@unlink-xyz/core 0.1.6 → 0.1.8

package/dist/browser/wallet/index.js

@@ -3555,7 +3555,7 @@ var init_fs = __esm({
 init_process();
 init_buffer();
 
-// wallet/unlink-wallet.ts
+// wallet/unlink.ts
 init_process();
 init_buffer();
 
@@ -3755,6 +3755,11 @@ function parseChainConfig(chain2, value) {
     "artifactVersion",
     raw.artifactVersion
   ).replace(/^\/+|\/+$/g, "");
+  const adapterAddress = parseOptionalString(
+    chain2,
+    "adapterAddress",
+    raw.adapterAddress
+  );
   const frostUrl = parseOptionalString(
     chain2,
     "frostUrl",
@@ -3765,13 +3770,33 @@ function parseChainConfig(chain2, value) {
     "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 fetchChainConfig(chain2) {
@@ -28519,8 +28544,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 });
   }
   /**
@@ -28546,9 +28571,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 });
   }
   /**
@@ -28593,12 +28618,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) => {
@@ -28616,7 +28641,7 @@ var PreparedTopicFilter = class {
           return value;
         });
       }));
-      return contract.interface.encodeFilterTopics(fragment, resolvedArgs);
+      return contract2.interface.encodeFilterTopics(fragment, resolvedArgs);
     })();
   }
   getTopicFilter() {
@@ -28665,14 +28690,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) {
@@ -28685,27 +28710,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));
   };
@@ -28713,7 +28738,7 @@ function buildWrappedFallback(contract) {
     return await send(overrides);
   };
   defineProperties(method, {
-    _contract: contract,
+    _contract: contract2,
     estimateGas,
     populateTransaction,
     send,
@@ -28721,9 +28746,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 }
@@ -28736,16 +28761,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) {
@@ -28756,19 +28781,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";
@@ -28776,12 +28801,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);
@@ -28791,8 +28816,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,
@@ -28805,7 +28830,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 }
@@ -28815,9 +28840,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 }
@@ -28825,11 +28850,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
   });
@@ -28837,7 +28862,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 }
@@ -28849,16 +28874,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)) {
@@ -28866,7 +28891,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;
     };
@@ -28885,7 +28910,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];
     }
@@ -28922,36 +28947,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) : [];
-        emit2(contract, event, args, (listener2) => {
-          return new ContractEventPayload(contract, listener2, event, _foundFragment, log);
+        const args = fragment ? contract2.interface.decodeEventLog(fragment, log.data, log.topics) : [];
+        emit2(contract2, event, args, (listener2) => {
+          return new ContractEventPayload(contract2, listener2, event, _foundFragment, log);
         });
       } else {
-        emit2(contract, event, [], (listener2) => {
-          return new ContractUnknownEventPayload(contract, listener2, event, log);
+        emit2(contract2, event, [], (listener2) => {
+          return new ContractUnknownEventPayload(contract2, listener2, event, log);
         });
       }
     };
@@ -28977,9 +29002,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;
   }
@@ -28990,23 +29015,23 @@ async function _emit(contract, event, args, payloadFunc) {
       passArgs.push(payloadFunc(once2 ? null : listener));
     }
     try {
-      listener.call(contract, ...passArgs);
+      listener.call(contract2, ...passArgs);
     } catch (error) {
     }
     return !once2;
   });
   if (sub2.listeners.length === 0) {
     sub2.stop();
-    getInternal(contract).subs.delete(sub2.tag);
+    getInternal(contract2).subs.delete(sub2.tag);
   }
   return count > 0;
 }
-async function emit2(contract, event, args, payloadFunc) {
+async function emit2(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;
 }
@@ -29432,8 +29457,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() {
@@ -29734,7 +29759,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)",
@@ -29743,21 +29768,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 };
@@ -29829,10 +29854,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) {
@@ -54558,26 +54583,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) {
@@ -54597,41 +54630,41 @@ 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 seenReshieldTokens = /* @__PURE__ */ new Set();
-      for (const r2 of reshieldSpecs) {
+      const seenReceiveTokens = /* @__PURE__ */ new Set();
+      for (const r2 of receiveSpecs) {
         const lower = r2.token.toLowerCase();
-        if (seenReshieldTokens.has(lower)) {
+        if (seenReceiveTokens.has(lower)) {
           throw new AdapterError(
-            `duplicate reshield token ${r2.token}; each reshield must target a unique token`
+            `duplicate receive token ${r2.token}; each receive must target a unique token`
           );
         }
-        seenReshieldTokens.add(lower);
+        seenReceiveTokens.add(lower);
       }
       const account = overrides?.account ?? await deps.requireActiveAccount();
       const signer = overrides?.signer ?? deps.requireSigner(account);
@@ -54641,19 +54674,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,
@@ -54670,7 +54703,7 @@ function createAdapterService(deps) {
       });
       const withdrawalPlans = planWithdrawalsImpl(
         notes,
-        inputs.map((input) => ({
+        spendInputs.map((input) => ({
           token: input.token,
           amount: input.amount,
           recipient: adapterAddress
@@ -54753,7 +54786,7 @@ function createAdapterService(deps) {
         adapterCalldata,
         historyPreview: {
           kind: "Withdraw",
-          amounts: inputs.map((input) => ({
+          amounts: spendInputs.map((input) => ({
             token: input.token,
             delta: (-input.amount).toString()
           }))
@@ -54775,6 +54808,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);
@@ -54822,8 +54858,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) {
@@ -54842,6 +54878,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");
@@ -54852,17 +54894,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 };
   }
@@ -55572,21 +55617,27 @@ async function createBrowserWalletSDK(options) {
   };
 }
 
-// wallet/unlink-wallet.ts
-var UnlinkWallet = class _UnlinkWallet {
+// wallet/unlink.ts
+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 chain config (if using `chain` instead of explicit URLs)
@@ -55598,12 +55649,14 @@ var UnlinkWallet = class _UnlinkWallet {
     let chainId;
     let gatewayUrl;
     let poolAddress;
+    let adapterAddress;
     let proverConfig = config2.prover;
     if ("chain" in config2) {
       const chainConfig = await fetchChainConfig(config2.chain);
       chainId = chainConfig.chainId;
       gatewayUrl = chainConfig.gatewayUrl;
       poolAddress = config2.poolAddress ?? chainConfig.poolAddress;
+      adapterAddress = config2.adapterAddress ?? chainConfig.adapterAddress;
       proverConfig = {
         artifactSource: {
           baseUrl: config2.prover?.artifactSource?.baseUrl ?? chainConfig.artifactBaseUrl,
@@ -55615,6 +55668,7 @@ var UnlinkWallet = class _UnlinkWallet {
       chainId = config2.chainId;
       gatewayUrl = config2.gatewayUrl;
       poolAddress = config2.poolAddress;
+      adapterAddress = config2.adapterAddress;
       if (typeof window !== "undefined" && !config2.prover?.artifactSource?.version) {
         throw new InitializationError(
           "prover.artifactSource.version is required in browser when using explicit gatewayUrl mode. Use chain mode or provide a pinned artifact version."
@@ -55635,7 +55689,7 @@ var UnlinkWallet = class _UnlinkWallet {
         autoSync: config2.autoSync
       }
     );
-    return new _UnlinkWallet(sdk, chainId, poolAddress);
+    return new _Unlink(sdk, chainId, poolAddress, adapterAddress ?? "");
   }
   // ===== Seed Lifecycle =====
   /** Seed management (create, import, export, delete mnemonic). */
@@ -55666,10 +55720,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,
@@ -55680,9 +55734,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,
@@ -55692,8 +55746,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 },
@@ -55842,31 +55896,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.
@@ -55914,6 +55968,7 @@ var defaultRng = (n2) => {
   }
   return globalThis.crypto.getRandomValues(new Uint8Array(n2));
 };
+var UnlinkWallet = Unlink;
 
 // utils/amounts.ts
 init_process();
@@ -55970,6 +56025,7 @@ export {
   HttpError,
   InitializationError,
   ProofError,
+  Unlink,
   UnlinkWallet,
   ValidationError,
   computeBalances,