viem 2.4.1 → 2.6.0

package/_types/chains/zksync/actions/sendTransaction.d.ts

@@ -0,0 +1,54 @@
+import type { Account } from '../../../accounts/types.js';
+import type { SendTransactionErrorType as SendTransactionErrorType_, SendTransactionParameters as SendTransactionParameters_, SendTransactionReturnType as SendTransactionReturnType_ } from '../../../actions/wallet/sendTransaction.js';
+import type { Client } from '../../../clients/createClient.js';
+import type { Transport } from '../../../clients/transports/createTransport.js';
+import { type ChainEIP712 } from '../types/chain.js';
+export type SendTransactionParameters<TChain extends ChainEIP712 | undefined = ChainEIP712 | undefined, TAccount extends Account | undefined = Account | undefined, TChainOverride extends ChainEIP712 | undefined = ChainEIP712 | undefined> = SendTransactionParameters_<TChain, TAccount, TChainOverride>;
+export type SendTransactionReturnType = SendTransactionReturnType_;
+export type SendTransactionErrorType = SendTransactionErrorType_;
+/**
+ * Creates, signs, and sends a new transaction to the network.
+ *
+ * - Docs: https://viem.sh/docs/zksync/actions/sendTransaction
+ * - JSON-RPC Methods:
+ *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+ *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SendTransactionParameters}
+ * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link SendTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { zkSync } from 'viem/chains'
+ * import { sendTransaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   chain: zkSync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { zkSync } from 'viem/chains'
+ * import { sendTransaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: zkSync,
+ *   transport: http(),
+ * })
+ * const hash = await sendTransaction(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ *   value: 1000000000000000000n,
+ * })
+ */
+export declare function sendTransaction<TChain extends ChainEIP712 | undefined, TAccount extends Account | undefined, TChainOverride extends ChainEIP712 | undefined = undefined>(client: Client<Transport, TChain, TAccount>, args: SendTransactionParameters<TChain, TAccount, TChainOverride>): Promise<SendTransactionReturnType>;
+//# sourceMappingURL=sendTransaction.d.ts.map

package/_types/chains/zksync/actions/sendTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sendTransaction.d.ts","sourceRoot":"","sources":["../../../../chains/zksync/actions/sendTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AAEzD,OAAO,KAAK,EACV,wBAAwB,IAAI,yBAAyB,EACrD,yBAAyB,IAAI,0BAA0B,EACvD,yBAAyB,IAAI,0BAA0B,EACxD,MAAM,4CAA4C,CAAA;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAC/E,OAAO,EAAE,KAAK,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAIpD,MAAM,MAAM,yBAAyB,CACnC,MAAM,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,EAChE,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,EAC1D,cAAc,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,IACtE,0BAA0B,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,CAAA;AAEhE,MAAM,MAAM,yBAAyB,GAAG,0BAA0B,CAAA;AAElE,MAAM,MAAM,wBAAwB,GAAG,yBAAyB,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,wBAAsB,eAAe,CACnC,MAAM,SAAS,WAAW,GAAG,SAAS,EACtC,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,cAAc,SAAS,WAAW,GAAG,SAAS,GAAG,SAAS,EAE1D,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC3C,IAAI,EAAE,yBAAyB,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,GAChE,OAAO,CAAC,yBAAyB,CAAC,CAGpC"}

package/_types/chains/zksync/actions/signEip712Transaction.d.ts

@@ -0,0 +1,54 @@
+import type { Account } from '../../../accounts/types.js';
+import type { SignTransactionErrorType, SignTransactionReturnType } from '../../../actions/wallet/signTransaction.js';
+import type { Client } from '../../../clients/createClient.js';
+import type { Transport } from '../../../clients/transports/createTransport.js';
+import type { GetAccountParameter } from '../../../types/account.js';
+import type { ExtractChainFormatterParameters, GetChainParameter } from '../../../types/chain.js';
+import type { UnionOmit } from '../../../types/utils.js';
+import type { ChainEIP712 } from '../types/chain.js';
+import type { TransactionRequestEIP712 } from '../types/transaction.js';
+type FormattedTransactionRequest<TChain extends ChainEIP712 | undefined = ChainEIP712 | undefined> = ExtractChainFormatterParameters<TChain, 'transactionRequest', TransactionRequestEIP712>;
+export type SignEip712TransactionParameters<TChain extends ChainEIP712 | undefined = ChainEIP712 | undefined, TAccount extends Account | undefined = Account | undefined, TChainOverride extends ChainEIP712 | undefined = ChainEIP712 | undefined> = UnionOmit<FormattedTransactionRequest<TChainOverride extends ChainEIP712 ? TChainOverride : TChain>, 'from'> & GetAccountParameter<TAccount> & GetChainParameter<TChain, TChainOverride>;
+export type SignEip712TransactionReturnType = SignTransactionReturnType;
+export type SignEip712TransactionErrorType = SignTransactionErrorType;
+/**
+ * Signs an EIP712 transaction.
+ *
+ * @param args - {@link SignTransactionParameters}
+ * @returns The signed serialized tranasction. {@link SignTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { zkSync } from 'viem/chains'
+ * import { signEip712Transaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   chain: zkSync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signEip712Transaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { zkSync } from 'viem/chains'
+ * import { signEip712Transaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: zkSync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signEip712Transaction(client, {
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ */
+export declare function signEip712Transaction<TChain extends ChainEIP712 | undefined, TAccount extends Account | undefined, TChainOverride extends ChainEIP712 | undefined>(client: Client<Transport, TChain, TAccount>, args: SignEip712TransactionParameters<TChain, TAccount, TChainOverride>): Promise<SignEip712TransactionReturnType>;
+export {};
+//# sourceMappingURL=signEip712Transaction.d.ts.map

