@matterlabs/zksync-js 0.0.1

package/dist/adapters/viem/resources/deposits/routes/erc20-nonbase.d.ts

@@ -0,0 +1,2 @@
+import type { DepositRouteStrategy } from './types';
+export declare function routeErc20NonBase(): DepositRouteStrategy;

package/dist/adapters/viem/resources/deposits/routes/eth-nonbase.d.ts

@@ -0,0 +1,2 @@
+import type { DepositRouteStrategy } from './types';
+export declare function routeEthNonBase(): DepositRouteStrategy;

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

@@ -0,0 +1,2 @@
+import type { DepositRouteStrategy } from './types';
+export declare function routeEthDirect(): DepositRouteStrategy;

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

@@ -0,0 +1,20 @@
+import type { WalletClient, Transport, Chain, Account } from 'viem';
+import type { DepositParams } from '../../../../../core/types/flows/deposits';
+import type { RouteStrategy } from '../../../../../core/types/flows/route';
+import type { BuildCtx as DepositBuildCtx } from '../context';
+type WriteParams = Parameters<WalletClient<Transport, Chain, Account>['writeContract']>[0];
+/**
+ * viem specific
+ * Plan-time write request: relax 'value' so a single type can hold both
+ * non-payable (no value) and payable (value: bigint) requests.
+ */
+export type ViemPlanWriteRequest = Omit<WriteParams, 'value'> & {
+    value?: bigint;
+};
+export type DepositQuoteExtras = {
+    baseCost: bigint;
+    mintValue: bigint;
+    l1GasLimit?: bigint;
+};
+export type DepositRouteStrategy = RouteStrategy<DepositParams, ViemPlanWriteRequest, DepositQuoteExtras, DepositBuildCtx>;
+export {};

package/dist/adapters/viem/resources/deposits/services/verification.d.ts

@@ -0,0 +1,7 @@
+import type { PublicClient, TransactionReceipt, Log } from 'viem';
+import type { Hex } from '../../../../../core/types/primitives';
+export declare function extractL2TxHashFromL1Logs(logs: ReadonlyArray<Log>): Hex | null;
+export declare function waitForL2ExecutionFromL1Tx(l1: PublicClient, l2: PublicClient, l1TxHash: Hex): Promise<{
+    l2Receipt: TransactionReceipt;
+    l2TxHash: Hex;
+}>;

package/dist/adapters/viem/resources/token-info.d.ts

@@ -0,0 +1,34 @@
+import type { PublicClient } from 'viem';
+export type L2Reader = {
+    readContract: PublicClient['readContract'];
+};
+import type { Address } from '../../../core/types/primitives';
+/**
+ * Read the `BASE_TOKEN_ASSET_ID` from the L2 NativeTokenVault.
+ * This is the encoded assetId of the chain’s base token.
+ */
+export declare function ntvBaseAssetId(l2: L2Reader, ntv: Address): Promise<`0x${string}`>;
+/**
+ * Read the `L1_CHAIN_ID` that the L2 NativeTokenVault is anchored to.
+ * Needed when encoding asset IDs.
+ */
+export declare function ntvL1ChainId(l2: L2Reader, ntv: Address): Promise<bigint>;
+/**
+ * Ensure a token is registered in the L2 NativeTokenVault and return its assetId.
+ * (Will register on-chain if not yet registered.)
+ */
+export declare function ntvAssetIdForToken(l2: L2Reader, ntv: Address, token: Address): Promise<`0x${string}`>;
+/**
+ * Check if the chain is ETH-based (i.e. base token == ETH).
+ */
+export declare function isEthBasedChain(l2: L2Reader, ntv: Address): Promise<boolean>;
+/**
+ * Check if a given token address is the chain’s base token.
+ */
+export declare function isBaseToken(l2: L2Reader, ntv: Address, token: Address): Promise<boolean>;
+/**
+ * Check if the token should be treated as "ETH" on this L2.
+ * - If it equals the universal ETH alias (0x…800A), return true immediately.
+ * - Else compare the token’s assetId to the ETH sentinel assetId via the NTV.
+ */
+export declare function isEthTokenOnThisChain(l2: L2Reader, ntv: Address, token: Address): Promise<boolean>;

package/dist/adapters/viem/resources/utils.d.ts

