@matterlabs/zksync-js 0.0.14 → 0.0.16

package/dist/adapters/ethers/index.js

@@ -1,10 +1,9 @@
-export { createEthersClient as createClient, createEthersClient } from '../../chunk-7CAVFIMW.js';
-export { buildDirectRequestStruct, createDepositsResource, createEthersSdk, createFinalizationServices, createInteropFinalizationServices, createInteropResource, createTokensResource, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs } from '../../chunk-XKRNLFET.js';
-export { classifyReadinessFromRevert, createErrorHandlers, decodeRevert, registerErrorAbi, toZKsyncError } from '../../chunk-5RRJDPAJ.js';
-import '../../chunk-EOBXYHTZ.js';
+export { createEthersClient as createClient, createEthersClient } from '../../chunk-24TE2NNJ.js';
+export { buildDirectRequestStruct, createDepositsResource, createEthersSdk, createFinalizationServices, createInteropFinalizationServices, createInteropResource, createTokensResource, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs } from '../../chunk-5HG2DUYW.js';
+export { classifyReadinessFromRevert, createErrorHandlers, decodeRevert, registerErrorAbi, toZKsyncError } from '../../chunk-NJK325XV.js';
+import '../../chunk-NLUCYVMX.js';
 import '../../chunk-3HHUZXSV.js';
 import '../../chunk-BWKWWLY4.js';
-import '../../chunk-HP3EWKJL.js';
-import '../../chunk-DYJKK5FW.js';
-import '../../chunk-JY62QO3W.js';
+import '../../chunk-JSBMIT4S.js';
+import '../../chunk-UEKFQAOS.js';
 import '../../chunk-MT4X5FEO.js';

package/dist/adapters/ethers/resources/interop/index.d.ts

@@ -1,4 +1,5 @@
 import type { EthersClient } from '../../client';
+import type { Hex } from '../../../../core/types/primitives';
 import type { AttributesResource } from '../../../../core/resources/interop/attributes/resource';
 import type { InteropRoute, InteropPlan, InteropQuote, InteropStatus, InteropFinalizationResult, InteropParams, InteropHandle, InteropWaitable, InteropFinalizationInfo } from '../../../../core/types/flows/interop';
 import type { ContractsResource } from '../contracts';
@@ -6,7 +7,7 @@ import type { TokensResource } from '../../../../core/types/flows/token';
 import type { InteropRouteStrategy } from './routes/types';
 import type { TransactionRequest } from 'ethers';
 import { createInteropFinalizationServices, type InteropFinalizationServices } from './services/finalization';
-import type { LogsQueryOptions } from './services/finalization/data-fetchers';
+import { type LogsQueryOptions } from './services/finalization/data-fetchers';
 import type { ChainRef, InteropConfig } from './types';
 export declare const ROUTES: Record<InteropRoute, InteropRouteStrategy>;
 export interface InteropResource {
@@ -57,6 +58,8 @@ export interface InteropResource {
         ok: false;
         error: unknown;
     }>;
+    getInteropRoot(dstChain: ChainRef, rootChainId: bigint, batchNumber: bigint): Promise<Hex>;
+    verifyBundle(dstChain: ChainRef, h: InteropWaitable | InteropFinalizationInfo): Promise<InteropFinalizationResult>;
 }
 export declare function createInteropResource(client: EthersClient, config?: InteropConfig, tokens?: TokensResource, contracts?: ContractsResource, attributes?: AttributesResource): InteropResource;
 export { createInteropFinalizationServices };

package/dist/adapters/ethers/resources/interop/services/finalization/bundle.d.ts

@@ -13,3 +13,7 @@ export declare function executeBundle(client: EthersClient, dstProvider: Abstrac
     hash: Hex;
     wait: () => Promise<TransactionReceipt>;
 }>;
+export declare function verifyBundle(client: EthersClient, dstProvider: AbstractProvider, info: InteropFinalizationInfo): Promise<{
+    hash: Hex;
+    wait: () => Promise<TransactionReceipt>;
+}>;

package/dist/adapters/ethers/resources/interop/services/gas.d.ts

