viem 0.0.0-portable-types-20230523145621 → 0.0.0-refactor-generics-20230831161903

package/src/clients/decorators/test.ts

@@ -84,9 +84,11 @@ import {
   type StopImpersonatingAccountParameters,
   stopImpersonatingAccount,
 } from '../../actions/test/stopImpersonatingAccount.js'
+import type { Account } from '../../types/account.js'
 import type { Chain } from '../../types/chain.js'
 import type { Quantity } from '../../types/rpc.js'
-import type { TestClient, TestClientMode } from '../createTestClient.js'
+import type { Client } from '../createClient.js'
+import type { TestClientMode } from '../createTestClient.js'
 import type { Transport } from '../transports/createTransport.js'
 
 export type TestActions = {
@@ -328,8 +330,8 @@ export type TestActions = {
    *   value: 1000000000000000000n,
    * })
    */
-  sendUnsignedTransaction: (
-    args: SendUnsignedTransactionParameters,
+  sendUnsignedTransaction: <TChain extends Chain | undefined>(
+    args: SendUnsignedTransactionParameters<TChain>,
   ) => Promise<SendUnsignedTransactionReturnType>
   /**
    * Enables or disables the automatic mining of new blocks with each new transaction submitted to the network.
@@ -666,39 +668,58 @@ export type TestActions = {
   ) => Promise<void>
 }
 
-export function testActions<TChain extends Chain | undefined>(
-  client: TestClient<TestClientMode, Transport, TChain>,
-): TestActions {
-  return {
-    dropTransaction: (args) => dropTransaction(client, args),
-    getAutomine: () => getAutomine(client),
-    getTxpoolContent: () => getTxpoolContent(client),
-    getTxpoolStatus: () => getTxpoolStatus(client),
-    impersonateAccount: (args) => impersonateAccount(client, args),
-    increaseTime: (args) => increaseTime(client, args),
-    inspectTxpool: () => inspectTxpool(client),
-    mine: (args) => mine(client, args),
-    removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
-    reset: (args) => reset(client, args),
-    revert: (args) => revert(client, args),
-    sendUnsignedTransaction: (args) => sendUnsignedTransaction(client, args),
-    setAutomine: (args) => setAutomine(client, args),
-    setBalance: (args) => setBalance(client, args),
-    setBlockGasLimit: (args) => setBlockGasLimit(client, args),
-    setBlockTimestampInterval: (args) =>
-      setBlockTimestampInterval(client, args),
-    setCode: (args) => setCode(client, args),
-    setCoinbase: (args) => setCoinbase(client, args),
-    setIntervalMining: (args) => setIntervalMining(client, args),
-    setLoggingEnabled: (args) => setLoggingEnabled(client, args),
-    setMinGasPrice: (args) => setMinGasPrice(client, args),
-    setNextBlockBaseFeePerGas: (args) =>
-      setNextBlockBaseFeePerGas(client, args),
-    setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
-    setNonce: (args) => setNonce(client, args),
-    setRpcUrl: (args) => setRpcUrl(client, args),
-    setStorageAt: (args) => setStorageAt(client, args),
-    snapshot: () => snapshot(client),
-    stopImpersonatingAccount: (args) => stopImpersonatingAccount(client, args),
+export function testActions<TMode extends TestClientMode>({
+  mode,
+}: { mode: TMode }): <
+  TTransport extends Transport = Transport,
+  TChain extends Chain | undefined = Chain | undefined,
+  TAccount extends Account | undefined = Account | undefined,
+>(
+  client: Client<TTransport, TChain, TAccount>,
+) => TestActions {
+  return <
+    TTransport extends Transport = Transport,
+    TChain extends Chain | undefined = Chain | undefined,
+    TAccount extends Account | undefined = Account | undefined,
+  >(
+    client_: Client<TTransport, TChain, TAccount>,
+  ): TestActions => {
+    const client = client_.extend(() => ({
+      mode,
+    }))
+    return {
+      dropTransaction: (args) => dropTransaction(client, args),
+      getAutomine: () => getAutomine(client),
+      getTxpoolContent: () => getTxpoolContent(client),
+      getTxpoolStatus: () => getTxpoolStatus(client),
+      impersonateAccount: (args) => impersonateAccount(client, args),
+      increaseTime: (args) => increaseTime(client, args),
+      inspectTxpool: () => inspectTxpool(client),
+      mine: (args) => mine(client, args),
+      removeBlockTimestampInterval: () => removeBlockTimestampInterval(client),
+      reset: (args) => reset(client, args),
+      revert: (args) => revert(client, args),
+      sendUnsignedTransaction: (args) =>
+        sendUnsignedTransaction(client, args as any),
+      setAutomine: (args) => setAutomine(client, args),
+      setBalance: (args) => setBalance(client, args),
+      setBlockGasLimit: (args) => setBlockGasLimit(client, args),
+      setBlockTimestampInterval: (args) =>
+        setBlockTimestampInterval(client, args),
+      setCode: (args) => setCode(client, args),
+      setCoinbase: (args) => setCoinbase(client, args),
+      setIntervalMining: (args) => setIntervalMining(client, args),
+      setLoggingEnabled: (args) => setLoggingEnabled(client, args),
+      setMinGasPrice: (args) => setMinGasPrice(client, args),
+      setNextBlockBaseFeePerGas: (args) =>
+        setNextBlockBaseFeePerGas(client, args),
+      setNextBlockTimestamp: (args) => setNextBlockTimestamp(client, args),
+      setNonce: (args) => setNonce(client, args),
+      setRpcUrl: (args) => setRpcUrl(client, args),
+      setStorageAt: (args) => setStorageAt(client, args),
+      snapshot: () => snapshot(client),
+      stopImpersonatingAccount: (args) =>
+        stopImpersonatingAccount(client, args),
+    }
   }
 }

package/src/clients/decorators/wallet.ts

@@ -22,6 +22,11 @@ import {
   type GetPermissionsReturnType,
   getPermissions,
 } from '../../actions/wallet/getPermissions.js'
+import {
+  type PrepareTransactionRequestParameters,
+  type PrepareTransactionRequestReturnType,
+  prepareTransactionRequest,
+} from '../../actions/wallet/prepareTransactionRequest.js'
 import {
   type RequestAddressesReturnType,
   requestAddresses,
@@ -31,6 +36,11 @@ import {
   type RequestPermissionsReturnType,
   requestPermissions,
 } from '../../actions/wallet/requestPermissions.js'
+import {
+  type SendRawTransactionParameters,
+  type SendRawTransactionReturnType,
+  sendRawTransaction,
+} from '../../actions/wallet/sendRawTransaction.js'
 import {
   type SendTransactionParameters,
   type SendTransactionReturnType,
@@ -41,6 +51,11 @@ import {
   type SignMessageReturnType,
   signMessage,
 } from '../../actions/wallet/signMessage.js'
+import {
+  type SignTransactionParameters,
+  type SignTransactionReturnType,
+  signTransaction,
+} from '../../actions/wallet/signTransaction.js'
 import {
   type SignTypedDataParameters,
   type SignTypedDataReturnType,
@@ -61,7 +76,7 @@ import {
   writeContract,
 } from '../../actions/wallet/writeContract.js'
 import type { Chain } from '../../types/chain.js'
-import type { WalletClient } from '../createWalletClient.js'
+import type { Client } from '../createClient.js'
 import type { Transport } from '../transports/createTransport.js'
 
 export type WalletActions<
@@ -112,7 +127,7 @@ export type WalletActions<
    * })
    */
   deployContract: <
-    TAbi extends Abi | readonly unknown[],
+    const TAbi extends Abi | readonly unknown[],
     TChainOverride extends Chain | undefined,
   >(
     args: DeployContractParameters<TAbi, TChain, TAccount, TChainOverride>,
@@ -175,6 +190,47 @@ export type WalletActions<
    * const permissions = await client.getPermissions()
    */
   getPermissions: () => Promise<GetPermissionsReturnType>
+  /**
+   * Prepares a transaction request for signing.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/prepareTransactionRequest.html
+   *
+   * @param args - {@link PrepareTransactionRequestParameters}
+   * @returns The transaction request. {@link PrepareTransactionRequestReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   */
+  prepareTransactionRequest: <TChainOverride extends Chain | undefined,>(
+    args: PrepareTransactionRequestParameters<TChain, TAccount, TChainOverride>,
+  ) => Promise<PrepareTransactionRequestReturnType>
   /**
    * Requests a list of accounts managed by a wallet.
    *
@@ -222,6 +278,33 @@ export type WalletActions<
   requestPermissions: (
     args: RequestPermissionsParameters,
   ) => Promise<RequestPermissionsReturnType>
+  /**
+   * Sends a **signed** transaction to the network
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/sendRawTransaction.html
+   * - JSON-RPC Method: [`eth_sendRawTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+   *
+   * @param client - Client to use
+   * @param parameters - {@link SendRawTransactionParameters}
+   * @returns The transaction hash. {@link SendRawTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   * import { sendRawTransaction } from 'viem/wallet'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   *
+   * const hash = await client.sendRawTransaction({
+   *   serializedTransaction: '0x02f850018203118080825208808080c080a04012522854168b27e5dc3d5839bab5e6b39e1a0ffd343901ce1622e3d64b48f1a04e00902ae0502c4728cbf12156290df99c3ed7de85b1dbfe20b5c36931733a33'
+   * })
+   */
+  sendRawTransaction: (
+    args: SendRawTransactionParameters,
+  ) => Promise<SendRawTransactionReturnType>
   /**
    * Creates, signs, and sends a new transaction to the network.
    *
@@ -313,6 +396,52 @@ export type WalletActions<
   signMessage: (
     args: SignMessageParameters<TAccount>,
   ) => Promise<SignMessageReturnType>
+  /**
+   * Signs a transaction.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/signTransaction.html
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`eth_signTransaction`](https://ethereum.github.io/execution-apis/api-documentation/)
+   *   - Local Accounts: Signs locally. No JSON-RPC request.
+   *
+   * @param args - {@link SignTransactionParameters}
+   * @returns The signed message. {@link SignTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   * const signature = await client.signTransaction(request)
+   *
+   * @example
+   * // Account Hoisting
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const request = await client.prepareTransactionRequest({
+   *   to: '0x0000000000000000000000000000000000000000',
+   *   value: 1n,
+   * })
+   * const signature = await client.signTransaction(request)
+   */
+  signTransaction: <TChainOverride extends Chain | undefined,>(
+    args: SignTransactionParameters<TChain, TAccount, TChainOverride>,
+  ) => Promise<SignTransactionReturnType>
   /**
    * Signs typed data and calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
    *
@@ -410,7 +539,7 @@ export type WalletActions<
    * })
    */
   signTypedData: <
-    TTypedData extends TypedData | { [key: string]: unknown },
+    const TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string,
   >(
     args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>,
@@ -509,7 +638,7 @@ export type WalletActions<
    * const hash = await client.writeContract(request)
    */
   writeContract: <
-    TAbi extends Abi | readonly unknown[],
+    const TAbi extends Abi | readonly unknown[],
     TFunctionName extends string,
     TChainOverride extends Chain | undefined,
   >(
@@ -523,30 +652,30 @@ export type WalletActions<
   ) => Promise<WriteContractReturnType>
 }
 
-export const walletActions: <
+export function walletActions<
   TTransport extends Transport,
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
 >(
-  client: WalletClient<TTransport, TChain, TAccount>,
-) => WalletActions<TChain, TAccount> = <
-  TTransport extends Transport,
-  TChain extends Chain | undefined = Chain | undefined,
-  TAccount extends Account | undefined = Account | undefined,
->(
-  client: WalletClient<TTransport, TChain, TAccount>,
-): WalletActions<TChain, TAccount> => ({
-  addChain: (args) => addChain(client, args),
-  deployContract: (args) => deployContract(client, args),
-  getAddresses: () => getAddresses(client),
-  getChainId: () => getChainId(client),
-  getPermissions: () => getPermissions(client),
-  requestAddresses: () => requestAddresses(client),
-  requestPermissions: (args) => requestPermissions(client, args),
-  sendTransaction: (args) => sendTransaction(client, args),
-  signMessage: (args) => signMessage(client, args),
-  signTypedData: (args) => signTypedData(client, args),
-  switchChain: (args) => switchChain(client, args),
-  watchAsset: (args) => watchAsset(client, args),
-  writeContract: (args) => writeContract(client, args),
-})
+  client: Client<TTransport, TChain, TAccount>,
+): WalletActions<TChain, TAccount> {
+  return {
+    addChain: (args) => addChain(client, args),
+    deployContract: (args) => deployContract(client, args),
+    getAddresses: () => getAddresses(client),
+    getChainId: () => getChainId(client),
+    getPermissions: () => getPermissions(client),
+    prepareTransactionRequest: (args) =>
+      prepareTransactionRequest(client as any, args as any),
+    requestAddresses: () => requestAddresses(client),
+    requestPermissions: (args) => requestPermissions(client, args),
+    sendRawTransaction: (args) => sendRawTransaction(client, args),
+    sendTransaction: (args) => sendTransaction(client, args),
+    signMessage: (args) => signMessage(client, args),
+    signTransaction: (args) => signTransaction(client, args),
+    signTypedData: (args) => signTypedData(client, args),
+    switchChain: (args) => switchChain(client, args),
+    watchAsset: (args) => watchAsset(client, args),
+    writeContract: (args) => writeContract(client, args),
+  }
+}

package/src/clients/transports/createTransport.ts

@@ -1,22 +1,18 @@
 import type { Chain } from '../../types/chain.js'
-import type { Requests } from '../../types/eip1193.js'
+import type { EIP1193RequestFn } from '../../types/eip1193.js'
 import { buildRequest } from '../../utils/buildRequest.js'
 import type { ClientConfig } from '../createClient.js'
 
-export type BaseRpcRequests = {
-  request(...args: any): Promise<any>
-}
-
 export type TransportConfig<
   TType extends string = string,
-  TRequests extends BaseRpcRequests['request'] = Requests['request'],
+  TEIP1193RequestFn extends EIP1193RequestFn = EIP1193RequestFn,
 > = {
   /** The name of the transport. */
   name: string
   /** The key of the transport. */
   key: string
   /** The JSON-RPC request function that matches the EIP-1193 request spec. */
-  request: TRequests
+  request: TEIP1193RequestFn
   /** The base delay (in ms) between retries. */
   retryDelay?: number
   /** The max number of times to retry. */
@@ -30,7 +26,7 @@ export type TransportConfig<
 export type Transport<
   TType extends string = string,
   TRpcAttributes = Record<string, any>,
-  TRequests extends BaseRpcRequests['request'] = Requests['request'],
+  TEIP1193RequestFn extends EIP1193RequestFn = EIP1193RequestFn,
 > = <TChain extends Chain | undefined = Chain>({
   chain,
 }: {
@@ -40,7 +36,7 @@ export type Transport<
   timeout?: TransportConfig['timeout']
 }) => {
   config: TransportConfig<TType>
-  request: TRequests
+  request: TEIP1193RequestFn
   value?: TRpcAttributes
 }
 

package/src/clients/transports/custom.ts

@@ -1,11 +1,10 @@
 import {
-  type BaseRpcRequests,
   type Transport,
   type TransportConfig,
   createTransport,
 } from './createTransport.js'
 
-type EthereumProvider = { request: BaseRpcRequests['request'] }
+type EthereumProvider = { request(...args: any): Promise<any> }
 
 export type CustomTransportConfig = {
   /** The key of the transport. */
@@ -18,7 +17,11 @@ export type CustomTransportConfig = {
   retryDelay?: TransportConfig['retryDelay']
 }
 
-export type CustomTransport = Transport<'custom', EthereumProvider['request']>
+export type CustomTransport = Transport<
+  'custom',
+  {},
+  EthereumProvider['request']
+>
 
 /**
  * @description Creates a custom transport given an EIP-1193 compliant `request` attribute.

package/src/clients/transports/fallback.ts

@@ -102,7 +102,7 @@ export function fallback(
         key,
         name,
         async request({ method, params }) {
-          const fetch = async (i: number = 0): Promise<any> => {
+          const fetch = async (i = 0): Promise<any> => {
             const transport = transports[i]({ chain, retryCount: 0, timeout })
             try {
               const response = await transport.request({

package/src/clients/transports/http.ts

@@ -1,5 +1,7 @@
+import { RpcRequestError } from '../../errors/request.js'
 import { UrlRequiredError } from '../../errors/transport.js'
-import { type HttpOptions, rpc } from '../../utils/rpc.js'
+import { createBatchScheduler } from '../../utils/promise/createBatchScheduler.js'
+import { type HttpOptions, type RpcRequest, rpc } from '../../utils/rpc.js'
 
 import {
   type Transport,
@@ -7,7 +9,19 @@ import {
   createTransport,
 } from './createTransport.js'
 
+export type BatchOptions = {
+  /** The maximum number of JSON-RPC requests to send in a batch. @default 1_000 */
+  batchSize?: number
+  /** The maximum number of milliseconds to wait before sending a batch. @default 0 */
+  wait?: number
+}
+
 export type HttpTransportConfig = {
+  /**
+   * Whether to enable Batch JSON-RPC.
+   * @link https://www.jsonrpc.org/specification#batch
+   */
+  batch?: boolean | BatchOptions
   /**
    * Request configuration to pass to `fetch`.
    * @link https://developer.mozilla.org/en-US/docs/Web/API/fetch
@@ -41,12 +55,15 @@ export function http(
   config: HttpTransportConfig = {},
 ): HttpTransport {
   const {
+    batch,
     fetchOptions,
     key = 'http',
     name = 'HTTP JSON-RPC',
     retryDelay,
   } = config
   return ({ chain, retryCount: retryCount_, timeout: timeout_ }) => {
+    const { batchSize = 1000, wait = 0 } =
+      typeof batch === 'object' ? batch : {}
     const retryCount = config.retryCount ?? retryCount_
     const timeout = timeout_ ?? config.timeout ?? 10_000
     const url_ = url || chain?.rpcUrls.default.http[0]
@@ -56,14 +73,34 @@ export function http(
         key,
         name,
         async request({ method, params }) {
-          const { result } = await rpc.http(url_, {
-            body: {
-              method,
-              params,
+          const body = { method, params }
+
+          const { schedule } = createBatchScheduler({
+            id: `${url}`,
+            wait,
+            shouldSplitBatch(requests) {
+              return requests.length > batchSize
             },
-            fetchOptions,
-            timeout,
+            fn: (body: RpcRequest[]) =>
+              rpc.http(url_, {
+                body,
+                fetchOptions,
+                timeout,
+              }),
           })
+
+          const fn = async (body: RpcRequest) =>
+            batch
+              ? schedule(body)
+              : [await rpc.http(url_, { body, fetchOptions, timeout })]
+
+          const [{ error, result }] = await fn(body)
+          if (error)
+            throw new RpcRequestError({
+              body,
+              error,
+              url: url_,
+            })
           return result
         },
         retryCount,

package/src/clients/transports/webSocket.ts

@@ -1,9 +1,9 @@
 import type { WebSocket } from 'isomorphic-ws'
 
+import { RpcRequestError } from '../../errors/request.js'
 import { UrlRequiredError } from '../../errors/transport.js'
 import type { Hash } from '../../types/misc.js'
 import { type RpcResponse, getSocket, rpc } from '../../utils/rpc.js'
-
 import {
   type Transport,
   type TransportConfig,
@@ -72,11 +72,18 @@ export function webSocket(
         key,
         name,
         async request({ method, params }) {
+          const body = { method, params }
           const socket = await getSocket(url_)
-          const { result } = await rpc.webSocketAsync(socket, {
-            body: { method, params },
+          const { error, result } = await rpc.webSocketAsync(socket, {
+            body,
             timeout,
           })
+          if (error)
+            throw new RpcRequestError({
+              body,
+              error,
+              url: url_,
+            })
           return result
         },
         retryCount,
@@ -97,31 +104,32 @@ export function webSocket(
                   method: 'eth_subscribe',
                   params,
                 },
-                onData: (data) => {
-                  if (typeof data.id === 'number') {
-                    resolve(data)
+                onResponse(response) {
+                  if (response.error) {
+                    reject(response.error)
+                    onError?.(response.error)
                     return
                   }
-                  if (data.method !== 'eth_subscription') return
-                  onData(data.params)
-                },
-                onError: (error) => {
-                  reject(error)
-                  onError?.(error)
+
+                  if (typeof response.id === 'number') {
+                    resolve(response)
+                    return
+                  }
+                  if (response.method !== 'eth_subscription') return
+                  onData(response.params)
                 },
               }),
           )
           return {
             subscriptionId,
             async unsubscribe() {
-              return new Promise<any>((resolve, reject) =>
+              return new Promise<any>((resolve) =>
                 rpc.webSocket(socket, {
                   body: {
                     method: 'eth_unsubscribe',
                     params: [subscriptionId],
                   },
-                  onData: resolve,
-                  onError: reject,
+                  onResponse: resolve,
                 }),
               )
             },