Trading

using TigerOpenAPI.Common;
using TigerOpenAPI.Trade;
using TigerOpenAPI.Trade.Response;
using TigerOpenAPI.Trade.Model;

TigerConfig config = new TigerConfig()
{
    ConfigFilePath = "/path/to/tiger_openapi_config.properties"
};
TradeClient tradeClient = new TradeClient(config);

// Get positions
TigerRequest<PositionResponse> request = new TigerRequest<PositionResponse>()
{
    ApiMethodName = TradeApiService.POSITIONS,
    ModelValue = new PositionModel() { Account = config.DefaultAccount }
};
PositionResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine(response);

// US stock contract
ContractItem contract = ContractItem.BuildStockContract("AAPL", Currency.USD.ToString());

TigerRequest<ContractResponse> request = new TigerRequest<ContractResponse>()
{
    ApiMethodName = TradeApiService.CONTRACT,
    ModelValue = new ContractModel() { ContractInfo = contract }
};
ContractResponse response = await tradeClient.ExecuteAsync(request);

// HK stock contract
ContractItem hkContract = ContractItem.BuildStockContract("00700", Currency.HKD.ToString());

// US option contract
ContractItem optContract = ContractItem.BuildOptionContract("AAPL", "20250117", 150.0D, "CALL");

// HK warrant contract
ContractItem warContract = ContractItem.BuildWarrantContract("13745", "20211217", 719.38D, Right.CALL.ToString());

// Limit buy AAPL
ContractItem contract = ContractItem.BuildStockContract("AAPL", Currency.USD.ToString());
PlaceOrderModel orderModel = PlaceOrderModel.buildLimitOrder(
    config.DefaultAccount, contract, ActionType.BUY, 10, 150.0D);

TigerRequest<PlaceOrderResponse> request = new TigerRequest<PlaceOrderResponse>()
{
    ApiMethodName = TradeApiService.PLACE_ORDER,
    ModelValue = orderModel
};
PlaceOrderResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine("Order ID: " + response.OrderId);

// Market sell
PlaceOrderModel mktOrder = PlaceOrderModel.buildMarketOrder(
    config.DefaultAccount, contract, ActionType.SELL, 10);

// Extended hours order
PlaceOrderModel extOrder = PlaceOrderModel.buildLimitOrder(
    config.DefaultAccount, contract, ActionType.BUY, 5, 148.0D);
extOrder.OutsideRth = true;
extOrder.TimeInForce = TimeInForce.DAY;

{
  "orderId": 12345678,
  "status": "Submitted",
  "symbol": "AAPL"
}

ContractItem contract = ContractItem.BuildStockContract("AAPL", Currency.USD.ToString());
PlaceOrderModel orderModel = PlaceOrderModel.buildLimitOrder(
    config.DefaultAccount, contract, ActionType.BUY, 10, 150.0D);

TigerRequest<PreviewOrderResponse> request = new TigerRequest<PreviewOrderResponse>()
{
    ApiMethodName = TradeApiService.PREVIEW_ORDER,
    ModelValue = orderModel
};
PreviewOrderResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine("Estimated commission: " + response.Commission);

PlaceOrderModel stpOrder = PlaceOrderModel.buildStopOrder(
    config.DefaultAccount, contract, ActionType.SELL, 10, 145.0D);

PlaceOrderModel stpLmtOrder = PlaceOrderModel.buildStopLimitOrder(
    config.DefaultAccount, contract, ActionType.SELL, 10, 145.0D, 144.0D);

PlaceOrderModel trailOrder = new PlaceOrderModel()
{
    Account = config.DefaultAccount,
    ContractInfo = contract,
    Action = ActionType.SELL,
    OrderType = OrderType.TRAIL,
    TotalQuantity = 10,
    AuxPrice = 5.0D  // Trailing amount
};