@@ -0,0 +1,12 @@
+import type { TransactionRequest } from 'ethers';
+import type { BuildCtx } from '../context';
+/**
+ * Estimates the combined L2 gas cost for all steps in an interop plan.
+ *
+ * Fetches gas price once, then estimates gas for each step using ctx.sender as the
+ * from address. Applies the standard buffer and sums gasLimit × maxFeePerGas across
+ * all steps. Returns undefined if estimation fails for any step.
+ */
+export declare function quoteStepsL2Fee(steps: Array<{
+    tx: TransactionRequest;
+}>, ctx: BuildCtx): Promise<bigint | undefined>;

package/dist/adapters/ethers/sdk.cjs

@@ -377,6 +377,7 @@ var OP_INTEROP = {
   tryWait: "interop.tryWait",
   finalize: "interop.finalize",
   tryFinalize: "interop.tryFinalize",
+  verify: "interop.verify",
   context: {
     chainTypeManager: "interop.chainTypeManager",
     protocolVersion: "interop.protocolVersion"
@@ -5930,7 +5931,33 @@ function buildDirectRequestStruct(args) {
   };
 }
 
+// src/core/resources/deposits/chains.ts
+var ERAVM_CHAIN_IDS = /* @__PURE__ */ new Set([324n, 2741n, 11124n, 300n]);
+function isEraVmChain(chainIdL2) {
+  return ERAVM_CHAIN_IDS.has(chainIdL2);
+}
+
 // src/core/resources/deposits/gas.ts
+var CREATE_REESTIMATE_BUFFER = 15n;
+var maxBigInt = (a, b) => a > b ? a : b;
+function applyGasBuffer(gasLimit, bufferPct = BUFFER) {
+  return gasLimit * (100n + bufferPct) / 100n;
+}
+function resolveCreateDepositL1GasLimit(input) {
+  const { chainIdL2, stepKey, preparedGasLimit, estimatedGasLimit } = input;
+  if (estimatedGasLimit == null) {
+    return preparedGasLimit;
+  }
+  const isEraVmBridgeStep = isEraVmChain(chainIdL2) && stepKey.startsWith("bridgehub:");
+  const reestimatedGasLimit = applyGasBuffer(
+    estimatedGasLimit,
+    isEraVmBridgeStep ? BUFFER : CREATE_REESTIMATE_BUFFER
+  );
+  if (isEraVmBridgeStep && preparedGasLimit != null) {
+    return maxBigInt(preparedGasLimit, reestimatedGasLimit);
+  }
+  return reestimatedGasLimit;
+}
 function makeGasQuote(p) {
   const maxPriorityFeePerGas = p.maxPriorityFeePerGas ?? 0n;
   return {
@@ -5981,7 +6008,7 @@ async function quoteL1Gas(input) {
   }
   try {
     const est = await estimator.estimateGas(tx);
-    const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+    const buffered = applyGasBuffer(BigInt(est));
     return makeGasQuote({ gasLimit: buffered, maxFeePerGas, maxPriorityFeePerGas });
   } catch {
     if (fallbackGasLimit != null) {
@@ -6018,7 +6045,7 @@ async function quoteL2Gas(input) {
     const memoryOverhead = memoryBytes * TX_MEMORY_OVERHEAD_GAS;
     const pubdataOverhead = pubdataBytes * pp;
     let total = BigInt(execEstimate) + TX_OVERHEAD_GAS + memoryOverhead + pubdataOverhead;
-    total = total * (100n + BUFFER) / 100n;
+    total = applyGasBuffer(total);
     return makeGasQuote({
       gasLimit: total,
       maxFeePerGas,
@@ -6455,18 +6482,19 @@ 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 ERAVM_PRIORITY_L2_GAS_BUFFER = 30n;
+var maxBigInt2 = (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(
+  const minBodyGas = maxBigInt2(
     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 overhead = maxBigInt2(TX_SLOT_OVERHEAD_L2_GAS, TX_MEMORY_OVERHEAD_GAS * input.encodedLength);
   const derivedBodyGas = minBodyGas;
   return {
     encodedLength: input.encodedLength,
@@ -6481,8 +6509,12 @@ function derivePriorityTxGasBreakdown(input) {
 function derivePriorityBodyGasEstimateCap(input) {
   return input.minBodyGas * (input.multiplier ?? DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER);
 }
-
-// src/adapters/ethers/resources/deposits/routes/priority.ts
+function applyPriorityL2GasLimitBuffer(input) {
+  if (!isEraVmChain(input.chainIdL2)) {
+    return input.gasLimit;
+  }
+  return input.gasLimit * (100n + ERAVM_PRIORITY_L2_GAS_BUFFER) / 100n;
+}
 var EMPTY_BYTES = "0x";
 var ZERO_RESERVED_WORDS = [0n, 0n, 0n, 0n];
 var L2_CANONICAL_TRANSACTION_TUPLE = "tuple(uint256 txType,uint256 from,uint256 to,uint256 gasLimit,uint256 gasPerPubdataByteLimit,uint256 maxFeePerGas,uint256 maxPriorityFeePerGas,uint256 paymaster,uint256 nonce,uint256 value,uint256[4] reserved,bytes data,bytes signature,uint256[] factoryDeps,bytes paymasterInput,bytes reservedDynamic)";
@@ -6539,7 +6571,10 @@ function routeEthDirect() {
         l2Calldata,
         gasPerPubdata: ctx.gasPerPubdata
       });
-      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
+      const quotedL2GasLimit = ctx.l2GasLimit ?? applyPriorityL2GasLimitBuffer({
+        chainIdL2: ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      });
       const l2GasParams = await quoteL2Gas2({
         ctx,
         route: "eth-base",
@@ -6642,7 +6677,10 @@ async function getPriorityGasModel(input) {
       gasPerPubdata: input.ctx.gasPerPubdata
     });
     const model = {
-      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      priorityFloorGasLimit: applyPriorityL2GasLimitBuffer({
+        chainIdL2: input.ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      })
     };
     if (isFirstBridge || input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS2) {
       model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
@@ -6864,7 +6902,10 @@ async function getPriorityGasModel2(input) {
       gasPerPubdata: input.ctx.gasPerPubdata
     });
     const model = {
-      priorityFloorGasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      priorityFloorGasLimit: applyPriorityL2GasLimitBuffer({
+        chainIdL2: input.ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      })
     };
     if (input.ctx.resolvedToken.l2.toLowerCase() === ZERO_L2_TOKEN_ADDRESS3) {
       model.undeployedGasLimit = derivePriorityBodyGasEstimateCap({
@@ -6986,7 +7027,7 @@ function routeEthNonBase() {
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
-        l2Value: p.amount,
+        l2Value: 0n,
         l2GasLimit: l2GasParams.gasLimit,
         l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
@@ -6994,6 +7035,7 @@ function routeEthNonBase() {
         secondBridgeValue: p.amount,
         secondBridgeCalldata
       };
+      const bridgehubValue = p.amount;
       const bridgehub = await ctx.contracts.bridgehub();
       const data = bridgehub.interface.encodeFunctionData("requestL2TransactionTwoBridges", [
         requestStruct
@@ -7001,8 +7043,7 @@ function routeEthNonBase() {
       const l1TxCandidate = {
         to: ctx.bridgehub,
         data,
-        value: p.amount,
-        // base ≠ ETH ⇒ msg.value == secondBridgeValue
+        value: bridgehubValue,
         from: ctx.sender,
         ...ctx.gasOverrides
       };
@@ -7081,7 +7122,10 @@ function routeErc20Base() {
         l2Calldata,
         gasPerPubdata: ctx.gasPerPubdata
       });
-      const quotedL2GasLimit = ctx.l2GasLimit ?? priorityFloorBreakdown.derivedL2GasLimit;
+      const quotedL2GasLimit = ctx.l2GasLimit ?? applyPriorityL2GasLimitBuffer({
+        chainIdL2: ctx.chainIdL2,
+        gasLimit: priorityFloorBreakdown.derivedL2GasLimit
+      });
       const l2GasParams = await quoteL2Gas2({
         ctx,
         route: "erc20-base",
@@ -7507,6 +7551,8 @@ function createDepositsResource(client, tokens, contracts) {
     async () => {
       const plan = await prepare(p);
       const stepHashes = {};
+      const { chainId } = await client.l2.getNetwork();
+      const chainIdL2 = BigInt(chainId);
       const managed = new ethers.NonceManager(client.signer);
       const from = await managed.getAddress();
       let next;
@@ -7552,8 +7598,14 @@ function createDepositsResource(client, tokens, contracts) {
         }
         if (!p.l1TxOverrides?.gasLimit) {
           try {
+            const preparedGasLimit = step.tx.gasLimit != null ? BigInt(step.tx.gasLimit.toString()) : void 0;
             const est = await client.l1.estimateGas(step.tx);
-            step.tx.gasLimit = BigInt(est) * 115n / 100n;
+            step.tx.gasLimit = resolveCreateDepositL1GasLimit({
+              chainIdL2,
+              stepKey: step.key,
+              preparedGasLimit,
+              estimatedGasLimit: BigInt(est)
+            });
           } catch {
           }
         }
@@ -9172,26 +9224,30 @@ function routeDirect() {
     }
   };
 }
+
+// src/core/resources/interop/protocol.ts
 var MIN_INTEROP_PROTOCOL = 31;
+function assertProtocolVersion(chainId, protocolVersion) {
+  if (protocolVersion[1] < MIN_INTEROP_PROTOCOL) {
+    throw createError("VALIDATION", {
+      resource: "interop",
+      operation: OP_INTEROP.context.protocolVersion,
+      message: `Interop requires protocol version 31.0+. Found: ${protocolVersion[1]}.${protocolVersion[2]} for chain: ${chainId}.`,
+      context: {
+        chainId,
+        requiredMinor: MIN_INTEROP_PROTOCOL,
+        semver: protocolVersion
+      }
+    });
+  }
+}
+
+// src/adapters/ethers/resources/interop/context.ts
 async function assertInteropProtocolVersion(client, srcChainId, dstChainId) {
   const [srcProtocolVersion, dstProtocolVersion] = await Promise.all([
     client.getProtocolVersion(srcChainId),
     client.getProtocolVersion(dstChainId)
   ]);
-  const assertProtocolVersion = (chainId, protocolVersion) => {
-    if (protocolVersion[1] < MIN_INTEROP_PROTOCOL) {
-      throw createError("VALIDATION", {
-        resource: "interop",
-        operation: OP_INTEROP.context.protocolVersion,
-        message: `Interop requires protocol version 31.0+. Found: ${protocolVersion[1]}.${protocolVersion[2]} for chain: ${chainId}.`,
-        context: {
-          chainId,
-          requiredMinor: MIN_INTEROP_PROTOCOL,
-          semver: protocolVersion
-        }
-      });
-    }
-  };
   assertProtocolVersion(srcChainId, srcProtocolVersion);
   assertProtocolVersion(dstChainId, dstProtocolVersion);
 }
@@ -9262,7 +9318,14 @@ function parseMaxBlockRangeLimit(error) {
 async function getTxReceipt(provider, txHash) {
   const receipt = await wrap3(
     OP_INTEROP.svc.status.sourceReceipt,
-    () => provider.getTransactionReceipt(txHash),
+    async () => {
+      try {
+        return await provider.getTransactionReceipt(txHash);
+      } catch (error) {
+        if (isReceiptNotFound(error)) return null;
+        throw error;
+      }
+    },
     {
       ctx: { where: "l2.getTransactionReceipt", l2SrcTxHash: txHash },
       message: "Failed to fetch source L2 receipt for interop tx."
@@ -9427,6 +9490,60 @@ async function executeBundle(client, dstProvider, info, opts) {
     );
   }
 }
+async function verifyBundle(client, dstProvider, info) {
+  const signer = await wrap4(OP_INTEROP.verify, () => client.signerFor(dstProvider), {
+    message: "Failed to resolve destination signer for verifyBundle."
+  });
+  const { interopHandler } = await client.ensureAddresses();
+  const handler = new ethers.Contract(interopHandler, IInteropHandler_default, signer);
+  try {
+    const txResponse = await handler.verifyBundle(
+      info.encodedData,
+      info.proof
+    );
+    const hash = txResponse.hash;
+    return {
+      hash,
+      wait: async () => {
+        try {
+          const receipt = await txResponse.wait();
+          if (!receipt || receipt.status !== 1) {
+            throw createError("EXECUTION", {
+              resource: "interop",
+              operation: OP_INTEROP.verify,
+              message: "Interop bundle verification reverted on destination.",
+              context: { txHash: hash }
+            });
+          }
+          return receipt;
+        } catch (e) {
+          if (isZKsyncError(e)) throw e;
+          throw toZKsyncError(
+            "EXECUTION",
+            {
+              resource: "interop",
+              operation: OP_INTEROP.verify,
+              message: "Failed while waiting for verifyBundle transaction on destination.",
+              context: { txHash: hash }
+            },
+            e
+          );
+        }
+      }
+    };
+  } catch (e) {
+    if (isZKsyncError(e)) throw e;
+    throw toZKsyncError(
+      "EXECUTION",
+      {
+        resource: "interop",
+        operation: OP_INTEROP.verify,
+        message: "Failed to send verifyBundle transaction on destination chain."
+      },
+      e
+    );
+  }
+}
 
 // src/core/resources/interop/finalization.ts
 var DEFAULT_POLL_MS = 1e3;
@@ -9792,6 +9909,31 @@ function resolveChainRef(ref) {
   return typeof ref === "string" ? new ethers.JsonRpcProvider(ref) : ref;
 }
 
+// src/adapters/ethers/resources/interop/services/gas.ts
+async function quoteStepsL2Fee(steps, ctx) {
+  if (steps.length === 0) return 0n;
+  const estimator = ethersToGasEstimator(ctx.client.l2);
+  let maxFeePerGas;
+  try {
+    const fees = await estimator.estimateFeesPerGas();
+    maxFeePerGas = fees.maxFeePerGas ?? fees.gasPrice ?? await estimator.getGasPrice();
+  } catch {
+    return void 0;
+  }
+  let total = 0n;
+  for (const step of steps) {
+    try {
+      const coreTx = toCoreTx({ ...step.tx, from: ctx.sender });
+      const est = await estimator.estimateGas(coreTx);
+      const buffered = BigInt(est) * (100n + BUFFER) / 100n;
+      total += buffered * maxFeePerGas;
+    } catch {
+      return void 0;
+    }
+  }
+  return total;
+}
+
 // src/adapters/ethers/resources/interop/index.ts
 var { wrap: wrap6, toResult: toResult2 } = createErrorHandlers("interop");
 var ROUTES3 = {
@@ -9848,12 +9990,14 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
         ctx: { where: `routes.${route}.build` }
       }
     );
+    const l2Fee = await quoteStepsL2Fee(steps, ctx).catch(() => void 0);
     const summary = {
       route,
       approvalsNeeded: approvals,
       totalActionValue: quoteExtras.totalActionValue,
       bridgedTokenTotal: quoteExtras.bridgedTokenTotal,
-      interopFee
+      interopFee,
+      l2Fee
     };
     return { plan: { route, summary, steps }, ctx };
   }
@@ -9978,6 +10122,28 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
     }
   );
   const tryFinalize = (dstChain, h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(dstChain, h, opts));
+  const interopGetRoot = (dstChain, rootChainId, batchNumber) => wrap6(
+    OP_INTEROP.svc.status.getRoot,
+    () => getInteropRoot(resolveChainRef(dstChain), rootChainId, batchNumber),
+    {
+      message: "Failed to get interop root from the destination chain.",
+      ctx: { where: "interop.getInteropRoot" }
+    }
+  );
+  const verifyBundle2 = (dstChain, h) => wrap6(
+    OP_INTEROP.verify,
+    async () => {
+      const dstProvider = resolveChainRef(dstChain);
+      const info = isInteropFinalizationInfo(h) ? h : await svc.wait(dstProvider, getGwProvider(), h);
+      const result = await verifyBundle(client, dstProvider, info);
+      await result.wait();
+      return { bundleHash: info.bundleHash, dstExecTxHash: result.hash };
+    },
+    {
+      message: "Failed to verify interop bundle on destination.",
+      ctx: { where: "interop.verifyBundle" }
+    }
+  );
   return {
     quote,
     tryQuote,
@@ -9989,7 +10155,9 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
     wait,
     tryWait,
     finalize,
-    tryFinalize
+    tryFinalize,
+    getInteropRoot: interopGetRoot,
+    verifyBundle: verifyBundle2
   };
 }