交易操作

package main

import (
	"fmt"
	"log"

	"github.com/tigerfintech/openapi-go-sdk/client"
	"github.com/tigerfintech/openapi-go-sdk/config"
	"github.com/tigerfintech/openapi-go-sdk/model"
	"github.com/tigerfintech/openapi-go-sdk/trade"
)

func main() {
	cfg, err := config.NewClientConfig()
	if err != nil {
		log.Fatal(err)
	}

	tc := trade.NewTradeClient(client.NewHttpClient(cfg), cfg.Account)

	// 查询持仓
	positions, err := tc.Positions(model.PositionsRequest{})
	if err != nil {
		log.Fatal(err)
	}
	for _, p := range positions {
		fmt.Printf("%s qty=%.2f avgCost=%.2f marketValue=%.2f\n",
			p.Symbol, p.PositionQty, p.AverageCost, p.MarketValue)
	}

	// 构造限价单并预览
	order := model.LimitOrder(cfg.Account, "AAPL", "STK", "BUY", 10, 150.0)
	preview, err := tc.PreviewOrder(order)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("isPass=%v commission=%.2f initMargin=%.2f\n",
		preview.IsPass, preview.Commission, preview.InitMargin)

	// 实际下单
	placed, err := tc.PlaceOrder(order)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Printf("order id=%d orderId=%d\n", placed.ID, placed.OrderID)
}

cs, err := tc.Contract("AAPL", "STK")
if err != nil {
    log.Fatal(err)
}
if len(cs) > 0 {
    fmt.Printf("%s contractId=%d exchange=%s\n", cs[0].Symbol, cs[0].ContractId, cs[0].PrimaryExchange)
}

cs, err := tc.Contracts([]string{"AAPL", "TSLA", "MSFT"}, "STK")

cs, err := tc.QuoteContract("AAPL", "OPT", "20260619")
if err != nil {
    log.Fatal(err)
}
fmt.Printf("options=%d\n", len(cs))

order := model.MarketOrder(account, symbol, secType, action, qty)
order := model.LimitOrder(account, symbol, secType, action, qty, price)
order := model.StopOrder(account, symbol, secType, action, qty, auxPrice)
order := model.StopLimitOrder(account, symbol, secType, action, qty, limit, aux)
order := model.TrailOrder(account, symbol, secType, action, qty, trailPct)

order := model.LimitOrder(cfg.Account, "AAPL", "STK", "BUY", 10, 150.0)
order.Market = "US"
order.Currency = "USD"

placed, err := tc.PlaceOrder(order)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("id=%d orderId=%d\n", placed.ID, placed.OrderID)

preview, err := tc.PreviewOrder(order)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("isPass=%v commission=%.2f initMargin=%.2f\n",
    preview.IsPass, preview.Commission, preview.InitMargin)

modifyReq := order
modifyReq.LimitPrice = 148.0
mod, err := tc.ModifyOrder(placed.ID, modifyReq)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("modified id=%d\n", mod.ID)

canc, err := tc.CancelOrder(placed.ID)
if err != nil {
    log.Fatal(err)
}
fmt.Printf("cancelled id=%d\n", canc.ID)

// 最简调用：查询全部订单
orders, err := tc.Orders(model.OrdersRequest{})
if err != nil {
    log.Fatal(err)
}

// 带过滤条件：近 100 条已成交的美股订单
orders, err = tc.Orders(model.OrdersRequest{
    Market:  "US",
    SecType: "STK",
    States:  []string{"Filled"},
    Limit:   100,
    SortBy:  "LATEST_CREATED",
})
for _, o := range orders {
    fmt.Printf("%d %s %s %s qty=%d filled=%d status=%s\n",
        o.ID, o.Symbol, o.Action, o.OrderType, o.TotalQuantity, o.FilledQuantity, o.Status)
}

o, err := tc.GetOrder(model.GetOrderRequest{Id: placed.ID})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("%d %s status=%s filled=%d/%d\n",
    o.ID, o.Symbol, o.Status, o.FilledQuantity, o.TotalQuantity)

