viem 0.0.1-alpha.3 → 0.0.1-alpha.31

package/dist/chunk-TLEMV4T3.js

@@ -1,258 +0,0 @@
-import {
-  UrlRequiredError,
-  buildRequest,
-  getSocket,
-  rpc
-} from "./chunk-WZITKXV3.js";
-
-// src/clients/transports/createTransport.ts
-function createTransport(config, value) {
-  return {
-    config,
-    value
-  };
-}
-
-// src/clients/transports/custom.ts
-function custom(provider, { key = "custom", name = "Custom Provider" } = {}) {
-  return () => createTransport({
-    key,
-    name,
-    request: provider.request.bind(provider),
-    type: "custom"
-  });
-}
-
-// src/clients/transports/fallback.ts
-function fallback(transports, { key = "fallback", name = "Fallback" } = {}) {
-  return ({ chain }) => createTransport(
-    {
-      key,
-      name,
-      async request({ method, params }) {
-        const fetch = async (i = 0) => {
-          const transport = transports[i]({ chain });
-          try {
-            return await transport.config.request({
-              method,
-              params
-            });
-          } catch (err) {
-            if (i < transports.length - 1)
-              return fetch(i + 1);
-            throw err;
-          }
-        };
-        return fetch();
-      },
-      type: "fallback"
-    },
-    {
-      transports: transports.map(
-        (fn) => fn({ chain })
-      )
-    }
-  );
-}
-
-// src/clients/transports/http.ts
-function http(url, { key = "http", name = "HTTP JSON-RPC" } = {}) {
-  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(url, {
-  key = "webSocket",
-  name = "WebSocket JSON-RPC"
-} = {}) {
-  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,
-  custom,
-  fallback,
-  http,
-  webSocket,
-  createClient,
-  createPublicClient,
-  createTestClient,
-  createWalletClient
-};