viem 2.5.0 → 2.6.0

package/chains/zksync/actions/signEip712Transaction.ts

@@ -0,0 +1,150 @@
+import type { Account } from '../../../accounts/types.js'
+import { parseAccount } from '../../../accounts/utils/parseAccount.js'
+import { getChainId } from '../../../actions/public/getChainId.js'
+import type {
+  SignTransactionErrorType,
+  SignTransactionReturnType,
+} from '../../../actions/wallet/signTransaction.js'
+import { signTypedData } from '../../../actions/wallet/signTypedData.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import { AccountNotFoundError } from '../../../errors/account.js'
+import { BaseError } from '../../../errors/base.js'
+import type { GetAccountParameter } from '../../../types/account.js'
+import type {
+  ExtractChainFormatterParameters,
+  GetChainParameter,
+} from '../../../types/chain.js'
+import type { UnionOmit } from '../../../types/utils.js'
+import { assertCurrentChain } from '../../../utils/chain/assertCurrentChain.js'
+import { getAction } from '../../../utils/getAction.js'
+import type { ChainEIP712 } from '../types/chain.js'
+import type { TransactionRequestEIP712 } from '../types/transaction.js'
+import {
+  type AssertEip712RequestParameters,
+  assertEip712Request,
+} from '../utils/assertEip712Request.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 async 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> {
+  const {
+    account: account_ = client.account,
+    chain = client.chain,
+    ...transaction
+  } = args
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/docs/actions/wallet/signTransaction',
+    })
+  const account = parseAccount(account_)
+
+  assertEip712Request({
+    account,
+    chain,
+    ...(args as AssertEip712RequestParameters),
+  })
+
+  if (!chain?.custom?.getEip712Domain)
+    throw new BaseError('`getEip712Domain` not found on chain.')
+  if (!chain?.serializers?.transaction)
+    throw new BaseError('transaction serializer not found on chain.')
+
+  const chainId = await getAction(client, getChainId, 'getChainId')({})
+  if (chain !== null)
+    assertCurrentChain({
+      currentChainId: chainId,
+      chain: chain,
+    })
+
+  const eip712Domain = chain?.custom.getEip712Domain({
+    ...transaction,
+    chainId,
+    from: account.address,
+    type: 'eip712',
+  })
+
+  const customSignature = await signTypedData(client, {
+    ...eip712Domain,
+    account,
+  })
+
+  return chain?.serializers?.transaction(
+    {
+      chainId,
+      ...transaction,
+      customSignature,
+      type: 'eip712',
+    },
+    { r: '0x0', s: '0x0', v: 0n },
+  )
+}

package/chains/zksync/actions/signTransaction.ts

@@ -0,0 +1,95 @@
+import type { Account } from '../../../accounts/types.js'
+import { signTransaction as signTransaction_ } from '../../../actions/wallet/signTransaction.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'
+import { isEIP712Transaction } from '../utils/isEip712Transaction.js'
+import { signEip712Transaction } from './signEip712Transaction.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 async 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> {
+  if (isEIP712Transaction(args)) return signEip712Transaction(client, args)
+  return await signTransaction_(client, args as any)
+}

package/chains/zksync/chainConfig.ts

@@ -1,7 +1,11 @@
 import { formatters } from './formatters.js'
 import { serializers } from './serializers.js'
+import { getEip712Domain } from './utils/getEip712Domain.js'
 
 export const chainConfig = {
   formatters,
   serializers,
+  custom: {
+    getEip712Domain,
+  },
 } as const

package/chains/zksync/chains.ts

@@ -0,0 +1,3 @@
+export { zkSync } from '../definitions/zkSync.js'
+export { zkSyncTestnet } from '../definitions/zkSyncTestnet.js'
+export { zkSyncSepoliaTestnet } from '../definitions/zkSyncSepoliaTestnet.js'

package/chains/zksync/decorators/eip712.ts

