viem 1.18.8 → 1.19.0

package/actions/test/loadState.ts

@@ -0,0 +1,47 @@
+import type {
+  TestClient,
+  TestClientMode,
+} from '../../clients/createTestClient.js'
+import type { Transport } from '../../clients/transports/createTransport.js'
+import type { ErrorType } from '../../errors/utils.js'
+import type { Account } from '../../types/account.js'
+import type { Chain } from '../../types/chain.js'
+import type { Hex } from '../../types/misc.js'
+import type { RequestErrorType } from '../../utils/buildRequest.js'
+
+export type LoadStateParameters = { state: Hex }
+export type LoadStateReturnType = void
+export type LoadStateErrorType = RequestErrorType | ErrorType
+
+/**
+ * Adds state previously dumped with `dumpState` to the current chain.
+ *
+ * - Docs: https://viem.sh/docs/actions/test/loadState.html
+ *
+ * @param client - Client to use
+ * @param parameters - {@link LoadStateParameters}
+ *
+ * @example
+ * import { createTestClient, http } from 'viem'
+ * import { foundry } from 'viem/chains'
+ * import { loadState } from 'viem/test'
+ *
+ * const client = createTestClient({
+ *   mode: 'anvil',
+ *   chain: 'foundry',
+ *   transport: http(),
+ * })
+ * await loadState(client, { state: '0x...' })
+ */
+export async function loadState<
+  TChain extends Chain | undefined,
+  TAccount extends Account | undefined,
+>(
+  client: TestClient<TestClientMode, Transport, TChain, TAccount, false>,
+  { state }: LoadStateParameters,
+): Promise<LoadStateReturnType> {
+  await client.request({
+    method: `${client.mode}_loadState`,
+    params: [state],
+  })
+}

package/chains/definitions/lukso.ts

@@ -0,0 +1,28 @@
+import { defineChain } from '../../utils/chain/defineChain.js'
+
+export const lukso = /*#__PURE__*/ defineChain({
+  id: 42,
+  network: 'lukso',
+  name: 'LUKSO',
+  nativeCurrency: {
+    name: 'LUKSO',
+    symbol: 'LYX',
+    decimals: 18,
+  },
+  rpcUrls: {
+    default: {
+      http: ['https://rpc.mainnet.lukso.network'],
+      webSocket: ['wss://ws-rpc.mainnet.lukso.network'],
+    },
+    public: {
+      http: ['https://rpc.mainnet.lukso.network'],
+      webSocket: ['wss://ws-rpc.mainnet.lukso.network'],
+    },
+  },
+  blockExplorers: {
+    default: {
+      name: 'LUKSO Mainnet Explorer',
+      url: 'https://explorer.execution.mainnet.lukso.network',
+    },
+  },
+})

package/chains/index.ts

@@ -72,6 +72,7 @@ export { kromaSepolia } from './definitions/kromaSepolia.js'
 export { linea } from './definitions/linea.js'
 export { lineaTestnet } from './definitions/lineaTestnet.js'
 export { localhost } from './definitions/localhost.js'
+export { lukso } from './definitions/lukso.js'
 export { mainnet } from './definitions/mainnet.js'
 export { manta } from './definitions/manta.js'
 export { mantaTestnet } from './definitions/mantaTestnet.js'

package/clients/decorators/test.ts

@@ -2,6 +2,10 @@ import {
   type DropTransactionParameters,
   dropTransaction,
 } from '../../actions/test/dropTransaction.js'
+import {
+  type DumpStateReturnType,
+  dumpState,
+} from '../../actions/test/dumpState.js'
 import {
   type GetAutomineReturnType,
   getAutomine,
@@ -26,6 +30,11 @@ import {
   type InspectTxpoolReturnType,
   inspectTxpool,
 } from '../../actions/test/inspectTxpool.js'
+import {
+  type LoadStateParameters,
+  type LoadStateReturnType,
+  loadState,
+} from '../../actions/test/loadState.js'
 import { type MineParameters, mine } from '../../actions/test/mine.js'
 import { removeBlockTimestampInterval } from '../../actions/test/removeBlockTimestampInterval.js'
 import { type ResetParameters, reset } from '../../actions/test/reset.js'
@@ -113,6 +122,26 @@ export type TestActions = {
    * })
    */
   dropTransaction: (args: DropTransactionParameters) => Promise<void>
