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

package/dist/wallet/index.js

@@ -1827,63 +1827,110 @@ var Runtime = {
 
 // config.ts
 var CONFIG_URL = "https://config.unlink.xyz/networks.json";
-function parseRequiredString(env, field, value) {
+function parseRequiredString(chain, field, value) {
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new InitializationError(
-      `Invalid SDK config for ${env}: ${field} must be a non-empty string`
+      `Invalid SDK config for ${chain}: ${field} must be a non-empty string`
     );
   }
   return value.trim();
 }
-function parseOptionalString(env, field, value) {
+function parseOptionalString(chain, field, value) {
   if (value === void 0) return void 0;
   if (typeof value !== "string" || value.trim().length === 0) {
     throw new InitializationError(
-      `Invalid SDK config for ${env}: ${field} must be a non-empty string when provided`
+      `Invalid SDK config for ${chain}: ${field} must be a non-empty string when provided`
     );
   }
   return value.trim();
 }
-function parseEnvironmentConfig(env, value) {
+function parseRequiredChainId(chain, value) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    throw new InitializationError(
+      `Invalid SDK config for ${chain}: chainId must be a positive integer`
+    );
+  }
+  return value;
+}
+function parseChainConfig(chain, value) {
   if (value === null || typeof value !== "object" || Array.isArray(value)) {
     throw new InitializationError(
-      `Invalid SDK config for ${env}: expected object`
+      `Invalid SDK config for ${chain}: expected object`
     );
   }
   const raw = value;
+  const chainId = parseRequiredChainId(chain, raw.chainId);
   const gatewayUrl = parseRequiredString(
-    env,
+    chain,
     "gatewayUrl",
     raw.gatewayUrl
   ).replace(/\/+$/, "");
-  const poolAddress = parseRequiredString(env, "poolAddress", raw.poolAddress);
+  const poolAddress = parseRequiredString(
+    chain,
+    "poolAddress",
+    raw.poolAddress
+  );
   const artifactVersion = parseRequiredString(
-    env,
+    chain,
     "artifactVersion",
     raw.artifactVersion
   ).replace(/^\/+|\/+$/g, "");
+  const adapterAddress = parseOptionalString(
+    chain,
+    "adapterAddress",
+    raw.adapterAddress
+  );
+  const frostUrl = parseOptionalString(
+    chain,
+    "frostUrl",
+    raw.frostUrl
+  )?.replace(/\/+$/, "");
   const artifactBaseUrl = parseOptionalString(
-    env,
+    chain,
     "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 ${chain}: tokenAddresses must be an object`
+      );
+    }
+    tokenAddresses = {};
+    for (const [name, addr] of Object.entries(
+      raw.tokenAddresses
+    )) {
+      tokenAddresses[name] = parseRequiredString(
+        chain,
+        `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(env) {
+async function fetchChainConfig(chain) {
   const res = await fetch(CONFIG_URL);
   if (!res.ok) {
     throw new InitializationError(`Failed to fetch SDK config: ${res.status}`);
   }
   const config = await res.json();
-  if (!config[env]) {
-    throw new InitializationError(`Unknown environment: ${env}`);
+  if (!config[chain]) {
+    throw new InitializationError(
+      `Unknown chain: "${chain}". Supported chains: ${Object.keys(config).join(", ")}`
+    );
   }
-  return parseEnvironmentConfig(env, config[env]);
+  return parseChainConfig(chain, config[chain]);
 }
 function createServiceConfig(gatewayUrl) {
   const baseUrl = gatewayUrl.replace(/\/+$/, "");
@@ -2220,9 +2267,9 @@ var Hex = class _Hex {
 
 // keys/address.ts
 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(hex) {
   const bytes = Hex.toBytes(hex);
@@ -3970,29 +4017,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 delay = BASE_DELAY_MS * 2 ** attempt + Math.random() * 200;
+          await new Promise((r2) => setTimeout(r2, delay));
+          continue;
+        }
+        break;
       }
       if (!res.ok) {
         const body = await readErrorBodySafe(res);
@@ -4210,7 +4269,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"}`
     );
   }
 }
@@ -6206,6 +6265,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]
   }
 };
 
@@ -6225,7 +6392,7 @@ function getCircuitConfig(inputs, outputs) {
 }
 
 // prover/prover.ts
