univo 0.1.15

package/dist/realtime.mjs

@@ -0,0 +1,210 @@
+import WS from 'ws';
+import { WebSocket } from 'partysocket';
+import { http } from './client.mjs';
+import { c as createLogger, r as retry, h as hexToNumber, j as raise, m as mutex, k as assert } from './shared/univo.rTUTP64t.mjs';
+
+function createSocket(url, opts) {
+  const ws = new WebSocket(url, [], { WebSocket: WS });
+  ws.binaryType = "arraybuffer";
+  if (opts.onOpen) ws.onopen = opts.onOpen;
+  if (opts.onError) ws.onerror = opts.onError;
+  if (opts.onClose) ws.onclose = opts.onClose;
+  if (opts.onMessage) ws.onmessage = opts.onMessage;
+  return ws;
+}
+function defineTransport(url) {
+  let id = 0;
+  const requests = /* @__PURE__ */ new Map();
+  async function request(opts) {
+    return await new Promise((resolve) => {
+      const body = Object.assign({ id: id++ }, opts);
+      requests.set(body.id, {
+        handler: (data) => {
+          requests.delete(body.id);
+          resolve(data);
+        }
+      });
+      socket.send(JSON.stringify(body));
+    });
+  }
+  const subscriptions = /* @__PURE__ */ new Map();
+  async function subscribe(param, handler) {
+    const id2 = await request({ method: "eth_subscribe", params: [param] });
+    subscriptions.set(id2, { param, handler, latest: Date.now() });
+    return {
+      async unsubscribe() {
+        subscriptions.delete(id2);
+        await request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
+        });
+      }
+    };
+  }
+  const socket = createSocket(url, {
+    onError(cause) {
+      console.error(new Error("Socket error", { cause }));
+    },
+    onOpen() {
+      if (subscriptions.size) {
+        const handlers = [];
+        for (const [id2, subscription] of subscriptions) {
+          handlers.push(subscription);
+          request({ method: "eth_unsubscribe", params: [id2] }).catch(() => {
+          });
+          subscriptions.delete(id2);
+        }
+        for (const handler of handlers) {
+          request({ method: "eth_subscribe", params: [handler.param] }).then((id2) => {
+            subscriptions.set(id2, handler);
+          });
+        }
+      }
+    },
+    onMessage(event) {
+      const data = JSON.parse(event.data);
+      if (data.method === "eth_subscription") {
+        const subscription = subscriptions.get(data.params.subscription);
+        if (!subscription) {
+          return request({ method: "eth_unsubscribe", params: [data.params.subscription] }).catch(() => {
+          });
+        }
+        subscription.latest = Date.now();
+        return subscription.handler(data.params.result);
+      }
+      const _request = requests.get(data.id);
+      if (_request) _request.handler(data.result);
+    }
+  });
+  return { request, subscribe };
+}
+function defineBlockchain(opts) {
+  const log = createLogger({ quiet: opts.quiet });
+  const chain = [];
+  function setHeadBlock(newBlock) {
+    chain.push(newBlock);
+    opts.onBlockAdded(newBlock);
+    if (chain.length > 100) chain.shift();
+  }
+  function removeHeadBlock() {
+    chain.pop();
+  }
+  function getHeadBlock() {
+    const block = chain[chain.length - 1];
+    assert(block !== void 0, "Expected non-empty chain when retrieving latest block");
+    return block;
+  }
+  function getOldestBlock() {
+    const block = chain[0];
+    assert(block !== void 0, "Expected non-empty chain when retrieving oldest block");
+    return block;
+  }
+  async function reconcile(newBlock) {
+    if (chain.length === 0) {
+      return setHeadBlock(newBlock);
+    }
+    if (hexToNumber(newBlock.number) < hexToNumber(getOldestBlock().number)) {
+      log.info(`Received block ${hexToNumber(newBlock.number)} older than our local chain`);
+      throw new Error("Not implemented");
+    }
+    if (chain.some((block) => block.hash === newBlock.hash)) {
+      return;
+    }
+    if (getHeadBlock().hash === newBlock.parentHash) {
+      return setHeadBlock(newBlock);
+    }
+    if (chain.some((block) => block.hash === newBlock.parentHash)) {
+      while (getHeadBlock().hash !== newBlock.parentHash) removeHeadBlock();
+      return setHeadBlock(newBlock);
+    }
+    if (newBlock.parentHash === "0x0000000000000000000000000000000000000000000000000000000000000000") {
+      while (chain.length > 0) removeHeadBlock();
+      return setHeadBlock(newBlock);
+    }
+    const parentBlock = await retry(opts.getBlockByHash, [newBlock.parentHash], 5);
+    if (!parentBlock) throw new Error(`Failed to fetch parent block ${hexToNumber(newBlock.number)} ${newBlock.parentHash.slice(0, 16)}`);
+    assert(parentBlock.hash === newBlock.parentHash, "Expected block hashes to match");
+    await reconcile(parentBlock);
+    return await reconcile(newBlock);
+  }
+  return {
+    reconcile: mutex(reconcile)
+  };
+}
+function createRealtimeStream(opts) {
+  const log = createLogger({ quiet: opts.quiet });
+  const handlers = /* @__PURE__ */ new Set();
+  function onBlockAdded(head) {
+    for (const handler of handlers) {
+      try {
+        const result = handler(head);
+        if (result instanceof Promise) {
+          result.catch(() => {
+            log.error("Failed to process handler");
+          });
+        }
+      } catch (error) {
+        if (error instanceof Error) {
+          log.error(error.message);
+        }
+      }
+    }
+  }
+  async function createRealtimeStreamForChain(chain) {
+    async function getBlockByHash(hash) {
+      const block = await opts.transport.request({
+        method: "eth_getBlockByHash",
+        params: [hash, false]
+      });
+      return { chain, number: block.number, hash: block.hash, parentHash: block.parentHash };
+    }
+    const latest = defineBlockchain({ onBlockAdded, getBlockByHash, quiet: opts.quiet });
+    async function onNewHead(head) {
+      try {
+        await latest.reconcile(head);
+      } catch (cause) {
+        log.error("Failed to reconcile latest head");
+      }
+    }
+    opts.transport.subscribe("newHeads", (head) => onNewHead({ chain, number: head.number, hash: head.hash, parentHash: head.parentHash })).then(() => log.debug(`Initialised subscription for chain ${hexToNumber(chain)}`)).catch((cause) => raise(`Failed to initialise subscription for chain ${hexToNumber(chain)}`, { cause }));
+  }
+  retry(opts.transport.request, [{ method: "eth_chainId", params: [] }], 5).then((chain) => createRealtimeStreamForChain(chain)).catch(() => log.error("Failed to load current chain"));
+  return {
+    on(_, handler) {
+      handlers.add(handler);
+      return { unsubscribe: () => handlers.delete(handler) };
+    }
+  };
+}
+function realtime(opts) {
+  const defaultOptions = { quiet: false };
+  const options = Object.assign(defaultOptions, opts);
+  const log = createLogger(options);
+  if (options.endpoints.length === 0) throw new Error("Must provide at least one url to `endpoints`");
+  function createClient(endpoint) {
+    const client = http(endpoint);
+    let id = 0;
+    let pending = [];
+    return {
+      async publish(head) {
+        try {
+          const heads = pending.concat(head);
+          const response = await client.request({ jsonrpc: "2.0", id: id++, method: "public_writeBlocks", params: [endpoint, heads] });
+          if (response.error) throw new Error(response.error.message);
+          pending = [];
+        } catch (cause) {
+          log.warn(`Failed to publish realtime block ${head.chain}:${head.number}`);
+          pending.push(head);
+        }
+      }
+    };
+  }
+  const clients = options.endpoints.map((endpoint) => createClient(endpoint));
+  createRealtimeStream(options).on("block", async (head) => {
+    await Promise.all(
+      clients.map(async (client) => {
+        await client.publish(head);
+      })
+    );
+  });
+}
+
+export { createRealtimeStream, defineTransport, realtime };