+  /**
+   * Serializes the current state (including contracts code, contract's storage,
+   * accounts properties, etc.) into a savable data blob.
+   *
+   * - Docs: https://viem.sh/docs/actions/test/dumpState.html
+   *
+   * @param client - Client to use
+   *
+   * @example
+   * import { createTestClient, http } from 'viem'
+   * import { foundry } from 'viem/chains'
+   *
+   * const client = createTestClient({
+   *   mode: 'anvil',
+   *   chain: 'foundry',
+   *   transport: http(),
+   * })
+   * await client.dumpState()
+   */
+  dumpState: () => Promise<DumpStateReturnType>
   /**
    * Returns the automatic mining status of the node.
    *
@@ -231,6 +260,25 @@ export type TestActions = {
    * const data = await client.inspectTxpool()
    */
   inspectTxpool: () => Promise<InspectTxpoolReturnType>
+  /**
+   * Adds state previously dumped with `dumpState` to the current chain.
+   *
+   * - Docs: https://viem.sh/docs/actions/test/loadState.html
+   *
+   * @param client - Client to use
+   *
+   * @example
+   * import { createTestClient, http } from 'viem'
+   * import { foundry } from 'viem/chains'
+   *
+   * const client = createTestClient({
+   *   mode: 'anvil',
+   *   chain: 'foundry',
+   *   transport: http(),
+   * })
+   * await client.loadState({ state: '0x...' })
+   */
+  loadState: (args: LoadStateParameters) => Promise<LoadStateReturnType>
   /**
    * Mine a specified number of blocks.
    *
@@ -689,12 +737,14 @@ export function testActions<TMode extends TestClientMode>({
     }))
     return {
       dropTransaction: (args) => dropTransaction(client, args),
+      dumpState: () => dumpState(client),
       getAutomine: () => getAutomine(client),
       getTxpoolContent: () => getTxpoolContent(client),
       getTxpoolStatus: () => getTxpoolStatus(client),
       impersonateAccount: (args) => impersonateAccount(client, args),
       increaseTime: (args) => increaseTime(client, args),
       inspectTxpool: () => inspectTxpool(client),
+      loadState: (args) => loadState(client, args),
       mine: (args) => mine(client, args),
       removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
       reset: (args) => reset(client, args),

package/constants/bytes.ts

@@ -0,0 +1,2 @@
+export const zeroHash =
+  '0x0000000000000000000000000000000000000000000000000000000000000000' as const

package/constants/strings.ts

@@ -0,0 +1 @@
+export const presignMessagePrefix = '\x19Ethereum Signed Message:\n'

package/index.ts

@@ -582,6 +582,8 @@ export {
   minInt248,
   minInt256,
 } from './constants/number.js'
+export { zeroHash } from './constants/bytes.js'
+export { presignMessagePrefix } from './constants/strings.js'
 export {
   AbiConstructorNotFoundError,
   type AbiConstructorNotFoundErrorType,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "viem",
   "description": "TypeScript Interface for Ethereum",
-  "version": "1.18.8",
+  "version": "1.19.0",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",

package/types/eip1193.ts

@@ -707,6 +707,14 @@ export type TestRpcSchema<TMode extends string> = [
     Parameters: [hash: Hash]
     ReturnType: void
   },
+  /**
+   * @description Serializes the current state (including contracts code, contract's storage, accounts properties, etc.) into a savable data blob.
+   */
+  {
+    Method: `${TMode}_dumpState`
+    Parameters?: undefined
+    ReturnType: Hex
+  },
   /**
    * @description Turn on call traces for transactions that are returned to the user when they execute a transaction (instead of just txhash/receipt).
    */
@@ -733,6 +741,14 @@ export type TestRpcSchema<TMode extends string> = [
     Parameters?: undefined
     ReturnType: boolean
   },
