ox 0.5.0 → 0.6.1

package/core/RpcResponse.ts

@@ -2,6 +2,7 @@ import type { Errors, RpcRequest } from '../index.js'
 import type {
   Compute,
   IsNarrowable,
+  IsNever,
   OneOf,
   UnionPartialBy,
 } from './internal/types.js'
@@ -215,28 +216,7 @@ export function parse<
   const { raw = false } = options
   const response_ = response as RpcResponse
   if (raw) return response as never
-  if (response_.error) {
-    const { code } = response_.error
-    const JsonRpcError = (() => {
-      if (code === InternalError.code) return InternalError
-      if (code === InvalidInputError.code) return InvalidInputError
-      if (code === InvalidParamsError.code) return InvalidParamsError
-      if (code === InvalidRequestError.code) return InvalidRequestError
-      if (code === LimitExceededError.code) return LimitExceededError
-      if (code === MethodNotFoundError.code) return MethodNotFoundError
-      if (code === MethodNotSupportedError.code) return MethodNotSupportedError
-      if (code === ParseError.code) return ParseError
-      if (code === ResourceNotFoundError.code) return ResourceNotFoundError
-      if (code === ResourceUnavailableError.code)
-        return ResourceUnavailableError
-      if (code === TransactionRejectedError.code)
-        return TransactionRejectedError
-      if (code === VersionNotSupportedError.code)
-        return VersionNotSupportedError
-      return BaseError
-    })()
-    throw new JsonRpcError(response_.error)
-  }
+  if (response_.error) throw parseErrorObject(response_.error)
   return response_.result as never
 }
 
@@ -283,6 +263,141 @@ export declare namespace parse {
     | Errors.GlobalErrorType
 }
 
+/**
+ * Parses a JSON-RPC error object into an error instance.
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcResponse } from 'ox'
+ *
+ * const error = RpcResponse.parseError({ code: -32000, message: 'unsupported method' })
+ *
+ * error
+ * // ^?
+ *
+ * ```
+ *
+ * @param errorObject - JSON-RPC error object.
+ * @returns Error instance.
+ */
+export function parseErrorObject<
+  const errorObject extends ErrorObject | unknown,
+>(
+  errorObject: errorObject | ErrorObject,
+): parseErrorObject.ReturnType<errorObject> {
+  const errorObject_ = errorObject as ErrorObject
+  const { code } = errorObject_
+  if (code === InternalError.code)
+    return new InternalError(errorObject_) as never
+  if (code === InvalidInputError.code)
+    return new InvalidInputError(errorObject_) as never
+  if (code === InvalidParamsError.code)
+    return new InvalidParamsError(errorObject_) as never
+  if (code === InvalidRequestError.code)
+    return new InvalidRequestError(errorObject_) as never
+  if (code === LimitExceededError.code)
+    return new LimitExceededError(errorObject_) as never
+  if (code === MethodNotFoundError.code)
+    return new MethodNotFoundError(errorObject_) as never
+  if (code === MethodNotSupportedError.code)
+    return new MethodNotSupportedError(errorObject_) as never
+  if (code === ParseError.code) return new ParseError(errorObject_) as never
+  if (code === ResourceNotFoundError.code)
+    return new ResourceNotFoundError(errorObject_) as never
+  if (code === ResourceUnavailableError.code)
+    return new ResourceUnavailableError(errorObject_) as never
+  if (code === TransactionRejectedError.code)
+    return new TransactionRejectedError(errorObject_) as never
+  if (code === VersionNotSupportedError.code)
+    return new VersionNotSupportedError(errorObject_) as never
+  return new BaseError(errorObject_) as never
+}
+
+export declare namespace parseErrorObject {
+  type ReturnType<
+    errorObject extends ErrorObject | unknown,
+    //
+    error = errorObject extends ErrorObject
+      ?
+          | (errorObject['code'] extends InternalError['code']
+              ? InternalError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? InternalError
+              : never)
+          | (errorObject['code'] extends InvalidInputError['code']
+              ? InvalidInputError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? InvalidInputError
+              : never)
+          | (errorObject['code'] extends ResourceNotFoundError['code']
+              ? ResourceNotFoundError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? ResourceNotFoundError
+              : never)
+          | (errorObject['code'] extends ResourceUnavailableError['code']
+              ? ResourceUnavailableError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? ResourceUnavailableError
+              : never)
+          | (errorObject['code'] extends TransactionRejectedError['code']
+              ? TransactionRejectedError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? TransactionRejectedError
+              : never)
+          | (errorObject['code'] extends ParseError['code']
+              ? ParseError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? ParseError
+              : never)
+          | (errorObject['code'] extends MethodNotSupportedError['code']
+              ? MethodNotSupportedError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? MethodNotSupportedError
+              : never)
+          | (errorObject['code'] extends LimitExceededError['code']
+              ? LimitExceededError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? LimitExceededError
+              : never)
+          | (errorObject['code'] extends VersionNotSupportedError['code']
+              ? VersionNotSupportedError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? VersionNotSupportedError
+              : never)
+          | (errorObject['code'] extends InvalidRequestError['code']
+              ? InvalidRequestError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? InvalidRequestError
+              : never)
+          | (errorObject['code'] extends MethodNotFoundError['code']
+              ? MethodNotFoundError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? MethodNotFoundError
+              : never)
+          | (errorObject['code'] extends InvalidParamsError['code']
+              ? InvalidParamsError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? InvalidParamsError
+              : never)
+          | (IsNarrowable<errorObject['code'], number> extends false
+              ? BaseError
+              : never)
+      : parseErrorObject.ReturnType<ErrorObject>,
+  > = IsNever<error> extends true ? BaseError : error
+}
+
 export type BaseErrorType = BaseError & { name: 'BaseError' }
 
 /** Thrown when a JSON-RPC error has occurred. */

