viem 0.0.1-alpha.24 → 0.0.1-alpha.26

package/src/chains.ts

@@ -1,99 +0,0 @@
-import * as chains from '@wagmi/chains'
-
-import type { Address, Hex, Quantity } from './types'
-import {
-  defineBlock,
-  defineChain,
-  defineTransaction,
-  defineTransactionReceipt,
-  defineTransactionRequest,
-} from './utils'
-
-export type { Chain } from './types'
-export { defineChain } from './utils'
-
-const celoFormatters = {
-  block: defineBlock({
-    exclude: ['difficulty', 'gasLimit', 'mixHash', 'nonce', 'uncles'],
-    format: (block) => ({
-      randomness: block.randomness as {
-        committed: Hex
-        revealed: Hex
-      },
-    }),
-  }),
-  transaction: defineTransaction({
-    format: (transaction) => ({
-      feeCurrency: transaction.feeCurrency as Address | null,
-      gatewayFee: transaction.gatewayFee
-        ? BigInt(transaction.gatewayFee as Quantity)
-        : null,
-      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
-    }),
-  }),
-  transactionReceipt: defineTransactionReceipt({
-    format: (transaction) => ({
-      feeCurrency: transaction.feeCurrency as Address | null,
-      gatewayFee: transaction.gatewayFee
-        ? BigInt(transaction.gatewayFee as Quantity)
-        : null,
-      gatewayFeeRecipient: transaction.gatewayFeeRecipient as Address | null,
-    }),
-  }),
-  transactionRequest: defineTransactionRequest({
-    format: (transactionRequest) => ({
-      feeCurrency: transactionRequest.feeCurrency as Address | undefined,
-      gatewayFee: transactionRequest.gatewayFee as Quantity | undefined,
-      gatewayFeeRecipient: transactionRequest.gatewayFeeRecipient as
-        | Address
-        | undefined,
-    }),
-  }),
-}
-
-export const arbitrum = defineChain(chains.arbitrum)
-export const arbitrumGoerli = defineChain(chains.arbitrumGoerli)
-export const aurora = defineChain(chains.aurora)
-export const auroraGoerli = defineChain(chains.auroraTestnet)
-export const avalanche = defineChain(chains.avalanche)
-export const avalancheFuji = defineChain(chains.avalancheFuji)
-export const bronos = defineChain(chains.bronos)
-export const bronosTestnet = defineChain(chains.bronosTestnet)
-export const bsc = defineChain(chains.bsc)
-export const bscTestnet = defineChain(chains.bscTestnet)
-export const canto = defineChain(chains.canto)
-export const celo = defineChain({
-  ...chains.celo,
-  formatters: celoFormatters,
-})
-export const celoAlfajores = defineChain({
-  ...chains.celoAlfajores,
-  formatters: celoFormatters,
-})
-export const crossbell = defineChain(chains.crossbell)
-export const evmos = defineChain(chains.evmos)
-export const evmosTestnet = defineChain(chains.evmosTestnet)
-export const fantom = defineChain(chains.fantom)
-export const fantomTestnet = defineChain(chains.fantomTestnet)
-export const filecoin = defineChain(chains.filecoin)
-export const filecoinTestnet = defineChain(chains.filecoinHyperspace)
-export const foundry = defineChain(chains.foundry)
-export const goerli = defineChain(chains.goerli)
-export const gnosis = defineChain(chains.gnosis)
-export const gnosisChiado = defineChain(chains.gnosisChiado)
-export const hardhat = defineChain(chains.hardhat)
-export const iotex = defineChain(chains.iotex)
-export const iotexTestnet = defineChain(chains.iotexTestnet)
-export const localhost = defineChain(chains.localhost)
-export const mainnet = defineChain(chains.mainnet)
-export const metis = defineChain(chains.metis)
-export const metisGoerli = defineChain(chains.metisGoerli)
-export const optimism = defineChain(chains.optimism)
-export const optimismGoerli = defineChain(chains.optimismGoerli)
-export const polygon = defineChain(chains.polygon)
-export const polygonMumbai = defineChain(chains.polygonMumbai)
-export const sepolia = defineChain(chains.sepolia)
-export const taraxa = defineChain(chains.taraxa)
-export const taraxaTestnet = defineChain(chains.taraxaTestnet)
-export const zkSync = defineChain(chains.zkSync)
-export const zkSyncTestnet = defineChain(chains.zkSyncTestnet)

package/src/clients/createClient.test.ts

