tenjin-cli 0.1.0-alpha.1 → 0.1.0-alpha.3

package/dist/chunk-JPHG2JW3.js

@@ -0,0 +1,96 @@
+import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
+import {
+  withFileLock
+} from "./chunk-YBMMV4Y4.js";
+import {
+  writeFileAtomic
+} from "./chunk-MUBUQVC3.js";
+import {
+  external_exports
+} from "./chunk-OYMYCW7J.js";
+
+// src/lib/lookup-store.ts
+import { mkdir, readFile } from "fs/promises";
+import { join } from "path";
+var MAX_ENTRIES = 50;
+var StoredCandidateSchema = external_exports.object({
+  resourceId: external_exports.string(),
+  url: external_exports.string(),
+  title: external_exports.string(),
+  price: external_exports.string()
+});
+var StoredLookupSchema = external_exports.object({
+  lookupId: external_exports.string(),
+  at: external_exports.string(),
+  question: external_exports.string(),
+  decision: external_exports.string(),
+  candidates: external_exports.array(StoredCandidateSchema)
+});
+var StoreSchema = external_exports.object({
+  schemaVersion: external_exports.literal(1),
+  lookups: external_exports.array(StoredLookupSchema)
+});
+function storePath(dataDir) {
+  return join(dataDir, "lookups.json");
+}
+async function loadLookups(dataDir) {
+  let raw;
+  try {
+    raw = await readFile(storePath(dataDir), "utf8");
+  } catch {
+    return [];
+  }
+  let json;
+  try {
+    json = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  const parsed = StoreSchema.safeParse(json);
+  return parsed.success ? parsed.data.lookups : [];
+}
+async function recordLookup(dataDir, entry) {
+  await mkdir(dataDir, { recursive: true, mode: 448 });
+  const lockPath = `${storePath(dataDir)}.lock`;
+  await withFileLock(lockPath, async () => {
+    const existing = await loadLookups(dataDir);
+    const lookups = [entry, ...existing.filter((l) => l.lookupId !== entry.lookupId)].slice(
+      0,
+      MAX_ENTRIES
+    );
+    await writeFileAtomic(
+      storePath(dataDir),
+      `${JSON.stringify({ schemaVersion: 1, lookups }, null, 2)}
+`,
+      { mode: 420, dirMode: 448 }
+    );
+  });
+}
+async function latestLookup(dataDir) {
+  const lookups = await loadLookups(dataDir);
+  return lookups[0] ?? null;
+}
+async function findStoredCandidate(dataDir, resourceId) {
+  for (const lookup of await loadLookups(dataDir)) {
+    const hit = lookup.candidates.find((c) => c.resourceId === resourceId);
+    if (hit) return hit;
+  }
+  return null;
+}
+async function findLookupForResource(dataDir, match) {
+  for (const lookup of await loadLookups(dataDir)) {
+    const hit = lookup.candidates.some(
+      (c) => match.resourceId !== void 0 && c.resourceId === match.resourceId || match.url !== void 0 && c.url === match.url
+    );
+    if (hit) return lookup.lookupId;
+  }
+  return null;
+}
+
+export {
+  recordLookup,
+  latestLookup,
+  findStoredCandidate,
+  findLookupForResource
+};
+//# sourceMappingURL=chunk-JPHG2JW3.js.map

package/dist/chunk-JPHG2JW3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/lookup-store.ts"],"sourcesContent":["import { mkdir, readFile } from 'node:fs/promises';\nimport { join } from 'node:path';\nimport { z } from 'zod';\nimport { writeFileAtomic } from './atomic-json';\nimport { withFileLock } from './lock';\n\n/**\n * A small local ledger of recent lookups so `outcome --last` can target the most\n * recent one and `buy <resourceId>` can resolve the payable read URL a candidate\n * carried (the read route is keyed by handle/slug, not id, so an id alone can't\n * build the URL). Bounded and best-effort: a corrupt file reads as empty rather\n * than blocking a command. NOT an entitlement record, that is the library receipt.\n */\n\nconst MAX_ENTRIES = 50;\n\nconst StoredCandidateSchema = z.object({\n  resourceId: z.string(),\n  url: z.string(),\n  title: z.string(),\n  price: z.string(),\n});\nexport type StoredCandidate = z.infer<typeof StoredCandidateSchema>;\n\nconst StoredLookupSchema = z.object({\n  lookupId: z.string(),\n  at: z.string(),\n  question: z.string(),\n  decision: z.string(),\n  candidates: z.array(StoredCandidateSchema),\n});\nexport type StoredLookup = z.infer<typeof StoredLookupSchema>;\n\nconst StoreSchema = z.object({\n  schemaVersion: z.literal(1),\n  lookups: z.array(StoredLookupSchema),\n});\n\nfunction storePath(dataDir: string): string {\n  return join(dataDir, 'lookups.json');\n}\n\nexport async function loadLookups(dataDir: string): Promise<StoredLookup[]> {\n  let raw: string;\n  try {\n    raw = await readFile(storePath(dataDir), 'utf8');\n  } catch {\n    return [];\n  }\n  let json: unknown;\n  try {\n    json = JSON.parse(raw);\n  } catch {\n    return [];\n  }\n  const parsed = StoreSchema.safeParse(json);\n  return parsed.success ? parsed.data.lookups : [];\n}\n\n/** Prepend a lookup (newest first), cap to MAX_ENTRIES, persist under a lock so\n *  concurrent lookups don't drop each other's entry. */\nexport async function recordLookup(dataDir: string, entry: StoredLookup): Promise<void> {\n  await mkdir(dataDir, { recursive: true, mode: 0o700 });\n  const lockPath = `${storePath(dataDir)}.lock`;\n  await withFileLock(lockPath, async () => {\n    const existing = await loadLookups(dataDir);\n    const lookups = [entry, ...existing.filter((l) => l.lookupId !== entry.lookupId)].slice(\n      0,\n      MAX_ENTRIES,\n    );\n    await writeFileAtomic(\n      storePath(dataDir),\n      `${JSON.stringify({ schemaVersion: 1, lookups }, null, 2)}\\n`,\n      { mode: 0o644, dirMode: 0o700 },\n    );\n  });\n}\n\nexport async function latestLookup(dataDir: string): Promise<StoredLookup | null> {\n  const lookups = await loadLookups(dataDir);\n  return lookups[0] ?? null;\n}\n\n/** The stored candidate for a resourceId across recent lookups (newest first). */\nexport async function findStoredCandidate(\n  dataDir: string,\n  resourceId: string,\n): Promise<StoredCandidate | null> {\n  for (const lookup of await loadLookups(dataDir)) {\n    const hit = lookup.candidates.find((c) => c.resourceId === resourceId);\n    if (hit) return hit;\n  }\n  return null;\n}\n\n/** The most recent lookupId that surfaced this resource (by id or url), for\n *  purchase attribution (`X-Tenjin-Lookup-Id`). Null when no local lookup did. */\nexport async function findLookupForResource(\n  dataDir: string,\n  match: { resourceId?: string; url?: string },\n): Promise<string | null> {\n  for (const lookup of await loadLookups(dataDir)) {\n    const hit = lookup.candidates.some(\n      (c) =>\n        (match.resourceId !== undefined && c.resourceId === match.resourceId) ||\n        (match.url !== undefined && c.url === match.url),\n    );\n    if (hit) return lookup.lookupId;\n  }\n  return null;\n}\n"],"mappings":";;;;;;;;;;;;AAAA,SAAS,OAAO,gBAAgB;AAChC,SAAS,YAAY;AAarB,IAAM,cAAc;AAEpB,IAAM,wBAAwB,iBAAE,OAAO;AAAA,EACrC,YAAY,iBAAE,OAAO;AAAA,EACrB,KAAK,iBAAE,OAAO;AAAA,EACd,OAAO,iBAAE,OAAO;AAAA,EAChB,OAAO,iBAAE,OAAO;AAClB,CAAC;AAGD,IAAM,qBAAqB,iBAAE,OAAO;AAAA,EAClC,UAAU,iBAAE,OAAO;AAAA,EACnB,IAAI,iBAAE,OAAO;AAAA,EACb,UAAU,iBAAE,OAAO;AAAA,EACnB,UAAU,iBAAE,OAAO;AAAA,EACnB,YAAY,iBAAE,MAAM,qBAAqB;AAC3C,CAAC;AAGD,IAAM,cAAc,iBAAE,OAAO;AAAA,EAC3B,eAAe,iBAAE,QAAQ,CAAC;AAAA,EAC1B,SAAS,iBAAE,MAAM,kBAAkB;AACrC,CAAC;AAED,SAAS,UAAU,SAAyB;AAC1C,SAAO,KAAK,SAAS,cAAc;AACrC;AAEA,eAAsB,YAAY,SAA0C;AAC1E,MAAI;AACJ,MAAI;AACF,UAAM,MAAM,SAAS,UAAU,OAAO,GAAG,MAAM;AAAA,EACjD,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,MAAI;AACJ,MAAI;AACF,WAAO,KAAK,MAAM,GAAG;AAAA,EACvB,QAAQ;AACN,WAAO,CAAC;AAAA,EACV;AACA,QAAM,SAAS,YAAY,UAAU,IAAI;AACzC,SAAO,OAAO,UAAU,OAAO,KAAK,UAAU,CAAC;AACjD;AAIA,eAAsB,aAAa,SAAiB,OAAoC;AACtF,QAAM,MAAM,SAAS,EAAE,WAAW,MAAM,MAAM,IAAM,CAAC;AACrD,QAAM,WAAW,GAAG,UAAU,OAAO,CAAC;AACtC,QAAM,aAAa,UAAU,YAAY;AACvC,UAAM,WAAW,MAAM,YAAY,OAAO;AAC1C,UAAM,UAAU,CAAC,OAAO,GAAG,SAAS,OAAO,CAAC,MAAM,EAAE,aAAa,MAAM,QAAQ,CAAC,EAAE;AAAA,MAChF;AAAA,MACA;AAAA,IACF;AACA,UAAM;AAAA,MACJ,UAAU,OAAO;AAAA,MACjB,GAAG,KAAK,UAAU,EAAE,eAAe,GAAG,QAAQ,GAAG,MAAM,CAAC,CAAC;AAAA;AAAA,MACzD,EAAE,MAAM,KAAO,SAAS,IAAM;AAAA,IAChC;AAAA,EACF,CAAC;AACH;AAEA,eAAsB,aAAa,SAA+C;AAChF,QAAM,UAAU,MAAM,YAAY,OAAO;AACzC,SAAO,QAAQ,CAAC,KAAK;AACvB;AAGA,eAAsB,oBACpB,SACA,YACiC;AACjC,aAAW,UAAU,MAAM,YAAY,OAAO,GAAG;AAC/C,UAAM,MAAM,OAAO,WAAW,KAAK,CAAC,MAAM,EAAE,eAAe,UAAU;AACrE,QAAI,IAAK,QAAO;AAAA,EAClB;AACA,SAAO;AACT;AAIA,eAAsB,sBACpB,SACA,OACwB;AACxB,aAAW,UAAU,MAAM,YAAY,OAAO,GAAG;AAC/C,UAAM,MAAM,OAAO,WAAW;AAAA,MAC5B,CAAC,MACE,MAAM,eAAe,UAAa,EAAE,eAAe,MAAM,cACzD,MAAM,QAAQ,UAAa,EAAE,QAAQ,MAAM;AAAA,IAChD;AACA,QAAI,IAAK,QAAO,OAAO;AAAA,EACzB;AACA,SAAO;AACT;","names":[]}

package/dist/{chunk-ZPZFPVDN.js → chunk-MUBUQVC3.js}

@@ -64,4 +64,4 @@ export {
   writeFileAtomic,
   writeFileAtomicExclusive
 };
-//# sourceMappingURL=chunk-ZPZFPVDN.js.map
+//# sourceMappingURL=chunk-MUBUQVC3.js.map

package/dist/chunk-MUBUQVC3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/lib/atomic-json.ts"],"sourcesContent":["import { chmod, link, mkdir, open, rename, rm, writeFile } from 'node:fs/promises';\nimport { randomBytes } from 'node:crypto';\nimport { basename, dirname, join } from 'node:path';\n\n/** fs modes are no-ops on Windows; the 0600/0700 custody story does not apply. */\nconst isWindows = process.platform === 'win32';\n\nexport interface AtomicWriteOptions {\n  /** Mode for the written file (ignored on win32). Default 0o644. */\n  mode?: number;\n  /** Mode for the parent dir when this call creates it (ignored on win32). Default 0o755. */\n  dirMode?: number;\n}\n\n/**\n * Write `data` to `targetPath` atomically: a uniquely-named temp file is created\n * in the SAME directory (so the rename is atomic — a cross-filesystem rename is\n * not), given the final mode at open time, then renamed over the target. A\n * reader therefore sees either the old file or the fully-written new one, never\n * a partial write.\n *\n * The temp file is born with the caller's `mode` (0o600 for a wallet key) so the\n * bytes are never written through a world-readable descriptor; the follow-up\n * chmod only makes the mode exact under an unusual umask and only ever touches\n * the temp path, so the live target still appears atomically at its final mode.\n */\nexport async function writeFileAtomic(\n  targetPath: string,\n  data: string | Buffer,\n  opts: AtomicWriteOptions = {},\n): Promise<void> {\n  const dir = dirname(targetPath);\n  const fileMode = opts.mode ?? 0o644;\n  const dirMode = opts.dirMode ?? 0o755;\n\n  await mkdir(dir, { recursive: true, ...(isWindows ? {} : { mode: dirMode }) });\n\n  const tmpPath = join(dir, `.${basename(targetPath)}.${randomBytes(6).toString('hex')}.tmp`);\n  try {\n    await writeFile(tmpPath, data, isWindows ? undefined : { mode: fileMode });\n    if (!isWindows) await chmod(tmpPath, fileMode);\n    await rename(tmpPath, targetPath);\n  } catch (err) {\n    await rm(tmpPath, { force: true }).catch(() => undefined);\n    throw err;\n  }\n}\n\n/**\n * Like {@link writeFileAtomic} but NO-CLOBBER and crash-durable: the commit fails\n * with `EEXIST` when `targetPath` already exists instead of replacing it, and the\n * new entry is fsynced before returning. This is what a wallet key needs — two\n * concurrent `create`/`import` runs must not both \"succeed\" and silently lose one\n * key; the loser gets a distinguishable EEXIST the wallet layer maps to\n * WALLET_EXISTS.\n *\n * The temp file is fsynced, then `link()` commits it — link is atomic and throws\n * EEXIST if the target already exists, so the check-then-write race is closed at\n * the filesystem, not by an earlier stat. The parent dir is then fsynced so the\n * new entry survives a crash. On win32, link semantics differ and a directory\n * cannot be fsynced, so we fall back to an exclusive `wx` open (still atomic\n * create-or-EEXIST, just not crash-durable — win32 has no 0600 custody story to\n * protect anyway).\n */\nexport async function writeFileAtomicExclusive(\n  targetPath: string,\n  data: string,\n  opts: AtomicWriteOptions = {},\n): Promise<void> {\n  const dir = dirname(targetPath);\n  const fileMode = opts.mode ?? 0o644;\n  const dirMode = opts.dirMode ?? 0o755;\n\n  await mkdir(dir, { recursive: true, ...(isWindows ? {} : { mode: dirMode }) });\n\n  if (isWindows) {\n    const handle = await open(targetPath, 'wx');\n    try {\n      await handle.writeFile(data);\n      await handle.sync();\n    } finally {\n      await handle.close();\n    }\n    return;\n  }\n\n  const tmpPath = join(dir, `.${basename(targetPath)}.${randomBytes(6).toString('hex')}.tmp`);\n  try {\n    const handle = await open(tmpPath, 'wx', fileMode);\n    try {\n      await handle.writeFile(data);\n      await handle.chmod(fileMode); // exact mode even under an unusual umask\n      await handle.sync();\n    } finally {\n      await handle.close();\n    }\n    await link(tmpPath, targetPath); // atomic; throws EEXIST when the target exists\n    await fsyncDir(dir);\n  } finally {\n    // On success the temp is now a redundant link to the target; on EEXIST it is\n    // the orphaned write. Either way remove it before returning/throwing.\n    await rm(tmpPath, { force: true }).catch(() => undefined);\n  }\n}\n\n/** fsync a directory so a freshly linked entry is durable. Never called on win32. */\nasync function fsyncDir(dir: string): Promise<void> {\n  const handle = await open(dir, 'r');\n  try {\n    await handle.sync();\n  } finally {\n    await handle.close();\n  }\n}\n"],"mappings":";;;AAAA,SAAS,OAAO,MAAM,OAAO,MAAM,QAAQ,IAAI,iBAAiB;AAChE,SAAS,mBAAmB;AAC5B,SAAS,UAAU,SAAS,YAAY;AAGxC,IAAM,YAAY,QAAQ,aAAa;AAqBvC,eAAsB,gBACpB,YACA,MACA,OAA2B,CAAC,GACb;AACf,QAAM,MAAM,QAAQ,UAAU;AAC9B,QAAM,WAAW,KAAK,QAAQ;AAC9B,QAAM,UAAU,KAAK,WAAW;AAEhC,QAAM,MAAM,KAAK,EAAE,WAAW,MAAM,GAAI,YAAY,CAAC,IAAI,EAAE,MAAM,QAAQ,EAAG,CAAC;AAE7E,QAAM,UAAU,KAAK,KAAK,IAAI,SAAS,UAAU,CAAC,IAAI,YAAY,CAAC,EAAE,SAAS,KAAK,CAAC,MAAM;AAC1F,MAAI;AACF,UAAM,UAAU,SAAS,MAAM,YAAY,SAAY,EAAE,MAAM,SAAS,CAAC;AACzE,QAAI,CAAC,UAAW,OAAM,MAAM,SAAS,QAAQ;AAC7C,UAAM,OAAO,SAAS,UAAU;AAAA,EAClC,SAAS,KAAK;AACZ,UAAM,GAAG,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AACxD,UAAM;AAAA,EACR;AACF;AAkBA,eAAsB,yBACpB,YACA,MACA,OAA2B,CAAC,GACb;AACf,QAAM,MAAM,QAAQ,UAAU;AAC9B,QAAM,WAAW,KAAK,QAAQ;AAC9B,QAAM,UAAU,KAAK,WAAW;AAEhC,QAAM,MAAM,KAAK,EAAE,WAAW,MAAM,GAAI,YAAY,CAAC,IAAI,EAAE,MAAM,QAAQ,EAAG,CAAC;AAE7E,MAAI,WAAW;AACb,UAAM,SAAS,MAAM,KAAK,YAAY,IAAI;AAC1C,QAAI;AACF,YAAM,OAAO,UAAU,IAAI;AAC3B,YAAM,OAAO,KAAK;AAAA,IACpB,UAAE;AACA,YAAM,OAAO,MAAM;AAAA,IACrB;AACA;AAAA,EACF;AAEA,QAAM,UAAU,KAAK,KAAK,IAAI,SAAS,UAAU,CAAC,IAAI,YAAY,CAAC,EAAE,SAAS,KAAK,CAAC,MAAM;AAC1F,MAAI;AACF,UAAM,SAAS,MAAM,KAAK,SAAS,MAAM,QAAQ;AACjD,QAAI;AACF,YAAM,OAAO,UAAU,IAAI;AAC3B,YAAM,OAAO,MAAM,QAAQ;AAC3B,YAAM,OAAO,KAAK;AAAA,IACpB,UAAE;AACA,YAAM,OAAO,MAAM;AAAA,IACrB;AACA,UAAM,KAAK,SAAS,UAAU;AAC9B,UAAM,SAAS,GAAG;AAAA,EACpB,UAAE;AAGA,UAAM,GAAG,SAAS,EAAE,OAAO,KAAK,CAAC,EAAE,MAAM,MAAM,MAAS;AAAA,EAC1D;AACF;AAGA,eAAe,SAAS,KAA4B;AAClD,QAAM,SAAS,MAAM,KAAK,KAAK,GAAG;AAClC,MAAI;AACF,UAAM,OAAO,KAAK;AAAA,EACpB,UAAE;AACA,UAAM,OAAO,MAAM;AAAA,EACrB;AACF;","names":[]}

package/dist/{chunk-T4LKNY7T.js → chunk-NCE5NSN6.js}

@@ -1,8 +1,10 @@
 import { createRequire as __tenjinCreateRequire } from 'node:module'; const require = __tenjinCreateRequire(import.meta.url);
 import {
-  secp256k1,
   sha256
-} from "./chunk-Q53IYV2G.js";
+} from "./chunk-RY4XKNV3.js";
+import {
+  secp256k1
+} from "./chunk-QVX5MWJZ.js";
 import {
   BaseError,
   BytesSizeMismatchError,
@@ -12,6 +14,7 @@ import {
   InvalidLegacyVError,
   InvalidSerializableTransactionError,
   InvalidStorageKeySizeError,
+  LruMap,
   TipAboveFeeCapError,
   bytesRegex,
   bytesToHex,
@@ -20,6 +23,7 @@ import {
   concatHex,
   createCursor,
   encodeAbiParameters,
+  formatBlockParameter,
   from2 as from,
   fromBytes,
   hexToBigInt,
@@ -29,7 +33,6 @@ import {
   isAddress,
   isHex,
   keccak256,
-  keccak_256,
   maxUint256,
   numberToHex,
   size,
@@ -39,7 +42,98 @@ import {
   toBytes,
   toHex,
   trim
-} from "./chunk-BRJHUQSY.js";
+} from "./chunk-YALGASEU.js";
+import {
+  keccak_256
+} from "./chunk-HIVZG55D.js";
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/actions/public/getTransactionCount.js
+async function getTransactionCount(client, { address, blockHash, blockNumber, blockTag = "latest", requireCanonical }) {
+  const block = formatBlockParameter({
+    blockHash,
+    blockNumber,
+    blockTag,
+    requireCanonical
+  });
+  const count = await client.request({
+    method: "eth_getTransactionCount",
+    params: [address, block]
+  }, {
+    dedupe: typeof blockNumber === "bigint" || blockHash !== void 0
+  });
+  return hexToNumber(count);
+}
+
+// node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/nonceManager.js
+function createNonceManager(parameters) {
+  const { source } = parameters;
+  const deltaMap = /* @__PURE__ */ new Map();
+  const nonceMap = new LruMap(8192);
+  const promiseMap = /* @__PURE__ */ new Map();
+  const getKey = ({ address, chainId }) => `${address}.${chainId}`;
+  const resetCache = (key) => {
+    deltaMap.delete(key);
+    promiseMap.delete(key);
+  };
+  return {
+    async consume({ address, chainId, client }) {
+      const key = getKey({ address, chainId });
+      const promise = this.get({ address, chainId, client });
+      this.increment({ address, chainId });
+      const nonce = await promise;
+      await source.set({ address, chainId }, nonce);
+      nonceMap.set(key, nonce);
+      return nonce;
+    },
+    async increment({ address, chainId }) {
+      const key = getKey({ address, chainId });
+      const delta = deltaMap.get(key) ?? 0;
+      deltaMap.set(key, delta + 1);
+    },
+    async get({ address, chainId, client }) {
+      const key = getKey({ address, chainId });
+      let promise = promiseMap.get(key);
+      if (!promise) {
+        promise = (async () => {
+          try {
+            const nonce = await source.get({ address, chainId, client });
+            const previousNonce = nonceMap.get(key) ?? 0;
+            if (previousNonce > 0 && nonce <= previousNonce)
+              return previousNonce + 1;
+            nonceMap.delete(key);
+            return nonce;
+          } finally {
+            resetCache(key);
+          }
+        })();
+        promiseMap.set(key, promise);
+      }
+      const delta = deltaMap.get(key) ?? 0;
+      return delta + await promise;
+    },
+    reset({ address, chainId }) {
+      const key = getKey({ address, chainId });
+      nonceMap.delete(key);
+      resetCache(key);
+    }
+  };
+}
+function jsonRpc() {
+  return {
+    async get(parameters) {
+      const { address, client } = parameters;
+      return getTransactionCount(client, {
+        address,
+        blockTag: "pending"
+      });
+    },
+    set() {
+    }
+  };
+}
+var nonceManager = /* @__PURE__ */ createNonceManager({
+  source: jsonRpc()
+});
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/signature/serializeSignature.js
 function serializeSignature({ r, s, to = "hex", v, yParity }) {
@@ -65,6 +159,12 @@ function toRlp(bytes, to = "hex") {
     return bytesToHex(cursor.bytes);
   return cursor.bytes;
 }
+function bytesToRlp(bytes, to = "bytes") {
+  return toRlp(bytes, to);
+}
+function hexToRlp(hex, to = "hex") {
+  return toRlp(hex, to);
+}
 function getEncodable(bytes) {
   if (Array.isArray(bytes))
     return getEncodableList(bytes.map((x) => getEncodable(x)));
@@ -192,13 +292,10 @@ function blobsToProofs(parameters) {
   return to === "bytes" ? proofs : proofs.map((x) => bytesToHex(x));
 }
 
-// node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha256.js
-var sha2562 = sha256;
-
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/hash/sha256.js
-function sha2563(value, to_) {
+function sha2562(value, to_) {
   const to = to_ || "hex";
-  const bytes = sha2562(isHex(value, { strict: false }) ? toBytes(value) : value);
+  const bytes = sha256(isHex(value, { strict: false }) ? toBytes(value) : value);
   if (to === "bytes")
     return bytes;
   return toHex(bytes);
@@ -208,7 +305,7 @@ function sha2563(value, to_) {
 function commitmentToVersionedHash(parameters) {
   const { commitment, version = 1 } = parameters;
   const to = parameters.to ?? (typeof commitment === "string" ? "hex" : "bytes");
-  const versionedHash = sha2563(commitment, "bytes");
+  const versionedHash = sha2562(commitment, "bytes");
   versionedHash.set([version], 0);
   return to === "bytes" ? versionedHash : bytesToHex(versionedHash);
 }
@@ -786,6 +883,31 @@ function encodeField({ types, name, type, value }) {
 }
 
 // node_modules/.pnpm/viem@2.55.2_typescript@6.0.3_zod@4.4.3/node_modules/viem/_esm/utils/typedData.js
+function serializeTypedData(parameters) {
+  const { domain: domain_, message: message_, primaryType, types } = parameters;
+  const normalizeData = (struct, data_) => {
+    const data = { ...data_ };
+    for (const param of struct) {
+      const { name, type } = param;
+      if (type === "address")
+        data[name] = data[name].toLowerCase();
+    }
+    return data;
+  };
+  const domain = (() => {
+    if (!types.EIP712Domain)
+      return {};
+    if (!domain_)
+      return {};
+    return normalizeData(types.EIP712Domain, domain_);
+  })();
+  const message = (() => {
+    if (primaryType === "EIP712Domain")
+      return void 0;
+    return normalizeData(types[primaryType], message_);
+  })();
+  return stringify({ domain, message, primaryType, types });
+}
 function validateTypedData(parameters) {
   const { domain, message, primaryType, types } = parameters;
   const validateData = (struct, data) => {
@@ -845,6 +967,14 @@ function getTypesForEIP712Domain({ domain }) {
     domain?.salt && { name: "salt", type: "bytes32" }
   ].filter(Boolean);
 }
+function domainSeparator({ domain }) {
+  return hashDomain({
+    domain,
+    types: {
+      EIP712Domain: getTypesForEIP712Domain({ domain })
+    }
+  });
+}
 function validateReference(type) {
   if (type === "address" || type === "bool" || type === "string" || type.startsWith("bytes") || type.startsWith("uint") || type.startsWith("int"))
     throw new InvalidStructTypeError({ type });
@@ -883,18 +1013,43 @@ function hashAuthorization(parameters) {
 }
 
 export {
+  getTransactionCount,
+  createNonceManager,
+  nonceManager,
   serializeSignature,
   publicKeyToAddress,
   toRlp,
+  bytesToRlp,
+  hexToRlp,
   hashAuthorization,
+  presignMessagePrefix,
+  toPrefixedMessage,
   hashMessage,
   blobsToCommitments,
   blobsToProofs,
+  sha2562 as sha256,
+  commitmentToVersionedHash,
   commitmentsToVersionedHashes,
+  toBlobs,
   toBlobSidecars,
+  assertTransactionEIP7702,
+  assertTransactionEIP4844,
+  assertTransactionEIP1559,
+  assertTransactionEIP2930,
+  assertTransactionLegacy,
   getTransactionType,
+  serializeAccessList,
   serializeTransaction,
+  InvalidDomainError,
+  InvalidPrimaryTypeError,
+  InvalidStructTypeError,
+  serializeTypedData,
+  validateTypedData,
+  getTypesForEIP712Domain,
+  domainSeparator,
   hashTypedData,
+  hashDomain,
+  hashStruct,
   keccak2562 as keccak256
 };
-//# sourceMappingURL=chunk-T4LKNY7T.js.map
+//# sourceMappingURL=chunk-NCE5NSN6.js.map