package/core/StateOverrides.ts

@@ -0,0 +1,131 @@
+import type * as Address from './Address.js'
+import * as Hex from './Hex.js'
+import type { Compute, OneOf } from './internal/types.js'
+
+/**
+ * State override set to specify state to be ephemerally overridden prior to executing a call.
+ */
+export type StateOverrides<bigintType = bigint> = Compute<{
+  [address: Address.Address]: AccountOverrides<bigintType>
+}>
+
+/**
+ * RPC state overrides.
+ */
+export type Rpc = StateOverrides<Hex.Hex>
+
+/**
+ * Details of an account to be overridden.
+ */
+export type AccountOverrides<bigintType = bigint> = Compute<
+  {
+    /** Balance to set for the account. */
+    balance?: bigintType | undefined
+    /** Code to set for the account. */
+    code?: Hex.Hex | undefined
+    /** Address to move the precompile to. */
+    movePrecompileToAddress?: Address.Address | undefined
+    /** Nonce to set for the account. */
+    nonce?: bigintType | undefined
+  } & OneOf<
+    | {
+        /** Key-value mapping to override all slots in the account storage. */
+        state?: AccountStorage | undefined
+      }
+    | {
+        /** Key-value mapping to override individual slots in the account storage. */
+        stateDiff?: AccountStorage | undefined
+      }
+  >
+>
+
+/**
+ * RPC account overrides.
+ */
+export type RpcAccountOverrides = AccountOverrides<Hex.Hex>
+
+/**
+ * Key-value mapping to override all slots in the account storage before executing the call.
+ */
+export type AccountStorage = Compute<{
+  [slot: Hex.Hex]: Hex.Hex
+}>
+
+/**
+ * Converts an {@link ox#StateOverrides.Rpc} to an {@link ox#StateOverrides.StateOverrides}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { StateOverrides } from 'ox'
+ *
+ * const stateOverrides = StateOverrides.fromRpc({
+ *   '0x0000000000000000000000000000000000000000': {
+ *     balance: '0x1',
+ *   },
+ * })
+ * ```
+ *
+ * @param rpcStateOverrides - The RPC state overrides to convert.
+ * @returns An instantiated {@link ox#StateOverrides.StateOverrides}.
+ */
+export function fromRpc(rpcStateOverrides: Rpc): StateOverrides {
+  const stateOverrides: StateOverrides = {}
+  for (const [address, accountOverridesRpc] of Object.entries(
+    rpcStateOverrides,
+  )) {
+    const accountOverrides: AccountOverrides = {}
+    if (accountOverridesRpc.balance)
+      accountOverrides.balance = BigInt(accountOverridesRpc.balance)
+    if (accountOverridesRpc.code)
+      accountOverrides.code = accountOverridesRpc.code
+    if (accountOverridesRpc.movePrecompileToAddress)
+      accountOverrides.movePrecompileToAddress =
+        accountOverridesRpc.movePrecompileToAddress
+    if (accountOverridesRpc.nonce)
+      accountOverrides.nonce = BigInt(accountOverridesRpc.nonce)
+    if (accountOverridesRpc.state)
+      accountOverrides.state = accountOverridesRpc.state
+    if (accountOverridesRpc.stateDiff)
+      accountOverrides.stateDiff = accountOverridesRpc.stateDiff
+    ;(stateOverrides as any)[address] = accountOverrides
+  }
+  return stateOverrides
+}
+
+/**
+ * Converts an {@link ox#StateOverrides.StateOverrides} to an {@link ox#StateOverrides.Rpc}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { StateOverrides } from 'ox'
+ *
+ * const stateOverrides = StateOverrides.toRpc({
+ *   '0x0000000000000000000000000000000000000000': {
+ *     balance: 1n,
+ *   },
+ * })
+ * ```
+ *
+ * @param stateOverrides - The state overrides to convert.
+ * @returns An instantiated {@link ox#StateOverrides.Rpc}.
+ */
+export function toRpc(stateOverrides: StateOverrides): Rpc {
+  const rpcStateOverrides: Rpc = {}
+  for (const [address, accountOverrides] of Object.entries(stateOverrides)) {
+    const accountOverridesRpc: RpcAccountOverrides = {}
+    if (typeof accountOverrides.balance === 'bigint')
+      accountOverridesRpc.balance = Hex.fromNumber(accountOverrides.balance)
+    if (accountOverrides.code) accountOverridesRpc.code = accountOverrides.code
+    if (accountOverrides.movePrecompileToAddress)
+      accountOverridesRpc.movePrecompileToAddress =
+        accountOverrides.movePrecompileToAddress
+    if (typeof accountOverrides.nonce === 'bigint')
+      accountOverridesRpc.nonce = Hex.fromNumber(accountOverrides.nonce)
+    if (accountOverrides.state)
+      accountOverridesRpc.state = accountOverrides.state
+    if (accountOverrides.stateDiff)
+      accountOverridesRpc.stateDiff = accountOverrides.stateDiff
+    ;(rpcStateOverrides as any)[address] = accountOverridesRpc
+  }
+  return rpcStateOverrides
+}

