@meantjs/profile 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meantjs/profile",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "description": "Candid Profile resolver: validates profiles, matches packs by Candid subtyping, merges layers (spec section 8) and emits the resolved form (spec section 10).",
   "license": "Apache-2.0",
   "repository": {

package/src/abi-iface.mjs

@@ -9,17 +9,33 @@
  *                    an unnamed one's is its position (`#1`)
  *   T[] and T[k]     a vector (`[]`); T[k] keeps its length
  *   anything else    a primitive named by its canonical ABI type (`uint256`, `address`, `bytes32`, `string`)
+ *   an EIP-712       a method of mode "message" (spec section 15.9) whose one argument is the struct, a record of its
+ *   message          members in order (`PermitSingle(0).details.amount`); it has no results
  */
 import { Iface } from "./iface.mjs";
 import { idlHash } from "./idl.mjs";
-import { AbiError, abiInterfaceId, componentKey, parseAbi, readAddress } from "./abi.mjs";
+import { AbiError, abiInterfaceId, componentKey, eip712AbiType, eip712TypeHash, encodeType, parseAbi, parseEip712Types, readAddress } from "./abi.mjs";
 
 export class AbiIface extends Iface {
-  /** @param functions from parseAbi */
-  constructor(envelope, functions, label) {
+  /**
+   * @param functions from parseAbi
+   * @param eip712  { types, messages } (spec section 15.9): the struct types, and which of them are messages
+   */
+  constructor(envelope, functions, label, eip712 = { types: {}, messages: [] }) {
     super(envelope, label);
     this.chain = "evm";
     this.functions = new Map(functions.map((f) => [f.name, f]));
+    /** The identity of the functions alone: what a contract profile's `binds.abi` binds to (spec section 15.1). */
+    this.abiId = abiInterfaceId(functions);
+    this.structs = eip712.types;
+    this.messages = new Map(eip712.messages.map((name) => [name, { encodeType: encodeType(eip712.types, name), typeHash: eip712TypeHash(eip712.types, name) }]));
+  }
+  resolve(addr) {
+    const r = super.resolve(addr);
+    if (r.error && addr.kind !== "type" && !this.methods.has(addr.method) && Object.hasOwn(this.structs, addr.method)) {
+      return { error: `${addr.method} is an EIP-712 type but not a message: tag its name with intent to make it one, or address it through a message that contains it` };
+    }
+    return r;
   }
   isBlob(ref) {
     const p = this.prim(ref);
@@ -43,12 +59,17 @@ export class AbiIface extends Iface {
 /**
  * @param entries  an ABI: human-readable fragments or JSON ABI entries (parseAbi)
  * @param label    how diagnostics name it (`binds.abi`, `abi`)
+ * @param eip712   { types, messages, label } (spec section 15.9): struct types already read by parseEip712Types, the
+ *                 names of those that are messages, and how diagnostics name the types; null for none
+ * @param opts.allowEmpty  an interface with no function and no message is not refused (resolveService adds the
+ *                 messages of its profiles later)
  * @returns {{ iface: AbiIface } | { failure: { at: string, message: string }[] }}
  */
-export function abiInterface(entries, label = "abi", ifaceLabel = "contract") {
+export function abiInterface(entries, label = "abi", ifaceLabel = "contract", eip712 = null, { allowEmpty = false } = {}) {
   const { functions, errors } = parseAbi(entries, label);
   if (errors.length) return { failure: errors };
-  if (functions.length === 0) return { failure: [{ at: label, message: "the ABI has no functions" }] };
+  const messages = eip712?.messages ?? [];
+  if (functions.length === 0 && messages.length === 0 && !allowEmpty) return { failure: [eip712 ? { at: eip712.label, message: "the ABI has no functions and no type is a message (tag a type's name with intent)" } : { at: label, message: "the ABI has no functions" }] };
   const types = [];
   const names = [];
   const failure = [];
@@ -81,13 +102,34 @@ export function abiInterface(entries, label = "abi", ifaceLabel = "contract") {
     const mode = f.stateMutability === "view" || f.stateMutability === "pure" ? "query" : "update";
     return { name: f.name, function: add({ kind: "func", mode, args, results }) };
   });
+  for (const name of messages) {
+    const at = `${eip712.label}.${name}`;
+    if (functions.some((f) => f.name === name)) {
+      failure.push({ at, message: `a function and a message are both named ${name}; an address names one of them` });
+      continue;
+    }
+    methods.push({ name, function: add({ kind: "func", mode: "message", args: [build(eip712AbiType(eip712.types, name), `${name}(0)`)], results: [] }) });
+  }
   if (failure.length) return { failure };
   const service = add({ kind: "service", methods });
+  const structs = eip712?.types ?? {};
   const envelope = {
-    contract: { types, declarations: [], actor: { kind: "service", service }, identities: { interface: abiInterfaceId(functions) } },
+    contract: { types, declarations: [], actor: { kind: "service", service }, identities: { interface: abiInterfaceId(functions, structs) } },
     extensions: { "org.candid-core.field-names/v1": names },
   };
-  return { iface: new AbiIface(envelope, functions, ifaceLabel) };
+  return { iface: new AbiIface(envelope, functions, ifaceLabel, { types: structs, messages }) };
+}
+
+/**
+ * The messages a profile or pack declares (spec section 15.9): the types of `binds.eip712` whose name the same
+ * document tags with `intent`. Returns { types, messages, errors }.
+ */
+export function eip712Of(doc, label = "binds.eip712.types") {
+  const spec = doc.binds?.eip712;
+  if (spec === undefined) return { types: {}, messages: [], errors: [] };
+  const { types, errors } = parseEip712Types(spec.types, label);
+  const messages = [...new Set(doc.annotations.filter((a) => a.tag === "intent" && Object.hasOwn(types, a.at)).map((a) => a.at))].sort();
+  return { types, messages, errors };
 }
 
 /**

package/src/abi-pack.mjs

@@ -5,7 +5,8 @@
  *
  * Parameter names are not part of a selector, and contracts name the parameters of one standard differently (EIP-20
  * says `_to`, OpenZeppelin `to`, WETH `dst`). A pack's addresses and template placeholders use the pack's own names;
- * when the pack applies, they are rewritten to the contract's names, component by component, by position.
+ * when the pack applies, they are rewritten to the contract's names, component by component, by position. So is an
+ * amount's `token` path (spec section 15.9).
  */
 import { parseAddress, parseRelPath } from "./address.mjs";
 import { componentKey, parseAbi, typeString } from "./abi.mjs";
@@ -107,7 +108,9 @@ export function translatePack(pack, functions, iface) {
   };
   const annotations = pack.annotations.map((a) => {
     const method = parseAddress(a.at)?.method;
-    const args = a.tag === "intent" && typeof a.args?.template === "string" && method ? { ...a.args, template: mapTemplate(a.args.template, placeholder(method)) } : a.args;
+    let args = a.args;
+    if (a.tag === "intent" && typeof a.args?.template === "string" && method) args = { ...a.args, template: mapTemplate(a.args.template, placeholder(method)) };
+    if (a.tag === "amount" && typeof a.args?.token === "string" && method) args = { ...a.args, token: placeholder(method)(a.args.token) ?? a.args.token };
     return { ...a, at: at(a.at), args };
   });
   return { ...pack, annotations };

package/src/abi.mjs

@@ -320,9 +320,13 @@ export function parseAbi(entries, label = "abi") {
   return { functions: kept.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0)), errors };
 }
 
-/** The identity of an EVM interface: SHA-256 over the JCS array of its canonical fragments, sorted (spec section 15). */
-export function abiInterfaceId(functions) {
-  return `candid-profile:evm-abi:v0:sha256:${sha256Hex(jcs(functions.map((f) => f.canonical).sort()))}`;
+/**
+ * The identity of an EVM interface: SHA-256 over the JCS array of its canonical fragments and, when it has EIP-712
+ * types (spec section 15.9), one `struct Name(type member,…)` line per type, sorted (spec section 15).
+ */
+export function abiInterfaceId(functions, types = {}) {
+  const structs = Object.keys(types).map((n) => `struct ${structText(types, n)}`);
+  return `candid-profile:evm-abi:v0:sha256:${sha256Hex(jcs([...functions.map((f) => f.canonical), ...structs].sort()))}`;
 }
 
 /** Read one function from its named signature (`transfer(address to,uint256 value)`), as a resolved form carries it. */
@@ -610,6 +614,8 @@ const EIP712_DOMAIN = [
   ["salt", "bytes32"],
 ];
 
+const structText = (types, name) => `${name}(${types[name].map((f) => `${f.type} ${f.name}`).join(",")})`;
+
 function typeEncoding(types, primary) {
   const deps = new Set();
   const visit = (name) => {
@@ -619,7 +625,108 @@ function typeEncoding(types, primary) {
   };
   visit(primary);
   deps.delete(primary);
-  return [primary, ...[...deps].sort()].map((n) => `${n}(${types[n].map((f) => `${f.type} ${f.name}`).join(",")})`).join("");
+  return [primary, ...[...deps].sort()].map((n) => structText(types, n)).join("");
+}
+
+/**
+ * EIP-712 `encodeType` of a struct type: the type with its members, then every struct type it refers to, sorted by
+ * name (`Mail(Person from,Person to,string contents)Person(string name,address wallet)`).
+ *
+ * @param {Record<string, { name: string, type: string }[]>} types
+ * @param {string} primary
+ */
+export function encodeType(types, primary) {
+  if (!Object.hasOwn(types, primary)) fail("E_EIP712", `no type ${primary}`);
+  return typeEncoding(types, primary);
+}
+
+/** EIP-712 `typeHash`: the Keccak-256 of `encodeType`, as `0x` and 64 hex digits. */
+export const eip712TypeHash = (types, primary) => `0x${keccak256Hex(encodeType(types, primary))}`;
+
+const EIP712_MEMBER = /^([A-Za-z_][A-Za-z0-9_]*)((?:\[\d*\])*)$/;
+/** Names a struct may not take: they read as ABI types, or are the domain's own type. */
+const RESERVED_STRUCT = /^(?:u?int\d*|u?fixed.*|address|bool|string|bytes\d*|byte|function|tuple|EIP712Domain)$/;
+
+/**
+ * Read the EIP-712 types of a profile (`binds.eip712.types`, spec section 15.9): struct names that are identifiers and
+ * not ABI type names, members with unique names, member types that are canonical ABI types (`uint256`, never `uint`:
+ * the type hash hashes the text as written) or struct types of the same map, with array suffixes, and no struct that
+ * contains itself. Every problem is reported, none thrown.
+ *
+ * @param {unknown} types
+ * @param {string} [label]  how diagnostics name the map (`binds.eip712.types`)
+ * @returns {{ types: Record<string, { name: string, type: string }[]>, errors: { at: string, message: string }[] }}
+ */
+export function parseEip712Types(types, label = "types") {
+  const errors = [];
+  const err = (at, message) => void errors.push({ at, message });
+  if (types === null || typeof types !== "object" || Array.isArray(types)) return { types: {}, errors: [{ at: label, message: "EIP-712 types are an object of struct name to members" }] };
+  const out = {};
+  for (const [name, members] of Object.entries(types)) {
+    const at = `${label}.${name}`;
+    if (!IDENT.test(name)) { err(at, `the struct name ${JSON.stringify(name)} is not an identifier (letters, digits and _)`); continue; }
+    if (RESERVED_STRUCT.test(name)) { err(at, `a struct cannot be named ${name}: the name reads as an ABI type or the domain's type`); continue; }
+    if (!Array.isArray(members) || members.length === 0) { err(at, "a struct has at least one member, each { name, type }"); continue; }
+    const seen = new Set();
+    let ok = true;
+    members.forEach((m, i) => {
+      const where = `${at}[${i}]`;
+      if (m === null || typeof m !== "object" || typeof m.name !== "string" || typeof m.type !== "string") { ok = false; return err(where, "a member is { name, type } with two strings"); }
+      if (!IDENT.test(m.name)) { ok = false; return err(where, `the member name ${JSON.stringify(m.name)} is not an identifier`); }
+      if (seen.has(m.name)) { ok = false; return err(where, `two members are named ${m.name}`); }
+      seen.add(m.name);
+      const t = EIP712_MEMBER.exec(m.type);
+      if (!t) { ok = false; return err(where, `${JSON.stringify(m.type)} is not a type`); }
+      for (const d of t[2].matchAll(/\[(\d*)\]/g)) if (d[1] !== "" && !/^[1-9]\d{0,5}$/.test(d[1])) { ok = false; return err(where, `array length [${d[1]}] must be a positive integer`); }
+      if (Object.hasOwn(types, t[1])) return;
+      try {
+        const e = elementary(t[1], where);
+        if (typeString(e) !== t[1]) { ok = false; err(where, `write ${typeString(e)}, not ${t[1]}: the type hash hashes the type as written`); }
+      } catch (e) {
+        if (!(e instanceof AbiError)) throw e;
+        ok = false;
+        err(where, `${t[1]} is neither an ABI type nor a struct of these types`);
+      }
+    });
+    if (ok) out[name] = members.map((m) => ({ name: m.name, type: m.type }));
+  }
+  // A struct that contains itself, directly or not, has no finite value to sign.
+  const state = new Map(); // name -> 1 on the walk, 2 done
+  const cyclic = new Set();
+  const visit = (name, trail) => {
+    if (state.get(name) === 2 || !Object.hasOwn(out, name)) return;
+    if (state.get(name) === 1) {
+      const loop = trail.slice(trail.indexOf(name));
+      for (const n of loop) cyclic.add(n);
+      err(`${label}.${name}`, `${[...loop, name].join(" -> ")}: a struct cannot contain itself`);
+      return;
+    }
+    state.set(name, 1);
+    for (const m of out[name]) visit(m.type.replace(/(\[\d*\])+$/, ""), [...trail, name]);
+    state.set(name, 2);
+  };
+  for (const name of Object.keys(out).sort()) visit(name, []);
+  for (const n of cyclic) delete out[n];
+  // A struct that refers to one refused above cannot be encoded either.
+  for (let dropped = true; dropped; ) {
+    dropped = false;
+    for (const name of Object.keys(out).sort()) {
+      const bad = out[name].map((m) => m.type.replace(/(\[\d*\])+$/, "")).find((t) => Object.hasOwn(types, t) && !Object.hasOwn(out, t));
+      if (bad === undefined) continue;
+      err(`${label}.${name}`, `refers to ${bad}, which is refused above`);
+      delete out[name];
+      dropped = true;
+    }
+  }
+  return { types: out, errors };
+}
+
+/** The ABI type tree of an EIP-712 member type: a struct is a tuple of its members, in order. */
+export function eip712AbiType(types, text) {
+  const m = EIP712_MEMBER.exec(text);
+  if (!m) fail("E_EIP712", `${JSON.stringify(text)} is not a type`);
+  const base = Object.hasOwn(types, m[1]) ? { kind: "tuple", components: types[m[1]].map((f) => ({ name: f.name, type: eip712AbiType(types, f.type) })) } : elementary(m[1], text);
+  return withDims(base, [...m[2].matchAll(/\[(\d*)\]/g)].map((d) => d[1]), text);
 }
 
 function encodeField(types, type, value, where) {

package/src/analyze.mjs

@@ -9,6 +9,7 @@ import { TagIndex, LayeredTags, positions } from "./tags.mjs";
 import {
   NUMERIC, METHOD_TAGS, CASE_TAGS, CONFIRM_KINDS, STALE_CODES, VALUE_CONVERSION_TAGS, EVM_LATER_TAGS,
   checkApplicability, checkDynamic, parseTemplate, outcomeCoverage, caseTargetError, otherCase, overlap, defaultEffect,
+  tokenPathError, grantError,
 } from "./checks.mjs";
 
 /** Spec section 8, highest precedence first. */
@@ -111,6 +112,11 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
 
   /** An effect against the method's mode (spec 5.3); for a case effect, the mode of the method it sits in. */
   const checkEffectMode = (m, { kind, irreversible, replicated }, diag, at) => {
+    // A signed EIP-712 message (spec section 15.9) runs nothing when it is signed: any kind describes what it allows.
+    if (m.mode === "message") {
+      if (replicated === true) diag("error", "E_EFFECT_MODE", at, "replicated: true applies to update methods, not to a message");
+      return;
+    }
     if (m.mode !== "update" && m.mode !== "oneway" && kind !== "read") diag("error", "E_EFFECT_MODE", at, `${m.mode} method cannot have effect kind "${kind}"`);
     // A read-only update (D-038): a read sent as an update so that its answer goes through consensus.
     if (replicated === true) {
@@ -141,6 +147,18 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
     }
   };
 
+  /**
+   * A grant that does not hold (spec 5.3, D-056). A pack applied to a service loses only its grant, never the effect:
+   * dropping the effect would leave a transfer or approve with the default effect, which needs no confirmation.
+   */
+  const grants = []; // effects whose grant holds, checked again once dropped tags are known
+  const badGrant = (e, diag, why) => {
+    if (!e.item.apply) return diag("error", "E_GRANT", e.ann.at, why);
+    const { grant, ...args } = e.entry.args;
+    e.entry.args = args;
+    e.item.diag("info", "I_PACK_ANNOTATION_SKIPPED", e.ann.at, `effect grant dropped, the effect kept: E_GRANT: ${why}`);
+  };
+
   const sets = new Map(); // names set -> { at, method, fields: { name, value, show?, kind? } } (spec 5.3, D-045)
   const named = []; // named positions, checked once every set is known
   for (const e of entries) {
@@ -161,8 +179,10 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
       const why = caseTargetError(iface, addr, res, a.tag);
       if (why) { diag("error", "E_TAG_TARGET", at, why); continue; }
       const m = iface.methods.get(addr.method);
-      if (a.tag === "effect") checkEffectMode(m, a.args, diag, at);
-      else checkTemplate(item, addr.method, a.args.template, diag, at, addr);
+      if (a.tag === "effect") {
+        checkEffectMode(m, a.args, diag, at);
+        if (a.args.grant) badGrant(e, diag, "a grant sits on the effect of a method, not of a case, in this version (D-056)");
+      } else checkTemplate(item, addr.method, a.args.template, diag, at, addr);
       caseEntries.push({ e, diag });
       continue;
     }
@@ -170,6 +190,11 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
       const m = res.method;
       const methodName = addr.method;
       if (a.tag === "effect") checkEffectMode(m, a.args, diag, at);
+      if (a.tag === "effect" && a.args.grant) {
+        const why = grantError(iface, tags, methodName, a.args);
+        if (why) badGrant(e, diag, why);
+        else grants.push({ e, diag });
+      }
       if (a.tag === "idempotency") {
         if (m.mode !== "update") diag("error", "E_IDEMPOTENCY_MODE", at, "idempotency applies to update methods");
         const r = iface.resolveRel(methodName, "args", a.args.stamp);
@@ -234,7 +259,10 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
     const err = checkApplicability(iface, a.tag, res.ref);
     if (err) diag("error", "E_TAG_NOT_APPLICABLE", at, err);
     if (a.tag === "named") named.push({ a, res, diag, at });
-    if (a.tag === "amount") {
+    if (a.tag === "amount" && a.args.token !== undefined) {
+      const why = tokenPathError(iface, addr, a.args.token);
+      if (why) diag("error", "E_TOKEN_PATH", at, why);
+    } else if (a.tag === "amount") {
       checkDynamic(iface, a.args.decimals, "numeric", diag, at);
       checkDynamic(iface, a.args.symbol, "text", diag, at);
     }
@@ -280,9 +308,14 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
     }
   }
 
-  // Dropping a value tag can leave an idempotency stamp without its timestamp tag: drop that idempotency too.
+  // Dropping a value tag can leave an idempotency stamp without its timestamp tag: drop that idempotency too. It can
+  // also leave a grant without the amount, timestamp or account tag it needs.
   if (dropped.size) {
     const without = buildLayers(entries, (e) => !dropped.has(e));
+    for (const { e, diag } of grants) {
+      const why = !dropped.has(e) && grantError(iface, without, e.addr.method, e.entry.args);
+      if (why) badGrant(e, diag, `${why} (a tag it needs was dropped in this service)`);
+    }
     for (const e of entries) {
       if (!e.item.apply || e.ann.tag !== "idempotency" || dropped.has(e)) continue;
       const r = iface.resolveRel(e.addr.method, "args", e.ann.args.stamp);
@@ -326,10 +359,11 @@ export function analyzeProfiles(iface, items, { attribute = true } = {}) {
     }
   }
 
-  // Coverage hint: numeric positions in update-method arguments with no meaning attached (merged view).
+  // Coverage hint: numeric positions in the arguments of update methods and EIP-712 messages with no meaning attached
+  // (merged view).
   const MEANING = ["amount", "timestamp", "duration", "describe", "range"];
   for (const [name, m] of iface.methods) {
-    if (m.mode !== "update") continue;
+    if (m.mode !== "update" && m.mode !== "message") continue;
     for (const pos of positions(iface, name, "args")) {
       const p = iface.prim(iface.unwrapOpt(pos.ref).ref);
       const t = final.at(pos, iface);

package/src/browser.mjs

@@ -11,6 +11,7 @@ import schema from "../data/profile-v0.schema.json" with { type: "json" };
 import icrc1 from "../data/packs/icrc1.profile.json" with { type: "json" };
 import icrc2 from "../data/packs/icrc2.profile.json" with { type: "json" };
 import erc20 from "../data/packs/erc20.profile.json" with { type: "json" };
+import erc2612 from "../data/packs/erc2612.profile.json" with { type: "json" };
 import { compileSchema } from "./schema-core.mjs";
 
 export { init as initCompiler } from "@candid-core/cli";
@@ -32,9 +33,13 @@ export { readServedProfile, SERVED_SECTION, SERVED_METADATA, SERVED_MAX_BYTES }
 /** The profile schema (a copy of spec/profile-v0.schema.json). */
 export const PROFILE_SCHEMA = schema;
 
-/** The standard packs (copies of packs/*.profile.json), sorted by file name, in the shape `loadPacks` returns. */
+/**
+ * The standard packs (copies of packs/*.profile.json whose kind is "pack"), sorted by file name, in the shape
+ * `loadPacks` returns. The standard contract profiles there (Permit2, DAI's permit) are under `./packs/*` too.
+ */
 export const STANDARD_PACKS = Object.freeze([
   { file: "erc20.profile.json", doc: erc20 },
+  { file: "erc2612.profile.json", doc: erc2612 },
   { file: "icrc1.profile.json", doc: icrc1 },
   { file: "icrc2.profile.json", doc: icrc2 },
 ]);

package/src/checks.mjs

@@ -18,7 +18,7 @@ export const CASE_TAGS = new Set(["intent", "effect"]);
 export const CONFIRM_KINDS = new Set(["transfer", "approve", "admin", "destroy"]);
 /** Tags that convert a value between its wire form and a human form; a stale profile must not supply them (spec section 7). */
 export const VALUE_CONVERSION_TAGS = new Set(["amount", "timestamp", "duration", "account", "subaccount", "bytes", "named"]);
-export const STALE_CODES = new Set(["E_ADDR_UNRESOLVED", "E_TYPE_NODE", "E_TAG_NOT_APPLICABLE", "E_REF_UNRESOLVED", "E_REF_NOT_QUERY", "E_REF_SHAPE", "E_REF_TYPE", "E_STAMP_UNTAGGED", "E_OUTCOME_NOT_CASE", "E_TEMPLATE_PATH", "E_TAG_TARGET", "E_NAMES_MODE", "E_NAMES_SHAPE", "E_NAMES_FIELD", "E_NAMED_SET", "E_NAMED_TYPE", "E_CASE_OVERLAP", "E_CASE_EFFECT"]);
+export const STALE_CODES = new Set(["E_ADDR_UNRESOLVED", "E_TYPE_NODE", "E_TAG_NOT_APPLICABLE", "E_REF_UNRESOLVED", "E_REF_NOT_QUERY", "E_REF_SHAPE", "E_REF_TYPE", "E_STAMP_UNTAGGED", "E_OUTCOME_NOT_CASE", "E_TEMPLATE_PATH", "E_TAG_TARGET", "E_NAMES_MODE", "E_NAMES_SHAPE", "E_NAMES_FIELD", "E_NAMED_SET", "E_NAMED_TYPE", "E_CASE_OVERLAP", "E_CASE_EFFECT", "E_TOKEN_PATH", "E_GRANT"]);
 
 export function checkApplicability(iface, tag, ref) {
   const { ref: r } = iface.unwrapOpt(ref);
@@ -37,6 +37,75 @@ export function checkApplicability(iface, tag, ref) {
   }
 }
 
+/**
+ * An amount's `token` (spec section 15.9): a path from the arguments of the same function or message to the `address`
+ * of the token the amount is in, through the same array elements as the amount. The reason it is wrong, or null.
+ */
+export function tokenPathError(iface, addr, token) {
+  if (iface.chain !== "evm") return "token names the address of an EVM token; a Candid amount's ledger cannot be named by a field yet (OQ-6)";
+  if (addr.kind !== "arg") return "an amount with a token sits in the arguments of a function or message, where the token's address is";
+  const p = parseRelPath(token);
+  const r = iface.resolveRel(addr.method, "args", token);
+  if (!p || r.error) return `token ${JSON.stringify(token)}: ${r.error ?? "not a relative path"}`;
+  if ((p.index ?? 0) !== addr.index) return `token ${JSON.stringify(token)} is in another argument than the amount`;
+  if (iface.prim(r.ref) !== "address") return `token ${JSON.stringify(token)} is ${iface.describeType(r.ref)}, not an address`;
+  const last = p.segs.findLastIndex((s) => s.kind === "elem");
+  const same = (a, b) => a.kind === b.kind && (a.kind === "elem" || a.id === b.id);
+  if (last >= 0 && (addr.segs.length <= last || !p.segs.slice(0, last + 1).every((s, i) => same(s, addr.segs[i])))) {
+    return `token ${JSON.stringify(token)} must be in the same array element as the amount: its path up to its last [] must be the amount's`;
+  }
+  return null;
+}
+
+/**
+ * An effect's grant (spec 5.3, D-056): who may take the tokens, how many and until when, as positions in the arguments
+ * of the method the effect is on. `tags` is the merged view: the amount, timestamp and account tags a grant needs may
+ * come from another profile. The reason it is wrong, or null.
+ */
+export function grantError(iface, tags, methodName, { kind, grant }) {
+  if (kind !== "transfer" && kind !== "approve") return `a grant goes with effect kind transfer or approve, not ${kind}`;
+  if ((grant.spender === undefined) === (grant.to === undefined)) return "a grant names exactly one of spender and to";
+  if (kind === "approve" && grant.to !== undefined) return "an approve's grant names a spender: an allowance is taken by its spender, not paid to it";
+  const at = (name, rel, mayBeAbsent) => {
+    const p = parseRelPath(rel);
+    const r = iface.resolveRel(methodName, "args", rel);
+    const what = `grant ${name} ${JSON.stringify(rel)}`;
+    if (!p || r.error) return { error: `${what}: ${r.error ?? "not a relative path"}` };
+    if (p.segs.some((s) => s.kind === "elem")) return { error: `${what} steps into []: a grant covers one token, so a request that grants several has none` };
+    // The value must be in every call: no case of a variant on the way, and no opt unless it may be left out.
+    let cur = iface.methods.get(methodName).args[p.index ?? 0];
+    let optional = false;
+    for (const s of p.segs) {
+      const u = iface.unwrapOpt(cur);
+      optional ||= u.optional;
+      const n = iface.node(u.ref);
+      if (n.kind === "variant") return { error: `${what} passes through a case of a variant, so a call need not hold it` };
+      cur = n.fields.find((f) => f.id === s.id).type;
+    }
+    if ((optional || iface.unwrapOpt(cur).optional) && !mayBeAbsent) return { error: `${what} is optional, but a grant needs its ${name} in every call` };
+    return { r, t: tags.at(r, iface) ?? {} };
+  };
+  const who = grant.spender !== undefined ? "spender" : "to";
+  const party = at(who, grant[who], false);
+  if (party.error) return party.error;
+  if (iface.prim(party.r.ref) !== "address" && !party.t.account) {
+    return `grant ${who} ${JSON.stringify(grant[who])} is ${iface.describeType(party.r.ref)}; it must be an address or carry an account tag`;
+  }
+  const amount = at("amount", grant.amount, false);
+  if (amount.error) return amount.error;
+  const p = iface.prim(amount.r.ref);
+  if (p !== "bool") {
+    if (!amount.t.amount) return `grant amount ${JSON.stringify(grant.amount)} is ${iface.describeType(amount.r.ref)} without an amount tag; it must carry one, or be a bool`;
+    if (!/^(nat|uint)/.test(p)) return `grant amount ${JSON.stringify(grant.amount)} is ${p}; an amount granted is never negative, so its type is unsigned`;
+  }
+  for (const rel of grant.ends ?? []) {
+    const end = at("ends", rel, true);
+    if (end.error) return end.error;
+    if (!end.t.timestamp) return `grant ends ${JSON.stringify(rel)} has no timestamp tag`;
+  }
+  return null;
+}
+
 export function checkDynamic(iface, value, want, diag, at) {
   if (!value || typeof value !== "object") return;
   const from = value.from;

package/src/evm.d.mts

@@ -38,7 +38,7 @@ export interface AbiLimits {
   maxDepth?: number;
   maxElements?: number;
 }
-/** Every failure of the ABI helpers: E_ABI (a fragment), E_ABI_ENCODE, E_ABI_DECODE, E_ADDRESS or E_ADDRESS_CHECKSUM. */
+/** Every failure of the ABI helpers: E_ABI (a fragment), E_ABI_ENCODE, E_ABI_DECODE, E_EIP712, E_ADDRESS or E_ADDRESS_CHECKSUM. */
 export declare class AbiError extends Error {
   constructor(code: string, message: string);
   name: "AbiError";
@@ -62,8 +62,11 @@ export const DEFAULT_ABI_LIMITS: Readonly<Required<AbiLimits>>;
 export function parseAbi(entries: unknown, label?: string): { functions: AbiFunction[]; errors: { at: string; message: string }[] };
 /** One function from its named signature, as a resolved form carries it. Throws AbiError. */
 export function parseSignature(signature: string, where?: string): AbiFunction;
-/** `candid-profile:evm-abi:v0:sha256:…`: SHA-256 over the JCS array of the canonical fragments, sorted. */
-export function abiInterfaceId(functions: readonly AbiFunction[]): string;
+/**
+ * `candid-profile:evm-abi:v0:sha256:…`: SHA-256 over the JCS array of the canonical fragments and, when given EIP-712
+ * types, one `struct Name(type member,…)` line per type, sorted.
+ */
+export function abiInterfaceId(functions: readonly AbiFunction[], types?: Eip712Types): string;
 export function canonicalFragment(f: Pick<AbiFunction, "name" | "inputs" | "outputs" | "stateMutability">): string;
 export function namedSignature(f: Pick<AbiFunction, "name" | "inputs">): string;
 export function typeSignature(f: Pick<AbiFunction, "name" | "inputs">): string;
@@ -84,3 +87,15 @@ export function toChecksumAddress(address: string): string;
 export function readAddress(text: string): string;
 /** The EIP-712 digest a signer signs, as `0x` and 64 hex digits. */
 export function typedDataDigest(typed: TypedData): string;
+/** EIP-712 struct types: struct name to its members, in order. */
+export type Eip712Types = Record<string, { name: string; type: string }[]>;
+/**
+ * Read EIP-712 struct types (spec section 15.9): identifier names that are not ABI types, unique member names,
+ * canonical member types (`uint256`, never `uint`) or structs of the same map, and no struct that contains itself.
+ * Problems are listed, not thrown; `types` keeps the structs that read.
+ */
+export function parseEip712Types(types: unknown, label?: string): { types: Eip712Types; errors: { at: string; message: string }[] };
+/** EIP-712 `encodeType`: the struct with its members, then the structs it refers to, sorted by name. Throws AbiError (E_EIP712). */
+export function encodeType(types: Eip712Types, primary: string): string;
+/** EIP-712 `typeHash`: the Keccak-256 of `encodeType`, as `0x` and 64 hex digits. */
+export function eip712TypeHash(types: Eip712Types, primary: string): string;

package/src/evm.mjs

@@ -1,7 +1,8 @@
 /**
  * `@meantjs/profile/evm`: the EVM helpers of spec section 15 (D-054), browser-safe and without dependencies.
  * Keccak-256, ABI fragments (reading, canonical text, selectors, the interface identity), a strict ABI codec, EIP-55
- * addresses and EIP-712 digests. The consent package builds calldata display and the ERC-7730 export on them.
+ * addresses, EIP-712 types (section 15.9: reading them, encodeType, type hashes) and digests. The consent package
+ * builds calldata display, typed-message display and the ERC-7730 export on them.
  *
  * test/evm.test.mjs checks the vectors; test/address-entry.test.mjs keeps this entry free of node:* imports.
  */
@@ -13,10 +14,13 @@ export {
   canonicalFragment,
   componentKey,
   decodeParams,
+  eip712TypeHash,
   encodeCall,
   encodeParams,
+  encodeType,
   namedSignature,
   parseAbi,
+  parseEip712Types,
   parseSignature,
   readAddress,
   selectorOf,

package/src/resolve.mjs

@@ -15,9 +15,10 @@ import { profileId } from "./util.mjs";
 import { compileInterface, interfaceFromEnvelope } from "./compile.mjs";
 import { analyzeProfiles } from "./analyze.mjs";
 import { matchPack } from "./pack-match.mjs";
-import { abiInterface, checkDeployments } from "./abi-iface.mjs";
+import { abiInterface, checkDeployments, eip712Of } from "./abi-iface.mjs";
 import { matchAbiPack, translatePack } from "./abi-pack.mjs";
 import { abiInterfaceId, parseAbi } from "./abi.mjs";
+import { jcs } from "./util.mjs";
 import { resolvedForm } from "./resolved.mjs";
 import { schemaDiagnostics } from "./schema-core.mjs";
 
@@ -59,12 +60,15 @@ async function resolveCompiled(opts, fromEnvelope) {
   const statuses = [];
   if (opts.abi !== undefined) {
     const label = opts.didLabel ?? "abi";
-    const compiled = abiInterface(opts.abi, label);
+    // The messages of an EVM contract come from its profiles and packs (spec section 15.9), so the interface is built
+    // again once they are known; an ABI without functions is refused only if none brings a message.
+    const build = (eip712, allowEmpty = false) => abiInterface(opts.abi, label, "contract", eip712, { allowEmpty });
+    const compiled = build(null, true);
     if (compiled.failure) {
       for (const d of compiled.failure) diagnostics.push({ severity: "error", code: "E_ABI", at: d.at, message: d.message });
       return { ok: false, resolved: null, diagnostics, profiles: statuses };
     }
-    return resolveWith(compiled.iface, opts, diagnostics, statuses);
+    return resolveWith(compiled.iface, opts, diagnostics, statuses, build);
   }
   const compiled = fromEnvelope ? interfaceFromEnvelope(opts.envelope, "canister") : await compileInterface(opts.did, "canister");
   if (compiled.failure) {
@@ -78,7 +82,7 @@ async function resolveCompiled(opts, fromEnvelope) {
 /** A profile or pack for an EVM contract (spec section 15) rather than a Candid service. */
 const isEvmDoc = (doc) => doc.kind === "contract" || (doc.kind === "pack" && doc.binds.abi !== undefined);
 
-async function resolveWith(iface, opts, diagnostics, statuses) {
+async function resolveWith(iface, opts, diagnostics, statuses, rebuild = null) {
   const evm = iface.chain === "evm";
 
   const candidates = [
@@ -106,6 +110,12 @@ async function resolveWith(iface, opts, diagnostics, statuses) {
       statuses.push({ ...status, status: "invalid" });
       continue;
     }
+    const eip712 = evm ? eip712Of(doc) : null;
+    if (eip712?.errors.length) {
+      for (const d of eip712.errors) note("error", "E_EIP712", d.at, d.message);
+      statuses.push({ ...status, status: "invalid" });
+      continue;
+    }
     if (evm && doc.kind === "pack") {
       const m = matchAbiPack(iface, doc);
       if (m.error) {
@@ -121,16 +131,17 @@ async function resolveWith(iface, opts, diagnostics, statuses) {
         continue;
       }
       note("info", "I_PACK_MATCHED", doc.name, "the contract has every function of the pack's binds.abi (same selectors, outputs and kind of call)");
-      items.push({ doc: translatePack(doc, m.functions, iface), pid, rebinding: false, apply: true, status });
+      items.push({ doc: translatePack(doc, m.functions, iface), pid, rebinding: false, apply: true, status, eip712 });
     } else if (evm) {
-      const own = parseAbi(doc.binds.abi, "binds.abi");
+      // A contract profile binds the functions of its `binds.abi`; one that only describes messages binds none.
+      const own = parseAbi(doc.binds.abi ?? [], "binds.abi");
       if (own.errors.length) {
         for (const d of own.errors) note("error", "E_ABI", d.at, d.message);
         statuses.push({ ...status, status: "invalid" });
         continue;
       }
       checkDeployments(doc, note);
-      items.push({ doc, pid, rebinding: abiInterfaceId(own.functions) !== iface.interfaceId, apply: false, status });
+      items.push({ doc, pid, rebinding: doc.binds.abi !== undefined && abiInterfaceId(own.functions) !== iface.abiId, apply: false, status, eip712 });
     } else if (doc.kind === "pack") {
       const m = await matchPack(iface, doc);
       if (m.error) {
@@ -154,6 +165,33 @@ async function resolveWith(iface, opts, diagnostics, statuses) {
     taken.add(pid);
   }
 
+  if (evm) {
+    // The EIP-712 types of every profile and pack applied, merged: one name, one struct (spec section 15.9).
+    const types = {};
+    const owner = {};
+    const messages = new Set();
+    for (const item of [...items]) {
+      const clash = Object.entries(item.eip712.types).find(([n, members]) => Object.hasOwn(types, n) && jcs(types[n]) !== jcs(members));
+      if (clash) {
+        diagnostics.push({ severity: "error", code: "E_EIP712", at: `binds.eip712.types.${clash[0]}`, message: `the type ${clash[0]} differs from the one profile "${owner[clash[0]]}" declares; one name is one struct`, profile: item.doc.name });
+        statuses.push({ ...item.status, status: "invalid" });
+        items.splice(items.indexOf(item), 1);
+        continue;
+      }
+      for (const [n, members] of Object.entries(item.eip712.types)) {
+        types[n] = members;
+        owner[n] ??= item.doc.name;
+      }
+      for (const n of item.eip712.messages) messages.add(n);
+    }
+    const built = Object.keys(types).length ? rebuild({ types, messages: [...messages].sort(), label: "binds.eip712.types" }) : iface.methods.size ? { iface } : rebuild(null);
+    if (built.failure) {
+      for (const d of built.failure) diagnostics.push({ severity: "error", code: d.at.startsWith("binds.eip712") ? "E_EIP712" : "E_ABI", at: d.at, message: d.message });
+      return { ok: false, resolved: null, diagnostics, profiles: [...items.map((i) => ({ ...i.status, status: "invalid" })), ...statuses] };
+    }
+    iface = built.iface;
+  }
+
   const analysis = analyzeProfiles(iface, items, { attribute: true });
   diagnostics.push(...analysis.diagnostics);
   for (const item of analysis.ordered) {