@invisi-labs/primitives 0.0.0-stage → 1.2.0

package/README.md

@@ -1,3 +1,5 @@
-# Temporary Holding Version
+# @invisi-labs/primitives
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Invisi Protocol pure cryptographic primitives.
+
+Install with `npm install @invisi-labs/primitives@1.2.0`. API documentation and runnable examples are in the [SDK repository](https://github.com/invisi-lab/invisi-sdk-ts).

package/dist/address.cjs

@@ -0,0 +1,263 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// src/address-entry.ts
+var address_entry_exports = {};
+__export(address_entry_exports, {
+  ReceivingAddress: () => ReceivingAddress,
+  decodeAddress: () => decodeAddress
+});
+module.exports = __toCommonJS(address_entry_exports);
+
+// src/address/address.ts
+var import_secp256k1 = require("@noble/curves/secp256k1");
+var import_sha3 = require("@noble/hashes/sha3");
+var import_utils2 = require("@noble/hashes/utils");
+var import_ethers = require("ethers");
+
+// src/fmd/fmd.ts
+var import_blake2b2 = require("@noble/hashes/blake2b");
+var import_utils = require("@noble/hashes/utils");
+
+// src/fmd/decaf377.ts
+var import_edwards = require("@noble/curves/abstract/edwards");
+var import_modular = require("@noble/curves/abstract/modular");
+var import_blake2b = require("@noble/hashes/blake2b");
+var FQ = 8444461749428370424248824938781546531375899335154063827935233455917409239041n;
+var FR = 2111115437357092606062206234695386632838870926408408195193685246394721360383n;
+var field = (0, import_modular.Field)(FQ, 253, true);
+var f = (n) => (0, import_modular.mod)(n, FQ);
+function secureRandomBytes(length) {
+  const webCrypto = globalThis.crypto;
+  if (!webCrypto?.getRandomValues) throw new Error("WebCrypto secure randomness is unavailable");
+  return webCrypto.getRandomValues(new Uint8Array(length));
+}
+var curve = (0, import_edwards.twistedEdwards)({
+  a: FQ - 1n,
+  d: 3021n,
+  Fp: field,
+  n: FR,
+  h: 4n,
+  Gx: 4959445789346820725352484487855828915252512307947624787834978378872129235627n,
+  Gy: 6060471950081851567114691557659790004756535011754163002297540472747064943288n,
+  hash: import_blake2b.blake2b,
+  randomBytes: (length = 32) => secureRandomBytes(length)
+});
+var generator = curve.ExtendedPoint.BASE;
+function readLE(bytes) {
+  let n = 0n;
+  for (let i = bytes.length - 1; i >= 0; i--) n = n << 8n | BigInt(bytes[i]);
+  return n;
+}
+function decodePoint(bytes) {
+  if (!(bytes instanceof Uint8Array) || bytes.length !== 32)
+    throw new Error("Invalid Decaf377 encoding length");
+  const s = readLE(bytes);
+  if (s >= FQ || (s & 1n) !== 0n || bytes[31] >> 5 !== 0)
+    throw new Error("Invalid Decaf377 encoding");
+  const ss = f(s * s);
+  const u1 = f(1n - ss);
+  const u2 = f(u1 * u1 - 4n * 3021n * ss);
+  const denominator = f(u2 * u1 * u1);
+  if (denominator === 0n) throw new Error("Invalid Decaf377 encoding");
+  let v;
+  try {
+    v = field.sqrt(field.inv(denominator));
+  } catch {
+    throw new Error("Invalid Decaf377 encoding");
+  }
+  const twoSU1 = f(2n * s * u1);
+  if ((f(twoSU1 * v) & 1n) !== 0n) v = f(-v);
+  const x = f(twoSU1 * v * v * u2);
+  const y = f((1n + ss) * v * u1);
+  return curve.ExtendedPoint.fromAffine({ x, y });
+}
+function isIdentity(point) {
+  return point.ex === 0n;
+}
+
+// src/fmd/fmd.ts
+function requireBytes(value, length, name) {
+  if (!(value instanceof Uint8Array) || value.length !== length)
+    throw new TypeError(`${name} must be a ${length}-byte Uint8Array`);
+}
+function validateClueKey(clueKey) {
+  requireBytes(clueKey, 32, "Clue key");
+  if (isIdentity(decodePoint(clueKey))) throw new Error("Clue key must not be the identity");
+}
+
+// src/address/address.ts
+var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+function identityBytes(value) {
+  if (typeof value !== "bigint" && (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)))
+    throw new Error("invalid owner address encoding");
+  const n = BigInt(value);
+  if (n <= 0n || n >= 1n << 160n)
+    throw new RangeError("owner address must be a nonzero EVM owner address");
+  return (0, import_utils2.hexToBytes)(n.toString(16).padStart(40, "0"));
+}
+function receivingKeys(keys) {
+  const publicKey = keys.viewingPublicKey;
+  if (!(publicKey instanceof Uint8Array) || publicKey.length !== 33 || publicKey[0] !== 2 && publicKey[0] !== 3)
+    throw new Error("invalid compressed viewing public key");
+  import_secp256k1.secp256k1.ProjectivePoint.fromHex(publicKey).assertValidity();
+  validateClueKey(keys.clueKey);
+  return { viewingPublicKey: Uint8Array.from(publicKey), clueKey: Uint8Array.from(keys.clueKey) };
+}
+function checkedText(prefix, data) {
+  const digest = (0, import_sha3.keccak_256)((0, import_utils2.utf8ToBytes)("Invisi.AddressCaseChecksum.v1:" + prefix + data));
+  return prefix + Array.from(
+    data,
+    (character, i) => digest[i >> 3] >> 7 - (i & 7) & 1 ? character.toUpperCase() : character
+  ).join("");
+}
+function encode(prefix, payload) {
+  let buffer = 0, bits = 0, data = "";
+  for (const byte of payload) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      data += ALPHABET[buffer >>> bits & 31];
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits) data += ALPHABET[buffer << 5 - bits & 31];
+  return checkedText(prefix, data);
+}
+function encodeLongAddress(recipient) {
+  const identity = identityBytes(recipient.ownerAddress), keys = receivingKeys(recipient);
+  return encode("0i", (0, import_utils2.concatBytes)(identity, keys.viewingPublicKey, keys.clueKey));
+}
+function encodeShortAddress(ownerAddress) {
+  const identity = identityBytes(ownerAddress);
+  return (0, import_ethers.getAddress)(
+    typeof ownerAddress === "string" ? ownerAddress : `0x${(0, import_utils2.bytesToHex)(identity)}`
+  );
+}
+function decodeAddress(address) {
+  if (typeof address !== "string") throw new TypeError("address must be text");
+  if (address.startsWith("0x")) {
+    const owner = (0, import_ethers.getAddress)(address);
+    return { kind: "short", ownerAddress: `0x${(0, import_utils2.bytesToHex)(identityBytes(owner))}` };
+  }
+  if (!address.startsWith("0i")) throw new Error("invalid Invisi address prefix");
+  const prefix = "0i";
+  if (address.length !== 138) throw new Error("invalid address length");
+  const data = address.slice(prefix.length).toLowerCase();
+  if (Array.from(data).some((character) => !ALPHABET.includes(character)))
+    throw new Error("invalid address alphabet");
+  if (checkedText(prefix, data) !== address) throw new Error("invalid address case checksum");
+  let buffer = 0, bits = 0;
+  const payload = [];
+  for (const character of data) {
+    buffer = buffer << 5 | ALPHABET.indexOf(character);
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      payload.push(buffer >>> bits & 255);
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits !== 0 || buffer !== 0) throw new Error("noncanonical address padding");
+  const raw = Uint8Array.from(payload);
+  const ownerAddress = `0x${(0, import_utils2.bytesToHex)(identityBytes(`0x${(0, import_utils2.bytesToHex)(raw.subarray(0, 20))}`))}`;
+  return {
+    kind: "long",
+    ownerAddress,
+    ...receivingKeys({ viewingPublicKey: raw.slice(20, 53), clueKey: raw.slice(53) })
+  };
+}
+
+// src/errors.ts
+var MissingCapabilityError = class extends Error {
+  constructor(capability) {
+    super(`Missing ${capability} capability`);
+    this.capability = capability;
+    this.name = "MissingCapabilityError";
+  }
+  code = "MISSING_CAPABILITY";
+};
+
+// src/address/receiving-address.ts
+var ReceivingAddress = class _ReceivingAddress {
+  #text;
+  constructor(text) {
+    const decoded = decodeAddress(text);
+    this.#text = decoded.kind === "short" ? encodeShortAddress(decoded.ownerAddress) : text;
+    Object.freeze(this);
+  }
+  static parse(text) {
+    return new _ReceivingAddress(text);
+  }
+  static from(recipient) {
+    return new _ReceivingAddress(encodeLongAddress(recipient));
+  }
+  static fromIdentity(identity) {
+    return new _ReceivingAddress(encodeShortAddress(identity));
+  }
+  get ownerAddress() {
+    return decodeAddress(this.#text).ownerAddress;
+  }
+  get kind() {
+    return decodeAddress(this.#text).kind;
+  }
+  getReceivingKeys() {
+    const decoded = decodeAddress(this.#text);
+    if (decoded.kind === "short") {
+      throw new MissingCapabilityError("resolved receiving keys");
+    }
+    return { viewingPublicKey: decoded.viewingPublicKey, clueKey: decoded.clueKey };
+  }
+  async resolve(lookup) {
+    if (this.kind === "long") {
+      return this;
+    }
+    if (!lookup) {
+      throw new MissingCapabilityError("explicit registry lookup");
+    }
+    const keys = await lookup(this.ownerAddress);
+    if (!keys) {
+      throw new Error("owner address is not registered");
+    }
+    return _ReceivingAddress.from({
+      ownerAddress: this.ownerAddress,
+      viewingPublicKey: keys.viewingPublicKey,
+      clueKey: keys.clueKey
+    });
+  }
+  get viewingPublicKey() {
+    return this.getReceivingKeys().viewingPublicKey;
+  }
+  get clueKey() {
+    return this.getReceivingKeys().clueKey;
+  }
+  toString() {
+    return this.#text;
+  }
+  toJSON() {
+    return this.#text;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ReceivingAddress,
+  decodeAddress
+});
+//# sourceMappingURL=address.cjs.map

package/dist/address.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/address-entry.ts","../src/address/address.ts","../src/fmd/fmd.ts","../src/fmd/decaf377.ts","../src/errors.ts","../src/address/receiving-address.ts"],"sourcesContent":["/** Public receiving addresses without wallet key derivation or a hashing backend. */\nexport { decodeAddress } from \"./address/address\";\nexport type { DecodedAddress, ReceivingKeyLookup } from \"./address/address\";\nexport { ReceivingAddress } from \"./address/receiving-address\";\nexport type { ReceivingKeys } from \"./types\";\n","import { secp256k1 } from \"@noble/curves/secp256k1\";\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from \"@noble/hashes/utils\";\nimport { getAddress } from \"ethers\";\nimport { validateClueKey } from \"../fmd/fmd\";\n\nexport interface ReceivingAddress {\n    ownerAddress: `0x${string}`;\n    viewingPublicKey: Uint8Array;\n    clueKey: Uint8Array;\n}\nexport type DecodedAddress =\n    ({ kind: \"long\" } & ReceivingAddress) | { kind: \"short\"; ownerAddress: `0x${string}` };\nexport type ReceivingKeyLookup = (\n    ownerAddress: `0x${string}`\n) => Promise<Pick<ReceivingAddress, \"viewingPublicKey\" | \"clueKey\"> | null | undefined>;\nconst ALPHABET = \"qpzry9x8gf2tvdw0s3jn54khce6mua7l\";\ntype Identity = bigint | `0x${string}`;\n\nfunction identityBytes(value: Identity): Uint8Array {\n    if (\n        typeof value !== \"bigint\" &&\n        (typeof value !== \"string\" || !/^0x[0-9a-fA-F]{40}$/.test(value))\n    )\n        throw new Error(\"invalid owner address encoding\");\n    const n = BigInt(value);\n    if (n <= 0n || n >= 1n << 160n)\n        throw new RangeError(\"owner address must be a nonzero EVM owner address\");\n    return hexToBytes(n.toString(16).padStart(40, \"0\"));\n}\nfunction receivingKeys(keys: Pick<ReceivingAddress, \"viewingPublicKey\" | \"clueKey\">) {\n    const publicKey = keys.viewingPublicKey;\n    if (\n        !(publicKey instanceof Uint8Array) ||\n        publicKey.length !== 33 ||\n        (publicKey[0] !== 2 && publicKey[0] !== 3)\n    )\n        throw new Error(\"invalid compressed viewing public key\");\n    secp256k1.ProjectivePoint.fromHex(publicKey).assertValidity();\n    validateClueKey(keys.clueKey);\n    return { viewingPublicKey: Uint8Array.from(publicKey), clueKey: Uint8Array.from(keys.clueKey) };\n}\nfunction checkedText(prefix: string, data: string): string {\n    const digest = keccak_256(utf8ToBytes(\"Invisi.AddressCaseChecksum.v1:\" + prefix + data));\n    return (\n        prefix +\n        Array.from(data, (character, i) =>\n            (digest[i >> 3]! >> (7 - (i & 7))) & 1 ? character.toUpperCase() : character\n        ).join(\"\")\n    );\n}\nfunction encode(prefix: string, payload: Uint8Array): string {\n    let buffer = 0,\n        bits = 0,\n        data = \"\";\n    for (const byte of payload) {\n        buffer = (buffer << 8) | byte;\n        bits += 8;\n        while (bits >= 5) {\n            bits -= 5;\n            data += ALPHABET[(buffer >>> bits) & 31];\n        }\n        buffer &= (1 << bits) - 1;\n    }\n    if (bits) data += ALPHABET[(buffer << (5 - bits)) & 31];\n    return checkedText(prefix, data);\n}\n\n/** 138 characters: 0i plus the complete offline receiving materials. */\nexport function encodeLongAddress(recipient: ReceivingAddress): string {\n    const identity = identityBytes(recipient.ownerAddress),\n        keys = receivingKeys(recipient);\n    return encode(\"0i\", concatBytes(identity, keys.viewingPublicKey, keys.clueKey));\n}\n/** The owner's 42-character checksummed EVM address; receiving keys require a chosen registry. */\nexport function encodeShortAddress(ownerAddress: Identity): string {\n    const identity = identityBytes(ownerAddress);\n    return getAddress(\n        typeof ownerAddress === \"string\" ? ownerAddress : `0x${bytesToHex(identity)}`\n    );\n}\n\n/** Standard EVM short addresses or a full 0i address with a strict custom Base32 case checksum. */\nexport function decodeAddress(address: string): DecodedAddress {\n    if (typeof address !== \"string\") throw new TypeError(\"address must be text\");\n    if (address.startsWith(\"0x\")) {\n        const owner = getAddress(address) as `0x${string}`;\n        return { kind: \"short\", ownerAddress: `0x${bytesToHex(identityBytes(owner))}` };\n    }\n    if (!address.startsWith(\"0i\")) throw new Error(\"invalid Invisi address prefix\");\n    const prefix = \"0i\";\n    if (address.length !== 138) throw new Error(\"invalid address length\");\n    const data = address.slice(prefix.length).toLowerCase();\n    if (Array.from(data).some((character) => !ALPHABET.includes(character)))\n        throw new Error(\"invalid address alphabet\");\n    if (checkedText(prefix, data) !== address) throw new Error(\"invalid address case checksum\");\n    let buffer = 0,\n        bits = 0;\n    const payload: number[] = [];\n    for (const character of data) {\n        buffer = (buffer << 5) | ALPHABET.indexOf(character);\n        bits += 5;\n        if (bits >= 8) {\n            bits -= 8;\n            payload.push((buffer >>> bits) & 255);\n        }\n        buffer &= (1 << bits) - 1;\n    }\n    if (bits !== 0 || buffer !== 0) throw new Error(\"noncanonical address padding\");\n    const raw = Uint8Array.from(payload);\n    const ownerAddress =\n        `0x${bytesToHex(identityBytes(`0x${bytesToHex(raw.subarray(0, 20))}`))}` as const;\n    return {\n        kind: \"long\",\n        ownerAddress,\n        ...receivingKeys({ viewingPublicKey: raw.slice(20, 53), clueKey: raw.slice(53) }),\n    };\n}\n\n/** Normalize either address into the same payment input. Long addresses never query. */\nexport async function resolveAddress(\n    address: string,\n    options: { lookup?: ReceivingKeyLookup } = {}\n): Promise<ReceivingAddress> {\n    const decoded = decodeAddress(address);\n    if (decoded.kind === \"long\")\n        return {\n            ownerAddress: decoded.ownerAddress,\n            viewingPublicKey: decoded.viewingPublicKey,\n            clueKey: decoded.clueKey,\n        };\n    if (!options.lookup) throw new Error(\"short address requires an explicit registry lookup\");\n    const keys = await options.lookup(decoded.ownerAddress);\n    if (!keys) throw new Error(\"owner address is not registered\");\n    return { ownerAddress: decoded.ownerAddress, ...receivingKeys(keys) };\n}\n","/**\n * Frozen S-FMD profile: decaf377-fmd 2.1.1, 24-bit clues (68 bytes).\n * Only FMD detection keys belong here; these are not transaction ownership keys.\n *\n * SECURITY: the noble Edwards arithmetic and this exact Decaf codec port use\n * JavaScript BigInt. They do not provide constant-time execution or reliable\n * secret erasure. This new composition has not received an independent audit.\n */\nimport { blake2b } from \"@noble/hashes/blake2b\";\nimport { concatBytes, utf8ToBytes } from \"@noble/hashes/utils\";\nimport {\n    FR,\n    decodePoint,\n    encodePoint,\n    generator,\n    inverseScalar,\n    isIdentity,\n    multiply,\n    readLE,\n    secureRandomBytes,\n    writeLE,\n} from \"./decaf377.js\";\n\nconst PRECISION = 24;\nfunction requireBytes(value: Uint8Array, length: number, name: string): void {\n    if (!(value instanceof Uint8Array) || value.length !== length)\n        throw new TypeError(`${name} must be a ${length}-byte Uint8Array`);\n}\nfunction detectionScalar(key: Uint8Array): bigint {\n    requireBytes(key, 32, \"Detection key\");\n    const scalar = readLE(key);\n    if (scalar === 0n || scalar >= FR)\n        throw new Error(\"Detection key must be a canonical nonzero Decaf377 scalar\");\n    return scalar;\n}\nfunction hash(domain: string, ...parts: Uint8Array[]): Uint8Array {\n    // Rust blake2b_simd defaults to 64 output bytes and zero-pads personalization.\n    const personalization = new Uint8Array(16);\n    personalization.set(utf8ToBytes(`decaf377-fmd.${domain}`));\n    return blake2b(concatBytes(...parts), { dkLen: 64, personalization });\n}\nconst hashScalar = (domain: string, ...parts: Uint8Array[]) => readLE(hash(domain, ...parts)) % FR;\nconst childOffset = (clueKey: Uint8Array, index: number) =>\n    hashScalar(\"hkd\", clueKey, Uint8Array.of(index));\nconst hashBit = (p: Uint8Array, shared: Uint8Array, q: Uint8Array) =>\n    hash(\"bit\", p, shared, q)[0]! & 1;\n\n/** Derive the canonical 32-byte Decaf377 clue key from a nonzero FMD scalar. */\nexport function deriveClueKey(detectionKey: Uint8Array): Uint8Array {\n    return encodePoint(multiply(generator, detectionScalar(detectionKey)));\n}\n/** Reject malformed, noncanonical, or identity clue keys. */\nexport function validateClueKey(clueKey: Uint8Array): void {\n    requireBytes(clueKey, 32, \"Clue key\");\n    if (isIdentity(decodePoint(clueKey))) throw new Error(\"Clue key must not be the identity\");\n}\n/** Create a fixed 24-bit clue using a fresh WebCrypto random seed. */\nexport function createClue(clueKey: Uint8Array): Uint8Array {\n    validateClueKey(clueKey);\n    return createClueFromSeed(clueKey, secureRandomBytes(32));\n}\n/**\n * Deterministic interoperability/backend entry point. Seed must be independently\n * generated with a CSPRNG for every production clue; never reuse a fixed seed.\n */\nexport function createClueFromSeed(clueKey: Uint8Array, seed32: Uint8Array): Uint8Array {\n    validateClueKey(clueKey);\n    requireBytes(seed32, 32, \"Clue seed\");\n    const root = decodePoint(clueKey);\n    const r = hashScalar(\"rdv\", clueKey, seed32);\n    const z = hashScalar(\"zdv\", clueKey, seed32);\n    if (r === 0n) throw new Error(\"Degenerate clue seed\");\n    const p = encodePoint(multiply(generator, r));\n    const q = encodePoint(multiply(generator, z));\n    const ciphertext = new Uint8Array(3);\n    for (let i = 0; i < PRECISION; i++) {\n        const child = root.add(multiply(generator, childOffset(clueKey, i)));\n        const shared = encodePoint(multiply(child, r));\n        ciphertext[i >> 3] = ciphertext[i >> 3]! | ((hashBit(p, shared, q) ^ 1) << (i & 7));\n    }\n    const m = hashScalar(\"sca\", p, Uint8Array.of(PRECISION), ciphertext);\n    const y = ((z - m + FR) * inverseScalar(r)) % FR;\n    if (y === 0n) throw new Error(\"Degenerate clue seed\");\n    return concatBytes(p, writeLE(y), Uint8Array.of(PRECISION), ciphertext);\n}\n\n/** Check a full-precision clue locally without exporting the detection key. */\nexport function detectClue(detectionKey: Uint8Array, clue: Uint8Array): boolean {\n    const scalar = detectionScalar(detectionKey);\n    requireBytes(clue, 68, \"Clue\");\n    if (clue[64] !== PRECISION) return false;\n    const p = clue.slice(0, 32),\n        y = readLE(clue.slice(32, 64));\n    if (y === 0n || y >= FR) return false;\n    let point;\n    try {\n        point = decodePoint(p);\n    } catch {\n        return false;\n    }\n    if (isIdentity(point)) return false;\n    const ciphertext = clue.slice(65);\n    const m = hashScalar(\"sca\", p, Uint8Array.of(PRECISION), ciphertext);\n    const q = encodePoint(multiply(generator, m).add(multiply(point, y)));\n    const clueKey = deriveClueKey(detectionKey);\n    for (let i = 0; i < PRECISION; i++) {\n        const child = (scalar + childOffset(clueKey, i)) % FR;\n        const bit = hashBit(p, encodePoint(multiply(point, child)), q);\n        if ((bit ^ ((ciphertext[i >> 3]! >> (i & 7)) & 1)) !== 1) return false;\n    }\n    return true;\n}\n","/**\n * Internal Decaf377 codec, ported from decaf377 0.10.1 min_curve/element.rs.\n * Edwards group/field arithmetic is supplied by @noble/curves 1.9.1. The\n * Montgomery constants below are converted to ordinary field integers.\n * This JavaScript BigInt backend is NOT constant-time and has not been audited.\n */\nimport { twistedEdwards, type ExtPointType } from \"@noble/curves/abstract/edwards\";\nimport { Field, mod } from \"@noble/curves/abstract/modular\";\nimport { blake2b } from \"@noble/hashes/blake2b\";\n\nexport const FQ = 8444461749428370424248824938781546531375899335154063827935233455917409239041n;\nexport const FR = 2111115437357092606062206234695386632838870926408408195193685246394721360383n;\nconst field = Field(FQ, 253, true);\nconst f = (n: bigint) => mod(n, FQ);\nconst abs = (n: bigint) => ((n & 1n) === 0n ? n : f(-n));\n\nexport function secureRandomBytes(length: number): Uint8Array {\n    const webCrypto = (\n        globalThis as { crypto?: { getRandomValues(array: Uint8Array): Uint8Array } }\n    ).crypto;\n    if (!webCrypto?.getRandomValues) throw new Error(\"WebCrypto secure randomness is unavailable\");\n    return webCrypto.getRandomValues(new Uint8Array(length));\n}\n\nconst curve = twistedEdwards({\n    a: FQ - 1n,\n    d: 3021n,\n    Fp: field,\n    n: FR,\n    h: 4n,\n    Gx: 4959445789346820725352484487855828915252512307947624787834978378872129235627n,\n    Gy: 6060471950081851567114691557659790004756535011754163002297540472747064943288n,\n    hash: blake2b,\n    randomBytes: (length = 32) => secureRandomBytes(length),\n});\nexport type DecafPoint = ExtPointType;\nexport const generator: DecafPoint = curve.ExtendedPoint.BASE;\n\nexport function readLE(bytes: Uint8Array): bigint {\n    let n = 0n;\n    for (let i = bytes.length - 1; i >= 0; i--) n = (n << 8n) | BigInt(bytes[i]!);\n    return n;\n}\nexport function writeLE(n: bigint): Uint8Array {\n    const bytes = new Uint8Array(32);\n    for (let i = 0; i < 32; i++) {\n        bytes[i] = Number(n & 255n);\n        n >>= 8n;\n    }\n    return bytes;\n}\nexport function multiply(point: DecafPoint, scalar: bigint): DecafPoint {\n    return scalar === 0n ? curve.ExtendedPoint.ZERO : point.multiply(scalar);\n}\nexport function inverseScalar(scalar: bigint): bigint {\n    // Noble's field inversion uses Euclid. Neither this nor BigInt is constant-time.\n    return Field(FR).inv(scalar);\n}\n\n/** Canonical Decaf decoding, including the low-bit sign convention. */\nexport function decodePoint(bytes: Uint8Array): DecafPoint {\n    if (!(bytes instanceof Uint8Array) || bytes.length !== 32)\n        throw new Error(\"Invalid Decaf377 encoding length\");\n    const s = readLE(bytes);\n    if (s >= FQ || (s & 1n) !== 0n || bytes[31]! >> 5 !== 0)\n        throw new Error(\"Invalid Decaf377 encoding\");\n    const ss = f(s * s);\n    const u1 = f(1n - ss);\n    const u2 = f(u1 * u1 - 4n * 3021n * ss);\n    const denominator = f(u2 * u1 * u1);\n    // This is the square branch of Rust sqrt_ratio_zeta(1, denominator).\n    // Decompression rejects the nonsquare branch; root sign is fixed below.\n    if (denominator === 0n) throw new Error(\"Invalid Decaf377 encoding\");\n    let v: bigint;\n    try {\n        v = field.sqrt(field.inv(denominator));\n    } catch {\n        throw new Error(\"Invalid Decaf377 encoding\");\n    }\n    const twoSU1 = f(2n * s * u1);\n    if ((f(twoSU1 * v) & 1n) !== 0n) v = f(-v);\n    const x = f(twoSU1 * v * v * u2);\n    const y = f((1n + ss) * v * u1);\n    return curve.ExtendedPoint.fromAffine({ x, y });\n}\nexport function encodePoint(point: DecafPoint): Uint8Array {\n    const { ex: x, ez: z, et: t } = point;\n    if (x === 0n) return new Uint8Array(32);\n    const aMinusD = -3022n;\n    const u1 = f((x + t) * (x - t));\n    const denominator = f(u1 * aMinusD * x * x);\n    const v = field.sqrt(field.inv(denominator));\n    const u2 = abs(f(v * u1));\n    const u3 = f(u2 * z - t);\n    return writeLE(abs(f(aMinusD * v * u3 * x)));\n}\nexport function isIdentity(point: DecafPoint): boolean {\n    return point.ex === 0n;\n}\n","/** A requested permission was not explicitly supplied to this component. */\nexport class MissingCapabilityError extends Error {\n    readonly code = \"MISSING_CAPABILITY\";\n    constructor(readonly capability: string) {\n        super(`Missing ${capability} capability`);\n        this.name = \"MissingCapabilityError\";\n    }\n}\n","import { MissingCapabilityError } from \"../errors\";\nimport type { ReceivingKeys } from \"../types\";\nimport {\n    decodeAddress,\n    encodeLongAddress,\n    encodeShortAddress,\n    type ReceivingAddress as ReceivingData,\n    type ReceivingKeyLookup,\n} from \"./address\";\n\n/** Validated public receiving material. A short address requires an explicit resolver. */\nexport class ReceivingAddress {\n    readonly #text: string;\n\n    private constructor(text: string) {\n        const decoded = decodeAddress(text);\n        this.#text = decoded.kind === \"short\" ? encodeShortAddress(decoded.ownerAddress) : text;\n        Object.freeze(this);\n    }\n\n    static parse(text: string): ReceivingAddress {\n        return new ReceivingAddress(text);\n    }\n\n    static from(recipient: ReceivingData): ReceivingAddress {\n        return new ReceivingAddress(encodeLongAddress(recipient));\n    }\n\n    static fromIdentity(identity: bigint | `0x${string}`): ReceivingAddress {\n        return new ReceivingAddress(encodeShortAddress(identity));\n    }\n\n    get ownerAddress(): `0x${string}` {\n        return decodeAddress(this.#text).ownerAddress;\n    }\n\n    get kind(): \"long\" | \"short\" {\n        return decodeAddress(this.#text).kind;\n    }\n\n    getReceivingKeys(): ReceivingKeys {\n        const decoded = decodeAddress(this.#text);\n        if (decoded.kind === \"short\") {\n            throw new MissingCapabilityError(\"resolved receiving keys\");\n        }\n        return { viewingPublicKey: decoded.viewingPublicKey, clueKey: decoded.clueKey };\n    }\n\n    async resolve(lookup?: ReceivingKeyLookup): Promise<ReceivingAddress> {\n        if (this.kind === \"long\") {\n            return this;\n        }\n        if (!lookup) {\n            throw new MissingCapabilityError(\"explicit registry lookup\");\n        }\n        const keys = await lookup(this.ownerAddress);\n        if (!keys) {\n            throw new Error(\"owner address is not registered\");\n        }\n        return ReceivingAddress.from({\n            ownerAddress: this.ownerAddress,\n            viewingPublicKey: keys.viewingPublicKey,\n            clueKey: keys.clueKey,\n        });\n    }\n\n    get viewingPublicKey(): Uint8Array {\n        return this.getReceivingKeys().viewingPublicKey;\n    }\n\n    get clueKey(): Uint8Array {\n        return this.getReceivingKeys().clueKey;\n    }\n\n    toString(): string {\n        return this.#text;\n    }\n\n    toJSON(): string {\n        return this.#text;\n    }\n}\n"],"mappings":"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","names":["import_utils","import_blake2b"]}

package/dist/address.d.cts

@@ -0,0 +1,35 @@
+import { R as ReceivingKeys } from './types-CEAuh35C.cjs';
+
+interface ReceivingAddress$1 {
+    ownerAddress: `0x${string}`;
+    viewingPublicKey: Uint8Array;
+    clueKey: Uint8Array;
+}
+type DecodedAddress = ({
+    kind: "long";
+} & ReceivingAddress$1) | {
+    kind: "short";
+    ownerAddress: `0x${string}`;
+};
+type ReceivingKeyLookup = (ownerAddress: `0x${string}`) => Promise<Pick<ReceivingAddress$1, "viewingPublicKey" | "clueKey"> | null | undefined>;
+/** Standard EVM short addresses or a full 0i address with a strict custom Base32 case checksum. */
+declare function decodeAddress(address: string): DecodedAddress;
+
+/** Validated public receiving material. A short address requires an explicit resolver. */
+declare class ReceivingAddress {
+    #private;
+    private constructor();
+    static parse(text: string): ReceivingAddress;
+    static from(recipient: ReceivingAddress$1): ReceivingAddress;
+    static fromIdentity(identity: bigint | `0x${string}`): ReceivingAddress;
+    get ownerAddress(): `0x${string}`;
+    get kind(): "long" | "short";
+    getReceivingKeys(): ReceivingKeys;
+    resolve(lookup?: ReceivingKeyLookup): Promise<ReceivingAddress>;
+    get viewingPublicKey(): Uint8Array;
+    get clueKey(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+}
+
+export { type DecodedAddress, ReceivingAddress, type ReceivingKeyLookup, ReceivingKeys, decodeAddress };

package/dist/address.d.ts

@@ -0,0 +1,35 @@
+import { R as ReceivingKeys } from './types-CEAuh35C.js';
+
+interface ReceivingAddress$1 {
+    ownerAddress: `0x${string}`;
+    viewingPublicKey: Uint8Array;
+    clueKey: Uint8Array;
+}
+type DecodedAddress = ({
+    kind: "long";
+} & ReceivingAddress$1) | {
+    kind: "short";
+    ownerAddress: `0x${string}`;
+};
+type ReceivingKeyLookup = (ownerAddress: `0x${string}`) => Promise<Pick<ReceivingAddress$1, "viewingPublicKey" | "clueKey"> | null | undefined>;
+/** Standard EVM short addresses or a full 0i address with a strict custom Base32 case checksum. */
+declare function decodeAddress(address: string): DecodedAddress;
+
+/** Validated public receiving material. A short address requires an explicit resolver. */
+declare class ReceivingAddress {
+    #private;
+    private constructor();
+    static parse(text: string): ReceivingAddress;
+    static from(recipient: ReceivingAddress$1): ReceivingAddress;
+    static fromIdentity(identity: bigint | `0x${string}`): ReceivingAddress;
+    get ownerAddress(): `0x${string}`;
+    get kind(): "long" | "short";
+    getReceivingKeys(): ReceivingKeys;
+    resolve(lookup?: ReceivingKeyLookup): Promise<ReceivingAddress>;
+    get viewingPublicKey(): Uint8Array;
+    get clueKey(): Uint8Array;
+    toString(): string;
+    toJSON(): string;
+}
+
+export { type DecodedAddress, ReceivingAddress, type ReceivingKeyLookup, ReceivingKeys, decodeAddress };

package/dist/address.js

@@ -0,0 +1,10 @@
+import {
+  ReceivingAddress,
+  decodeAddress
+} from "./chunk-3SEC7POH.js";
+import "./chunk-Q3NNEKKR.js";
+export {
+  ReceivingAddress,
+  decodeAddress
+};
+//# sourceMappingURL=address.js.map

package/dist/address.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/chunk-3SEC7POH.js

@@ -0,0 +1,168 @@
+import {
+  validateClueKey
+} from "./chunk-Q3NNEKKR.js";
+
+// src/address/address.ts
+import { secp256k1 } from "@noble/curves/secp256k1";
+import { keccak_256 } from "@noble/hashes/sha3";
+import { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from "@noble/hashes/utils";
+import { getAddress } from "ethers";
+var ALPHABET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+function identityBytes(value) {
+  if (typeof value !== "bigint" && (typeof value !== "string" || !/^0x[0-9a-fA-F]{40}$/.test(value)))
+    throw new Error("invalid owner address encoding");
+  const n = BigInt(value);
+  if (n <= 0n || n >= 1n << 160n)
+    throw new RangeError("owner address must be a nonzero EVM owner address");
+  return hexToBytes(n.toString(16).padStart(40, "0"));
+}
+function receivingKeys(keys) {
+  const publicKey = keys.viewingPublicKey;
+  if (!(publicKey instanceof Uint8Array) || publicKey.length !== 33 || publicKey[0] !== 2 && publicKey[0] !== 3)
+    throw new Error("invalid compressed viewing public key");
+  secp256k1.ProjectivePoint.fromHex(publicKey).assertValidity();
+  validateClueKey(keys.clueKey);
+  return { viewingPublicKey: Uint8Array.from(publicKey), clueKey: Uint8Array.from(keys.clueKey) };
+}
+function checkedText(prefix, data) {
+  const digest = keccak_256(utf8ToBytes("Invisi.AddressCaseChecksum.v1:" + prefix + data));
+  return prefix + Array.from(
+    data,
+    (character, i) => digest[i >> 3] >> 7 - (i & 7) & 1 ? character.toUpperCase() : character
+  ).join("");
+}
+function encode(prefix, payload) {
+  let buffer = 0, bits = 0, data = "";
+  for (const byte of payload) {
+    buffer = buffer << 8 | byte;
+    bits += 8;
+    while (bits >= 5) {
+      bits -= 5;
+      data += ALPHABET[buffer >>> bits & 31];
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits) data += ALPHABET[buffer << 5 - bits & 31];
+  return checkedText(prefix, data);
+}
+function encodeLongAddress(recipient) {
+  const identity = identityBytes(recipient.ownerAddress), keys = receivingKeys(recipient);
+  return encode("0i", concatBytes(identity, keys.viewingPublicKey, keys.clueKey));
+}
+function encodeShortAddress(ownerAddress) {
+  const identity = identityBytes(ownerAddress);
+  return getAddress(
+    typeof ownerAddress === "string" ? ownerAddress : `0x${bytesToHex(identity)}`
+  );
+}
+function decodeAddress(address) {
+  if (typeof address !== "string") throw new TypeError("address must be text");
+  if (address.startsWith("0x")) {
+    const owner = getAddress(address);
+    return { kind: "short", ownerAddress: `0x${bytesToHex(identityBytes(owner))}` };
+  }
+  if (!address.startsWith("0i")) throw new Error("invalid Invisi address prefix");
+  const prefix = "0i";
+  if (address.length !== 138) throw new Error("invalid address length");
+  const data = address.slice(prefix.length).toLowerCase();
+  if (Array.from(data).some((character) => !ALPHABET.includes(character)))
+    throw new Error("invalid address alphabet");
+  if (checkedText(prefix, data) !== address) throw new Error("invalid address case checksum");
+  let buffer = 0, bits = 0;
+  const payload = [];
+  for (const character of data) {
+    buffer = buffer << 5 | ALPHABET.indexOf(character);
+    bits += 5;
+    if (bits >= 8) {
+      bits -= 8;
+      payload.push(buffer >>> bits & 255);
+    }
+    buffer &= (1 << bits) - 1;
+  }
+  if (bits !== 0 || buffer !== 0) throw new Error("noncanonical address padding");
+  const raw = Uint8Array.from(payload);
+  const ownerAddress = `0x${bytesToHex(identityBytes(`0x${bytesToHex(raw.subarray(0, 20))}`))}`;
+  return {
+    kind: "long",
+    ownerAddress,
+    ...receivingKeys({ viewingPublicKey: raw.slice(20, 53), clueKey: raw.slice(53) })
+  };
+}
+
+// src/errors.ts
+var MissingCapabilityError = class extends Error {
+  constructor(capability) {
+    super(`Missing ${capability} capability`);
+    this.capability = capability;
+    this.name = "MissingCapabilityError";
+  }
+  code = "MISSING_CAPABILITY";
+};
+
+// src/address/receiving-address.ts
+var ReceivingAddress = class _ReceivingAddress {
+  #text;
+  constructor(text) {
+    const decoded = decodeAddress(text);
+    this.#text = decoded.kind === "short" ? encodeShortAddress(decoded.ownerAddress) : text;
+    Object.freeze(this);
+  }
+  static parse(text) {
+    return new _ReceivingAddress(text);
+  }
+  static from(recipient) {
+    return new _ReceivingAddress(encodeLongAddress(recipient));
+  }
+  static fromIdentity(identity) {
+    return new _ReceivingAddress(encodeShortAddress(identity));
+  }
+  get ownerAddress() {
+    return decodeAddress(this.#text).ownerAddress;
+  }
+  get kind() {
+    return decodeAddress(this.#text).kind;
+  }
+  getReceivingKeys() {
+    const decoded = decodeAddress(this.#text);
+    if (decoded.kind === "short") {
+      throw new MissingCapabilityError("resolved receiving keys");
+    }
+    return { viewingPublicKey: decoded.viewingPublicKey, clueKey: decoded.clueKey };
+  }
+  async resolve(lookup) {
+    if (this.kind === "long") {
+      return this;
+    }
+    if (!lookup) {
+      throw new MissingCapabilityError("explicit registry lookup");
+    }
+    const keys = await lookup(this.ownerAddress);
+    if (!keys) {
+      throw new Error("owner address is not registered");
+    }
+    return _ReceivingAddress.from({
+      ownerAddress: this.ownerAddress,
+      viewingPublicKey: keys.viewingPublicKey,
+      clueKey: keys.clueKey
+    });
+  }
+  get viewingPublicKey() {
+    return this.getReceivingKeys().viewingPublicKey;
+  }
+  get clueKey() {
+    return this.getReceivingKeys().clueKey;
+  }
+  toString() {
+    return this.#text;
+  }
+  toJSON() {
+    return this.#text;
+  }
+};
+
+export {
+  decodeAddress,
+  MissingCapabilityError,
+  ReceivingAddress
+};
+//# sourceMappingURL=chunk-3SEC7POH.js.map

package/dist/chunk-3SEC7POH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/address/address.ts","../src/errors.ts","../src/address/receiving-address.ts"],"sourcesContent":["import { secp256k1 } from \"@noble/curves/secp256k1\";\nimport { keccak_256 } from \"@noble/hashes/sha3\";\nimport { bytesToHex, concatBytes, hexToBytes, utf8ToBytes } from \"@noble/hashes/utils\";\nimport { getAddress } from \"ethers\";\nimport { validateClueKey } from \"../fmd/fmd\";\n\nexport interface ReceivingAddress {\n    ownerAddress: `0x${string}`;\n    viewingPublicKey: Uint8Array;\n    clueKey: Uint8Array;\n}\nexport type DecodedAddress =\n    ({ kind: \"long\" } & ReceivingAddress) | { kind: \"short\"; ownerAddress: `0x${string}` };\nexport type ReceivingKeyLookup = (\n    ownerAddress: `0x${string}`\n) => Promise<Pick<ReceivingAddress, \"viewingPublicKey\" | \"clueKey\"> | null | undefined>;\nconst ALPHABET = \"qpzry9x8gf2tvdw0s3jn54khce6mua7l\";\ntype Identity = bigint | `0x${string}`;\n\nfunction identityBytes(value: Identity): Uint8Array {\n    if (\n        typeof value !== \"bigint\" &&\n        (typeof value !== \"string\" || !/^0x[0-9a-fA-F]{40}$/.test(value))\n    )\n        throw new Error(\"invalid owner address encoding\");\n    const n = BigInt(value);\n    if (n <= 0n || n >= 1n << 160n)\n        throw new RangeError(\"owner address must be a nonzero EVM owner address\");\n    return hexToBytes(n.toString(16).padStart(40, \"0\"));\n}\nfunction receivingKeys(keys: Pick<ReceivingAddress, \"viewingPublicKey\" | \"clueKey\">) {\n    const publicKey = keys.viewingPublicKey;\n    if (\n        !(publicKey instanceof Uint8Array) ||\n        publicKey.length !== 33 ||\n        (publicKey[0] !== 2 && publicKey[0] !== 3)\n    )\n        throw new Error(\"invalid compressed viewing public key\");\n    secp256k1.ProjectivePoint.fromHex(publicKey).assertValidity();\n    validateClueKey(keys.clueKey);\n    return { viewingPublicKey: Uint8Array.from(publicKey), clueKey: Uint8Array.from(keys.clueKey) };\n}\nfunction checkedText(prefix: string, data: string): string {\n    const digest = keccak_256(utf8ToBytes(\"Invisi.AddressCaseChecksum.v1:\" + prefix + data));\n    return (\n        prefix +\n        Array.from(data, (character, i) =>\n            (digest[i >> 3]! >> (7 - (i & 7))) & 1 ? character.toUpperCase() : character\n        ).join(\"\")\n    );\n}\nfunction encode(prefix: string, payload: Uint8Array): string {\n    let buffer = 0,\n        bits = 0,\n        data = \"\";\n    for (const byte of payload) {\n        buffer = (buffer << 8) | byte;\n        bits += 8;\n        while (bits >= 5) {\n            bits -= 5;\n            data += ALPHABET[(buffer >>> bits) & 31];\n        }\n        buffer &= (1 << bits) - 1;\n    }\n    if (bits) data += ALPHABET[(buffer << (5 - bits)) & 31];\n    return checkedText(prefix, data);\n}\n\n/** 138 characters: 0i plus the complete offline receiving materials. */\nexport function encodeLongAddress(recipient: ReceivingAddress): string {\n    const identity = identityBytes(recipient.ownerAddress),\n        keys = receivingKeys(recipient);\n    return encode(\"0i\", concatBytes(identity, keys.viewingPublicKey, keys.clueKey));\n}\n/** The owner's 42-character checksummed EVM address; receiving keys require a chosen registry. */\nexport function encodeShortAddress(ownerAddress: Identity): string {\n    const identity = identityBytes(ownerAddress);\n    return getAddress(\n        typeof ownerAddress === \"string\" ? ownerAddress : `0x${bytesToHex(identity)}`\n    );\n}\n\n/** Standard EVM short addresses or a full 0i address with a strict custom Base32 case checksum. */\nexport function decodeAddress(address: string): DecodedAddress {\n    if (typeof address !== \"string\") throw new TypeError(\"address must be text\");\n    if (address.startsWith(\"0x\")) {\n        const owner = getAddress(address) as `0x${string}`;\n        return { kind: \"short\", ownerAddress: `0x${bytesToHex(identityBytes(owner))}` };\n    }\n    if (!address.startsWith(\"0i\")) throw new Error(\"invalid Invisi address prefix\");\n    const prefix = \"0i\";\n    if (address.length !== 138) throw new Error(\"invalid address length\");\n    const data = address.slice(prefix.length).toLowerCase();\n    if (Array.from(data).some((character) => !ALPHABET.includes(character)))\n        throw new Error(\"invalid address alphabet\");\n    if (checkedText(prefix, data) !== address) throw new Error(\"invalid address case checksum\");\n    let buffer = 0,\n        bits = 0;\n    const payload: number[] = [];\n    for (const character of data) {\n        buffer = (buffer << 5) | ALPHABET.indexOf(character);\n        bits += 5;\n        if (bits >= 8) {\n            bits -= 8;\n            payload.push((buffer >>> bits) & 255);\n        }\n        buffer &= (1 << bits) - 1;\n    }\n    if (bits !== 0 || buffer !== 0) throw new Error(\"noncanonical address padding\");\n    const raw = Uint8Array.from(payload);\n    const ownerAddress =\n        `0x${bytesToHex(identityBytes(`0x${bytesToHex(raw.subarray(0, 20))}`))}` as const;\n    return {\n        kind: \"long\",\n        ownerAddress,\n        ...receivingKeys({ viewingPublicKey: raw.slice(20, 53), clueKey: raw.slice(53) }),\n    };\n}\n\n/** Normalize either address into the same payment input. Long addresses never query. */\nexport async function resolveAddress(\n    address: string,\n    options: { lookup?: ReceivingKeyLookup } = {}\n): Promise<ReceivingAddress> {\n    const decoded = decodeAddress(address);\n    if (decoded.kind === \"long\")\n        return {\n            ownerAddress: decoded.ownerAddress,\n            viewingPublicKey: decoded.viewingPublicKey,\n            clueKey: decoded.clueKey,\n        };\n    if (!options.lookup) throw new Error(\"short address requires an explicit registry lookup\");\n    const keys = await options.lookup(decoded.ownerAddress);\n    if (!keys) throw new Error(\"owner address is not registered\");\n    return { ownerAddress: decoded.ownerAddress, ...receivingKeys(keys) };\n}\n","/** A requested permission was not explicitly supplied to this component. */\nexport class MissingCapabilityError extends Error {\n    readonly code = \"MISSING_CAPABILITY\";\n    constructor(readonly capability: string) {\n        super(`Missing ${capability} capability`);\n        this.name = \"MissingCapabilityError\";\n    }\n}\n","import { MissingCapabilityError } from \"../errors\";\nimport type { ReceivingKeys } from \"../types\";\nimport {\n    decodeAddress,\n    encodeLongAddress,\n    encodeShortAddress,\n    type ReceivingAddress as ReceivingData,\n    type ReceivingKeyLookup,\n} from \"./address\";\n\n/** Validated public receiving material. A short address requires an explicit resolver. */\nexport class ReceivingAddress {\n    readonly #text: string;\n\n    private constructor(text: string) {\n        const decoded = decodeAddress(text);\n        this.#text = decoded.kind === \"short\" ? encodeShortAddress(decoded.ownerAddress) : text;\n        Object.freeze(this);\n    }\n\n    static parse(text: string): ReceivingAddress {\n        return new ReceivingAddress(text);\n    }\n\n    static from(recipient: ReceivingData): ReceivingAddress {\n        return new ReceivingAddress(encodeLongAddress(recipient));\n    }\n\n    static fromIdentity(identity: bigint | `0x${string}`): ReceivingAddress {\n        return new ReceivingAddress(encodeShortAddress(identity));\n    }\n\n    get ownerAddress(): `0x${string}` {\n        return decodeAddress(this.#text).ownerAddress;\n    }\n\n    get kind(): \"long\" | \"short\" {\n        return decodeAddress(this.#text).kind;\n    }\n\n    getReceivingKeys(): ReceivingKeys {\n        const decoded = decodeAddress(this.#text);\n        if (decoded.kind === \"short\") {\n            throw new MissingCapabilityError(\"resolved receiving keys\");\n        }\n        return { viewingPublicKey: decoded.viewingPublicKey, clueKey: decoded.clueKey };\n    }\n\n    async resolve(lookup?: ReceivingKeyLookup): Promise<ReceivingAddress> {\n        if (this.kind === \"long\") {\n            return this;\n        }\n        if (!lookup) {\n            throw new MissingCapabilityError(\"explicit registry lookup\");\n        }\n        const keys = await lookup(this.ownerAddress);\n        if (!keys) {\n            throw new Error(\"owner address is not registered\");\n        }\n        return ReceivingAddress.from({\n            ownerAddress: this.ownerAddress,\n            viewingPublicKey: keys.viewingPublicKey,\n            clueKey: keys.clueKey,\n        });\n    }\n\n    get viewingPublicKey(): Uint8Array {\n        return this.getReceivingKeys().viewingPublicKey;\n    }\n\n    get clueKey(): Uint8Array {\n        return this.getReceivingKeys().clueKey;\n    }\n\n    toString(): string {\n        return this.#text;\n    }\n\n    toJSON(): string {\n        return this.#text;\n    }\n}\n"],"mappings":"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","names":[]}