@jaw.id/ui 0.4.2 → 0.4.5

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './justaNameInstance';
+export * from './reverseResolve';
 export * from './tokenPrice';
 export * from './formatAddress';
 export * from './tokenBalance';

package/dist/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC;AACpC,cAAc,kBAAkB,CAAC;AACjC,cAAc,cAAc,CAAC;AAC7B,cAAc,iBAAiB,CAAC;AAChC,cAAc,gBAAgB,CAAC;AAC/B,cAAc,qBAAqB,CAAC;AACpC,cAAc,gBAAgB,CAAC"}

package/dist/utils/reverseResolve.d.ts

@@ -0,0 +1,13 @@
+export interface ReverseInput {
+    address: string;
+    chainId: number;
+}
+export interface ResolvedIdentity {
+    name: string;
+    avatar?: string;
+}
+/** Reverse-resolve addresses to ENS names in one batched request (deduped, chunked at 50, parallel). Never rejects; unresolved addresses are omitted. Returns lowercased address -> name. */
+export declare function reverseResolveAddresses(inputs: ReverseInput[], rpcUrl: string): Promise<Record<string, string>>;
+/** Like {@link reverseResolveAddresses} but with `records=true`, so each name's avatar comes back in the same request. Returns lowercased address -> { name, avatar? }. */
+export declare function reverseResolveWithAvatars(inputs: ReverseInput[], rpcUrl: string): Promise<Record<string, ResolvedIdentity>>;
+//# sourceMappingURL=reverseResolve.d.ts.map

package/dist/utils/reverseResolve.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverseResolve.d.ts","sourceRoot":"","sources":["../../src/utils/reverseResolve.ts"],"names":[],"mappings":"AAIA,MAAM,WAAW,YAAY;IAC3B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAiFD,6LAA6L;AAC7L,wBAAsB,uBAAuB,CAAC,MAAM,EAAE,YAAY,EAAE,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAOrH;AAED,2KAA2K;AAC3K,wBAAsB,yBAAyB,CAC7C,MAAM,EAAE,YAAY,EAAE,EACtB,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAE3C"}

package/dist/utils-so0pTN_S.js

