@matterlabs/zksync-js 0.0.16 → 0.0.18

package/dist/adapters/viem/index.js

@@ -1,5 +1,5 @@
-export { buildDirectRequestStruct, createContractsResource, createDepositsResource, createFinalizationServices, createInteropFinalizationServices, createInteropResource, createTokensResource, createViemSdk, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs } from '../../chunk-3KH5PCD6.js';
-import '../../chunk-NLUCYVMX.js';
+export { buildDirectRequestStruct, createContractsResource, createDepositsResource, createFinalizationServices, createInteropFinalizationServices, createInteropResource, createTokensResource, createViemSdk, createWithdrawalsResource, encodeNativeTokenVaultTransferData, encodeSecondBridgeArgs, encodeSecondBridgeDataV1, encodeSecondBridgeErc20Args, encodeSecondBridgeEthArgs, getL2TransactionHashFromLogs } from '../../chunk-GBS7KQFU.js';
+import '../../chunk-6LYAENO6.js';
 import '../../chunk-3HHUZXSV.js';
 export { createViemClient as createClient, createViemClient } from '../../chunk-CK5UFAZK.js';
 export { classifyReadinessFromRevert, createErrorHandlers, decodeRevert, registerErrorAbi, toZKsyncError } from '../../chunk-SBGBYZJM.js';

package/dist/adapters/viem/resources/deposits/routes/approval.d.ts

@@ -0,0 +1,11 @@
+import type { Address } from '../../../../../core/types/primitives';
+import type { BuildCtx } from '../context';
+import type { ViemPlanWriteRequest } from './types';
+type BuildApprovalRequestInput = {
+    ctx: BuildCtx;
+    token: Address;
+    spender: Address;
+    amount: bigint;
+};
+export declare function buildApprovalRequest({ ctx, token, spender, amount, }: BuildApprovalRequestInput): Promise<ViemPlanWriteRequest>;
+export {};

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

@@ -8,6 +8,7 @@ import type { InteropRouteStrategy, ViemTransactionRequest } from './routes/type
 import { createInteropFinalizationServices, type InteropFinalizationServices } from './services/finalization';
 import { type LogsQueryOptions } from './services/finalization/data-fetchers';
 import type { ChainRef, InteropConfig } from './types';
