viem 2.19.8 → 2.20.0

package/account-abstraction/actions/bundler/sendUserOperation.ts

@@ -7,7 +7,7 @@ import type { BaseError } from '../../../errors/base.js'
 import type { ErrorType } from '../../../errors/utils.js'
 import type { Chain } from '../../../types/chain.js'
 import type { Hex } from '../../../types/misc.js'
-import type { Assign, OneOf } from '../../../types/utils.js'
+import type { Assign, MaybeRequired, OneOf } from '../../../types/utils.js'
 import type { RequestErrorType } from '../../../utils/buildRequest.js'
 import { getAction } from '../../../utils/getAction.js'
 import type { SmartAccount } from '../../accounts/types.js'
@@ -47,27 +47,39 @@ export type SendUserOperationParameters<
   >,
   _derivedVersion extends
     EntryPointVersion = DeriveEntryPointVersion<_derivedAccount>,
-> = Assign<
-  UserOperationRequest<_derivedVersion>,
-  OneOf<{ calls: UserOperationCalls<Narrow<calls>> } | { callData: Hex }> & {
-    paymaster?:
-      | Address
-      | true
-      | {
-          /** Retrieves paymaster-related User Operation properties to be used for sending the User Operation. */
-          getPaymasterData?: PaymasterActions['getPaymasterData'] | undefined
-          /** Retrieves paymaster-related User Operation properties to be used for gas estimation. */
-          getPaymasterStubData?:
-            | PaymasterActions['getPaymasterStubData']
+> = GetSmartAccountParameter<account, accountOverride, false> &
+  (
+    | UserOperation // Accept a full-formed User Operation.
+    | Assign<
+        // Accept a partially-formed User Operation (UserOperationRequest) to be filled.
+        UserOperationRequest<_derivedVersion>,
+        OneOf<
+          { calls: UserOperationCalls<Narrow<calls>> } | { callData: Hex }
+        > & {
+          paymaster?:
+            | Address
+            | true
+            | {
+                /** Retrieves paymaster-related User Operation properties to be used for sending the User Operation. */
+                getPaymasterData?:
+                  | PaymasterActions['getPaymasterData']
+                  | undefined
+                /** Retrieves paymaster-related User Operation properties to be used for gas estimation. */
+                getPaymasterStubData?:
+                  | PaymasterActions['getPaymasterStubData']
+                  | undefined
+              }
             | undefined
+          /** Paymaster context to pass to `getPaymasterData` and `getPaymasterStubData` calls. */
+          paymasterContext?: unknown | undefined
         }
-      | undefined
-    /** Paymaster context to pass to `getPaymasterData` and `getPaymasterStubData` calls. */
-    paymasterContext?: unknown
-  }
-> &
-  GetSmartAccountParameter<account, accountOverride>
-
+      >
+  ) &
+  // Allow the EntryPoint address to be overridden, if no Account is provided, it will need to be required.
+  MaybeRequired<
+    { entryPointAddress?: Address },
+    _derivedAccount extends undefined ? true : false
+  >
 export type SendUserOperationReturnType = Hex
 
 export type SendUserOperationErrorType =
@@ -111,20 +123,21 @@ export async function sendUserOperation<
   client: Client<Transport, Chain | undefined, account>,
   parameters: SendUserOperationParameters<account, accountOverride, calls>,
 ) {
-  const { account: account_ = client.account } = parameters
+  const { account: account_ = client.account, entryPointAddress } = parameters
 
-  if (!account_) throw new AccountNotFoundError()
-  const account = parseAccount(account_)
+  if (!account_ && !parameters.sender) throw new AccountNotFoundError()
+  const account = account_ ? parseAccount(account_) : undefined
 
-  const request = await getAction(
-    client,
-    prepareUserOperation,
-    'prepareUserOperation',
-  )(parameters as unknown as PrepareUserOperationParameters)
+  const request = account
+    ? await getAction(
+        client,
+        prepareUserOperation,
+        'prepareUserOperation',
+      )(parameters as unknown as PrepareUserOperationParameters)
+    : parameters
 
-  const signature =
-    parameters.signature ||
-    (await account.signUserOperation(request as UserOperation))
+  const signature = (parameters.signature ||
+    (await account?.signUserOperation(request as UserOperation)))!
 
   const rpcParameters = formatUserOperationRequest({
     ...request,
@@ -135,14 +148,18 @@ export async function sendUserOperation<
     return await client.request(
       {
         method: 'eth_sendUserOperation',
-        params: [rpcParameters, account.entryPoint.address],
+        params: [
+          rpcParameters,
+          (entryPointAddress ?? account?.entryPoint.address)!,
+        ],
       },
       { retryCount: 0 },
     )
   } catch (error) {
+    const calls = (parameters as any).calls
     throw getUserOperationError(error as BaseError, {
       ...(request as UserOperation),
-      calls: parameters.calls,
+      ...(calls ? { calls } : {}),
       signature,
     })
   }

package/accounts/privateKeyToAccount.ts

@@ -66,7 +66,7 @@ export function privateKeyToAccount(
       return signTransaction({ privateKey, transaction, serializer })
     },
     async signTypedData(typedData) {
-      return signTypedData({ ...typedData, privateKey })
+      return signTypedData({ ...typedData, privateKey } as any)
     },
   })
 