@@ -1,295 +0,0 @@
-import { assertType, describe, expect, test, vi } from 'vitest'
-
-import { localhost } from '../chains'
-import type { Requests } from '../types/eip1193'
-import { localWsUrl } from '../_test'
-import { createClient } from './createClient'
-import { createTransport, custom, http, webSocket } from './transports'
-
-test('creates', () => {
-  const mockTransport = () =>
-    createTransport({
-      key: 'mock',
-      name: 'Mock Transport',
-      request: vi.fn(async () => null) as unknown as Requests['request'],
-      type: 'mock',
-    })
-  const { uid, ...client } = createClient({
-    transport: mockTransport,
-  })
-
-  assertType<Requests['request']>(client.request)
-
-  expect(uid).toBeDefined()
-  expect(client).toMatchInlineSnapshot(`
-    {
-      "chain": undefined,
-      "key": "base",
-      "name": "Base Client",
-      "pollingInterval": 4000,
-      "request": [Function],
-      "transport": {
-        "key": "mock",
-        "name": "Mock Transport",
-        "request": [MockFunction spy],
-        "type": "mock",
-      },
-      "type": "base",
-    }
-  `)
-})
-
-describe('transports', () => {
-  test('http', () => {
-    const { uid, ...client } = createClient({
-      chain: localhost,
-      transport: http(),
-    })
-
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": {
-          "id": 1337,
-          "name": "Localhost",
-          "nativeCurrency": {
-            "decimals": 18,
-            "name": "Ether",
-            "symbol": "ETH",
-          },
-          "network": "localhost",
-          "rpcUrls": {
-            "default": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-            "public": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-          },
-        },
-        "key": "base",
-        "name": "Base Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "http",
-          "name": "HTTP JSON-RPC",
-          "request": [Function],
-          "type": "http",
-          "url": undefined,
-        },
-        "type": "base",
-      }
-    `)
-  })
-
-  test('webSocket', () => {
-    const { uid, ...client } = createClient({
-      chain: localhost,
-      transport: webSocket(localWsUrl),
-    })
-
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": {
-          "id": 1337,
-          "name": "Localhost",
-          "nativeCurrency": {
-            "decimals": 18,
-            "name": "Ether",
-            "symbol": "ETH",
-          },
-          "network": "localhost",
-          "rpcUrls": {
-            "default": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-            "public": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-          },
-        },
-        "key": "base",
-        "name": "Base Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "getSocket": [Function],
-          "key": "webSocket",
-          "name": "WebSocket JSON-RPC",
-          "request": [Function],
-          "subscribe": [Function],
-          "type": "webSocket",
-        },
-        "type": "base",
-      }
-    `)
-  })
-
-  test('custom', () => {
-    const { uid, ...client } = createClient({
-      transport: custom({ request: async () => null }),
-    })
-
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "base",
-        "name": "Base Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "custom",
-          "name": "Custom Provider",
-          "request": [Function],
-          "type": "custom",
-        },
-        "type": "base",
-      }
-    `)
-  })
-})
-
-describe('config', () => {
-  test('key', () => {
-    const mockTransport = () =>
-      createTransport({
-        key: 'mock',
-        name: 'Mock Transport',
-        request: vi.fn(async () => null) as unknown as Requests['request'],
-        type: 'mock',
-      })
-    const { uid, ...client } = createClient({
-      key: 'bar',
-      transport: mockTransport,
-    })
-
-    assertType<Requests['request']>(client.request)
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "bar",
-        "name": "Base Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "mock",
-          "name": "Mock Transport",
-          "request": [MockFunction spy],
-          "type": "mock",
-        },
-        "type": "base",
-      }
-    `)
-  })
-
-  test('name', () => {
-    const mockTransport = () =>
-      createTransport({
-        key: 'mock',
-        name: 'Mock Transport',
-        request: vi.fn(async () => null) as unknown as Requests['request'],
-        type: 'mock',
-      })
-    const { uid, ...client } = createClient({
-      name: 'Mock Client',
-      transport: mockTransport,
-    })
-
-    assertType<Requests['request']>(client.request)
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "base",
-        "name": "Mock Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "mock",
-          "name": "Mock Transport",
-          "request": [MockFunction spy],
-          "type": "mock",
-        },
-        "type": "base",
-      }
-    `)
-  })
-
-  test('pollingInterval', () => {
-    const mockTransport = () =>
-      createTransport({
-        key: 'mock',
-        name: 'Mock Transport',
-        request: vi.fn(async () => null) as unknown as Requests['request'],
-        type: 'mock',
-      })
-    const { uid, ...client } = createClient({
-      pollingInterval: 10_000,
-      transport: mockTransport,
-    })
-
-    assertType<Requests['request']>(client.request)
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "base",
-        "name": "Base Client",
-        "pollingInterval": 10000,
-        "request": [Function],
-        "transport": {
-          "key": "mock",
-          "name": "Mock Transport",
-          "request": [MockFunction spy],
-          "type": "mock",
-        },
-        "type": "base",
-      }
-    `)
-  })
-
-  test('type', () => {
-    const mockTransport = () =>
-      createTransport({
-        key: 'mock',
-        name: 'Mock Transport',
-        request: vi.fn(async () => null) as unknown as Requests['request'],
-        type: 'mock',
-      })
-    const { uid, ...client } = createClient({
-      transport: mockTransport,
-      type: 'foo',
-    })
-
-    assertType<Requests['request']>(client.request)
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "base",
-        "name": "Base Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "mock",
-          "name": "Mock Transport",
-          "request": [MockFunction spy],
-          "type": "mock",
-        },
-        "type": "foo",
-      }
-    `)
-  })
-})

package/src/clients/createClient.ts

@@ -1,81 +0,0 @@
-import { Chain } from '../types'
-import type { Requests } from '../types/eip1193'
-import { buildRequest } from '../utils/buildRequest'
-import { uid } from '../utils/uid'
-import type { BaseRpcRequests, Transport } from './transports/createTransport'
-
-export type Client<
-  TTransport extends Transport = Transport,
-  TChain extends Chain = Chain,
-  TRequests extends BaseRpcRequests = Requests,
-> = {
-  /** Chain for the client. */
-  chain?: TChain
-  /** A key for the client. */
-  key: string
-  /** A name for the client. */
-  name: string
-  /** Frequency (in ms) for polling enabled actions & events. Defaults to 4_000 milliseconds. */
-  pollingInterval: number
-  /** Request function wrapped with friendly error handling */
-  request: TRequests['request']
-  /** The RPC transport (http, webSocket, custom, etc) */
-  transport: ReturnType<TTransport>['config'] & ReturnType<TTransport>['value']
-  /** The type of client. */
-  type: string
-  /** A unique ID for the client. */
-  uid: string
-}
-
-export type ClientConfig<
-  TTransport extends Transport = Transport,
-  TChain extends Chain = Chain,
-  TRequests extends BaseRpcRequests = Requests,
-> = Partial<
-  Pick<
-    Client<TTransport, TChain, TRequests>,
-    'chain' | 'key' | 'name' | 'pollingInterval' | 'type'
-  >
-> & {
-  transport: TTransport
-}
-
-/**
- * @description Creates a base RPC client with the given transport.
- *
- * - Intended to be used as a base for other RPC clients.
- * - Has access to _all_ EIP-1474 RPC methods.
- *
- * @example
- * import { mainnet } from 'viem/chains'
- * import { createClient, http } from 'viem/clients'
- * const client = createClient(http({ chain: mainnet }))
- */
-export function createClient<
-  TTransport extends Transport,
-  TChain extends Chain,
-  TRequests extends BaseRpcRequests,
->({
-  chain,
-  key = 'base',
-  name = 'Base Client',
-  pollingInterval = 4_000,
-  transport,
-  type = 'base',
-}: ClientConfig<TTransport, TChain, TRequests>): Client<
-  TTransport,
-  TChain,
-  TRequests
-> {
-  const { config, value } = transport({ chain })
-  return {
-    chain,
-    key,
-    name,
-    pollingInterval,
-    request: buildRequest(config.request),
-    transport: { ...config, ...value },
-    type,
-    uid: uid(),
-  }
-}

package/src/clients/createPublicClient.test.ts

@@ -1,165 +0,0 @@
-import { assertType, describe, expect, test, vi } from 'vitest'
-
-import { createPublicClient } from './createPublicClient'
-import { createTransport } from './transports/createTransport'
-import { http } from './transports/http'
-import { custom } from './transports/custom'
-import { webSocket } from './transports/webSocket'
-import { localhost } from '../chains'
-import type { PublicRequests } from '../types/eip1193'
-import { localWsUrl } from '../_test'
-
-const mockTransport = () =>
-  createTransport({
-    key: 'mock',
-    name: 'Mock Transport',
-    request: vi.fn(() => null) as any,
-    type: 'mock',
-  })
-
-test('creates', () => {
-  const { uid, ...client } = createPublicClient({
-    transport: mockTransport,
-  })
-
-  assertType<PublicRequests['request']>(client.request)
-
-  expect(uid).toBeDefined()
-  expect(client).toMatchInlineSnapshot(`
-    {
-      "chain": undefined,
-      "key": "public",
-      "name": "Public Client",
-      "pollingInterval": 4000,
-      "request": [Function],
-      "transport": {
-        "key": "mock",
-        "name": "Mock Transport",
-        "request": [MockFunction spy],
-        "type": "mock",
-      },
-      "type": "publicClient",
-    }
-  `)
-})
-
-describe('transports', () => {
-  test('http', () => {
-    const { uid, ...client } = createPublicClient({
-      chain: localhost,
-      transport: http(),
-    })
-
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": {
-          "id": 1337,
-          "name": "Localhost",
-          "nativeCurrency": {
-            "decimals": 18,
-            "name": "Ether",
-            "symbol": "ETH",
-          },
-          "network": "localhost",
-          "rpcUrls": {
-            "default": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-            "public": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-          },
-        },
-        "key": "public",
-        "name": "Public Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "http",
-          "name": "HTTP JSON-RPC",
-          "request": [Function],
-          "type": "http",
-          "url": undefined,
-        },
-        "type": "publicClient",
-      }
-    `)
-  })
-
-  test('webSocket', () => {
-    const { uid, ...client } = createPublicClient({
-      chain: localhost,
-      transport: webSocket(localWsUrl),
-    })
-
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": {
-          "id": 1337,
-          "name": "Localhost",
-          "nativeCurrency": {
-            "decimals": 18,
-            "name": "Ether",
-            "symbol": "ETH",
-          },
-          "network": "localhost",
-          "rpcUrls": {
-            "default": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-            "public": {
-              "http": [
-                "http://127.0.0.1:8545",
-              ],
-            },
-          },
-        },
-        "key": "public",
-        "name": "Public Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "getSocket": [Function],
-          "key": "webSocket",
-          "name": "WebSocket JSON-RPC",
-          "request": [Function],
-          "subscribe": [Function],
-          "type": "webSocket",
-        },
-        "type": "publicClient",
-      }
-    `)
-  })
-
-  test('custom', () => {
-    const { uid, ...client } = createPublicClient({
-      transport: custom({ request: async () => null }),
-    })
-
-    expect(uid).toBeDefined()
-    expect(client).toMatchInlineSnapshot(`
-      {
-        "chain": undefined,
-        "key": "public",
-        "name": "Public Client",
-        "pollingInterval": 4000,
-        "request": [Function],
-        "transport": {
-          "key": "custom",
-          "name": "Custom Provider",
-          "request": [Function],
-          "type": "custom",
-        },
-        "type": "publicClient",
-      }
-    `)
-  })
-})

package/src/clients/createPublicClient.ts

@@ -1,49 +0,0 @@
-import type { PublicRequests } from '../types/eip1193'
-import type { Transport } from './transports/createTransport'
-import type { Client, ClientConfig } from './createClient'
-import { createClient } from './createClient'
-import { Chain } from '../types'
-
-export type PublicClientConfig<
-  TTransport extends Transport = Transport,
-  TChain extends Chain = Chain,
-> = Pick<
-  ClientConfig<TTransport, TChain>,
-  'chain' | 'key' | 'name' | 'pollingInterval' | 'transport'
->
-
-export type PublicClient<
-  TTransport extends Transport = Transport,
-  TChain extends Chain = Chain,
-> = Client<TTransport, TChain, PublicRequests>
-
-/**
- * @description Creates a public client with a given transport.
- *
- * - Only has access to "public" EIP-1474 RPC methods (ie. `eth_blockNumber`, etc).
- *
- * @example
- * import { mainnet } from 'viem/chains'
- * import { createPublicClient, http } from 'viem/clients'
- * const client = createPublicClient(http({ chain: mainnet }))
- */
-export function createPublicClient<
-  TTransport extends Transport,
-  TChain extends Chain,
->({
-  chain,
-  key = 'public',
-  name = 'Public Client',
-  transport,
-  pollingInterval,
-}: PublicClientConfig<TTransport, TChain>): PublicClient<TTransport, TChain> {
-  chain
-  return createClient({
-    chain,
-    key,
-    name,
-    pollingInterval,
-    transport,
-    type: 'publicClient',
-  })
-}