+import type { TxGasOverrides } from '../../../../core/types/fees';
 export declare const ROUTES: Record<InteropRoute, InteropRouteStrategy>;
 export interface InteropResource {
     quote(dstChain: ChainRef, params: InteropParams): Promise<InteropQuote>;
@@ -49,8 +50,8 @@ export interface InteropResource {
         ok: false;
         error: unknown;
     }>;
-    finalize(dstChain: ChainRef, h: InteropWaitable | InteropFinalizationInfo, opts?: LogsQueryOptions): Promise<InteropFinalizationResult>;
-    tryFinalize(dstChain: ChainRef, h: InteropWaitable | InteropFinalizationInfo, opts?: LogsQueryOptions): Promise<{
+    finalize(dstChain: ChainRef, h: InteropWaitable | InteropFinalizationInfo, opts?: LogsQueryOptions, txOverrides?: TxGasOverrides): Promise<InteropFinalizationResult>;
+    tryFinalize(dstChain: ChainRef, h: InteropWaitable | InteropFinalizationInfo, opts?: LogsQueryOptions, txOverrides?: TxGasOverrides): Promise<{
         ok: true;
         value: InteropFinalizationResult;
     } | {

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

@@ -1,6 +1,7 @@
 import { type PublicClient, type TransactionReceipt } from 'viem';
 import type { Hex } from '../../../../../../core/types/primitives';
 import type { InteropFinalizationInfo } from '../../../../../../core/types/flows/interop';
+import type { TxGasOverrides } from '../../../../../../core/types/fees';
 import type { ViemClient } from '../../../../client';
 import type { InteropPhase } from '../../../../../../core/types/flows/interop';
 import type { InteropTopics } from '../../../../../../core/resources/interop/events';
@@ -9,7 +10,7 @@ export declare function getBundleStatus(client: ViemClient, dstProvider: PublicC
     phase: InteropPhase;
     dstExecTxHash?: Hex;
 }>;
-export declare function executeBundle(client: ViemClient, dstProvider: PublicClient, info: InteropFinalizationInfo, opts?: LogsQueryOptions): Promise<{
+export declare function executeBundle(client: ViemClient, dstProvider: PublicClient, info: InteropFinalizationInfo, opts?: LogsQueryOptions, txOverrides?: TxGasOverrides): Promise<{
     hash: Hex;
     wait: () => Promise<TransactionReceipt>;
 }>;

package/dist/adapters/viem/resources/interop/services/finalization/index.d.ts

@@ -2,12 +2,13 @@ import type { PublicClient } from 'viem';
 import type { InteropStatus, InteropWaitable, InteropFinalizationInfo, InteropFinalizationResult } from '../../../../../../core/types/flows/interop';
 import type { ViemClient } from '../../../../client';
 import type { LogsQueryOptions } from './data-fetchers';
+import type { TxGasOverrides } from '../../../../../../core/types/fees';
 export interface InteropFinalizationServices {
     status(dstProvider: PublicClient, input: InteropWaitable, opts?: LogsQueryOptions): Promise<InteropStatus>;
     wait(dstProvider: PublicClient, gwProvider: PublicClient, input: InteropWaitable, opts?: {
         pollMs?: number;
         timeoutMs?: number;
     }): Promise<InteropFinalizationInfo>;
-    finalize(dstProvider: PublicClient, info: InteropFinalizationInfo, opts?: LogsQueryOptions): Promise<InteropFinalizationResult>;
+    finalize(dstProvider: PublicClient, info: InteropFinalizationInfo, opts?: LogsQueryOptions, txOverrides?: TxGasOverrides): Promise<InteropFinalizationResult>;
 }
 export declare function createInteropFinalizationServices(client: ViemClient): InteropFinalizationServices;

package/dist/adapters/viem/sdk.cjs

@@ -6533,8 +6533,8 @@ 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 ERAVM_PRIORITY_L2_GAS_BUFFER = 30n;
+var DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER = 7n;
+var PRIORITY_L2_GAS_BUFFER = 40n;
 var maxBigInt2 = (a, b) => a > b ? a : b;
 var ceilDiv = (a, b) => (a + b - 1n) / b;
 function derivePriorityTxGasBreakdown(input) {
@@ -6562,10 +6562,7 @@ function derivePriorityBodyGasEstimateCap(input) {
   return input.minBodyGas * (input.multiplier ?? DEFAULT_PRIORITY_BODY_GAS_ESTIMATE_MULTIPLIER);
 }
 function applyPriorityL2GasLimitBuffer(input) {
-  if (!isEraVmChain(input.chainIdL2)) {
-    return input.gasLimit;
-  }
-  return input.gasLimit * (100n + ERAVM_PRIORITY_L2_GAS_BUFFER) / 100n;
+  return input.gasLimit * (100n + PRIORITY_L2_GAS_BUFFER) / 100n;
 }
 var EMPTY_BYTES = "0x";
 var ZERO_RESERVED_WORDS = [0n, 0n, 0n, 0n];
@@ -6732,8 +6729,73 @@ function routeEthDirect() {
     }
   };
 }
+
+// src/adapters/viem/resources/deposits/routes/approval.ts
+function errorText(error) {
+  const parts = [];
+  let current = error;
+  for (let depth = 0; current && depth < 8; depth++) {
+    const record = current;
+    for (const key of ["name", "shortMessage", "message", "details"]) {
+      const value = record[key];
+      if (typeof value === "string") parts.push(value);
+    }
+    current = record.cause;
+  }
+  return parts.join("\n");
+}
+function isNoReturnApproveSimulationError(error) {
+  const text = errorText(error);
+  return /approve/i.test(text) && (/returned no data/i.test(text) || /return(?:ed)? data[^\n]*0x/i.test(text) || /0x[^\n]*no data/i.test(text));
+}
+async function buildApprovalRequest({
+  ctx,
+  token,
+  spender,
+  amount
+}) {
+  try {
+    const sim = await ctx.client.l1.simulateContract({
+      address: token,
+      abi: IERC20_default,
+      functionName: "approve",
+      args: [spender, amount],
+      account: ctx.client.account
+    });
+    return { ...sim.request };
+  } catch (error) {
+    if (!isNoReturnApproveSimulationError(error)) {
+      throw error;
+    }
+    return {
+      address: token,
+      abi: IERC20_default,
+      functionName: "approve",
+      args: [spender, amount],
+      account: ctx.client.account
+    };
+  }
+}
+
+// src/adapters/viem/resources/deposits/routes/erc20-nonbase.ts
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
 var ZERO_ASSET_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
+async function encodeSecondBridgeErc20DepositCalldata(input) {
+  if (!input.ctx.resolvedToken) {
+    return encodeSecondBridgeErc20Args(input.token, input.amount, input.receiver);
+  }
+  const l1ChainId = BigInt(await input.ctx.client.l1.getChainId());
+  const isL1Origin = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID || input.ctx.resolvedToken.originChainId === 0n || input.ctx.resolvedToken.originChainId === l1ChainId;
+  if (isL1Origin) {
+    return encodeSecondBridgeErc20Args(input.token, input.amount, input.receiver);
+  }
+  const transferData = encodeNativeTokenVaultTransferData(
+    input.amount,
+    input.receiver,
+    input.token
+  );
+  return encodeSecondBridgeDataV1(input.ctx.resolvedToken.assetId, transferData);
+}
 async function getPriorityGasModel(input) {
   try {
     const l1NativeTokenVault = await input.ctx.contracts.l1NativeTokenVault();
@@ -6823,10 +6885,15 @@ function routeErc20NonBase() {
       const secondBridgeCalldata = await wrapAs3(
         "INTERNAL",
         OP_DEPOSITS.nonbase.encodeCalldata,
-        () => Promise.resolve(encodeSecondBridgeErc20Args(p.token, p.amount, receiver)),
+        () => encodeSecondBridgeErc20DepositCalldata({
+          ctx,
+          token: p.token,
+          amount: p.amount,
+          receiver
+        }),
         {
           ctx: {
-            where: "encodeSecondBridgeErc20Args",
+            where: "encodeSecondBridgeErc20DepositCalldata",
             token: p.token,
             amount: p.amount.toString()
           },
@@ -6871,15 +6938,14 @@ function routeErc20NonBase() {
         }
       );
       if (depositAllowance < p.amount) {
-        const approveSim = await wrapAs3(
+        const approveTx = await wrapAs3(
           "CONTRACT",
           OP_DEPOSITS.nonbase.estGas,
-          () => ctx.client.l1.simulateContract({
-            address: p.token,
-            abi: IERC20_default,
-            functionName: "approve",
-            args: [assetRouter, p.amount],
-            account: ctx.client.account
+          () => buildApprovalRequest({
+            ctx,
+            token: p.token,
+            spender: assetRouter,
+            amount: p.amount
           }),
           {
             ctx: { where: "l1.simulateContract", to: p.token },
@@ -6891,7 +6957,7 @@ function routeErc20NonBase() {
           key: `approve:${p.token}:${assetRouter}`,
           kind: "approve",
           description: `Approve deposit token for amount`,
-          tx: { ...approveSim.request }
+          tx: approveTx
         });
       }
       if (!baseIsEth) {
@@ -6910,15 +6976,14 @@ function routeErc20NonBase() {
           }
         );
         if (baseAllowance < mintValue) {
-          const approveBaseSim = await wrapAs3(
+          const approveBaseTx = await wrapAs3(
             "CONTRACT",
             OP_DEPOSITS.nonbase.estGas,
-            () => ctx.client.l1.simulateContract({
-              address: baseToken,
-              abi: IERC20_default,
-              functionName: "approve",
-              args: [assetRouter, mintValue],
-              account: ctx.client.account
+            () => buildApprovalRequest({
+              ctx,
+              token: baseToken,
+              spender: assetRouter,
+              amount: mintValue
             }),
             {
               ctx: { where: "l1.simulateContract", to: baseToken },
@@ -6930,7 +6995,7 @@ function routeErc20NonBase() {
             key: `approve:${baseToken}:${assetRouter}`,
             kind: "approve",
             description: `Approve base token for mintValue`,
-            tx: { ...approveBaseSim.request }
+            tx: approveBaseTx
           });
         }
       }
@@ -7182,15 +7247,14 @@ function routeEthNonBase() {
       );
       const needsApprove = allowance < mintValue;
       if (needsApprove) {
-        const approveSim = await wrapAs4(
+        const approveTx = await wrapAs4(
           "CONTRACT",
           OP_DEPOSITS.ethNonBase.estGas,
-          () => ctx.client.l1.simulateContract({
-            address: baseToken,
-            abi: IERC20_default,
-            functionName: "approve",
-            args: [ctx.l1AssetRouter, mintValue],
-            account: ctx.client.account
+          () => buildApprovalRequest({
+            ctx,
+            token: baseToken,
+            spender: ctx.l1AssetRouter,
+            amount: mintValue
           }),
           {
             ctx: { where: "l1.simulateContract", to: baseToken },
@@ -7202,7 +7266,7 @@ function routeEthNonBase() {
           key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
           kind: "approve",
           description: `Approve base token for fees (mintValue)`,
-          tx: { ...approveSim.request }
+          tx: approveTx
         });
       }
       const secondBridgeCalldata = await wrapAs4(
@@ -7382,15 +7446,14 @@ function routeErc20Base() {
       );
       const needsApprove = allowance < mintValue;
       if (needsApprove) {
-        const approveSim = await wrapAs5(
+        const approveTx = await wrapAs5(
           "CONTRACT",
           OP_DEPOSITS.base.estGas,
-          () => ctx.client.l1.simulateContract({
-            address: baseToken,
-            abi: IERC20_default,
-            functionName: "approve",
-            args: [ctx.l1AssetRouter, mintValue],
-            account: ctx.client.account
+          () => buildApprovalRequest({
+            ctx,
+            token: baseToken,
+            spender: ctx.l1AssetRouter,
+            amount: mintValue
           }),
           {
             ctx: { where: "l1.simulateContract", to: baseToken },
@@ -7402,7 +7465,7 @@ function routeErc20Base() {
           key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
           kind: "approve",
           description: "Approve base token for mintValue",
-          tx: { ...approveSim.request }
+          tx: approveTx
         });
       }
       const req = buildDirectRequestStruct({
@@ -9709,13 +9772,23 @@ function routeIndirect() {
 }
 function routeDirect() {
   return {
-    // eslint-disable-next-line @typescript-eslint/require-await
     async preflight(params, ctx) {
       preflightDirect(params, {
         dstChainId: ctx.dstChainId,
         baseTokens: ctx.baseTokens,
         l2AssetRouter: ctx.l2AssetRouter,
         l2NativeTokenVault: ctx.l2NativeTokenVault});
+      for (const action of params.actions) {
+        const bytecode = await ctx.dstPublicClient.getCode({ address: action.to });
+        if (!bytecode || bytecode === "0x") {
+          throw createError("VALIDATION", {
+            resource: "interop",
+            operation: OP_INTEROP.routes.direct.preflight,
+            message: `Destination address ${action.to} is not a contract on the destination chain. The receiver must be a contract that implements the IERC7786Recipient interface (receiveMessage).`,
+            context: { to: action.to, action: action.type }
+          });
+        }
+      }
     },
     async build(params, ctx) {
       const steps = [];
@@ -9975,7 +10048,7 @@ async function getBundleStatus(client, dstProvider, topics, bundleHash, opts) {
   }
   return { phase: "SENT" };
 }
-async function executeBundle(client, dstProvider, info, opts) {
+async function executeBundle(client, dstProvider, info, opts, txOverrides) {
   const { topics } = getTopics();
   const { bundleHash, encodedData, proof } = info;
   const dstStatus = await getBundleStatus(client, dstProvider, topics, bundleHash, opts);
@@ -10004,7 +10077,10 @@ async function executeBundle(client, dstProvider, info, opts) {
       functionName: "executeBundle",
       args: [encodedData, proof],
       account: client.account,
-      chain: dstProvider.chain ?? null
+      chain: dstProvider.chain ?? null,
+      gas: txOverrides?.gasLimit,
+      maxFeePerGas: txOverrides?.maxFeePerGas,
+      maxPriorityFeePerGas: txOverrides?.maxPriorityFeePerGas
     });
     return {
       hash,
@@ -10461,8 +10537,8 @@ function createInteropFinalizationServices(client) {
     wait(dstProvider, gwProvider, input, opts) {
       return waitForFinalization(client, dstProvider, gwProvider, input, opts);
     },
-    async finalize(dstProvider, info, opts) {
-      const execResult = await executeBundle(client, dstProvider, info, opts);
+    async finalize(dstProvider, info, opts, txOverrides) {
+      const execResult = await executeBundle(client, dstProvider, info, opts, txOverrides);
       await execResult.wait();
       return {
         bundleHash: info.bundleHash,
@@ -10690,22 +10766,25 @@ function createInteropResource(client, config, tokens, contracts, attributes) {
     ctx: { where: "interop.wait" }
   });
   const tryWait = (dstChain, h, opts) => toResult2(OP_INTEROP.tryWait, () => wait(dstChain, h, opts));
-  const finalize = (dstChain, h, opts) => wrap6(
+  const finalize = (dstChain, h, opts, txOverrides) => wrap6(
     OP_INTEROP.finalize,
     async () => {
       const dstProvider = resolveChainRef(dstChain);
       if (isInteropFinalizationInfo(h)) {
-        return svc.finalize(dstProvider, h, opts);
+        return svc.finalize(dstProvider, h, opts, txOverrides);
       }
       const info = await svc.wait(dstProvider, getGwProvider(), h);
-      return svc.finalize(dstProvider, info, opts);
+      return svc.finalize(dstProvider, info, opts, txOverrides);
     },
     {
       message: "Failed to finalize/execute interop bundle on destination.",
       ctx: { where: "interop.finalize" }
     }
   );
-  const tryFinalize = (dstChain, h, opts) => toResult2(OP_INTEROP.tryFinalize, () => finalize(dstChain, h, opts));
+  const tryFinalize = (dstChain, h, opts, txOverrides) => toResult2(
+    OP_INTEROP.tryFinalize,
+    () => finalize(dstChain, h, opts, txOverrides)
+  );
   const interopGetRoot = (dstChain, rootChainId, batchNumber) => wrap6(
     OP_INTEROP.svc.status.getRoot,
     () => getInteropRoot(resolveChainRef(dstChain), rootChainId, batchNumber),