package/core/internal/rpcSchemas/eth.ts

@@ -1,11 +1,13 @@
 import type * as AccountProof from '../../AccountProof.js'
 import type * as Address from '../../Address.js'
 import type * as Block from '../../Block.js'
+import type * as BlockOverrides from '../../BlockOverrides.js'
 import type * as Fee from '../../Fee.js'
 import type * as Filter from '../../Filter.js'
 import type * as Hex from '../../Hex.js'
 import type * as Log from '../../Log.js'
 import type * as RpcSchema from '../../RpcSchema.js'
+import type * as StateOverrides from '../../StateOverrides.js'
 import type * as Transaction from '../../Transaction.js'
 import type * as TransactionReceipt from '../../TransactionReceipt.js'
 import type * as TransactionRequest from '../../TransactionRequest.js'
@@ -111,8 +113,7 @@ export type Eth = RpcSchema.From<
                 | Block.Tag
                 | Block.Hash
                 | Block.Identifier,
-              // TODO: add type
-              stateOverride: unknown,
+              stateOverrides: StateOverrides.Rpc,
             ]
       }
       ReturnType: Hex.Hex
@@ -181,8 +182,7 @@ export type Eth = RpcSchema.From<
                 | Block.Tag
                 | Block.Hash
                 | Block.Identifier,
-              // TODO: add type
-              stateOverride: unknown,
+              stateOverrides: StateOverrides.Rpc,
             ]
       }
       ReturnType: Hex.Hex
@@ -707,6 +707,45 @@ export type Eth = RpcSchema.From<
       }
       ReturnType: Hex.Hex
     }
