@usherlabs/cex-broker 0.2.9 → 0.2.11

package/dist/commands/cli.js

@@ -310995,6 +310995,45 @@ var CCXT_METHODS_WITH_VERITY = [
   "fetchWithdrawal",
   "fetchAccountId"
 ];
+var Action = {
+  NoAction: 0,
+  Deposit: 1,
+  Withdraw: 2,
+  CreateOrder: 3,
+  GetOrderDetails: 4,
+  CancelOrder: 5,
+  FetchBalances: 6,
+  FetchDepositAddresses: 7,
+  FetchTicker: 8,
+  FetchCurrency: 9,
+  Call: 10,
+  FetchAccountId: 11,
+  FetchFees: 12,
+  InternalTransfer: 13
+};
+var SubscriptionType = {
+  NO_ACTION: 0,
+  ORDERBOOK: 1,
+  TRADES: 2,
+  TICKER: 3,
+  OHLCV: 4,
+  BALANCE: 5,
+  ORDERS: 6
+};
+function createEnumNameMap(enumValues) {
+  return Object.fromEntries(Object.entries(enumValues).map(([name, value]) => [value, name]));
+}
+var actionNames = createEnumNameMap(Action);
+var subscriptionTypeNames = createEnumNameMap(SubscriptionType);
+function getActionName(action) {
+  return typeof action === "number" ? actionNames[action] ?? `unknown_${action}` : `unknown_${action ?? "undefined"}`;
+}
+function getSubscriptionTypeName(subscriptionType) {
+  return subscriptionTypeNames[subscriptionType] ?? `unknown_${subscriptionType}`;
+}
+function resolveSubscriptionType(type2) {
+  return type2 === undefined || type2 === SubscriptionType.NO_ACTION ? SubscriptionType.ORDERBOOK : type2;
+}
 
 // node_modules/@loglayer/plugin-opentelemetry/dist/index.mjs
 var import_api = __toESM(require_src5(), 1);
@@ -313495,16 +313534,18 @@ if (process.env.LOG_LEVEL !== "debug") {
 var log = baseLogger;
 
 // src/helpers/index.ts
-class WithdrawRoutingError extends Error {
-}
-
-class WithdrawRoutingUnavailableError extends WithdrawRoutingError {
-}
-function isMasterBrokerAccount(account) {
-  return account.label === "primary" || account.role === "master";
+class BrokerAccountPreconditionError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BrokerAccountPreconditionError";
+  }
 }
