@unlink-xyz/core 0.1.3-canary.0bfbcf1 → 0.1.3-canary.18566ec

package/dist/browser/index.js

@@ -3611,6 +3611,12 @@ var ReconcileError = class extends CoreError {
     this.status = status;
   }
 };
+var AdapterError = class extends CoreError {
+  constructor(message) {
+    super(message);
+    this.name = "AdapterError";
+  }
+};
 
 // keys.ts
 init_process();
@@ -7962,7 +7968,12 @@ var VALID_STATUSES = [
   "failed",
   "dead"
 ];
-var VALID_KINDS = ["deposit", "transfer", "withdraw"];
+var VALID_KINDS = [
+  "deposit",
+  "transfer",
+  "withdraw",
+  "adapter"
+];
 function assertStatus(status) {
   if (!VALID_STATUSES.includes(status)) {
     throw new CoreError(`invalid job status: ${status}`);
@@ -8042,6 +8053,12 @@ function validateDepositRecord(job) {
     }
   }
 }
+function validateAdapterRecord(job) {
+  ensureAddress("adapter address", job.adapterAddress);
+  if (!job.adapterCalldata) {
+    throw new CoreError("adapterCalldata is required for adapter record");
+  }
+}
 function validateJob(job) {
   if (!job.relayId) {
     throw new CoreError("relayId is required");
@@ -8061,6 +8078,9 @@ function validateJob(job) {
     validateDepositRecord(job);
   } else {
     validatePoolTransactionRecord(job);
+    if (job.kind === "adapter") {
+      validateAdapterRecord(job);
+    }
   }
 }
 function buildJobKey(relayId) {
@@ -8585,6 +8605,9 @@ function randomBigint(bytes2 = 32) {
 function randomHex(bytes2) {
   return `0x${randomBigint(bytes2).toString(16).padStart(bytes2 * 2, "0")}`;
 }
+function generateRelayId(prefix) {
+  return globalThis.crypto?.randomUUID?.() ?? `${prefix}-${randomHex(16).slice(2)}`;
+}
 
 // utils/format.ts
 function normalizeAddress(value) {
@@ -34653,7 +34676,11 @@ function createIndexerClient(baseUrl, deps) {
     root: record.root,
     txHash: record.tx_hash,
     insertedAt: record.inserted_at,
-    eventType: record.event_type ?? "unknown"
+    eventType: record.event_type ?? "unknown",
+    adapterNpk: record.adapter_npk,
+    adapterToken: record.adapter_token,
+    adapterAmount: record.adapter_amount,
+    adapterRandom: record.adapter_random
   });
   const normalizeNullifierRecord = (record) => ({
     nullifier: record.nullifier,
@@ -35024,9 +35051,6 @@ function buildDepositCalldata(depositor, processedNotes) {
     }))
   ]);
 }
