@cloak.dev/sdk 0.1.2 → 0.1.4

package/dist/index.cjs

@@ -4978,6 +4978,7 @@ 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;
@@ -5177,7 +5178,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")));
@@ -6083,6 +6084,7 @@ function collectLookupCandidatesFromInstructions(instructions, payer, existingAl
 }
 async function createEphemeralALT(connection, depositor, onProgress, additionalAddresses = []) {
   const MAX_ALT_ADDRESSES = 20;
+  const MAX_ALT_CREATE_RETRIES = 3;
   const altAddresses = dedupePubkeys([
     ...getCommonALTAddresses(),
     ...additionalAddresses
@@ -6093,46 +6095,59 @@ async function createEphemeralALT(connection, depositor, onProgress, additionalA
       `ALT address set truncated (${addressesForCreate.length}/${altAddresses.length}); packet savings may be limited.`
     );
   }
-  const slot = await connection.getSlot();
-  const [createIx, altAddress] = import_web37.AddressLookupTableProgram.createLookupTable({
-    authority: depositor.publicKey,
-    payer: depositor.publicKey,
-    recentSlot: slot
-  });
-  const extendIx = import_web37.AddressLookupTableProgram.extendLookupTable({
-    payer: depositor.publicKey,
-    authority: depositor.publicKey,
-    lookupTable: altAddress,
-    addresses: addressesForCreate
-  });
-  const tx = new import_web37.Transaction().add(createIx).add(extendIx);
-  const { blockhash } = await connection.getLatestBlockhash();
-  tx.recentBlockhash = blockhash;
-  tx.feePayer = depositor.publicKey;
-  if (depositor.keypair) {
-    await (0, import_web37.sendAndConfirmTransaction)(connection, tx, [depositor.keypair], { commitment: "confirmed" });
-  } else if (depositor.signTransaction) {
-    const signedTx = await depositor.signTransaction(tx);
-    const sig = await connection.sendRawTransaction(signedTx.serialize());
-    const latestBH = await connection.getLatestBlockhash();
-    await connection.confirmTransaction({ signature: sig, blockhash: latestBH.blockhash, lastValidBlockHeight: latestBH.lastValidBlockHeight }, "confirmed");
-  } else {
-    throw new Error("Cannot create ALT: no signing method provided");
-  }
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 500));
-    const result = await connection.getAddressLookupTable(altAddress);
-    if (result.value && result.value.isActive()) {
-      onProgress?.(`ALT created and active: ${altAddress.toBase58()}`);
-      return [result.value];
+  for (let altAttempt = 0; altAttempt < MAX_ALT_CREATE_RETRIES; altAttempt++) {
+    try {
+      const slot = await connection.getSlot("finalized");
+      const [createIx, altAddress] = import_web37.AddressLookupTableProgram.createLookupTable({
+        authority: depositor.publicKey,
+        payer: depositor.publicKey,
+        recentSlot: slot
+      });
+      const extendIx = import_web37.AddressLookupTableProgram.extendLookupTable({
+        payer: depositor.publicKey,
+        authority: depositor.publicKey,
+        lookupTable: altAddress,
+        addresses: addressesForCreate
+      });
+      const tx = new import_web37.Transaction().add(createIx).add(extendIx);
+      const { blockhash } = await connection.getLatestBlockhash();
+      tx.recentBlockhash = blockhash;
+      tx.feePayer = depositor.publicKey;
+      if (depositor.keypair) {
+        await (0, import_web37.sendAndConfirmTransaction)(connection, tx, [depositor.keypair], { commitment: "confirmed" });
+      } else if (depositor.signTransaction) {
+        const signedTx = await depositor.signTransaction(tx);
+        const sig = await connection.sendRawTransaction(signedTx.serialize());
+        const latestBH = await connection.getLatestBlockhash();
+        await connection.confirmTransaction({ signature: sig, blockhash: latestBH.blockhash, lastValidBlockHeight: latestBH.lastValidBlockHeight }, "confirmed");
+      } else {
+        throw new Error("Cannot create ALT: no signing method provided");
+      }
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        const result = await connection.getAddressLookupTable(altAddress);
+        if (result.value && result.value.isActive()) {
+          onProgress?.(`ALT created and active: ${altAddress.toBase58()}`);
+          return [result.value];
+        }
+      }
+      const finalResult = await connection.getAddressLookupTable(altAddress);
+      if (finalResult.value) {
+        onProgress?.("ALT created (activation pending)");
+        return [finalResult.value];
+      }
+      throw new Error("Failed to create ALT: not active after 15 seconds");
+    } catch (err) {
+      const msg = err?.message ?? String(err);
+      if (msg.includes("not a recent slot") && altAttempt < MAX_ALT_CREATE_RETRIES - 1) {
+        onProgress?.(`ALT creation failed (stale slot), retrying (${altAttempt + 2}/${MAX_ALT_CREATE_RETRIES})...`);
+        await new Promise((r) => setTimeout(r, 2e3));
+        continue;
+      }
+      throw err;
     }
   }