-var MAX_ARTIFACT_CACHE_ENTRIES = 8;
+var MAX_ARTIFACT_CACHE_ENTRIES = 16;
 var artifactCache = /* @__PURE__ */ new Map();
 function selectCircuit(inputs, outputs) {
   const config = getCircuitConfig(inputs, outputs);
@@ -8208,26 +8375,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) {
@@ -8247,32 +8422,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));
@@ -8281,19 +8466,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,
@@ -8310,7 +8495,7 @@ function createAdapterService(deps) {
       });
       const withdrawalPlans = planWithdrawalsImpl(
         notes,
-        inputs.map((input) => ({
+        spendInputs.map((input) => ({
           token: input.token,
           amount: input.amount,
           recipient: adapterAddress
@@ -8393,7 +8578,7 @@ function createAdapterService(deps) {
         adapterCalldata,
         historyPreview: {
           kind: "Withdraw",
-          amounts: inputs.map((input) => ({
+          amounts: spendInputs.map((input) => ({
             token: input.token,
             delta: (-input.amount).toString()
           }))
@@ -8420,6 +8605,9 @@ import {
 } from "ethers";
 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);
@@ -8467,8 +8655,8 @@ function createBurnerService(deps) {
   }
   async function getTokenBalance(address, token) {
     const iface = new Interface4([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) {
@@ -8487,6 +8675,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");
@@ -8497,17 +8691,20 @@ function createBurnerService(deps) {
       depositor: address,
       deposits: [{ token: params.token, amount }]
     });
-    const erc20Iface = new Interface4([
-      "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 Interface4([
+        "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 };
   }
@@ -9163,28 +9360,31 @@ function createWalletSDK(deps, options) {
   return sdk;
 }
 async function createBrowserWalletSDK(options) {
+  let chainId;
   let gatewayUrl;
   let poolAddress;
   let prover = options.prover;
-  if ("gatewayUrl" in options) {
+  if ("chain" in options) {
+    const chainConfig = await fetchChainConfig(options.chain);
+    chainId = chainConfig.chainId;
+    gatewayUrl = chainConfig.gatewayUrl;
+    poolAddress = options.poolAddress ?? chainConfig.poolAddress;
+    prover = {
+      artifactSource: {
+        baseUrl: options.prover?.artifactSource?.baseUrl ?? chainConfig.artifactBaseUrl,
+        version: options.prover?.artifactSource?.version ?? chainConfig.artifactVersion,
+        preferLocalFiles: options.prover?.artifactSource?.preferLocalFiles
+      }
+    };
+  } else {
+    chainId = options.chainId;
     gatewayUrl = options.gatewayUrl;
     poolAddress = options.poolAddress;
     if (typeof window !== "undefined" && !options.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(options.environment);
-    gatewayUrl = envConfig.gatewayUrl;
-    poolAddress = options.poolAddress ?? envConfig.poolAddress;
-    prover = {
-      artifactSource: {
-        baseUrl: options.prover?.artifactSource?.baseUrl ?? envConfig.artifactBaseUrl,
-        version: options.prover?.artifactSource?.version ?? envConfig.artifactVersion,
-        preferLocalFiles: options.prover?.artifactSource?.preferLocalFiles
-      }
-    };
   }
   const storage = createIndexedDbStorage({ name: "unlink-wallet" });
   const rng = (n) => {
@@ -9201,7 +9401,7 @@ async function createBrowserWalletSDK(options) {
       core,
       fetch: globalThis.fetch
     },
-    { chainId: options.chainId, gatewayUrl, prover }
+    { chainId, gatewayUrl, prover }
   );
   return {
     sdk,
@@ -9214,51 +9414,63 @@ 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 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(config) {
+    let chainId;
     let gatewayUrl;
     let poolAddress;
+    let adapterAddress;
     let proverConfig = config.prover;
-    if ("gatewayUrl" in config) {
+    if ("chain" in config) {
+      const chainConfig = await fetchChainConfig(config.chain);
+      chainId = chainConfig.chainId;
+      gatewayUrl = chainConfig.gatewayUrl;
+      poolAddress = config.poolAddress ?? chainConfig.poolAddress;
+      adapterAddress = config.adapterAddress ?? chainConfig.adapterAddress;
+      proverConfig = {
+        artifactSource: {
+          baseUrl: config.prover?.artifactSource?.baseUrl ?? chainConfig.artifactBaseUrl,
+          version: config.prover?.artifactSource?.version ?? chainConfig.artifactVersion,
+          preferLocalFiles: config.prover?.artifactSource?.preferLocalFiles
+        }
+      };
+    } else {
+      chainId = config.chainId;
       gatewayUrl = config.gatewayUrl;
       poolAddress = config.poolAddress;
+      adapterAddress = config.adapterAddress;
       if (typeof window !== "undefined" && !config.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(config.environment);
-      gatewayUrl = envConfig.gatewayUrl;
-      poolAddress = config.poolAddress ?? envConfig.poolAddress;
-      proverConfig = {
-        artifactSource: {
-          baseUrl: config.prover?.artifactSource?.baseUrl ?? envConfig.artifactBaseUrl,
-          version: config.prover?.artifactSource?.version ?? envConfig.artifactVersion,
-          preferLocalFiles: config.prover?.artifactSource?.preferLocalFiles
-        }
-      };
     }
     const storage = config.storage ?? detectStorage();
     const rng = config.rng ?? defaultRng;
@@ -9267,14 +9479,14 @@ var UnlinkWallet = class _UnlinkWallet {
     const sdk = createWalletSDK(
       { core, fetch: fetchImpl },
       {
-        chainId: config.chainId,
+        chainId,
         gatewayUrl,
         chainRpcUrl: config.chainRpcUrl,
         prover: proverConfig,
         autoSync: config.autoSync
       }
     );
-    return new _UnlinkWallet(sdk, config.chainId, poolAddress);
+    return new _Unlink(sdk, chainId, poolAddress, adapterAddress ?? "");
   }
   // ===== Seed Lifecycle =====
   /** Seed management (create, import, export, delete mnemonic). */
@@ -9305,10 +9517,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,
@@ -9319,9 +9531,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,
@@ -9331,8 +9543,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 },
@@ -9481,31 +9693,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.
@@ -9553,6 +9765,7 @@ var defaultRng = (n) => {
   }
   return globalThis.crypto.getRandomValues(new Uint8Array(n));
 };
+var UnlinkWallet = Unlink;
 
 // utils/amounts.ts
 function parseAmount(value, decimals) {
@@ -9605,6 +9818,7 @@ export {
   HttpError,
   InitializationError,
   ProofError,
+  Unlink,
   UnlinkWallet,
   ValidationError,
   computeBalances,