+  | {
+      Request: {
+        method: 'eth_simulateV1'
+        params: [
+          {
+            blockStateCalls: readonly {
+              blockOverrides?: BlockOverrides.Rpc | undefined
+              calls?: readonly TransactionRequest.Rpc[] | undefined
+              stateOverrides?: StateOverrides.Rpc | undefined
+            }[]
+            returnFullTransactions?: boolean | undefined
+            traceTransfers?: boolean | undefined
+            validation?: boolean | undefined
+          },
+          block:
+            | Block.Number<Hex.Hex>
+            | Block.Tag
+            | Block.Hash
+            | Block.Identifier,
+        ]
+      }
+      ReturnType: readonly (Block.Rpc & {
+        calls?:
+          | readonly {
+              error?:
+                | {
+                    data?: Hex.Hex | undefined
+                    code: number
+                    message: string
+                  }
+                | undefined
+              logs?: readonly Log.Rpc[] | undefined
+              gasUsed: Hex.Hex
+              returnData: Hex.Hex
+              status: Hex.Hex
+            }[]
+          | undefined
+      })[]
+    }
   /**
    * Signs a transaction that can be submitted to the network at a later time using with `eth_sendRawTransaction`
    *

package/erc4337/RpcSchema.ts

@@ -1,6 +1,7 @@
 import type * as Address from '../core/Address.js'
 import type * as Hex from '../core/Hex.js'
 import type * as RpcSchema from '../core/RpcSchema.js'
+import type * as StateOverrides from '../core/StateOverrides.js'
 import type * as EntryPoint from './EntryPoint.js'
 import type * as UserOperation from './UserOperation.js'
 import type * as UserOperationGas from './UserOperationGas.js'
@@ -49,8 +50,7 @@ export type Bundler<
           | [
               userOperation: UserOperation.Rpc<entryPointVersion>,
               entrypoint: Address.Address,
-              /** TODO: Add type. */
-              stateOverrides: unknown,
+              stateOverrides: StateOverrides.Rpc,
             ]
       }
       ReturnType: UserOperationGas.Rpc<entryPointVersion>

package/index.ts

@@ -986,6 +986,13 @@ export * as Blobs from './core/Blobs.js'
  */
 export * as Block from './core/Block.js'
 
+/**
+ * Utilities & types for working with **Block Overrides**.
+ *
+ * @category Execution Spec
+ */
+export * as BlockOverrides from './core/BlockOverrides.js'
+
 /**
  * Utility functions for working with Bloom Filters as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/block.yaml)
  *
@@ -2275,6 +2282,13 @@ export * as Siwe from './core/Siwe.js'
 
 export * as Solidity from './core/Solidity.js'
 
+/**
+ * Utilities & types for working with **State Overrides**.
+ *
+ * @category Execution Spec
+ */
+export * as StateOverrides from './core/StateOverrides.js'
+
 /**
  * Utilities & types for working with **Transactions** as defined in the [Execution API specification](https://github.com/ethereum/execution-apis/blob/main/src/schemas/transaction.yaml)
  *

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "ox",
   "description": "Ethereum Standard Library",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "main": "./_cjs/index.js",
   "module": "./_esm/index.js",
   "types": "./_types/index.d.ts",
@@ -132,6 +132,11 @@
       "import": "./_esm/core/Block.js",
       "default": "./_cjs/core/Block.js"
     },
+    "./BlockOverrides": {
+      "types": "./_types/core/BlockOverrides.d.ts",
+      "import": "./_esm/core/BlockOverrides.js",
+      "default": "./_cjs/core/BlockOverrides.js"
+    },
     "./Bloom": {
       "types": "./_types/core/Bloom.d.ts",
       "import": "./_esm/core/Bloom.js",
@@ -282,6 +287,11 @@
       "import": "./_esm/core/Solidity.js",
       "default": "./_cjs/core/Solidity.js"
     },
+    "./StateOverrides": {
+      "types": "./_types/core/StateOverrides.d.ts",
+      "import": "./_esm/core/StateOverrides.js",
+      "default": "./_cjs/core/StateOverrides.js"
+    },
     "./Transaction": {
       "types": "./_types/core/Transaction.d.ts",
       "import": "./_esm/core/Transaction.js",

package/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '0.5.0'
+export const version = '0.6.1'