@meantjs/consent 0.0.0-stage → 0.2.0

package/src/consent.mjs

@@ -0,0 +1,42 @@
+// resolved form + method + Candid argument bytes -> a consent message, without the ICRC-21 envelope.
+// `icrc21.mjs` wraps this into the ICRC-21 request/response shapes.
+
+import { Renderer } from "./display.mjs";
+import { buildModel } from "./model.mjs";
+import { renderFields, renderGeneric } from "./render.mjs";
+
+/**
+ * @param {object} input
+ * @param {object} input.resolved  a resolved form (docs/profile-v0.md section 10)
+ * @param {string} input.method  the method being called
+ * @param {Uint8Array | ArrayBuffer | number[]} input.arg  the Candid-encoded argument tuple
+ * @param {Record<string, unknown>} [input.refs]  resolved dynamic refs, for example { "query:icrc1_decimals": 8, "query:icrc1_symbol": "ICP" }
+ * @param {"fields" | "generic"} [input.form]  default "generic"
+ * @param {number | null} [input.utcOffsetMinutes]  generic form only: show timestamps in this zone (default 0, UTC). The fields form is always UTC seconds
+ * @param {boolean} [input.rawArguments]  append the decoded raw arguments (spec section 11 item 1)
+ * @param {object} [input.limits]  decoder limits (maxBytes, maxDepth, maxElements)
+ * @returns {{ form: "fields" | "generic", message: object, zoneSensitive: boolean, diagnostics: object[], provenance: object, model: object }}
+ *   `message` is `{ FieldsDisplayMessage: { intent, fields } }` or `{ GenericDisplayMessage: string }` (ICRC-21 shapes,
+ *   integers as bigint). `zoneSensitive` is true when a timestamp was shown in the requested zone.
+ */
+export function generateConsent({ resolved, method, arg, refs = {}, form = "generic", utcOffsetMinutes = null, rawArguments = false, limits }) {
+  const model = buildModel({ resolved, method, arg, limits });
+  const diagnostics = model.diagnostics;
+  const done = (rest) => ({ ...rest, diagnostics: dedupe(diagnostics), provenance: model.provenance, model });
+  if (form === "fields") {
+    const renderer = new Renderer({ refs, utcOffsetMinutes: null, diagnostics });
+    const { intent, fields } = renderFields(model, renderer, { rawArguments });
+    return done({ form, message: { FieldsDisplayMessage: { intent, fields } }, zoneSensitive: false });
+  }
+  const renderer = new Renderer({ refs, utcOffsetMinutes: utcOffsetMinutes ?? 0, diagnostics });
+  const text = renderGeneric(model, renderer, { rawArguments });
+  return done({ form: "generic", message: { GenericDisplayMessage: text }, zoneSensitive: renderer.usedZone });
+}
+
+function dedupe(diagnostics) {
+  const seen = new Set();
+  return diagnostics.filter((d) => {
+    const key = `${d.code}\u0000${d.at}\u0000${d.message}`;
+    return seen.has(key) ? false : (seen.add(key), true);
+  });
+}

package/src/decode.mjs

