@polyester/sdk 0.3.0 → 0.4.0

package/dist/services/orders/orders-risk.schemas.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"orders-risk.schemas.d.ts","names":[],"sources":["../../../src/services/orders/orders-risk.schemas.ts"],"mappings":";;;;iBAkBS,2BAA2B,QAAQ,WAAW,yCAAsC,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiGpF,8BAA8B,QAAQ,YAAS,EAAA,yBAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8ExC,4BAA4B,QAAQ,YAAS,EAAA,yBAAA,EAAA,eAAA,EAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO7C,oCAAoC,QAAQ,YAAS,EAAA,yBAAA,EAAA,aAAA,EAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOzD,kBAAkB,EAAE,WAAW,kBAAkB;KACjD,gBAAgB,EAAE,WAAW,kBAAkB;KAC/C,oBAAoB,EAAE,WAAW,kBAAkB;KACnD,kBAAkB,EAAE,WAAW,kBAAkB;KAOjD;EACJ;EAAkB;;EAClB;EAAa"}
+{"version":3,"file":"orders-risk.schemas.d.ts","names":[],"sources":["../../../src/services/orders/orders-risk.schemas.ts"],"mappings":";;;;iBAkBS,2BAA2B,QAAQ,WAAW,yCAAsC,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAiGpF,8BAA8B,QAAQ,YAAS,qBAAA,yBAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA8ExC,4BAA4B,QAAQ,YAAS,qBAAA,yBAAA,qBAAA,eAAA,qBAAA,aAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAO7C,oCAAoC,QAAQ,YAAS,qBAAA,yBAAA,qBAAA,aAAA,qBAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOzD,kBAAkB,qBAAE,WAAW,kBAAkB;KACjD,gBAAgB,qBAAE,WAAW,kBAAkB;KAC/C,oBAAoB,qBAAE,WAAW,kBAAkB;KACnD,kBAAkB,qBAAE,WAAW,kBAAkB;KAOjD;EACJ;EAAkB;;EAClB;EAAa"}

package/dist/services/orders/orders-risk.schemas.js

@@ -1,19 +1,19 @@
+import { validation_exports } from "../../shared/validation.js";
 import { RiskLimitGtcSchema, RiskMarketIocSchema } from "../../gen/orders/v1/orders_pb.js";
 import { positiveDecimalInputToScaled, scaledToDecimalOutput } from "../../shared/decimal-surface.js";
 import { BpsStringOrNumberInputSchema, NoneInputSchema, PriceDistanceInputSchema, PriceSlippageInputSchema } from "../shared.js";
 import { parseSlippageInput, parseTrailingDistanceInput } from "../trailing-oneof-inputs.js";
 import { create } from "@bufbuild/protobuf";
-import * as v from "valibot";
 //#region src/services/orders/orders-risk.schemas.ts
