viem 0.0.1-cjs.10 → 0.0.1-sushi.26

package/src/chains.ts

@@ -0,0 +1,99 @@
+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

@@ -0,0 +1,295 @@
+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

@@ -0,0 +1,81 @@
+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

@@ -0,0 +1,165 @@
+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

@@ -0,0 +1,49 @@
+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',
+  })
+}