@usherlabs/cex-broker 0.2.16 → 0.2.17

package/dist/index.js

@@ -78926,7 +78926,7 @@ class binance extends binance_default {
       }
       if (api === "sapi" && path === "asset/dust") {
         query = this.urlencodeWithArrayRepeat(extendedParams);
-      } else if (path === "batchOrders" || path.indexOf("sub-account") >= 0 || path === "capital/withdraw/apply" || path === "localentity/withdraw/apply" || path.indexOf("staking") >= 0 || path.indexOf("simple-earn") >= 0) {
+      } else if (path === "batchOrders" || path.indexOf("sub-account") >= 0 || path === "capital/withdraw/apply" || path === "localentity/withdraw/apply" || path === "localentity/deposit/provide-info" || path.indexOf("staking") >= 0 || path.indexOf("simple-earn") >= 0) {
         if (method === "DELETE" && path === "batchOrders") {
           const orderidlist = this.safeList(extendedParams, "orderidlist", []);
           const origclientorderidlist = this.safeList(extendedParams, "origclientorderidlist", []);
@@ -272836,6 +272836,40 @@ function registerBinanceTravelRuleWithdrawEndpoint(exchange) {
   }
   exchange.defineRestApi({ sapi: { post: { "localentity/withdraw/apply": 4.0002 } } }, "request");
 }
+var australiaDepositQuestionnaireSchema = import_joi.default.object({
+  depositOriginator: import_joi.default.number().valid(1).required(),
+  receiveFrom: import_joi.default.number().valid(1).required(),
+  declaration: import_joi.default.boolean().valid(true).required()
+});
+function getEnabledTravelRuleDepositConfig(policy, exchange) {
+  const rules = policy.travelRule?.rule ?? [];
+  const exchangeNorm = exchange.trim().toUpperCase();
+  const entry = rules.find((rule) => rule.exchange.trim().toUpperCase() === exchangeNorm);
+  const deposits = entry?.deposits;
+  if (!deposits || !deposits.enabled) {
+    return null;
+  }
+  return deposits;
+}
+function resolveDepositOriginatorQuestionnaire(config, senderAddress) {
+  const senderNorm = senderAddress.trim().toLowerCase();
+  const match = Object.entries(config.originators).find(([address]) => address.trim().toLowerCase() === senderNorm);
+  return match ? match[1].questionnaire : null;
+}
+function registerBinanceTravelRuleDepositEndpoints(exchange) {
+  if (exchange.id !== "binance") {
+    return;
+  }
+  exchange.defineRestApi({
+    sapi: {
+      get: {
+        "localentity/deposit/history": 1,
+        "localentity/questionnaire-requirements": 1
+      },
+      put: { "localentity/deposit/provide-info": 4.0002 }
+    }
+  }, "request");
+}
 async function withdrawViaLocalEntity(broker, args) {
   const exchange = broker;
   if (typeof exchange.sapiPostLocalentityWithdrawApply !== "function") {
@@ -272884,6 +272918,7 @@ function applyCommonExchangeConfig(exchange) {
     adjustForTimeDifference: true
   });
   registerBinanceTravelRuleWithdrawEndpoint(exchange);
+  registerBinanceTravelRuleDepositEndpoints(exchange);
 }
 function createBroker(cex3, credsOrMetadata) {
   let apiKey;
@@ -273189,6 +273224,538 @@ function authenticateRequest(call, whitelistIps) {
   }
   return true;
 }
+// src/helpers/deposit.ts
+function depositField(deposit, fields) {
+  for (const field of fields) {
+    const value = deposit[field];
+    if (value !== undefined && value !== null && String(value).length > 0) {
+      return value;
+    }
+  }
+  return;
+}
+function normalizeDepositStatus(status) {
+  const normalized = String(status ?? "").trim().toLowerCase();
+  if (["ok", "credited", "complete", "completed", "success"].includes(normalized)) {
+    return "credited";
+  }
+  if (["failed", "failure", "canceled", "cancelled", "rejected"].includes(normalized)) {
+    return "failed";
+  }
+  if (["timeout", "timed_out", "timedout", "expired"].includes(normalized)) {
+    return "timed_out";
+  }
+  if (["pending", "processing", "confirming", "waiting"].includes(normalized)) {
+    return "pending";
+  }
+  return "pending";
+}
+function depositMatchesTransaction(deposit, transactionHash) {
+  const candidates = [
+    depositField(deposit, [
+      "txid",
+      "txId",
+      "tx_hash",
+      "txHash",
+      "transactionHash"
+    ]),
+    depositField(deposit, ["id"])
+  ];
+  return candidates.some((candidate) => String(candidate) === transactionHash);
+}
+function stringAmountEquals(left, right) {
+  const leftNum = Number(left);
+  const rightNum = Number(right);
+  if (Number.isFinite(leftNum) && Number.isFinite(rightNum)) {
+    return Math.abs(leftNum - rightNum) < 0.000000000001;
+  }
+  return String(left) === String(right);
+}
+function normalizeAddress(value) {
+  if (value === undefined || value === null) {
+    return;
+  }
+  return String(value).trim().toLowerCase();
+}
+
+// src/helpers/travel-rule-deposit-reconciler.ts
+function toBool(value) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "number")
+    return value !== 0;
+  if (typeof value === "string")
+    return value.trim().toLowerCase() === "true";
+  return false;
+}
+function parseLocalEntityDeposit(raw) {
+  const tranId = depositField(raw, ["tranId"]);
+  if (tranId === undefined)
+    return null;
+  return {
+    tranId: String(tranId),
+    coin: String(depositField(raw, ["coin", "asset"]) ?? ""),
+    amount: String(depositField(raw, ["amount"]) ?? ""),
+    network: String(depositField(raw, ["network"]) ?? ""),
+    txId: String(depositField(raw, ["txId", "txid", "tx_hash", "txHash"]) ?? ""),
+    travelRuleStatus: String(depositField(raw, ["travelRuleStatusV2", "travelRuleStatus"]) ?? "").trim().toUpperCase(),
+    requireQuestionnaire: toBool(raw.requireQuestionnaire ?? raw.requireQuestionnaireV2),
+    raw
+  };
+}
+var EVM_TX_HASH = /^0x[0-9a-fA-F]{64}$/;
+async function resolveOnChainSender(rpcUrl, txHash, timeoutMs = 1e4) {
+  if (!EVM_TX_HASH.test(txHash))
+    return null;
+  const controller = new AbortController;
+  const timeout2 = setTimeout(() => controller.abort(), timeoutMs);
+  let response;
+  try {
+    response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      signal: controller.signal,
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        id: 1,
+        method: "eth_getTransactionByHash",
+        params: [txHash]
+      })
+    });
+  } finally {
+    clearTimeout(timeout2);
+  }
+  if (!response.ok) {
+    throw new Error(`travel_rule_rpc_http_${response.status}`);
+  }
+  const json3 = await response.json();
+  if (json3.error) {
+    throw new Error(`travel_rule_rpc_error: ${JSON.stringify(json3.error)}`);
+  }
+  const from = json3.result?.from;
+  return typeof from === "string" && from.length > 0 ? from.toLowerCase() : null;
+}
+function errorText(error) {
+  if (error instanceof Error)
+    return error.message;
+  if (typeof error === "string")
+    return error;
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return String(error);
+  }
+}
+function isRateLimitError(error) {
+  const text = errorText(error).toLowerCase();
+  return text.includes("-1003") || text.includes("too many requests") || text.includes("429") || text.includes("ddosprotection") || text.includes("ratelimitexceeded");
+}
+function isAlreadyProvidedError(error) {
+  const text = errorText(error).toLowerCase();
+  return text.includes("already") && (text.includes("provided") || text.includes("processed") || text.includes("passed") || text.includes("submit"));
+}
+function isAcceptedResponse(response) {
+  return response.accepted !== false;
+}
+function createAccountState() {
+  return {
+    submittedTranIds: new Set,
+    surfacedFailed: new Set,
+    backoffUntil: new Map,
+    rateLimitedUntil: 0
+  };
+}
+function isInBackoff(state, tranId, now3) {
+  const until = state.backoffUntil.get(tranId);
+  return until !== undefined && now3 < until;
+}
+async function reconcileAccountOnce(deps) {
+  const { state, now: now3, accountLabel } = deps;
+  const outcomes = [];
+  if (now3 < state.rateLimitedUntil) {
+    return {
+      accountLabel,
+      frozenDeposits: [],
+      outcomes,
+      hadActionableWork: false
+    };
+  }
+  let rawDeposits;
+  try {
+    rawDeposits = await deps.fetchDepositHistory();
+  } catch (error) {
+    if (isRateLimitError(error)) {
+      state.rateLimitedUntil = now3 + deps.rateLimitCooldownMs;
+    }
+    return {
+      accountLabel,
+      frozenDeposits: [],
+      outcomes: [{ kind: "poll-error", error: errorText(error) }],
+      hadActionableWork: false
+    };
+  }
+  const deposits = rawDeposits.map(parseLocalEntityDeposit).filter((d) => d !== null);
+  const frozen = deposits.filter((d) => d.requireQuestionnaire && d.travelRuleStatus === "PENDING");
+  for (const deposit of deposits) {
+    if (deposit.travelRuleStatus === "FAILED" && !state.surfacedFailed.has(deposit.tranId)) {
+      state.surfacedFailed.add(deposit.tranId);
+      outcomes.push({ kind: "failed-terminal", deposit });
+    }
+  }
+  const candidates = frozen.filter((d) => !state.submittedTranIds.has(d.tranId) && !isInBackoff(state, d.tranId, now3));
+  if (candidates.length === 0) {
+    return {
+      accountLabel,
+      frozenDeposits: frozen,
+      outcomes,
+      hadActionableWork: false
+    };
+  }
+  let country = null;
+  try {
+    country = await deps.fetchQuestionnaireCountry();
+  } catch (error) {
+    if (isRateLimitError(error)) {
+      state.rateLimitedUntil = now3 + deps.rateLimitCooldownMs;
+    }
+    country = null;
+  }
+  if (country !== deps.expectedCountry) {
+    for (const deposit of candidates) {
+      outcomes.push({ kind: "entity-drift", deposit, country });
+    }
+    return {
+      accountLabel,
+      frozenDeposits: frozen,
+      outcomes,
+      hadActionableWork: true
+    };
+  }
+  for (const deposit of candidates) {
+    if (now3 < state.rateLimitedUntil)
+      break;
+    let sender = null;
+    try {
+      sender = await deps.resolveSender(deposit.network, deposit.txId);
+    } catch (error) {
+      sender = null;
+      if (isRateLimitError(error)) {
+        state.rateLimitedUntil = now3 + deps.rateLimitCooldownMs;
+      }
+    }
+    if (!sender) {
+      state.backoffUntil.set(deposit.tranId, now3 + deps.failureBackoffMs);
+      outcomes.push({ kind: "unproven-origin", deposit });
+      continue;
+    }
+    const questionnaire = deps.resolveQuestionnaire(deps.depositConfig, sender);
+    if (!questionnaire) {
+      state.backoffUntil.set(deposit.tranId, now3 + deps.failureBackoffMs);
+      outcomes.push({ kind: "undeclared-origin", deposit, sender });
+      continue;
+    }
+    try {
+      const response = await deps.submitProvideInfo(deposit.tranId, questionnaire);
+      if (isAcceptedResponse(response)) {
+        state.submittedTranIds.add(deposit.tranId);
+        state.backoffUntil.delete(deposit.tranId);
+        outcomes.push({ kind: "submitted", deposit, sender });
+      } else {
+        state.backoffUntil.set(deposit.tranId, now3 + deps.failureBackoffMs);
+        outcomes.push({
+          kind: "submit-error",
+          deposit,
+          error: JSON.stringify(response)
+        });
+      }
+    } catch (error) {
+      if (isAlreadyProvidedError(error)) {
+        state.submittedTranIds.add(deposit.tranId);
+        state.backoffUntil.delete(deposit.tranId);
+        outcomes.push({ kind: "already-provided", deposit, sender });
+      } else {
+        if (isRateLimitError(error)) {
+          state.rateLimitedUntil = now3 + deps.rateLimitCooldownMs;
+        }
+        state.backoffUntil.set(deposit.tranId, now3 + deps.failureBackoffMs);
+        outcomes.push({
+          kind: "submit-error",
+          deposit,
+          error: errorText(error)
+        });
+      }
+    }
+  }
+  return {
+    accountLabel,
+    frozenDeposits: frozen,
+    outcomes,
+    hadActionableWork: true
+  };
+}
+var DEFAULTS = {
+  pollIntervalActiveMs: 60000,
+  pollIntervalIdleMs: 600000,
+  expectedQuestionnaireCountry: "AU",
+  failureBackoffMs: 15 * 60000,
+  rateLimitCooldownMs: 5 * 60000
+};
+function envSecondsToMs(env, key, fallbackMs) {
+  const raw = env[key];
+  if (raw === undefined)
+    return fallbackMs;
+  const secs = Number(raw);
+  return Number.isFinite(secs) && secs > 0 ? secs * 1000 : fallbackMs;
+}
+function loadTravelRuleDepositReconcilerConfigFromEnv(env) {
+  const rpcUrlsByNetwork = {};
+  const prefix = "TRAVEL_RULE_RPC_URL_";
+  for (const [key, value] of Object.entries(env)) {
+    if (key.startsWith(prefix) && value) {
+      rpcUrlsByNetwork[key.slice(prefix.length).toUpperCase()] = value;
+    }
+  }
+  return {
+    rpcUrlsByNetwork,
+    pollIntervalActiveMs: envSecondsToMs(env, "TRAVEL_RULE_DEPOSIT_POLL_ACTIVE_SECS", DEFAULTS.pollIntervalActiveMs),
+    pollIntervalIdleMs: envSecondsToMs(env, "TRAVEL_RULE_DEPOSIT_POLL_IDLE_SECS", DEFAULTS.pollIntervalIdleMs),
+    expectedQuestionnaireCountry: env.TRAVEL_RULE_QUESTIONNAIRE_COUNTRY?.trim().toUpperCase() || DEFAULTS.expectedQuestionnaireCountry,
+    failureBackoffMs: envSecondsToMs(env, "TRAVEL_RULE_DEPOSIT_FAILURE_BACKOFF_SECS", DEFAULTS.failureBackoffMs),
+    rateLimitCooldownMs: envSecondsToMs(env, "TRAVEL_RULE_DEPOSIT_RATE_LIMIT_COOLDOWN_SECS", DEFAULTS.rateLimitCooldownMs)
+  };
+}
+function parseQuestionnaireCountry(response) {
+  if (!response || typeof response !== "object")
+    return null;
+  const code = response.questionnaireCountryCode;
+  return typeof code === "string" ? code.trim().toUpperCase() : null;
+}
+
+class TravelRuleDepositReconciler {
+  params;
+  #timer = null;
+  #stopped = false;
+  #running = false;
+  #states = new Map;
+  constructor(params) {
+    this.params = params;
+  }
+  static hasEnabledExchange(policy) {
+    return (policy.travelRule?.rule ?? []).some((rule) => getEnabledTravelRuleDepositConfig(policy, rule.exchange));
+  }
+  start() {
+    if (this.#timer || this.#stopped)
+      return;
+    if (!TravelRuleDepositReconciler.hasEnabledExchange(this.params.policy)) {
+      return;
+    }
+    if (Object.keys(this.params.config.rpcUrlsByNetwork).length === 0) {
+      log.warn("\u26A0\uFE0F Travel-rule deposit auto-clear is enabled but no TRAVEL_RULE_RPC_URL_<NETWORK> is configured; every frozen deposit will be treated as unproven (left frozen).");
+    }
+    log.info("\uD83D\uDEC2 Travel-rule deposit auto-clear reconciler started");
+    this.#scheduleImmediate();
+  }
+  stop() {
+    this.#stopped = true;
+    if (this.#timer) {
+      clearTimeout(this.#timer);
+      this.#timer = null;
+    }
+  }
+  #scheduleImmediate() {
+    this.#timer = setTimeout(() => void this.#tick(), 0);
+  }
+  #stateFor(key) {
+    let state = this.#states.get(key);
+    if (!state) {
+      state = createAccountState();
+      this.#states.set(key, state);
+    }
+    return state;
+  }
+  #targets() {
+    const targets = [];
+    for (const rule of this.params.policy.travelRule?.rule ?? []) {
+      const depositConfig = getEnabledTravelRuleDepositConfig(this.params.policy, rule.exchange);
+      if (!depositConfig)
+        continue;
+      const exchangeId = rule.exchange.trim().toLowerCase();
+      const pool = this.params.brokers[exchangeId];
+      if (!pool)
+        continue;
+      for (const account of [pool.primary, ...pool.secondaryBrokers]) {
+        targets.push({ exchangeId, account, depositConfig });
+      }
+    }
+    return targets;
+  }
+  async#tick() {
+    if (this.#stopped || this.#running)
+      return;
+    this.#running = true;
+    let anyActionable = false;
+    try {
+      for (const target of this.#targets()) {
+        if (this.#stopped)
+          break;
+        const report = await this.#reconcileTarget(target);
+        this.#emit(target, report);
+        if (report.hadActionableWork)
+          anyActionable = true;
+      }
+    } catch (error) {
+      log.error("Travel-rule deposit reconciler tick failed", error);
+    } finally {
+      this.#running = false;
+      if (!this.#stopped) {
+        const delay = anyActionable ? this.params.config.pollIntervalActiveMs : this.params.config.pollIntervalIdleMs;
+        this.#timer = setTimeout(() => void this.#tick(), delay);
+      }
+    }
+  }
+  #reconcileTarget(target) {
+    const exchange = target.account.exchange;
+    const accountLabel = `${target.exchangeId}:${target.account.label}`;
+    const { config } = this.params;
+    return reconcileAccountOnce({
+      accountLabel,
+      depositConfig: target.depositConfig,
+      expectedCountry: config.expectedQuestionnaireCountry,
+      failureBackoffMs: config.failureBackoffMs,
+      rateLimitCooldownMs: config.rateLimitCooldownMs,
+      now: Date.now(),
+      state: this.#stateFor(accountLabel),
+      fetchDepositHistory: async () => {
+        if (typeof exchange.sapiGetLocalentityDepositHistory !== "function") {
+          throw new Error("binance_localentity_deposit_history_unavailable: endpoint not registered");
+        }
+        const result = await exchange.sapiGetLocalentityDepositHistory({});
+        return Array.isArray(result) ? result : [];
+      },
+      fetchQuestionnaireCountry: async () => {
+        if (typeof exchange.sapiGetLocalentityQuestionnaireRequirements !== "function") {
+          return null;
+        }
+        const result = await exchange.sapiGetLocalentityQuestionnaireRequirements({});
+        return parseQuestionnaireCountry(result);
+      },
+      resolveSender: (network, txId) => {
+        const url2 = config.rpcUrlsByNetwork[network.trim().toUpperCase()];
+        if (!url2)
+          return Promise.resolve(null);
+        return resolveOnChainSender(url2, txId);
+      },
+      submitProvideInfo: (tranId, questionnaire) => {
+        if (typeof exchange.sapiPutLocalentityDepositProvideInfo !== "function") {
+          throw new Error("binance_localentity_provide_info_unavailable: endpoint not registered");
+        }
+        return exchange.sapiPutLocalentityDepositProvideInfo({
+          tranId,
+          questionnaire: JSON.stringify(questionnaire)
+        });
+      },
+      resolveQuestionnaire: resolveDepositOriginatorQuestionnaire
+    });
+  }
+  #emit(target, report) {
+    const { metrics } = this.params;
+    const base2 = { exchange: target.exchangeId, account: target.account.label };
+    metrics?.recordGauge("travel_rule_frozen_deposits", report.frozenDeposits.length, base2);
+    for (const outcome of report.outcomes) {
+      switch (outcome.kind) {
+        case "submitted":
+        case "already-provided": {
+          log.info("\uD83D\uDEC2 Travel-rule deposit auto-declared", {
+            result: outcome.kind,
+            account: report.accountLabel,
+            tranId: outcome.deposit.tranId,
+            coin: outcome.deposit.coin,
+            amount: outcome.deposit.amount,
+            network: outcome.deposit.network,
+            txId: outcome.deposit.txId,
+            originator: outcome.sender
+          });
+          metrics?.recordCounter("travel_rule_deposit_submissions_total", 1, {
+            ...base2,
+            coin: outcome.deposit.coin,
+            result: outcome.kind
+          });
+          break;
+        }
+        case "undeclared-origin":
+          log.warn("\uD83D\uDEC2 Travel-rule deposit from UNDECLARED originator \u2014 left frozen", {
+            account: report.accountLabel,
+            tranId: outcome.deposit.tranId,
+            coin: outcome.deposit.coin,
+            amount: outcome.deposit.amount,
+            sender: outcome.sender
+          });
+          metrics?.recordCounter("travel_rule_deposit_anomalies_total", 1, {
+            ...base2,
+            reason: "undeclared_origin"
+          });
+          break;
+        case "unproven-origin":
+          log.warn("\uD83D\uDEC2 Travel-rule deposit origin UNPROVEN (tx sender unresolved) \u2014 left frozen", {
+            account: report.accountLabel,
+            tranId: outcome.deposit.tranId,
+            coin: outcome.deposit.coin,
+            network: outcome.deposit.network,
+            txId: outcome.deposit.txId
+          });
+          metrics?.recordCounter("travel_rule_deposit_anomalies_total", 1, {
+            ...base2,
+            reason: "unproven_origin"
+          });
+          break;
+        case "entity-drift":
+          log.warn("\uD83D\uDEC2 Travel-rule deposit skipped \u2014 questionnaire entity is not the expected country", {
+            account: report.accountLabel,
+            tranId: outcome.deposit.tranId,
+            observedCountry: outcome.country,
+            expectedCountry: this.params.config.expectedQuestionnaireCountry
+          });
+          metrics?.recordCounter("travel_rule_deposit_anomalies_total", 1, {
+            ...base2,
+            reason: "entity_drift"
+          });
+          break;
+        case "failed-terminal":
+          log.warn("\uD83D\uDEC2 Travel-rule deposit is FAILED (terminal) \u2014 needs manual handling", {
+            account: report.accountLabel,
+            tranId: outcome.deposit.tranId,
+            coin: outcome.deposit.coin
+          });
+          metrics?.recordCounter("travel_rule_deposit_anomalies_total", 1, {
+            ...base2,
+            reason: "failed_status"
+          });
+          break;
+        case "submit-error":
+          log.error("\uD83D\uDEC2 Travel-rule deposit provide-info failed", {
+            account: report.accountLabel,
+            tranId: outcome.deposit.tranId,
+            error: outcome.error
+          });
+          metrics?.recordCounter("travel_rule_deposit_anomalies_total", 1, {
+            ...base2,
+            reason: "submit_error"
+          });
+          break;
+        case "poll-error":
+          log.error("\uD83D\uDEC2 Travel-rule deposit history poll failed", {
+            account: report.accountLabel,
+            error: outcome.error
+          });
+          metrics?.recordCounter("travel_rule_deposit_anomalies_total", 1, {
+            ...base2,
+            reason: "poll_error"
+          });
+          break;
+      }
+    }
+  }
+}
 // src/helpers/verity.ts
 var import_verity_client = __toESM(require_dist(), 1);
 
