viem 2.21.58 → 2.21.60

package/experimental/erc7821/actions/supportsExecutionMode.ts

@@ -0,0 +1,60 @@
+import type { Address } from '../../../accounts/index.js'
+import { readContract } from '../../../actions/public/readContract.js'
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Chain } from '../../../types/chain.js'
+import type { Hex } from '../../../types/misc.js'
+import { abi, executionMode } from '../constants.js'
+
+export type SupportsExecutionModeParameters = {
+  address: Address
+  opData?: Hex | undefined
+}
+
+export type SupportsExecutionModeReturnType = boolean
+
+export type SupportsExecutionModeErrorType = ErrorType
+
+/**
+ * Checks if the contract supports the ERC-7821 execution mode.
+ *
+ * @example
+ * ```ts
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { supportsExecutionMode } from 'viem/experimental/erc7821'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ *
+ * const supported = await supportsExecutionMode(client, {
+ *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+ * })
+ * ```
+ *
+ * @param client - Client to use.
+ * @param parameters - {@link SupportsExecutionModeParameters}
+ * @returns If the execution mode is supported. {@link SupportsExecutionModeReturnType}
+ */
+export async function supportsExecutionMode<
+  chain extends Chain | undefined = Chain | undefined,
+>(
+  client: Client<Transport, chain>,
+  parameters: SupportsExecutionModeParameters,
+): Promise<SupportsExecutionModeReturnType> {
+  const { address, opData } = parameters
+  const mode = opData ? executionMode.opData : executionMode.default
+  try {
+    return await readContract(client, {
+      abi,
+      address,
+      functionName: 'supportsExecutionMode',
+      args: [mode],
+    })
+  } catch {
+    return false
+  }
+}

package/experimental/erc7821/constants.ts

@@ -0,0 +1,62 @@
+export const abi = [
+  {
+    type: 'fallback',
+    stateMutability: 'payable',
+  },
+  {
+    type: 'receive',
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'execute',
+    inputs: [
+      {
+        name: 'mode',
+        type: 'bytes32',
+        internalType: 'bytes32',
+      },
+      {
+        name: 'executionData',
+        type: 'bytes',
+        internalType: 'bytes',
+      },
+    ],
+    outputs: [],
+    stateMutability: 'payable',
+  },
+  {
+    type: 'function',
+    name: 'supportsExecutionMode',
+    inputs: [
+      {
+        name: 'mode',
+        type: 'bytes32',
+        internalType: 'bytes32',
+      },
+    ],
+    outputs: [
+      {
+        name: 'result',
+        type: 'bool',
+        internalType: 'bool',
+      },
+    ],
+    stateMutability: 'view',
+  },
+  {
+    type: 'error',
+    name: 'FnSelectorNotRecognized',
+    inputs: [],
+  },
+  {
+    type: 'error',
+    name: 'UnsupportedExecutionMode',
+    inputs: [],
+  },
+] as const
+
+export const executionMode = {
+  default: '0x0100000000000000000000000000000000000000000000000000000000000000',
+  opData: '0x0100000000007821000100000000000000000000000000000000000000000000',
+} as const

package/experimental/erc7821/decorators/erc7821.ts

