viem 0.0.1-alpha.2 → 0.0.1-alpha.21

package/src/clients/createTestClient.test.ts

@@ -0,0 +1,145 @@
+import { assertType, describe, expect, test, vi } from 'vitest'
+
+import { createTestClient } from './createTestClient'
+import { createTransport } from './transports/createTransport'
+import { http } from './transports/http'
+import { localhost } from '../chains'
+import type { TestRequests } from '../types/eip1193'
+import { webSocket } from './transports/webSocket'
+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 } = createTestClient({
+    mode: 'anvil',
+    transport: mockTransport,
+  })
+
+  assertType<TestRequests<'anvil'>['request']>(client.request)
+  expect(uid).toBeDefined()
+  expect(client).toMatchInlineSnapshot(`
+    {
+      "chain": undefined,
+      "key": "test",
+      "mode": "anvil",
+      "name": "Test Client",
+      "pollingInterval": 4000,
+      "request": [Function],
+      "transport": {
+        "key": "mock",
+        "name": "Mock Transport",
+        "request": [MockFunction spy],
+        "type": "mock",
+      },
+      "type": "testClient",
+    }
+  `)
+})
+
+describe('transports', () => {
+  test('http', () => {
+    const { uid, ...client } = createTestClient({
+      chain: localhost,
+      mode: 'anvil',
+      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": "test",
+        "mode": "anvil",
+        "name": "Test Client",
+        "pollingInterval": 4000,
+        "request": [Function],
+        "transport": {
+          "key": "http",
+          "name": "HTTP JSON-RPC",
+          "request": [Function],
+          "type": "http",
+          "url": undefined,
+        },
+        "type": "testClient",
+      }
+    `)
+  })
+
+  test('webSocket', () => {
+    const { uid, ...client } = createTestClient({
+      chain: localhost,
+      mode: 'anvil',
+      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": "test",
+        "mode": "anvil",
+        "name": "Test Client",
+        "pollingInterval": 4000,
+        "request": [Function],
+        "transport": {
+          "getSocket": [Function],
+          "key": "webSocket",
+          "name": "WebSocket JSON-RPC",
+          "request": [Function],
+          "subscribe": [Function],
+          "type": "webSocket",
+        },
+        "type": "testClient",
+      }
+    `)
+  })
+})

package/src/clients/createTestClient.ts

@@ -0,0 +1,72 @@
+import type { TestRequests } from '../types/eip1193'
+import type { Transport } from './transports/createTransport'
+import type { Client, ClientConfig } from './createClient'
+import { createClient } from './createClient'
+import { Chain } from '../types'
+
+type TestClientModes = 'anvil' | 'hardhat'
+
+export type TestClientConfig<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+  TMode extends TestClientModes = TestClientModes,
+> = {
+  chain?: ClientConfig<TTransport, TChain>['chain']
+  /** The key of the client. */
+  key?: ClientConfig['key']
+  /** Mode of the test client. Available: "anvil" | "hardhat" */
+  mode: TMode
+  /** The name of the client. */
+  name?: ClientConfig['name']
+  /** Frequency (in ms) for polling enabled actions & events. Defaults to 4_000 milliseconds. */
+  pollingInterval?: ClientConfig['pollingInterval']
+  transport: ClientConfig<TTransport, TChain>['transport']
+}
+
+export type TestClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+  TMode extends TestClientModes = TestClientModes,
+> = Client<TTransport, TChain, TestRequests<TMode>> & {
+  mode: TMode
+}
+
+/**
+ * @description Creates a test client with a given transport.
+ *
+ * - Only has access to "test" RPC methods (ie. `anvil_setBalance`,
+ * `evm_mine`, etc).
+ *
+ * @example
+ * import { createTestClient, http } from 'viem'
+ * import { local } from 'viem/chains'
+ * const client = createTestClient({ chain: local, mode: 'anvil', transport: http() })
+ */
+export function createTestClient<
+  TTransport extends Transport,
+  TChain extends Chain,
+  TMode extends TestClientModes,
+>({
+  chain,
+  key = 'test',
+  name = 'Test Client',
+  mode,
+  pollingInterval,
+  transport,
+}: TestClientConfig<TTransport, TChain, TMode>): TestClient<
+  TTransport,
+  TChain,
+  TMode
+> {
+  return {
+    ...createClient({
+      chain,
+      key,
+      name,
+      pollingInterval,
+      transport,
+      type: 'testClient',
+    }),
+    mode,
+  }
+}

