@meantjs/consent 0.1.0 → 0.3.0

package/CHANGELOG.md

@@ -2,6 +2,36 @@
 
 The five Candid Profile library packages (`@meantjs/profile`, `/format`, `/consent`, `/tools`, `/reconcile`) release together under one version and pin each other exactly; a version appears here even when this package did not change. Release steps: `docs/releasing.md` in the repository.
 
+## 0.3.0 — 2026-10-29
+
+- `@meantjs/consent/evm`: `eip712Consent`, the consent text of an EIP-712 signing request (spec §15.9, D-055),
+  matched to a message of the resolved form by its type hash and refused before anything is shown when its domain,
+  contract, type hash or values do not match (new codes `E_DOMAIN` and `E_TYPE_HASH`). The text ends with the
+  verifying contract, the EIP-712 digest and the note that a signature is not a transaction. `evmConsent` and
+  `eip712Consent` take `tokens`, the decimals and symbol of each token an amount's `token` field names; the token's
+  address is shown beside its symbol.
+- `@meantjs/consent/erc7730`: `erc7730Descriptor(resolved, { context: "eip712" })` writes the ERC-7730 file of the
+  messages (formats keyed by `encode_type`, field groups for arrays of tokens). It returns `notes`: a timestamp's
+  words and a template ERC-7730 cannot interpolate are left out with a note instead of refusing the file, for
+  functions as well. Every file 0.2.0 writes is written the same.
+- ICRC-21 fields: an amount at or above its threshold, and a timestamp shown as words, are `Text`, never a
+  `TokenAmount` or `TimestampSeconds` of the raw number.
+
+## 0.2.0 — 2026-10-28
+
+- A call takes the `intent` and `effect` of the deepest tagged variant case its arguments hold, else the method's
+  (spec §5.2, D-053): the title, template and provenance of the message, the model's `effect` and the effect line
+  of the SNS rendering. A resolved form without case tags renders as before. The Rust version does the same.
+- EVM contracts, experimental (spec §15, D-054), in two new subpaths; the main entry is unchanged and refuses an EVM
+  resolved form (`E_RESOLVED_FORM`).
+  - `@meantjs/consent/evm`: `decodeCalldata` (strict) and `evmConsent`, the consent text of a call in the generic or
+    fields form, ending with the contract's address and chain. A call to a contract its profiles do not list is
+    `E_DEPLOYMENT`; a payable function is refused until its native value has a position.
+  - `@meantjs/consent/erc7730`: `erc7730Descriptor`, the ERC-7730 clear-signing file of a contract (schema 2.1.0,
+    deterministic) with its ERC-8176 `descriptorHash`; `descriptorHash`; `erc8176Attestation`, the unsigned EAS
+    offchain attestation a reviewer signs, with its EIP-712 digest. What a file cannot say is refused (`E_EXPORT`).
+  - New codes `E_DEPLOYMENT` and `E_EXPORT`. The Rust version does not cover EVM.
+
 ## 0.1.0 — 2026-10-28
 
 First published version.

package/README.md