package/dist/shared/univo.rTUTP64t.mjs

@@ -0,0 +1,154 @@
+const name = "univo";
+const version = "0.1.15";
+
+function createException(message) {
+  return `univo:${message}`;
+}
+function catchException(unknown, exception) {
+  if (unknown instanceof Error) {
+    if (unknown.message === exception) {
+      return true;
+    }
+  }
+  return false;
+}
+function getException(unknown) {
+  if (unknown instanceof Error) {
+    if (unknown.message.startsWith("univo")) {
+      const [_, message] = unknown.message.split(":");
+      if (message) return message;
+    }
+  }
+}
+
+function createLogger(opts) {
+  return {
+    debug(...any) {
+      if (!opts.quiet && process.env.LOG_LEVEL === "DEBUG") {
+        console.log(`[${name}@${version}] DEBUG`, ...any);
+      }
+    },
+    info(...any) {
+      if (!opts.quiet && (process.env.LOG_LEVEL === "DEBUG" || process.env.LOG_LEVEL === "INFO")) {
+        console.log(`[${name}@${version}] INFO`, ...any);
+      }
+    },
+    warn(...any) {
+      if (!opts.quiet && (process.env.LOG_LEVEL === "DEBUG" || process.env.LOG_LEVEL === "INFO" || process.env.LOG_LEVEL === "WARN")) {
+        console.log(`[${name}@${version}] WARN`, ...any);
+      }
+    },
+    error(...any) {
+      if (process.env.LOG_LEVEL === "DEBUG" || process.env.LOG_LEVEL === "INFO" || process.env.LOG_LEVEL === "WARN" || process.env.LOG_LEVEL === "ERROR") {
+        console.log(`[${name}@${version}] ERROR`, ...any);
+      }
+    }
+  };
+}
+const encoder = new TextEncoder();
+function assert(value, message) {
+  if (value === false || value === null || value === void 0) {
+    throw new Error(message ?? `Assertion failed: value is ${String(value)}`);
+  }
+  return value;
+}
+async function getSignature(opts) {
+  const keyData = encoder.encode(opts.key);
+  const key = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  if (typeof opts.body === "string") {
+    const dataToAuthenticate = encoder.encode(opts.body);
+    const hmac2 = await crypto.subtle.sign("HMAC", key, dataToAuthenticate);
+    return [...new Uint8Array(hmac2)].map((binary) => binary.toString(16).padStart(2, "0")).join("");
+  }
+  const hmac = await crypto.subtle.sign("HMAC", key, opts.body);
+  return [...new Uint8Array(hmac)].map((binary) => binary.toString(16).padStart(2, "0")).join("");
+}
+async function verifySignature(opts) {
+  const keyData = encoder.encode(opts.key);
+  const key = await crypto.subtle.importKey("raw", keyData, { name: "HMAC", hash: "SHA-256" }, false, ["verify"]);
+  const pairs = opts.signature.match(/[\da-f]{2}/gi);
+  if (!pairs) return false;
+  if (typeof opts.body === "string") {
+    const dataToAuthenticate = encoder.encode(opts.body);
+    const hmac2 = new Uint8Array(pairs.map((byte) => Number.parseInt(byte, 16))).buffer;
+    return await crypto.subtle.verify("HMAC", key, hmac2, dataToAuthenticate);
+  }
+  const hmac = new Uint8Array(pairs.map((byte) => Number.parseInt(byte, 16))).buffer;
+  return await crypto.subtle.verify("HMAC", key, hmac, opts.body);
+}
+function hexToNumber(hex) {
+  return Number.parseInt(hex, 16);
+}
+function mutex(fn) {
+  let locked = false;
+  return async (...args) => {
+    if (locked) return;
+    locked = true;
+    await fn(...args);
+    locked = false;
+  };
+}
+function isAddressEqual(a, b) {
+  return a.toLowerCase() === b.toLowerCase();
+}
+async function retry(fn, args, retries, __count = 1) {
+  try {
+    return await fn(...args);
+  } catch (error) {
+    if (__count > retries) throw error;
+    await new Promise((resolve) => setTimeout(resolve, 1e3 * 2 ** __count));
+    return retry(fn, args, retries, __count + 1);
+  }
+}
+function raise(...args) {
+  if (args[0] instanceof Error) throw args[0];
+  throw new Error(...args);
+}
+function nonNullable(value) {
+  return value !== null && value !== void 0;
+}
+async function compress(input) {
+  const encoded = new TextEncoder().encode(input);
+  const stream = new CompressionStream("gzip");
+  const writer = stream.writable.getWriter();
+  writer.write(encoded);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+async function decompress(input) {
+  const stream = new DecompressionStream("gzip");
+  const writer = stream.writable.getWriter();
+  writer.write(input);
+  writer.close();
+  const chunks = [];
+  const reader = stream.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return new TextDecoder().decode(result);
+}
+
+export { createException as a, catchException as b, createLogger as c, decompress as d, version as e, getSignature as f, getException as g, hexToNumber as h, isAddressEqual as i, raise as j, assert as k, name as l, mutex as m, nonNullable as n, compress as o, retry as r, verifySignature as v };

package/package.json

@@ -0,0 +1,55 @@
+{
+	"name": "univo",
+	"license": "MIT",
+	"type": "module",
+	"version": "0.1.15",
+	"sideEffects": false,
+	"module": "./dist/index.mjs",
+	"types": "./dist/index.d.ts",
+	"bin": {
+		"univo": "dist/cli.mjs"
+	},
+	"exports": {
+		".": {
+			"types": "./dist/index.d.ts",
+			"import": "./dist/index.mjs"
+		},
+		"./client": {
+			"types": "./dist/client.d.ts",
+			"import": "./dist/client.mjs"
+		},
+		"./realtime": {
+			"types": "./dist/realtime.d.ts",
+			"import": "./dist/realtime.mjs"
+		}
+	},
+	"files": [
+		"dist"
+	],
+	"scripts": {
+		"test": "vitest",
+		"build": "unbuild",
+		"univo": "NODE_ENV=production LOG_LEVEL=DEBUG jiti ./src/cli",
+		"build:release": "pnpm build && changelogen --release --push && pnpm build && npm publish"
+	},
+	"dependencies": {
+		"citty": "^0.1.6",
+		"dotenv": "^17.2.2",
+		"open": "^10.2.0",
+		"partysocket": "^1.1.3",
+		"ws": "^8.18.1"
+	},
+	"devDependencies": {
+		"@hono/node-server": "^1.14.1",
+		"@types/node": "^20.11.27",
+		"@types/ws": "^8.18.1",
+		"changelogen": "^0.6.1",
+		"hono": "^4.7.8",
+		"jiti": "^2.4.2",
+		"msw": "^2.10.2",
+		"typescript": "^5.8.2",
+		"unbuild": "^3.5.0",
+		"viem": "2.45.1",
+		"vitest": "^3.1.3"
+	}
+}