@matterlabs/zksync-js 0.0.13 → 0.0.14

package/dist/adapters/viem/sdk.js

@@ -1,7 +1,7 @@
-export { createViemSdk } from '../../chunk-EDWBCPO3.js';
-import '../../chunk-5L6EYUJB.js';
-import '../../chunk-E3KP7XCG.js';
-import '../../chunk-5R7L5NM5.js';
-import '../../chunk-53MC5BR2.js';
-import '../../chunk-RI73VJSH.js';
-import '../../chunk-QQ2OR434.js';
+export { createViemSdk } from '../../chunk-75IOOODG.js';
+import '../../chunk-EOBXYHTZ.js';
+import '../../chunk-3HHUZXSV.js';
+import '../../chunk-XDRCN4FC.js';
+import '../../chunk-HP3EWKJL.js';
+import '../../chunk-JY62QO3W.js';
+import '../../chunk-MT4X5FEO.js';

package/dist/{chunk-E3KP7XCG.js → chunk-3HHUZXSV.js}

@@ -1,4 +1,4 @@
-import { L2_BASE_TOKEN_ADDRESS, TOPIC_L1_MESSAGE_SENT_NEW, TOPIC_L1_MESSAGE_SENT_LEG, L1_MESSENGER_ADDRESS, ETH_ADDRESS, L2_ASSET_ROUTER_ADDRESS } from './chunk-QQ2OR434.js';
+import { L2_BASE_TOKEN_ADDRESS, TOPIC_L1_MESSAGE_SENT_NEW, TOPIC_L1_MESSAGE_SENT_LEG, L1_MESSENGER_ADDRESS, ETH_ADDRESS, L2_ASSET_ROUTER_ADDRESS } from './chunk-MT4X5FEO.js';
 
 // src/core/resources/withdrawals/route.ts
 function normalizeTokenForRouting(token) {

package/dist/{chunk-UDBRUBEK.js → chunk-5RRJDPAJ.js}

@@ -1,5 +1,5 @@
-import { createErrorOps, REVERT_TO_READINESS } from './chunk-53MC5BR2.js';
-import { IL1Nullifier_default, IERC20_default, L1NativeTokenVault_default, L2NativeTokenVault_default, Mailbox_default, IL1ContractErrors_default, IInteropErrors_default } from './chunk-RI73VJSH.js';
+import { createErrorOps, REVERT_TO_READINESS } from './chunk-HP3EWKJL.js';
+import { IL1Nullifier_default, IERC20_default, L1NativeTokenVault_default, L2NativeTokenVault_default, Mailbox_default, IL1ContractErrors_default, IInteropErrors_default } from './chunk-JY62QO3W.js';
 import { Interface } from 'ethers';
 
 var ERROR_IFACES = [];

package/dist/{chunk-EDWBCPO3.js → chunk-75IOOODG.js}

@@ -1,8 +1,8 @@
-import { createNTVCodec, toGasOverrides, buildFeeBreakdown, quoteL2Gas, quoteL1Gas, quoteL2Gas2 } from './chunk-5L6EYUJB.js';
-import { findL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-E3KP7XCG.js';
-import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-5R7L5NM5.js';
-import { isHash66, IL1Nullifier_default, OP_WITHDRAWALS, createError, normalizeL1Token, isAddressEq, hexEq, OP_DEPOSITS, IERC20_default, isZKsyncError, isReceiptNotFound, IBridgehub_default, isETH, normalizeAddrEq, L2NativeTokenVault_default, IL2AssetRouter_default, IBaseToken_default } from './chunk-RI73VJSH.js';
-import { ETH_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS, L1_MESSENGER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, SAFE_L1_BRIDGE_GAS, FORMAL_ETH_ADDRESS } from './chunk-QQ2OR434.js';
+import { createNTVCodec, toGasOverrides, buildFeeBreakdown, derivePriorityTxGasBreakdown, quoteL2Gas, quoteL1Gas, derivePriorityBodyGasEstimateCap, quoteL2Gas2 } from './chunk-EOBXYHTZ.js';
+import { findL1MessageSentLog, messengerLogIndex, pickWithdrawRoute } from './chunk-3HHUZXSV.js';
+import { createErrorHandlers, toZKsyncError, classifyReadinessFromRevert } from './chunk-XDRCN4FC.js';
+import { isHash66, IL1Nullifier_default, OP_WITHDRAWALS, createError, normalizeL1Token, isAddressEq, hexEq, OP_DEPOSITS, IERC20_default, isZKsyncError, isReceiptNotFound, IBridgehub_default, isETH, normalizeAddrEq, L2NativeTokenVault_default, IL2AssetRouter_default, IBaseToken_default } from './chunk-JY62QO3W.js';
+import { ETH_ADDRESS, TOPIC_CANONICAL_ASSIGNED, TOPIC_CANONICAL_SUCCESS, L1_MESSENGER_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, SAFE_L1_BRIDGE_GAS, L2_ASSET_ROUTER_ADDRESS, FORMAL_ETH_ADDRESS } from './chunk-MT4X5FEO.js';
 import { keccak256, encodeAbiParameters, concat, decodeEventLog, decodeAbiParameters, encodeFunctionData, zeroAddress } from 'viem';
 
 // src/adapters/viem/resources/deposits/context.ts
@@ -221,8 +221,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 === zeroAddress) {
+      if (input.undeployedGasLimit != null) {
+        return quoteL2Gas3({
+          ctx,
+          route,
+          overrideGasLimit: input.undeployedGasLimit
+        });
+      }
       return fallbackQuote();
     }
+    if (input.priorityFloorGasLimit != null) {
+      return quoteL2Gas3({
+        ctx,
+        route,
+        overrideGasLimit: input.priorityFloorGasLimit
+      });
+    }
     const modelTx = {
       to: input.modelTx?.to ?? ctx.sender,
       from: input.modelTx?.from ?? ctx.sender,
@@ -238,8 +252,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();
   }
 }