@@ -0,0 +1,42 @@
+import { type Hex } from 'viem';
+import type { Address } from '../../../core/types';
+import type { ViemClient } from '../client';
+import type { Eip1559GasOverrides, ResolvedEip1559Fees } from '../../../core/types/flows/base';
+export declare function encodeNativeTokenVaultAssetId(chainId: bigint, address: string): Hex;
+export declare function encodeNativeTokenVaultTransferData(amount: bigint, receiver: Address, token: Address): Hex;
+export declare function encodeSecondBridgeDataV1(assetId: Hex, transferData: Hex): Hex;
+export declare const encodeNTVAssetId: typeof encodeNativeTokenVaultAssetId;
+export declare const encodeNTVTransferData: typeof encodeNativeTokenVaultTransferData;
+export declare function scaleGasLimit(gasLimit: bigint): bigint;
+/** Throws if baseCost > value */
+export declare function checkBaseCost(baseCost: bigint, value: bigint | Promise<bigint>): Promise<void>;
+export type FeeOverrides = ResolvedEip1559Fees & {
+    gasPriceForBaseCost: bigint;
+};
+export declare function getFeeOverrides(client: ViemClient, overrides?: Eip1559GasOverrides): Promise<FeeOverrides>;
+export declare function getL2FeeOverrides(client: ViemClient, overrides?: Eip1559GasOverrides): Promise<ResolvedEip1559Fees>;
+export declare function buildViemFeeOverrides(fees: ResolvedEip1559Fees): Record<string, unknown>;
+/** Fetches the gas price in wei (legacy) or falls back to maxFeePerGas. */
+export declare function getGasPriceWei(client: ViemClient): Promise<bigint>;
+export declare function buildDirectRequestStruct(args: {
+    chainId: bigint;
+    mintValue: bigint;
+    l2GasLimit: bigint;
+    gasPerPubdata: bigint;
+    refundRecipient: Address;
+    l2Contract: Address;
+    l2Value: bigint;
+}): {
+    chainId: bigint;
+    l2Contract: `0x${string}`;
+    mintValue: bigint;
+    l2Value: bigint;
+    l2Calldata: Hex;
+    l2GasLimit: bigint;
+    l2GasPerPubdataByteLimit: bigint;
+    factoryDeps: Hex[];
+    refundRecipient: `0x${string}`;
+};
+export declare function encodeSecondBridgeArgs(token: Address, amount: bigint, l2Receiver: Address): Hex;
+export declare function encodeSecondBridgeErc20Args(token: Address, amount: bigint, l2Receiver: Address): Hex;
+export declare function encodeSecondBridgeEthArgs(amount: bigint, l2Receiver: Address, ethToken?: Address): Hex;

package/dist/adapters/viem/resources/withdrawals/context.d.ts

@@ -0,0 +1,22 @@
+import type { ViemClient } from '../../client';
+import type { Address } from '../../../../core/types/primitives';
+import type { WithdrawParams, WithdrawRoute } from '../../../../core/types/flows/withdrawals';
+import type { CommonCtx, ResolvedEip1559Fees } from '../../../../core/types/flows/base';
+export interface BuildCtx extends CommonCtx {
+    client: ViemClient;
+    bridgehub: Address;
+    l1AssetRouter: Address;
+    l1Nullifier: Address;
+    l2AssetRouter: Address;
+    l2NativeTokenVault: Address;
+    l2BaseTokenSystem: Address;
+    baseIsEth: boolean;
+    chainIdL2: bigint;
+    sender: Address;
+    l2GasLimit: bigint;
+    gasBufferPct: number;
+    fee: ResolvedEip1559Fees;
+}
+export declare function commonCtx(p: WithdrawParams, client: ViemClient): Promise<BuildCtx & {
+    route: WithdrawRoute;
+}>;

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

