@polyester/sdk 0.0.0

package/dist/services/trading-withdraws/trading-withdraws.d.ts

@@ -0,0 +1,124 @@
+import { ClientCatalog } from "../../catalogs/types.js";
+import { TradingWithdrawAction } from "../../gen/chain/withdraw/v1/withdraw_pb.js";
+import { PolyesterMutationOptions } from "../../shared/request-options.js";
+import { SubaccountResolver } from "../subaccount-resolver.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { CreateTradingWithdrawResult, CreateTradingWithdrawToExternalChainInput, CreateTradingWithdrawToFundingInput, TradingWithdrawIntentPayloadRequest } from "./trading-withdraws.schemas.js";
+import { Transport } from "@connectrpc/connect";
+import { Address, Hex } from "viem";
+//#region src/services/trading-withdraws/trading-withdraws.d.ts
+type TradingWithdrawWalletTypedData = ReturnType<typeof buildTradingWithdrawWalletTypedData>;
+type TradingWithdrawWalletSigner = {
+  signerWallet: string;
+  accountId: string;
+  signTypedData: (typedData: TradingWithdrawWalletTypedData) => Promise<Hex>;
+};
+type TradingWithdrawSigningConfig = {
+  chainId: number;
+  tradingGatewayAddress: Address;
+};
+type CreateTradingWithdrawToFundingServiceInput = CreateTradingWithdrawToFundingInput & {
+  walletSigner?: TradingWithdrawWalletSigner;
+};
+type CreateTradingWithdrawToExternalChainServiceInput = CreateTradingWithdrawToExternalChainInput & {
+  walletSigner?: TradingWithdrawWalletSigner;
+};
+type PreparedTradingWithdraw = Readonly<{
+  /**
+   * Submits the exact payload and signature produced during preparation.
+   * Repeated calls only change transport options such as the step-up token.
+   */
+  submit: (options?: PolyesterMutationOptions) => Promise<CreateTradingWithdrawResult>;
+}>;
+declare function buildTradingWithdrawWalletTypedData(params: {
+  signingConfig: TradingWithdrawSigningConfig;
+  payload: TradingWithdrawIntentPayloadRequest;
+  signerWallet: Address;
+  accountId: bigint;
+  targetAccountId: bigint;
+}): {
+  readonly domain: {
+    readonly name: "Polyester Trading Withdraw";
+    readonly version: "1";
+    readonly chainId: number;
+    readonly verifyingContract: `0x${string}`;
+  };
+  readonly types: {
+    readonly WalletTradingWithdraw: readonly [{
+      readonly name: "signerWallet";
+      readonly type: "address";
+    }, {
+      readonly name: "actionType";
+      readonly type: "uint8";
+    }, {
+      readonly name: "accountId";
+      readonly type: "uint64";
+    }, {
+      readonly name: "targetAccountId";
+      readonly type: "uint64";
+    }, {
+      readonly name: "assetId";
+      readonly type: "uint32";
+    }, {
+      readonly name: "destinationChainId";
+      readonly type: "uint64";
+    }, {
+      readonly name: "amountQ";
+      readonly type: "uint128";
+    }, {
+      readonly name: "destinationHash";
+      readonly type: "bytes32";
+    }, {
+      readonly name: "deadlineTsSec";
+      readonly type: "uint256";
+    }, {
+      readonly name: "nonce";
+      readonly type: "uint128";
+    }, {
+      readonly name: "idempotencyKeyHash";
+      readonly type: "bytes32";
+    }];
+  };
+  readonly primaryType: "WalletTradingWithdraw";
+  readonly message: {
+    readonly signerWallet: `0x${string}`;
+    readonly actionType: TradingWithdrawAction;
+    readonly accountId: bigint;
+    readonly targetAccountId: bigint;
+    readonly assetId: number;
+    readonly destinationChainId: bigint;
+    readonly amountQ: bigint;
+    readonly destinationHash: `0x${string}`;
+    readonly deadlineTsSec: bigint;
+    readonly nonce: bigint;
+    readonly idempotencyKeyHash: `0x${string}`;
+  };
+};
+/**
+ * Creates durable Trading withdrawal intents to Funding using API signatures or wallet EIP-712 signatures.
+ */
+declare class TradingWithdrawsService {
+  #private;
+  constructor(transport: Transport, resolver: SubaccountResolver | undefined, signingConfig: TradingWithdrawSigningConfig, scales: SdkScales, catalog?: ClientCatalog);
+  /**
+   * Builds a Trading-to-Funding withdraw intent payload with asset id, decimal amount, destination address, five-minute deadline, nonce, and idempotency key. If a wallet signer is provided, it signs EIP-712 typed data and calls the wallet endpoint; otherwise a payload signature is required for the backend-authorized endpoint.
+   */
+  createToFunding(input: CreateTradingWithdrawToFundingServiceInput, options?: PolyesterMutationOptions): Promise<CreateTradingWithdrawResult>;
+  /**
+   * Builds and signs a Trading-to-Funding withdrawal once so the exact request can be
+   * resubmitted after backend-directed authorization such as MFA step-up.
+   */
+  prepareToFunding(input: CreateTradingWithdrawToFundingServiceInput): Promise<PreparedTradingWithdraw>;
+  /**
+   * Builds a Trading-to-external-chain withdraw intent payload with asset id, decimal gross amount, destination network, destination address, five-minute deadline, nonce, and idempotency key. If a wallet signer is provided, it signs EIP-712 typed data and calls the wallet endpoint; otherwise a payload signature is required for the backend-authorized endpoint.
+   */
+  createToExternalChain(input: CreateTradingWithdrawToExternalChainServiceInput, options?: PolyesterMutationOptions): Promise<CreateTradingWithdrawResult>;
+  /**
+   * Builds and signs a Trading-to-external-chain withdrawal once so the exact request can
+   * be resubmitted after backend-directed authorization such as MFA step-up.
+   */
+  prepareToExternalChain(input: CreateTradingWithdrawToExternalChainServiceInput): Promise<PreparedTradingWithdraw>;
+}
+//#endregion
+export { CreateTradingWithdrawToExternalChainServiceInput, CreateTradingWithdrawToFundingServiceInput, PreparedTradingWithdraw, TradingWithdrawSigningConfig, TradingWithdrawWalletSigner, TradingWithdrawWalletTypedData, TradingWithdrawsService };
+//# sourceMappingURL=trading-withdraws.d.ts.map

package/dist/services/trading-withdraws/trading-withdraws.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trading-withdraws.d.ts","names":[],"sources":["../../../src/services/trading-withdraws/trading-withdraws.ts"],"mappings":";;;;;;;;;KAiCY,iCAAiC,kBAAkB;KAEnD;EACR;EACA;EACA,gBAAgB,WAAW,mCAAmC,QAAQ;;KAG9D;EACR;EACA,uBAAuB;;KAGf,6CAA6C;EACrD,eAAe;;KAGP,mDACR;EACI,eAAe;;KAGX,0BAA0B;;;;;EAKlC,SAAS,UAAU,6BAA6B,QAAQ;;iBAyCnD,oCAAoC;EACzC,eAAe;EACf,SAAS;EACT,cAAc;EACd;EACA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cA0ES;;EAYL,YAAA,WAAW,WACX,UAAU,gCACV,eAAe,8BACf,QAAQ,WACR,UAAU;;;;EAeR,gBACF,OAAO,4CACP,UAAU,2BACX,QAAQ;;;;;EASL,iBACF,OAAO,6CACR,QAAQ;;;;EAWL,sBACF,OAAO,kDACP,UAAU,2BACX,QAAQ;;;;;EASL,uBACF,OAAO,mDACR,QAAQ"}

