@polyester/sdk 0.23.1 → 0.24.0

package/dist/services/orders/orders.schemas.d.ts

@@ -1,7 +1,8 @@
 import { OrderErrorCode, OrderErrorDetail, OrderErrorDetailSchema } from "./order-errors.schemas.js";
+import { RiskPolicyInput, StopLossInput, TakeProfitInput, TrailingStopInput, createRiskPolicyInputSchema } from "./orders-risk.schemas.js";
+import { Order, OrderDetails, OrderTransfer, createOrderDetailsSchema, createOrderSchema, createOrderTransferSchema } from "./orders-output.schemas.js";
 import { CancelAllOrdersInput, CancelAllOrdersInputSchema, CancelAllOrdersResponse, CancelAllOrdersResponseSchema, CancelOrderInput, CancelOrderInputSchema, CancelOrderResult, CancelOrderResultSchema, CreateOrderResult, GetOrderDetailsInput, GetOrderDetailsInputSchema, NewOrderInput, OpenOrdersInput, OpenOrdersInputSchema, OrderHistoryInput, OrderHistoryInputSchema, OrderIntentInput, PreviewOrderResult, createCreateOrderResultSchema, createNewOrderInputSchema, createOrderIntentInputSchema, createPreviewOrderResultSchema } from "./orders-input.schemas.js";
 import { ModifyOrderInput, ModifyOrderResult, ModifyOrderResultSchema, createModifyOrderInputSchema } from "./orders-modify.schemas.js";
-import { RiskPolicyInput, StopLossInput, TakeProfitInput, TrailingStopInput, createRiskPolicyInputSchema } from "./orders-risk.schemas.js";
 import { BatchCancelOrderInput, BatchCancelOrderResult, BatchCancelOrdersInput, BatchCancelOrdersInputSchema, BatchCancelOrdersResult, BatchCancelOrdersResultSchema, BatchCreateOrderResult, BatchCreateOrdersInput, BatchCreateOrdersResult, BatchReplaceAdmissionItem, BatchReplaceOrdersInput, BatchReplaceOrdersResult, BatchReplaceOrdersResultSchema, CancelAllAfterInput, CancelAllAfterInputSchema, CancelAllAfterResult, CancelAllAfterResultSchema, GetBatchReplaceStatusInput, GetBatchReplaceStatusInputSchema, GetBatchReplaceStatusResult, GetBatchReplaceStatusResultSchema, createBatchCreateOrdersInputSchema, createBatchCreateOrdersResultSchema } from "./orders-batch.schemas.js";
-import { Order, OrderDetails, OrderTransfer, createOrderDetailsSchema, createOrderSchema, createOrderTransferSchema } from "./orders-output.schemas.js";
-export { type BatchCancelOrderInput, type BatchCancelOrderResult, type BatchCancelOrdersInput, type BatchCancelOrdersResult, type BatchCreateOrderResult, type BatchCreateOrdersInput, type BatchCreateOrdersResult, type BatchReplaceAdmissionItem, type BatchReplaceOrdersInput, type BatchReplaceOrdersResult, type CancelAllAfterInput, type CancelAllAfterResult, type CancelAllOrdersInput, CancelAllOrdersInputSchema, type CancelAllOrdersResponse, type CancelOrderInput, CancelOrderInputSchema, type CancelOrderResult, type CreateOrderResult, type GetBatchReplaceStatusInput, type GetBatchReplaceStatusResult, type GetOrderDetailsInput, GetOrderDetailsInputSchema, type ModifyOrderInput, type ModifyOrderResult, type NewOrderInput, type OpenOrdersInput, OpenOrdersInputSchema, type Order, type OrderDetails, type OrderErrorCode, type OrderErrorDetail, type OrderHistoryInput, OrderHistoryInputSchema, type OrderIntentInput, type OrderTransfer, type PreviewOrderResult, type RiskPolicyInput, type StopLossInput, type TakeProfitInput, type TrailingStopInput };
+import { OrderLineage, OrderLineageSchema } from "./order-lineage.schemas.js";
+export { type BatchCancelOrderInput, type BatchCancelOrderResult, type BatchCancelOrdersInput, type BatchCancelOrdersResult, type BatchCreateOrderResult, type BatchCreateOrdersInput, type BatchCreateOrdersResult, type BatchReplaceAdmissionItem, type BatchReplaceOrdersInput, type BatchReplaceOrdersResult, type CancelAllAfterInput, type CancelAllAfterResult, type CancelAllOrdersInput, CancelAllOrdersInputSchema, type CancelAllOrdersResponse, type CancelOrderInput, CancelOrderInputSchema, type CancelOrderResult, type CreateOrderResult, type GetBatchReplaceStatusInput, type GetBatchReplaceStatusResult, type GetOrderDetailsInput, GetOrderDetailsInputSchema, type ModifyOrderInput, type ModifyOrderResult, type NewOrderInput, type OpenOrdersInput, OpenOrdersInputSchema, type Order, type OrderDetails, type OrderErrorCode, type OrderErrorDetail, type OrderHistoryInput, OrderHistoryInputSchema, type OrderIntentInput, type OrderLineage, type OrderTransfer, type PreviewOrderResult, type RiskPolicyInput, type StopLossInput, type TakeProfitInput, type TrailingStopInput };

package/dist/services/orders/orders.types.d.ts

@@ -1,8 +1,9 @@
 import { OrderErrorCode, OrderErrorDetail } from "./order-errors.schemas.js";
+import { RiskPolicyInput, StopLossInput, TakeProfitInput, TrailingStopInput } from "./orders-risk.schemas.js";
+import { Order, OrderDetails, OrderTransfer } from "./orders-output.schemas.js";
 import { CancelAllOrdersInput, CancelAllOrdersResponse, CancelOrderInput, CancelOrderResult, CreateOrderResult, GetOrderDetailsInput, NewOrderInput, OpenOrdersInput, OrderHistoryInput, OrderIntentInput, PreviewOrderResult } from "./orders-input.schemas.js";
 import { ModifyOrderInput, ModifyOrderResult } from "./orders-modify.schemas.js";
-import { RiskPolicyInput, StopLossInput, TakeProfitInput, TrailingStopInput } from "./orders-risk.schemas.js";
 import { BatchCancelOrderInput, BatchCancelOrderResult, BatchCancelOrdersInput, BatchCancelOrdersResult, BatchCreateOrderResult, BatchCreateOrdersInput, BatchCreateOrdersResult, BatchReplaceAdmissionItem, BatchReplaceOrdersInput, BatchReplaceOrdersResult, CancelAllAfterInput, CancelAllAfterResult, GetBatchReplaceStatusInput, GetBatchReplaceStatusResult } from "./orders-batch.schemas.js";
-import { Order, OrderDetails, OrderTransfer } from "./orders-output.schemas.js";
+import { OrderLineage } from "./order-lineage.schemas.js";
 import "./orders.schemas.js";
-export type { BatchCancelOrderInput, BatchCancelOrderResult, BatchCancelOrdersInput, BatchCancelOrdersResult, BatchCreateOrderResult, BatchCreateOrdersInput, BatchCreateOrdersResult, BatchReplaceAdmissionItem, BatchReplaceOrdersInput, BatchReplaceOrdersResult, CancelAllAfterInput, CancelAllAfterResult, CancelAllOrdersInput, CancelAllOrdersResponse, CancelOrderInput, CancelOrderResult, CreateOrderResult, GetBatchReplaceStatusInput, GetBatchReplaceStatusResult, GetOrderDetailsInput, ModifyOrderInput, ModifyOrderResult, NewOrderInput, OpenOrdersInput, Order, OrderDetails, OrderErrorCode, OrderErrorDetail, OrderHistoryInput, OrderIntentInput, OrderTransfer, PreviewOrderResult, RiskPolicyInput, StopLossInput, TakeProfitInput, TrailingStopInput };
+export type { BatchCancelOrderInput, BatchCancelOrderResult, BatchCancelOrdersInput, BatchCancelOrdersResult, BatchCreateOrderResult, BatchCreateOrdersInput, BatchCreateOrdersResult, BatchReplaceAdmissionItem, BatchReplaceOrdersInput, BatchReplaceOrdersResult, CancelAllAfterInput, CancelAllAfterResult, CancelAllOrdersInput, CancelAllOrdersResponse, CancelOrderInput, CancelOrderResult, CreateOrderResult, GetBatchReplaceStatusInput, GetBatchReplaceStatusResult, GetOrderDetailsInput, ModifyOrderInput, ModifyOrderResult, NewOrderInput, OpenOrdersInput, Order, OrderDetails, OrderErrorCode, OrderErrorDetail, OrderHistoryInput, OrderIntentInput, OrderLineage, OrderTransfer, PreviewOrderResult, RiskPolicyInput, StopLossInput, TakeProfitInput, TrailingStopInput };