package/src/clients/createWalletClient.test.ts

@@ -0,0 +1,121 @@
+import { assertType, describe, expect, test, vi } from 'vitest'
+
+import { createWalletClient } from './createWalletClient'
+import { createTransport } from './transports/createTransport'
+import { http } from './transports/http'
+import { webSocket } from './transports/webSocket'
+import { localhost } from '../chains'
+import type { SignableRequests, WalletRequests } from '../types/eip1193'
+import { custom } from './transports/custom'
+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 } = createWalletClient({ transport: mockTransport })
+
+  assertType<SignableRequests['request'] & WalletRequests['request']>(
+    client.request,
+  )
+  expect(uid).toBeDefined()
+  expect(client).toMatchInlineSnapshot(`
+    {
+      "chain": undefined,
+      "key": "wallet",
+      "name": "Wallet Client",
+      "pollingInterval": 4000,
+      "request": [Function],
+      "transport": {
+        "key": "mock",
+        "name": "Mock Transport",
+        "request": [MockFunction spy],
+        "type": "mock",
+      },
+      "type": "walletClient",
+    }
+  `)
+})
+
+describe('transports', () => {
+  test('custom', () => {
+    const { uid, ...client } = createWalletClient({
+      transport: custom({ request: async () => null }),
+    })
+
+    expect(uid).toBeDefined()
+    expect(client).toMatchInlineSnapshot(`
+      {
+        "chain": undefined,
+        "key": "wallet",
+        "name": "Wallet Client",
+        "pollingInterval": 4000,
+        "request": [Function],
+        "transport": {
+          "key": "custom",
+          "name": "Custom Provider",
+          "request": [Function],
+          "type": "custom",
+        },
+        "type": "walletClient",
+      }
+    `)
+  })
+
+  test('http', () => {
+    const { uid, ...client } = createWalletClient({
+      transport: http('https://mockapi.com/rpc'),
+    })
+
+    expect(uid).toBeDefined()
+    expect(client).toMatchInlineSnapshot(`
+      {
+        "chain": undefined,
+        "key": "wallet",
+        "name": "Wallet Client",
+        "pollingInterval": 4000,
+        "request": [Function],
+        "transport": {
+          "key": "http",
+          "name": "HTTP JSON-RPC",
+          "request": [Function],
+          "type": "http",
+          "url": "https://mockapi.com/rpc",
+        },
+        "type": "walletClient",
+      }
+    `)
+  })
+
+  test('webSocket', () => {
+    const { uid, ...client } = createWalletClient({
+      chain: localhost,
+      transport: webSocket(localWsUrl),
+    })
+
+    expect(uid).toBeDefined()
+    expect(client).toMatchInlineSnapshot(`
+      {
+        "chain": undefined,
+        "key": "wallet",
+        "name": "Wallet Client",
+        "pollingInterval": 4000,
+        "request": [Function],
+        "transport": {
+          "getSocket": [Function],
+          "key": "webSocket",
+          "name": "WebSocket JSON-RPC",
+          "request": [Function],
+          "subscribe": [Function],
+          "type": "webSocket",
+        },
+        "type": "walletClient",
+      }
+    `)
+  })
+})

package/src/clients/createWalletClient.ts

