@matterlabs/zksync-js 0.0.13 → 0.0.14

package/dist/adapters/viem/index.js

@@ -1,9 +1,10 @@
-export { buildDirectRequestStruct, createContractsResource, createDepositsResource, createFinalizationServices, createTokensResource, createViemSdk, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs } from '../../chunk-EDWBCPO3.js';
-import '../../chunk-5L6EYUJB.js';
-import '../../chunk-E3KP7XCG.js';
-export { createViemClient as createClient, createViemClient } from '../../chunk-2RIARDXZ.js';
-export { classifyReadinessFromRevert, createErrorHandlers, decodeRevert, registerErrorAbi, toZKsyncError } from '../../chunk-5R7L5NM5.js';
-import '../../chunk-4S4XDA4N.js';
-import '../../chunk-53MC5BR2.js';
-import '../../chunk-RI73VJSH.js';
-import '../../chunk-QQ2OR434.js';
+export { buildDirectRequestStruct, createContractsResource, createDepositsResource, createFinalizationServices, createTokensResource, createViemSdk, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs } from '../../chunk-75IOOODG.js';
+import '../../chunk-EOBXYHTZ.js';
+import '../../chunk-3HHUZXSV.js';
+export { createViemClient as createClient, createViemClient } from '../../chunk-OTXPSNNC.js';
+export { classifyReadinessFromRevert, createErrorHandlers, decodeRevert, registerErrorAbi, toZKsyncError } from '../../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/resources/deposits/routes/priority.d.ts

@@ -0,0 +1,13 @@
+import { type Hex } from 'viem';
+import { type PriorityTxGasBreakdown } from '../../../../../core/resources/deposits/priority.ts';
+import type { Address } from '../../../../../core/types/primitives';
+export type CanonicalPriorityTxInput = {
+    sender: Address;
+    l2Contract: Address;
+    l2Value: bigint;
+    l2Calldata: Hex;
+    gasPerPubdata: bigint;
+    factoryDepsHashes?: bigint[];
+};
+export declare function getPriorityTxEncodedLength(input: CanonicalPriorityTxInput): bigint;
+export declare function getPriorityTxGasBreakdown(input: CanonicalPriorityTxInput): PriorityTxGasBreakdown;

package/dist/adapters/viem/resources/deposits/services/gas.d.ts

@@ -30,8 +30,12 @@ export declare function determineErc20L2Gas(input: {
     ctx: BuildCtx;
     l1Token: Address;
     modelTx?: TransactionRequest;
+    priorityFloorGasLimit?: bigint;
+    undeployedGasLimit?: bigint;
 }): Promise<GasQuote | undefined>;
 export declare function determineEthNonBaseL2Gas(input: {
     ctx: BuildCtx;
     modelTx?: TransactionRequest;
+    priorityFloorGasLimit?: bigint;
+    undeployedGasLimit?: bigint;
 }): Promise<GasQuote | undefined>;

package/dist/adapters/viem/sdk.cjs

@@ -3709,7 +3709,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/adapters/viem/resources/utils.ts
 function encodeSecondBridgeArgs(token, amount, l2Receiver) {
@@ -4318,11 +4326,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;
   }
 }
@@ -4360,8 +4367,7 @@ async function quoteL2Gas(input) {
       maxFeePerGas,
       gasPerPubdata: pp
     });
-  } catch (err) {
-    console.warn("L2 gas estimation failed", err);
+  } catch {
     return makeGasQuote({
       gasLimit: l2GasLimit ?? 0n,
       maxFeePerGas,
@@ -4495,8 +4501,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,
@@ -4512,8 +4532,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();
   }
 }
@@ -4530,7 +4549,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
   });
 }
 
@@ -4584,34 +4605,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,
@@ -4680,6 +4790,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?
@@ -4710,11 +4873,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
@@ -4803,19 +4988,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,
@@ -4906,7 +5078,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?
@@ -4953,15 +5194,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 });
@@ -5010,12 +5259,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."
         }
@@ -5116,6 +5365,7 @@ function routeEthNonBase() {
   };
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
+var EMPTY_BYTES3 = "0x";
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -5143,17 +5393,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 });
@@ -5205,8 +5459,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;
@@ -5367,24 +5621,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
@@ -5498,7 +5736,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