@@ -0,0 +1,149 @@
+import type { Client } from '../../../clients/createClient.js'
+import type { Transport } from '../../../clients/transports/createTransport.js'
+import type { Account } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import {
+  type ExecuteParameters,
+  type ExecuteReturnType,
+  execute,
+} from '../actions/execute.js'
+import {
+  type SupportsExecutionModeParameters,
+  type SupportsExecutionModeReturnType,
+  supportsExecutionMode,
+} from '../actions/supportsExecutionMode.js'
+
+export type Erc7821Actions<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = {
+  /**
+   * Executes call(s) using the `execute` function on an [ERC-7821-compatible contract](https://eips.ethereum.org/EIPS/eip-7821).
+   *
+   * @example
+   * ```ts
+   * import { createClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { erc7821Actions } from 'viem/experimental'
+   *
+   * const account = privateKeyToAccount('0x...')
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const hash = await client.execute({
+   *   account,
+   *   calls: [{
+   *     {
+   *       data: '0xdeadbeef',
+   *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *     },
+   *     {
+   *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *       value: 69420n,
+   *     },
+   *   }],
+   *   to: account.address,
+   * })
+   * ```
+   *
+   * @example
+   * ```ts
+   * // Account Hoisting
+   * import { createClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   * import { erc7821Actions } from 'viem/experimental'
+   *
+   * const account = privateKeyToAccount('0x...')
+   *
+   * const client = createClient({
+   *   account,
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const hash = await client.execute({
+   *   calls: [{
+   *     {
+   *       data: '0xdeadbeef',
+   *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *     },
+   *     {
+   *       to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *       value: 69420n,
+   *     },
+   *   }],
+   *   to: account.address,
+   * })
+   * ```
+   *
+   * @param client - Client to use.
+   * @param parameters - {@link ExecuteParameters}
+   * @returns Transaction hash. {@link ExecuteReturnType}
+   */
+  execute: <
+    const calls extends readonly unknown[],
+    chainOverride extends Chain | undefined = undefined,
+  >(
+    parameters: ExecuteParameters<chain, account, chainOverride, calls>,
+  ) => Promise<ExecuteReturnType>
+  /**
+   * Checks if the contract supports the ERC-7821 execution mode.
+   *
+   * @example
+   * ```ts
+   * import { createClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { erc7821Actions } from 'viem/experimental'
+   *
+   * const client = createClient({
+   *   chain: mainnet,
+   *   transport: http(),
+   * }).extend(erc7821Actions())
+   *
+   * const supported = await supportsExecutionMode(client, {
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   * })
+   * ```
+   *
+   * @param client - Client to use.
+   * @param parameters - {@link SupportsExecutionModeParameters}
+   * @returns If the execution mode is supported. {@link SupportsExecutionModeReturnType}
+   */
+  supportsExecutionMode: (
+    parameters: SupportsExecutionModeParameters,
+  ) => Promise<SupportsExecutionModeReturnType>
+}
+
+/**
+ * A suite of Actions for [ERC-7821](https://eips.ethereum.org/EIPS/eip-7821).
+ *
+ * @example
+ * import { createClient, http } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { erc7821Actions } from 'viem/experimental'
+ *
+ * const client = createClient({
+ *   chain: mainnet,
+ *   transport: http(),
+ * }).extend(erc7821Actions())
+ */
+export function erc7821Actions() {
+  return <
+    transport extends Transport,
+    chain extends Chain | undefined = Chain | undefined,
+    account extends Account | undefined = Account | undefined,
+  >(
+    client: Client<transport, chain, account>,
+  ): Erc7821Actions<chain, account> => {
+    return {
+      execute: (parameters) => execute(client, parameters),
+      supportsExecutionMode: (parameters) =>
+        supportsExecutionMode(client, parameters),
+    }
+  }
+}

package/experimental/erc7821/errors.ts

@@ -0,0 +1,29 @@
+import { BaseError } from '../../errors/base.js'
+
+export type ExecuteUnsupportedErrorType = ExecuteUnsupportedError & {
+  name: 'ExecuteUnsupportedError'
+}
+export class ExecuteUnsupportedError extends BaseError {
+  constructor() {
+    super('ERC-7821 execution is not supported.', {
+      name: 'ExecuteUnsupportedError',
+    })
+  }
+}
+
+export type FunctionSelectorNotRecognizedErrorType =
+  FunctionSelectorNotRecognizedError & {
+    name: 'FunctionSelectorNotRecognizedError'
+  }
+export class FunctionSelectorNotRecognizedError extends BaseError {
+  constructor() {
+    super('Function is not recognized.', {
+      metaMessages: [
+        'This could be due to any of the following:',
+        '  - The contract does not have the function,',
+        '  - The address is not a contract.',
+      ],
+      name: 'FunctionSelectorNotRecognizedError',
+    })
+  }
+}

package/experimental/erc7821/index.ts

@@ -0,0 +1,23 @@
+/**  */
+// biome-ignore lint/performance/noBarrelFile: entrypoint
+export {
+  type ExecuteErrorType,
+  type ExecuteParameters,
+  type ExecuteReturnType,
+  execute,
+} from './actions/execute.js'
+export {
+  type SupportsExecutionModeErrorType,
+  type SupportsExecutionModeParameters,
+  type SupportsExecutionModeReturnType,
+  supportsExecutionMode,
+} from './actions/supportsExecutionMode.js'
+
+export {
+  ExecuteUnsupportedError,
+  type ExecuteUnsupportedErrorType,
+  FunctionSelectorNotRecognizedError,
+  type FunctionSelectorNotRecognizedErrorType,
+} from './errors.js'
+
+export { type Erc7821Actions, erc7821Actions } from './decorators/erc7821.js'

package/experimental/index.ts

@@ -111,6 +111,11 @@ export {
   erc7739Actions,
 } from './erc7739/decorators/erc7739.js'
 
