viem 2.16.0 → 2.16.2

package/experimental/solady/actions/signTypedData.ts

@@ -16,16 +16,9 @@ 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'
+import { wrapTypedDataSignature } from '../utils/wrapTypedDataSignature.js'
 
 export type SignTypedDataParameters<
   typedData extends TypedData | Record<string, unknown> = TypedData,
@@ -248,33 +241,11 @@ export async function signTypedData<
     },
   })
 
-  // 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({
+  return wrapTypedDataSignature({
+    domain,
+    message,
     primaryType,
-    types: types as any,
+    signature,
+    types,
   })
-
-  // Construct wrapped signature.
-  return encodePacked(
-    ['bytes', 'bytes32', 'bytes32', 'bytes', 'uint16'],
-    [
-      signature,
-      hashedDomain,
-      hashedContents,
-      stringToHex(encodedType),
-      size(stringToHex(encodedType)),
-    ],
-  )
 }

package/experimental/solady/index.ts

@@ -0,0 +1,36 @@
+// biome-ignore lint/performance/noBarrelFile: entrypoint
+export {
+  type SignMessageErrorType,
+  type SignMessageParameters,
+  type SignMessageReturnType,
+  signMessage,
+} from './actions/signMessage.js'
+export {
+  type SignTypedDataErrorType,
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
+  signTypedData,
+} from './actions/signTypedData.js'
+export {
+  type SoladyActions,
+  type SoladyActionsParameters,
+  soladyActions,
+} from './decorators/solady.js'
+export {
+  type HashMessageErrorType,
+  type HashMessageParameters,
+  type HashMessageReturnType,
+  hashMessage,
+} from './utils/hashMessage.js'
+export {
+  type HashTypedDataErrorType,
+  type HashTypedDataParameters,
+  type HashTypedDataReturnType,
+  hashTypedData,
+} from './utils/hashTypedData.js'
+export {
+  type WrapTypedDataSignatureErrorType,
+  type WrapTypedDataSignatureParameters,
+  type WrapTypedDataSignatureReturnType,
+  wrapTypedDataSignature,
+} from './utils/wrapTypedDataSignature.js'

package/experimental/solady/utils/hashMessage.ts

@@ -0,0 +1,60 @@
+import type { TypedDataDomain } from 'abitype'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex, SignableMessage } from '../../../types/misc.js'
+import type { RequiredBy } from '../../../types/utils.js'
+import { hashTypedData } from '../../../utils/index.js'
+import type { HashTypedDataErrorType } from '../../../utils/signature/hashTypedData.js'
+import {
+  type ToPrefixedMessageErrorType,
+  toPrefixedMessage,
+} from '../../../utils/signature/toPrefixedMessage.js'
+
+export type HashMessageParameters = {
+  message: SignableMessage
+  verifierDomain: RequiredBy<
+    TypedDataDomain,
+    'chainId' | 'name' | 'verifyingContract' | 'version'
+  >
+}
+
+export type HashMessageReturnType = Hex
+
+export type HashMessageErrorType =
+  | HashTypedDataErrorType
+  | ToPrefixedMessageErrorType
+  | ErrorType
+
+/**
+ * Generates a signable hash for a Solady ERC-1271 personal sign message.
+ *
+ * @example
+ * ```ts
+ * const hash = hashMessage({
+ *   message: 'hello world',
+ *   verifierDomain: {
+ *     name: 'Smart Account',
+ *     version: '1',
+ *     verifyingContract: '0x1234567890abcdef1234567890abcdef12345678',
+ *     chainId: 1,
+ *   },
+ * })
+ * ```
+ */
+export function hashMessage(
+  parameters: HashMessageParameters,
+): HashMessageReturnType {
+  const {
+    message,
+    verifierDomain: { salt, ...domain },
+  } = parameters
+  return hashTypedData({
+    domain,
+    types: {
+      PersonalSign: [{ name: 'prefixed', type: 'bytes' }],
+    },
+    primaryType: 'PersonalSign',
+    message: {
+      prefixed: toPrefixedMessage(message),
+    },
+  })
+}

package/experimental/solady/utils/hashTypedData.ts