package/actions/test/setCode.ts

@@ -50,8 +50,14 @@ export async function setCode<
   client: TestClient<TestClientMode, Transport, chain, account, false>,
   { address, bytecode }: SetCodeParameters,
 ) {
-  await client.request({
-    method: `${client.mode}_setCode`,
-    params: [address, bytecode],
-  })
+  if (client.mode === 'ganache')
+    await client.request({
+      method: 'evm_setAccountCode',
+      params: [address, bytecode],
+    })
+  else
+    await client.request({
+      method: `${client.mode}_setCode`,
+      params: [address, bytecode],
+    })
 }

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.19.8'
+export const version = '2.20.0'

package/experimental/eip5792/actions/sendCalls.ts

@@ -1,3 +1,4 @@
+import type { AbiStateMutability, Address, Narrow } from 'abitype'
 import { parseAccount } from '../../../accounts/utils/parseAccount.js'
 import type { Client } from '../../../clients/createClient.js'
 import type { Transport } from '../../../clients/transports/createTransport.js'
@@ -6,13 +7,16 @@ import type { BaseError } from '../../../errors/base.js'
 import { ChainNotFoundError } from '../../../errors/chain.js'
 import type { ErrorType } from '../../../errors/utils.js'
 import type { Account, GetAccountParameter } from '../../../types/account.js'
-import type { Chain, GetChainParameter } from '../../../types/chain.js'
+import type { Chain, DeriveChain } from '../../../types/chain.js'
+import type { ContractFunctionParameters } from '../../../types/contract.js'
 import type {
   WalletCapabilities,
   WalletSendCallsParameters,
 } from '../../../types/eip1193.js'
 import type { Hex } from '../../../types/misc.js'
-import type { OneOf } from '../../../types/utils.js'
+import type { GetMulticallContractParameters } from '../../../types/multicall.js'
+import type { MaybeRequired, OneOf, Prettify } from '../../../types/utils.js'
+import { encodeFunctionData } from '../../../utils/abi/encodeFunctionData.js'
 import type { RequestErrorType } from '../../../utils/buildRequest.js'
 import { numberToHex } from '../../../utils/encoding/toHex.js'
 import { getTransactionError } from '../../../utils/errors/getTransactionError.js'
@@ -21,23 +25,17 @@ export type SendCallsParameters<
   chain extends Chain | undefined = Chain | undefined,
   account extends Account | undefined = Account | undefined,
   chainOverride extends Chain | undefined = Chain | undefined,