@@ -6,8 +6,8 @@ ICRC-21 consent messages, and the text an SNS proposal's validator returns, from
 npm install @meantjs/consent
 ```
 
-- **Runs on:** Node 22 or later and browsers for the main entry (no Node built-in, no `Buffer`; checked with esbuild).
-  `@meantjs/consent/sns` hashes with `node:crypto` and is Node only.
+- **Runs on:** Node 22 or later and browsers for the main entry and the EVM subpaths (no Node built-in, no `Buffer`;
+  checked with esbuild). `@meantjs/consent/sns` hashes with `node:crypto` and is Node only.
 - **Module format:** ES modules only, with hand-written TypeScript declarations for every entry.
 - **Spec:** [Candid Profile v0](https://github.com/B3Pay/Meant/blob/main/profile/docs/profile-v0.md). **Licence:** Apache-2.0.
 - **Versions:** the five Candid Profile packages (`@meantjs/profile`, `/format`, `/consent`, `/tools`,
@@ -56,11 +56,46 @@ bundles it with esbuild for the browser platform). The three SNS rows below are
 ## What happens, in order
 
 1. **Decode** (`src/decode.mjs`). The argument bytes are decoded against the method's resolved-form tree into a value tree aligned with its positions: integers as decimal strings, floats as numbers, `blob` as `Uint8Array`, absent `opt` as `null`, records as objects keyed like `fields`, variants as `{ tag, value }`, vectors as arrays. Nothing is rounded or truncated.
-2. **Intent** (`src/template.mjs`, `src/model.mjs`). The method's `intent.template`: placeholders rendered through `formatterFor` of `@meantjs/format` (so `amount`, `timestamp`, `duration`, `account`, `subaccount`, `bytes` mean exactly what arm C means), `[ ... ]` dropped when a placeholder inside is absent, escapes `{{ }} [[ ]]`. Untagged positions render as Candid text. A method without `intent` gets a generic intent (title from `describe.label` of the method or `Call <method>`, one row per argument leaf). The renderer has no network access and never states anything about ledger state; dynamic refs come in through `refs`. A ref you did not supply stops the message (`E_REF_UNRESOLVED`), a number is never shown without its decimals.
+2. **Intent** (`src/template.mjs`, `src/model.mjs`). The call's `intent.template`: that of the deepest variant case with an `intent` that the decoded arguments hold, else the method's (spec §5.2, D-053; the call's effect, shown in the SNS rendering, is chosen the same way). A resolved form whose tagged cases one call holds side by side is not one a resolver writes; the method's tag is used for it. placeholders rendered through `formatterFor` of `@meantjs/format` (so `amount`, `timestamp`, `duration`, `account`, `subaccount`, `bytes` mean exactly what arm C means), `[ ... ]` dropped when a placeholder inside is absent, escapes `{{ }} [[ ]]`. Untagged positions render as Candid text. A method without `intent` gets a generic intent (title from `describe.label` of the method or `Call <method>`, one row per argument leaf). The renderer has no network access and never states anything about ledger state; dynamic refs come in through `refs`. A ref you did not supply stops the message (`E_REF_UNRESOLVED`), a number is never shown without its decimals.
 3. **Forms** (`src/render.mjs`, `src/icrc21.mjs`), section 12:
    - `FieldsDisplayMessage`: `intent` = title, `": "`, rendered template; one `(label, Value)` row per placeholder, label from `describe.label` else the field name; `amount` is a `TokenAmount` when it fits `nat64` and has a symbol, else `Text`; `timestamp` is `TimestampSeconds` after an exact ns-to-s conversion (the library throws `E_INEXACT` otherwise and the row is `Text` in RFC 3339 UTC); `duration` is `DurationSeconds`; everything else is `Text`. UTC only, never zone-sensitive.
    - `GenericDisplayMessage`: `# title`, the rendered template as a paragraph, then `- **label:** value` for the same fields. Times are shown in `utc_offset_minutes` (`2026-10-09 14:00:00 UTC+02:00`), UTC when absent, and the response metadata says which offset was applied.
 