-function isSubaccountBrokerAccount(account) {
-  return !isMasterBrokerAccount(account);
+function requireDestinationEmail(dest, transferType) {
+  const email = dest.email?.trim();
+  if (!email) {
+    throw new BrokerAccountPreconditionError(`Destination account '${dest.label}' requires an email configured for ${transferType} transfers`);
+  }
+  return email;
 }
 function authenticateRequest(call, whitelistIps) {
   const clientIp = call.getPeer().split(":")[0];
@@ -313826,81 +313867,50 @@ function validateWithdraw(policy, exchange, network, recipientAddress, _amount,
   }
   return { valid: true };
 }
-function normalizeAccountSelector(selector2, metadata, defaultSelector) {
-  const raw = selector2?.trim().toLowerCase() ?? defaultSelector;
-  if (raw === "current") {
-    return getCurrentBrokerSelector(metadata);
-  }
-  if (raw === "primary") {
-    return "primary";
-  }
-  const secondaryMatch = raw.match(/^secondary:(\d+)$/);
-  if (secondaryMatch) {
-    return `secondary:${secondaryMatch[1]}`;
-  }
-  throw new WithdrawRoutingError(`Invalid account selector "${selector2}"`);
-}
-async function transferBinanceSubAccountToMaster(source, code, amount) {
+async function transferBinanceInternal(source, dest, code, amount) {
   const exchange = source.exchange;
-  if (typeof exchange.sapiPostSubAccountTransferSubToMaster !== "function") {
-    throw new WithdrawRoutingUnavailableError("Binance sub-account to master transfer is unavailable in this CCXT build");
-  }
   await source.exchange.loadMarkets();
   const currency = source.exchange.currency(code);
-  return await exchange.sapiPostSubAccountTransferSubToMaster({
-    asset: currency.id,
-    amount: source.exchange.currencyToPrecision(code, amount)
-  });
-}
-async function executeWithdrawWithRouting(args) {
-  const {
-    cex: cex3,
-    brokers,
-    metadata,
-    selectedBroker,
-    code,
-    amount,
-    recipientAddress,
-    network,
-    params,
-    routeViaMaster,
-    sourceAccount,
-    masterAccount
-  } = args;
-  const withdrawParams = {
-    ...params ?? {},
-    network
-  };
-  if (!routeViaMaster) {
-    return await selectedBroker.withdraw(code, amount, recipientAddress, undefined, withdrawParams);
-  }
-  const sourceSelector = normalizeAccountSelector(sourceAccount, metadata, "current");
-  const masterSelector = normalizeAccountSelector(masterAccount, metadata, "primary");
-  if (!brokers) {
-    throw new WithdrawRoutingUnavailableError("Routed withdraw requires configured broker accounts");
-  }
-  const source = resolveBrokerAccount(brokers, sourceSelector);
-  if (!source) {
-    throw new WithdrawRoutingError(`Source account ${sourceSelector} is not configured`);
-  }
-  const master = resolveBrokerAccount(brokers, masterSelector);
-  if (!master) {
-    throw new WithdrawRoutingError(`Master account ${masterSelector} is not configured`);
-  }
-  if (!isMasterBrokerAccount(master)) {
-    throw new WithdrawRoutingError(`Master account ${masterSelector} must resolve to the primary/master account`);
-  }
-  if (source.label === master.label) {
-    return await master.exchange.withdraw(code, amount, recipientAddress, undefined, withdrawParams);
+  const asset = currency.id;
+  const amountStr = source.exchange.currencyToPrecision(code, amount);
+  const isSourceSecondary = source.label.startsWith("secondary:");
+  const isDestPrimary = dest.label === "primary";
+  const isDestSecondary = dest.label.startsWith("secondary:");
+  const isSourcePrimary = source.label === "primary";
+  if (isSourceSecondary && isDestPrimary) {
+    if (typeof exchange.sapiPostSubAccountTransferSubToMaster !== "function") {
+      throw new Error("Binance sub→master transfer is unavailable in this CCXT build");
+    }
+    return await exchange.sapiPostSubAccountTransferSubToMaster({
+      asset,
+      amount: amountStr
+    });
   }
-  if (!isSubaccountBrokerAccount(source)) {
-    throw new WithdrawRoutingError(`Source account ${sourceSelector} must resolve to a subaccount when routeViaMaster is enabled`);
+  if (isSourceSecondary && isDestSecondary) {
+    if (typeof exchange.sapiPostSubAccountTransferSubToSub !== "function") {
+      throw new Error("Binance sub→sub transfer is unavailable in this CCXT build");
+    }
+    const destEmail = requireDestinationEmail(dest, "sub-to-sub");
+    return await exchange.sapiPostSubAccountTransferSubToSub({
+      toEmail: destEmail,
+      asset,
+      amount: amountStr
+    });
   }
-  if (cex3.trim().toLowerCase() !== "binance") {
-    throw new WithdrawRoutingUnavailableError(`Withdraw routing via master is not supported for ${cex3}`);
+  if (isSourcePrimary && isDestSecondary) {
+    if (typeof exchange.sapiPostSubAccountUniversalTransfer !== "function") {
+      throw new Error("Binance universal transfer is unavailable in this CCXT build");
+    }
+    const destEmail = requireDestinationEmail(dest, "primary-to-sub");
+    return await exchange.sapiPostSubAccountUniversalTransfer({
+      fromAccountType: "SPOT",
+      toAccountType: "SPOT",
+      toEmail: destEmail,
+      asset,
+      amount: amountStr
+    });
   }
-  await transferBinanceSubAccountToMaster(source, code, amount);
-  return await master.exchange.withdraw(code, amount, recipientAddress, undefined, withdrawParams);
+  throw new Error(`Unsupported transfer direction: ${source.label} → ${dest.label}`);
 }
 function isMarketPatternMatch(pattern, broker, fromToken, toToken) {
   const normalizedPattern = pattern.toUpperCase().trim();
@@ -314368,160 +314378,8 @@ function createOtelLogsFromEnv() {
 // src/server.ts
 var grpc = __toESM(require_src3(), 1);
 var protoLoader = __toESM(require_src2(), 1);
-
-// src/proto/cex_broker/Action.ts
-var Action = {
-  NoAction: 0,
-  Deposit: 1,
-  Withdraw: 2,
-  CreateOrder: 3,
-  GetOrderDetails: 4,
-  CancelOrder: 5,
-  FetchBalances: 6,
-  FetchDepositAddresses: 7,
-  FetchTicker: 8,
-  FetchCurrency: 9,
-  Call: 10,
-  FetchAccountId: 11,
-  FetchFees: 12
-};
-
-// src/proto/cex_broker/SubscriptionType.ts
-var SubscriptionType = {
-  NO_ACTION: 0,
-  ORDERBOOK: 1,
-  TRADES: 2,
-  TICKER: 3,
-  OHLCV: 4,
-  BALANCE: 5,
-  ORDERS: 6
-};
-
-// src/proto/node.descriptor.ts
-var descriptor = {
-  nested: {
-    cex_broker: {
-      nested: {
-        ActionRequest: {
-          fields: {
-            action: {
-              type: "Action",
-              id: 1
-            },
-            payload: {
-              keyType: "string",
-              type: "string",
-              id: 2
-            },
-            cex: {
-              type: "string",
-              id: 3
-            },
-            symbol: {
-              type: "string",
-              id: 4
-            }
-          }
-        },
-        ActionResponse: {
-          fields: {
-            result: {
-              type: "string",
-              id: 1
-            },
-            proof: {
-              type: "string",
-              id: 2
-            }
-          }
-        },
-        SubscribeRequest: {
-          fields: {
-            cex: {
-              type: "string",
-              id: 1
-            },
-            symbol: {
-              type: "string",
-              id: 2
-            },
-            type: {
-              type: "SubscriptionType",
-              id: 3
-            },
-            options: {
-              keyType: "string",
-              type: "string",
-              id: 4
-            }
-          }
-        },
-        SubscribeResponse: {
-          fields: {
-            data: {
-              type: "string",
-              id: 1
-            },
-            timestamp: {
-              type: "int64",
-              id: 2
-            },
-            symbol: {
-              type: "string",
-              id: 3
-            },
-            type: {
-              type: "SubscriptionType",
-              id: 4
-            }
-          }
-        },
-        SubscriptionType: {
-          values: {
-            NO_ACTION: 0,
-            ORDERBOOK: 1,
-            TRADES: 2,
-            TICKER: 3,
-            OHLCV: 4,
-            BALANCE: 5,
-            ORDERS: 6
-          }
-        },
-        cex_service: {
-          methods: {
-            ExecuteAction: {
-              requestType: "ActionRequest",
-              responseType: "ActionResponse"
-            },
-            Subscribe: {
-              requestType: "SubscribeRequest",
-              responseType: "SubscribeResponse",
-              responseStream: true
-            }
-          }
-        },
-        Action: {
-          values: {
-            NoAction: 0,
-            Deposit: 1,
-            Withdraw: 2,
-            CreateOrder: 3,
-            GetOrderDetails: 4,
-            CancelOrder: 5,
-            FetchBalances: 6,
-            FetchDepositAddresses: 7,
-            FetchTicker: 8,
-            FetchCurrency: 9,
-            Call: 10,
-            FetchAccountId: 11,
-            FetchFees: 12
-          }
-        }
-      }
-    }
-  }
-};
-var node_descriptor_default = descriptor;
+import path from "path";
+import { fileURLToPath } from "url";
 
 // node_modules/zod/v4/classic/external.js
 var exports_external = {};
@@ -315464,9 +315322,9 @@ function createTransparentProxy(getter) {
       target ?? (target = getter());
       return Reflect.getOwnPropertyDescriptor(target, prop3);
     },
-    defineProperty(_, prop3, descriptor2) {
+    defineProperty(_, prop3, descriptor) {
       target ?? (target = getter());
-      return Reflect.defineProperty(target, prop3, descriptor2);
+      return Reflect.defineProperty(target, prop3, descriptor);
     }
   });
 }
@@ -328100,11 +327958,13 @@ var WithdrawPayloadSchema = exports_external.object({
   recipientAddress: exports_external.string().min(1),
   amount: exports_external.coerce.number().positive(),
   chain: exports_external.string().min(1),
-  routeViaMaster: booleanLikeSchema.optional().default(false),
-  sourceAccount: exports_external.string().min(1).optional(),
-  masterAccount: exports_external.string().min(1).optional(),
   params: exports_external.preprocess(parseJsonString, stringNumberRecordSchema).default({})
 });
+var InternalTransferPayloadSchema = exports_external.object({
+  amount: exports_external.coerce.number().positive(),
+  fromAccount: exports_external.string().min(1).optional(),
+  toAccount: exports_external.string().min(1).optional()
+});
 var CreateOrderPayloadSchema = exports_external.object({
   orderType: exports_external.enum(["market", "limit"]).default("limit"),
   amount: exports_external.coerce.number().positive(),
@@ -328127,7 +327987,15 @@ var FetchFeesPayloadSchema = exports_external.object({
 });
 
 // src/server.ts
-var packageDef = protoLoader.fromJSON(node_descriptor_default);
+var __filename2 = fileURLToPath(import.meta.url);
+var __dirname2 = path.dirname(__filename2);
+var protoPath = path.join(__dirname2, "proto", "node.proto");
+var packageDef = protoLoader.loadSync(protoPath, {
+  keepCase: true,
+  longs: String,
+  defaults: true,
+  oneofs: true
+});
 var grpcObj = grpc.loadPackageDefinition(packageDef);
 var cexNode = grpcObj.cex_broker;
 function parsePayload(schema, rawPayload) {
@@ -328136,10 +328004,10 @@ function parsePayload(schema, rawPayload) {
     return { success: true, data: parsed.data };
   }
   const firstIssue = parsed.error.issues[0];
-  const path = firstIssue && firstIssue.path.length > 0 ? `${firstIssue.path.join(".")}: ` : "";
+  const path2 = firstIssue && firstIssue.path.length > 0 ? `${firstIssue.path.join(".")}: ` : "";
   return {
     success: false,
-    message: `ValidationError: ${path}${firstIssue?.message ?? "Invalid payload"}`
+    message: `ValidationError: ${path2}${firstIssue?.message ?? "Invalid payload"}`
   };
 }
 function getErrorMessage(error48) {
@@ -328152,6 +328020,31 @@ function safeLogError(context2, error48) {
     console.error(context2, error48);
   }
 }
+function mapCcxtErrorToGrpcStatus(error48) {
+  if (error48 instanceof ccxt_default.AuthenticationError)
+    return grpc.status.UNAUTHENTICATED;
+  if (error48 instanceof ccxt_default.PermissionDenied)
+    return grpc.status.PERMISSION_DENIED;
+  if (error48 instanceof ccxt_default.InsufficientFunds)
+    return grpc.status.FAILED_PRECONDITION;
+  if (error48 instanceof ccxt_default.InvalidAddress)
+    return grpc.status.INVALID_ARGUMENT;
+  if (error48 instanceof ccxt_default.BadSymbol)
+    return grpc.status.NOT_FOUND;
+  if (error48 instanceof ccxt_default.BadRequest)
+    return grpc.status.INVALID_ARGUMENT;
+  if (error48 instanceof ccxt_default.NotSupported)
+    return grpc.status.UNIMPLEMENTED;
+  if (error48 instanceof ccxt_default.RateLimitExceeded)
+    return grpc.status.RESOURCE_EXHAUSTED;
+  if (error48 instanceof ccxt_default.OnMaintenance)
+    return grpc.status.UNAVAILABLE;
+  if (error48 instanceof ccxt_default.ExchangeNotAvailable)
+    return grpc.status.UNAVAILABLE;
+  if (error48 instanceof ccxt_default.NetworkError)
+    return grpc.status.UNAVAILABLE;
+  return;
+}
 function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, otelMetrics) {
   const server = new grpc.Server;
   server.addService(cexNode.cex_service.service, {
@@ -328163,7 +328056,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
         if (!actionCompleted) {
           actionCompleted = true;
           const latency = Date.now() - startTime;
-          const actionName = action !== undefined && action in Action ? Action[action] : `unknown_${action ?? "undefined"}`;
+          const actionName = getActionName(action);
           otelMetrics?.recordHistogram("execute_action_duration_ms", latency, {
             action: actionName,
             cex: cex3 || "unknown"
@@ -328189,7 +328082,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
           cex: cex3,
           symbol: symbol2
         });
-        const actionName = action !== undefined && action in Action ? Action[action] : `unknown_${action ?? "undefined"}`;
+        const actionName = getActionName(action);
         otelMetrics?.recordCounter("execute_action_requests_total", 1, {
           action: actionName,
           cex: cex3 || "unknown"
@@ -328207,7 +328100,8 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
             message: "`action` AND `cex` fields are required"
           }, null);
         }
-        const broker = selectBroker(brokers[cex3], metadata) ?? createBroker(cex3, metadata);
+        const normalizedCex = cex3.trim().toLowerCase();
+        const broker = selectBroker(brokers[normalizedCex], metadata) ?? createBroker(normalizedCex, metadata);
         if (!broker) {
           return wrappedCallback({
             code: grpc.status.UNAUTHENTICATED,
@@ -328545,39 +328439,10 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
               }, null);
             }
             try {
-              let transaction;
-              try {
-                transaction = await executeWithdrawWithRouting({
-                  cex: cex3,
-                  brokers: brokers[cex3],
-                  metadata,
-                  selectedBroker: broker,
-                  code: symbol2,
-                  amount: transferValue.amount,
-                  recipientAddress: transferValue.recipientAddress,
-                  network: transferValue.chain,
-                  params: transferValue.params,
-                  routeViaMaster: transferValue.routeViaMaster,
-                  sourceAccount: transferValue.sourceAccount,
-                  masterAccount: transferValue.masterAccount
-                });
-              } catch (error48) {
-                if (error48 instanceof WithdrawRoutingUnavailableError) {
-                  log.warn("Withdraw routing unavailable, falling back", {
-                    cex: cex3,
-                    error: error48.message
-                  });
-                  if (transferValue.routeViaMaster) {
-                    throw error48;
-                  }
-                  transaction = await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
-                    ...transferValue.params ?? {},
-                    network: transferValue.chain
-                  });
-                } else {
-                  throw error48;
-                }
-              }
+              const transaction = await broker.withdraw(symbol2, transferValue.amount, transferValue.recipientAddress, undefined, {
+                ...transferValue.params ?? {},
+                network: transferValue.chain
+              });
               log.info(`Withdraw Result: ${JSON.stringify(transaction)}`);
               wrappedCallback(null, {
                 proof: verityProof,
@@ -328585,10 +328450,10 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
               });
             } catch (error48) {
               safeLogError("Withdraw failed", error48);
-              const message = error48 instanceof WithdrawRoutingError ? error48.message : getErrorMessage(error48);
+              const code = mapCcxtErrorToGrpcStatus(error48) ?? grpc.status.INTERNAL;
               wrappedCallback({
-                code: error48 instanceof WithdrawRoutingError ? grpc.status.INVALID_ARGUMENT : grpc.status.INTERNAL,
-                message: `Withdraw failed: ${message}`
+                code,
+                message: `Withdraw failed: ${getErrorMessage(error48)}`
               }, null);
             }
             break;
@@ -328761,6 +328626,86 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
               }, null);
             }
             break;
+          case Action.InternalTransfer: {
+            if (!symbol2) {
+              return wrappedCallback({
+                code: grpc.status.INVALID_ARGUMENT,
+                message: `ValidationError: Symbol required`
+              }, null);
+            }
+            const parsedPayload = parsePayload(InternalTransferPayloadSchema, call.request.payload);
+            if (!parsedPayload.success) {
+              return wrappedCallback({
+                code: grpc.status.INVALID_ARGUMENT,
+                message: parsedPayload.message
+              }, null);
+            }
+            const transferPayload = parsedPayload.data;
+            if (normalizedCex !== "binance") {
+              return wrappedCallback({
+                code: grpc.status.UNIMPLEMENTED,
+                message: `InternalTransfer is only supported for Binance`
+              }, null);
+            }
+            const pool = brokers[normalizedCex];
+            if (!pool) {
+              return wrappedCallback({
+                code: grpc.status.FAILED_PRECONDITION,
+                message: `No broker accounts configured for ${normalizedCex}`
+              }, null);
+            }
+            const fromSelector = transferPayload.fromAccount ?? getCurrentBrokerSelector(metadata);
+            const toSelector = transferPayload.toAccount ?? "primary";
+            const sourceAccount = resolveBrokerAccount(pool, fromSelector);
+            if (!sourceAccount) {
+              return wrappedCallback({
+                code: grpc.status.INVALID_ARGUMENT,
+                message: `Source account "${fromSelector}" is not configured`
+              }, null);
+            }
+            const destAccount = resolveBrokerAccount(pool, toSelector);
+            if (!destAccount) {
+              return wrappedCallback({
+                code: grpc.status.INVALID_ARGUMENT,
+                message: `Destination account "${toSelector}" is not configured`
+              }, null);
+            }
+            try {
+              if (useVerity) {
+                sourceAccount.exchange.setHttpClientOverride(buildHttpClientOverrideFromMetadata(metadata, verityProverUrl, (proof, notaryPubKey) => {
+                  verityProof = proof;
+                  log.debug(`Verity proof:`, { proof, notaryPubKey });
+                }), verityHttpClientOverridePredicate);
+              }
+              const result = await transferBinanceInternal(sourceAccount, destAccount, symbol2, transferPayload.amount);
+              wrappedCallback(null, {
+                proof: verityProof,
+                result: JSON.stringify(result)
+              });
+            } catch (error48) {
+              safeLogError("InternalTransfer failed", error48);
+              if (error48 instanceof BrokerAccountPreconditionError) {
+                return wrappedCallback({
+                  code: grpc.status.FAILED_PRECONDITION,
+                  message: getErrorMessage(error48)
+                }, null);
+              }
+              const msg = getErrorMessage(error48);
+              let code;
+              if (msg.includes("Unsupported transfer direction")) {
+                code = grpc.status.INVALID_ARGUMENT;
+              } else if (msg.includes("unavailable in this CCXT build")) {
+                code = grpc.status.UNIMPLEMENTED;
+              } else {
+                code = mapCcxtErrorToGrpcStatus(error48) ?? grpc.status.INTERNAL;
+              }
+              wrappedCallback({
+                code,
+                message: `InternalTransfer failed: ${msg}`
+              }, null);
+            }
+            break;
+          }
           default:
             return wrappedCallback({
               code: grpc.status.INVALID_ARGUMENT,
@@ -328793,20 +328738,13 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
       try {
         const request = call.request;
         const { cex: cex3, symbol: symbol2, type: type2, options } = request;
-        const subscriptionType = type2 !== undefined ? type2 : SubscriptionType.ORDERBOOK;
+        const subscriptionType = resolveSubscriptionType(type2);
         log.info(`Request - Subscribe:`, {
           cex: request.cex,
           symbol: request.symbol,
           type: subscriptionType
         });
-        const subscriptionTypeName = (() => {
-          for (const [key, value] of Object.entries(SubscriptionType)) {
-            if (value === subscriptionType && Number.isNaN(Number(key))) {
-              return key;
-            }
-          }
-          return `unknown_${subscriptionType}`;
-        })();
+        const subscriptionTypeName = getSubscriptionTypeName(subscriptionType);
         otelMetrics?.recordCounter("subscribe_requests_total", 1, {
           cex: cex3 || "unknown",
           symbol: symbol2 || "unknown",
@@ -328894,7 +328832,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
                   data: JSON.stringify(ticker),
                   timestamp: Date.now(),
                   symbol: symbol2,
-                  type: type2
+                  type: subscriptionType
                 });
               }
             } catch (error48) {
@@ -328919,7 +328857,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
                   data: JSON.stringify(ohlcv),
                   timestamp: Date.now(),
                   symbol: symbol2,
-                  type: type2
+                  type: subscriptionType
                 });
               }
             } catch (error48) {
@@ -328943,7 +328881,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
                   data: JSON.stringify(balance),
                   timestamp: Date.now(),
                   symbol: symbol2,
-                  type: type2
+                  type: subscriptionType
                 });
               }
             } catch (error48) {
@@ -328967,7 +328905,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
                   data: JSON.stringify(orders),
                   timestamp: Date.now(),
                   symbol: symbol2,
-                  type: type2
+                  type: subscriptionType
                 });
               }
             } catch (error48) {
@@ -328988,7 +328926,7 @@ function getServer(policy, brokers, whitelistIps, useVerity, verityProverUrl, ot
               data: JSON.stringify({ error: "Invalid subscription type" }),
               timestamp: Date.now(),
               symbol: symbol2,
-              type: type2
+              type: subscriptionType
             });
         }
       } catch (error48) {