-function generateRelayId(prefix) {
-  return globalThis.crypto?.randomUUID?.() ?? `${prefix}-${Date.now().toString(16)}`;
-}
 async function deposit(store, req) {
   if (!req.notes?.length) {
     throw new ValidationError("At least one note is required for deposit");
@@ -52677,7 +52701,7 @@ async function proveTransaction(input, options) {
 }
 
 // transactions/transact.ts
-var TRANSACT_ABI = "function transact(((uint256[2] pA, uint256[2][2] pB, uint256[2] pC) proof, uint256 merkleRoot, uint256[] nullifierHashes, uint256[] newCommitments, (uint64 chainId, address poolAddress) context, (uint256 npk, uint256 amount, address token) withdrawal, (uint256 ephemeralKey, uint256[3] data)[] ciphertexts)[] _transactions)";
+var TRANSACT_ABI = "function transact(((uint256[2] pA, uint256[2][2] pB, uint256[2] pC) proof, uint256 merkleRoot, uint256[] nullifierHashes, uint256[] newCommitments, (uint64 chainId, address poolAddress, uint256 adapterDataHash) context, (uint256 npk, uint256 amount, address token) withdrawal, (uint256 ephemeralKey, uint256[3] data)[] ciphertexts)[] _transactions)";
 var DEFAULT_PROOF_TIMEOUT_MS = 6e4;
 var transactInterface = new Interface([TRANSACT_ABI]);
 var DEFAULT_WITHDRAWAL = {
@@ -52685,11 +52709,33 @@ var DEFAULT_WITHDRAWAL = {
   amount: 0n,
   token: "0x0000000000000000000000000000000000000000"
 };
-function computeBoundParamsHash(chainId, poolAddress) {
+function computeBoundParamsHash(chainId, poolAddress, adapterDataHash = 0n) {
+  const coder = AbiCoder.defaultAbiCoder();
+  const encoded = coder.encode(
+    ["uint64", "uint160", "uint256"],
+    [BigInt(chainId), BigInt(poolAddress), adapterDataHash]
+  );
+  return parseHexToBigInt(keccak256(encoded)) % SNARK_SCALAR_FIELD;
+}
+function computeAdapterDataHash(params) {
   const coder = AbiCoder.defaultAbiCoder();
   const encoded = coder.encode(
-    ["uint64", "uint160"],
-    [BigInt(chainId), BigInt(poolAddress)]
+    [
+      "tuple(address to, bytes data, uint256 value)[]",
+      "tuple(uint256 npk, uint256 random, address token, uint256 minAmount)[]",
+      "address[]",
+      "uint256",
+      "uint256",
+      "uint256"
+    ],
+    [
+      params.calls,
+      params.reshields,
+      params.inputTokens,
+      params.nonce,
+      params.deadline,
+      BigInt(params.chainId)
+    ]
   );
   return parseHexToBigInt(keccak256(encoded)) % SNARK_SCALAR_FIELD;
 }
@@ -52744,7 +52790,12 @@ async function buildSingleTransactionProof(store, account, signer, chainId, pool
   const allCommitmentsOut = hasWithdrawal ? [...outputs.map((o) => o.value), withdrawalCommitment] : outputs.map((o) => o.value);
   const allNpkOut = hasWithdrawal ? [...tx.outputs.map((o) => poseidon([o.mpk, o.random])), withdrawal.npk] : tx.outputs.map((o) => poseidon([o.mpk, o.random]));
   const allValueOut = hasWithdrawal ? [...tx.outputs.map((o) => o.amount), withdrawal.amount] : tx.outputs.map((o) => o.amount);
-  const boundParams = computeBoundParamsHash(chainId, poolAddress);
+  const adapterDataHash = tx.adapterDataHash ?? 0n;
+  const boundParams = computeBoundParamsHash(
+    chainId,
+    poolAddress,
+    adapterDataHash
+  );
   const pubSignals = [
     parseHexToBigInt(merkleRoot),
     boundParams,
@@ -52851,7 +52902,7 @@ async function transact(store, req, opts) {
   );
   const results = await Promise.all(proofPromises);
   const calldata = transactInterface.encodeFunctionData("transact", [
-    results.map((r2) => ({
+    results.map((r2, i) => ({
       proof: { pA: r2.proof.pA, pB: r2.proof.pB, pC: r2.proof.pC },
       merkleRoot: parseHexToBigInt(r2.merkleRoot),
       nullifierHashes: r2.contexts.map((c) => c.nullifier),
@@ -52860,12 +52911,16 @@ async function transact(store, req, opts) {
         // Skip root + boundParams + nullifiers
         r2.withdrawal.amount > 0n ? r2.proof.pubSignals.length - 1 : void 0
       ),
-      context: { chainId: BigInt(req.chainId), poolAddress: req.poolAddress },
+      context: {
+        chainId: BigInt(req.chainId),
+        poolAddress: req.poolAddress,
+        adapterDataHash: req.transactions[i]?.adapterDataHash ?? 0n
+      },
       withdrawal: r2.withdrawal,
       ciphertexts: r2.ciphertexts
     }))
   ]);
-  const relayId = globalThis.crypto?.randomUUID?.() ?? `tx-${Date.now().toString(16)}`;
+  const relayId = generateRelayId("tx");
   const hasAnyWithdrawal = results.some((r2) => r2.withdrawal.amount > 0n);
   const historyKind = hasAnyWithdrawal ? "Withdraw" : "Send";
   const deltasByToken = /* @__PURE__ */ new Map();
@@ -52908,7 +52963,7 @@ async function transact(store, req, opts) {
   };
   const job = hasAnyWithdrawal ? { ...jobBase, kind: "withdraw" } : { ...jobBase, kind: "transfer" };
   let txHash = null;
-  if (broadcaster) {
+  if (!opts.skipBroadcast && broadcaster) {
     const submission = await broadcaster.submitRelay({
       clientTxId: relayId,
       chainId: req.chainId,
@@ -52952,11 +53007,13 @@ async function transact(store, req, opts) {
       throw new CoreError("broadcaster relay timed out");
     }
   }
-  await store.putJob({
-    ...job,
-    status: "broadcasting",
-    txHash
-  });
+  if (opts.persistJob !== false) {
+    await store.putJob({
+      ...job,
+      status: "broadcasting",
+      txHash
+    });
+  }
   const transactionResults = results.map((r2) => ({
     proof: r2.proof,
     witnesses: r2.witnesses,
@@ -52971,7 +53028,7 @@ async function transact(store, req, opts) {
 }
 async function syncTransact(store, relayId, opts) {
   const record = await store.getJob(relayId);
-  if (!record || record.kind !== "transfer" && record.kind !== "withdraw")
+  if (!record || record.kind !== "transfer" && record.kind !== "withdraw" && record.kind !== "adapter")
     throw new CoreError(`unknown pool transaction relay ${relayId}`);
   const job = record;
   const serviceConfig = createServiceConfig(opts.gatewayUrl);
@@ -53074,6 +53131,116 @@ async function syncTransact(store, relayId, opts) {
   };
 }
 
+// transactions/adapter.ts
+init_process();
+init_buffer();
+var ADAPTER_EXECUTE_ABI = [
+  "function execute(bytes _transactData, (address to, bytes data, uint256 value)[] _calls, (uint256 npk, uint256 random, address token, uint256 minAmount)[] _reshields, address[] _inputTokens, uint256 _nonce, uint256 _deadline)"
+];
+var adapterInterface = new Interface(ADAPTER_EXECUTE_ABI);
+var approveInterface = new Interface([
+  "function approve(address spender, uint256 amount)"
+]);
+var HEX_DATA_REGEX = /^0x[0-9a-fA-F]*$/;
+function ensureNonNegative(label, value) {
+  if (value < 0n) {
+    throw new AdapterError(`${label} must be non-negative`);
+  }
+  return value;
+}
+function ensureHexData(label, value) {
+  if (typeof value !== "string" || !HEX_DATA_REGEX.test(value) || value.length % 2 !== 0) {
+    throw new AdapterError(`${label} must be 0x-prefixed even-length hex data`);
+  }
+  return value;
+}
+function normalizeCall(call, index) {
+  const to = ensureAddress(`calls[${index}].to`, call.to);
+  const data = ensureHexData(`calls[${index}].data`, call.data);
+  const value = ensureNonNegative(`calls[${index}].value`, call.value);
+  return { to, data, value };
+}
+function normalizeReshield(reshield, index) {
+  const token = ensureAddress(`reshields[${index}].token`, reshield.token);
+  const npk = ensureNonNegative(`reshields[${index}].npk`, reshield.npk);
+  const random = ensureNonNegative(
+    `reshields[${index}].random`,
+    reshield.random
+  );
+  const minAmount = ensureNonNegative(
+    `reshields[${index}].minAmount`,
+    reshield.minAmount
+  );
+  return { npk, random, token, minAmount };
+}
+function buildCall(params) {
+  const to = ensureAddress("call.to", params.to);
+  if (typeof params.abi !== "string" || params.abi.trim().length === 0) {
+    throw new AdapterError("call.abi must be a non-empty ABI fragment string");
+  }
+  if (typeof params.functionName !== "string" || params.functionName.trim().length === 0) {
+    throw new AdapterError("call.functionName must be a non-empty string");
+  }
+  if (!Array.isArray(params.args)) {
+    throw new AdapterError("call.args must be an array");
+  }
+  const value = ensureNonNegative("call.value", params.value ?? 0n);
+  let iface;
+  try {
+    iface = new Interface([params.abi]);
+  } catch (err) {
+    throw new AdapterError(
+      `invalid ABI fragment for call: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  let data;
+  try {
+    data = iface.encodeFunctionData(params.functionName, params.args);
+  } catch (err) {
+    throw new AdapterError(
+      `failed to encode ${params.functionName}: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return { to, data, value };
+}
+function buildApproveCall(token, spender, amount) {
+  const normalizedToken = ensureAddress("token", token);
+  const normalizedSpender = ensureAddress("spender", spender);
+  const normalizedAmount = ensureNonNegative("amount", amount);
+  const data = approveInterface.encodeFunctionData("approve", [
+    normalizedSpender,
+    normalizedAmount
+  ]);
+  return {
+    to: normalizedToken,
+    data,
+    value: 0n
+  };
+}
+function encodeAdapterExecute(params) {
+  const transactCalldata = ensureHexData(
+    "transactCalldata",
+    params.transactCalldata
+  );
+  const calls = params.calls.map((call, i) => normalizeCall(call, i));
+  const reshields = params.reshields.map(
+    (reshield, i) => normalizeReshield(reshield, i)
+  );
+  const inputTokens = params.inputTokens.map(
+    (token, i) => ensureAddress(`inputTokens[${i}]`, token)
+  );
+  const nonce = ensureNonNegative("nonce", params.nonce);
+  const deadline = ensureNonNegative("deadline", params.deadline);
+  return adapterInterface.encodeFunctionData("execute", [
+    transactCalldata,
+    calls,
+    reshields,
+    inputTokens,
+    nonce,
+    deadline
+  ]);
+}
+
 // transactions/transaction-planner.ts
 init_process();
 init_buffer();
@@ -53515,12 +53682,20 @@ function createJobReconciler(deps) {
           latest.status
         );
       }
-      return null;
+      if (latest.kind === "deposit") {
+        return depositClient.syncPendingDeposit(latest.relayId);
+      }
+      return transactService.syncPendingTransact(latest.relayId);
     }
     if (latest.status !== "succeeded" && isTimedOut(latest)) {
       await markDead(latest, "job timed out");
       const current = await stateStore.getJob(latest.relayId);
-      if (current?.status === "succeeded") return null;
+      if (current?.status === "succeeded") {
+        if (current.kind === "deposit") {
+          return depositClient.syncPendingDeposit(current.relayId);
+        }
+        return transactService.syncPendingTransact(current.relayId);
+      }
       throw new ReconcileError("job timed out", "dead");
     }
     if (latest.kind === "deposit") {
@@ -53646,7 +53821,43 @@ function createNoteSyncService(stateStore, options = {}) {
     };
     return spentAt === void 0 ? base : { ...base, spentAt };
   }
+  function tryReconstructAdapterNote(chainId, record, account) {
+    if (!record.adapterNpk || !record.adapterToken || !record.adapterAmount || !record.adapterRandom) {
+      return null;
+    }
+    const eventNpk = parseHexToBigInt(record.adapterNpk);
+    const eventRandom = parseHexToBigInt(record.adapterRandom);
+    const eventAmount = parseHexToBigInt(record.adapterAmount);
+    const eventToken = record.adapterToken.toLowerCase();
+    const derivedNpk = poseidon([account.masterPublicKey, eventRandom]);
+    if (derivedNpk !== eventNpk) {
+      return null;
+    }
+    const commitment = poseidon([eventNpk, BigInt(eventToken), eventAmount]);
+    if (commitment !== parseHexToBigInt(record.commitment)) {
+      return null;
+    }
+    const nullifier = poseidon([account.nullifyingKey, BigInt(record.index)]);
+    const nullifierHex = formatUint256(nullifier);
+    return createNoteRecord({
+      chainId,
+      index: record.index,
+      commitment: record.commitment,
+      token: eventToken,
+      amount: eventAmount,
+      npk: eventNpk,
+      mpk: account.masterPublicKey,
+      random: eventRandom,
+      nullifier: nullifierHex,
+      createdTxHash: record.txHash,
+      createdEventType: record.eventType,
+      createdAt: record.insertedAt != null ? record.insertedAt * 1e3 : void 0
+    });
+  }
   function tryDecryptNoteRecord(chainId, record, account) {
+    if (record.eventType === "adapter_deposit") {
+      return tryReconstructAdapterNote(chainId, record, account);
+    }
     const ciphertext = buildCiphertext(record.ephemeralKey, record.ciphertext);
     if (ciphertext.ephemeralKey === 0n) {
       return null;
@@ -53721,6 +53932,10 @@ function createNoteSyncService(stateStore, options = {}) {
             commitment: record.commitment,
             txHash: record.txHash,
             eventType: record.eventType,
+            adapterNpk: record.adapterNpk,
+            adapterToken: record.adapterToken,
+            adapterAmount: record.adapterAmount,
+            adapterRandom: record.adapterRandom,
             insertedAt: record.insertedAt
           },
           ciphertext: {
@@ -53877,12 +54092,81 @@ function createNoteSyncService(stateStore, options = {}) {
     const noteSet = new Set(allNotes.map((n2) => n2.index));
     const ctMap = new Map(allCiphertexts.map((c) => [c.index, c.payload]));
     const leafMap = new Map(allLeaves.map((l) => [l.index, l]));
+    const adapterRecords = /* @__PURE__ */ new Map();
+    const missingAdapterIndices = [];
+    for (let index = fromIndex; index < leafCount; index++) {
+      const leaf = leafMap.get(index);
+      if (!leaf || leaf.eventType !== "adapter_deposit") continue;
+      if (leaf.adapterNpk && leaf.adapterToken && leaf.adapterAmount && leaf.adapterRandom) {
+        adapterRecords.set(index, {
+          index,
+          commitment: leaf.commitment,
+          txHash: leaf.txHash,
+          insertedAt: leaf.insertedAt,
+          eventType: leaf.eventType ?? "adapter_deposit",
+          adapterNpk: leaf.adapterNpk,
+          adapterToken: leaf.adapterToken,
+          adapterAmount: leaf.adapterAmount,
+          adapterRandom: leaf.adapterRandom
+        });
+      } else {
+        missingAdapterIndices.push(index);
+      }
+    }
+    if (missingAdapterIndices.length > 0) {
+      const missingSet = new Set(missingAdapterIndices);
+      const minIndex = missingAdapterIndices[0];
+      const maxIndex = missingAdapterIndices[missingAdapterIndices.length - 1];
+      let cursor = minIndex;
+      while (cursor <= maxIndex && missingSet.size > 0) {
+        const batch = await indexerClient.fetchCommitmentBatch({
+          chainId,
+          start: cursor,
+          limit
+        });
+        if (batch.commitments.length === 0) break;
+        for (const record of batch.commitments) {
+          if (!missingSet.has(record.index)) continue;
+          adapterRecords.set(record.index, record);
+          missingSet.delete(record.index);
+        }
+        cursor = batch.commitments[batch.commitments.length - 1].index + 1;
+      }
+    }
     for (let index = fromIndex; index < leafCount; index++) {
       if (noteSet.has(index)) continue;
       const ciphertextBytes = ctMap.get(index);
-      if (!ciphertextBytes) continue;
       const leaf = leafMap.get(index);
       if (!leaf) continue;
+      if (leaf.eventType === "adapter_deposit") {
+        const record = adapterRecords.get(index);
+        if (record) {
+          const adapterNote = tryReconstructAdapterNote(
+            chainId,
+            record,
+            account
+          );
+          if (adapterNote) {
+            const baseParams = {
+              chainId,
+              index,
+              commitment: record.commitment,
+              token: adapterNote.token,
+              amount: BigInt(adapterNote.value),
+              npk: parseHexToBigInt(adapterNote.npk),
+              mpk: account.masterPublicKey,
+              random: parseHexToBigInt(adapterNote.random),
+              nullifier: adapterNote.nullifier,
+              createdTxHash: record.txHash || leaf.txHash,
+              createdEventType: record.eventType || leaf.eventType,
+              createdAt: record.insertedAt != null ? record.insertedAt * 1e3 : leaf.insertedAt != null ? leaf.insertedAt * 1e3 : void 0
+            };
+            pendingNotes.push({ note: adapterNote, baseParams });
+          }
+        }
+        continue;
+      }
+      if (!ciphertextBytes) continue;
       const ciphertext = decodeCiphertext(ciphertextBytes);
       if (ciphertext.ephemeralKey === 0n) continue;
       let note;
@@ -54073,6 +54357,10 @@ function createNoteSyncService(stateStore, options = {}) {
   };
 }
 
+// wallet/unlink-wallet.ts
+init_process();
+init_buffer();
+
 // wallet/sdk.ts
 init_process();
 init_buffer();
@@ -54343,6 +54631,231 @@ function createSeedService(deps) {
   };
 }
 
+// wallet/adapter.ts
+init_process();
+init_buffer();
+var DEFAULT_DEADLINE_WINDOW_SECONDS = 600n;
+var HEX_DATA_REGEX2 = /^0x[0-9a-fA-F]*$/;
+function ensureHexData2(label, value) {
+  if (typeof value !== "string" || !HEX_DATA_REGEX2.test(value) || value.length % 2 !== 0) {
+    throw new AdapterError(`${label} must be 0x-prefixed even-length hex data`);
+  }
+  return value;
+}
+function normalizeCall2(call, index) {
+  const to = ensureAddress(`calls[${index}].to`, call.to);
+  const data = ensureHexData2(`calls[${index}].data`, call.data);
+  if (call.value < 0n) {
+    throw new AdapterError(`calls[${index}].value must be non-negative`);
+  }
+  return {
+    to,
+    data,
+    value: call.value
+  };
+}
+function normalizeInputSpec(input, index) {
+  const token = ensureAddress(`inputs[${index}].token`, input.token);
+  if (input.amount <= 0n) {
+    throw new AdapterError(`inputs[${index}].amount must be greater than zero`);
+  }
+  return {
+    token,
+    amount: input.amount
+  };
+}
+function normalizeReshieldSpec(reshield, index) {
+  const token = ensureAddress(`reshields[${index}].token`, reshield.token);
+  if (reshield.minAmount < 0n) {
+    throw new AdapterError(
+      `reshields[${index}].minAmount must be non-negative`
+    );
+  }
+  return {
+    token,
+    minAmount: reshield.minAmount
+  };
+}
+function randomFieldElement(randomBigintFn) {
+  const value = randomBigintFn() % SNARK_SCALAR_FIELD;
+  return value < 0n ? value + SNARK_SCALAR_FIELD : value;
+}
+function createAdapterService(deps) {
+  const planWithdrawalsImpl = deps.planWithdrawalsFn ?? planWithdrawals;
+  const transactImpl = deps.transactFn ?? transact;
+  const randomBigintImpl = deps.randomBigintFn ?? randomBigint;
+  const nowImpl = deps.nowFn ?? Date.now;
+  return {
+    async execute(params, opts, overrides) {
+      ensureChainId(params.chainId);
+      const poolAddress = ensureAddress("poolAddress", params.poolAddress);
+      const adapterAddress = ensureAddress(
+        "adapterAddress",
+        params.adapterAddress
+      );
+      if (!params.inputs.length) {
+        throw new AdapterError("at least one input token is required");
+      }
+      if (!params.calls.length) {
+        throw new AdapterError("at least one adapter call is required");
+      }
+      if (!params.reshields.length) {
+        throw new AdapterError("at least one reshield output is required");
+      }
+      const inputs = params.inputs.map(
+        (input, i) => normalizeInputSpec(input, i)
+      );
+      const seenTokens = /* @__PURE__ */ new Set();
+      for (const input of inputs) {
+        const lower = input.token.toLowerCase();
+        if (seenTokens.has(lower)) {
+          throw new AdapterError(
+            `duplicate input token ${input.token}; combine amounts per token instead`
+          );
+        }
+        seenTokens.add(lower);
+      }
+      const calls = params.calls.map((call, i) => normalizeCall2(call, i));
+      const reshieldSpecs = params.reshields.map(
+        (reshield, i) => normalizeReshieldSpec(reshield, i)
+      );
+      const account = overrides?.account ?? await deps.requireActiveAccount();
+      const signer = overrides?.signer ?? deps.requireSigner(account);
+      const nowSeconds = BigInt(Math.floor(nowImpl() / 1e3));
+      const deadline = params.deadline ?? nowSeconds + DEFAULT_DEADLINE_WINDOW_SECONDS;
+      if (deadline <= nowSeconds) {
+        throw new AdapterError("deadline must be in the future");
+      }
+      const executionCalls = calls;
+      const reshields = reshieldSpecs.map(
+        (reshield) => {
+          const random = randomFieldElement(randomBigintImpl);
+          const npk = poseidon([account.masterPublicKey, random]);
+          return {
+            npk,
+            random,
+            token: reshield.token,
+            minAmount: reshield.minAmount
+          };
+        }
+      );
+      const inputTokens = inputs.map((input) => input.token);
+      const nonce = randomFieldElement(randomBigintImpl);
+      const adapterDataHash = computeAdapterDataHash({
+        calls: executionCalls,
+        reshields,
+        inputTokens,
+        nonce,
+        deadline,
+        chainId: params.chainId
+      });
+      const notes = await deps.stateStore.listNotes({
+        chainId: params.chainId,
+        mpk: formatUint256(account.masterPublicKey),
+        includeSpent: false
+      });
+      const withdrawalPlans = planWithdrawalsImpl(
+        notes,
+        inputs.map((input) => ({
+          token: input.token,
+          amount: input.amount,
+          recipient: adapterAddress
+        })),
+        account.masterPublicKey,
+        account.viewingKeyPair.pubkey
+      );
+      const transactResult = await transactImpl(
+        deps.stateStore,
+        {
+          account,
+          signer,
+          chainId: params.chainId,
+          poolAddress,
+          transactions: withdrawalPlans.map((plan) => ({
+            token: plan.token,
+            inputs: plan.inputs.map((note) => ({ index: note.index })),
+            outputs: plan.outputNotes,
+            withdrawal: plan.withdrawal,
+            adapterDataHash
+          }))
+        },
+        {
+          ...deps.txOpts,
+          skipBroadcast: true,
+          persistJob: false
+        }
+      );
+      const adapterCalldata = encodeAdapterExecute({
+        transactCalldata: transactResult.calldata,
+        calls: executionCalls,
+        reshields,
+        inputTokens,
+        nonce,
+        deadline
+      });
+      if (opts?.skipBroadcast) {
+        return {
+          relayId: transactResult.relayId,
+          adapterCalldata,
+          transactCalldata: transactResult.calldata,
+          transactResult,
+          reshields
+        };
+      }
+      const relayId = generateRelayId("adapter");
+      const submission = await deps.broadcasterClient.submitRelay({
+        clientTxId: relayId,
+        chainId: params.chainId,
+        payload: {
+          kind: "call_data",
+          to: adapterAddress,
+          data: adapterCalldata
+        }
+      });
+      if (!submission.accepted) {
+        throw new AdapterError(submission.message ?? "broadcaster rejected");
+      }
+      await deps.stateStore.putJob({
+        relayId,
+        kind: "adapter",
+        chainId: params.chainId,
+        mpk: formatUint256(account.masterPublicKey),
+        status: "broadcasting",
+        txHash: null,
+        createdAt: nowImpl(),
+        timeoutMs: DEFAULT_JOB_TIMEOUT_MS,
+        poolAddress,
+        calldata: transactResult.calldata,
+        transactions: withdrawalPlans.map((plan, i) => ({
+          token: plan.token,
+          nullifiers: transactResult.transactions[i]?.nullifiers ?? [],
+          predictedCommitments: (transactResult.transactions[i]?.predictedCommitments ?? []).map((hex2) => ({ hex: hex2 })),
+          withdrawal: {
+            amount: plan.withdrawal.amount.toString(),
+            recipient: adapterAddress
+          }
+        })),
+        adapterAddress,
+        adapterCalldata,
+        historyPreview: {
+          kind: "Withdraw",
+          amounts: inputs.map((input) => ({
+            token: input.token,
+            delta: (-input.amount).toString()
+          }))
+        }
+      });
+      return {
+        relayId,
+        adapterCalldata,
+        transactCalldata: transactResult.calldata,
+        transactResult,
+        reshields
+      };
+    }
+  };
+}
+
 // wallet/burner/service.ts
 init_process();
 init_buffer();
@@ -54692,7 +55205,26 @@ function createWalletSDK(deps, options) {
     }
     return account;
   }
-  if (configuredChainId) {
+  function requireSigner(acct) {
+    if (!("spendingKeyPair" in acct)) {
+      throw new Error(
+        "No signer: account has no spending key and no SignerOverride was provided"
+      );
+    }
+    const { spendingKeyPair } = acct;
+    return createSingleKeySigner(
+      spendingKeyPair.privateKey,
+      spendingKeyPair.pubkey
+    );
+  }
+  const adapterService = createAdapterService({
+    stateStore,
+    txOpts,
+    broadcasterClient,
+    requireActiveAccount,
+    requireSigner
+  });
+  if (configuredChainId && options.autoSync !== false) {
     scheduler.start();
   }
   let burnerService;
@@ -54792,10 +55324,13 @@ function createWalletSDK(deps, options) {
         return getBurnerService().sweepToPool(index, params);
       }
     },
+    adapter: {
+      execute: async (params, opts, overrides) => adapterService.execute(params, opts, overrides)
+    },
     balances: {
-      async list(chainId) {
+      async list(chainId, overrides) {
         ensureChainId(chainId);
-        const account = await requireActiveAccount();
+        const account = overrides?.account ?? await requireActiveAccount();
         const notes = await stateStore.listNotes({
           chainId,
           mpk: formatUint256(account.masterPublicKey),
@@ -54803,15 +55338,15 @@ function createWalletSDK(deps, options) {
         });
         return computeBalances(notes);
       },
-      async get(chainId, token) {
-        const balances = await this.list(chainId);
+      async get(chainId, token, overrides) {
+        const balances = await this.list(chainId, overrides);
         return balances[token.toLowerCase()] ?? 0n;
       }
     },
     deposit: {
       async request(params) {
         ensureChainId(params.chainId);
-        const account = await requireActiveAccount();
+        const account = params.account ?? await requireActiveAccount();
         const notes = params.deposits.map((d2) => {
           const randomBytes5 = rng(32);
           const random = BigInt(
@@ -54834,11 +55369,9 @@ function createWalletSDK(deps, options) {
         });
       },
       async reconcile(relayId) {
-        const res = await reconciler.reconcileRelay(relayId);
-        if (!res) {
-          throw new ReconcileError("job already succeeded", "succeeded");
-        }
-        const result = res;
+        const result = await reconciler.reconcileRelay(
+          relayId
+        );
         const account = await requireActiveAccount();
         await historyService.rebuildHistory({
           chainId: result.chainId,
@@ -54848,9 +55381,9 @@ function createWalletSDK(deps, options) {
       }
     },
     history: {
-      async list(chainId, options2) {
+      async list(chainId, options2, overrides) {
         ensureChainId(chainId);
-        const account = await requireActiveAccount();
+        const account = overrides?.account ?? await requireActiveAccount();
         return historyService.getHistory({
           chainId,
           mpk: formatUint256(account.masterPublicKey),
@@ -54875,9 +55408,9 @@ function createWalletSDK(deps, options) {
         });
         await historyService.rebuildHistory({ chainId: note.chainId, mpk });
       },
-      async list(chainId) {
+      async list(chainId, overrides) {
         ensureChainId(chainId);
-        const account = await requireActiveAccount();
+        const account = overrides?.account ?? await requireActiveAccount();
         return stateStore.listNotes({
           chainId,
           mpk: formatUint256(account.masterPublicKey),
@@ -54886,30 +55419,25 @@ function createWalletSDK(deps, options) {
       }
     },
     transact: {
-      async transact(params) {
-        const account = await requireActiveAccount();
-        const signer = createSingleKeySigner(
-          account.spendingKeyPair.privateKey,
-          account.spendingKeyPair.pubkey
-        );
+      async transact(params, opts, overrides) {
+        const acct = overrides?.account ?? await requireActiveAccount();
+        const signer = overrides?.signer ?? requireSigner(acct);
         return transact(
           stateStore,
           {
-            account,
+            account: acct,
             signer,
             chainId: params.chainId,
             poolAddress: params.poolAddress,
             transactions: params.transactions
           },
-          txOpts
+          { ...txOpts, ...opts }
         );
       },
       reconcile: async (relayId) => {
-        const res = await reconciler.reconcileRelay(relayId);
-        if (!res) {
-          throw new ReconcileError("job already succeeded", "succeeded");
-        }
-        const result = res;
+        const result = await reconciler.reconcileRelay(
+          relayId
+        );
         const account = await requireActiveAccount();
         await historyService.rebuildHistory({
           chainId: result.chainId,
@@ -54919,12 +55447,12 @@ function createWalletSDK(deps, options) {
       }
     },
     transfer: {
-      async plan(params) {
+      async plan(params, account) {
         ensureChainId(params.chainId);
-        const account = await requireActiveAccount();
+        const acct = account ?? await requireActiveAccount();
         const notes = await stateStore.listNotes({
           chainId: params.chainId,
-          mpk: formatUint256(account.masterPublicKey),
+          mpk: formatUint256(acct.masterPublicKey),
           includeSpent: false
         });
         return planTransfers(
@@ -54938,12 +55466,13 @@ function createWalletSDK(deps, options) {
               recipientViewingPubKey: parsed.viewingPublicKey
             };
           }),
-          account.masterPublicKey,
-          account.viewingKeyPair.pubkey
+          acct.masterPublicKey,
+          acct.viewingKeyPair.pubkey
         );
       },
-      async execute(plans, params) {
-        const account = await requireActiveAccount();
+      async execute(plans, params, overrides) {
+        const acct = overrides?.account ?? await requireActiveAccount();
+        const signer = overrides?.signer ?? requireSigner(acct);
         const transactions = plans.map((plan) => ({
           token: plan.token,
           inputs: plan.inputs.map((note) => ({
@@ -54951,14 +55480,10 @@ function createWalletSDK(deps, options) {
           })),
           outputs: plan.outputNotes
         }));
-        const signer = createSingleKeySigner(
-          account.spendingKeyPair.privateKey,
-          account.spendingKeyPair.pubkey
-        );
         const transactResult = await transact(
           stateStore,
           {
-            account,
+            account: acct,
             signer,
             chainId: params.chainId,
             poolAddress: params.poolAddress,
@@ -54972,18 +55497,18 @@ function createWalletSDK(deps, options) {
           transactResult
         };
       },
-      async send(params) {
-        const plans = await this.plan(params);
-        return this.execute(plans, params);
+      async send(params, overrides) {
+        const plans = await this.plan(params, overrides?.account);
+        return this.execute(plans, params, overrides);
       }
     },
     withdraw: {
-      async plan(params) {
+      async plan(params, account) {
         ensureChainId(params.chainId);
-        const account = await requireActiveAccount();
+        const acct = account ?? await requireActiveAccount();
         const notes = await stateStore.listNotes({
           chainId: params.chainId,
-          mpk: formatUint256(account.masterPublicKey),
+          mpk: formatUint256(acct.masterPublicKey),
           includeSpent: false
         });
         return planWithdrawals(
@@ -54993,12 +55518,13 @@ function createWalletSDK(deps, options) {
             amount: w.amount,
             recipient: w.recipient
           })),
-          account.masterPublicKey,
-          account.viewingKeyPair.pubkey
+          acct.masterPublicKey,
+          acct.viewingKeyPair.pubkey
         );
       },
-      async execute(plans, params) {
-        const account = await requireActiveAccount();
+      async execute(plans, params, overrides) {
+        const acct = overrides?.account ?? await requireActiveAccount();
+        const signer = overrides?.signer ?? requireSigner(acct);
         const transactions = plans.map((plan) => ({
           token: plan.token,
           inputs: plan.inputs.map((note) => ({
@@ -55007,14 +55533,10 @@ function createWalletSDK(deps, options) {
           outputs: plan.outputNotes,
           withdrawal: plan.withdrawal
         }));
-        const signer = createSingleKeySigner(
-          account.spendingKeyPair.privateKey,
-          account.spendingKeyPair.pubkey
-        );
         const transactResult = await transact(
           stateStore,
           {
-            account,
+            account: acct,
             signer,
             chainId: params.chainId,
             poolAddress: params.poolAddress,
@@ -55028,9 +55550,9 @@ function createWalletSDK(deps, options) {
           transactResult
         };
       },
-      async send(params) {
-        const plans = await this.plan(params);
-        return this.execute(plans, params);
+      async send(params, overrides) {
+        const plans = await this.plan(params, overrides?.account);
+        return this.execute(plans, params, overrides);
       }
     },
     events: {
@@ -55132,10 +55654,353 @@ async function createBrowserWalletSDK(options) {
     }
   };
 }
+
+// wallet/unlink-wallet.ts
+var UnlinkWallet = class _UnlinkWallet {
+  /** @internal */
+  sdk;
+  /** Chain ID this wallet operates on. */
+  chainId;
+  /** Pool contract address this wallet transacts with. */
+  poolAddress;
+  constructor(sdk, chainId, poolAddress) {
+    this.sdk = sdk;
+    this.chainId = chainId;
+    this.poolAddress = poolAddress;
+  }
+  /**
+   * Create a new UnlinkWallet instance.
+   *
+   * Handles all initialization internally:
+   * - Resolves environment config (if using `environment` instead of explicit URLs)
+   * - Auto-detects storage (IndexedDB in browser) and rng (crypto.getRandomValues)
+   * - Runs schema migration via `initCore()`
+   * - Creates the internal SDK
+   */
+  static async create(config2) {
+    let gatewayUrl;
+    let poolAddress;
+    let proverConfig = config2.prover;
+    if ("gatewayUrl" in config2) {
+      gatewayUrl = config2.gatewayUrl;
+      poolAddress = config2.poolAddress;
+      if (typeof window !== "undefined" && !config2.prover?.artifactSource?.version) {
+        throw new InitializationError(
+          "prover.artifactSource.version is required in browser when using explicit gatewayUrl mode. Use environment mode or provide a pinned artifact version."
+        );
+      }
+    } else {
+      const envConfig = await fetchEnvironmentConfig(config2.environment);
+      gatewayUrl = envConfig.gatewayUrl;
+      poolAddress = config2.poolAddress ?? envConfig.poolAddress;
+      proverConfig = {
+        artifactSource: {
+          baseUrl: config2.prover?.artifactSource?.baseUrl ?? envConfig.artifactBaseUrl,
+          version: config2.prover?.artifactSource?.version ?? envConfig.artifactVersion,
+          preferLocalFiles: config2.prover?.artifactSource?.preferLocalFiles
+        }
+      };
+    }
+    const storage = config2.storage ?? detectStorage();
+    const rng = config2.rng ?? defaultRng;
+    const fetchImpl = config2.fetch ?? globalThis.fetch;
+    const core = await initCore({ storage, rng });
+    const sdk = createWalletSDK(
+      { core, fetch: fetchImpl },
+      {
+        chainId: config2.chainId,
+        gatewayUrl,
+        chainRpcUrl: config2.chainRpcUrl,
+        prover: proverConfig,
+        autoSync: config2.autoSync
+      }
+    );
+    return new _UnlinkWallet(sdk, config2.chainId, poolAddress);
+  }
+  // ===== Seed Lifecycle =====
+  /** Seed management (create, import, export, delete mnemonic). */
+  get seed() {
+    return this.sdk.seed;
+  }
+  // ===== Account Management =====
+  /** Account management (create, list, switch accounts). */
+  get accounts() {
+    return this.sdk.accounts;
+  }
+  // ===== Core Operations =====
+  /**
+   * Request a deposit (1 or more tokens).
+   * Returns calldata the depositor must submit on-chain via their EOA.
+   */
+  async deposit(params) {
+    return this.sdk.deposit.request({
+      chainId: this.chainId,
+      poolAddress: this.poolAddress,
+      depositor: params.depositor,
+      deposits: params.deposits,
+      account: params.account
+    });
+  }
+  /** Wait for a deposit to be confirmed on-chain. */
+  async confirmDeposit(relayId) {
+    return this.sdk.deposit.reconcile(relayId);
+  }
+  /**
+   * Execute a private transfer (1 or more recipients).
+   * Handles note selection, circuit selection, and proof generation automatically.
+   */
+  async transfer(params, overrides) {
+    return this.sdk.transfer.send(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        transfers: params.transfers
+      },
+      overrides
+    );
+  }
+  /**
+   * Get a transfer plan without executing (for preview/confirmation UIs).
+   */
+  async planTransfer(params, account) {
+    return this.sdk.transfer.plan(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        transfers: params.transfers
+      },
+      account
+    );
+  }
+  /** Execute a pre-built transfer plan. */
+  async executeTransfer(plans, overrides) {
+    return this.sdk.transfer.execute(
+      plans,
+      { chainId: this.chainId, poolAddress: this.poolAddress },
+      overrides
+    );
+  }
+  /**
+   * Execute a withdrawal (1 or more recipients).
+   * Handles note selection, circuit selection, and proof generation automatically.
+   */
+  async withdraw(params, overrides) {
+    return this.sdk.withdraw.send(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        withdrawals: params.withdrawals
+      },
+      overrides
+    );
+  }
+  /**
+   * Get a withdrawal plan without executing (for preview/confirmation UIs).
+   */
+  async planWithdraw(params, account) {
+    return this.sdk.withdraw.plan(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        withdrawals: params.withdrawals
+      },
+      account
+    );
+  }
+  /** Execute a pre-built withdrawal plan. */
+  async executeWithdraw(plans, overrides) {
+    return this.sdk.withdraw.execute(
+      plans,
+      { chainId: this.chainId, poolAddress: this.poolAddress },
+      overrides
+    );
+  }
+  /** Wait for a transfer or withdrawal to be confirmed on-chain. */
+  async confirmTransaction(relayId) {
+    return this.sdk.transact.reconcile(relayId);
+  }
+  // ===== Queries =====
+  /**
+   * Get balance for a specific token (defaults to all tokens if no token specified).
+   * @param token Token address. If omitted, returns balance for all tokens via getBalances().
+   */
+  async getBalance(token, overrides) {
+    return this.sdk.balances.get(this.chainId, token, overrides);
+  }
+  /** Get balances for all tokens. */
+  async getBalances(overrides) {
+    return this.sdk.balances.list(this.chainId, overrides);
+  }
+  /** Get transaction history. */
+  async getHistory(options, overrides) {
+    return this.sdk.history.list(this.chainId, options, overrides);
+  }
+  /** Get UTXO notes for the active account (or override account). */
+  async getNotes(overrides) {
+    return this.sdk.notes.list(this.chainId, overrides);
+  }
+  // ===== Sync =====
+  /**
+   * Sync notes from the blockchain.
+   * Automatically resolves the active account (no need to pass it).
+   */
+  async sync(options, overrides) {
+    const account = overrides?.account ?? await this.requireActiveAccount();
+    return this.sdk.sync.syncChain(this.chainId, account, options);
+  }
+  /** Start auto-sync at the given interval (default: 5000ms). */
+  startAutoSync(intervalMs) {
+    void this.sdk.sync.startAutoSync(intervalMs);
+  }
+  /** Stop auto-sync. */
+  stopAutoSync() {
+    this.sdk.sync.stopAutoSync();
+  }
+  // ===== Transaction Status =====
+  /** Get the current status of a transaction. */
+  async getTxStatus(txId) {
+    return this.sdk.tx.getStatus(txId);
+  }
+  /** Start tracking a transaction for status-changed events. */
+  trackTx(txId) {
+    this.sdk.tx.track(txId);
+  }
+  /** Stop tracking a transaction. */
+  untrackTx(txId) {
+    this.sdk.tx.untrack(txId);
+  }
+  // ===== Events =====
+  /**
+   * Subscribe to wallet events (notes-updated, sync-error, tx-status-changed, etc.).
+   * @returns Unsubscribe function.
+   */
+  on(listener) {
+    return this.sdk.events.on(listener);
+  }
+  // ===== Burner =====
+  /**
+   * Burner account operations (BIP-44 derived EOAs for DeFi interactions).
+   * chainId/poolAddress are injected automatically for fund/sweepToPool.
+   */
+  burner = {
+    /** Derive burner address for a given index. */
+    addressOf: (index) => {
+      return this.sdk.burner.addressOf(index);
+    },
+    /** Send a transaction from burner at index. */
+    send: (index, tx) => {
+      return this.sdk.burner.send(index, tx);
+    },
+    /** Export the raw private key (0x-prefixed hex) for wallet import. */
+    exportKey: (index) => {
+      return this.sdk.burner.exportKey(index);
+    },
+    /** Withdraw from shielded pool to fund this burner. */
+    fund: (index, params) => {
+      return this.sdk.burner.fund(index, {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        token: params.token,
+        amount: params.amount
+      });
+    },
+    /** Approve + deposit tokens from burner back into shielded pool. */
+    sweepToPool: (index, params) => {
+      return this.sdk.burner.sweepToPool(index, {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        token: params.token,
+        amount: params.amount
+      });
+    },
+    /** Get ERC-20 token balance of any address. */
+    getTokenBalance: (address, token) => {
+      return this.sdk.burner.getTokenBalance(address, token);
+    },
+    /** Get native ETH balance of any address. */
+    getBalance: (address) => {
+      return this.sdk.burner.getBalance(address);
+    }
+  };
+  // ===== Adapter =====
+  /**
+   * Private DeFi adapter operations.
+   * chainId/poolAddress are injected automatically.
+   */
+  adapter = {
+    /**
+     * Execute an atomic unshield -> call(s) -> reshield flow through an adapter.
+     */
+    execute: (params, opts, overrides) => {
+      return this.sdk.adapter.execute(
+        {
+          chainId: this.chainId,
+          poolAddress: this.poolAddress,
+          adapterAddress: params.adapterAddress,
+          inputs: params.inputs,
+          calls: params.calls,
+          reshields: params.reshields,
+          deadline: params.deadline
+        },
+        opts,
+        overrides
+      );
+    }
+  };
+  // ===== Advanced =====
+  /**
+   * Advanced escape hatch for raw JoinSplit transaction building.
+   * Use this for custom transaction construction (e.g. swap adapters).
+   */
+  advanced = {
+    /** Build and submit raw JoinSplit transactions. */
+    transact: (params, opts) => {
+      return this.sdk.transact.transact(
+        {
+          chainId: this.chainId,
+          poolAddress: this.poolAddress,
+          transactions: params.transactions
+        },
+        opts
+      );
+    },
+    /** Wait for a raw transaction to be confirmed on-chain. */
+    reconcile: (relayId) => {
+      return this.sdk.transact.reconcile(relayId);
+    }
+  };
+  // ===== Private Helpers =====
+  async requireActiveAccount() {
+    const account = await this.sdk.accounts.getActive();
+    if (!account) {
+      throw new Error("No active account. Create an account first.");
+    }
+    return account;
+  }
+};
+function detectStorage() {
+  if (typeof globalThis.indexedDB !== "undefined" && typeof globalThis.window !== "undefined") {
+    return createIndexedDbStorage({ name: "unlink-wallet" });
+  }
+  throw new InitializationError(
+    "No storage backend detected. In Node.js, provide a storage option (e.g. createSqliteStorage or createMemoryStorage)."
+  );
+}
+var defaultRng = (n2) => {
+  if (!globalThis.crypto?.getRandomValues) {
+    throw new InitializationError(
+      "crypto.getRandomValues unavailable. Provide a custom rng in config."
+    );
+  }
+  return globalThis.crypto.getRandomValues(new Uint8Array(n2));
+};
 export {
+  ADAPTER_EXECUTE_ABI,
+  AdapterError,
   CORE_SCHEMA_VERSION,
   CoreError,
   DEFAULT_JOB_TIMEOUT_MS,
+  DEPOSIT_ABI,
   ETH_TOKEN,
   FieldSize,
   Hex,
@@ -55152,9 +56017,15 @@ export {
   ReconcileError,
   SNARK_SCALAR_FIELD,
   SchemaMismatchError,
+  UnlinkWallet,
   ValidationError,
   assertNonNegative,
+  buildApproveCall,
+  buildCall,
+  computeAdapterDataHash,
   computeBalances,
+  computeBoundParamsHash,
+  computeCommitment,
   computeMasterPublicKey,
   computeNullifyingKey,
   createBroadcasterClient,
@@ -55183,10 +56054,13 @@ export {
   deriveAccount,
   deriveAccountFromMnemonic,
   deriveAccountKeys,
+  deriveNpk,
   deriveSpendingKeyPair,
   derivePublicKey as deriveSpendingPublicKey,
   deriveViewingKeyPair,
+  encodeAdapterExecute,
   encodeAddress,
+  encryptNote,
   ensureAddress,
   ensureBigIntString,
   ensureChainId,