@unlink-xyz/react 0.1.0 → 0.1.3-canary.01ac52d

package/dist/index.js

@@ -5292,6 +5292,12 @@ var ReconcileError = class extends CoreError {
     this.status = status;
   }
 };
+var AdapterError = class extends CoreError {
+  constructor(message) {
+    super(message);
+    this.name = "AdapterError";
+  }
+};
 init_process();
 init_buffer();
 var RESERVED_PREFIXES = [
@@ -9036,9 +9042,9 @@ function genBech32(encoding) {
 }
 var bech32m = /* @__PURE__ */ genBech32("bech32m");
 var VERSION = 1;
-var LIMIT = 127;
+var LIMIT = 130;
 var ALL_CHAINS = "ffffffffffffffff";
-var PREFIX = "0zk";
+var PREFIX = "unlink";
 var SALT = new TextEncoder().encode("unlink");
 function xorWithSalt(hex2) {
   const bytes2 = Hex.toBytes(hex2);
@@ -9156,7 +9162,7 @@ function parseZkAddress(value) {
     };
   } catch (err) {
     throw new ValidationError(
-      `Invalid ZK address (expected 0zk1... format): ${err instanceof Error ? err.message : "unknown error"}`
+      `Invalid ZK address (expected unlink1... format): ${err instanceof Error ? err.message : "unknown error"}`
     );
   }
 }
@@ -9444,7 +9450,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}`);
@@ -9524,6 +9535,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");
@@ -9543,6 +9560,9 @@ function validateJob(job) {
     validateDepositRecord(job);
   } else {
     validatePoolTransactionRecord(job);
+    if (job.kind === "adapter") {
+      validateAdapterRecord(job);
+    }
   }
 }
 function buildJobKey(relayId) {
@@ -10047,6 +10067,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)}`;
+}
 function normalizeAddress(value) {
   return ensureAddress("address", value);
 }
@@ -35848,63 +35871,79 @@ var Runtime = {
   }
 };
 var CONFIG_URL = "https://config.unlink.xyz/networks.json";
-function parseRequiredString(env22, field, value) {
+function parseRequiredString(chain2, field, value) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new InitializationError(
-      `Invalid SDK config for ${env22}: ${field} must be a non-empty string`
+      `Invalid SDK config for ${chain2}: ${field} must be a non-empty string`
     );
   }
   return value.trim();
 }
-function parseOptionalString(env22, field, value) {
+function parseOptionalString(chain2, field, value) {
   if (value === void 0) return void 0;
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new InitializationError(
-      `Invalid SDK config for ${env22}: ${field} must be a non-empty string when provided`
+      `Invalid SDK config for ${chain2}: ${field} must be a non-empty string when provided`
     );
   }
   return value.trim();
 }
-function parseEnvironmentConfig(env22, value) {
+function parseRequiredChainId(chain2, value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new InitializationError(
+      `Invalid SDK config for ${chain2}: chainId must be a positive integer`
+    );
+  }
+  return value;
+}
+function parseChainConfig(chain2, value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new InitializationError(
-      `Invalid SDK config for ${env22}: expected object`
+      `Invalid SDK config for ${chain2}: expected object`
     );
   }
   const raw = value;
+  const chainId = parseRequiredChainId(chain2, raw.chainId);
   const gatewayUrl = parseRequiredString(
-    env22,
+    chain2,
     "gatewayUrl",
     raw.gatewayUrl
   ).replace(/\/+$/, "");
-  const poolAddress = parseRequiredString(env22, "poolAddress", raw.poolAddress);
+  const poolAddress = parseRequiredString(
+    chain2,
+    "poolAddress",
+    raw.poolAddress
+  );
   const artifactVersion = parseRequiredString(
-    env22,
+    chain2,
     "artifactVersion",
     raw.artifactVersion
   ).replace(/^\/+|\/+$/g, "");
   const artifactBaseUrl = parseOptionalString(
-    env22,
+    chain2,
     "artifactBaseUrl",
     raw.artifactBaseUrl
   )?.replace(/\/+$/, "");
   return {
+    chainId,
     gatewayUrl,
     poolAddress,
     artifactVersion,
     ...artifactBaseUrl !== void 0 ? { artifactBaseUrl } : { artifactBaseUrl: DEFAULT_ARTIFACT_BASE_URL }
   };
 }
