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<PositionsResponse> request = new TigerRequest<PositionsResponse>()
{
    ApiMethodName = TradeApiService.POSITIONS,
    ModelValue = new PositionsModel() { Account = config.DefaultAccount }
};
PositionsResponse 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 contract = ContractItem.BuildStockContract("AAPL", Currency.USD.ToString());

// Basic parameters (defaults to LIMIT_PRICE mode)
PlaceOrderModel icebergOrder = PlaceOrderModel.BuildIcebergOrder(
    config.DefaultAccount, contract, ActionType.BUY, 1000, 180.0, 100);

// Full parameters
// priceType options: ICEBERG_PRICE_TYPE_LIMIT / ICEBERG_PRICE_TYPE_ASK / ICEBERG_PRICE_TYPE_BID / ICEBERG_PRICE_TYPE_LATEST
PlaceOrderModel icebergFull = PlaceOrderModel.BuildIcebergOrder(
    config.DefaultAccount, contract, ActionType.BUY, 1000, 180.0,
    100, 50, 30,  // displaySize, minDisplaySize, checkIntervals
    PlaceOrderModel.ICEBERG_PRICE_TYPE_LIMIT,  // priceType
    startTime, endTime);

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<OrderBatchResponse> request = new TigerRequest<OrderBatchResponse>()
{
    ApiMethodName = TradeApiService.ORDERS,
    ModelValue = new QueryOrderModel() { Account = config.DefaultAccount }
};
OrderBatchResponse 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<OrderBatchResponse> request = new TigerRequest<OrderBatchResponse>()
{
    ApiMethodName = TradeApiService.ACTIVE_ORDERS,
    ModelValue = new QueryOrderModel() { Account = config.DefaultAccount }
};
OrderBatchResponse response = await tradeClient.ExecuteAsync(request);

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

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

TigerRequest<OrderTransactionsResponse> request = new TigerRequest<OrderTransactionsResponse>()
{
    ApiMethodName = TradeApiService.ORDER_TRANSACTIONS,
    ModelValue = new OrderTransactionsModel() { Account = config.DefaultAccount, Symbol = "AAPL" }
};
OrderTransactionsResponse response = await tradeClient.ExecuteAsync(request);

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

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

TigerRequest<TigerDictResponse> request = new TigerRequest<TigerDictResponse>()
{
    ApiMethodName = TradeApiService.ASSETS,
    ModelValue = new GlobalAssetsModel() { Account = config.DefaultAccount }
};
TigerDictResponse 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 PrimeAssetsModel() { 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);

TigerRequest<OptionExerciseCheckResponse> request = new TigerRequest<OptionExerciseCheckResponse>()
{
    ApiMethodName = TradeApiService.OPTION_EXERCISE_CHECK,
    ModelValue = new OptionExerciseCheckModel(
        contractId: 1234567890L,
        exerciseType: "Exercise",
        quantity: 1.0,
        executingDate: "2025-06-20",
        isForce: false,
        account: config.DefaultAccount
    )
};
OptionExerciseCheckResponse response = await tradeClient.ExecuteAsync(request);
OptionExerciseCheckItem item = response.Item;
Console.WriteLine($"symbol={item.Symbol} availableQty={item.AvailableQuantity}");
Console.WriteLine($"stkBefore={item.StkPositionBefore} stkAfter={item.StkPositionAfter}");

TigerRequest<OptionExercisePositionResponse> request = new TigerRequest<OptionExercisePositionResponse>()
{
    ApiMethodName = TradeApiService.OPTION_EXERCISE_POSITION,
    ModelValue = new OptionExercisePositionModel(
        exerciseType: "Exercise",
        account: config.DefaultAccount
    )
};
OptionExercisePositionResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine($"itemCount={response.ItemCount} pageCount={response.PageCount}");
foreach (OptionExercisePositionItem pos in response.Items)
{
    Console.WriteLine($"contractId={pos.ContractId} symbol={pos.Symbol} availableQty={pos.AvailableQuantity}");
}

// Early exercise
TigerRequest<OptionExerciseSubmitResponse> request = new TigerRequest<OptionExerciseSubmitResponse>()
{
    ApiMethodName = TradeApiService.OPTION_EXERCISE_SUBMIT,
    ModelValue = new OptionExerciseSubmitModel(
        contractId: 1234567890L,
        exerciseType: "Exercise",
        quantity: 1.0,
        executingDate: "2025-06-20",
        isForce: false,
        account: config.DefaultAccount
    )
};
OptionExerciseSubmitResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine(response.Success ? "Submitted successfully" : "Submission failed");

TigerRequest<OptionExerciseRecordResponse> request = new TigerRequest<OptionExerciseRecordResponse>()
{
    ApiMethodName = TradeApiService.OPTION_EXERCISE_RECORD,
    ModelValue = new OptionExerciseRecordModel(
        page: 1,
        size: 20,
        account: config.DefaultAccount
    )
};
OptionExerciseRecordResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine($"itemCount={response.ItemCount} pageCount={response.PageCount}");
foreach (OptionExerciseRecordItem r in response.Items)
{
    Console.WriteLine($"id={r.Id} type={r.ExerciseType} status={r.Status}");
}

TigerRequest<OptionExerciseCancelResponse> request = new TigerRequest<OptionExerciseCancelResponse>()
{
    ApiMethodName = TradeApiService.OPTION_EXERCISE_CANCEL,
    ModelValue = new OptionExerciseCancelModel(
        id: recordId,
        account: config.DefaultAccount
    )
};
OptionExerciseCancelResponse response = await tradeClient.ExecuteAsync(request);
Console.WriteLine(response.Success ? "Cancelled successfully" : "Cancellation failed");