package/_types/chains/zksync/actions/signEip712Transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signEip712Transaction.d.ts","sourceRoot":"","sources":["../../../../chains/zksync/actions/signEip712Transaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AAGzD,OAAO,KAAK,EACV,wBAAwB,EACxB,yBAAyB,EAC1B,MAAM,4CAA4C,CAAA;AAEnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAG/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AACpE,OAAO,KAAK,EACV,+BAA+B,EAC/B,iBAAiB,EAClB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAGxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAMvE,KAAK,2BAA2B,CAC9B,MAAM,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,IAC9D,+BAA+B,CACjC,MAAM,EACN,oBAAoB,EACpB,wBAAwB,CACzB,CAAA;AAED,MAAM,MAAM,+BAA+B,CACzC,MAAM,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,EAChE,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,EAC1D,cAAc,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,IACtE,SAAS,CACX,2BAA2B,CACzB,cAAc,SAAS,WAAW,GAAG,cAAc,GAAG,MAAM,CAC7D,EACD,MAAM,CACP,GACC,mBAAmB,CAAC,QAAQ,CAAC,GAC7B,iBAAiB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAE3C,MAAM,MAAM,+BAA+B,GAAG,yBAAyB,CAAA;AAEvE,MAAM,MAAM,8BAA8B,GAAG,wBAAwB,CAAA;AAErE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,SAAS,WAAW,GAAG,SAAS,EACtC,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,cAAc,SAAS,WAAW,GAAG,SAAS,EAE9C,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC3C,IAAI,EAAE,+BAA+B,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,GACtE,OAAO,CAAC,+BAA+B,CAAC,CAoD1C"}

package/_types/chains/zksync/actions/signTransaction.d.ts

@@ -0,0 +1,56 @@
+import type { Account } from '../../../accounts/types.js';
+import type { SignTransactionErrorType as SignTransactionErrorType_, SignTransactionReturnType as SignTransactionReturnType_ } from '../../../actions/wallet/signTransaction.js';
+import type { Client } from '../../../clients/createClient.js';
+import type { Transport } from '../../../clients/transports/createTransport.js';
+import type { GetAccountParameter } from '../../../types/account.js';
+import type { ExtractChainFormatterParameters, GetChainParameter } from '../../../types/chain.js';
+import type { UnionOmit } from '../../../types/utils.js';
+import type { ChainEIP712 } from '../types/chain.js';
+import type { TransactionRequestEIP712 } from '../types/transaction.js';
+type FormattedTransactionRequest<TChain extends ChainEIP712 | undefined = ChainEIP712 | undefined> = ExtractChainFormatterParameters<TChain, 'transactionRequest', TransactionRequestEIP712>;
+export type SignTransactionParameters<TChain extends ChainEIP712 | undefined = ChainEIP712 | undefined, TAccount extends Account | undefined = Account | undefined, TChainOverride extends ChainEIP712 | undefined = ChainEIP712 | undefined> = UnionOmit<FormattedTransactionRequest<TChainOverride extends ChainEIP712 ? TChainOverride : TChain>, 'from'> & GetAccountParameter<TAccount> & GetChainParameter<TChain, TChainOverride>;
+export type SignTransactionReturnType = SignTransactionReturnType_;
+export type SignTransactionErrorType = SignTransactionErrorType_;
+/**
+ * Signs a transaction.
+ *
+ * - Docs: https://viem.sh/docs/zksync/actions/signTransaction
+ *
+ * @param args - {@link SignTransactionParameters}
+ * @returns The signed serialized tranasction. {@link SignTransactionReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { zkSync } from 'viem/chains'
+ * import { signTransaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   chain: zkSync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTransaction(client, {
+ *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { zkSync } from 'viem/chains'
+ * import { signTransaction } from 'viem/zksync'
+ *
+ * const client = createWalletClient({
+ *   account: privateKeyToAccount('0x…'),
+ *   chain: zkSync,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTransaction(client, {
+ *   to: '0x0000000000000000000000000000000000000000',
+ *   value: 1n,
+ * })
+ */
+export declare function signTransaction<TChain extends ChainEIP712 | undefined, TAccount extends Account | undefined, TChainOverride extends ChainEIP712 | undefined>(client: Client<Transport, TChain, TAccount>, args: SignTransactionParameters<TChain, TAccount, TChainOverride>): Promise<SignTransactionReturnType>;
+export {};
+//# sourceMappingURL=signTransaction.d.ts.map