@@ -0,0 +1,186 @@
+import { writeContract } from '../../../actions/wallet/writeContract.js'
+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,
+  sendTransaction,
+} from '../actions/sendTransaction.js'
+import {
+  type SignTransactionParameters,
+  type SignTransactionReturnType,
+  signTransaction,
+} 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 function eip712WalletActions() {
+  return <
+    transport extends Transport,
+    chain extends ChainEIP712 | undefined = ChainEIP712 | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): Eip712WalletActions<chain, account> => ({
+    sendTransaction: (args) => sendTransaction(client, args),
+    signTransaction: (args) => signTransaction(client, args),
+    writeContract: (args) =>
+      writeContract(
+        Object.assign(client, {
+          sendTransaction: (args: any) => sendTransaction(client, args),
+        }),
+        args,
+      ),
+  })
+}

package/chains/zksync/errors/transaction.ts

@@ -0,0 +1,21 @@
+import { BaseError } from '../../../errors/base.js'
+
+export type InvalidEip712TransactionErrorType =
+  InvalidEip712TransactionError & {
+    name: 'InvalidEip712TransactionError'
+  }
+export class InvalidEip712TransactionError extends BaseError {
+  override name = 'InvalidEip712TransactionError'
+
+  constructor() {
+    super(
+      [
+        'Transaction is not an EIP712 transaction.',
+        '',
+        'Transaction must:',
+        '  - include `type: "eip712"`',
+        '  - include one of the following: `customSignature`, `paymaster`, `paymasterInput`, `gasPerPubdata`, `factoryDeps`',
+      ].join('\n'),
+    )
+  }
+}

package/chains/zksync/formatters.ts

