@cloak.dev/sdk 0.2.3-staging.16d1078 → 0.2.3-staging.4f641ea

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";
@@ -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
@@ -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;
@@ -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,236 +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, 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 = 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")
-  };
-}
-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 bytesToHex3(sha2563(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/proving/artifacts.ts
 import { sha256 as sha2564 } from "@noble/hashes/sha2";
 
@@ -5252,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}`);
   }
@@ -5320,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 {
@@ -5410,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
   );
@@ -5572,17 +5620,27 @@ async function registerViewingKeyOnce(relayUrl, userPubkey, viewingKeyHex, cache
     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...");
@@ -5593,7 +5651,8 @@ async function registerViewingKeyOnce(relayUrl, userPubkey, viewingKeyHex, cache
       user_pubkey: userPubkey.toBase58(),
       viewing_key: viewingKeyHex,
       nonce: challenge.nonce,
-      signature: signatureBase64
+      signature: signatureBase64,
+      ...authMode === "transaction" ? { auth_mode: authMode } : {}
     })
   });
   if (!response.ok) {
@@ -5687,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
   );
@@ -5706,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
   );
@@ -5739,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;
@@ -5769,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) {
@@ -5814,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
@@ -5892,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;
@@ -6553,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);
         }
@@ -6777,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");
     }
@@ -6878,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) {
@@ -8035,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
         );
@@ -9023,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
       );
@@ -9443,8 +9506,7 @@ function cleanupStalePendingOperations(maxAgeMs = 24 * 60 * 60 * 1e3) {
 }
 
 // src/relay/batch-auth.ts
-import { Keypair as Keypair3 } from "@solana/web3.js";
-import nacl7 from "tweetnacl";
+import { Keypair as Keypair4 } from "@solana/web3.js";
 var RelayBatchAuthCoordinator = class {
   constructor(options) {
     this.proofSlotsInUse = 0;
@@ -9467,7 +9529,7 @@ var RelayBatchAuthCoordinator = class {
       throw new Error(`submitConcurrency must be a positive integer (got ${concurrency}).`);
     }
     this.signer = options.signer;
-    this.sender = options.signer instanceof Keypair3 ? options.signer.publicKey : options.signer.walletPublicKey;
+    this.sender = options.signer instanceof Keypair4 ? options.signer.publicKey : options.signer.walletPublicKey;
     this.expectedItems = options.items;
     this.submitConcurrency = concurrency;
     const proofConcurrency = options.proofConcurrency ?? 2;
@@ -9591,24 +9653,19 @@ var RelayBatchAuthCoordinator = class {
       const issuedAt = preimages[0].auth_issued_at;
       const message = buildRelayBatchAuthMessage(programId, issuedAt, digests);
       this.waves += 1;
-      let signature;
-      if (this.signer instanceof Keypair3) {
-        signature = nacl7.sign.detached(message, this.signer.secretKey);
-      } else {
+      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)` : "") + `. This signs the requests for the relay, not a transaction, and must be approved within a few minutes to stay valid.`
+          `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();
-        signature = await this.signer.signMessage(message);
+      }
+      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
         );
-        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}).`
-          );
-        }
       }
       const signatureB64 = Buffer.from(signature).toString("base64");
       wave.forEach((item, i) => {
@@ -9620,6 +9677,7 @@ var RelayBatchAuthCoordinator = class {
             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] }
@@ -9668,10 +9726,18 @@ async function transactBatch(items, options) {
     throw new Error("transactBatch requires relayUrl: batch approval is a relay authentication scheme.");
   }
   const { proofConcurrency, submitConcurrency, ...shared } = options;
-  const signer = shared.depositorKeypair ? shared.depositorKeypair : shared.walletPublicKey && shared.signMessage ? { walletPublicKey: shared.walletPublicKey, signMessage: shared.signMessage } : shared.depositorPublicKey && shared.signMessage ? { walletPublicKey: shared.depositorPublicKey, signMessage: shared.signMessage } : null;
+  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 `signMessage` together with `walletPublicKey` (a browser wallet adapter). Checked before proof generation, so nothing has been computed or submitted yet."
+      "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({
@@ -9708,7 +9774,7 @@ async function transactBatch(items, options) {
 // src/scanning/scan.ts
 import _bs583 from "bs58";
 import {
-  PublicKey as PublicKey10
+  PublicKey as PublicKey12
 } from "@solana/web3.js";
 import { getAssociatedTokenAddressSync as getAssociatedTokenAddressSync2 } from "@solana/spl-token";
 var bs583 = _bs583.default || _bs583;
@@ -9796,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 PublicKey10(mintBytes).toBase58();
+    return new PublicKey12(mintBytes).toBase58();
   } catch {
     return void 0;
   }
@@ -9886,7 +9952,7 @@ function parseSwapRecipientAta(data) {
   const recipientAtaBytes = data.slice(recipientAtaStart, recipientAtaEnd);
   if (recipientAtaBytes.every((byte) => byte === 0)) return void 0;
   try {
-    return new PublicKey10(recipientAtaBytes).toBase58();
+    return new PublicKey12(recipientAtaBytes).toBase58();
   } catch {
     return void 0;
   }
@@ -10048,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] = PublicKey10.findProgramAddressSync(
+  const [registry] = PublicKey12.findProgramAddressSync(
     [Buffer.from("cloak_chain_note_registry")],
     programId
   );
@@ -10451,8 +10517,8 @@ async function scanTransactions(opts) {
                   if (onChainAta) {
                     try {
                       const expectedAta = getAssociatedTokenAddressSync2(
-                        new PublicKey10(asset.mint),
-                        new PublicKey10(walletPublicKey)
+                        new PublicKey12(asset.mint),
+                        new PublicKey12(walletPublicKey)
                       ).toBase58();
                       if (onChainAta === expectedAta) {
                         isOurs = true;
@@ -10666,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 PublicKey10(asset.mint),
+                  mintAddress: new PublicKey12(asset.mint),
                   outputCommitments: ixCtx.outputCommitments ?? []
                 });
                 if (recoveredDeposit) {
@@ -10692,7 +10758,7 @@ async function scanTransactions(opts) {
                   noteSalt: compactNote.noteSalt,
                   amount: compactNote.outAmount0,
                   keypair: { privateKey: 0n, publicKey: compactNote.outPubkey0 },
-                  mintAddress: new PublicKey10(asset.mint),
+                  mintAddress: new PublicKey12(asset.mint),
                   outputIndex: 0,
                   // v4 describes output 0, which is where change lands
                   outputCommitments: ixCtx.outputCommitments ?? []
@@ -10885,7 +10951,7 @@ function formatComplianceCsv(report) {
 }
 
 // src/wallet/utxo-wallet.ts
-import { PublicKey as PublicKey11 } from "@solana/web3.js";
+import { PublicKey as PublicKey13 } from "@solana/web3.js";
 var UtxoWallet = class _UtxoWallet {
   constructor(viewingKey) {
     this.wallets = /* @__PURE__ */ new Map();
@@ -11097,7 +11163,7 @@ var UtxoWallet = class _UtxoWallet {
       data.viewingKey ? new Uint8Array(data.viewingKey) : void 0
     );
     for (const w of data.wallets) {
-      const mint = new PublicKey11(w.mint);
+      const mint = new PublicKey13(w.mint);
       for (const u of w.utxos) {
         wallet.addUtxo({
           amount: BigInt(u.amount),
@@ -11180,7 +11246,7 @@ var SimpleWallet = class {
 };
 
 // src/bridge/rail-verify.ts
-import nacl8 from "tweetnacl";
+import nacl7 from "tweetnacl";
 import { sha256 as sha2565 } from "@noble/hashes/sha256";
 var ONECLICK_PUBKEY_B58 = "reYaWhvwu8Jzo3WUM3zhn6VrhuMEF4eADL17qtRVifc";
 var b58 = /* @__PURE__ */ (() => {
@@ -11291,7 +11357,7 @@ function verifyQuoteSignature(resp) {
   const message = new TextEncoder().encode(b58.encode(new Uint8Array(digest)));
   const sig = resp.signature.replace(/^ed25519:/, "");
   try {
-    return { valid: nacl8.sign.detached.verify(message, b58.decode(sig), b58.decode(ONECLICK_PUBKEY_B58)) };
+    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) };
   }
@@ -11390,10 +11456,10 @@ function cloakBridgeRail(relayUrl) {
 
 // src/bridge/paymaster-client.ts
 import {
-  PublicKey as PublicKey12,
+  PublicKey as PublicKey14,
   SystemInstruction,
-  SystemProgram as SystemProgram3,
-  Transaction as Transaction3
+  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) {
@@ -11404,7 +11470,7 @@ function validatePaymasterTopUpTransaction(tx, expect) {
     );
   }
   const ix0 = ixs[0];
-  if (!ix0.programId.equals(SystemProgram3.programId)) {
+  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`
     );
@@ -11488,10 +11554,10 @@ async function fundReceiverViaPaymaster(relayUrl, receiver, grantLamports) {
       "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 PublicKey12(prepared.fee_mint);
-  const paymentAddress = new PublicKey12(prepared.payment_address);
+  const feeMint = new PublicKey14(prepared.fee_mint);
+  const paymentAddress = new PublicKey14(prepared.payment_address);
   const feeTokenAmount = BigInt(prepared.fee_token_amount);
-  const tx = Transaction3.from(Buffer.from(prepared.transaction, "base64"));
+  const tx = Transaction4.from(Buffer.from(prepared.transaction, "base64"));
   validatePaymasterTopUpTransaction(tx, {
     recipient: receiver.publicKey,
     maxGrantLamports: grantLamports,
@@ -11510,7 +11576,7 @@ async function fundReceiverViaPaymaster(relayUrl, receiver, grantLamports) {
   });
   const cosigned = await parseBridgeResponse2(cosignRes, "paymaster cosign");
   return {
-    transaction: Transaction3.from(Buffer.from(cosigned.transaction, "base64")),
+    transaction: Transaction4.from(Buffer.from(cosigned.transaction, "base64")),
     feeTokenAmount,
     feeMint: prepared.fee_mint,
     paymentAddress: prepared.payment_address
@@ -11518,7 +11584,7 @@ async function fundReceiverViaPaymaster(relayUrl, receiver, grantLamports) {
 }
 
 // src/bridge/derive.ts
-import { Keypair as Keypair5 } from "@solana/web3.js";
+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";
@@ -11533,7 +11599,7 @@ function deriveBridgeReceiver(nk, index) {
     );
   }
   const h = hmac(sha512, new Uint8Array(nk), new TextEncoder().encode(`${BRIDGE_ESCROW_LABEL}:${index}`));
-  return Keypair5.fromSeed(h.slice(0, 32));
+  return Keypair6.fromSeed(h.slice(0, 32));
 }
 
 // src/bridge/discover.ts
@@ -11615,21 +11681,21 @@ async function listBridgeDeposits(conn, nk, opts) {
 
 // src/bridge/deposit-core.ts
 import {
-  SystemProgram as SystemProgram4,
-  Transaction as Transaction4,
+  SystemProgram as SystemProgram5,
+  Transaction as Transaction5,
   VersionedTransaction as VersionedTransaction2,
   sendAndConfirmTransaction as sendAndConfirmTransaction2
 } from "@solana/web3.js";
-import nacl9 from "tweetnacl";
+import nacl8 from "tweetnacl";
 
 // src/bridge/funder.ts
-import { PublicKey as PublicKey14 } from "@solana/web3.js";
+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) => PublicKey14.findProgramAddressSync(seeds.map((s) => Buffer.from(s)), programId)[0];
+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 {
@@ -11690,8 +11756,8 @@ async function depositFromDerivedKey(conn, R, funder, amount, log = console.log,
   if (heldByR >= grantR) {
     log(`   R already holds ${heldByR} (>= ${grantR}) \u2014 no top-up needed`);
   } else {
-    await sendAndConfirmTransaction2(conn, new Transaction4().add(
-      SystemProgram4.transfer({ fromPubkey: funder.publicKey, toPubkey: R.publicKey, lamports: grantR - heldByR })
+    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"}`);
   }
@@ -11717,13 +11783,13 @@ async function depositFromDerivedKey(conn, R, funder, amount, log = console.log,
         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 ? [] : [SystemProgram4.transfer({
+      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 Transaction4().add(...ixs), [funder]);
+        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]);
@@ -11732,7 +11798,7 @@ async function depositFromDerivedKey(conn, R, funder, amount, log = console.log,
     tx.partialSign(R);
     return tx;
   };
-  const signMessage = async (m) => nacl9.sign.detached(m, R.secretKey);
+  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);
@@ -11780,8 +11846,8 @@ async function depositFromDerivedKey(conn, R, funder, amount, log = console.log,
 
 // src/bridge/cleanup.ts
 import {
-  PublicKey as PublicKey16,
-  Transaction as Transaction5,
+  PublicKey as PublicKey18,
+  Transaction as Transaction6,
   sendAndConfirmTransaction as sendAndConfirmTransaction3
 } from "@solana/web3.js";
 import {
@@ -11791,7 +11857,7 @@ import {
   createAssociatedTokenAccountIdempotentInstruction,
   getMinimumBalanceForRentExemptAccount
 } from "@solana/spl-token";
-var DEFAULT_MINT = new PublicKey16("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
+var DEFAULT_MINT = new PublicKey18("EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v");
 async function cleanupReceivingAddress(conn, R, dustDestination, mint = DEFAULT_MINT) {
   assertAllowedRpcConnection(conn);
   const rAta = getAssociatedTokenAddressSync6(mint, R.publicKey);
@@ -11837,7 +11903,7 @@ async function cleanupReceivingAddress(conn, R, dustDestination, mint = DEFAULT_
     destination = destAta.toBase58();
   }
   ixs.push(createCloseAccountInstruction(rAta, R.publicKey, R.publicKey));
-  const signature = await sendAndConfirmTransaction3(conn, new Transaction5().add(...ixs), [R], {
+  const signature = await sendAndConfirmTransaction3(conn, new Transaction6().add(...ixs), [R], {
     commitment: "confirmed"
   });
   const after = await conn.getBalance(R.publicKey);
@@ -12038,6 +12104,7 @@ export {
   assessBridgeQuote,
   bigintToBytes32,
   bigintToHex,
+  buildAuthTransactionMessage,
   buildMerkleTree,
   buildMerkleTreeFromChain,
   buildMerkleTreeFromRelay,
@@ -12218,10 +12285,12 @@ export {
   sdkLogger,
   selectUtxos,
   sendTransaction,
+  serializeAuthTransactionMessage,
   serializeNote,
   serializeUtxo,
   setCircuitsPath,
   setDebugMode,
+  signRelayAuthPayload,
   signTransaction,
   splitTo2Limbs,
   submitTransactToRelay,