// Auction market order (AM)
PlaceOrderModel amOrder = new PlaceOrderModel()
{
    Account = config.DefaultAccount,
    ContractInfo = contract,
    Action = ActionType.BUY,
    OrderType = OrderType.AUCTION_MKT,
    TotalQuantity = 10
};

// Auction limit order (AL)
PlaceOrderModel alOrder = new PlaceOrderModel()
{
    Account = config.DefaultAccount,
    ContractInfo = contract,
    Action = ActionType.BUY,
    OrderType = OrderType.AUCTION_LIMIT,
    TotalQuantity = 10,
    LimitPrice = 150.0D
};

ContractItem optContract = ContractItem.BuildOptionContract("AAPL", "20250117", 150.0D, "CALL");
PlaceOrderModel optOrder = PlaceOrderModel.buildLimitOrder(
    config.DefaultAccount, optContract, ActionType.BUY, 1, 9.50D);

ContractItem futContract = ContractItem.BuildFutureContract("ES2506", Currency.USD.ToString());
PlaceOrderModel futOrder = PlaceOrderModel.buildLimitOrder(
    config.DefaultAccount, futContract, ActionType.BUY, 1, 5900.0D);

ModifyOrderModel modifyModel = new ModifyOrderModel()
{
    Account = config.DefaultAccount,
    Id = 12345,
    LimitPrice = 148.0D,
    TotalQuantity = 10
};

TigerRequest<ModifyOrderResponse> request = new TigerRequest<ModifyOrderResponse>()
{
    ApiMethodName = TradeApiService.MODIFY_ORDER,
    ModelValue = modifyModel
};
ModifyOrderResponse response = await tradeClient.ExecuteAsync(request);

CancelOrderModel cancelModel = new CancelOrderModel()
{
    Account = config.DefaultAccount,
    Id = 12345
};

TigerRequest<CancelOrderResponse> request = new TigerRequest<CancelOrderResponse>()
{
    ApiMethodName = TradeApiService.CANCEL_ORDER,
    ModelValue = cancelModel
};
CancelOrderResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<OrdersResponse> request = new TigerRequest<OrdersResponse>()
{
    ApiMethodName = TradeApiService.ORDERS,
    ModelValue = new OrdersModel() { Account = config.DefaultAccount }
};
OrdersResponse response = await tradeClient.ExecuteAsync(request);

[
  {
    "id": 12345678,
    "symbol": "AAPL",
    "action": "BUY",
    "status": "Filled",
    "totalQuantity": 10,
    "filledQuantity": 10,
    "limitPrice": 150.0,
    "avgFillPrice": 149.95,
    "createTime": 1735042800000
  }
]

TigerRequest<OrdersResponse> request = new TigerRequest<OrdersResponse>()
{
    ApiMethodName = TradeApiService.ACTIVE_ORDERS,
    ModelValue = new OrdersModel() { Account = config.DefaultAccount }
};
OrdersResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<OrdersResponse> request = new TigerRequest<OrdersResponse>()
{
    ApiMethodName = TradeApiService.FILLED_ORDERS,
    ModelValue = new OrdersModel() { Account = config.DefaultAccount }
};
OrdersResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<OrdersResponse> request = new TigerRequest<OrdersResponse>()
{
    ApiMethodName = TradeApiService.INACTIVE_ORDERS,
    ModelValue = new OrdersModel() { Account = config.DefaultAccount }
};
OrdersResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<TransactionsResponse> request = new TigerRequest<TransactionsResponse>()
{
    ApiMethodName = TradeApiService.ORDER_TRANSACTIONS,
    ModelValue = new TransactionModel() { Id = 12345 }
};
TransactionsResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<PositionResponse> request = new TigerRequest<PositionResponse>()
{
    ApiMethodName = TradeApiService.POSITIONS,
    ModelValue = new PositionModel() { Account = config.DefaultAccount }
};
PositionResponse response = await tradeClient.ExecuteAsync(request);