@@ -256,7 +269,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
   });
 }
 
@@ -281,35 +296,92 @@ async function quoteL2BaseCost(input) {
     { ctx: { chainIdL2: ctx.chainIdL2 } }
   );
 }
+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 = 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 quoteL2Gas3({
         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,
@@ -378,6 +450,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 = 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 ? 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() === zeroAddress) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeErc20NonBase() {
   return {
     // TODO: do we even need these validations?
@@ -408,11 +533,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
@@ -501,19 +648,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,
@@ -605,6 +739,59 @@ function routeErc20NonBase() {
   };
 }
 var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
+var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => encodeAbiParameters(
+    types.map((type, index) => ({ type, name: `arg${index}` })),
+    values
+  ),
+  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 = 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() === zeroAddress) {
+      model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
+        minBodyGas: priorityFloorBreakdown.minBodyGas
+      }) + priorityFloorBreakdown.overhead;
+    }
+    return model;
+  } catch {
+    return {};
+  }
+}
 function routeEthNonBase() {
   return {
     // TODO: do we even need these validations?
@@ -651,15 +838,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 });
@@ -708,12 +903,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."
         }
@@ -814,6 +1009,7 @@ function routeEthNonBase() {
   };
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("deposits");
+var EMPTY_BYTES3 = "0x";
 function routeErc20Base() {
   return {
     async preflight(p, ctx) {
@@ -841,17 +1037,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 quoteL2Gas3({
         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 });
@@ -903,8 +1103,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;
@@ -1066,7 +1266,7 @@ async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   return { l2Receipt, l2TxHash };
 }
 var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => encodeAbiParameters(
     types.map((t, i) => ({ type: t, name: `arg${i}` })),
     values
@@ -1180,7 +1380,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

package/dist/{chunk-R5WRFPK2.js → chunk-7CAVFIMW.js}

@@ -1,7 +1,8 @@
-import { createErrorHandlers } from './chunk-UDBRUBEK.js';
-import { createZksRpc, makeTransportFromEthers } from './chunk-4S4XDA4N.js';
-import { createError, OP_CLIENT, IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, L2MessageVerification_default, IInteropHandler_default, IInteropCenter_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default, OP_DEPOSITS } from './chunk-RI73VJSH.js';
-import { L2_ASSET_ROUTER_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_INTEROP_CENTER_ADDRESS, L2_INTEROP_HANDLER_ADDRESS, L2_MESSAGE_VERIFICATION_ADDRESS, FORMAL_ETH_ADDRESS } from './chunk-QQ2OR434.js';
+import { createErrorHandlers } from './chunk-5RRJDPAJ.js';
+import { makeTransportFromEthers } from './chunk-BWKWWLY4.js';
+import { createZksRpc } from './chunk-DYJKK5FW.js';
+import { createError, OP_CLIENT, IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, L2MessageVerification_default, IInteropHandler_default, IInteropCenter_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default, OP_DEPOSITS } from './chunk-JY62QO3W.js';
+import { L2_ASSET_ROUTER_ADDRESS, L2_NATIVE_TOKEN_VAULT_ADDRESS, L2_BASE_TOKEN_ADDRESS, L2_INTEROP_CENTER_ADDRESS, L2_INTEROP_HANDLER_ADDRESS, L2_MESSAGE_VERIFICATION_ADDRESS, FORMAL_ETH_ADDRESS } from './chunk-MT4X5FEO.js';
 import { BrowserProvider, Interface, Contract } from 'ethers';
 
 // src/adapters/ethers/rpc.ts

package/dist/chunk-BWKWWLY4.js

@@ -0,0 +1,9 @@
+// src/core/rpc/transport.ts
+function makeTransportFromEthers(provider) {
+  return (m, p = []) => provider.send(m, p);
+}
+function makeTransportFromViem(client) {
+  return (m, p = []) => client.request({ method: m, params: p });
+}
+
+export { makeTransportFromEthers, makeTransportFromViem };

package/dist/{chunk-4S4XDA4N.js → chunk-DYJKK5FW.js}

@@ -1,9 +1,10 @@
-import { createError, isBigint, isNumber, isZKsyncError, shapeCause } from './chunk-RI73VJSH.js';
-import { __export } from './chunk-QQ2OR434.js';
+import { createError, isBigint, isNumber, isZKsyncError, shapeCause } from './chunk-JY62QO3W.js';
+import { __export } from './chunk-MT4X5FEO.js';
 
 // src/core/rpc/zks.ts
 var zks_exports = {};
 __export(zks_exports, {
+  ProofTarget: () => ProofTarget,
   createZksRpc: () => createZksRpc,
   normalizeBlockMetadata: () => normalizeBlockMetadata,
   normalizeGenesis: () => normalizeGenesis,
@@ -27,6 +28,11 @@ async function withRpcOp(operation, message, ctx, fn) {
 }
 
 // src/core/rpc/zks.ts
+var ProofTarget = /* @__PURE__ */ ((ProofTarget2) => {
+  ProofTarget2["L1BatchRoot"] = "l1BatchRoot";
+  ProofTarget2["MessageRoot"] = "messageRoot";
+  return ProofTarget2;
+})(ProofTarget || {});
 var METHODS = {
   getBridgehub: "zks_getBridgehubContract",
   getL2ToL1LogProof: "zks_getL2ToL1LogProof",
@@ -44,6 +50,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",
@@ -64,7 +71,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;
@@ -341,13 +349,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",
@@ -404,12 +414,4 @@ function createZksRpc(transport) {
   };
 }
 
-// src/core/rpc/transport.ts
-function makeTransportFromEthers(provider) {
-  return (m, p = []) => provider.send(m, p);
-}
-function makeTransportFromViem(client) {
-  return (m, p = []) => client.request({ method: m, params: p });
-}
-
-export { createZksRpc, makeTransportFromEthers, makeTransportFromViem, zks_exports };
+export { createZksRpc, zks_exports };

package/dist/{chunk-5L6EYUJB.js → chunk-EOBXYHTZ.js}

@@ -1,5 +1,5 @@
-import { IBridgehub_default } from './chunk-RI73VJSH.js';
-import { BUFFER, DEFAULT_ABI_BYTES, DEFAULT_PUBDATA_BYTES, TX_MEMORY_OVERHEAD_GAS, TX_OVERHEAD_GAS } from './chunk-QQ2OR434.js';
+import { IBridgehub_default } from './chunk-JY62QO3W.js';
+import { L1_TX_MIN_L2_GAS_BASE, L1_TX_INTRINSIC_L2_GAS, L1_TX_DELTA_544_ENCODING_BYTES, L1_TX_DELTA_FACTORY_DEPS_L2_GAS, L1_TX_INTRINSIC_PUBDATA, L1_TX_DELTA_FACTORY_DEPS_PUBDATA, TX_MEMORY_OVERHEAD_GAS, TX_SLOT_OVERHEAD_L2_GAS, PRIORITY_TX_MAX_GAS_LIMIT, BUFFER, DEFAULT_ABI_BYTES, DEFAULT_PUBDATA_BYTES, TX_OVERHEAD_GAS } from './chunk-MT4X5FEO.js';
 
 // src/core/codec/ntv.ts
 function createNTVCodec(deps) {
@@ -49,6 +49,36 @@ 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/core/resources/deposits/gas.ts
 function makeGasQuote(p) {
   const maxPriorityFeePerGas = p.maxPriorityFeePerGas ?? 0n;
@@ -102,11 +132,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;
   }
 }
@@ -144,8 +173,7 @@ async function quoteL2Gas(input) {
       maxFeePerGas,
       gasPerPubdata: pp
     });
-  } catch (err) {
-    console.warn("L2 gas estimation failed", err);
+  } catch {
     return makeGasQuote({
       gasLimit: l2GasLimit ?? 0n,
       maxFeePerGas,
@@ -234,4 +262,4 @@ async function quoteL2Gas2(input) {
   }
 }
 
-export { buildFeeBreakdown, createNTVCodec, quoteL1Gas, quoteL2BaseCost, quoteL2Gas, quoteL2Gas2, toGasOverrides };
+export { buildFeeBreakdown, createNTVCodec, derivePriorityBodyGasEstimateCap, derivePriorityTxGasBreakdown, quoteL1Gas, quoteL2BaseCost, quoteL2Gas, quoteL2Gas2, toGasOverrides };

package/dist/{chunk-53MC5BR2.js → chunk-HP3EWKJL.js}

@@ -1,4 +1,4 @@
-import { isZKsyncError, createError, shapeCause } from './chunk-RI73VJSH.js';
+import { isZKsyncError, createError, shapeCause } from './chunk-JY62QO3W.js';
 
 // src/core/errors/error-ops.ts
 function resolveMessage(op, msg) {

package/dist/{chunk-HI64OOAR.js → chunk-J47RI3G7.js}

@@ -1,4 +1,4 @@
-import { isETH, normalizeAddrEq } from './chunk-RI73VJSH.js';
+import { isETH, normalizeAddrEq } from './chunk-JY62QO3W.js';
 
 // src/core/resources/deposits/route.ts
 async function pickDepositRoute(client, chainIdL2, token) {