-async function fetchEnvironmentConfig(env22) {
+async function fetchChainConfig(chain2) {
   const res = await fetch(CONFIG_URL);
   if (!res.ok) {
     throw new InitializationError(`Failed to fetch SDK config: ${res.status}`);
   }
   const config22 = await res.json();
-  if (!config22[env22]) {
-    throw new InitializationError(`Unknown environment: ${env22}`);
+  if (!config22[chain2]) {
+    throw new InitializationError(
+      `Unknown chain: "${chain2}". Supported chains: ${Object.keys(config22).join(", ")}`
+    );
   }
-  return parseEnvironmentConfig(env22, config22[env22]);
+  return parseChainConfig(chain2, config22[chain2]);
 }
 function createServiceConfig(gatewayUrl) {
   const baseUrl = gatewayUrl.replace(/\/+$/, "");
@@ -36037,9 +36076,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");
@@ -53692,6 +53728,28 @@ function computeBoundParamsHash(chainId, poolAddress, adapterDataHash = 0n) {
   );
   return parseHexToBigInt(keccak256(encoded)) % SNARK_SCALAR_FIELD;
 }
+function computeAdapterDataHash(params) {
+  const coder = AbiCoder.defaultAbiCoder();
+  const encoded = coder.encode(
+    [
+      "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;
+}
 async function buildSingleTransactionProof(store, account, signer, chainId, poolAddress, tx, trees, baseIndex, opts) {
   if (!tx.inputs?.length)
     throw new ValidationError("at least one input note is required");
@@ -53873,7 +53931,7 @@ async function transact(store, req, opts) {
       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();
@@ -53960,11 +54018,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,
@@ -53979,7 +54039,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);
@@ -54083,6 +54143,70 @@ async function syncTransact(store, relayId, opts) {
 }
 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 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
+  ]);
+}
+init_process();
+init_buffer();
 init_process();
 init_buffer();
 var MAX_CIRCUIT_INPUTS = Math.max(
@@ -55447,6 +55571,239 @@ function createSeedService(deps) {
 }
 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 seenReshieldTokens = /* @__PURE__ */ new Set();
+      for (const r2 of reshieldSpecs) {
+        const lower = r2.token.toLowerCase();
+        if (seenReshieldTokens.has(lower)) {
+          throw new AdapterError(
+            `duplicate reshield token ${r2.token}; each reshield must target a unique token`
+          );
+        }
+        seenReshieldTokens.add(lower);
+      }
+      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
+      };
+    }
+  };
+}
+init_process();
+init_buffer();
 var BIP44_ETH_PREFIX = "m/44'/60'/0'/0";
 var ERC20_BALANCE_OF = "function balanceOf(address) view returns (uint256)";
 function createBurnerService(deps) {
@@ -55803,7 +56160,14 @@ function createWalletSDK(deps, options) {
       spendingKeyPair.pubkey
     );
   }