package/_types/chains/zksync/actions/signTransaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signTransaction.d.ts","sourceRoot":"","sources":["../../../../chains/zksync/actions/signTransaction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,4BAA4B,CAAA;AAEzD,OAAO,KAAK,EACV,wBAAwB,IAAI,yBAAyB,EACrD,yBAAyB,IAAI,0BAA0B,EACxD,MAAM,4CAA4C,CAAA;AACnD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAC/E,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AACpE,OAAO,KAAK,EACV,+BAA+B,EAC/B,iBAAiB,EAClB,MAAM,yBAAyB,CAAA;AAChC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,yBAAyB,CAAA;AAIvE,KAAK,2BAA2B,CAC9B,MAAM,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,IAC9D,+BAA+B,CACjC,MAAM,EACN,oBAAoB,EACpB,wBAAwB,CACzB,CAAA;AAED,MAAM,MAAM,yBAAyB,CACnC,MAAM,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,EAChE,QAAQ,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,EAC1D,cAAc,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,IACtE,SAAS,CACX,2BAA2B,CACzB,cAAc,SAAS,WAAW,GAAG,cAAc,GAAG,MAAM,CAC7D,EACD,MAAM,CACP,GACC,mBAAmB,CAAC,QAAQ,CAAC,GAC7B,iBAAiB,CAAC,MAAM,EAAE,cAAc,CAAC,CAAA;AAE3C,MAAM,MAAM,yBAAyB,GAAG,0BAA0B,CAAA;AAElE,MAAM,MAAM,wBAAwB,GAAG,yBAAyB,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAsB,eAAe,CACnC,MAAM,SAAS,WAAW,GAAG,SAAS,EACtC,QAAQ,SAAS,OAAO,GAAG,SAAS,EACpC,cAAc,SAAS,WAAW,GAAG,SAAS,EAE9C,MAAM,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAC3C,IAAI,EAAE,yBAAyB,CAAC,MAAM,EAAE,QAAQ,EAAE,cAAc,CAAC,GAChE,OAAO,CAAC,yBAAyB,CAAC,CAGpC"}

package/_types/chains/zksync/chainConfig.d.ts