+  calls extends readonly unknown[] = readonly unknown[],
+  //
+  _chain extends Chain | undefined = DeriveChain<chain, chainOverride>,
 > = {
-  calls: OneOf<
-    | {
-        to: Hex
-        data?: Hex | undefined
-        value?: bigint | undefined
-      }
-    | {
-        data: Hex
-      }
-  >[]
+  chain?: chainOverride | Chain | undefined
+  calls: Calls<Narrow<calls>, _chain>
   capabilities?:
     | WalletSendCallsParameters<WalletCapabilities>[number]['capabilities']
     | undefined
   version?: WalletSendCallsParameters[number]['version'] | undefined
-} & GetAccountParameter<account> &
-  GetChainParameter<chain, chainOverride>
+} & GetAccountParameter<account>
 
 export type SendCallsReturnType = string
 
@@ -76,16 +74,16 @@ export type SendCallsErrorType = RequestErrorType | ErrorType
  * })
  */
 export async function sendCalls<
+  const calls extends readonly unknown[],
   chain extends Chain | undefined,
   account extends Account | undefined = undefined,
   chainOverride extends Chain | undefined = undefined,
 >(
   client: Client<Transport, chain, account>,
-  parameters: SendCallsParameters<chain, account, chainOverride>,
+  parameters: SendCallsParameters<chain, account, chainOverride, calls>,
 ): Promise<SendCallsReturnType> {
   const {
     account: account_ = client.account,
-    calls,
     capabilities,
     chain = client.chain,
     version = '1.0',
@@ -97,7 +95,27 @@ export async function sendCalls<
     })
   const account = parseAccount(account_)
 
-  if (!chain) throw new ChainNotFoundError()
+  const calls = parameters.calls.map((call_: unknown) => {
+    const call = call_ as Call
+
+    const chainId = call.chain?.id ?? call.chainId ?? chain?.id
+    if (!chainId) throw new ChainNotFoundError()
+
+    const data = call.abi
+      ? encodeFunctionData({
+          abi: call.abi,
+          functionName: call.functionName,
+          args: call.args,
+        })
+      : call.data
+
+    return {
+      chainId: numberToHex(chainId),
+      data,
+      to: call.to,
+      value: call.value ? numberToHex(call.value) : undefined,
+    }
+  })
 
   try {
     return await client.request(
@@ -105,10 +123,7 @@ export async function sendCalls<
         method: 'wallet_sendCalls',
         params: [
           {
-            calls: calls.map((call) => ({
-              ...call,
-              value: call.value ? numberToHex(call.value) : undefined,
-            })) as any,
+            calls,
             capabilities,
             chainId: numberToHex(chain!.id),
             from: account.address,
@@ -126,3 +141,74 @@ export async function sendCalls<
     })
   }
 }
+
+///////////////////////////////////////////////////////////////////////////////////////////////////
+
+type RawCall = { data?: Hex; to?: Address; value?: bigint }
+
+type Call<
+  chain extends Chain | undefined = Chain | undefined,
+  contractFunctionParameters = Omit<ContractFunctionParameters, 'address'>,
+> = OneOf<
+  | (contractFunctionParameters & {
+      to: Address
+      value?: bigint | undefined
+    })
+  | RawCall
+> &
+  OneOf<
+    | MaybeRequired<
+        { chain?: Chain | undefined },
+        chain extends Chain ? false : true
+      >
+    | MaybeRequired<{ chainId?: number }, chain extends Chain ? false : true>
+  >
+
+type Calls<
+  calls extends readonly unknown[],
+  chain extends Chain | undefined,
+  ///
+  result extends readonly any[] = [],
+> = calls extends readonly [] // no calls, return empty
+  ? readonly []
+  : calls extends readonly [infer call] // one call left before returning `result`
+    ? readonly [
+        ...result,
+        Prettify<
+          Call<
+            chain,
+            Omit<
+              GetMulticallContractParameters<call, AbiStateMutability>,
+              'address'
+            >
+          >
+        >,
+      ]
+    : calls extends readonly [infer call, ...infer rest] // grab first call and recurse through `rest`
+      ? Calls<
+          [...rest],
+          chain,
+          [
+            ...result,
+            Prettify<
+              Call<
+                chain,
+                Omit<
+                  GetMulticallContractParameters<call, AbiStateMutability>,
+                  'address'
+                >
+              >
+            >,
+          ]
+        >
+      : readonly unknown[] extends calls
+        ? calls
+        : // If `calls` is *some* array but we couldn't assign `unknown[]` to it, then it must hold some known/homogenous type!
+          // use this to infer the param types in the case of Array.map() argument
+          calls extends readonly (infer call extends Call<
+              chain,
+              Omit<ContractFunctionParameters, 'address'>
+            >)[]
+          ? readonly Prettify<call>[]
+          : // Fallback
+            readonly Call<chain, Omit<ContractFunctionParameters, 'address'>>[]