+  /**
+   * @description Adds state previously dumped with `dumpState` to the current chain.
+   */
+  {
+    Method: `${TMode}_loadState`
+    Parameters?: [Hex]
+    ReturnType: void
+  },
   /**
    * @description Advance the block number of the network by a certain number of blocks
    * @link https://hardhat.org/hardhat-network/docs/reference#hardhat_mine

package/types/rpc.ts

@@ -17,7 +17,7 @@ import type {
   TransactionRequestEIP2930,
   TransactionRequestLegacy,
 } from './transaction.js'
-import type { UnionOmit } from './utils.js'
+import type { UnionOmit, UnionPartialBy } from './utils.js'
 
 export type Index = `0x${string}`
 export type Quantity = `0x${string}`
@@ -46,9 +46,18 @@ export type RpcTransactionRequest =
   | TransactionRequestLegacy<Quantity, Index, '0x0'>
   | TransactionRequestEIP2930<Quantity, Index, '0x1'>
   | TransactionRequestEIP1559<Quantity, Index, '0x2'>
-export type RpcTransaction<TPending extends boolean = boolean> = UnionOmit<
-  | TransactionLegacy<Quantity, Index, TPending, '0x0'>
-  | TransactionEIP2930<Quantity, Index, TPending, '0x1'>
-  | TransactionEIP1559<Quantity, Index, TPending, '0x2'>,
-  'typeHex'
+export type RpcTransaction<
+  TPending extends boolean = boolean,
+  // `yParity` is optional on the RPC type as some nodes do not return it
+  // for 1559 & 2930 transactions (they should!).
+  _optionalProperties extends 'yParity' = 'yParity',
+  _excludedProperties extends string = 'typeHex',
+> = UnionOmit<
+  UnionPartialBy<
+    | TransactionLegacy<Quantity, Index, TPending, '0x0'>
+    | TransactionEIP2930<Quantity, Index, TPending, '0x1'>
+    | TransactionEIP1559<Quantity, Index, TPending, '0x2'>,
+    _optionalProperties
+  >,
+  _excludedProperties
 >

package/types/transaction.ts

@@ -80,16 +80,21 @@ export type TransactionBase<
   v: TQuantity
   /** Value in wei sent with this transaction */
   value: TQuantity
+  /** The parity of the y-value of the secp256k1 signature. */
+  yParity: TIndex
 }
 export type TransactionLegacy<
   TQuantity = bigint,
   TIndex = number,
   TPending extends boolean = boolean,
   TType = 'legacy',
-> = TransactionBase<TQuantity, TIndex, TPending> &
+> = Omit<TransactionBase<TQuantity, TIndex, TPending>, 'yParity'> &
   FeeValuesLegacy<TQuantity> & {
+    /** EIP-2930 Access List. */
     accessList?: never
+    /** Chain ID that this transaction is valid on. */
     chainId?: TIndex
+    yParity?: never
     type: TType
   }
 export type TransactionEIP2930<
@@ -99,7 +104,9 @@ export type TransactionEIP2930<
   TType = 'eip2930',
 > = TransactionBase<TQuantity, TIndex, TPending> &
   FeeValuesLegacy<TQuantity> & {
+    /** EIP-2930 Access List. */
     accessList: AccessList
+    /** Chain ID that this transaction is valid on. */
     chainId: TIndex
     type: TType
   }
@@ -110,7 +117,9 @@ export type TransactionEIP1559<
   TType = 'eip1559',
 > = TransactionBase<TQuantity, TIndex, TPending> &
   FeeValuesEIP1559<TQuantity> & {
+    /** EIP-2930 Access List. */
     accessList: AccessList
+    /** Chain ID that this transaction is valid on. */
     chainId: TIndex
     type: TType
   }

package/types/utils.ts

@@ -194,6 +194,17 @@ export type UnionOmit<T, K extends keyof any> = T extends any
  */
 export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>
 