@@ -10,16 +10,17 @@ import { defineTransactionReceipt } from '../../utils/formatters/transactionRece
 import { defineTransactionRequest } from '../../utils/formatters/transactionRequest.js'
 import type {
   ZkSyncBlockOverrides,
-  ZkSyncL2ToL1Log,
-  ZkSyncLog,
   ZkSyncRpcBlockOverrides,
+} from './types/block.js'
+import type { ZkSyncL2ToL1Log, ZkSyncLog } from './types/log.js'
+import type {
   ZkSyncRpcTransaction,
   ZkSyncRpcTransactionReceiptOverrides,
   ZkSyncRpcTransactionRequest,
   ZkSyncTransaction,
   ZkSyncTransactionReceipt,
   ZkSyncTransactionRequest,
-} from './types.js'
+} from './types/transaction.js'
 
 export const formatters = {
   block: /*#__PURE__*/ defineBlock({
@@ -32,7 +33,7 @@ export const formatters = {
     } {
       const transactions = args.transactions?.map((transaction) => {
         if (typeof transaction === 'string') return transaction
-        const formatted = formatters.transaction.format(
+        const formatted = formatters.transaction?.format(
           transaction as ZkSyncRpcTransaction,
         ) as ZkSyncTransaction
         if (formatted.typeHex === '0x71') formatted.type = 'eip712'
@@ -140,7 +141,7 @@ export const formatters = {
                 }
               : {}),
           },
-          type: args.type === 'eip712' ? '0x71' : '0xff',
+          type: '0x71',
         } as ZkSyncRpcTransactionRequest
       return {} as ZkSyncRpcTransactionRequest
     },

package/chains/zksync/index.ts

@@ -1,18 +1,65 @@
+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,
+  ZkSyncRpcBlock,
+  ZkSyncRpcBlockOverrides,
+} from './types/block.js'
+export type { ChainEIP712 } from './types/chain.js'
+export type {
+  EIP712Domain,
+  EIP712DomainFn,
   ZkSyncEip712Meta,
-  ZkSyncFeeValues,
+} from './types/eip712.js'
+export type { ZkSyncFeeValues } from './types/fee.js'
+export type {
   ZkSyncL2ToL1Log,
   ZkSyncLog,
-  ZkSyncRpcBlock,
-  ZkSyncRpcBlockOverrides,
   ZkSyncRpcL2ToL1Log,
   ZkSyncRpcLog,
+} from './types/log.js'
+export type {
+  TransactionRequestEIP712,
+  ZkSyncEIP712TransactionSignable,
   ZkSyncRpcTransaction,
   ZkSyncRpcTransactionEIP712,
   ZkSyncRpcTransactionPriority,
@@ -30,4 +77,4 @@ export type {
   ZkSyncTransactionSerialized,
   ZkSyncTransactionSerializedEIP712,
   ZkSyncTransactionType,
-} from './types.js'
+} from './types/transaction.js'

package/chains/zksync/serializers.ts

@@ -1,9 +1,5 @@
-import { InvalidAddressError } from '../../errors/address.js'
-import { BaseError } from '../../errors/base.js'
-import { InvalidChainIdError } from '../../errors/chain.js'
 import type { ChainSerializers } from '../../types/chain.js'
 import type { TransactionSerializable } from '../../types/transaction.js'
-import { isAddress } from '../../utils/address/isAddress.js'
 import { concatHex } from '../../utils/data/concat.js'
 import { toHex } from '../../utils/encoding/toHex.js'
 import { toRlp } from '../../utils/encoding/toRlp.js'
@@ -15,12 +11,14 @@ import type {
   ZkSyncTransactionSerializable,
   ZkSyncTransactionSerializableEIP712,
   ZkSyncTransactionSerializedEIP712,
-} from './types.js'
+} from './types/transaction.js'
+import { assertEip712Transaction } from './utils/assertEip712Transaction.js'
+import { isEIP712Transaction } from './utils/isEip712Transaction.js'
 
 export const serializeTransaction: SerializeTransactionFn<
   ZkSyncTransactionSerializable
 > = (tx, signature) => {
-  if (isEIP712(tx))
+  if (isEIP712Transaction(tx))
     return serializeTransactionEIP712(tx as ZkSyncTransactionSerializableEIP712)
   return serializeTransaction_(tx as TransactionSerializable, signature)
 }
@@ -29,9 +27,6 @@ export const serializers = {
   transaction: serializeTransaction,
 } as const satisfies ChainSerializers
 
-//////////////////////////////////////////////////////////////////////////////
-// Serializers
-
 export type SerializeTransactionEIP712ReturnType =
   ZkSyncTransactionSerializedEIP712
 
@@ -55,7 +50,7 @@ function serializeTransactionEIP712(
     data,
   } = transaction
 
-  assertTransactionEIP712(transaction)
+  assertEip712Transaction(transaction)
 
   const serializedTransaction = [
     nonce ? toHex(nonce) : '0x',
@@ -64,7 +59,7 @@ function serializeTransactionEIP712(
     gas ? toHex(gas) : '0x',
     to ?? '0x',
     value ? toHex(value) : '0x',
-    data ?? '0x',
+    data ?? '0x0',
     toHex(chainId),
     toHex(''),
     toHex(''),
@@ -81,42 +76,3 @@ function serializeTransactionEIP712(
     toRlp(serializedTransaction),
   ]) as SerializeTransactionEIP712ReturnType
 }
-
-//////////////////////////////////////////////////////////////////////////////
-// Utilities
-
-function isEIP712(transaction: ZkSyncTransactionSerializable) {
-  if (
-    'customSignature' in transaction ||
-    'paymaster' in transaction ||
-    'paymasterInput' in transaction ||
-    'gasPerPubdata' in transaction ||
-    'factoryDeps' in transaction
-  )
-    return true
-  return false
-}
-
-export function assertTransactionEIP712(
-  transaction: ZkSyncTransactionSerializableEIP712,
-) {
-  const { chainId, to, from, paymaster, paymasterInput } = transaction
-  if (chainId <= 0) throw new InvalidChainIdError({ chainId })
-
-  if (to && !isAddress(to)) throw new InvalidAddressError({ address: to })
-  if (from && !isAddress(from)) throw new InvalidAddressError({ address: from })
-  if (paymaster && !isAddress(paymaster))
-    throw new InvalidAddressError({ address: paymaster })
-
-  if (paymaster && !paymasterInput) {
-    throw new BaseError(
-      '`paymasterInput` must be provided when `paymaster` is defined',
-    )
-  }
-
-  if (!paymaster && paymasterInput) {
-    throw new BaseError(
-      '`paymaster` must be provided when `paymasterInput` is defined',
-    )
-  }
-}