viem 2.42.1 → 2.43.0

package/tempo/chainConfig.ts

@@ -0,0 +1,114 @@
+import * as SignatureEnvelope from 'ox/tempo/SignatureEnvelope'
+import type * as TokenId from 'ox/tempo/TokenId'
+import { getCode } from '../actions/public/getCode.js'
+import { verifyHash } from '../actions/public/verifyHash.js'
+import type { Chain, ChainConfig as viem_ChainConfig } from '../types/chain.js'
+import { extendSchema } from '../utils/chain/defineChain.js'
+import { defineTransaction } from '../utils/formatters/transaction.js'
+import { defineTransactionReceipt } from '../utils/formatters/transactionReceipt.js'
+import { defineTransactionRequest } from '../utils/formatters/transactionRequest.js'
+import { getAction } from '../utils/getAction.js'
+import type { SerializeTransactionFn } from '../utils/transaction/serializeTransaction.js'
+import type { Account } from './Account.js'
+import * as Formatters from './Formatters.js'
+import * as NonceKeyStore from './internal/nonceKeyStore.js'
+import * as Transaction from './Transaction.js'
+
+export const chainConfig = {
+  blockTime: 1_000,
+  extendSchema: extendSchema<{
+    feeToken?: TokenId.TokenIdOrAddress | undefined
+  }>(),
+  formatters: {
+    transaction: defineTransaction({
+      exclude: ['aaAuthorizationList' as never],
+      format: Formatters.formatTransaction,
+    }),
+    transactionReceipt: defineTransactionReceipt({
+      format: Formatters.formatTransactionReceipt,
+    }),
+    transactionRequest: defineTransactionRequest({
+      format: Formatters.formatTransactionRequest,
+    }),
+  },
+  async prepareTransactionRequest(r) {
+    const request = r as Transaction.TransactionRequest & {
+      account?: Account | undefined
+      chain?:
+        | (Chain & { feeToken?: TokenId.TokenIdOrAddress | undefined })
+        | undefined
+    }
+
+    request.nonceKey = (() => {
+      if (typeof request.nonceKey !== 'undefined') return request.nonceKey
+
+      const address = request.account?.address ?? request.from
+      if (!address) return undefined
+      if (!request.chain) return undefined
+      const nonceKey = NonceKeyStore.getNonceKey(NonceKeyStore.store, {
+        address,
+        chainId: request.chain.id,
+      })
+
+      if (nonceKey === 0n) return undefined
+      return nonceKey
+    })()
+
+    request.nonce = (() => {
+      if (typeof request.nonce === 'number') return request.nonce
+      // TODO: remove this line once `eth_fillTransaction` supports nonce keys.
+      if (request.nonceKey) return 0
+      return undefined
+    })()
+
+    if (!request.feeToken && request.chain?.feeToken)
+      request.feeToken = request.chain.feeToken
+
+    return request as unknown as typeof r
+  },
+  serializers: {
+    // TODO: casting to satisfy viem – viem v3 to have more flexible serializer type.
+    transaction: ((transaction, signature) =>
+      Transaction.serialize(transaction, signature)) as SerializeTransactionFn,
+  },
+  async verifyHash(client, parameters) {
+    const { address, hash, signature } = parameters
+
+    // `verifyHash` supports "signature envelopes" (a Tempo proposal) to natively verify arbitrary
+    // envelope-compatible (WebAuthn, P256, etc.) signatures.
+    // We can directly verify stateless, non-keychain signature envelopes without a
+    // network request to the chain.
+    if (
+      typeof signature === 'string' &&
+      signature.endsWith(SignatureEnvelope.magicBytes.slice(2))
+    ) {
+      const envelope = SignatureEnvelope.deserialize(signature)
+      if (envelope.type !== 'keychain') {
+        const code = await getCode(client, {
+          address,
+          blockNumber: parameters.blockNumber,
+          blockTag: parameters.blockTag,
+        } as never)
+        // Check if EOA, if not, we want to go down the ERC-1271 flow.
+        if (
+          // not a contract (EOA)
+          !code ||
+          // default delegation (tempo EOA)
+          code === '0xef01007702c00000000000000000000000000000000000'
+        )
+          return SignatureEnvelope.verify(envelope, {
+            address,
+            payload: hash,
+          })
+      }
+    }
+
+    return await getAction(
+      client,
+      verifyHash,
+      'verifyHash',
+    )({ ...parameters, chain: null })
+  },
+} as const satisfies viem_ChainConfig & { blockTime: number }
+
+export type ChainConfig = typeof chainConfig

