@cloak.dev/sdk 0.2.2 → 0.2.3-staging.005e3de

package/dist/index.js

@@ -577,9 +577,9 @@ var LocalStorageAdapter = class {
 };
 
 // src/scanning/compliance-keys.ts
-import nacl2 from "tweetnacl";
+import nacl3 from "tweetnacl";
 import { blake3 as blake32 } from "@noble/hashes/blake3";
-import { sha256 } from "@noble/hashes/sha2";
+import { sha256 as sha2562 } from "@noble/hashes/sha2";
 
 // src/relay/viewing-key.ts
 var VIEWING_KEY_CHALLENGE_PREFIX = "CLOAK_VIEWING_KEY_REGISTER";
@@ -621,7 +621,7 @@ function parseStrictViewingKeyChallenge(response, userPubkey, viewingKeyHex) {
 
 // src/config/relay.ts
 var CLOAK_PRODUCTION_RELAY_URL = "https://api.cloak.ag";
-var RELAY_ORIGIN_ALLOWLIST = [CLOAK_PRODUCTION_RELAY_URL];
+var RELAY_ORIGIN_ALLOWLIST = ["https://staging-api.cloak.ag"];
 var ABSOLUTE_URL = /^[a-z][a-z0-9+.-]*:\/\//i;
 var LOOPBACK_IPV4 = /^127\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
 var THIS_NETWORK_IPV4 = /^0\.\d{1,3}\.\d{1,3}\.\d{1,3}$/;
@@ -766,6 +766,275 @@ function connectionRpcEndpoint(connection) {
   return connection?._rpcEndpoint ?? connection?.rpcEndpoint;
 }
 
+// src/relay/payload.ts
+import { sha256 } from "@noble/hashes/sha2";
+import { bytesToHex as bytesToHex2 } from "@noble/hashes/utils";
+import nacl2 from "tweetnacl";
+import { Keypair, PublicKey as PublicKey3, SystemProgram, Transaction } from "@solana/web3.js";
+var REQUEST_AUTH_DOMAIN = "CLOAK_RELAY_REQUEST_AUTH_V1";
+var REQUEST_AUTH_MAX_AGE_SECONDS = 300;
+var REQUEST_AUTH_MAX_FUTURE_SKEW_SECONDS = 30;
+var RELAY_AUTH_APPROVAL_MARGIN_SECONDS = 15;
+function sha256Hex(text) {
+  return bytesToHex2(sha256(new TextEncoder().encode(text)));
+}
+function randomNonceUuid() {
+  const webCrypto = globalThis?.crypto;
+  if (typeof webCrypto?.randomUUID === "function") return webCrypto.randomUUID();
+  const proc = globalThis?.process;
+  const nodeCrypto = typeof proc?.getBuiltinModule === "function" ? proc.getBuiltinModule("node:crypto") : void 0;
+  if (typeof nodeCrypto?.randomUUID === "function") return nodeCrypto.randomUUID();
+  const bytes = randomBytes(16);
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = bytesToHex2(bytes);
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+var TRANSACT_AUTH_FIELDS = [
+  "encrypted_notes",
+  "max_fee",
+  "mint",
+  "proof_bytes",
+  "public_inputs",
+  "recipient",
+  "recipient_delivery_notes",
+  "risk_quote",
+  "sender"
+];
+var TRANSACT_SWAP_AUTH_FIELDS = [
+  "close_timed_out",
+  "dexes",
+  "encrypted_notes",
+  "exclude_dexes",
+  "max_fee",
+  "min_output_amount",
+  "output_mint",
+  "proof_bytes",
+  "public_inputs",
+  "recipient",
+  "recipient_ata",
+  "refund_blinding",
+  "refund_pubkey",
+  "retry_request_id",
+  "risk_quote",
+  "route_retry_attempts",
+  "sender",
+  "slippage_bps",
+  "swap_max_retries"
+];
+var UTF8 = new TextEncoder();
+function compareKeysBytewise(a, b) {
+  if (a === b) return 0;
+  const ab = UTF8.encode(a);
+  const bb = UTF8.encode(b);
+  const shared = Math.min(ab.length, bb.length);
+  for (let i = 0; i < shared; i++) {
+    if (ab[i] !== bb[i]) return ab[i] - bb[i];
+  }
+  return ab.length - bb.length;
+}
+function canonicalJson(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
+      throw new Error(
+        `canonicalJson: refusing to sign the number ${String(value)}. The relay renders numbers with serde_json, which spells non-integer, non-finite and very large values differently from JavaScript, so the two digests would differ and the request would be rejected with an unexplained 401. Send it as a decimal string instead, which is how every amount in this schema travels.`
+      );
+    }
+    return String(value);
+  }
+  if (typeof value === "bigint") return value.toString();
+  if (typeof value === "string") return JSON.stringify(value);
+  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj).sort(compareKeysBytewise);
+    return "{" + keys.map((k) => {
+      const v = obj[k];
+      if (typeof v === "function" || typeof v === "symbol") {
+        throw new Error(
+          `canonicalJson: the key "${k}" holds a ${typeof v}, which has no JSON representation. JSON.stringify would drop it from the wire body while it stayed in the signed view, so the relay's digest could never match this one.`
+        );
+      }
+      return `${JSON.stringify(k)}:${canonicalJson(v)}`;
+    }).join(",") + "}";
+  }
+  throw new Error(`canonicalJson: unsupported value of type ${typeof value}`);
+}
+var FIELDS_WITHOUT_NULL_ENCODING = {
+  slippage_bps: "500 (`default_slippage_bps` in api/transact_swap.rs)"
+};
+function buildAuthRequest(body, sender, fields) {
+  const out = {};
+  for (const k of fields) {
+    if (k === "sender") {
+      out[k] = sender;
+      continue;
+    }
+    const value = body[k];
+    if (value === void 0 || value === null) {
+      const relayDefault = FIELDS_WITHOUT_NULL_ENCODING[k];
+      if (relayDefault) {
+        throw new Error(
+          `Relay request auth: \`${k}\` must be present in the body. It is the one field in this schema that is not optional on the relay side: when it is missing the relay signs its default, ${relayDefault}, while this request would sign null. The two digests differ and the relay answers 401 "Relay request signature does not match the exact request", which points at nothing. Set \`${k}\` explicitly, to the same value the body will carry.`
+        );
+      }
+      out[k] = null;
+      continue;
+    }
+    out[k] = value;
+  }
+  return out;
+}
+function buildRequestAuthMessage(endpoint, programId, issuedAt, nonce, request) {
+  const digest = sha256Hex(canonicalJson(request));
+  return new TextEncoder().encode(
+    `${REQUEST_AUTH_DOMAIN}
+${endpoint}
+${programId.toBase58()}
+${nonce}
+${issuedAt}
+${digest}`
+  );
+}
+function buildRelayAuthPreimage(endpoint, programId, body, sender, nowSeconds, fields = TRANSACT_AUTH_FIELDS) {
+  const senderB58 = sender.toBase58();
+  const issuedAt = String(nowSeconds ?? Math.floor(Date.now() / 1e3));
+  const nonce = randomNonceUuid();
+  const request = buildAuthRequest({ ...body, sender: senderB58 }, senderB58, fields);
+  const message = buildRequestAuthMessage(endpoint, programId, issuedAt, nonce, request);
+  return { sender: senderB58, auth_issued_at: issuedAt, auth_nonce: nonce, message };
+}
+function signRelayRequest(endpoint, programId, body, signer, nowSeconds, fields = TRANSACT_AUTH_FIELDS) {
+  const preimage = buildRelayAuthPreimage(
+    endpoint,
+    programId,
+    body,
+    signer.publicKey,
+    nowSeconds,
+    fields
+  );
+  const signature = nacl2.sign.detached(preimage.message, signer.secretKey);
+  return {
+    sender: preimage.sender,
+    auth_issued_at: preimage.auth_issued_at,
+    auth_nonce: preimage.auth_nonce,
+    auth_signature: Buffer.from(signature).toString("base64")
+  };
+}
+function buildAuthTransactionMessage(sender, digest) {
+  if (digest.length !== 32) throw new Error(`auth transaction digest must be 32 bytes (got ${digest.length})`);
+  const tx = new Transaction();
+  tx.add(SystemProgram.transfer({ fromPubkey: sender, toPubkey: sender, lamports: 0 }));
+  tx.feePayer = sender;
+  tx.recentBlockhash = new PublicKey3(digest).toBase58();
+  return tx;
+}
+function serializeAuthTransactionMessage(sender, digest) {
+  return Uint8Array.from(buildAuthTransactionMessage(sender, digest).compileMessage().serialize());
+}
+async function signRelayAuthPayload(signer, payload) {
+  if (signer instanceof Keypair) {
+    return { signature: nacl2.sign.detached(payload, signer.secretKey), mode: "message" };
+  }
+  if (signer.signMessage) {
+    const signature = await signer.signMessage(payload);
+    assertDetachedSignature(signature, "signMessage");
+    return { signature, mode: "message" };
+  }
+  if (signer.signAuthTransaction) {
+    const digest = sha256(payload);
+    const signed = await signer.signAuthTransaction(buildAuthTransactionMessage(signer.walletPublicKey, digest));
+    const own = signed.signatures.find((s) => s.publicKey.equals(signer.walletPublicKey))?.signature;
+    if (!own) {
+      throw new Error(
+        "The wallet returned no signature for the Cloak auth transaction. Nothing was submitted."
+      );
+    }
+    const signature = Uint8Array.from(own);
+    assertDetachedSignature(signature, "signTransaction");
+    return { signature, mode: "transaction" };
+  }
+  throw new Error("Relay auth signer has neither signMessage nor signAuthTransaction.");
+}
+function assertDetachedSignature(signature, method) {
+  if (!(signature instanceof Uint8Array) || signature.length !== 64) {
+    throw new Error(
+      `The wallet's ${method} did not return a 64-byte ed25519 detached signature (got ${signature instanceof Uint8Array ? `${signature.length} bytes` : typeof signature}). Cloak signs with a raw detached signature over the bytes it hands the wallet; adapters that wrap or re-encode the result cannot be used here.`
+    );
+  }
+}
+function assertApprovalWithinFreshnessWindow(elapsedMs, maxAgeSeconds = REQUEST_AUTH_MAX_AGE_SECONDS) {
+  const elapsedSeconds = elapsedMs / 1e3;
+  const budget = maxAgeSeconds - RELAY_AUTH_APPROVAL_MARGIN_SECONDS;
+  if (elapsedSeconds <= budget) return;
+  throw new Error(
+    `The wallet approval took ${Math.round(elapsedSeconds)} seconds, and Cloak requests stay valid for ${maxAgeSeconds} seconds from the moment they are signed (${RELAY_AUTH_APPROVAL_MARGIN_SECONDS} of those are held back for the request to reach the network). The timestamp is inside the signature, so it cannot be refreshed without your approval again. NOTHING WAS SUBMITTED and no funds moved. Start the same operation again and approve the prompt when it appears.`
+  );
+}
+function explainRelayAuthRejection(responseText) {
+  const text = String(responseText);
+  const has = (needle) => text.includes(needle);
+  if (has("issued too far in the future")) {
+    return `This computer's clock is more than ${REQUEST_AUTH_MAX_FUTURE_SKEW_SECONDS} seconds ahead of the network's, so the request looks like it was signed in the future and is refused before anything else happens. Turn on automatic date and time (or resynchronise the clock) and try again. Nothing was submitted.`;
+  }
+  if (has("signature expired")) {
+    return `The request was signed more than ${REQUEST_AUTH_MAX_AGE_SECONDS} seconds before it arrived, usually because a wallet approval was left waiting, or because this computer's clock is running behind. The signed timestamp cannot be refreshed on its own. Start the operation again. Nothing was submitted.`;
+  }
+  if (has("does not match the exact request")) {
+    return `The request body changed after it was signed, so the relay's digest and this one disagree. Sign the exact body that is POSTed, and re-POST a retry byte for byte rather than rebuilding it. If this is a hand-built swap call, check that every field in TRANSACT_SWAP_AUTH_FIELDS is present, including \`slippage_bps\`.`;
+  }
+  if (has("has no registered viewing key")) {
+    return `The signature was accepted, so this is not a signing problem: the wallet that signed has no viewing key registered with Cloak yet. Register one first, or let the SDK do it by leaving \`enforceViewingKeyRegistration\` on and supplying the viewing key.`;
+  }
+  if (has("Authenticated sender is required") || has("auth_issued_at is required") || has("auth_nonce is required") || has("auth_signature is required")) {
+    return `The request reached the relay without its authentication fields. Pass \`depositorKeypair\`, or \`signMessage\` together with \`walletPublicKey\`, so the request can be signed.`;
+  }
+  if (has("auth_nonce must be a canonical UUID")) {
+    return `\`auth_nonce\` must be a canonical lowercase UUID. Reuse the one from the preimage.`;
+  }
+  if (has("Relay request signature must be exactly 64 bytes") || has("Invalid relay request signature encoding")) {
+    return `\`auth_signature\` must be the raw 64-byte ed25519 detached signature, base64 encoded. Wallet adapters that wrap or re-encode what \`signMessage\` returns cannot be used here.`;
+  }
+  return null;
+}
+async function buildRelayAuthFields(endpoint, programId, body, signers, fields = TRANSACT_AUTH_FIELDS) {
+  if (signers.depositorKeypair) {
+    return signRelayRequest(endpoint, programId, body, signers.depositorKeypair, void 0, fields);
+  }
+  const wallet = signers.relayAuthSigner;
+  if (!wallet) return null;
+  const preimage = buildRelayAuthPreimage(
+    endpoint,
+    programId,
+    body,
+    wallet.walletPublicKey,
+    void 0,
+    fields
+  );
+  const approvalStartedMs = Date.now();
+  const { signature, mode } = await signRelayAuthPayload(wallet, preimage.message);
+  assertApprovalWithinFreshnessWindow(Date.now() - approvalStartedMs);
+  return {
+    sender: preimage.sender,
+    auth_issued_at: preimage.auth_issued_at,
+    auth_nonce: preimage.auth_nonce,
+    auth_signature: Buffer.from(signature).toString("base64"),
+    ...mode === "transaction" ? { auth_mode: mode } : {}
+  };
+}
+var REQUEST_AUTH_BATCH_DOMAIN = "CLOAK_RELAY_BATCH_AUTH_V1";
+var REQUEST_AUTH_BATCH_MAX_AGE_SECONDS = 600;
+var RELAY_BATCH_AUTH_MAX_ITEMS = 64;
+function relayRequestDigestHex(preimage) {
+  return bytesToHex2(sha256(preimage.message));
+}
+function buildRelayBatchAuthMessage(programId, issuedAt, digests) {
+  const lines = [REQUEST_AUTH_BATCH_DOMAIN, programId.toBase58(), issuedAt, String(digests.length)];
+  return new TextEncoder().encode([...lines, ...digests].join("\n"));
+}
+
 // src/scanning/compliance-keys.ts
 var X25519_KEY_LENGTH = 32;
 var DIVERSIFIER_LENGTH = 11;