+/**
+ * @description Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * => { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any
+  ? PartialBy<T, K>
+  : never
+
 /**
  * @description Combines members of an intersection into a readable type.
  *

package/utils/contract/extractFunctionParts.ts

@@ -4,6 +4,7 @@ const paramsRegex = /((function|event)\s)?(.*)(\((.*)\))/
 
 export type ExtractFunctionPartsErrorType = ErrorType
 
+/** @deprecated – use `parseAbiItem` from `abitype`. */
 export function extractFunctionParts(def: string) {
   const parts = def.match(paramsRegex)
   const type = parts?.[2] || undefined
@@ -14,12 +15,14 @@ export function extractFunctionParts(def: string) {
 
 export type ExtractFunctionNameErrorType = ErrorType
 
+/** @deprecated – use `parseAbiItem` from `abitype`. */
 export function extractFunctionName(def: string) {
   return extractFunctionParts(def).name
 }
 
 export type ExtractFunctionParamsErrorType = ErrorType
 
+/** @deprecated – use `parseAbiItem` from `abitype`. */
 export function extractFunctionParams(def: string) {
   const params = extractFunctionParts(def).params
   const splitParams = params?.split(',').map((x) => x.trim().split(' '))
@@ -32,6 +35,7 @@ export function extractFunctionParams(def: string) {
 
 export type ExtractFunctionTypeErrorType = ErrorType
 
+/** @deprecated – use `parseAbiItem` from `abitype`. */
 export function extractFunctionType(def: string) {
   return extractFunctionParts(def).type
 }

package/utils/formatters/transaction.ts

@@ -68,18 +68,33 @@ export function formatTransaction(transaction: Partial<RpcTransaction>) {
     typeHex: transaction.type ? transaction.type : undefined,
     value: transaction.value ? BigInt(transaction.value) : undefined,
     v: transaction.v ? BigInt(transaction.v) : undefined,
-  }
+  } as Transaction
+
+  transaction_.yParity = (() => {
+    // If `yParity` is provided, we will use it.
+    if (transaction.yParity) return Number(transaction.yParity)
+
+    // If no `yParity` provided, try derive from `v`.
+    if (typeof transaction_.v === 'bigint') {
+      if (transaction_.v === 0n || transaction_.v === 27n) return 0
+      if (transaction_.v === 1n || transaction_.v === 28n) return 1
+      if (transaction_.v >= 35n) return transaction_.v % 2n === 0n ? 1 : 0
+    }
+
+    return undefined
+  })()
 
   if (transaction_.type === 'legacy') {
     delete transaction_.accessList
     delete transaction_.maxFeePerGas
     delete transaction_.maxPriorityFeePerGas
+    delete transaction_.yParity
   }
   if (transaction_.type === 'eip2930') {
     delete transaction_.maxFeePerGas
     delete transaction_.maxPriorityFeePerGas
   }
-  return transaction_ as Transaction
+  return transaction_
 }
 
 export type DefineTransactionErrorType = DefineFormatterErrorType | ErrorType

package/utils/hash/getFunctionSignature.ts

@@ -1,29 +1,19 @@
-import type { AbiFunction } from 'abitype'
+import { type AbiFunction, formatAbiItem } from 'abitype'
 
 import type { ErrorType } from '../../errors/utils.js'
 import {
-  type FormatAbiItemErrorType,
-  formatAbiItem,
-} from '../abi/formatAbiItem.js'
-import {
-  type ExtractFunctionNameErrorType,
-  type ExtractFunctionParamsErrorType,
-  extractFunctionName,
-  extractFunctionParams,
-} from '../contract/extractFunctionParts.js'
+  type NormalizeSignatureErrorType,
+  normalizeSignature,
+} from './normalizeSignature.js'
 
 export type GetFunctionSignatureErrorType =
-  | ExtractFunctionNameErrorType
-  | ExtractFunctionParamsErrorType
-  | FormatAbiItemErrorType
+  | NormalizeSignatureErrorType
   | ErrorType
 
-export const getFunctionSignature = (fn: string | AbiFunction) => {
-  if (typeof fn === 'string') {
-    const name = extractFunctionName(fn)
-    const params = extractFunctionParams(fn) || []
-    return `${name}(${params.map(({ type }) => type).join(',')})`
-  }
-
-  return formatAbiItem(fn)
+export const getFunctionSignature = (fn_: string | AbiFunction) => {
+  const fn = (() => {
+    if (typeof fn_ === 'string') return fn_
+    return formatAbiItem(fn_)
+  })()
+  return normalizeSignature(fn)
 }

package/utils/hash/normalizeSignature.ts

@@ -0,0 +1,64 @@
+import { BaseError } from '../../errors/base.js'
+import type { ErrorType } from '../../errors/utils.js'
+
+export type NormalizeSignatureParameters = string
+export type NormalizeSignatureReturnType = string
+export type NormalizeSignatureErrorType = ErrorType
+
+export function normalizeSignature(
+  signature: NormalizeSignatureParameters,
+): NormalizeSignatureReturnType {
+  let active = true
+  let current = ''
+  let level = 0
+  let result = ''
+  let valid = false
+
+  for (let i = 0; i < signature.length; i++) {
+    const char = signature[i]
+
+    // If the character is a separator, we want to reactivate.
+    if (['(', ')', ','].includes(char)) active = true
+
+    // If the character is a "level" token, we want to increment/decrement.
+    if (char === '(') level++
+    if (char === ')') level--
+
+    // If we aren't active, we don't want to mutate the result.
+    if (!active) continue
+
+    // If level === 0, we are at the definition level.
+    if (level === 0) {
+      if (char === ' ' && ['event', 'function', ''].includes(result))
+        result = ''
+      else {
+        result += char
+
+        // If we are at the end of the definition, we must be finished.
+        if (char === ')') {
+          valid = true
+          break
+        }
+      }
+
+      continue
+    }
+
+    // Ignore spaces
+    if (char === ' ') {
+      // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
+      if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+        current = ''
+        active = false
+      }
+      continue
+    }
+
+    result += char
+    current += char
+  }
+
+  if (!valid) throw new BaseError('Unable to normalize signature.')
+
+  return result
+}

package/utils/signature/hashMessage.ts

@@ -1,3 +1,4 @@
+import { presignMessagePrefix } from '../../constants/strings.js'
 import type { ErrorType } from '../../errors/utils.js'
 import type { ByteArray, Hex, SignableMessage } from '../../types/misc.js'
 import { type ConcatErrorType, concat } from '../data/concat.js'
@@ -32,7 +33,7 @@ export function hashMessage<TTo extends To = 'hex'>(
     return toBytes(message.raw)
   })()
   const prefixBytes = stringToBytes(
-    `\x19Ethereum Signed Message:\n${messageBytes.length}`,
+    `${presignMessagePrefix}${messageBytes.length}`,
   )
   return keccak256(concat([prefixBytes, messageBytes]), to_)
 }