+## EVM contracts (experimental: `src/evm.mjs`, `src/erc7730.mjs`)
+
+Spec section 15, D-054 and D-055 (EIP-712 messages, §15.9). An EVM contract's resolved form (`"chain": "evm"`, from `resolveService({ abi })` of
+`@meantjs/profile`) is read by two subpaths; the main entry refuses it with `E_RESOLVED_FORM`, and `evmConsent` refuses
+a Candid one.
+
+| Function | Does |
+|---|---|
+| `decodeCalldata(resolved, calldata, limits)` (`/evm`) | The function a selector names and its arguments, keyed by parameter name. Strict: values read from anything but their canonical ABI encoding are `E_DECODE`. |
+| `evmConsent({ resolved, calldata, to, chainId, refs, tokens, form, utcOffsetMinutes, rawArguments, limits })` (`/evm`) | The consent text of a call: the same model and the same two forms as ICRC-21, without its envelope (`"generic"` Markdown, or `"fields"` as an intent line and `[label, text]` rows), ending with the contract's address and chain, which a person must see because a pack matches any contract with the right functions. A call to a contract its profiles do not list is `E_DEPLOYMENT`; a payable function is `E_UNSUPPORTED_TYPE` (its native value has no position yet). `tokens`: the decimals and symbol of each token an amount's `token` field names, by address; the address is shown beside the symbol. |
+| `eip712Consent({ resolved, typedData, chainId, refs, tokens, form, utcOffsetMinutes, rawArguments, limits })` (`/evm`) | The consent text of an EIP-712 signing request (`eth_signTypedData_v4`'s JSON), matched to a message of the resolved form by its type hash, never its name. Refused before anything is shown: a domain for another chain than the wallet's, without `chainId` or `verifyingContract`, with a salt, or whose name or version is not its profiles' (`E_DOMAIN`); a contract its profiles do not list (`E_DEPLOYMENT`); no message with the type hash (`E_TYPE_HASH`); values that are not exactly the members, canonically written (`E_DECODE`); a token not in `tokens` (`E_REF_UNRESOLVED`). Ends with the verifying contract, the EIP-712 digest and "This is a signature, not a transaction: whoever holds it can submit it." Returns `typeHash`, `digest`, `verifyingContract` and `chainId` with the text. |
+| `erc7730Descriptor(resolved, { context, deployments, owner, contractName, info, token })` (`/erc7730`) | The contract's ERC-7730 clear-signing file and its ERC-8176 `descriptorHash`: deterministic, `$schema` pinned to the exact 2.1.0 file, one entry per function a transaction calls, or with `context: "eip712"` one per message, keyed by its `encodeType`. What an ERC-7730 file cannot say (a time in ms, `utf8` bytes, an amount in another token, an unnamed parameter) is `E_EXPORT`, never written as something near it; no deployment is `E_DEPLOYMENT`. What it cannot say but changes no value (a timestamp's "Never", a template over an array) is left out and listed in `notes`. The mapping is spec §15.7 and §15.9. |
+| `descriptorHash(descriptor)` (`/erc7730`) | Keccak-256 of the RFC 8785 form: the hash of a file someone edited. |
+| `erc8176Attestation({ descriptorHash, time, expirationTime, salt, refUID })` (`/erc7730`) | The unsigned ERC-8176 attestation (EAS offchain v2 typed data) and its EIP-712 digest, for a reviewer to sign with their own key. Nothing is signed or sent. |
+
+```js
+import { eip712Consent, evmConsent } from "@meantjs/consent/evm";
+import { erc7730Descriptor, erc8176Attestation } from "@meantjs/consent/erc7730";
+
+evmConsent({ resolved, calldata, to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", refs: { "query:decimals": 18, "query:symbol": "WETH" } }).message;
+// # Send tokens\n\nSend `1.5 WETH` to `0xfB69…d359`\n\n- **Amount:** `1.5 WETH`\n- **Recipient:** `0xfB69…d359`\n\n**Contract:** `0xC02a…6Cc2`
+const { descriptor, descriptorHash } = erc7730Descriptor(resolved, { deployments: [{ chainId: 1, address: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2" }] });
+const { typedData, digest } = erc8176Attestation({ descriptorHash, time: 1777630591, expirationTime: 1785406591, salt });
+
+// A Permit2 signing request, with the profile in @meantjs/profile/packs/permit2.profile.json
+eip712Consent({ resolved: permit2, typedData, chainId: 1, tokens: { "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48": { decimals: 6, symbol: "USDC" } } }).message;
+// # Permit2: allow token spending\n\nLet `0x66a9…A8Af` spend up to `Unlimited USDC (0xA0b8…eB48)`. Allowance expires: …
+```
+
+Every exported file in the tests is checked against the ERC-7730 2.1.0 JSON Schema (vendored in
+`test/upstream/erc7730/`, CC0, sha256 in its `SOURCE.json`), and the hashes and digests they pin were computed by an
+independent implementation. **Fact** (ERC-7730): a wallet that finds no ticker for a `tokenAmount` "SHOULD display the
+raw value instead with an 'Unknown token' warning"; this package would produce no message there, and a file cannot make
+a wallet refuse. The Rust version does not cover EVM.
+
 ## SNS proposal validators (`src/sns.mjs`)
 
 The governance counterpart of ICRC-21. An SNS proposal that executes a generic nervous system function calls a dapp method with a payload. Apart from the proposer's own title and summary, the only description of that payload governance shows is the text the dapp's validator method returns. `snsValidatorRendering` is that validator, generated from the profile. Proposal for the spec text: `docs/proposals/w4-sns-validator-rendering.md`.
@@ -125,7 +160,7 @@ The relying party is not trusted, so every value that comes from the call is sho
 |---|---|
 | Unknown method, argument bytes that do not decode, arguments too large, malformed request, unsupported language with `languagePolicy: "error"` | `UnsupportedCanisterCall` (`description` starts with the code: `E_METHOD_UNKNOWN`, `E_DECODE`, `E_TOO_LARGE`, `E_REQUEST`, `E_LANGUAGE`) |
 | A value that reaches a position the resolved form cuts (`recursive: true`; a call whose value avoids every cut gets its message, D-042), or a method with a `func` or `service` position | `ConsentMessageUnavailable` (`E_UNSUPPORTED_TYPE`) |
