@matterlabs/zksync-js 0.0.13 → 0.0.14

package/dist/adapters/viem/client.js

@@ -1,6 +1,7 @@
-export { createViemClient } from '../../chunk-2RIARDXZ.js';
-import '../../chunk-5R7L5NM5.js';
-import '../../chunk-4S4XDA4N.js';
-import '../../chunk-53MC5BR2.js';
-import '../../chunk-RI73VJSH.js';
-import '../../chunk-QQ2OR434.js';
+export { createViemClient } from '../../chunk-OTXPSNNC.js';
+import '../../chunk-XDRCN4FC.js';
+import '../../chunk-BWKWWLY4.js';
+import '../../chunk-HP3EWKJL.js';
+import '../../chunk-DYJKK5FW.js';
+import '../../chunk-JY62QO3W.js';
+import '../../chunk-MT4X5FEO.js';

package/dist/adapters/viem/index.cjs

@@ -33,7 +33,15 @@ var TX_OVERHEAD_GAS = 10000n;
 var TX_MEMORY_OVERHEAD_GAS = 10n;
 var DEFAULT_PUBDATA_BYTES = 155n;
 var DEFAULT_ABI_BYTES = 400n;
-var SAFE_L1_BRIDGE_GAS = 800000n;
+var SAFE_L1_BRIDGE_GAS = 3000000n;
+var L1_TX_INTRINSIC_L2_GAS = 167157n;
+var L1_TX_INTRINSIC_PUBDATA = 88n;
+var L1_TX_MIN_L2_GAS_BASE = 173484n;
+var L1_TX_DELTA_544_ENCODING_BYTES = 1656n;
+var L1_TX_DELTA_FACTORY_DEPS_L2_GAS = 2473n;
+var L1_TX_DELTA_FACTORY_DEPS_PUBDATA = 64n;
+var TX_SLOT_OVERHEAD_L2_GAS = 10000n;
+var PRIORITY_TX_MAX_GAS_LIMIT = 72000000n;
 
 // src/core/utils/addr.ts
 function isAddressEq(a, b) {
@@ -407,6 +415,7 @@ function normalizeProof(p) {
     const raw = p ?? {};
     const idRaw = raw?.id ?? raw?.index;
     const bnRaw = raw?.batch_number ?? raw?.batchNumber;
+    const gwBlockNumberRaw = raw?.gatewayBlockNumber;
     if (idRaw == null || bnRaw == null) {
       throw createError("RPC", {
         resource: "zksrpc",
@@ -427,7 +436,8 @@ function normalizeProof(p) {
       id: toBig(idRaw),
       batchNumber: toBig(bnRaw),
       proof: toHexArray(raw?.proof),
-      root: raw.root
+      root: raw.root,
+      gatewayBlockNumber: gwBlockNumberRaw != null ? toBig(gwBlockNumberRaw) : void 0
     };
   } catch (e) {
     if (isZKsyncError(e)) throw e;
@@ -704,13 +714,15 @@ function createZksRpc(transport) {
       );
     },
     // Fetches a proof for an L2→L1 log emitted in the given transaction.
-    async getL2ToL1LogProof(txHash, index) {
+    async getL2ToL1LogProof(txHash, index, proofTarget) {
       return withRpcOp(
         "zksrpc.getL2ToL1LogProof",
         "Failed to fetch L2\u2192L1 log proof.",
-        { txHash, index },
+        { txHash, index, proofTarget },
         async () => {
-          const proof = await transport(METHODS.getL2ToL1LogProof, [txHash, index]);
+          const params = [txHash, index];
+          if (proofTarget != void 0) params.push(proofTarget);
+          const proof = await transport(METHODS.getL2ToL1LogProof, params);
           if (!proof) {
             throw createError("STATE", {
               resource: "zksrpc",
@@ -5718,11 +5730,10 @@ async function quoteL1Gas(input) {
     const est = await estimator.estimateGas(tx);
     const buffered = BigInt(est) * (100n + BUFFER) / 100n;
     return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
-  } catch (err) {
+  } catch {
     if (fallbackGasLimit != null) {
       return makeGasQuote({ gasLimit: fallbackGasLimit, maxFeePerGas, maxPriorityFeePerGas });
     }
-    console.warn("L1 gas estimation failed", err);
     return void 0;
   }
 }
@@ -5760,8 +5771,7 @@ async function quoteL2Gas(input) {
       maxFeePerGas,
       gasPerPubdata: pp
     });
-  } catch (err) {
-    console.warn("L2 gas estimation failed", err);
+  } catch {
     return makeGasQuote({
       gasLimit: l2GasLimit ?? 0n,
       maxFeePerGas,
@@ -5895,8 +5905,22 @@ async function determineNonBaseL2Gas(input) {
   try {
     const l2TokenAddress = input.knownL2Token ?? (ctx.tokens ? await ctx.tokens.toL2Address(l1Token) : await (await ctx.contracts.l2NativeTokenVault()).read.l2TokenAddress([l1Token]));
     if (l2TokenAddress === viem.zeroAddress) {
+      if (input.undeployedGasLimit != null) {
+        return quoteL2Gas2({
+          ctx,
+          route,
+          overrideGasLimit: input.undeployedGasLimit
+        });
+      }
       return fallbackQuote();
     }
+    if (input.priorityFloorGasLimit != null) {
+      return quoteL2Gas2({
+        ctx,
+        route,
+        overrideGasLimit: input.priorityFloorGasLimit
+      });
+    }
     const modelTx = {
       to: input.modelTx?.to ?? ctx.sender,
       from: input.modelTx?.from ?? ctx.sender,
@@ -5912,8 +5936,7 @@ async function determineNonBaseL2Gas(input) {
       return fallbackQuote();
     }
     return gas;
-  } catch (err) {
-    console.warn("Failed to determine non-base deposit L2 gas; defaulting to safe gas limit.", err);
+  } catch {
     return fallbackQuote();
   }
 }
@@ -5930,7 +5953,9 @@ async function determineEthNonBaseL2Gas(input) {
     route: "eth-nonbase",
     l1Token: input.ctx.resolvedToken?.l1 ?? FORMAL_ETH_ADDRESS,
     knownL2Token: input.ctx.resolvedToken?.l2,
-    modelTx: input.modelTx
+    modelTx: input.modelTx,
+    priorityFloorGasLimit: input.priorityFloorGasLimit,
+    undeployedGasLimit: input.undeployedGasLimit
   });
 }
 
@@ -5984,34 +6009,123 @@ function buildFeeBreakdown(p) {
   };
 }
 
+// src/core/resources/deposits/priority.ts
+var PRIORITY_TX_ENCODING_STEP_BYTES = 544n;
+var DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER = 6n;
+var maxBigInt = (a, b) => a > b ? a : b;
+var ceilDiv = (a, b) => (a + b - 1n) / b;
+function derivePriorityTxGasBreakdown(input) {
+  const factoryDepsCount = input.factoryDepsCount ?? 0n;
+  const minBodyGas = maxBigInt(
+    L1_TX_INTRINSIC_L2_GAS + ceilDiv(
+      input.encodedLength * L1_TX_DELTA_544_ENCODING_BYTES,
+      PRIORITY_TX_ENCODING_STEP_BYTES
+    ) + factoryDepsCount * L1_TX_DELTA_FACTORY_DEPS_L2_GAS,
+    L1_TX_MIN_L2_GAS_BASE
+  ) + L1_TX_INTRINSIC_PUBDATA * input.gasPerPubdata + factoryDepsCount * L1_TX_DELTA_FACTORY_DEPS_PUBDATA * input.gasPerPubdata;
+  const overhead = maxBigInt(TX_SLOT_OVERHEAD_L2_GAS, TX_MEMORY_OVERHEAD_GAS * input.encodedLength);
+  const derivedBodyGas = minBodyGas;
+  return {
+    encodedLength: input.encodedLength,
+    minBodyGas,
+    overhead,
+    derivedBodyGas,
+    derivedL2GasLimit: derivedBodyGas + overhead,
+    priorityTxMaxGasLimit: PRIORITY_TX_MAX_GAS_LIMIT,
+    priorityTxMaxGasLimitExceeded: derivedBodyGas > PRIORITY_TX_MAX_GAS_LIMIT
+  };
+}
+function derivePriorityBodyGasEstimateCap(input) {
+  return input.minBodyGas * (input.multiplier ?? DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER);
+}
+
+// src/adapters/viem/resources/deposits/routes/priority.ts
+var EMPTY_BYTES = "0x";
+var ZERO_RESERVED_WORDS = [0n, 0n, 0n, 0n];
+var L2_CANONICAL_TRANSACTION_PARAMETER = {
+  type: "tuple",
+  components: [
+    { name: "txType", type: "uint256" },
+    { name: "from", type: "uint256" },
+    { name: "to", type: "uint256" },
+    { name: "gasLimit", type: "uint256" },
+    { name: "gasPerPubdataByteLimit", type: "uint256" },
+    { name: "maxFeePerGas", type: "uint256" },
+    { name: "maxPriorityFeePerGas", type: "uint256" },
+    { name: "paymaster", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "value", type: "uint256" },
+    { name: "reserved", type: "uint256[4]" },
+    { name: "data", type: "bytes" },
+    { name: "signature", type: "bytes" },
+    { name: "factoryDeps", type: "uint256[]" },
+    { name: "paymasterInput", type: "bytes" },
+    { name: "reservedDynamic", type: "bytes" }
+  ]
+};
+function hexByteLength(hex) {
+  return BigInt(Math.max(hex.length - 2, 0) / 2);
+}
+function getPriorityTxEncodedLength(input) {
+  const encoded = viem.encodeAbiParameters(
+    [L2_CANONICAL_TRANSACTION_PARAMETER],
+    [
+      {
+        txType: 0n,
+        from: BigInt(input.sender),
+        to: BigInt(input.l2Contract),
+        gasLimit: 0n,
+        gasPerPubdataByteLimit: input.gasPerPubdata,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 0n,
+        paymaster: 0n,
+        nonce: 0n,
+        value: input.l2Value,
+        reserved: ZERO_RESERVED_WORDS,
+        data: input.l2Calldata,
+        signature: EMPTY_BYTES,
+        factoryDeps: input.factoryDepsHashes ?? [],
+        paymasterInput: EMPTY_BYTES,
+        reservedDynamic: EMPTY_BYTES
+      }
+    ]
+  );
+  return hexByteLength(encoded);
+}
+function getPriorityTxGasBreakdown(input) {
+  return derivePriorityTxGasBreakdown({
+    encodedLength: getPriorityTxEncodedLength(input),
+    gasPerPubdata: input.gasPerPubdata,
+    factoryDepsCount: BigInt(input.factoryDepsHashes?.length ?? 0)
+  });
+}
+
 // src/adapters/viem/resources/deposits/routes/eth.ts
 var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
+var EMPTY_BYTES2 = "0x";
 function routeEthDirect() {
   return {
     async build(p, ctx) {
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: p.amount
-      };
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const l2Calldata = EMPTY_BYTES2;
+      const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+        sender: ctx.sender,
+        l2Contract,
+        l2Value,
+        l2Calldata,
+        gasPerPubdata: ctx.gasPerPubdata
+      });
+      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
       const l2GasParams = await quoteL2Gas2({
         ctx,
         route: "eth-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit,
-        stateOverrides: {
-          [ctx.sender]: {
-            balance: "0xffffffffffffffffffff"
-          }
-        }
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2GasParams) {
         throw new Error("Failed to estimate L2 gas for deposit.");
       }
       const baseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2GasParams.gasLimit });
-      const l2Contract = p.to ?? ctx.sender;
-      const l2Value = p.amount;
       const mintValue = baseCost + ctx.operatorTip + l2Value;
       const req = buildDirectRequestStruct({
         chainId: ctx.chainIdL2,
@@ -6080,6 +6194,59 @@ function routeEthDirect() {
   };
 }
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
+var ZERO_ASSET_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
+async function getPriorityGasModel(input) {
+  try {
+    const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
+    const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
+    const l1ChainId = BigInt(await input.ctx.client.l1.getChainId());
+    const isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID || input.ctx.resolvedToken.originChainId === 0n;
+    const erc20MetadataOriginChainId = isFirstBridge ? l1ChainId : input.ctx.resolvedToken.originChainId;
+    const erc20Metadata = await l1NativeTokenVault.read.getERC20Getters([
+      input.token,
+      erc20MetadataOriginChainId
+    ]);
+    const bridgeMintCalldata = viem.encodeAbiParameters(
+      [
+        { type: "address", name: "originalCaller" },
+        { type: "address", name: "receiver" },
+        { type: "address", name: "originToken" },
+        { type: "uint256", name: "amount" },
+        { type: "bytes", name: "erc20Metadata" }
+      ],
+      [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    );
+    const l2Calldata = isFirstBridge ? viem.encodeFunctionData({
+      abi: IL2AssetRouter_default,
+      functionName: "finalizeDeposit",
+      args: [input.ctx.sender, input.receiver, input.token, input.amount, erc20Metadata]
+    }) : await (async () => {
+      return await l1AssetRouter.read.getDepositCalldata([
+        input.ctx.sender,
+        input.ctx.resolvedToken.assetId,
+        bridgeMintCalldata
+      ]);
+    })();
+    const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+      sender: input.ctx.l1AssetRouter,
+      l2Contract: L2_ASSET_ROUTER_ADDRESS,
+      l2Value: 0n,
+      l2Calldata,
+      gasPerPubdata: input.ctx.gasPerPubdata
+    });
+    const model = {
+      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+    };
+    if (isFirstBridge || input.ctx.resolvedToken.l2.toLowerCase() === viem.zeroAddress) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeErc20NonBase() {
   return {
     // TODO: do we even need these validations?
@@ -6110,11 +6277,33 @@ function routeErc20NonBase() {
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
       const baseIsEth = ctx.baseIsEth ?? isETH(baseToken);
       const assetRouter = ctx.l1AssetRouter;
+      const receiver = p.to ?? ctx.sender;
+      const secondBridgeCalldata = await wrapAs3(
+        "INTERNAL",
+        OP_DEPOSITS.nonbase.encodeCalldata,
+        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, receiver)),
+        {
+          ctx: {
+            where: "encodeSecondBridgeErc20Args",
+            token: p.token,
+            amount: p.amount.toString()
+          },
+          message: "Failed to encode bridging calldata."
+        }
+      );
+      const priorityGasModel = await getPriorityGasModel({
+        ctx,
+        token: p.token,
+        amount: p.amount,
+        receiver
+      });
       const l2Gas = await determineErc20L2Gas({
         ctx,
         l1Token: p.token,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit,
         modelTx: {
-          to: p.to ?? ctx.sender,
+          to: receiver,
           from: ctx.sender,
           data: "0x",
           value: 0n
@@ -6203,19 +6392,6 @@ function routeErc20NonBase() {
           });
         }
       }
-      const secondBridgeCalldata = await wrapAs3(
-        "INTERNAL",
-        OP_DEPOSITS.nonbase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, p.to ?? ctx.sender)),
-        {
-          ctx: {
-            where: "encodeSecondBridgeErc20Args",
-            token: p.token,
-            amount: p.amount.toString()
-          },
-          message: "Failed to encode bridging calldata."
-        }
-      );
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
@@ -6306,7 +6482,76 @@ function routeErc20NonBase() {
     }
   };
 }
+
+// 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/viem/resources/deposits/routes/eth-nonbase.ts
 var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => viem.encodeAbiParameters(
+    types.map((type, index) => ({ type, name: `arg${index}` })),
+    values
+  ),
+  keccak256: viem.keccak256
+});
+async function getPriorityGasModel2(input) {
+  try {
+    const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
+    const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
+    const originChainId = input.ctx.resolvedToken.originChainId !== 0n ? input.ctx.resolvedToken.originChainId : BigInt(await input.ctx.client.l1.getChainId());
+    const resolvedAssetId = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID2 ? ntvCodec.encodeAssetId(originChainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, ETH_ADDRESS) : input.ctx.resolvedToken.assetId;
+    const erc20Metadata = await l1NativeTokenVault.read.getERC20Getters([
+      ETH_ADDRESS,
+      originChainId
+    ]);
+    const bridgeMintCalldata = viem.encodeAbiParameters(
+      [
+        { type: "address", name: "originalCaller" },
+        { type: "address", name: "receiver" },
+        { type: "address", name: "originToken" },
+        { type: "uint256", name: "amount" },
+        { type: "bytes", name: "erc20Metadata" }
+      ],
+      [input.ctx.sender, input.receiver, ETH_ADDRESS, input.amount, erc20Metadata]
+    );
+    const l2Calldata = await l1AssetRouter.read.getDepositCalldata([
+      input.ctx.sender,
+      resolvedAssetId,
+      bridgeMintCalldata
+    ]);
+    const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+      sender: input.ctx.l1AssetRouter,
+      l2Contract: L2_ASSET_ROUTER_ADDRESS,
+      l2Value: 0n,
+      l2Calldata,
+      gasPerPubdata: input.ctx.gasPerPubdata
+    });
+    const model = {
+      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+    };
+    if (input.ctx.resolvedToken.l2.toLowerCase() === viem.zeroAddress) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeEthNonBase() {
   return {
     // TODO: do we even need these validations?
@@ -6353,15 +6598,23 @@ function routeEthNonBase() {
     },
     async build(p, ctx) {
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
+      const receiver = p.to ?? ctx.sender;
+      const priorityGasModel = await getPriorityGasModel2({
+        ctx,
+        amount: p.amount,
+        receiver
+      });
       const l2TxModel = {
-        to: p.to ?? ctx.sender,
+        to: receiver,
         from: ctx.sender,
         data: "0x",
         value: 0n
       };
       const l2Gas = await determineEthNonBaseL2Gas({
         ctx,
-        modelTx: l2TxModel
+        modelTx: l2TxModel,
+        priorityFloorGasLimit: priorityGasModel.priorityFloorGasLimit,
+        undeployedGasLimit: priorityGasModel.undeployedGasLimit
       });
       if (!l2Gas) throw new Error("Failed to estimate L2 gas parameters.");
       const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
@@ -6410,12 +6663,12 @@ function routeEthNonBase() {
       const secondBridgeCalldata = await wrapAs4(
         "INTERNAL",
         OP_DEPOSITS.ethNonBase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, p.to ?? ctx.sender)),
+        () => Promise.resolve(encodeSecondBridgeEthArgs(p.amount, receiver)),
         {
           ctx: {
             where: "encodeSecondBridgeEthArgs",
             amount: p.amount.toString(),
-            to: p.to ?? ctx.sender
+            to: receiver
           },
           message: "Failed to encode ETH bridging calldata."
         }
@@ -6516,6 +6769,7 @@ function routeEthNonBase() {
   };
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
+var EMPTY_BYTES3 = "0x";
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -6543,17 +6797,21 @@ function routeErc20Base() {
     },
     async build(p, ctx) {
       const baseToken = ctx.baseTokenL1 ?? await ctx.client.baseToken(ctx.chainIdL2);
-      const l2TxModel = {
-        to: p.to ?? ctx.sender,
-        from: ctx.sender,
-        data: "0x",
-        value: 0n
-      };
+      const l2Contract = p.to ?? ctx.sender;
+      const l2Value = p.amount;
+      const l2Calldata = EMPTY_BYTES3;
+      const priorityFloorBreakdown = getPriorityTxGasBreakdown({
+        sender: ctx.sender,
+        l2Contract,
+        l2Value,
+        l2Calldata,
+        gasPerPubdata: ctx.gasPerPubdata
+      });
+      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
       const l2Gas = await quoteL2Gas2({
         ctx,
         route: "erc20-base",
-        l2TxForModeling: l2TxModel,
-        overrideGasLimit: ctx.l2GasLimit
+        overrideGasLimit: quotedL2GasLimit
       });
       if (!l2Gas) throw new Error("Failed to estimate L2 gas parameters.");
       const l2BaseCost = await quoteL2BaseCost({ ctx, l2GasLimit: l2Gas.gasLimit });
@@ -6605,8 +6863,8 @@ function routeErc20Base() {
         l2GasLimit: l2Gas.gasLimit,
         gasPerPubdata: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
-        l2Contract: p.to ?? ctx.sender,
-        l2Value: p.amount
+        l2Contract,
+        l2Value
       });
       let bridgeTx;
       let calldata;
@@ -6767,24 +7025,8 @@ async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   }
   return { l2Receipt, l2TxHash };
 }
-
-// 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/viem/resources/tokens/tokens.ts
 var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => viem.encodeAbiParameters(
     types.map((t, i) => ({ type: t, name: `arg${i}` })),
     values
@@ -6898,7 +7140,7 @@ function createTokensResource(client) {
     return wrapAs6("CONTRACT", "tokens.isChainEthBased", async () => {
       const baseAssetId = await getBaseTokenAssetId();
       const l1ChainId = await getL1ChainId();
-      const ethAssetId = ntvCodec.encodeAssetId(
+      const ethAssetId = ntvCodec2.encodeAssetId(
         l1ChainId,
         L2_NATIVE_TOKEN_VAULT_ADDRESS,
         ETH_ADDRESS