-const DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));
+const DecimalInputStringSchema = validation_exports.pipe(validation_exports.string(), validation_exports.trim(), validation_exports.minLength(1));
 function attachedTriggerInputSchema(scales, fieldPrefix) {
-	return v.pipe(v.strictObject({
+	return validation_exports.pipe(validation_exports.strictObject({
 		triggerPrice: DecimalInputStringSchema,
-		execution: v.variant("type", [v.strictObject({ type: v.literal("market_ioc") }), v.strictObject({
-			type: v.literal("limit_gtc"),
+		execution: validation_exports.variant("type", [validation_exports.strictObject({ type: validation_exports.literal("market_ioc") }), validation_exports.strictObject({
+			type: validation_exports.literal("limit_gtc"),
 			price: DecimalInputStringSchema
 		})])
-	}), v.transform((input) => {
+	}), validation_exports.transform((input) => {
 		const execution = input.execution.type === "market_ioc" ? {
 			case: "marketIoc",
 			value: create(RiskMarketIocSchema)
@@ -27,17 +27,17 @@ function attachedTriggerInputSchema(scales, fieldPrefix) {
 		};
 	}));
 }
-const TrailingDistanceSchema = v.union([
+const TrailingDistanceSchema = validation_exports.union([
 	PriceDistanceInputSchema,
 	BpsStringOrNumberInputSchema,
 	NoneInputSchema
 ]);
-const MaxSlippageSchema = v.union([
+const MaxSlippageSchema = validation_exports.union([
 	PriceSlippageInputSchema,
 	BpsStringOrNumberInputSchema,
 	NoneInputSchema
 ]);
-const MarketMaxSlippageSchema = v.union([
+const MarketMaxSlippageSchema = validation_exports.union([
 	PriceSlippageInputSchema,
 	BpsStringOrNumberInputSchema,
 	NoneInputSchema
@@ -66,11 +66,11 @@ function parseMarketMaxSlippage(scales, slippage) {
 	});
 }
 function createTrailingStopInputSchema(scales) {
-	return v.pipe(v.strictObject({
+	return validation_exports.pipe(validation_exports.strictObject({
 		trailingDistance: TrailingDistanceSchema,
-		maxSlippage: v.optional(MaxSlippageSchema),
-		activationPrice: v.optional(DecimalInputStringSchema)
-	}), v.transform((input) => ({
+		maxSlippage: validation_exports.optional(MaxSlippageSchema),
+		activationPrice: validation_exports.optional(DecimalInputStringSchema)
+	}), validation_exports.transform((input) => ({
 		trailingDistance: parseTrailingDistance(scales, input.trailingDistance),
 		maxSlippage: input.maxSlippage ? parseMaxSlippage(scales, input.maxSlippage) : UNSET_TRAILING_STOP_MAX_SLIPPAGE,
 		activationPriceTicks: input.activationPrice === void 0 ? 0n : positiveDecimalInputToScaled("trailingStop.activationPrice", input.activationPrice, scales.price())
@@ -80,36 +80,36 @@ function createRiskPolicyObjectInputSchema(scales) {
 	const TakeProfitInputSchema = attachedTriggerInputSchema(scales, "takeProfit");
 	const StopLossInputSchema = attachedTriggerInputSchema(scales, "stopLoss");
 	const TrailingStopInputSchema = createTrailingStopInputSchema(scales);
-	return v.union([
-		v.strictObject({
+	return validation_exports.union([
+		validation_exports.strictObject({
 			takeProfit: TakeProfitInputSchema,
 			stopLoss: StopLossInputSchema,
-			trailingStop: v.optional(v.never()),
-			oco: v.optional(v.boolean())
+			trailingStop: validation_exports.optional(validation_exports.never()),
+			oco: validation_exports.optional(validation_exports.boolean())
 		}),
-		v.strictObject({
+		validation_exports.strictObject({
 			takeProfit: TakeProfitInputSchema,
-			stopLoss: v.optional(v.never()),
+			stopLoss: validation_exports.optional(validation_exports.never()),
 			trailingStop: TrailingStopInputSchema,
-			oco: v.optional(v.boolean())
+			oco: validation_exports.optional(validation_exports.boolean())
 		}),
-		v.strictObject({
+		validation_exports.strictObject({
 			takeProfit: TakeProfitInputSchema,
-			stopLoss: v.optional(v.never()),
-			trailingStop: v.optional(v.never()),
-			oco: v.optional(v.boolean())
+			stopLoss: validation_exports.optional(validation_exports.never()),
+			trailingStop: validation_exports.optional(validation_exports.never()),
+			oco: validation_exports.optional(validation_exports.boolean())
 		}),
-		v.strictObject({
-			takeProfit: v.optional(v.never()),
+		validation_exports.strictObject({
+			takeProfit: validation_exports.optional(validation_exports.never()),
 			stopLoss: StopLossInputSchema,
-			trailingStop: v.optional(v.never()),
-			oco: v.optional(v.boolean())
+			trailingStop: validation_exports.optional(validation_exports.never()),
+			oco: validation_exports.optional(validation_exports.boolean())
 		}),
-		v.strictObject({
-			takeProfit: v.optional(v.never()),
-			stopLoss: v.optional(v.never()),
+		validation_exports.strictObject({
+			takeProfit: validation_exports.optional(validation_exports.never()),
+			stopLoss: validation_exports.optional(validation_exports.never()),
 			trailingStop: TrailingStopInputSchema,
-			oco: v.optional(v.boolean())
+			oco: validation_exports.optional(validation_exports.boolean())
 		})
 	]);
 }
@@ -132,57 +132,57 @@ function transformRiskPolicyInput(input) {
 	};
 }
 function createRiskPolicyInputSchema(scales) {
-	return v.pipe(v.optional(createRiskPolicyObjectInputSchema(scales)), v.transform((input) => input ? transformRiskPolicyInput(input) : void 0));
+	return validation_exports.pipe(validation_exports.optional(createRiskPolicyObjectInputSchema(scales)), validation_exports.transform((input) => input ? transformRiskPolicyInput(input) : void 0));
 }
 function createRequiredRiskPolicyInputSchema(scales) {
-	return v.pipe(createRiskPolicyObjectInputSchema(scales), v.transform((input) => transformRiskPolicyInput(input)));
+	return validation_exports.pipe(createRiskPolicyObjectInputSchema(scales), validation_exports.transform((input) => transformRiskPolicyInput(input)));
 }
-const ReadRiskExecutionSchema = v.object({ execution: v.variant("case", [v.object({
-	case: v.literal("marketIoc"),
-	value: v.object({})
-}), v.object({
-	case: v.literal("limitGtc"),
-	value: v.object({ priceTicks: v.bigint() })
+const ReadRiskExecutionSchema = validation_exports.object({ execution: validation_exports.variant("case", [validation_exports.object({
+	case: validation_exports.literal("marketIoc"),
+	value: validation_exports.object({})
+}), validation_exports.object({
+	case: validation_exports.literal("limitGtc"),
+	value: validation_exports.object({ priceTicks: validation_exports.bigint() })
 })]) });
-const ReadTakeProfitPolicySchema = v.object({
-	triggerPriceTicks: v.bigint(),
+const ReadTakeProfitPolicySchema = validation_exports.object({
+	triggerPriceTicks: validation_exports.bigint(),
 	child: ReadRiskExecutionSchema
 });
-const ReadStopLossPolicySchema = v.object({
-	triggerPriceTicks: v.bigint(),
+const ReadStopLossPolicySchema = validation_exports.object({
+	triggerPriceTicks: validation_exports.bigint(),
 	child: ReadRiskExecutionSchema
 });
-const ReadTrailingStopPolicySchema = v.object({
-	trailingDistance: v.object({
-		case: v.optional(v.union([
-			v.literal("trailingDistanceTicks"),
-			v.literal("trailingDistanceBps"),
-			v.undefined()
+const ReadTrailingStopPolicySchema = validation_exports.object({
+	trailingDistance: validation_exports.object({
+		case: validation_exports.optional(validation_exports.union([
+			validation_exports.literal("trailingDistanceTicks"),
+			validation_exports.literal("trailingDistanceBps"),
+			validation_exports.undefined()
 		])),
-		value: v.optional(v.union([
-			v.bigint(),
-			v.number(),
-			v.undefined()
+		value: validation_exports.optional(validation_exports.union([
+			validation_exports.bigint(),
+			validation_exports.number(),
+			validation_exports.undefined()
 		]))
 	}),
-	maxSlippage: v.object({
-		case: v.union([
-			v.literal("maxSlippageTicks"),
-			v.literal("maxSlippageBps"),
-			v.undefined()
+	maxSlippage: validation_exports.object({
+		case: validation_exports.union([
+			validation_exports.literal("maxSlippageTicks"),
+			validation_exports.literal("maxSlippageBps"),
+			validation_exports.undefined()
 		]),
-		value: v.optional(v.union([v.number(), v.undefined()]))
+		value: validation_exports.optional(validation_exports.union([validation_exports.number(), validation_exports.undefined()]))
 	}),
-	activationPriceTicks: v.bigint()
+	activationPriceTicks: validation_exports.bigint()
 });
-const ReadAttachedRiskTakeProfitSchema = v.object({ policy: v.optional(ReadTakeProfitPolicySchema) });
-const ReadAttachedRiskStopLossSchema = v.object({ policy: v.optional(ReadStopLossPolicySchema) });
-const ReadAttachedRiskTrailingStopSchema = v.object({ policy: v.optional(ReadTrailingStopPolicySchema) });
-const ReadAttachedRiskSchema = v.object({
-	takeProfit: v.optional(ReadAttachedRiskTakeProfitSchema),
-	stopLoss: v.optional(ReadAttachedRiskStopLossSchema),
-	trailingStop: v.optional(ReadAttachedRiskTrailingStopSchema),
-	oco: v.optional(v.boolean(), false)
+const ReadAttachedRiskTakeProfitSchema = validation_exports.object({ policy: validation_exports.optional(ReadTakeProfitPolicySchema) });
+const ReadAttachedRiskStopLossSchema = validation_exports.object({ policy: validation_exports.optional(ReadStopLossPolicySchema) });
+const ReadAttachedRiskTrailingStopSchema = validation_exports.object({ policy: validation_exports.optional(ReadTrailingStopPolicySchema) });
+const ReadAttachedRiskSchema = validation_exports.object({
+	takeProfit: validation_exports.optional(ReadAttachedRiskTakeProfitSchema),
+	stopLoss: validation_exports.optional(ReadAttachedRiskStopLossSchema),
+	trailingStop: validation_exports.optional(ReadAttachedRiskTrailingStopSchema),
+	oco: validation_exports.optional(validation_exports.boolean(), false)
 });
 function formatRiskExecution(scales, child) {
 	if (child.execution.case === "marketIoc") return { type: "market_ioc" };

package/dist/services/orders/orders-risk.schemas.js.map

@@ -1 +1 @@
-{"version":3,"file":"orders-risk.schemas.js","names":["ProtoWrite.RiskMarketIocSchema","ProtoWrite.RiskLimitGtcSchema"],"sources":["../../../src/services/orders/orders-risk.schemas.ts"],"sourcesContent":["import * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport { create } from \"@bufbuild/protobuf\";\nimport * as v from \"valibot\";\nimport {\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n    PriceDistanceInputSchema,\n    PriceSlippageInputSchema,\n} from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport { parseSlippageInput, parseTrailingDistanceInput } from \"../trailing-oneof-inputs.js\";\n\nconst DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\n\nfunction attachedTriggerInputSchema(scales: SdkScales, fieldPrefix: \"takeProfit\" | \"stopLoss\") {\n    return v.pipe(\n        v.strictObject({\n            triggerPrice: DecimalInputStringSchema,\n            execution: v.variant(\"type\", [\n                v.strictObject({\n                    type: v.literal(\"market_ioc\"),\n                }),\n                v.strictObject({\n                    type: v.literal(\"limit_gtc\"),\n                    price: DecimalInputStringSchema,\n                }),\n            ]),\n        }),\n        v.transform((input) => {\n            const execution: ProtoWrite.RiskExecution[\"execution\"] =\n                input.execution.type === \"market_ioc\"\n                    ? {\n                          case: \"marketIoc\",\n                          value: create(ProtoWrite.RiskMarketIocSchema),\n                      }\n                    : {\n                          case: \"limitGtc\",\n                          value: create(ProtoWrite.RiskLimitGtcSchema, {\n                              priceTicks: positiveDecimalInputToScaled(\n                                  `${fieldPrefix}.execution.price`,\n                                  input.execution.price,\n                                  scales.price(),\n                              ),\n                          }),\n                      };\n            return {\n                triggerPriceTicks: positiveDecimalInputToScaled(\n                    `${fieldPrefix}.triggerPrice`,\n                    input.triggerPrice,\n                    scales.price(),\n                ),\n                child: { execution },\n            };\n        }),\n    );\n}\n\nconst TrailingDistanceSchema = v.union([\n    PriceDistanceInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nconst MaxSlippageSchema = v.union([\n    PriceSlippageInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nexport const MarketMaxSlippageSchema = v.union([\n    PriceSlippageInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nconst MAX_BPS = 10_000;\nconst UNSET_TRAILING_STOP_MAX_SLIPPAGE: ProtoWrite.TrailingStopPolicy[\"maxSlippage\"] = {\n    case: undefined,\n    value: undefined,\n};\n\nfunction parseTrailingDistance(\n    scales: SdkScales,\n    distance: v.InferOutput<typeof TrailingDistanceSchema>,\n): ProtoWrite.TrailingStopPolicy[\"trailingDistance\"] {\n    return parseTrailingDistanceInput(scales, distance, \"trailingStop.trailingDistance\");\n}\n\nfunction parseMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof MaxSlippageSchema>,\n): ProtoWrite.TrailingStopPolicy[\"maxSlippage\"] {\n    return parseSlippageInput(scales, slippage, {\n        fieldName: \"trailingStop.maxSlippage\",\n        ticksCase: \"maxSlippageTicks\",\n        bpsCase: \"maxSlippageBps\",\n    });\n}\n\nexport function parseMarketMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof MarketMaxSlippageSchema> | undefined,\n): ProtoWrite.MarketIoc[\"maxSlippage\"] {\n    return parseSlippageInput(scales, slippage, {\n        fieldName: \"execution.maxSlippage\",\n        ticksCase: \"maxSlippageTicks\",\n        bpsCase: \"maxSlippageBps\",\n        maxBps: MAX_BPS,\n    });\n}\n\nfunction createTrailingStopInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            trailingDistance: TrailingDistanceSchema,\n            maxSlippage: v.optional(MaxSlippageSchema),\n            activationPrice: v.optional(DecimalInputStringSchema),\n        }),\n        v.transform((input) => ({\n            trailingDistance: parseTrailingDistance(scales, input.trailingDistance),\n            maxSlippage: input.maxSlippage\n                ? parseMaxSlippage(scales, input.maxSlippage)\n                : UNSET_TRAILING_STOP_MAX_SLIPPAGE,\n            activationPriceTicks:\n                input.activationPrice === undefined\n                    ? 0n\n                    : positiveDecimalInputToScaled(\n                          \"trailingStop.activationPrice\",\n                          input.activationPrice,\n                          scales.price(),\n                      ),\n        })),\n    );\n}\n\nfunction createRiskPolicyObjectInputSchema(scales: SdkScales) {\n    const TakeProfitInputSchema = attachedTriggerInputSchema(scales, \"takeProfit\");\n    const StopLossInputSchema = attachedTriggerInputSchema(scales, \"stopLoss\");\n    const TrailingStopInputSchema = createTrailingStopInputSchema(scales);\n    return v.union([\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: StopLossInputSchema,\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: v.optional(v.never()),\n            trailingStop: TrailingStopInputSchema,\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: v.optional(v.never()),\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: v.optional(v.never()),\n            stopLoss: StopLossInputSchema,\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: v.optional(v.never()),\n            stopLoss: v.optional(v.never()),\n            trailingStop: TrailingStopInputSchema,\n            oco: v.optional(v.boolean()),\n        }),\n    ]);\n}\n\ntype RiskPolicyObjectInput = v.InferOutput<ReturnType<typeof createRiskPolicyObjectInputSchema>>;\n\nfunction transformRiskPolicyInput(input: RiskPolicyObjectInput) {\n    const stopLeg = input.stopLoss\n        ? ({ case: \"stopLoss\", value: input.stopLoss } as const)\n        : input.trailingStop\n          ? ({ case: \"trailingStop\", value: input.trailingStop } as const)\n          : ({ case: undefined, value: undefined } as const);\n    const oco = input.oco === true && !!input.takeProfit && stopLeg.case !== undefined;\n    return {\n        takeProfit: input.takeProfit,\n        stopLeg,\n        oco,\n    };\n}\n\nexport function createRiskPolicyInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.optional(createRiskPolicyObjectInputSchema(scales)),\n        v.transform((input) => (input ? transformRiskPolicyInput(input) : undefined)),\n    );\n}\n\nexport function createRequiredRiskPolicyInputSchema(scales: SdkScales) {\n    return v.pipe(\n        createRiskPolicyObjectInputSchema(scales),\n        v.transform((input) => transformRiskPolicyInput(input)),\n    );\n}\n\nexport type TakeProfitInput = v.InferInput<ReturnType<typeof attachedTriggerInputSchema>>;\nexport type StopLossInput = v.InferInput<ReturnType<typeof attachedTriggerInputSchema>>;\nexport type TrailingStopInput = v.InferInput<ReturnType<typeof createTrailingStopInputSchema>>;\nexport type RiskPolicyInput = v.InferInput<ReturnType<typeof createRiskPolicyInputSchema>>;\n\ntype TrailingDistance =\n    | { kind: \"distance\"; distance: string }\n    | { kind: \"bps\"; bps: number }\n    | { kind: \"none\" };\ntype TrailingMaxSlippage = { kind: \"slippage\"; slippage: string } | { kind: \"bps\"; bps: number };\nexport type MarketMaxSlippage =\n    | { kind: \"slippage\"; slippage: string }\n    | { kind: \"bps\"; bps: number };\n\nconst ReadRiskExecutionSchema = v.object({\n    execution: v.variant(\"case\", [\n        v.object({\n            case: v.literal(\"marketIoc\"),\n            value: v.object({}),\n        }),\n        v.object({\n            case: v.literal(\"limitGtc\"),\n            value: v.object({\n                priceTicks: v.bigint(),\n            }),\n        }),\n    ]),\n});\n\nconst ReadTakeProfitPolicySchema = v.object({\n    triggerPriceTicks: v.bigint(),\n    child: ReadRiskExecutionSchema,\n});\n\nconst ReadStopLossPolicySchema = v.object({\n    triggerPriceTicks: v.bigint(),\n    child: ReadRiskExecutionSchema,\n});\n\nconst ReadTrailingStopPolicySchema = v.object({\n    trailingDistance: v.object({\n        case: v.optional(\n            v.union([\n                v.literal(\"trailingDistanceTicks\"),\n                v.literal(\"trailingDistanceBps\"),\n                v.undefined(),\n            ]),\n        ),\n        value: v.optional(v.union([v.bigint(), v.number(), v.undefined()])),\n    }),\n    maxSlippage: v.object({\n        case: v.union([v.literal(\"maxSlippageTicks\"), v.literal(\"maxSlippageBps\"), v.undefined()]),\n        value: v.optional(v.union([v.number(), v.undefined()])),\n    }),\n    activationPriceTicks: v.bigint(),\n});\n\nconst ReadAttachedRiskTakeProfitSchema = v.object({\n    policy: v.optional(ReadTakeProfitPolicySchema),\n});\n\nconst ReadAttachedRiskStopLossSchema = v.object({\n    policy: v.optional(ReadStopLossPolicySchema),\n});\n\nconst ReadAttachedRiskTrailingStopSchema = v.object({\n    policy: v.optional(ReadTrailingStopPolicySchema),\n});\n\nexport const ReadAttachedRiskSchema = v.object({\n    takeProfit: v.optional(ReadAttachedRiskTakeProfitSchema),\n    stopLoss: v.optional(ReadAttachedRiskStopLossSchema),\n    trailingStop: v.optional(ReadAttachedRiskTrailingStopSchema),\n    oco: v.optional(v.boolean(), false),\n});\n\nfunction formatRiskExecution(\n    scales: SdkScales,\n    child: v.InferOutput<typeof ReadRiskExecutionSchema>,\n) {\n    if (child.execution.case === \"marketIoc\") {\n        return { type: \"market_ioc\" } as const;\n    }\n    return {\n        type: \"limit_gtc\",\n        price: scaledToDecimalOutput(child.execution.value.priceTicks, scales.price()),\n    } as const;\n}\n\nfunction formatRiskLeg(\n    scales: SdkScales,\n    leg:\n        | v.InferOutput<typeof ReadTakeProfitPolicySchema>\n        | v.InferOutput<typeof ReadStopLossPolicySchema>,\n) {\n    return {\n        triggerPrice: scaledToDecimalOutput(leg.triggerPriceTicks, scales.price()),\n        execution: formatRiskExecution(scales, leg.child),\n    };\n}\n\nfunction formatTrailingDistance(\n    scales: SdkScales,\n    distance: v.InferOutput<typeof ReadTrailingStopPolicySchema>[\"trailingDistance\"],\n): TrailingDistance {\n    if (distance.case === \"trailingDistanceTicks\" && typeof distance.value === \"bigint\") {\n        return {\n            kind: \"distance\",\n            distance: scaledToDecimalOutput(distance.value, scales.price()),\n        };\n    }\n    if (distance.case === \"trailingDistanceBps\" && typeof distance.value === \"number\") {\n        return { kind: \"bps\", bps: distance.value };\n    }\n    return { kind: \"none\" };\n}\n\nfunction formatTrailingMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof ReadTrailingStopPolicySchema>[\"maxSlippage\"],\n): TrailingMaxSlippage | undefined {\n    if (slippage.case === \"maxSlippageTicks\" && typeof slippage.value === \"number\") {\n        return {\n            kind: \"slippage\",\n            slippage: scaledToDecimalOutput(BigInt(slippage.value), scales.price()),\n        };\n    }\n    if (slippage.case === \"maxSlippageBps\" && typeof slippage.value === \"number\") {\n        return { kind: \"bps\", bps: slippage.value };\n    }\n    return undefined;\n}\n\nexport function formatMarketMaxSlippage(\n    scales: SdkScales,\n    ticks: number,\n    bps: number,\n): MarketMaxSlippage | undefined {\n    if (ticks > 0) {\n        return { kind: \"slippage\", slippage: scaledToDecimalOutput(BigInt(ticks), scales.price()) };\n    }\n    if (bps > 0) {\n        return { kind: \"bps\", bps };\n    }\n    return undefined;\n}\n\nexport function formatAttachedRisk(\n    scales: SdkScales,\n    risk: v.InferOutput<typeof ReadAttachedRiskSchema> | undefined,\n) {\n    if (!risk) return undefined;\n\n    const takeProfit = risk.takeProfit?.policy\n        ? formatRiskLeg(scales, risk.takeProfit.policy)\n        : undefined;\n    const stopLoss = risk.stopLoss?.policy\n        ? formatRiskLeg(scales, risk.stopLoss.policy)\n        : undefined;\n    const trailingStop = risk.trailingStop?.policy\n        ? {\n              trailingDistance: formatTrailingDistance(\n                  scales,\n                  risk.trailingStop.policy.trailingDistance,\n              ),\n              maxSlippage: formatTrailingMaxSlippage(scales, risk.trailingStop.policy.maxSlippage),\n              activationPrice:\n                  risk.trailingStop.policy.activationPriceTicks > 0n\n                      ? scaledToDecimalOutput(\n                            risk.trailingStop.policy.activationPriceTicks,\n                            scales.price(),\n                        )\n                      : undefined,\n          }\n        : undefined;\n\n    if (!takeProfit && !stopLoss && !trailingStop) return undefined;\n\n    const effectiveStopLoss = trailingStop ? undefined : stopLoss;\n\n    return {\n        takeProfit,\n        stopLoss: effectiveStopLoss,\n        trailingStop,\n        oco: risk.oco,\n    };\n}\n"],"mappings":"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"}
+{"version":3,"file":"orders-risk.schemas.js","names":["v","ProtoWrite.RiskMarketIocSchema","ProtoWrite.RiskLimitGtcSchema"],"sources":["../../../src/services/orders/orders-risk.schemas.ts"],"sourcesContent":["import * as ProtoWrite from \"../../gen/orders/v1/orders_pb.js\";\nimport { create } from \"@bufbuild/protobuf\";\nimport * as v from \"../../shared/validation.js\";\nimport {\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n    PriceDistanceInputSchema,\n    PriceSlippageInputSchema,\n} from \"../shared.js\";\nimport {\n    positiveDecimalInputToScaled,\n    scaledToDecimalOutput,\n    type SdkScales,\n} from \"../../shared/decimal-surface.js\";\nimport { parseSlippageInput, parseTrailingDistanceInput } from \"../trailing-oneof-inputs.js\";\n\nconst DecimalInputStringSchema = v.pipe(v.string(), v.trim(), v.minLength(1));\n\nfunction attachedTriggerInputSchema(scales: SdkScales, fieldPrefix: \"takeProfit\" | \"stopLoss\") {\n    return v.pipe(\n        v.strictObject({\n            triggerPrice: DecimalInputStringSchema,\n            execution: v.variant(\"type\", [\n                v.strictObject({\n                    type: v.literal(\"market_ioc\"),\n                }),\n                v.strictObject({\n                    type: v.literal(\"limit_gtc\"),\n                    price: DecimalInputStringSchema,\n                }),\n            ]),\n        }),\n        v.transform((input) => {\n            const execution: ProtoWrite.RiskExecution[\"execution\"] =\n                input.execution.type === \"market_ioc\"\n                    ? {\n                          case: \"marketIoc\",\n                          value: create(ProtoWrite.RiskMarketIocSchema),\n                      }\n                    : {\n                          case: \"limitGtc\",\n                          value: create(ProtoWrite.RiskLimitGtcSchema, {\n                              priceTicks: positiveDecimalInputToScaled(\n                                  `${fieldPrefix}.execution.price`,\n                                  input.execution.price,\n                                  scales.price(),\n                              ),\n                          }),\n                      };\n            return {\n                triggerPriceTicks: positiveDecimalInputToScaled(\n                    `${fieldPrefix}.triggerPrice`,\n                    input.triggerPrice,\n                    scales.price(),\n                ),\n                child: { execution },\n            };\n        }),\n    );\n}\n\nconst TrailingDistanceSchema = v.union([\n    PriceDistanceInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nconst MaxSlippageSchema = v.union([\n    PriceSlippageInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nexport const MarketMaxSlippageSchema = v.union([\n    PriceSlippageInputSchema,\n    BpsStringOrNumberInputSchema,\n    NoneInputSchema,\n]);\n\nconst MAX_BPS = 10_000;\nconst UNSET_TRAILING_STOP_MAX_SLIPPAGE: ProtoWrite.TrailingStopPolicy[\"maxSlippage\"] = {\n    case: undefined,\n    value: undefined,\n};\n\nfunction parseTrailingDistance(\n    scales: SdkScales,\n    distance: v.InferOutput<typeof TrailingDistanceSchema>,\n): ProtoWrite.TrailingStopPolicy[\"trailingDistance\"] {\n    return parseTrailingDistanceInput(scales, distance, \"trailingStop.trailingDistance\");\n}\n\nfunction parseMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof MaxSlippageSchema>,\n): ProtoWrite.TrailingStopPolicy[\"maxSlippage\"] {\n    return parseSlippageInput(scales, slippage, {\n        fieldName: \"trailingStop.maxSlippage\",\n        ticksCase: \"maxSlippageTicks\",\n        bpsCase: \"maxSlippageBps\",\n    });\n}\n\nexport function parseMarketMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof MarketMaxSlippageSchema> | undefined,\n): ProtoWrite.MarketIoc[\"maxSlippage\"] {\n    return parseSlippageInput(scales, slippage, {\n        fieldName: \"execution.maxSlippage\",\n        ticksCase: \"maxSlippageTicks\",\n        bpsCase: \"maxSlippageBps\",\n        maxBps: MAX_BPS,\n    });\n}\n\nfunction createTrailingStopInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.strictObject({\n            trailingDistance: TrailingDistanceSchema,\n            maxSlippage: v.optional(MaxSlippageSchema),\n            activationPrice: v.optional(DecimalInputStringSchema),\n        }),\n        v.transform((input) => ({\n            trailingDistance: parseTrailingDistance(scales, input.trailingDistance),\n            maxSlippage: input.maxSlippage\n                ? parseMaxSlippage(scales, input.maxSlippage)\n                : UNSET_TRAILING_STOP_MAX_SLIPPAGE,\n            activationPriceTicks:\n                input.activationPrice === undefined\n                    ? 0n\n                    : positiveDecimalInputToScaled(\n                          \"trailingStop.activationPrice\",\n                          input.activationPrice,\n                          scales.price(),\n                      ),\n        })),\n    );\n}\n\nfunction createRiskPolicyObjectInputSchema(scales: SdkScales) {\n    const TakeProfitInputSchema = attachedTriggerInputSchema(scales, \"takeProfit\");\n    const StopLossInputSchema = attachedTriggerInputSchema(scales, \"stopLoss\");\n    const TrailingStopInputSchema = createTrailingStopInputSchema(scales);\n    return v.union([\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: StopLossInputSchema,\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: v.optional(v.never()),\n            trailingStop: TrailingStopInputSchema,\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: TakeProfitInputSchema,\n            stopLoss: v.optional(v.never()),\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: v.optional(v.never()),\n            stopLoss: StopLossInputSchema,\n            trailingStop: v.optional(v.never()),\n            oco: v.optional(v.boolean()),\n        }),\n        v.strictObject({\n            takeProfit: v.optional(v.never()),\n            stopLoss: v.optional(v.never()),\n            trailingStop: TrailingStopInputSchema,\n            oco: v.optional(v.boolean()),\n        }),\n    ]);\n}\n\ntype RiskPolicyObjectInput = v.InferOutput<ReturnType<typeof createRiskPolicyObjectInputSchema>>;\n\nfunction transformRiskPolicyInput(input: RiskPolicyObjectInput) {\n    const stopLeg = input.stopLoss\n        ? ({ case: \"stopLoss\", value: input.stopLoss } as const)\n        : input.trailingStop\n          ? ({ case: \"trailingStop\", value: input.trailingStop } as const)\n          : ({ case: undefined, value: undefined } as const);\n    const oco = input.oco === true && !!input.takeProfit && stopLeg.case !== undefined;\n    return {\n        takeProfit: input.takeProfit,\n        stopLeg,\n        oco,\n    };\n}\n\nexport function createRiskPolicyInputSchema(scales: SdkScales) {\n    return v.pipe(\n        v.optional(createRiskPolicyObjectInputSchema(scales)),\n        v.transform((input) => (input ? transformRiskPolicyInput(input) : undefined)),\n    );\n}\n\nexport function createRequiredRiskPolicyInputSchema(scales: SdkScales) {\n    return v.pipe(\n        createRiskPolicyObjectInputSchema(scales),\n        v.transform((input) => transformRiskPolicyInput(input)),\n    );\n}\n\nexport type TakeProfitInput = v.InferInput<ReturnType<typeof attachedTriggerInputSchema>>;\nexport type StopLossInput = v.InferInput<ReturnType<typeof attachedTriggerInputSchema>>;\nexport type TrailingStopInput = v.InferInput<ReturnType<typeof createTrailingStopInputSchema>>;\nexport type RiskPolicyInput = v.InferInput<ReturnType<typeof createRiskPolicyInputSchema>>;\n\ntype TrailingDistance =\n    | { kind: \"distance\"; distance: string }\n    | { kind: \"bps\"; bps: number }\n    | { kind: \"none\" };\ntype TrailingMaxSlippage = { kind: \"slippage\"; slippage: string } | { kind: \"bps\"; bps: number };\nexport type MarketMaxSlippage =\n    | { kind: \"slippage\"; slippage: string }\n    | { kind: \"bps\"; bps: number };\n\nconst ReadRiskExecutionSchema = v.object({\n    execution: v.variant(\"case\", [\n        v.object({\n            case: v.literal(\"marketIoc\"),\n            value: v.object({}),\n        }),\n        v.object({\n            case: v.literal(\"limitGtc\"),\n            value: v.object({\n                priceTicks: v.bigint(),\n            }),\n        }),\n    ]),\n});\n\nconst ReadTakeProfitPolicySchema = v.object({\n    triggerPriceTicks: v.bigint(),\n    child: ReadRiskExecutionSchema,\n});\n\nconst ReadStopLossPolicySchema = v.object({\n    triggerPriceTicks: v.bigint(),\n    child: ReadRiskExecutionSchema,\n});\n\nconst ReadTrailingStopPolicySchema = v.object({\n    trailingDistance: v.object({\n        case: v.optional(\n            v.union([\n                v.literal(\"trailingDistanceTicks\"),\n                v.literal(\"trailingDistanceBps\"),\n                v.undefined(),\n            ]),\n        ),\n        value: v.optional(v.union([v.bigint(), v.number(), v.undefined()])),\n    }),\n    maxSlippage: v.object({\n        case: v.union([v.literal(\"maxSlippageTicks\"), v.literal(\"maxSlippageBps\"), v.undefined()]),\n        value: v.optional(v.union([v.number(), v.undefined()])),\n    }),\n    activationPriceTicks: v.bigint(),\n});\n\nconst ReadAttachedRiskTakeProfitSchema = v.object({\n    policy: v.optional(ReadTakeProfitPolicySchema),\n});\n\nconst ReadAttachedRiskStopLossSchema = v.object({\n    policy: v.optional(ReadStopLossPolicySchema),\n});\n\nconst ReadAttachedRiskTrailingStopSchema = v.object({\n    policy: v.optional(ReadTrailingStopPolicySchema),\n});\n\nexport const ReadAttachedRiskSchema = v.object({\n    takeProfit: v.optional(ReadAttachedRiskTakeProfitSchema),\n    stopLoss: v.optional(ReadAttachedRiskStopLossSchema),\n    trailingStop: v.optional(ReadAttachedRiskTrailingStopSchema),\n    oco: v.optional(v.boolean(), false),\n});\n\nfunction formatRiskExecution(\n    scales: SdkScales,\n    child: v.InferOutput<typeof ReadRiskExecutionSchema>,\n) {\n    if (child.execution.case === \"marketIoc\") {\n        return { type: \"market_ioc\" } as const;\n    }\n    return {\n        type: \"limit_gtc\",\n        price: scaledToDecimalOutput(child.execution.value.priceTicks, scales.price()),\n    } as const;\n}\n\nfunction formatRiskLeg(\n    scales: SdkScales,\n    leg:\n        | v.InferOutput<typeof ReadTakeProfitPolicySchema>\n        | v.InferOutput<typeof ReadStopLossPolicySchema>,\n) {\n    return {\n        triggerPrice: scaledToDecimalOutput(leg.triggerPriceTicks, scales.price()),\n        execution: formatRiskExecution(scales, leg.child),\n    };\n}\n\nfunction formatTrailingDistance(\n    scales: SdkScales,\n    distance: v.InferOutput<typeof ReadTrailingStopPolicySchema>[\"trailingDistance\"],\n): TrailingDistance {\n    if (distance.case === \"trailingDistanceTicks\" && typeof distance.value === \"bigint\") {\n        return {\n            kind: \"distance\",\n            distance: scaledToDecimalOutput(distance.value, scales.price()),\n        };\n    }\n    if (distance.case === \"trailingDistanceBps\" && typeof distance.value === \"number\") {\n        return { kind: \"bps\", bps: distance.value };\n    }\n    return { kind: \"none\" };\n}\n\nfunction formatTrailingMaxSlippage(\n    scales: SdkScales,\n    slippage: v.InferOutput<typeof ReadTrailingStopPolicySchema>[\"maxSlippage\"],\n): TrailingMaxSlippage | undefined {\n    if (slippage.case === \"maxSlippageTicks\" && typeof slippage.value === \"number\") {\n        return {\n            kind: \"slippage\",\n            slippage: scaledToDecimalOutput(BigInt(slippage.value), scales.price()),\n        };\n    }\n    if (slippage.case === \"maxSlippageBps\" && typeof slippage.value === \"number\") {\n        return { kind: \"bps\", bps: slippage.value };\n    }\n    return undefined;\n}\n\nexport function formatMarketMaxSlippage(\n    scales: SdkScales,\n    ticks: number,\n    bps: number,\n): MarketMaxSlippage | undefined {\n    if (ticks > 0) {\n        return { kind: \"slippage\", slippage: scaledToDecimalOutput(BigInt(ticks), scales.price()) };\n    }\n    if (bps > 0) {\n        return { kind: \"bps\", bps };\n    }\n    return undefined;\n}\n\nexport function formatAttachedRisk(\n    scales: SdkScales,\n    risk: v.InferOutput<typeof ReadAttachedRiskSchema> | undefined,\n) {\n    if (!risk) return undefined;\n\n    const takeProfit = risk.takeProfit?.policy\n        ? formatRiskLeg(scales, risk.takeProfit.policy)\n        : undefined;\n    const stopLoss = risk.stopLoss?.policy\n        ? formatRiskLeg(scales, risk.stopLoss.policy)\n        : undefined;\n    const trailingStop = risk.trailingStop?.policy\n        ? {\n              trailingDistance: formatTrailingDistance(\n                  scales,\n                  risk.trailingStop.policy.trailingDistance,\n              ),\n              maxSlippage: formatTrailingMaxSlippage(scales, risk.trailingStop.policy.maxSlippage),\n              activationPrice:\n                  risk.trailingStop.policy.activationPriceTicks > 0n\n                      ? scaledToDecimalOutput(\n                            risk.trailingStop.policy.activationPriceTicks,\n                            scales.price(),\n                        )\n                      : undefined,\n          }\n        : undefined;\n\n    if (!takeProfit && !stopLoss && !trailingStop) return undefined;\n\n    const effectiveStopLoss = trailingStop ? undefined : stopLoss;\n\n    return {\n        takeProfit,\n        stopLoss: effectiveStopLoss,\n        trailingStop,\n        oco: risk.oco,\n    };\n}\n"],"mappings":"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"}

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

@@ -1,3 +1,4 @@
+import { validation_d_exports } from "../../shared/validation.js";
 import { PolyesterMutationOptions, PolyesterRequestOptions } from "../../shared/request-options.js";
 import { SubaccountResolver } from "../subaccount-resolver.js";
 import { PolyesterRealtime } from "../../realtime/types.js";
@@ -9,7 +10,6 @@ import { BatchCancelOrdersInput, BatchCancelOrdersResult, BatchCreateOrdersInput
 import { Order, OrderDetails } from "./orders-output.schemas.js";
 import "./orders.schemas.js";
 import { Transport } from "@connectrpc/connect";
-import * as v from "valibot";
 //#region src/services/orders/orders.d.ts
 interface SubscribeOrdersInput extends BaseSubscribeInput<Order> {
   accountId: string;
@@ -23,14 +23,14 @@ declare class OrdersService {
   /**
    * Returns open orders for the resolved root account or subaccount, with optional symbol, trigger ID, side, pagination, and attached-risk inclusion filters. Results include the next page token returned by GetOpenOrders.
    */
-  listOpen(input?: v.InferInput<typeof OpenOrdersInputSchema>, options?: PolyesterRequestOptions): Promise<{
+  listOpen(input?: validation_d_exports.InferInput<typeof OpenOrdersInputSchema>, options?: PolyesterRequestOptions): Promise<{
     orders: Order[];
     nextPageToken: string;
   }>;
   /**
    * Returns historical orders for the resolved account scope, supporting symbol, trigger ID, side, status, time range, pagination, and attached-risk filters. Results are paginated with the backend nextPageToken.
    */
-  listHistory(input?: v.InferInput<typeof OrderHistoryInputSchema>, options?: PolyesterRequestOptions): Promise<{
+  listHistory(input?: validation_d_exports.InferInput<typeof OrderHistoryInputSchema>, options?: PolyesterRequestOptions): Promise<{
     orders: Order[];
     nextPageToken: string;
   }>;
@@ -47,9 +47,9 @@ declare class OrdersService {
    */
   batchCreate(input: BatchCreateOrdersInput, options?: PolyesterMutationOptions): Promise<BatchCreateOrdersResult>;
   /**
-   * Cancels one open order in the resolved account scope by order id or client order id, with optional symbol routing. Returns the backend cancellation status, order id, and server timestamp fields.
+   * Requests cancellation of one order in the resolved account scope by order id or client order id, with optional symbol routing. The response acknowledges the cancellation request, not the order's final lifecycle state; reconcile through order reads or realtime before releasing local state. A missing target remains a {@link ResourceNotFoundError}; callers performing desired-state cleanup may treat that error as success when the order could already have filled or left the book.
    */
-  cancel(input: v.InferInput<typeof CancelOrderInputSchema>, options?: PolyesterMutationOptions): Promise<CancelOrderResult>;
+  cancel(input: validation_d_exports.InferInput<typeof CancelOrderInputSchema>, options?: PolyesterMutationOptions): Promise<CancelOrderResult>;
   /**
    * Cancels 1–50 explicit orders in one best-effort request. Results preserve item order and acknowledge cancellation admission rather than final order state. Supply a stable requestId when an ambiguous batch may be retried.
    */
@@ -69,15 +69,15 @@ declare class OrdersService {
   /**
    * Cancels all matching open orders for the resolved account scope, optionally narrowed by symbol and side, with dry-run preview. A requestId is generated when omitted; provide a stable value when retrying the same logical bulk cancellation.
    */
-  cancelAll(input: v.InferInput<typeof CancelAllOrdersInputSchema>, options?: PolyesterMutationOptions): Promise<CancelAllOrdersResponse>;
+  cancelAll(input: validation_d_exports.InferInput<typeof CancelAllOrdersInputSchema>, options?: PolyesterMutationOptions): Promise<CancelAllOrdersResponse>;
   /**
    * Arms, refreshes, or disables the account dead-man switch. timeoutSec 0 disables it; 10–120 arms it. Generate a new requestId for each deliberate heartbeat, but reuse the same ID when retrying one ambiguous heartbeat.
    */
   cancelAllAfter(input: CancelAllAfterInput, options?: PolyesterMutationOptions): Promise<CancelAllAfterResult>;
   /**
-   * Fetches one order by id or client order id and returns its order, trades, and transfer details when found. Returns null when the backend response has no order.
+   * Fetches one order by id or client order id and returns its order, trades, and transfer details when found. Returns null when the requested order is not found.
    */
-  getDetails(input: v.InferInput<typeof GetOrderDetailsInputSchema>, options?: PolyesterRequestOptions): Promise<OrderDetails | null>;
+  getDetails(input: validation_d_exports.InferInput<typeof GetOrderDetailsInputSchema>, options?: PolyesterRequestOptions): Promise<OrderDetails | null>;
   /**
    * Subscribes to private order updates on private:spot:orders:{accountId}:proto and emits parsed order records until the returned unsubscribe function is called.
    */

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

@@ -1 +1 @@
-{"version":3,"file":"orders.d.ts","names":[],"sources":["../../../src/services/orders/orders.ts"],"mappings":";;;;;;;;;;;;;UAwEU,6BAA6B,mBAAmB;EACtD;;;;;cAqBS;;EAaL,YAAA,WAAW,WACX,UAAU,mBACV,UAAU,gCACV,QAAQ;;;;EAiBN,SACF,QAAO,EAAE,kBAAkB,wBAC3B,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAoBxB,YACF,QAAO,EAAE,kBAAkB,0BAC3B,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAoBxB,QACF,OAAO,eACP,UAAU,0BACX,QAAQ;;;;EAcL,OACF,OAAO,eACP,UAAU,2BACX,QAAQ;;;;EAeL,YACF,OAAO,wBACP,UAAU,2BACX,QAAQ;;;;EAyBL,OACF,OAAO,EAAE,kBAAkB,yBAC3B,UAAU,2BACX,QAAQ;;;;EAmBL,YACF,OAAO,wBACP,UAAU,2BACX,QAAQ;;;;EAkBL,OACF,OAAO,kBACP,UAAU,2BACX,QAAQ;;;;EAkBL,aACF,OAAO,yBACP,UAAU,2BACX,QAAQ;;;;EAyBL,sBACF,OAAO,4BACP,UAAU,0BACX,QAAQ;;;;EAaL,UACF,OAAO,EAAE,kBAAkB,6BAC3B,UAAU,2BACX,QAAQ;;;;EAgBL,eACF,OAAO,qBACP,UAAU,2BACX,QAAQ;;;;EAgBL,WACF,OAAO,EAAE,kBAAkB,6BAC3B,UAAU,0BACX,QAAQ;;;;EAeX,UAAU,OAAO"}
+{"version":3,"file":"orders.d.ts","names":[],"sources":["../../../src/services/orders/orders.ts"],"mappings":";;;;;;;;;;;;;UAoFU,6BAA6B,mBAAmB;EACtD;;;;;cAqBS;;EAaL,YAAA,WAAW,WACX,UAAU,mBACV,UAAU,gCACV,QAAQ;;;;EAiBN,SACF,QAAO,qBAAE,kBAAkB,wBAC3B,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAoBxB,YACF,QAAO,qBAAE,kBAAkB,0BAC3B,UAAU,0BACX;IAAU,QAAQ;IAAS;;;;;EAoBxB,QACF,OAAO,eACP,UAAU,0BACX,QAAQ;;;;EAcL,OACF,OAAO,eACP,UAAU,2BACX,QAAQ;;;;EAeL,YACF,OAAO,wBACP,UAAU,2BACX,QAAQ;;;;EAyBL,OACF,OAAO,qBAAE,kBAAkB,yBAC3B,UAAU,2BACX,QAAQ;;;;EAmBL,YACF,OAAO,wBACP,UAAU,2BACX,QAAQ;;;;EAkBL,OACF,OAAO,kBACP,UAAU,2BACX,QAAQ;;;;EAkBL,aACF,OAAO,yBACP,UAAU,2BACX,QAAQ;;;;EAyBL,sBACF,OAAO,4BACP,UAAU,0BACX,QAAQ;;;;EAaL,UACF,OAAO,qBAAE,kBAAkB,6BAC3B,UAAU,2BACX,QAAQ;;;;EAgBL,eACF,OAAO,qBACP,UAAU,2BACX,QAAQ;;;;EAgBL,WACF,OAAO,qBAAE,kBAAkB,6BAC3B,UAAU,0BACX,QAAQ;;;;EAqBX,UAAU,OAAO"}

package/dist/services/orders/orders.js

@@ -1,16 +1,18 @@
+import { parse, validation_exports } from "../../shared/validation.js";
 import { OrdersService as OrdersService$1 } from "../../gen/orders/v1/orders_pb.js";
 import { toConnectCallOptions } from "../../shared/request-options.js";
 import { removeUndefined } from "../../utils/remove-undefined.js";
 import { resolveAccountScopedInput } from "../subaccount-resolver.js";
 import { publicationHandlerErrorContext } from "../../shared/subscription-errors.js";
 import { createReadyGate } from "../../shared/decimal-surface.js";
+import { formatConnectError, isResourceNotFoundError } from "../../utils/errors.js";
 import { OrderSchema, OrdersReadService } from "../../gen/orders/v1/orders_read_pb.js";
+import { getOrderErrorDetail } from "../../utils/connect-order-errors.js";
 import { CancelAllOrdersInputSchema, CancelAllOrdersResponseSchema, CancelOrderInputSchema, CancelOrderResultSchema, GetOrderDetailsInputSchema, OpenOrdersInputSchema, OrderHistoryInputSchema, createCreateOrderResultSchema, createNewOrderInputSchema, createPreviewOrderResultSchema } from "./orders-input.schemas.js";
 import { ModifyOrderResultSchema, assertKnownModifyOrderInputKeys, createModifyOrderInputSchema } from "./orders-modify.schemas.js";
 import { BatchCancelOrdersInputSchema, BatchCancelOrdersResultSchema, BatchReplaceOrdersResultSchema, CancelAllAfterInputSchema, CancelAllAfterResultSchema, GetBatchReplaceStatusInputSchema, GetBatchReplaceStatusResultSchema, assertKnownBatchReplaceOrderItemInputKeys, createBatchCreateOrdersInputSchema, createBatchCreateOrdersResultSchema, createBatchReplaceOrdersInputSchema } from "./orders-batch.schemas.js";
 import { createOrderDetailsSchema, createOrderSchema } from "./orders-output.schemas.js";
 import { createClient } from "@connectrpc/connect";
-import * as v from "valibot";
 //#region src/services/orders/orders.ts
 function hasKnownOrderSymbol(scales, order) {
 	try {
@@ -20,6 +22,10 @@ function hasKnownOrderSymbol(scales, order) {
 		return false;
 	}
 }
+const MISCLASSIFIED_ORDER_NOT_FOUND_MESSAGE = "order not found";
+function isOrderNotFoundError(error) {
+	return isResourceNotFoundError(error) || getOrderErrorDetail(error)?.code === "NOT_FOUND" || formatConnectError(error, "").toLowerCase() === MISCLASSIFIED_ORDER_NOT_FOUND_MESSAGE;
+}
 function createMutationRequestId() {
 	return globalThis.crypto?.randomUUID?.() ?? `req_${Date.now()}_${Math.random().toString(16).slice(2)}`;
 }
@@ -58,10 +64,10 @@ var OrdersService = class {
 	async listOpen(input = {}, options) {
 		await this.#scales.ready();
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const validatedInput = v.parse(OpenOrdersInputSchema, resolved);
+		const validatedInput = parse(OpenOrdersInputSchema, resolved);
 		const res = await this.#readClient.getOpenOrders(removeUndefined(validatedInput), toConnectCallOptions(options));
 		return {
-			orders: v.parse(v.array(this.#orderSchema), res.orders.filter((order) => hasKnownOrderSymbol(this.#scales, order))),
+			orders: parse(validation_exports.array(this.#orderSchema), res.orders.filter((order) => hasKnownOrderSymbol(this.#scales, order))),
 			nextPageToken: res.nextPageToken
 		};
 	}
@@ -71,10 +77,10 @@ var OrdersService = class {
 	async listHistory(input = {}, options) {
 		await this.#scales.ready();
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const validatedInput = v.parse(OrderHistoryInputSchema, resolved);
+		const validatedInput = parse(OrderHistoryInputSchema, resolved);
 		const res = await this.#readClient.getOrderHistory(removeUndefined(validatedInput), toConnectCallOptions(options));
 		return {
-			orders: v.parse(v.array(this.#orderSchema), res.orders.filter((order) => hasKnownOrderSymbol(this.#scales, order))),
+			orders: parse(validation_exports.array(this.#orderSchema), res.orders.filter((order) => hasKnownOrderSymbol(this.#scales, order))),
 			nextPageToken: res.nextPageToken
 		};
 	}
@@ -84,9 +90,9 @@ var OrdersService = class {
 	async preview(input, options) {
 		await this.#scales.ready();
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const request = v.parse(this.#newOrderInputSchema, resolved);
+		const request = parse(this.#newOrderInputSchema, resolved);
 		const response = await this.#writeClient.previewOrder(removeUndefined(request), toConnectCallOptions(options));
-		return v.parse(createPreviewOrderResultSchema(this.#scales, input.symbol), response);
+		return parse(createPreviewOrderResultSchema(this.#scales, input.symbol), response);
 	}
 	/**
 	* Places a spot order with an explicit market-IOC, limit-GTC, limit-IOC, or limit-FOK execution policy and optional attached risk controls. clientOrderId is the caller-controlled idempotency key and should be reused only for the same logical order.
@@ -94,10 +100,10 @@ var OrdersService = class {
 	async create(input, options) {
 		await this.#scales.ready();
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const validatedInput = v.parse(this.#newOrderInputSchema, resolved);
+		const validatedInput = parse(this.#newOrderInputSchema, resolved);
 		const requestPayload = removeUndefined(validatedInput);
 		const res = await this.#writeClient.createOrder(requestPayload, toConnectCallOptions(options));
-		return v.parse(createCreateOrderResultSchema(this.#scales, input.symbol), res);
+		return parse(createCreateOrderResultSchema(this.#scales, input.symbol), res);
 	}
 	/**
 	* Places 1–20 spot orders in one best-effort request. Results preserve item order and report admission as accepted or rejected; accepted orders still require lifecycle reconciliation. Supply a clientOrderId for each item and a stable requestId when an ambiguous batch may be retried.
@@ -108,24 +114,24 @@ var OrdersService = class {
 			...resolveAccountScopedInput(input, this.#resolver),
 			requestId: input.requestId ?? createMutationRequestId()
 		};
-		const request = v.parse(this.#batchCreateOrdersInputSchema, resolved);
+		const request = parse(this.#batchCreateOrdersInputSchema, resolved);
 		const response = await this.#writeClient.batchCreateOrders(removeUndefined(request), toConnectCallOptions(options));
-		const result = v.parse(createBatchCreateOrdersResultSchema(this.#scales, input.items.map((item) => item.symbol)), response);
+		const result = parse(createBatchCreateOrdersResultSchema(this.#scales, input.items.map((item) => item.symbol)), response);
 		assertBatchResultCount("batchCreate", input.items.length, result.results.length);
 		return result;
 	}
 	/**
-	* Cancels one open order in the resolved account scope by order id or client order id, with optional symbol routing. Returns the backend cancellation status, order id, and server timestamp fields.
+	* Requests cancellation of one order in the resolved account scope by order id or client order id, with optional symbol routing. The response acknowledges the cancellation request, not the order's final lifecycle state; reconcile through order reads or realtime before releasing local state. A missing target remains a {@link ResourceNotFoundError}; callers performing desired-state cleanup may treat that error as success when the order could already have filled or left the book.
 	*/
 	async cancel(input, options) {
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const validated = v.parse(CancelOrderInputSchema, resolved);
+		const validated = parse(CancelOrderInputSchema, resolved);
 		const res = await this.#writeClient.cancelOrder({
 			key: validated.key,
 			symbolId: validated.symbolId,
 			subaccountId: validated.subaccountId
 		}, toConnectCallOptions(options));
-		return v.parse(CancelOrderResultSchema, res);
+		return parse(CancelOrderResultSchema, res);
 	}
 	/**
 	* Cancels 1–50 explicit orders in one best-effort request. Results preserve item order and acknowledge cancellation admission rather than final order state. Supply a stable requestId when an ambiguous batch may be retried.
@@ -135,9 +141,9 @@ var OrdersService = class {
 			...resolveAccountScopedInput(input, this.#resolver),
 			requestId: input.requestId ?? createMutationRequestId()
 		};
-		const request = v.parse(BatchCancelOrdersInputSchema, resolved);
+		const request = parse(BatchCancelOrdersInputSchema, resolved);
 		const response = await this.#writeClient.batchCancelOrders(removeUndefined(request), toConnectCallOptions(options));
-		const result = v.parse(BatchCancelOrdersResultSchema, response);
+		const result = parse(BatchCancelOrdersResultSchema, response);
 		assertBatchResultCount("batchCancel", input.items.length, result.results.length);
 		return result;
 	}
@@ -151,9 +157,9 @@ var OrdersService = class {
 			requestId: input.requestId ?? createMutationRequestId()
 		};
 		assertKnownModifyOrderInputKeys(resolved);
-		const validated = v.parse(this.#modifyOrderInputSchema, resolved);
+		const validated = parse(this.#modifyOrderInputSchema, resolved);
 		const res = await this.#writeClient.modifyOrder(removeUndefined(validated), toConnectCallOptions(options));
-		return v.parse(ModifyOrderResultSchema, res);
+		return parse(ModifyOrderResultSchema, res);
 	}
 	/**
 	* Replaces 1–50 same-symbol orders and returns an index-stable durable admission receipt. Reuse requestId only when retrying the same logical batch; use the returned batchRequestId for later status reads.
@@ -165,9 +171,9 @@ var OrdersService = class {
 			...resolveAccountScopedInput(input, this.#resolver),
 			requestId: input.requestId ?? createMutationRequestId()
 		};
-		const request = v.parse(createBatchReplaceOrdersInputSchema(this.#scales, input.symbolId), resolved);
+		const request = parse(createBatchReplaceOrdersInputSchema(this.#scales, input.symbolId), resolved);
 		const response = await this.#writeClient.batchReplaceOrders(removeUndefined(request), toConnectCallOptions(options));
-		const result = v.parse(BatchReplaceOrdersResultSchema, response);
+		const result = parse(BatchReplaceOrdersResultSchema, response);
 		assertBatchResultCount("batchReplace", input.items.length, result.results.length);
 		return result;
 	}
@@ -176,9 +182,9 @@ var OrdersService = class {
 	*/
 	async getBatchReplaceStatus(input, options) {
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const request = v.parse(GetBatchReplaceStatusInputSchema, resolved);
+		const request = parse(GetBatchReplaceStatusInputSchema, resolved);
 		const response = await this.#readClient.getBatchReplaceStatus(removeUndefined(request), toConnectCallOptions(options));
-		return v.parse(GetBatchReplaceStatusResultSchema, response);
+		return parse(GetBatchReplaceStatusResultSchema, response);
 	}
 	/**
 	* Cancels all matching open orders for the resolved account scope, optionally narrowed by symbol and side, with dry-run preview. A requestId is generated when omitted; provide a stable value when retrying the same logical bulk cancellation.
@@ -188,9 +194,9 @@ var OrdersService = class {
 			...resolveAccountScopedInput(input, this.#resolver),
 			requestId: input.requestId ?? createMutationRequestId()
 		};
-		const validated = v.parse(CancelAllOrdersInputSchema, resolved);
+		const validated = parse(CancelAllOrdersInputSchema, resolved);
 		const res = await this.#writeClient.cancelAllOrders(removeUndefined(validated), toConnectCallOptions(options));
-		return v.parse(CancelAllOrdersResponseSchema, res);
+		return parse(CancelAllOrdersResponseSchema, res);
 	}
 	/**
 	* Arms, refreshes, or disables the account dead-man switch. timeoutSec 0 disables it; 10–120 arms it. Generate a new requestId for each deliberate heartbeat, but reuse the same ID when retrying one ambiguous heartbeat.
@@ -200,20 +206,26 @@ var OrdersService = class {
 			...resolveAccountScopedInput(input, this.#resolver),
 			requestId: input.requestId ?? createMutationRequestId()
 		};
-		const request = v.parse(CancelAllAfterInputSchema, resolved);
+		const request = parse(CancelAllAfterInputSchema, resolved);
 		const response = await this.#writeClient.cancelAllAfter(removeUndefined(request), toConnectCallOptions(options));
-		return v.parse(CancelAllAfterResultSchema, response);
+		return parse(CancelAllAfterResultSchema, response);
 	}
 	/**
-	* Fetches one order by id or client order id and returns its order, trades, and transfer details when found. Returns null when the backend response has no order.
+	* Fetches one order by id or client order id and returns its order, trades, and transfer details when found. Returns null when the requested order is not found.
 	*/
 	async getDetails(input, options) {
 		await this.#scales.ready();
 		const resolved = resolveAccountScopedInput(input, this.#resolver);
-		const validatedInput = v.parse(GetOrderDetailsInputSchema, resolved);
-		const res = await this.#readClient.getOrder(removeUndefined(validatedInput), toConnectCallOptions(options));
+		const validatedInput = parse(GetOrderDetailsInputSchema, resolved);
+		let res;
+		try {
+			res = await this.#readClient.getOrder(removeUndefined(validatedInput), toConnectCallOptions(options));
+		} catch (error) {
+			if (isOrderNotFoundError(error)) return null;
+			throw error;
+		}
 		if (!res.order) return null;
-		return v.parse(this.#orderDetailsSchema, res);
+		return parse(this.#orderDetailsSchema, res);
 	}
 	/**
 	* Subscribes to private order updates on private:spot:orders:{accountId}:proto and emits parsed order records until the returned unsubscribe function is called.
@@ -226,13 +238,13 @@ var OrdersService = class {
 			schema: OrderSchema,
 			onPublication: (data) => {
 				gate.run(() => {
-					const order = v.parse(this.#orderSchema, data);
+					const order = parse(this.#orderSchema, data);
 					input.onEvent(order);
 				});
 			},
 			onConnected: () => input.onOpen?.(),
 			onDisconnected: () => input.onClose?.(),
-			onError: (ctx) => input.onError?.(ctx)
+			onError: input.onError
 		});
 	}
 };