@matterlabs/zksync-js 0.0.14 → 0.0.16

package/dist/adapters/ethers/client.d.ts

@@ -1,8 +1,7 @@
 import type { AbstractProvider, Signer } from 'ethers';
 import { Contract } from 'ethers';
-import type { Address } from '../../core/types/primitives';
+import type { Address, ProtocolVersion } from '../../core/types/primitives';
 import type { ZksRpc } from '../../core/rpc/zks';
-export type ProtocolVersion = readonly [number, number, number];
 export interface ResolvedAddresses {
     bridgehub: Address;
     l1AssetRouter: Address;

package/dist/adapters/ethers/client.js

@@ -1,7 +1,6 @@
-export { createEthersClient } from '../../chunk-7CAVFIMW.js';
-import '../../chunk-5RRJDPAJ.js';
+export { createEthersClient } from '../../chunk-24TE2NNJ.js';
+import '../../chunk-NJK325XV.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/index.cjs

@@ -389,6 +389,7 @@ var OP_INTEROP = {
   tryWait: "interop.tryWait",
   finalize: "interop.finalize",
   tryFinalize: "interop.tryFinalize",
+  verify: "interop.verify",
   context: {
     chainTypeManager: "interop.chainTypeManager",
     protocolVersion: "interop.protocolVersion"
@@ -8036,7 +8037,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 {
@@ -8087,7 +8114,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) {
@@ -8124,7 +8151,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,
@@ -8378,18 +8405,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,
@@ -8404,8 +8432,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)";
@@ -8462,7 +8494,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",
@@ -8560,7 +8595,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({
@@ -8782,7 +8820,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({
@@ -8904,7 +8945,7 @@ function routeEthNonBase() {
       const requestStruct = {
         chainId: ctx.chainIdL2,
         mintValue,
-        l2Value: p.amount,
+        l2Value: 0n,
         l2GasLimit: l2GasParams.gasLimit,
         l2GasPerPubdataByteLimit: ctx.gasPerPubdata,
         refundRecipient: ctx.refundRecipient,
@@ -8912,6 +8953,7 @@ function routeEthNonBase() {
         secondBridgeValue: p.amount,
         secondBridgeCalldata
       };
+      const bridgehubValue = p.amount;
       const bridgehub = await ctx.contracts.bridgehub();
       const data = bridgehub.interface.encodeFunctionData("requestL2TransactionTwoBridges", [
         requestStruct
@@ -8919,8 +8961,7 @@ function routeEthNonBase() {
       const l1TxCandidate = {
         to: ctx.bridgehub,
         data,
-        value: p.amount,
-        // base ≠ ETH ⇒ msg.value == secondBridgeValue
+        value: bridgehubValue,
         from: ctx.sender,
         ...ctx.gasOverrides
       };
@@ -8999,7 +9040,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",
@@ -9425,6 +9469,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;
@@ -9470,8 +9516,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 {
           }
         }
@@ -11090,26 +11142,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);
 }
@@ -11180,7 +11236,14 @@ function parseMaxBlockRangeLimit(error) {
 async function getTxReceipt(provider, txHash) {
   const receipt = await wrap4(
     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."
@@ -11345,6 +11408,60 @@ async function executeBundle(client, dstProvider, info, opts) {
     );
   }
 }
+async function verifyBundle(client, dstProvider, info) {
+  const signer = await wrap5(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;
@@ -11710,6 +11827,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: wrap7, toResult: toResult2 } = createErrorHandlers("interop");
 var ROUTES3 = {
@@ -11766,12 +11908,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 };
   }
@@ -11896,6 +12040,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) => wrap7(
+    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) => wrap7(
+    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,
@@ -11907,7 +12073,9 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
     wait,
     tryWait,
     finalize,
-    tryFinalize
+    tryFinalize,
+    getInteropRoot: interopGetRoot,
+    verifyBundle: verifyBundle2
   };
 }