@@ -0,0 +1,54 @@
+import type { SignableRequests, WalletRequests } 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 WalletClientConfig<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = {
+  chain?: ClientConfig<TTransport, TChain>['chain']
+  /** The key of the Wallet Client. */
+  key?: ClientConfig['key']
+  /** The name of the Wallet Client. */
+  name?: ClientConfig['name']
+  /** Frequency (in ms) for polling enabled actions & events. Defaults to 4_000 milliseconds. */
+  pollingInterval?: ClientConfig['pollingInterval']
+  transport: ClientConfig<TTransport, TChain>['transport']
+}
+
+export type WalletClient<
+  TTransport extends Transport = Transport,
+  TChain extends Chain = Chain,
+> = Client<TTransport, TChain, SignableRequests & WalletRequests>
+
+/**
+ * @description Creates a wallet client with a given transport.
+ *
+ * - Only has access to "wallet" & "signable" EIP-1474 RPC methods
+ * (ie. `eth_sendTransaction`, `eth_requestAccounts`, etc).
+ *
+ * @example
+ * import { createWalletClient, custom } from 'viem'
+ * const client = createWalletClient(
+ *  custom(window.ethereum)
+ * )
+ */
+export function createWalletClient<
+  TTransport extends Transport,
+  TChain extends Chain,
+>({
+  transport,
+  key = 'wallet',
+  name = 'Wallet Client',
+  pollingInterval,
+}: WalletClientConfig<TTransport, TChain>): WalletClient<TTransport, TChain> {
+  return createClient({
+    key,
+    name,
+    pollingInterval,
+    transport,
+    type: 'walletClient',
+  })
+}

package/src/clients/index.test.ts

@@ -0,0 +1,19 @@
+import { expect, test } from 'vitest'
+
+import * as clients from './index'
+
+test('exports clients', () => {
+  expect(clients).toMatchInlineSnapshot(`
+    {
+      "createClient": [Function],
+      "createPublicClient": [Function],
+      "createTestClient": [Function],
+      "createTransport": [Function],
+      "createWalletClient": [Function],
+      "custom": [Function],
+      "fallback": [Function],
+      "http": [Function],
+      "webSocket": [Function],
+    }
+  `)
+})

package/src/clients/index.ts

@@ -0,0 +1,31 @@
+export {
+  createTransport,
+  custom,
+  fallback,
+  http,
+  webSocket,
+} from './transports'
+export type {
+  CustomTransport,
+  CustomTransportConfig,
+  Transport,
+  TransportConfig,
+  FallbackTransport,
+  FallbackTransportConfig,
+  HttpTransport,
+  HttpTransportConfig,
+  WebSocketTransport,
+  WebSocketTransportConfig,
+} from './transports'
+
+export { createClient } from './createClient'
+export type { Client, ClientConfig } from './createClient'
+
+export { createPublicClient } from './createPublicClient'
+export type { PublicClient, PublicClientConfig } from './createPublicClient'
+
+export { createTestClient } from './createTestClient'
+export type { TestClient, TestClientConfig } from './createTestClient'
+
+export { createWalletClient } from './createWalletClient'
+export type { WalletClient, WalletClientConfig } from './createWalletClient'

package/src/clients/transports/createTransport.test.ts

@@ -0,0 +1,58 @@
+import { assertType, expect, test, vi } from 'vitest'
+
+import type { Requests } from '../../types/eip1193'
+
+import { createTransport } from './createTransport'
+
+test('default', () => {
+  const transport = createTransport({
+    key: 'mock',
+    name: 'Mock Transport',
+    request: vi.fn(async () => null) as unknown as Requests['request'],
+    type: 'mock',
+  })
+
+  assertType<'mock'>(transport.config.type)
+
+  expect(transport).toMatchInlineSnapshot(`
+    {
+      "config": {
+        "key": "mock",
+        "name": "Mock Transport",
+        "request": [MockFunction spy],
+        "type": "mock",
+      },
+      "value": undefined,
+    }
+  `)
+})
+
+test('value', () => {
+  const transport = createTransport(
+    {
+      key: 'mock',
+      name: 'Mock Transport',
+      request: vi.fn(async () => null) as unknown as Requests['request'],
+      type: 'mock',
+    },
+    {
+      foo: 'bar',
+      baz: 'foo',
+    },
+  )
+
+  expect(transport).toMatchInlineSnapshot(`
+    {
+      "config": {
+        "key": "mock",
+        "name": "Mock Transport",
+        "request": [MockFunction spy],
+        "type": "mock",
+      },
+      "value": {
+        "baz": "foo",
+        "foo": "bar",
+      },
+    }
+  `)
+})

package/src/clients/transports/createTransport.ts