@@ -0,0 +1,112 @@
+import type { TypedData, TypedDataDomain } from 'abitype'
+import type { ErrorType } from '../../../errors/utils.js'
+import type { Hex } from '../../../types/misc.js'
+import type { TypedDataDefinition } from '../../../types/typedData.js'
+import type { RequiredBy } from '../../../types/utils.js'
+import {
+  type HashTypedDataErrorType as HashTypedDataErrorType_,
+  hashTypedData as hashTypedData_,
+} from '../../../utils/signature/hashTypedData.js'
+
+export type HashTypedDataParameters<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = TypedDataDefinition<typedData, primaryType, primaryTypes> & {
+  fields: Hex
+  extensions: readonly bigint[]
+  verifierDomain: RequiredBy<
+    TypedDataDomain,
+    'chainId' | 'name' | 'verifyingContract' | 'version'
+  >
+}
+
+export type HashTypedDataReturnType = Hex
+
+export type HashTypedDataErrorType = HashTypedDataErrorType_ | ErrorType
+
+/**
+ * Generates a signable hash for Solady ERC-1271 typed data.
+ *
+ * @example
+ * ```ts
+ * const hash = hashTypedData({
+ *   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!',
+ *   },
+ *   verifierDomain: {
+ *     name: 'Smart Account',
+ *     version: '1',
+ *     verifyingContract: '0x1234567890abcdef1234567890abcdef12345678',
+ *     chainId: 1,
+ *   },
+ * })
+ * ```
+ */
+export function hashTypedData<
+  const typedData extends TypedData | Record<string, unknown>,
+  primaryType extends keyof typedData | 'EIP712Domain',
+>(
+  parameters: HashTypedDataParameters<typedData, primaryType>,
+): HashTypedDataReturnType {
+  const {
+    domain,
+    extensions,
+    fields,
+    message,
+    primaryType,
+    types,
+    verifierDomain,
+  } = parameters
+
+  return hashTypedData_({
+    domain: domain as any,
+    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),
+    },
+  })
+}

package/experimental/solady/utils/wrapTypedDataSignature.ts

@@ -0,0 +1,108 @@
+import type { TypedData } from 'abitype'
+import { serializeSignature } from '../../../accounts/index.js'
+import type { ByteArray, Hex, Signature } from '../../../types/misc.js'
+import type { TypedDataDefinition } from '../../../types/typedData.js'
+import { encodePacked } from '../../../utils/abi/encodePacked.js'
+import { type IsHexErrorType, isHex } from '../../../utils/data/isHex.js'
+import { size } from '../../../utils/data/size.js'
+import { bytesToHex, stringToHex } from '../../../utils/encoding/toHex.js'
+import {
+  encodeType,
+  hashStruct,
+} from '../../../utils/signature/hashTypedData.js'
+import { getTypesForEIP712Domain } from '../../../utils/typedData.js'
+
+export type WrapTypedDataSignatureParameters<
+  typedData extends TypedData | Record<string, unknown> = TypedData,
+  primaryType extends keyof typedData | 'EIP712Domain' = keyof typedData,
+  ///
+  primaryTypes = typedData extends TypedData ? keyof typedData : string,
+> = TypedDataDefinition<typedData, primaryType, primaryTypes> & {
+  signature: Hex | ByteArray | Signature
+}
+
+export type WrapTypedDataSignatureReturnType = Hex
+
+export type WrapTypedDataSignatureErrorType = IsHexErrorType
+
+/**
+ * Wraps a typed data signature for Solady's ERC-1271 implementation.
+ *
+ * @example
+ * ```ts
+ * const signature = wrapTypedDataSignature({
+ *   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!',
+ *   },
+ *   signature: '0x...',
+ * })
+ * ```
+ */
+export function wrapTypedDataSignature(
+  parameters: WrapTypedDataSignatureParameters,
+): WrapTypedDataSignatureReturnType {
+  const { domain, message, primaryType, signature, types } = parameters
+
+  const signatureHex = (() => {
+    if (isHex(signature)) return signature
+    if (typeof signature === 'object' && 'r' in signature && 's' in signature)
+      return serializeSignature(signature)
+    return bytesToHex(signature)
+  })()
+
+  // 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'],
+    [
+      signatureHex,
+      hashedDomain,
+      hashedContents,
+      stringToHex(encodedType),
+      size(stringToHex(encodedType)),
+    ],
+  )
+}

package/index.ts

