@usherlabs/cex-broker 0.2.9 → 0.2.10

package/dist/index.js

@@ -272748,16 +272748,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];
@@ -273079,81 +273081,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\u2192master 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\u2192sub 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} \u2192 ${dest.label}`);
 }
 function isMarketPatternMatch(pattern, broker, fromToken, toToken) {
   const normalizedPattern = pattern.toUpperCase().trim();
@@ -277336,7 +277307,8 @@ var Action = {
   FetchCurrency: 9,
   Call: 10,
   FetchAccountId: 11,
-  FetchFees: 12
+  FetchFees: 12,
+  InternalTransfer: 13
 };
 
 // src/proto/cex_broker/SubscriptionType.ts
@@ -277467,7 +277439,8 @@ var descriptor = {
             FetchCurrency: 9,
             Call: 10,
             FetchAccountId: 11,
-            FetchFees: 12
+            FetchFees: 12,
+            InternalTransfer: 13
           }
         }
       }
@@ -291053,11 +291026,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(),
@@ -291105,6 +291080,31 @@ function safeLogError(context3, error48) {
     console.error(context3, 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, {
@@ -291160,7 +291160,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,
@@ -291498,39 +291499,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,
@@ -291538,10 +291510,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;
@@ -291714,6 +291686,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,
@@ -292272,4 +292324,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=D692BFF7F06F00CD64756E2164756E21
+//# debugId=AC580D825044D41564756E2164756E21