@@ -273326,7 +273893,14 @@ function loadPolicy(policyPath) {
       description: import_joi2.default.string().optional(),
       addresses: import_joi2.default.object().pattern(import_joi2.default.string(), import_joi2.default.object({
         questionnaire: australiaQuestionnaireSchema.required()
-      })).required()
+      })).required(),
+      deposits: import_joi2.default.object({
+        enabled: import_joi2.default.boolean().required(),
+        description: import_joi2.default.string().optional(),
+        originators: import_joi2.default.object().pattern(import_joi2.default.string(), import_joi2.default.object({
+          questionnaire: australiaDepositQuestionnaireSchema.required()
+        })).required()
+      }).optional()
     });
     const policyConfigSchema = import_joi2.default.object({
       withdraw: import_joi2.default.object({
@@ -277670,60 +278244,6 @@ import * as grpc14 from "@grpc/grpc-js";
 // src/handlers/execute-action/deposit.ts
 import * as grpc3 from "@grpc/grpc-js";
 
-// src/helpers/deposit.ts
-function depositField(deposit, fields) {
-  for (const field of fields) {
-    const value = deposit[field];
-    if (value !== undefined && value !== null && String(value).length > 0) {
-      return value;
-    }
-  }
-  return;
-}
-function normalizeDepositStatus(status) {
-  const normalized = String(status ?? "").trim().toLowerCase();
-  if (["ok", "credited", "complete", "completed", "success"].includes(normalized)) {
-    return "credited";
-  }
-  if (["failed", "failure", "canceled", "cancelled", "rejected"].includes(normalized)) {
-    return "failed";
-  }
-  if (["timeout", "timed_out", "timedout", "expired"].includes(normalized)) {
-    return "timed_out";
-  }
-  if (["pending", "processing", "confirming", "waiting"].includes(normalized)) {
-    return "pending";
-  }
-  return "pending";
-}
-function depositMatchesTransaction(deposit, transactionHash) {
-  const candidates = [
-    depositField(deposit, [
-      "txid",
-      "txId",
-      "tx_hash",
-      "txHash",
-      "transactionHash"
-    ]),
-    depositField(deposit, ["id"])
-  ];
-  return candidates.some((candidate) => String(candidate) === transactionHash);
-}
-function stringAmountEquals(left, right) {
-  const leftNum = Number(left);
-  const rightNum = Number(right);
-  if (Number.isFinite(leftNum) && Number.isFinite(rightNum)) {
-    return Math.abs(leftNum - rightNum) < 0.000000000001;
-  }
-  return String(left) === String(right);
-}
-function normalizeAddress(value) {
-  if (value === undefined || value === null) {
-    return;
-  }
-  return String(value).trim().toLowerCase();
-}
-
 // src/helpers/shared/errors.ts
 function getErrorMessage(error) {
   return error instanceof Error ? error.message : typeof error === "string" ? error : "Unknown error";
@@ -294249,6 +294769,7 @@ class CEXBroker {
   useVerity = false;
   otelMetrics;
   otelLogs;
+  depositReconciler;
   loadEnvConfig() {
     log.info("\uD83D\uDD27 Loading CEX_BROKER_ environment variables:");
     const configMap = {};
@@ -294384,6 +294905,10 @@ class CEXBroker {
       unwatchFile(this.#policyFilePath);
       log.info(`Stopped watching policy file: ${this.#policyFilePath}`);
     }
+    if (this.depositReconciler) {
+      this.depositReconciler.stop();
+      this.depositReconciler = undefined;
+    }
     if (this.server) {
       await this.server.forceShutdown();
     }
@@ -294398,6 +294923,10 @@ class CEXBroker {
     if (this.server) {
       await this.server.forceShutdown();
     }
+    if (this.depositReconciler) {
+      this.depositReconciler.stop();
+      this.depositReconciler = undefined;
+    }
     log.info(`Running CEXBroker at ${new Date().toISOString()}`);
     if (this.otelMetrics?.isOtelEnabled()) {
       await this.otelMetrics.initialize();
@@ -294410,6 +294939,13 @@ class CEXBroker {
       }
       log.info(`Your server as started on port ${port}`);
     });
+    this.depositReconciler = new TravelRuleDepositReconciler({
+      policy: this.policy,
+      brokers: this.brokers,
+      config: loadTravelRuleDepositReconcilerConfigFromEnv(process.env),
+      metrics: this.otelMetrics
+    });
+    this.depositReconciler.start();
     return this;
   }
 }
@@ -294417,4 +294953,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=5C43863FE4632C1564756E2164756E21
+//# debugId=FEB8CDC1C50AA70B64756E2164756E21