viem 2.15.0 → 2.16.0

package/actions/public/verifyTypedData.ts

@@ -53,6 +53,8 @@ export async function verifyTypedData<
 ): Promise<VerifyTypedDataReturnType> {
   const {
     address,
+    factory,
+    factoryData,
     signature,
     message,
     primaryType,
@@ -63,6 +65,8 @@ export async function verifyTypedData<
   const hash = hashTypedData({ message, primaryType, types, domain })
   return verifyHash(client, {
     address,
+    factory: factory!,
+    factoryData: factoryData!,
     hash,
     signature,
     ...callRequest,

package/chains/definitions/zetachain.ts

@@ -13,6 +13,12 @@ export const zetachain = /*#__PURE__*/ defineChain({
       http: ['https://zetachain-evm.blockpi.network/v1/rpc/public'],
     },
   },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 1632781,
+    },
+  },
   blockExplorers: {
     default: {
       name: 'ZetaScan',

package/chains/definitions/zetachainAthensTestnet.ts

@@ -13,6 +13,12 @@ export const zetachainAthensTestnet = /*#__PURE__*/ defineChain({
       http: ['https://zetachain-athens-evm.blockpi.network/v1/rpc/public'],
     },
   },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 2715217,
+    },
+  },
   blockExplorers: {
     default: {
       name: 'ZetaScan',

package/chains/definitions/zircuitTestnet.ts

@@ -0,0 +1,24 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const zircuitTestnet = /*#__PURE__*/ defineChain({
+  id: 48899,
+  name: 'Zircuit Testnet',
+  nativeCurrency: { name: 'ETH', symbol: 'ETH', decimals: 18 },
+  rpcUrls: {
+    default: {
+      http: ['https://zircuit1.p2pify.com'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'Zircuit Explorer',
+      url: 'https://explorer.zircuit.com',
+    },
+  },
+  contracts: {
+    multicall3: {
+      address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+      blockCreated: 6040287,
+    },
+  },
+})

package/chains/index.ts

@@ -293,6 +293,7 @@ export { zkSyncTestnet } from './definitions/zkSyncTestnet.js'
 export { zora } from './definitions/zora.js'
 export { zoraSepolia } from './definitions/zoraSepolia.js'
 export { zoraTestnet } from './definitions/zoraTestnet.js'
+export { zircuitTestnet } from './definitions/zircuitTestnet.js'
 
 //////////////////////////////////////////////////////////////////////////////////////
 // Required type exports to prevent TypeScript error "TS2742".

package/errors/version.ts

@@ -1 +1 @@
-export const version = '2.15.0'
+export const version = '2.16.0'

package/experimental/index.ts

@@ -36,23 +36,35 @@ export {
 } from './eip5792/decorators/eip5792.js'
 
 export {
+  /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureErrorType } from 'viem'` instead. */
   type ParseErc6492SignatureErrorType,
+  /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureParameters } from 'viem'` instead. */
   type ParseErc6492SignatureParameters,
+  /** @deprecated This is no longer experimental – use `import type { ParseErc6492SignatureReturnType } from 'viem'` instead. */
   type ParseErc6492SignatureReturnType,
+  /** @deprecated This is no longer experimental – use `import { parseErc6492Signature } from 'viem'` instead. */
   parseErc6492Signature,
-} from './erc6492/parseErc6492Signature.js'
+} from '../utils/signature/parseErc6492Signature.js'
 export {
+  /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureErrorType } from 'viem'` instead. */
   type IsErc6492SignatureErrorType,
+  /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureParameters } from 'viem'` instead. */
   type IsErc6492SignatureParameters,
+  /** @deprecated This is no longer experimental – use `import type { IsErc6492SignatureReturnType } from 'viem'` instead. */
   type IsErc6492SignatureReturnType,
+  /** @deprecated This is no longer experimental – use `import { isErc6492Signature } from 'viem'` instead. */
   isErc6492Signature,
-} from './erc6492/isErc6492Signature.js'
+} from '../utils/signature/isErc6492Signature.js'
 export {
+  /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureErrorType } from 'viem'` instead. */
   type SerializeErc6492SignatureErrorType,
+  /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureParameters } from 'viem'` instead. */
   type SerializeErc6492SignatureParameters,
+  /** @deprecated This is no longer experimental – use `import type { SerializeErc6492SignatureReturnType } from 'viem'` instead. */
   type SerializeErc6492SignatureReturnType,
+  /** @deprecated This is no longer experimental – use `import { serializeErc6492Signature } from 'viem'` instead. */
   serializeErc6492Signature,
-} from './erc6492/serializeErc6492Signature.js'
+} from '../utils/signature/serializeErc6492Signature.js'
 
 export {
   type IssuePermissionsParameters,
@@ -63,3 +75,21 @@ export {
   type WalletActionsErc7715,
   walletActionsErc7715,
 } from './erc7715/decorators/erc7715.js'
+
+export {
+  type SignMessageErrorType,
+  type SignMessageParameters,
+  type SignMessageReturnType,
+  signMessage,
+} from './solady/actions/signMessage.js'
+export {
+  type SignTypedDataErrorType,
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
+  signTypedData,
+} from './solady/actions/signTypedData.js'
+export {
+  type SoladyActions,
+  type SoladyActionsParameters,
+  soladyActions,
+} from './solady/decorators/solady.js'

package/experimental/solady/actions/signMessage.ts

@@ -0,0 +1,151 @@
+import type { Address, TypedDataDomain } from 'abitype'
+import type { Account } from '../../../accounts/types.js'
+import { parseAccount } from '../../../accounts/utils/parseAccount.js'
+import {
+  type GetEip712DomainParameters,
+  getEip712Domain,
+} from '../../../actions/public/getEip712Domain.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 type { ErrorType } from '../../../errors/utils.js'
+import type { GetAccountParameter } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import type { Hex, SignableMessage } from '../../../types/misc.js'
+import type { OneOf, RequiredBy } from '../../../types/utils.js'
+import { getAction } from '../../../utils/getAction.js'
+import { toPrefixedMessage } from '../../../utils/signature/toPrefixedMessage.js'
+import type { GetVerifierParameter } from '../types.js'
+
+export type SignMessageParameters<
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | undefined = Account | undefined,
+  verifier extends Address | undefined = Address | undefined,
+> = Pick<GetEip712DomainParameters, 'factory' | 'factoryData'> &
+  GetAccountParameter<account, accountOverride> & {
+    message: SignableMessage
+  } & OneOf<
+    | {
+        verifierDomain: RequiredBy<
+          TypedDataDomain,
+          'chainId' | 'name' | 'verifyingContract' | 'version'
+        >
+        verifier?: undefined
+      }
+    | (GetVerifierParameter<verifier> & {
+        verifierDomain?:
+          | RequiredBy<
+              TypedDataDomain,
+              'chainId' | 'name' | 'verifyingContract' | 'version'
+            >
+          | undefined
+      })
+  >
+
+export type SignMessageReturnType = Hex
+
+export type SignMessageErrorType = ErrorType
+
+/**
+ * Signs a [EIP-191](https://eips.ethereum.org/EIPS/eip-191) personal sign message via Solady's [ERC1271 `PersonalSign` format](https://github.com/Vectorized/solady/blob/678c9163550810b08f0ffb09624c9f7532392303/src/accounts/ERC1271.sol#L154-L166).
+ *
+ * This Action is suitable to sign messages for Smart Accounts that implement (or conform to) Solady's [ERC1271.sol](https://github.com/Vectorized/solady/blob/main/src/accounts/ERC1271.sol).
+ *
+ * - Docs: https://viem.sh/experimental/solady/signMessage
+ *
+ * With the calculated signature, you can:
+ * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage) to verify the signature,
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignMessageParameters}
+ * @returns The signed message. {@link SignMessageReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const signature = await signMessage(client, {
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+ *   message: 'hello world',
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, custom } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signMessage } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ *
+ * const signature = await signMessage(client, {
+ *   message: 'hello world',
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ */
+export async function signMessage<
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  accountOverride extends Account | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SignMessageParameters<account, accountOverride>,
+): Promise<SignMessageReturnType> {
+  const {
+    account: account_ = client.account,
+    factory,
+    factoryData,
+    message,
+    verifier,
+  } = parameters
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/experimental/solady/signMessage',
+    })
+  const account = parseAccount(account_)
+
+  const domain = await (async () => {
+    if (parameters.verifierDomain) return parameters.verifierDomain
+    const {
+      domain: { salt, ...domain },
+    } = await getAction(
+      client,
+      getEip712Domain,
+      'getEip712Domain',
+    )({
+      address: verifier!,
+      factory,
+      factoryData,
+    })
+    return domain
+  })()
+
+  return getAction(
+    client,
+    signTypedData,
+    'signTypedData',
+  )({
+    account,
+    domain,
+    types: {
+      PersonalSign: [{ name: 'prefixed', type: 'bytes' }],
+    },
+    primaryType: 'PersonalSign',
+    message: {
+      prefixed: toPrefixedMessage(message),
+    },
+  })
+}