package/tempo/index.ts

@@ -0,0 +1,59 @@
+// Export types required for inference.
+export type {
+  /** @deprecated */
+  KeyAuthorization as z_KeyAuthorization,
+  /** @deprecated */
+  SignatureEnvelope as z_SignatureEnvelope,
+  /** @deprecated */
+  TokenId as z_TokenId,
+  /** @deprecated */
+  TxEnvelopeTempo as z_TxEnvelopeTempo,
+} from 'ox/tempo'
+// biome-ignore lint/performance/noBarrelFile: _
+export { Tick } from 'ox/tempo'
+export * as Abis from './Abis.js'
+export * as Account from './Account.js'
+export * as Addresses from './Addresses.js'
+export * as Actions from './actions/index.js'
+export {
+  type Decorator as TempoActions,
+  decorator as tempoActions,
+} from './Decorator.js'
+export * as Formatters from './Formatters.js'
+export * as P256 from './P256.js'
+export * as Secp256k1 from './Secp256k1.js'
+export * as TokenIds from './TokenIds.js'
+// Export types required for inference.
+export type {
+  /** @deprecated */
+  Transaction as z_Transaction,
+  /** @deprecated */
+  TransactionReceipt as z_TransactionReceipt,
+  /** @deprecated */
+  TransactionReceiptRpc as z_TransactionReceiptRpc,
+  /** @deprecated */
+  TransactionRequest as z_TransactionRequest,
+  /** @deprecated */
+  TransactionRequestRpc as z_TransactionRequestRpc,
+  /** @deprecated */
+  TransactionRequestTempo as z_TransactionRequestTempo,
+  /** @deprecated */
+  TransactionRpc as z_TransactionRpc,
+  /** @deprecated */
+  TransactionSerializable as z_TransactionSerializable,
+  /** @deprecated */
+  TransactionSerializableTempo as z_TransactionSerializableTempo,
+  /** @deprecated */
+  TransactionSerialized as z_TransactionSerialized,
+  /** @deprecated */
+  TransactionSerializedTempo as z_TransactionSerializedTempo,
+  /** @deprecated */
+  TransactionTempo as z_TransactionTempo,
+  /** @deprecated */
+  TransactionType as z_TransactionType,
+} from './Transaction.js'
+export * as Transaction from './Transaction.js'
+export * as Transport from './Transport.js'
+export { withFeePayer } from './Transport.js'
+export * as WebAuthnP256 from './WebAuthnP256.js'
+export * as WebCryptoP256 from './WebCryptoP256.js'

package/tempo/internal/nonceKeyStore.ts

@@ -0,0 +1,50 @@
+import type { Address } from 'abitype'
+import * as Hex from 'ox/Hex'
+
+type Parameters = { address: Address; chainId: number }
+
+type Store = Map<string, { counter: number; resetScheduled: boolean }>
+
+/** @internal */
+export const store = /*#__PURE__*/ create()
+
+/** @internal */
+export function create(): Store {
+  return new Map()
+}
+
+/** @internal */
+export function getCacheKey(parameters: Parameters) {
+  return `${parameters.address.toLowerCase()}-${parameters.chainId}`
+}
+
+/** @internal */
+export function getEntry(store: Store, parameters: Parameters) {
+  const key = getCacheKey(parameters)
+  let entry = store.get(key)
+  if (!entry) {
+    entry = { counter: 0, resetScheduled: false }
+    store.set(key, entry)
+  }
+  return entry
+}
+
+/** @internal */
+export function reset(store: Store, parameters: Parameters) {
+  const entry = getEntry(store, parameters)
+  entry.counter = 0
+  entry.resetScheduled = false
+}
+
+/** @internal */
+export function getNonceKey(store: Store, parameters: Parameters) {
+  const entry = getEntry(store, parameters)
+  if (!entry.resetScheduled) {
+    entry.resetScheduled = true
+    queueMicrotask(() => reset(store, parameters))
+  }
+  const count = entry.counter
+  entry.counter++
+  if (count === 0) return 0n
+  return Hex.toBigInt(Hex.random(6))
+}

