viem 0.0.1-alpha.10 → 0.0.1-alpha.11

package/dist/{chunk-6GAKRM5P.js → chunk-DY4MSK2M.mjs}

@@ -8,8 +8,8 @@ var __publicField = (obj, key, value) => {
 // package.json
 var package_default = {
   name: "viem",
-  description: "TypeScript (& JavaScript) Interface for Ethereum",
-  version: "0.0.1-alpha.10",
+  description: "TypeScript Interface for Ethereum",
+  version: "0.0.1-alpha.11",
   scripts: {
     anvil: "source .env && anvil --fork-url $VITE_ANVIL_FORK_URL --fork-block-number $VITE_ANVIL_BLOCK_NUMBER --block-time $VITE_ANVIL_BLOCK_TIME",
     bench: "vitest bench --no-threads",
@@ -26,11 +26,14 @@ var package_default = {
     playground: "pnpm --filter playground-dev dev",
     "playground:benchmark": "pnpm --filter playground-benchmark dev",
     postinstall: "pnpm dev",
+    postpublish: "pnpm ts-node scripts/restore-package-json.ts",
     preinstall: "npx only-allow pnpm",
+    prepublishOnly: "pnpm ts-node scripts/generate-package-json.ts",
     prepare: "npx simple-git-hooks",
     test: "vitest dev --coverage --no-threads",
     "test:ci": "CI=true vitest --coverage --no-threads",
     "test:ui": "vitest dev --ui --no-threads",
+    "ts-node": "node --loader esbuild-register/loader -r esbuild-register",
     typecheck: "tsc --noEmit"
   },
   files: [
@@ -45,37 +48,43 @@ var package_default = {
   exports: {
     ".": {
       types: "./dist/index.d.ts",
+      module: "./dist/index.mjs",
       default: "./dist/index.js"
     },
     "./actions": {
       types: "./dist/actions/index.d.ts",
+      module: "./dist/actions/index.mjs",
       default: "./dist/actions/index.js"
     },
     "./chains": {
       types: "./dist/chains.d.ts",
+      module: "./dist/chains.mjs",
       default: "./dist/chains.js"
     },
     "./clients": {
       types: "./dist/clients/index.d.ts",
+      module: "./dist/clients/index.mjs",
       default: "./dist/clients/index.js"
     },
     "./utils": {
       types: "./dist/utils/index.d.ts",
+      module: "./dist/utils/index.mjs",
       default: "./dist/utils/index.js"
     },
     "./window": {
       types: "./dist/window.d.ts",
+      module: "./dist/window.mjs",
       default: "./dist/window.js"
     },
     "./package.json": "./package.json"
   },
-  type: "module",
   main: "dist/index.js",
+  module: "dist/index.mjs",
   types: "dist/index.d.ts",
   sideEffects: false,
   dependencies: {
     "@noble/hashes": "^1.1.2",
-    "@wagmi/chains": "^0.1.0",
+    "@wagmi/chains": "0.0.0-20230201210619",
     abitype: "^0.2.5"
   },
   devDependencies: {
@@ -119,9 +128,6 @@ var package_default = {
     "wallet",
     "web3"
   ],
-  engines: {
-    node: ">=18"
-  },
   "simple-git-hooks": {
     "pre-commit": "pnpm format & pnpm lint:fix"
   },

package/dist/chunk-GXCYE2PD.js

@@ -0,0 +1,258 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+var _chunk35OJIFIWjs = require('./chunk-35OJIFIW.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 || _optionalChain([chain, 'optionalAccess', _ => _.rpcUrls, 'access', _2 => _2.default, 'access', _3 => _3.http, 'access', _4 => _4[0]]);
+    if (!url_)
+      throw new (0, _chunk35OJIFIWjs.UrlRequiredError)();
+    return createTransport(
+      {
+        key,
+        name,
+        async request({ method, params }) {
+          const { result } = await _chunk35OJIFIWjs.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 || _optionalChain([chain, 'optionalAccess', _5 => _5.rpcUrls, 'access', _6 => _6.default, 'access', _7 => _7.webSocket, 'optionalAccess', _8 => _8[0]]);
+    if (!url_)
+      throw new (0, _chunk35OJIFIWjs.UrlRequiredError)();
+    return createTransport(
+      {
+        key,
+        name,
+        async request({ method, params }) {
+          const socket = await _chunk35OJIFIWjs.getSocket.call(void 0, url_);
+          const { result } = await _chunk35OJIFIWjs.rpc.webSocketAsync(socket, {
+            body: { method, params }
+          });
+          return result;
+        },
+        type: "webSocket"
+      },
+      {
+        getSocket() {
+          return _chunk35OJIFIWjs.getSocket.call(void 0, url_);
+        },
+        async subscribe({ params, onData, onError }) {
+          const socket = await _chunk35OJIFIWjs.getSocket.call(void 0, url_);
+          const { result: subscriptionId } = await new Promise(
+            (resolve, reject) => _chunk35OJIFIWjs.rpc.webSocket(socket, {
+              body: {
+                method: "eth_subscribe",
+                params
+              },
+              onData: (data) => {
+                if (typeof data.id === "number") {
+                  resolve(data);
+                  return;
+                }
+                onData(data);
+              },
+              onError: (error) => {
+                reject(error);
+                _optionalChain([onError, 'optionalCall', _9 => _9(error)]);
+              }
+            })
+          );
+          return {
+            subscriptionId,
+            async unsubscribe() {
+              return new Promise(
+                (resolve, reject) => _chunk35OJIFIWjs.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: _chunk35OJIFIWjs.buildRequest.call(void 0, 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"
+  });
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.createTransport = createTransport; exports.custom = custom; exports.fallback = fallback; exports.http = http; exports.webSocket = webSocket; exports.createClient = createClient; exports.createPublicClient = createPublicClient; exports.createTestClient = createTestClient; exports.createWalletClient = createWalletClient;

package/dist/{chunk-NMN4TFDP.js → chunk-JXGK2LUM.mjs}

@@ -23,7 +23,7 @@ import {
   numberToHex,
   wait,
   withCache
-} from "./chunk-6GAKRM5P.js";
+} from "./chunk-DY4MSK2M.mjs";
 
 // src/actions/public/call.ts
 async function call(client, {