@matterlabs/zksync-js 0.0.8 → 0.0.10

package/dist/chunk-HOZTREW6.js

@@ -0,0 +1,209 @@
+import { createErrorHandlers } from './chunk-QDJOEVGJ.js';
+import { createZksRpc, makeTransportFromEthers } from './chunk-UIXU35ZU.js';
+import { createError, OP_CLIENT, IBridgehub_default, IL1AssetRouter_default, IL1Nullifier_default, L2MessageVerification_default, IInteropHandler_default, InteropCenter_default, IBaseToken_default, L2NativeTokenVault_default, IL2AssetRouter_default, L1NativeTokenVault_default, OP_DEPOSITS } from './chunk-FBKBF7YM.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-C3AGOEHR.js';
+import { BrowserProvider, Interface, Contract } from 'ethers';
+
+// src/adapters/ethers/rpc.ts
+function zksRpcFromEthers(l2Provider) {
+  const maybe = l2Provider;
+  if (typeof maybe.send !== "function") {
+    throw new Error(
+      "zksRpcFromEthers requires a JSON-RPC capable provider with .send(method, params). Pass an ethers JsonRpcProvider (or wrap your EIP-1193 provider: new BrowserProvider(window.ethereum))."
+    );
+  }
+  return createZksRpc(makeTransportFromEthers(maybe));
+}
+
+// src/adapters/ethers/client.ts
+var { wrapAs, wrap } = createErrorHandlers("client");
+var ChainTypeManagerABI = [
+  "function getSemverProtocolVersion() view returns (uint32,uint32,uint32)"
+];
+function createEthersClient(args) {
+  const { l1, l2, signer } = args;
+  let boundSigner = signer;
+  const signerProvider = signer.provider;
+  const isBrowserProvider = signerProvider instanceof BrowserProvider;
+  if (!isBrowserProvider && (!boundSigner.provider || boundSigner.provider !== l1)) {
+    boundSigner = signer.connect(l1);
+  } else if (isBrowserProvider && signerProvider) {
+    void (async () => {
+      try {
+        const [signerNet, l1Net] = await Promise.all([
+          signerProvider.getNetwork(),
+          l1.getNetwork()
+        ]);
+        if (signerNet.chainId !== l1Net.chainId) {
+          const warning = createError("STATE", {
+            message: `BrowserProvider signer chainId (${signerNet.chainId}) != L1 provider chainId (${l1Net.chainId}). Ensure the wallet is connected to the correct network.`,
+            resource: "helpers",
+            operation: "client.browserProvider.networkMismatch",
+            context: {
+              signerChainId: signerNet.chainId,
+              l1ChainId: l1Net.chainId
+            }
+          });
+          console.debug("[zksync-sdk] non-fatal warning:", warning);
+        }
+      } catch (e) {
+      }
+    })();
+  }
+  const zks = zksRpcFromEthers(l2);
+  let addrCache;
+  let cCache;
+  async function ensureAddresses() {
+    if (addrCache) return addrCache;
+    return await wrap(
+      OP_CLIENT.ensureAddresses,
+      async () => {
+        const bridgehub = args.overrides?.bridgehub ?? await zks.getBridgehubAddress();
+        const IBridgehub = new Interface(IBridgehub_default);
+        const bh = new Contract(bridgehub, IBridgehub, l1);
+        const l1AssetRouter = args.overrides?.l1AssetRouter ?? await bh.assetRouter();
+        const IL1AssetRouter = new Interface(IL1AssetRouter_default);
+        const ar = new Contract(l1AssetRouter, IL1AssetRouter, l1);
+        const l1Nullifier = args.overrides?.l1Nullifier ?? await ar.L1_NULLIFIER();
+        const IL1Nullifier = new Interface(IL1Nullifier_default);
+        const nf = new Contract(l1Nullifier, IL1Nullifier, l1);
+        const l1NativeTokenVault = args.overrides?.l1NativeTokenVault ?? await nf.l1NativeTokenVault();
+        const l2AssetRouter = args.overrides?.l2AssetRouter ?? L2_ASSET_ROUTER_ADDRESS;
+        const l2NativeTokenVault = args.overrides?.l2NativeTokenVault ?? L2_NATIVE_TOKEN_VAULT_ADDRESS;
+        const l2BaseTokenSystem = args.overrides?.l2BaseTokenSystem ?? L2_BASE_TOKEN_ADDRESS;
+        const interopCenter = args.overrides?.interopCenter ?? L2_INTEROP_CENTER_ADDRESS;
+        const interopHandler = args.overrides?.interopHandler ?? L2_INTEROP_HANDLER_ADDRESS;
+        const l2MessageVerification = args.overrides?.l2MessageVerification ?? L2_MESSAGE_VERIFICATION_ADDRESS;
+        addrCache = {
+          bridgehub,
+          l1AssetRouter,
+          l1Nullifier,
+          l1NativeTokenVault,
+          l2AssetRouter,
+          l2NativeTokenVault,
+          l2BaseTokenSystem,
+          interopCenter,
+          interopHandler,
+          l2MessageVerification
+        };
+        return addrCache;
+      },
+      {
+        ctx: { where: "ensureAddresses" },
+        message: "Failed to ensure contract addresses."
+      }
+    );
+  }
+  async function contracts() {
+    if (cCache) return cCache;
+    const a = await ensureAddresses();
+    cCache = {
+      bridgehub: new Contract(a.bridgehub, IBridgehub_default, l1),
+      l1AssetRouter: new Contract(a.l1AssetRouter, IL1AssetRouter_default, l1),
+      l1Nullifier: new Contract(a.l1Nullifier, IL1Nullifier_default, l1),
+      l1NativeTokenVault: new Contract(a.l1NativeTokenVault, L1NativeTokenVault_default, l1),
+      l2AssetRouter: new Contract(a.l2AssetRouter, IL2AssetRouter_default, l2),
+      l2NativeTokenVault: new Contract(a.l2NativeTokenVault, L2NativeTokenVault_default, l2),
+      l2BaseTokenSystem: new Contract(a.l2BaseTokenSystem, IBaseToken_default, l2),
+      interopCenter: new Contract(a.interopCenter, InteropCenter_default, l2),
+      interopHandler: new Contract(a.interopHandler, IInteropHandler_default, l2),
+      l2MessageVerification: new Contract(a.l2MessageVerification, L2MessageVerification_default, l2)
+    };
+    return cCache;
+  }
+  function refresh() {
+    addrCache = void 0;
+    cCache = void 0;
+  }
+  function resolveSignerFor(provider) {
+    const signerProvider2 = boundSigner.provider;
+    if (signerProvider2 === provider) {
+      return boundSigner;
+    }
+    if (!isBrowserProvider && typeof boundSigner.connect === "function") {
+      return boundSigner.connect(provider);
+    }
+    if (!signerProvider2) {
+      throw createError("STATE", {
+        resource: "helpers",
+        message: "Signer has no associated provider; cannot resolve requested signer.",
+        operation: "client.resolveSignerFor"
+      });
+    }
+    return boundSigner;
+  }
+  async function baseToken(chainId) {
+    const { bridgehub } = await ensureAddresses();
+    const bh = new Contract(bridgehub, IBridgehub_default, l1);
+    return await wrapAs("CONTRACT", OP_DEPOSITS.base.baseToken, () => bh.baseToken(chainId), {
+      ctx: { where: "bridgehub.baseToken", chainId },
+      message: "Failed to read base token."
+    });
+  }
+  async function getProtocolVersion(chainId) {
+    const targetChainId = chainId ?? (await l2.getNetwork()).chainId;
+    const { bridgehub } = await ensureAddresses();
+    const bh = new Contract(bridgehub, IBridgehub_default, l1);
+    const chainTypeManager = await wrapAs(
+      "CONTRACT",
+      OP_CLIENT.getSemverProtocolVersion,
+      () => bh.chainTypeManager(targetChainId),
+      {
+        ctx: { where: "bridgehub.chainTypeManager", bridgehub, chainId: targetChainId },
+        message: "Failed to read chain type manager."
+      }
+    );
+    if (chainTypeManager.toLowerCase() === FORMAL_ETH_ADDRESS) {
+      throw createError("STATE", {
+        resource: "client",
+        operation: OP_CLIENT.getSemverProtocolVersion,
+        message: "No registered chain type manager for the chain.",
+        context: { chainId }
+      });
+    }
+    const ctm = new Contract(chainTypeManager, ChainTypeManagerABI, l1);
+    const semver = await wrapAs(
+      "CONTRACT",
+      OP_CLIENT.getSemverProtocolVersion,
+      () => ctm.getSemverProtocolVersion(),
+      {
+        ctx: {
+          where: "chainTypeManager.getSemverProtocolVersion",
+          chainId: targetChainId,
+          chainTypeManager
+        },
+        message: "Failed to read semver protocol version."
+      }
+    );
+    return semver;
+  }
+  function signerFor(target) {
+    if (target === "l1") {
+      return boundSigner.provider === l1 ? boundSigner : boundSigner.connect(l1);
+    }
+    const provider = target ?? l2;
+    return boundSigner.provider === provider ? boundSigner : boundSigner.connect(provider);
+  }
+  const client = {
+    kind: "ethers",
+    l1,
+    l2,
+    signer: boundSigner,
+    getL1Signer() {
+      return resolveSignerFor(l1);
+    },
+    getL2Signer() {
+      return resolveSignerFor(l2);
+    },
+    zks,
+    ensureAddresses,
+    contracts,
+    refresh,
+    baseToken,
+    getProtocolVersion,
+    signerFor
+  };
+  return client;
+}
+
+export { createEthersClient };

package/dist/{chunk-L343N56B.js → chunk-IYEDEUXG.js}

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