+export {
+  type Erc7821Actions,
+  erc7821Actions,
+} from './erc7821/decorators/erc7821.js'
+
 export {
   /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureErrorType } from 'viem'` instead. */
   type ParseErc6492SignatureErrorType,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.21.58",
+  "version": "2.21.60",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -69,6 +69,11 @@
       "import": "./_esm/experimental/erc7739/index.js",
       "default": "./_cjs/experimental/erc7739/index.js"
     },
+    "./experimental/erc7821": {
+      "types": "./_types/experimental/erc7821/index.d.ts",
+      "import": "./_esm/experimental/erc7821/index.js",
+      "default": "./_cjs/experimental/erc7821/index.js"
+    },
     "./linea": {
       "types": "./_types/linea/index.d.ts",
       "import": "./_esm/linea/index.js",

package/types/calls.ts

@@ -0,0 +1,38 @@
+import type { AbiStateMutability, Address } from 'abitype'
+import type { Hex } from './misc.js'
+import type { GetMulticallContractParameters } from './multicall.js'
+import type { OneOf, Prettify } from './utils.js'
+
+export type Call<call = unknown> = OneOf<
+  | {
+      data?: Hex | undefined
+      to: Address
+      value?: bigint | undefined
+    }
+  | (Omit<
+      GetMulticallContractParameters<call, AbiStateMutability>,
+      'address'
+    > & {
+      to: Address
+      value?: bigint | undefined
+    })
+>
+
+export type Calls<
+  calls extends readonly unknown[],
+  ///
+  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<call>>]
+    : calls extends readonly [infer call, ...infer rest] // grab first call and recurse through `rest`
+      ? Calls<[...rest], [...result, Prettify<Call<call>>]>
+      : 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 OneOf<Call>)[]
+          ? readonly Prettify<call>[]
+          : // Fallback
+            readonly OneOf<Call>[]

package/types/eip1193.ts

@@ -22,6 +22,7 @@ import type {
   RpcTransactionRequest as TransactionRequest,
   RpcUncle as Uncle,
 } from './rpc.js'
+import type { AccessList } from './transaction.js'
 import type { ExactPartial, OneOf, PartialBy, Prettify } from './utils.js'
 
 //////////////////////////////////////////////////
@@ -644,6 +645,26 @@ export type PublicRpcSchema = [
         ]
     ReturnType: Hex
   },
+  /**
+   * @description Executes a new message call immediately without submitting a transaction to the network
+   *
+   * @example
+   * provider.request({ method: 'eth_call', params: [{ to: '0x...', data: '0x...' }] })
+   * // => '0x...'
+   */
+  {
+    Method: 'eth_createAccessList'
+    Parameters:
+      | [transaction: ExactPartial<TransactionRequest>]
+      | [
+          transaction: ExactPartial<TransactionRequest>,
+          block: BlockNumber | BlockTag | BlockIdentifier,
+        ]
+    ReturnType: {
+      accessList: AccessList
+      gasUsed: Quantity
+    }
+  },
   /**
    * @description Returns the chain ID associated with the current network
    * @example

package/zksync/actions/deployContract.ts

@@ -7,7 +7,10 @@ import type { Transport } from '../../clients/transports/createTransport.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ContractConstructorArgs } from '../../types/contract.js'
 import type { Hash, Hex } from '../../types/misc.js'
-import { contractDeployerAddress } from '../constants/address.js'
+import {
+  contract2FactoryAddress,
+  contractDeployerAddress,
+} from '../constants/address.js'
 import type { ChainEIP712 } from '../types/chain.js'
 import type { ContractDeploymentType } from '../types/contract.js'
 import {
@@ -45,7 +48,7 @@ export type DeployContractErrorType =
  *
  * - Docs: https://viem.sh/docs/contract/deployContract
  *
- * @param client - Client to use
+ * @param walletClient - Client to use
  * @param parameters - {@link DeployContractParameters}
  * @returns The [Transaction](https://viem.sh/docs/glossary/terms#transaction) hash. {@link DeployContractReturnType}
  *
@@ -97,7 +100,10 @@ export function deployContract<
   return sendEip712Transaction(walletClient, {
     ...request,
     data,
-    to: contractDeployerAddress,
+    to:
+      deploymentType === 'create2' || deploymentType === 'create2Account'
+        ? contract2FactoryAddress
+        : contractDeployerAddress,
   } as unknown as SendEip712TransactionParameters<
     chain,
     account,

package/zksync/actions/getL1TokenAddress.ts

@@ -0,0 +1,59 @@
+import type { Address } from '../../accounts/index.js'
+import { readContract } from '../../actions/public/readContract.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import { isAddressEqual } from '../../utils/index.js'
+import { l2SharedBridgeAbi } from '../constants/abis.js'
+import { legacyEthAddress } from '../constants/address.js'
+import { getDefaultBridgeAddresses } from './getDefaultBridgeAddresses.js'
+
+export type GetL1TokenAddressParameters = {
+  /** The address of the token on L2. */
+  token: Address
+}
+
+export type GetL1TokenAddressReturnType = Address
+
+/**
+ * Returns the L1 token address equivalent for a L2 token address as they are not equal.
+ * ETH address is set to zero address.
+ *
+ * @remarks Only works for tokens bridged on default ZKsync Era bridges.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetL1TokenAddressParameters}
+ * @returns The L1 token address equivalent for a L2 token address.
+ *
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { zksync } from 'viem/chains'
+ *
+ * const client = createPublicClient({
+ *   chain: zksync,
+ *   transport: http(),
+ * })
+ *
+ * const address = await getL1TokenAddress(client, {token: '0x...'});
+ */
+export async function getL1TokenAddress<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: GetL1TokenAddressParameters,
+): Promise<Address> {
+  const { token } = parameters
+  if (isAddressEqual(token, legacyEthAddress)) return legacyEthAddress
+
+  const bridgeAddress = (await getDefaultBridgeAddresses(client)).sharedL2
+
+  return await readContract(client, {
+    address: bridgeAddress,
+    abi: l2SharedBridgeAbi,
+    functionName: 'l1TokenAddress',
+    args: [token],
+  })
+}

package/zksync/actions/getL2TokenAddress.ts

@@ -0,0 +1,70 @@
+import type { Address } from '../../accounts/index.js'
+import { readContract } from '../../actions/public/readContract.js'
+import type { Client } from '../../clients/createClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { Account } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import { isAddressEqual } from '../../utils/index.js'
+import { l2SharedBridgeAbi } from '../constants/abis.js'
+import {
+  ethAddressInContracts,
+  l2BaseTokenAddress,
+  legacyEthAddress,
+} from '../constants/address.js'
+import { getBaseTokenL1Address } from './getBaseTokenL1Address.js'
+import { getDefaultBridgeAddresses } from './getDefaultBridgeAddresses.js'
+
+export type GetL2TokenAddressParameters = {
+  /** The address of the token on L1. */
+  token: Address
+  /** The address of custom bridge, which will be used to get l2 token address. */
+  bridgeAddress?: Address | undefined
+}
+
+export type GetL2TokenAddressReturnType = Address
+
+/**
+ * Returns the L2 token address equivalent for a L1 token address as they are not equal.
+ * ETH address is set to zero address.
+ *
+ * @remarks Only works for tokens bridged on default ZKsync Era bridges.
+ *
+ * @param client - Client to use
+ * @param parameters - {@link GetL2TokenAddressParameters}
+ * @returns The L2 token address equivalent for a L1 token address.
+ *
+ *
+ * @example
+ * import { createPublicClient, http } from 'viem'
+ * import { zksync } from 'viem/chains'
+ * import { publicActionsL2 } from 'viem/zksync'
+ *
+ * const client = createPublicClient({
+ *   chain: zksync,
+ *   transport: http(),
+ * }).extend(publicActionsL2())
+ *
+ * const address = await getL2TokenAddress(client, {token: '0x...'});
+ */
+export async function getL2TokenAddress<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: GetL2TokenAddressParameters,
+): Promise<Address> {
+  let { token, bridgeAddress } = parameters
+  if (isAddressEqual(token, legacyEthAddress)) token = ethAddressInContracts
+
+  const baseToken = await getBaseTokenL1Address(client)
+  if (isAddressEqual(token, baseToken)) return l2BaseTokenAddress
+
+  bridgeAddress ??= (await getDefaultBridgeAddresses(client)).sharedL2
+
+  return await readContract(client, {
+    address: bridgeAddress,
+    abi: l2SharedBridgeAbi,
+    functionName: 'l2TokenAddress',
+    args: [token],
+  })
+}

package/zksync/actions/sendEip712Transaction.ts

@@ -92,13 +92,15 @@ export async function sendEip712Transaction<
     request
   >,
 ): Promise<SendEip712TransactionReturnType> {
-  const { chain = client.chain } = parameters
+  const { account: account_ = client.account, chain = client.chain } =
+    parameters
 
-  if (!parameters.account)
+  const account = account_ ? parseAccount(account_) : client.account
+
+  if (!account)
     throw new AccountNotFoundError({
       docsPath: '/docs/actions/wallet/sendTransaction',
     })
-  const account = parseAccount(parameters.account)
 
   try {
     assertEip712Request(parameters)

package/zksync/actions/signEip712Transaction.ts

@@ -53,6 +53,8 @@ export type SignEip712TransactionErrorType = SignTransactionErrorType
 /**
  * Signs an EIP712 transaction.
  *
+ *
+ * @param client - Client to use
  * @param args - {@link SignTransactionParameters}
  * @returns The signed serialized transaction. {@link SignTransactionReturnType}
  *
@@ -102,11 +104,12 @@ export async function signEip712Transaction<
     ...transaction
   } = args
 
-  if (!account_)
+  const account = account_ ? parseAccount(account_) : client.account
+
+  if (!account)
     throw new AccountNotFoundError({
       docsPath: '/docs/actions/wallet/signTransaction',
     })
-  const account = parseAccount(account_)
 
   assertEip712Request({
     account,