@@ -0,0 +1,269 @@
+//#region ../../node_modules/@noble/hashes/esm/_u64.js
+var e = /* @__PURE__ */ BigInt(2 ** 32 - 1), t = /* @__PURE__ */ BigInt(32);
+function n(n, r = !1) {
+	return r ? {
+		h: Number(n & e),
+		l: Number(n >> t & e)
+	} : {
+		h: Number(n >> t & e) | 0,
+		l: Number(n & e) | 0
+	};
+}
+function r(e, t = !1) {
+	let r = e.length, i = new Uint32Array(r), a = new Uint32Array(r);
+	for (let o = 0; o < r; o++) {
+		let { h: r, l: s } = n(e[o], t);
+		[i[o], a[o]] = [r, s];
+	}
+	return [i, a];
+}
+var i = (e, t, n) => e >>> n, a = (e, t, n) => e << 32 - n | t >>> n, o = (e, t, n) => e >>> n | t << 32 - n, s = (e, t, n) => e << 32 - n | t >>> n, c = (e, t, n) => e << 64 - n | t >>> n - 32, l = (e, t, n) => e >>> n - 32 | t << 64 - n, u = (e, t, n) => e << n | t >>> 32 - n, d = (e, t, n) => t << n | e >>> 32 - n, ee = (e, t, n) => t << n - 32 | e >>> 64 - n, f = (e, t, n) => e << n - 32 | t >>> 64 - n;
+function p(e, t, n, r) {
+	let i = (t >>> 0) + (r >>> 0);
+	return {
+		h: e + n + (i / 2 ** 32 | 0) | 0,
+		l: i | 0
+	};
+}
+var m = (e, t, n) => (e >>> 0) + (t >>> 0) + (n >>> 0), h = (e, t, n, r) => t + n + r + (e / 2 ** 32 | 0) | 0, g = (e, t, n, r) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (r >>> 0), _ = (e, t, n, r, i) => t + n + r + i + (e / 2 ** 32 | 0) | 0, v = (e, t, n, r, i) => (e >>> 0) + (t >>> 0) + (n >>> 0) + (r >>> 0) + (i >>> 0), te = (e, t, n, r, i, a) => t + n + r + i + a + (e / 2 ** 32 | 0) | 0, y = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+//#endregion
+//#region ../../node_modules/@noble/hashes/esm/utils.js
+function b(e) {
+	return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function x(e) {
+	if (!Number.isSafeInteger(e) || e < 0) throw Error("positive integer expected, got " + e);
+}
+function S(e, ...t) {
+	if (!b(e)) throw Error("Uint8Array expected");
+	if (t.length > 0 && !t.includes(e.length)) throw Error("Uint8Array expected of length " + t + ", got length=" + e.length);
+}
+function ne(e) {
+	if (typeof e != "function" || typeof e.create != "function") throw Error("Hash should be wrapped by utils.createHasher");
+	x(e.outputLen), x(e.blockLen);
+}
+function re(e, t = !0) {
+	if (e.destroyed) throw Error("Hash instance has been destroyed");
+	if (t && e.finished) throw Error("Hash#digest() has already been called");
+}
+function ie(e, t) {
+	S(e);
+	let n = t.outputLen;
+	if (e.length < n) throw Error("digestInto() expects output buffer of length at least " + n);
+}
+function ae(e) {
+	return new Uint32Array(e.buffer, e.byteOffset, Math.floor(e.byteLength / 4));
+}
+function oe(...e) {
+	for (let t = 0; t < e.length; t++) e[t].fill(0);
+}
+function se(e) {
+	return new DataView(e.buffer, e.byteOffset, e.byteLength);
+}
+function C(e, t) {
+	return e << 32 - t | e >>> t;
+}
+var w = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function T(e) {
+	return e << 24 & 4278190080 | e << 8 & 16711680 | e >>> 8 & 65280 | e >>> 24 & 255;
+}
+function E(e) {
+	for (let t = 0; t < e.length; t++) e[t] = T(e[t]);
+	return e;
+}
+var D = w ? (e) => e : E;
+function O(e) {
+	if (typeof e != "string") throw Error("string expected");
+	return new Uint8Array(new TextEncoder().encode(e));
+}
+function k(e) {
+	return typeof e == "string" && (e = O(e)), S(e), e;
+}
+function A(...e) {
+	let t = 0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		S(r), t += r.length;
+	}
+	let n = new Uint8Array(t);
+	for (let t = 0, r = 0; t < e.length; t++) {
+		let i = e[t];
+		n.set(i, r), r += i.length;
+	}
+	return n;
+}
+var j = class {};
+function M(e) {
+	let t = (t) => e().update(k(t)).digest(), n = e();
+	return t.outputLen = n.outputLen, t.blockLen = n.blockLen, t.create = () => e(), t;
+}
+function N(e = 32) {
+	if (y && typeof y.getRandomValues == "function") return y.getRandomValues(new Uint8Array(e));
+	if (y && typeof y.randomBytes == "function") return Uint8Array.from(y.randomBytes(e));
+	throw Error("crypto.getRandomValues must be defined");
+}
+//#endregion
+//#region ../../node_modules/@noble/curves/esm/abstract/utils.js
+var P = /* @__PURE__ */ BigInt(0), F = /* @__PURE__ */ BigInt(1);
+function I(e) {
+	return e instanceof Uint8Array || ArrayBuffer.isView(e) && e.constructor.name === "Uint8Array";
+}
+function L(e) {
+	if (!I(e)) throw Error("Uint8Array expected");
+}
+function R(e, t) {
+	if (typeof t != "boolean") throw Error(e + " boolean expected, got " + t);
+}
+function z(e) {
+	let t = e.toString(16);
+	return t.length & 1 ? "0" + t : t;
+}
+function B(e) {
+	if (typeof e != "string") throw Error("hex string expected, got " + typeof e);
+	return e === "" ? P : BigInt("0x" + e);
+}
+var V = typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", H = /* @__PURE__ */ Array.from({ length: 256 }, (e, t) => t.toString(16).padStart(2, "0"));
+function U(e) {
+	if (L(e), V) return e.toHex();
+	let t = "";
+	for (let n = 0; n < e.length; n++) t += H[e[n]];
+	return t;
+}
+var W = {
+	_0: 48,
+	_9: 57,
+	A: 65,
+	F: 70,
+	a: 97,
+	f: 102
+};
+function G(e) {
+	if (e >= W._0 && e <= W._9) return e - W._0;
+	if (e >= W.A && e <= W.F) return e - (W.A - 10);
+	if (e >= W.a && e <= W.f) return e - (W.a - 10);
+}
+function K(e) {
+	if (typeof e != "string") throw Error("hex string expected, got " + typeof e);
+	if (V) return Uint8Array.fromHex(e);
+	let t = e.length, n = t / 2;
+	if (t % 2) throw Error("hex string expected, got unpadded hex of length " + t);
+	let r = new Uint8Array(n);
+	for (let t = 0, i = 0; t < n; t++, i += 2) {
+		let n = G(e.charCodeAt(i)), a = G(e.charCodeAt(i + 1));
+		if (n === void 0 || a === void 0) {
+			let t = e[i] + e[i + 1];
+			throw Error("hex string expected, got non-hex character \"" + t + "\" at index " + i);
+		}
+		r[t] = n * 16 + a;
+	}
+	return r;
+}
+function ce(e) {
+	return B(U(e));
+}
+function le(e) {
+	return L(e), B(U(Uint8Array.from(e).reverse()));
+}
+function q(e, t) {
+	return K(e.toString(16).padStart(t * 2, "0"));
+}
+function ue(e, t) {
+	return q(e, t).reverse();
+}
+function de(e, t, n) {
+	let r;
+	if (typeof t == "string") try {
+		r = K(t);
+	} catch (t) {
+		throw Error(e + " must be hex string or Uint8Array, cause: " + t);
+	}
+	else if (I(t)) r = Uint8Array.from(t);
+	else throw Error(e + " must be hex string or Uint8Array");
+	let i = r.length;
+	if (typeof n == "number" && i !== n) throw Error(e + " of length " + n + " expected, got " + i);
+	return r;
+}
+function J(...e) {
+	let t = 0;
+	for (let n = 0; n < e.length; n++) {
+		let r = e[n];
+		L(r), t += r.length;
+	}
+	let n = new Uint8Array(t);
+	for (let t = 0, r = 0; t < e.length; t++) {
+		let i = e[t];
+		n.set(i, r), r += i.length;
+	}
+	return n;
+}
+var Y = (e) => typeof e == "bigint" && P <= e;
+function X(e, t, n) {
+	return Y(e) && Y(t) && Y(n) && t <= e && e < n;
+}
+function fe(e, t, n, r) {
+	if (!X(t, n, r)) throw Error("expected valid " + e + ": " + n + " <= n < " + r + ", got " + t);
+}
+function pe(e) {
+	let t;
+	for (t = 0; e > P; e >>= F, t += 1);
+	return t;
+}
+var me = (e) => (F << BigInt(e)) - F, Z = (e) => new Uint8Array(e), Q = (e) => Uint8Array.from(e);
+function he(e, t, n) {
+	if (typeof e != "number" || e < 2) throw Error("hashLen must be a number");
+	if (typeof t != "number" || t < 2) throw Error("qByteLen must be a number");
+	if (typeof n != "function") throw Error("hmacFn must be a function");
+	let r = Z(e), i = Z(e), a = 0, o = () => {
+		r.fill(1), i.fill(0), a = 0;
+	}, s = (...e) => n(i, r, ...e), c = (e = Z(0)) => {
+		i = s(Q([0]), e), r = s(), e.length !== 0 && (i = s(Q([1]), e), r = s());
+	}, l = () => {
+		if (a++ >= 1e3) throw Error("drbg: tried 1000 values");
+		let e = 0, n = [];
+		for (; e < t;) {
+			r = s();
+			let t = r.slice();
+			n.push(t), e += r.length;
+		}
+		return J(...n);
+	};
+	return (e, t) => {
+		o(), c(e);
+		let n;
+		for (; !(n = t(l()));) c();
+		return o(), n;
+	};
+}
+var ge = {
+	bigint: (e) => typeof e == "bigint",
+	function: (e) => typeof e == "function",
+	boolean: (e) => typeof e == "boolean",
+	string: (e) => typeof e == "string",
+	stringOrUint8Array: (e) => typeof e == "string" || I(e),
+	isSafeInteger: (e) => Number.isSafeInteger(e),
+	array: (e) => Array.isArray(e),
+	field: (e, t) => t.Fp.isValid(e),
+	hash: (e) => typeof e == "function" && Number.isSafeInteger(e.outputLen)
+};
+function $(e, t, n = {}) {
+	let r = (t, n, r) => {
+		let i = ge[n];
+		if (typeof i != "function") throw Error("invalid validator function");
+		let a = e[t];
+		if (!(r && a === void 0) && !i(a, e)) throw Error("param " + String(t) + " is invalid. Expected " + n + ", got " + a);
+	};
+	for (let [e, n] of Object.entries(t)) r(e, n, !1);
+	for (let [e, t] of Object.entries(n)) r(e, t, !0);
+	return e;
+}
+function _e(e) {
+	let t = /* @__PURE__ */ new WeakMap();
+	return (n, ...r) => {
+		let i = t.get(n);
+		if (i !== void 0) return i;
+		let a = e(n, ...r);
+		return t.set(n, a), a;
+	};
+}
+//#endregion
+export { C as A, v as B, x as C, M as D, A as E, h as F, c as G, f as H, m as I, s as J, l as K, _ as L, k as M, ae as N, se as O, p as P, g as R, ne as S, oe as T, u as U, ee as V, d as W, a as X, i as Y, r as Z, z as _, U as a, S as b, J as c, K as d, X as f, ue as g, q as h, me as i, D as j, N as k, he as l, _e as m, R as n, ce as o, I as p, o as q, pe as r, le as s, fe as t, de as u, $ as v, ie as w, re as x, j as y, te as z };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@jaw.id/ui",
   "description": "Pre-built React dialogs for JAW.id",