@@ -0,0 +1,140 @@
+// Step 1: Candid argument bytes -> a value tree aligned with the resolved form's positions.
+//
+// Codec: @candid-core/schema 0.5.0 `decodeArgs` (schema-directed, with the Candid coercion relation and explicit
+// resource budgets). The expected schema is built from the method's resolved-form tree, so the decoder never
+// trusts the types the bytes claim: an argument is read as the signature says or the call is refused.
+//
+// Value tree (lossless; the same shape at every position of the resolved form):
+//   nat, int, nat8..nat64, int8..int64   decimal string       (D-006: never a JavaScript number)
+//   float32, float64                     number
+//   bool, text                           boolean, string
+//   null, reserved                       null
+//   principal                            canonical text
+//   blob (vec nat8)                      Uint8Array
+//   opt T                                null when absent, else the value of T
+//   record                               plain object keyed exactly like the resolved form's `fields`
+//   variant                              { tag: <key of the resolved form's `cases`>, value }   (value null for a bare tag)
+//   vec T                                array
+//
+// Limits of the resolved form, refused (E_UNSUPPORTED_TYPE) rather than guessed:
+//   - a value that reaches a position with `recursive: true` (the resolver cut a cycle or a depth of 8 there; the type
+//     below is unknown). The position is decoded as `reserved`, which every Candid type is a subtype of, so the bytes
+//     there are skipped without trusting their type; a call whose value lies there (the case is chosen, the `opt` is
+//     present, the field exists, the `vec` has an element) is refused when the value tree is built. A call whose value
+//     never goes there gets its message (spec section 12, rule 12; D-042);
+//   - `func` and `service` positions anywhere in the method (the resolved form does not carry their signatures);
+//   - nested `opt` (`opt opt T` collapses to one `optional` flag in the resolved form).
+
+import { c } from "@candid-core/schema";
+import { decodeArgs } from "@candid-core/schema/codec";
+import { bytesOf } from "./bytes.mjs";
+import { CODES, fail } from "./errors.mjs";
+import { entriesOf } from "./resolved.mjs";
+
+/** A consent message is for one ingress message at most (IC limit: 2 MiB). */
+export const DEFAULT_LIMITS = Object.freeze({ maxBytes: 2 * 1024 * 1024, maxDepth: 64, maxElements: 100_000 });
+
+const INTEGERS = new Set(["nat", "int", "nat8", "nat16", "nat32", "nat64", "int8", "int16", "int32", "int64"]);
+const FLOATS = new Set(["float32", "float64"]);
+const PRIMITIVES = new Set(["null", "bool", "text", "principal", "reserved", "empty", ...INTEGERS, ...FLOATS]);
+const MAX_NODE_DEPTH = 64;
+
+/** The codec's name for a resolved-form key: `#123` has no name, so the codec's `_123_` convention carries the id. */
+const codecName = (key) => (/^#(0|[1-9][0-9]{0,9})$/.test(key) ? `_${key.slice(1)}_` : key);
+
+const NO_OPT_BOX = new Set(["null", "reserved"]); // `opt null` and `opt reserved` are boxed by the codec
+
+/** Build the codec schema for one position of the resolved form. */
+export function schemaFor(node, where = "argument", depth = 0) {
+  if (node === null || typeof node !== "object" || typeof node.candid !== "string") {
+    fail(CODES.RESOLVED_FORM, `${where}: not a resolved-form position`);
+  }
+  if (depth > MAX_NODE_DEPTH) fail(CODES.UNSUPPORTED_TYPE, `${where}: nested deeper than ${MAX_NODE_DEPTH}`);
+  const inner = node.recursive === true ? c.reserved : innerSchema(node, where, depth);
+  return node.optional === true ? c.opt(inner) : inner;
+}
+
+function innerSchema(node, where, depth) {
+  const kind = node.candid;
+  if (PRIMITIVES.has(kind)) return c[kind];
+  switch (kind) {
+    case "blob":
+      return c.blob();
+    case "vec": {
+      if (node.element === undefined) fail(CODES.UNSUPPORTED_TYPE, `${where}: vec without an element type`);
+      return c.vec(schemaFor(node.element, `${where}[]`, depth + 1));
+    }
+    case "record": {
+      const fields = Object.create(null);
+      for (const [key, child] of entriesOf(node.fields)) fields[codecName(key)] = schemaFor(child, `${where}.${key}`, depth + 1);
+      return c.record(fields);
+    }
+    case "variant": {
+      const arms = Object.create(null);
+      for (const [key, child] of entriesOf(node.cases)) arms[codecName(key)] = schemaFor(child, `${where}.${key}`, depth + 1);
+      return c.variant(arms);
+    }
+    default:
+      fail(CODES.UNSUPPORTED_TYPE, `${where}: ${kind} positions cannot be decoded (the resolved form carries no signature for them)`);
+  }
+}
+
+const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k);
+
+/** Own enumerable property, also for a key like "__proto__" (assignment would set the prototype instead). */
+export function setOwn(obj, key, value) {
+  Object.defineProperty(obj, key, { value, enumerable: true, writable: true, configurable: true });
+}
+
+/** Codec value -> value tree. `node` is the resolved-form position the schema was built from. */
+export function toTree(node, v, where = "argument") {
+  if (node.recursive === true) {
+    if (node.optional === true && v === null) return null;
+    fail(CODES.UNSUPPORTED_TYPE, `${where}: the resolved form cuts this ${node.candid} at a cycle (recursive: true), so its type below is unknown`);
+  }
+  if (node.optional === true) {
+    if (v === null) return null;
+    if (NO_OPT_BOX.has(node.candid)) v = v.some; // boxed opt null / opt reserved
+  }
+  const kind = node.candid;
+  if (INTEGERS.has(kind)) return String(v);
+  if (FLOATS.has(kind) || kind === "bool" || kind === "text" || kind === "principal" || kind === "blob") return v;
+  if (kind === "null" || kind === "reserved") return null;
+  if (kind === "vec") return v.map((e, i) => toTree(node.element, e, `${where}[${i}]`));
+  if (kind === "record") {
+    const out = {};
+    for (const [key, child] of entriesOf(node.fields)) setOwn(out, key, toTree(child, v[codecName(key)], `${where}.${key}`));
+    return out;
+  }
+  if (kind === "variant") {
+    const cases = entriesOf(node.cases);
+    const hit = cases.find(([key]) => codecName(key) === v.tag);
+    if (hit === undefined) fail(CODES.DECODE, `${where}: the decoder returned the case ${JSON.stringify(v.tag)}, which the resolved form lacks`);
+    return { tag: hit[0], value: hasOwn(v, "value") ? toTree(hit[1], v.value, `${where}.${hit[0]}`) : null };
+  }
+  fail(CODES.UNSUPPORTED_TYPE, `${where}: cannot convert ${kind}`);
+}
+
+/**
+ * Decode the Candid-encoded argument tuple of a call against a resolved-form method.
+ *
+ * @param {{ args: object[] }} method  an entry of `resolved.methods`
+ * @param {Uint8Array | ArrayBuffer | number[]} arg  the bytes of the call's argument (the `arg` of the ICRC-21 request)
+ * @param {{ maxBytes?: number, maxDepth?: number, maxElements?: number }} [limits]
+ * @returns {unknown[]} one value tree per argument, in order
+ * @throws {ConsentError} E_DECODE, E_TOO_LARGE, E_UNSUPPORTED_TYPE, E_RESOLVED_FORM
+ */
+export function decodeArguments(method, arg, limits = {}) {
+  const bytes = bytesOf(arg);
+  if (bytes === null) fail(CODES.DECODE, "the argument is not bytes: a Uint8Array, an ArrayBuffer or an array of integers 0 to 255");
+  const opts = { ...DEFAULT_LIMITS, ...limits };
+  if (bytes.length > opts.maxBytes) fail(CODES.TOO_LARGE, `the argument is ${bytes.length} bytes; the limit for a consent message is ${opts.maxBytes}`);
+  const schemas = method.args.map((node, i) => schemaFor(node, `argument ${i}`));
+  const r = decodeArgs(schemas, bytes, opts);
+  if (!r.ok) {
+    const first = r.issues[0];
+    const code = first.code === "resource_limit_exceeded" ? CODES.TOO_LARGE : CODES.DECODE;
+    fail(code, `the argument bytes do not decode as the method's signature: ${first.code} at ${first.path}: ${first.message}`);
+  }
+  return r.values.map((v, i) => toTree(method.args[i], v, `argument ${i}`));
+}