package/dist/services/trading-withdraws/trading-withdraws.js

@@ -0,0 +1,218 @@
+import { WithdrawService } from "../../gen/chain/withdraw/v1/withdraw_pb.js";
+import { ValidationError } from "../../shared/errors.js";
+import { toConnectCallOptions } from "../../shared/request-options.js";
+import { idToBigInt } from "../../utils/base58-id.js";
+import { removeUndefined } from "../../utils/remove-undefined.js";
+import { resolveAccountScopedInput } from "../subaccount-resolver.js";
+import { checksumEvmAddress, evmHexToBytes, evmUtf8ToBytes, keccak256Hex } from "../../utils/evm.js";
+import { CreateTradingWithdrawResultSchema, CreateWalletTradingWithdrawResultSchema, createCreateTradingWithdrawToExternalChainInputSchema, createCreateTradingWithdrawToFundingInputSchema } from "./trading-withdraws.schemas.js";
+import { createClient } from "@connectrpc/connect";
+import * as v from "valibot";
+//#region src/services/trading-withdraws/trading-withdraws.ts
+function fromU128(value) {
+	if (!value) return 0n;
+	return (value.hi << 64n) + value.lo;
+}
+function resolveTradingWithdrawTargetAccountId(params) {
+	if (params.subaccountId !== void 0) return params.subaccountId;
+	return idToBigInt(params.rootAccountId, "targetAccountId");
+}
+async function resolveTradingWithdrawSigningConfig(params) {
+	if (!params.catalog) return params.fallback;
+	try {
+		await params.catalog.ensureReady();
+		const address = params.catalog.zipper.getContractByName("tradingGateway")?.address?.trim();
+		if (!address?.startsWith("0x")) return params.fallback;
+		return {
+			chainId: params.fallback.chainId,
+			tradingGatewayAddress: checksumEvmAddress(address)
+		};
+	} catch {
+		return params.fallback;
+	}
+}
+function buildTradingWithdrawWalletTypedData(params) {
+	const payload = params.payload;
+	const destinationAddress = (payload.destinationAddress ?? "").trim();
+	const idempotencyKey = payload.idempotencyKey.trim();
+	return {
+		domain: {
+			name: "Polyester Trading Withdraw",
+			version: "1",
+			chainId: params.signingConfig.chainId,
+			verifyingContract: params.signingConfig.tradingGatewayAddress
+		},
+		types: { WalletTradingWithdraw: [
+			{
+				name: "signerWallet",
+				type: "address"
+			},
+			{
+				name: "actionType",
+				type: "uint8"
+			},
+			{
+				name: "accountId",
+				type: "uint64"
+			},
+			{
+				name: "targetAccountId",
+				type: "uint64"
+			},
+			{
+				name: "assetId",
+				type: "uint32"
+			},
+			{
+				name: "destinationChainId",
+				type: "uint64"
+			},
+			{
+				name: "amountQ",
+				type: "uint128"
+			},
+			{
+				name: "destinationHash",
+				type: "bytes32"
+			},
+			{
+				name: "deadlineTsSec",
+				type: "uint256"
+			},
+			{
+				name: "nonce",
+				type: "uint128"
+			},
+			{
+				name: "idempotencyKeyHash",
+				type: "bytes32"
+			}
+		] },
+		primaryType: "WalletTradingWithdraw",
+		message: {
+			signerWallet: params.signerWallet,
+			actionType: payload.action,
+			accountId: params.accountId,
+			targetAccountId: params.targetAccountId,
+			assetId: payload.assetId,
+			destinationChainId: payload.destinationChainId ?? 0n,
+			amountQ: fromU128(payload.amountE18),
+			destinationHash: keccak256Hex(evmUtf8ToBytes(destinationAddress)),
+			deadlineTsSec: payload.deadlineTsSec,
+			nonce: fromU128(payload.nonce),
+			idempotencyKeyHash: keccak256Hex(evmUtf8ToBytes(idempotencyKey))
+		}
+	};
+}
+async function resolveWalletSignature(params) {
+	const signerWallet = params.walletSigner.signerWallet.trim();
+	if (!signerWallet.startsWith("0x")) throw new ValidationError("Trading withdraw signer wallet is required.");
+	const accountId = idToBigInt(params.walletSigner.accountId, "accountId");
+	const signature = await params.walletSigner.signTypedData(buildTradingWithdrawWalletTypedData({
+		signingConfig: params.signingConfig,
+		payload: params.payload,
+		signerWallet,
+		accountId,
+		targetAccountId: params.targetAccountId
+	}));
+	return {
+		signerWallet,
+		payloadSignature: evmHexToBytes(signature)
+	};
+}
+/**
+* Creates durable Trading withdrawal intents to Funding using API signatures or wallet EIP-712 signatures.
+*/
+var TradingWithdrawsService = class {
+	#client;
+	#resolver;
+	#signingConfig;
+	#catalog;
+	#scales;
+	#toFundingInputSchema;
+	#toExternalChainInputSchema;
+	constructor(transport, resolver, signingConfig, scales, catalog) {
+		this.#client = createClient(WithdrawService, transport);
+		this.#resolver = resolver;
+		this.#signingConfig = signingConfig;
+		this.#catalog = catalog;
+		this.#scales = scales;
+		this.#toFundingInputSchema = createCreateTradingWithdrawToFundingInputSchema(scales);
+		this.#toExternalChainInputSchema = createCreateTradingWithdrawToExternalChainInputSchema(scales);
+	}
+	/**
+	* Builds a Trading-to-Funding withdraw intent payload with asset id, decimal amount, destination address, five-minute deadline, nonce, and idempotency key. If a wallet signer is provided, it signs EIP-712 typed data and calls the wallet endpoint; otherwise a payload signature is required for the backend-authorized endpoint.
+	*/
+	async createToFunding(input, options) {
+		return (await this.prepareToFunding(input)).submit(options);
+	}
+	/**
+	* Builds and signs a Trading-to-Funding withdrawal once so the exact request can be
+	* resubmitted after backend-directed authorization such as MFA step-up.
+	*/
+	async prepareToFunding(input) {
+		await this.#scales.ready();
+		const { walletSigner, ...inputForValidation } = input;
+		const resolvedInput = resolveAccountScopedInput(inputForValidation, this.#resolver);
+		const validated = v.parse(this.#toFundingInputSchema, resolvedInput);
+		return this.#prepareWithdraw(validated, walletSigner);
+	}
+	/**
+	* Builds a Trading-to-external-chain withdraw intent payload with asset id, decimal gross amount, destination network, destination address, five-minute deadline, nonce, and idempotency key. If a wallet signer is provided, it signs EIP-712 typed data and calls the wallet endpoint; otherwise a payload signature is required for the backend-authorized endpoint.
+	*/
+	async createToExternalChain(input, options) {
+		return (await this.prepareToExternalChain(input)).submit(options);
+	}
+	/**
+	* Builds and signs a Trading-to-external-chain withdrawal once so the exact request can
+	* be resubmitted after backend-directed authorization such as MFA step-up.
+	*/
+	async prepareToExternalChain(input) {
+		await this.#scales.ready();
+		const { walletSigner, ...inputForValidation } = input;
+		const resolvedInput = resolveAccountScopedInput(inputForValidation, this.#resolver);
+		const validated = v.parse(this.#toExternalChainInputSchema, resolvedInput);
+		return this.#prepareWithdraw(validated, walletSigner);
+	}
+	async #prepareWithdraw(validated, walletSigner) {
+		if (walletSigner) {
+			const signingConfig = await resolveTradingWithdrawSigningConfig({
+				fallback: this.#signingConfig,
+				catalog: this.#catalog
+			});
+			const targetAccountId = resolveTradingWithdrawTargetAccountId({
+				subaccountId: validated.subaccountId,
+				rootAccountId: walletSigner.accountId
+			});
+			const walletSignature = await resolveWalletSignature({
+				signingConfig,
+				payload: validated.payload,
+				walletSigner,
+				targetAccountId
+			});
+			const request = removeUndefined({
+				payload: validated.payload,
+				subaccountId: validated.subaccountId,
+				signerWallet: walletSignature.signerWallet,
+				payloadSignature: walletSignature.payloadSignature
+			});
+			return { submit: async (options) => {
+				const response = await this.#client.createWalletTradingWithdraw(request, toConnectCallOptions(options));
+				return v.parse(CreateWalletTradingWithdrawResultSchema, response);
+			} };
+		}
+		if (!validated.payloadSignature) throw new ValidationError("Trading withdraw requires a wallet signer or payload signature.");
+		const request = removeUndefined({
+			payload: validated.payload,
+			payloadSignature: validated.payloadSignature
+		});
+		return { submit: async (options) => {
+			const response = await this.#client.createTradingWithdraw(request, toConnectCallOptions(options));
+			return v.parse(CreateTradingWithdrawResultSchema, response);
+		} };
+	}
+};
+//#endregion
+export { TradingWithdrawsService };
+
+//# sourceMappingURL=trading-withdraws.js.map

package/dist/services/trading-withdraws/trading-withdraws.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trading-withdraws.js","names":["#client","Proto.WithdrawService","#resolver","#signingConfig","#catalog","#scales","#toFundingInputSchema","#toExternalChainInputSchema","#prepareWithdraw"],"sources":["../../../src/services/trading-withdraws/trading-withdraws.ts"],"sourcesContent":["import { ValidationError } from \"../../shared/errors.js\";\nimport { createClient, type Client, type Transport } from \"@connectrpc/connect\";\nimport type { Address, Hex } from \"viem\";\nimport {\n    checksumEvmAddress,\n    evmHexToBytes,\n    evmUtf8ToBytes,\n    keccak256Hex,\n} from \"../../utils/evm.js\";\nimport type { ClientCatalog } from \"../../catalogs/types.js\";\nimport * as Proto from \"../../gen/chain/withdraw/v1/withdraw_pb.js\";\nimport { idToBigInt } from \"../../utils/base58-id.js\";\nimport { removeUndefined } from \"../../utils/remove-undefined.js\";\nimport {\n    toConnectCallOptions,\n    type PolyesterMutationOptions,\n} from \"../../shared/request-options.js\";\nimport { type SubaccountResolver, resolveAccountScopedInput } from \"../subaccount-resolver.js\";\nimport type { SdkScales } from \"../../shared/decimal-surface.js\";\nimport * as v from \"valibot\";\nimport {\n    createCreateTradingWithdrawToExternalChainInputSchema,\n    createCreateTradingWithdrawToFundingInputSchema,\n    CreateTradingWithdrawResultSchema,\n    CreateWalletTradingWithdrawResultSchema,\n    type CreateTradingWithdrawResult,\n    type CreateTradingWithdrawToExternalChainInput,\n    type CreateTradingWithdrawToExternalChainRequest,\n    type CreateTradingWithdrawToFundingInput,\n    type CreateTradingWithdrawToFundingRequest,\n    type TradingWithdrawIntentPayloadRequest,\n} from \"./trading-withdraws.schemas.js\";\n\nexport type TradingWithdrawWalletTypedData = ReturnType<typeof buildTradingWithdrawWalletTypedData>;\n\nexport type TradingWithdrawWalletSigner = {\n    signerWallet: string;\n    accountId: string;\n    signTypedData: (typedData: TradingWithdrawWalletTypedData) => Promise<Hex>;\n};\n\nexport type TradingWithdrawSigningConfig = {\n    chainId: number;\n    tradingGatewayAddress: Address;\n};\n\nexport type CreateTradingWithdrawToFundingServiceInput = CreateTradingWithdrawToFundingInput & {\n    walletSigner?: TradingWithdrawWalletSigner;\n};\n\nexport type CreateTradingWithdrawToExternalChainServiceInput =\n    CreateTradingWithdrawToExternalChainInput & {\n        walletSigner?: TradingWithdrawWalletSigner;\n    };\n\nexport type PreparedTradingWithdraw = Readonly<{\n    /**\n     * Submits the exact payload and signature produced during preparation.\n     * Repeated calls only change transport options such as the step-up token.\n     */\n    submit: (options?: PolyesterMutationOptions) => Promise<CreateTradingWithdrawResult>;\n}>;\n\ntype TradingWithdrawRequest =\n    | CreateTradingWithdrawToFundingRequest\n    | CreateTradingWithdrawToExternalChainRequest;\n\nfunction fromU128(value: TradingWithdrawIntentPayloadRequest[\"amountE18\"] | undefined): bigint {\n    if (!value) return 0n;\n    return (value.hi << 64n) + value.lo;\n}\n\nfunction resolveTradingWithdrawTargetAccountId(params: {\n    subaccountId: bigint | undefined;\n    rootAccountId: string;\n}): bigint {\n    if (params.subaccountId !== undefined) return params.subaccountId;\n    return idToBigInt(params.rootAccountId, \"targetAccountId\");\n}\n\nasync function resolveTradingWithdrawSigningConfig(params: {\n    fallback: TradingWithdrawSigningConfig;\n    catalog?: ClientCatalog;\n}): Promise<TradingWithdrawSigningConfig> {\n    if (!params.catalog) return params.fallback;\n\n    try {\n        await params.catalog.ensureReady();\n        const gateway = params.catalog.zipper.getContractByName(\"tradingGateway\");\n        const address = gateway?.address?.trim();\n        if (!address?.startsWith(\"0x\")) return params.fallback;\n\n        return {\n            chainId: params.fallback.chainId,\n            tradingGatewayAddress: checksumEvmAddress(address),\n        };\n    } catch {\n        return params.fallback;\n    }\n}\n\nfunction buildTradingWithdrawWalletTypedData(params: {\n    signingConfig: TradingWithdrawSigningConfig;\n    payload: TradingWithdrawIntentPayloadRequest;\n    signerWallet: Address;\n    accountId: bigint;\n    targetAccountId: bigint;\n}) {\n    const payload = params.payload;\n    const destinationAddress = (payload.destinationAddress ?? \"\").trim();\n    const idempotencyKey = payload.idempotencyKey.trim();\n\n    return {\n        domain: {\n            name: \"Polyester Trading Withdraw\",\n            version: \"1\",\n            chainId: params.signingConfig.chainId,\n            verifyingContract: params.signingConfig.tradingGatewayAddress,\n        },\n        types: {\n            WalletTradingWithdraw: [\n                { name: \"signerWallet\", type: \"address\" },\n                { name: \"actionType\", type: \"uint8\" },\n                { name: \"accountId\", type: \"uint64\" },\n                { name: \"targetAccountId\", type: \"uint64\" },\n                { name: \"assetId\", type: \"uint32\" },\n                { name: \"destinationChainId\", type: \"uint64\" },\n                { name: \"amountQ\", type: \"uint128\" },\n                { name: \"destinationHash\", type: \"bytes32\" },\n                { name: \"deadlineTsSec\", type: \"uint256\" },\n                { name: \"nonce\", type: \"uint128\" },\n                { name: \"idempotencyKeyHash\", type: \"bytes32\" },\n            ],\n        },\n        primaryType: \"WalletTradingWithdraw\",\n        message: {\n            signerWallet: params.signerWallet,\n            actionType: payload.action,\n            accountId: params.accountId,\n            targetAccountId: params.targetAccountId,\n            assetId: payload.assetId,\n            destinationChainId: payload.destinationChainId ?? 0n,\n            amountQ: fromU128(payload.amountE18),\n            destinationHash: keccak256Hex(evmUtf8ToBytes(destinationAddress)),\n            deadlineTsSec: payload.deadlineTsSec,\n            nonce: fromU128(payload.nonce),\n            idempotencyKeyHash: keccak256Hex(evmUtf8ToBytes(idempotencyKey)),\n        },\n    } as const;\n}\n\nasync function resolveWalletSignature(params: {\n    signingConfig: TradingWithdrawSigningConfig;\n    payload: TradingWithdrawIntentPayloadRequest;\n    walletSigner: TradingWithdrawWalletSigner;\n    targetAccountId: bigint;\n}): Promise<{ signerWallet: string; payloadSignature: Uint8Array }> {\n    const signerWallet = params.walletSigner.signerWallet.trim();\n    if (!signerWallet.startsWith(\"0x\")) {\n        throw new ValidationError(\"Trading withdraw signer wallet is required.\");\n    }\n    const accountId = idToBigInt(params.walletSigner.accountId, \"accountId\");\n    const signature = await params.walletSigner.signTypedData(\n        buildTradingWithdrawWalletTypedData({\n            signingConfig: params.signingConfig,\n            payload: params.payload,\n            signerWallet: signerWallet as Address,\n            accountId,\n            targetAccountId: params.targetAccountId,\n        }),\n    );\n    return {\n        signerWallet,\n        payloadSignature: evmHexToBytes(signature),\n    };\n}\n\n/**\n * Creates durable Trading withdrawal intents to Funding using API signatures or wallet EIP-712 signatures.\n */\nexport class TradingWithdrawsService {\n    #client: Client<typeof Proto.WithdrawService>;\n    #resolver?: SubaccountResolver;\n    #signingConfig: TradingWithdrawSigningConfig;\n    #catalog?: ClientCatalog;\n    #scales: SdkScales;\n    #toFundingInputSchema: ReturnType<typeof createCreateTradingWithdrawToFundingInputSchema>;\n    #toExternalChainInputSchema: ReturnType<\n        typeof createCreateTradingWithdrawToExternalChainInputSchema\n    >;\n\n    constructor(\n        transport: Transport,\n        resolver: SubaccountResolver | undefined,\n        signingConfig: TradingWithdrawSigningConfig,\n        scales: SdkScales,\n        catalog?: ClientCatalog,\n    ) {\n        this.#client = createClient(Proto.WithdrawService, transport);\n        this.#resolver = resolver;\n        this.#signingConfig = signingConfig;\n        this.#catalog = catalog;\n        this.#scales = scales;\n        this.#toFundingInputSchema = createCreateTradingWithdrawToFundingInputSchema(scales);\n        this.#toExternalChainInputSchema =\n            createCreateTradingWithdrawToExternalChainInputSchema(scales);\n    }\n\n    /**\n     * Builds a Trading-to-Funding withdraw intent payload with asset id, decimal amount, destination address, five-minute deadline, nonce, and idempotency key. If a wallet signer is provided, it signs EIP-712 typed data and calls the wallet endpoint; otherwise a payload signature is required for the backend-authorized endpoint.\n     */\n    async createToFunding(\n        input: CreateTradingWithdrawToFundingServiceInput,\n        options?: PolyesterMutationOptions,\n    ): Promise<CreateTradingWithdrawResult> {\n        const prepared = await this.prepareToFunding(input);\n        return prepared.submit(options);\n    }\n\n    /**\n     * Builds and signs a Trading-to-Funding withdrawal once so the exact request can be\n     * resubmitted after backend-directed authorization such as MFA step-up.\n     */\n    async prepareToFunding(\n        input: CreateTradingWithdrawToFundingServiceInput,\n    ): Promise<PreparedTradingWithdraw> {\n        await this.#scales.ready();\n        const { walletSigner, ...inputForValidation } = input;\n        const resolvedInput = resolveAccountScopedInput(inputForValidation, this.#resolver);\n        const validated = v.parse(this.#toFundingInputSchema, resolvedInput);\n        return this.#prepareWithdraw(validated, walletSigner);\n    }\n\n    /**\n     * Builds a Trading-to-external-chain withdraw intent payload with asset id, decimal gross amount, destination network, destination address, five-minute deadline, nonce, and idempotency key. If a wallet signer is provided, it signs EIP-712 typed data and calls the wallet endpoint; otherwise a payload signature is required for the backend-authorized endpoint.\n     */\n    async createToExternalChain(\n        input: CreateTradingWithdrawToExternalChainServiceInput,\n        options?: PolyesterMutationOptions,\n    ): Promise<CreateTradingWithdrawResult> {\n        const prepared = await this.prepareToExternalChain(input);\n        return prepared.submit(options);\n    }\n\n    /**\n     * Builds and signs a Trading-to-external-chain withdrawal once so the exact request can\n     * be resubmitted after backend-directed authorization such as MFA step-up.\n     */\n    async prepareToExternalChain(\n        input: CreateTradingWithdrawToExternalChainServiceInput,\n    ): Promise<PreparedTradingWithdraw> {\n        await this.#scales.ready();\n        const { walletSigner, ...inputForValidation } = input;\n        const resolvedInput = resolveAccountScopedInput(inputForValidation, this.#resolver);\n        const validated = v.parse(this.#toExternalChainInputSchema, resolvedInput);\n        return this.#prepareWithdraw(validated, walletSigner);\n    }\n\n    async #prepareWithdraw(\n        validated: TradingWithdrawRequest,\n        walletSigner: TradingWithdrawWalletSigner | undefined,\n    ): Promise<PreparedTradingWithdraw> {\n        if (walletSigner) {\n            const signingConfig = await resolveTradingWithdrawSigningConfig({\n                fallback: this.#signingConfig,\n                catalog: this.#catalog,\n            });\n            const targetAccountId = resolveTradingWithdrawTargetAccountId({\n                subaccountId: validated.subaccountId,\n                rootAccountId: walletSigner.accountId,\n            });\n\n            const walletSignature = await resolveWalletSignature({\n                signingConfig,\n                payload: validated.payload,\n                walletSigner,\n                targetAccountId,\n            });\n            const request = removeUndefined({\n                payload: validated.payload,\n                subaccountId: validated.subaccountId,\n                signerWallet: walletSignature.signerWallet,\n                payloadSignature: walletSignature.payloadSignature,\n            });\n            return {\n                submit: async (options) => {\n                    const response = await this.#client.createWalletTradingWithdraw(\n                        request,\n                        toConnectCallOptions(options),\n                    );\n                    return v.parse(CreateWalletTradingWithdrawResultSchema, response);\n                },\n            };\n        }\n\n        if (!validated.payloadSignature) {\n            throw new ValidationError(\n                \"Trading withdraw requires a wallet signer or payload signature.\",\n            );\n        }\n\n        const request = removeUndefined({\n            payload: validated.payload,\n            payloadSignature: validated.payloadSignature,\n        });\n        return {\n            submit: async (options) => {\n                const response = await this.#client.createTradingWithdraw(\n                    request,\n                    toConnectCallOptions(options),\n                );\n                return v.parse(CreateTradingWithdrawResultSchema, response);\n            },\n        };\n    }\n}\n"],"mappings":"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"}

package/dist/services/trading-withdraws/trading-withdraws.schemas.d.ts

@@ -0,0 +1,73 @@
+import { TradingWithdrawAction } from "../../gen/chain/withdraw/v1/withdraw_pb.js";
+import { SdkScales } from "../../shared/decimal-surface.js";
+import { U128Value } from "../../utils/u128.js";
+import * as v from "valibot";
+//#region src/services/trading-withdraws/trading-withdraws.schemas.d.ts
+type TradingWithdrawIntentPayloadRequest = {
+  action: TradingWithdrawAction;
+  assetId: number;
+  destinationChainId: bigint;
+  amountE18: U128Value;
+  deadlineTsSec: bigint;
+  nonce: U128Value;
+  destinationAddress: string;
+  idempotencyKey: string;
+};
+type CreateTradingWithdrawRequestBase = {
+  subaccountId: bigint | undefined;
+  payload: TradingWithdrawIntentPayloadRequest;
+  payloadSignature?: Uint8Array;
+};
+declare function createCreateTradingWithdrawToFundingInputSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly assetId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+  readonly quantity: v.StringSchema<undefined>;
+  readonly idempotencyKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly destinationAddress: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, "">;
+  readonly signerWallet: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, "">;
+  readonly payloadSignature: v.OptionalSchema<v.InstanceSchema<Uint8ArrayConstructor, 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>, v.TransformAction<{
+  assetId: number;
+  quantity: string;
+  idempotencyKey: string;
+  destinationAddress: string;
+  signerWallet: string;
+  payloadSignature?: Uint8Array<ArrayBuffer> | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, CreateTradingWithdrawRequestBase>]>;
+declare function createCreateTradingWithdrawToExternalChainInputSchema(scales: SdkScales): v.SchemaWithPipe<readonly [v.StrictObjectSchema<{
+  readonly assetId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>]>;
+  readonly quantity: v.StringSchema<undefined>;
+  readonly destinationChainId: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.IntegerAction<number, undefined>, v.GtValueAction<number, 0, undefined>, v.MaxValueAction<number, number, undefined>]>;
+  readonly destinationAddress: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly idempotencyKey: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+  readonly signerWallet: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction]>, "">;
+  readonly payloadSignature: v.OptionalSchema<v.InstanceSchema<Uint8ArrayConstructor, 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>, v.TransformAction<{
+  assetId: number;
+  quantity: string;
+  destinationChainId: number;
+  destinationAddress: string;
+  idempotencyKey: string;
+  signerWallet: string;
+  payloadSignature?: Uint8Array<ArrayBuffer> | undefined;
+  account?: "active" | "main" | {
+    subaccountId: string;
+  } | undefined;
+}, CreateTradingWithdrawRequestBase>]>;
+type CreateTradingWithdrawToFundingInput = v.InferInput<ReturnType<typeof createCreateTradingWithdrawToFundingInputSchema>>;
+type CreateTradingWithdrawToExternalChainInput = v.InferInput<ReturnType<typeof createCreateTradingWithdrawToExternalChainInputSchema>>;
+declare const CreateTradingWithdrawResultSchema: v.ObjectSchema<{
+  readonly intentId: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 1, undefined>]>;
+}, undefined>;
+type CreateTradingWithdrawResult = v.InferOutput<typeof CreateTradingWithdrawResultSchema>;
+//#endregion
+export { CreateTradingWithdrawResult, CreateTradingWithdrawResultSchema, CreateTradingWithdrawToExternalChainInput, CreateTradingWithdrawToFundingInput, TradingWithdrawIntentPayloadRequest, createCreateTradingWithdrawToExternalChainInputSchema, createCreateTradingWithdrawToFundingInputSchema };
+//# sourceMappingURL=trading-withdraws.schemas.d.ts.map