package/tempo/internal/types.ts

@@ -0,0 +1,55 @@
+import type { Address } from 'abitype'
+import type { Account } from '../../accounts/types.js'
+import type { ReadContractParameters as viem_ReadContractParameters } from '../../actions/public/readContract.js'
+import type { WriteContractSyncParameters as viem_WriteContractSyncParameters } from '../../actions/wallet/writeContractSync.js'
+import type { Chain } from '../../types/chain.js'
+import type {
+  IsUndefined,
+  MaybeRequired,
+  UnionPick,
+} from '../../types/utils.js'
+import type { TransactionRequestTempo } from '../Transaction.js'
+
+export type GetAccountParameter<
+  account extends Account | undefined = Account | undefined,
+  accountOverride extends Account | Address | undefined = Account | Address,
+  required extends boolean = true,
+  nullish extends boolean = false,
+> = MaybeRequired<
+  {
+    account?:
+      | accountOverride
+      | Account
+      | Address
+      | (nullish extends true ? null : never)
+      | undefined
+  },
+  IsUndefined<account> extends true
+    ? required extends true
+      ? true
+      : false
+    : false
+>
+
+export type ReadParameters = Pick<
+  viem_ReadContractParameters<never, never, never>,
+  'account' | 'blockNumber' | 'blockOverrides' | 'blockTag' | 'stateOverride'
+>
+
+export type WriteParameters<
+  chain extends Chain | undefined = Chain | undefined,
+  account extends Account | undefined = Account | undefined,
+> = UnionPick<
+  viem_WriteContractSyncParameters<never, never, never, chain, account>,
+  | 'account'
+  | 'chain'
+  | 'gas'
+  | 'maxFeePerGas'
+  | 'maxPriorityFeePerGas'
+  | 'nonce'
+  | 'throwOnReceiptRevert'
+> &
+  UnionPick<
+    TransactionRequestTempo,
+    'feeToken' | 'feePayer' | 'nonceKey' | 'validAfter' | 'validBefore'
+  >

package/tempo/internal/utils.ts

@@ -0,0 +1,57 @@
+import type { Abi, AbiStateMutability, Address } from 'abitype'
+import type {
+  ContractFunctionName,
+  ContractFunctionParameters,
+  ExtractAbiItem,
+} from '../../types/contract.js'
+import type { Hex } from '../../types/misc.js'
+import { encodeFunctionData } from '../../utils/index.js'
+
+export function defineCall<
+  const abi extends Abi,
+  const functionName extends ContractFunctionName<abi, AbiStateMutability>,
+  call extends ContractFunctionParameters<
+    abi,
+    AbiStateMutability,
+    functionName
+  >,
+>(
+  call:
+    | call
+    | ContractFunctionParameters<abi, AbiStateMutability, functionName>,
+): ContractFunctionParameters<
+  [ExtractAbiItem<abi, functionName>],
+  AbiStateMutability,
+  functionName
+> & {
+  data: Hex
+  to: Address
+} {
+  return {
+    ...(call as any),
+    data: encodeFunctionData(call as never),
+    to: call.address,
+  } as const
+}
+
+/**
+ * Normalizes a value into a structured-clone compatible format.
+ *
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Window/structuredClone
+ * @internal
+ */
+export function normalizeValue<type>(value: type): type {
+  if (Array.isArray(value)) return value.map(normalizeValue) as never
+  if (typeof value === 'function') return undefined as never
+  if (typeof value !== 'object' || value === null) return value
+  if (Object.getPrototypeOf(value) !== Object.prototype)
+    try {
+      return structuredClone(value)
+    } catch {
+      return undefined as never
+    }
+
+  const normalized: Record<string, unknown> = {}
+  for (const [k, v] of Object.entries(value)) normalized[k] = normalizeValue(v)
+  return normalized as never
+}