package/dist/services/trades/trades.d.ts

@@ -4,6 +4,7 @@ import { SubaccountResolver } from "../subaccount-resolver.js";
 import { PolyesterRealtime } from "../../realtime/types.js";
 import { BaseSubscribeInput } from "../../shared/types.js";
 import { SdkScales } from "../../shared/decimal-surface.js";
+import { OrderTransfer } from "../orders/orders-output.schemas.js";
 import { GetUserTradesInput, Trade } from "./trades.schemas.js";
 //#region src/services/trades/trades.d.ts
 interface SubscribeTradesInput extends BaseSubscribeInput<Trade> {
@@ -17,9 +18,12 @@ declare class TradesService {
   constructor(transports: AuthApiTransports, realtime: PolyesterRealtime, resolver: SubaccountResolver | undefined, scales: SdkScales);
   /**
    * Returns user trades for the resolved root account or subaccount, supporting symbol, side, time range, limit, page token, and after-match-ID replay cursor filters. The `afterMatchId` cursor requires `symbolId`, enforced at the type and validation level. Results include the next page token from GetUserTrades.
+   * Scope executions to an order or lineage, optionally through a generation. Requested transfers
+   * belong to matches on this page; deduplicate them across pages by txId.
    */
   list(input?: GetUserTradesInput, options?: PolyesterRequestOptions): Promise<{
     trades: Trade[];
+    transfers: OrderTransfer[];
     nextPageToken: string;
   }>;
   /**

package/dist/services/trades/trades.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trades.d.ts","names":[],"sources":["../../../src/services/trades/trades.ts"],"mappings":";;;;;;;;UAsBU,6BAA6B,mBAAmB;EACtD;;;;;cAMS;;EAQL,YAAA,YAAY,mBACZ,UAAU,mBACV,UAAU,gCACV,QAAQ;;;;EAYN,KACF,QAAO,oBACP,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAiB9B,UAAU,OAAO"}
+{"version":3,"file":"trades.d.ts","names":[],"sources":["../../../src/services/trades/trades.ts"],"mappings":";;;;;;;;;UAuBU,6BAA6B,mBAAmB;EACtD;;;;;cAMS;;EAQL,YAAA,YAAY,mBACZ,UAAU,mBACV,UAAU,gCACV,QAAQ;;;;;;EAcN,KACF,QAAO,oBACP,UAAU,0BACX;IAAU,QAAQ;IAAS,WAAW;IAAiB;;;;;EAkB1D,UAAU,OAAO"}

package/dist/services/trades/trades.js

@@ -5,6 +5,7 @@ import { resolveAccountScopedInput } from "../subaccount-resolver.js";
 import { connectReadyGatedProtoChannel } from "../../realtime/ready-gated-subscription.js";
 import { OrdersReadService, UserTradeSchema } from "../../gen/orders/v1/orders_read_pb.js";
 import { GetUserTradesInputSchema, createUserTradeSchema } from "./trades.schemas.js";
+import { createOrderTransferSchema } from "../orders/orders-output.schemas.js";
 import { createClient } from "@connectrpc/connect";
 import * as v from "valibot";
 //#region src/services/trades/trades.ts
@@ -26,6 +27,8 @@ var TradesService = class {
 	}
 	/**
 	* Returns user trades for the resolved root account or subaccount, supporting symbol, side, time range, limit, page token, and after-match-ID replay cursor filters. The `afterMatchId` cursor requires `symbolId`, enforced at the type and validation level. Results include the next page token from GetUserTrades.
+	* Scope executions to an order or lineage, optionally through a generation. Requested transfers
+	* belong to matches on this page; deduplicate them across pages by txId.
 	*/
 	async list(input = {}, options) {
 		await this.#scales.ready();
@@ -34,6 +37,7 @@ var TradesService = class {
 		const res = await this.#client.getUserTrades(removeUndefined(validatedInput), toConnectCallOptions(options));
 		return {
 			trades: parse(v.array(this.#userTradeSchema), res.trades),
+			transfers: parse(v.array(createOrderTransferSchema()), res.transfers ?? []),
 			nextPageToken: res.nextPageToken
 		};
 	}

package/dist/services/trades/trades.js.map

@@ -1 +1 @@
-{"version":3,"file":"trades.js","names":["#client","Proto.OrdersReadService","#realtime","#resolver","#scales","#userTradeSchema","Proto.UserTradeSchema"],"sources":["../../../src/services/trades/trades.ts"],"sourcesContent":["import * as Proto from \"../../gen/orders/v1/orders_read_pb.js\";\nimport { createClient, type Client } from \"@connectrpc/connect\";\nimport * as v from \"valibot\";\nimport { parse } from \"../../shared/validation.js\";\nimport { removeUndefined } from \"../../utils/remove-undefined.js\";\nimport { type SubaccountResolver, resolveAccountScopedInput } from \"../subaccount-resolver.js\";\nimport type { PolyesterRealtime } from \"../../realtime/types.js\";\nimport { connectReadyGatedProtoChannel } from \"../../realtime/ready-gated-subscription.js\";\nimport type { BaseSubscribeInput } from \"../../shared/types.js\";\nimport {\n    toConnectCallOptions,\n    type PolyesterRequestOptions,\n} from \"../../shared/request-options.js\";\nimport type { SdkScales } from \"../../shared/decimal-surface.js\";\nimport type { AuthApiTransports } from \"../../shared/transports.js\";\nimport {\n    GetUserTradesInputSchema,\n    createUserTradeSchema,\n    type GetUserTradesInput,\n    type Trade,\n} from \"./trades.schemas.js\";\n\ninterface SubscribeTradesInput extends BaseSubscribeInput<Trade> {\n    accountId: string;\n}\n\n/**\n * Reads and streams authenticated user trade fills.\n */\nexport class TradesService {\n    #client: Client<typeof Proto.OrdersReadService>;\n    #realtime: PolyesterRealtime;\n    #resolver?: SubaccountResolver;\n    #scales: SdkScales;\n    #userTradeSchema: ReturnType<typeof createUserTradeSchema>;\n\n    constructor(\n        transports: AuthApiTransports,\n        realtime: PolyesterRealtime,\n        resolver: SubaccountResolver | undefined,\n        scales: SdkScales,\n    ) {\n        this.#client = createClient(Proto.OrdersReadService, transports.authApi);\n        this.#realtime = realtime;\n        this.#resolver = resolver;\n        this.#scales = scales;\n        this.#userTradeSchema = createUserTradeSchema(scales);\n    }\n\n    /**\n     * Returns user trades for the resolved root account or subaccount, supporting symbol, side, time range, limit, page token, and after-match-ID replay cursor filters. The `afterMatchId` cursor requires `symbolId`, enforced at the type and validation level. Results include the next page token from GetUserTrades.\n     */\n    async list(\n        input: GetUserTradesInput = {},\n        options?: PolyesterRequestOptions,\n    ): Promise<{ trades: Trade[]; nextPageToken: string }> {\n        await this.#scales.ready();\n        const resolved = resolveAccountScopedInput(input, this.#resolver);\n        const validatedInput = parse(GetUserTradesInputSchema, resolved);\n        const res = await this.#client.getUserTrades(\n            removeUndefined(validatedInput),\n            toConnectCallOptions(options),\n        );\n        return {\n            trades: parse(v.array(this.#userTradeSchema), res.trades),\n            nextPageToken: res.nextPageToken,\n        };\n    }\n\n    /**\n     * Subscribes to private user trade updates on private:spot:trades:{accountId}:proto and emits parsed fills.\n     */\n    subscribe(input: SubscribeTradesInput) {\n        const channel = `private:spot:trades:${input.accountId}:proto`;\n        return connectReadyGatedProtoChannel(this.#realtime, {\n            channel,\n            schema: Proto.UserTradeSchema,\n            ready: () => this.#scales.ready(),\n            onPublication: (data) => {\n                const trade = parse(this.#userTradeSchema, data);\n                input.onEvent(trade);\n            },\n            onConnected: () => input.onOpen?.(),\n            onDisconnected: () => input.onClose?.(),\n            onError: input.onError,\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;;;AA6BA,IAAa,gBAAb,MAA2B;CACvB;CACA;CACA;CACA;CACA;CAEA,YACI,YACA,UACA,UACA,QACF;EACE,KAAKA,UAAU,aAAaC,mBAAyB,WAAW,OAAO;EACvE,KAAKC,YAAY;EACjB,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,mBAAmB,sBAAsB,MAAM;CACxD;;;;CAKA,MAAM,KACF,QAA4B,CAAC,GAC7B,SACmD;EACnD,MAAM,KAAKD,QAAQ,MAAM;EACzB,MAAM,WAAW,0BAA0B,OAAO,KAAKD,SAAS;EAChE,MAAM,iBAAiB,MAAM,0BAA0B,QAAQ;EAC/D,MAAM,MAAM,MAAM,KAAKH,QAAQ,cAC3B,gBAAgB,cAAc,GAC9B,qBAAqB,OAAO,CAChC;EACA,OAAO;GACH,QAAQ,MAAM,EAAE,MAAM,KAAKK,gBAAgB,GAAG,IAAI,MAAM;GACxD,eAAe,IAAI;EACvB;CACJ;;;;CAKA,UAAU,OAA6B;EACnC,MAAM,UAAU,uBAAuB,MAAM,UAAU;EACvD,OAAO,8BAA8B,KAAKH,WAAW;GACjD;GACA,QAAQI;GACR,aAAa,KAAKF,QAAQ,MAAM;GAChC,gBAAgB,SAAS;IACrB,MAAM,QAAQ,MAAM,KAAKC,kBAAkB,IAAI;IAC/C,MAAM,QAAQ,KAAK;GACvB;GACA,mBAAmB,MAAM,SAAS;GAClC,sBAAsB,MAAM,UAAU;GACtC,SAAS,MAAM;EACnB,CAAC;CACL;AACJ"}
+{"version":3,"file":"trades.js","names":["#client","Proto.OrdersReadService","#realtime","#resolver","#scales","#userTradeSchema","Proto.UserTradeSchema"],"sources":["../../../src/services/trades/trades.ts"],"sourcesContent":["import { createOrderTransferSchema, type OrderTransfer } from \"../orders/orders-output.schemas.js\";\nimport * as Proto from \"../../gen/orders/v1/orders_read_pb.js\";\nimport { createClient, type Client } from \"@connectrpc/connect\";\nimport * as v from \"valibot\";\nimport { parse } from \"../../shared/validation.js\";\nimport { removeUndefined } from \"../../utils/remove-undefined.js\";\nimport { type SubaccountResolver, resolveAccountScopedInput } from \"../subaccount-resolver.js\";\nimport type { PolyesterRealtime } from \"../../realtime/types.js\";\nimport { connectReadyGatedProtoChannel } from \"../../realtime/ready-gated-subscription.js\";\nimport type { BaseSubscribeInput } from \"../../shared/types.js\";\nimport {\n    toConnectCallOptions,\n    type PolyesterRequestOptions,\n} from \"../../shared/request-options.js\";\nimport type { SdkScales } from \"../../shared/decimal-surface.js\";\nimport type { AuthApiTransports } from \"../../shared/transports.js\";\nimport {\n    GetUserTradesInputSchema,\n    createUserTradeSchema,\n    type GetUserTradesInput,\n    type Trade,\n} from \"./trades.schemas.js\";\n\ninterface SubscribeTradesInput extends BaseSubscribeInput<Trade> {\n    accountId: string;\n}\n\n/**\n * Reads and streams authenticated user trade fills.\n */\nexport class TradesService {\n    #client: Client<typeof Proto.OrdersReadService>;\n    #realtime: PolyesterRealtime;\n    #resolver?: SubaccountResolver;\n    #scales: SdkScales;\n    #userTradeSchema: ReturnType<typeof createUserTradeSchema>;\n\n    constructor(\n        transports: AuthApiTransports,\n        realtime: PolyesterRealtime,\n        resolver: SubaccountResolver | undefined,\n        scales: SdkScales,\n    ) {\n        this.#client = createClient(Proto.OrdersReadService, transports.authApi);\n        this.#realtime = realtime;\n        this.#resolver = resolver;\n        this.#scales = scales;\n        this.#userTradeSchema = createUserTradeSchema(scales);\n    }\n\n    /**\n     * Returns user trades for the resolved root account or subaccount, supporting symbol, side, time range, limit, page token, and after-match-ID replay cursor filters. The `afterMatchId` cursor requires `symbolId`, enforced at the type and validation level. Results include the next page token from GetUserTrades.\n     * Scope executions to an order or lineage, optionally through a generation. Requested transfers\n     * belong to matches on this page; deduplicate them across pages by txId.\n     */\n    async list(\n        input: GetUserTradesInput = {},\n        options?: PolyesterRequestOptions,\n    ): Promise<{ trades: Trade[]; transfers: OrderTransfer[]; nextPageToken: string }> {\n        await this.#scales.ready();\n        const resolved = resolveAccountScopedInput(input, this.#resolver);\n        const validatedInput = parse(GetUserTradesInputSchema, resolved);\n        const res = await this.#client.getUserTrades(\n            removeUndefined(validatedInput),\n            toConnectCallOptions(options),\n        );\n        return {\n            trades: parse(v.array(this.#userTradeSchema), res.trades),\n            transfers: parse(v.array(createOrderTransferSchema()), res.transfers ?? []),\n            nextPageToken: res.nextPageToken,\n        };\n    }\n\n    /**\n     * Subscribes to private user trade updates on private:spot:trades:{accountId}:proto and emits parsed fills.\n     */\n    subscribe(input: SubscribeTradesInput) {\n        const channel = `private:spot:trades:${input.accountId}:proto`;\n        return connectReadyGatedProtoChannel(this.#realtime, {\n            channel,\n            schema: Proto.UserTradeSchema,\n            ready: () => this.#scales.ready(),\n            onPublication: (data) => {\n                const trade = parse(this.#userTradeSchema, data);\n                input.onEvent(trade);\n            },\n            onConnected: () => input.onOpen?.(),\n            onDisconnected: () => input.onClose?.(),\n            onError: input.onError,\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;AA8BA,IAAa,gBAAb,MAA2B;CACvB;CACA;CACA;CACA;CACA;CAEA,YACI,YACA,UACA,UACA,QACF;EACE,KAAKA,UAAU,aAAaC,mBAAyB,WAAW,OAAO;EACvE,KAAKC,YAAY;EACjB,KAAKC,YAAY;EACjB,KAAKC,UAAU;EACf,KAAKC,mBAAmB,sBAAsB,MAAM;CACxD;;;;;;CAOA,MAAM,KACF,QAA4B,CAAC,GAC7B,SAC+E;EAC/E,MAAM,KAAKD,QAAQ,MAAM;EACzB,MAAM,WAAW,0BAA0B,OAAO,KAAKD,SAAS;EAChE,MAAM,iBAAiB,MAAM,0BAA0B,QAAQ;EAC/D,MAAM,MAAM,MAAM,KAAKH,QAAQ,cAC3B,gBAAgB,cAAc,GAC9B,qBAAqB,OAAO,CAChC;EACA,OAAO;GACH,QAAQ,MAAM,EAAE,MAAM,KAAKK,gBAAgB,GAAG,IAAI,MAAM;GACxD,WAAW,MAAM,EAAE,MAAM,0BAA0B,CAAC,GAAG,IAAI,aAAa,CAAC,CAAC;GAC1E,eAAe,IAAI;EACvB;CACJ;;;;CAKA,UAAU,OAA6B;EACnC,MAAM,UAAU,uBAAuB,MAAM,UAAU;EACvD,OAAO,8BAA8B,KAAKH,WAAW;GACjD;GACA,QAAQI;GACR,aAAa,KAAKF,QAAQ,MAAM;GAChC,gBAAgB,SAAS;IACrB,MAAM,QAAQ,MAAM,KAAKC,kBAAkB,IAAI;IAC/C,MAAM,QAAQ,KAAK;GACvB;GACA,mBAAmB,MAAM,SAAS;GAClC,sBAAsB,MAAM,UAAU;GACtC,SAAS,MAAM;EACnB,CAAC;CACL;AACJ"}

package/dist/services/trades/trades.schemas.d.ts

@@ -22,6 +22,10 @@ declare function createUserTradeSchema(scales: SdkScales): v.SchemaWithPipe<read
   readonly feeIsRebate: v.BooleanSchema<undefined>;
   readonly tsNs: v.BigintSchema<undefined>;
   readonly matchId: v.BigintSchema<undefined>;
+  readonly lineage: v.OptionalSchema<v.ObjectSchema<{
+    readonly id: v.SchemaWithPipe<readonly [v.BigintSchema<undefined>, v.TransformAction<bigint, string>]>;
+    readonly generation: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>;
+  }, undefined>, undefined>;
 }, undefined>, v.TransformAction<{
   orderId: bigint;
   symbolId: number;
@@ -41,7 +45,15 @@ declare function createUserTradeSchema(scales: SdkScales): v.SchemaWithPipe<read
   feeIsRebate: boolean;
   tsNs: bigint;
   matchId: bigint;
+  lineage?: {
+    id: string;
+    generation: number;
+  } | undefined;
 }, {
+  lineage?: {
+    id: string;
+    generation: number;
+  } | undefined;
   feeIsRebate: boolean;
   tsNs: string;
   tsIso: string;
@@ -60,29 +72,133 @@ declare function createUserTradeSchema(scales: SdkScales): v.SchemaWithPipe<read
 /** A JSON-safe authenticated trade fill returned by the SDK. */
 type Trade = v.InferOutput<ReturnType<typeof createUserTradeSchema>>;
 /** Validates filters accepted by {@link TradesService.list}. */
-declare const GetUserTradesInputSchema: v.SchemaWithPipe<readonly [v.UnionSchema<[v.StrictObjectSchema<{
+declare const GetUserTradesInputSchema: v.SchemaWithPipe<readonly [v.UnionSchema<[v.UnionSchema<readonly [v.StrictObjectSchema<{
   readonly symbolId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.TransformAction<string, number>]>, undefined>, v.TransformAction<number | undefined, number | undefined>]>;
   readonly afterMatchId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
   readonly side: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<["buy", "sell"], undefined>, undefined>, v.TransformAction<"buy" | "sell" | undefined, Side.BUY | Side.SELL | undefined>]>;
   readonly startTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
   readonly endTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
-  readonly limit: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
   readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>;
+  readonly includeTransfers: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
   readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
     readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
   }, undefined>], undefined>, undefined>;
+} & {
+  readonly orderId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly lineageId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly throughGeneration: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+  readonly symbolId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.TransformAction<string, number>]>, undefined>, v.TransformAction<number | undefined, number | undefined>]>;
+  readonly afterMatchId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly side: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<["buy", "sell"], undefined>, undefined>, v.TransformAction<"buy" | "sell" | undefined, Side.BUY | Side.SELL | undefined>]>;
+  readonly startTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly endTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+  readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>;
+  readonly includeTransfers: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+} & {
+  readonly orderId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>, v.CheckAction<bigint, `${string} must be greater than zero`>]>;
+  readonly lineageId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly throughGeneration: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+  readonly symbolId: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.TransformAction<string, number>]>, undefined>, v.TransformAction<number | undefined, number | undefined>]>;
+  readonly afterMatchId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly side: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<["buy", "sell"], undefined>, undefined>, v.TransformAction<"buy" | "sell" | undefined, Side.BUY | Side.SELL | undefined>]>;
+  readonly startTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly endTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+  readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>;
+  readonly includeTransfers: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+} & {
+  readonly orderId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly lineageId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>, v.CheckAction<bigint, `${string} must be greater than zero`>]>;
+  readonly throughGeneration: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>, undefined>;
+}, undefined>], undefined>, v.UnionSchema<readonly [v.StrictObjectSchema<{
+  readonly symbolId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.TransformAction<string, number>]>, v.CheckAction<number, "symbolId is required when afterMatchId is set">]>;
+  readonly afterMatchId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint | undefined>]>;
+  readonly side: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<["buy", "sell"], undefined>, undefined>, v.TransformAction<"buy" | "sell" | undefined, Side.BUY | Side.SELL | undefined>]>;
+  readonly startTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly endTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+  readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>;
+  readonly includeTransfers: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+} & {
+  readonly orderId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly lineageId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly throughGeneration: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>, undefined>;
 }, undefined>, v.StrictObjectSchema<{
   readonly symbolId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.TransformAction<string, number>]>, v.CheckAction<number, "symbolId is required when afterMatchId is set">]>;
   readonly afterMatchId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint | undefined>]>;
   readonly side: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<["buy", "sell"], undefined>, undefined>, v.TransformAction<"buy" | "sell" | undefined, Side.BUY | Side.SELL | undefined>]>;
   readonly startTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
   readonly endTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