package/dist/services/trading-withdraws/trading-withdraws.schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trading-withdraws.schemas.d.ts","names":[],"sources":["../../../src/services/trading-withdraws/trading-withdraws.schemas.ts"],"mappings":";;;;;KAYY;EACR,QAAQ;EACR;EACA;EACA,WAAW;EACX;EACA,OAAO;EACP;EACA;;KAGC;EACD;EACA,SAAS;EACT,mBAAmB;;iBAoCP,gDAAgD,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;GA+BhF;iBAEe,sDAAsD,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;GAqCtF;KAEW,sCAAsC,EAAE,WAChD,kBAAkB;KAOV,4CAA4C,EAAE,WACtD,kBAAkB;cAOT,mCAAiC,EAAA;;;KAIlC,8BAA8B,EAAE,mBAAmB"}

package/dist/services/trading-withdraws/trading-withdraws.schemas.js

@@ -0,0 +1,95 @@
+import { AccountScopeInputEntries, accountScopeToSubaccountId } from "../../shared/account-scope.js";
+import { quantityInputToE18 } from "../../shared/decimal-surface.js";
+import { toU128 } from "../../utils/u128.js";
+import { TradingWithdrawActionCodec } from "./trading-withdraws.codecs.js";
+import * as v from "valibot";
+//#region src/services/trading-withdraws/trading-withdraws.schemas.ts
+const DEFAULT_DEADLINE_SECONDS = 300;
+function createNonce() {
+	const random = globalThis.crypto?.getRandomValues?.bind(globalThis.crypto);
+	if (!random) {
+		const nonce = BigInt(Date.now());
+		return nonce === 0n ? 1n : nonce;
+	}
+	const bytes = /* @__PURE__ */ new BigUint64Array(1);
+	random(bytes);
+	const nonce = bytes[0] ?? BigInt(Date.now());
+	return nonce === 0n ? 1n : nonce;
+}
+function createTradingWithdrawPayload(input) {
+	return {
+		action: input.action,
+		assetId: input.assetId,
+		destinationChainId: input.destinationChainId,
+		amountE18: toU128(input.quantityScaled),
+		deadlineTsSec: BigInt(Math.floor(Date.now() / 1e3) + DEFAULT_DEADLINE_SECONDS),
+		nonce: toU128(createNonce()),
+		destinationAddress: input.destinationAddress,
+		idempotencyKey: input.idempotencyKey
+	};
+}
+function createCreateTradingWithdrawToFundingInputSchema(scales) {
+	return v.pipe(v.strictObject({
+		...AccountScopeInputEntries,
+		assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
+		quantity: v.string(),
+		idempotencyKey: v.pipe(v.string(), v.trim(), v.minLength(1)),
+		destinationAddress: v.optional(v.pipe(v.string(), v.trim()), ""),
+		signerWallet: v.optional(v.pipe(v.string(), v.trim()), ""),
+		payloadSignature: v.optional(v.instance(Uint8Array))
+	}), v.transform((input) => {
+		const quantityScaled = quantityInputToE18({
+			scales,
+			assetId: input.assetId,
+			quantity: input.quantity
+		});
+		return {
+			subaccountId: accountScopeToSubaccountId(input.account),
+			payloadSignature: input.payloadSignature,
+			payload: createTradingWithdrawPayload({
+				action: TradingWithdrawActionCodec.inputToProto.to_funding,
+				assetId: input.assetId,
+				destinationChainId: 0n,
+				quantityScaled,
+				destinationAddress: input.destinationAddress,
+				idempotencyKey: input.idempotencyKey
+			})
+		};
+	}));
+}
+function createCreateTradingWithdrawToExternalChainInputSchema(scales) {
+	return v.pipe(v.strictObject({
+		...AccountScopeInputEntries,
+		assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),
+		quantity: v.string(),
+		destinationChainId: v.pipe(v.number(), v.integer(), v.gtValue(0), v.maxValue(Number.MAX_SAFE_INTEGER)),
+		destinationAddress: v.pipe(v.string(), v.trim(), v.minLength(1)),
+		idempotencyKey: v.pipe(v.string(), v.trim(), v.minLength(1)),
+		signerWallet: v.optional(v.pipe(v.string(), v.trim()), ""),
+		payloadSignature: v.optional(v.instance(Uint8Array))
+	}), v.transform((input) => {
+		const quantityScaled = quantityInputToE18({
+			scales,
+			assetId: input.assetId,
+			quantity: input.quantity
+		});
+		return {
+			subaccountId: accountScopeToSubaccountId(input.account),
+			payloadSignature: input.payloadSignature,
+			payload: createTradingWithdrawPayload({
+				action: TradingWithdrawActionCodec.inputToProto.to_external_chain,
+				assetId: input.assetId,
+				destinationChainId: BigInt(input.destinationChainId),
+				quantityScaled,
+				destinationAddress: input.destinationAddress,
+				idempotencyKey: input.idempotencyKey
+			})
+		};
+	}));
+}
+const CreateTradingWithdrawResultSchema = v.object({ intentId: v.pipe(v.string(), v.trim(), v.minLength(1)) });
+const CreateWalletTradingWithdrawResultSchema = CreateTradingWithdrawResultSchema;
+//#endregion
+export { CreateTradingWithdrawResultSchema, CreateWalletTradingWithdrawResultSchema, createCreateTradingWithdrawToExternalChainInputSchema, createCreateTradingWithdrawToFundingInputSchema };
+
+//# sourceMappingURL=trading-withdraws.schemas.js.map