-| Missing dynamic ref, invalid tag argument, malformed resolved form | `GenericError` with `error_code` 1100 (ref), 1101 (arg), 1102 (tag type), 1103 (tag conflict), 1000 (resolved form), 1999 (internal) |
+| Missing dynamic ref, invalid tag argument, malformed resolved form (an EVM one among them) | `GenericError` with `error_code` 1100 (ref), 1101 (arg), 1102 (tag type), 1103 (tag conflict), 1000 (resolved form), 1999 (internal) |
 
 A language other than English is **not** an error: ICRC-21 says a message "should be preferred over sending an icrc21_error" and "the metadata must match the consent_message provided", so the answer is English with `metadata.language: "en"` (`I_LANGUAGE_FALLBACK` in `diagnostics`). Limits are explicit and never truncate: 2 MiB of argument bytes, 64 fields, 256 list elements, 32 KiB of message text.
 
@@ -213,3 +248,6 @@ Untrusted third-party data lives in `test/upstream/icrc21/` (the standard, commi
 - The caller's account (`From`) and a fee line: see `docs/oisy-comparison.md` for why they are absent.
 - Other languages; `device_spec` hints beyond the two forms.
 - Recursive and `func`/`service` positions (need a richer resolved form, or the Contract).
+- EVM: payable functions in the consent text, EIP-712 witness messages and the signer check (spec §15.9 O9, O13),
+  ERC-7730 import, checking attestations, and the Rust
+  version.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meantjs/consent",
-  "version": "0.1.0",
+  "version": "0.3.0",
   "description": "ICRC-21 consent messages and SNS proposal validator renderings generated from a Candid Profile resolved form: any method, both GenericDisplayMessage and FieldsDisplayMessage, values formatted and escaped, nothing rounded.",
   "license": "Apache-2.0",
   "repository": {
@@ -19,7 +19,11 @@
     "icrc-21",
     "consent-message",
     "sns",
-    "wallet"
+    "wallet",
+    "evm",
+    "erc-7730",
+    "erc-8176",
+    "clear-signing"
   ],
   "type": "module",
   "sideEffects": false,
@@ -34,6 +38,14 @@
       "types": "./src/sns.d.mts",
       "default": "./src/sns.mjs"
     },
+    "./evm": {
+      "types": "./src/evm.d.mts",
+      "default": "./src/evm.mjs"
+    },
+    "./erc7730": {
+      "types": "./src/erc7730.d.mts",
+      "default": "./src/erc7730.mjs"
+    },
     "./package.json": "./package.json"
   },
   "files": [
@@ -51,12 +63,13 @@
     "sns": "node scripts/sns-render.mjs"
   },
   "dependencies": {
-    "@meantjs/profile": "0.1.0",
-    "@meantjs/format": "0.1.0",
-    "@candid-core/schema": "0.5.0"
+    "@candid-core/schema": "0.5.0",
+    "@meantjs/format": "0.3.0",
+    "@meantjs/profile": "0.3.0"
   },
   "devDependencies": {
     "@dfinity/didc": "0.0.4",
+    "ajv": "8.18.0",
     "commonmark": "0.31.2",
     "esbuild": "0.28.2"
   }

package/src/display.mjs