@@ -803,7 +1072,7 @@ function deriveViewingKeyFromNk(nk) {
   preimage.set(nk, CHAIN_NOTE_VK_DOMAIN.length);
   const derived = blake32(preimage);
   const privateKey = clampX25519Secret(derived);
-  const publicKey = nacl2.scalarMult.base(privateKey);
+  const publicKey = nacl3.scalarMult.base(privateKey);
   return { privateKey, publicKey };
 }
 function deriveDiversifier(nk, commitmentHex, outputIndex) {
@@ -838,7 +1107,7 @@ function deriveDiversifiedViewingKey(nk, diversifier) {
   preimage.set(diversifier, SK_D_DOMAIN.length + nk.length);
   const derived = blake32(preimage);
   const privateKey = clampX25519Secret(derived);
-  const publicKey = nacl2.scalarMult.base(privateKey);
+  const publicKey = nacl3.scalarMult.base(privateKey);
   return { privateKey, publicKey };
 }
 function deriveViewingKeyFromSpendKey(skSpend) {
@@ -901,19 +1170,19 @@ async function deriveUserCompliancePublicKey(masterCompliancePublicKey, userPubl
     masterCompliancePublicKey,
     userPublicKey
   );
-  return nacl2.scalarMult(factor, masterCompliancePublicKey);
+  return nacl3.scalarMult(factor, masterCompliancePublicKey);
 }
-function bytesToHex2(bytes) {
+function bytesToHex3(bytes) {
   return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
 }
 function computeViewingKeyIdentifier(userPubkey, nkHex) {
   const preimage = new TextEncoder().encode(`${userPubkey.toBase58()}${nkHex}`);
-  return bytesToHex2(sha256(preimage));
+  return bytesToHex3(sha2562(preimage));
 }
 var SIGN_IN_MESSAGE = "Cloak: Sign in\n\nSign this message to securely access your Cloak account.\nThis does NOT authorize any transaction or spend any funds.";
 async function registerViewingKey(relayUrl, userPubkey, nk, signMessage) {
   assert32Bytes(nk, "nk");
-  const nkHex = bytesToHex2(nk);
+  const nkHex = bytesToHex3(nk);
   const keyId = computeViewingKeyIdentifier(userPubkey, nkHex);
   const challengeResponse = await relayFetch(`${relayUrl}/viewing-key/challenge`, {
     method: "POST",
@@ -934,8 +1203,11 @@ async function registerViewingKey(relayUrl, userPubkey, nk, signMessage) {
     nkHex
   );
   const messageBytes = new TextEncoder().encode(challenge.message);
-  const signatureBytes = await signMessage(messageBytes);
-  const signature = Buffer.from(signatureBytes).toString("base64");
+  const signed = await signRelayAuthPayload(
+    typeof signMessage === "function" ? { walletPublicKey: userPubkey, signMessage } : signMessage,
+    messageBytes
+  );
+  const signature = Buffer.from(signed.signature).toString("base64");
   const response = await relayFetch(`${relayUrl}/viewing-key/register`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -944,7 +1216,8 @@ async function registerViewingKey(relayUrl, userPubkey, nk, signMessage) {
       viewing_key: nkHex,
       nonce: challenge.nonce,
       identifier: keyId,
-      signature
+      signature,
+      ...signed.mode === "transaction" ? { auth_mode: signed.mode } : {}
     })
   });
   if (!response.ok) {
@@ -953,7 +1226,7 @@ async function registerViewingKey(relayUrl, userPubkey, nk, signMessage) {
 }
 
 // src/scanning/metadata-encryption.ts
-import nacl3 from "tweetnacl";
+import nacl4 from "tweetnacl";
 var AES_GCM_NONCE_LENGTH = 12;
 var AES_GCM_TAG_LENGTH = 16;
 var X25519_KEY_LENGTH2 = 32;
@@ -1050,8 +1323,8 @@ async function aesGcmDecrypt(ciphertext, keyBytes, nonce) {
 }
 async function encryptForRecipient(plaintext, recipientPublicKey) {
   assert32Bytes2(recipientPublicKey, "recipientPublicKey");
-  const ephemeral = nacl3.box.keyPair();
-  const sharedSecret = nacl3.scalarMult(ephemeral.secretKey, recipientPublicKey);
+  const ephemeral = nacl4.box.keyPair();
+  const sharedSecret = nacl4.scalarMult(ephemeral.secretKey, recipientPublicKey);
   const nonce = randomBytes(AES_GCM_NONCE_LENGTH);
   const ciphertext = await aesGcmEncrypt(plaintext, sharedSecret, nonce);
   return {
@@ -1110,7 +1383,7 @@ async function encryptTransactionMetadataBundle(metadata, viewingKeyPrivate, use
   const plaintext = new TextEncoder().encode(JSON.stringify(metadata));
   const basePoint = new Uint8Array(32);
   basePoint[0] = 9;
-  const viewingKeyPublic = nacl3.scalarMult(viewingKeyPrivate, basePoint);
+  const viewingKeyPublic = nacl4.scalarMult(viewingKeyPrivate, basePoint);
   const [userPayload, compliancePayload] = await Promise.all([
     encryptForRecipient(plaintext, viewingKeyPublic),
     encryptForRecipient(plaintext, viewingKeyPublic)
@@ -1129,7 +1402,7 @@ async function decryptTransactionMetadata(encrypted, viewKeySecret) {
   const payload = decodePayload(encrypted);
   const ephemeralPk = hexToBytes(payload.ephemeral_pk);
   assert32Bytes2(ephemeralPk, "ephemeral public key");
-  const sharedSecret = nacl3.scalarMult(viewKeySecret, ephemeralPk);
+  const sharedSecret = nacl4.scalarMult(viewKeySecret, ephemeralPk);
   return decryptWithSharedSecret(payload, sharedSecret);
 }
 async function decryptComplianceMetadataWithMasterKey(encrypted, masterCompliancePrivateKey, masterCompliancePublicKey, userPublicKey) {
@@ -1142,8 +1415,8 @@ async function decryptComplianceMetadataWithMasterKey(encrypted, masterComplianc
     masterCompliancePublicKey,
     userPublicKey
   );
-  const scaledEphemeral = nacl3.scalarMult(userFactor, ephemeralPk);
-  const sharedSecret = nacl3.scalarMult(masterCompliancePrivateKey, scaledEphemeral);
+  const scaledEphemeral = nacl4.scalarMult(userFactor, ephemeralPk);
+  const sharedSecret = nacl4.scalarMult(masterCompliancePrivateKey, scaledEphemeral);
   return decryptWithSharedSecret(payload, sharedSecret);
 }
 
@@ -2073,22 +2346,22 @@ function formatErrorForLogging(error) {
 }
 
 // src/program/pda.ts
-import { PublicKey as PublicKey3 } from "@solana/web3.js";
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
 function getShieldPoolPDAs(programId, mint = NATIVE_SOL_MINT) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  const [pool] = PublicKey3.findProgramAddressSync(
+  const [pool] = PublicKey4.findProgramAddressSync(
     [Buffer.from("pool"), mint.toBuffer()],
     pid
   );
-  const [merkleTree] = PublicKey3.findProgramAddressSync(
+  const [merkleTree] = PublicKey4.findProgramAddressSync(
     [Buffer.from("merkle_tree"), mint.toBuffer()],
     pid
   );
-  const [treasury] = PublicKey3.findProgramAddressSync(
+  const [treasury] = PublicKey4.findProgramAddressSync(
     [Buffer.from("treasury"), mint.toBuffer()],
     pid
   );
-  const [vaultAuthority] = PublicKey3.findProgramAddressSync(
+  const [vaultAuthority] = PublicKey4.findProgramAddressSync(
     [Buffer.from("vault_authority"), mint.toBuffer()],
     pid
   );
@@ -2104,7 +2377,7 @@ function getNullifierPDA(poolPubkey, nullifier, programId) {
   if (nullifier.length !== 32) {
     throw new Error(`Nullifier must be 32 bytes, got ${nullifier.length}`);
   }
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("nullifier"), poolPubkey.toBuffer(), Buffer.from(nullifier)],
     pid
   );
@@ -2114,25 +2387,25 @@ function getSwapStatePDA(poolPubkey, nullifier, programId) {
   if (nullifier.length !== 32) {
     throw new Error(`Nullifier must be 32 bytes, got ${nullifier.length}`);
   }
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("swap_state"), poolPubkey.toBuffer(), Buffer.from(nullifier)],
     pid
   );
 }
 function getPoolAuthorityConfigPDA(mint = NATIVE_SOL_MINT, programId) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  return PublicKey3.findProgramAddressSync(
+  return PublicKey4.findProgramAddressSync(
     [Buffer.from("pool_authority"), mint.toBuffer()],
     pid
   );
 }
 function getDeliveryRegistryPDA(programId) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  return PublicKey3.findProgramAddressSync([Buffer.from("cloak_delivery_registry")], pid)[0];
+  return PublicKey4.findProgramAddressSync([Buffer.from("cloak_delivery_registry")], pid)[0];
 }
 function getChainNoteRegistryPDA(programId) {
   const pid = programId || CLOAK_PROGRAM_ID;
-  return PublicKey3.findProgramAddressSync([Buffer.from("cloak_chain_note_registry")], pid)[0];
+  return PublicKey4.findProgramAddressSync([Buffer.from("cloak_chain_note_registry")], pid)[0];
 }
 
 // src/flows/verify-utxos.ts
@@ -2150,8 +2423,8 @@ async function verifyUtxos(utxos, connection, programId, commitment = "confirmed
       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 });
+      const [pda2] = getNullifierPDA(pool, nullifierBytes, programId);
+      checkable.push({ utxo, pda: pda2 });
     } catch {
       skipped.push(utxo);
     }
@@ -2221,8 +2494,8 @@ function deriveInputNullifierPdas(programId, mint, inputNullifiers) {
   const pdas = [];
   for (const nullifier of inputNullifiers) {
     if (nullifier === BigInt(0)) continue;
-    const [pda] = getNullifierPDA(pool, bigintToBytes324(nullifier), programId);
-    pdas.push(pda);
+    const [pda2] = getNullifierPDA(pool, bigintToBytes324(nullifier), programId);
+    pdas.push(pda2);
   }
   return pdas;
 }
@@ -2463,7 +2736,8 @@ function truncate(str, len = 20) {
 var sdkLogger = createLogger("cloak::sdk");
 
 // src/relay/relay-service.ts
-import { sha256 as sha2562 } from "@noble/hashes/sha2";
+import { sha256 as sha2563 } from "@noble/hashes/sha2";
+import { PublicKey as PublicKey5 } from "@solana/web3.js";
 var RelayService = class {
   /**
    * Create a new Relay Service client
@@ -2779,8 +3053,11 @@ var RelayService = class {
       userPubkey,
       viewingKey
     );
-    const signatureBytes = await signMessage(new TextEncoder().encode(challenge.message));
-    const signature = this.bytesToBase64(signatureBytes);
+    const signed = await signRelayAuthPayload(
+      typeof signMessage === "function" ? { walletPublicKey: new PublicKey5(userPubkey), signMessage } : signMessage,
+      new TextEncoder().encode(challenge.message)
+    );
+    const signature = this.bytesToBase64(signed.signature);
     const response = await relayFetch(`${this.baseUrl}/viewing-key/register`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
@@ -2789,7 +3066,8 @@ var RelayService = class {
         viewing_key: viewingKey,
         nonce: challenge.nonce,
         identifier,
-        signature
+        signature,
+        ...signed.mode === "transaction" ? { auth_mode: signed.mode } : {}
       })
     });
     if (!response.ok) {
@@ -2827,7 +3105,7 @@ var RelayService = class {
   }
   computeViewingKeyIdentifier(userPubkey, viewingKeyHex) {
     const preimage = new TextEncoder().encode(`${userPubkey}${viewingKeyHex}`);
-    const hash = sha2562(preimage);
+    const hash = sha2563(preimage);
     return Array.from(hash).map((b) => b.toString(16).padStart(2, "0")).join("");
   }
 };
@@ -2945,10 +3223,10 @@ function encodeNoteSimple(note) {
 
 // src/wallet/adapter.ts
 import {
-  Keypair
+  Keypair as Keypair2
 } from "@solana/web3.js";
 function validateWalletConnected(wallet) {
-  if (wallet instanceof Keypair) {
+  if (wallet instanceof Keypair2) {
     return;
   }
   if (!wallet.publicKey) {
@@ -2960,7 +3238,7 @@ function validateWalletConnected(wallet) {
   }
 }
 function getPublicKey(wallet) {
-  if (wallet instanceof Keypair) {
+  if (wallet instanceof Keypair2) {
     return wallet.publicKey;
   }
   if (!wallet.publicKey) {
@@ -2974,7 +3252,7 @@ function getPublicKey(wallet) {
 }
 async function sendTransaction(transaction, wallet, connection, options) {
   assertAllowedRpcConnection(connection);
-  if (wallet instanceof Keypair) {
+  if (wallet instanceof Keypair2) {
     return await connection.sendTransaction(transaction, [wallet], options);
   }
   if (wallet.sendTransaction) {
@@ -2991,7 +3269,7 @@ async function sendTransaction(transaction, wallet, connection, options) {
   }
 }
 async function signTransaction(transaction, wallet) {
-  if (wallet instanceof Keypair) {
+  if (wallet instanceof Keypair2) {
     transaction.sign(wallet);
     return transaction;
   }
@@ -3020,8 +3298,8 @@ function keypairToAdapter(keypair) {
 
 // src/program/instructions.ts
 import {
-  PublicKey as PublicKey5,
-  SystemProgram,
+  PublicKey as PublicKey7,
+  SystemProgram as SystemProgram2,
   TransactionInstruction
 } from "@solana/web3.js";
 function createDepositInstruction(params) {
@@ -3053,7 +3331,7 @@ function createDepositInstruction(params) {
       // Account 1: Pool (writable) - receives SOL
       { pubkey: params.pool, isSigner: false, isWritable: true },
       // Account 2: System Program (readonly) - for transfers
-      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: SystemProgram2.programId, isSigner: false, isWritable: false },
       // Account 3: Merkle Tree (writable) - stores on-chain Merkle tree
       { pubkey: params.merkleTree, isSigner: false, isWritable: true }
     ],
@@ -3061,16 +3339,16 @@ function createDepositInstruction(params) {
   });
 }
 function validateDepositParams(params) {
-  if (!(params.programId instanceof PublicKey5)) {
+  if (!(params.programId instanceof PublicKey7)) {
     throw new Error("programId must be a PublicKey");
   }
-  if (!(params.payer instanceof PublicKey5)) {
+  if (!(params.payer instanceof PublicKey7)) {
     throw new Error("payer must be a PublicKey");
   }
-  if (!(params.pool instanceof PublicKey5)) {
+  if (!(params.pool instanceof PublicKey7)) {
     throw new Error("pool must be a PublicKey");
   }
-  if (!(params.merkleTree instanceof PublicKey5)) {
+  if (!(params.merkleTree instanceof PublicKey7)) {
     throw new Error("merkleTree must be a PublicKey");
   }
   if (typeof params.amount !== "number" || params.amount <= 0) {
@@ -3410,7 +3688,7 @@ async function buildMerkleTree(commitments, height = MERKLE_TREE_HEIGHT2) {
 }
 
 // src/relay/client.ts
-import { PublicKey as PublicKey6 } from "@solana/web3.js";
+import { PublicKey as PublicKey8 } from "@solana/web3.js";
 import _bs58 from "bs58";
 
 // src/notes/refund-leaf.ts
@@ -3527,7 +3805,7 @@ var CLOSE_SWAP_STATE_TAG = 13;
 var CLOSE_SWAP_STATE_PHASE1_PAYLOAD_LEN = 40;
 var CLOSE_SWAP_STATE_PHASE1_WIRE_LEN = 1 + CLOSE_SWAP_STATE_PHASE1_PAYLOAD_LEN;
 var CLOSE_SWAP_STATE_COMMITMENT_END = 1 + 32;
-var NATIVE_SOL_MINT2 = new PublicKey6("So11111111111111111111111111111111111111112");
+var NATIVE_SOL_MINT2 = new PublicKey8("So11111111111111111111111111111111111111112");
 var PROOF_LEN = 256;
 var PUBLIC_INPUTS_LEN = 264;
 var COMMITMENTS_OFFSET = 168;
@@ -3543,7 +3821,7 @@ async function fetchWithRetry(url, options = {}) {
   const {
     timeoutMs = DEFAULT_TIMEOUT_MS,
     maxRetries = DEFAULT_MAX_RETRIES,
-    retryDelayMs = 1e3
+    retryDelayMs: retryDelayMs2 = 1e3
   } = options;
   assertAllowedRelayOrigin(url);
   let lastError = null;
@@ -3567,7 +3845,7 @@ async function fetchWithRetry(url, options = {}) {
           `Relay request failed after ${attempt + 1} attempts: ${lastError.message}`
         );
       }
-      const delay = retryDelayMs * Math.pow(2, attempt) + Math.random() * 500;
+      const delay = retryDelayMs2 * Math.pow(2, attempt) + Math.random() * 500;
       await new Promise((resolve) => setTimeout(resolve, delay));
     }
   }
@@ -3817,11 +4095,11 @@ async function preflightCheck(relayUrl, rootHex) {
 
 // src/flows/transact.ts
 import {
-  PublicKey as PublicKey8,
-  Transaction as Transaction2,
+  PublicKey as PublicKey10,
+  Transaction as Transaction3,
   TransactionInstruction as TransactionInstruction2,
   sendAndConfirmTransaction,
-  SystemProgram as SystemProgram2,
+  SystemProgram as SystemProgram3,
   ComputeBudgetProgram,
   SYSVAR_INSTRUCTIONS_PUBKEY,
   SYSVAR_SLOT_HASHES_PUBKEY,
@@ -4060,7 +4338,7 @@ function chainNoteFromBase64(base64) {
 }
 
 // src/notes/delivery-note.ts
-import nacl4 from "tweetnacl";
+import nacl5 from "tweetnacl";
 var RECIPIENT_DELIVERY_EPHEMERAL_PK_LEN = 32;
 var RECIPIENT_DELIVERY_NONCE_LEN = 24;
 var RECIPIENT_DELIVERY_PLAINTEXT_LEN = 40;
@@ -4111,10 +4389,10 @@ function encodeRecipientDeliveryNote(note, recipientViewingPublicKey) {
   const plaintext = new Uint8Array(RECIPIENT_DELIVERY_PLAINTEXT_LEN);
   writeU64LE2(plaintext, 0, note.amount);
   writeU256BE2(plaintext, 8, note.blinding);
-  const ephemeral = nacl4.box.keyPair();
-  const shared = nacl4.box.before(recipientViewingPublicKey, ephemeral.secretKey);
-  const nonce = nacl4.randomBytes(nacl4.secretbox.nonceLength);
-  const ciphertext = nacl4.secretbox(plaintext, nonce, shared);
+  const ephemeral = nacl5.box.keyPair();
+  const shared = nacl5.box.before(recipientViewingPublicKey, ephemeral.secretKey);
+  const nonce = nacl5.randomBytes(nacl5.secretbox.nonceLength);
+  const ciphertext = nacl5.secretbox(plaintext, nonce, shared);
   if (ciphertext.length !== RECIPIENT_DELIVERY_CIPHERTEXT_LEN) {
     throw new Error(
       `delivery ciphertext must be ${RECIPIENT_DELIVERY_CIPHERTEXT_LEN} bytes, got ${ciphertext.length}`
@@ -4140,8 +4418,8 @@ function openRecipientDeliveryNote(envelope, viewingSecretKey) {
     const ciphertext = envelope.slice(
       RECIPIENT_DELIVERY_EPHEMERAL_PK_LEN + RECIPIENT_DELIVERY_NONCE_LEN
     );
-    const shared = nacl4.box.before(ephemeralPk, viewingSecretKey);
-    const plaintext = nacl4.secretbox.open(ciphertext, nonce, shared);
+    const shared = nacl5.box.before(ephemeralPk, viewingSecretKey);
+    const plaintext = nacl5.secretbox.open(ciphertext, nonce, shared);
     if (!plaintext || plaintext.length !== RECIPIENT_DELIVERY_PLAINTEXT_LEN) return null;
     return { amount: readU64LE2(plaintext, 0), blinding: readU256BE2(plaintext, 8) };
   } catch {
@@ -4199,7 +4477,7 @@ function parseDeliveryCarrierMemo(data) {
 
 // src/notes/swap-refund.ts
 import { blake3 as blake33 } from "@noble/hashes/blake3";
-import { PublicKey as PublicKey7 } from "@solana/web3.js";
+import { PublicKey as PublicKey9 } from "@solana/web3.js";
 import _bs582 from "bs58";
 var bs582 = _bs582.default || _bs582;
 var REFUND_SEED_DOMAIN = new TextEncoder().encode("cloak_swap_refund_v1");
@@ -4344,7 +4622,7 @@ async function discoverSwapRefunds(connection, programId, viewingKeyNk, options
   const { limit = 0, untilSignature, batchSize = 50, onStatus } = options;
   const poolMint = options.poolMint ?? NATIVE_SOL_MINT;
   const programIdBase58 = programId.toBase58();
-  const [pool] = PublicKey7.findProgramAddressSync(
+  const [pool] = PublicKey9.findProgramAddressSync(
     [Buffer.from("pool"), poolMint.toBuffer()],
     programId
   );
@@ -4395,7 +4673,7 @@ async function discoverSwapRefunds(connection, programId, viewingKeyNk, options
         if (data[0] !== TRANSACT_SWAP_TAG2 || data.length < MIN_TRANSACT_SWAP_LEN) continue;
         const nullifier = data.slice(NULLIFIER_0_OFFSET, NULLIFIER_0_OFFSET + 32);
         if (nullifier.length !== 32) continue;
-        const [swapState] = PublicKey7.findProgramAddressSync(
+        const [swapState] = PublicKey9.findProgramAddressSync(
           [Buffer.from("swap_state"), pool.toBuffer(), Buffer.from(nullifier)],
           programId
         );
@@ -4622,226 +4900,6 @@ async function matchChangeNote(params) {
 import { buildPoseidon as buildPoseidon2 } from "circomlibjs";
 import nacl6 from "tweetnacl";
 
-// src/relay/payload.ts
-import { sha256 as sha2563 } from "@noble/hashes/sha2";
-import { bytesToHex as bytesToHex3 } from "@noble/hashes/utils";
-import nacl5 from "tweetnacl";
-var REQUEST_AUTH_DOMAIN = "CLOAK_RELAY_REQUEST_AUTH_V1";
-var REQUEST_AUTH_MAX_AGE_SECONDS = 300;
-var REQUEST_AUTH_MAX_FUTURE_SKEW_SECONDS = 30;
-var RELAY_AUTH_APPROVAL_MARGIN_SECONDS = 15;
-function sha256Hex(text) {
-  return bytesToHex3(sha2563(new TextEncoder().encode(text)));
-}
-function randomNonceUuid() {
-  const webCrypto = globalThis?.crypto;
-  if (typeof webCrypto?.randomUUID === "function") return webCrypto.randomUUID();
-  const proc = globalThis?.process;
-  const nodeCrypto = typeof proc?.getBuiltinModule === "function" ? proc.getBuiltinModule("node:crypto") : void 0;
-  if (typeof nodeCrypto?.randomUUID === "function") return nodeCrypto.randomUUID();
-  const bytes = randomBytes(16);
-  bytes[6] = bytes[6] & 15 | 64;
-  bytes[8] = bytes[8] & 63 | 128;
-  const hex = bytesToHex3(bytes);
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
-}
-var TRANSACT_AUTH_FIELDS = [
-  "encrypted_notes",
-  "max_fee",
-  "mint",
-  "proof_bytes",
-  "public_inputs",
-  "recipient",
-  "recipient_delivery_notes",
-  "risk_quote",
-  "sender"
-];
-var TRANSACT_SWAP_AUTH_FIELDS = [
-  "close_timed_out",
-  "dexes",
-  "encrypted_notes",
-  "exclude_dexes",
-  "max_fee",
-  "min_output_amount",
-  "output_mint",
-  "proof_bytes",
-  "public_inputs",
-  "recipient",
-  "recipient_ata",
-  "refund_blinding",
-  "refund_pubkey",
-  "retry_request_id",
-  "risk_quote",
-  "route_retry_attempts",
-  "sender",
-  "slippage_bps",
-  "swap_max_retries"
-];
-var UTF8 = new TextEncoder();
-function compareKeysBytewise(a, b) {
-  if (a === b) return 0;
-  const ab = UTF8.encode(a);
-  const bb = UTF8.encode(b);
-  const shared = Math.min(ab.length, bb.length);
-  for (let i = 0; i < shared; i++) {
-    if (ab[i] !== bb[i]) return ab[i] - bb[i];
-  }
-  return ab.length - bb.length;
-}
-function canonicalJson(value) {
-  if (value === null || value === void 0) return "null";
-  if (typeof value === "boolean") return value ? "true" : "false";
-  if (typeof value === "number") {
-    if (!Number.isFinite(value) || !Number.isInteger(value) || !Number.isSafeInteger(value)) {
-      throw new Error(
-        `canonicalJson: refusing to sign the number ${String(value)}. The relay renders numbers with serde_json, which spells non-integer, non-finite and very large values differently from JavaScript, so the two digests would differ and the request would be rejected with an unexplained 401. Send it as a decimal string instead, which is how every amount in this schema travels.`
-      );
-    }
-    return String(value);
-  }
-  if (typeof value === "bigint") return value.toString();
-  if (typeof value === "string") return JSON.stringify(value);
-  if (Array.isArray(value)) return "[" + value.map(canonicalJson).join(",") + "]";
-  if (typeof value === "object") {
-    const obj = value;
-    const keys = Object.keys(obj).sort(compareKeysBytewise);
-    return "{" + keys.map((k) => {
-      const v = obj[k];
-      if (typeof v === "function" || typeof v === "symbol") {
-        throw new Error(
-          `canonicalJson: the key "${k}" holds a ${typeof v}, which has no JSON representation. JSON.stringify would drop it from the wire body while it stayed in the signed view, so the relay's digest could never match this one.`
-        );
-      }
-      return `${JSON.stringify(k)}:${canonicalJson(v)}`;
-    }).join(",") + "}";
-  }
-  throw new Error(`canonicalJson: unsupported value of type ${typeof value}`);
-}
-var FIELDS_WITHOUT_NULL_ENCODING = {
-  slippage_bps: "500 (`default_slippage_bps` in api/transact_swap.rs)"
-};
-function buildAuthRequest(body, sender, fields) {
-  const out = {};
-  for (const k of fields) {
-    if (k === "sender") {
-      out[k] = sender;
-      continue;
-    }
-    const value = body[k];
-    if (value === void 0 || value === null) {
-      const relayDefault = FIELDS_WITHOUT_NULL_ENCODING[k];
-      if (relayDefault) {
-        throw new Error(
-          `Relay request auth: \`${k}\` must be present in the body. It is the one field in this schema that is not optional on the relay side: when it is missing the relay signs its default, ${relayDefault}, while this request would sign null. The two digests differ and the relay answers 401 "Relay request signature does not match the exact request", which points at nothing. Set \`${k}\` explicitly, to the same value the body will carry.`
-        );
-      }
-      out[k] = null;
-      continue;
-    }
-    out[k] = value;
-  }
-  return out;
-}
-function buildRequestAuthMessage(endpoint, programId, issuedAt, nonce, request) {
-  const digest = sha256Hex(canonicalJson(request));
-  return new TextEncoder().encode(
-    `${REQUEST_AUTH_DOMAIN}
-${endpoint}
-${programId.toBase58()}
-${nonce}
-${issuedAt}
-${digest}`
-  );
-}
-function buildRelayAuthPreimage(endpoint, programId, body, sender, nowSeconds, fields = TRANSACT_AUTH_FIELDS) {
-  const senderB58 = sender.toBase58();
-  const issuedAt = String(nowSeconds ?? Math.floor(Date.now() / 1e3));
-  const nonce = randomNonceUuid();
-  const request = buildAuthRequest({ ...body, sender: senderB58 }, senderB58, fields);
-  const message = buildRequestAuthMessage(endpoint, programId, issuedAt, nonce, request);
-  return { sender: senderB58, auth_issued_at: issuedAt, auth_nonce: nonce, message };
-}
-function signRelayRequest(endpoint, programId, body, signer, nowSeconds, fields = TRANSACT_AUTH_FIELDS) {
-  const preimage = buildRelayAuthPreimage(
-    endpoint,
-    programId,
-    body,
-    signer.publicKey,
-    nowSeconds,
-    fields
-  );
-  const signature = nacl5.sign.detached(preimage.message, signer.secretKey);
-  return {
-    sender: preimage.sender,
-    auth_issued_at: preimage.auth_issued_at,
-    auth_nonce: preimage.auth_nonce,
-    auth_signature: Buffer.from(signature).toString("base64")
-  };
-}
-function assertApprovalWithinFreshnessWindow(elapsedMs) {
-  const elapsedSeconds = elapsedMs / 1e3;
-  const budget = REQUEST_AUTH_MAX_AGE_SECONDS - RELAY_AUTH_APPROVAL_MARGIN_SECONDS;
-  if (elapsedSeconds <= budget) return;
-  throw new Error(
-    `The wallet approval took ${Math.round(elapsedSeconds)} seconds, and Cloak requests stay valid for ${REQUEST_AUTH_MAX_AGE_SECONDS} seconds from the moment they are signed (${RELAY_AUTH_APPROVAL_MARGIN_SECONDS} of those are held back for the request to reach the network). The timestamp is inside the signature, so it cannot be refreshed without your approval again. NOTHING WAS SUBMITTED and no funds moved. Start the same operation again and approve the prompt when it appears.`
-  );
-}
-function explainRelayAuthRejection(responseText) {
-  const text = String(responseText);
-  const has = (needle) => text.includes(needle);
-  if (has("issued too far in the future")) {
-    return `This computer's clock is more than ${REQUEST_AUTH_MAX_FUTURE_SKEW_SECONDS} seconds ahead of the network's, so the request looks like it was signed in the future and is refused before anything else happens. Turn on automatic date and time (or resynchronise the clock) and try again. Nothing was submitted.`;
-  }
-  if (has("signature expired")) {
-    return `The request was signed more than ${REQUEST_AUTH_MAX_AGE_SECONDS} seconds before it arrived, usually because a wallet approval was left waiting, or because this computer's clock is running behind. The signed timestamp cannot be refreshed on its own. Start the operation again. Nothing was submitted.`;
-  }
-  if (has("does not match the exact request")) {
-    return `The request body changed after it was signed, so the relay's digest and this one disagree. Sign the exact body that is POSTed, and re-POST a retry byte for byte rather than rebuilding it. If this is a hand-built swap call, check that every field in TRANSACT_SWAP_AUTH_FIELDS is present, including \`slippage_bps\`.`;
-  }
-  if (has("has no registered viewing key")) {
-    return `The signature was accepted, so this is not a signing problem: the wallet that signed has no viewing key registered with Cloak yet. Register one first, or let the SDK do it by leaving \`enforceViewingKeyRegistration\` on and supplying the viewing key.`;
-  }
-  if (has("Authenticated sender is required") || has("auth_issued_at is required") || has("auth_nonce is required") || has("auth_signature is required")) {
-    return `The request reached the relay without its authentication fields. Pass \`depositorKeypair\`, or \`signMessage\` together with \`walletPublicKey\`, so the request can be signed.`;
-  }
-  if (has("auth_nonce must be a canonical UUID")) {
-    return `\`auth_nonce\` must be a canonical lowercase UUID. Reuse the one from the preimage.`;
-  }
-  if (has("Relay request signature must be exactly 64 bytes") || has("Invalid relay request signature encoding")) {
-    return `\`auth_signature\` must be the raw 64-byte ed25519 detached signature, base64 encoded. Wallet adapters that wrap or re-encode what \`signMessage\` returns cannot be used here.`;
-  }
-  return null;
-}
-async function buildRelayAuthFields(endpoint, programId, body, signers, fields = TRANSACT_AUTH_FIELDS) {
-  if (signers.depositorKeypair) {
-    return signRelayRequest(endpoint, programId, body, signers.depositorKeypair, void 0, fields);
-  }
-  const wallet = signers.relayAuthSigner;
-  if (!wallet) return null;
-  const preimage = buildRelayAuthPreimage(
-    endpoint,
-    programId,
-    body,
-    wallet.walletPublicKey,
-    void 0,
-    fields
-  );
-  const approvalStartedMs = Date.now();
-  const signature = await wallet.signMessage(preimage.message);
-  assertApprovalWithinFreshnessWindow(Date.now() - approvalStartedMs);
-  if (!(signature instanceof Uint8Array) || signature.length !== 64) {
-    throw new Error(
-      `The wallet's signMessage did not return a 64-byte ed25519 detached signature (got ${signature instanceof Uint8Array ? `${signature.length} bytes` : typeof signature}). Cloak signs with a raw detached signature over the bytes it hands the wallet; adapters that wrap or re-encode the result cannot be used here. Pass depositorKeypair instead, or use an adapter whose signMessage returns the raw signature.`
-    );
-  }
-  return {
-    sender: preimage.sender,
-    auth_issued_at: preimage.auth_issued_at,
-    auth_nonce: preimage.auth_nonce,
-    auth_signature: Buffer.from(signature).toString("base64")
-  };
-}
-
 // src/proving/artifacts.ts
 import { sha256 as sha2564 } from "@noble/hashes/sha2";
 
@@ -5117,6 +5175,7 @@ async function resolveTransactionCircuitFiles() {
 }
 var _transactPaddingSaltCounter = 0;
 var _registeredViewingKeys = /* @__PURE__ */ new Set();
+var _viewingKeyRegistrationsInFlight = /* @__PURE__ */ new Map();
 var _resolvedAltAccountsCache = /* @__PURE__ */ new Map();
 var _relayMerkleDisabledMints = /* @__PURE__ */ new Set();
 var _relayMerkleFallbackNotifiedMints = /* @__PURE__ */ new Set();
@@ -5241,7 +5300,7 @@ async function fetchSupplementalAltFromRelay(relayUrl, params) {
     throw new Error("Supplemental ALT response is missing a 'table' address");
   }
   try {
-    return new PublicKey8(table);
+    return new PublicKey10(table);
   } catch {
     throw new Error(`Supplemental ALT response 'table' is not a valid public key: ${table}`);
   }
@@ -5309,7 +5368,7 @@ async function resolveAddressLookupTableAccounts(connection, relayUrl, altAddres
   const fetched = await Promise.all(
     altAddresses.map(async (addr) => {
       try {
-        const pubkey = new PublicKey8(addr);
+        const pubkey = new PublicKey10(addr);
         const result = await connection.getAddressLookupTable(pubkey);
         return result.value ?? null;
       } catch {
@@ -5399,7 +5458,7 @@ function calculateConfiguredProtocolFee(amount, config) {
   return total;
 }
 async function readLiveProtocolFee(connection, programId, mint, amount, requireSwapOpen = false) {
-  const [poolConfigPda] = PublicKey8.findProgramAddressSync(
+  const [poolConfigPda] = PublicKey10.findProgramAddressSync(
     [Buffer.from("pool_config"), mint.toBuffer()],
     programId
   );
@@ -5449,6 +5508,23 @@ async function computeSwapExtDataHash(outputMint, recipientAta, minOutputAmount,
   ]);
   return poseidonHasher.F.toObject(hash);
 }
+function assertInputMints(inputUtxos, expectedMint) {
+  const funded = inputUtxos.filter((u) => u.amount > BigInt(0));
+  if (funded.length === 0) return;
+  const first = funded[0].mintAddress;
+  for (const utxo of funded) {
+    if (!utxo.mintAddress.equals(first)) {
+      throw new Error(
+        `Input notes span more than one mint (${first.toBase58()} and ${utxo.mintAddress.toBase58()}). Every pool holds a single mint, so this cannot be a valid spend of either. Select notes of one mint.`
+      );
+    }
+  }
+  if (expectedMint && !first.equals(expectedMint)) {
+    throw new Error(
+      `Input notes are ${first.toBase58()} but this transaction expects ${expectedMint.toBase58()}. The notes decide which pool is spent, so proceeding would move the wrong asset \u2014 refusing. This usually means note selection ignored the mint.`
+    );
+  }
+}
 function parseNkInput(input) {
   if (typeof input !== "string") {
     if (input.length !== 32) {
@@ -5504,6 +5580,26 @@ async function ensureViewingKeyRegistered(options, onProgress, fallbackNk) {
   if (_registeredViewingKeys.has(cacheKey)) {
     return;
   }
+  const inFlight = _viewingKeyRegistrationsInFlight.get(cacheKey);
+  if (inFlight) {
+    return inFlight;
+  }
+  const registration = registerViewingKeyOnce(
+    relayUrl,
+    userPubkey,
+    viewingKeyHex,
+    cacheKey,
+    options,
+    onProgress
+  );
+  _viewingKeyRegistrationsInFlight.set(cacheKey, registration);
+  try {
+    await registration;
+  } finally {
+    _viewingKeyRegistrationsInFlight.delete(cacheKey);
+  }
+}
+async function registerViewingKeyOnce(relayUrl, userPubkey, viewingKeyHex, cacheKey, options, onProgress) {
   const challengeResponse = await relayFetch(`${relayUrl}/viewing-key/challenge`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
@@ -5524,17 +5620,27 @@ async function ensureViewingKeyRegistered(options, onProgress, fallbackNk) {
     viewingKeyHex
   );
   let signatureBase64;
+  let authMode = "message";
+  const messageBytes = new TextEncoder().encode(challenge.message);
   if (options.signMessage) {
-    const messageBytes = new TextEncoder().encode(challenge.message);
     const sig = await options.signMessage(messageBytes);
     signatureBase64 = Buffer.from(sig).toString("base64");
   } else if (options.depositorKeypair) {
-    const messageBytes = new TextEncoder().encode(challenge.message);
     const sig = nacl6.sign.detached(messageBytes, options.depositorKeypair.secretKey);
     signatureBase64 = Buffer.from(sig).toString("base64");
+  } else if (options.signAuthTransaction) {
+    onProgress?.(
+      "Approve the viewing-key registration in your wallet. It shows as a 0 SOL transfer to yourself and is never sent to the network."
+    );
+    const signed = await signRelayAuthPayload(
+      { walletPublicKey: userPubkey, signAuthTransaction: options.signAuthTransaction },
+      messageBytes
+    );
+    signatureBase64 = Buffer.from(signed.signature).toString("base64");
+    authMode = signed.mode;
   } else {
     throw new Error(
-      "Viewing key registration is mandatory: signMessage (wallet) or depositorKeypair is required."
+      "Viewing key registration is mandatory: signMessage or signAuthTransaction (wallet) or depositorKeypair is required."
     );
   }
   onProgress?.("Registering viewing key...");
@@ -5545,7 +5651,8 @@ async function ensureViewingKeyRegistered(options, onProgress, fallbackNk) {
       user_pubkey: userPubkey.toBase58(),
       viewing_key: viewingKeyHex,
       nonce: challenge.nonce,
-      signature: signatureBase64
+      signature: signatureBase64,
+      ...authMode === "transaction" ? { auth_mode: authMode } : {}
     })
   });
   if (!response.ok) {
@@ -5639,7 +5746,7 @@ function buildPublicInputsBytesFromSignals(publicSignals) {
 var TRANSACT_DISCRIMINATOR = 0;
 var RANGE_QUOTE_TAG_DEPOSIT = 1;
 function deriveRiskNoncePDA(programId, nonce) {
-  return PublicKey8.findProgramAddressSync(
+  return PublicKey10.findProgramAddressSync(
     [Buffer.from("risk_nonce"), Buffer.from(nonce)],
     programId
   );
@@ -5658,7 +5765,7 @@ function extractDepositNonceFromEd25519Ix(ix) {
   }
 }
 function deriveNullifierPDA(programId, poolPDA, nullifier) {
-  return PublicKey8.findProgramAddressSync(
+  return PublicKey10.findProgramAddressSync(
     [Buffer.from("nullifier"), poolPDA.toBuffer(), Buffer.from(nullifier)],
     programId
   );
@@ -5691,7 +5798,7 @@ function buildTransactInstruction(programId, payer, poolPDA, treasuryPDA, merkle
   }
   if (!isDepositData) {
     data[offset++] = 3;
-    data.set((relayer ?? PublicKey8.default).toBytes(), offset);
+    data.set((relayer ?? PublicKey10.default).toBytes(), offset);
     offset += 32;
     writeBigUInt64LE(data, relayerFee ?? BigInt(0), offset);
     offset += 8;
@@ -5721,7 +5828,7 @@ function buildTransactInstruction(programId, payer, poolPDA, treasuryPDA, merkle
     // 4. nullifier PDA 0 (writable)
     { pubkey: nullifierPDA1, isSigner: false, isWritable: true },
     // 5. nullifier PDA 1 (writable)
-    { pubkey: SystemProgram2.programId, isSigner: false, isWritable: false }
+    { pubkey: SystemProgram3.programId, isSigner: false, isWritable: false }
     // 6. system_program
   ];
   if (splAccounts) {
@@ -5766,7 +5873,7 @@ function buildTransactInstruction(programId, payer, poolPDA, treasuryPDA, merkle
 var PACKET_LIMIT_BYTES = 1232;
 function getCommonALTAddresses() {
   return [
-    SystemProgram2.programId,
+    SystemProgram3.programId,
     SYSVAR_SLOT_HASHES_PUBKEY,
     SYSVAR_INSTRUCTIONS_PUBKEY,
     ComputeBudgetProgram.programId
@@ -5844,7 +5951,7 @@ async function createEphemeralALT(connection, depositor, onProgress, additionalA
           allowSupplementalAlt
         );
       } else {
-        const tx = new Transaction2().add(createIx).add(extendIx);
+        const tx = new Transaction3().add(createIx).add(extendIx);
         const { blockhash } = await connection.getLatestBlockhash();
         tx.recentBlockhash = blockhash;
         tx.feePayer = depositor.publicKey;
@@ -6505,7 +6612,7 @@ async function submitTransactionDirect(connection, programId, depositor, proofBy
     let legacyTransportAttempt = 0;
     while (true) {
       try {
-        const tx = new Transaction2();
+        const tx = new Transaction3();
         for (const ix of instructions) {
           tx.add(ix);
         }
@@ -6729,7 +6836,7 @@ async function fetchRiskQuote(riskQuoteUrl, wallet, options) {
     const messageArr = hexToBytes2(messageHex);
     let signerPubkey;
     try {
-      signerPubkey = new PublicKey8(signerB58);
+      signerPubkey = new PublicKey10(signerB58);
     } catch {
       throw new Error("Invalid risk quote response: signer_pubkey is not a public key");
     }
@@ -6830,18 +6937,22 @@ function planRelayAuth(options) {
   const walletPublicKey = resolveUserWallet(options);
   if (options.depositorKeypair) return { kind: "keypair" };
   const signMessage = options.signMessage;
+  const signAuthTransaction = options.signAuthTransaction;
   if (walletPublicKey && signMessage) return { kind: "wallet", signer: { walletPublicKey, signMessage } };
-  if (!walletPublicKey && !signMessage) return { kind: "none" };
+  if (walletPublicKey && signAuthTransaction) {
+    return { kind: "wallet", signer: { walletPublicKey, signAuthTransaction } };
+  }
+  if (!walletPublicKey && !signMessage && !signAuthTransaction) return { kind: "none" };
   return {
     kind: "incomplete",
-    detail: signMessage ? "`signMessage` was provided but no wallet public key, so the request has no sender to authenticate as. Add `walletPublicKey` (or `depositorPublicKey`)." : "a wallet public key was provided but no `signMessage`, so nothing can sign. Add `signMessage` from the same wallet adapter."
+    detail: signMessage || signAuthTransaction ? "a signer was provided but no wallet public key, so the request has no sender to authenticate as. Add `walletPublicKey` (or `depositorPublicKey`)." : "a wallet public key was provided but no `signMessage` and no `signAuthTransaction`, so nothing can sign. Add `signMessage` from the wallet adapter, or `signAuthTransaction` (its `signTransaction`) for a wallet that cannot sign messages."
   };
 }
 function assertRelayAuthAvailable(plan, flow) {
   if (plan.kind === "keypair" || plan.kind === "wallet") return;
   const cause = plan.kind === "none" ? "no signer was provided." : `the signer provided cannot produce one: ${plan.detail}`;
   throw new Error(
-    `Cloak ${flow} requires an authenticated sender, and ${cause} Pass either \`depositorKeypair\` (a local Keypair) or \`signMessage\` together with \`walletPublicKey\` (a browser wallet adapter). The sender must be the end user's own wallet. Checked before proof generation, so nothing has been computed or submitted yet.`
+    `Cloak ${flow} requires an authenticated sender, and ${cause} Pass either \`depositorKeypair\` (a local Keypair), or \`signMessage\` (a browser wallet adapter) or \`signAuthTransaction\` (a hardware wallet that cannot sign messages) together with \`walletPublicKey\`. The sender must be the end user's own wallet. Checked up front, so nothing has been computed or submitted yet.`
   );
 }
 async function submitTransactToRelay(args) {
@@ -6859,12 +6970,12 @@ async function submitTransactToRelay(args) {
   const doFetch = args.fetchImpl ?? fetch;
   const maxNetworkRetries = args.maxNetworkRetries ?? relayNetworkRetries();
   const requestTimeoutMs = args.requestTimeoutMs ?? relayRequestTimeoutMs();
-  if (!depositorKeypair && args.relayAuthSigner) {
+  if (!depositorKeypair && args.relayAuthSigner && !args.relayAuthBatch) {
     onProgress?.(
       "Approve the request in your wallet. This signs the request for the relay, not a transaction, and it must be approved within a few minutes to stay valid."
     );
   }
-  const authFields = await buildRelayAuthFields("/transact", programId, requestBody, {
+  const authFields = args.relayAuthBatch ? await args.relayAuthBatch.authorize("/transact", programId, requestBody, TRANSACT_AUTH_FIELDS) : await buildRelayAuthFields("/transact", programId, requestBody, {
     depositorKeypair,
     relayAuthSigner: args.relayAuthSigner
   });
@@ -7060,7 +7171,7 @@ async function transact(params, options) {
     // names is refused.
     maxRootRetries = 40,
     // Increased to handle prolonged relay sync recovery under high concurrency
-    retryDelayMs = 500,
+    retryDelayMs: retryDelayMs2 = 500,
     // Start with short delay, will exponentially back off
     riskOracleQueue,
     riskQuoteUrl: riskQuoteUrlOption,
@@ -7115,6 +7226,7 @@ async function transact(params, options) {
     }
   }
   assertAllowedRpcConnection(connection);
+  assertInputMints(inputUtxos, options.expectedMint);
   await ensureViewingKeyRegistered(options, onProgress, fallbackNk);
   const resolvedChainNoteNk = explicitChainNoteNk ?? fallbackNk ?? null;
   if (inputUtxos.length > 2) {
@@ -7481,7 +7593,7 @@ async function transact(params, options) {
   while (submissionAttempts <= maxRootRetries) {
     const isRetry = submissionAttempts > 0;
     if (isRetry) {
-      const exponentialDelay = Math.min(retryDelayMs * Math.pow(1.5, submissionAttempts - 1), 5e3);
+      const exponentialDelay = Math.min(retryDelayMs2 * Math.pow(1.5, submissionAttempts - 1), 5e3);
       const jitter = Math.random() * 500;
       const totalDelay = Math.floor(exponentialDelay + jitter);
       await sleep2(totalDelay);
@@ -7620,11 +7732,14 @@ async function transact(params, options) {
     }
     let proof;
     let publicSignals;
+    const releaseProofSlot = options.relayAuthBatch ? await options.relayAuthBatch.proofSlot() : void 0;
     try {
       const result = await generateTransactionProof(circuitInputs, onProofProgress);
       proof = result.proof;
       publicSignals = result.publicSignals;
+      releaseProofSlot?.();
     } catch (proofError) {
+      releaseProofSlot?.();
       const errorMsg = proofError?.message || String(proofError);
       if ((errorMsg.includes("ForceEqual") || errorMsg.includes("Assert Failed")) && submissionAttempts < maxRootRetries) {
         onProgress?.(`Merkle proof error (stale sibling data), will regenerate with fresh tree...`);
@@ -7644,7 +7759,7 @@ async function transact(params, options) {
         }
         treeState = null;
         useSiblingInfo = false;
-        const waitMs = Math.min(retryDelayMs * Math.pow(2, Math.min(submissionAttempts, 4)), 5e3);
+        const waitMs = Math.min(retryDelayMs2 * Math.pow(2, Math.min(submissionAttempts, 4)), 5e3);
         if (waitMs > 0) {
           onProgress?.(`Waiting ${waitMs}ms for relay sync before retry...`);
           await new Promise((r) => setTimeout(r, waitMs));
@@ -7937,6 +8052,7 @@ async function transact(params, options) {
       // point where they reach the relay submission instead of stopping at viewing-key
       // registration. The keypair still wins when both are present.
       relayAuthSigner: relayAuthPlan.kind === "wallet" ? relayAuthPlan.signer : void 0,
+      relayAuthBatch: options.relayAuthBatch,
       settlement: {
         connection,
         programId,
@@ -7982,7 +8098,7 @@ async function transact(params, options) {
         "All relay-tree attempts failed. Rebuilding merkle tree from chain as last resort..."
       );
       try {
-        const [merkleTreePda] = PublicKey8.findProgramAddressSync(
+        const [merkleTreePda] = PublicKey10.findProgramAddressSync(
           [Buffer.from("merkle_tree"), mint.toBuffer()],
           programId
         );
@@ -8338,7 +8454,7 @@ async function swapUtxo(params, options) {
     riskQuoteUrl: riskQuoteUrlOption,
     maxRootRetries = 40,
     // Increased to handle prolonged relay sync recovery under high concurrency
-    retryDelayMs = 500,
+    retryDelayMs: retryDelayMs2 = 500,
     // Start with short delay, will exponentially back off
     useUniqueNullifiers,
     useChainRootForProof = true
@@ -8357,6 +8473,12 @@ async function swapUtxo(params, options) {
   if (inputUtxos.length > 2) {
     throw new Error("Maximum 2 input UTXOs allowed");
   }
+  assertInputMints(inputUtxos, NATIVE_SOL_MINT);
+  if (options.expectedMint && !options.expectedMint.equals(NATIVE_SOL_MINT)) {
+    throw new Error(
+      `swapUtxo expects ${NATIVE_SOL_MINT.toBase58()} input notes (a swap always spends from the wSOL pool), but expectedMint was ${options.expectedMint.toBase58()}. Drop expectedMint, or spend the other mint with transact/transfer instead.`
+    );
+  }
   await preflightNullifiers(inputUtxos, connection, programId);
   const outputMintAccount = await connection.getAccountInfo(outputMint, {
     commitment: "confirmed"
@@ -8743,7 +8865,7 @@ async function swapUtxo(params, options) {
   let walletApprovals = 0;
   for (let attempt = 0; attempt <= maxRootRetries; attempt++) {
     if (attempt > 0) {
-      const exponentialDelay = Math.min(retryDelayMs * Math.pow(1.5, attempt - 1), 5e3);
+      const exponentialDelay = Math.min(retryDelayMs2 * Math.pow(1.5, attempt - 1), 5e3);
       const jitter = Math.random() * 500;
       const totalDelay = Math.floor(exponentialDelay + jitter);
       await sleep2(totalDelay);
@@ -8881,7 +9003,7 @@ async function swapUtxo(params, options) {
         }
         merkleState = null;
         useSiblingInfo = false;
-        const waitMs = Math.min(retryDelayMs * Math.pow(2, Math.min(attempt, 4)), 5e3);
+        const waitMs = Math.min(retryDelayMs2 * Math.pow(2, Math.min(attempt, 4)), 5e3);
         if (waitMs > 0) {
           onProgress?.(`Waiting ${waitMs}ms for relay sync before retry...`);
           await new Promise((r) => setTimeout(r, waitMs));
@@ -8964,7 +9086,7 @@ async function swapUtxo(params, options) {
     }
     if (options.onSwapStatePredicted && inputNullifiers.length > 0) {
       const nBytes = bigintToBytes322(inputNullifiers[0]);
-      const [ssp] = PublicKey8.findProgramAddressSync(
+      const [ssp] = PublicKey10.findProgramAddressSync(
         [Buffer.from("swap_state"), pdas.pool.toBuffer(), Buffer.from(nBytes)],
         programId
       );
@@ -9383,10 +9505,276 @@ function cleanupStalePendingOperations(maxAgeMs = 24 * 60 * 60 * 1e3) {
   return { removedDeposits, removedWithdrawals };
 }
 
+// src/relay/batch-auth.ts
+import { Keypair as Keypair4 } from "@solana/web3.js";
+var RelayBatchAuthCoordinator = class {
+  constructor(options) {
+    this.proofSlotsInUse = 0;
+    this.proofQueue = [];
+    this.items = [];
+    this.signing = false;
+    this.slotsInUse = 0;
+    this.ready = [];
+    this.waves = 0;
+    if (!Number.isInteger(options.items) || options.items < 1) {
+      throw new Error(`A batch needs at least one item (got ${options.items}).`);
+    }
+    if (options.items > RELAY_BATCH_AUTH_MAX_ITEMS) {
+      throw new Error(
+        `A batch may cover at most ${RELAY_BATCH_AUTH_MAX_ITEMS} requests (got ${options.items}); the relay refuses longer digest lists. Chunk the payout. The practical bound is lower still: each spend appends two roots to the on-chain ring of 100, so a batch proved against one root evicts it by itself before 50 items.`
+      );
+    }
+    const concurrency = options.submitConcurrency ?? 3;
+    if (!Number.isInteger(concurrency) || concurrency < 1) {
+      throw new Error(`submitConcurrency must be a positive integer (got ${concurrency}).`);
+    }
+    this.signer = options.signer;
+    this.sender = options.signer instanceof Keypair4 ? options.signer.publicKey : options.signer.walletPublicKey;
+    this.expectedItems = options.items;
+    this.submitConcurrency = concurrency;
+    const proofConcurrency = options.proofConcurrency ?? 2;
+    if (!Number.isInteger(proofConcurrency) || proofConcurrency < 1) {
+      throw new Error(`proofConcurrency must be a positive integer (got ${proofConcurrency}).`);
+    }
+    this.proofConcurrency = proofConcurrency;
+    this.onProgress = options.onProgress;
+  }
+  /** The wallet that signs and is every item's authenticated `sender`. */
+  get walletPublicKey() {
+    return this.sender;
+  }
+  /** How many times the signer has been asked so far: one per wave. */
+  get approvals() {
+    return this.waves;
+  }
+  /** Where every item is right now. For progress UIs and for diagnosing a batch that never signs. */
+  snapshot() {
+    const count = (state) => this.items.filter((i) => i.state === state).length;
+    return {
+      building: count("building"),
+      waiting: count("waiting"),
+      submitting: count("submitting"),
+      done: count("done"),
+      proving: this.proofSlotsInUse,
+      proofQueue: this.proofQueue.length,
+      registered: this.items.length,
+      expected: this.expectedItems
+    };
+  }
+  /** Register one item. Throws past `items`: the wave condition would never be reachable. */
+  item() {
+    if (this.items.length >= this.expectedItems) {
+      throw new Error(
+        `This batch was created for ${this.expectedItems} item(s) and all of them are registered.`
+      );
+    }
+    const item = { state: "building", waiting: null, holdsSlot: false };
+    this.items.push(item);
+    return {
+      proofSlot: () => this.acquireProofSlot(),
+      authorize: (endpoint, programId, body, fields) => this.authorize(item, endpoint, programId, body, fields),
+      finish: () => this.finish(item)
+    };
+  }
+  acquireProofSlot() {
+    return new Promise((resolve) => {
+      const grant = () => {
+        this.proofSlotsInUse += 1;
+        let released = false;
+        resolve(() => {
+          if (released) return;
+          released = true;
+          this.proofSlotsInUse -= 1;
+          const next = this.proofQueue.shift();
+          if (next) next();
+        });
+      };
+      if (this.proofSlotsInUse < this.proofConcurrency) grant();
+      else this.proofQueue.push(grant);
+    });
+  }
+  authorize(item, endpoint, programId, body, fields) {
+    if (item.state === "done") {
+      return Promise.reject(new Error("This batch item already finished; it cannot authorize."));
+    }
+    if (item.state === "waiting") {
+      return Promise.reject(new Error("This batch item is already waiting for a signature."));
+    }
+    this.releaseSlot(item);
+    return new Promise((resolve, reject) => {
+      item.state = "waiting";
+      item.waiting = { endpoint, programId, body, fields, resolve, reject };
+      this.maybeSign();
+    });
+  }
+  finish(item) {
+    if (item.state === "done") return;
+    if (item.state === "waiting" && item.waiting) {
+      item.waiting.reject(new Error("Batch item finished before it was signed."));
+      item.waiting = null;
+    }
+    this.releaseSlot(item);
+    item.state = "done";
+    this.maybeSign();
+    this.pump();
+  }
+  releaseSlot(item) {
+    if (!item.holdsSlot) return;
+    item.holdsSlot = false;
+    this.slotsInUse -= 1;
+  }
+  /** Sign when every registered item is either waiting here or finished, and nothing is building. */
+  maybeSign() {
+    if (this.signing) return;
+    if (this.items.length < this.expectedItems) return;
+    if (this.items.some((item) => item.state === "building" || item.state === "submitting")) return;
+    const wave = this.items.filter((item) => item.state === "waiting");
+    if (wave.length === 0) return;
+    this.signing = true;
+    void this.signWave(wave).finally(() => {
+      this.signing = false;
+      this.maybeSign();
+    });
+  }
+  async signWave(wave) {
+    const waiting = wave.map((item) => item.waiting);
+    try {
+      const programId = waiting[0].programId;
+      for (const w of waiting) {
+        if (!w.programId.equals(programId)) {
+          throw new Error("Every item of a batch must target the same program id.");
+        }
+      }
+      const nowSeconds = Math.floor(Date.now() / 1e3);
+      const preimages = waiting.map(
+        (w) => buildRelayAuthPreimage(w.endpoint, programId, w.body, this.sender, nowSeconds, w.fields)
+      );
+      const digests = preimages.map(relayRequestDigestHex);
+      const issuedAt = preimages[0].auth_issued_at;
+      const message = buildRelayBatchAuthMessage(programId, issuedAt, digests);
+      this.waves += 1;
+      if (!(this.signer instanceof Keypair4)) {
+        const asTransaction = !this.signer.signMessage;
+        this.onProgress?.(
+          `Approve ${waiting.length} request(s) in your wallet` + (this.waves > 1 ? ` (approval ${this.waves}, for the rows that had to re-prove)` : "") + (asTransaction ? `. Your wallet shows this as a 0 SOL transfer to yourself: it is how a wallet that cannot sign messages authorizes the requests for the relay, and it is never sent to the network. Approve it on the device within a few minutes.` : `. This signs the requests for the relay, not a transaction, and must be approved within a few minutes to stay valid.`)
+        );
+      }
+      const approvalStartedMs = Date.now();
+      const { signature, mode } = await signRelayAuthPayload(this.signer, message);
+      if (!(this.signer instanceof Keypair4)) {
+        assertApprovalWithinFreshnessWindow(
+          Date.now() - approvalStartedMs,
+          REQUEST_AUTH_BATCH_MAX_AGE_SECONDS
+        );
+      }
+      const signatureB64 = Buffer.from(signature).toString("base64");
+      wave.forEach((item, i) => {
+        const preimage = preimages[i];
+        this.ready.push({
+          item,
+          fields: {
+            sender: preimage.sender,
+            auth_issued_at: preimage.auth_issued_at,
+            auth_nonce: preimage.auth_nonce,
+            auth_signature: signatureB64,
+            ...mode === "transaction" ? { auth_mode: mode } : {},
+            // A fresh array per item: `Object.assign` puts this on the wire body, and the body is
+            // serialized again on every network retry.
+            auth_batch: { digests: [...digests] }
+          }
+        });
+      });
+      this.pump();
+    } catch (error) {
+      for (const item of wave) {
+        const w = item.waiting;
+        item.waiting = null;
+        item.state = "done";
+        w?.reject(error);
+      }
+    }
+  }
+  /** Release signed items to submit, `submitConcurrency` at a time, in signing order. */
+  pump() {
+    while (this.ready.length > 0 && this.slotsInUse < this.submitConcurrency) {
+      const next = this.ready.shift();
+      const w = next.item.waiting;
+      next.item.waiting = null;
+      if (next.item.state !== "waiting" || !w) continue;
+      next.item.state = "submitting";
+      next.item.holdsSlot = true;
+      this.slotsInUse += 1;
+      w.resolve(next.fields);
+    }
+  }
+};
+function createRelayBatchAuthCoordinator(options) {
+  return new RelayBatchAuthCoordinator(options);
+}
+
+// src/flows/transact-batch.ts
+async function transactBatch(items, options) {
+  if (items.length === 0) {
+    return { results: [], approvals: 0 };
+  }
+  if (items.length > RELAY_BATCH_AUTH_MAX_ITEMS) {
+    throw new Error(
+      `transactBatch accepts at most ${RELAY_BATCH_AUTH_MAX_ITEMS} items per call (got ${items.length}). Chunk the payout; see RELAY_BATCH_AUTH_MAX_ITEMS for why the practical bound is lower.`
+    );
+  }
+  if (!options.relayUrl) {
+    throw new Error("transactBatch requires relayUrl: batch approval is a relay authentication scheme.");
+  }
+  const { proofConcurrency, submitConcurrency, ...shared } = options;
+  const signer = shared.depositorKeypair ? shared.depositorKeypair : (() => {
+    const wallet = shared.walletPublicKey ?? shared.depositorPublicKey;
+    if (!wallet) return null;
+    if (shared.signMessage) return { walletPublicKey: wallet, signMessage: shared.signMessage };
+    if (shared.signAuthTransaction) {
+      return { walletPublicKey: wallet, signAuthTransaction: shared.signAuthTransaction };
+    }
+    return null;
+  })();
+  if (!signer) {
+    throw new Error(
+      "transactBatch requires an authenticated sender: pass `depositorKeypair` (a local Keypair), or `walletPublicKey` with `signMessage` (a browser wallet adapter) or `signAuthTransaction` (a hardware wallet). Checked up front, so nothing has been computed or submitted yet."
+    );
+  }
+  const coordinator = createRelayBatchAuthCoordinator({
+    signer,
+    items: items.length,
+    proofConcurrency,
+    submitConcurrency,
+    onProgress: shared.onProgress
+  });
+  const handles = items.map(() => coordinator.item());
+  const results = new Array(items.length);
+  const runOne = async (index) => {
+    const item = items[index];
+    const handle = handles[index];
+    const label = `[batch ${index + 1}/${items.length}]`;
+    try {
+      const value = await transact(item.params, {
+        ...shared,
+        ...item.options,
+        relayAuthBatch: handle,
+        onProgress: shared.onProgress ? (status) => shared.onProgress?.(`${label} ${status}`) : void 0
+      });
+      results[index] = { status: "fulfilled", value };
+    } catch (reason) {
+      results[index] = { status: "rejected", reason };
+    } finally {
+      handle.finish();
+    }
+  };
+  await Promise.all(items.map((_, index) => runOne(index)));
+  return { results, approvals: coordinator.approvals };
+}
+
 // src/scanning/scan.ts
 import _bs583 from "bs58";
 import {
-  PublicKey as PublicKey9
+  PublicKey as PublicKey12
 } from "@solana/web3.js";
 import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2 } from "@solana/spl-token";
 var bs583 = _bs583.default || _bs583;
@@ -9474,7 +9862,7 @@ function parseSwapOutputMint(data) {
   const mintBytes = data.slice(SWAP_OUTPUT_MINT_OFFSET, end);
   if (mintBytes.every((byte) => byte === 0)) return void 0;
   try {
-    return new PublicKey9(mintBytes).toBase58();
+    return new PublicKey12(mintBytes).toBase58();
   } catch {
     return void 0;
   }
@@ -9564,7 +9952,7 @@ function parseSwapRecipientAta(data) {
   const recipientAtaBytes = data.slice(recipientAtaStart, recipientAtaEnd);
   if (recipientAtaBytes.every((byte) => byte === 0)) return void 0;
   try {
-    return new PublicKey9(recipientAtaBytes).toBase58();
+    return new PublicKey12(recipientAtaBytes).toBase58();
   } catch {
     return void 0;
   }
@@ -9726,7 +10114,7 @@ async function scanSwapNoteCarriers(connection, programId, viewingKeyNk, swapCtx
   let rpcCalls = 0;
   const candidates = Array.from(swapCtxByCommitment.keys());
   if (candidates.length === 0) return { records, rpcCalls };
-  const [registry] = PublicKey9.findProgramAddressSync(
+  const [registry] = PublicKey12.findProgramAddressSync(
     [Buffer.from("cloak_chain_note_registry")],
     programId
   );
@@ -10129,8 +10517,8 @@ async function scanTransactions(opts) {
                   if (onChainAta) {
                     try {
                       const expectedAta = getAssociatedTokenAddressSync2(
-                        new PublicKey9(asset.mint),
-                        new PublicKey9(walletPublicKey)
+                        new PublicKey12(asset.mint),
+                        new PublicKey12(walletPublicKey)
                       ).toBase58();
                       if (onChainAta === expectedAta) {
                         isOurs = true;
@@ -10344,7 +10732,7 @@ async function scanTransactions(opts) {
                   // deposit — that is the public deposit amount. A deposit that also merged inputs
                   // carries a larger output 0 and is not recoverable from public data alone.
                   amount: grossAmount,
-                  mintAddress: new PublicKey9(asset.mint),
+                  mintAddress: new PublicKey12(asset.mint),
                   outputCommitments: ixCtx.outputCommitments ?? []
                 });
                 if (recoveredDeposit) {
@@ -10370,7 +10758,7 @@ async function scanTransactions(opts) {
                   noteSalt: compactNote.noteSalt,
                   amount: compactNote.outAmount0,
                   keypair: { privateKey: 0n, publicKey: compactNote.outPubkey0 },
-                  mintAddress: new PublicKey9(asset.mint),
+                  mintAddress: new PublicKey12(asset.mint),
                   outputIndex: 0,
                   // v4 describes output 0, which is where change lands
                   outputCommitments: ixCtx.outputCommitments ?? []
@@ -10563,7 +10951,7 @@ function formatComplianceCsv(report) {
 }
 
 // src/wallet/utxo-wallet.ts
-import { PublicKey as PublicKey10 } from "@solana/web3.js";
+import { PublicKey as PublicKey13 } from "@solana/web3.js";
 var UtxoWallet = class _UtxoWallet {
   constructor(viewingKey) {
     this.wallets = /* @__PURE__ */ new Map();
@@ -10775,7 +11163,7 @@ var UtxoWallet = class _UtxoWallet {
       data.viewingKey ? new Uint8Array(data.viewingKey) : void 0
     );
     for (const w of data.wallets) {
-      const mint = new PublicKey10(w.mint);
+      const mint = new PublicKey13(w.mint);
       for (const u of w.utxos) {
         wallet.addUtxo({
           amount: BigInt(u.amount),
@@ -10857,12 +11245,799 @@ var SimpleWallet = class {
   }
 };
 
+// src/bridge/rail-verify.ts
+import nacl7 from "tweetnacl";
+import { sha256 as sha2565 } from "@noble/hashes/sha256";
+var ONECLICK_PUBKEY_B58 = "reYaWhvwu8Jzo3WUM3zhn6VrhuMEF4eADL17qtRVifc";
+var b58 = /* @__PURE__ */ (() => {
+  const A = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  return {
+    decode(s) {
+      let n = 0n;
+      for (const c of s) {
+        const i = A.indexOf(c);
+        if (i < 0) throw new Error("bad base58");
+        n = n * 58n + BigInt(i);
+      }
+      const bytes = [];
+      while (n > 0n) {
+        bytes.unshift(Number(n & 255n));
+        n >>= 8n;
+      }
+      for (const c of s) {
+        if (c === "1") bytes.unshift(0);
+        else break;
+      }
+      return Uint8Array.from(bytes);
+    },
+    encode(b) {
+      let n = 0n;
+      for (const x of b) n = n * 256n + BigInt(x);
+      let s = "";
+      while (n > 0n) {
+        s = A[Number(n % 58n)] + s;
+        n /= 58n;
+      }
+      for (const x of b) {
+        if (x === 0) s = "1" + s;
+        else break;
+      }
+      return s;
+    }
+  };
+})();
+function stable(v) {
+  if (v === null || typeof v !== "object") return JSON.stringify(v) ?? "null";
+  if (Array.isArray(v)) return `[${v.map(stable).join(",")}]`;
+  const o = v;
+  const parts = Object.keys(o).sort().filter((k) => o[k] !== void 0).map((k) => `${JSON.stringify(k)}:${stable(o[k])}`);
+  return `{${parts.join(",")}}`;
+}
+function signedRequest(r) {
+  const q = r.quoteRequest ?? {};
+  return {
+    dry: q.dry,
+    swapType: q.swapType,
+    slippageTolerance: q.slippageTolerance,
+    originAsset: q.originAsset,
+    depositType: q.depositType,
+    destinationAsset: q.destinationAsset,
+    amount: q.amount,
+    refundTo: q.refundTo,
+    refundType: q.refundType,
+    recipient: q.recipient,
+    recipientType: q.recipientType,
+    deadline: q.deadline,
+    quoteWaitingTimeMs: q.quoteWaitingTimeMs || void 0,
+    referral: q.referral || void 0,
+    virtualChainRecipient: q.virtualChainRecipient || void 0,
+    virtualChainRefundRecipient: q.virtualChainRefundRecipient || void 0,
+    customRecipientMsg: q.customRecipientMsg || void 0
+    // Deliberately unsigned by the rail: sessionId, connectedWallets, correlationId, appFees,
+    // partnerId, userAccountId, depositMode. APP FEES ARE NOT AUTHENTICATED — never display a fee
+    // caption as if the signature vouched for it.
+  };
+}
+function signedQuote(r) {
+  const q = r.quote ?? {};
+  const base = {
+    amountIn: q.amountIn,
+    amountInFormatted: q.amountInFormatted,
+    amountInUsd: q.amountInUsd,
+    minAmountIn: q.minAmountIn,
+    amountOut: q.amountOut,
+    amountOutFormatted: q.amountOutFormatted,
+    amountOutUsd: q.amountOutUsd,
+    minAmountOut: q.minAmountOut
+  };
+  if (r.quoteRequest?.dry) return base;
+  return {
+    ...base,
+    depositAddress: q.depositAddress || void 0,
+    // <- the field that makes substitution detectable
+    depositMemo: q.depositMemo || void 0,
+    deadline: q.deadline || void 0,
+    // <- a real, SIGNED expiry
+    timeWhenInactive: q.timeWhenInactive || void 0,
+    timeEstimate: q.timeEstimate || void 0,
+    virtualChainRecipient: q.virtualChainRecipient || void 0,
+    virtualChainRefundRecipient: q.virtualChainRefundRecipient || void 0,
+    customRecipientMsg: q.customRecipientMsg || void 0,
+    refundFee: q.refundFee || void 0,
+    withdrawFee: q.withdrawFee || void 0
+  };
+}
+function canonicalPayloadString(resp) {
+  return stable({ ...signedRequest(resp), ...signedQuote(resp), timestamp: resp.timestamp });
+}
+function verifyQuoteSignature(resp) {
+  if (!resp?.signature) return { valid: false, reason: "no signature on the response" };
+  const payload = { ...signedRequest(resp), ...signedQuote(resp), timestamp: resp.timestamp };
+  const digest = sha2565(new TextEncoder().encode(stable(payload)));
+  const message = new TextEncoder().encode(b58.encode(new Uint8Array(digest)));
+  const sig = resp.signature.replace(/^ed25519:/, "");
+  try {
+    return { valid: nacl7.sign.detached.verify(message, b58.decode(sig), b58.decode(ONECLICK_PUBKEY_B58)) };
+  } catch (e) {
+    return { valid: false, reason: e instanceof Error ? e.message : String(e) };
+  }
+}
+
+// src/bridge/rails.ts
+async function parseBridgeResponse(res, what) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new Error(`${what} failed: ${res.status} ${res.statusText} (response body was not JSON)`);
+  }
+  if (!res.ok) {
+    const b = body ?? {};
+    throw new Error(
+      `${what} failed: ${b.message ?? res.statusText} (${b.code ?? res.status}${b.retryable ? ", retryable" : ""})`
+    );
+  }
+  return body;
+}
+function toAttestation(raw) {
+  if (raw.kind === "ed25519") {
+    return { kind: "ed25519", verified: raw.verified ?? false, signer: raw.signer ?? "" };
+  }
+  return { kind: "none", checks: raw.checks ?? [], note: raw.note ?? "" };
+}
+async function fetchBridgeQuote(relayUrl, req) {
+  const body = {
+    recipient: req.recipient,
+    origin_chain: req.originChain,
+    amount_base_units: req.amountBaseUnits.toString(),
+    allocate: req.allocate ?? false
+  };
+  if (req.refundTo !== void 0) body.refund_to = req.refundTo;
+  if (req.rails !== void 0) body.rails = req.rails;
+  const res = await relayFetch(`${relayUrl}/bridge/quote`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const raw = await parseBridgeResponse(res, "bridge quote");
+  const options = [];
+  const unavailable = (raw.unavailable ?? []).map((p) => ({
+    rail: p.rail,
+    reason: p.reason
+  }));
+  for (const opt of raw.options) {
+    const attestation = toAttestation(opt.attestation);
+    if (attestation.kind === "ed25519") {
+      const verdict = opt.rail_response ? verifyQuoteSignature(opt.rail_response) : { valid: false, reason: "no rail_response to verify against" };
+      if (!verdict.valid) {
+        unavailable.push({
+          rail: opt.rail,
+          reason: `deposit address failed independent signature verification, refusing to display it (${verdict.reason ?? "signature did not verify"})`
+        });
+        continue;
+      }
+    }
+    options.push({
+      rail: opt.rail,
+      refunds: opt.refunds,
+      addressLifetime: opt.address_lifetime,
+      amountOut: BigInt(opt.amount_out),
+      minAmountOut: BigInt(opt.min_amount_out),
+      timeEstimateSeconds: opt.time_estimate_s,
+      expiresAt: opt.expires_at,
+      depositAddress: opt.deposit_address,
+      attestation
+    });
+  }
+  return { options, unavailable };
+}
+var STATUS_STATES = [
+  "pending",
+  "delivered",
+  "refunded",
+  "expired",
+  "unknown"
+];
+async function fetchBridgeStatus(relayUrl, depositAddress, rail) {
+  const qs = new URLSearchParams({ deposit_address: depositAddress, rail });
+  const res = await relayFetch(`${relayUrl}/bridge/status?${qs.toString()}`);
+  const raw = await parseBridgeResponse(res, "bridge status");
+  const state = STATUS_STATES.includes(raw.state ?? "") ? raw.state : "unknown";
+  return { rail: raw.rail ?? rail, state, detail: raw.detail ?? "" };
+}
+function cloakBridgeRail(relayUrl) {
+  assertAllowedRelayOrigin(relayUrl);
+  return {
+    id: "cloak-bridge",
+    quote: (req) => fetchBridgeQuote(relayUrl, req),
+    status: (depositAddress, rail) => fetchBridgeStatus(relayUrl, depositAddress, rail)
+  };
+}
+
+// src/bridge/paymaster-client.ts
+import {
+  PublicKey as PublicKey14,
+  SystemInstruction,
+  SystemProgram as SystemProgram4,
+  Transaction as Transaction4
+} from "@solana/web3.js";
+import { TOKEN_PROGRAM_ID as TOKEN_PROGRAM_ID3, decodeTransferInstruction, getAssociatedTokenAddressSync as getAssociatedTokenAddressSync3 } from "@solana/spl-token";
+function validatePaymasterTopUpTransaction(tx, expect) {
+  const ixs = tx.instructions;
+  if (ixs.length !== 1 && ixs.length !== 2) {
+    throw new Error(
+      `paymaster top-up must be exactly 1 or 2 instructions, got ${ixs.length} \u2014 refusing to sign a transaction whose shape does not match the documented top-up contract`
+    );
+  }
+  const ix0 = ixs[0];
+  if (!ix0.programId.equals(SystemProgram4.programId)) {
+    throw new Error(
+      `paymaster top-up instruction 0 is owned by ${ix0.programId.toBase58()}, not the System Program \u2014 refusing to sign an unrecognised first instruction`
+    );
+  }
+  const transfer2 = SystemInstruction.decodeTransfer(ix0);
+  if (!transfer2.toPubkey.equals(expect.recipient)) {
+    throw new Error(
+      `paymaster top-up sends SOL to ${transfer2.toPubkey.toBase58()}, which is not our recipient ${expect.recipient.toBase58()} \u2014 refusing to sign a transaction that funds a key we do not control`
+    );
+  }
+  if (BigInt(transfer2.lamports) > expect.maxGrantLamports) {
+    throw new Error(
+      `paymaster top-up grants ${transfer2.lamports} lamports, more than the ${expect.maxGrantLamports} we asked for \u2014 refusing a transaction that funds beyond our own request`
+    );
+  }
+  if (ixs.length === 1) return;
+  const ix1 = ixs[1];
+  if (!ix1.programId.equals(TOKEN_PROGRAM_ID3)) {
+    throw new Error(
+      `paymaster top-up instruction 1 is owned by ${ix1.programId.toBase58()}, not the SPL Token program \u2014 refusing to sign an unrecognised second instruction`
+    );
+  }
+  const spl = decodeTransferInstruction(ix1, TOKEN_PROGRAM_ID3);
+  const authority = spl.keys.owner.pubkey;
+  if (!authority.equals(expect.recipient)) {
+    throw new Error(
+      `paymaster top-up's fee transfer is authorised by ${authority.toBase58()}, not our recipient ${expect.recipient.toBase58()} \u2014 refusing to sign away tokens from an account we do not control`
+    );
+  }
+  const expectedDestination = getAssociatedTokenAddressSync3(
+    expect.feeMint,
+    expect.paymentAddress,
+    false
+  );
+  const destination = spl.keys.destination.pubkey;
+  if (!destination.equals(expectedDestination)) {
+    throw new Error(
+      `paymaster top-up's fee transfer is addressed to ${destination.toBase58()}, not the paymaster's own payment ATA ${expectedDestination.toBase58()} \u2014 refusing to sign a payment to an unverified destination`
+    );
+  }
+  const paidAmount = BigInt(spl.data.amount);
+  if (paidAmount !== expect.feeTokenAmount) {
+    throw new Error(
+      `paymaster top-up's fee amount is ${paidAmount}, not the ${expect.feeTokenAmount} Kora quoted at prepare time \u2014 refusing to sign a payment that does not match the quote`
+    );
+  }
+}
+async function parseBridgeResponse2(res, what) {
+  let body;
+  try {
+    body = await res.json();
+  } catch {
+    throw new Error(`${what} failed: ${res.status} ${res.statusText} (response body was not JSON)`);
+  }
+  if (!res.ok) {
+    const b = body ?? {};
+    throw new Error(
+      `${what} failed: ${b.message ?? res.statusText} (${b.code ?? res.status}${b.retryable ? ", retryable" : ""})`
+    );
+  }
+  return body;
+}
+async function fundReceiverViaPaymaster(relayUrl, receiver, grantLamports) {
+  assertAllowedRelayOrigin(relayUrl);
+  if (grantLamports <= 0n || grantLamports > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new Error(
+      `grantLamports must be a positive value representable as a JS number, got ${grantLamports}`
+    );
+  }
+  const prepareRes = await relayFetch(`${relayUrl}/bridge/paymaster/prepare`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      recipient: receiver.publicKey.toBase58(),
+      grant_lamports: Number(grantLamports)
+    })
+  });
+  const prepared = await parseBridgeResponse2(prepareRes, "paymaster prepare");
+  if (Math.floor(Date.now() / 1e3) >= prepared.expires_at_unix) {
+    throw new Error(
+      "paymaster prepare returned a voucher that is already expired \u2014 refusing to sign a stale top-up rather than fail confusingly at cosign"
+    );
+  }
+  const feeMint = new PublicKey14(prepared.fee_mint);
+  const paymentAddress = new PublicKey14(prepared.payment_address);
+  const feeTokenAmount = BigInt(prepared.fee_token_amount);
+  const tx = Transaction4.from(Buffer.from(prepared.transaction, "base64"));
+  validatePaymasterTopUpTransaction(tx, {
+    recipient: receiver.publicKey,
+    maxGrantLamports: grantLamports,
+    feeMint,
+    feeTokenAmount,
+    paymentAddress
+  });
+  tx.partialSign(receiver);
+  const cosignRes = await relayFetch(`${relayUrl}/bridge/paymaster/cosign`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      transaction: tx.serialize({ requireAllSignatures: false, verifySignatures: false }).toString("base64"),
+      voucher: prepared.voucher
+    })
+  });
+  const cosigned = await parseBridgeResponse2(cosignRes, "paymaster cosign");
+  return {
+    transaction: Transaction4.from(Buffer.from(cosigned.transaction, "base64")),
+    feeTokenAmount,
+    feeMint: prepared.fee_mint,
+    paymentAddress: prepared.payment_address
+  };
+}
+
+// src/bridge/derive.ts
+import { Keypair as Keypair6 } from "@solana/web3.js";
+import { hmac } from "@noble/hashes/hmac";
+import { sha512 } from "@noble/hashes/sha512";
+var BRIDGE_ESCROW_LABEL = "cloak_bridge_escrow";
+var MAX_RECEIVER_INDEX = 1e4;
+function deriveBridgeReceiver(nk, index) {
+  if (!Number.isInteger(index) || index < 0) {
+    throw new Error(`index must be a non-negative integer, got ${index}`);
+  }
+  if (index > MAX_RECEIVER_INDEX) {
+    throw new Error(
+      `index ${index} exceeds MAX_RECEIVER_INDEX (${MAX_RECEIVER_INDEX}). Indices must be a small sequential counter \u2014 discovery derives 0\u2026N and reads each on chain, so a timestamp index is unreachable by any scan and the deposit would be invisible to every device but this one.`
+    );
+  }
+  const h = hmac(sha512, new Uint8Array(nk), new TextEncoder().encode(`${BRIDGE_ESCROW_LABEL}:${index}`));
+  return Keypair6.fromSeed(h.slice(0, 32));
+}
+
+// src/bridge/discover.ts
+import { SolanaJSONRPCError } from "@solana/web3.js";
+import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync4 } from "@solana/spl-token";
+function describeError(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+async function listBridgeDeposits(conn, nk, opts) {
+  const scanDepth = Math.min(opts.scanDepth ?? 20, MAX_RECEIVER_INDEX + 1);
+  const stopAfterUnused = opts.stopAfterUnused ?? 5;
+  const out = [];
+  let consecutiveUnused = 0;
+  for (let index = 0; index < scanDepth; index++) {
+    const kp = deriveBridgeReceiver(nk, index);
+    const receiver = kp.publicKey;
+    const tokenAccount = getAssociatedTokenAddressSync4(opts.mint, receiver, false);
+    try {
+      const [recvInfo, ataInfo] = await conn.getMultipleAccountsInfo([receiver, tokenAccount]);
+      const lamports = recvInfo?.lamports ?? 0;
+      let tokenBalance = 0n;
+      if (ataInfo) {
+        try {
+          tokenBalance = BigInt((await conn.getTokenAccountBalance(tokenAccount)).value.amount);
+        } catch (err) {
+          if (!(err instanceof SolanaJSONRPCError && /could not find account/i.test(err.message))) {
+            throw err;
+          }
+        }
+      }
+      if (lamports === 0 && !ataInfo) {
+        consecutiveUnused++;
+        if (consecutiveUnused >= stopAfterUnused) break;
+        continue;
+      }
+      consecutiveUnused = 0;
+      const shieldSignatures = [];
+      const sigs = await conn.getSignaturesForAddress(receiver, { limit: 20 });
+      for (const s of sigs) {
+        if (s.err) continue;
+        const tx = await conn.getTransaction(s.signature, { maxSupportedTransactionVersion: 0 });
+        const keys = tx?.transaction.message.getAccountKeys({
+          accountKeysFromLookups: tx.meta?.loadedAddresses
+        });
+        if (keys && [...Array(keys.length).keys()].some((i) => keys.get(i)?.equals(opts.programId))) {
+          shieldSignatures.push(s.signature);
+        }
+      }
+      const shieldSignature = shieldSignatures[0];
+      const indexReused = shieldSignatures.length > 1;
+      let state;
+      if (tokenBalance > 0n) state = shieldSignature ? "needs-cleanup" : "arrived";
+      else if (shieldSignature) state = ataInfo ? "needs-cleanup" : "complete";
+      else state = "awaiting";
+      out.push({
+        index,
+        receiver,
+        tokenAccount,
+        state,
+        tokenBalance,
+        lamports,
+        shieldSignature,
+        ...indexReused ? { indexReused, shieldSignatures } : {}
+      });
+    } catch (err) {
+      out.push({
+        index,
+        receiver,
+        tokenAccount,
+        state: "unknown",
+        tokenBalance: 0n,
+        lamports: 0,
+        error: describeError(err)
+      });
+    }
+  }
+  return out;
+}
+
+// src/bridge/deposit-core.ts
+import {
+  SystemProgram as SystemProgram5,
+  Transaction as Transaction5,
+  VersionedTransaction as VersionedTransaction2,
+  sendAndConfirmTransaction as sendAndConfirmTransaction2
+} from "@solana/web3.js";
+import nacl8 from "tweetnacl";
+
+// src/bridge/funder.ts
+import { PublicKey as PublicKey16 } from "@solana/web3.js";
+import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync5 } from "@solana/spl-token";
+var MAINNET_RENT_0 = 890880;
+var MAINNET_RENT_1 = 897840;
+var FEE_BUDGET = 13e4;
+var CLEANUP_FEE_BUDGET = 5e3;
+var pda = (seeds, programId) => PublicKey16.findProgramAddressSync(seeds.map((s) => Buffer.from(s)), programId)[0];
+function deriveFundingTargets(d) {
+  const pool = pda([Buffer.from("pool"), d.mint.toBuffer()], d.programId);
+  return {
+    pool,
+    // program: NullifierAccount::derive_pda_with_pool -> [b"nullifier", pool, nullifier]
+    nullifier0: pda([Buffer.from("nullifier"), pool.toBuffer(), d.nullifiers[0]], d.programId),
+    nullifier1: pda([Buffer.from("nullifier"), pool.toBuffer(), d.nullifiers[1]], d.programId),
+    // relay: derive_risk_nonce_pda -> [b"risk_nonce", bind0]
+    riskNonce: pda([Buffer.from("risk_nonce"), d.bind0], d.programId),
+    depositorAta: getAssociatedTokenAddressSync5(d.mint, d.depositor, false)
+  };
+}
+async function readRent(conn) {
+  const [zero, one] = await Promise.all([
+    conn.getMinimumBalanceForRentExemption(0),
+    conn.getMinimumBalanceForRentExemption(1)
+  ]);
+  return { zero, one };
+}
+
+// src/bridge/deposit-core.ts
+var DepositError = class extends Error {
+  constructor(message, fundedAccounts, measuredTxSize) {
+    super(message);
+    this.fundedAccounts = fundedAccounts;
+    this.measuredTxSize = measuredTxSize;
+    this.name = "DepositError";
+  }
+};
+async function depositFromDerivedKey(conn, R, funder, amount, log = console.log, grantOverride, opts) {
+  if (!opts.noteSpendKey || opts.noteSpendKey.length !== 32) {
+    throw new Error(
+      "opts.noteSpendKey (32 bytes) is required. It derives the note's spending key, and a note whose key is not derived from something you can reproduce is unspendable forever. Pass the same Cloak seed you derived the receiving address from."
+    );
+  }
+  if (!opts.relayUrl) {
+    throw new Error(
+      "opts.relayUrl is required. There is no default: a missing relay used to resolve silently to the local stack, which is how a live run built a deposit against infrastructure that only existed on someone's laptop. Say which relay, every call."
+    );
+  }
+  if (!opts.programId) {
+    throw new Error(
+      "opts.programId is required. There is no default: this is the exact field a live mainnet run once inherited from this module's local-stack constant, built a deposit against a program that does not exist on mainnet, and failed hunting a merkle tree that was never there."
+    );
+  }
+  if (!opts.mint) {
+    throw new Error(
+      "opts.mint is required. There is no default: a deposit built for the wrong mint produces a note for an asset that never arrived at R, and there is nothing to silently fall back to."
+    );
+  }
+  assertAllowedRpcConnection(conn);
+  const relayUrl = opts.relayUrl;
+  const programId = opts.programId;
+  const mint = opts.mint;
+  setCircuitsPath(resolveCircuitsBase());
+  const grantR = grantOverride ?? MAINNET_RENT_0 + FEE_BUDGET + CLEANUP_FEE_BUDGET;
+  const heldByR = await conn.getBalance(R.publicKey);
+  if (heldByR >= grantR) {
+    log(`   R already holds ${heldByR} (>= ${grantR}) \u2014 no top-up needed`);
+  } else {
+    await sendAndConfirmTransaction2(conn, new Transaction5().add(
+      SystemProgram5.transfer({ fromPubkey: funder.publicKey, toPubkey: R.publicKey, lamports: grantR - heldByR })
+    ), [funder]);
+    log(`   funder topped R up by ${grantR - heldByR} to ${grantR}${grantOverride !== void 0 ? " (OVERRIDDEN for a deliberate test)" : " \u2014 floor + deposit fee + cleanup fee, no rent"}`);
+  }
+  let measuredSize = -1;
+  let fundedAccounts = [];
+  const signTransaction2 = async (tx) => {
+    if (tx instanceof VersionedTransaction2) {
+      measuredSize = tx.serialize().length;
+      const alts = await Promise.all(
+        tx.message.addressTableLookups.map(async (l) => (await conn.getAddressLookupTable(l.accountKey)).value)
+      );
+      const keys = tx.message.getAccountKeys({ addressLookupTableAccounts: alts });
+      const ix = tx.message.compiledInstructions.find((i) => keys.get(i.programIdIndex).equals(programId));
+      const at = (n) => keys.get(ix.accountKeyIndexes[n]);
+      const targets = [
+        { a: at(12), need: MAINNET_RENT_0, name: "risk_nonce" },
+        { a: at(4), need: MAINNET_RENT_1, name: "nullifier_0" },
+        { a: at(5), need: MAINNET_RENT_1, name: "nullifier_1" }
+      ];
+      const infos = await conn.getMultipleAccountsInfo(targets.map((t) => t.a));
+      fundedAccounts = targets.map((t, i) => ({
+        name: t.name,
+        address: t.a.toBase58(),
+        lamportsSent: Math.max(0, t.need - (infos[i]?.lamports ?? 0))
+      }));
+      const ixs = targets.flatMap((t, i) => (infos[i]?.lamports ?? 0) >= t.need ? [] : [SystemProgram5.transfer({
+        fromPubkey: funder.publicKey,
+        toPubkey: t.a,
+        lamports: t.need - (infos[i]?.lamports ?? 0)
+      })]);
+      if (ixs.length) {
+        const sig = await sendAndConfirmTransaction2(conn, new Transaction5().add(...ixs), [funder]);
+        log(`   seam: funded ${ixs.length} program accounts read off the built tx \u2014 ${sig.slice(0, 16)}\u2026`);
+      }
+      tx.sign([R]);
+      return tx;
+    }
+    tx.partialSign(R);
+    return tx;
+  };
+  const signMessage = async (m) => nacl8.sign.detached(m, R.secretKey);
+  const utxoKeypair = await deriveUtxoKeypairFromSpendKey(opts.noteSpendKey);
+  const nk = getNkFromUtxoPrivateKey(utxoKeypair.privateKey);
+  const { utxo, noteSalt } = await createRecoverableDepositUtxo(amount, nk, mint);
+  const zeroInput = await createZeroUtxo(mint);
+  const rBefore = await conn.getBalance(R.publicKey);
+  let result;
+  try {
+    result = await transact(
+      { inputUtxos: [zeroInput], outputUtxos: [utxo], externalAmount: amount, depositor: R.publicKey },
+      {
+        connection: conn,
+        programId,
+        relayUrl,
+        // NO depositorKeypair: the SDK branches `if (keypair) … else if (signTransaction)`
+        // (transact.ts:2786, :2936), so passing one silently skips the funding seam.
+        depositorPublicKey: R.publicKey,
+        walletPublicKey: R.publicKey,
+        signTransaction: signTransaction2,
+        signMessage,
+        chainNoteViewingKeyNk: nk,
+        chainNoteSalt: noteSalt,
+        relaySupplementalAlt: true,
+        onProgress: (s) => log(`   \xB7 ${s}`)
+      }
+    );
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new DepositError(msg, fundedAccounts, measuredSize);
+  }
+  const rAfter = await conn.getBalance(R.publicKey);
+  const noteIndex = result.outputUtxos[0].index;
+  if (noteIndex === void 0) throw new Error("deposit landed but the note has no index \u2014 it cannot be discovered later");
+  return {
+    signature: result.signature,
+    noteIndex,
+    amount: result.outputUtxos[0].amount,
+    txSize: measuredSize,
+    rBefore,
+    rAfter,
+    rentExempt: rAfter >= MAINNET_RENT_0,
+    inputNullifiers: result.inputNullifiers,
+    fundedAccounts
+  };
+}
+
+// src/bridge/cleanup.ts
+import {
+  PublicKey as PublicKey18,
+  Transaction as Transaction6,
+  sendAndConfirmTransaction as sendAndConfirmTransaction3
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddressSync as getAssociatedTokenAddressSync6,
+  createCloseAccountInstruction,
+  createTransferInstruction,
+  createAssociatedTokenAccountIdempotentInstruction,
+  getMinimumBalanceForRentExemptAccount
+} from "@solana/spl-token";
+var DEFAULT_MINT = new PublicKey18("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+async function cleanupReceivingAddress(conn, R, dustDestination, mint = DEFAULT_MINT) {
+  assertAllowedRpcConnection(conn);
+  const rAta = getAssociatedTokenAddressSync6(mint, R.publicKey);
+  const info = await conn.getAccountInfo(rAta);
+  if (!info) {
+    return {
+      closed: false,
+      dustSwept: 0n,
+      rentReturned: 0,
+      destination: null,
+      signature: null,
+      note: "no token account \u2014 nothing to recover"
+    };
+  }
+  const bal = BigInt((await conn.getTokenAccountBalance(rAta)).value.amount);
+  const rentHeld = info.lamports;
+  const before = await conn.getBalance(R.publicKey);
+  const ixs = [];
+  let destination = null;
+  if (bal > 0n && !dustDestination) {
+    return {
+      closed: false,
+      dustSwept: 0n,
+      rentReturned: 0,
+      destination: null,
+      signature: null,
+      note: `dusted with ${bal} base units after the deposit; leaving the account open and ${rentHeld.toLocaleString()} lamports of rent unrecovered, because sweeping it would publish a link from this deposit to whoever receives it`
+    };
+  }
+  if (bal > 0n && dustDestination) {
+    const destAta = getAssociatedTokenAddressSync6(mint, dustDestination);
+    const destInfo = await conn.getAccountInfo(destAta);
+    if (!destInfo) {
+      const ataRent = await getMinimumBalanceForRentExemptAccount(conn);
+      if (before < ataRent + CLEANUP_FEE_BUDGET) {
+        throw new Error(
+          `dustDestination ${dustDestination.toBase58()} has no token account for mint ${mint.toBase58()}, and creating one costs ${ataRent} lamports of rent that R does not have: R holds ${before}, which deposit-core.ts reserved only for this transaction's own fee (CLEANUP_FEE_BUDGET = ${CLEANUP_FEE_BUDGET} in funder.ts), not for a fresh account's rent. Fund R with at least ${ataRent + CLEANUP_FEE_BUDGET - before} more lamports first, or choose a destination that already has a token account for this mint.`
+        );
+      }
+      ixs.push(createAssociatedTokenAccountIdempotentInstruction(R.publicKey, destAta, dustDestination, mint));
+    }
+    ixs.push(createTransferInstruction(rAta, destAta, R.publicKey, bal));
+    destination = destAta.toBase58();
+  }
+  ixs.push(createCloseAccountInstruction(rAta, R.publicKey, R.publicKey));
+  const signature = await sendAndConfirmTransaction3(conn, new Transaction6().add(...ixs), [R], {
+    commitment: "confirmed"
+  });
+  const after = await conn.getBalance(R.publicKey);
+  const gone = await conn.getAccountInfo(rAta) === null;
+  return {
+    closed: gone,
+    dustSwept: bal,
+    rentReturned: after - before,
+    destination,
+    signature,
+    note: bal > 0n ? `swept ${bal} base units of dust to the caller-chosen destination and closed, in one transaction \u2014 note this publishes a link from the deposit to that destination` : `closed cleanly, nothing to sweep`
+  };
+}
+
+// src/bridge/quote.ts
+var MIN_DEPOSIT_SPL_BASE_UNITS = 1000000n;
+var WITHDRAW_FIXED_FEE = 450000n;
+var WITHDRAW_FEE_BPS = 30n;
+function withdrawFeeAt(amount, fixedFee, feeBps) {
+  return fixedFee + amount * feeBps / 10000n;
+}
+var MAX_FEE_FRACTION = 0.063;
+var FIXED_ROUND_TRIP = 903000n;
+var ECONOMIC_MINIMUM = FIXED_ROUND_TRIP * 1000000n / BigInt(Math.round((MAX_FEE_FRACTION - 3e-3) * 1e6));
+function withdrawFeeFor(amount) {
+  return withdrawFeeAt(amount, WITHDRAW_FIXED_FEE, WITHDRAW_FEE_BPS);
+}
+function assessBridgeQuote(q) {
+  if (q.sent < 0n) {
+    throw new Error(`assessBridgeQuote: sent must not be negative (got ${q.sent}).`);
+  }
+  if (q.arrivesMin > q.sent) {
+    throw new Error(
+      `assessBridgeQuote: arrivesMin (${q.arrivesMin}) exceeds sent (${q.sent}) \u2014 no rail returns more than it was given, so this input did not come from a real quote.`
+    );
+  }
+  const shieldedMinRaw = q.arrivesMin - q.paymasterFee;
+  const shieldedTargetRaw = q.arrivesTarget - q.paymasterFee;
+  const shieldedMin = shieldedMinRaw > 0n ? shieldedMinRaw : 0n;
+  const shieldedTarget = shieldedTargetRaw > 0n ? shieldedTargetRaw : 0n;
+  const viable = shieldedMinRaw >= MIN_DEPOSIT_SPL_BASE_UNITS;
+  const economic = q.sent >= ECONOMIC_MINIMUM;
+  const withdrawFee = shieldedMin > 0n ? withdrawFeeAt(shieldedMin, q.liveWithdrawFixedFee ?? WITHDRAW_FIXED_FEE, q.liveWithdrawFeeBps ?? WITHDRAW_FEE_BPS) : 0n;
+  const roundTripCost = q.sent - (shieldedMin > withdrawFee ? shieldedMin - withdrawFee : 0n);
+  const roundTripFraction = q.sent > 0n ? Number(roundTripCost) / Number(q.sent) : 0;
+  const reasons = [];
+  if (!viable) {
+    const short = MIN_DEPOSIT_SPL_BASE_UNITS - shieldedMinRaw;
+    reasons.push(
+      (shieldedMinRaw <= 0n ? `The ${fmt(q.paymasterFee)} paymaster fee alone is ${shieldedMinRaw < 0n ? `${fmt(-shieldedMinRaw)} more than` : "all of"} the ${fmt(q.arrivesMin)} the rail guarantees, so nothing would be left to shield.` : `Only ${fmt(shieldedMinRaw)} would be left to shield after the ${fmt(q.paymasterFee)} paymaster fee.`) + ` The program's minimum deposit is ${fmt(MIN_DEPOSIT_SPL_BASE_UNITS)}. Send at least ${fmt(q.sent + short)} to clear it.`
+    );
+  }
+  if (viable && !economic) {
+    reasons.push(
+      `This works, but ${fmt(roundTripCost)} of ${fmt(q.sent)} goes to fees (${(roundTripFraction * 100).toFixed(0)}%). The costs are almost all fixed, so bridging ${fmt(ECONOMIC_MINIMUM)} or more spreads them much further.`
+    );
+  }
+  return {
+    ...q,
+    shieldedMin,
+    shieldedTarget,
+    viable,
+    economic,
+    withdrawFee,
+    roundTripCost,
+    roundTripFraction,
+    reasons
+  };
+}
+var fmt = (v) => `${(Number(v) / 1e6).toFixed(6)} USDC`;
+function renderAssessment(a) {
+  const L = [];
+  L.push(`  you send            ${fmt(a.sent)}`);
+  L.push(`  arrives at least    ${fmt(a.arrivesMin)}        (target ${fmt(a.arrivesTarget)}, not a promise)`);
+  L.push(`  paymaster fee       ${fmt(a.paymasterFee)}        buys the receiver its SOL, so your wallet stays off chain`);
+  L.push(`  SHIELDED            ${fmt(a.shieldedMin)}        at least \u2014 this is what you end up with`);
+  L.push(`  to withdraw later   ${fmt(a.withdrawFee)}        the program's fee, whenever you take it out`);
+  for (const r of a.reasons) L.push(`
+  ${a.viable ? "NOTE" : "REFUSED"}: ${r}`);
+  return L.join("\n");
+}
+
+// src/bridge/retry.ts
+var TERMINAL_FAILURE = /DepositTooSmall|minimum is 1\.000000|insufficient|holds only|below the program|kora wants|over the .* ceiling/i;
+function isTerminalFailure(message) {
+  return TERMINAL_FAILURE.test(message);
+}
+function classifyPostFailure(attempted, after) {
+  if (after === null) return "unknown";
+  if (after === 0n) return "landed";
+  if (after >= attempted) return "did-not-land";
+  return "unknown";
+}
+function mayRetry(verdict, message) {
+  return verdict === "did-not-land" && !isTerminalFailure(message);
+}
+function retryDelayMs(attempt) {
+  return 15e3 * Math.max(0, attempt - 1);
+}
+var DoNotRetry = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "DoNotRetry";
+  }
+};
+async function withShieldRetries(attempt, hooks = {}) {
+  const attempts = hooks.attempts ?? 3;
+  const sleep4 = hooks.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  let last = "";
+  for (let n = 1; n <= attempts; n++) {
+    if (n > 1) {
+      const delay = retryDelayMs(n);
+      hooks.onRetry?.(n, delay, last);
+      await sleep4(delay);
+    }
+    try {
+      return await attempt(n);
+    } catch (e) {
+      if (e instanceof DoNotRetry) throw e;
+      last = e instanceof Error ? e.message : String(e);
+      if (isTerminalFailure(last) || n === attempts) throw e;
+    }
+  }
+  throw new Error("unreachable");
+}
+
 // src/index.ts
-var VERSION = "0.2.1";
+var VERSION = "0.2.3";
 var SCANNER_SUPPORTS_TRANSACT_SWAP = true;
 export {
+  BRIDGE_ESCROW_LABEL,
   BUILD_ALLOWS_LOCAL_ENDPOINTS,
   CHAIN_NOTE_SALT_BITS,
+  CLEANUP_FEE_BUDGET,
   CLOAK_PRODUCTION_RELAY_URL,
   CLOAK_PROGRAM_ID,
   CloakError,
@@ -10870,25 +12045,38 @@ export {
   DEFAULT_TRANSACTION_CIRCUITS_URL,
   DELIVERY_MEMO_TAG,
   DELIVERY_REGISTRY_SEED,
+  DepositError,
+  DoNotRetry,
+  ECONOMIC_MINIMUM,
   EXPECTED_CIRCUIT_HASHES,
+  FEE_BUDGET,
   FIXED_FEE_LAMPORTS,
   InsecureRandomnessError,
   LAMPORTS_PER_SOL,
   LocalStorageAdapter,
+  MAINNET_RENT_0,
+  MAINNET_RENT_1,
+  MAX_RECEIVER_INDEX,
   MERKLE_TREE_HEIGHT2 as MERKLE_TREE_HEIGHT,
   MIN_DEPOSIT_LAMPORTS,
+  MIN_DEPOSIT_SPL_BASE_UNITS,
   MemoryStorageAdapter,
   MerkleTree,
   NATIVE_SOL_MINT,
+  ONECLICK_PUBKEY_B58,
   RECIPIENT_DELIVERY_CIPHERTEXT_LEN,
   RECIPIENT_DELIVERY_EPHEMERAL_PK_LEN,
   RECIPIENT_DELIVERY_NONCE_LEN,
   RECIPIENT_DELIVERY_NOTE_BYTES,
   RECIPIENT_DELIVERY_PLAINTEXT_LEN,
   RECIPIENT_DELIVERY_TAG_LEN,
+  RELAY_BATCH_AUTH_MAX_ITEMS,
   RELAY_ORIGIN_ALLOWLIST,
+  REQUEST_AUTH_BATCH_DOMAIN,
+  REQUEST_AUTH_BATCH_MAX_AGE_SECONDS,
   REQUEST_AUTH_MAX_AGE_SECONDS,
   REQUEST_AUTH_MAX_FUTURE_SKEW_SECONDS,
+  RelayBatchAuthCoordinator,
   RelayInternalError,
   RelayService,
   RootNotFoundError,
@@ -10898,6 +12086,7 @@ export {
   SettlementVerificationError,
   ShieldPoolErrors,
   SimpleWallet,
+  TERMINAL_FAILURE,
   TRANSACTION_CIRCUITS_VERSION,
   TRANSACT_AUTH_FIELDS,
   TRANSACT_SWAP_AUTH_FIELDS,
@@ -10907,15 +12096,21 @@ export {
   VARIABLE_FEE_NUMERATOR,
   VARIABLE_FEE_RATE,
   VERSION,
+  WITHDRAW_FEE_BPS,
+  WITHDRAW_FIXED_FEE,
   assertDirectSubmissionLanded,
+  assertInputMints,
   assertTransactionCircuitIntegrity,
+  assessBridgeQuote,
   bigintToBytes32,
   bigintToHex,
+  buildAuthTransactionMessage,
   buildMerkleTree,
   buildMerkleTreeFromChain,
   buildMerkleTreeFromRelay,
   buildRecipientDeliveryNotes,
   buildRelayAuthPreimage,
+  buildRelayBatchAuthMessage,
   buildTransactRequestBody,
   bytesToHex,
   calculateFee,
@@ -10923,12 +12118,16 @@ export {
   calculateRelayFee,
   canRebuildMerkleTreeFromChain,
   canonicalJson,
+  canonicalPayloadString,
   chainNoteFromBase64,
   chainNoteToBase64,
+  classifyPostFailure,
   classifyRelayError,
+  cleanupReceivingAddress,
   cleanupStalePendingOperations,
   clearPendingDeposits,
   clearPendingWithdrawals,
+  cloakBridgeRail,
   computeChainNoteHash,
   computeExtDataHash,
   computeMerkleRoot,
@@ -10945,15 +12144,19 @@ export {
   createLogger,
   createRecoverableChangeUtxo,
   createRecoverableDepositUtxo,
+  createRelayBatchAuthCoordinator,
   createUtxo,
   createZeroUtxo,
   decryptCompactChainNote,
   decryptComplianceMetadataWithMasterKey,
   decryptTransactionMetadata,
+  depositFromDerivedKey,
+  deriveBridgeReceiver,
   deriveChangeNoteBlinding,
   deriveDepositNoteSecrets,
   deriveDiversifiedViewingKey,
   deriveDiversifier,
+  deriveFundingTargets,
   deriveInputNullifierPdas,
   derivePublicKey,
   deriveSpendKey,
@@ -10992,6 +12195,7 @@ export {
   formatErrorForLogging,
   formatSol,
   fullWithdraw,
+  fundReceiverViaPaymaster,
   generateCloakKeys,
   generateCommitmentAsync,
   generateMasterSeed,
@@ -11027,18 +12231,21 @@ export {
   isReactNative,
   isRootNotFoundError,
   isSubmissionOutcomeUnknownResponse,
+  isTerminalFailure,
   isValidHex,
   isValidRpcUrl,
   isValidSolanaAddress,
   isWithdrawAmountSufficient,
   isWithdrawable,
   keypairToAdapter,
+  listBridgeDeposits,
   loadPendingDeposits,
   loadPendingWithdrawals,
   loadVerifiedCircuitArtifacts,
   matchChangeNote,
   matchDepositNote,
   matchSwapRefundLeaf,
+  mayRetry,
   openRecipientDeliveryNote,
   parseAmount,
   parseDeliveryCarrierMemo,
@@ -11061,11 +12268,15 @@ export {
   randomDepositNoteSalt,
   randomFieldElement,
   readMerkleTreeState,
+  readRent,
   recipientDeliveryNoteToBase64,
   registerViewingKey,
+  relayRequestDigestHex,
   removePendingDeposit,
   removePendingWithdrawal,
+  renderAssessment,
   resolveCircuitsBase,
+  retryDelayMs,
   savePendingDeposit,
   savePendingWithdrawal,
   scanNotesForWallet,
@@ -11074,10 +12285,12 @@ export {
   sdkLogger,
   selectUtxos,
   sendTransaction,
+  serializeAuthTransactionMessage,
   serializeNote,
   serializeUtxo,
   setCircuitsPath,
   setDebugMode,
+  signRelayAuthPayload,
   signTransaction,
   splitTo2Limbs,
   submitTransactToRelay,
@@ -11086,6 +12299,7 @@ export {
   swapWithChange,
   toComplianceReport,
   transact,
+  transactBatch,
   transfer,
   truncate,
   tryDecryptNote,
@@ -11098,13 +12312,17 @@ export {
   validateDepositParams,
   validateNote,
   validateOutputsSum,
+  validatePaymasterTopUpTransaction,
   validateRoot,
   validateTransfers,
   validateWalletConnected,
   validateWithdrawableNote,
   verifyAllCircuits,
   verifyCircuitIntegrity,
+  verifyQuoteSignature,
   verifyUtxos,
   waitForRoot,
-  withTiming
+  withShieldRetries,
+  withTiming,
+  withdrawFeeFor
 };