@liquiditytech/rapidx-cli 1.0.28 → 1.0.30

package/dist/core/contracts/input-schema.js

@@ -1,10 +1,10 @@
-import { ProductError } from "../errors/product-error.js";
+import { CORE_ERRORS, ProductError } from "../errors/product-error.js";
 const stringSchema = { type: "string" };
 const booleanSchema = { type: "boolean" };
 const numberSchema = { type: "number" };
 const symbolSchema = {
     type: "string",
-    description: "RapidX symbol. Recommended format: BINANCE_PERP_<BASE>_<QUOTE>.",
+    description: "RapidX symbol. Recommended format: BINANCE_PERP_<BASE>_<QUOTE>. OKX_PERP_<BASE>_<QUOTE> is supported; OKX_SWAP_<BASE>_<QUOTE> is accepted as an input alias and normalized to OKX_PERP.",
     examples: ["BINANCE_PERP_BTC_USDT", "BINANCE_PERP_ETH_USDT"]
 };
 const sideSchema = {
@@ -15,7 +15,7 @@ const sideSchema = {
 const orderTypeSchema = {
     type: "string",
     enum: ["LIMIT", "MARKET"],
-    description: "Order type. LIMIT is the expected default for agent-driven trading; MARKET may be blocked by safety policy."
+    description: "Order type. MARKET is allowed when the write operation passes preview and consent checks; preview includes immediate-execution and slippage risk notes."
 };
 const priceSchema = {
     type: "string",
@@ -55,6 +55,19 @@ const acceptedRiskTextSchema = {
     description: "Human confirmation text bound to the exact symbol, side, maxNotional, real-order risk, and cancel/cleanup behavior.",
     examples: ["I authorize a real verification order for BINANCE_PERP_BTC_USDT BUY maxNotional 10 with cancel cleanup."]
 };
+const automationModeSchema = {
+    type: "boolean",
+    description: "Set true only when the human user has explicitly enabled RapidX automation mode in chat for this preview."
+};
+const automationConsentTextSchema = {
+    type: "string",
+    description: "Human chat authorization text for automation mode. The agent must not invent this text.",
+    examples: ["I enable RapidX automation mode for BINANCE_PERP_BTC_USDT with maxNotional 100 and accept automated preview-submit execution."]
+};
+const automationScopeSchema = {
+    type: "string",
+    description: "Optional automation scope label, for example single-preview, strategy-session, or the user's exact scope phrase."
+};
 const previewIdSchema = {
     type: "string",
     description: "Preview id returned by the matching preview tool or command.",
@@ -73,7 +86,7 @@ const targetCapabilityIdSchema = {
 const orderIdSchema = {
     type: "string",
     description: "RapidX order id returned by order.place, order.list, or order.get.",
-    examples: ["1234567890"]
+    examples: ["2173374713391199"]
 };
 const accountBalanceModeSchema = {
     type: "string",
@@ -82,6 +95,7 @@ const accountBalanceModeSchema = {
 };
 const positionSideSchema = {
     type: "string",
+    enum: ["LONG", "SHORT"],
     description: "Position side when the account is in hedge mode, for example LONG or SHORT. Omit in one-way NET mode unless RapidX returns a specific side."
 };
 const closePositionReduceOnlySchema = {
@@ -103,7 +117,10 @@ export function inputSchemaForName(name) {
         case "AccountBalanceInput":
             return objectSchema({ mode: accountBalanceModeSchema, currency: stringSchema });
         case "OrderLookupInput":
-            return objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, symbol: symbolSchema });
+            return {
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, symbol: symbolSchema }),
+                anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
+            };
         case "OrderListInput":
         case "OrderHistoryInput":
             return objectSchema({ symbol: symbolSchema, pageSize: numberSchema, startTime: stringSchema, endTime: stringSchema });
@@ -121,6 +138,7 @@ export function inputSchemaForName(name) {
                 price: priceSchema,
                 quantity: quantitySchema,
                 amount: amountSchema,
+                positionSide: positionSideSchema,
                 timeInForce: stringSchema,
                 postOnly: booleanSchema,
                 reduceOnly: booleanSchema,
@@ -140,6 +158,7 @@ export function inputSchemaForName(name) {
                 takeProfitLimitPrice: stringSchema,
                 algoType: stringSchema,
                 consentId: stringSchema,
+                ...automationProperties(),
                 ...compatibilityProperties()
             }, ["targetCapabilityId"]);
         case "PreviewOrderInput":
@@ -147,6 +166,7 @@ export function inputSchemaForName(name) {
                 ...objectSchema({
                     ...tradeCreateProperties(),
                     consentId: stringSchema,
+                    ...automationProperties(),
                     ...compatibilityProperties()
                 }, ["symbol", "side", "orderType", "maxNotional", "clientOrderId"]),
                 oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
@@ -166,7 +186,7 @@ export function inputSchemaForName(name) {
             };
         case "AmendOrderPreviewInput":
             return {
-                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, ...compatibilityProperties() }),
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, price: priceSchema, quantity: quantitySchema, ...automationProperties(), ...compatibilityProperties() }),
                 allOf: [
                     { anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }] },
                     { anyOf: [{ required: ["price"] }, { required: ["quantity"] }] }
@@ -174,7 +194,7 @@ export function inputSchemaForName(name) {
             };
         case "CancelOrderPreviewInput":
             return {
-                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, ...compatibilityProperties() }),
+                ...objectSchema({ orderId: orderIdSchema, clientOrderId: clientOrderIdSchema, ...automationProperties(), ...compatibilityProperties() }),
                 anyOf: [{ required: ["orderId"] }, { required: ["clientOrderId"] }]
             };
         case "AmendOrderInput":
