@cloak.dev/sdk 0.1.3 → 0.1.5

package/dist/index.cjs

@@ -301,12 +301,15 @@ __export(index_exports, {
   MemoryStorageAdapter: () => MemoryStorageAdapter,
   MerkleTree: () => MerkleTree,
   NATIVE_SOL_MINT: () => NATIVE_SOL_MINT,
+  RelayInternalError: () => RelayInternalError,
   RelayService: () => RelayService,
   RootNotFoundError: () => RootNotFoundError,
   SCANNER_SUPPORTS_TRANSACT_SWAP: () => SCANNER_SUPPORTS_TRANSACT_SWAP,
   SIGN_IN_MESSAGE: () => SIGN_IN_MESSAGE,
+  SanctionsQuoteError: () => SanctionsQuoteError,
   ShieldPoolErrors: () => ShieldPoolErrors,
   SimpleWallet: () => SimpleWallet,
+  UtxoAlreadySpentError: () => UtxoAlreadySpentError,
   UtxoWallet: () => UtxoWallet,
   VARIABLE_FEE_DENOMINATOR: () => VARIABLE_FEE_DENOMINATOR,
   VARIABLE_FEE_NUMERATOR: () => VARIABLE_FEE_NUMERATOR,
@@ -325,6 +328,7 @@ __export(index_exports, {
   calculateRelayFee: () => calculateRelayFee,
   chainNoteFromBase64: () => chainNoteFromBase64,
   chainNoteToBase64: () => chainNoteToBase64,
+  classifyRelayError: () => classifyRelayError,
   cleanupStalePendingOperations: () => cleanupStalePendingOperations,
   clearPendingDeposits: () => clearPendingDeposits,
   clearPendingWithdrawals: () => clearPendingWithdrawals,
@@ -437,6 +441,7 @@ __export(index_exports, {
   partialWithdraw: () => partialWithdraw,
   poseidonHash: () => poseidonHash,
   preflightCheck: () => preflightCheck,
+  preflightNullifiers: () => preflightNullifiers,
   prepareEncryptedOutput: () => prepareEncryptedOutput,
   prepareEncryptedOutputForRecipient: () => prepareEncryptedOutputForRecipient,
   proofToBytes: () => proofToBytes,
@@ -484,6 +489,7 @@ __export(index_exports, {
   validateWithdrawableNote: () => validateWithdrawableNote,
   verifyAllCircuits: () => verifyAllCircuits,
   verifyCircuitIntegrity: () => verifyCircuitIntegrity,
+  verifyUtxos: () => verifyUtxos,
   waitForRoot: () => waitForRoot,
   withTiming: () => withTiming
 });
@@ -1339,6 +1345,71 @@ function parseRelayErrorResponse(responseText) {
     return { isRootNotFound: false };
   }
 }
+var UtxoAlreadySpentError = class extends Error {
+  constructor(message, spentUtxoCommitments = []) {
+    super(message);
+    this.spentUtxoCommitments = spentUtxoCommitments;
+    this.name = "UtxoAlreadySpentError";
+  }
+};
+var SanctionsQuoteError = class extends Error {
+  constructor(message, onChainCode, subKind) {
+    super(message);
+    this.onChainCode = onChainCode;
+    this.subKind = subKind;
+    this.name = "SanctionsQuoteError";
+  }
+};
+var RelayInternalError = class extends Error {
+  constructor(message, relayMessage, httpStatus, cachedTreeFromChain) {
+    super(message);
+    this.relayMessage = relayMessage;
+    this.httpStatus = httpStatus;
+    this.cachedTreeFromChain = cachedTreeFromChain;
+    this.name = "RelayInternalError";
+  }
+};
+function classifyRelayError(responseText, httpStatus) {
+  let inner = "";
+  try {
+    const parsed = JSON.parse(responseText);
+    inner = parsed?.message ?? "";
+  } catch {
+    inner = responseText;
+  }
+  const haystack = inner.toLowerCase();
+  if (haystack.includes("0x1020") || haystack.includes("doublespend")) {
+    return new UtxoAlreadySpentError(
+      "This shielded balance was already spent. The UTXO's nullifier is registered on-chain \u2014 typically means you spent it via another session or device. Run verifyUtxos() to reconcile local state."
+    );
+  }
+  if (haystack.includes("0x10b0") || haystack.includes("rangequoteexpired")) {
+    return new SanctionsQuoteError(
+      "Range sanctions quote expired before the on-chain program processed the transaction. The relay's quote-expiry window is too short relative to proof-gen + confirmation latency, or on-chain clock drifted. Retry the send; the relay will issue a fresh quote.",
+      4272,
+      "expired"
+    );
+  }
+  if (haystack.includes("0x10b2") || haystack.includes("rangequotewalletmismatch")) {
+    return new SanctionsQuoteError(
+      "Range sanctions quote's wallet doesn't match the on-chain expected wallet. Indicates a relay config drift \u2014 the sender used for quote signing doesn't match the program's pool.range_signer / fee payer. Relay operators must fix; caller retry will not help.",
+      4274,
+      "wallet_mismatch"
+    );
+  }
+  if (haystack.includes("0x10b3") || haystack.includes("rangequotemissinged25519")) {
+    return new SanctionsQuoteError(
+      "Transaction reached the on-chain program without the required Ed25519 sanctions quote instruction. This is a relay bug \u2014 the relay constructed the tx without attaching the signed quote. Caller retry will not help.",
+      4275,
+      "missing_ix"
+    );
+  }
+  return new RelayInternalError(
+    `Relay returned ${httpStatus ?? "an error"}: ${inner || responseText}`,
+    inner || responseText,
+    httpStatus
+  );
+}
 var ShieldPoolErrors = {
   // Root management errors
   4096: "Invalid Merkle root",
@@ -4635,6 +4706,64 @@ async function decryptComplianceMetadataWithMasterKey(encrypted, masterComplianc
   return decryptWithSharedSecret(payload, sharedSecret);
 }
 
+// src/utils/verify-utxos.ts
+init_utxo();
+async function verifyUtxos(utxos, connection, programId, commitment = "confirmed") {
+  const checkable = [];
+  const skipped = [];
+  for (const utxo of utxos) {
+    if (utxo.commitment === void 0 || utxo.mintAddress === void 0 || utxo.keypair === void 0 || utxo.keypair.privateKey === void 0) {
+      skipped.push(utxo);
+      continue;
+    }
+    try {
+      const nullifierBig = await computeNullifier2(utxo);
+      const nullifierHex = nullifierBig.toString(16).padStart(64, "0");
+      const nullifierBytes = Buffer.from(nullifierHex, "hex");
+      const { pool } = getShieldPoolPDAs(programId, utxo.mintAddress);
+      const [pda] = getNullifierPDA(pool, nullifierBytes, programId);
+      checkable.push({ utxo, pda });
+    } catch {
+      skipped.push(utxo);
+    }
+  }
+  if (checkable.length === 0) {
+    return { spent: [], unspent: [], skipped };
+  }
+  const CHUNK = 100;
+  const infos = [];
+  for (let i = 0; i < checkable.length; i += CHUNK) {
+    const page = checkable.slice(i, i + CHUNK).map((e) => e.pda);
+    const pageInfos = await connection.getMultipleAccountsInfo(page, commitment);
+    infos.push(...pageInfos);
+  }
+  const spent = [];
+  const unspent = [];
+  for (let i = 0; i < checkable.length; i++) {
+    if (infos[i] !== null) {
+      spent.push(checkable[i].utxo);
+    } else {
+      unspent.push(checkable[i].utxo);
+    }
+  }
+  return { spent, unspent, skipped };
+}
+async function preflightNullifiers(utxos, connection, programId, commitment = "confirmed") {
+  if (utxos.length === 0) return;
+  const result = await verifyUtxos(utxos, connection, programId, commitment);
+  if (result.spent.length > 0) {
+    const allCommitments = result.spent.map(
+      (u) => u.commitment !== void 0 ? u.commitment.toString(16).padStart(64, "0") : "<unknown>"
+    );
+    const preview = allCommitments.slice(0, 5);
+    const extra = allCommitments.length > preview.length ? ` (+${allCommitments.length - preview.length} more)` : "";
+    throw new UtxoAlreadySpentError(
+      `Pre-flight detected ${allCommitments.length} already-spent UTXO(s). First spent commitment(s): ${preview.join(", ")}${extra}. Call verifyUtxos() and remove these from local state before retrying.`,
+      allCommitments
+    );
+  }
+}
+
 // src/services/risk-oracle.ts
 function buildRangeRiskScoreJob(OracleJob, walletAddress) {
   return OracleJob.fromObject({
@@ -4978,12 +5107,18 @@ async function buildMerkleTree(commitments, height = MERKLE_TREE_HEIGHT2) {
 
 // src/utils/relay-client.ts
 var import_bs58 = __toESM(require("bs58"), 1);
+var bs58 = import_bs58.default.default || import_bs58.default;
 var TRANSACT_TAG = 0;
 var TRANSACT_SWAP_TAG = 1;
-var DEPOSIT_TAG = 1;
 var PROOF_LEN = 256;
 var PUBLIC_INPUTS_LEN = 264;
 var COMMITMENTS_OFFSET = 168;
+function isAllZero(b) {
+  for (let i = 0; i < b.length; i++) {
+    if (b[i] !== 0) return false;
+  }
+  return true;
+}
 var DEFAULT_TIMEOUT_MS = 3e4;
 var DEFAULT_MAX_RETRIES = 3;
 async function fetchWithRetry(url, options = {}) {
@@ -5121,24 +5256,20 @@ async function buildMerkleTreeFromRelay(relayUrl, options) {
 function extractCommitmentsFromInstruction(data) {
   if (data.length === 0) return [];
   const tag = data[0];
-  if (tag === TRANSACT_TAG || tag === TRANSACT_SWAP_TAG) {
-    const publicInputsStart = 1 + PROOF_LEN;
-    const publicInputsEnd = publicInputsStart + PUBLIC_INPUTS_LEN;
-    if (data.length < publicInputsEnd) return [];
-    const publicInputs = data.slice(publicInputsStart, publicInputsEnd);
-    const commitments = [];
-    const c0 = publicInputs.slice(COMMITMENTS_OFFSET, COMMITMENTS_OFFSET + 32);
-    const c1 = publicInputs.slice(COMMITMENTS_OFFSET + 32, COMMITMENTS_OFFSET + 64);
-    commitments.push(c0);
-    commitments.push(c1);
-    return commitments;
-  }
-  if (tag === DEPOSIT_TAG) {
-    if (data.length < 1 + 8 + 32) return [];
-    const commitment = data.slice(1 + 8, 1 + 8 + 32);
-    return [commitment];
-  }
-  return [];
+  if (tag !== TRANSACT_TAG && tag !== TRANSACT_SWAP_TAG) return [];
+  const publicInputsStart = 1 + PROOF_LEN;
+  const publicInputsEnd = publicInputsStart + PUBLIC_INPUTS_LEN;
+  if (data.length < publicInputsEnd) return [];
+  const publicInputs = data.slice(publicInputsStart, publicInputsEnd);
+  const c0 = publicInputs.slice(COMMITMENTS_OFFSET, COMMITMENTS_OFFSET + 32);
+  const c1 = publicInputs.slice(
+    COMMITMENTS_OFFSET + 32,
+    COMMITMENTS_OFFSET + 64
+  );
+  const out = [];
+  if (!isAllZero(c0)) out.push(c0);
+  if (!isAllZero(c1)) out.push(c1);
+  return out;
 }
 function isBrowser() {
   return typeof globalThis !== "undefined" && typeof globalThis.window !== "undefined";
@@ -5177,7 +5308,7 @@ async function buildMerkleTreeFromChain(connection, programId, merkleTree, onPro
     for (const ix of tx.transaction.message.instructions) {
       if (!("programId" in ix) || !("data" in ix)) continue;
       if (ix.programId.toBase58() !== programIdBase58) continue;
-      const data = import_bs58.default.decode(ix.data);
+      const data = bs58.decode(ix.data);
       const extracted = extractCommitmentsFromInstruction(data);
       for (const commitment of extracted) {
         commitments.push(BigInt("0x" + Buffer.from(commitment).toString("hex")));
@@ -6745,6 +6876,7 @@ async function transact(params, options) {
   if (outputUtxos.length > 2) {
     throw new Error("Maximum 2 output UTXOs allowed");
   }
+  await preflightNullifiers(inputUtxos, connection, programId);
   const mint = inputUtxos.find((u) => u.amount > 0)?.mintAddress ?? outputUtxos.find((u) => u.amount > 0)?.mintAddress ?? NATIVE_SOL_MINT;
   const paddedInputs = [...inputUtxos];
   while (paddedInputs.length < 2) {
@@ -6815,7 +6947,7 @@ async function transact(params, options) {
       }
       merkleTree = null;
     }
-    if (needsTreeForProof && relayUrl && !relayTreeDisabledForMint && !forceChainIndexing && (forceRefresh || !merkleTree)) {
+    if (needsTreeForProof && relayUrl && !relayTreeDisabledForMint && !forceChainIndexing && (forceRefresh || !merkleTree) && !hasCachedTree) {
       try {
         const shouldRequestRelaySync = forceSync || requiredRelayIndex >= 0;
         const syncTimeoutMs = shouldRequestRelaySync ? Math.min(3e4, relayRequestTimeoutMs()) : 3500;
@@ -6840,7 +6972,7 @@ async function transact(params, options) {
         merkleTree = null;
       }
     }
-    if (merkleTree && treeState) {
+    if (merkleTree && treeState && !hasCachedTree) {
       const relayRoot = merkleTree.root().toString(16).padStart(64, "0");
       const lengthDiff = treeState.nextIndex - merkleTree.length;
       if (merkleTree.length === 0) {
@@ -6971,7 +7103,7 @@ async function transact(params, options) {
         const disableNearTipFallbackEnv = typeof process !== "undefined" && !!process.env && (process.env.CLOAK_DISABLE_NEAR_TIP_ONCHAIN_PROOF === "1" || process.env.CLOAK_DISABLE_NEAR_TIP_ONCHAIN_PROOF === "true");
         const hasSiblingHints = !!utxo.siblingCommitment || !!utxo.leftSiblingCommitment;
         const baseNearTipEligible = chainDistanceFromTip !== null && chainDistanceFromTip >= 0 && chainDistanceFromTip <= nearTipMaxDistance;
-        const allowNearTipOnChainFallback = relayTreeDisabledForMint && !disableNearTipFallbackEnv && baseNearTipEligible && (forceEnableNearTipFallbackEnv || useSiblingInfo && hasSiblingHints);
+        let allowNearTipOnChainFallback = relayTreeDisabledForMint && !disableNearTipFallbackEnv && baseNearTipEligible && (forceEnableNearTipFallbackEnv || useSiblingInfo && hasSiblingHints);
         if (!relayTreeDisabledForMint && !useSiblingInfo) {
           onProgress?.(`Relay tree missing index ${utxo.index} (length: ${treeLength}) with sibling cache disabled; proof may require retry after relay sync.`);
         } else if (!relayTreeDisabledForMint && relayUrl && !forceChainIndexing && utxo.index >= treeLength && !allowNearTipOnChainFallback) {
@@ -6982,9 +7114,10 @@ async function transact(params, options) {
           onProgress?.(`Relay tree is lagging (missing index ${utxo.index}, length: ${treeLength}); using guarded on-chain proof fallback.`);
         }
         if (relayUrl && !relayTreeDisabledForMint && !forceChainIndexing && utxo.index >= treeLength && !allowNearTipOnChainFallback) {
-          throw new Error(
-            `Relay tree missing required commitment index ${utxo.index} (tree length: ${treeLength}); waiting for relay sync is required.`
+          onProgress?.(
+            `Relay tree missing index ${utxo.index} (tree length: ${treeLength}) \u2014 falling through to on-chain proof.`
           );
+          allowNearTipOnChainFallback = true;
         }
         if (allowNearTipOnChainFallback && relayTreeDisabledForMint) {
           onProgress?.(
@@ -7218,11 +7351,19 @@ async function transact(params, options) {
         onProgress?.(`Merkle proof error (stale sibling data), will regenerate with fresh tree...`);
         lastError = new Error(`Circuit assertion failed: ${errorMsg}`);
         if (forceChainIndexing) {
-          onProgress?.("On-chain fallback proof failed; returning to relay-sync mode.");
-          forceChainIndexing = false;
+          onProgress?.("On-chain frontier proof failed; escalating to full chain tree rebuild...");
+          try {
+            merkleTree = await buildMerkleTreeFromChain(connection, programId, pdas.merkleTree, onProgress);
+            onProgress?.(`Chain tree rebuilt with ${merkleTree.length} leaves.`);
+          } catch (chainBuildErr) {
+            onProgress?.(`Chain tree rebuild failed (${chainBuildErr?.message?.slice(0, 80)}); returning to relay-sync mode.`);
+            forceChainIndexing = false;
+            merkleTree = null;
+          }
+        } else {
+          merkleTree = null;
         }
         treeState = null;
-        merkleTree = null;
         useSiblingInfo = false;
         const waitMs = Math.min(retryDelayMs * Math.pow(2, Math.min(submissionAttempts, 4)), 5e3);
         if (waitMs > 0) {
@@ -7563,25 +7704,68 @@ async function transact(params, options) {
     }
   }
   if (lastError) {
+    const classified = classifyRelayError(lastError.message);
+    const isMerkleClass = !(classified instanceof UtxoAlreadySpentError) && !(classified instanceof SanctionsQuoteError) && !isRootNotFoundError2(lastError);
+    if (!IS_BROWSER2 && isMerkleClass && relayUrl) {
+      onProgress?.(
+        "All relay-tree attempts failed. Rebuilding merkle tree from chain as last resort..."
+      );
+      try {
+        const [merkleTreePda] = import_web37.PublicKey.findProgramAddressSync(
+          [Buffer.from("merkle_tree"), mint.toBuffer()],
+          programId
+        );
+        const chainTree = await buildMerkleTreeFromChain(
+          connection,
+          programId,
+          merkleTreePda,
+          onProgress
+        );
+        const chainRootHex = chainTree.root().toString(16).padStart(64, "0");
+        onProgress?.(
+          `Chain-rebuilt tree root: ${chainRootHex.substring(0, 16)}... \u2014 attached to error for caller retry`
+        );
+        throw new RelayInternalError(
+          `All relay-tree attempts failed. Chain-rebuilt tree available (root ${chainRootHex.substring(0, 16)}...). Retry this call with options.cachedMerkleTree = err.cachedTreeFromChain. Original error: ${lastError.message}`,
+          lastError.message,
+          void 0,
+          chainTree
+        );
+      } catch (e) {
+        if (e instanceof RelayInternalError) throw e;
+        onProgress?.(
+          `Chain-replay fallback failed: ${e instanceof Error ? e.message : String(e)}`
+        );
+      }
+    }
     if (isRootNotFoundError2(lastError)) {
-      throw new Error(`Transaction failed after ${maxRootRetries + 1} retries: ${lastError.message}`);
+      throw new Error(
+        `Transaction failed after ${maxRootRetries + 1} retries: ${lastError.message}`
+      );
     }
-    throw new Error(`Transaction failed: ${lastError.message}`);
+    throw classified;
   }
   if (relayUrl && outputCommitments.length >= 2) {
-    const reconcileSeedIndices = commitmentIndices[0] >= 0 && commitmentIndices[1] >= 0 ? commitmentIndices : lastObservedNextIndexForOutputs !== null ? [lastObservedNextIndexForOutputs, lastObservedNextIndexForOutputs + 1] : commitmentIndices;
-    const reconciledIndices = await reconcileCommitmentIndicesWithRelay(
-      relayUrl,
-      mint,
-      reconcileSeedIndices,
-      [outputCommitments[0], outputCommitments[1]],
-      onProgress
-    );
-    if (reconciledIndices[0] !== commitmentIndices[0] || reconciledIndices[1] !== commitmentIndices[1]) {
+    const hasOnChainIndices = commitmentIndices[0] >= 0 && commitmentIndices[1] >= 0;
+    if (!hasOnChainIndices) {
+      const reconcileSeedIndices = lastObservedNextIndexForOutputs !== null ? [lastObservedNextIndexForOutputs, lastObservedNextIndexForOutputs + 1] : commitmentIndices;
+      const reconciledIndices = await reconcileCommitmentIndicesWithRelay(
+        relayUrl,
+        mint,
+        reconcileSeedIndices,
+        [outputCommitments[0], outputCommitments[1]],
+        onProgress
+      );
+      if (reconciledIndices[0] !== commitmentIndices[0] || reconciledIndices[1] !== commitmentIndices[1]) {
+        onProgress?.(
+          `Adjusted commitment indices after relay reconciliation: [${commitmentIndices[0]}, ${commitmentIndices[1]}] -> [${reconciledIndices[0]}, ${reconciledIndices[1]}]`
+        );
+        commitmentIndices = reconciledIndices;
+      }
+    } else {
       onProgress?.(
-        `Adjusted commitment indices after relay reconciliation: [${commitmentIndices[0]}, ${commitmentIndices[1]}] -> [${reconciledIndices[0]}, ${reconciledIndices[1]}]`
+        `Using on-chain commitment indices [${commitmentIndices[0]}, ${commitmentIndices[1]}] (skipping relay reconciliation).`
       );
-      commitmentIndices = reconciledIndices;
     }
   }
   const siblingCommitments = [
@@ -7863,6 +8047,7 @@ async function swapUtxo(params, options) {
   if (inputUtxos.length > 2) {
     throw new Error("Maximum 2 input UTXOs allowed");
   }
+  await preflightNullifiers(inputUtxos, connection, programId);
   const outputMintAccount = await connection.getAccountInfo(outputMint, {
     commitment: "confirmed"
   });
@@ -7934,7 +8119,7 @@ async function swapUtxo(params, options) {
       }
       merkleTree = null;
     }
-    if (needsTreeForProof && relayUrl && !relayTreeDisabledForMint && !forceChainIndexing && (forceRefresh || !merkleTree)) {
+    if (needsTreeForProof && relayUrl && !relayTreeDisabledForMint && !forceChainIndexing && (forceRefresh || !merkleTree) && !hasCachedTree) {
       try {
         const shouldRequestRelaySync = forceSync || requiredRelayIndex >= 0;
         const syncTimeoutMs = shouldRequestRelaySync ? Math.min(3e4, relayRequestTimeoutMs()) : 3500;
@@ -7959,7 +8144,7 @@ async function swapUtxo(params, options) {
         merkleTree = null;
       }
     }
-    if (merkleTree && merkleState) {
+    if (merkleTree && merkleState && !hasCachedTree) {
       const relayRoot = merkleTree.root().toString(16).padStart(64, "0");
       const lengthDiff = merkleState.nextIndex - merkleTree.length;
       if (merkleTree.length === 0) {
@@ -8087,7 +8272,7 @@ async function swapUtxo(params, options) {
         const disableNearTipFallbackEnv = typeof process !== "undefined" && !!process.env && (process.env.CLOAK_DISABLE_NEAR_TIP_ONCHAIN_PROOF === "1" || process.env.CLOAK_DISABLE_NEAR_TIP_ONCHAIN_PROOF === "true");
         const hasSiblingHints = !!utxo.siblingCommitment || !!utxo.leftSiblingCommitment;
         const baseNearTipEligible = chainDistanceFromTip !== null && chainDistanceFromTip >= 0 && chainDistanceFromTip <= nearTipMaxDistance;
-        const allowNearTipOnChainFallback = relayTreeDisabledForMint && !disableNearTipFallbackEnv && baseNearTipEligible && (forceEnableNearTipFallbackEnv || useSiblingInfo && hasSiblingHints);
+        let allowNearTipOnChainFallback = relayTreeDisabledForMint && !disableNearTipFallbackEnv && baseNearTipEligible && (forceEnableNearTipFallbackEnv || useSiblingInfo && hasSiblingHints);
         if (!relayTreeDisabledForMint && !useSiblingInfo) {
           onProgress?.(`Relay tree missing index ${utxo.index} (length: ${treeLength}) with sibling cache disabled; proof may require retry after relay sync.`);
         } else if (!relayTreeDisabledForMint && relayUrl && !forceChainIndexing && utxo.index >= treeLength && !allowNearTipOnChainFallback) {
@@ -8098,9 +8283,10 @@ async function swapUtxo(params, options) {
           onProgress?.(`Relay tree is lagging (missing index ${utxo.index}, length: ${treeLength}); using guarded on-chain proof fallback.`);
         }
         if (relayUrl && !relayTreeDisabledForMint && !forceChainIndexing && utxo.index >= treeLength && !allowNearTipOnChainFallback) {
-          throw new Error(
-            `Relay tree missing required commitment index ${utxo.index} (tree length: ${treeLength}); waiting for relay sync is required.`
+          onProgress?.(
+            `Relay tree missing index ${utxo.index} (tree length: ${treeLength}) \u2014 falling through to on-chain proof.`
           );
+          allowNearTipOnChainFallback = true;
         }
         if (allowNearTipOnChainFallback && relayTreeDisabledForMint) {
           onProgress?.(
@@ -8304,10 +8490,18 @@ async function swapUtxo(params, options) {
         onProgress?.(`Merkle proof error (stale sibling data), will regenerate with fresh tree...`);
         lastError = new Error(`Circuit assertion failed: ${errorMsg}`);
         if (forceChainIndexing) {
-          onProgress?.("On-chain fallback proof failed; returning to relay-sync mode.");
-          forceChainIndexing = false;
+          onProgress?.("On-chain frontier proof failed; escalating to full chain tree rebuild...");
+          try {
+            merkleTree = await buildMerkleTreeFromChain(connection, programId, pdas.merkleTree, onProgress);
+            onProgress?.(`Chain tree rebuilt with ${merkleTree.length} leaves.`);
+          } catch (chainBuildErr) {
+            onProgress?.(`Chain tree rebuild failed (${chainBuildErr?.message?.slice(0, 80)}); returning to relay-sync mode.`);
+            forceChainIndexing = false;
+            merkleTree = null;
+          }
+        } else {
+          merkleTree = null;
         }
-        merkleTree = null;
         merkleState = null;
         useSiblingInfo = false;
         const waitMs = Math.min(retryDelayMs * Math.pow(2, Math.min(attempt, 4)), 5e3);
@@ -8502,19 +8696,26 @@ async function swapUtxo(params, options) {
     throw new Error(`Swap transaction failed: ${lastError.message}`);
   }
   if (relayUrl && outputCommitments.length >= 2) {
-    const reconcileSeedIndices = commitmentIndices[0] >= 0 && commitmentIndices[1] >= 0 ? commitmentIndices : lastObservedNextIndexForOutputs !== null ? [lastObservedNextIndexForOutputs, lastObservedNextIndexForOutputs + 1] : commitmentIndices;
-    const reconciledIndices = await reconcileCommitmentIndicesWithRelay(
-      relayUrl,
-      swapPoolMint,
-      reconcileSeedIndices,
-      [outputCommitments[0], outputCommitments[1]],
-      onProgress
-    );
-    if (reconciledIndices[0] !== commitmentIndices[0] || reconciledIndices[1] !== commitmentIndices[1]) {
+    const hasOnChainIndices = commitmentIndices[0] >= 0 && commitmentIndices[1] >= 0;
+    if (!hasOnChainIndices) {
+      const reconcileSeedIndices = lastObservedNextIndexForOutputs !== null ? [lastObservedNextIndexForOutputs, lastObservedNextIndexForOutputs + 1] : commitmentIndices;
+      const reconciledIndices = await reconcileCommitmentIndicesWithRelay(
+        relayUrl,
+        swapPoolMint,
+        reconcileSeedIndices,
+        [outputCommitments[0], outputCommitments[1]],
+        onProgress
+      );
+      if (reconciledIndices[0] !== commitmentIndices[0] || reconciledIndices[1] !== commitmentIndices[1]) {
+        onProgress?.(
+          `Adjusted swap commitment indices after relay reconciliation: [${commitmentIndices[0]}, ${commitmentIndices[1]}] -> [${reconciledIndices[0]}, ${reconciledIndices[1]}]`
+        );
+        commitmentIndices = reconciledIndices;
+      }
+    } else {
       onProgress?.(
-        `Adjusted swap commitment indices after relay reconciliation: [${commitmentIndices[0]}, ${commitmentIndices[1]}] -> [${reconciledIndices[0]}, ${reconciledIndices[1]}]`
+        `Using on-chain swap commitment indices [${commitmentIndices[0]}, ${commitmentIndices[1]}] (skipping relay reconciliation).`
       );
-      commitmentIndices = reconciledIndices;
     }
   }
   const siblingCommitments = [
@@ -8580,6 +8781,7 @@ async function swapWithChange(inputUtxos, swapAmount, outputMint, recipientAta,
 var import_bs582 = __toESM(require("bs58"), 1);
 var import_web38 = require("@solana/web3.js");
 var import_spl_token2 = require("@solana/spl-token");
+var bs582 = import_bs582.default.default || import_bs582.default;
 var TRANSACT_TAG2 = 0;
 var TRANSACT_SWAP_TAG2 = 1;
 var PROOF_LEN2 = 256;
@@ -8763,7 +8965,7 @@ function normalizeIxData(rawData) {
   if (rawData instanceof Uint8Array) return rawData;
   if (typeof rawData === "string") {
     try {
-      const decoded = import_bs582.default.decode(rawData);
+      const decoded = bs582.decode(rawData);
       return new Uint8Array(decoded);
     } catch {
       if (typeof Buffer !== "undefined") {
@@ -9669,7 +9871,7 @@ var SimpleWallet = class {
 };
 
 // src/index.ts
-var VERSION = "1.0.0";
+var VERSION = "0.1.5";
 var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -9687,12 +9889,15 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   MemoryStorageAdapter,
   MerkleTree,
   NATIVE_SOL_MINT,
+  RelayInternalError,
   RelayService,
   RootNotFoundError,
   SCANNER_SUPPORTS_TRANSACT_SWAP,
   SIGN_IN_MESSAGE,
+  SanctionsQuoteError,
   ShieldPoolErrors,
   SimpleWallet,
+  UtxoAlreadySpentError,
   UtxoWallet,
   VARIABLE_FEE_DENOMINATOR,
   VARIABLE_FEE_NUMERATOR,
@@ -9711,6 +9916,7 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   calculateRelayFee,
   chainNoteFromBase64,
   chainNoteToBase64,
+  classifyRelayError,
   cleanupStalePendingOperations,
   clearPendingDeposits,
   clearPendingWithdrawals,
@@ -9823,6 +10029,7 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   partialWithdraw,
   poseidonHash,
   preflightCheck,
+  preflightNullifiers,
   prepareEncryptedOutput,
   prepareEncryptedOutputForRecipient,
   proofToBytes,
@@ -9870,6 +10077,7 @@ var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
   validateWithdrawableNote,
   verifyAllCircuits,
   verifyCircuitIntegrity,
+  verifyUtxos,
   waitForRoot,
   withTiming
 });