package/src/display.mjs

@@ -0,0 +1,248 @@
+// Turning one value of the tree into text, and into an ICRC-21 `Value`.
+//
+// Formatting goes through `formatterFor` of @meantjs/format for every tagged position
+// (spec section 6: "rendered with the formatter of the tag at that position"); nothing here converts a unit,
+// a decimal or an account by itself. An untagged position renders as Candid text.
+//
+// A formatter can fail on a value (for example a 5-byte subaccount, which no ledger accepts). The value is then
+// shown as raw Candid text instead of hiding it, and the failure is recorded in `diagnostics`. A formatter that
+// cannot be built (a dynamic ref the caller did not supply, a bad tag argument) is a configuration error and
+// stops the message: showing a number without its decimals would be worse than no message.
+
+import { FormatError, convertUnit, displayTimestamp, formatterFor } from "@meantjs/format";
+import { CODES, ConsentError, fail } from "./errors.mjs";
+import { entriesOf } from "./resolved.mjs";
+import { visible } from "./text.mjs";
+
+const U64_MAX = 2n ** 64n - 1n;
+const CONFIG_CODES = new Set(["E_REF_UNRESOLVED", "E_ARG", "E_TAG_TYPE", "E_TAG_CONFLICT", "E_TYPE"]);
+
+/** Budget for the text of one message: a consent message is read by a person (ICRC-21: short and concise). */
+export const MAX_MESSAGE_CHARS = 32 * 1024;
+
+export class Renderer {
+  /** Set while `plainTupleText` runs: no formatter applies. */
+  #plain = false;
+
+  /**
+   * @param {{ refs?: Record<string, unknown>, utcOffsetMinutes?: number | null, diagnostics?: object[] }} options
+   *   `refs`: the resolved dynamic values, keyed by their `from` string (for example `query:icrc1_decimals`).
+   *   `utcOffsetMinutes`: when a number, timestamps are shown in that zone (the generic form); otherwise in UTC.
+   */
+  constructor({ refs = {}, utcOffsetMinutes = null, diagnostics = [] } = {}) {
+    this.refs = refs;
+    this.utcOffsetMinutes = utcOffsetMinutes;
+    this.diagnostics = diagnostics;
+    this.chars = 0;
+    this.formatters = new WeakMap();
+    /** Set when a timestamp was shown in the requested zone, so the response can say the text is zone-sensitive. */
+    this.usedZone = false;
+  }
+
+  /** @returns {import("@meantjs/format").Formatter | null} */
+  formatter(node) {
+    if (this.formatters.has(node)) return this.formatters.get(node);
+    let f;
+    try {
+      f = formatterFor(node, { refs: this.refs });
+    } catch (e) {
+      if (e instanceof FormatError && CONFIG_CODES.has(e.code)) throw new ConsentError(e.code, e.message, { cause: e });
+      throw e;
+    }
+    this.formatters.set(node, f);
+    return f;
+  }
+
+  charge(text) {
+    this.chars += text.length;
+    if (this.chars > MAX_MESSAGE_CHARS) fail(CODES.TOO_LARGE, `the message would exceed ${MAX_MESSAGE_CHARS} characters; it is never truncated`);
+    return text;
+  }
+
+  /**
+   * Plain display text of one value, not yet escaped for any format: the formatter of its tag, or Candid text
+   * (spec section 6; a bare principal is its canonical text).
+   * @param {object} node  the resolved-form position
+   * @param {unknown} value  its value (a tree node, never absent)
+   * @param {string} where  for diagnostics
+   */
+  text(node, value, where) {
+    const shown = this.#formatted(node, value, where);
+    if (shown !== null) return this.charge(shown);
+    // An untagged principal is its canonical text, as everywhere else on the Internet Computer. Inside a composite it
+    // stays `principal "..."` so that the Candid text of the composite is still Candid.
+    if (node.candid === "principal") return this.charge(value);
+    return this.charge(this.#raw(node, value, where));
+  }
+
+  /** Candid text of a whole argument tuple (the "raw arguments" of spec section 11 item 1), tagged children formatted. */
+  tupleText(nodes, values) {
+    if (isAbiParams(nodes)) return this.charge(this.#child(nodes[0], values[0], "arguments"));
+    return this.charge(`(${nodes.map((n, i) => this.#child(n, values[i], `argument ${i}`)).join(", ")})`);
+  }
+
+  /**
+   * Candid text of a whole argument tuple with no formatter applied: base units, nanoseconds, blobs as bytes. A view
+   * that does not depend on the profile's units, for a reader who checks the profile itself (spec section 11 item 1).
+   */
+  plainTupleText(nodes, values) {
+    this.#plain = true;
+    try {
+      if (isAbiParams(nodes)) return this.charge(this.#child(nodes[0], values[0], "arguments"));
+      return this.charge(`(${nodes.map((n, i) => this.#child(n, values[i], `argument ${i}`)).join(", ")})`);
+    } finally {
+      this.#plain = false;
+    }
+  }
+
+  /** The formatter's text, or null when the position has no value tag or the formatter refuses the value. */
+  #formatted(node, value, where) {
+    if (this.#plain) return null;
+    const f = this.formatter(node);
+    if (f === null) return null;
+    try {
+      return f.tag === "timestamp" && this.utcOffsetMinutes !== null ? this.#zoned(f, value) : f.display(value);
+    } catch (e) {
+      if (!(e instanceof FormatError)) throw e;
+      this.diagnostics.push({ code: "W_FORMAT_FALLBACK", at: where, message: `the ${f.tag} formatter refused the value (${e.code}: ${e.message}); it is shown as raw Candid text` });
+      return null;
+    }
+  }
+
+  /** A timestamp in the requested zone: the instant shifted by whole minutes, then shown with the library's calendar code. */
+  #zoned(f, value) {
+    const offset = this.utcOffsetMinutes;
+    const local = BigInt(convertUnit(value, f.args.unit, "ns")) + BigInt(offset) * 60_000_000_000n;
+    const utc = displayTimestamp(local, { unit: "ns", candid: "int" });
+    this.usedZone = true;
+    return `${utc.slice(0, -1).replace("T", " ")} ${zoneName(offset)}`;
+  }
+
+  /** A child of a composite: absent is `null`, a tagged child uses its formatter, any other is raw (`opt` marks a present optional). */
+  #child(node, value, where) {
+    if (node.optional === true && value === null) return "null";
+    const shown = this.#formatted(node, value, where);
+    if (shown !== null) return shown;
+    const raw = this.#raw(node, value, where);
+    return node.optional === true ? `opt ${raw}` : raw;
+  }
+
+  #raw(node, value, where) {
+    if (typeof node.abi === "string") return this.#abi(node, value, where);
+    switch (node.candid) {
+      case "null":
+      case "reserved":
+        return "null";
+      case "bool":
+        return value ? "true" : "false";
+      case "text":
+        return candidString(value);
+      case "principal":
+        return `principal "${value}"`;
+      case "blob":
+        return `blob "${[...value].map((b) => `\\${b.toString(16).padStart(2, "0")}`).join("")}"`;
+      case "float32":
+      case "float64":
+        return Number.isNaN(value) ? "nan" : value === Infinity ? "inf" : value === -Infinity ? "-inf" : String(value);
+      case "vec":
+        return value.length === 0 ? "vec {}" : `vec { ${value.map((e, i) => this.#child(node.element, e, `${where}[${i}]`)).join("; ")} }`;
+      case "record": {
+        const parts = entriesOf(node.fields).map(([key, child]) => `${candidLabel(key)} = ${this.#child(child, value[key], `${where}.${key}`)}`);
+        return parts.length === 0 ? "record {}" : `record { ${parts.join("; ")} }`;
+      }
+      case "variant": {
+        const arm = entriesOf(node.cases).find(([key]) => key === value.tag);
+        const key = arm === undefined ? String(value.tag) : arm[0];
+        if (arm === undefined || (arm[1].candid === "null" && arm[1].optional !== true)) return `variant { ${candidLabel(key)} }`;
+        return `variant { ${candidLabel(key)} = ${this.#child(arm[1], value.value, `${where}.${key}`)} }`;
+      }
+      default:
+        return String(value); // integers (decimal strings)
+    }
+  }
+
+  /**
+   * ABI text of an EVM value (spec section 15), as evm.mjs decodes it: an address in its EIP-55 form, bytes as 0x hex,
+   * a string quoted, an array in [ ], a tuple in ( ) with its component names.
+   */
+  #abi(node, value, where) {
+    switch (node.abi) {
+      case "address":
+        return value;
+      case "bool":
+        return value ? "true" : "false";
+      case "string":
+        return candidString(value);
+      case "array":
+        return `[${value.map((e, i) => this.#child(node.element, e, `${where}[${i}]`)).join(", ")}]`;
+      case "tuple":
+        return `(${entriesOf(node.fields)
+          .map(([key, child]) => `${key.startsWith("#") ? "" : `${key}: `}${this.#child(child, value[key], `${where}.${key}`)}`)
+          .join(", ")})`;
+      default:
+        if (value instanceof Uint8Array) return `0x${[...value].map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+        return String(value); // integers (decimal strings)
+    }
+  }
+
+  /**
+   * The ICRC-21 `Value` of one value (spec section 12). Falls back to `Text` whenever the typed form cannot carry
+   * the value exactly: an amount above nat64 or negative or without a symbol, a timestamp or duration that is not a
+   * whole number of seconds, below zero or above nat64.
+   *
+   * @returns {{ TokenAmount: object } | { TimestampSeconds: object } | { DurationSeconds: object } | { Text: { content: string } }}
+   */
+  icrc21Value(node, value, where) {
+    const f = this.formatter(node);
+    if (f !== null && typeof value === "string") {
+      const typed = this.#typed(f, value);
+      if (typed !== null) return typed;
+    }
+    return { Text: { content: this.text(node, value, where) } };
+  }
+
+  #typed(f, value) {
+    try {
+      if (f.tag === "amount") {
+        const amount = BigInt(value);
+        const { decimals, symbol } = f.args;
+        if (amount < 0n || amount > U64_MAX || typeof symbol !== "string") return null;
+        f.display(value); // the library must accept the value too (type range), or it is shown as raw text
+        return { TokenAmount: { decimals, amount, symbol } };
+      }
+      if (f.tag === "timestamp" || f.tag === "duration") {
+        const seconds = BigInt(convertUnit(value, f.args.unit, "s")); // throws E_INEXACT when not whole seconds
+        if (seconds < 0n || seconds > U64_MAX) return null;
+        f.display(value);
+        return f.tag === "timestamp" ? { TimestampSeconds: { amount: seconds } } : { DurationSeconds: { amount: seconds } };
+      }
+    } catch (e) {
+      if (e instanceof FormatError) return null;
+      throw e;
+    }
+    return null;
+  }
+}
+
+/** An EVM function's arguments: its parameters as one tuple (spec section 15), written as the ABI writes them. */
+const isAbiParams = (nodes) => nodes.length === 1 && nodes[0]?.abi === "tuple";
+
+/** `UTC`, `UTC+02:00`, `UTC-05:30`. */
+export function zoneName(offsetMinutes) {
+  if (offsetMinutes === 0) return "UTC";
+  const abs = Math.abs(offsetMinutes);
+  return `UTC${offsetMinutes < 0 ? "-" : "+"}${String(Math.floor(abs / 60)).padStart(2, "0")}:${String(abs % 60).padStart(2, "0")}`;
+}
+
+/** A Candid text literal: quotes, backslashes and invisible characters escaped. */
+function candidString(s) {
+  const escaped = s.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t");
+  return `"${visible(escaped)}"`;
+}
+
+/** A record field or variant case label as Candid writes it: an identifier, a number for `#id`, else quoted. */
+function candidLabel(key) {
+  if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) return key;
+  if (/^#(0|[1-9][0-9]*)$/.test(key)) return key.slice(1);
+  return candidString(key);
+}