-  const finalResult = await connection.getAddressLookupTable(altAddress);
-  if (finalResult.value) {
-    onProgress?.("ALT created (activation pending)");
-    return [finalResult.value];
-  }
-  throw new Error("Failed to create ALT: not active after 15 seconds");
+  throw new Error(`Failed to create ALT after ${MAX_ALT_CREATE_RETRIES} retries`);
 }
 async function submitTransactionDirect(connection, programId, depositor, proofBytes, publicInputsBytes, nullifiers, mint, recipient, riskOracleQueue, riskQuoteUrl, getRiskQuoteInstruction, onProgress, addressLookupTableAccounts, rangeApiKey, encryptedNoteBytes, relayUrl, altAddresses) {
   onProgress?.("Building transaction...");
@@ -6163,6 +6178,10 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
     onProgress?.("Creating address lookup table (chain notes require v0 tx to fit)...");
     addressLookupTableAccounts = await createEphemeralALT(connection, depositor, onProgress);
   }
+  if (isDeposit && isSplPool && (!addressLookupTableAccounts || addressLookupTableAccounts.length === 0)) {
+    onProgress?.("Creating address lookup table (SPL deposit requires v0 tx)...");
+    addressLookupTableAccounts = await createEphemeralALT(connection, depositor, onProgress);
+  }
   const publicAmountBytes = publicInputsBytes.slice(32, 40);
   const publicAmountBuffer = Buffer.from(publicAmountBytes);
   const publicAmount = publicAmountBuffer.readBigInt64LE(0);