// 最简调用
activeOrders, err := tc.ActiveOrders(model.OrdersRequest{})

// 查询某父订单下的子订单
activeOrders, err = tc.ActiveOrders(model.OrdersRequest{ParentId: 12345678})

// 最简调用
inactive, err := tc.InactiveOrders(model.OrdersRequest{})

// 仅查询已撤销
inactive, err = tc.InactiveOrders(model.OrdersRequest{
    States: []string{"Cancelled"},
    Limit:  50,
})

import "time"

// 最简调用：不限时间（由服务端默认时间窗控制）
filled, err := tc.FilledOrders(model.OrdersRequest{})

// 带时间过滤：近 30 天已成交订单
now := time.Now().UnixMilli()
filled, err = tc.FilledOrders(model.OrdersRequest{
    StartDate: now - 30*24*3600*1000,
    EndDate:   now,
    Limit:     200,
})

// 最简调用：查询指定订单成交明细
txs, err := tc.OrderTransactions(model.OrderTransactionsRequest{
    OrderId: placed.ID,
    Symbol:  "AAPL",
    SecType: "STK",
})

// 带过滤：按时间窗查询某合约的全部成交
txs, err = tc.OrderTransactions(model.OrderTransactionsRequest{
    Symbol:    "AAPL",
    SecType:   "STK",
    StartDate: now - 7*24*3600*1000,
    EndDate:   now,
    Limit:     100,
})
for _, tx := range txs {
    fmt.Printf("%s %s filledPrice=%.2f qty=%d\n", tx.TransactedAt, tx.Action, tx.FilledPrice, tx.FilledQuantity)
}

// 最简调用：查询全部持仓
ps, err := tc.Positions(model.PositionsRequest{})

// 带过滤：仅查询美股持仓
ps, err = tc.Positions(model.PositionsRequest{
    Market:  "US",
    SecType: "STK",
})
for _, p := range ps {
    fmt.Printf("%s qty=%.0f avgCost=%.2f latest=%.2f pnl=%.2f\n",
        p.Symbol, p.PositionQty, p.AverageCost, p.LatestPrice, p.UnrealizedPnl)
}

// 最简调用
assets, err := tc.Assets(model.AssetsRequest{})

// 带过滤：返回分段明细
assets, err = tc.Assets(model.AssetsRequest{
    Segment:     true,
    MarketValue: true,
})
for _, a := range assets {
    fmt.Printf("account=%s buyingPower=%.2f netLiq=%.2f segments=%d\n",
        a.Account, a.BuyingPower, a.NetLiquidation, len(a.Segments))
    for _, s := range a.Segments {
        fmt.Printf("  [%s] %s netLiq=%.2f available=%.2f\n",
            s.Category, s.Title, s.NetLiquidation, s.AvailableFunds)
    }
}

// 最简调用
pa, err := tc.PrimeAssets(model.AssetsRequest{})

// 带过滤：指定基础币种
pa, err = tc.PrimeAssets(model.AssetsRequest{BaseCurrency: "USD"})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("account=%s segments=%d\n", pa.AccountID, len(pa.Segments))
for _, s := range pa.Segments {
    fmt.Printf("  [%s] netLiq=%.2f buyingPower=%.2f\n",
        s.Category, s.NetLiquidation, s.BuyingPower)
    for _, ca := range s.CurrencyAssets {
        fmt.Printf("    %s cash=%.2f fx=%.4f\n", ca.Currency, ca.CashBalance, ca.ForexRate)
    }
}

subs, err := tc.ManagedAccounts(model.ManagedAccountsRequest{})
if err != nil {
    log.Fatal(err)
}
for _, s := range subs {
    fmt.Printf("%s type=%s capability=%s status=%s\n",
        s.Account, s.AccountType, s.Capability, s.Status)
}

cs, err := tc.DerivativeContracts(model.DerivativeContractsRequest{
    Symbols: []string{"AAPL", "TSLA"},
    SecType: "OPT",
    Expiry:  "20260619",
})
fmt.Printf("contracts=%d\n", len(cs))

