viem 0.0.0 → 0.0.1-alpha.0

package/dist/chunk-OPR6LKYX.js

@@ -0,0 +1,251 @@
+import {
+  BaseError,
+  buildRequest,
+  getSocket,
+  rpc
+} from "./chunk-GI67STNV.js";
+
+// src/clients/transports/createTransport.ts
+function createTransport(config, value) {
+  return {
+    config,
+    value
+  };
+}
+
+// src/clients/transports/errors.ts
+var UrlRequiredError = class extends BaseError {
+  constructor() {
+    super(
+      "No URL was provided to the Transport. Please provide a valid RPC URL to the Transport.",
+      {
+        docsPath: "/TODO"
+      }
+    );
+  }
+};
+
+// src/clients/transports/ethereumProvider.ts
+function ethereumProvider({
+  key = "ethereumProvider",
+  name = "Ethereum Provider",
+  provider
+}) {
+  return () => createTransport({
+    key,
+    name,
+    request: provider.request.bind(provider),
+    type: "ethereumProvider"
+  });
+}
+
+// src/clients/transports/http.ts
+function http({
+  key = "http",
+  name = "HTTP JSON-RPC",
+  url
+} = {}) {
+  return ({ chain }) => {
+    const url_ = url || chain?.rpcUrls.default.http[0];
+    if (!url_)
+      throw new UrlRequiredError();
+    return createTransport(
+      {
+        key,
+        name,
+        async request({ method, params }) {
+          const { result } = await rpc.http(url_, {
+            body: {
+              method,
+              params
+            }
+          });
+          return result;
+        },
+        type: "http"
+      },
+      {
+        url
+      }
+    );
+  };
+}
+
+// src/clients/transports/webSocket.ts
+function webSocket({
+  key = "webSocket",
+  name = "WebSocket JSON-RPC",
+  url
+} = {}) {
+  return ({ chain }) => {
+    const url_ = url || chain?.rpcUrls.default.webSocket?.[0];
+    if (!url_)
+      throw new UrlRequiredError();
+    return createTransport(
+      {
+        key,
+        name,
+        async request({ method, params }) {
+          const socket = await getSocket(url_);
+          const { result } = await rpc.webSocketAsync(socket, {
+            body: { method, params }
+          });
+          return result;
+        },
+        type: "webSocket"
+      },
+      {
+        getSocket() {
+          return getSocket(url_);
+        },
+        async subscribe({ params, onData, onError }) {
+          const socket = await getSocket(url_);
+          const { result: subscriptionId } = await new Promise(
+            (resolve, reject) => rpc.webSocket(socket, {
+              body: {
+                method: "eth_subscribe",
+                params
+              },
+              onData: (data) => {
+                if (typeof data.id === "number") {
+                  resolve(data);
+                  return;
+                }
+                onData(data);
+              },
+              onError: (error) => {
+                reject(error);
+                onError?.(error);
+              }
+            })
+          );
+          return {
+            subscriptionId,
+            async unsubscribe() {
+              return new Promise(
+                (resolve, reject) => rpc.webSocket(socket, {
+                  body: {
+                    method: "eth_unsubscribe",
+                    params: [subscriptionId]
+                  },
+                  onData: resolve,
+                  onError: reject
+                })
+              );
+            }
+          };
+        }
+      }
+    );
+  };
+}
+
+// src/utils/uid.ts
+var size = 256;
+var index = size;
+var buffer;
+function uid(length = 11) {
+  if (!buffer || index + length > size * 2) {
+    buffer = "";
+    index = 0;
+    for (let i = 0; i < size; i++) {
+      buffer += (256 + Math.random() * 256 | 0).toString(16).substring(1);
+    }
+  }
+  return buffer.substring(index, index++ + length);
+}
+
+// src/clients/createClient.ts
+function createClient({
+  chain,
+  key = "base",
+  name = "Base Client",
+  pollingInterval = 4e3,
+  transport,
+  type = "base"
+}) {
+  const { config, value } = transport({ chain });
+  return {
+    chain,
+    key,
+    name,
+    pollingInterval,
+    request: buildRequest(config.request),
+    transport: { ...config, ...value },
+    type,
+    uid: uid()
+  };
+}
+
+// src/clients/createPublicClient.ts
+function createPublicClient({
+  chain,
+  key = "public",
+  name = "Public Client",
+  transport,
+  pollingInterval
+}) {
+  chain;
+  return {
+    ...createClient({
+      chain,
+      key,
+      name,
+      pollingInterval,
+      transport,
+      type: "publicClient"
+    })
+  };
+}
+
+// src/clients/createTestClient.ts
+function createTestClient({
+  chain,
+  key = "test",
+  name = "Test Client",
+  mode,
+  pollingInterval,
+  transport
+}) {
+  return {
+    ...createClient({
+      chain,
+      key,
+      name,
+      pollingInterval,
+      transport,
+      type: "testClient"
+    }),
+    mode
+  };
+}
+
+// src/clients/createWalletClient.ts
+function createWalletClient({
+  transport,
+  key = "wallet",
+  name = "Wallet Client",
+  pollingInterval
+}) {
+  return {
+    ...createClient({
+      key,
+      name,
+      pollingInterval,
+      transport,
+      type: "walletClient"
+    })
+  };
+}
+
+export {
+  createTransport,
+  UrlRequiredError,
+  ethereumProvider,
+  http,
+  webSocket,
+  createClient,
+  createPublicClient,
+  createTestClient,
+  createWalletClient
+};