package/utils/transaction/serializeTransaction.ts

@@ -121,12 +121,15 @@ function serializeTransactionEIP1559(
     serializedAccessList,
   ]
 
-  if (signature)
-    serializedTransaction.push(
-      signature.v === 27n ? '0x' : toHex(1), // yParity
-      trim(signature.r),
-      trim(signature.s),
-    )
+  if (signature) {
+    const yParity = (() => {
+      if (signature.v === 0n) return '0x'
+      if (signature.v === 1n) return toHex(1)
+
+      return signature.v === 27n ? '0x' : toHex(1)
+    })()
+    serializedTransaction.push(yParity, trim(signature.r), trim(signature.s))
+  }
 
   return concatHex([
     '0x02',
@@ -165,12 +168,15 @@ function serializeTransactionEIP2930(
     serializedAccessList,
   ]
 
-  if (signature)
-    serializedTransaction.push(
-      signature.v === 27n ? '0x' : toHex(1), // yParity
-      signature.r,
-      signature.s,
-    )
+  if (signature) {
+    const yParity = (() => {
+      if (signature.v === 0n) return '0x'
+      if (signature.v === 1n) return toHex(1)
+
+      return signature.v === 27n ? '0x' : toHex(1)
+    })()
+    serializedTransaction.push(yParity, trim(signature.r), trim(signature.s))
+  }
 
   return concatHex([
     '0x01',