[
  {
    "symbol": "AAPL",
    "quantity": 100,
    "averageCost": 145.50,
    "marketValue": 22752.0,
    "unrealizedPnl": 2202.0,
    "realizedPnl": 500.0
  }
]

TigerRequest<AssetResponse> request = new TigerRequest<AssetResponse>()
{
    ApiMethodName = TradeApiService.ASSETS,
    ModelValue = new AssetModel() { Account = config.DefaultAccount }
};
AssetResponse response = await tradeClient.ExecuteAsync(request);

{
  "account": "123456789",
  "netLiquidation": 250000.0,
  "cashBalance": 50000.0,
  "buyingPower": 100000.0,
  "grossPositionValue": 200000.0,
  "unrealizedPnl": 5000.0,
  "realizedPnl": 3000.0
}

TigerRequest<PrimeAssetResponse> request = new TigerRequest<PrimeAssetResponse>()
{
    ApiMethodName = TradeApiService.PRIME_ASSETS,
    ModelValue = new AssetModel() { Account = config.DefaultAccount }
};
PrimeAssetResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<AccountsResponse> request = new TigerRequest<AccountsResponse>()
{
    ApiMethodName = TradeApiService.MANAGED_ACCOUNTS
};
AccountsResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine("Accounts: " + string.Join(", ", response.Accounts));

TigerRequest<DepositWithdrawResponse> request = new TigerRequest<DepositWithdrawResponse>()
{
    ApiMethodName = TradeApiService.TRANSFER_FUND,
    ModelValue = new DepositWithdrawModel { Account = config.DefaultAccount, SegType = SegmentType.SEC }
};
DepositWithdrawResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<FundDetailsResponse> request = new TigerRequest<FundDetailsResponse>()
{
    ApiMethodName = TradeApiService.FUND_DETAILS,
    ModelValue = new FundDetailsModel(config.DefaultAccount, new List<string> { "SEC" })
};
FundDetailsResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<AggregateAssetResponse> request = new TigerRequest<AggregateAssetResponse>()
{
    ApiMethodName = TradeApiService.AGGREGATE_ASSETS,
    ModelValue = new AggregateAssetModel(config.DefaultAccount, "SEC")
};
AggregateAssetResponse response = await tradeClient.ExecuteAsync(request);

var items = new List<PositionTransferDetail>
{
    new PositionTransferDetail { Symbol = "AAPL", SecType = "STK", Quantity = 100 }
};
TigerRequest<PositionTransferResponse> request = new TigerRequest<PositionTransferResponse>()
{
    ApiMethodName = TradeApiService.POSITION_TRANSFER,
    ModelValue = new PositionTransferModel(config.DefaultAccount, "account_b", "US", items)
};
PositionTransferResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<PositionTransferRecordsResponse> request = new TigerRequest<PositionTransferRecordsResponse>()
{
    ApiMethodName = TradeApiService.POSITION_TRANSFER_RECORDS,
    ModelValue = new PositionTransferRecordsModel(config.DefaultAccount, "2025-01-01", "2025-04-01")
};
PositionTransferRecordsResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<PositionTransferDetailResponse> request = new TigerRequest<PositionTransferDetailResponse>()
{
    ApiMethodName = TradeApiService.POSITION_TRANSFER_DETAIL,
    ModelValue = new PositionTransferDetailModel(transferId, config.DefaultAccount)
};
PositionTransferDetailResponse response = await tradeClient.ExecuteAsync(request);

TigerRequest<PositionTransferExternalRecordsResponse> request = new TigerRequest<PositionTransferExternalRecordsResponse>()
{
    ApiMethodName = TradeApiService.POSITION_TRANSFER_EXTERNAL_RECORDS,
    ModelValue = new PositionTransferRecordsModel(config.DefaultAccount, "2025-01-01", "2025-04-01")
};
PositionTransferExternalRecordsResponse response = await tradeClient.ExecuteAsync(request);