@@ -0,0 +1,56 @@
+import type { ViemClient } from '../../client';
+import type { WithdrawParams, WithdrawQuote, WithdrawPlan, WithdrawHandle, WithdrawalWaitable, WithdrawRoute, WithdrawalStatus } from '../../../../core/types/flows/withdrawals';
+import type { Hex } from '../../../../core/types/primitives';
+import type { TransactionReceipt } from 'viem';
+import type { WithdrawRouteStrategy, TransactionReceiptZKsyncOS, ViemPlanWriteRequest } from './routes/types';
+import { createFinalizationServices, type FinalizationServices } from './services/finalization';
+export declare const ROUTES: Record<WithdrawRoute, WithdrawRouteStrategy>;
+export interface WithdrawalsResource {
+    quote(p: WithdrawParams): Promise<WithdrawQuote>;
+    tryQuote(p: WithdrawParams): Promise<{
+        ok: true;
+        value: WithdrawQuote;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+    prepare(p: WithdrawParams): Promise<WithdrawPlan<ViemPlanWriteRequest>>;
+    tryPrepare(p: WithdrawParams): Promise<{
+        ok: true;
+        value: WithdrawPlan<ViemPlanWriteRequest>;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+    create(p: WithdrawParams): Promise<WithdrawHandle<ViemPlanWriteRequest>>;
+    tryCreate(p: WithdrawParams): Promise<{
+        ok: true;
+        value: WithdrawHandle<ViemPlanWriteRequest>;
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+    status(h: WithdrawalWaitable | Hex): Promise<WithdrawalStatus>;
+    wait(h: WithdrawalWaitable | Hex, opts: {
+        for: 'l2' | 'ready' | 'finalized';
+        pollMs?: number;
+        timeoutMs?: number;
+    }): Promise<TransactionReceiptZKsyncOS | TransactionReceipt | null>;
+    finalize(l2TxHash: Hex): Promise<{
+        status: WithdrawalStatus;
+        receipt?: TransactionReceipt;
+    }>;
+    tryFinalize(l2TxHash: Hex): Promise<{
+        ok: true;
+        value: {
+            status: WithdrawalStatus;
+            receipt?: TransactionReceipt;
+        };
+    } | {
+        ok: false;
+        error: unknown;
+    }>;
+}
+export declare function createWithdrawalsResource(client: ViemClient): WithdrawalsResource;
+export { createFinalizationServices };
+export type { FinalizationServices };

package/dist/adapters/viem/resources/withdrawals/routes/erc20-nonbase.d.ts

@@ -0,0 +1,2 @@
+import type { WithdrawRouteStrategy } from './types.ts';
+export declare function routeErc20NonBase(): WithdrawRouteStrategy;

package/dist/adapters/viem/resources/withdrawals/routes/eth-nonbase.d.ts

@@ -0,0 +1,2 @@
+import type { WithdrawRouteStrategy } from './types';
+export declare function routeEthNonBase(): WithdrawRouteStrategy;

package/dist/adapters/viem/resources/withdrawals/routes/eth.d.ts

@@ -0,0 +1,2 @@
+import type { WithdrawRouteStrategy } from './types';
+export declare function routeEthBase(): WithdrawRouteStrategy;

package/dist/adapters/viem/resources/withdrawals/routes/types.d.ts

@@ -0,0 +1,19 @@
+import type { WalletClient, Transport, Chain, Account, TransactionReceipt } from 'viem';
+import type { WithdrawParams } from '../../../../../core/types/flows/withdrawals';
+import type { RouteStrategy } from '../../../../../core/types/flows/route';
+import type { BuildCtx as WithdrawBuildCtx } from '../context';
+import type { Address, Hex } from '../../../../../core/types';
+export type ViemPlanWriteRequest = Parameters<WalletClient<Transport, Chain, Account>['writeContract']>[0];
+export type WithdrawQuoteExtras = Record<string, never>;
+export type WithdrawRouteStrategy = RouteStrategy<WithdrawParams, ViemPlanWriteRequest, WithdrawQuoteExtras, WithdrawBuildCtx>;
+export interface L2ToL1Log {
+    l2ShardId?: number;
+    isService?: boolean;
+    txNumberInBlock?: number;
+    sender?: Address;
+    key?: Hex;
+    value?: Hex;
+}
+export type TransactionReceiptZKsyncOS = TransactionReceipt & {
+    l2ToL1Logs?: L2ToL1Log[];
+};

package/dist/adapters/viem/resources/withdrawals/services/finalization.d.ts

@@ -0,0 +1,33 @@
+import type { Address, Hex } from '../../../../../core/types/primitives';
+import type { ViemClient } from '../../../client';
+import { type FinalizeReadiness, type FinalizeDepositParams, type WithdrawalKey, type FinalizationEstimate } from '../../../../../core/types/flows/withdrawals';
+import type { TransactionReceipt } from 'viem';
+export interface FinalizationServices {
+    /**
+     * Build finalizeDeposit params.
+     */
+    fetchFinalizeDepositParams(l2TxHash: Hex): Promise<{
+        params: FinalizeDepositParams;
+        nullifier: Address;
+    }>;
+    /**
+     * Read the Nullifier mapping to check finalization status.
+     */
+    isWithdrawalFinalized(key: WithdrawalKey): Promise<boolean>;
+    /**
+     * Simulate finalizeDeposit on L1 Nullifier to check readiness.
+     */
+    simulateFinalizeReadiness(params: FinalizeDepositParams): Promise<FinalizeReadiness>;
+    /**
+     * Estimate gas & fees for finalizeDeposit on L1 Nullifier.
+     */
+    estimateFinalization(params: FinalizeDepositParams): Promise<FinalizationEstimate>;
+    /**
+     * Call finalizeDeposit on L1 Nullifier.
+     */
+    finalizeDeposit(params: FinalizeDepositParams): Promise<{
+        hash: string;
+        wait: () => Promise<TransactionReceipt>;
+    }>;
+}
+export declare function createFinalizationServices(client: ViemClient): FinalizationServices;

package/dist/adapters/viem/rpc.d.ts

@@ -0,0 +1,2 @@
+import type { PublicClient } from 'viem';
+export declare function zksRpcFromViem(l2Client: PublicClient): import("../..").ZksRpc;