@@ -0,0 +1,48 @@
+import type { Chain } from '../../types'
+import type { Requests } from '../../types/eip1193'
+
+export type BaseRpcRequests = {
+  request(...args: any): Promise<any>
+}
+
+export type TransportConfig<
+  TType extends string = string,
+  TRequests extends BaseRpcRequests['request'] = Requests['request'],
+> = {
+  /** 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
+  /** The type of the transport. */
+  type: TType
+}
+
+export type Transport<
+  TType extends string = string,
+  TRpcAttributes = Record<string, any>,
+> = <TChain extends Chain = Chain>({
+  chain,
+}: {
+  chain?: TChain
+}) => {
+  config: TransportConfig<TType>
+  value?: TRpcAttributes
+}
+
+/**
+ * @description Creates an transport intended to be used with a client.
+ */
+export function createTransport<
+  TType extends string = string,
+  TRpcAttributes = any,
+>(
+  config: TransportConfig<TType>,
+  value?: TRpcAttributes,
+): ReturnType<Transport<TType, TRpcAttributes>> {
+  return {
+    config,
+    value,
+  }
+}

package/src/clients/transports/custom.test.ts

@@ -0,0 +1,98 @@
+import { assertType, describe, expect, test, vi } from 'vitest'
+import '../../types/window'
+
+import type { Requests } from '../../types/eip1193'
+
+import type { CustomTransport } from './custom'
+import { custom } from './custom'
+
+vi.stubGlobal('window', {
+  ethereum: {
+    on: vi.fn(() => null),
+    removeListener: vi.fn(() => null),
+    request: vi.fn(() => null),
+  },
+})
+
+test('default', () => {
+  const transport = custom({
+    request: vi.fn(async () => null) as unknown as Requests['request'],
+  })
+
+  assertType<CustomTransport>(transport)
+  assertType<'custom'>(transport({}).config.type)
+
+  expect(transport({})).toMatchInlineSnapshot(`
+    {
+      "config": {
+        "key": "custom",
+        "name": "Custom Provider",
+        "request": [Function],
+        "type": "custom",
+      },
+      "value": undefined,
+    }
+  `)
+})
+
+describe('config', () => {
+  test('provider', () => {
+    const transport = custom(window.ethereum!)({})
+
+    expect(transport).toMatchInlineSnapshot(`
+      {
+        "config": {
+          "key": "custom",
+          "name": "Custom Provider",
+          "request": [Function],
+          "type": "custom",
+        },
+        "value": undefined,
+      }
+    `)
+  })
+
+  test('key', () => {
+    const transport = custom(
+      {
+        request: vi.fn(async () => null) as unknown as Requests['request'],
+      },
+      { key: 'mock' },
+    )({})
+
+    expect(transport).toMatchInlineSnapshot(`
+      {
+        "config": {
+          "key": "mock",
+          "name": "Custom Provider",
+          "request": [Function],
+          "type": "custom",
+        },
+        "value": undefined,
+      }
+    `)
+  })
+
+  test('name', () => {
+    const transport = custom(
+      {
+        request: vi.fn(async () => null) as unknown as Requests['request'],
+      },
+      {
+        name: 'Mock Transport',
+      },
+    )({})
+
+    expect(transport).toMatchInlineSnapshot(`
+      {
+        "config": {
+          "key": "custom",
+          "name": "Mock Transport",
+          "request": [Function],
+          "type": "custom",
+        },
+        "value": undefined,
+      }
+    `)
+  })
+})

package/src/clients/transports/custom.ts

@@ -0,0 +1,34 @@
+import type {
+  BaseRpcRequests,
+  Transport,
+  TransportConfig,
+} from './createTransport'
+import { createTransport } from './createTransport'
+
+type EthereumProvider = { request: BaseRpcRequests['request'] }
+
+export type CustomTransportConfig = {
+  /** The key of the transport. */
+  key?: TransportConfig['key']
+  /** The name of the transport. */
+  name?: TransportConfig['name']
+}
+
+export type CustomTransport = Transport<'custom', EthereumProvider['request']>
+
+/**
+ * @description Creates a custom transport given an EIP-1193 compliant `request` attribute.
+ */
+export function custom<TProvider extends EthereumProvider>(
+  /** An Ethereum provider with an EIP-1193 "request" attribute. */
+  provider: TProvider,
+  { key = 'custom', name = 'Custom Provider' }: CustomTransportConfig = {},
+): CustomTransport {
+  return () =>
+    createTransport({
+      key,
+      name,
+      request: provider.request.bind(provider),
+      type: 'custom',
+    })
+}