package/experimental/eip5792/actions/writeContracts.ts

@@ -50,6 +50,8 @@ export type WriteContractsErrorType =
   | ErrorType
 
 /**
+ * @deprecated Use {@link sendCalls} instead. See https://viem.sh/experimental/eip5792/sendCalls#contract-calls.
+ *
  * Requests for the wallet to sign and broadcast a batch of write contract calls (transactions) to the network.
  *
  * - Docs: https://viem.sh/experimental/eip5792/writeContracts

package/op-stack/actions/getTimeToFinalize.ts

@@ -128,11 +128,18 @@ export async function getTimeToFinalize<
     return { period: Number(period), seconds, timestamp }
   }
 
+  const numProofSubmitters = await readContract(client, {
+    abi: portal2Abi,
+    address: portalAddress,
+    functionName: 'numProofSubmitters',
+    args: [withdrawalHash],
+  }).catch(() => 1n)
+
   const proofSubmitter = await readContract(client, {
     abi: portal2Abi,
     address: portalAddress,
     functionName: 'proofSubmitters',
-    args: [withdrawalHash, 0n],
+    args: [withdrawalHash, numProofSubmitters - 1n],
   }).catch(() => undefined)
 
   const [[_disputeGameProxy, proveTimestamp], proofMaturityDelaySeconds] =

package/op-stack/actions/getWithdrawalStatus.ts

@@ -197,11 +197,18 @@ export async function getWithdrawalStatus<
     return seconds > 0 ? 'waiting-to-finalize' : 'ready-to-finalize'
   }
 
+  const numProofSubmitters = await readContract(client, {
+    abi: portal2Abi,
+    address: portalAddress,
+    functionName: 'numProofSubmitters',
+    args: [withdrawal.withdrawalHash],
+  }).catch(() => 1n)
+
   const proofSubmitter = await readContract(client, {
     abi: portal2Abi,
     address: portalAddress,
     functionName: 'proofSubmitters',
-    args: [withdrawal.withdrawalHash, 0n],
+    args: [withdrawal.withdrawalHash, numProofSubmitters - 1n],
   }).catch(() => withdrawal.sender)
 
   const [disputeGameResult, checkWithdrawalResult, finalizedResult] =

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.19.8",
+  "version": "2.20.0",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/eip1193.ts

@@ -207,18 +207,15 @@ export type WalletSendCallsParameters<
   quantity extends Quantity | bigint = Quantity,
 > = [
   {
-    calls: OneOf<
-      | {
-          to: Address
-          data?: Hex | undefined
-          value?: quantity | undefined
-        }
-      | {
-          data: Hex
-        }
-    >[]
+    calls: readonly {
+      chainId?: chainId | undefined
+      to?: Address | undefined
+      data?: Hex | undefined
+      value?: quantity | undefined
+    }[]
     capabilities?: capabilities | undefined
-    chainId: chainId
+    /** @deprecated Use `chainId` on `calls` instead. */
+    chainId?: chainId | undefined
     from: Address
     version: string
   },
