@matterlabs/zksync-js 0.0.2 → 0.0.5

package/dist/adapters/ethers/index.cjs

@@ -5137,9 +5137,9 @@ var IFACE_PANIC = new ethers.Interface(["error Panic(uint256)"]);
   } catch {
   }
 })();
-function registerErrorAbi(name, abi) {
+function registerErrorAbi(name, abi2) {
   const existing = ERROR_IFACES.findIndex((x) => x.name === name);
-  const entry = { name, iface: new ethers.Interface(abi) };
+  const entry = { name, iface: new ethers.Interface(abi2) };
   if (existing >= 0) ERROR_IFACES[existing] = entry;
   else ERROR_IFACES.push(entry);
 }
@@ -5231,7 +5231,7 @@ function createErrorHandlers(resource) {
   function wrap2(operation, fn, opts) {
     return run("INTERNAL", operation, fn, opts);
   }
-  function wrapAs9(kind, operation, fn, opts) {
+  function wrapAs10(kind, operation, fn, opts) {
     return run(kind, operation, fn, opts);
   }
   async function toResult2(operation, fn, opts) {
@@ -5252,7 +5252,7 @@ function createErrorHandlers(resource) {
       return { ok: false, error: shaped };
     }
   }
-  return { wrap: wrap2, wrapAs: wrapAs9, toResult: toResult2 };
+  return { wrap: wrap2, wrapAs: wrapAs10, toResult: toResult2 };
 }
 
 // src/adapters/ethers/client.ts
@@ -5396,6 +5396,8 @@ function normalizeAddrEq(a, b) {
   };
   return normalize(a) === normalize(b);
 }
+var hexEq = (a, b) => a.toLowerCase() === b.toLowerCase();
+var normalizeL1Token = (token) => isAddressEq(token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : token;
 
 // src/adapters/ethers/resources/deposits/services/verification.ts
 var I_BRIDGEHUB = new ethers.Interface([
@@ -5462,27 +5464,35 @@ async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   return { l2Receipt, l2TxHash };
 }
 
-// src/core/resources/deposits/route.ts
-async function pickDepositRoute(client, chainIdL2, token) {
-  if (isETH(token)) {
-    const base2 = await client.baseToken(chainIdL2);
-    return isETH(base2) ? "eth-base" : "eth-nonbase";
-  }
-  const base = await client.baseToken(chainIdL2);
-  return normalizeAddrEq(token, base) ? "erc20-base" : "erc20-nonbase";
-}
-
 // src/adapters/ethers/resources/deposits/context.ts
-async function commonCtx(p, client) {
-  const { bridgehub, l1AssetRouter } = await client.ensureAddresses();
+async function commonCtx(p, client, tokens, contracts) {
+  const { bridgehub, l1AssetRouter } = await contracts.addresses();
   const { chainId } = await client.l2.getNetwork();
   const sender = await client.signer.getAddress();
   const gasPerPubdata = p.gasPerPubdata ?? 800n;
   const operatorTip = p.operatorTip ?? 0n;
   const refundRecipient = p.refundRecipient ?? sender;
-  const route = await pickDepositRoute(client, BigInt(chainId), p.token);
+  const resolvedToken = await tokens.resolve(p.token, { chain: "l1" });
+  const baseTokenAssetId = resolvedToken.baseTokenAssetId;
+  const baseTokenL1 = await tokens.l1TokenFromAssetId(baseTokenAssetId);
+  const baseIsEth = resolvedToken.isChainEthBased;
+  const route = (() => {
+    if (resolvedToken.kind === "eth") {
+      return baseIsEth ? "eth-base" : "eth-nonbase";
+    }
+    if (resolvedToken.kind === "base") {
+      return baseIsEth ? "eth-base" : "erc20-base";
+    }
+    return "erc20-nonbase";
+  })();
   return {
     client,
+    tokens,
+    contracts,
+    resolvedToken,
+    baseTokenAssetId,
+    baseTokenL1,
+    baseIsEth,
     l1AssetRouter,
     route,
     bridgehub,
@@ -5495,31 +5505,14 @@ async function commonCtx(p, client) {
     refundRecipient
   };
 }
-function encodeNativeTokenVaultAssetId(chainId, address) {
-  const abi = new ethers.AbiCoder();
-  const hex = abi.encode(
-    ["uint256", "address", "address"],
-    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
-  );
-  return ethers.ethers.keccak256(hex);
-}
 function encodeNativeTokenVaultTransferData(amount, receiver, token) {
   return new ethers.AbiCoder().encode(["uint256", "address", "address"], [amount, receiver, token]);
 }
 function encodeSecondBridgeDataV1(assetId, transferData) {
-  const abi = new ethers.AbiCoder();
-  const data = abi.encode(["bytes32", "bytes"], [assetId, transferData]);
+  const abi2 = new ethers.AbiCoder();
+  const data = abi2.encode(["bytes32", "bytes"], [assetId, transferData]);
   return ethers.ethers.concat(["0x01", data]);
 }
-function encodeNTVAssetId(chainId, address) {
-  const abi = new ethers.AbiCoder();
-  const hex = abi.encode(
-    ["uint256", "address", "address"],
-    [chainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, address]
-  );
-  return ethers.ethers.keccak256(hex);
-}
-var encodeNTVTransferData = encodeNativeTokenVaultTransferData;
 function encodeSecondBridgeArgs(token, amount, l2Receiver) {
   return ethers.AbiCoder.defaultAbiCoder().encode(
     ["address", "uint256", "address"],
@@ -5741,8 +5734,8 @@ function ethersToGasEstimator(provider) {
 
 // src/adapters/ethers/resources/deposits/services/fee.ts
 var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
-var encode = (abi, fn, args) => {
-  return new ethers.Interface(abi).encodeFunctionData(fn, args);
+var encode = (abi2, fn, args) => {
+  return new ethers.Interface(abi2).encodeFunctionData(fn, args);
 };
 async function quoteL2BaseCost2(input) {
   const { ctx, l2GasLimit } = input;
@@ -5797,8 +5790,7 @@ async function determineErc20L2Gas(input) {
     });
   }
   try {
-    const { l2NativeTokenVault } = await ctx.client.contracts();
-    const l2TokenAddress = await l2NativeTokenVault.l2TokenAddress(l1Token);
+    const l2TokenAddress = ctx.tokens ? await ctx.tokens.toL2Address(l1Token) : await (await ctx.contracts.l2NativeTokenVault()).l2TokenAddress(l1Token);
     if (l2TokenAddress === "0x0000000000000000000000000000000000000000") {
       return quoteL2Gas2({
         ctx,
@@ -5867,7 +5859,7 @@ function buildFeeBreakdown(p) {
 function routeEthDirect() {
   return {
     async build(p, ctx) {
-      const bh = new ethers.Contract(ctx.bridgehub, IBridgehub_default, ctx.client.l1);
+      const bh = await ctx.contracts.bridgehub();
       const l2TxModel = {
         to: p.to ?? ctx.sender,
         from: ctx.sender,
@@ -5944,14 +5936,14 @@ function routeEthDirect() {
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
 function routeErc20NonBase() {
   return {
-    // TODO: do we even need these validations?
     async preflight(p, ctx) {
-      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const resolved = ctx.resolvedToken ?? (ctx.tokens ? await ctx.tokens.resolve(p.token, { chain: "l1" }) : void 0);
+      const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       await wrapAs3(
         "VALIDATION",
         OP_DEPOSITS.nonbase.assertNonBaseToken,
         () => {
-          if (normalizeAddrEq(baseToken, p.token)) {
+          if (resolved?.kind === "base" || resolved?.kind === "eth") {
             throw new Error("erc20-nonbase route requires a non-base ERC-20 deposit token.");
           }
         },
@@ -5960,8 +5952,8 @@ function routeErc20NonBase() {
     },
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
-      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
-      const baseIsEth = isETH(baseToken);
+      const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
+      const baseIsEth = ctx.baseIsEth ?? isETH(baseToken);
       const l2GasParams = await determineErc20L2Gas({
         ctx,
         l1Token: p.token,
@@ -6048,7 +6040,7 @@ function routeErc20NonBase() {
         secondBridgeValue: 0n,
         secondBridgeCalldata
       };
-      const bh = (await ctx.client.contracts()).bridgehub;
+      const bh = await ctx.contracts.bridgehub();
       const data = bh.interface.encodeFunctionData("requestL2TransactionTwoBridges", [
         requestStruct
       ]);
@@ -6097,26 +6089,26 @@ var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
 function routeEthNonBase() {
   return {
     async preflight(p, ctx) {
+      const resolved = ctx.resolvedToken ?? (ctx.tokens ? await ctx.tokens.resolve(p.token, { chain: "l1" }) : void 0);
       await wrapAs4(
         "VALIDATION",
         OP_DEPOSITS.ethNonBase.assertEthAsset,
         () => {
-          if (!isETH(p.token)) {
+          if (resolved?.kind !== "eth" && !isETH(p.token)) {
             throw new Error("eth-nonbase route requires ETH as the deposit asset.");
           }
         },
         { ctx: { token: p.token } }
       );
-      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
       await wrapAs4(
         "VALIDATION",
         OP_DEPOSITS.ethNonBase.assertNonEthBase,
         () => {
-          if (isETH(baseToken)) {
+          if (ctx.baseIsEth) {
             throw new Error("eth-nonbase route requires target chain base token \u2260 ETH.");
           }
         },
-        { ctx: { baseToken, chainIdL2: ctx.chainIdL2 } }
+        { ctx: { baseIsEth: ctx.baseIsEth, chainIdL2: ctx.chainIdL2 } }
       );
       const ethBal = await wrapAs4(
         "RPC",
@@ -6141,7 +6133,7 @@ function routeEthNonBase() {
     },
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
-      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const baseToken = ctx.baseTokenL1;
       const l2TxModel = {
         to: p.to ?? ctx.sender,
         from: ctx.sender,
@@ -6206,11 +6198,10 @@ function routeEthNonBase() {
         secondBridgeValue: p.amount,
         secondBridgeCalldata
       };
-      const data = new ethers.Contract(
-        ctx.bridgehub,
-        IBridgehub_default,
-        ctx.client.l1
-      ).interface.encodeFunctionData("requestL2TransactionTwoBridges", [requestStruct]);
+      const bridgehub = await ctx.contracts.bridgehub();
+      const data = bridgehub.interface.encodeFunctionData("requestL2TransactionTwoBridges", [
+        requestStruct
+      ]);
       const l1TxCandidate = {
         to: ctx.bridgehub,
         data,
@@ -6256,17 +6247,18 @@ var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
+      const resolved = ctx.resolvedToken ?? (ctx.tokens ? await ctx.tokens.resolve(p.token, { chain: "l1" }) : void 0);
       await wrapAs5(
         "VALIDATION",
         OP_DEPOSITS.base.assertErc20Asset,
         () => {
-          if (isETH(p.token)) {
+          if (resolved?.kind === "eth" || isETH(p.token)) {
             throw new Error("erc20-base route requires an ERC-20 token (not ETH).");
           }
         },
         { ctx: { token: p.token } }
       );
-      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       await wrapAs5(
         "VALIDATION",
         OP_DEPOSITS.base.assertMatchesBase,
@@ -6281,7 +6273,7 @@ function routeErc20Base() {
     },
     async build(p, ctx) {
       const l1Signer = ctx.client.getL1Signer();
-      const baseToken = await ctx.client.baseToken(ctx.chainIdL2);
+      const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       const l2TxModel = {
         to: p.to ?? ctx.sender,
         from: ctx.sender,
@@ -6334,11 +6326,10 @@ function routeErc20Base() {
         l2Contract: p.to ?? ctx.sender,
         l2Value: p.amount
       });
-      const data = new ethers.Contract(
-        ctx.bridgehub,
-        IBridgehub_default,
-        ctx.client.l1
-      ).interface.encodeFunctionData("requestL2TransactionDirect", [requestStruct]);
+      const bridgehub = await ctx.contracts.bridgehub();
+      const data = bridgehub.interface.encodeFunctionData("requestL2TransactionDirect", [
+        requestStruct
+      ]);
       const l1TxCandidate = {
         to: ctx.bridgehub,
         data,
@@ -6381,6 +6372,282 @@ function routeErc20Base() {
   };
 }
 
+// src/core/codec/ntv.ts
+function createNTVCodec(deps) {
+  function encodeAssetId(originChainId, ntvAddress, tokenAddress) {
+    const encoded = deps.encode(
+      ["uint256", "address", "address"],
+      [originChainId, ntvAddress, tokenAddress]
+    );
+    return deps.keccak256(encoded);
+  }
+  return {
+    encodeAssetId
+  };
+}
+
+// src/adapters/ethers/resources/tokens/tokens.ts
+var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
+var abi = ethers.AbiCoder.defaultAbiCoder();
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => abi.encode(types, values),
+  keccak256: (data) => ethers.ethers.keccak256(data)
+});
+function createTokensResource(client) {
+  let l2NtvL1ChainIdPromise = null;
+  let baseTokenAssetIdPromise = null;
+  let wethL1Promise = null;
+  let wethL2Promise = null;
+  async function getL1ChainId() {
+    if (!l2NtvL1ChainIdPromise) {
+      l2NtvL1ChainIdPromise = wrapAs6("INTERNAL", "getL1ChainId", async () => {
+        const { l2NativeTokenVault } = await client.contracts();
+        const chainId = await l2NativeTokenVault.L1_CHAIN_ID();
+        return chainId;
+      });
+    }
+    return l2NtvL1ChainIdPromise;
+  }
+  async function getBaseTokenAssetId() {
+    if (!baseTokenAssetIdPromise) {
+      baseTokenAssetIdPromise = wrapAs6("INTERNAL", "baseTokenAssetId", async () => {
+        const { l2NativeTokenVault } = await client.contracts();
+        const assetId = await l2NativeTokenVault.BASE_TOKEN_ASSET_ID();
+        return assetId;
+      });
+    }
+    return baseTokenAssetIdPromise;
+  }
+  async function getWethL1() {
+    if (!wethL1Promise) {
+      wethL1Promise = wrapAs6("INTERNAL", "wethL1", async () => {
+        const { l1NativeTokenVault } = await client.contracts();
+        const weth = await l1NativeTokenVault.WETH_TOKEN();
+        return weth;
+      });
+    }
+    return wethL1Promise;
+  }
+  async function getWethL2() {
+    if (!wethL2Promise) {
+      wethL2Promise = wrapAs6("INTERNAL", "wethL2", async () => {
+        const { l2NativeTokenVault } = await client.contracts();
+        const weth = await l2NativeTokenVault.WETH_TOKEN();
+        return weth;
+      });
+    }
+    return wethL2Promise;
+  }
+  async function toL2Address(l1Token) {
+    return wrapAs6("CONTRACT", "tokens.toL2Address", async () => {
+      const normalized = normalizeL1Token(l1Token);
+      const { chainId } = await client.l2.getNetwork();
+      const baseToken = await client.baseToken(BigInt(chainId));
+      if (isAddressEq(normalized, baseToken)) {
+        return L2_BASE_TOKEN_ADDRESS;
+      }
+      const { l2NativeTokenVault } = await client.contracts();
+      const l2Token = await l2NativeTokenVault.l2TokenAddress(normalized);
+      return l2Token;
+    });
+  }
+  async function toL1Address(l2Token) {
+    return wrapAs6("CONTRACT", "tokens.toL1Address", async () => {
+      if (isAddressEq(l2Token, ETH_ADDRESS)) {
+        return ETH_ADDRESS;
+      }
+      if (isAddressEq(l2Token, L2_BASE_TOKEN_ADDRESS)) {
+        const { chainId } = await client.l2.getNetwork();
+        return await client.baseToken(BigInt(chainId));
+      }
+      const { l2AssetRouter } = await client.contracts();
+      const l1Token = await l2AssetRouter.l1TokenAddress(l2Token);
+      return l1Token;
+    });
+  }
+  async function assetIdOfL1(l1Token) {
+    return wrapAs6("CONTRACT", "tokens.assetIdOfL1", async () => {
+      const normalized = normalizeL1Token(l1Token);
+      const { l1NativeTokenVault } = await client.contracts();
+      const assetId = await l1NativeTokenVault.assetId(normalized);
+      return assetId;
+    });
+  }
+  async function assetIdOfL2(l2Token) {
+    return wrapAs6("CONTRACT", "tokens.assetIdOfL2", async () => {
+      const { l2NativeTokenVault } = await client.contracts();
+      const assetId = await l2NativeTokenVault.assetId(l2Token);
+      return assetId;
+    });
+  }
+  async function l2TokenFromAssetId(assetId) {
+    return wrapAs6("CONTRACT", "tokens.l2TokenFromAssetId", async () => {
+      const { l2NativeTokenVault } = await client.contracts();
+      const tokenAddr = await l2NativeTokenVault.tokenAddress(assetId);
+      return tokenAddr;
+    });
+  }
+  async function l1TokenFromAssetId(assetId) {
+    return wrapAs6("CONTRACT", "tokens.l1TokenFromAssetId", async () => {
+      const { l1NativeTokenVault } = await client.contracts();
+      const tokenAddr = await l1NativeTokenVault.tokenAddress(assetId);
+      return tokenAddr;
+    });
+  }
+  async function originChainId(assetId) {
+    return wrapAs6("CONTRACT", "tokens.originChainId", async () => {
+      const { l2NativeTokenVault } = await client.contracts();
+      const chainId = await l2NativeTokenVault.originChainId(assetId);
+      return chainId;
+    });
+  }
+  async function baseTokenAssetId() {
+    return getBaseTokenAssetId();
+  }
+  async function isChainEthBased() {
+    return wrapAs6("CONTRACT", "tokens.isChainEthBased", async () => {
+      const baseAssetId = await getBaseTokenAssetId();
+      const l1ChainId = await getL1ChainId();
+      const ethAssetId = ntvCodec.encodeAssetId(
+        l1ChainId,
+        L2_NATIVE_TOKEN_VAULT_ADDRESS,
+        ETH_ADDRESS
+      );
+      return hexEq(baseAssetId, ethAssetId);
+    });
+  }
+  async function wethL1() {
+    return getWethL1();
+  }
+  async function wethL2() {
+    return getWethL2();
+  }
+  async function computeL2BridgedAddress(args) {
+    return wrapAs6("CONTRACT", "tokens.computeL2BridgedAddress", async () => {
+      const normalized = normalizeL1Token(args.l1Token);
+      const { l2NativeTokenVault } = await client.contracts();
+      const predicted = await l2NativeTokenVault.calculateCreate2TokenAddress(
+        args.originChainId,
+        normalized
+      );
+      return predicted;
+    });
+  }
+  async function resolve(ref, opts) {
+    return wrapAs6("CONTRACT", "tokens.resolve", async () => {
+      let chain;
+      let address;
+      if (typeof ref === "string") {
+        chain = opts?.chain ?? "l1";
+        address = ref;
+      } else {
+        chain = ref.chain;
+        address = ref.address;
+      }
+      let l1;
+      let l2;
+      if (chain === "l1") {
+        l1 = normalizeL1Token(address);
+        l2 = await toL2Address(address);
+      } else {
+        l2 = address;
+        l1 = await toL1Address(address);
+      }
+      const assetId = await assetIdOfL1(l1);
+      const originChainIdVal = await originChainId(assetId);
+      const [baseAssetId, wethL1Addr, wethL2Addr, ethBased] = await Promise.all([
+        baseTokenAssetId(),
+        wethL1(),
+        wethL2(),
+        isChainEthBased()
+      ]);
+      let kind;
+      if (isAddressEq(l1, ETH_ADDRESS)) {
+        kind = "eth";
+      } else if (hexEq(assetId, baseAssetId)) {
+        kind = "base";
+      } else {
+        kind = "erc20";
+      }
+      return {
+        kind,
+        l1,
+        l2,
+        assetId,
+        originChainId: originChainIdVal,
+        isChainEthBased: ethBased,
+        baseTokenAssetId: baseAssetId,
+        wethL1: wethL1Addr,
+        wethL2: wethL2Addr
+      };
+    });
+  }
+  return {
+    resolve,
+    toL2Address,
+    toL1Address,
+    assetIdOfL1,
+    assetIdOfL2,
+    l2TokenFromAssetId,
+    l1TokenFromAssetId,
+    originChainId,
+    baseTokenAssetId,
+    isChainEthBased,
+    wethL1,
+    wethL2,
+    computeL2BridgedAddress
+  };
+}
+
+// src/adapters/ethers/resources/contracts/contracts.ts
+function createContractsResource(client) {
+  async function addresses() {
+    return client.ensureAddresses();
+  }
+  async function instances() {
+    return client.contracts();
+  }
+  async function bridgehub() {
+    const { bridgehub: bridgehub2 } = await instances();
+    return bridgehub2;
+  }
+  async function l1AssetRouter() {
+    const { l1AssetRouter: l1AssetRouter2 } = await instances();
+    return l1AssetRouter2;
+  }
+  async function l1NativeTokenVault() {
+    const { l1NativeTokenVault: l1NativeTokenVault2 } = await instances();
+    return l1NativeTokenVault2;
+  }
+  async function l1Nullifier() {
+    const { l1Nullifier: l1Nullifier2 } = await instances();
+    return l1Nullifier2;
+  }
+  async function l2AssetRouter() {
+    const { l2AssetRouter: l2AssetRouter2 } = await instances();
+    return l2AssetRouter2;
+  }
+  async function l2NativeTokenVault() {
+    const { l2NativeTokenVault: l2NativeTokenVault2 } = await instances();
+    return l2NativeTokenVault2;
+  }
+  async function l2BaseTokenSystem() {
+    const { l2BaseTokenSystem: l2BaseTokenSystem2 } = await instances();
+    return l2BaseTokenSystem2;
+  }
+  return {
+    addresses,
+    instances,
+    bridgehub,
+    l1AssetRouter,
+    l1NativeTokenVault,
+    l1Nullifier,
+    l2AssetRouter,
+    l2NativeTokenVault,
+    l2BaseTokenSystem
+  };
+}
+
 // src/adapters/ethers/resources/deposits/index.ts
 var { wrap, toResult } = createErrorHandlers("deposits");
 var ROUTES = {
@@ -6389,9 +6656,11 @@ var ROUTES = {
   "erc20-nonbase": routeErc20NonBase(),
   "erc20-base": routeErc20Base()
 };
-function createDepositsResource(client) {
+function createDepositsResource(client, tokens, contracts) {
+  const tokensResource = tokens ?? createTokensResource(client);
+  const contractsResource = contracts ?? createContractsResource(client);
   async function buildPlan(p) {
-    const ctx = await commonCtx(p, client);
+    const ctx = await commonCtx(p, client, tokensResource, contractsResource);
     const route = ctx.route;
     await ROUTES[route].preflight?.(p, ctx);
     const { steps, approvals, fees } = await ROUTES[route].build(p, ctx);
@@ -6669,25 +6938,9 @@ function pickWithdrawRoute(args) {
   if (isL2BaseAlias) return "base";
   return "erc20-nonbase";
 }
-async function ntvBaseAssetId(l2, ntv) {
-  const c = new ethers.Contract(ntv, L2NativeTokenVault_default, l2);
-  return await c.BASE_TOKEN_ASSET_ID();
-}
-async function ntvL1ChainId(l2, ntv) {
-  const c = new ethers.Contract(ntv, L2NativeTokenVault_default, l2);
-  return await c.L1_CHAIN_ID();
-}
-async function isEthBasedChain(l2, ntv) {
-  const [baseAssetId, l1ChainId] = await Promise.all([
-    ntvBaseAssetId(l2, ntv),
-    ntvL1ChainId(l2, ntv)
-  ]);
-  const ethAssetId = encodeNativeTokenVaultAssetId(l1ChainId, ETH_ADDRESS);
-  return baseAssetId.toLowerCase() === ethAssetId.toLowerCase();
-}
 
 // src/adapters/ethers/resources/withdrawals/context.ts
-async function commonCtx2(p, client) {
+async function commonCtx2(p, client, tokens, contracts) {
   const sender = await client.signer.getAddress();
   const {
     bridgehub,
@@ -6696,13 +6949,21 @@ async function commonCtx2(p, client) {
     l2AssetRouter,
     l2NativeTokenVault,
     l2BaseTokenSystem
-  } = await client.ensureAddresses();
+  } = await contracts.addresses();
   const { chainId } = await client.l2.getNetwork();
   const chainIdL2 = BigInt(chainId);
-  const baseIsEth = await isEthBasedChain(client.l2, l2NativeTokenVault);
+  const resolvedToken = await tokens.resolve(p.token, { chain: "l2" });
+  const baseTokenAssetId = resolvedToken.baseTokenAssetId;
+  const baseTokenL1 = await tokens.l1TokenFromAssetId(baseTokenAssetId);
+  const baseIsEth = resolvedToken.isChainEthBased;
   const route = pickWithdrawRoute({ token: p.token});
   return {
     client,
+    tokens,
+    contracts,
+    resolvedToken,
+    baseTokenAssetId,
+    baseTokenL1,
     bridgehub,
     chainIdL2,
     sender,
@@ -6806,13 +7067,13 @@ function buildFeeBreakdown2(p) {
 }
 
 // src/adapters/ethers/resources/withdrawals/routes/eth.ts
-var { wrapAs: wrapAs6 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
 function routeEthBase() {
   return {
     async build(p, ctx) {
       const steps = [];
-      const base = (await ctx.client.contracts()).l2BaseTokenSystem;
-      const data = await wrapAs6(
+      const base = await ctx.contracts.l2BaseTokenSystem();
+      const data = await wrapAs7(
         "INTERNAL",
         OP_WITHDRAWALS.eth.encodeWithdraw,
         () => Promise.resolve(base.interface.encodeFunctionData("withdraw", [p.to ?? ctx.sender])),
@@ -6847,7 +7108,7 @@ function routeEthBase() {
     }
   };
 }
-var { wrapAs: wrapAs7 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
 var SIG = {
   withdraw: "withdraw(bytes32,bytes)"
 };
@@ -6857,7 +7118,7 @@ function routeErc20NonBase2() {
       const steps = [];
       const approvals = [];
       const erc20 = new ethers.Contract(p.token, IERC20_default, ctx.client.getL2Signer());
-      const current = await wrapAs7(
+      const current = await wrapAs8(
         "CONTRACT",
         OP_WITHDRAWALS.erc20.allowance,
         () => erc20.allowance(ctx.sender, ctx.l2NativeTokenVault),
@@ -6895,17 +7156,21 @@ function routeErc20NonBase2() {
           tx: approveTx
         });
       }
-      const ntv = (await ctx.client.contracts()).l2NativeTokenVault;
-      const assetId = await wrapAs7(
+      const resolved = ctx.resolvedToken ?? (ctx.tokens ? await ctx.tokens.resolve(p.token, { chain: "l2" }) : void 0);
+      const assetId = resolved?.assetId ?? await wrapAs8(
         "CONTRACT",
         OP_WITHDRAWALS.erc20.ensureRegistered,
-        () => ntv.getFunction("ensureTokenIsRegistered").staticCall(p.token),
+        async () => {
+          const ntv = await ctx.contracts.l2NativeTokenVault();
+          const ensured = await ntv.getFunction("ensureTokenIsRegistered").staticCall(p.token);
+          return ensured;
+        },
         {
           ctx: { where: "L2NativeTokenVault.ensureTokenIsRegistered", token: p.token },
           message: "Failed to ensure token is registered in L2NativeTokenVault."
         }
       );
-      const assetData = await wrapAs7(
+      const assetData = await wrapAs8(
         "INTERNAL",
         OP_WITHDRAWALS.erc20.encodeAssetData,
         () => Promise.resolve(
@@ -6916,8 +7181,8 @@ function routeErc20NonBase2() {
           message: "Failed to encode burn/withdraw asset data."
         }
       );
-      const l2ar = (await ctx.client.contracts()).l2AssetRouter;
-      const dataWithdraw = await wrapAs7(
+      const l2ar = await ctx.contracts.l2AssetRouter();
+      const dataWithdraw = await wrapAs8(
         "INTERNAL",
         OP_WITHDRAWALS.erc20.encodeWithdraw,
         () => Promise.resolve(l2ar.interface.encodeFunctionData(SIG.withdraw, [assetId, assetData])),
@@ -6944,7 +7209,7 @@ function routeErc20NonBase2() {
         tx: withdrawTx
       });
       const fees = buildFeeBreakdown2({
-        feeToken: await ctx.client.baseToken(ctx.chainIdL2),
+        feeToken: ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2),
         l2Gas: withdrawGas
       });
       return { steps, approvals, fees };
@@ -6985,7 +7250,7 @@ function messengerLogIndex(raw, opts) {
 }
 
 // src/adapters/ethers/resources/withdrawals/services/finalization.ts
-var { wrapAs: wrapAs8 } = createErrorHandlers("withdrawals");
+var { wrapAs: wrapAs9 } = createErrorHandlers("withdrawals");
 var IL1NullifierMini = [
   "function isWithdrawalFinalized(uint256,uint256,uint256) view returns (bool)"
 ];
@@ -6993,7 +7258,7 @@ function createFinalizationServices(client) {
   const { l1, l2, signer } = client;
   return {
     async fetchFinalizeDepositParams(l2TxHash) {
-      const parsed = await wrapAs8(
+      const parsed = await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.fetchParams.receipt,
         () => client.zks.getReceiptWithL2ToL1(l2TxHash),
@@ -7010,7 +7275,7 @@ function createFinalizationServices(client) {
           context: { l2TxHash }
         });
       }
-      const ev = await wrapAs8(
+      const ev = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.fetchParams.findMessage,
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument, @typescript-eslint/no-explicit-any
@@ -7020,7 +7285,7 @@ function createFinalizationServices(client) {
           message: "Failed to locate L1MessageSent event in L2 receipt."
         }
       );
-      const message = await wrapAs8(
+      const message = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.fetchParams.decodeMessage,
         () => Promise.resolve(ethers.AbiCoder.defaultAbiCoder().decode(["bytes"], ev.data)[0]),
@@ -7029,7 +7294,7 @@ function createFinalizationServices(client) {
           message: "Failed to decode withdrawal message."
         }
       );
-      const raw = await wrapAs8(
+      const raw = await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.fetchParams.rawReceipt,
         () => client.zks.getReceiptWithL2ToL1(l2TxHash),
@@ -7046,7 +7311,7 @@ function createFinalizationServices(client) {
           context: { l2TxHash }
         });
       }
-      const idx = await wrapAs8(
+      const idx = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.fetchParams.messengerIndex,
         () => Promise.resolve(messengerLogIndex(raw, { index: 0, messenger: L1_MESSENGER_ADDRESS })),
@@ -7055,7 +7320,7 @@ function createFinalizationServices(client) {
           message: "Failed to derive messenger log index."
         }
       );
-      const proof = await wrapAs8(
+      const proof = await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.fetchParams.proof,
         () => client.zks.getL2ToL1LogProof(l2TxHash, idx),
@@ -7064,7 +7329,7 @@ function createFinalizationServices(client) {
           message: "Failed to fetch L2\u2192L1 log proof."
         }
       );
-      const { chainId } = await wrapAs8(
+      const { chainId } = await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.fetchParams.network,
         () => l2.getNetwork(),
@@ -7083,7 +7348,7 @@ function createFinalizationServices(client) {
         message,
         merkleProof: proof.proof
       };
-      const { l1Nullifier } = await wrapAs8(
+      const { l1Nullifier } = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
         () => client.ensureAddresses(),
@@ -7095,7 +7360,7 @@ function createFinalizationServices(client) {
       return { params, nullifier: l1Nullifier };
     },
     async simulateFinalizeReadiness(params) {
-      const { l1Nullifier } = await wrapAs8(
+      const { l1Nullifier } = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.readiness.ensureAddresses,
         () => client.ensureAddresses(),
@@ -7107,7 +7372,7 @@ function createFinalizationServices(client) {
       const done = await (async () => {
         try {
           const cMini = new ethers.Contract(l1Nullifier, IL1NullifierMini, l1);
-          const isFinalized = await wrapAs8(
+          const isFinalized = await wrapAs9(
             "RPC",
             OP_WITHDRAWALS.finalize.readiness.isFinalized,
             () => cMini.isWithdrawalFinalized(
@@ -7135,7 +7400,7 @@ function createFinalizationServices(client) {
       }
     },
     async isWithdrawalFinalized(key) {
-      const { l1Nullifier } = await wrapAs8(
+      const { l1Nullifier } = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
         () => client.ensureAddresses(),
@@ -7145,7 +7410,7 @@ function createFinalizationServices(client) {
         }
       );
       const c = new ethers.Contract(l1Nullifier, IL1NullifierMini, l1);
-      return await wrapAs8(
+      return await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.isFinalized,
         () => c.isWithdrawalFinalized(key.chainIdL2, key.l2BatchNumber, key.l2MessageIndex),
@@ -7156,7 +7421,7 @@ function createFinalizationServices(client) {
       );
     },
     async estimateFinalization(params) {
-      const { l1Nullifier } = await wrapAs8(
+      const { l1Nullifier } = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.estimate,
         () => client.ensureAddresses(),
@@ -7167,7 +7432,7 @@ function createFinalizationServices(client) {
       );
       const signer2 = client.getL1Signer();
       const c = new ethers.Contract(l1Nullifier, IL1Nullifier_default, signer2);
-      const gasLimit = await wrapAs8(
+      const gasLimit = await wrapAs9(
         "RPC",
         OP_WITHDRAWALS.finalize.estimate,
         () => c.finalizeDeposit.estimateGas(params),
@@ -7182,7 +7447,7 @@ function createFinalizationServices(client) {
           message: "Failed to estimate gas for finalizeDeposit."
         }
       );
-      const feeData = await wrapAs8("RPC", OP_WITHDRAWALS.finalize.estimate, () => l1.getFeeData(), {
+      const feeData = await wrapAs9("RPC", OP_WITHDRAWALS.finalize.estimate, () => l1.getFeeData(), {
         ctx: { where: "l1.getFeeData" },
         message: "Failed to estimate fee data for finalizeDeposit."
       });
@@ -7203,7 +7468,7 @@ function createFinalizationServices(client) {
       };
     },
     async finalizeDeposit(params) {
-      const { l1Nullifier } = await wrapAs8(
+      const { l1Nullifier } = await wrapAs9(
         "INTERNAL",
         OP_WITHDRAWALS.finalize.fetchParams.ensureAddresses,
         () => client.ensureAddresses(),
@@ -7264,11 +7529,13 @@ var ROUTES2 = {
   "erc20-nonbase": routeErc20NonBase2()
   // AssetRouter.withdraw for non-base ERC-20s
 };
-function createWithdrawalsResource(client) {
+function createWithdrawalsResource(client, tokens, contracts) {
   const svc = createFinalizationServices(client);
   const { wrap: wrap2, toResult: toResult2 } = createErrorHandlers("withdrawals");
+  const tokensResource = tokens ?? createTokensResource(client);
+  const contractsResource = contracts ?? createContractsResource(client);
   async function buildPlan(p) {
-    const ctx = await commonCtx2(p, client);
+    const ctx = await commonCtx2(p, client, tokensResource, contractsResource);
     await ROUTES2[ctx.route].preflight?.(p, ctx);
     const { steps, approvals, fees } = await ROUTES2[ctx.route].build(p, ctx);
     return {
@@ -7592,57 +7859,13 @@ function createWithdrawalsResource(client) {
 
 // src/adapters/ethers/sdk.ts
 function createEthersSdk(client) {
+  const tokens = createTokensResource(client);
+  const contracts = createContractsResource(client);
   return {
-    deposits: createDepositsResource(client),
-    withdrawals: createWithdrawalsResource(client),
-    // TODO: might update to create dedicated resources for these
-    helpers: {
-      addresses: () => client.ensureAddresses(),
-      contracts: () => client.contracts(),
-      async l1AssetRouter() {
-        const { l1AssetRouter } = await client.contracts();
-        return l1AssetRouter;
-      },
-      async l1NativeTokenVault() {
-        const { l1NativeTokenVault } = await client.contracts();
-        return l1NativeTokenVault;
-      },
-      async l1Nullifier() {
-        const { l1Nullifier } = await client.contracts();
-        return l1Nullifier;
-      },
-      async baseToken(chainId) {
-        const id = chainId ?? BigInt((await client.l2.getNetwork()).chainId);
-        return client.baseToken(id);
-      },
-      async l2TokenAddress(l1Token) {
-        if (isAddressEq(l1Token, FORMAL_ETH_ADDRESS)) {
-          return ETH_ADDRESS;
-        }
-        const { chainId } = await client.l2.getNetwork();
-        const base = await client.baseToken(BigInt(chainId));
-        if (isAddressEq(l1Token, base)) {
-          return L2_BASE_TOKEN_ADDRESS;
-        }
-        const { l2NativeTokenVault } = await client.contracts();
-        const addr = await l2NativeTokenVault.l2TokenAddress(l1Token);
-        return addr;
-      },
-      async l1TokenAddress(l2Token) {
-        if (isAddressEq(l2Token, ETH_ADDRESS)) {
-          return ETH_ADDRESS;
-        }
-        const { l2AssetRouter } = await client.contracts();
-        const addr = await l2AssetRouter.l1TokenAddress(l2Token);
-        return addr;
-      },
-      async assetId(l1Token) {
-        const norm = isAddressEq(l1Token, FORMAL_ETH_ADDRESS) ? ETH_ADDRESS : l1Token;
-        const { l1NativeTokenVault } = await client.contracts();
-        const id = await l1NativeTokenVault.assetId(norm);
-        return id;
-      }
-    }
+    deposits: createDepositsResource(client, tokens, contracts),
+    withdrawals: createWithdrawalsResource(client, tokens, contracts),
+    tokens,
+    contracts
   };
 }
 
@@ -7654,11 +7877,9 @@ exports.createErrorHandlers = createErrorHandlers;
 exports.createEthersClient = createEthersClient;
 exports.createEthersSdk = createEthersSdk;
 exports.createFinalizationServices = createFinalizationServices;
+exports.createTokensResource = createTokensResource;
 exports.createWithdrawalsResource = createWithdrawalsResource;
 exports.decodeRevert = decodeRevert;
-exports.encodeNTVAssetId = encodeNTVAssetId;
-exports.encodeNTVTransferData = encodeNTVTransferData;
-exports.encodeNativeTokenVaultAssetId = encodeNativeTokenVaultAssetId;
 exports.encodeNativeTokenVaultTransferData = encodeNativeTokenVaultTransferData;
 exports.encodeSecondBridgeArgs = encodeSecondBridgeArgs;
 exports.encodeSecondBridgeDataV1 = encodeSecondBridgeDataV1;