tersign 0.0.1 → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Tersign
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,5 +1,55 @@
-# Tersign
+# tersign
 
-The evidence layer for the agent economy: counter-signed receipts, compliance-grade evidence exports, and dispute adjudication for agent commerce.
+**The evidence layer for the agent economy.** When software buys from software, someone has to keep the records straight — this SDK gives agent-commerce sellers counter-signed receipts, tamper-evident action records, and jury-ready evidence envelopes on top of x402 settlement.
 
-This package name is reserved. The SDK is published as `@tersign/assure`.
+```sh
+npm install tersign
+```
+
+## What it does
+
+- **Signed receipts** — implements the merged x402 `offer-receipt` extension (EIP-712), plus **compliance records** (tax/audit-grade fields: EU Art-226b minimal tier / EN 16931 full tier / HK IRO s.51C retention) bound to the base receipt by digest.
+- **Agent action records** — `ActionRecordV1`: digest-bound, GDPR-minimized evidence of agent actions and disclosures, mapped to EU AI Act Art-50 obligations.
+- **Idempotency enforcement** — the x402 `payment-identifier` extension ships the key; this ships the semantics (replay cache, `Idempotent-Replayed`, 409 in-flight/conflict) with pluggable stores (memory, Cloudflare D1).
+- **Refund orchestration** — corrective records hash-chained via `refundOf` (ViDA-style), ACP/UCP adjustment vocabulary verbatim.
+- **Disputes** — signed dispute/evidence/acceptance-criteria artifacts with objective reason codes; deterministic triage upstream of any arbitration venue.
+- **Evidence envelopes** — package any counter-signed record into a jury-ready submission for external venues (Internet Court slot format, Kleros ERC-1497, UMA claims): digests + a public verify URL, never raw evidence, with party statements structurally segregated from ledger-attested content.
+- **Ledger client** — counter-signature + sequential hash-chaining + evidence-pack exports via the hosted Tersign ledger (optional; the SDK works standalone).
+- **MCP server** — `npx tersign-mcp` exposes the full loop (issue / verify / refund / dispute) as Model Context Protocol tools for agent frameworks.
+- **Third-party verification** — `npx tersign-verify <receipt.json | 0xdigest>` recovers signatures and checks the public chain with no account and no trust in Tersign.
+
+## Quick start
+
+```ts
+import { privateKeyToAccount } from 'viem/accounts';
+import { Assure, attachToExtensions } from 'tersign';
+
+const assure = new Assure({
+  signer: privateKeyToAccount(process.env.SELLER_KEY as `0x${string}`),
+  issuer: { name: 'Example API Ltd', jurisdiction: 'HK', taxId: 'BR-12345678' },
+  // ledger: { url: 'https://tersign-ledger.kevinn-zhang.workers.dev', apiKey: '…', sellerId: '…' },
+});
+
+// after your x402 middleware reports settlement:
+const issued = await assure.issueFor({
+  network: 'eip155:8453',
+  resourceUrl: 'https://api.example.com/data',
+  payer: settlement.payer,
+  settledAt: Math.floor(Date.now() / 1000),
+  txHash: settlement.transaction,
+  supplyDescription: 'Market data, per call',
+});
+return Response.json(attachToExtensions(body, issued));
+```
+
+## Why not just the official x402 SDK?
+
+The official extension gives you the receipt *format*. This gives you the *operation*: replay enforcement (x402 #452 punts it to the app layer), refund records, compliance-grade fields your accountant recognizes, dispute-ready evidence — and third-party verifiability via counter-signed hash chains, so your receipts are exhibits, not testimony.
+
+## Verify without trusting anyone
+
+Every counter-signed record is publicly checkable: [live ledger + verification](https://tersign-ledger.kevinn-zhang.workers.dev/verify) — no account, no API key. Venues rotate; the transcript endures.
+
+## Status
+
+v0.1 — EIP-712 receipts, MINIMAL-tier compliance records, action records, disputes v0, evidence envelopes (Internet Court / Kleros / UMA), memory + D1 idempotency stores, MCP server, verify CLI. Wire formats are digest-bound and schema-evolvable; cross-implementation vectors are pinned in CI. MIT.

package/dist/adapter/x402.d.ts

@@ -0,0 +1,29 @@
+import type { Assure, SettlementContext } from '../assure.js';
+import { type IdempotencyStore } from '../idempotency/middleware.js';
+export interface SettlementInfo {
+    success: boolean;
+    transaction?: string | undefined;
+    network?: string | undefined;
+    payer?: string | undefined;
+}
+export declare function extractPaymentPayload(headers: Headers): unknown;
+export declare function extractSettlement(headers: Headers): SettlementInfo | undefined;
+export interface WithAssureConfig {
+    assure: Assure;
+    /** describe the supply for the receipt; defaults to the request path */
+    describeSupply?: (req: Request) => string;
+    /** override receipt fields derived from the settlement header */
+    toSettlementContext?: (req: Request, info: SettlementInfo) => Partial<SettlementContext>;
+    clock?: () => number;
+    idempotency?: {
+        store: IdempotencyStore;
+        required: boolean;
+        scope: string;
+    };
+}
+type FetchHandler = (req: Request) => Response | Promise<Response>;
+/** Wrap an x402-protected handler: enforce idempotency on the way in, issue the signed
+ * receipt + compliance record on the way out (only when the settlement header reports
+ * success and the response body is JSON). */
+export declare function withAssure(handler: FetchHandler, cfg: WithAssureConfig): FetchHandler;
+export {};

package/dist/adapter/x402.js

@@ -0,0 +1,105 @@
+import { attachToExtensions } from '../assure.js';
+import { checkIdempotency, extractPaymentId, fingerprint, REPLAY_HEADER, } from '../idempotency/middleware.js';
+/** Adapter for x402-protected fetch-style handlers ((Request) => Response) — this is the
+ * shape of a Hono app (`app.fetch`), a Workers export, and Next.js route handlers, so one
+ * wrapper covers the common seller stacks. An adapter pinned to the official x402 SDK's
+ * middleware internals is deliberately deferred until we integrate against a pinned
+ * version (its surface is still churning); this wrapper only touches the WIRE contract:
+ * the payment payload request header and the settlement response header. */
+/** x402 v2 header names, with v1 fallbacks. Re-verify at integration (CLAUDE.md rule 1). */
+const PAYMENT_PAYLOAD_HEADERS = ['payment-signature', 'x-payment'];
+const SETTLEMENT_HEADERS = ['payment-response', 'x-payment-response'];
+function b64json(value) {
+    try {
+        return JSON.parse(atob(value));
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractPaymentPayload(headers) {
+    for (const name of PAYMENT_PAYLOAD_HEADERS) {
+        const raw = headers.get(name);
+        if (raw)
+            return b64json(raw);
+    }
+    return undefined;
+}
+export function extractSettlement(headers) {
+    for (const name of SETTLEMENT_HEADERS) {
+        const raw = headers.get(name);
+        if (!raw)
+            continue;
+        const parsed = b64json(raw);
+        if (!parsed || typeof parsed !== 'object')
+            continue;
+        return {
+            success: parsed.success === true,
+            transaction: str(parsed.transaction) ?? str(parsed.txHash),
+            network: str(parsed.network) ?? str(parsed.networkId),
+            payer: str(parsed.payer) ?? str(parsed.from),
+        };
+    }
+    return undefined;
+}
+function str(v) {
+    return typeof v === 'string' && v.length > 0 ? v : undefined;
+}
+/** Wrap an x402-protected handler: enforce idempotency on the way in, issue the signed
+ * receipt + compliance record on the way out (only when the settlement header reports
+ * success and the response body is JSON). */
+export function withAssure(handler, cfg) {
+    const now = cfg.clock ?? (() => Math.floor(Date.now() / 1000));
+    return async (req) => {
+        let onComplete;
+        if (cfg.idempotency) {
+            const id = extractPaymentId(extractPaymentPayload(req.headers));
+            const url = new URL(req.url);
+            const fp = fingerprint({ method: req.method, path: url.pathname });
+            const outcome = await checkIdempotency(cfg.idempotency, id, fp);
+            switch (outcome.kind) {
+                case 'missing':
+                    return Response.json({ error: 'payment-identifier id required' }, { status: 400 });
+                case 'conflict':
+                    return Response.json({ error: 'payment id reused with a different request' }, { status: 409 });
+                case 'in-flight':
+                    return Response.json({ error: 'request with this payment id is in flight' }, { status: 409 });
+                case 'replay': {
+                    const headers = new Headers(outcome.response.headers);
+                    headers.set(REPLAY_HEADER, 'true');
+                    return new Response(outcome.response.body, { status: outcome.response.status, headers });
+                }
+                case 'process':
+                    onComplete = outcome.onComplete;
+            }
+        }
+        let res = await handler(req);
+        const settlement = extractSettlement(res.headers);
+        if (settlement?.success && (res.headers.get('content-type') ?? '').includes('application/json')) {
+            const url = new URL(req.url);
+            const overrides = cfg.toSettlementContext?.(req, settlement) ?? {};
+            const ctx = {
+                network: settlement.network ?? 'eip155:8453',
+                resourceUrl: url.origin + url.pathname,
+                payer: settlement.payer ?? 'unknown',
+                settledAt: now(),
+                supplyDescription: cfg.describeSupply?.(req) ?? url.pathname,
+                ...(settlement.transaction !== undefined ? { txHash: settlement.transaction } : {}),
+                ...overrides,
+            };
+            const issued = await cfg.assure.issueFor(ctx);
+            const body = (await res.json());
+            const decorated = attachToExtensions(body, issued);
+            const headers = new Headers(res.headers);
+            headers.delete('content-length');
+            res = new Response(JSON.stringify(decorated), { status: res.status, headers });
+        }
+        if (onComplete) {
+            const body = await res.clone().text();
+            const headerRecord = {};
+            res.headers.forEach((v, k) => (headerRecord[k] = v));
+            await onComplete({ status: res.status, headers: headerRecord, body });
+        }
+        return res;
+    };
+}

package/dist/assure.d.ts

@@ -0,0 +1,47 @@
+import type { Account } from 'viem/accounts';
+import { type IssuerConfig } from './compliance/record.js';
+import { type LedgerConfig, type CountersignResult } from './ledgerClient.js';
+import type { ComplianceRecordV1, SignedComplianceRecord, SignedReceipt } from './types.js';
+export interface AssureConfig {
+    /** viem account holding the seller's signing key (payTo-key authorization model) */
+    signer: Account;
+    issuer: IssuerConfig;
+    ledger?: LedgerConfig;
+}
+export interface SettlementContext {
+    /** CAIP-2 */
+    network: string;
+    resourceUrl: string;
+    payer: string;
+    /** unix seconds */
+    settledAt: number;
+    txHash?: string;
+    supplyDescription: string;
+    tax?: ComplianceRecordV1['tax'];
+    buyer?: ComplianceRecordV1['buyer'];
+    fiatValuation?: {
+        amount: string;
+        currency: string;
+        source: string;
+    };
+}
+export interface IssuedReceipt {
+    receipt: SignedReceipt;
+    compliance: SignedComplianceRecord;
+    ledger?: CountersignResult;
+}
+/** The core primitive: after a settled x402 payment, issue the signed base receipt
+ * (merged offer-receipt extension, EIP-712) plus the Tersign compliance record bound to it,
+ * and counter-sign into the hosted ledger when configured. Attach the result to the
+ * SettlementResponse via `attachToExtensions`. */
+export declare class Assure {
+    private cfg;
+    private ledger?;
+    constructor(cfg: AssureConfig);
+    issueFor(ctx: SettlementContext): Promise<IssuedReceipt>;
+}
+/** Decorate an x402 SettlementResponse body with the receipt at the spec-defined placement
+ * (`extensions["offer-receipt"].info.receipt`) and the Tersign record alongside it. */
+export declare function attachToExtensions<T extends Record<string, unknown>>(responseBody: T, issued: IssuedReceipt): T & {
+    extensions: Record<string, unknown>;
+};

package/dist/assure.js

@@ -0,0 +1,68 @@
+import { signReceipt } from './receipt/eip712.js';
+import { buildMinimalRecord, signComplianceRecord } from './compliance/record.js';
+import { LedgerClient } from './ledgerClient.js';
+/** The core primitive: after a settled x402 payment, issue the signed base receipt
+ * (merged offer-receipt extension, EIP-712) plus the Tersign compliance record bound to it,
+ * and counter-sign into the hosted ledger when configured. Attach the result to the
+ * SettlementResponse via `attachToExtensions`. */
+export class Assure {
+    cfg;
+    ledger;
+    constructor(cfg) {
+        this.cfg = cfg;
+        if (cfg.ledger)
+            this.ledger = new LedgerClient(cfg.ledger);
+    }
+    async issueFor(ctx) {
+        const payload = {
+            version: 1,
+            network: ctx.network,
+            resourceUrl: ctx.resourceUrl,
+            payer: ctx.payer,
+            issuedAt: ctx.settledAt,
+            transaction: ctx.txHash ?? '',
+        };
+        const receipt = await signReceipt(payload, this.cfg.signer);
+        const input = {
+            receipt,
+            supplyDescription: ctx.supplyDescription,
+            tax: ctx.tax ?? { scheme: 'none', currency: 'USD' },
+            issuedAt: ctx.settledAt,
+        };
+        if (ctx.buyer)
+            input.buyer = ctx.buyer;
+        if (ctx.fiatValuation) {
+            input.settlement = {
+                fiat: { ...ctx.fiatValuation, asOf: ctx.settledAt },
+                ...(ctx.txHash !== undefined ? { txHash: ctx.txHash } : {}),
+            };
+        }
+        const record = buildMinimalRecord(this.cfg.issuer, input);
+        const compliance = await signComplianceRecord(record, this.cfg.signer);
+        if (!this.ledger)
+            return { receipt, compliance };
+        const ledger = await this.ledger.submitReceipt(receipt, compliance);
+        return { receipt, compliance, ledger };
+    }
+}
+/** Decorate an x402 SettlementResponse body with the receipt at the spec-defined placement
+ * (`extensions["offer-receipt"].info.receipt`) and the Tersign record alongside it. */
+export function attachToExtensions(responseBody, issued) {
+    const prior = (responseBody.extensions ?? {});
+    return {
+        ...responseBody,
+        extensions: {
+            ...prior,
+            'offer-receipt': { info: { receipt: issued.receipt } },
+            'compliance-fields': {
+                info: {
+                    record: issued.compliance.record,
+                    attestation: issued.compliance.attestation,
+                    ...(issued.ledger
+                        ? { ledger: { seq: issued.ledger.seq, digest: issued.ledger.digest, countersignature: issued.ledger.countersignature } }
+                        : {}),
+                },
+            },
+        },
+    };
+}

package/dist/canonical.d.ts

@@ -0,0 +1,4 @@
+/** Deterministic JSON: recursively key-sorted, no whitespace. Arrays keep order.
+ * undefined properties are dropped (matches JSON.stringify semantics). */
+export declare function canonicalStringify(value: unknown): string;
+export declare function digestOf(value: unknown): `0x${string}`;

package/dist/canonical.js

@@ -0,0 +1,23 @@
+import { keccak256, toBytes } from 'viem';
+/** Deterministic JSON: recursively key-sorted, no whitespace. Arrays keep order.
+ * undefined properties are dropped (matches JSON.stringify semantics). */
+export function canonicalStringify(value) {
+    return JSON.stringify(sortValue(value));
+}
+function sortValue(value) {
+    if (Array.isArray(value))
+        return value.map(sortValue);
+    if (value !== null && typeof value === 'object') {
+        const out = {};
+        for (const key of Object.keys(value).sort()) {
+            const v = value[key];
+            if (v !== undefined)
+                out[key] = sortValue(v);
+        }
+        return out;
+    }
+    return value;
+}
+export function digestOf(value) {
+    return keccak256(toBytes(canonicalStringify(value)));
+}

package/dist/compliance/record.d.ts

@@ -0,0 +1,45 @@
+import type { Account } from 'viem/accounts';
+import type { Adjustment, ComplianceRecordV1, SignedComplianceRecord, SignedReceipt, VerifyLike } from './types.js';
+export declare const COMPLIANCE_DOMAIN: {
+    readonly name: "tersign compliance-record";
+    readonly version: "1";
+    readonly chainId: 1n;
+};
+export declare const COMPLIANCE_TYPES: {
+    readonly ComplianceAttestation: readonly [{
+        readonly name: "version";
+        readonly type: "uint256";
+    }, {
+        readonly name: "recordDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "receiptDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "issuedAt";
+        readonly type: "uint256";
+    }];
+};
+export interface IssuerConfig {
+    name: string;
+    jurisdiction: string;
+    taxId?: string;
+    /** default 7 — HK IRO s.51C floor, ≥ MiCA 5+2 */
+    retentionYears?: number;
+}
+export interface MinimalRecordInput {
+    receipt: SignedReceipt;
+    supplyDescription: string;
+    tax: ComplianceRecordV1['tax'];
+    issuedAt: number;
+    buyer?: ComplianceRecordV1['buyer'];
+    settlement?: ComplianceRecordV1['settlement'];
+    refundOf?: `0x${string}`;
+    adjustment?: Adjustment;
+}
+/** MINIMAL tier ≈ EU VAT Art 226b simplified-invoice content — legally sufficient for
+ * sub-€100 supplies EU-wide, and the default for machine-to-machine micro-receipts. */
+export declare function buildMinimalRecord(issuer: IssuerConfig, input: MinimalRecordInput): ComplianceRecordV1;
+export declare function recordDigest(record: ComplianceRecordV1): `0x${string}`;
+export declare function signComplianceRecord(record: ComplianceRecordV1, account: Account): Promise<SignedComplianceRecord>;
+export declare function verifyComplianceRecord(signed: SignedComplianceRecord, expectedSigner?: string): Promise<VerifyLike>;

package/dist/compliance/record.js

@@ -0,0 +1,94 @@
+import { recoverTypedDataAddress } from 'viem';
+import { digestOf } from '../canonical.js';
+export const COMPLIANCE_DOMAIN = { name: 'tersign compliance-record', version: '1', chainId: 1n };
+export const COMPLIANCE_TYPES = {
+    ComplianceAttestation: [
+        { name: 'version', type: 'uint256' },
+        { name: 'recordDigest', type: 'bytes32' },
+        { name: 'receiptDigest', type: 'bytes32' },
+        { name: 'issuedAt', type: 'uint256' },
+    ],
+};
+/** MINIMAL tier ≈ EU VAT Art 226b simplified-invoice content — legally sufficient for
+ * sub-€100 supplies EU-wide, and the default for machine-to-machine micro-receipts. */
+export function buildMinimalRecord(issuer, input) {
+    const record = {
+        version: 1,
+        receiptDigest: digestOf(input.receipt),
+        issuedAt: input.issuedAt,
+        issuer: {
+            name: issuer.name,
+            jurisdiction: issuer.jurisdiction,
+            ...(issuer.taxId !== undefined ? { taxId: issuer.taxId } : {}),
+        },
+        supply: { description: input.supplyDescription },
+        tax: input.tax,
+        retentionYears: issuer.retentionYears ?? 7,
+    };
+    if (input.buyer)
+        record.buyer = input.buyer;
+    if (input.settlement)
+        record.settlement = input.settlement;
+    if (input.refundOf)
+        record.refundOf = input.refundOf;
+    if (input.adjustment)
+        record.adjustment = input.adjustment;
+    return record;
+}
+export function recordDigest(record) {
+    return digestOf(record);
+}
+export async function signComplianceRecord(record, account) {
+    if (!account.signTypedData)
+        throw new Error('account cannot sign typed data');
+    const payload = {
+        version: 1,
+        recordDigest: recordDigest(record),
+        receiptDigest: record.receiptDigest,
+        issuedAt: record.issuedAt,
+    };
+    const signature = await account.signTypedData({
+        domain: COMPLIANCE_DOMAIN,
+        types: COMPLIANCE_TYPES,
+        primaryType: 'ComplianceAttestation',
+        message: {
+            version: BigInt(payload.version),
+            recordDigest: payload.recordDigest,
+            receiptDigest: payload.receiptDigest,
+            issuedAt: BigInt(payload.issuedAt),
+        },
+    });
+    return { record, attestation: { format: 'eip712', payload, signature } };
+}
+export async function verifyComplianceRecord(signed, expectedSigner) {
+    const { attestation, record } = signed;
+    if (attestation.format !== 'eip712')
+        return { valid: false, reason: 'jws not implemented in v0' };
+    if (attestation.payload.recordDigest !== recordDigest(record)) {
+        return { valid: false, reason: 'record digest mismatch — record was altered after signing' };
+    }
+    if (attestation.payload.receiptDigest !== record.receiptDigest) {
+        return { valid: false, reason: 'attestation/receipt digest mismatch' };
+    }
+    try {
+        const signer = await recoverTypedDataAddress({
+            domain: COMPLIANCE_DOMAIN,
+            types: COMPLIANCE_TYPES,
+            primaryType: 'ComplianceAttestation',
+            message: {
+                version: BigInt(attestation.payload.version),
+                recordDigest: attestation.payload.recordDigest,
+                receiptDigest: attestation.payload.receiptDigest,
+                issuedAt: BigInt(attestation.payload.issuedAt),
+            },
+            signature: attestation.signature,
+        });
+        if (expectedSigner && signer.toLowerCase() !== expectedSigner.toLowerCase()) {
+            return { valid: false, signer, reason: 'unexpected signer' };
+        }
+        return { valid: true, signer };
+    }
+    catch (e) {
+        return { valid: false, reason: e instanceof Error ? e.message : 'signature recovery failed' };
+    }
+}

package/dist/compliance/types.d.ts

@@ -0,0 +1,6 @@
+export type { Adjustment, ComplianceAttestationPayload, ComplianceRecordV1, SignedComplianceRecord, SignedReceipt, } from '../types.js';
+export interface VerifyLike {
+    valid: boolean;
+    signer?: `0x${string}`;
+    reason?: string;
+}

package/dist/compliance/types.js

@@ -0,0 +1 @@
+export {};

package/dist/dispute/sign.d.ts

@@ -0,0 +1,80 @@
+import type { Account } from 'viem/accounts';
+import type { AcceptanceCriteriaV1, DisputePayloadV1, EvidencePayloadV1, SignedCriteria, SignedDispute, SignedEvidence, VerifyLike } from './types.js';
+export declare const DISPUTE_DOMAIN: {
+    readonly name: "tersign dispute";
+    readonly version: "1";
+    readonly chainId: 1n;
+};
+export declare const EVIDENCE_DOMAIN: {
+    readonly name: "tersign evidence";
+    readonly version: "1";
+    readonly chainId: 1n;
+};
+export declare const CRITERIA_DOMAIN: {
+    readonly name: "tersign acceptance-criteria";
+    readonly version: "1";
+    readonly chainId: 1n;
+};
+export declare const DISPUTE_TYPES: {
+    readonly DisputeAttestation: readonly [{
+        readonly name: "version";
+        readonly type: "uint256";
+    }, {
+        readonly name: "disputeDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "receiptDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "openedAt";
+        readonly type: "uint256";
+    }];
+};
+export declare const EVIDENCE_TYPES: {
+    readonly EvidenceAttestation: readonly [{
+        readonly name: "version";
+        readonly type: "uint256";
+    }, {
+        readonly name: "evidenceDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "disputeDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "submittedAt";
+        readonly type: "uint256";
+    }];
+};
+export declare const CRITERIA_TYPES: {
+    readonly CriteriaAttestation: readonly [{
+        readonly name: "version";
+        readonly type: "uint256";
+    }, {
+        readonly name: "criteriaDigest";
+        readonly type: "bytes32";
+    }, {
+        readonly name: "issuedAt";
+        readonly type: "uint256";
+    }];
+};
+/** Pinned digest of the dispute-layer EIP-712 material. The ledger re-declares these
+ * constants (Workers bundle, no shared package yet) and pins the SAME vector — if either
+ * side edits a domain or type, the cross-impl test breaks before signatures do. */
+export declare const DISPUTE_WIRE_VECTOR: `0x${string}`;
+export declare function disputeDigest(dispute: DisputePayloadV1): `0x${string}`;
+export declare function evidenceDigest(evidence: EvidencePayloadV1): `0x${string}`;
+export declare function criteriaDigest(criteria: AcceptanceCriteriaV1): `0x${string}`;
+/** Sign a dispute as the CLAIMANT. The ledger only accepts disputes whose recovered
+ * signer equals the disputed receipt's `payer` — possession of the paying key IS the
+ * standing to dispute. */
+export declare function signDispute(dispute: DisputePayloadV1, account: Account): Promise<SignedDispute>;
+export declare function verifyDispute(signed: SignedDispute, expectedSigner?: string): Promise<VerifyLike>;
+/** Sign evidence as either party. Role/identity binding is enforced by the ledger:
+ * claimant evidence must recover to the receipt payer, respondent evidence to the
+ * seller's payTo key. */
+export declare function signEvidence(evidence: EvidencePayloadV1, account: Account): Promise<SignedEvidence>;
+export declare function verifyEvidence(signed: SignedEvidence, expectedSigner?: string): Promise<VerifyLike>;
+/** Sign acceptance criteria as the SELLER, pre-committing the machine-checkable bar the
+ * arbiter will hold the delivery to. Attach the returned digest to offers/records. */
+export declare function signCriteria(criteria: AcceptanceCriteriaV1, account: Account): Promise<SignedCriteria>;
+export declare function verifyCriteria(signed: SignedCriteria, expectedSigner?: string): Promise<VerifyLike>;