viem 0.0.1-alpha.25 → 0.0.1-alpha.26

package/src/clients/createTestClient.test.ts

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

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

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

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

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

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

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

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

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

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