-  if (configuredChainId) {
+  const adapterService = createAdapterService({
+    stateStore,
+    txOpts,
+    broadcasterClient,
+    requireActiveAccount,
+    requireSigner
+  });
+  if (configuredChainId && options.autoSync !== false) {
     scheduler.start();
   }
   let burnerService;
@@ -55903,10 +56267,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),
@@ -55914,15 +56281,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(
@@ -55957,9 +56324,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),
@@ -55984,9 +56351,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),
@@ -56195,34 +56562,37 @@ var UnlinkWallet = class _UnlinkWallet {
    * Create a new UnlinkWallet instance.
    *
    * Handles all initialization internally:
-   * - Resolves environment config (if using `environment` instead of explicit URLs)
+   * - Resolves chain config (if using `chain` 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(config22) {
+    let chainId;
     let gatewayUrl;
     let poolAddress;
     let proverConfig = config22.prover;
-    if ("gatewayUrl" in config22) {
+    if ("chain" in config22) {
+      const chainConfig = await fetchChainConfig(config22.chain);
+      chainId = chainConfig.chainId;
+      gatewayUrl = chainConfig.gatewayUrl;
+      poolAddress = config22.poolAddress ?? chainConfig.poolAddress;
+      proverConfig = {
+        artifactSource: {
+          baseUrl: config22.prover?.artifactSource?.baseUrl ?? chainConfig.artifactBaseUrl,
+          version: config22.prover?.artifactSource?.version ?? chainConfig.artifactVersion,
+          preferLocalFiles: config22.prover?.artifactSource?.preferLocalFiles
+        }
+      };
+    } else {
+      chainId = config22.chainId;
       gatewayUrl = config22.gatewayUrl;
       poolAddress = config22.poolAddress;
       if (typeof window !== "undefined" && !config22.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."
+          "prover.artifactSource.version is required in browser when using explicit gatewayUrl mode. Use chain mode or provide a pinned artifact version."
         );
       }
-    } else {
-      const envConfig = await fetchEnvironmentConfig(config22.environment);
-      gatewayUrl = envConfig.gatewayUrl;
-      poolAddress = config22.poolAddress ?? envConfig.poolAddress;
-      proverConfig = {
-        artifactSource: {
-          baseUrl: config22.prover?.artifactSource?.baseUrl ?? envConfig.artifactBaseUrl,
-          version: config22.prover?.artifactSource?.version ?? envConfig.artifactVersion,
-          preferLocalFiles: config22.prover?.artifactSource?.preferLocalFiles
-        }
-      };
     }
     const storage = config22.storage ?? detectStorage();
     const rng = config22.rng ?? defaultRng;
@@ -56231,13 +56601,14 @@ var UnlinkWallet = class _UnlinkWallet {
     const sdk = createWalletSDK(
       { core, fetch: fetchImpl },
       {
-        chainId: config22.chainId,
+        chainId,
         gatewayUrl,
         chainRpcUrl: config22.chainRpcUrl,
-        prover: proverConfig
+        prover: proverConfig,
+        autoSync: config22.autoSync
       }
     );
-    return new _UnlinkWallet(sdk, config22.chainId, poolAddress);
+    return new _UnlinkWallet(sdk, chainId, poolAddress);
   }
   // ===== Seed Lifecycle =====
   /** Seed management (create, import, export, delete mnemonic). */
@@ -56259,7 +56630,8 @@ var UnlinkWallet = class _UnlinkWallet {
       chainId: this.chainId,
       poolAddress: this.poolAddress,
       depositor: params.depositor,
-      deposits: params.deposits
+      deposits: params.deposits,
+      account: params.account
     });
   }
   /** Wait for a deposit to be confirmed on-chain. */
@@ -56270,57 +56642,71 @@ var UnlinkWallet = class _UnlinkWallet {
    * Execute a private transfer (1 or more recipients).
    * Handles note selection, circuit selection, and proof generation automatically.
    */
-  async transfer(params) {
-    return this.sdk.transfer.send({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      transfers: params.transfers
-    });
+  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) {
-    return this.sdk.transfer.plan({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      transfers: params.transfers
-    });
+  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) {
-    return this.sdk.transfer.execute(plans, {
-      chainId: this.chainId,
-      poolAddress: this.poolAddress
-    });
+  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) {
-    return this.sdk.withdraw.send({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      withdrawals: params.withdrawals
-    });
+  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) {
-    return this.sdk.withdraw.plan({
-      chainId: this.chainId,
-      poolAddress: this.poolAddress,
-      withdrawals: params.withdrawals
-    });
+  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) {
-    return this.sdk.withdraw.execute(plans, {
-      chainId: this.chainId,
-      poolAddress: this.poolAddress
-    });
+  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) {
@@ -56331,28 +56717,28 @@ var UnlinkWallet = class _UnlinkWallet {
    * 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) {
-    return this.sdk.balances.get(this.chainId, token);
+  async getBalance(token, overrides) {
+    return this.sdk.balances.get(this.chainId, token, overrides);
   }
   /** Get balances for all tokens. */
-  async getBalances() {
-    return this.sdk.balances.list(this.chainId);
+  async getBalances(overrides) {
+    return this.sdk.balances.list(this.chainId, overrides);
   }
   /** Get transaction history. */
-  async getHistory(options) {
-    return this.sdk.history.list(this.chainId, options);
+  async getHistory(options, overrides) {
+    return this.sdk.history.list(this.chainId, options, overrides);
   }
-  /** Get UTXO notes for the active account. */
-  async getNotes() {
-    return this.sdk.notes.list(this.chainId);
+  /** 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) {
-    const account = await this.requireActiveAccount();
+  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). */
@@ -56429,6 +56815,31 @@ var UnlinkWallet = class _UnlinkWallet {
       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.
@@ -56553,8 +56964,10 @@ var initialState = {
   accounts: [],
   activeAccount: null,
   activeAccountIndex: null,
+  chainId: null,
   notes: [],
   balances: {},
+  burners: [],
   pendingDeposits: [],
   pendingTransfers: [],
   pendingWithdrawals: [],
@@ -56572,14 +56985,15 @@ function convertNotes(noteRecords) {
 }
 function UnlinkProvider({
   children,
-  chainId,
   poolAddress,
   syncInterval = 5e3,
   autoSync = true,
-  gatewayUrl,
-  environment,
-  prover
+  prover,
+  ...configProps
 }) {
+  const chain2 = "chain" in configProps ? configProps.chain : void 0;
+  const chainId = "chainId" in configProps ? configProps.chainId : void 0;
+  const gatewayUrl = "gatewayUrl" in configProps ? configProps.gatewayUrl : void 0;
   const [state, setState] = useState(initialState);
   const walletRef = useRef(null);
   const proverKey = JSON.stringify(prover ?? null);
@@ -56591,8 +57005,8 @@ function UnlinkProvider({
       setState((prev2) => ({
         ...prev2,
         accounts,
-        activeAccount,
-        activeAccountIndex
+        activeAccount: activeAccount ?? prev2.activeAccount,
+        activeAccountIndex: activeAccountIndex ?? prev2.activeAccountIndex
       }));
     } catch (err) {
       console.error("[UnlinkProvider] refreshAccounts error", err);
@@ -56609,13 +57023,13 @@ function UnlinkProvider({
     }
   }, []);
   useEffect(() => {
-    if (!gatewayUrl && !environment) {
+    if (!chain2 && !gatewayUrl) {
       const configError = new ValidationError(
-        "Either gatewayUrl or environment is required"
+        "Either chain or gatewayUrl is required"
       );
       setState((prev2) => ({
         ...prev2,
-        status: "Error: Either gatewayUrl or environment is required",
+        status: "Error: Either chain or gatewayUrl is required",
         error: createUnlinkError(configError, "init")
       }));
       return;
@@ -56629,14 +57043,13 @@ function UnlinkProvider({
           status: "Initializing SDK..."
         }));
         const wallet = await UnlinkWallet.create(
-          gatewayUrl ? {
-            chainId,
-            gatewayUrl,
+          chain2 ? {
+            chain: chain2,
             poolAddress,
             ...prover ? { prover } : {}
           } : {
             chainId,
-            environment,
+            gatewayUrl,
             poolAddress,
             ...prover ? { prover } : {}
           }
@@ -56677,6 +57090,7 @@ function UnlinkProvider({
           accounts,
           activeAccount,
           activeAccountIndex,
+          chainId: wallet.chainId,
           notes,
           balances,
           ready: true,
@@ -56687,7 +57101,7 @@ function UnlinkProvider({
           wallet.startAutoSync(syncInterval);
         }
         unsubscribe = wallet.on((event) => {
-          if (event.type === "notes-updated" && event.chainId === chainId) {
+          if (event.type === "notes-updated" && event.chainId === wallet.chainId) {
             setState((prev2) => ({ ...prev2, syncError: null }));
             void refreshState(wallet);
           }
@@ -56721,13 +57135,13 @@ function UnlinkProvider({
       walletRef.current?.stopAutoSync();
     };
   }, [
+    chain2,
     chainId,
     autoSync,
     syncInterval,
     refreshState,
     refreshAccounts,
     gatewayUrl,
-    environment,
     poolAddress,
     proverKey
   ]);
@@ -56775,6 +57189,7 @@ function UnlinkProvider({
         accounts,
         activeAccount,
         activeAccountIndex,
+        burners: [],
         busy: false,
         status: accounts.length > 0 ? "Wallet imported" : "Wallet imported - create an account",
         syncError: null,
@@ -56809,6 +57224,7 @@ function UnlinkProvider({
         activeAccountIndex: null,
         notes: [],
         balances: {},
+        burners: [],
         busy: false,
         status: "Wallet cleared",
         syncError: null,
@@ -57093,6 +57509,36 @@ function UnlinkProvider({
     },
     []
   );
+  const executeAdapter = useCallback(
+    async (params) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Executing adapter..."
+      }));
+      try {
+        const result = await wallet.adapter.execute(params);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: "Adapter execution submitted",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "executeAdapter")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
   const planWithdraw = useCallback(
     async (params) => {
       const wallet = walletRef.current;
@@ -57134,6 +57580,149 @@ function UnlinkProvider({
       throw err;
     }
   }, []);
+  const createBurner = useCallback(async (index) => {
+    const wallet = walletRef.current;
+    if (!wallet) throw new Error("SDK not initialized");
+    setState((prev2) => ({
+      ...prev2,
+      busy: true,
+      status: `Creating burner ${index}...`
+    }));
+    try {
+      const burner = await wallet.burner.addressOf(index);
+      setState((prev2) => ({
+        ...prev2,
+        burners: [
+          ...prev2.burners.filter((existing) => existing.index !== burner.index),
+          burner
+        ],
+        busy: false,
+        status: `Burner ${index} ready`,
+        error: null
+      }));
+      return burner;
+    } catch (err) {
+      setState((prev2) => ({
+        ...prev2,
+        busy: false,
+        status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+        error: createUnlinkError(err, "createBurner")
+      }));
+      throw err;
+    }
+  }, []);
+  const removeBurner = useCallback((index) => {
+    setState((prev2) => ({
+      ...prev2,
+      burners: prev2.burners.filter((burner) => burner.index !== index)
+    }));
+  }, []);
+  const burnerSend = useCallback(
+    async (index, tx) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Sending burner transaction..."
+      }));
+      try {
+        const result = await wallet.burner.send(index, tx);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: "Burner transaction sent",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "burnerSend")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const burnerFund = useCallback(
+    async (index, params) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Funding burner..."
+      }));
+      try {
+        const result = await wallet.burner.fund(index, params);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: "Burner funded",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "burnerFund")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const burnerSweepToPool = useCallback(
+    async (index, params) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Sweeping burner to pool..."
+      }));
+      try {
+        const result = await wallet.burner.sweepToPool(index, params);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: "Burner sweep submitted",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "burnerSweepToPool")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const burnerGetTokenBalance = useCallback(
+    async (address, token) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
+      return wallet.burner.getTokenBalance(address, token);
+    },
+    []
+  );
+  const burnerGetBalance = useCallback(
+    async (address) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
+      return wallet.burner.getBalance(address);
+    },
+    []
+  );
   const refresh = useCallback(async () => {
     const wallet = walletRef.current;
     if (!wallet) return;
@@ -57249,7 +57838,6 @@ function UnlinkProvider({
   const value = useMemo(
     () => ({
       ...state,
-      chainId,
       // Wallet actions
       createWallet,
       importWallet,
@@ -57266,8 +57854,18 @@ function UnlinkProvider({
       requestDeposit,
       // Withdraw actions
       requestWithdraw,
+      // Adapter actions
+      executeAdapter,
       planWithdraw,
       executeWithdraw,
+      // Burner actions
+      createBurner,
+      removeBurner,
+      burnerSend,
+      burnerFund,
+      burnerSweepToPool,
+      burnerGetTokenBalance,
+      burnerGetBalance,
       // Sync actions
       refresh,
       forceResync,
@@ -57279,7 +57877,6 @@ function UnlinkProvider({
     }),
     [
       state,
-      chainId,
       createWallet,
       importWallet,
       exportMnemonic,
@@ -57291,8 +57888,16 @@ function UnlinkProvider({
       executeTransfer,
       requestDeposit,
       requestWithdraw,
+      executeAdapter,
       planWithdraw,
       executeWithdraw,
+      createBurner,
+      removeBurner,
+      burnerSend,
+      burnerFund,
+      burnerSweepToPool,
+      burnerGetTokenBalance,
+      burnerGetBalance,
       refresh,
       forceResync,
       clearError,
@@ -57528,6 +58133,57 @@ function useWithdraw() {
   );
   return useOperationMutation(op);
 }
+
+// src/useAdapter.ts
+import { useCallback as useCallback8 } from "react";
+function useAdapter() {
+  const { executeAdapter } = useUnlink();
+  const op = useCallback8(
+    (params) => executeAdapter(params),
+    [executeAdapter]
+  );
+  return useOperationMutation(op);
+}
+
+// src/useBurner.ts
+import { useCallback as useCallback9 } from "react";
+function useBurner() {
+  const {
+    burners,
+    createBurner,
+    removeBurner,
+    burnerSend,
+    burnerFund,
+    burnerSweepToPool,
+    burnerGetTokenBalance,
+    burnerGetBalance
+  } = useUnlink();
+  const sendOp = useCallback9(
+    (input) => burnerSend(input.index, input.tx),
+    [burnerSend]
+  );
+  const fundOp = useCallback9(
+    (input) => burnerFund(input.index, input.params),
+    [burnerFund]
+  );
+  const sweepOp = useCallback9(
+    (input) => burnerSweepToPool(input.index, input.params),
+    [burnerSweepToPool]
+  );
+  const send = useOperationMutation(sendOp);
+  const fund = useOperationMutation(fundOp);
+  const sweepToPool = useOperationMutation(sweepOp);
+  return {
+    burners,
+    createBurner,
+    removeBurner,
+    send,
+    fund,
+    sweepToPool,
+    getTokenBalance: burnerGetTokenBalance,
+    getBalance: burnerGetBalance
+  };
+}
 export {
   CONFIRMATION_POLL_INTERVAL_MS,
   DEFAULT_CONFIRMATION_TIMEOUT_MS,
@@ -57544,6 +58200,8 @@ export {
   parseZkAddress,
   randomHex,
   shortenHex,
+  useAdapter,
+  useBurner,
   useDeposit,
   useOperationMutation,
   useTransfer,