@@ -20,6 +20,23 @@ const CONFIG_CODES = new Set(["E_REF_UNRESOLVED", "E_ARG", "E_TAG_TYPE", "E_TAG_
 /** 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;
 
+/**
+ * An amount in the token a field of the same value names (spec section 15.9): the base units, the token's EIP-55
+ * address, and its decimals and symbol as the caller supplied them. evm.mjs puts one in place of each such amount of a
+ * decoded value; its text is the base units, so a view without formatters shows those.
+ */
+export class TokenAmount {
+  constructor(value, token, metadata) {
+    this.value = value;
+    this.token = token;
+    this.metadata = metadata;
+    Object.freeze(this);
+  }
+  toString() {
+    return this.value;
+  }
+}
+
 export class Renderer {
   /** Set while `plainTupleText` runs: no formatter applies. */
   #plain = false;
@@ -39,17 +56,24 @@ export class Renderer {
     this.usedZone = false;
   }
 
-  /** @returns {import("@meantjs/format").Formatter | null} */
-  formatter(node) {
-    if (this.formatters.has(node)) return this.formatters.get(node);
+  /**
+   * @param {object} node
+   * @param {TokenAmount} [amount]  a value whose token a field names: the formatter takes that token's metadata
+   * @returns {import("@meantjs/format").Formatter | null}
+   */
+  formatter(node, amount) {
+    const key = amount === undefined ? "" : amount.token;
+    if (!this.formatters.has(node)) this.formatters.set(node, new Map());
+    const cache = this.formatters.get(node);
+    if (cache.has(key)) return cache.get(key);
     let f;
     try {
-      f = formatterFor(node, { refs: this.refs });
+      f = formatterFor(node, { refs: this.refs, token: amount?.metadata });
     } 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);
+    cache.set(key, f);
     return f;
   }
 
@@ -77,6 +101,7 @@ export class Renderer {
 
   /** 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(", ")})`);
   }
 
@@ -87,6 +112,7 @@ export class Renderer {
   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;
@@ -96,10 +122,21 @@ export class Renderer {
   /** 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;
+    if (value instanceof TokenAmount) {
+      // The token's own symbol is its claim, so its address is always shown beside it (spec section 15.9).
+      const f = this.formatter(node, value);
+      try {
+        return `${f.display(value.value)} (${value.token})`;
+      } 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 in base units` });
+        return `${value.value} (${value.token})`;
+      }
+    }
     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);
+      return f.tag === "timestamp" && this.utcOffsetMinutes !== null && !this.#worded(f, value) ? 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` });
@@ -107,6 +144,13 @@ export class Renderer {
     }
   }
 
+  /** Whether a timestamp shows words instead of a time: a label for its value, or its threshold's message (spec section 15.9). */
+  #worded(f, value) {
+    if (typeof value !== "bigint" && !(typeof value === "string" && /^-?[0-9]+$/.test(value))) return false; // the formatter refuses it anyway
+    const v = BigInt(value);
+    return (f.args.labels !== undefined && Object.hasOwn(f.args.labels, v.toString())) || (f.args.threshold !== undefined && v >= BigInt(f.args.threshold));
+  }
+
   /** 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;
@@ -126,6 +170,7 @@ export class Renderer {
   }
 
   #raw(node, value, where) {
+    if (typeof node.abi === "string") return this.#abi(node, value, where);
     switch (node.candid) {
       case "null":
       case "reserved":
@@ -158,6 +203,30 @@ export class Renderer {
     }
   }
 
+  /**
+   * 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
@@ -178,12 +247,14 @@ export class Renderer {
     try {
       if (f.tag === "amount") {
         const amount = BigInt(value);
-        const { decimals, symbol } = f.args;
+        const { decimals, symbol, threshold } = f.args;
         if (amount < 0n || amount > U64_MAX || typeof symbol !== "string") return null;
+        if (threshold !== undefined && amount >= BigInt(threshold)) return null; // shown as its message ("Unlimited ICP"), not a number
         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") {
+        if (f.tag === "timestamp" && this.#worded(f, value)) return null; // shown as its words ("Never"), not a time
         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);
@@ -197,6 +268,9 @@ export class Renderer {
   }
 }
 
+/** 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";

package/src/erc7730.d.mts

@@ -0,0 +1,92 @@
+// 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";
+  /** `tokenPath`: `@.to` (the contract, or a message's verifying contract) or a path to the token's address field. */
+  params?: Record<string, unknown>;
+}
+/** The fields of each element of an array whose elements carry their own token (`path: "details.[]"`); paths relative. */
+export interface Erc7730FieldGroup {
+  path: string;
+  fields: (Erc7730Field | Erc7730FieldGroup)[];
+}
+export interface Erc7730Descriptor {
+  $schema: typeof ERC7730_SCHEMA_URL;
+  /** `contract` for a file of functions; `eip712` for a file of messages, with the domain name and version its profiles give. */
+  context: { contract: { deployments: Erc7730Deployment[] } } | { eip712: { domain?: { name?: string; version?: string }; deployments: Erc7730Deployment[] } };
+  metadata?: {
+    owner?: string;
+    contractName?: string;
+    info?: { url: string; deploymentDate?: string };
+    token?: { name: string; ticker: string; decimals: number };
+  };
+  /** Keyed by named signature (functions) or by encodeType (messages). */
+  display: { formats: Record<string, { intent: string; interpolatedIntent?: string; fields?: (Erc7730Field | Erc7730FieldGroup)[] }> };
+}
+export interface Erc7730Options {
+  /** "contract" (default): the functions a transaction calls. "eip712": the EIP-712 messages (spec section 15.9). */
+  context?: "contract" | "eip712";
+  /** 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. What it cannot say but changes no
+ * value (a timestamp's words, an interpolation of an array) is left out and listed in `notes`.
+ */
+export function erc7730Descriptor(resolved: ResolvedForm, options?: Erc7730Options): { descriptor: Erc7730Descriptor; descriptorHash: string; notes: 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 };