-  "version": "0.4.2",
+  "version": "0.4.5",
   "license": "MIT",
   "type": "module",
   "sideEffects": [
@@ -40,7 +40,7 @@
     "react-dom": ">=18.0.0"
   },
   "dependencies": {
-    "@jaw.id/core": "0.4.0",
+    "@jaw.id/core": "0.4.2",
     "@hookform/resolvers": "^5.2.2",
     "@justaname.id/sdk": "^0.2.204",
     "@radix-ui/react-accordion": "^1.2.12",

package/dist/ccip-DrLXsCxz.js

@@ -1,147 +0,0 @@
-import { B as p, g as m, s as w, d as k, i as b, l as L, a as O, c as R, b as E, e as x, H as y, f as M } from "./index-DN4LuV_Z.js";
-class S extends p {
-  constructor({ callbackSelector: s, cause: e, data: o, extraData: n, sender: c, urls: t }) {
-    super(e.shortMessage || "An error occurred while fetching for an offchain result.", {
-      cause: e,
-      metaMessages: [
-        ...e.metaMessages || [],
-        e.metaMessages?.length ? "" : [],
-        "Offchain Gateway Call:",
-        t && [
-          "  Gateway URL(s):",
-          ...t.map((i) => `    ${m(i)}`)
-        ],
-        `  Sender: ${c}`,
-        `  Data: ${o}`,
-        `  Callback selector: ${s}`,
-        `  Extra data: ${n}`
-      ].flat(),
-      name: "OffchainLookupError"
-    });
-  }
-}
-class $ extends p {
-  constructor({ result: s, url: e }) {
-    super("Offchain gateway response is malformed. Response data must be a hex value.", {
-      metaMessages: [
-        `Gateway URL: ${m(e)}`,
-        `Response: ${w(s)}`
-      ],
-      name: "OffchainLookupResponseMalformedError"
-    });
-  }
-}
-class q extends p {
-  constructor({ sender: s, to: e }) {
-    super("Reverted sender address does not match target contract address (`to`).", {
-      metaMessages: [
-        `Contract address: ${e}`,
-        `OffchainLookup sender address: ${s}`
-      ],
-      name: "OffchainLookupSenderMismatchError"
-    });
-  }
-}
-const A = "0x556f1830", T = {
-  name: "OffchainLookup",
-  type: "error",
-  inputs: [
-    {
-      name: "sender",
-      type: "address"
-    },
-    {
-      name: "urls",
-      type: "string[]"
-    },
-    {
-      name: "callData",
-      type: "bytes"
-    },
-    {
-      name: "callbackFunction",
-      type: "bytes4"
-    },
-    {
-      name: "extraData",
-      type: "bytes"
-    }
-  ]
-};
-async function D(d, { blockNumber: s, blockTag: e, data: o, to: n }) {
-  const { args: c } = k({
-    data: o,
-    abi: [T]
-  }), [t, i, l, a, r] = c, { ccipRead: f } = d, h = f && typeof f?.request == "function" ? f.request : C;
-  try {
-    if (!b(n, t))
-      throw new q({ sender: t, to: n });
-    const u = i.includes(L) ? await O({
-      data: l,
-      ccipRequest: h
-    }) : await h({ data: l, sender: t, urls: i }), { data: g } = await R(d, {
-      blockNumber: s,
-      blockTag: e,
-      data: E([
-        a,
-        x([{ type: "bytes" }, { type: "bytes" }], [u, r])
-      ]),
-      to: n
-    });
-    return g;
-  } catch (u) {
-    throw new S({
-      callbackSelector: a,
-      cause: u,
-      data: o,
-      extraData: r,
-      sender: t,
-      urls: i
-    });
-  }
-}
-async function C({ data: d, sender: s, urls: e }) {
-  let o = new Error("An unknown error occurred.");
-  for (let n = 0; n < e.length; n++) {
-    const c = e[n], t = c.includes("{data}") ? "GET" : "POST", i = t === "POST" ? { data: d, sender: s } : void 0, l = t === "POST" ? { "Content-Type": "application/json" } : {};
-    try {
-      const a = await fetch(c.replace("{sender}", s.toLowerCase()).replace("{data}", d), {
-        body: JSON.stringify(i),
-        headers: l,
-        method: t
-      });
-      let r;
-      if (a.headers.get("Content-Type")?.startsWith("application/json") ? r = (await a.json()).data : r = await a.text(), !a.ok) {
-        o = new y({
-          body: i,
-          details: r?.error ? w(r.error) : a.statusText,
-          headers: a.headers,
-          status: a.status,
-          url: c
-        });
-        continue;
-      }
-      if (!M(r)) {
-        o = new $({
-          result: r,
-          url: c
-        });
-        continue;
-      }
-      return r;
-    } catch (a) {
-      o = new y({
-        body: i,
-        details: a.message,
-        url: c
-      });
-    }
-  }
-  throw o;
-}
-export {
-  C as ccipRequest,
-  D as offchainLookup,
-  T as offchainLookupAbiItem,
-  A as offchainLookupSignature
-};