@@ -2,8 +2,8 @@ export declare const chainConfig: {
     readonly formatters: {
         readonly block: {
             exclude: [] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcBlock>, import("./types.js").ZkSyncRpcBlockOverrides & {
-                transactions: `0x${string}`[] | import("./types.js").ZkSyncRpcTransaction[];
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcBlock>, import("./index.js").ZkSyncRpcBlockOverrides & {
+                transactions: `0x${string}`[] | import("./index.js").ZkSyncRpcTransaction[];
             }>) => {
                 baseFeePerGas: bigint | null;
                 difficulty: bigint;
@@ -24,7 +24,7 @@ export declare const chainConfig: {
                 stateRoot: `0x${string}`;
                 timestamp: bigint;
                 totalDifficulty: bigint | null;
-                transactions: `0x${string}`[] | import("./types.js").ZkSyncTransaction[];
+                transactions: `0x${string}`[] | import("./index.js").ZkSyncTransaction[];
                 transactionsRoot: `0x${string}`;
                 uncles: `0x${string}`[];
                 withdrawals?: import("../../index.js").Withdrawal[] | undefined;
@@ -36,7 +36,7 @@ export declare const chainConfig: {
         };
         readonly transaction: {
             exclude: [] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransaction>, import("./types.js").ZkSyncRpcTransaction>) => ({
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransaction>, import("./index.js").ZkSyncRpcTransaction>) => ({
                 blockHash: `0x${string}` | null;
                 blockNumber: bigint | null;
                 from: `0x${string}`;
@@ -305,7 +305,7 @@ export declare const chainConfig: {
         };
         readonly transactionReceipt: {
             exclude: [] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransactionReceipt>, import("./types.js").ZkSyncRpcTransactionReceiptOverrides>) => {
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").RpcTransactionReceipt>, import("./index.js").ZkSyncRpcTransactionReceiptOverrides>) => {
                 blockHash: `0x${string}`;
                 blockNumber: bigint;
                 contractAddress: `0x${string}` | null;
@@ -313,22 +313,23 @@ export declare const chainConfig: {
                 effectiveGasPrice: bigint;
                 from: `0x${string}`;
                 gasUsed: bigint;
-                logs: import("./types.js").ZkSyncLog<bigint, number, boolean, undefined, undefined, undefined, undefined>[];
+                logs: import("./index.js").ZkSyncLog[];
                 logsBloom: `0x${string}`;
+                root?: `0x${string}` | undefined;
                 status: "success" | "reverted";
                 to: `0x${string}` | null;
                 transactionHash: `0x${string}`;
                 transactionIndex: number;
-                type: import("./types.js").ZkSyncTransactionType;
+                type: import("./index.js").ZkSyncTransactionType;
                 l1BatchNumber: bigint | null;
                 l1BatchTxIndex: bigint | null;
-                l2ToL1Logs: import("./types.js").ZkSyncL2ToL1Log[];
+                l2ToL1Logs: import("./index.js").ZkSyncL2ToL1Log[];
             } & {};
             type: "transactionReceipt";
         };
         readonly transactionRequest: {
-            exclude: ("customSignature" | "factoryDeps" | "gasPerPubdata" | "paymaster" | "paymasterInput")[] | undefined;
-            format: (args: import("../index.js").Assign<Partial<import("../../index.js").TransactionRequest>, import("./types.js").ZkSyncTransactionRequest>) => ({
+            exclude: ("gasPerPubdata" | "paymaster" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
+            format: (args: import("../index.js").Assign<Partial<import("../../index.js").TransactionRequest>, import("./index.js").ZkSyncTransactionRequest>) => ({
                 data?: `0x${string}` | undefined;
                 from: `0x${string}`;
                 gas?: `0x${string}` | undefined;
@@ -379,7 +380,7 @@ export declare const chainConfig: {
                 maxPriorityFeePerGas?: `0x${string}` | undefined;
                 accessList?: undefined;
                 type: "0xff" | "0x71";
-                eip712Meta: import("./types.js").ZkSyncEip712Meta;
+                eip712Meta: import("./index.js").ZkSyncEip712Meta;
             } | {
                 data?: `0x${string}` | undefined;
                 from: `0x${string}`;
@@ -431,7 +432,7 @@ export declare const chainConfig: {
                 maxPriorityFeePerGas?: `0x${string}` | undefined;
                 accessList?: import("../../index.js").AccessList | undefined;
                 type: "0xff" | "0x71";
-                eip712Meta: import("./types.js").ZkSyncEip712Meta;
+                eip712Meta: import("./index.js").ZkSyncEip712Meta;
             } | {
                 data?: `0x${string}` | undefined;
                 from: `0x${string}`;
@@ -483,19 +484,22 @@ export declare const chainConfig: {
                 maxPriorityFeePerGas?: `0x${string}` | undefined;
                 accessList?: import("../../index.js").AccessList | undefined;
                 type: "0xff" | "0x71";
-                eip712Meta: import("./types.js").ZkSyncEip712Meta;
+                eip712Meta: import("./index.js").ZkSyncEip712Meta;
             }) & {
-                customSignature: never;
-                factoryDeps: never;
                 gasPerPubdata: never;
                 paymaster: never;
+                factoryDeps: never;
                 paymasterInput: never;
+                customSignature: never;
             };
             type: "transactionRequest";
         };
     };
     readonly serializers: {
-        readonly transaction: import("../../index.js").SerializeTransactionFn<import("./types.js").ZkSyncTransactionSerializable>;
+        readonly transaction: import("../../index.js").SerializeTransactionFn<import("./index.js").ZkSyncTransactionSerializable>;
+    };
+    readonly custom: {
+        readonly getEip712Domain: import("./index.js").EIP712DomainFn<import("./index.js").ZkSyncTransactionSerializable, import("./index.js").ZkSyncEIP712TransactionSignable>;
     };
 };
 //# sourceMappingURL=chainConfig.d.ts.map

package/_types/chains/zksync/chainConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chainConfig.d.ts","sourceRoot":"","sources":["../../../chains/zksync/chainConfig.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAGd,CAAA"}
+{"version":3,"file":"chainConfig.d.ts","sourceRoot":"","sources":["../../../chains/zksync/chainConfig.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMd,CAAA"}

package/_types/chains/zksync/chains.d.ts

@@ -0,0 +1,4 @@
+export { zkSync } from '../definitions/zkSync.js';
+export { zkSyncTestnet } from '../definitions/zkSyncTestnet.js';
+export { zkSyncSepoliaTestnet } from '../definitions/zkSyncSepoliaTestnet.js';
+//# sourceMappingURL=chains.d.ts.map

package/_types/chains/zksync/chains.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chains.d.ts","sourceRoot":"","sources":["../../../chains/zksync/chains.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAC/D,OAAO,EAAE,oBAAoB,EAAE,MAAM,wCAAwC,CAAA"}

package/_types/chains/zksync/decorators/eip712.d.ts

@@ -0,0 +1,151 @@
+import type { Client } from '../../../clients/createClient.js';
+import type { WalletActions } from '../../../clients/decorators/wallet.js';
+import type { Transport } from '../../../clients/transports/createTransport.js';
+import type { Account } from '../../../types/account.js';
+import { type SendTransactionParameters, type SendTransactionReturnType } from '../actions/sendTransaction.js';
+import { type SignTransactionParameters, type SignTransactionReturnType } from '../actions/signTransaction.js';
+import type { ChainEIP712 } from '../types/chain.js';
+export type Eip712WalletActions<chain extends ChainEIP712 | undefined = ChainEIP712 | undefined, account extends Account | undefined = Account | undefined> = {
+    /**
+     * Creates, signs, and sends a new transaction to the network.
+     *
+     * - Docs: https://viem.sh/docs/zksync/actions/sendTransaction
+     * - JSON-RPC Methods:
+     *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+     *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+     *
+     * @param client - Client to use
+     * @param parameters - {@link SendTransactionParameters}
+     * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link SendTransactionReturnType}
+     *
+     * @example
+     * import { createWalletClient, custom } from 'viem'
+     * import { zkSync } from 'viem/chains'
+     * import { eip712WalletActions } from 'viem/zksync'
+     *
+     * const client = createWalletClient({
+     *   chain: zkSync,
+     *   transport: custom(window.ethereum),
+     * }).extend(eip712WalletActions())
+     * const hash = await client.sendTransaction({
+     *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+     *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+     *   value: 1000000000000000000n,
+     * })
+     *
+     * @example
+     * // Account Hoisting
+     * import { createWalletClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { zkSync } from 'viem/chains'
+     * import { eip712WalletActions } from 'viem/zksync'
+     *
+     * const client = createWalletClient({
+     *   account: privateKeyToAccount('0x…'),
+     *   chain: zkSync,
+     *   transport: http(),
+     * }).extend(eip712WalletActions())
+     * const hash = await client.sendTransaction({
+     *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+     *   value: 1000000000000000000n,
+     * })
+     */
+    sendTransaction: <chainOverride extends ChainEIP712 | undefined = undefined>(args: SendTransactionParameters<chain, account, chainOverride>) => Promise<SendTransactionReturnType>;
+    /**
+     * Signs a transaction.
+     *
+     * - Docs: https://viem.sh/docs/actions/wallet/signTransaction
+     * - JSON-RPC Methods:
+     *   - JSON-RPC Accounts: [`eth_signTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+     *   - Local Accounts: Signs locally. No JSON-RPC request.
+     *
+     * @param args - {@link SignTransactionParameters}
+     * @returns The signed serialized tranasction. {@link SignTransactionReturnType}
+     *
+     * @example
+     * import { createWalletClient, custom } from 'viem'
+     * import { zkSync } from 'viem/chains'
+     * import { eip712WalletActions } from 'viem/zksync'
+     *
+     * const client = createWalletClient({
+     *   chain: zkSync,
+     *   transport: custom(window.ethereum),
+     * }).extend(eip712WalletActions())
+     * const signature = await client.signTransaction({
+     *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+     *   to: '0x0000000000000000000000000000000000000000',
+     *   value: 1n,
+     * })
+     *
+     * @example
+     * // Account Hoisting
+     * import { createWalletClient, http } from 'viem'
+     * import { privateKeyToAccount } from 'viem/accounts'
+     * import { zkSync } from 'viem/chains'
+     * import { eip712WalletActions } from 'viem/zksync'
+     *
+     * const client = createWalletClient({
+     *   account: privateKeyToAccount('0x…'),
+     *   chain: zkSync,
+     *   transport: custom(window.ethereum),
+     * }).extend(eip712WalletActions())
+     * const signature = await client.signTransaction({
+     *   to: '0x0000000000000000000000000000000000000000',
+     *   value: 1n,
+     * })
+     */
+    signTransaction: <chainOverride extends ChainEIP712 | undefined = undefined>(args: SignTransactionParameters<chain, account, chainOverride>) => Promise<SignTransactionReturnType>;
+    /**
+     * Executes a write function on a contract.
+     *
+     * - Docs: https://viem.sh/docs/contract/writeContract
+     * - Examples: https://stackblitz.com/github/wevm/viem/tree/main/examples/contracts/writing-to-contracts
+     *
+     * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms) is needed to be broadcast in order to change the state.
+     *
+     * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData).
+     *
+     * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract#usage) before you execute it.__
+     *
+     * @param client - Client to use
+     * @param parameters - {@link WriteContractParameters}
+     * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms#hash). {@link WriteContractReturnType}
+     *
+     * @example
+     * import { createWalletClient, custom, parseAbi } from 'viem'
+     * import { zkSync } from 'viem/chains'
+     * import { eip712WalletActions } from 'viem/zksync'
+     *
+     * const client = createWalletClient({
+     *   chain: zkSync,
+     *   transport: custom(window.ethereum),
+     * }).extend(eip712WalletActions())
+     * const hash = await client.writeContract({
+     *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+     *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+     *   functionName: 'mint',
+     *   args: [69420],
+     * })
+     *
+     * @example
+     * // With Validation
+     * import { createWalletClient, http, parseAbi } from 'viem'
+     * import { zkSync } from 'viem/chains'
+     * import { eip712WalletActions } from 'viem/zksync'
+     *
+     * const client = createWalletClient({
+     *   chain: zkSync,
+     *   transport: http(),
+     * }).extend(eip712WalletActions())
+     * const { request } = await client.simulateContract({
+     *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+     *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+     *   functionName: 'mint',
+     *   args: [69420],
+     * }
+     * const hash = await client.writeContract(request)
+     */
+    writeContract: WalletActions<chain, account>['writeContract'];
+};
+export declare function eip712WalletActions(): <transport extends Transport, chain extends ChainEIP712 | undefined = ChainEIP712 | undefined, account extends Account | undefined = Account | undefined>(client: Client<transport, chain, account>) => Eip712WalletActions<chain, account>;
+//# sourceMappingURL=eip712.d.ts.map

package/_types/chains/zksync/decorators/eip712.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eip712.d.ts","sourceRoot":"","sources":["../../../../chains/zksync/decorators/eip712.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kCAAkC,CAAA;AAC9D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uCAAuC,CAAA;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gDAAgD,CAAA;AAC/E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,2BAA2B,CAAA;AACxD,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAE/B,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAE/B,MAAM,+BAA+B,CAAA;AACtC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAEpD,MAAM,MAAM,mBAAmB,CAC7B,KAAK,SAAS,WAAW,GAAG,SAAS,GAAG,WAAW,GAAG,SAAS,EAC/D,OAAO,SAAS,OAAO,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,IACvD;IACF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2CG;IACH,eAAe,EAAE,CAAC,aAAa,SAAS,WAAW,GAAG,SAAS,GAAG,SAAS,EACzE,IAAI,EAAE,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,KAC3D,OAAO,CAAC,yBAAyB,CAAC,CAAA;IACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0CG;IACH,eAAe,EAAE,CAAC,aAAa,SAAS,WAAW,GAAG,SAAS,GAAG,SAAS,EACzE,IAAI,EAAE,yBAAyB,CAAC,KAAK,EAAE,OAAO,EAAE,aAAa,CAAC,KAC3D,OAAO,CAAC,yBAAyB,CAAC,CAAA;IACvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAiDG;IACH,aAAa,EAAE,aAAa,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,eAAe,CAAC,CAAA;CAC9D,CAAA;AAED,wBAAgB,mBAAmB,gPAkBlC"}

package/_types/chains/zksync/errors/transaction.d.ts

@@ -0,0 +1,9 @@
+import { BaseError } from '../../../errors/base.js';
+export type InvalidEip712TransactionErrorType = InvalidEip712TransactionError & {
+    name: 'InvalidEip712TransactionError';
+};
+export declare class InvalidEip712TransactionError extends BaseError {
+    name: string;
+    constructor();
+}
+//# sourceMappingURL=transaction.d.ts.map

package/_types/chains/zksync/errors/transaction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction.d.ts","sourceRoot":"","sources":["../../../../chains/zksync/errors/transaction.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAEnD,MAAM,MAAM,iCAAiC,GAC3C,6BAA6B,GAAG;IAC9B,IAAI,EAAE,+BAA+B,CAAA;CACtC,CAAA;AACH,qBAAa,6BAA8B,SAAQ,SAAS;IACjD,IAAI,SAAkC;;CAahD"}

package/_types/chains/zksync/formatters.d.ts

@@ -1,5 +1,7 @@
 import type { Hash } from '../../types/misc.js';
-import type { ZkSyncL2ToL1Log, ZkSyncLog, ZkSyncRpcBlockOverrides, ZkSyncRpcTransaction, ZkSyncRpcTransactionReceiptOverrides, ZkSyncTransaction, ZkSyncTransactionRequest } from './types.js';
+import type { ZkSyncRpcBlockOverrides } from './types/block.js';
+import type { ZkSyncL2ToL1Log, ZkSyncLog } from './types/log.js';
+import type { ZkSyncRpcTransaction, ZkSyncRpcTransactionReceiptOverrides, ZkSyncTransaction, ZkSyncTransactionRequest } from './types/transaction.js';
 export declare const formatters: {
     readonly block: {
         exclude: [] | undefined;
@@ -314,13 +316,14 @@ export declare const formatters: {
             effectiveGasPrice: bigint;
             from: `0x${string}`;
             gasUsed: bigint;
-            logs: ZkSyncLog<bigint, number, boolean, undefined, undefined, undefined, undefined>[];
+            logs: ZkSyncLog[];
             logsBloom: `0x${string}`;
+            root?: `0x${string}` | undefined;
             status: "success" | "reverted";
             to: `0x${string}` | null;
             transactionHash: `0x${string}`;
             transactionIndex: number;
-            type: import("./types.js").ZkSyncTransactionType;
+            type: import("./types/transaction.js").ZkSyncTransactionType;
             l1BatchNumber: bigint | null;
             l1BatchTxIndex: bigint | null;
             l2ToL1Logs: ZkSyncL2ToL1Log[];
@@ -328,7 +331,7 @@ export declare const formatters: {
         type: "transactionReceipt";
     };
     readonly transactionRequest: {
-        exclude: ("customSignature" | "factoryDeps" | "gasPerPubdata" | "paymaster" | "paymasterInput")[] | undefined;
+        exclude: ("gasPerPubdata" | "paymaster" | "factoryDeps" | "paymasterInput" | "customSignature")[] | undefined;
         format: (args: import("../index.js").Assign<Partial<import("../../index.js").TransactionRequest>, ZkSyncTransactionRequest>) => ({
             data?: `0x${string}` | undefined;
             from: `0x${string}`;
@@ -380,7 +383,7 @@ export declare const formatters: {
             maxPriorityFeePerGas?: `0x${string}` | undefined;
             accessList?: undefined;
             type: "0xff" | "0x71";
-            eip712Meta: import("./types.js").ZkSyncEip712Meta;
+            eip712Meta: import("./index.js").ZkSyncEip712Meta;
         } | {
             data?: `0x${string}` | undefined;
             from: `0x${string}`;
@@ -432,7 +435,7 @@ export declare const formatters: {
             maxPriorityFeePerGas?: `0x${string}` | undefined;
             accessList?: import("../../index.js").AccessList | undefined;
             type: "0xff" | "0x71";
-            eip712Meta: import("./types.js").ZkSyncEip712Meta;
+            eip712Meta: import("./index.js").ZkSyncEip712Meta;
         } | {
             data?: `0x${string}` | undefined;
             from: `0x${string}`;
@@ -484,13 +487,13 @@ export declare const formatters: {
             maxPriorityFeePerGas?: `0x${string}` | undefined;
             accessList?: import("../../index.js").AccessList | undefined;
             type: "0xff" | "0x71";
-            eip712Meta: import("./types.js").ZkSyncEip712Meta;
+            eip712Meta: import("./index.js").ZkSyncEip712Meta;
         }) & {
-            customSignature: never;
-            factoryDeps: never;
             gasPerPubdata: never;
             paymaster: never;
+            factoryDeps: never;
             paymasterInput: never;
+            customSignature: never;
         };
         type: "transactionRequest";
     };

package/_types/chains/zksync/formatters.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../chains/zksync/formatters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAS/C,OAAO,KAAK,EAEV,eAAe,EACf,SAAS,EACT,uBAAuB,EACvB,oBAAoB,EACpB,oCAAoC,EAEpC,iBAAiB,EAEjB,wBAAwB,EACzB,MAAM,YAAY,CAAA;AAEnB,eAAO,MAAM,UAAU;;;;0BAID,IAAI,EAAE,GAAG,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;0BAGjC,IAAI,EAAE,GAAG,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHZ,CAAA"}
+{"version":3,"file":"formatters.d.ts","sourceRoot":"","sources":["../../../chains/zksync/formatters.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAA;AAS/C,OAAO,KAAK,EAEV,uBAAuB,EACxB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAChE,OAAO,KAAK,EACV,oBAAoB,EACpB,oCAAoC,EAEpC,iBAAiB,EAEjB,wBAAwB,EACzB,MAAM,wBAAwB,CAAA;AAE/B,eAAO,MAAM,UAAU;;;;0BAID,IAAI,EAAE,GAAG,oBAAoB,EAAE;;;;;;;;;;;;;;;;;;;;;0BAGjC,IAAI,EAAE,GAAG,iBAAiB,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqHZ,CAAA"}

package/_types/chains/zksync/index.d.ts

@@ -1,4 +1,15 @@
+export { type SendTransactionErrorType, type SendTransactionParameters, type SendTransactionReturnType, sendTransaction, } from './actions/sendTransaction.js';
+export { type SendEip712TransactionErrorType, type SendEip712TransactionParameters, type SendEip712TransactionReturnType, sendEip712Transaction, } from './actions/sendEip712Transaction.js';
+export { type SignEip712TransactionErrorType, type SignEip712TransactionParameters, type SignEip712TransactionReturnType, signEip712Transaction, } from './actions/signEip712Transaction.js';
+export { type SignTransactionErrorType, type SignTransactionParameters, type SignTransactionReturnType, signTransaction, } from './actions/signTransaction.js';
+export { zkSync, zkSyncTestnet, zkSyncSepoliaTestnet, } from './chains.js';
 export { chainConfig } from './chainConfig.js';
+export { eip712WalletActions, type Eip712WalletActions, } from './decorators/eip712.js';
 export { serializeTransaction } from './serializers.js';
-export type { ZkSyncBlock, ZkSyncBlockOverrides, ZkSyncEip712Meta, ZkSyncFeeValues, ZkSyncL2ToL1Log, ZkSyncLog, ZkSyncRpcBlock, ZkSyncRpcBlockOverrides, ZkSyncRpcL2ToL1Log, ZkSyncRpcLog, ZkSyncRpcTransaction, ZkSyncRpcTransactionEIP712, ZkSyncRpcTransactionPriority, ZkSyncRpcTransactionReceiptOverrides, ZkSyncRpcTransactionRequest, ZkSyncRpcTransactionRequestEIP712, ZkSyncTransaction, ZkSyncTransactionEIP712, ZkSyncTransactionReceipt, ZkSyncTransactionReceiptOverrides, ZkSyncTransactionRequest, ZkSyncTransactionRequestEIP712, ZkSyncTransactionSerializable, ZkSyncTransactionSerializableEIP712, ZkSyncTransactionSerialized, ZkSyncTransactionSerializedEIP712, ZkSyncTransactionType, } from './types.js';
+export type { ZkSyncBlock, ZkSyncBlockOverrides, ZkSyncRpcBlock, ZkSyncRpcBlockOverrides, } from './types/block.js';
+export type { ChainEIP712 } from './types/chain.js';
+export type { EIP712Domain, EIP712DomainFn, ZkSyncEip712Meta, } from './types/eip712.js';
+export type { ZkSyncFeeValues } from './types/fee.js';
+export type { ZkSyncL2ToL1Log, ZkSyncLog, ZkSyncRpcL2ToL1Log, ZkSyncRpcLog, } from './types/log.js';
+export type { TransactionRequestEIP712, ZkSyncEIP712TransactionSignable, ZkSyncRpcTransaction, ZkSyncRpcTransactionEIP712, ZkSyncRpcTransactionPriority, ZkSyncRpcTransactionReceiptOverrides, ZkSyncRpcTransactionRequest, ZkSyncRpcTransactionRequestEIP712, ZkSyncTransaction, ZkSyncTransactionEIP712, ZkSyncTransactionReceipt, ZkSyncTransactionReceiptOverrides, ZkSyncTransactionRequest, ZkSyncTransactionRequestEIP712, ZkSyncTransactionSerializable, ZkSyncTransactionSerializableEIP712, ZkSyncTransactionSerialized, ZkSyncTransactionSerializedEIP712, ZkSyncTransactionType, } from './types/transaction.js';
 //# sourceMappingURL=index.d.ts.map

package/_types/chains/zksync/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../chains/zksync/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,gBAAgB,EAChB,eAAe,EACf,eAAe,EACf,SAAS,EACT,cAAc,EACd,uBAAuB,EACvB,kBAAkB,EAClB,YAAY,EACZ,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,oCAAoC,EACpC,2BAA2B,EAC3B,iCAAiC,EACjC,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,wBAAwB,EACxB,8BAA8B,EAC9B,6BAA6B,EAC7B,mCAAmC,EACnC,2BAA2B,EAC3B,iCAAiC,EACjC,qBAAqB,GACtB,MAAM,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../chains/zksync/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,eAAe,GAChB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACpC,qBAAqB,GACtB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EACL,KAAK,8BAA8B,EACnC,KAAK,+BAA+B,EACpC,KAAK,+BAA+B,EACpC,qBAAqB,GACtB,MAAM,oCAAoC,CAAA;AAC3C,OAAO,EACL,KAAK,wBAAwB,EAC7B,KAAK,yBAAyB,EAC9B,KAAK,yBAAyB,EAC9B,eAAe,GAChB,MAAM,8BAA8B,CAAA;AAErC,OAAO,EACL,MAAM,EACN,aAAa,EACb,oBAAoB,GACrB,MAAM,aAAa,CAAA;AAEpB,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAE9C,OAAO,EACL,mBAAmB,EACnB,KAAK,mBAAmB,GACzB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAEvD,YAAY,EACV,WAAW,EACX,oBAAoB,EACpB,cAAc,EACd,uBAAuB,GACxB,MAAM,kBAAkB,CAAA;AACzB,YAAY,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AACnD,YAAY,EACV,YAAY,EACZ,cAAc,EACd,gBAAgB,GACjB,MAAM,mBAAmB,CAAA;AAC1B,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AACrD,YAAY,EACV,eAAe,EACf,SAAS,EACT,kBAAkB,EAClB,YAAY,GACb,MAAM,gBAAgB,CAAA;AACvB,YAAY,EACV,wBAAwB,EACxB,+BAA+B,EAC/B,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,oCAAoC,EACpC,2BAA2B,EAC3B,iCAAiC,EACjC,iBAAiB,EACjB,uBAAuB,EACvB,wBAAwB,EACxB,iCAAiC,EACjC,wBAAwB,EACxB,8BAA8B,EAC9B,6BAA6B,EAC7B,mCAAmC,EACnC,2BAA2B,EAC3B,iCAAiC,EACjC,qBAAqB,GACtB,MAAM,wBAAwB,CAAA"}

package/_types/chains/zksync/serializers.d.ts

@@ -1,9 +1,8 @@
 import { type SerializeTransactionFn } from '../../utils/transaction/serializeTransaction.js';
-import type { ZkSyncTransactionSerializable, ZkSyncTransactionSerializableEIP712, ZkSyncTransactionSerializedEIP712 } from './types.js';
+import type { ZkSyncTransactionSerializable, ZkSyncTransactionSerializedEIP712 } from './types/transaction.js';
 export declare const serializeTransaction: SerializeTransactionFn<ZkSyncTransactionSerializable>;
 export declare const serializers: {
     readonly transaction: SerializeTransactionFn<ZkSyncTransactionSerializable>;
 };
 export type SerializeTransactionEIP712ReturnType = ZkSyncTransactionSerializedEIP712;
-export declare function assertTransactionEIP712(transaction: ZkSyncTransactionSerializableEIP712): void;
 //# sourceMappingURL=serializers.d.ts.map

package/_types/chains/zksync/serializers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serializers.d.ts","sourceRoot":"","sources":["../../../chains/zksync/serializers.ts"],"names":[],"mappings":"AASA,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,iDAAiD,CAAA;AACxD,OAAO,KAAK,EACV,6BAA6B,EAC7B,mCAAmC,EACnC,iCAAiC,EAClC,MAAM,YAAY,CAAA;AAEnB,eAAO,MAAM,oBAAoB,EAAE,sBAAsB,CACvD,6BAA6B,CAK9B,CAAA;AAED,eAAO,MAAM,WAAW;;CAEa,CAAA;AAKrC,MAAM,MAAM,oCAAoC,GAC9C,iCAAiC,CAAA;AAgEnC,wBAAgB,uBAAuB,CACrC,WAAW,EAAE,mCAAmC,QAqBjD"}
+{"version":3,"file":"serializers.d.ts","sourceRoot":"","sources":["../../../chains/zksync/serializers.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,KAAK,sBAAsB,EAE5B,MAAM,iDAAiD,CAAA;AACxD,OAAO,KAAK,EACV,6BAA6B,EAE7B,iCAAiC,EAClC,MAAM,wBAAwB,CAAA;AAI/B,eAAO,MAAM,oBAAoB,EAAE,sBAAsB,CACvD,6BAA6B,CAK9B,CAAA;AAED,eAAO,MAAM,WAAW;;CAEa,CAAA;AAErC,MAAM,MAAM,oCAAoC,GAC9C,iCAAiC,CAAA"}

package/_types/chains/zksync/types/block.d.ts

@@ -0,0 +1,15 @@
+import type { Block, BlockTag } from '../../../types/block.js';
+import type { Hex } from '../../../types/misc.js';
+import type { RpcBlock } from '../../../types/rpc.js';
+import type { ZkSyncRpcTransaction, ZkSyncTransaction } from './transaction.js';
+export type ZkSyncBlockOverrides = {
+    l1BatchNumber: bigint | null;
+    l1BatchTimestamp: bigint | null;
+};
+export type ZkSyncBlock<TIncludeTransactions extends boolean = boolean, TBlockTag extends BlockTag = BlockTag> = Block<bigint, TIncludeTransactions, TBlockTag, ZkSyncTransaction<TBlockTag extends 'pending' ? true : false>> & ZkSyncBlockOverrides;
+export type ZkSyncRpcBlockOverrides = {
+    l1BatchNumber: Hex | null;
+    l1BatchTimestamp: Hex | null;
+};
+export type ZkSyncRpcBlock<TBlockTag extends BlockTag = BlockTag, TIncludeTransactions extends boolean = boolean> = RpcBlock<TBlockTag, TIncludeTransactions, ZkSyncRpcTransaction<TBlockTag extends 'pending' ? true : false>> & ZkSyncRpcBlockOverrides;
+//# sourceMappingURL=block.d.ts.map