@matterlabs/zksync-js 0.0.7 → 0.0.9

package/dist/core/internal/abis/L2MessageVerification.d.ts

@@ -0,0 +1,277 @@
+declare const L2MessageVerificationABI: readonly [{
+    readonly inputs: readonly [];
+    readonly name: "DepthMoreThanOneForRecursiveMerkleProof";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "HashedLogIsDefault";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "InvalidProofLengthForFinalNode";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MerkleIndexOutOfBounds";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MerklePathEmpty";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "MerklePathOutOfBounds";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "metadataVersion";
+        readonly type: "uint256";
+    }];
+    readonly name: "UnsupportedProofMetadataVersion";
+    readonly type: "error";
+}, {
+    readonly inputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "uint256";
+            readonly name: "chainId";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "l2BatchNumber";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "l2MessageIndex";
+            readonly type: "uint256";
+        }, {
+            readonly internalType: "address";
+            readonly name: "l2Sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "uint16";
+            readonly name: "l2TxNumberInBatch";
+            readonly type: "uint16";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "message";
+            readonly type: "bytes";
+        }, {
+            readonly internalType: "bytes32[]";
+            readonly name: "merkleProof";
+            readonly type: "bytes32[]";
+        }];
+        readonly internalType: "struct FinalizeL1DepositParams";
+        readonly name: "_finalizeWithdrawalParams";
+        readonly type: "tuple";
+    }];
+    readonly name: "proveL1DepositParamsInclusion";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "success";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "_l2TxHash";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_l2BatchNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_l2MessageIndex";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint16";
+        readonly name: "_l2TxNumberInBatch";
+        readonly type: "uint16";
+    }, {
+        readonly internalType: "bytes32[]";
+        readonly name: "_merkleProof";
+        readonly type: "bytes32[]";
+    }, {
+        readonly internalType: "enum TxStatus";
+        readonly name: "_status";
+        readonly type: "uint8";
+    }];
+    readonly name: "proveL1ToL2TransactionStatusShared";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_blockOrBatchNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_leafProofMask";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "_leaf";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32[]";
+        readonly name: "_proof";
+        readonly type: "bytes32[]";
+    }];
+    readonly name: "proveL2LeafInclusionShared";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_blockOrBatchNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_leafProofMask";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "_leaf";
+        readonly type: "bytes32";
+    }, {
+        readonly internalType: "bytes32[]";
+        readonly name: "_proof";
+        readonly type: "bytes32[]";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_depth";
+        readonly type: "uint256";
+    }];
+    readonly name: "proveL2LeafInclusionSharedRecursive";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_blockOrBatchNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_index";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint8";
+            readonly name: "l2ShardId";
+            readonly type: "uint8";
+        }, {
+            readonly internalType: "bool";
+            readonly name: "isService";
+            readonly type: "bool";
+        }, {
+            readonly internalType: "uint16";
+            readonly name: "txNumberInBatch";
+            readonly type: "uint16";
+        }, {
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "key";
+            readonly type: "bytes32";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "value";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct L2Log";
+        readonly name: "_log";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes32[]";
+        readonly name: "_proof";
+        readonly type: "bytes32[]";
+    }];
+    readonly name: "proveL2LogInclusionShared";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "_chainId";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_blockOrBatchNumber";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "_index";
+        readonly type: "uint256";
+    }, {
+        readonly components: readonly [{
+            readonly internalType: "uint16";
+            readonly name: "txNumberInBatch";
+            readonly type: "uint16";
+        }, {
+            readonly internalType: "address";
+            readonly name: "sender";
+            readonly type: "address";
+        }, {
+            readonly internalType: "bytes";
+            readonly name: "data";
+            readonly type: "bytes";
+        }];
+        readonly internalType: "struct L2Message";
+        readonly name: "_message";
+        readonly type: "tuple";
+    }, {
+        readonly internalType: "bytes32[]";
+        readonly name: "_proof";
+        readonly type: "bytes32[]";
+    }];
+    readonly name: "proveL2MessageInclusionShared";
+    readonly outputs: readonly [{
+        readonly internalType: "bool";
+        readonly name: "";
+        readonly type: "bool";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+export default L2MessageVerificationABI;

package/dist/core/resources/interop/attributes/bundle.d.ts

@@ -0,0 +1,6 @@
+import type { Address, Hex } from '../../../types/primitives';
+import type { AttributesCodec } from './types';
+export declare function createBundleAttributes(codec: AttributesCodec): {
+    executionAddress: (executor: Address) => Hex;
+    unbundlerAddress: (addr: Address) => Hex;
+};

package/dist/core/resources/interop/attributes/call.d.ts

@@ -0,0 +1,6 @@
+import type { Hex } from '../../../types/primitives';
+import type { AttributesCodec } from './types';
+export declare function createCallAttributes(codec: AttributesCodec): {
+    indirectCall: (messageValue: bigint) => Hex;
+    interopCallValue: (bridgedAmount: bigint) => Hex;
+};

package/dist/core/resources/interop/attributes/index.d.ts

@@ -0,0 +1,4 @@
+export * from './types';
+export * from './call';
+export * from './bundle';
+export * from './resource';

package/dist/core/resources/interop/attributes/resource.d.ts

@@ -0,0 +1,12 @@
+import type { AttributesCodec } from './types';
+export declare function createAttributesResource(codec: AttributesCodec): {
+    call: {
+        indirectCall: (messageValue: bigint) => import("../../..").Hex;
+        interopCallValue: (bridgedAmount: bigint) => import("../../..").Hex;
+    };
+    bundle: {
+        executionAddress: (executor: import("../../..").Address) => import("../../..").Hex;
+        unbundlerAddress: (addr: import("../../..").Address) => import("../../..").Hex;
+    };
+};
+export type AttributesResource = ReturnType<typeof createAttributesResource>;

package/dist/core/resources/interop/attributes/types.d.ts

@@ -0,0 +1,4 @@
+import type { Hex } from '../../../types/primitives';
+export interface AttributesCodec {
+    encode(fn: string, args: readonly unknown[]): Hex;
+}

package/dist/core/resources/interop/events.d.ts

@@ -0,0 +1,7 @@
+import type { Hex } from '../../types/primitives';
+export type InteropTopics = {
+    interopBundleSent: Hex;
+    bundleVerified: Hex;
+    bundleExecuted: Hex;
+    bundleUnbundled: Hex;
+};

package/dist/core/resources/interop/finalization.d.ts

@@ -0,0 +1,60 @@
+import type { Address, Hex } from '../../types/primitives';
+import type { InteropFinalizationInfo, InteropWaitable } from '../../types/flows/interop';
+import type { Log, TxReceipt } from '../../types/transactions';
+import type { ProofNormalized, ReceiptWithL2ToL1 } from '../../rpc/types';
+export interface BundleReceiptInfo {
+    bundleHash: Hex;
+    dstChainId: bigint;
+    sourceChainId: bigint;
+    l1MessageData: Hex;
+    l2ToL1LogIndex: number;
+    txNumberInBatch: number;
+    rawReceipt: ReceiptWithL2ToL1;
+}
+export declare const DEFAULT_POLL_MS = 1000;
+export declare const DEFAULT_TIMEOUT_MS = 300000;
+interface ResolvedInteropIds {
+    l2SrcTxHash?: Hex;
+    bundleHash?: Hex;
+    dstExecTxHash?: Hex;
+}
+export declare function resolveIdsFromWaitable(input: InteropWaitable): ResolvedInteropIds;
+export interface ParseBundleSentInput {
+    receipt: TxReceipt;
+    interopCenter: Address;
+    interopBundleSentTopic: Hex;
+    decodeInteropBundleSent: (log: {
+        data: Hex;
+        topics: Hex[];
+    }) => {
+        bundleHash: Hex;
+        sourceChainId: bigint;
+        destinationChainId: bigint;
+    };
+}
+export declare function parseBundleSentFromReceipt(input: ParseBundleSentInput): {
+    bundleHash: Hex;
+    dstChainId: bigint;
+};
+export interface ParseBundleReceiptParams {
+    rawReceipt: ReceiptWithL2ToL1;
+    interopCenter: Address;
+    interopBundleSentTopic: Hex;
+    decodeInteropBundleSent: (log: {
+        data: Hex;
+        topics: Hex[];
+    }) => {
+        bundleHash: Hex;
+        sourceChainId: bigint;
+        destinationChainId: bigint;
+    };
+    decodeL1MessageData: (log: Log) => Hex;
+    l2SrcTxHash: Hex;
+}
+export declare function parseBundleReceiptInfo(params: ParseBundleReceiptParams): BundleReceiptInfo;
+export declare function getBundleEncodedData(messageData: Hex): Hex;
+export declare function buildFinalizationInfo(ids: {
+    l2SrcTxHash: Hex;
+    bundleHash?: Hex;
+}, bundleInfo: BundleReceiptInfo, proof: ProofNormalized, messageData: Hex): InteropFinalizationInfo;
+export {};

package/dist/core/resources/interop/plan.d.ts

@@ -0,0 +1,39 @@
+import type { Address, Hex } from '../../types/primitives';
+import type { ApprovalNeed } from '../../types/flows/base';
+import type { InteropParams } from '../../types/flows/interop';
+export type InteropStarter = [Hex, Hex, Hex[]];
+export interface InteropBundleBuild {
+    dstChain: Hex;
+    starters: InteropStarter[];
+    bundleAttributes: Hex[];
+    approvals: ApprovalNeed[];
+    quoteExtras: {
+        totalActionValue: bigint;
+        bridgedTokenTotal: bigint;
+    };
+}
+export interface InteropAddressCodec {
+    formatChain(chainId: bigint): Hex;
+    formatAddress(address: Address): Hex;
+}
+export interface InteropBuildCtx {
+    dstChainId: bigint;
+    baseTokens: {
+        src: Address;
+        dst: Address;
+    };
+    l2AssetRouter: Address;
+    l2NativeTokenVault: Address;
+    codec: InteropAddressCodec;
+}
+export interface InteropAttributes {
+    bundleAttributes: Hex[];
+    callAttributes: Hex[][];
+}
+export interface InteropStarterData {
+    assetRouterPayload?: Hex;
+}
+export declare function preflightDirect(params: InteropParams, ctx: InteropBuildCtx): void;
+export declare function buildDirectBundle(params: InteropParams, ctx: InteropBuildCtx, attrs: InteropAttributes): InteropBundleBuild;
+export declare function preflightIndirect(params: InteropParams, ctx: InteropBuildCtx): void;
+export declare function buildIndirectBundle(params: InteropParams, ctx: InteropBuildCtx, attrs: InteropAttributes, starterData: InteropStarterData[]): InteropBundleBuild;

package/dist/core/resources/interop/route.d.ts

@@ -0,0 +1,15 @@
+import type { Address } from '../../types/primitives';
+import type { InteropAction, InteropRoute } from '../../types/flows/interop';
+export interface InteropCtx {
+    sender: Address;
+    srcChainId: bigint;
+    dstChainId: bigint;
+    baseTokenSrc: Address;
+    baseTokenDst: Address;
+}
+export declare function sumActionMsgValue(actions: readonly InteropAction[]): bigint;
+export declare function sumErc20Amounts(actions: readonly InteropAction[]): bigint;
+export declare function pickInteropRoute(args: {
+    actions: readonly InteropAction[];
+    ctx: InteropCtx;
+}): InteropRoute;

package/dist/core/rpc/types.d.ts

@@ -8,6 +8,7 @@ export type L2ToL1Log = {
     value: Hex;
 };
 export type ReceiptWithL2ToL1 = {
+    transactionIndex: Hex;
     transactionHash?: Hex;
     status?: string | number;
     blockNumber?: string | number;
@@ -15,6 +16,7 @@ export type ReceiptWithL2ToL1 = {
         address: Address;
         topics: Hex[];
         data: Hex;
+        transactionHash: Hex;
     }>;
     l2ToL1Logs?: L2ToL1Log[];
 };
@@ -22,12 +24,19 @@ export type ProofNormalized = {
     id: bigint;
     batchNumber: bigint;
     proof: Hex[];
+    root: Hex;
 };
 export type GenesisContractDeployment = {
     address: Address;
     bytecode: Hex;
 };
 export type GenesisStorageEntry = {
+    format: 'raw';
+    key: Hex;
+    value: Hex;
+} | {
+    format: 'pretty';
+    address: Address;
     key: Hex;
     value: Hex;
 };

package/dist/core/types/errors.d.ts

@@ -1,6 +1,6 @@
-export type ErrorType = 'VALIDATION' | 'STATE' | 'EXECUTION' | 'RPC' | 'INTERNAL' | 'VERIFICATION' | 'CONTRACT';
+export type ErrorType = 'VALIDATION' | 'STATE' | 'EXECUTION' | 'RPC' | 'INTERNAL' | 'VERIFICATION' | 'CONTRACT' | 'TIMEOUT';
 /** Resource surface */
-export type Resource = 'deposits' | 'withdrawals' | 'withdrawal-finalization' | 'tokens' | 'contracts' | 'helpers' | 'zksrpc' | 'client';
+export type Resource = 'deposits' | 'withdrawals' | 'withdrawal-finalization' | 'interop' | 'tokens' | 'contracts' | 'helpers' | 'zksrpc' | 'client';
 /** Envelope we throw only for SDK-domain errors. */
 export interface ErrorEnvelope {
     /** Resource surface that raised the error. */
@@ -66,7 +66,12 @@ export declare class ZKsyncError extends Error {
         name: string;
     };
 }
-export declare function isZKsyncError(e: unknown): e is ZKsyncError;
+export declare function isZKsyncError(e: unknown, opts?: {
+    type?: ErrorType;
+    resource?: Resource;
+    operation?: string;
+    messageIncludes?: string;
+}): e is ZKsyncError;
 export declare function isReceiptNotFound(e: unknown): boolean;
 export type TryResult<T> = {
     ok: true;
@@ -75,6 +80,10 @@ export type TryResult<T> = {
     ok: false;
     error: ZKsyncError;
 };
+export declare const OP_CLIENT: {
+    readonly ensureAddresses: "client.ensureAddresses";
+    readonly getSemverProtocolVersion: "client.getSemverProtocolVersion";
+};
 export declare const OP_DEPOSITS: {
     readonly quote: "deposits.quote";
     readonly tryQuote: "deposits.tryQuote";
@@ -162,10 +171,8 @@ export declare const OP_WITHDRAWALS: {
             readonly messengerIndex: "withdrawals.finalize.fetchParams:messengerIndex";
             readonly proof: "withdrawals.finalize.fetchParams:proof";
             readonly network: "withdrawals.finalize.fetchParams:network";
-            readonly ensureAddresses: "withdrawals.finalize.fetchParams:ensureAddresses";
         };
         readonly readiness: {
-            readonly ensureAddresses: "withdrawals.finalize.readiness:ensureAddresses";
             readonly isFinalized: "withdrawals.finalize.readiness:isWithdrawalFinalized";
             readonly simulate: "withdrawals.finalize.readiness:simulate";
         };
@@ -175,3 +182,47 @@ export declare const OP_WITHDRAWALS: {
         readonly estimate: "withdrawals.finalize.estimateFinalizationFees";
     };
 };
+export declare const OP_INTEROP: {
+    readonly quote: "interop.quote";
+    readonly tryQuote: "interop.tryQuote";
+    readonly prepare: "interop.prepare";
+    readonly tryPrepare: "interop.tryPrepare";
+    readonly create: "interop.create";
+    readonly tryCreate: "interop.tryCreate";
+    readonly status: "interop.status";
+    readonly wait: "interop.wait";
+    readonly tryWait: "interop.tryWait";
+    readonly finalize: "interop.finalize";
+    readonly tryFinalize: "interop.tryFinalize";
+    readonly context: {
+        readonly chainTypeManager: "interop.chainTypeManager";
+        readonly protocolVersion: "interop.protocolVersion";
+    };
+    readonly routes: {
+        readonly direct: {
+            readonly preflight: "interop.routes.direct:preflight";
+            readonly build: "interop.routes.direct:build";
+        };
+        readonly indirect: {
+            readonly preflight: "interop.routes.indirect:preflight";
+            readonly build: "interop.routes.indirect:build";
+        };
+    };
+    readonly exec: {
+        readonly sendStep: "interop.exec:sendStep";
+        readonly waitStep: "interop.exec:waitStep";
+    };
+    readonly svc: {
+        readonly status: {
+            readonly sourceReceipt: "interop.svc.status:sourceReceipt";
+            readonly parseSentLog: "interop.svc.status:parseSentLog";
+            readonly dstLogs: "interop.svc.status:dstLogs";
+            readonly derive: "interop.svc.status:derive";
+            readonly getRoot: "interop.svc.status:getRoot";
+        };
+        readonly wait: {
+            readonly poll: "interop.svc.wait:poll";
+            readonly timeout: "interop.svc.wait:timeout";
+        };
+    };
+};

package/dist/core/types/fees.d.ts

@@ -37,4 +37,13 @@ export type TxOverrides = {
     gasLimit: bigint;
     maxFeePerGas: bigint;
     maxPriorityFeePerGas?: bigint;
+    /** Optional nonce override.
+     *  - number: use as the starting nonce directly (skip getTransactionCount). If there are multiple transactions,
+     * the specified number will be used as a starting nonce and incremented for each transaction.
+     *  - 'latest' | 'pending': call getTransactionCount with the given block tag.
+     */
+    nonce?: number | 'latest' | 'pending';
 };
+/** TxOverrides without the nonce field. */
+export type TxGasOverrides = Omit<TxOverrides, 'nonce'>;
+export declare function toGasOverrides(overrides: TxOverrides): TxGasOverrides;

package/dist/core/types/flows/base.d.ts

@@ -23,7 +23,7 @@ export interface Plan<Tx, Route, Quote> {
 }
 /** Generic handle (returned by create()) */
 export interface Handle<TxHashMap extends Record<string, Hex>, Route, PlanT> {
-    kind: 'deposit' | 'withdrawal';
+    kind: 'deposit' | 'withdrawal' | 'interop';
     route?: Route;
     stepHashes: TxHashMap;
     plan: PlanT;