@@ -1335,7 +1332,7 @@ export type TestRpcSchema<mode extends string> = [
    * @link https://ganache.dev/#evm_setAccountBalance
    */
   {
-    Method: `evm_setAccountBalance`
+    Method: 'evm_setAccountBalance'
     Parameters: [
       /** The address of the target account. */
       address: Address,
@@ -1344,12 +1341,26 @@ export type TestRpcSchema<mode extends string> = [
     ]
     ReturnType: void
   },
+  /**
+   * @description Modifies the bytecode stored at an account's address.
+   * @link https://ganache.dev/#evm_setAccountCode
+   */
+  {
+    Method: 'evm_setAccountCode'
+    Parameters: [
+      /** The address of the contract. */
+      address: Address,
+      /** Data bytecode. */
+      data: string,
+    ]
+    ReturnType: void
+  },
   /**
    * @description Enables or disables, based on the single boolean argument, the automatic mining of new blocks with each new transaction submitted to the network.
    * @link https://hardhat.org/hardhat-network/docs/reference#evm_setautomine
    */
   {
-    Method: `evm_setAutomine`
+    Method: 'evm_setAutomine'
     Parameters: [boolean]
     ReturnType: void
   },
@@ -1367,7 +1378,7 @@ export type TestRpcSchema<mode extends string> = [
    * @link https://github.com/trufflesuite/ganache/blob/ef1858d5d6f27e4baeb75cccd57fb3dc77a45ae8/src/chains/ethereum/ethereum/RPC-METHODS.md#evm_increasetime
    */
   {
-    Method: `evm_increaseTime`
+    Method: 'evm_increaseTime'
     Parameters: [seconds: Quantity]
     ReturnType: Quantity
   },

package/zksync/accounts/toMultisigSmartAccount.ts

@@ -0,0 +1,37 @@
+import type { Address } from 'abitype'
+
+import { sign } from '../../accounts/utils/sign.js'
+import type { Hex } from '../../types/misc.js'
+import { concatHex } from '../../utils/index.js'
+import type { ZksyncSmartAccount } from '../types/account.js'
+import { toSmartAccount } from './toSmartAccount.js'
+
+export type ToMultisigSmartAccountParameters = {
+  /** Address of the deployed Account's Contract implementation. */
+  address: Address
+  /** Array of Private Keys belonging to the owners. */
+  privateKeys: readonly Hex[]
+}
+
+/**
+ * Creates a [ZKsync Smart Account](https://docs.zksync.io/build/developer-reference/account-abstraction/building-smart-accounts)
+ * from a Contract Address and an array of Private Keys belonging to the owners.
+ */
+export function toMultisigSmartAccount(
+  parameters: ToMultisigSmartAccountParameters,
+): ZksyncSmartAccount {
+  const { address, privateKeys } = parameters
+
+  return toSmartAccount({
+    address,
+    async sign({ hash }) {
+      return concatHex(
+        await Promise.all(
+          privateKeys.map((privateKey) =>
+            sign({ hash, privateKey, to: 'hex' }),
+          ),
+        ),
+      )
+    },
+  })
+}

package/zksync/accounts/toSinglesigSmartAccount.ts

@@ -0,0 +1,30 @@
+import type { Address } from 'abitype'
+
+import { sign } from '../../accounts/utils/sign.js'
+import type { Hex } from '../../types/misc.js'
+import type { ZksyncSmartAccount } from '../types/account.js'
+import { toSmartAccount } from './toSmartAccount.js'
+
+export type ToSinglesigSmartAccountParameters = {
+  /** Address of the deployed Account's Contract implementation. */
+  address: Address
+  /** Private Key of the owner. */
+  privateKey: Hex
+}
+
+/**
+ * Creates a [ZKsync Smart Account](https://docs.zksync.io/build/developer-reference/account-abstraction/building-smart-accounts)
+ * from a Contract Address and a Private Key belonging to the owner.
+ */
+export function toSinglesigSmartAccount(
+  parameters: ToSinglesigSmartAccountParameters,
+): ZksyncSmartAccount {
+  const { address, privateKey } = parameters
+
+  return toSmartAccount({
+    address,
+    async sign({ hash }) {
+      return sign({ hash, privateKey, to: 'hex' })
+    },
+  })
+}

package/zksync/accounts/toSmartAccount.ts

@@ -0,0 +1,63 @@
+import type { Address } from 'abitype'
+
+import { toAccount } from '../../accounts/toAccount.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Hash, Hex } from '../../types/misc.js'
+import { keccak256 } from '../../utils/index.js'
+import { hashMessage } from '../../utils/signature/hashMessage.js'
+import { hashTypedData } from '../../utils/signature/hashTypedData.js'
+import { serializeTransaction } from '../serializers.js'
+import type { ZksyncSmartAccount } from '../types/account.js'
+import type { ZksyncTransactionSerializableEIP712 } from '../types/transaction.js'
+
+export type ToSmartAccountParameters = {
+  /** Address of the deployed Account's Contract implementation. */
+  address: Address
+  /** Function to sign a hash. */
+  sign: (parameters: { hash: Hash }) => Promise<Hex>
+}
+
+export type ToSmartAccountErrorType = ErrorType
+
+/**
+ * Creates a [ZKsync Smart Account](https://docs.zksync.io/build/developer-reference/account-abstraction/building-smart-accounts)
+ * from a Contract Address and a custom sign function.
+ */
+export function toSmartAccount(
+  parameters: ToSmartAccountParameters,
+): ZksyncSmartAccount {
+  const { address, sign } = parameters
+
+  const account = toAccount({
+    address,
+    sign,
+    async signMessage({ message }) {
+      return sign({
+        hash: hashMessage(message),
+      })
+    },
+    async signTransaction(transaction) {
+      const signableTransaction = {
+        ...transaction,
+        from: this.address!,
+      } as ZksyncTransactionSerializableEIP712
+
+      return serializeTransaction({
+        ...signableTransaction,
+        customSignature: await sign({
+          hash: keccak256(serializeTransaction(signableTransaction)),
+        }),
+      })
+    },
+    async signTypedData(typedData) {
+      return sign({
+        hash: hashTypedData(typedData),
+      })
+    },
+  })
+
+  return {
+    ...account,
+    source: 'smartAccountZksync',
+  } as ZksyncSmartAccount
+}

package/zksync/index.ts

@@ -1,4 +1,18 @@
 // biome-ignore lint/performance/noBarrelFile: entrypoint module
+export {
+  type ToSmartAccountErrorType,
+  type ToSmartAccountParameters,
+  toSmartAccount,
+} from './accounts/toSmartAccount.js'
+export {
+  type ToMultisigSmartAccountParameters,
+  toMultisigSmartAccount,
+} from './accounts/toMultisigSmartAccount.js'
+export {
+  type ToSinglesigSmartAccountParameters,
+  toSinglesigSmartAccount,
+} from './accounts/toSinglesigSmartAccount.js'
+
 export {
   type DeployContractErrorType,
   type DeployContractParameters,
@@ -131,6 +145,7 @@ export {
 
 export { serializeTransaction } from './serializers.js'
 
+export type { ZksyncSmartAccount } from './types/account.js'
 export type {
   /** @deprecated Use `ZksyncBlock` instead */
   ZksyncBlock as ZkSyncBlock,

package/zksync/types/account.ts

@@ -0,0 +1,5 @@
+import type { CustomSource, LocalAccount } from '../../accounts/types.js'
+
+export type ZksyncSmartAccount = LocalAccount<'smartAccountZksync'> & {
+  sign: NonNullable<CustomSource['sign']>
+}