@usherlabs/cex-broker 0.2.51 → 0.2.52

package/dist/helpers/deposit-archive-poller.d.ts

@@ -7,6 +7,38 @@ export type DepositArchivePollerConfig = {
     lookbackMs: number;
     depositsLimit: number;
 };
+type BinanceUnlockProgressState = "pending" | "credited_not_withdrawable" | "ok" | "failed" | "unknown";
+type BinanceUnlockProgressQuality = "valid" | "unknown" | "contradictory";
+declare const BINANCE_UNLOCK_PROGRESS_SOURCE: {
+    readonly venue: "binance";
+    readonly endpoint: "GET /sapi/v1/capital/deposit/hisrec";
+    readonly fields: {
+        readonly status: "info.status";
+        readonly confirmTimes: "info.confirmTimes";
+        readonly unlockConfirm: "info.unlockConfirm";
+        readonly completeTime: "info.completeTime";
+    };
+};
+export type BinanceUnlockProgress = {
+    version: 1;
+    state: BinanceUnlockProgressState;
+    progress_state: BinanceUnlockProgressQuality;
+    reason: string | null;
+    native_status: number | null;
+    current: number | null;
+    credit_required: number | null;
+    unlock_required: number | null;
+    complete_time: number | null;
+    observed_at: string;
+    source: typeof BINANCE_UNLOCK_PROGRESS_SOURCE;
+};
+/**
+ * Extracts Binance's native deposit confirmation fields without trusting
+ * ccxt's normalized status. `confirmTimes` is normally the venue string
+ * `"current/credit_required"`; the object form is accepted only for callers
+ * that already decoded that exact field.
+ */
+export declare function parseBinanceUnlockProgress(record: Record<string, unknown>): BinanceUnlockProgress;
 /**
  * Advances the inclusive since-watermark only across a fully observed,
  * terminal prefix of deposit history.
@@ -31,3 +63,4 @@ export declare class DepositArchivePoller {
     stop(): Promise<void>;
     pollAllOnce(): Promise<boolean>;
 }
+export {};

package/dist/index.js

@@ -292725,6 +292725,16 @@ function withTimeout(promise, timeoutMs, label) {
   return Promise.race([promise, expiry]).finally(() => clearTimeout(timer));
 }
 var ALL_CURRENCIES_CODE = "*";
+var BINANCE_UNLOCK_PROGRESS_SOURCE = {
+  venue: "binance",
+  endpoint: "GET /sapi/v1/capital/deposit/hisrec",
+  fields: {
+    status: "info.status",
+    confirmTimes: "info.confirmTimes",
+    unlockConfirm: "info.unlockConfirm",
+    completeTime: "info.completeTime"
+  }
+};
 function depositTimestamp(record) {
   const observedAt = depositField(record, [
     "timestamp",
@@ -292737,12 +292747,185 @@ function depositTimestamp(record) {
   const timestamp = typeof observedAt === "number" ? observedAt : typeof observedAt === "string" ? Date.parse(observedAt) : Number.NaN;
   return Number.isFinite(timestamp) ? timestamp : undefined;
 }
-function archivedDepositStatus(exchangeId, record) {
-  const rawStatus = asRecord(record.info)?.status;
-  if (exchangeId?.toLowerCase() === "binance" && String(rawStatus ?? "").trim() === "6") {
-    return "credited_not_withdrawable";
+function parseNonNegativeInteger(value) {
+  if (typeof value === "number") {
+    return Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+  }
+  if (typeof value !== "string") {
+    return;
+  }
+  const trimmed = value.trim();
+  if (!/^\d+$/.test(trimmed)) {
+    return;
+  }
+  const parsed = Number(trimmed);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+function parseConfirmTimes(value) {
+  if (value === undefined || value === null) {
+    return { reason: "missing_confirmTimes" };
+  }
+  let currentValue;
+  let creditRequiredValue;
+  if (typeof value === "string") {
+    const match = /^(\d+)\s*\/\s*(\d+)$/.exec(value.trim());
+    if (!match) {
+      return { reason: "invalid_confirmTimes" };
+    }
+    currentValue = match[1];
+    creditRequiredValue = match[2];
+  } else {
+    const record = asRecord(value);
+    if (!record) {
+      return { reason: "invalid_confirmTimes" };
+    }
+    currentValue = record.current;
+    creditRequiredValue = record.credit_required;
+  }
+  const current = parseNonNegativeInteger(currentValue);
+  const creditRequired = parseNonNegativeInteger(creditRequiredValue);
+  if (current === undefined || creditRequired === undefined) {
+    return { reason: "invalid_confirmTimes" };
   }
-  return normalizeCcxtTransactionForArchive(record).status;
+  return { current, creditRequired, reason: null };
+}
+function parseOptionalNonNegativeInteger(value, fieldName) {
+  if (value === undefined || value === null) {
+    return { value: undefined, reason: null };
+  }
+  const parsed = parseNonNegativeInteger(value);
+  return parsed === undefined ? { value: undefined, reason: `invalid_${fieldName}` } : { value: parsed, reason: null };
+}
+function parseBinanceUnlockProgress(record) {
+  const info = asRecord(record.info);
+  const nativeStatus = parseNonNegativeInteger(info?.status);
+  const confirmations = parseConfirmTimes(info?.confirmTimes);
+  const unlockRequired = parseOptionalNonNegativeInteger(info?.unlockConfirm, "unlockConfirm");
+  const completeTime = parseOptionalNonNegativeInteger(info?.completeTime, "completeTime");
+  let quality = "valid";
+  let reason = null;
+  if (nativeStatus === undefined) {
+    quality = "unknown";
+    reason = "missing_or_invalid_status";
+  } else if (confirmations.reason !== null) {
+    quality = "unknown";
+    reason = confirmations.reason;
+  } else if (unlockRequired.reason !== null) {
+    quality = "unknown";
+    reason = unlockRequired.reason;
+  } else if (completeTime.reason !== null) {
+    quality = "unknown";
+    reason = completeTime.reason;
+  }
+  let state = "unknown";
+  switch (nativeStatus) {
+    case 0:
+      state = "pending";
+      break;
+    case 1:
+      if (quality === "valid" && confirmations.current !== undefined && unlockRequired.value !== undefined && confirmations.current >= unlockRequired.value) {
+        state = "ok";
+      } else if (quality === "valid") {
+        state = "credited_not_withdrawable";
+      }
+      break;
+    case 2:
+    case 7:
+      state = "failed";
+      break;
+    case 6:
+      state = "credited_not_withdrawable";
+      break;
+    case 8:
+      state = "pending";
+      break;
+    default:
+      quality = "unknown";
+      reason = "unsupported_status";
+      break;
+  }
+  return {
+    version: 1,
+    state,
+    progress_state: quality,
+    reason,
+    native_status: nativeStatus ?? null,
+    current: confirmations.current ?? null,
+    credit_required: confirmations.creditRequired ?? null,
+    unlock_required: unlockRequired.value ?? null,
+    complete_time: completeTime.value ?? null,
+    observed_at: new Date().toISOString(),
+    source: BINANCE_UNLOCK_PROGRESS_SOURCE
+  };
+}
+function unlockProgressKey(progress) {
+  return JSON.stringify({
+    version: progress.version,
+    state: progress.state,
+    progress_state: progress.progress_state,
+    reason: progress.reason,
+    native_status: progress.native_status,
+    current: progress.current,
+    credit_required: progress.credit_required,
+    unlock_required: progress.unlock_required,
+    complete_time: progress.complete_time
+  });
+}
+function progressWatermark(progress, previous) {
+  if (progress.progress_state !== "valid" || progress.current === null || progress.credit_required === null || progress.unlock_required === null) {
+    return previous;
+  }
+  return {
+    current: Math.max(previous?.current ?? 0, progress.current),
+    credit_required: progress.credit_required,
+    unlock_required: progress.unlock_required
+  };
+}
+function classifyBinanceDeposit(record, previous) {
+  let progress = parseBinanceUnlockProgress(record);
+  let highWatermark = previous?.highWatermark;
+  if (progress.progress_state === "valid" && progress.current !== null && progress.credit_required !== null && progress.unlock_required !== null && previous?.highWatermark !== undefined && (progress.current < previous.highWatermark.current || progress.credit_required !== previous.highWatermark.credit_required || progress.unlock_required !== previous.highWatermark.unlock_required)) {
+    progress = {
+      ...progress,
+      state: "unknown",
+      progress_state: "contradictory",
+      reason: "confirmation_progress_regressed_or_requirement_changed"
+    };
+  } else {
+    highWatermark = progressWatermark(progress, previous?.highWatermark);
+  }
+  return {
+    archiveStatus: progress.state,
+    holdCursor: progress.state === "pending" || progress.state === "credited_not_withdrawable" || progress.state === "unknown",
+    unlockProgress: progress,
+    progressKey: unlockProgressKey(progress),
+    highWatermark
+  };
+}
+function classifyDeposit(exchangeId, record, previous) {
+  if (exchangeId?.toLowerCase() === "binance") {
+    return classifyBinanceDeposit(record, previous);
+  }
+  const archiveStatus = normalizeCcxtTransactionForArchive(record).status ?? "";
+  const status = normalizeDepositStatus(depositField(record, ["status", "state"]));
+  return {
+    archiveStatus,
+    holdCursor: archiveStatus === "credited_not_withdrawable" || status === "pending",
+    progressKey: JSON.stringify({ status: archiveStatus })
+  };
+}
+function depositIdentity(input) {
+  if (input.externalId === undefined && input.txid === undefined) {
+    return;
+  }
+  return JSON.stringify({
+    exchange: input.exchangeId,
+    account: input.accountSelector,
+    coin: input.coin === undefined ? "" : String(input.coin),
+    network: input.network === undefined ? "" : String(input.network),
+    external_id: input.externalId ?? "",
+    txid: input.txid ?? ""
+  });
 }
 function nextDepositCursor(deposits, currentSince, depositsLimit, exchangeId) {
   if (deposits.length >= depositsLimit) {
@@ -292756,9 +292939,8 @@ function nextDepositCursor(deposits, currentSince, depositsLimit, exchangeId) {
       return currentSince;
     }
     const timestamp = depositTimestamp(record);
-    const archiveStatus = archivedDepositStatus(exchangeId, record);
-    const status = normalizeDepositStatus(depositField(record, ["status", "state"]));
-    const isPending = archiveStatus === "credited_not_withdrawable" || status === "pending";
+    const classification = classifyDeposit(exchangeId, record);
+    const isPending = classification.holdCursor;
     if (timestamp === undefined) {
       if (isPending) {
         return currentSince;
@@ -292878,7 +293060,8 @@ class DepositArchivePoller {
       if (!record) {
         continue;
       }
-      const assetSymbol = depositField(record, ["currency", "code", "asset"]);
+      const info = asRecord(record.info);
+      const assetSymbol = depositField(record, ["currency", "code", "asset"]) ?? info?.coin;
       const amount = depositField(record, ["amount"]);
       const address = depositField(record, [
         "address",
@@ -292887,8 +293070,21 @@ class DepositArchivePoller {
         "destination"
       ]);
       const txid = depositField(record, ["txid", "txId", "tx_hash", "txHash"]);
-      const network = depositField(record, ["network", "chain"]);
-      const archiveStatus = archivedDepositStatus(target.exchangeId, record);
+      const network = depositField(record, ["network", "chain"]) ?? info?.network;
+      const depositTxid = txid === undefined ? undefined : String(txid);
+      const identity = depositIdentity({
+        exchangeId: target.exchangeId,
+        accountSelector: target.account.label,
+        coin: assetSymbol,
+        network,
+        externalId: depositTxid,
+        txid: depositTxid
+      });
+      const lastArchived = identity === undefined ? undefined : this.#lastArchivedByTarget.get(key)?.get(identity);
+      const classification = classifyDeposit(target.exchangeId, record, lastArchived);
+      if (lastArchived && lastArchived.status === classification.archiveStatus && lastArchived.progressKey === classification.progressKey) {
+        continue;
+      }
       const creditedAt = depositField(record, [
         "creditedAt",
         "credited_at",
@@ -292897,11 +293093,7 @@ class DepositArchivePoller {
         "timestamp",
         "datetime"
       ]);
-      const depositTxid = txid === undefined ? undefined : String(txid);
-      const lastArchived = depositTxid === undefined ? undefined : this.#lastArchivedByTarget.get(key)?.get(depositTxid);
-      if (lastArchived && lastArchived.status === archiveStatus) {
-        continue;
-      }
+      const payload = classification.unlockProgress === undefined ? record : { ...record, unlock_progress: classification.unlockProgress };
       this.params.archiver.enqueue(buildTransferEventArchiveRow({
         tags: buildCommonArchiveTags({
           deploymentId: this.params.archiver.getDeploymentId(),
@@ -292912,25 +293104,27 @@ class DepositArchivePoller {
         transfer: {
           eventKind: "deposit",
           lifecycleAction: "observe_deposit",
-          status: archiveStatus,
+          status: classification.archiveStatus,
           amount: amount === undefined ? undefined : String(amount),
           address: address === undefined ? undefined : String(address),
           network: network === undefined ? undefined : String(network),
           externalId: depositTxid,
           txid: depositTxid,
           exchangeTimestamp: normalizeTimestamp(creditedAt),
-          payload: record
+          payload
         }
       }));
-      if (depositTxid !== undefined) {
+      if (identity !== undefined) {
         let targetDeposits2 = this.#lastArchivedByTarget.get(key);
         if (!targetDeposits2) {
           targetDeposits2 = new Map;
           this.#lastArchivedByTarget.set(key, targetDeposits2);
         }
-        targetDeposits2.set(depositTxid, {
-          status: archiveStatus,
-          timestamp: depositTimestamp(record)
+        targetDeposits2.set(identity, {
+          status: classification.archiveStatus,
+          timestamp: depositTimestamp(record),
+          progressKey: classification.progressKey,
+          highWatermark: classification.highWatermark
         });
       }
       archived += 1;
@@ -313345,4 +313539,4 @@ export {
   CEXBroker as default
 };
 
-//# debugId=298884FD1F08284464756E2164756E21
+//# debugId=72C8C3614857C3F664756E2164756E21