@matterlabs/zksync-js 0.0.17 → 0.0.19

package/dist/adapters/viem/sdk.js

@@ -1,4 +1,4 @@
-export { createViemSdk } from '../../chunk-ONCNOWNC.js';
+export { createViemSdk } from '../../chunk-3T5V4HKS.js';
 import '../../chunk-6LYAENO6.js';
 import '../../chunk-3HHUZXSV.js';
 import '../../chunk-SBGBYZJM.js';

package/dist/{chunk-ONCNOWNC.js → chunk-3T5V4HKS.js}

@@ -461,15 +461,93 @@ 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";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => encodeAbiParameters(
+    types.map((t, i) => ({ type: t, name: `arg${i}` })),
+    values
+  ),
+  keccak256
+});
+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 expectedL1AssetId = ntvCodec.encodeAssetId(
+    l1ChainId,
+    L2_NATIVE_TOKEN_VAULT_ADDRESS,
+    input.token
+  );
+  const assetId = input.ctx.resolvedToken.assetId.toLowerCase();
+  const isL1Origin = assetId === ZERO_ASSET_ID || assetId === expectedL1AssetId.toLowerCase();
+  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();
     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 isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID;
+    const erc20MetadataOriginChainId = isFirstBridge ? l1ChainId : input.ctx.resolvedToken.originChainId !== 0n ? input.ctx.resolvedToken.originChainId : await l1NativeTokenVault.read.originChainId([input.ctx.resolvedToken.assetId]);
     const erc20Metadata = await l1NativeTokenVault.read.getERC20Getters([
       input.token,
       erc20MetadataOriginChainId
@@ -552,10 +630,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()
           },
@@ -600,15 +683,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 },
@@ -620,7 +702,7 @@ function routeErc20NonBase() {
           key: `approve:${p.token}:${assetRouter}`,
           kind: "approve",
           description: `Approve deposit token for amount`,
-          tx: { ...approveSim.request }
+          tx: approveTx
         });
       }
       if (!baseIsEth) {
@@ -639,15 +721,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 },
@@ -659,7 +740,7 @@ function routeErc20NonBase() {
             key: `approve:${baseToken}:${assetRouter}`,
             kind: "approve",
             description: `Approve base token for mintValue`,
-            tx: { ...approveBaseSim.request }
+            tx: approveBaseTx
           });
         }
       }
@@ -755,19 +836,19 @@ function routeErc20NonBase() {
 }
 var { wrapAs: wrapAs4 } = createErrorHandlers("deposits");
 var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => encodeAbiParameters(
     types.map((type, index) => ({ type, name: `arg${index}` })),
     values
   ),
