viem 2.21.58 → 2.21.59

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.59",
   "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/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,

package/zksync/constants/abis.ts

@@ -461,3 +461,188 @@ export const paymasterAbi = [
     type: 'function',
   },
 ]
+
+export const l2SharedBridgeAbi = [
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'l1Sender',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'l2Receiver',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'l2Token',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'FinalizeDeposit',
+    type: 'event',
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'l2Sender',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'l1Receiver',
+        type: 'address',
+      },
+      {
+        indexed: true,
+        internalType: 'address',
+        name: 'l2Token',
+        type: 'address',
+      },
+      {
+        indexed: false,
+        internalType: 'uint256',
+        name: 'amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'WithdrawalInitiated',
+    type: 'event',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_l1Sender',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: '_l2Receiver',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: '_l1Token',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: '_amount',
+        type: 'uint256',
+      },
+      {
+        internalType: 'bytes',
+        name: '_data',
+        type: 'bytes',
+      },
+    ],
+    name: 'finalizeDeposit',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'l1Bridge',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [],
+    name: 'l1SharedBridge',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_l2Token',
+        type: 'address',
+      },
+    ],
+    name: 'l1TokenAddress',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_l1Token',
+        type: 'address',
+      },
+    ],
+    name: 'l2TokenAddress',
+    outputs: [
+      {
+        internalType: 'address',
+        name: '',
+        type: 'address',
+      },
+    ],
+    stateMutability: 'view',
+    type: 'function',
+  },
+  {
+    inputs: [
+      {
+        internalType: 'address',
+        name: '_l1Receiver',
+        type: 'address',
+      },
+      {
+        internalType: 'address',
+        name: '_l2Token',
+        type: 'address',
+      },
+      {
+        internalType: 'uint256',
+        name: '_amount',
+        type: 'uint256',
+      },
+    ],
+    name: 'withdraw',
+    outputs: [],
+    stateMutability: 'nonpayable',
+    type: 'function',
+  },
+] as const

package/zksync/constants/address.ts

@@ -1,6 +1,9 @@
 export const contractDeployerAddress =
   '0x0000000000000000000000000000000000008006' as const
 
+export const contract2FactoryAddress =
+  '0x0000000000000000000000000000000000010000' as const
+
 export const legacyEthAddress =
   '0x0000000000000000000000000000000000000000' as const
 

package/zksync/decorators/publicL2.ts

@@ -52,6 +52,16 @@ import {
   type GetL1ChainIdReturnType,
   getL1ChainId,
 } from '../actions/getL1ChainId.js'
+import {
+  type GetL1TokenAddressParameters,
+  type GetL1TokenAddressReturnType,
+  getL1TokenAddress,
+} from '../actions/getL1TokenAddress.js'
+import {
+  type GetL2TokenAddressParameters,
+  type GetL2TokenAddressReturnType,
+  getL2TokenAddress,
+} from '../actions/getL2TokenAddress.js'
 import {
   type GetLogProofParameters,
   type GetLogProofReturnType,
@@ -411,6 +421,56 @@ export type PublicActionsL2<
    * const address = await client.getBaseTokenL1Address();
    */
   getBaseTokenL1Address: () => Promise<GetBaseTokenL1AddressReturnType>
+
+  /**
+   * 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 args - {@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 client.getL2TokenAddress({token: '0x...'});
+   */
+  getL2TokenAddress: (
+    args: GetL2TokenAddressParameters,
+  ) => Promise<GetL2TokenAddressReturnType>
+
+  /**
+   * 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 args - {@link GetL1TokenAddressParameters}
+   * @returns The L1 token address equivalent for a L2 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 client.getL1TokenAddress({token: '0x...'});
+   */
+  getL1TokenAddress: (
+    args: GetL1TokenAddressParameters,
+  ) => Promise<GetL1TokenAddressReturnType>
 }
 
 export function publicActionsL2() {
@@ -438,6 +498,8 @@ export function publicActionsL2() {
       estimateFee: (args) => estimateFee(client, args),
       getBridgehubContractAddress: () => getBridgehubContractAddress(client),
       getBaseTokenL1Address: () => getBaseTokenL1Address(client),
+      getL2TokenAddress: (args) => getL2TokenAddress(client, args),
+      getL1TokenAddress: (args) => getL1TokenAddress(client, args),
     }
   }
 }

package/zksync/index.ts

@@ -119,6 +119,16 @@ export {
   type SignTransactionReturnType,
   signTransaction,
 } from './actions/signTransaction.js'
+export {
+  type GetL2TokenAddressReturnType,
+  type GetL2TokenAddressParameters,
+  getL2TokenAddress,
+} from './actions/getL2TokenAddress.js'
+export {
+  type GetL1TokenAddressReturnType,
+  type GetL1TokenAddressParameters,
+  getL1TokenAddress,
+} from './actions/getL1TokenAddress.js'
 
 export {
   /** @deprecated Use `zksync` instead */