package/tempo/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/tempo/index.d.ts",
+  "module": "../_esm/tempo/index.js",
+  "main": "../_cjs/tempo/index.js"
+}

package/types/chain.ts

@@ -1,6 +1,10 @@
 import type { Address } from 'abitype'
 
 import type { EstimateFeesPerGasReturnType } from '../actions/public/estimateFeesPerGas.js'
+import type {
+  VerifyHashParameters,
+  VerifyHashReturnType,
+} from '../actions/public/verifyHash.js'
 import type { PrepareTransactionRequestParameters } from '../actions/wallet/prepareTransactionRequest.js'
 import type { Client } from '../clients/createClient.js'
 import type { Transport } from '../clients/transports/createTransport.js'
@@ -17,7 +21,7 @@ import type { SerializeTransactionFn } from '../utils/transaction/serializeTrans
 
 export type Chain<
   formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
-  custom extends Record<string, unknown> | undefined =
+  extendSchema extends Record<string, unknown> | undefined =
     | Record<string, unknown>
     | undefined,
 > = {
@@ -65,7 +69,7 @@ export type Chain<
   sourceId?: number | undefined
   /** Flag for test networks */
   testnet?: boolean | undefined
-} & ChainConfig<formatters, custom>
+} & ChainConfig<formatters, extendSchema>
 
 /////////////////////////////////////////////////////////////////////
 // Config
@@ -80,14 +84,21 @@ type PrepareTransactionRequestFn = (
   options: { phase: PrepareTransactionRequestPhase },
 ) => Promise<PrepareTransactionRequestParameters>
 
+type ChainVerifyHashFn = (
+  client: Client,
+  parameters: VerifyHashParameters,
+) => Promise<VerifyHashReturnType>
+
 export type ChainConfig<
   formatters extends ChainFormatters | undefined = ChainFormatters | undefined,
-  custom extends Record<string, unknown> | undefined =
+  extendSchema extends Record<string, unknown> | undefined =
     | Record<string, unknown>
     | undefined,
 > = {
-  /** Custom chain data. */
-  custom?: custom | undefined
+  /** Custom chain data. @deprecated use `.extend` instead. */
+  custom?: extendSchema | undefined
+  /** Extend schema. */
+  extendSchema?: extendSchema | undefined
   /** Modifies how fees are derived. */
   fees?: ChainFees<formatters | undefined> | undefined
   /** Modifies how data is formatted and typed (e.g. blocks and transactions) */
@@ -111,6 +122,8 @@ export type ChainConfig<
     | undefined
   /** Modifies how data is serialized (e.g. transactions). */
   serializers?: ChainSerializers<formatters> | undefined
+  /** Chain-specific signature verification. */
+  verifyHash?: ChainVerifyHashFn | undefined
 }
 
 /////////////////////////////////////////////////////////////////////

package/types/contract.ts

@@ -71,7 +71,8 @@ export type ContractFunctionArgs<
     functionName,
     mutability
   >['inputs'],
-  'inputs'
+  'inputs',
+  true
 > extends infer args
   ? [args] extends [never]
     ? readonly unknown[]
@@ -85,7 +86,8 @@ export type ContractConstructorArgs<
     (abi extends Abi ? abi : Abi)[number],
     { type: 'constructor' }
   >['inputs'],
-  'inputs'
+  'inputs',
+  true
 > extends infer args
   ? [args] extends [never]
     ? readonly unknown[]
@@ -97,7 +99,8 @@ export type ContractErrorArgs<
   errorName extends ContractErrorName<abi> = ContractErrorName<abi>,
 > = AbiParametersToPrimitiveTypes<
   ExtractAbiError<abi extends Abi ? abi : Abi, errorName>['inputs'],