-  keccak256
+  keccak256: 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 resolvedAssetId = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID2 ? ntvCodec2.encodeAssetId(originChainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, ETH_ADDRESS) : input.ctx.resolvedToken.assetId;
     const erc20Metadata = await l1NativeTokenVault.read.getERC20Getters([
       ETH_ADDRESS,
       originChainId
@@ -895,15 +976,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 },
@@ -915,7 +995,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(
@@ -1095,15 +1175,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 },
@@ -1115,7 +1194,7 @@ function routeErc20Base() {
           key: `approve:${baseToken}:${ctx.l1AssetRouter}`,
           kind: "approve",
           description: "Approve base token for mintValue",
-          tx: { ...approveSim.request }
+          tx: approveTx
         });
       }
       const req = buildDirectRequestStruct({
@@ -1287,7 +1366,7 @@ async function waitForL2ExecutionFromL1Tx(l1, l2, l1TxHash) {
   return { l2Receipt, l2TxHash };
 }
 var { wrapAs: wrapAs6 } = createErrorHandlers("tokens");
-var ntvCodec2 = createNTVCodec({
+var ntvCodec3 = createNTVCodec({
   encode: (types, values) => encodeAbiParameters(
     types.map((t, i) => ({ type: t, name: `arg${i}` })),
     values
@@ -1401,7 +1480,7 @@ function createTokensResource(client) {
     return wrapAs6("CONTRACT", "tokens.isChainEthBased", async () => {
       const baseAssetId = await getBaseTokenAssetId();
       const l1ChainId = await getL1ChainId();
-      const ethAssetId = ntvCodec2.encodeAssetId(
+      const ethAssetId = ntvCodec3.encodeAssetId(
         l1ChainId,
         L2_NATIVE_TOKEN_VAULT_ADDRESS,
         ETH_ADDRESS

package/dist/{chunk-J2RPWU2R.js → chunk-5H3VTIYD.js}

@@ -456,13 +456,39 @@ function routeEthDirect() {
 var { wrapAs: wrapAs2 } = createErrorHandlers("deposits");
 var ZERO_L2_TOKEN_ADDRESS2 = "0x0000000000000000000000000000000000000000";
 var ZERO_ASSET_ID = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var ntvCodec = createNTVCodec({
+  encode: (types, values) => AbiCoder.defaultAbiCoder().encode(types, values),
+  keccak256: (data) => keccak256(data)
+});
+async function encodeSecondBridgeErc20DepositCalldata(input) {
+  if (!input.ctx.resolvedToken) {
+    return encodeSecondBridgeErc20Args(input.token, input.amount, input.receiver);
+  }
+  const { chainId } = await input.ctx.client.l1.getNetwork();
+  const expectedL1AssetId = ntvCodec.encodeAssetId(
+    BigInt(chainId),
+    L2_NATIVE_TOKEN_VAULT_ADDRESS,
+    input.token
+  );
+  const assetId = input.ctx.resolvedToken.assetId.toLowerCase();
+  const isL1Origin = assetId === ZERO_ASSET_ID || assetId === expectedL1AssetId.toLowerCase();
+  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();
     const l1AssetRouter = await input.ctx.contracts.l1AssetRouter();
     const { chainId: l1ChainId } = await input.ctx.client.l1.getNetwork();
-    const isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID || input.ctx.resolvedToken.originChainId === 0n;
-    const erc20MetadataOriginChainId = isFirstBridge ? BigInt(l1ChainId) : input.ctx.resolvedToken.originChainId;
+    const isFirstBridge = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID;
+    const erc20MetadataOriginChainId = isFirstBridge ? BigInt(l1ChainId) : input.ctx.resolvedToken.originChainId !== 0n ? input.ctx.resolvedToken.originChainId : await l1NativeTokenVault.originChainId(input.ctx.resolvedToken.assetId);
     const erc20Metadata = await l1NativeTokenVault.getERC20Getters(
       input.token,
       erc20MetadataOriginChainId
@@ -528,9 +554,14 @@ function routeErc20NonBase() {
       const secondBridgeCalldata = await wrapAs2(
         "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" },
+          ctx: { where: "encodeSecondBridgeErc20DepositCalldata" },
           message: "Failed to encode bridging calldata."
         }
       );
@@ -667,7 +698,7 @@ function routeErc20NonBase() {
 var { wrapAs: wrapAs3 } = createErrorHandlers("deposits");
 var ZERO_L2_TOKEN_ADDRESS3 = "0x0000000000000000000000000000000000000000";
 var ZERO_ASSET_ID2 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var ntvCodec = createNTVCodec({
+var ntvCodec2 = createNTVCodec({
   encode: (types, values) => AbiCoder.defaultAbiCoder().encode(types, values),
   keccak256: (data) => keccak256(data)
 });
@@ -676,7 +707,7 @@ async function getPriorityGasModel2(input) {
     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.getNetwork()).chainId);
-    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 resolvedAssetId = input.ctx.resolvedToken.assetId.toLowerCase() === ZERO_ASSET_ID2 ? ntvCodec2.encodeAssetId(originChainId, L2_NATIVE_TOKEN_VAULT_ADDRESS, ETH_ADDRESS) : input.ctx.resolvedToken.assetId;
     const erc20Metadata = await l1NativeTokenVault.getERC20Getters(
       ETH_ADDRESS,
       originChainId
@@ -1014,7 +1045,7 @@ function routeErc20Base() {
 }
 var { wrapAs: wrapAs5 } = createErrorHandlers("tokens");
 var abi = AbiCoder.defaultAbiCoder();
-var ntvCodec2 = createNTVCodec({
+var ntvCodec3 = createNTVCodec({
   encode: (types, values) => abi.encode(types, values),
   keccak256: (data) => ethers.keccak256(data)
 });
@@ -1133,7 +1164,7 @@ function createTokensResource(client) {
     return wrapAs5("CONTRACT", "tokens.isChainEthBased", async () => {
       const baseAssetId = await getBaseTokenAssetId();
       const l1ChainId = await getL1ChainId();
-      const ethAssetId = ntvCodec2.encodeAssetId(
+      const ethAssetId = ntvCodec3.encodeAssetId(
         l1ChainId,
         L2_NATIVE_TOKEN_VAULT_ADDRESS,
         ETH_ADDRESS

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matterlabs/zksync-js",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "devDependencies": {
@@ -141,12 +141,14 @@
     "docs:serve": "mdbook serve docs -p 3000",
     "docs:build": "mdbook build docs",
     "test": "bun test",
-    "test:e2e:ethers": "bun test ./src/adapters/ethers/e2e/*.e2e.ts",
-    "test:e2e:viem": "bun test ./src/adapters/viem/e2e/*.e2e.ts",
+    "test:e2e:ethers": "bun test ./src/adapters/ethers/e2e/*.e2e.ts --path-ignore-patterns='**/interop*'",
+    "test:e2e:viem": "bun test ./src/adapters/viem/e2e/*.e2e.ts --path-ignore-patterns='**/interop*'",
+    "test:e2e:interop:ethers": "bun test ./src/adapters/ethers/e2e/interop.e2e.ts",
+    "test:e2e:interop:viem": "bun test ./src/adapters/viem/e2e/interop.e2e.ts",
     "test:watch": "bun test --watch",
     "test:cov": "bun test --coverage",
     "test:core": "bun test src/core",
-    "test:docs": "bun test docs/snippets --timeout 100000"
+    "test:docs": "bun test docs/snippets --timeout 200000"
   },
   "sideEffects": false,
   "type": "module",