package/dist/clients/index.d.ts

@@ -0,0 +1,8 @@
+export { C as Client, a as ClientConfig, P as PublicClient, b as PublicClientConfig, T as TestClient, c as TestClientConfig, d as Transport, e as TransportConfig, W as WalletClient, f as WalletClientConfig, g as createClient, h as createPublicClient, i as createTestClient, j as createTransport, k as createWalletClient } from '../createWalletClient-c40fef16.js';
+export { E as EthereumProviderTransport, a as EthereumProviderTransportConfig, H as HttpTransport, b as HttpTransportConfig, U as UrlRequiredError, W as WebSocketTransport, c as WebSocketTransportConfig, e as ethereumProvider, h as http, w as webSocket } from '../webSocket-14584a7e.js';
+import '../chains.js';
+import '../rpc-655c0ba4.js';
+import '@wagmi/chains';
+import '../eip1193-8f7c22ce.js';
+import '../BaseError-7688f84e.js';
+import '../rpc-3c0e3985.js';

package/dist/clients/index.js

@@ -0,0 +1,23 @@
+import {
+  UrlRequiredError,
+  createClient,
+  createPublicClient,
+  createTestClient,
+  createTransport,
+  createWalletClient,
+  ethereumProvider,
+  http,
+  webSocket
+} from "../chunk-OPR6LKYX.js";
+import "../chunk-GI67STNV.js";
+export {
+  UrlRequiredError,
+  createClient,
+  createPublicClient,
+  createTestClient,
+  createTransport,
+  createWalletClient,
+  ethereumProvider,
+  http,
+  webSocket
+};

package/dist/createWalletClient-c40fef16.d.ts

@@ -0,0 +1,130 @@
+import { Chain } from './chains.js';
+import { R as Requests, P as PublicRequests, T as TestRequests, S as SignableRequests, b as WalletRequests } from './eip1193-8f7c22ce.js';
+
+type BaseRpcRequests = {
+    request(...args: any): Promise<any>;
+};
+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;
+};
+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.
+ */
+declare function createTransport<TType extends string = string, TRpcAttributes = any>(config: TransportConfig<TType>, value?: TRpcAttributes): ReturnType<Transport<TType, TRpcAttributes>>;
+
+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, ethereumProvider, etc) */
+    transport: ReturnType<TTransport>['config'] & ReturnType<TTransport>['value'];
+    /** The type of client. */
+    type: string;
+    /** A unique ID for the client. */
+    uid: string;
+};
+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 }))
+ */
+declare function createClient<TTransport extends Transport, TChain extends Chain, TRequests extends BaseRpcRequests>({ chain, key, name, pollingInterval, transport, type, }: ClientConfig<TTransport, TChain, TRequests>): Client<TTransport, TChain, TRequests>;
+
+type PublicClientConfig<TTransport extends Transport = Transport, TChain extends Chain = Chain> = Pick<ClientConfig<TTransport, TChain>, 'chain' | 'key' | 'name' | 'pollingInterval' | 'transport'>;
+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 }))
+ */
+declare function createPublicClient<TTransport extends Transport, TChain extends Chain>({ chain, key, name, transport, pollingInterval, }: PublicClientConfig<TTransport, TChain>): PublicClient<TTransport, TChain>;
+
+type TestClientModes = 'anvil' | 'hardhat';
+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'];
+};
+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 { local } from 'viem/chains'
+ * import { createTestClient, http } from 'viem/clients'
+ * const client = createTestClient(http({ chain: local }), { mode: 'anvil' })
+ */
+declare function createTestClient<TTransport extends Transport, TChain extends Chain, TMode extends TestClientModes>({ chain, key, name, mode, pollingInterval, transport, }: TestClientConfig<TTransport, TChain, TMode>): TestClient<TTransport, TChain, TMode>;
+
+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'];
+};
+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, ethereumProvider } from 'viem/clients'
+ * const client = createWalletClient(
+ *  ethereumProvider({ provider: window.ethereum })
+ * )
+ */
+declare function createWalletClient<TTransport extends Transport, TChain extends Chain>({ transport, key, name, pollingInterval, }: WalletClientConfig<TTransport, TChain>): WalletClient<TTransport, TChain>;
+
+export { BaseRpcRequests as B, Client as C, PublicClient as P, TestClient as T, WalletClient as W, ClientConfig as a, PublicClientConfig as b, TestClientConfig as c, Transport as d, TransportConfig as e, WalletClientConfig as f, createClient as g, createPublicClient as h, createTestClient as i, createTransport as j, createWalletClient as k };