package/experimental/solady/actions/signTypedData.ts

@@ -0,0 +1,280 @@
+import type { Address, TypedData, TypedDataDomain } from 'abitype'
+
+import type { Account } from '../../../accounts/types.js'
+import { parseAccount } from '../../../accounts/utils/parseAccount.js'
+import {
+  type GetEip712DomainParameters,
+  getEip712Domain,
+} from '../../../actions/public/getEip712Domain.js'
+import { signTypedData as 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 type { ErrorType } from '../../../errors/utils.js'
+import type { GetAccountParameter } from '../../../types/account.js'
+import type { Chain } from '../../../types/chain.js'
+import type { Hex } from '../../../types/misc.js'
+import type { TypedDataDefinition } from '../../../types/typedData.js'
+import type { OneOf, RequiredBy } from '../../../types/utils.js'
+import { encodePacked } from '../../../utils/abi/encodePacked.js'
+import { size } from '../../../utils/data/size.js'
+import { stringToHex } from '../../../utils/encoding/toHex.js'
+import { getAction } from '../../../utils/getAction.js'
+import {
+  encodeType,
+  hashStruct,
+} from '../../../utils/signature/hashTypedData.js'
+import { getTypesForEIP712Domain } from '../../../utils/typedData.js'
+import type { GetVerifierParameter } from '../types.js'
+
+export type SignTypedDataParameters<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  account extends Account | undefined = undefined,
+  accountOverride extends Account | undefined = undefined,
+  verifier extends Address | undefined = Address | undefined,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = TypedDataDefinition<typedData, primaryType, primaryTypes> &
+  Pick<GetEip712DomainParameters, 'factory' | 'factoryData'> &
+  GetAccountParameter<account, accountOverride> &
+  OneOf<
+    | {
+        verifierDomain: RequiredBy<
+          TypedDataDomain,
+          'chainId' | 'name' | 'verifyingContract' | 'salt' | 'version'
+        >
+        fields: Hex
+        extensions: readonly bigint[]
+        verifier?: undefined
+      }
+    | (GetVerifierParameter<verifier> & {
+        verifierDomain?:
+          | RequiredBy<
+              TypedDataDomain,
+              'chainId' | 'name' | 'verifyingContract' | 'salt' | 'version'
+            >
+          | undefined
+        fields?: Hex | undefined
+        extensions?: readonly bigint[] | undefined
+      })
+  >
+
+export type SignTypedDataReturnType = Hex
+
+export type SignTypedDataErrorType = ErrorType
+
+/**
+ * Signs an [EIP-712](https://eips.ethereum.org/EIPS/eip-712) typed data message via Solady's [ERC1271 `TypedDataSign` format](https://github.com/Vectorized/solady/blob/678c9163550810b08f0ffb09624c9f7532392303/src/accounts/ERC1271.sol#L130-L151).
+ *
+ * This Action is suitable to sign messages for Smart Accounts that implement (or conform to) Solady's [ERC1271.sol](https://github.com/Vectorized/solady/blob/main/src/accounts/ERC1271.sol).
+ *
+ * - Docs: https://viem.sh/experimental/solady/signTypedData
+ *
+ * @param client - Client to use
+ * @param parameters - {@link SignTypedDataParameters}
+ * @returns The signed data. {@link SignTypedDataReturnType}
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   chain: mainnet,
+ *   transport: custom(window.ethereum),
+ * })
+ * const signature = await signTypedData(client, {
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb',
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ *
+ * @example
+ * // Account Hoisting
+ * import { createWalletClient, http } from 'viem'
+ * import { privateKeyToAccount } from 'viem/accounts'
+ * import { mainnet } from 'viem/chains'
+ * import { signTypedData } from 'viem/experimental/solady'
+ *
+ * const client = createWalletClient({
+ *   account: '0xE8Df82fA4E10e6A12a9Dab552bceA2acd26De9bb'
+ *   chain: mainnet,
+ *   transport: http(),
+ * })
+ * const signature = await signTypedData(client, {
+ *   domain: {
+ *     name: 'Ether Mail',
+ *     version: '1',
+ *     chainId: 1,
+ *     verifyingContract: '0xCcCCccccCCCCcCCCCCCcCcCccCcCCCcCcccccccC',
+ *   },
+ *   types: {
+ *     Person: [
+ *       { name: 'name', type: 'string' },
+ *       { name: 'wallet', type: 'address' },
+ *     ],
+ *     Mail: [
+ *       { name: 'from', type: 'Person' },
+ *       { name: 'to', type: 'Person' },
+ *       { name: 'contents', type: 'string' },
+ *     ],
+ *   },
+ *   primaryType: 'Mail',
+ *   message: {
+ *     from: {
+ *       name: 'Cow',
+ *       wallet: '0xCD2a3d9F938E13CD947Ec05AbC7FE734Df8DD826',
+ *     },
+ *     to: {
+ *       name: 'Bob',
+ *       wallet: '0xbBbBBBBbbBBBbbbBbbBbbbbBBbBbbbbBbBbbBBbB',
+ *     },
+ *     contents: 'Hello, Bob!',
+ *   },
+ *   verifier: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+ * })
+ */
+export async function signTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  accountOverride extends Account | undefined = undefined,
+>(
+  client: Client<Transport, chain, account>,
+  parameters: SignTypedDataParameters<
+    typedData,
+    primaryType,
+    account,
+    accountOverride
+  >,
+): Promise<SignTypedDataReturnType> {
+  const {
+    account: account_ = client.account,
+    domain,
+    factory,
+    factoryData,
+    message,
+    primaryType,
+    types,
+    verifier,
+  } = parameters as unknown as SignTypedDataParameters
+
+  if (!account_)
+    throw new AccountNotFoundError({
+      docsPath: '/experimental/solady/signTypedData',
+    })
+  const account = parseAccount(account_!)
+
+  // Retrieve account EIP712 domain.
+  const {
+    domain: verifierDomain,
+    fields,
+    extensions,
+  } = await (async () => {
+    if (parameters.verifierDomain && parameters.fields && parameters.extensions)
+      return {
+        domain: parameters.verifierDomain,
+        fields: parameters.fields,
+        extensions: parameters.extensions,
+      }
+    return getAction(
+      client,
+      getEip712Domain,
+      'getEip712Domain',
+    )({
+      address: verifier!,
+      factory,
+      factoryData,
+    })
+  })()
+
+  // Sign with typed data wrapper.
+  const signature = await getAction(
+    client,
+    signTypedData_,
+    'signTypedData',
+  )({
+    account,
+    domain,
+    types: {
+      ...types,
+      TypedDataSign: [
+        { name: 'contents', type: primaryType },
+        { name: 'fields', type: 'bytes1' },
+        { name: 'name', type: 'string' },
+        { name: 'version', type: 'string' },
+        { name: 'chainId', type: 'uint256' },
+        { name: 'verifyingContract', type: 'address' },
+        { name: 'salt', type: 'bytes32' },
+        { name: 'extensions', type: 'uint256[]' },
+      ],
+    },
+    primaryType: 'TypedDataSign',
+    message: {
+      contents: message as any,
+      fields,
+      extensions,
+      ...(verifierDomain as any),
+    },
+  })
+
+  // Compute dependencies for wrapped signature.
+  const hashedDomain = hashStruct({
+    data: domain ?? {},
+    types: {
+      EIP712Domain: getTypesForEIP712Domain({ domain }),
+    },
+    primaryType: 'EIP712Domain',
+  })
+  const hashedContents = hashStruct({
+    data: message,
+    types: types as any,
+    primaryType,
+  })
+  const encodedType = encodeType({
+    primaryType,
+    types: types as any,
+  })
+
+  // Construct wrapped signature.
+  return encodePacked(
+    ['bytes', 'bytes32', 'bytes32', 'bytes', 'uint16'],
+    [
+      signature,
+      hashedDomain,
+      hashedContents,
+      stringToHex(encodedType),
+      size(stringToHex(encodedType)),
+    ],
+  )
+}