-  'inputs'
+  'inputs',
+  true
 > extends infer args
   ? [args] extends [never]
     ? readonly unknown[]
@@ -179,8 +182,9 @@ type CheckArgs<
   ///
   targetArgs extends AbiParametersToPrimitiveTypes<
     abiFunction['inputs'],
-    'inputs'
-  > = AbiParametersToPrimitiveTypes<abiFunction['inputs'], 'inputs'>,
+    'inputs',
+    true
+  > = AbiParametersToPrimitiveTypes<abiFunction['inputs'], 'inputs', true>,
 > = (readonly [] extends args ? readonly [] : args) extends targetArgs // fallback to `readonly []` if `args` has no value (e.g. `args` property not provided)
   ? abiFunction
   : never
@@ -201,6 +205,11 @@ export type ContractFunctionParameters<
   ///
   allFunctionNames = ContractFunctionName<abi, mutability>,
   allArgs = ContractFunctionArgs<abi, mutability, functionName>,
+  abiFunction = ExtractAbiFunction<
+    abi extends Abi ? abi : Abi,
+    functionName,
+    mutability
+  >,
   // when `args` is inferred to `readonly []` ("inputs": []) or `never` (`abi` declared as `Abi` or not inferrable), allow `args` to be optional.
   // important that both branches return same structural type
 > = {
@@ -208,11 +217,28 @@ export type ContractFunctionParameters<
   functionName:
     | allFunctionNames // show all options
     | (functionName extends allFunctionNames ? functionName : never) // infer value
-  args?: (abi extends Abi ? UnionWiden<args> : never) | allArgs | undefined
-} & (readonly [] extends allArgs ? {} : { args: Widen<args> }) &
+} & (readonly [] extends allArgs
+  ? {
+      args?:
+        | allArgs
+        | (abi extends Abi
+            ? Abi extends abi
+              ? never
+              : UnionWiden<IsUnion<abiFunction> extends true ? args : allArgs>
+            : never)
+        | undefined
+    }
+  : {
+      args: args
+    }) &
   (deployless extends true
-    ? { address?: undefined; code: Hex }
-    : { address: Address })
+    ? {
+        address?: undefined
+        code: Hex
+      }
+    : {
+        address: Address
+      })
 
 export type ContractFunctionReturnType<
   abi extends Abi | readonly unknown[] = Abi,
@@ -235,7 +261,9 @@ export type ContractFunctionReturnType<
             mutability,
             functionName,
             args
-          >['outputs']
+          >['outputs'],
+          'outputs',
+          true
         > extends infer types
       ? types extends readonly []
         ? void
@@ -265,7 +293,8 @@ export type AbiItemArgs<
   name extends AbiItemName<abi> = AbiItemName<abi>,
 > = AbiParametersToPrimitiveTypes<
   ExtractAbiItem<abi extends Abi ? abi : Abi, name>['inputs'],
-  'inputs'
+  'inputs',
+  true
 > extends infer args
   ? [args] extends [never]
     ? readonly unknown[]
@@ -290,7 +319,8 @@ export type ExtractAbiItemForArgs<
               : args
           ) extends AbiParametersToPrimitiveTypes<
             abiItems[k]['inputs'],
-            'inputs'
+            'inputs',
+            true
           >
             ? abiItems[k]
             : never

package/types/utils.ts

@@ -166,6 +166,8 @@ export type Prettify<T> = {
   [K in keyof T]: T[K]
 } & {}
 
