@unlink-xyz/react 0.1.5 → 0.1.7-canary.252b8ea

package/dist/index.js

@@ -9042,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);
@@ -9162,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"}`
     );
   }
 }
@@ -28352,8 +28352,8 @@ var ContractUnknownEventPayload = class extends EventPayload {
   /**
    *  @_event:
    */
-  constructor(contract, listener, filter, log) {
-    super(contract, listener, filter);
+  constructor(contract2, listener, filter, log) {
+    super(contract2, listener, filter);
     defineProperties(this, { log });
   }
   /**
@@ -28379,9 +28379,9 @@ var ContractEventPayload = class extends ContractUnknownEventPayload {
   /**
    *  @_ignore:
    */
-  constructor(contract, listener, filter, fragment, _log) {
-    super(contract, listener, filter, new EventLog(_log, contract.interface, fragment));
-    const args = contract.interface.decodeEventLog(fragment, this.log.data, this.log.topics);
+  constructor(contract2, listener, filter, fragment, _log) {
+    super(contract2, listener, filter, new EventLog(_log, contract2.interface, fragment));
+    const args = contract2.interface.decodeEventLog(fragment, this.log.data, this.log.topics);
     defineProperties(this, { args, fragment });
   }
   /**
@@ -28424,12 +28424,12 @@ function getResolver(value) {
 var PreparedTopicFilter = class {
   #filter;
   fragment;
-  constructor(contract, fragment, args) {
+  constructor(contract2, fragment, args) {
     defineProperties(this, { fragment });
     if (fragment.inputs.length < args.length) {
       throw new Error("too many arguments");
     }
-    const runner = getRunner(contract.runner, "resolveName");
+    const runner = getRunner(contract2.runner, "resolveName");
     const resolver = canResolve(runner) ? runner : null;
     this.#filter = (async function() {
       const resolvedArgs = await Promise.all(fragment.inputs.map((param, index) => {
@@ -28447,7 +28447,7 @@ var PreparedTopicFilter = class {
           return value;
         });
       }));
-      return contract.interface.encodeFilterTopics(fragment, resolvedArgs);
+      return contract2.interface.encodeFilterTopics(fragment, resolvedArgs);
     })();
   }
   getTopicFilter() {
@@ -28496,14 +28496,14 @@ async function resolveArgs(_runner, inputs, args) {
     });
   }));
 }
-function buildWrappedFallback(contract) {
+function buildWrappedFallback(contract2) {
   const populateTransaction = async function(overrides) {
     const tx = await copyOverrides(overrides, ["data"]);
-    tx.to = await contract.getAddress();
+    tx.to = await contract2.getAddress();
     if (tx.from) {
-      tx.from = await resolveAddress(tx.from, getResolver(contract.runner));
+      tx.from = await resolveAddress(tx.from, getResolver(contract2.runner));
     }
-    const iface = contract.interface;
+    const iface = contract2.interface;
     const noValue = getBigInt(tx.value || BN_09, "overrides.value") === BN_09;
     const noData = (tx.data || "0x") === "0x";
     if (iface.fallback && !iface.fallback.payable && iface.receive && !noData && !noValue) {
@@ -28516,27 +28516,27 @@ function buildWrappedFallback(contract) {
     return tx;
   };
   const staticCall = async function(overrides) {
-    const runner = getRunner(contract.runner, "call");
+    const runner = getRunner(contract2.runner, "call");
     assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
     const tx = await populateTransaction(overrides);
     try {
       return await runner.call(tx);
     } catch (error) {
       if (isCallException(error) && error.data) {
-        throw contract.interface.makeError(error.data, tx);
+        throw contract2.interface.makeError(error.data, tx);
       }
       throw error;
     }
   };
   const send = async function(overrides) {
-    const runner = contract.runner;
+    const runner = contract2.runner;
     assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
     const tx = await runner.sendTransaction(await populateTransaction(overrides));
-    const provider = getProvider(contract.runner);
-    return new ContractTransactionResponse(contract.interface, provider, tx);
+    const provider = getProvider(contract2.runner);
+    return new ContractTransactionResponse(contract2.interface, provider, tx);
   };
   const estimateGas = async function(overrides) {
-    const runner = getRunner(contract.runner, "estimateGas");
+    const runner = getRunner(contract2.runner, "estimateGas");
     assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
     return await runner.estimateGas(await populateTransaction(overrides));
   };
@@ -28544,7 +28544,7 @@ function buildWrappedFallback(contract) {
     return await send(overrides);
   };
   defineProperties(method, {
-    _contract: contract,
+    _contract: contract2,
     estimateGas,
     populateTransaction,
     send,
@@ -28552,9 +28552,9 @@ function buildWrappedFallback(contract) {
   });
   return method;
 }
-function buildWrappedMethod(contract, key) {
+function buildWrappedMethod(contract2, key) {
   const getFragment = function(...args) {
-    const fragment = contract.interface.getFunction(key, args);
+    const fragment = contract2.interface.getFunction(key, args);
     assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
       operation: "fragment",
       info: { key, args }
@@ -28567,16 +28567,16 @@ function buildWrappedMethod(contract, key) {
     if (fragment.inputs.length + 1 === args.length) {
       overrides = await copyOverrides(args.pop());
       if (overrides.from) {
-        overrides.from = await resolveAddress(overrides.from, getResolver(contract.runner));
+        overrides.from = await resolveAddress(overrides.from, getResolver(contract2.runner));
       }
     }
     if (fragment.inputs.length !== args.length) {
       throw new Error("internal error: fragment inputs doesn't match arguments; should not happen");
     }
-    const resolvedArgs = await resolveArgs(contract.runner, fragment.inputs, args);
+    const resolvedArgs = await resolveArgs(contract2.runner, fragment.inputs, args);
     return Object.assign({}, overrides, await resolveProperties({
-      to: contract.getAddress(),
-      data: contract.interface.encodeFunctionData(fragment, resolvedArgs)
+      to: contract2.getAddress(),
+      data: contract2.interface.encodeFunctionData(fragment, resolvedArgs)
     }));
   };
   const staticCall = async function(...args) {
@@ -28587,19 +28587,19 @@ function buildWrappedMethod(contract, key) {
     return result;
   };
   const send = async function(...args) {
-    const runner = contract.runner;
+    const runner = contract2.runner;
     assert(canSend(runner), "contract runner does not support sending transactions", "UNSUPPORTED_OPERATION", { operation: "sendTransaction" });
     const tx = await runner.sendTransaction(await populateTransaction(...args));
-    const provider = getProvider(contract.runner);
-    return new ContractTransactionResponse(contract.interface, provider, tx);
+    const provider = getProvider(contract2.runner);
+    return new ContractTransactionResponse(contract2.interface, provider, tx);
   };
   const estimateGas = async function(...args) {
-    const runner = getRunner(contract.runner, "estimateGas");
+    const runner = getRunner(contract2.runner, "estimateGas");
     assert(canEstimate(runner), "contract runner does not support gas estimation", "UNSUPPORTED_OPERATION", { operation: "estimateGas" });
     return await runner.estimateGas(await populateTransaction(...args));
   };
   const staticCallResult = async function(...args) {
-    const runner = getRunner(contract.runner, "call");
+    const runner = getRunner(contract2.runner, "call");
     assert(canCall(runner), "contract runner does not support calling", "UNSUPPORTED_OPERATION", { operation: "call" });
     const tx = await populateTransaction(...args);
     let result = "0x";
@@ -28607,12 +28607,12 @@ function buildWrappedMethod(contract, key) {
       result = await runner.call(tx);
     } catch (error) {
       if (isCallException(error) && error.data) {
-        throw contract.interface.makeError(error.data, tx);
+        throw contract2.interface.makeError(error.data, tx);
       }
       throw error;
     }
     const fragment = getFragment(...args);
-    return contract.interface.decodeFunctionResult(fragment, result);
+    return contract2.interface.decodeFunctionResult(fragment, result);
   };
   const method = async (...args) => {
     const fragment = getFragment(...args);
@@ -28622,8 +28622,8 @@ function buildWrappedMethod(contract, key) {
     return await send(...args);
   };
   defineProperties(method, {
-    name: contract.interface.getFunctionName(key),
-    _contract: contract,
+    name: contract2.interface.getFunctionName(key),
+    _contract: contract2,
     _key: key,
     getFragment,
     estimateGas,
@@ -28636,7 +28636,7 @@ function buildWrappedMethod(contract, key) {
     configurable: false,
     enumerable: true,
     get: () => {
-      const fragment = contract.interface.getFunction(key);
+      const fragment = contract2.interface.getFunction(key);
       assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
         operation: "fragment",
         info: { key }
@@ -28646,9 +28646,9 @@ function buildWrappedMethod(contract, key) {
   });
   return method;
 }
-function buildWrappedEvent(contract, key) {
+function buildWrappedEvent(contract2, key) {
   const getFragment = function(...args) {
-    const fragment = contract.interface.getEvent(key, args);
+    const fragment = contract2.interface.getEvent(key, args);
     assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
       operation: "fragment",
       info: { key, args }
@@ -28656,11 +28656,11 @@ function buildWrappedEvent(contract, key) {
     return fragment;
   };
   const method = function(...args) {
-    return new PreparedTopicFilter(contract, getFragment(...args), args);
+    return new PreparedTopicFilter(contract2, getFragment(...args), args);
   };
   defineProperties(method, {
-    name: contract.interface.getEventName(key),
-    _contract: contract,
+    name: contract2.interface.getEventName(key),
+    _contract: contract2,
     _key: key,
     getFragment
   });
@@ -28668,7 +28668,7 @@ function buildWrappedEvent(contract, key) {
     configurable: false,
     enumerable: true,
     get: () => {
-      const fragment = contract.interface.getEvent(key);
+      const fragment = contract2.interface.getEvent(key);
       assert(fragment, "no matching fragment", "UNSUPPORTED_OPERATION", {
         operation: "fragment",
         info: { key }
@@ -28680,16 +28680,16 @@ function buildWrappedEvent(contract, key) {
 }
 var internal2 = /* @__PURE__ */ Symbol.for("_ethersInternal_contract");
 var internalValues = /* @__PURE__ */ new WeakMap();
-function setInternal(contract, values) {
-  internalValues.set(contract[internal2], values);
+function setInternal(contract2, values) {
+  internalValues.set(contract2[internal2], values);
 }
-function getInternal(contract) {
-  return internalValues.get(contract[internal2]);
+function getInternal(contract2) {
+  return internalValues.get(contract2[internal2]);
 }
 function isDeferred(value) {
   return value && typeof value === "object" && "getTopicFilter" in value && typeof value.getTopicFilter === "function" && value.fragment;
 }
-async function getSubInfo(contract, event) {
+async function getSubInfo(contract2, event) {
   let topics;
   let fragment = null;
   if (Array.isArray(event)) {
@@ -28697,7 +28697,7 @@ async function getSubInfo(contract, event) {
       if (isHexString(name, 32)) {
         return name;
       }
-      const fragment2 = contract.interface.getEvent(name);
+      const fragment2 = contract2.interface.getEvent(name);
       assertArgument(fragment2, "unknown fragment", "name", name);
       return fragment2.topicHash;
     };
@@ -28716,7 +28716,7 @@ async function getSubInfo(contract, event) {
     if (isHexString(event, 32)) {
       topics = [event];
     } else {
-      fragment = contract.interface.getEvent(event);
+      fragment = contract2.interface.getEvent(event);
       assertArgument(fragment, "unknown fragment", "event", event);
       topics = [fragment.topicHash];
     }
@@ -28753,36 +28753,36 @@ async function getSubInfo(contract, event) {
   }).join("&");
   return { fragment, tag, topics };
 }
-async function hasSub(contract, event) {
-  const { subs } = getInternal(contract);
-  return subs.get((await getSubInfo(contract, event)).tag) || null;
+async function hasSub(contract2, event) {
+  const { subs } = getInternal(contract2);
+  return subs.get((await getSubInfo(contract2, event)).tag) || null;
 }
-async function getSub(contract, operation, event) {
-  const provider = getProvider(contract.runner);
+async function getSub(contract2, operation, event) {
+  const provider = getProvider(contract2.runner);
   assert(provider, "contract runner does not support subscribing", "UNSUPPORTED_OPERATION", { operation });
-  const { fragment, tag, topics } = await getSubInfo(contract, event);
-  const { addr, subs } = getInternal(contract);
+  const { fragment, tag, topics } = await getSubInfo(contract2, event);
+  const { addr, subs } = getInternal(contract2);
   let sub2 = subs.get(tag);
   if (!sub2) {
-    const address = addr ? addr : contract;
+    const address = addr ? addr : contract2;
     const filter = { address, topics };
     const listener = (log) => {
       let foundFragment = fragment;
       if (foundFragment == null) {
         try {
-          foundFragment = contract.interface.getEvent(log.topics[0]);
+          foundFragment = contract2.interface.getEvent(log.topics[0]);
         } catch (error) {
         }
       }
       if (foundFragment) {
         const _foundFragment = foundFragment;
-        const args = fragment ? contract.interface.decodeEventLog(fragment, log.data, log.topics) : [];
-        emit22(contract, event, args, (listener2) => {
-          return new ContractEventPayload(contract, listener2, event, _foundFragment, log);
+        const args = fragment ? contract2.interface.decodeEventLog(fragment, log.data, log.topics) : [];
+        emit22(contract2, event, args, (listener2) => {
+          return new ContractEventPayload(contract2, listener2, event, _foundFragment, log);
         });
       } else {
-        emit22(contract, event, [], (listener2) => {
-          return new ContractUnknownEventPayload(contract, listener2, event, log);
+        emit22(contract2, event, [], (listener2) => {
+          return new ContractUnknownEventPayload(contract2, listener2, event, log);
         });
       }
     };
@@ -28808,9 +28808,9 @@ async function getSub(contract, operation, event) {
   return sub2;
 }
 var lastEmit = Promise.resolve();
-async function _emit(contract, event, args, payloadFunc) {
+async function _emit(contract2, event, args, payloadFunc) {
   await lastEmit;
-  const sub2 = await hasSub(contract, event);
+  const sub2 = await hasSub(contract2, event);
   if (!sub2) {
     return false;
   }
@@ -28821,23 +28821,23 @@ async function _emit(contract, event, args, payloadFunc) {
       passArgs.push(payloadFunc(once22 ? null : listener));
     }
     try {
-      listener.call(contract, ...passArgs);
+      listener.call(contract2, ...passArgs);
     } catch (error) {
     }
     return !once22;
   });
   if (sub2.listeners.length === 0) {
     sub2.stop();
-    getInternal(contract).subs.delete(sub2.tag);
+    getInternal(contract2).subs.delete(sub2.tag);
   }
   return count > 0;
 }
-async function emit22(contract, event, args, payloadFunc) {
+async function emit22(contract2, event, args, payloadFunc) {
   try {
     await lastEmit;
   } catch (error) {
   }
-  const resultPromise = _emit(contract, event, args, payloadFunc);
+  const resultPromise = _emit(contract2, event, args, payloadFunc);
   lastEmit = resultPromise;
   return await resultPromise;
 }
@@ -29263,8 +29263,8 @@ var BaseContract = class _BaseContract {
     if (runner == null) {
       runner = null;
     }
-    const contract = new this(target, abi, runner);
-    return contract;
+    const contract2 = new this(target, abi, runner);
+    return contract2;
   }
 };
 function _ContractBase() {
@@ -29559,7 +29559,7 @@ var EnsResolver = class _EnsResolver {
               return { url: null, linkage };
             }
             const tokenId = comps[1];
-            const contract = new Contract(comps[0], [
+            const contract2 = new Contract(comps[0], [
               // ERC-721
               "function tokenURI(uint) view returns (string)",
               "function ownerOf(uint) view returns (address)",
@@ -29568,21 +29568,21 @@ var EnsResolver = class _EnsResolver {
               "function balanceOf(address, uint256) view returns (uint)"
             ], this.provider);
             if (scheme === "erc721") {
-              const tokenOwner = await contract.ownerOf(tokenId);
+              const tokenOwner = await contract2.ownerOf(tokenId);
               if (owner !== tokenOwner) {
                 linkage.push({ type: "!owner", value: tokenOwner });
                 return { url: null, linkage };
               }
               linkage.push({ type: "owner", value: tokenOwner });
             } else if (scheme === "erc1155") {
-              const balance = await contract.balanceOf(owner, tokenId);
+              const balance = await contract2.balanceOf(owner, tokenId);
               if (!balance) {
                 linkage.push({ type: "!balance", value: "0" });
                 return { url: null, linkage };
               }
               linkage.push({ type: "balance", value: balance.toString() });
             }
-            let metadataUrl = await contract[selector](tokenId);
+            let metadataUrl = await contract2[selector](tokenId);
             if (metadataUrl == null || metadataUrl === "0x") {
               linkage.push({ type: "!metadata-url", value: "" });
               return { url: null, linkage };
@@ -29654,10 +29654,10 @@ var EnsResolver = class _EnsResolver {
   static async #getResolver(provider, name) {
     const ensAddr = await _EnsResolver.getEnsAddress(provider);
     try {
-      const contract = new Contract(ensAddr, [
+      const contract2 = new Contract(ensAddr, [
         "function resolver(bytes32) view returns (address)"
       ], provider);
-      const addr = await contract.resolver(namehash(name), {
+      const addr = await contract2.resolver(namehash(name), {
         enableCcipRead: true
       });
       if (addr === ZeroAddress) {
@@ -35647,29 +35647,41 @@ function createJsonHttpClient(baseUrl, deps) {
     fetch: fetchImpl,
     // Disable ky's automatic error throwing to prevent browser DevTools
     // from logging expected 404s as network errors
-    throwHttpErrors: false
+    throwHttpErrors: false,
+    retry: 0
   });
+  const RETRYABLE_STATUSES = [502, 503, 504];
+  const MAX_RETRIES = 3;
+  const BASE_DELAY_MS = 500;
   return {
     async request(opts) {
       let res;
-      try {
-        res = await api(opts.path.replace(/^\//, ""), {
-          method: opts.method,
-          searchParams: opts.query,
-          json: opts.json,
-          body: opts.body,
-          headers: opts.headers,
-          signal: opts.signal
-        });
-      } catch (err) {
-        if (err instanceof TimeoutError) {
-          throw new HttpError("HTTP timeout", 408, null);
+      for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        try {
+          res = await api(opts.path.replace(/^\//, ""), {
+            method: opts.method,
+            searchParams: opts.query,
+            json: opts.json,
+            body: opts.body,
+            headers: opts.headers,
+            signal: opts.signal
+          });
+        } catch (err) {
+          if (err instanceof TimeoutError) {
+            throw new HttpError("HTTP timeout", 408, null);
+          }
+          throw new HttpError(
+            err instanceof Error ? err.message : "Network error",
+            0,
+            null
+          );
         }
-        throw new HttpError(
-          err instanceof Error ? err.message : "Network error",
-          0,
-          null
-        );
+        if (RETRYABLE_STATUSES.includes(res.status) && attempt < MAX_RETRIES) {
+          const delay2 = BASE_DELAY_MS * 2 ** attempt + Math.random() * 200;
+          await new Promise((r2) => setTimeout(r2, delay2));
+          continue;
+        }
+        break;
       }
       if (!res.ok) {
         const body = await readErrorBodySafe(res);
@@ -35871,63 +35883,110 @@ 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 adapterAddress = parseOptionalString(
+    chain2,
+    "adapterAddress",
+    raw.adapterAddress
+  );
+  const frostUrl = parseOptionalString(
+    chain2,
+    "frostUrl",
+    raw.frostUrl
+  )?.replace(/\/+$/, "");
   const artifactBaseUrl = parseOptionalString(
-    env22,
+    chain2,
     "artifactBaseUrl",
     raw.artifactBaseUrl
   )?.replace(/\/+$/, "");
+  let tokenAddresses;
+  if (raw.tokenAddresses !== void 0) {
+    if (raw.tokenAddresses === null || typeof raw.tokenAddresses !== "object" || Array.isArray(raw.tokenAddresses)) {
+      throw new InitializationError(
+        `Invalid SDK config for ${chain2}: tokenAddresses must be an object`
+      );
+    }
+    tokenAddresses = {};
+    for (const [name, addr] of Object.entries(
+      raw.tokenAddresses
+    )) {
+      tokenAddresses[name] = parseRequiredString(
+        chain2,
+        `tokenAddresses.${name}`,
+        addr
+      );
+    }
+  }
   return {
+    chainId,
     gatewayUrl,
+    ...frostUrl !== void 0 ? { frostUrl } : {},
     poolAddress,
+    ...adapterAddress !== void 0 ? { adapterAddress } : {},
     artifactVersion,
-    ...artifactBaseUrl !== void 0 ? { artifactBaseUrl } : { artifactBaseUrl: DEFAULT_ARTIFACT_BASE_URL }
+    ...artifactBaseUrl !== void 0 ? { artifactBaseUrl } : { artifactBaseUrl: DEFAULT_ARTIFACT_BASE_URL },
+    ...tokenAddresses !== void 0 ? { tokenAddresses } : {}
   };
 }
-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(/\/+$/, "");
@@ -53316,6 +53375,114 @@ var circuits_default = {
     template: "JoinSplit",
     pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
     params: [5, 2, 16]
+  },
+  joinsplit_1x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [1, 3, 16]
+  },
+  joinsplit_4x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [4, 3, 16]
+  },
+  joinsplit_5x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [5, 3, 16]
+  },
+  joinsplit_6x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [6, 1, 16]
+  },
+  joinsplit_6x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [6, 2, 16]
+  },
+  joinsplit_6x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [6, 3, 16]
+  },
+  joinsplit_7x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [7, 1, 16]
+  },
+  joinsplit_7x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [7, 2, 16]
+  },
+  joinsplit_7x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [7, 3, 16]
+  },
+  joinsplit_8x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [8, 1, 16]
+  },
+  joinsplit_8x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [8, 2, 16]
+  },
+  joinsplit_8x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [8, 3, 16]
+  },
+  joinsplit_9x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [9, 1, 16]
+  },
+  joinsplit_9x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [9, 2, 16]
+  },
+  joinsplit_9x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [9, 3, 16]
+  },
+  joinsplit_10x1_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [10, 1, 16]
+  },
+  joinsplit_10x2_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [10, 2, 16]
+  },
+  joinsplit_10x3_16: {
+    file: "joinsplit",
+    template: "JoinSplit",
+    pubs: ["merkleRoot", "boundParamsHash", "nullifiers", "commitmentsOut"],
+    params: [10, 3, 16]
   }
 };
 var registry = {};
@@ -53331,7 +53498,7 @@ var SUPPORTED_CIRCUITS = Object.keys(CIRCUIT_REGISTRY);
 function getCircuitConfig(inputs, outputs) {
   return CIRCUIT_REGISTRY[`${inputs}x${outputs}`];
 }
-var MAX_ARTIFACT_CACHE_ENTRIES = 8;
+var MAX_ARTIFACT_CACHE_ENTRIES = 16;
 var artifactCache = /* @__PURE__ */ new Map();
 function selectCircuit(inputs, outputs) {
   const config22 = getCircuitConfig(inputs, outputs);
@@ -54166,6 +54333,58 @@ function normalizeReshield(reshield, index) {
   );
   return { npk, random, token, minAmount };
 }
+function approve(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 toCall(tx) {
+  if (tx.to == null) {
+    throw new AdapterError("tx.to is required");
+  }
+  const to = ensureAddress("tx.to", tx.to);
+  if (tx.data == null) {
+    throw new AdapterError("tx.data is required");
+  }
+  const data = ensureHexData("tx.data", tx.data);
+  let value;
+  if (tx.value == null) {
+    value = 0n;
+  } else {
+    try {
+      value = BigInt(tx.value);
+    } catch {
+      throw new AdapterError(
+        `tx.value must be convertible to bigint, received: ${String(tx.value)}`
+      );
+    }
+  }
+  return { to, data, value: ensureNonNegative("tx.value", value) };
+}
+function contract(address, abi) {
+  const to = ensureAddress("contract.address", address);
+  const iface = new Interface(abi);
+  return new Proxy(
+    {},
+    {
+      get(_, method) {
+        return (...args) => {
+          const data = iface.encodeFunctionData(method, args);
+          return { to, data, value: 0n };
+        };
+      }
+    }
+  );
+}
 function encodeAdapterExecute(params) {
   const transactCalldata = ensureHexData(
     "transactCalldata",
@@ -54189,6 +54408,7 @@ function encodeAdapterExecute(params) {
     deadline
   ]);
 }
+var buildApproveCall = approve;
 init_process();
 init_buffer();
 init_process();
@@ -55575,26 +55795,34 @@ function normalizeCall2(call, index) {
     value: call.value
   };
 }
-function normalizeInputSpec(input, index) {
-  const token = ensureAddress(`inputs[${index}].token`, input.token);
+function normalizeSpendInput(input, index) {
+  const token = ensureAddress(`spend[${index}].token`, input.token);
+  if (token.toLowerCase() === ETH_TOKEN.toLowerCase()) {
+    throw new AdapterError(
+      `spend[${index}].token: native ETH is not supported in adapter execution`
+    );
+  }
   if (input.amount <= 0n) {
-    throw new AdapterError(`inputs[${index}].amount must be greater than zero`);
+    throw new AdapterError(`spend[${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) {
+function normalizeReceiveInput(receive, index) {
+  const token = ensureAddress(`receive[${index}].token`, receive.token);
+  if (token.toLowerCase() === ETH_TOKEN.toLowerCase()) {
     throw new AdapterError(
-      `reshields[${index}].minAmount must be non-negative`
+      `receive[${index}].token: native ETH is not supported in adapter execution`
     );
   }
+  if (receive.minAmount < 0n) {
+    throw new AdapterError(`receive[${index}].minAmount must be non-negative`);
+  }
   return {
     token,
-    minAmount: reshield.minAmount
+    minAmount: receive.minAmount
   };
 }
 function randomFieldElement(randomBigintFn) {
@@ -55614,32 +55842,42 @@ function createAdapterService(deps) {
         "adapterAddress",
         params.adapterAddress
       );
-      if (!params.inputs.length) {
-        throw new AdapterError("at least one input token is required");
+      if (!params.spend.length) {
+        throw new AdapterError("at least one spend 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");
+      if (!params.receive.length) {
+        throw new AdapterError("at least one receive output is required");
       }
-      const inputs = params.inputs.map(
-        (input, i) => normalizeInputSpec(input, i)
+      const spendInputs = params.spend.map(
+        (input, i) => normalizeSpendInput(input, i)
       );
       const seenTokens = /* @__PURE__ */ new Set();
-      for (const input of inputs) {
+      for (const input of spendInputs) {
         const lower = input.token.toLowerCase();
         if (seenTokens.has(lower)) {
           throw new AdapterError(
-            `duplicate input token ${input.token}; combine amounts per token instead`
+            `duplicate spend 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 receiveSpecs = params.receive.map(
+        (receive, i) => normalizeReceiveInput(receive, i)
       );
+      const seenReceiveTokens = /* @__PURE__ */ new Set();
+      for (const r2 of receiveSpecs) {
+        const lower = r2.token.toLowerCase();
+        if (seenReceiveTokens.has(lower)) {
+          throw new AdapterError(
+            `duplicate receive token ${r2.token}; each receive must target a unique token`
+          );
+        }
+        seenReceiveTokens.add(lower);
+      }
       const account = overrides?.account ?? await deps.requireActiveAccount();
       const signer = overrides?.signer ?? deps.requireSigner(account);
       const nowSeconds = BigInt(Math.floor(nowImpl() / 1e3));
@@ -55648,19 +55886,19 @@ function createAdapterService(deps) {
         throw new AdapterError("deadline must be in the future");
       }
       const executionCalls = calls;
-      const reshields = reshieldSpecs.map(
-        (reshield) => {
+      const reshields = receiveSpecs.map(
+        (receive) => {
           const random = randomFieldElement(randomBigintImpl);
           const npk = poseidon([account.masterPublicKey, random]);
           return {
             npk,
             random,
-            token: reshield.token,
-            minAmount: reshield.minAmount
+            token: receive.token,
+            minAmount: receive.minAmount
           };
         }
       );
-      const inputTokens = inputs.map((input) => input.token);
+      const inputTokens = spendInputs.map((input) => input.token);
       const nonce = randomFieldElement(randomBigintImpl);
       const adapterDataHash = computeAdapterDataHash({
         calls: executionCalls,
@@ -55677,7 +55915,7 @@ function createAdapterService(deps) {
       });
       const withdrawalPlans = planWithdrawalsImpl(
         notes,
-        inputs.map((input) => ({
+        spendInputs.map((input) => ({
           token: input.token,
           amount: input.amount,
           recipient: adapterAddress
@@ -55760,7 +55998,7 @@ function createAdapterService(deps) {
         adapterCalldata,
         historyPreview: {
           kind: "Withdraw",
-          amounts: inputs.map((input) => ({
+          amounts: spendInputs.map((input) => ({
             token: input.token,
             delta: (-input.amount).toString()
           }))
@@ -55780,6 +56018,9 @@ init_process();
 init_buffer();
 var BIP44_ETH_PREFIX = "m/44'/60'/0'/0";
 var ERC20_BALANCE_OF = "function balanceOf(address) view returns (uint256)";
+function isNativeToken(token) {
+  return token.toLowerCase() === ETH_TOKEN.toLowerCase();
+}
 function createBurnerService(deps) {
   const { chainRpcUrl, getMasterSeed, withdrawToAddress, requestDeposit } = deps;
   const provider = new JsonRpcProvider(chainRpcUrl);
@@ -55827,8 +56068,8 @@ function createBurnerService(deps) {
   }
   async function getTokenBalance(address, token) {
     const iface = new Interface([ERC20_BALANCE_OF]);
-    const contract = new Contract(token, iface, provider);
-    const bal = await contract.getFunction("balanceOf")(address);
+    const contract2 = new Contract(token, iface, provider);
+    const bal = await contract2.getFunction("balanceOf")(address);
     return BigInt(bal ?? 0);
   }
   async function getBalance(address) {
@@ -55847,6 +56088,12 @@ function createBurnerService(deps) {
   }
   async function sweepToPool(index, params) {
     const { address } = await addressOf(index);
+    const native = isNativeToken(params.token);
+    if (native && params.amount == null) {
+      throw new Error(
+        "amount is required for native ETH sweeps (needed to reserve gas)"
+      );
+    }
     const amount = params.amount ?? await getTokenBalance(address, params.token);
     if (amount === 0n) {
       throw new Error("No token balance to sweep");
@@ -55857,17 +56104,20 @@ function createBurnerService(deps) {
       depositor: address,
       deposits: [{ token: params.token, amount }]
     });
-    const erc20Iface = new Interface([
-      "function approve(address spender, uint256 amount)"
-    ]);
-    const approveData = erc20Iface.encodeFunctionData("approve", [
-      params.poolAddress,
-      amount
-    ]);
-    await send(index, { to: params.token, data: approveData });
+    if (!native) {
+      const erc20Iface = new Interface([
+        "function approve(address spender, uint256 amount)"
+      ]);
+      const approveData = erc20Iface.encodeFunctionData("approve", [
+        params.poolAddress,
+        amount
+      ]);
+      await send(index, { to: params.token, data: approveData });
+    }
     const { txHash } = await send(index, {
       to: depositResult.to,
-      data: depositResult.calldata
+      data: depositResult.calldata,
+      value: depositResult.value
     });
     return { txHash };
   }
@@ -56520,50 +56770,62 @@ function createWalletSDK(deps, options) {
   };
   return sdk;
 }
-var UnlinkWallet = class _UnlinkWallet {
+var Unlink = class _Unlink {
   /** @internal */
   sdk;
   /** Chain ID this wallet operates on. */
   chainId;
   /** Pool contract address this wallet transacts with. */
   poolAddress;
-  constructor(sdk, chainId, poolAddress) {
+  /** Adapter contract address for DeFi operations. */
+  adapterAddress;
+  constructor(sdk, chainId, poolAddress, adapterAddress) {
     this.sdk = sdk;
     this.chainId = chainId;
     this.poolAddress = poolAddress;
+    this.adapterAddress = adapterAddress;
+    this.adapter = {
+      address: adapterAddress
+    };
   }
   /**
-   * Create a new UnlinkWallet instance.
+   * Create a new Unlink 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 adapterAddress;
     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;
+      adapterAddress = config22.adapterAddress ?? chainConfig.adapterAddress;
+      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;
+      adapterAddress = config22.adapterAddress;
       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;
@@ -56572,14 +56834,14 @@ var UnlinkWallet = class _UnlinkWallet {
     const sdk = createWalletSDK(
       { core, fetch: fetchImpl },
       {
-        chainId: config22.chainId,
+        chainId,
         gatewayUrl,
         chainRpcUrl: config22.chainRpcUrl,
         prover: proverConfig,
         autoSync: config22.autoSync
       }
     );
-    return new _UnlinkWallet(sdk, config22.chainId, poolAddress);
+    return new _Unlink(sdk, chainId, poolAddress, adapterAddress ?? "");
   }
   // ===== Seed Lifecycle =====
   /** Seed management (create, import, export, delete mnemonic). */
@@ -56610,10 +56872,10 @@ var UnlinkWallet = class _UnlinkWallet {
     return this.sdk.deposit.reconcile(relayId);
   }
   /**
-   * Execute a private transfer (1 or more recipients).
+   * Send a private transfer (1 or more recipients).
    * Handles note selection, circuit selection, and proof generation automatically.
    */
-  async transfer(params, overrides) {
+  async send(params, overrides) {
     return this.sdk.transfer.send(
       {
         chainId: this.chainId,
@@ -56624,9 +56886,9 @@ var UnlinkWallet = class _UnlinkWallet {
     );
   }
   /**
-   * Get a transfer plan without executing (for preview/confirmation UIs).
+   * Get a send plan without executing (for preview/confirmation UIs).
    */
-  async planTransfer(params, account) {
+  async planSend(params, account) {
     return this.sdk.transfer.plan(
       {
         chainId: this.chainId,
@@ -56636,8 +56898,8 @@ var UnlinkWallet = class _UnlinkWallet {
       account
     );
   }
-  /** Execute a pre-built transfer plan. */
-  async executeTransfer(plans, overrides) {
+  /** Execute a pre-built send plan. */
+  async executeSend(plans, overrides) {
     return this.sdk.transfer.execute(
       plans,
       { chainId: this.chainId, poolAddress: this.poolAddress },
@@ -56786,31 +57048,31 @@ var UnlinkWallet = class _UnlinkWallet {
       return this.sdk.burner.getBalance(address);
     }
   };
-  // ===== Adapter =====
+  // ===== Interact (Private DeFi) =====
   /**
-   * Private DeFi adapter operations.
-   * chainId/poolAddress are injected automatically.
+   * Adapter contract address (resolved from config).
+   * Use for building DeFi calls that reference the adapter.
    */
-  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
-      );
-    }
-  };
+  adapter;
+  /**
+   * Execute an atomic unshield -> DeFi call(s) -> reshield flow through an adapter.
+   * chainId/poolAddress/adapterAddress are injected automatically.
+   */
+  async interact(params, opts, overrides) {
+    return this.sdk.adapter.execute(
+      {
+        chainId: this.chainId,
+        poolAddress: this.poolAddress,
+        adapterAddress: this.adapterAddress,
+        spend: params.spend,
+        calls: params.calls,
+        receive: params.receive,
+        deadline: params.deadline
+      },
+      opts,
+      overrides
+    );
+  }
   // ===== Advanced =====
   /**
    * Advanced escape hatch for raw JoinSplit transaction building.
@@ -56930,15 +57192,17 @@ function createUnlinkError(err, operation) {
   };
 }
 var initialState = {
-  wallet: null,
+  unlink: null,
   walletExists: false,
   accounts: [],
   activeAccount: null,
   activeAccountIndex: null,
+  chainId: null,
   notes: [],
   balances: {},
+  burners: [],
   pendingDeposits: [],
-  pendingTransfers: [],
+  pendingSends: [],
   pendingWithdrawals: [],
   ready: false,
   busy: false,
@@ -56954,22 +57218,23 @@ 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 unlinkRef = useRef(null);
   const proverKey = JSON.stringify(prover ?? null);
-  const refreshAccounts = useCallback(async (wallet) => {
+  const refreshAccounts = useCallback(async (unlink) => {
     try {
-      const accounts = await wallet.accounts.list();
-      const activeAccount = await wallet.accounts.getActive();
-      const activeAccountIndex = await wallet.accounts.getActiveIndex();
+      const accounts = await unlink.accounts.list();
+      const activeAccount = await unlink.accounts.getActive();
+      const activeAccountIndex = await unlink.accounts.getActiveIndex();
       setState((prev2) => ({
         ...prev2,
         accounts,
@@ -56980,24 +57245,24 @@ function UnlinkProvider({
       console.error("[UnlinkProvider] refreshAccounts error", err);
     }
   }, []);
-  const refreshState = useCallback(async (wallet) => {
+  const refreshState = useCallback(async (unlink) => {
     try {
-      const noteRecords = await wallet.getNotes();
+      const noteRecords = await unlink.getNotes();
       const notes = convertNotes(noteRecords);
-      const balances = await wallet.getBalances();
+      const balances = await unlink.getBalances();
       setState((prev2) => ({ ...prev2, notes, balances }));
     } catch (err) {
       console.error("[UnlinkProvider] refresh error", err);
     }
   }, []);
   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;
@@ -57010,22 +57275,21 @@ function UnlinkProvider({
           ...prev2,
           status: "Initializing SDK..."
         }));
-        const wallet = await UnlinkWallet.create(
-          gatewayUrl ? {
-            chainId,
-            gatewayUrl,
+        const unlink = await Unlink.create(
+          chain2 ? {
+            chain: chain2,
             poolAddress,
             ...prover ? { prover } : {}
           } : {
             chainId,
-            environment,
+            gatewayUrl,
             poolAddress,
             ...prover ? { prover } : {}
           }
         );
         if (cancelled) return;
-        walletRef.current = wallet;
-        const walletExists = await wallet.seed.exists();
+        unlinkRef.current = unlink;
+        const walletExists = await unlink.seed.exists();
         if (cancelled) return;
         let accounts = [];
         let activeAccount = null;
@@ -57033,32 +57297,33 @@ function UnlinkProvider({
         let notes = [];
         let balances = {};
         if (walletExists) {
-          accounts = await wallet.accounts.list();
+          accounts = await unlink.accounts.list();
           if (accounts.length === 0) {
-            await wallet.accounts.create();
-            accounts = await wallet.accounts.list();
+            await unlink.accounts.create();
+            accounts = await unlink.accounts.list();
           }
-          activeAccount = await wallet.accounts.getActive();
-          activeAccountIndex = await wallet.accounts.getActiveIndex();
+          activeAccount = await unlink.accounts.getActive();
+          activeAccountIndex = await unlink.accounts.getActiveIndex();
           if (accounts.length > 0 && !activeAccount) {
-            await wallet.accounts.setActive(accounts[0].index);
-            activeAccount = await wallet.accounts.getActive();
-            activeAccountIndex = await wallet.accounts.getActiveIndex();
+            await unlink.accounts.setActive(accounts[0].index);
+            activeAccount = await unlink.accounts.getActive();
+            activeAccountIndex = await unlink.accounts.getActiveIndex();
           }
           if (activeAccount) {
-            const noteRecords = await wallet.getNotes();
+            const noteRecords = await unlink.getNotes();
             notes = convertNotes(noteRecords);
-            balances = await wallet.getBalances();
+            balances = await unlink.getBalances();
           }
         }
         const statusMessage = !walletExists ? "No wallet - create or import one" : !activeAccount ? "No account - create one to get started" : "Ready";
         setState((prev2) => ({
           ...prev2,
-          wallet,
+          unlink,
           walletExists,
           accounts,
           activeAccount,
           activeAccountIndex,
+          chainId: unlink.chainId,
           notes,
           balances,
           ready: true,
@@ -57066,12 +57331,12 @@ function UnlinkProvider({
           error: null
         }));
         if (autoSync && walletExists && activeAccount) {
-          wallet.startAutoSync(syncInterval);
+          unlink.startAutoSync(syncInterval);
         }
-        unsubscribe = wallet.on((event) => {
-          if (event.type === "notes-updated" && event.chainId === chainId) {
+        unsubscribe = unlink.on((event) => {
+          if (event.type === "notes-updated" && event.chainId === unlink.chainId) {
             setState((prev2) => ({ ...prev2, syncError: null }));
-            void refreshState(wallet);
+            void refreshState(unlink);
           }
           if (event.type === "sync-error") {
             setState((prev2) => ({ ...prev2, syncError: event.error }));
@@ -57080,9 +57345,9 @@ function UnlinkProvider({
             setState((prev2) => ({ ...prev2, walletExists: true }));
           }
           if (event.type === "account-created" || event.type === "account-switched") {
-            void refreshAccounts(wallet);
+            void refreshAccounts(unlink);
             if (event.type === "account-switched") {
-              void refreshState(wallet);
+              void refreshState(unlink);
             }
           }
         });
@@ -57100,25 +57365,25 @@ function UnlinkProvider({
     return () => {
       cancelled = true;
       unsubscribe?.();
-      walletRef.current?.stopAutoSync();
+      unlinkRef.current?.stopAutoSync();
     };
   }, [
+    chain2,
     chainId,
     autoSync,
     syncInterval,
     refreshState,
     refreshAccounts,
     gatewayUrl,
-    environment,
     poolAddress,
     proverKey
   ]);
   const createWallet = useCallback(async () => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
     setState((prev2) => ({ ...prev2, busy: true, status: "Creating wallet..." }));
     try {
-      const result = await wallet.seed.create();
+      const result = await unlink.seed.create();
       setState((prev2) => ({
         ...prev2,
         walletExists: true,
@@ -57139,24 +57404,25 @@ function UnlinkProvider({
     }
   }, []);
   const importWallet = useCallback(async (mnemonic) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
     setState((prev2) => ({
       ...prev2,
       busy: true,
       status: "Importing wallet..."
     }));
     try {
-      await wallet.seed.importMnemonic(mnemonic);
-      const accounts = await wallet.accounts.list();
-      const activeAccount = await wallet.accounts.getActive();
-      const activeAccountIndex = await wallet.accounts.getActiveIndex();
+      await unlink.seed.importMnemonic(mnemonic);
+      const accounts = await unlink.accounts.list();
+      const activeAccount = await unlink.accounts.getActive();
+      const activeAccountIndex = await unlink.accounts.getActiveIndex();
       setState((prev2) => ({
         ...prev2,
         walletExists: true,
         accounts,
         activeAccount,
         activeAccountIndex,
+        burners: [],
         busy: false,
         status: accounts.length > 0 ? "Wallet imported" : "Wallet imported - create an account",
         syncError: null,
@@ -57173,16 +57439,16 @@ function UnlinkProvider({
     }
   }, []);
   const exportMnemonic = useCallback(async () => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
-    return wallet.seed.exportMnemonic();
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
+    return unlink.seed.exportMnemonic();
   }, []);
   const clearWallet = useCallback(async () => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
     setState((prev2) => ({ ...prev2, busy: true, status: "Clearing wallet..." }));
     try {
-      await wallet.seed.delete();
+      await unlink.seed.delete();
       setState((prev2) => ({
         ...prev2,
         walletExists: false,
@@ -57191,6 +57457,7 @@ function UnlinkProvider({
         activeAccountIndex: null,
         notes: [],
         balances: {},
+        burners: [],
         busy: false,
         status: "Wallet cleared",
         syncError: null,
@@ -57208,18 +57475,18 @@ function UnlinkProvider({
   }, []);
   const createAccount = useCallback(
     async (index) => {
-      const wallet = walletRef.current;
-      if (!wallet) throw new Error("SDK not initialized");
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
       setState((prev2) => ({
         ...prev2,
         busy: true,
         status: "Creating account..."
       }));
       try {
-        const account = await wallet.accounts.create(index);
-        const accounts = await wallet.accounts.list();
-        const activeAccount = await wallet.accounts.getActive();
-        const activeAccountIndex = await wallet.accounts.getActiveIndex();
+        const account = await unlink.accounts.create(index);
+        const accounts = await unlink.accounts.list();
+        const activeAccount = await unlink.accounts.getActive();
+        const activeAccountIndex = await unlink.accounts.getActiveIndex();
         setState((prev2) => ({
           ...prev2,
           accounts,
@@ -57230,7 +57497,7 @@ function UnlinkProvider({
           error: null
         }));
         if (autoSync && accounts.length === 1) {
-          wallet.startAutoSync(syncInterval);
+          unlink.startAutoSync(syncInterval);
         }
         return account;
       } catch (err) {
@@ -57246,22 +57513,22 @@ function UnlinkProvider({
     [autoSync, syncInterval]
   );
   const switchAccount = useCallback(async (index) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
     setState((prev2) => ({
       ...prev2,
       busy: true,
       status: "Switching account..."
     }));
     try {
-      await wallet.accounts.setActive(index);
-      const activeAccount = await wallet.accounts.getActive();
+      await unlink.accounts.setActive(index);
+      const activeAccount = await unlink.accounts.getActive();
       let notes = [];
       let balances = {};
       if (activeAccount) {
-        const noteRecords = await wallet.getNotes();
+        const noteRecords = await unlink.getNotes();
         notes = convertNotes(noteRecords);
-        balances = await wallet.getBalances();
+        balances = await unlink.getBalances();
       }
       setState((prev2) => ({
         ...prev2,
@@ -57283,58 +57550,64 @@ function UnlinkProvider({
       throw err;
     }
   }, []);
-  const send = useCallback(async (params) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
-    if (params.length === 0) {
-      throw new Error("At least one transfer is required");
-    }
-    setState((prev2) => ({
-      ...prev2,
-      busy: true,
-      status: params.length > 1 ? `Sending (${params.length} transfers)...` : "Sending..."
-    }));
-    try {
-      const result = await wallet.transfer({
-        transfers: params.map((t) => ({
-          token: t.token,
-          recipient: t.recipient,
-          amount: t.amount
-        }))
-      });
-      setState((prev2) => ({
-        ...prev2,
-        busy: false,
-        status: params.length > 1 ? `Transfer submitted (${params.length} transfers)` : "Transfer submitted",
-        pendingTransfers: [
-          ...prev2.pendingTransfers,
-          ...params.map((t, i) => ({
-            txId: `${result.relayId}-${i}`,
-            status: "pending",
-            chainId: wallet.chainId,
-            token: t.token,
-            amount: t.amount,
-            recipient: t.recipient,
-            startedAt: Date.now()
-          }))
-        ],
-        error: null
-      }));
-      return result;
-    } catch (err) {
+  const send = useCallback(
+    async (params, overrides) => {
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      if (params.length === 0) {
+        throw new Error("At least one transfer is required");
+      }
       setState((prev2) => ({
         ...prev2,
-        busy: false,
-        status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
-        error: createUnlinkError(err, "send")
+        busy: true,
+        status: params.length > 1 ? `Sending (${params.length} transfers)...` : "Sending..."
       }));
-      throw err;
-    }
-  }, []);
-  const planTransfer = useCallback(async (params) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
-    return wallet.planTransfer({
+      try {
+        const result = await unlink.send(
+          {
+            transfers: params.map((t) => ({
+              token: t.token,
+              recipient: t.recipient,
+              amount: t.amount
+            }))
+          },
+          overrides
+        );
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: params.length > 1 ? `Transfer submitted (${params.length} transfers)` : "Transfer submitted",
+          pendingSends: [
+            ...prev2.pendingSends,
+            ...params.map((t, i) => ({
+              txId: `${result.relayId}-${i}`,
+              status: "pending",
+              chainId: unlink.chainId,
+              token: t.token,
+              amount: t.amount,
+              recipient: t.recipient,
+              startedAt: Date.now()
+            }))
+          ],
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "send")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const planSend = useCallback(async (params) => {
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
+    return unlink.planSend({
       transfers: params.map((t) => ({
         token: t.token,
         recipient: t.recipient,
@@ -57342,37 +57615,40 @@ function UnlinkProvider({
       }))
     });
   }, []);
-  const executeTransfer = useCallback(async (plans) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
-    setState((prev2) => ({
-      ...prev2,
-      busy: true,
-      status: "Executing transfer..."
-    }));
-    try {
-      const result = await wallet.executeTransfer(plans);
+  const executeSend = useCallback(
+    async (plans, overrides) => {
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
       setState((prev2) => ({
         ...prev2,
-        busy: false,
-        status: "Transfer executed",
-        error: null
-      }));
-      return result;
-    } catch (err) {
-      setState((prev2) => ({
-        ...prev2,
-        busy: false,
-        status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
-        error: createUnlinkError(err, "executeTransfer")
+        busy: true,
+        status: "Executing send..."
       }));
-      throw err;
-    }
-  }, []);
-  const requestDeposit = useCallback(
+      try {
+        const result = await unlink.executeSend(plans, overrides);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: "Send executed",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "executeSend")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const deposit2 = useCallback(
     async (params) => {
-      const wallet = walletRef.current;
-      if (!wallet) throw new Error("SDK not initialized");
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
       if (params.length === 0) {
         throw new Error("At least one deposit is required");
       }
@@ -57386,7 +57662,7 @@ function UnlinkProvider({
         status: params.length > 1 ? `Preparing deposit (${params.length} tokens)...` : "Preparing deposit..."
       }));
       try {
-        const result = await wallet.deposit({
+        const result = await unlink.deposit({
           depositor,
           deposits: params.map((d2) => ({
             token: d2.token,
@@ -57404,7 +57680,7 @@ function UnlinkProvider({
               status: "pending",
               token: c.token,
               amount: c.amount,
-              chainId: wallet.chainId,
+              chainId: unlink.chainId,
               commitment: c.commitment,
               startedAt: Date.now()
             }))
@@ -57417,17 +57693,17 @@ function UnlinkProvider({
           ...prev2,
           busy: false,
           status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
-          error: createUnlinkError(err, "requestDeposit")
+          error: createUnlinkError(err, "deposit")
         }));
         throw err;
       }
     },
     []
   );
-  const requestWithdraw = useCallback(
-    async (params) => {
-      const wallet = walletRef.current;
-      if (!wallet) throw new Error("SDK not initialized");
+  const withdraw = useCallback(
+    async (params, overrides) => {
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
       if (params.length === 0) {
         throw new Error("At least one withdrawal is required");
       }
@@ -57437,13 +57713,16 @@ function UnlinkProvider({
         status: params.length > 1 ? `Processing withdrawal (${params.length} tokens)...` : "Withdrawing..."
       }));
       try {
-        const result = await wallet.withdraw({
-          withdrawals: params.map((w) => ({
-            token: w.token,
-            amount: w.amount,
-            recipient: w.recipient
-          }))
-        });
+        const result = await unlink.withdraw(
+          {
+            withdrawals: params.map((w) => ({
+              token: w.token,
+              amount: w.amount,
+              recipient: w.recipient
+            }))
+          },
+          overrides
+        );
         setState((prev2) => ({
           ...prev2,
           busy: false,
@@ -57453,7 +57732,7 @@ function UnlinkProvider({
             ...params.map((w, i) => ({
               txId: `${result.relayId}-${i}`,
               status: "pending",
-              chainId: wallet.chainId,
+              chainId: unlink.chainId,
               token: w.token,
               amount: w.amount,
               recipient: w.recipient,
@@ -57468,7 +57747,37 @@ function UnlinkProvider({
           ...prev2,
           busy: false,
           status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
-          error: createUnlinkError(err, "requestWithdraw")
+          error: createUnlinkError(err, "withdraw")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const interact = useCallback(
+    async (params) => {
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Executing interaction..."
+      }));
+      try {
+        const result = await unlink.interact(params);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: "Interaction submitted",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "interact")
         }));
         throw err;
       }
@@ -57477,9 +57786,9 @@ function UnlinkProvider({
   );
   const planWithdraw = useCallback(
     async (params) => {
-      const wallet = walletRef.current;
-      if (!wallet) throw new Error("SDK not initialized");
-      return wallet.planWithdraw({
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      return unlink.planWithdraw({
         withdrawals: params.map((w) => ({
           token: w.token,
           amount: w.amount,
@@ -57489,37 +57798,183 @@ function UnlinkProvider({
     },
     []
   );
-  const executeWithdraw = useCallback(async (plans) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
+  const executeWithdraw = useCallback(
+    async (plans, overrides) => {
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: plans.length > 1 ? `Executing withdrawal (${plans.length} tokens)...` : "Executing withdrawal..."
+      }));
+      try {
+        const result = await unlink.executeWithdraw(plans, overrides);
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: plans.length > 1 ? `Withdrawal executed (${plans.length} tokens)` : "Withdrawal executed",
+          error: null
+        }));
+        return result;
+      } catch (err) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "executeWithdraw")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
+  const createBurner = useCallback(async (index) => {
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
     setState((prev2) => ({
       ...prev2,
       busy: true,
-      status: plans.length > 1 ? `Executing withdrawal (${plans.length} tokens)...` : "Executing withdrawal..."
+      status: `Creating burner ${index}...`
     }));
     try {
-      const result = await wallet.executeWithdraw(plans);
+      const burner = await unlink.burner.addressOf(index);
       setState((prev2) => ({
         ...prev2,
+        burners: [
+          ...prev2.burners.filter((existing) => existing.index !== burner.index),
+          burner
+        ],
         busy: false,
-        status: plans.length > 1 ? `Withdrawal executed (${plans.length} tokens)` : "Withdrawal executed",
+        status: `Burner ${index} ready`,
         error: null
       }));
-      return result;
+      return burner;
     } catch (err) {
       setState((prev2) => ({
         ...prev2,
         busy: false,
         status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
-        error: createUnlinkError(err, "executeWithdraw")
+        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 unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Sending burner transaction..."
+      }));
+      try {
+        const result = await unlink.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 unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Funding burner..."
+      }));
+      try {
+        const result = await unlink.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 unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      setState((prev2) => ({
+        ...prev2,
+        busy: true,
+        status: "Sweeping burner to pool..."
+      }));
+      try {
+        const result = await unlink.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 unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      return unlink.burner.getTokenBalance(address, token);
+    },
+    []
+  );
+  const burnerGetBalance = useCallback(
+    async (address) => {
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
+      return unlink.burner.getBalance(address);
+    },
+    []
+  );
   const refresh = useCallback(async () => {
-    const wallet = walletRef.current;
-    if (!wallet) return;
-    const activeAccount = await wallet.accounts.getActive();
+    const unlink = unlinkRef.current;
+    if (!unlink) return;
+    const activeAccount = await unlink.accounts.getActive();
     if (!activeAccount) return;
     setState((prev2) => ({
       ...prev2,
@@ -57527,8 +57982,8 @@ function UnlinkProvider({
       status: "Syncing..."
     }));
     try {
-      await wallet.sync();
-      await refreshState(wallet);
+      await unlink.sync();
+      await refreshState(unlink);
       setState((prev2) => ({
         ...prev2,
         busy: false,
@@ -57545,9 +58000,9 @@ function UnlinkProvider({
     }
   }, [refreshState]);
   const forceResync = useCallback(async () => {
-    const wallet = walletRef.current;
-    if (!wallet) return;
-    const activeAccount = await wallet.accounts.getActive();
+    const unlink = unlinkRef.current;
+    if (!unlink) return;
+    const activeAccount = await unlink.accounts.getActive();
     if (!activeAccount) return;
     setState((prev2) => ({
       ...prev2,
@@ -57555,8 +58010,8 @@ function UnlinkProvider({
       status: "Resyncing..."
     }));
     try {
-      await wallet.sync({ forceFullResync: true });
-      await refreshState(wallet);
+      await unlink.sync({ forceFullResync: true });
+      await refreshState(unlink);
       setState((prev2) => ({
         ...prev2,
         busy: false,
@@ -57576,9 +58031,9 @@ function UnlinkProvider({
     setState((prev2) => ({ ...prev2, error: null }));
   }, []);
   const getTxStatus = useCallback(async (txId) => {
-    const wallet = walletRef.current;
-    if (!wallet) throw new Error("SDK not initialized");
-    const response = await wallet.getTxStatus(txId);
+    const unlink = unlinkRef.current;
+    if (!unlink) throw new Error("SDK not initialized");
+    const response = await unlink.getTxStatus(txId);
     return {
       txId: response.id,
       state: response.state,
@@ -57589,8 +58044,8 @@ function UnlinkProvider({
   }, []);
   const waitForConfirmation = useCallback(
     async (txId, options) => {
-      const wallet = walletRef.current;
-      if (!wallet) throw new Error("SDK not initialized");
+      const unlink = unlinkRef.current;
+      if (!unlink) throw new Error("SDK not initialized");
       const timeout2 = options?.timeout ?? DEFAULT_CONFIRMATION_TIMEOUT_MS;
       const startTime3 = Date.now();
       let delay2 = CONFIRMATION_POLL_INTERVAL_MS;
@@ -57631,7 +58086,6 @@ function UnlinkProvider({
   const value = useMemo(
     () => ({
       ...state,
-      chainId,
       // Wallet actions
       createWallet,
       importWallet,
@@ -57640,16 +58094,26 @@ function UnlinkProvider({
       // Account actions
       createAccount,
       switchAccount,
-      // Transfer actions
+      // Send actions
       send,
-      planTransfer,
-      executeTransfer,
+      planSend,
+      executeSend,
       // Deposit actions
-      requestDeposit,
+      deposit: deposit2,
       // Withdraw actions
-      requestWithdraw,
+      withdraw,
+      // Interact actions
+      interact,
       planWithdraw,
       executeWithdraw,
+      // Burner actions
+      createBurner,
+      removeBurner,
+      burnerSend,
+      burnerFund,
+      burnerSweepToPool,
+      burnerGetTokenBalance,
+      burnerGetBalance,
       // Sync actions
       refresh,
       forceResync,
@@ -57661,7 +58125,6 @@ function UnlinkProvider({
     }),
     [
       state,
-      chainId,
       createWallet,
       importWallet,
       exportMnemonic,
@@ -57669,12 +58132,20 @@ function UnlinkProvider({
       createAccount,
       switchAccount,
       send,
-      planTransfer,
-      executeTransfer,
-      requestDeposit,
-      requestWithdraw,
+      planSend,
+      executeSend,
+      deposit2,
+      withdraw,
+      interact,
       planWithdraw,
       executeWithdraw,
+      createBurner,
+      removeBurner,
+      burnerSend,
+      burnerFund,
+      burnerSweepToPool,
+      burnerGetTokenBalance,
+      burnerGetBalance,
       refresh,
       forceResync,
       clearError,
@@ -57698,20 +58169,20 @@ function useUnlink() {
 // src/useUnlinkHistory.ts
 import { useCallback as useCallback2, useEffect as useEffect2, useState as useState2 } from "react";
 function useUnlinkHistory(options) {
-  const { wallet, activeAccount } = useUnlink();
+  const { unlink, activeAccount } = useUnlink();
   const includeSelfSends = options?.includeSelfSends;
   const [history, setHistory] = useState2([]);
   const [loading, setLoading] = useState2(true);
   const [error, setError] = useState2(null);
   const fetchHistory = useCallback2(async () => {
-    if (!wallet || !activeAccount) {
+    if (!unlink || !activeAccount) {
       setHistory([]);
       setLoading(false);
       return;
     }
     try {
       setLoading(true);
-      const entries = await wallet.getHistory({
+      const entries = await unlink.getHistory({
         includeSelfSends
       });
       setHistory(entries);
@@ -57721,19 +58192,19 @@ function useUnlinkHistory(options) {
     } finally {
       setLoading(false);
     }
-  }, [wallet, activeAccount, includeSelfSends]);
+  }, [unlink, activeAccount, includeSelfSends]);
   useEffect2(() => {
     void fetchHistory();
   }, [fetchHistory]);
   useEffect2(() => {
-    if (!wallet) return;
-    const unsubscribe = wallet.on((event) => {
+    if (!unlink) return;
+    const unsubscribe = unlink.on((event) => {
       if (event.type === "notes-updated") {
         void fetchHistory();
       }
     });
     return unsubscribe;
-  }, [wallet, fetchHistory]);
+  }, [unlink, fetchHistory]);
   const refresh = useCallback2(async () => {
     await fetchHistory();
   }, [fetchHistory]);
@@ -57766,7 +58237,7 @@ function useUnlinkBalances() {
 // src/useTxStatus.ts
 import { useCallback as useCallback3, useEffect as useEffect3, useRef as useRef2, useState as useState3 } from "react";
 function useTxStatus(txId) {
-  const { getTxStatus, wallet } = useUnlink();
+  const { getTxStatus, unlink } = useUnlink();
   const [state, setState] = useState3(null);
   const [txHash, setTxHash] = useState3(null);
   const [blockNumber, setBlockNumber] = useState3(null);
@@ -57776,7 +58247,7 @@ function useTxStatus(txId) {
   currentTxIdRef.current = txId;
   const refresh = useCallback3(async () => {
     const targetTxId = currentTxIdRef.current;
-    if (!targetTxId || !wallet) return;
+    if (!targetTxId || !unlink) return;
     setIsLoading(true);
     try {
       const status = await getTxStatus(targetTxId);
@@ -57793,13 +58264,13 @@ function useTxStatus(txId) {
         setIsLoading(false);
       }
     }
-  }, [wallet, getTxStatus]);
+  }, [unlink, getTxStatus]);
   useEffect3(() => {
-    if (txId && wallet) {
-      wallet.trackTx(txId);
+    if (txId && unlink) {
+      unlink.trackTx(txId);
       void refresh();
       return () => {
-        wallet.untrackTx(txId);
+        unlink.untrackTx(txId);
       };
     } else {
       setState(null);
@@ -57807,10 +58278,10 @@ function useTxStatus(txId) {
       setBlockNumber(null);
       setError(null);
     }
-  }, [txId, wallet, refresh]);
+  }, [txId, unlink, refresh]);
   useEffect3(() => {
-    if (!wallet || !txId) return;
-    const unsubscribe = wallet.on((event) => {
+    if (!unlink || !txId) return;
+    const unsubscribe = unlink.on((event) => {
       if (event.type === "tx-status-changed" && event.txId === txId) {
         setState(event.state);
         setTxHash(event.txHash ?? null);
@@ -57819,7 +58290,7 @@ function useTxStatus(txId) {
       }
     });
     return unsubscribe;
-  }, [wallet, txId]);
+  }, [unlink, txId]);
   return { state, txHash, blockNumber, error, isLoading, refresh };
 }
 
@@ -57836,7 +58307,7 @@ function useOperationMutation(operation) {
   const [isError2, setIsError] = useState4(false);
   const pendingRef = useRef3(false);
   const generationRef = useRef3(0);
-  const mutate = useCallback4(
+  const execute = useCallback4(
     async (input) => {
       if (pendingRef.current) {
         throw new Error("Operation already in progress");
@@ -57879,36 +58350,94 @@ function useOperationMutation(operation) {
     setIsSuccess(false);
     setIsError(false);
   }, []);
-  return { mutate, data, isPending, isSuccess, isError: isError2, error, reset };
+  return { execute, data, isPending, isSuccess, isError: isError2, error, reset };
 }
 
 // src/useDeposit.ts
 function useDeposit() {
-  const { requestDeposit } = useUnlink();
+  const { deposit: deposit2 } = useUnlink();
   const op = useCallback5(
-    (params) => requestDeposit(params),
-    [requestDeposit]
+    (params) => deposit2(params),
+    [deposit2]
   );
-  return useOperationMutation(op);
+  const { execute, ...rest } = useOperationMutation(op);
+  return { deposit: execute, ...rest };
 }
 
-// src/useTransfer.ts
+// src/useSend.ts
 import { useCallback as useCallback6 } from "react";
-function useTransfer() {
+function useSend(overrides) {
   const { send } = useUnlink();
-  const op = useCallback6((params) => send(params), [send]);
-  return useOperationMutation(op);
+  const op = useCallback6(
+    (params) => send(params, overrides),
+    [send, overrides]
+  );
+  const { execute, ...rest } = useOperationMutation(op);
+  return { send: execute, ...rest };
 }
 
 // src/useWithdraw.ts
 import { useCallback as useCallback7 } from "react";
-function useWithdraw() {
-  const { requestWithdraw } = useUnlink();
+function useWithdraw(overrides) {
+  const { withdraw } = useUnlink();
   const op = useCallback7(
-    (params) => requestWithdraw(params),
-    [requestWithdraw]
+    (params) => withdraw(params, overrides),
+    [withdraw, overrides]
+  );
+  const { execute, ...rest } = useOperationMutation(op);
+  return { withdraw: execute, ...rest };
+}
+
+// src/useInteract.ts
+import { useCallback as useCallback8 } from "react";
+function useInteract() {
+  const { interact } = useUnlink();
+  const op = useCallback8(
+    (params) => interact(params),
+    [interact]
+  );
+  const { execute, ...rest } = useOperationMutation(op);
+  return { interact: execute, ...rest };
+}
+
+// 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]
   );
-  return useOperationMutation(op);
+  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,
@@ -57917,7 +58446,10 @@ export {
   TimeoutError2 as TimeoutError,
   TransactionFailedError,
   UnlinkProvider,
+  approve,
+  buildApproveCall,
   computeBalances,
+  contract,
   decodeAddress,
   encodeAddress,
   formatAmount,
@@ -57926,9 +58458,12 @@ export {
   parseZkAddress,
   randomHex,
   shortenHex,
+  toCall,
+  useBurner,
   useDeposit,
+  useInteract,
   useOperationMutation,
-  useTransfer,
+  useSend,
   useTxStatus,
   useUnlink,
   useUnlinkBalance,