@reinconsole/erc8004 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,651 @@
+import { Address, PublicClient, WalletClient, Transport, Chain, Account } from 'viem';
+import { ReputationScore, ReputationSubject } from '@reinconsole/core';
+
+/**
+ * The slice of the ERC-8004 Identity Registry ABI Rein touches, verified
+ * against the published ABIs (github.com/erc-8004/erc-8004-contracts, abis/)
+ * in session 17. The registry is an upgradeable ERC-721 (URIStorage): tokenId
+ * IS the spec's `agentId`.
+ *
+ * Only the `register(string)` overload is declared — the contract also has
+ * `register()` and `register(string, (string,bytes)[])`, but a single overload
+ * keeps viem call sites unambiguous and we always pass an agentURI.
+ *
+ * `getAgentWallet` returns `address(bytes20(metadata["agentWallet"]))` — the
+ * ZERO address when unset/cleared, never a revert (even for a nonexistent
+ * agent). `ownerOf` is standard OZ ERC-721 and DOES revert on nonexistent ids.
+ */
+declare const identityRegistryAbi: readonly [{
+    readonly name: "register";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "string";
+        readonly name: "agentURI";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }];
+}, {
+    readonly name: "ownerOf";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "tokenURI";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "tokenId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "string";
+    }];
+}, {
+    readonly name: "getAgentWallet";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "Registered";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+        readonly indexed: true;
+    }, {
+        readonly type: "string";
+        readonly name: "agentURI";
+    }, {
+        readonly type: "address";
+        readonly name: "owner";
+        readonly indexed: true;
+    }];
+}];
+/**
+ * The Reputation Registry slice Rein touches, verified against the published
+ * ABI + contract source (ReputationRegistryUpgradeable.sol) in session 19:
+ *
+ * - `giveFeedback` is open to any clientAddress EXCEPT the agent's owner or
+ *   an approved operator ("Self-feedback not allowed"); a nonexistent agentId
+ *   reverts ERC721NonexistentToken via the Identity Registry.
+ * - `feedbackIndex` is a 1-BASED counter per (agentId, clientAddress).
+ * - `feedbackHash` is the KECCAK-256 of the content behind `feedbackURI`
+ *   (optional for content-addressed URIs); bytes32(0) is accepted.
+ * - `getSummary` returns the WAD-normalized AVERAGE of matching non-revoked
+ *   feedback, scaled to the mode of the matched valueDecimals. LIVE-VERIFIED
+ *   DIVERGENCE from the repo's main-branch source (S19): the DEPLOYED Base
+ *   Sepolia contract REVERTS "clientAddresses required" on an empty client
+ *   list — callers must resolve `getClients(agentId)` first (readSummary
+ *   does). `readFeedback` reverts on an out-of-bounds index.
+ */
+declare const reputationRegistryAbi: readonly [{
+    readonly name: "getIdentityRegistry";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [];
+    readonly outputs: readonly [{
+        readonly type: "address";
+    }];
+}, {
+    readonly name: "giveFeedback";
+    readonly type: "function";
+    readonly stateMutability: "nonpayable";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }, {
+        readonly type: "int128";
+        readonly name: "value";
+    }, {
+        readonly type: "uint8";
+        readonly name: "valueDecimals";
+    }, {
+        readonly type: "string";
+        readonly name: "tag1";
+    }, {
+        readonly type: "string";
+        readonly name: "tag2";
+    }, {
+        readonly type: "string";
+        readonly name: "endpoint";
+    }, {
+        readonly type: "string";
+        readonly name: "feedbackURI";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "feedbackHash";
+    }];
+    readonly outputs: readonly [];
+}, {
+    readonly name: "readFeedback";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }, {
+        readonly type: "address";
+        readonly name: "clientAddress";
+    }, {
+        readonly type: "uint64";
+        readonly name: "feedbackIndex";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "int128";
+        readonly name: "value";
+    }, {
+        readonly type: "uint8";
+        readonly name: "valueDecimals";
+    }, {
+        readonly type: "string";
+        readonly name: "tag1";
+    }, {
+        readonly type: "string";
+        readonly name: "tag2";
+    }, {
+        readonly type: "bool";
+        readonly name: "isRevoked";
+    }];
+}, {
+    readonly name: "getSummary";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }, {
+        readonly type: "address[]";
+        readonly name: "clientAddresses";
+    }, {
+        readonly type: "string";
+        readonly name: "tag1";
+    }, {
+        readonly type: "string";
+        readonly name: "tag2";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint64";
+        readonly name: "count";
+    }, {
+        readonly type: "int128";
+        readonly name: "summaryValue";
+    }, {
+        readonly type: "uint8";
+        readonly name: "summaryValueDecimals";
+    }];
+}, {
+    readonly name: "getClients";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "address[]";
+    }];
+}, {
+    readonly name: "getLastIndex";
+    readonly type: "function";
+    readonly stateMutability: "view";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+    }, {
+        readonly type: "address";
+        readonly name: "clientAddress";
+    }];
+    readonly outputs: readonly [{
+        readonly type: "uint64";
+    }];
+}, {
+    readonly name: "NewFeedback";
+    readonly type: "event";
+    readonly inputs: readonly [{
+        readonly type: "uint256";
+        readonly name: "agentId";
+        readonly indexed: true;
+    }, {
+        readonly type: "address";
+        readonly name: "clientAddress";
+        readonly indexed: true;
+    }, {
+        readonly type: "uint64";
+        readonly name: "feedbackIndex";
+    }, {
+        readonly type: "int128";
+        readonly name: "value";
+    }, {
+        readonly type: "uint8";
+        readonly name: "valueDecimals";
+    }, {
+        readonly type: "string";
+        readonly name: "indexedTag1";
+        readonly indexed: true;
+    }, {
+        readonly type: "string";
+        readonly name: "tag1";
+    }, {
+        readonly type: "string";
+        readonly name: "tag2";
+    }, {
+        readonly type: "string";
+        readonly name: "endpoint";
+    }, {
+        readonly type: "string";
+        readonly name: "feedbackURI";
+    }, {
+        readonly type: "bytes32";
+        readonly name: "feedbackHash";
+    }];
+}];
+
+type Erc8004ErrorCode = 'unknown_agent' | 'registration_failed' | 'bad_id' | 'feedback_failed';
+/** A registry lookup or write that failed, with a machine-readable code. */
+declare class Erc8004Error extends Error {
+    readonly code: Erc8004ErrorCode;
+    constructor(code: Erc8004ErrorCode, message: string);
+}
+
+/**
+ * ERC-8004 singleton deployments (verified live, session 17). The same
+ * address serves Ethereum + Base per environment.
+ */
+declare const IDENTITY_REGISTRY_MAINNET: Address;
+declare const IDENTITY_REGISTRY_TESTNET: Address;
+declare const REPUTATION_REGISTRY_TESTNET: Address;
+declare const BASE_SEPOLIA_CHAIN_ID = 84532;
+/** Which registry contract (on which chain) a set of identity facts came from. */
+interface RegistryRef {
+    chainId: number;
+    address: string;
+}
+declare const BASE_SEPOLIA_REGISTRY: RegistryRef;
+/**
+ * The slice of viem's PublicClient the reader needs. Offline code fakes the
+ * domain-level `IdentityRegistryReader` port instead (MockIdentityRegistry) —
+ * nothing in the repo ever fakes raw readContract calls.
+ */
+type RegistryChainReader = Pick<PublicClient, 'readContract'>;
+/**
+ * The domain-level port the linking layer depends on: resolve on-chain
+ * identity facts for one agentId. viem-backed against the real registry
+ * (`identityRegistryReader`), in-memory for every offline path
+ * (`MockIdentityRegistry`).
+ */
+interface IdentityRegistryReader {
+    readonly ref: RegistryRef;
+    /** ERC-721 owner. Throws Erc8004Error('unknown_agent') for a nonexistent id. */
+    ownerOf(tokenId: bigint): Promise<string>;
+    /**
+     * The EIP-712-verified payment wallet (`agentWallet` reserved metadata key;
+     * auto-set to the owner at registration, cleared on transfer). `undefined`
+     * when unset — the real contract returns the zero address and never reverts,
+     * even for nonexistent agents.
+     */
+    agentWallet(tokenId: bigint): Promise<string | undefined>;
+    /** The registration file URI (ERC-721 tokenURI). Throws 'unknown_agent' like ownerOf. */
+    agentURI(tokenId: bigint): Promise<string>;
+}
+/** The real reader, over any viem PublicClient (or structural equivalent). */
+declare function identityRegistryReader(client: RegistryChainReader, ref?: RegistryRef): IdentityRegistryReader;
+/** Cross-check: the Reputation Registry names its Identity Registry on-chain. */
+declare function getIdentityRegistryAddress(client: RegistryChainReader, reputationRegistry?: Address): Promise<string>;
+interface RegisteredAgent {
+    tokenId: bigint;
+    /** Canonical id string — what goes on the Agent/Vendor doc. */
+    erc8004Id: string;
+    txHash: string;
+    owner: string;
+}
+/**
+ * The write path: mint an agent on the real registry. simulate -> write ->
+ * wait for the receipt -> decode the `Registered` event (the EVENT is
+ * authoritative — a simulate return value can go stale between simulation and
+ * inclusion). The client params are the exact method slices used — naming the
+ * full viem client types here trips chain-formatter variance (a baseSepolia-
+ * typed client is not assignable to PublicClient<Transport, Chain>).
+ *
+ * RETRY WARNING: a 'registration_failed' can be a receipt-wait TIMEOUT — the
+ * tx may still land later. Blindly retrying on that code can mint a SECOND
+ * identity; callers persisting the id (the demo's .env) should check the
+ * chain before re-registering.
+ */
+declare function registerAgent(options: {
+    publicClient: Pick<PublicClient, 'simulateContract' | 'waitForTransactionReceipt'>;
+    walletClient: Pick<WalletClient<Transport, Chain, Account>, 'writeContract' | 'account'>;
+    ref?: RegistryRef;
+    agentURI: string;
+}): Promise<RegisteredAgent>;
+
+/**
+ * The ERC-8004 Reputation Registry write side: publish Rein's graph-derived
+ * scores on-chain as feedback about an agent's on-chain identity.
+ *
+ * Contract facts this module is built on (verified against source, S19):
+ * `giveFeedback` may be called by ANY address except the agent's owner or an
+ * approved operator — so the publisher is a counterparty (a Rein gate/graph
+ * operator scoring the agents it transacted with), never the agent itself.
+ * Feedback indexes are 1-based per (agentId, clientAddress). `getSummary`
+ * averages (WAD-normalized) non-revoked matching entries.
+ */
+/** The singleton Reputation Registry on Base Sepolia (same 0x8004B… everywhere). */
+declare const BASE_SEPOLIA_REPUTATION: RegistryRef;
+/** Rein's tag1 convention: filters getSummary down to Rein-published scores. */
+declare const REIN_SCORE_TAG = "rein-score";
+interface FeedbackInput {
+    /** The identity's tokenId (the spec's agentId). */
+    agentId: bigint;
+    /** Fixed-point value at `valueDecimals` (Rein scores: 0-100, decimals 0). */
+    value: bigint;
+    valueDecimals?: number;
+    tag1?: string;
+    tag2?: string;
+    /** The evaluated service endpoint; empty = the agent overall. */
+    endpoint?: string;
+    /** Off-chain evidence JSON; data: URIs keep the demo infra-free. */
+    feedbackURI?: string;
+    /** keccak256 of the feedbackURI content (optional for content-addressed URIs). */
+    feedbackHash?: `0x${string}`;
+}
+interface PublishedFeedback {
+    agentId: bigint;
+    clientAddress: string;
+    /** 1-based per (agentId, clientAddress). */
+    feedbackIndex: bigint;
+    txHash: string;
+}
+interface FeedbackSummary {
+    count: bigint;
+    /** WAD-normalized average, scaled to `valueDecimals`. */
+    value: bigint;
+    valueDecimals: number;
+}
+interface FeedbackEntry {
+    value: bigint;
+    valueDecimals: number;
+    tag1: string;
+    tag2: string;
+    revoked: boolean;
+}
+declare function validateFeedback(input: FeedbackInput): void;
+/**
+ * The write path: publish one feedback entry. Mirrors registerAgent's shape —
+ * simulate -> write -> receipt -> decode the NewFeedback EVENT (authoritative;
+ * filtered by registry address). The same retry warning applies: a
+ * 'feedback_failed' can be a receipt-wait timeout with the tx still landing;
+ * feedback is APPEND-ONLY, so a blind retry publishes a duplicate entry
+ * (skewing getSummary), not a corrupt one.
+ */
+declare function giveFeedback(options: {
+    publicClient: Pick<PublicClient, 'simulateContract' | 'waitForTransactionReceipt'>;
+    walletClient: Pick<WalletClient<Transport, Chain, Account>, 'writeContract' | 'account'>;
+    registry?: RegistryRef;
+    input: FeedbackInput;
+}): Promise<PublishedFeedback>;
+/** Every address that has published feedback about the agent. */
+declare function feedbackClients(client: RegistryChainReader, options: {
+    agentId: bigint;
+    registry?: RegistryRef;
+}): Promise<readonly string[]>;
+/**
+ * getSummary over the real registry. Filters: clients omitted = ALL known
+ * clients, tags '' = any. LIVE-VERIFIED (S19): the deployed contract reverts
+ * "clientAddresses required" on an empty list — unlike the repo's main-branch
+ * source — so an omitted/empty filter is resolved through getClients(agentId)
+ * first; an agent with no feedback at all short-circuits to zeros.
+ */
+declare function readSummary(client: RegistryChainReader, options: {
+    agentId: bigint;
+    clients?: readonly string[];
+    tag1?: string;
+    tag2?: string;
+    registry?: RegistryRef;
+}): Promise<FeedbackSummary>;
+/** One stored entry. Reverts (as 'feedback_failed') on an out-of-bounds index. */
+declare function readFeedbackEntry(client: RegistryChainReader, options: {
+    agentId: bigint;
+    clientAddress: string;
+    index: bigint;
+    registry?: RegistryRef;
+}): Promise<FeedbackEntry>;
+/** How many entries this client has published about the agent (0 = none). */
+declare function lastFeedbackIndex(client: RegistryChainReader, options: {
+    agentId: bigint;
+    clientAddress: string;
+    registry?: RegistryRef;
+}): Promise<bigint>;
+/**
+ * Map a graph score onto the feedback wire: value = the 0-100 headline score
+ * (decimals 0 — the spec's quality-rating convention), tag1 = the Rein filter
+ * tag, tag2 = the confidence as an integer percentage. The score's SUBJECT
+ * must already be erc8004-canonical (that is what links.ts makes true for
+ * registered agents) — the tokenId is parsed straight out of it, so feedback
+ * can never be published about a different identity than the evidence keys by.
+ */
+declare function scoreToFeedback(score: ReputationScore, opts?: {
+    /** When given, the score's embedded registry ref must match (chain + address). */
+    identity?: RegistryRef;
+    endpoint?: string;
+    feedbackURI?: string;
+    feedbackHash?: `0x${string}`;
+}): FeedbackInput;
+interface FeedbackEvidence {
+    /** The off-chain JSON document (spec-example shape + Rein's explanation). */
+    doc: Record<string, unknown>;
+    json: string;
+    /** keccak256 of the exact json bytes — what goes on-chain as feedbackHash. */
+    feedbackHash: `0x${string}`;
+    /** data: URI carrying the json itself — content-addressed, no hosting needed. */
+    dataUri: string;
+}
+/**
+ * Build the off-chain evidence document for a score. Field names follow the
+ * spec's feedbackURI example (agentRegistry/agentId/clientAddress/createdAt/
+ * value/valueDecimals); Rein's component breakdown rides along under `rein`,
+ * so anyone can recompute WHY the number is what it is. The data: URI form is
+ * self-contained and self-verifying (hash the content, compare on-chain).
+ */
+declare function feedbackEvidence(score: ReputationScore, opts: {
+    clientAddress: string;
+}): FeedbackEvidence;
+/**
+ * The whole loop in one call: evidence doc -> hash -> data: URI ->
+ * giveFeedback on-chain. Returns the published pointer AND the score with
+ * `evidenceUri` filled in (core's ReputationScore field exists for exactly
+ * this — a hash-anchored attestation, now actually anchored).
+ */
+declare function publishAgentScore(options: {
+    publicClient: Pick<PublicClient, 'simulateContract' | 'waitForTransactionReceipt'>;
+    walletClient: Pick<WalletClient<Transport, Chain, Account>, 'writeContract' | 'account'>;
+    score: ReputationScore;
+    registry?: RegistryRef;
+    identity?: RegistryRef;
+    endpoint?: string;
+}): Promise<{
+    published: PublishedFeedback;
+    score: ReputationScore;
+    evidenceUri: string;
+}>;
+
+/**
+ * In-memory twin of the ERC-8004 Identity Registry — the offline counterpart
+ * of `identityRegistryReader`, for demos, tests, and the console world.
+ *
+ * Mirrors the real contract's observable behavior: sequential tokenIds from 1,
+ * `agentWallet` auto-set to the owner at registration (the reserved-key rule),
+ * `ownerOf`/`agentURI` throw for nonexistent agents while `agentWallet`
+ * returns undefined (the real read never reverts). One documented divergence:
+ * `setAgentWallet` skips the EIP-712/ERC-1271 signature check and trusts the
+ * caller — mock custody, mock proofs.
+ *
+ * The default ref is a FAKE address on Base's chain id: a mock must not claim
+ * facts about the real deployment.
+ */
+declare class MockIdentityRegistry implements IdentityRegistryReader {
+    readonly ref: RegistryRef;
+    private readonly agents;
+    private nextId;
+    constructor(options?: {
+        chainId?: number;
+        address?: string;
+    });
+    /** ERC-721-ish mint. agentWallet starts as the owner, per the spec. */
+    register(input: {
+        owner: string;
+        agentURI?: string;
+    }): {
+        tokenId: bigint;
+        erc8004Id: string;
+    };
+    /** Rotate the verified payment wallet. DIVERGENCE: no signature verification. */
+    setAgentWallet(tokenId: bigint, wallet: string): void;
+    /**
+     * Hydration primitive: reinsert a known registration verbatim (world boot
+     * rebuilding "the chain" from persisted agent docs). Keeps minted ids stable
+     * across restarts — the next register() mints past the highest loaded id.
+     */
+    load(record: {
+        tokenId: bigint;
+        owner: string;
+        agentWallet?: string;
+        agentURI?: string;
+    }): void;
+    /** The canonical id string this mock would put on a doc for `tokenId`. */
+    idOf(tokenId: bigint): string;
+    ownerOf(tokenId: bigint): Promise<string>;
+    agentWallet(tokenId: bigint): Promise<string | undefined>;
+    agentURI(tokenId: bigint): Promise<string>;
+}
+/**
+ * In-memory twin of the ERC-8004 Reputation Registry, tied to a
+ * MockIdentityRegistry the way the real contracts are tied (the identity
+ * registry answers existence + the self-feedback restriction).
+ *
+ * Mirrors the real contract's observable behavior: 1-based feedbackIndex per
+ * (agentId, clientAddress); giveFeedback reverts for a nonexistent agent
+ * (via ownerOf) and for the agent's own owner ("Self-feedback not allowed");
+ * getSummary WAD-averages non-revoked matching rows and scales the result to
+ * the mode of the matched valueDecimals; readFeedback reverts out-of-bounds.
+ * Documented divergences: no ERC-721 operator approvals (only the OWNER is
+ * blocked from self-feedback); no revokeFeedback/appendResponse surface; and
+ * getSummary here treats an empty client filter as ALL clients — matching
+ * feedback.ts's readSummary HELPER semantics, not the raw deployed contract,
+ * which live-reverts "clientAddresses required" on an empty list (S19).
+ */
+declare class MockReputationRegistry {
+    private readonly identity;
+    readonly ref: RegistryRef;
+    /** agentId -> clientAddress (lowercased) -> rows (index i = feedbackIndex i+1). */
+    private readonly rows;
+    private txCounter;
+    constructor(identity: MockIdentityRegistry, options?: {
+        address?: string;
+    });
+    giveFeedback(clientAddress: string, input: FeedbackInput): Promise<PublishedFeedback>;
+    getSummary(agentId: bigint, opts?: {
+        clients?: readonly string[];
+        tag1?: string;
+        tag2?: string;
+    }): Promise<FeedbackSummary>;
+    readFeedback(agentId: bigint, clientAddress: string, feedbackIndex: bigint): Promise<FeedbackEntry>;
+    getLastIndex(agentId: bigint, clientAddress: string): Promise<bigint>;
+    /** Every client that has published about the agent (lowercased here). */
+    getClients(agentId: bigint): Promise<readonly string[]>;
+}
+
+/**
+ * Turning on-chain identity facts into reputation-graph link facts.
+ *
+ * Agents are ERC-8004-CANONICAL: a registered agent's evidence keys by its
+ * on-chain identity (`eip155:{chainId}:{registry}/{tokenId}`), and the local
+ * engine id plus every wallet fold in as aliases — one on-chain identity, one
+ * reputation, portable across deployments; two local agents claiming the same
+ * registration merge.
+ *
+ * Vendors stay HOST-canonical: hosts are the enforcement key (`syncVendors`
+ * pushes host -> score into the engine; intents carry hosts), so a vendor's
+ * on-chain identity and wallets fold INTO the host row, never the other way.
+ *
+ * TRUST NOTE: these helpers verify the identity's FACTS (owner, agentWallet)
+ * but not the claimant's ENTITLEMENT — any doc can claim any tokenId and its
+ * local history folds in. That is deliberate inside one trust domain (an
+ * operator's own registry of agents; same-registration merge is a feature).
+ * A multi-tenant deployment must gate claims first (e.g. require the doc's
+ * wallet to be the identity's owner or agentWallet).
+ */
+/** Structurally satisfied by ReputationGraph — this package never imports @reinconsole/graph. */
+interface LinkSink {
+    link(canonical: ReputationSubject, alias: ReputationSubject): void;
+}
+interface LinkPair {
+    canonical: ReputationSubject;
+    alias: ReputationSubject;
+}
+/**
+ * PURE: the link pairs for a registered agent. Canonical = the parse->format
+ * normalized erc8004 id (never hand-build the string — casing is load-bearing).
+ * Throws Erc8004Error('bad_id') on an unparseable id.
+ */
+declare function agentLinkPairs(facts: {
+    erc8004Id: string;
+    localId?: string;
+    wallets?: readonly string[];
+}): LinkPair[];
+/** PURE: vendors keep the host canonical; identity + wallets fold into it. */
+declare function vendorLinkPairs(facts: {
+    host: string;
+    erc8004Id?: string;
+    wallets?: readonly string[];
+}): LinkPair[];
+interface LinkedIdentity {
+    /** The subject the party's evidence now keys by. */
+    canonical: ReputationSubject;
+    /** How many alias pairs were asserted (0 = nothing to fold). */
+    pairs: number;
+    /** 'erc8004' when on-chain facts resolved; 'local' on the lenient fallback. */
+    source: 'erc8004' | 'local';
+}
+/**
+ * Resolve an agent's on-chain identity facts (ownerOf + agentWallet) and
+ * assert the links. LENIENT by design — a world boot must not die on one
+ * stale doc: a missing/unparseable/foreign-registry erc8004Id, or one the
+ * registry does not know, falls back to today's local semantics (ULID
+ * canonical, doc wallets as aliases). Network errors stay loud.
+ *
+ * Callers MUST await this — the registry reads are async, and evidence
+ * arriving before the alias map is populated mints a stray row (S15 lesson).
+ */
+declare function linkAgentFromRegistry(sink: LinkSink, registry: IdentityRegistryReader, agent: {
+    id: string;
+    erc8004Id?: string;
+    wallets: readonly {
+        address: string;
+    }[];
+}): Promise<LinkedIdentity>;
+/**
+ * Vendor twin: fold the vendor's on-chain identity (id string, owner,
+ * agentWallet — typically the treasury the gate pays to) into the HOST row.
+ * Same leniency: unresolvable identity facts assert nothing.
+ */
+declare function linkVendorFromRegistry(sink: LinkSink, registry: IdentityRegistryReader, vendor: {
+    host: string;
+    erc8004Id: string;
+}): Promise<LinkedIdentity>;
+
+export { BASE_SEPOLIA_CHAIN_ID, BASE_SEPOLIA_REGISTRY, BASE_SEPOLIA_REPUTATION, Erc8004Error, type Erc8004ErrorCode, type FeedbackEntry, type FeedbackEvidence, type FeedbackInput, type FeedbackSummary, IDENTITY_REGISTRY_MAINNET, IDENTITY_REGISTRY_TESTNET, type IdentityRegistryReader, type LinkPair, type LinkSink, type LinkedIdentity, MockIdentityRegistry, MockReputationRegistry, type PublishedFeedback, REIN_SCORE_TAG, REPUTATION_REGISTRY_TESTNET, type RegisteredAgent, type RegistryChainReader, type RegistryRef, agentLinkPairs, feedbackClients, feedbackEvidence, getIdentityRegistryAddress, giveFeedback, identityRegistryAbi, identityRegistryReader, lastFeedbackIndex, linkAgentFromRegistry, linkVendorFromRegistry, publishAgentScore, readFeedbackEntry, readSummary, registerAgent, reputationRegistryAbi, scoreToFeedback, validateFeedback, vendorLinkPairs };