-  readonly limit: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
   readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>;
+  readonly includeTransfers: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
   readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
     readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
   }, undefined>], undefined>, undefined>;
-}, undefined>], "symbolId is required when afterMatchId is set">, v.TransformAction<{
+} & {
+  readonly orderId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>, v.CheckAction<bigint, `${string} must be greater than zero`>]>;
+  readonly lineageId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly throughGeneration: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>, undefined>;
+}, undefined>, v.StrictObjectSchema<{
+  readonly symbolId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.TransformAction<string, number>]>, v.CheckAction<number, "symbolId is required when afterMatchId is set">]>;
+  readonly afterMatchId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint | undefined>]>;
+  readonly side: v.SchemaWithPipe<readonly [v.OptionalSchema<v.PicklistSchema<["buy", "sell"], undefined>, undefined>, v.TransformAction<"buy" | "sell" | undefined, Side.BUY | Side.SELL | undefined>]>;
+  readonly startTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly endTsNs: v.SchemaWithPipe<readonly [v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>, v.TransformAction<string | undefined, bigint | undefined>]>;
+  readonly limit: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 1000, undefined>]>, undefined>;
+  readonly pageToken: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, undefined>;
+  readonly includeTransfers: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
+  readonly account: v.OptionalSchema<v.UnionSchema<[v.PicklistSchema<["active", "main"], undefined>, v.StrictObjectSchema<{
+    readonly subaccountId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  }, undefined>], undefined>, undefined>;
+} & {
+  readonly orderId: v.OptionalSchema<v.NeverSchema<undefined>, undefined>;
+  readonly lineageId: v.SchemaWithPipe<readonly [v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>, v.TransformAction<string, bigint>]>, v.CheckAction<bigint, `${string} must be greater than zero`>]>;
+  readonly throughGeneration: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.MinValueAction<number, 1, undefined>, v.MaxValueAction<number, 4294967295, undefined>]>, undefined>;
+}, undefined>], undefined>], ({ input }: v.UnionIssue<v.StringIssue | v.PicklistIssue | v.StrictObjectIssue | v.MinLengthIssue<string, 1> | v.UnionIssue<v.StringIssue | v.PicklistIssue | v.StrictObjectIssue | v.MinLengthIssue<string, 1>> | v.NumberIssue | v.IntegerIssue<number> | v.MaxValueIssue<number, 4294967295> | v.CheckIssue<bigint> | v.BooleanIssue | v.NeverIssue | v.MinValueIssue<number, 1> | v.MaxValueIssue<number, 1000> | v.UnionIssue<v.StringIssue | v.PicklistIssue | v.StrictObjectIssue | v.MinLengthIssue<string, 1> | v.UnionIssue<v.StringIssue | v.PicklistIssue | v.StrictObjectIssue | v.MinLengthIssue<string, 1>> | v.NumberIssue | v.IntegerIssue<number> | v.MaxValueIssue<number, 4294967295> | v.CheckIssue<bigint> | v.BooleanIssue | v.NeverIssue | v.MinValueIssue<number, 1> | v.MaxValueIssue<number, 1000>> | v.CheckIssue<number> | v.UnionIssue<v.StringIssue | v.PicklistIssue | v.StrictObjectIssue | v.MinLengthIssue<string, 1> | v.UnionIssue<v.StringIssue | v.PicklistIssue | v.StrictObjectIssue | v.MinLengthIssue<string, 1>> | v.NumberIssue | v.IntegerIssue<number> | v.MaxValueIssue<number, 4294967295> | v.CheckIssue<bigint> | v.BooleanIssue | v.NeverIssue | v.MinValueIssue<number, 1> | v.MaxValueIssue<number, 1000> | v.CheckIssue<number>>>) => "symbolId is required when afterMatchId is set" | "Provide at most one of orderId or lineageId">, v.TransformAction<{
+  symbolId?: number | undefined;
+  afterMatchId?: undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+  orderId?: undefined;
+  lineageId?: undefined;
+  throughGeneration?: number | undefined;
+} | {
+  symbolId?: number | undefined;
+  afterMatchId?: undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+  orderId: bigint;
+  lineageId?: undefined;
+  throughGeneration?: number | undefined;
+} | {
   symbolId?: number | undefined;
   afterMatchId?: undefined;
   side?: Side.BUY | Side.SELL | undefined;
@@ -90,9 +206,13 @@ declare const GetUserTradesInputSchema: v.SchemaWithPipe<readonly [v.UnionSchema
   endTsNs?: bigint | undefined;
   limit?: number | undefined;
   pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
   account?: "active" | "main" | {
     subaccountId: string;
   } | undefined;
+  orderId?: undefined;
+  lineageId: bigint;
+  throughGeneration?: number | undefined;
 } | {
   symbolId: number;
   afterMatchId: bigint | undefined;
@@ -101,10 +221,51 @@ declare const GetUserTradesInputSchema: v.SchemaWithPipe<readonly [v.UnionSchema
   endTsNs?: bigint | undefined;
   limit?: number | undefined;
   pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
   account?: "active" | "main" | {
     subaccountId: string;
   } | undefined;
+  orderId?: undefined;
+  lineageId?: undefined;
+  throughGeneration?: number | undefined;
+} | {
+  symbolId: number;
+  afterMatchId: bigint | undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+  orderId: bigint;
+  lineageId?: undefined;
+  throughGeneration?: number | undefined;
+} | {
+  symbolId: number;
+  afterMatchId: bigint | undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+  orderId?: undefined;
+  lineageId: bigint;
+  throughGeneration?: number | undefined;
 }, {
+  executionScope: {
+    readonly case: "orderId";
+    readonly value: bigint;
+  } | {
+    readonly case: "lineageId";
+    readonly value: bigint;
+  } | undefined;
   subaccountId: bigint | undefined;
   symbolId?: number | undefined;
   afterMatchId?: undefined;
@@ -113,7 +274,88 @@ declare const GetUserTradesInputSchema: v.SchemaWithPipe<readonly [v.UnionSchema
   endTsNs?: bigint | undefined;
   limit?: number | undefined;
   pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  throughGeneration?: number | undefined;
 } | {
+  executionScope: {
+    readonly case: "orderId";
+    readonly value: bigint;
+  } | {
+    readonly case: "lineageId";
+    readonly value: bigint;
+  } | undefined;
+  subaccountId: bigint | undefined;
+  symbolId?: number | undefined;
+  afterMatchId?: undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  throughGeneration?: number | undefined;
+} | {
+  executionScope: {
+    readonly case: "orderId";
+    readonly value: bigint;
+  } | {
+    readonly case: "lineageId";
+    readonly value: bigint;
+  } | undefined;
+  subaccountId: bigint | undefined;
+  symbolId?: number | undefined;
+  afterMatchId?: undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  throughGeneration?: number | undefined;
+} | {
+  executionScope: {
+    readonly case: "orderId";
+    readonly value: bigint;
+  } | {
+    readonly case: "lineageId";
+    readonly value: bigint;
+  } | undefined;
+  subaccountId: bigint | undefined;
+  symbolId: number;
+  afterMatchId: bigint | undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  throughGeneration?: number | undefined;
+} | {
+  executionScope: {
+    readonly case: "orderId";
+    readonly value: bigint;
+  } | {
+    readonly case: "lineageId";
+    readonly value: bigint;
+  } | undefined;
+  subaccountId: bigint | undefined;
+  symbolId: number;
+  afterMatchId: bigint | undefined;
+  side?: Side.BUY | Side.SELL | undefined;
+  startTsNs?: bigint | undefined;
+  endTsNs?: bigint | undefined;
+  limit?: number | undefined;
+  pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  throughGeneration?: number | undefined;
+} | {
+  executionScope: {
+    readonly case: "orderId";
+    readonly value: bigint;
+  } | {
+    readonly case: "lineageId";
+    readonly value: bigint;
+  } | undefined;
   subaccountId: bigint | undefined;
   symbolId: number;
   afterMatchId: bigint | undefined;
@@ -122,6 +364,8 @@ declare const GetUserTradesInputSchema: v.SchemaWithPipe<readonly [v.UnionSchema
   endTsNs?: bigint | undefined;
   limit?: number | undefined;
   pageToken?: string | undefined;
+  includeTransfers?: boolean | undefined;
+  throughGeneration?: number | undefined;
 }>]>;
 /**
  * Filters accepted by {@link TradesService.list}. Passing `afterMatchId` requires

package/dist/services/trades/trades.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"trades.schemas.d.ts","names":[],"sources":["../../../src/services/trades/trades.schemas.ts"],"mappings":";;;;;iBAsBgB,sBAAsB,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAwD3C,QAAQ,EAAE,YAAY,kBAAkB;;cAkDvC,0BAAwB,EAAA,yBAAA,EAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAezB,qBAAqB,EAAE,kBAAkB"}
+{"version":3,"file":"trades.schemas.d.ts","names":[],"sources":["../../../src/services/trades/trades.schemas.ts"],"mappings":";;;;;iBAyBgB,sBAAsB,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA0D3C,QAAQ,EAAE,YAAY,kBAAkB;;cAmFvC,0BAAwB,EAAA,yBAAA,EAAA,aAAA,EAAA,sBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KA8BzB,qBAAqB,EAAE,kBAAkB"}

package/dist/services/trades/trades.schemas.js

@@ -2,13 +2,16 @@ import { requiredEnumLabel } from "../../shared/proto-enum-codec.js";
 import { formatId } from "../../utils/base58-id.js";
 import { parseOptionalUint64DecimalStrict } from "../../utils/numbers.js";
 import { tsNsToISO, tsNsToMs } from "../../utils/time.js";
+import { PROTOBUF_UINT32_MAX } from "../../shared/wire-bounds.js";
 import { optionalUint64DecimalFilterSchema } from "../../shared/schemas.js";
 import { SideSchema } from "../shared.js";
 import { AccountScopeInputEntries, accountScopeToSubaccountId } from "../../shared/account-scope.js";
 import { scaledToDecimalOutput } from "../../shared/decimal-surface.js";
 import { fromU128 } from "../../utils/u128.js";
+import { OrderLineageSchema } from "../orders/order-lineage.schemas.js";
 import { FeeAssetCodec, OrderSideCodec } from "../orders/order-enums.codecs.js";
 import { TradeSideCodec } from "./trades.codecs.js";
+import { positiveOrderIdInputSchema } from "../orders/orders-identifiers.schemas.js";
 import * as v from "valibot";
 //#region src/services/trades/trades.schemas.ts
 const U128Schema = v.object({
@@ -29,7 +32,8 @@ function createUserTradeSchema(scales) {
 		referralShareAmountE18: v.optional(U128Schema),
 		feeIsRebate: v.boolean(),
 		tsNs: v.bigint(),
-		matchId: v.bigint()
+		matchId: v.bigint(),
+		lineage: v.optional(OrderLineageSchema)
 	}), v.transform((t) => {
 		const feeAsset = requiredEnumLabel(FeeAssetCodec.protoToOutput, t.feeAsset, "UserTradeSchema", "fee asset");
 		return {
@@ -46,37 +50,73 @@ function createUserTradeSchema(scales) {
 			tsNs: t.tsNs.toString(),
 			tsIso: tsNsToISO(t.tsNs),
 			tsMs: tsNsToMs(t.tsNs),
-			matchId: t.matchId.toString()
+			matchId: t.matchId.toString(),
+			...t.lineage === void 0 ? {} : { lineage: t.lineage }
 		};
 	}));
 }
 const AFTER_MATCH_REQUIRES_SYMBOL = "symbolId is required when afterMatchId is set";
+const EXECUTION_SCOPE_CONFLICT = "Provide at most one of orderId or lineageId";
 const SymbolIdStringSchema = v.pipe(v.string(), v.trim(), v.transform((value) => Number(value)));
 const GetUserTradesCommonEntries = {
 	...AccountScopeInputEntries,
 	side: v.pipe(v.optional(SideSchema), v.transform((v) => v ? TradeSideCodec.inputToProto[v] : void 0)),
 	startTsNs: optionalUint64DecimalFilterSchema("startTsNs"),
 	endTsNs: optionalUint64DecimalFilterSchema("endTsNs"),
-	limit: v.optional(v.number()),
-	pageToken: v.optional(v.pipe(v.string(), v.trim()))
+	limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(1e3))),
+	pageToken: v.optional(v.pipe(v.string(), v.trim())),
+	includeTransfers: v.optional(v.boolean())
 };
+const ThroughGenerationSchema = v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(PROTOBUF_UINT32_MAX)));
+function userTradesScopeSchemas(entries) {
+	return [
+		v.strictObject({
+			...entries,
+			orderId: v.optional(v.never()),
+			lineageId: v.optional(v.never()),
+			throughGeneration: ThroughGenerationSchema
+		}),
+		v.strictObject({
+			...entries,
+			orderId: positiveOrderIdInputSchema("orderId"),
+			lineageId: v.optional(v.never()),
+			throughGeneration: ThroughGenerationSchema
+		}),
+		v.strictObject({
+			...entries,
+			orderId: v.optional(v.never()),
+			lineageId: positiveOrderIdInputSchema("lineageId"),
+			throughGeneration: ThroughGenerationSchema
+		})
+	];
+}
 /** Browse mode: optional symbol filter, no replay cursor. */
-const BrowseUserTradesInputSchema = v.strictObject({
+const BrowseUserTradesInputSchema = v.union(userTradesScopeSchemas({
 	...GetUserTradesCommonEntries,
 	symbolId: v.pipe(v.optional(SymbolIdStringSchema), v.transform((sid) => sid !== void 0 && Number.isFinite(sid) && sid > 0 ? sid : void 0)),
 	afterMatchId: v.optional(v.never())
-});
+}));
 /** Replay mode: `afterMatchId` cursor, which the backend only accepts scoped to a symbol. */
-const ReplayUserTradesInputSchema = v.strictObject({
+const ReplayUserTradesInputSchema = v.union(userTradesScopeSchemas({
 	...GetUserTradesCommonEntries,
 	symbolId: v.pipe(SymbolIdStringSchema, v.check((sid) => Number.isInteger(sid) && sid > 0, AFTER_MATCH_REQUIRES_SYMBOL)),
 	afterMatchId: v.pipe(v.string(), v.trim(), v.minLength(1), v.transform((value) => parseOptionalUint64DecimalStrict(value, "afterMatchId")))
-});
+}));
 /** Validates filters accepted by {@link TradesService.list}. */
-const GetUserTradesInputSchema = v.pipe(v.union([BrowseUserTradesInputSchema, ReplayUserTradesInputSchema], AFTER_MATCH_REQUIRES_SYMBOL), v.transform(({ account, ...input }) => ({
-	...input,
-	subaccountId: accountScopeToSubaccountId(account)
-})));
+const GetUserTradesInputSchema = v.pipe(v.union([BrowseUserTradesInputSchema, ReplayUserTradesInputSchema], ({ input }) => typeof input === "object" && input !== null && "orderId" in input && input.orderId !== void 0 && "lineageId" in input && input.lineageId !== void 0 ? EXECUTION_SCOPE_CONFLICT : AFTER_MATCH_REQUIRES_SYMBOL), v.transform(({ account, orderId, lineageId, ...input }) => {
+	const executionScope = orderId !== void 0 ? {
+		case: "orderId",
+		value: orderId
+	} : lineageId !== void 0 ? {
+		case: "lineageId",
+		value: lineageId
+	} : void 0;
+	return {
+		...input,
+		executionScope,
+		subaccountId: accountScopeToSubaccountId(account)
+	};
+}));
 //#endregion
 export { GetUserTradesInputSchema, createUserTradeSchema };
 

package/dist/services/trades/trades.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"trades.schemas.js","names":[],"sources":["../../../src/services/trades/trades.schemas.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { tsNsToISO, tsNsToMs } from \"../../utils/time.js\";\nimport { SideSchema } from \"../shared.js\";\nimport { FeeAssetCodec, OrderSideCodec } from \"../orders/orders.codecs.js\";\nimport { formatId } from \"../../utils/base58-id.js\";\nimport { optionalUint64DecimalFilterSchema } from \"../../shared/schemas.js\";\nimport { parseOptionalUint64DecimalStrict } from \"../../utils/numbers.js\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport { TradeSideCodec } from \"./trades.codecs.js\";\nimport { requiredEnumLabel } from \"../../shared/proto-enum-codec.js\";\nimport { E18_SCALE, scaledToDecimalOutput, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport { fromU128 } from \"../../utils/u128.js\";\n\nconst U128Schema = v.object({\n    hi: v.bigint(),\n    lo: v.bigint(),\n});\n\n/** Parses a generated user-trade fill into the SDK's JSON-safe public shape. */\nexport function createUserTradeSchema(scales: SdkScales) {\n    return v.pipe(\n        v.object({\n            orderId: v.bigint(),\n            symbolId: v.number(),\n            side: v.number(),\n            isMaker: v.boolean(),\n            feeAsset: v.number(),\n            qtyScaled: v.bigint(),\n            priceTicks: v.bigint(),\n            feeAmountE18: v.optional(U128Schema),\n            referralShareAmountE18: v.optional(U128Schema),\n            feeIsRebate: v.boolean(),\n            tsNs: v.bigint(),\n            matchId: v.bigint(),\n        }),\n        v.transform((t) => {\n            const feeAsset = requiredEnumLabel(\n                FeeAssetCodec.protoToOutput,\n                t.feeAsset,\n                \"UserTradeSchema\",\n                \"fee asset\",\n            );\n            return {\n                orderId: formatId(t.orderId),\n                symbolId: t.symbolId,\n                sideLabel: requiredEnumLabel(\n                    OrderSideCodec.protoToOutput,\n                    t.side,\n                    \"UserTradeSchema\",\n                    \"side\",\n                ),\n                liquidityLabel: t.isMaker ? (\"maker\" as const) : (\"taker\" as const),\n                feeAsset,\n                qty: scaledToDecimalOutput(t.qtyScaled, scales.baseQty(t.symbolId)),\n                price: scaledToDecimalOutput(t.priceTicks, scales.price()),\n                fee: scaledToDecimalOutput(fromU128(t.feeAmountE18), E18_SCALE),\n                ...(t.referralShareAmountE18 === undefined\n                    ? {}\n                    : {\n                          referralShare: scaledToDecimalOutput(\n                              fromU128(t.referralShareAmountE18),\n                              E18_SCALE,\n                          ),\n                      }),\n                feeIsRebate: t.feeIsRebate,\n                tsNs: t.tsNs.toString(),\n                tsIso: tsNsToISO(t.tsNs),\n                tsMs: tsNsToMs(t.tsNs),\n                matchId: t.matchId.toString(),\n            };\n        }),\n    );\n}\n\n/** A JSON-safe authenticated trade fill returned by the SDK. */\nexport type Trade = v.InferOutput<ReturnType<typeof createUserTradeSchema>>;\n\nconst AFTER_MATCH_REQUIRES_SYMBOL = \"symbolId is required when afterMatchId is set\";\n\nconst SymbolIdStringSchema = v.pipe(\n    v.string(),\n    v.trim(),\n    v.transform((value) => Number(value)),\n);\n\nconst GetUserTradesCommonEntries = {\n    ...AccountScopeInputEntries,\n    side: v.pipe(\n        v.optional(SideSchema),\n        v.transform((v) => (v ? TradeSideCodec.inputToProto[v] : undefined)),\n    ),\n    startTsNs: optionalUint64DecimalFilterSchema(\"startTsNs\"),\n    endTsNs: optionalUint64DecimalFilterSchema(\"endTsNs\"),\n    limit: v.optional(v.number()),\n    pageToken: v.optional(v.pipe(v.string(), v.trim())),\n};\n\n/** Browse mode: optional symbol filter, no replay cursor. */\nconst BrowseUserTradesInputSchema = v.strictObject({\n    ...GetUserTradesCommonEntries,\n    symbolId: v.pipe(\n        v.optional(SymbolIdStringSchema),\n        v.transform((sid) =>\n            sid !== undefined && Number.isFinite(sid) && sid > 0 ? sid : undefined,\n        ),\n    ),\n    afterMatchId: v.optional(v.never()),\n});\n\n/** Replay mode: `afterMatchId` cursor, which the backend only accepts scoped to a symbol. */\nconst ReplayUserTradesInputSchema = v.strictObject({\n    ...GetUserTradesCommonEntries,\n    symbolId: v.pipe(\n        SymbolIdStringSchema,\n        v.check((sid) => Number.isInteger(sid) && sid > 0, AFTER_MATCH_REQUIRES_SYMBOL),\n    ),\n    afterMatchId: v.pipe(\n        v.string(),\n        v.trim(),\n        v.minLength(1),\n        v.transform((value) => parseOptionalUint64DecimalStrict(value, \"afterMatchId\")),\n    ),\n});\n\n/** Validates filters accepted by {@link TradesService.list}. */\nexport const GetUserTradesInputSchema = v.pipe(\n    v.union(\n        [BrowseUserTradesInputSchema, ReplayUserTradesInputSchema],\n        AFTER_MATCH_REQUIRES_SYMBOL,\n    ),\n    v.transform(({ account, ...input }) => ({\n        ...input,\n        subaccountId: accountScopeToSubaccountId(account),\n    })),\n);\n\n/**\n * Filters accepted by {@link TradesService.list}. Passing `afterMatchId` requires\n * `symbolId`; the two shapes form a discriminated union so the constraint is a compile error.\n */\nexport type GetUserTradesInput = v.InferInput<typeof GetUserTradesInputSchema>;\n"],"mappings":";;;;;;;;;;;;;AAgBA,MAAM,aAAa,EAAE,OAAO;CACxB,IAAI,EAAE,OAAO;CACb,IAAI,EAAE,OAAO;AACjB,CAAC;;AAGD,SAAgB,sBAAsB,QAAmB;CACrD,OAAO,EAAE,KACL,EAAE,OAAO;EACL,SAAS,EAAE,OAAO;EAClB,UAAU,EAAE,OAAO;EACnB,MAAM,EAAE,OAAO;EACf,SAAS,EAAE,QAAQ;EACnB,UAAU,EAAE,OAAO;EACnB,WAAW,EAAE,OAAO;EACpB,YAAY,EAAE,OAAO;EACrB,cAAc,EAAE,SAAS,UAAU;EACnC,wBAAwB,EAAE,SAAS,UAAU;EAC7C,aAAa,EAAE,QAAQ;EACvB,MAAM,EAAE,OAAO;EACf,SAAS,EAAE,OAAO;CACtB,CAAC,GACD,EAAE,WAAW,MAAM;EACf,MAAM,WAAW,kBACb,cAAc,eACd,EAAE,UACF,mBACA,WACJ;EACA,OAAO;GACH,SAAS,SAAS,EAAE,OAAO;GAC3B,UAAU,EAAE;GACZ,WAAW,kBACP,eAAe,eACf,EAAE,MACF,mBACA,MACJ;GACA,gBAAgB,EAAE,UAAW,UAAqB;GAClD;GACA,KAAK,sBAAsB,EAAE,WAAW,OAAO,QAAQ,EAAE,QAAQ,CAAC;GAClE,OAAO,sBAAsB,EAAE,YAAY,OAAO,MAAM,CAAC;GACzD,KAAK,sBAAsB,SAAS,EAAE,YAAY,GAAA,EAAY;GAC9D,GAAI,EAAE,2BAA2B,KAAA,IAC3B,CAAC,IACD,EACI,eAAe,sBACX,SAAS,EAAE,sBAAsB,GAAA,EAErC,EACJ;GACN,aAAa,EAAE;GACf,MAAM,EAAE,KAAK,SAAS;GACtB,OAAO,UAAU,EAAE,IAAI;GACvB,MAAM,SAAS,EAAE,IAAI;GACrB,SAAS,EAAE,QAAQ,SAAS;EAChC;CACJ,CAAC,CACL;AACJ;AAKA,MAAM,8BAA8B;AAEpC,MAAM,uBAAuB,EAAE,KAC3B,EAAE,OAAO,GACT,EAAE,KAAK,GACP,EAAE,WAAW,UAAU,OAAO,KAAK,CAAC,CACxC;AAEA,MAAM,6BAA6B;CAC/B,GAAG;CACH,MAAM,EAAE,KACJ,EAAE,SAAS,UAAU,GACrB,EAAE,WAAW,MAAO,IAAI,eAAe,aAAa,KAAK,KAAA,CAAU,CACvE;CACA,WAAW,kCAAkC,WAAW;CACxD,SAAS,kCAAkC,SAAS;CACpD,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC;CAC5B,WAAW,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,GAAG,EAAE,KAAK,CAAC,CAAC;AACtD;;AAGA,MAAM,8BAA8B,EAAE,aAAa;CAC/C,GAAG;CACH,UAAU,EAAE,KACR,EAAE,SAAS,oBAAoB,GAC/B,EAAE,WAAW,QACT,QAAQ,KAAA,KAAa,OAAO,SAAS,GAAG,KAAK,MAAM,IAAI,MAAM,KAAA,CACjE,CACJ;CACA,cAAc,EAAE,SAAS,EAAE,MAAM,CAAC;AACtC,CAAC;;AAGD,MAAM,8BAA8B,EAAE,aAAa;CAC/C,GAAG;CACH,UAAU,EAAE,KACR,sBACA,EAAE,OAAO,QAAQ,OAAO,UAAU,GAAG,KAAK,MAAM,GAAG,2BAA2B,CAClF;CACA,cAAc,EAAE,KACZ,EAAE,OAAO,GACT,EAAE,KAAK,GACP,EAAE,UAAU,CAAC,GACb,EAAE,WAAW,UAAU,iCAAiC,OAAO,cAAc,CAAC,CAClF;AACJ,CAAC;;AAGD,MAAa,2BAA2B,EAAE,KACtC,EAAE,MACE,CAAC,6BAA6B,2BAA2B,GACzD,2BACJ,GACA,EAAE,WAAW,EAAE,SAAS,GAAG,aAAa;CACpC,GAAG;CACH,cAAc,2BAA2B,OAAO;AACpD,EAAE,CACN"}
+{"version":3,"file":"trades.schemas.js","names":[],"sources":["../../../src/services/trades/trades.schemas.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { tsNsToISO, tsNsToMs } from \"../../utils/time.js\";\nimport { SideSchema } from \"../shared.js\";\nimport { FeeAssetCodec, OrderSideCodec } from \"../orders/orders.codecs.js\";\nimport { formatId } from \"../../utils/base58-id.js\";\nimport { optionalUint64DecimalFilterSchema } from \"../../shared/schemas.js\";\nimport { parseOptionalUint64DecimalStrict } from \"../../utils/numbers.js\";\nimport { PROTOBUF_UINT32_MAX } from \"../../shared/wire-bounds.js\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport { TradeSideCodec } from \"./trades.codecs.js\";\nimport { requiredEnumLabel } from \"../../shared/proto-enum-codec.js\";\nimport { E18_SCALE, scaledToDecimalOutput, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport { fromU128 } from \"../../utils/u128.js\";\nimport { OrderLineageSchema } from \"../orders/order-lineage.schemas.js\";\nimport { positiveOrderIdInputSchema } from \"../orders/orders-identifiers.schemas.js\";\n\nconst U128Schema = v.object({\n    hi: v.bigint(),\n    lo: v.bigint(),\n});\n\n/** Parses a generated user-trade fill into the SDK's JSON-safe public shape. */\nexport function createUserTradeSchema(scales: SdkScales) {\n    return v.pipe(\n        v.object({\n            orderId: v.bigint(),\n            symbolId: v.number(),\n            side: v.number(),\n            isMaker: v.boolean(),\n            feeAsset: v.number(),\n            qtyScaled: v.bigint(),\n            priceTicks: v.bigint(),\n            feeAmountE18: v.optional(U128Schema),\n            referralShareAmountE18: v.optional(U128Schema),\n            feeIsRebate: v.boolean(),\n            tsNs: v.bigint(),\n            matchId: v.bigint(),\n            lineage: v.optional(OrderLineageSchema),\n        }),\n        v.transform((t) => {\n            const feeAsset = requiredEnumLabel(\n                FeeAssetCodec.protoToOutput,\n                t.feeAsset,\n                \"UserTradeSchema\",\n                \"fee asset\",\n            );\n            return {\n                orderId: formatId(t.orderId),\n                symbolId: t.symbolId,\n                sideLabel: requiredEnumLabel(\n                    OrderSideCodec.protoToOutput,\n                    t.side,\n                    \"UserTradeSchema\",\n                    \"side\",\n                ),\n                liquidityLabel: t.isMaker ? (\"maker\" as const) : (\"taker\" as const),\n                feeAsset,\n                qty: scaledToDecimalOutput(t.qtyScaled, scales.baseQty(t.symbolId)),\n                price: scaledToDecimalOutput(t.priceTicks, scales.price()),\n                fee: scaledToDecimalOutput(fromU128(t.feeAmountE18), E18_SCALE),\n                ...(t.referralShareAmountE18 === undefined\n                    ? {}\n                    : {\n                          referralShare: scaledToDecimalOutput(\n                              fromU128(t.referralShareAmountE18),\n                              E18_SCALE,\n                          ),\n                      }),\n                feeIsRebate: t.feeIsRebate,\n                tsNs: t.tsNs.toString(),\n                tsIso: tsNsToISO(t.tsNs),\n                tsMs: tsNsToMs(t.tsNs),\n                matchId: t.matchId.toString(),\n                ...(t.lineage === undefined ? {} : { lineage: t.lineage }),\n            };\n        }),\n    );\n}\n\n/** A JSON-safe authenticated trade fill returned by the SDK. */\nexport type Trade = v.InferOutput<ReturnType<typeof createUserTradeSchema>>;\n\nconst AFTER_MATCH_REQUIRES_SYMBOL = \"symbolId is required when afterMatchId is set\";\nconst EXECUTION_SCOPE_CONFLICT = \"Provide at most one of orderId or lineageId\";\n\nconst SymbolIdStringSchema = v.pipe(\n    v.string(),\n    v.trim(),\n    v.transform((value) => Number(value)),\n);\n\nconst GetUserTradesCommonEntries = {\n    ...AccountScopeInputEntries,\n    side: v.pipe(\n        v.optional(SideSchema),\n        v.transform((v) => (v ? TradeSideCodec.inputToProto[v] : undefined)),\n    ),\n    startTsNs: optionalUint64DecimalFilterSchema(\"startTsNs\"),\n    endTsNs: optionalUint64DecimalFilterSchema(\"endTsNs\"),\n    limit: v.optional(v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(1000))),\n    pageToken: v.optional(v.pipe(v.string(), v.trim())),\n    includeTransfers: v.optional(v.boolean()),\n};\n\nconst ThroughGenerationSchema = v.optional(\n    v.pipe(v.number(), v.integer(), v.minValue(1), v.maxValue(PROTOBUF_UINT32_MAX)),\n);\n\nfunction userTradesScopeSchemas<const TEntries extends v.ObjectEntries>(entries: TEntries) {\n    return [\n        v.strictObject({\n            ...entries,\n            orderId: v.optional(v.never()),\n            lineageId: v.optional(v.never()),\n            throughGeneration: ThroughGenerationSchema,\n        }),\n        v.strictObject({\n            ...entries,\n            orderId: positiveOrderIdInputSchema(\"orderId\"),\n            lineageId: v.optional(v.never()),\n            throughGeneration: ThroughGenerationSchema,\n        }),\n        v.strictObject({\n            ...entries,\n            orderId: v.optional(v.never()),\n            lineageId: positiveOrderIdInputSchema(\"lineageId\"),\n            throughGeneration: ThroughGenerationSchema,\n        }),\n    ] as const;\n}\n\n/** Browse mode: optional symbol filter, no replay cursor. */\nconst BrowseUserTradesInputSchema = v.union(\n    userTradesScopeSchemas({\n        ...GetUserTradesCommonEntries,\n        symbolId: v.pipe(\n            v.optional(SymbolIdStringSchema),\n            v.transform((sid) =>\n                sid !== undefined && Number.isFinite(sid) && sid > 0 ? sid : undefined,\n            ),\n        ),\n        afterMatchId: v.optional(v.never()),\n    }),\n);\n\n/** Replay mode: `afterMatchId` cursor, which the backend only accepts scoped to a symbol. */\nconst ReplayUserTradesInputSchema = v.union(\n    userTradesScopeSchemas({\n        ...GetUserTradesCommonEntries,\n        symbolId: v.pipe(\n            SymbolIdStringSchema,\n            v.check((sid) => Number.isInteger(sid) && sid > 0, AFTER_MATCH_REQUIRES_SYMBOL),\n        ),\n        afterMatchId: v.pipe(\n            v.string(),\n            v.trim(),\n            v.minLength(1),\n            v.transform((value) => parseOptionalUint64DecimalStrict(value, \"afterMatchId\")),\n        ),\n    }),\n);\n\n/** Validates filters accepted by {@link TradesService.list}. */\nexport const GetUserTradesInputSchema = v.pipe(\n    v.union([BrowseUserTradesInputSchema, ReplayUserTradesInputSchema], ({ input }) =>\n        typeof input === \"object\" &&\n        input !== null &&\n        \"orderId\" in input &&\n        input.orderId !== undefined &&\n        \"lineageId\" in input &&\n        input.lineageId !== undefined\n            ? EXECUTION_SCOPE_CONFLICT\n            : AFTER_MATCH_REQUIRES_SYMBOL,\n    ),\n    v.transform(({ account, orderId, lineageId, ...input }) => {\n        const executionScope =\n            orderId !== undefined\n                ? ({ case: \"orderId\" as const, value: orderId } as const)\n                : lineageId !== undefined\n                  ? ({ case: \"lineageId\" as const, value: lineageId } as const)\n                  : undefined;\n        return {\n            ...input,\n            executionScope,\n            subaccountId: accountScopeToSubaccountId(account),\n        };\n    }),\n);\n\n/**\n * Filters accepted by {@link TradesService.list}. Passing `afterMatchId` requires\n * `symbolId`; the two shapes form a discriminated union so the constraint is a compile error.\n */\nexport type GetUserTradesInput = v.InferInput<typeof GetUserTradesInputSchema>;\n"],"mappings":"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"}