@@ -6797,7 +6816,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;
@@ -6822,7 +6841,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) {
@@ -6953,7 +6972,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) {
@@ -6964,9 +6983,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?.(
@@ -7200,11 +7220,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) {
@@ -7551,19 +7579,26 @@ async function transact(params, options) {
     throw new Error(`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,
-      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 = [
@@ -7916,7 +7951,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;
@@ -7941,7 +7976,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) {
@@ -8069,7 +8104,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) {
@@ -8080,9 +8115,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?.(
@@ -8286,10 +8322,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);
@@ -8484,19 +8528,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 = [
@@ -8562,6 +8613,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;
@@ -8745,7 +8797,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") {

package/dist/index.js

@@ -4517,7 +4517,8 @@ async function buildMerkleTree(commitments, height = MERKLE_TREE_HEIGHT2) {
 }
 
 // src/utils/relay-client.ts
-import bs58 from "bs58";
+import _bs58 from "bs58";
+var bs58 = _bs58.default || _bs58;
 var TRANSACT_TAG = 0;
 var TRANSACT_SWAP_TAG = 1;
 var DEPOSIT_TAG = 1;
@@ -5636,6 +5637,7 @@ function collectLookupCandidatesFromInstructions(instructions, payer, existingAl
 }
 async function createEphemeralALT(connection, depositor, onProgress, additionalAddresses = []) {
   const MAX_ALT_ADDRESSES = 20;
+  const MAX_ALT_CREATE_RETRIES = 3;
   const altAddresses = dedupePubkeys([
     ...getCommonALTAddresses(),
     ...additionalAddresses
@@ -5646,46 +5648,59 @@ async function createEphemeralALT(connection, depositor, onProgress, additionalA
       `ALT address set truncated (${addressesForCreate.length}/${altAddresses.length}); packet savings may be limited.`
     );
   }
-  const slot = await connection.getSlot();
-  const [createIx, altAddress] = AddressLookupTableProgram.createLookupTable({
-    authority: depositor.publicKey,
-    payer: depositor.publicKey,
-    recentSlot: slot
-  });
-  const extendIx = AddressLookupTableProgram.extendLookupTable({
-    payer: depositor.publicKey,
-    authority: depositor.publicKey,
-    lookupTable: altAddress,
-    addresses: addressesForCreate
-  });
-  const tx = new Transaction3().add(createIx).add(extendIx);
-  const { blockhash } = await connection.getLatestBlockhash();
-  tx.recentBlockhash = blockhash;
-  tx.feePayer = depositor.publicKey;
-  if (depositor.keypair) {
-    await sendAndConfirmTransaction(connection, tx, [depositor.keypair], { commitment: "confirmed" });
-  } else if (depositor.signTransaction) {
-    const signedTx = await depositor.signTransaction(tx);
-    const sig = await connection.sendRawTransaction(signedTx.serialize());
-    const latestBH = await connection.getLatestBlockhash();
-    await connection.confirmTransaction({ signature: sig, blockhash: latestBH.blockhash, lastValidBlockHeight: latestBH.lastValidBlockHeight }, "confirmed");
-  } else {
-    throw new Error("Cannot create ALT: no signing method provided");
-  }
-  for (let i = 0; i < 30; i++) {
-    await new Promise((r) => setTimeout(r, 500));
-    const result = await connection.getAddressLookupTable(altAddress);
-    if (result.value && result.value.isActive()) {
-      onProgress?.(`ALT created and active: ${altAddress.toBase58()}`);
-      return [result.value];
+  for (let altAttempt = 0; altAttempt < MAX_ALT_CREATE_RETRIES; altAttempt++) {
+    try {
+      const slot = await connection.getSlot("finalized");
+      const [createIx, altAddress] = AddressLookupTableProgram.createLookupTable({
+        authority: depositor.publicKey,
+        payer: depositor.publicKey,
+        recentSlot: slot
+      });
+      const extendIx = AddressLookupTableProgram.extendLookupTable({
+        payer: depositor.publicKey,
+        authority: depositor.publicKey,
+        lookupTable: altAddress,
+        addresses: addressesForCreate
+      });
+      const tx = new Transaction3().add(createIx).add(extendIx);
+      const { blockhash } = await connection.getLatestBlockhash();
+      tx.recentBlockhash = blockhash;
+      tx.feePayer = depositor.publicKey;
+      if (depositor.keypair) {
+        await sendAndConfirmTransaction(connection, tx, [depositor.keypair], { commitment: "confirmed" });
+      } else if (depositor.signTransaction) {
+        const signedTx = await depositor.signTransaction(tx);
+        const sig = await connection.sendRawTransaction(signedTx.serialize());
+        const latestBH = await connection.getLatestBlockhash();
+        await connection.confirmTransaction({ signature: sig, blockhash: latestBH.blockhash, lastValidBlockHeight: latestBH.lastValidBlockHeight }, "confirmed");
+      } else {
+        throw new Error("Cannot create ALT: no signing method provided");
+      }
+      for (let i = 0; i < 30; i++) {
+        await new Promise((r) => setTimeout(r, 500));
+        const result = await connection.getAddressLookupTable(altAddress);
+        if (result.value && result.value.isActive()) {
+          onProgress?.(`ALT created and active: ${altAddress.toBase58()}`);
+          return [result.value];
+        }
+      }
+      const finalResult = await connection.getAddressLookupTable(altAddress);
+      if (finalResult.value) {
+        onProgress?.("ALT created (activation pending)");
+        return [finalResult.value];
+      }
+      throw new Error("Failed to create ALT: not active after 15 seconds");
+    } catch (err) {
+      const msg = err?.message ?? String(err);
+      if (msg.includes("not a recent slot") && altAttempt < MAX_ALT_CREATE_RETRIES - 1) {
+        onProgress?.(`ALT creation failed (stale slot), retrying (${altAttempt + 2}/${MAX_ALT_CREATE_RETRIES})...`);
+        await new Promise((r) => setTimeout(r, 2e3));
+        continue;
+      }
+      throw err;
     }
   }
-  const finalResult = await connection.getAddressLookupTable(altAddress);
-  if (finalResult.value) {
-    onProgress?.("ALT created (activation pending)");
-    return [finalResult.value];
-  }
-  throw new Error("Failed to create ALT: not active after 15 seconds");
+  throw new Error(`Failed to create ALT after ${MAX_ALT_CREATE_RETRIES} retries`);
 }
 async function submitTransactionDirect(connection, programId, depositor, proofBytes, publicInputsBytes, nullifiers, mint, recipient, riskOracleQueue, riskQuoteUrl, getRiskQuoteInstruction, onProgress, addressLookupTableAccounts, rangeApiKey, encryptedNoteBytes, relayUrl, altAddresses) {
   onProgress?.("Building transaction...");
@@ -5716,6 +5731,10 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
     onProgress?.("Creating address lookup table (chain notes require v0 tx to fit)...");
     addressLookupTableAccounts = await createEphemeralALT(connection, depositor, onProgress);
   }
+  if (isDeposit && isSplPool && (!addressLookupTableAccounts || addressLookupTableAccounts.length === 0)) {
+    onProgress?.("Creating address lookup table (SPL deposit requires v0 tx)...");
+    addressLookupTableAccounts = await createEphemeralALT(connection, depositor, onProgress);
+  }
   const publicAmountBytes = publicInputsBytes.slice(32, 40);
   const publicAmountBuffer = Buffer.from(publicAmountBytes);
   const publicAmount = publicAmountBuffer.readBigInt64LE(0);
@@ -6350,7 +6369,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;
@@ -6375,7 +6394,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) {
@@ -6506,7 +6525,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) {
@@ -6517,9 +6536,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?.(
@@ -6753,11 +6773,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) {
@@ -7104,19 +7132,26 @@ async function transact(params, options) {
     throw new Error(`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,
-      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 = [
@@ -7469,7 +7504,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;
@@ -7494,7 +7529,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) {
@@ -7622,7 +7657,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) {
@@ -7633,9 +7668,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?.(
@@ -7839,10 +7875,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);
@@ -8037,19 +8081,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 = [
@@ -8112,11 +8163,12 @@ async function swapWithChange(inputUtxos, swapAmount, outputMint, recipientAta,
 }
 
 // src/core/scanner.ts
-import bs582 from "bs58";
+import _bs582 from "bs58";
 import {
   PublicKey as PublicKey7
 } from "@solana/web3.js";
 import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2 } from "@solana/spl-token";
+var bs582 = _bs582.default || _bs582;
 var TRANSACT_TAG2 = 0;
 var TRANSACT_SWAP_TAG2 = 1;
 var PROOF_LEN2 = 256;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@cloak.dev/sdk",
-  "description": "TypeScript SDK for Cloak",
-  "version": "0.1.2",
+  "description": "Shield, send, and swap on Solana privately — TypeScript SDK with UTXO-based zero-knowledge transactions",
+  "version": "0.1.4",
   "type": "module",
   "main": "dist/index.cjs",
   "module": "dist/index.js",
@@ -47,7 +47,7 @@
     "web3",
     "blockchain"
   ],
-  "author": "Cloak Labs",
+  "author": "Cloak",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -61,15 +61,15 @@
     "@jup-ag/api": "^6.0.48",
     "@lightprotocol/hasher.rs": "^0.2.1",
     "@noble/hashes": "^1.8.0",
-    "@solana/spl-token": "^0.4.0",
-    "@solana/web3.js": "^1.0.0",
+    "@solana/spl-token": "0.4.14",
+    "@solana/web3.js": "^1.98.0",
     "bs58": "^6.0.0",
-    "circomlibjs": "^0.1.7",
+    "circomlibjs": "0.1.7",
     "ffjavascript": "^0.3.0",
-    "snarkjs": "^0.7.4",
+    "snarkjs": "0.7.6",
     "tweetnacl": "^1.0.3",
     "tweetnacl-util": "^0.15.1",
-    "yaml": "^2.8.2"
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
     "@coral-xyz/anchor": "^0.32.1",
@@ -86,8 +86,8 @@
   "peerDependencies": {
     "@switchboard-xyz/common": "^5.6.1",
     "@switchboard-xyz/on-demand": "^3.8.2",
-    "@solana/spl-token": "^0.4.0",
-    "@solana/web3.js": "^1.0.0"
+    "@solana/spl-token": ">=0.4.9",
+    "@solana/web3.js": ">=1.98.0"
   },
   "peerDependenciesMeta": {
     "@switchboard-xyz/common": {