viem 0.0.0-tsc-and-nodenext-20230405154910 → 0.0.0-w-20230711200108

package/src/clients/decorators/wallet.ts

@@ -1,77 +1,513 @@
 import type { Abi, TypedData } from 'abitype'
-import type {
-  AddChainParameters,
-  DeployContractParameters,
-  DeployContractReturnType,
-  GetAddressesReturnType,
-  GetChainIdReturnType,
-  GetPermissionsReturnType,
-  RequestAddressesReturnType,
-  RequestPermissionsParameters,
-  RequestPermissionsReturnType,
-  SendTransactionParameters,
-  SendTransactionReturnType,
-  SignMessageParameters,
-  SignMessageReturnType,
-  SignTypedDataParameters,
-  SignTypedDataReturnType,
-  SwitchChainParameters,
-  WatchAssetParameters,
-  WatchAssetReturnType,
-  WriteContractParameters,
-  WriteContractReturnType,
-} from '../../actions/wallet/index.js'
+
+import type { Account } from '../../accounts/types.js'
+import {
+  type GetChainIdReturnType,
+  getChainId,
+} from '../../actions/public/getChainId.js'
 import {
+  type AddChainParameters,
   addChain,
+} from '../../actions/wallet/addChain.js'
+import {
+  type DeployContractParameters,
+  type DeployContractReturnType,
   deployContract,
+} from '../../actions/wallet/deployContract.js'
+import {
+  type GetAddressesReturnType,
   getAddresses,
-  getChainId,
+} from '../../actions/wallet/getAddresses.js'
+import {
+  type GetPermissionsReturnType,
   getPermissions,
+} from '../../actions/wallet/getPermissions.js'
+import {
+  type RequestAddressesReturnType,
   requestAddresses,
+} from '../../actions/wallet/requestAddresses.js'
+import {
+  type RequestPermissionsParameters,
+  type RequestPermissionsReturnType,
   requestPermissions,
+} from '../../actions/wallet/requestPermissions.js'
+import {
+  type SendTransactionParameters,
+  type SendTransactionReturnType,
   sendTransaction,
+} from '../../actions/wallet/sendTransaction.js'
+import {
+  type SignMessageParameters,
+  type SignMessageReturnType,
   signMessage,
+} from '../../actions/wallet/signMessage.js'
+import {
+  type SignTypedDataParameters,
+  type SignTypedDataReturnType,
   signTypedData,
+} from '../../actions/wallet/signTypedData.js'
+import {
+  type SwitchChainParameters,
   switchChain,
+} from '../../actions/wallet/switchChain.js'
+import {
+  type WatchAssetParameters,
+  type WatchAssetReturnType,
   watchAsset,
+} from '../../actions/wallet/watchAsset.js'
+import {
+  type WriteContractParameters,
+  type WriteContractReturnType,
   writeContract,
-} from '../../actions/wallet/index.js'
-import type { Account, Chain } from '../../types/index.js'
-import type { WalletClient } from '../createWalletClient.js'
-import type { Transport } from '../transports/index.js'
+} from '../../actions/wallet/writeContract.js'
+import type { Chain } from '../../types/chain.js'
+import type { Client } from '../createClient.js'
+import type { Transport } from '../transports/createTransport.js'
 
 export type WalletActions<
   TChain extends Chain | undefined = Chain | undefined,
   TAccount extends Account | undefined = Account | undefined,
 > = {
+  /**
+   * Adds an EVM chain to the wallet.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/addChain.html
+   * - JSON-RPC Methods: [`eth_addEthereumChain`](https://eips.ethereum.org/EIPS/eip-3085)
+   *
+   * @param args - {@link AddChainParameters}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { optimism } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   transport: custom(window.ethereum),
+   * })
+   * await client.addChain({ chain: optimism })
+   */
   addChain: (args: AddChainParameters) => Promise<void>
+  /**
+   * Deploys a contract to the network, given bytecode and constructor arguments.
+   *
+   * - Docs: https://viem.sh/docs/contract/deployContract.html
+   * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/deploying-contracts
+   *
+   * @param args - {@link DeployContractParameters}
+   * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash. {@link DeployContractReturnType}
+   *
+   * @example
+   * import { createWalletClient, http } from 'viem'
+   * import { privateKeyToAccount } from 'viem/accounts'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   account: privateKeyToAccount('0x…'),
+   *   chain: mainnet,
+   *   transport: http(),
+   * })
+   * const hash = await client.deployContract({
+   *   abi: [],
+   *   account: '0x…,
+   *   bytecode: '0x608060405260405161083e38038061083e833981016040819052610...',
+   * })
+   */
   deployContract: <
     TAbi extends Abi | readonly unknown[],
     TChainOverride extends Chain | undefined,
   >(
     args: DeployContractParameters<TAbi, TChain, TAccount, TChainOverride>,
   ) => Promise<DeployContractReturnType>
+  /**
+   * Returns a list of account addresses owned by the wallet or client.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/getAddresses.html
+   * - JSON-RPC Methods: [`eth_accounts`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_accounts)
+   *
+   * @returns List of account addresses owned by the wallet or client. {@link GetAddressesReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const accounts = await client.getAddresses()
+   */
   getAddresses: () => Promise<GetAddressesReturnType>
+  /**
+   * Returns the chain ID associated with the current network.
+   *
+   * - Docs: https://viem.sh/docs/actions/public/getChainId.html
+   * - JSON-RPC Methods: [`eth_chainId`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_chainid)
+   *
+   * @returns The current chain ID. {@link GetChainIdReturnType}
+   *
+   * @example
+   * import { createWalletClient, http } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const chainId = await client.getChainId()
+   * // 1
+   */
   getChainId: () => Promise<GetChainIdReturnType>
+  /**
+   * Gets the wallets current permissions.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/getPermissions.html
+   * - JSON-RPC Methods: [`wallet_getPermissions`](https://eips.ethereum.org/EIPS/eip-2255)
+   *
+   * @returns The wallet permissions. {@link GetPermissionsReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const permissions = await client.getPermissions()
+   */
   getPermissions: () => Promise<GetPermissionsReturnType>
+  /**
+   * Requests a list of accounts managed by a wallet.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/requestAddresses.html
+   * - JSON-RPC Methods: [`eth_requestAccounts`](https://eips.ethereum.org/EIPS/eip-1102)
+   *
+   * Sends a request to the wallet, asking for permission to access the user's accounts. After the user accepts the request, it will return a list of accounts (addresses).
+   *
+   * This API can be useful for dapps that need to access the user's accounts in order to execute transactions or interact with smart contracts.
+   *
+   * @returns List of accounts managed by a wallet {@link RequestAddressesReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const accounts = await client.requestAddresses()
+   */
   requestAddresses: () => Promise<RequestAddressesReturnType>
+  /**
+   * Requests permissions for a wallet.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/requestPermissions.html
+   * - JSON-RPC Methods: [`wallet_requestPermissions`](https://eips.ethereum.org/EIPS/eip-2255)
+   *
+   * @param args - {@link RequestPermissionsParameters}
+   * @returns The wallet permissions. {@link RequestPermissionsReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const permissions = await client.requestPermissions({
+   *   eth_accounts: {}
+   * })
+   */
   requestPermissions: (
     args: RequestPermissionsParameters,
   ) => Promise<RequestPermissionsReturnType>
+  /**
+   * Creates, signs, and sends a new transaction to the network.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/sendTransaction.html
+   * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/transactions/sending-transactions
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`eth_sendTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendtransaction)
+   *   - Local Accounts: [`eth_sendRawTransaction`](https://ethereum.org/en/developers/docs/apis/json-rpc/#eth_sendrawtransaction)
+   *
+   * @param args - {@link SendTransactionParameters}
+   * @returns The [Transaction](https://viem.sh/docs/glossary/terms.html#transaction) hash. {@link SendTransactionReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const hash = await client.sendTransaction({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: 1000000000000000000n,
+   * })
+   *
+   * @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: http(),
+   * })
+   * const hash = await client.sendTransaction({
+   *   to: '0x70997970c51812dc3a010c7d01b50e0d17dc79c8',
+   *   value: 1000000000000000000n,
+   * })
+   */
   sendTransaction: <TChainOverride extends Chain | undefined>(
     args: SendTransactionParameters<TChain, TAccount, TChainOverride>,
   ) => Promise<SendTransactionReturnType>
+  /**
+   * Calculates an Ethereum-specific signature in [EIP-191 format](https://eips.ethereum.org/EIPS/eip-191): `keccak256("\x19Ethereum Signed Message:\n" + len(message) + message))`.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/signMessage.html
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`personal_sign`](https://docs.metamask.io/guide/signing-data.html#personal-sign)
+   *   - Local Accounts: Signs locally. No JSON-RPC request.
+   *
+   * With the calculated signature, you can:
+   * - use [`verifyMessage`](https://viem.sh/docs/utilities/verifyMessage.html) to verify the signature,
+   * - use [`recoverMessageAddress`](https://viem.sh/docs/utilities/recoverMessageAddress.html) to recover the signing address from a signature.
+   *
+   * @param args - {@link SignMessageParameters}
+   * @returns The signed message. {@link SignMessageReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const signature = await client.signMessage({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   message: 'hello world',
+   * })
+   *
+   * @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: http(),
+   * })
+   * const signature = await client.signMessage({
+   *   message: 'hello world',
+   * })
+   */
   signMessage: (
     args: SignMessageParameters<TAccount>,
   ) => Promise<SignMessageReturnType>
+  /**
+   * 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))`.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/signTypedData.html
+   * - JSON-RPC Methods:
+   *   - JSON-RPC Accounts: [`eth_signTypedData_v4`](https://docs.metamask.io/guide/signing-data.html#signtypeddata-v4)
+   *   - Local Accounts: Signs locally. No JSON-RPC request.
+   *
+   * @param client - Client to use
+   * @param args - {@link SignTypedDataParameters}
+   * @returns The signed data. {@link SignTypedDataReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const signature = await client.signTypedData({
+   *   account: '0xA0Cf798816D4b9b9866b5330EEa46a18382f251e',
+   *   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!',
+   *   },
+   * })
+   *
+   * @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: http(),
+   * })
+   * const signature = await client.signTypedData({
+   *   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!',
+   *   },
+   * })
+   */
   signTypedData: <
     TTypedData extends TypedData | { [key: string]: unknown },
     TPrimaryType extends string,
   >(
     args: SignTypedDataParameters<TTypedData, TPrimaryType, TAccount>,
   ) => Promise<SignTypedDataReturnType>
+  /**
+   * Switch the target chain in a wallet.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/switchChain.html
+   * - JSON-RPC Methods: [`eth_switchEthereumChain`](https://eips.ethereum.org/EIPS/eip-3326)
+   *
+   * @param args - {@link SwitchChainParameters}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet, optimism } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * await client.switchChain({ id: optimism.id })
+   */
   switchChain: (args: SwitchChainParameters) => Promise<void>
+  /**
+   * Adds an EVM chain to the wallet.
+   *
+   * - Docs: https://viem.sh/docs/actions/wallet/watchAsset.html
+   * - JSON-RPC Methods: [`eth_switchEthereumChain`](https://eips.ethereum.org/EIPS/eip-747)
+   *
+   * @param args - {@link WatchAssetParameters}
+   * @returns Boolean indicating if the token was successfully added. {@link WatchAssetReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const success = await client.watchAsset({
+   *   type: 'ERC20',
+   *   options: {
+   *     address: '0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2',
+   *     decimals: 18,
+   *     symbol: 'WETH',
+   *   },
+   * })
+   */
   watchAsset: (args: WatchAssetParameters) => Promise<WatchAssetReturnType>
+  /**
+   * Executes a write function on a contract.
+   *
+   * - Docs: https://viem.sh/docs/contract/writeContract.html
+   * - Examples: https://stackblitz.com/github/wagmi-dev/viem/tree/main/examples/contracts/writing-to-contracts
+   *
+   * A "write" function on a Solidity contract modifies the state of the blockchain. These types of functions require gas to be executed, and hence a [Transaction](https://viem.sh/docs/glossary/terms.html) is needed to be broadcast in order to change the state.
+   *
+   * Internally, uses a [Wallet Client](https://viem.sh/docs/clients/wallet.html) to call the [`sendTransaction` action](https://viem.sh/docs/actions/wallet/sendTransaction.html) with [ABI-encoded `data`](https://viem.sh/docs/contract/encodeFunctionData.html).
+   *
+   * __Warning: The `write` internally sends a transaction – it does not validate if the contract write will succeed (the contract may throw an error). It is highly recommended to [simulate the contract write with `contract.simulate`](https://viem.sh/docs/contract/writeContract.html#usage) before you execute it.__
+   *
+   * @param args - {@link WriteContractParameters}
+   * @returns A [Transaction Hash](https://viem.sh/docs/glossary/terms.html#hash). {@link WriteContractReturnType}
+   *
+   * @example
+   * import { createWalletClient, custom, parseAbi } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const hash = await client.writeContract({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+   *   functionName: 'mint',
+   *   args: [69420],
+   * })
+   *
+   * @example
+   * // With Validation
+   * import { createWalletClient, custom, parseAbi } from 'viem'
+   * import { mainnet } from 'viem/chains'
+   *
+   * const client = createWalletClient({
+   *   chain: mainnet,
+   *   transport: custom(window.ethereum),
+   * })
+   * const { request } = await client.simulateContract({
+   *   address: '0xFBA3912Ca04dd458c843e2EE08967fC04f3579c2',
+   *   abi: parseAbi(['function mint(uint32 tokenId) nonpayable']),
+   *   functionName: 'mint',
+   *   args: [69420],
+   * }
+   * const hash = await client.writeContract(request)
+   */
   writeContract: <
     TAbi extends Abi | readonly unknown[],
     TFunctionName extends string,
@@ -87,30 +523,26 @@ 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),
+    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),
+  }
+}

package/src/clients/transports/createTransport.ts

@@ -1,22 +1,18 @@
-import type { Chain } from '../../types/index.js'
-import type { Requests } from '../../types/eip1193.js'
-import { buildRequest } from '../../utils/index.js'
+import type { Chain } from '../../types/chain.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,
-  Transport,
-  TransportConfig,
+import {
+  type Transport,
+  type TransportConfig,
+  createTransport,
 } from './createTransport.js'
-import { 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.