@@ -193,7 +213,7 @@ export function inputSchemaForName(name) {
         case "ClosePositionInput":
             return objectSchema({ symbol: symbolSchema, positionSide: positionSideSchema, reduceOnly: closePositionReduceOnlySchema, maxNotional: maxNotionalSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "reduceOnly", "maxNotional", "previewId", "continueConsentId"]);
         case "SetLeverageInput":
-            return objectSchema({ symbol: symbolSchema, leverage: numberSchema, positionSide: stringSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "leverage", "previewId", "continueConsentId"]);
+            return objectSchema({ symbol: symbolSchema, leverage: numberSchema, positionSide: positionSideSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["symbol", "leverage", "previewId", "continueConsentId"]);
         case "SetPositionModeInput":
             return objectSchema({ mode: { type: "string", enum: ["BOTH", "NET"] }, exchange: stringSchema, previewId: previewIdSchema, continueConsentId: continueConsentIdSchema }, ["mode", "exchange", "previewId", "continueConsentId"]);
         case "AlgoPlaceInput":
@@ -201,7 +221,6 @@ export function inputSchemaForName(name) {
                 ...objectSchema({
                     ...tradeCreateProperties(),
                     algoType: stringSchema,
-                    positionSide: stringSchema,
                     conditionType: algoConditionTypeSchema,
                     triggerPrice: stringSchema,
                     triggerType: triggerTypeSchema,
@@ -221,7 +240,7 @@ export function inputSchemaForName(name) {
                     "previewId",
                     "continueConsentId"
                 ]),
-                oneOf: [{ required: ["quantity"] }, { required: ["amount"] }]
+                anyOf: [{ required: ["quantity"] }, { required: ["amount"] }, { required: ["conditionType"] }]
             };
         case "AlgoAmendInput":
             return objectSchema({
@@ -244,6 +263,7 @@ export function inputSchemaForName(name) {
                 side: sideSchema,
                 maxNotional: maxNotionalSchema,
                 clientOrderId: clientOrderIdSchema,
+                positionSide: positionSideSchema,
                 explicitUserConsent: explicitUserConsentSchema,
                 acceptedRiskText: acceptedRiskTextSchema
             }, ["symbol", "side", "maxNotional", "clientOrderId", "explicitUserConsent", "acceptedRiskText"]);
@@ -326,15 +346,27 @@ export function assertInputMatchesSchema(schemaName, input, options = {}) {
             collectAnyOfProblem(group.anyOf, input, problems);
         }
     }
+    collectSchemaSpecificProblems(schemaName, input, problems);
     if (problems.length > 0) {
         throw new ProductError({
-            code: "RCORE00001",
-            status: "FAIL",
+            code: CORE_ERRORS.SCHEMA_INVALID,
+            status: "INVALID_INPUT",
             message: `Input schema validation failed: ${problems.join("; ")}.`
         });
     }
     void allowedFields;
 }
+function collectSchemaSpecificProblems(schemaName, input, problems) {
+    if (schemaName !== "AlgoPlaceInput") {
+        return;
+    }
+    if (String(input.conditionType ?? "").toUpperCase() !== "ENTIRE_CLOSE_POSITION") {
+        return;
+    }
+    if (!hasValue(input.stopLossPrice) && !hasValue(input.takeProfitPrice)) {
+        problems.push("TPSL ENTIRE_CLOSE_POSITION requires stopLossPrice or takeProfitPrice");
+    }
+}
 function collectAnyOfProblem(rules, input, problems) {
     if (!rules.some((candidate) => (candidate.required ?? []).every((field) => hasValue(input[field])))) {
         const labels = rules.map((candidate) => (candidate.required ?? []).join(", ")).join(" or ");
@@ -362,7 +394,15 @@ function tradeCreateProperties() {
         postOnly: booleanSchema,
         reduceOnly: booleanSchema,
         maxNotional: maxNotionalSchema,
-        clientOrderId: clientOrderIdSchema
+        clientOrderId: clientOrderIdSchema,
+        positionSide: positionSideSchema
+    };
+}
+function automationProperties() {
+    return {
+        automationMode: automationModeSchema,
+        automationConsentText: automationConsentTextSchema,
+        automationScope: automationScopeSchema
     };
 }
 function compatibilityProperties() {

package/dist/core/errors/product-error.js

@@ -12,11 +12,13 @@ export class ProductError extends Error {
         }
     }
     toEnvelope(evidence = []) {
+        const details = publicErrorDetails(this);
         return {
             ok: false,
             status: this.status,
             code: this.code,
             message: this.message,
+            ...(details ? { details } : {}),
             evidence
         };
     }
@@ -26,7 +28,10 @@ export const CORE_ERRORS = {
     INVALID_CREDENTIAL: "RCORE01002",
     MISSING_API_HOST: "RCORE01003",
     SECRET_REDACTION_RISK: "RCORE90002",
+    INVALID_ORDER_ID: "RCORE00002",
     UPSTREAM_REJECTED: "RCORE22001",
+    PERMISSION_SCOPE_ERROR: "RCORE01004",
+    NOT_FOUND: "RCORE22004",
     UPSTREAM_TIMEOUT: "RCORE23002",
     UPSTREAM_RATE_LIMITED: "RCORE23003",
     SCHEMA_INVALID: "RCORE30001"
@@ -49,6 +54,18 @@ export function normalizeUnknownError(error, fallbackCode = "RCORE00001") {
         message
     });
 }
+export function publicErrorDetails(error) {
+    if (!error.details) {
+        return undefined;
+    }
+    const details = {};
+    for (const key of ["upstreamStatus", "upstreamCode", "upstreamMessage", "hint", "attempts"]) {
+        if (error.details[key] !== undefined) {
+            details[key] = error.details[key];
+        }
+    }
+    return Object.keys(details).length > 0 ? details : undefined;
+}
 function isUpstreamNetworkError(error) {
     if (!(error instanceof Error)) {
         return false;

package/dist/core/index.js

@@ -12,10 +12,12 @@ export * from "./errors/product-error.js";
 export * from "./client/signing.js";
 export * from "./client/rapid-x-client.js";
 export * from "./client/capability-executor.js";
+export * from "./client/order-id.js";
 export * from "./client/symbol.js";
 export * from "./safety/policy.js";
 export * from "./safety/raw-api.js";
 export * from "./trading/preview.js";
+export * from "./trading/preview-preflight.js";
 export * from "./update/check-update.js";
 export * from "./self-check/run-self-check.js";
 export * from "./self-check/live-read-only-probes.js";

package/dist/core/safety/policy.js

@@ -78,8 +78,8 @@ export function evaluateSafety(capability, input, policy, state = makeSafetyStat
             return { allowed: false, code: "RCORE00001", reason: "mode must be BOTH or NET.", paramsHash };
         }
     }
-    if (String(input.orderType ?? "").toUpperCase() === "MARKET" && (policy.marketOrderPolicy ?? "BLOCK_BY_DEFAULT") === "BLOCK_BY_DEFAULT") {
-        return { allowed: false, code: "RCORE20002", reason: "Market orders are blocked by default.", paramsHash };
+    if (String(input.orderType ?? "").toUpperCase() === "MARKET" && (policy.marketOrderPolicy ?? "ALLOW") === "BLOCK_BY_DEFAULT") {
+        return { allowed: false, code: "RCORE20002", reason: "Market orders are blocked by safety policy.", paramsHash };
     }
     if (requiresNotionalLimit(capability)) {
         const maxNotional = input.maxNotional ?? policy.maxNotional;
@@ -114,7 +114,7 @@ function requiredTradeFields(capability, input) {
             requireString(input, "orderType", missing);
             requireString(input, "clientOrderId", missing);
             requireString(input, "maxNotional", missing);
-            if (!hasString(input, "quantity") && !hasString(input, "amount")) {
+            if (!hasString(input, "quantity") && !hasString(input, "amount") && !isEntireCloseAlgo(capability, input)) {
                 missing.push("quantity or amount");
             }
             if (String(input.orderType ?? "").toUpperCase() === "LIMIT") {
@@ -194,6 +194,9 @@ function stringValue(value) {
 function hasString(input, field) {
     return typeof input[field] === "string" && input[field].length > 0;
 }
+function isEntireCloseAlgo(capability, input) {
+    return capability.capabilityId === "algo.place" && String(input.conditionType ?? "").toUpperCase() === "ENTIRE_CLOSE_POSITION";
+}
 function requireString(input, field, missing) {
     if (!hasString(input, field)) {
         missing.push(field);

package/dist/core/self-check/live-trading-verification-probes.js

@@ -13,6 +13,7 @@ export function buildLiveTradingVerificationProbes(input = {}) {
                 orderType: "LIMIT",
                 price: orderInput.price,
                 quantity: orderInput.quantity,
+                positionSide: orderInput.positionSide,
                 maxNotional: orderInput.maxNotional,
                 clientOrderId: orderInput.clientOrderId,
                 postOnly: true,
@@ -34,7 +35,7 @@ export function buildLiveTradingVerificationProbes(input = {}) {
                 previewId: `internal-${order.orderId}`,
                 continueConsentId: continueConsentId(order.orderId, "cancel")
             });
-            const data = extractDataObject(result);
+            const data = extractDataObject(extractWrappedResponse(result));
             const status = normalizeOrderStatus(stringField(data, "orderState") ?? stringField(data, "action") ?? "");
             if (status === "CANCELED") {
                 return { orderId: order.orderId, status };
@@ -186,6 +187,12 @@ function extractDataObject(result) {
     }
     return {};
 }
+function extractWrappedResponse(result) {
+    if (result && typeof result === "object" && !Array.isArray(result) && Object.prototype.hasOwnProperty.call(result, "response")) {
+        return result.response;
+    }
+    return result;
+}
 function extractArrayData(result) {
     const data = extractData(result);
     if (Array.isArray(data)) {

package/dist/core/trading/preview-preflight.js

@@ -0,0 +1,333 @@
+import { RapidXClient } from "../client/rapid-x-client.js";
+import { assertOrderLookupReference } from "../client/order-id.js";
+import { parseRapidXSymbol } from "../client/symbol.js";
+import { ProductError } from "../errors/product-error.js";
+export async function runPreviewPreflight(capabilityId, input, options = {}) {
+    switch (capabilityId) {
+        case "order.preview":
+        case "order.place-preview":
+        case "order.place":
+        case "algo.place":
+            return validateOrderPlacementPreflight(input, options);
+        case "order.cancel":
+            return validateOrderMutationPreflight(input, "cancel", options);
+        case "order.amend":
+            return validateOrderMutationPreflight(input, "amend", options);
+        case "position.close":
+            return validatePositionClosePreflight(input, options);
+        default:
+            return {};
+    }
+}
+async function validateOrderPlacementPreflight(input, options) {
+    const symbolInput = requiredString(input.symbol, "symbol");
+    const parsed = parseRapidXSymbol(symbolInput);
+    const client = options.client ?? new RapidXClient();
+    const response = await client.get("/api/v1/trading/sym/info", { sym: parsed.canonicalSymbol });
+    const rules = extractSymbolRules(response, parsed.canonicalSymbol);
+    validateQuantity(input, rules);
+    validatePrice(input, rules);
+    validateNotional(input, rules);
+    return {
+        marketRules: compactObject({
+            symbol: parsed.canonicalSymbol,
+            inputSymbol: parsed.inputSymbol !== parsed.canonicalSymbol ? parsed.inputSymbol : undefined,
+            minNotional: rules.minNotional,
+            minSize: rules.minSize,
+            lotSize: rules.lotSize,
+            qtyPrecision: rules.qtyPrecision,
+            tickSize: rules.tickSize,
+            pricePrecision: rules.pricePrecision
+        })
+    };
+}
+async function validateOrderMutationPreflight(input, action, options) {
+    const client = options.client ?? new RapidXClient();
+    const params = orderLookupParams(input);
+    const response = await client.get("/api/v1/trading/order", params);
+    const order = extractOrderReadback(response);
+    if (!order) {
+        throw new ProductError({
+            code: "RCORE22004",
+            status: "BLOCKED",
+            message: "ORDER_NOT_FOUND: order.get did not return an order for preview preflight."
+        });
+    }
+    const state = normalizeOrderState(order.orderState ?? order.state ?? order.status);
+    if (!isOpenOrderState(state)) {
+        throw new ProductError({
+            code: "RCORE22005",
+            status: "BLOCKED",
+            message: `ORDER_NOT_OPEN: order is ${state || "UNKNOWN"} and cannot be ${action}ed.`
+        });
+    }
+    return {
+        orderReadback: {
+            ...order,
+            orderState: state || order.orderState
+        }
+    };
+}
+async function validatePositionClosePreflight(input, options) {
+    const symbolInput = requiredString(input.symbol, "symbol");
+    const parsed = parseRapidXSymbol(symbolInput);
+    const client = options.client ?? new RapidXClient();
+    const response = await client.get("/api/v1/trading/position", { sym: parsed.canonicalSymbol });
+    const positions = extractPositions(response);
+    const positionSide = typeof input.positionSide === "string" && input.positionSide.length > 0 ? input.positionSide.toUpperCase() : undefined;
+    const position = positions.find((item) => {
+        const itemSymbol = stringField(item, "sym") ?? stringField(item, "symbol");
+        const itemSide = stringField(item, "positionSide")?.toUpperCase();
+        const qty = Number(stringField(item, "positionQty") ?? stringField(item, "quantity") ?? stringField(item, "qty") ?? "0");
+        return itemSymbol === parsed.canonicalSymbol && Math.abs(qty) > 0 && (!positionSide || !itemSide || itemSide === positionSide);
+    });
+    if (!position) {
+        throw new ProductError({
+            code: "RCORE24003",
+            status: "BLOCKED",
+            message: `NO_POSITION_TO_CLOSE: no non-zero position found for ${parsed.canonicalSymbol}.`
+        });
+    }
+    return {
+        positionReadback: {
+            ...position,
+            sym: stringField(position, "sym") ?? parsed.canonicalSymbol
+        }
+    };
+}
+function extractSymbolRules(response, symbol) {
+    const data = unwrapData(response);
+    const candidates = [
+        isRecord(data) ? data[symbol] : undefined,
+        isRecord(data) && isRecord(data.data) ? data.data[symbol] : undefined,
+        isRecord(data) && Array.isArray(data.list) ? data.list.find((item) => isRecord(item) && (item.sym === symbol || item.symbol === symbol)) : undefined,
+        data
+    ];
+    const record = candidates.find((item) => isSymbolRuleRecord(item, symbol));
+    if (!record) {
+        throw new ProductError({
+            code: "RCORE12001",
+            status: "BLOCKED",
+            message: `INVALID_SYMBOL: ${symbol} was not found in RapidX symbol-info.`
+        });
+    }
+    const rules = { symbol };
+    assignIfDefined(rules, "minNotional", stringField(record, "minNotional"));
+    assignIfDefined(rules, "minSize", stringField(record, "minSize") ?? stringField(record, "minQty") ?? stringField(record, "minOrderQty"));
+    assignIfDefined(rules, "lotSize", stringField(record, "lotSize") ?? stringField(record, "qtyStep") ?? stringField(record, "stepSize"));
+    assignIfDefined(rules, "qtyPrecision", stringField(record, "qtyPrecision") ?? stringField(record, "quantityPrecision"));
+    assignIfDefined(rules, "tickSize", stringField(record, "tickSize") ?? stringField(record, "priceTick") ?? stringField(record, "priceStep"));
+    assignIfDefined(rules, "pricePrecision", stringField(record, "pricePrecision"));
+    return rules;
+}
+function assignIfDefined(target, key, value) {
+    if (value !== undefined) {
+        target[key] = value;
+    }
+}
+function isSymbolRuleRecord(value, symbol) {
+    if (!isRecord(value) || Object.keys(value).length === 0) {
+        return false;
+    }
+    const recordSymbol = stringField(value, "sym") ?? stringField(value, "symbol");
+    if (recordSymbol !== undefined) {
+        return recordSymbol === symbol;
+    }
+    return [
+        "minNotional",
+        "minSize",
+        "minQty",
+        "minOrderQty",
+        "lotSize",
+        "qtyStep",
+        "stepSize",
+        "qtyPrecision",
+        "quantityPrecision",
+        "tickSize",
+        "priceTick",
+        "priceStep",
+        "pricePrecision"
+    ].some((field) => stringField(value, field) !== undefined);
+}
+function validateNotional(input, rules) {
+    const minNotional = positiveNumber(rules.minNotional);
+    if (minNotional === undefined) {
+        return;
+    }
+    const notional = estimateNotional(input);
+    if (notional !== undefined && notional < minNotional - 1e-12) {
+        throw new ProductError({
+            code: "RCORE24005",
+            status: "BLOCKED",
+            message: `MIN_NOTIONAL_NOT_MET: estimatedNotional ${formatNumber(notional)} is below minNotional ${rules.minNotional}.`
+        });
+    }
+}
+function validateQuantity(input, rules) {
+    const quantityValue = input.quantity ?? input.qty;
+    if (quantityValue === undefined || quantityValue === null || quantityValue === "") {
+        return;
+    }
+    const quantityText = String(quantityValue);
+    const quantity = positiveNumber(quantityText);
+    if (quantity === undefined) {
+        return;
+    }
+    const minSize = positiveNumber(rules.minSize);
+    if (minSize !== undefined && quantity < minSize - 1e-12) {
+        throw new ProductError({
+            code: "RCORE24006",
+            status: "BLOCKED",
+            message: `INVALID_QUANTITY: quantity ${quantityText} is below minSize ${rules.minSize}.`
+        });
+    }
+    const lotSize = positiveNumber(rules.lotSize);
+    if (lotSize !== undefined && !isAlignedToStep(quantity, lotSize)) {
+        throw new ProductError({
+            code: "RCORE24006",
+            status: "BLOCKED",
+            message: `INVALID_QUANTITY: quantity ${quantityText} is not aligned to lotSize ${rules.lotSize}.`
+        });
+    }
+    const qtyPrecision = integerValue(rules.qtyPrecision);
+    if (qtyPrecision !== undefined && decimalPlaces(quantityText) > qtyPrecision) {
+        throw new ProductError({
+            code: "RCORE24006",
+            status: "BLOCKED",
+            message: `INVALID_QUANTITY: quantity ${quantityText} exceeds qtyPrecision ${rules.qtyPrecision}.`
+        });
+    }
+}
+function validatePrice(input, rules) {
+    if (input.price === undefined || input.price === null || input.price === "") {
+        return;
+    }
+    const priceText = String(input.price);
+    const price = positiveNumber(priceText);
+    if (price === undefined) {
+        return;
+    }
+    const tickSize = positiveNumber(rules.tickSize);
+    if (tickSize !== undefined && !isAlignedToStep(price, tickSize)) {
+        throw new ProductError({
+            code: "RCORE24007",
+            status: "BLOCKED",
+            message: `INVALID_PRICE_TICK: price ${priceText} is not aligned to tickSize ${rules.tickSize}.`
+        });
+    }
+    const pricePrecision = integerValue(rules.pricePrecision);
+    if (pricePrecision !== undefined && decimalPlaces(priceText) > pricePrecision) {
+        throw new ProductError({
+            code: "RCORE24007",
+            status: "BLOCKED",
+            message: `INVALID_PRICE_TICK: price ${priceText} exceeds pricePrecision ${rules.pricePrecision}.`
+        });
+    }
+}
+function estimateNotional(input) {
+    const direct = positiveNumber(input.amount ?? input.notional);
+    if (direct !== undefined) {
+        return direct;
+    }
+    const price = positiveNumber(input.price);
+    const quantity = positiveNumber(input.quantity ?? input.qty);
+    if (price === undefined || quantity === undefined) {
+        return undefined;
+    }
+    return price * quantity;
+}
+function orderLookupParams(input) {
+    assertOrderLookupReference(input);
+    const params = compactObject({
+        orderId: input.orderId,
+        clientOrderId: input.clientOrderId,
+        symbol: input.symbol
+    });
+    return params;
+}
+function extractOrderReadback(response) {
+    const data = unwrapData(response);
+    if (isRecord(data) && Array.isArray(data.list)) {
+        return data.list.find(isRecord);
+    }
+    if (isRecord(data) && Array.isArray(data.orders)) {
+        return data.orders.find(isRecord);
+    }
+    return isRecord(data) && Object.keys(data).length > 0 ? data : undefined;
+}
+function extractPositions(response) {
+    const data = unwrapData(response);
+    if (Array.isArray(data)) {
+        return data.filter(isRecord);
+    }
+    if (isRecord(data) && Array.isArray(data.list)) {
+        return data.list.filter(isRecord);
+    }
+    if (isRecord(data) && Array.isArray(data.positions)) {
+        return data.positions.filter(isRecord);
+    }
+    return isRecord(data) ? [data] : [];
+}
+function unwrapData(response) {
+    if (isRecord(response) && "data" in response) {
+        return response.data;
+    }
+    return response;
+}
+function normalizeOrderState(value) {
+    return value === undefined || value === null ? "" : String(value).toUpperCase();
+}
+function isOpenOrderState(state) {
+    return ["NEW", "OPEN", "ACCEPTED", "PARTIALLY_FILLED"].includes(state);
+}
+function requiredString(value, field) {
+    if (value === undefined || value === null || value === "") {
+        throw new ProductError({
+            code: "RCORE00001",
+            status: "FAIL",
+            message: `${field} is required.`
+        });
+    }
+    return String(value);
+}
+function stringField(record, field) {
+    const value = record[field];
+    return value === undefined || value === null || value === "" ? undefined : String(value);
+}
+function positiveNumber(value) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : undefined;
+}
+function integerValue(value) {
+    if (value === undefined || value === null || value === "") {
+        return undefined;
+    }
+    const number = Number(value);
+    return Number.isInteger(number) && number >= 0 ? number : undefined;
+}
+function isAlignedToStep(value, step) {
+    const ratio = value / step;
+    return Math.abs(ratio - Math.round(ratio)) < 1e-9;
+}
+function decimalPlaces(value) {
+    const normalized = value.toLowerCase();
+    if (normalized.includes("e")) {
+        const [mantissa, exponentRaw] = normalized.split("e");
+        const exponent = Number(exponentRaw);
+        return Math.max(0, decimalPlaces(mantissa ?? "0") - exponent);
+    }
+    const [, fractional = ""] = normalized.split(".");
+    return fractional.replace(/0+$/, "").length;
+}
+function formatNumber(value) {
+    return Number.isInteger(value) ? String(value) : String(Number(value.toFixed(12)));
+}
+function compactObject(input) {
+    return Object.fromEntries(Object.entries(input).filter(([, value]) => value !== undefined && value !== null && value !== ""));
+}
+function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}