package/dist/services/trading-withdraws/trading-withdraws.schemas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trading-withdraws.schemas.js","names":[],"sources":["../../../src/services/trading-withdraws/trading-withdraws.schemas.ts"],"sourcesContent":["import * as v from \"valibot\";\nimport { quantityInputToE18, type SdkScales } from \"../../shared/decimal-surface.js\";\nimport {\n    AccountScopeInputEntries,\n    accountScopeToSubaccountId,\n} from \"../../shared/account-scope.js\";\nimport type * as Proto from \"../../gen/chain/withdraw/v1/withdraw_pb.js\";\nimport { toU128, type U128Value } from \"../../utils/u128.js\";\nimport { TradingWithdrawActionCodec } from \"./trading-withdraws.codecs.js\";\n\nconst DEFAULT_DEADLINE_SECONDS = 5 * 60;\n\nexport type TradingWithdrawIntentPayloadRequest = {\n    action: Proto.TradingWithdrawAction;\n    assetId: number;\n    destinationChainId: bigint;\n    amountE18: U128Value;\n    deadlineTsSec: bigint;\n    nonce: U128Value;\n    destinationAddress: string;\n    idempotencyKey: string;\n};\n\ntype CreateTradingWithdrawRequestBase = {\n    subaccountId: bigint | undefined;\n    payload: TradingWithdrawIntentPayloadRequest;\n    payloadSignature?: Uint8Array;\n};\n\nfunction createNonce(): bigint {\n    const random = globalThis.crypto?.getRandomValues?.bind(globalThis.crypto);\n    if (!random) {\n        const nonce = BigInt(Date.now());\n        return nonce === 0n ? 1n : nonce;\n    }\n\n    const bytes = new BigUint64Array(1);\n    random(bytes);\n    const nonce = bytes[0] ?? BigInt(Date.now());\n    return nonce === 0n ? 1n : nonce;\n}\n\nfunction createTradingWithdrawPayload(input: {\n    action: Proto.TradingWithdrawAction;\n    assetId: number;\n    destinationChainId: bigint;\n    quantityScaled: bigint;\n    destinationAddress: string;\n    idempotencyKey: string;\n}): TradingWithdrawIntentPayloadRequest {\n    return {\n        action: input.action,\n        assetId: input.assetId,\n        destinationChainId: input.destinationChainId,\n        amountE18: toU128(input.quantityScaled),\n        deadlineTsSec: BigInt(Math.floor(Date.now() / 1000) + DEFAULT_DEADLINE_SECONDS),\n        nonce: toU128(createNonce()),\n        destinationAddress: input.destinationAddress,\n        idempotencyKey: input.idempotencyKey,\n    };\n}\n\nexport function createCreateTradingWithdrawToFundingInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),\n            quantity: v.string(),\n            idempotencyKey: v.pipe(v.string(), v.trim(), v.minLength(1)),\n            destinationAddress: v.optional(v.pipe(v.string(), v.trim()), \"\"),\n            signerWallet: v.optional(v.pipe(v.string(), v.trim()), \"\"),\n            payloadSignature: v.optional(v.instance(Uint8Array)),\n        }),\n        v.transform((input): CreateTradingWithdrawRequestBase => {\n            const quantityScaled = quantityInputToE18({\n                scales,\n                assetId: input.assetId,\n                quantity: input.quantity,\n            });\n            return {\n                subaccountId: accountScopeToSubaccountId(input.account),\n                payloadSignature: input.payloadSignature,\n                payload: createTradingWithdrawPayload({\n                    action: TradingWithdrawActionCodec.inputToProto.to_funding,\n                    assetId: input.assetId,\n                    destinationChainId: 0n,\n                    quantityScaled,\n                    destinationAddress: input.destinationAddress,\n                    idempotencyKey: input.idempotencyKey,\n                }),\n            };\n        }),\n    );\n}\n\nexport function createCreateTradingWithdrawToExternalChainInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            ...AccountScopeInputEntries,\n            assetId: v.pipe(v.number(), v.integer(), v.gtValue(0)),\n            quantity: v.string(),\n            destinationChainId: v.pipe(\n                v.number(),\n                v.integer(),\n                v.gtValue(0),\n                v.maxValue(Number.MAX_SAFE_INTEGER),\n            ),\n            destinationAddress: v.pipe(v.string(), v.trim(), v.minLength(1)),\n            idempotencyKey: v.pipe(v.string(), v.trim(), v.minLength(1)),\n            signerWallet: v.optional(v.pipe(v.string(), v.trim()), \"\"),\n            payloadSignature: v.optional(v.instance(Uint8Array)),\n        }),\n        v.transform((input): CreateTradingWithdrawRequestBase => {\n            const quantityScaled = quantityInputToE18({\n                scales,\n                assetId: input.assetId,\n                quantity: input.quantity,\n            });\n            return {\n                subaccountId: accountScopeToSubaccountId(input.account),\n                payloadSignature: input.payloadSignature,\n                payload: createTradingWithdrawPayload({\n                    action: TradingWithdrawActionCodec.inputToProto.to_external_chain,\n                    assetId: input.assetId,\n                    destinationChainId: BigInt(input.destinationChainId),\n                    quantityScaled,\n                    destinationAddress: input.destinationAddress,\n                    idempotencyKey: input.idempotencyKey,\n                }),\n            };\n        }),\n    );\n}\n\nexport type CreateTradingWithdrawToFundingInput = v.InferInput<\n    ReturnType<typeof createCreateTradingWithdrawToFundingInputSchema>\n>;\n\nexport type CreateTradingWithdrawToFundingRequest = v.InferOutput<\n    ReturnType<typeof createCreateTradingWithdrawToFundingInputSchema>\n>;\n\nexport type CreateTradingWithdrawToExternalChainInput = v.InferInput<\n    ReturnType<typeof createCreateTradingWithdrawToExternalChainInputSchema>\n>;\n\nexport type CreateTradingWithdrawToExternalChainRequest = v.InferOutput<\n    ReturnType<typeof createCreateTradingWithdrawToExternalChainInputSchema>\n>;\n\nexport const CreateTradingWithdrawResultSchema = v.object({\n    intentId: v.pipe(v.string(), v.trim(), v.minLength(1)),\n});\n\nexport type CreateTradingWithdrawResult = v.InferOutput<typeof CreateTradingWithdrawResultSchema>;\n\nexport const CreateWalletTradingWithdrawResultSchema = CreateTradingWithdrawResultSchema;\nexport type CreateWalletTradingWithdrawResult = v.InferOutput<\n    typeof CreateWalletTradingWithdrawResultSchema\n>;\n"],"mappings":"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"}