+export type Compute<T> = Prettify<T>
+
 /** @internal */
 export type Evaluate<type> = {
   [key in keyof type]: type[key]

package/utils/abi/decodeAbiParameters.ts

@@ -1,4 +1,8 @@
-import type { AbiParameter, AbiParametersToPrimitiveTypes } from 'abitype'
+import type {
+  AbiParameter,
+  AbiParameterKind,
+  AbiParametersToPrimitiveTypes,
+} from 'abitype'
 import {
   AbiDecodingDataSizeTooSmallError,
   AbiDecodingZeroDataError,
@@ -36,7 +40,9 @@ import { getArrayComponents } from './encodeAbiParameters.js'
 export type DecodeAbiParametersReturnType<
   params extends readonly AbiParameter[] = readonly AbiParameter[],
 > = AbiParametersToPrimitiveTypes<
-  params extends readonly AbiParameter[] ? params : AbiParameter[]
+  params extends readonly AbiParameter[] ? params : AbiParameter[],
+  AbiParameterKind,
+  true
 >
 
 export type DecodeAbiParametersErrorType =
@@ -76,7 +82,7 @@ export function decodeAbiParameters<
     consumed += consumed_
     values.push(data)
   }
-  return values as DecodeAbiParametersReturnType<params>
+  return values as never
 }
 
 type DecodeParameterErrorType =

package/utils/abi/decodeEventLog.ts

@@ -152,7 +152,10 @@ export function decodeEventLog<
   if (nonIndexedInputs.length > 0) {
     if (data && data !== '0x') {
       try {
-        const decodedData = decodeAbiParameters(nonIndexedInputs, data)
+        const decodedData = decodeAbiParameters(
+          nonIndexedInputs,
+          data,
+        ) as unknown[]
         if (decodedData) {
           if (isUnnamed)
             for (let i = 0; i < inputs.length; i++)

package/utils/abi/encodeAbiParameters.ts

@@ -1,5 +1,6 @@
 import type {
   AbiParameter,
+  AbiParameterKind,
   AbiParametersToPrimitiveTypes,
   AbiParameterToPrimitiveType,
 } from 'abitype'
@@ -87,7 +88,7 @@ export function encodeAbiParameters<
 >(
   params: params,
   values: params extends readonly AbiParameter[]
-    ? AbiParametersToPrimitiveTypes<params>
+    ? AbiParametersToPrimitiveTypes<params, AbiParameterKind, true>
     : never,
 ): EncodeAbiParametersReturnType {
   if (params.length !== values.length)

package/utils/chain/defineChain.ts

@@ -1,14 +1,44 @@
 import type { Chain, ChainFormatters } from '../../types/chain.js'
 import type { Assign, Prettify } from '../../types/utils.js'
 
+export type DefineChainReturnType<chain extends Chain = Chain> = Prettify<
+  chain &
+    (chain['extendSchema'] extends Record<string, unknown>
+      ? {
+          extend: <const extended extends chain['extendSchema']>(
+            extended: extended,
+          ) => Assign<chain, extended>
+        }
+      : {})
+>
+
 export function defineChain<
   formatters extends ChainFormatters,
   const chain extends Chain<formatters>,
->(chain: chain): Prettify<Assign<Chain<undefined>, chain>> {
-  return {
+>(chain: chain): DefineChainReturnType<Assign<Chain<undefined>, chain>> {
+  const chainInstance = {
     formatters: undefined,
     fees: undefined,
     serializers: undefined,
     ...chain,
   } as Assign<Chain<undefined>, chain>
+
+  function extend(base: typeof chainInstance) {
+    type ExtendFn = (base: typeof chainInstance) => unknown
+    return (fnOrExtended: ExtendFn | Record<string, unknown>) => {
+      const properties = (
+        typeof fnOrExtended === 'function' ? fnOrExtended(base) : fnOrExtended
+      ) as (typeof chainInstance)['extendSchema']
+      const combined = { ...base, ...properties }
+      return Object.assign(combined, { extend: extend(combined) })
+    }
+  }
+
+  return Object.assign(chainInstance, {
+    extend: extend(chainInstance),
+  }) as never
+}
+
+export function extendSchema<schema extends Record<string, unknown>>(): schema {
+  return {} as schema
 }

package/utils/formatters/transaction.ts

@@ -111,9 +111,8 @@ export function formatTransaction(
     delete transaction_.maxFeePerGas
     delete transaction_.maxPriorityFeePerGas
   }
-  if (transaction_.type === 'eip1559') {
-    delete transaction_.maxFeePerBlobGas
-  }
+  if (transaction_.type === 'eip1559') delete transaction_.maxFeePerBlobGas
+
   return transaction_
 }