@@ -1021,8 +1021,8 @@ export type {
   WalletCapabilitiesRecord,
   WalletCallReceipt,
   WalletGetCallsStatusReturnType,
-  WalletIssuePermissionsParameters,
-  WalletIssuePermissionsReturnType,
+  WalletGrantPermissionsParameters,
+  WalletGrantPermissionsReturnType,
   WalletSendCallsParameters,
   WalletPermissionCaveat,
   WalletPermission,
@@ -1142,6 +1142,7 @@ export {
 export {
   type EncodeEventTopicsErrorType,
   type EncodeEventTopicsParameters,
+  type EncodeEventTopicsReturnType,
   encodeEventTopics,
 } from './utils/abi/encodeEventTopics.js'
 export {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "2.16.0",
+  "version": "2.16.2",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -59,6 +59,11 @@
       "import": "./_esm/experimental/index.js",
       "default": "./_cjs/experimental/index.js"
     },
+    "./experimental/solady": {
+      "types": "./_types/experimental/solady/index.d.ts",
+      "import": "./_esm/experimental/solady/index.js",
+      "default": "./_cjs/experimental/solady/index.js"
+    },
     "./node": {
       "types": "./_types/node/index.d.ts",
       "import": "./_esm/node/index.js",
@@ -119,6 +124,9 @@
       "experimental": [
         "./_types/experimental/index.d.ts"
       ],
+      "experimental/solady": [
+        "./_types/experimental/solady/index.d.ts"
+      ],
       "node": [
         "./_types/node/index.d.ts"
       ],

package/types/eip1193.ts

@@ -131,28 +131,37 @@ export type WalletCallReceipt<quantity = Hex, status = Hex> = {
   transactionHash: Hex
 }
 
-export type WalletIssuePermissionsParameters = {
+export type WalletGrantPermissionsParameters = {
   signer?:
     | {
         type: string
-        data: unknown
+        data?: unknown | undefined
       }
     | undefined
   permissions: readonly {
-    type: string
     data: unknown
-    required: boolean
+    policies: readonly {
+      data: unknown
+      type: string
+    }[]
+    required?: boolean | undefined
+    type: string
   }[]
   expiry: number
 }
 
-export type WalletIssuePermissionsReturnType = {
+export type WalletGrantPermissionsReturnType = {
   expiry: number
   factory?: `0x${string}` | undefined
   factoryData?: string | undefined
   grantedPermissions: readonly {
+    data: unknown
+    policies: readonly {
+      data: unknown
+      type: string
+    }[]
+    required?: boolean | undefined
     type: string
-    data: any
   }[]
   permissionsContext: string
   signerData?:
@@ -1404,13 +1413,13 @@ export type WalletRpcSchema = [
    * @description Requests permissions from a wallet
    * @link https://eips.ethereum.org/EIPS/eip-7715
    * @example
-   * provider.request({ method: 'wallet_issuePermissions', params: [{ ... }] })
+   * provider.request({ method: 'wallet_grantPermissions', params: [{ ... }] })
    * // => { ... }
    */
   {
-    Method: 'wallet_issuePermissions'
-    Parameters?: [WalletIssuePermissionsParameters]
-    ReturnType: Prettify<WalletIssuePermissionsReturnType>
+    Method: 'wallet_grantPermissions'
+    Parameters?: [WalletGrantPermissionsParameters]
+    ReturnType: Prettify<WalletGrantPermissionsReturnType>
   },
   /**
    * @description Requests the given permissions from the user.

package/utils/abi/encodeEventTopics.ts

@@ -66,6 +66,8 @@ export type EncodeEventTopicsParameters<
 > &
   (hasEvents extends true ? unknown : never)
 
+export type EncodeEventTopicsReturnType = [Hex, ...(Hex | Hex[] | null)[]]
+
 export type EncodeEventTopicsErrorType =
   | AbiEventNotFoundErrorType
   | EncodeArgErrorType
@@ -77,7 +79,9 @@ export type EncodeEventTopicsErrorType =
 export function encodeEventTopics<
   const abi extends Abi | readonly unknown[],
   eventName extends ContractEventName<abi> | undefined = undefined,
->(parameters: EncodeEventTopicsParameters<abi, eventName>) {
+>(
+  parameters: EncodeEventTopicsParameters<abi, eventName>,
+): EncodeEventTopicsReturnType {
   const { abi, eventName, args } = parameters as EncodeEventTopicsParameters
 
   let abiItem = abi[0]
@@ -93,7 +97,7 @@ export function encodeEventTopics<
   const definition = formatAbiItem(abiItem)
   const signature = toEventSelector(definition as EventDefinition)
 
-  let topics: Hex[] = []
+  let topics: (Hex | Hex[] | null)[] = []
   if (args && 'inputs' in abiItem) {
     const indexedInputs = abiItem.inputs?.filter(
       (param) => 'indexed' in param && param.indexed,
@@ -106,15 +110,13 @@ export function encodeEventTopics<
 
     if (args_.length > 0) {
       topics =
-        indexedInputs?.map((param, i) =>
-          Array.isArray(args_[i])
-            ? args_[i].map((_: any, j: number) =>
-                encodeArg({ param, value: args_[i][j] }),
-              )
-            : args_[i]
-              ? encodeArg({ param, value: args_[i] })
-              : null,
-        ) ?? []
+        indexedInputs?.map((param, i) => {
+          if (Array.isArray(args_[i]))
+            return args_[i].map((_: any, j: number) =>
+              encodeArg({ param, value: args_[i][j] }),
+            )
+          return args_[i] ? encodeArg({ param, value: args_[i] }) : null
+        }) ?? []
     }
   }
   return [signature, ...topics]

package/utils/getAction.ts

@@ -1,4 +1,10 @@
 import type { Client } from '../clients/createClient.js'
+import type { PublicActions } from '../clients/decorators/public.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 { Chain } from '../types/chain.js'
+import type { RpcSchema } from '../types/eip1193.js'
 
 /**
  * Retrieves and returns an action from the client (if exists), and falls
@@ -7,20 +13,30 @@ import type { Client } from '../clients/createClient.js'
  * Useful for extracting overridden actions from a client (ie. if a consumer
  * wants to override the `sendTransaction` implementation).
  */
-export function getAction<params extends {}, returnType extends {}>(
-  client: Client,
-  action: (_: any, params: params) => returnType,
-  // Some minifiers drop `Function.prototype.name` or can change function
-  // names so that getting the name by reflection through `action.name` will
-  // not work.
-  name: string,
-) {
-  type DecoratedClient = Client & {
-    [key: string]: (params: params) => returnType
-  }
+export function getAction<
+  transport extends Transport,
+  chain extends Chain | undefined,
+  account extends Account | undefined,
+  rpcSchema extends RpcSchema | undefined,
+  extended extends { [key: string]: unknown },
+  client extends Client<transport, chain, account, rpcSchema, extended>,
+  parameters,
+  returnType,
+>(
+  client: client,
+  actionFn: (_: any, parameters: parameters) => returnType,
+  // Some minifiers drop `Function.prototype.name`, or replace it with short letters,
+  // meaning that `actionFn.name` will not always work. For that case, the consumer
+  // needs to pass the name explicitly.
+  name: keyof PublicActions | keyof WalletActions | (string & {}),
+): (parameters: parameters) => returnType {
+  const action_implicit = client[actionFn.name]
+  if (typeof action_implicit === 'function')
+    return action_implicit as (params: parameters) => returnType
 
-  return (params: params): returnType =>
-    (client as DecoratedClient)[action.name]?.(params) ??
-    (client as DecoratedClient)[name]?.(params) ??
-    action(client, params)
+  const action_explicit = client[name]
+  if (typeof action_explicit === 'function')
+    return action_explicit as (params: parameters) => returnType
+
+  return (params) => actionFn(client, params)
 }

package/utils/index.ts

@@ -116,6 +116,7 @@ export {
 export {
   type EncodeArgErrorType,
   type EncodeEventTopicsParameters,
+  type EncodeEventTopicsReturnType,
   encodeEventTopics,
 } from './abi/encodeEventTopics.js'
 export {

package/_cjs/experimental/erc7715/actions/issuePermissions.js

@@ -1,74 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.issuePermissions = void 0;
-const toHex_js_1 = require("../../../utils/encoding/toHex.js");
-async function issuePermissions(client, parameters) {
-    const { expiry, permissions, signer } = parameters;
-    const result = await client.request({
-        method: 'wallet_issuePermissions',
-        params: [parseParameters({ expiry, permissions, signer })],
-    }, { retryCount: 0 });
-    return parseResult(result);
-}
-exports.issuePermissions = issuePermissions;
-function parseParameters(parameters) {
-    const { account, expiry, permissions, signer: signer_ } = parameters;
-    const signer = (() => {
-        if (!account && !signer_)
-            return undefined;
-        if (account) {
-            if (typeof account === 'string')
-                return {
-                    type: 'account',
-                    data: {
-                        id: account,
-                    },
-                };
-            return {
-                type: 'account',
-                data: {
-                    id: account.address,
-                },
-            };
-        }
-        return signer_;
-    })();
-    return {
-        expiry,
-        permissions: permissions.map((permission) => ({
-            ...permission,
-            ...(permission.data && typeof permission.data === 'object'
-                ? {
-                    data: {
-                        ...permission.data,
-                        ...('amount' in permission.data &&
-                            typeof permission.data.amount === 'bigint'
-                            ? { amount: (0, toHex_js_1.numberToHex)(permission.data.amount) }
-                            : {}),
-                    },
-                }
-                : {}),
-            required: permission.required ?? false,
-        })),
-        ...(signer ? { signer } : {}),
-    };
-}
-function parseResult(result) {
-    return {
-        expiry: result.expiry,
-        ...(result.factory ? { factory: result.factory } : {}),
-        ...(result.factoryData ? { factoryData: result.factoryData } : {}),
-        grantedPermissions: result.grantedPermissions.map((permission) => ({
-            ...permission,
-            data: {
-                ...permission.data,
-                ...('amount' in permission.data
-                    ? { amount: BigInt(permission.data.amount) }
-                    : {}),
-            },
-        })),
-        permissionsContext: result.permissionsContext,
-        ...(result.signerData ? { signerData: result.signerData } : {}),
-    };
-}
-//# sourceMappingURL=issuePermissions.js.map