@unlink-xyz/react 0.1.5 → 0.1.6

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"}`
     );
   }
 }
@@ -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,85 @@ 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 frostUrl = parseOptionalString(
+    chain2,
+    "frostUrl",
+    raw.frostUrl
+  )?.replace(/\/+$/, "");
   const artifactBaseUrl = parseOptionalString(
-    env22,
+    chain2,
     "artifactBaseUrl",
     raw.artifactBaseUrl
   )?.replace(/\/+$/, "");
   return {
+    chainId,
     gatewayUrl,
+    ...frostUrl !== void 0 ? { frostUrl } : {},
     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(/\/+$/, "");
@@ -53316,6 +53350,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 +53473,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);
@@ -55640,6 +55782,16 @@ function createAdapterService(deps) {
       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));
@@ -56536,34 +56688,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;
@@ -56572,14 +56727,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 _UnlinkWallet(sdk, chainId, poolAddress);
   }
   // ===== Seed Lifecycle =====
   /** Seed management (create, import, export, delete mnemonic). */
@@ -56935,8 +57090,10 @@ var initialState = {
   accounts: [],
   activeAccount: null,
   activeAccountIndex: null,
+  chainId: null,
   notes: [],
   balances: {},
+  burners: [],
   pendingDeposits: [],
   pendingTransfers: [],
   pendingWithdrawals: [],
@@ -56954,14 +57111,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);
@@ -56991,13 +57149,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;
@@ -57011,14 +57169,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 } : {}
           }
@@ -57059,6 +57216,7 @@ function UnlinkProvider({
           accounts,
           activeAccount,
           activeAccountIndex,
+          chainId: wallet.chainId,
           notes,
           balances,
           ready: true,
@@ -57069,7 +57227,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);
           }
@@ -57103,13 +57261,13 @@ function UnlinkProvider({
       walletRef.current?.stopAutoSync();
     };
   }, [
+    chain2,
     chainId,
     autoSync,
     syncInterval,
     refreshState,
     refreshAccounts,
     gatewayUrl,
-    environment,
     poolAddress,
     proverKey
   ]);
@@ -57157,6 +57315,7 @@ function UnlinkProvider({
         accounts,
         activeAccount,
         activeAccountIndex,
+        burners: [],
         busy: false,
         status: accounts.length > 0 ? "Wallet imported" : "Wallet imported - create an account",
         syncError: null,
@@ -57191,6 +57350,7 @@ function UnlinkProvider({
         activeAccountIndex: null,
         notes: [],
         balances: {},
+        burners: [],
         busy: false,
         status: "Wallet cleared",
         syncError: null,
@@ -57283,54 +57443,60 @@ 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 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: 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;
-    }
-  }, []);
+      try {
+        const result = await wallet.transfer(
+          {
+            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",
+          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) {
+        setState((prev2) => ({
+          ...prev2,
+          busy: false,
+          status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
+          error: createUnlinkError(err, "send")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
   const planTransfer = useCallback(async (params) => {
     const wallet = walletRef.current;
     if (!wallet) throw new Error("SDK not initialized");
@@ -57342,33 +57508,36 @@ 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);
-      setState((prev2) => ({
-        ...prev2,
-        busy: false,
-        status: "Transfer executed",
-        error: null
-      }));
-      return result;
-    } catch (err) {
+  const executeTransfer = useCallback(
+    async (plans, overrides) => {
+      const wallet = walletRef.current;
+      if (!wallet) throw new Error("SDK not initialized");
       setState((prev2) => ({
         ...prev2,
-        busy: false,
-        status: `Error: ${err instanceof Error ? err.message : "Unknown"}`,
-        error: createUnlinkError(err, "executeTransfer")
+        busy: true,
+        status: "Executing transfer..."
       }));
-      throw err;
-    }
-  }, []);
+      try {
+        const result = await wallet.executeTransfer(plans, overrides);
+        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")
+        }));
+        throw err;
+      }
+    },
+    []
+  );
   const requestDeposit = useCallback(
     async (params) => {
       const wallet = walletRef.current;
@@ -57425,7 +57594,7 @@ function UnlinkProvider({
     []
   );
   const requestWithdraw = useCallback(
-    async (params) => {
+    async (params, overrides) => {
       const wallet = walletRef.current;
       if (!wallet) throw new Error("SDK not initialized");
       if (params.length === 0) {
@@ -57437,13 +57606,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 wallet.withdraw(
+          {
+            withdrawals: params.map((w) => ({
+              token: w.token,
+              amount: w.amount,
+              recipient: w.recipient
+            }))
+          },
+          overrides
+        );
         setState((prev2) => ({
           ...prev2,
           busy: false,
@@ -57475,6 +57647,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;
@@ -57489,33 +57691,179 @@ function UnlinkProvider({
     },
     []
   );
-  const executeWithdraw = useCallback(async (plans) => {
+  const executeWithdraw = useCallback(
+    async (plans, overrides) => {
+      const wallet = walletRef.current;
+      if (!wallet) 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 wallet.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 wallet = walletRef.current;
     if (!wallet) 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 wallet.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 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;
@@ -57631,7 +57979,6 @@ function UnlinkProvider({
   const value = useMemo(
     () => ({
       ...state,
-      chainId,
       // Wallet actions
       createWallet,
       importWallet,
@@ -57648,8 +57995,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,
@@ -57661,7 +58018,6 @@ function UnlinkProvider({
     }),
     [
       state,
-      chainId,
       createWallet,
       importWallet,
       exportMnemonic,
@@ -57673,8 +58029,16 @@ function UnlinkProvider({
       executeTransfer,
       requestDeposit,
       requestWithdraw,
+      executeAdapter,
       planWithdraw,
       executeWithdraw,
+      createBurner,
+      removeBurner,
+      burnerSend,
+      burnerFund,
+      burnerSweepToPool,
+      burnerGetTokenBalance,
+      burnerGetBalance,
       refresh,
       forceResync,
       clearError,
@@ -57836,7 +58200,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,7 +58243,7 @@ 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
@@ -57894,22 +58258,76 @@ function useDeposit() {
 
 // src/useTransfer.ts
 import { useCallback as useCallback6 } from "react";
-function useTransfer() {
+function useTransfer(overrides) {
   const { send } = useUnlink();
-  const op = useCallback6((params) => send(params), [send]);
+  const op = useCallback6(
+    (params) => send(params, overrides),
+    [send, overrides]
+  );
   return useOperationMutation(op);
 }
 
 // src/useWithdraw.ts
 import { useCallback as useCallback7 } from "react";
-function useWithdraw() {
+function useWithdraw(overrides) {
   const { requestWithdraw } = useUnlink();
   const op = useCallback7(
-    (params) => requestWithdraw(params),
-    [requestWithdraw]
+    (params) => requestWithdraw(params, overrides),
+    [requestWithdraw, overrides]
   );
   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,
@@ -57926,6 +58344,8 @@ export {
   parseZkAddress,
   randomHex,
   shortenHex,
+  useAdapter,
+  useBurner,
   useDeposit,
   useOperationMutation,
   useTransfer,