rows, err := tc.AnalyticsAsset(model.AnalyticsAssetRequest{
    StartDate: "2025-01-01",
    EndDate:   "2025-12-31",
    Currency:  "USD",
})
for _, r := range rows {
    fmt.Printf("%s holding=%.2f cash=%.2f pnl=%.2f nav=%.4f\n",
        r.Date, r.HoldingValue, r.CashBalance, r.Pnl, r.NetValueIndex)
}

agg, err := tc.AggregateAssets(model.AggregateAssetsRequest{BaseCurrency: "USD"})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("netLiq=%.2f gross=%.2f cash=%.2f currencies=%d\n",
    agg.NetLiquidation, agg.GrossPositionValue, agg.CashBalance, len(agg.CurrencyAssets))

est, err := tc.EstimateTradableQuantity(model.EstimateTradableQuantityRequest{
    Symbol:     "AAPL",
    SecType:    "STK",
    Action:     "BUY",
    OrderType:  "LMT",
    LimitPrice: 150.0,
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("tradable=%.2f cashBuy=%.2f marginBuy=%.2f\n",
    est.TradableQuantity, est.MaxCashBuyQuantity, est.MaxMarginBuyQuantity)

now := time.Now().UnixMilli()
rows, err := tc.FundDetails(model.FundDetailsRequest{
    StartDate: now - 30*24*3600*1000,
    EndDate:   now,
    Currency:  "USD",
    Limit:     100,
})
for _, r := range rows {
    fmt.Printf("%d %s amount=%.2f balance=%.2f remark=%s\n",
        r.OccurTime, r.FundType, r.Amount, r.Balance, r.Remark)
}

rows, err := tc.FundingHistory(model.FundingHistoryRequest{})
for _, r := range rows {
    fmt.Printf("%d %s amount=%.2f type=%s status=%s\n", r.ID, r.Currency, r.Amount, r.TypeDesc, r.Status)
}

res, err := tc.PlaceForexOrder(model.ForexOrderRequest{
    SourceCurrency: "USD",
    SourceAmount:   10000,
    TargetCurrency: "HKD",
})
if err != nil {
    log.Fatal(err)
}
fmt.Printf("id=%s rate=%.4f target=%.2f\n", res.ID, res.Rate, res.TargetAmount)

avail, err := tc.SegmentFundAvailable(model.SegmentFundRequest{
    FromSegment: "S",
    ToSegment:   "C",
    Currency:    "USD",
})
for _, a := range avail {
    fmt.Printf("%s->%s %s available=%.2f\n", a.FromSegment, a.ToSegment, a.Currency, a.AvailableAmt)
}

history, err := tc.SegmentFundHistory(model.SegmentFundRequest{Limit: 50})
for _, h := range history {
    fmt.Printf("%d %s->%s %s amount=%.2f status=%s\n",
        h.ID, h.FromSegment, h.ToSegment, h.Currency, h.Amount, h.Status)
}

res, err := tc.TransferSegmentFund(model.SegmentFundRequest{
    FromSegment: "S",
    ToSegment:   "C",
    Currency:    "USD",
    Amount:      1000,
})
fmt.Printf("transferId=%s status=%s\n", res.ID, res.Status)

res, err := tc.CancelSegmentFund(model.SegmentFundRequest{ID: "TX123456"})
fmt.Printf("cancelled id=%s status=%s\n", res.ID, res.Status)

package main

import (
	"fmt"
	"log"

	"github.com/tigerfintech/openapi-go-sdk/client"
	"github.com/tigerfintech/openapi-go-sdk/config"
)

func main() {
	cfg, err := config.NewClientConfig()
	if err != nil {
		log.Fatal(err)
	}

	httpClient := client.NewHttpClient(cfg)

	// 直接传入 API 方法名和 JSON 参数
	resp, err := httpClient.ExecuteRaw("market_state", `{"market":"US"}`)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("原始响应:", resp)
}