package/dist/services/trading-withdraws/trading-withdraws.types.d.ts

@@ -0,0 +1,3 @@
+import { CreateTradingWithdrawResult, CreateTradingWithdrawToExternalChainInput, CreateTradingWithdrawToFundingInput } from "./trading-withdraws.schemas.js";
+import { CreateTradingWithdrawToExternalChainServiceInput, CreateTradingWithdrawToFundingServiceInput, PreparedTradingWithdraw, TradingWithdrawSigningConfig, TradingWithdrawWalletSigner, TradingWithdrawWalletTypedData } from "./trading-withdraws.js";
+export type { CreateTradingWithdrawResult, CreateTradingWithdrawToExternalChainInput, CreateTradingWithdrawToExternalChainServiceInput, CreateTradingWithdrawToFundingInput, CreateTradingWithdrawToFundingServiceInput, PreparedTradingWithdraw, TradingWithdrawSigningConfig, TradingWithdrawWalletSigner, TradingWithdrawWalletTypedData };

package/dist/services/trailing-oneof-inputs.js

@@ -0,0 +1,49 @@
+import { parseOptionalPositiveIntLike } from "../utils/numbers.js";
+import { CatalogConversionError } from "../catalogs/types.js";
+import { positiveDecimalInputToScaled } from "../shared/decimal-surface.js";
+//#region src/services/trailing-oneof-inputs.ts
+/** Slippage ticks travel as int32 on the wire. */
+const MAX_INT32_TICKS = 2147483647n;
+function parseTrailingDistanceInput(scales, distance, fieldName) {
+	if (distance.kind === "none") return {
+		case: void 0,
+		value: void 0
+	};
+	if (distance.kind === "distance") return {
+		case: "trailingDistanceTicks",
+		value: positiveDecimalInputToScaled(`${fieldName}.distance`, distance.distance, scales.price())
+	};
+	const bps = parseOptionalPositiveIntLike(distance.bps);
+	if (bps === void 0 || bps <= 0) throw new Error(`${fieldName}Bps must be a positive integer`);
+	return {
+		case: "trailingDistanceBps",
+		value: bps
+	};
+}
+function parseSlippageInput(scales, slippage, options) {
+	if (!slippage || slippage.kind === "none") return {
+		case: void 0,
+		value: void 0
+	};
+	if (slippage.kind === "slippage") {
+		const ticks = positiveDecimalInputToScaled(`${options.fieldName}.slippage`, slippage.slippage, scales.price());
+		if (ticks > MAX_INT32_TICKS) throw new CatalogConversionError(`${options.fieldName}.slippage`, `${options.fieldName}.slippage exceeds the maximum supported price distance: ${slippage.slippage}`);
+		return {
+			case: options.ticksCase,
+			value: Number(ticks)
+		};
+	}
+	const bps = parseOptionalPositiveIntLike(slippage.bps);
+	if (bps === void 0 || bps <= 0 || exceedsMax(bps, options.maxBps)) throw new Error(`${options.fieldName}Bps must be ${options.maxBps === void 0 ? "a positive integer" : `between 1 and ${options.maxBps}`}`);
+	return {
+		case: options.bpsCase,
+		value: bps
+	};
+}
+function exceedsMax(value, max) {
+	return max !== void 0 && value > max;
+}
+//#endregion
+export { parseSlippageInput, parseTrailingDistanceInput };
+
+//# sourceMappingURL=trailing-oneof-inputs.js.map