package/src/erc7730.d.mts

@@ -0,0 +1,81 @@
+// Types for @meantjs/consent/erc7730: ERC-7730 clear-signing files from an EVM contract's resolved form, and the
+// ERC-8176 attestation a reviewer signs for one (spec section 15, D-054). Hand-written; the source is src/erc7730.mjs.
+// scripts/types.test.mjs keeps the declared names equal to the runtime exports.
+import type { ResolvedForm } from "./index.mjs";
+
+/** The exact-version ERC-7730 schema every exported file names in `$schema`. */
+export const ERC7730_SCHEMA_URL: "https://eips.ethereum.org/assets/eip-7730/erc7730-v2.1.0.schema.json";
+/** ERC-8176's canonical EAS schema UID (`bytes32 descriptorHash`). */
+export const ERC8176_SCHEMA_UID: "0xe023eef113c1670774801c34b377fdf612dd8a4d2fa92fe382e15bd91fafb5c2";
+/** The canonical EAS contract on Ethereum mainnet. */
+export const EAS_ADDRESS: "0xA1207F3BBa224E2c9c3c6D5aF63D0eb1582Ce587";
+
+export interface Erc7730Deployment {
+  chainId: number;
+  /** EIP-55 text. */
+  address: string;
+}
+export interface Erc7730Field {
+  path: string;
+  label: string;
+  format: "tokenAmount" | "amount" | "date" | "duration" | "addressName" | "raw";
+  params?: Record<string, unknown>;
+}
+export interface Erc7730Descriptor {
+  $schema: typeof ERC7730_SCHEMA_URL;
+  context: { contract: { deployments: Erc7730Deployment[] } };
+  metadata?: {
+    owner?: string;
+    contractName?: string;
+    info?: { url: string; deploymentDate?: string };
+    token?: { name: string; ticker: string; decimals: number };
+  };
+  display: { formats: Record<string, { intent: string; interpolatedIntent?: string; fields?: Erc7730Field[] }> };
+}
+export interface Erc7730Options {
+  /** Default: the deployments every profile that lists deployments lists. Given, each must be listed by those profiles. */
+  deployments?: Erc7730Deployment[];
+  owner?: string;
+  contractName?: string;
+  info?: { url: string; deploymentDate?: string };
+  /** Say that the contract is the token its literal amounts are in: written as `metadata.token`. */
+  token?: { name: string };
+}
+/**
+ * The ERC-7730 file of an EVM contract's resolved form and its ERC-8176 `descriptorHash`. What the profile says that an
+ * ERC-7730 file cannot say is refused (E_EXPORT); no deployments is E_DEPLOYMENT.
+ */
+export function erc7730Descriptor(resolved: ResolvedForm, options?: Erc7730Options): { descriptor: Erc7730Descriptor; descriptorHash: string };
+/** ERC-8176 `descriptorHash`: `0x` and the Keccak-256 of the RFC 8785 (JCS) form, for a descriptor without `includes`. */
+export function descriptorHash(descriptor: object): string;
+
+export interface Erc8176Input {
+  descriptorHash: string;
+  /** Unix seconds. */
+  time: bigint | number | string;
+  /** Unix seconds; 0 never expires (ERC-8176 advises a bound). */
+  expirationTime: bigint | number | string;
+  /** 32 random bytes as 0x hex, chosen by the caller. */
+  salt: string;
+  /** Default 32 zero bytes. */
+  refUID?: string;
+}
+export interface Erc8176TypedData {
+  domain: { name: "EAS Attestation"; version: "0.26"; chainId: 1; verifyingContract: typeof EAS_ADDRESS };
+  primaryType: "Attest";
+  types: { Attest: { name: string; type: string }[] };
+  message: {
+    version: 2;
+    schema: typeof ERC8176_SCHEMA_UID;
+    recipient: string;
+    time: string;
+    expirationTime: string;
+    revocable: true;
+    refUID: string;
+    /** abi.encode(descriptorHash): the 32 bytes. */
+    data: string;
+    salt: string;
+  };
+}
+/** The unsigned ERC-8176 offchain attestation (EAS offchain v2 typed data) and its EIP-712 digest. Nothing is signed. */
+export function erc8176Attestation(input: Erc8176Input): { typedData: Erc8176TypedData; digest: string };