package/dist/services/trailing-oneof-inputs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trailing-oneof-inputs.js","names":[],"sources":["../../src/services/trailing-oneof-inputs.ts"],"sourcesContent":["import { positiveDecimalInputToScaled, type SdkScales } from \"../shared/decimal-surface.js\";\nimport { CatalogConversionError } from \"../catalogs/types.js\";\nimport { parseOptionalPositiveIntLike } from \"../utils/numbers.js\";\n\ntype PositiveIntLikeInput = string | number;\n\n/**\n * Trailing distance and slippage inputs: absolute price distances and\n * slippages are decimal price strings (e.g. \"0.50\"), converted to wire ticks\n * via the price scale; basis points are integers.\n */\nexport type TrailingDistanceInput =\n    | { kind: \"distance\"; distance: string }\n    | { kind: \"bps\"; bps: PositiveIntLikeInput }\n    | { kind: \"none\" };\n\nexport type SlippageInput =\n    | { kind: \"slippage\"; slippage: string }\n    | { kind: \"bps\"; bps: PositiveIntLikeInput }\n    | { kind: \"none\" };\n\ntype UnsetOneof = { case: undefined; value: undefined };\n\ntype TrailingDistanceOneof =\n    | { case: \"trailingDistanceTicks\"; value: bigint }\n    | { case: \"trailingDistanceBps\"; value: number }\n    | UnsetOneof;\n\ntype SlippageOneof<TicksCase extends string, BpsCase extends string> =\n    | { case: TicksCase; value: number }\n    | { case: BpsCase; value: number }\n    | UnsetOneof;\n\ntype SlippageOptions<TicksCase extends string, BpsCase extends string> = {\n    fieldName: string;\n    ticksCase: TicksCase;\n    bpsCase: BpsCase;\n    maxBps?: number;\n};\n\n/** Slippage ticks travel as int32 on the wire. */\nconst MAX_INT32_TICKS = 2_147_483_647n;\n\nexport function parseTrailingDistanceInput(\n    scales: SdkScales,\n    distance: TrailingDistanceInput,\n    fieldName: string,\n): TrailingDistanceOneof {\n    if (distance.kind === \"none\") {\n        return { case: undefined, value: undefined };\n    }\n    if (distance.kind === \"distance\") {\n        return {\n            case: \"trailingDistanceTicks\",\n            value: positiveDecimalInputToScaled(\n                `${fieldName}.distance`,\n                distance.distance,\n                scales.price(),\n            ),\n        };\n    }\n\n    const bps = parseOptionalPositiveIntLike(distance.bps);\n    if (bps === undefined || bps <= 0) {\n        throw new Error(`${fieldName}Bps must be a positive integer`);\n    }\n    return { case: \"trailingDistanceBps\", value: bps };\n}\n\nexport function parseSlippageInput<const TicksCase extends string, const BpsCase extends string>(\n    scales: SdkScales,\n    slippage: SlippageInput | undefined,\n    options: SlippageOptions<TicksCase, BpsCase>,\n): SlippageOneof<TicksCase, BpsCase> {\n    if (!slippage || slippage.kind === \"none\") {\n        return { case: undefined, value: undefined };\n    }\n    if (slippage.kind === \"slippage\") {\n        const ticks = positiveDecimalInputToScaled(\n            `${options.fieldName}.slippage`,\n            slippage.slippage,\n            scales.price(),\n        );\n        if (ticks > MAX_INT32_TICKS) {\n            throw new CatalogConversionError(\n                `${options.fieldName}.slippage`,\n                `${options.fieldName}.slippage exceeds the maximum supported price distance: ${slippage.slippage}`,\n            );\n        }\n        return { case: options.ticksCase, value: Number(ticks) };\n    }\n\n    const bps = parseOptionalPositiveIntLike(slippage.bps);\n    if (bps === undefined || bps <= 0 || exceedsMax(bps, options.maxBps)) {\n        throw new Error(\n            `${options.fieldName}Bps must be ${\n                options.maxBps === undefined\n                    ? \"a positive integer\"\n                    : `between 1 and ${options.maxBps}`\n            }`,\n        );\n    }\n    return { case: options.bpsCase, value: bps };\n}\n\nfunction exceedsMax(value: number, max: number | undefined): boolean {\n    return max !== undefined && value > max;\n}\n"],"mappings":";;;;;AAyCA,MAAM,kBAAkB;AAExB,SAAgB,2BACZ,QACA,UACA,WACqB;CACrB,IAAI,SAAS,SAAS,QAClB,OAAO;EAAE,MAAM,KAAA;EAAW,OAAO,KAAA;CAAU;CAE/C,IAAI,SAAS,SAAS,YAClB,OAAO;EACH,MAAM;EACN,OAAO,6BACH,GAAG,UAAU,YACb,SAAS,UACT,OAAO,MAAM,CACjB;CACJ;CAGJ,MAAM,MAAM,6BAA6B,SAAS,GAAG;CACrD,IAAI,QAAQ,KAAA,KAAa,OAAO,GAC5B,MAAM,IAAI,MAAM,GAAG,UAAU,+BAA+B;CAEhE,OAAO;EAAE,MAAM;EAAuB,OAAO;CAAI;AACrD;AAEA,SAAgB,mBACZ,QACA,UACA,SACiC;CACjC,IAAI,CAAC,YAAY,SAAS,SAAS,QAC/B,OAAO;EAAE,MAAM,KAAA;EAAW,OAAO,KAAA;CAAU;CAE/C,IAAI,SAAS,SAAS,YAAY;EAC9B,MAAM,QAAQ,6BACV,GAAG,QAAQ,UAAU,YACrB,SAAS,UACT,OAAO,MAAM,CACjB;EACA,IAAI,QAAQ,iBACR,MAAM,IAAI,uBACN,GAAG,QAAQ,UAAU,YACrB,GAAG,QAAQ,UAAU,0DAA0D,SAAS,UAC5F;EAEJ,OAAO;GAAE,MAAM,QAAQ;GAAW,OAAO,OAAO,KAAK;EAAE;CAC3D;CAEA,MAAM,MAAM,6BAA6B,SAAS,GAAG;CACrD,IAAI,QAAQ,KAAA,KAAa,OAAO,KAAK,WAAW,KAAK,QAAQ,MAAM,GAC/D,MAAM,IAAI,MACN,GAAG,QAAQ,UAAU,cACjB,QAAQ,WAAW,KAAA,IACb,uBACA,iBAAiB,QAAQ,UAEvC;CAEJ,OAAO;EAAE,MAAM,QAAQ;EAAS,OAAO;CAAI;AAC/C;AAEA,SAAS,WAAW,OAAe,KAAkC;CACjE,OAAO,QAAQ,KAAA,KAAa,QAAQ;AACxC"}

package/dist/services/transfers/index.d.ts

@@ -0,0 +1,4 @@
+import { LedgerTransfer, LedgerTransferSide, LedgerTransferSideSchema, ListTransfersInput, ListTransfersInputSchema, createLedgerTransferSchema } from "./transfers.schemas.js";
+import { TransfersService } from "./transfers.js";
+import { TRANSFER_SIDE_KIND_VALUES, TransferSideKind } from "./transfers.codecs.js";
+export { LedgerTransfer, LedgerTransferSide, LedgerTransferSideSchema, ListTransfersInput, ListTransfersInputSchema, TRANSFER_SIDE_KIND_VALUES, TransferSideKind, TransfersService, createLedgerTransferSchema };