@provex/eas 1.9.2-rc.20260721051954.c2db778 → 1.9.2

package/dist/eas-age.test.d.ts

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

package/dist/eas-age.test.js

@@ -0,0 +1,212 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { encodePacked, keccak256, zeroAddress } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { buildOffchainAgeAttestation, buildOffchainAgeAttestationForChain, encodeAgeClaim, } from './eas-builder.js';
+import { decodeAgeClaim } from './offchain-verify.js';
+import { EAS_ADDRESSES_BY_CHAIN_ID, EAS_MAINNET_ADDRESS, PROVEX_AGE_SCHEMA, PROVEX_AGE_SCHEMA_UID_BY_CHAIN_ID, getAgeSchemaUid, getAgeSchemaUidOrPlaceholder, } from './eas.js';
+const ZERO_BYTES32 = ('0x' + '0'.repeat(64));
+/** Deterministic unique identifier of the age schema — kept in lockstep with eas.ts. */
+const AGE_UID = '0x4ffe2fd75afc43a65b604589606c0996db197fcae4f834d240e3c023c40f297d';
+/** Deterministic unique identifiers of the OTHER two schemas, used as miswiring canaries. */
+const IDENTITY_UID_369 = '0xdda0f5748fee977851ba75a82b2d378dcdc20b2a816278ff55e411852c4a4092';
+const RELEASE_UID_369 = '0xc9bf5f19b85d6a84403428964837965e16f72d40863f5d9351d3951249f0d043';
+const CLAIM = {
+    nullifier: ('0x' + 'ab'.repeat(32)),
+    overN: true,
+    threshold: 21,
+    identityVerified: true,
+    expiresAt: 2000000000n,
+};
+describe('PROVEX_AGE_SCHEMA', () => {
+    it('encodes no personally identifying field', () => {
+        // The privacy invariant, as an executable check: a future edit that adds a
+        // name / date of birth / Social Security field to the schema fails HERE,
+        // loudly, rather than silently shipping personal data inside every
+        // attestation this schema produces.
+        for (const banned of ['name', 'handle', 'birth', 'dob', 'ssn', 'address ']) {
+            assert.ok(!PROVEX_AGE_SCHEMA.toLowerCase().includes(banned), `PROVEX_AGE_SCHEMA must not carry a "${banned}" field`);
+        }
+    });
+    it('is comma-separated typed fields in the documented order', () => {
+        // Field order is load-bearing: it fixes the encoding of every attestation
+        // issued under this schema, and the decoder reads positionally.
+        const fields = PROVEX_AGE_SCHEMA.split(',').map((field) => field.trim());
+        assert.deepEqual(fields, [
+            'bytes32 nullifier',
+            'bool overN',
+            'uint8 threshold',
+            'bool identityVerified',
+            'uint64 expiresAt',
+        ]);
+    });
+});
+describe('age claim round-trip', () => {
+    it('decodes back to the same claim it encoded', () => {
+        assert.deepEqual(decodeAgeClaim(encodeAgeClaim(CLAIM)), CLAIM);
+    });
+    it('preserves a false overN rather than dropping the field', () => {
+        // WHY: "this person is NOT over the threshold" is a real, signed answer —
+        // not a missing field. A decoder that coerced it away (or an encoder that
+        // omitted it) would turn a refusal into an absence, which a consuming
+        // application could misread as "unknown" and then fail open.
+        const minor = { ...CLAIM, overN: false };
+        assert.equal(decodeAgeClaim(encodeAgeClaim(minor)).overN, false);
+        assert.deepEqual(decodeAgeClaim(encodeAgeClaim(minor)), minor);
+    });
+    it('round-trips both identityVerified states independently of overN', () => {
+        // The two booleans are adjacent in the schema; a field-order slip would
+        // swap them and silently mislabel an unverified identity as verified.
+        const claim = { ...CLAIM, overN: true, identityVerified: false };
+        const decoded = decodeAgeClaim(encodeAgeClaim(claim));
+        assert.equal(decoded.overN, true);
+        assert.equal(decoded.identityVerified, false);
+    });
+    it('round-trips the uint8 threshold at both boundaries', () => {
+        // 0 and 255 are the extremes the uint8 field can hold. 0 must not be
+        // confused with "unset", and 255 must not overflow into the next word.
+        for (const threshold of [0, 255]) {
+            const claim = { ...CLAIM, threshold };
+            assert.equal(decodeAgeClaim(encodeAgeClaim(claim)).threshold, threshold);
+        }
+    });
+    it('round-trips an expiresAt at the uint64 ceiling', () => {
+        const claim = { ...CLAIM, expiresAt: 2n ** 64n - 1n };
+        assert.equal(decodeAgeClaim(encodeAgeClaim(claim)).expiresAt, 2n ** 64n - 1n);
+    });
+});
+describe('encodeAgeClaim', () => {
+    it('produces deterministic bytes for the same claim', () => {
+        assert.equal(encodeAgeClaim(CLAIM), encodeAgeClaim(CLAIM));
+        assert.match(encodeAgeClaim(CLAIM), /^0x[0-9a-fA-F]+$/);
+    });
+    it('produces different bytes when the nullifier differs', () => {
+        // WHY: the nullifier is what enforces one credential per person. If two
+        // different nullifiers encoded identically, the uniqueness guarantee
+        // would collapse.
+        assert.notEqual(encodeAgeClaim(CLAIM), encodeAgeClaim({ ...CLAIM, nullifier: ('0x' + 'cd'.repeat(32)) }));
+    });
+    it('produces different bytes when the threshold differs', () => {
+        // WHY: an "over 18" credential must not be byte-identical to an "over 21"
+        // one, or a signature over the former would verify as the latter.
+        assert.notEqual(encodeAgeClaim(CLAIM), encodeAgeClaim({ ...CLAIM, threshold: 18 }));
+    });
+});
+describe('getAgeSchemaUid', () => {
+    it('resolves the pinned unique identifier on the Provex chains', () => {
+        assert.equal(getAgeSchemaUid(369), AGE_UID);
+        assert.equal(getAgeSchemaUid(943), AGE_UID);
+        assert.equal(getAgeSchemaUid(11155111), AGE_UID);
+    });
+    it('throws while the per-chain unique identifier is still the placeholder', () => {
+        // Ethereum mainnet (1) stays a placeholder — there is no Provex deployment there.
+        assert.throws(() => getAgeSchemaUid(1), /Provex schema not registered on chainId 1/);
+    });
+    it('throws for chains with no unique-identifier slot at all', () => {
+        assert.throws(() => getAgeSchemaUid(999_999), /no schema UID slot for chainId 999999/);
+    });
+    it('returns the override when EAS_AGE_SCHEMA_UID_<chainId>_OVERRIDE is set', () => {
+        const override = '0x' + '99'.repeat(32);
+        process.env.EAS_AGE_SCHEMA_UID_369_OVERRIDE = override;
+        try {
+            assert.equal(getAgeSchemaUid(369), override);
+        }
+        finally {
+            delete process.env.EAS_AGE_SCHEMA_UID_369_OVERRIDE;
+        }
+    });
+});
+describe('getAgeSchemaUidOrPlaceholder', () => {
+    it('returns the all-zero placeholder for unregistered or unknown chains', () => {
+        assert.equal(getAgeSchemaUidOrPlaceholder(1), ZERO_BYTES32);
+        assert.equal(getAgeSchemaUidOrPlaceholder(999_999), ZERO_BYTES32);
+    });
+    it('returns the pinned unique identifier for the Provex chains', () => {
+        assert.equal(getAgeSchemaUidOrPlaceholder(369), AGE_UID);
+    });
+});
+describe('PROVEX_AGE_SCHEMA_UID_BY_CHAIN_ID', () => {
+    it('pins the deterministic unique identifier the schema string produces', () => {
+        // An Ethereum Attestation Service schema unique identifier is
+        // keccak256(abi.encodePacked(schema, resolver, revocable)) — computable
+        // with no transaction. WHY this assertion: it makes editing the schema
+        // string without re-pinning the identifier fail the suite, instead of
+        // silently signing under an identifier that no registration would match.
+        const derived = keccak256(encodePacked(['string', 'address', 'bool'], [PROVEX_AGE_SCHEMA, zeroAddress, true]));
+        assert.equal(derived, AGE_UID);
+        assert.equal(PROVEX_AGE_SCHEMA_UID_BY_CHAIN_ID[369], derived);
+    });
+    it('is distinct from the identity and release schema unique identifiers', () => {
+        // Three schemas share one registry unique-identifier space; a collision
+        // would let an age attestation be read as an identity or release one.
+        assert.notEqual(AGE_UID, IDENTITY_UID_369);
+        assert.notEqual(AGE_UID, RELEASE_UID_369);
+    });
+    it('has the same chain keys as the Ethereum Attestation Service address map', () => {
+        assert.deepEqual(Object.keys(PROVEX_AGE_SCHEMA_UID_BY_CHAIN_ID).sort(), Object.keys(EAS_ADDRESSES_BY_CHAIN_ID).sort());
+    });
+});
+describe('buildOffchainAgeAttestation', () => {
+    // Hardhat's deterministic account 0 — the same key the identity and release
+    // builder tests use, so the address/key pair is recognizable at a glance.
+    const ATTESTER_KEY = '0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d';
+    const HOLDER = '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
+    const AGE_SCHEMA_UID = ('0x' + '77'.repeat(32));
+    it('binds the credential to the holder wallet as recipient', async () => {
+        // WHY: unlike a release attestation (subject is a manifest, recipient is
+        // the zero address), an age credential is ABOUT a person. The recipient is
+        // the only thing that tells a consuming application whose credential it is.
+        const attester = privateKeyToAccount(ATTESTER_KEY);
+        const result = await buildOffchainAgeAttestation({
+            claim: CLAIM,
+            attester,
+            recipient: HOLDER,
+            eas: EAS_MAINNET_ADDRESS,
+            schemaUid: AGE_SCHEMA_UID,
+            chainId: 1,
+        });
+        assert.match(result.signature, /^0x[0-9a-fA-F]{130}$/);
+        assert.equal(result.message.recipient.toLowerCase(), HOLDER.toLowerCase());
+        assert.notEqual(result.message.recipient.toLowerCase(), zeroAddress);
+        assert.equal(result.message.schema, AGE_SCHEMA_UID);
+        assert.equal(result.domain.chainId, 1);
+    });
+    it('embeds the encoded age claim and derives the envelope expiry from it', async () => {
+        const attester = privateKeyToAccount(ATTESTER_KEY);
+        const result = await buildOffchainAgeAttestation({
+            claim: CLAIM,
+            attester,
+            recipient: HOLDER,
+            eas: EAS_MAINNET_ADDRESS,
+            schemaUid: AGE_SCHEMA_UID,
+            chainId: 1,
+        });
+        assert.equal(result.message.data, encodeAgeClaim(CLAIM));
+        // WHY THIS MATTERS: the envelope expiry is DERIVED from claim.expiresAt,
+        // never passed alongside it. If a future edit reintroduces a separate
+        // expirationTime parameter, these two can drift — a consumer using standard
+        // Ethereum Attestation Service tooling would read the envelope while one
+        // decoding the claim reads the data, and they would disagree about whether
+        // the same credential is still valid, with nothing to flag the split.
+        assert.equal(result.message.expirationTime, CLAIM.expiresAt);
+        assert.equal(result.message.revocable, true);
+        // The signed bytes decode back to the claim the caller handed in — the
+        // end-to-end guarantee a verifier depends on.
+        assert.deepEqual(decodeAgeClaim(result.message.data), CLAIM);
+    });
+    it('signs with the age schema unique identifier via the ForChain wrapper', async () => {
+        // Proves the wrapper routes through getAgeSchemaUid rather than the
+        // identity or release lookup — a miswiring TypeScript cannot catch.
+        const attester = privateKeyToAccount(ATTESTER_KEY);
+        const result = await buildOffchainAgeAttestationForChain({
+            claim: CLAIM,
+            attester,
+            recipient: HOLDER,
+            chainId: 369,
+        });
+        assert.equal(result.message.schema, AGE_UID);
+        assert.notEqual(result.message.schema, IDENTITY_UID_369);
+        assert.notEqual(result.message.schema, RELEASE_UID_369);
+        assert.equal(result.message.recipient.toLowerCase(), HOLDER.toLowerCase());
+    });
+});

package/dist/eas-builder.d.ts

@@ -0,0 +1,352 @@
+import * as easSdkNamespace from '@ethereum-attestation-service/eas-sdk';
+import type { Address, Hex, LocalAccount } from 'viem';
+type OffchainAttestationVersionEnum = (typeof easSdkNamespace)['OffchainAttestationVersion'][keyof (typeof easSdkNamespace)['OffchainAttestationVersion']];
+/**
+ * @provex/eas — off-chain Ethereum Attestation Service attestation builder.
+ *
+ * Wraps the upstream `@ethereum-attestation-service/eas-sdk` so callers
+ * (notary-gate's webhook) can hand in a viem `LocalAccount` + an
+ * `IdentityClaim` and get back a fully-signed off-chain attestation
+ * without touching ethers directly.
+ *
+ * The SDK's signer interface is ethers-shaped (`signTypedData(domain,
+ * types, value)`), but we live in viem-land. The thin adapter below
+ * translates the SDK's three-arg call into viem's
+ * `account.signTypedData({ domain, types, primaryType, message })` and
+ * returns the resulting hex signature unchanged. Same EIP-712 wire bytes,
+ * different SDK conventions.
+ *
+ * Output normalization: the SDK returns `signature: { r, s, v }` and
+ * `domain.chainId: bigint`. We flatten the signature to a single 65-byte
+ * 0x-hex and convert chainId to `number` so downstream JSON serialization
+ * (notary-gate's attestationStore → polling UI) is straightforward and
+ * consumers can compare chainId without bigint juggling.
+ */
+/**
+ * Identity claim destined for an off-chain EAS attestation. The `handle`
+ * is the proven platform username (e.g. Discord username, X screen_name);
+ * the contract-level wire encoding is the EAS schema string in `eas.ts`.
+ */
+export type IdentityClaim = {
+    platformHash: Hex;
+    handle: string;
+    user: Address;
+    /** Unix seconds at which this attestation expires; encoded as uint64. */
+    expiresAt: bigint;
+};
+export type BuildOffchainEasAttestationArgs = {
+    claim: IdentityClaim;
+    attester: LocalAccount;
+    /** EAS contract address on the target chain (used in the EIP-712 domain). */
+    eas: Address;
+    /** Pinned EAS schema UID — must match `PROVEX_IDENTITY_SCHEMA`. */
+    schemaUid: Hex;
+    /** EVM chain id the attestation is bound to (1 = Ethereum mainnet). */
+    chainId: number;
+};
+/**
+ * Final wire shape returned by the builder. Matches `SignedOffchainAttestation`
+ * from the EAS SDK with two normalizations applied:
+ *   - signature flattened to single hex string
+ *   - domain.chainId widened to plain number for JSON safety
+ */
+export type OffchainEasAttestation = {
+    version: OffchainAttestationVersionEnum;
+    uid: string;
+    domain: {
+        name: string;
+        version: string;
+        chainId: number;
+        verifyingContract: string;
+    };
+    primaryType: string;
+    types: Record<string, Array<{
+        name: string;
+        type: string;
+    }>>;
+    message: {
+        version: number;
+        schema: string;
+        recipient: string;
+        time: bigint;
+        expirationTime: bigint;
+        revocable: boolean;
+        refUID: string;
+        data: string;
+        salt?: string;
+    };
+    signature: Hex;
+};
+/**
+ * EAS-encoded `bytes data` for a Provex identity claim.
+ *
+ * Pure (no I/O), idempotent, deterministic — the same claim always
+ * produces the same hex. Three callers depend on this byte-exact match:
+ *
+ *   - {@link buildOffchainEasAttestation} — bytes signed by the gate's
+ *     off-chain EIP-712 envelope.
+ *   - {@link buildDelegatedEasAttestationRequest} — bytes signed by the
+ *     gate's delegated EIP-712 envelope (sponsored on-chain publish).
+ *   - `packages/ui/src/lib/identityChain.ts` — bytes the user's own
+ *     wallet writes via plain `attest()` (self-pay on-chain publish).
+ *
+ * Centralized so a schema field reorder lands in one place — if any
+ * caller drifted out of sync, the on-chain delegated signature would
+ * verify against different bytes than the contract was handed, and EAS
+ * would revert with `InvalidSignature()`.
+ *
+ * Field order is load-bearing — it must match `PROVEX_IDENTITY_SCHEMA`
+ * in `eas.ts` exactly.
+ */
+export declare const encodeIdentityClaim: (claim: IdentityClaim) => Hex;
+/**
+ * Default attestation validity window — 90 days, matching the off-chain
+ * signing validity in `signOffchainAttestation`. EAS reverts with
+ * `InvalidExpirationTime()` when `expirationTime <= block.timestamp`, so
+ * any value here must comfortably exceed worst-case mining time even on
+ * a congested network. A previous 5-minute window kept tripping that
+ * revert when a PulseChain tx took longer than 5 minutes to mine.
+ *
+ * Exposed as a function (rather than a constant) so callers compute the
+ * deadline relative to the moment they sign/submit, not module-load
+ * time.
+ */
+export declare const attestationExpirationTime: (options?: {
+    nowSeconds?: number;
+}) => bigint;
+/**
+ * Build a fully-signed off-chain EAS attestation for a Provex identity
+ * claim. Pure function modulo the signature: no network I/O, no on-chain
+ * verification (the SDK's `verifyOnchain` option is left disabled — we
+ * don't need an RPC just to sign).
+ *
+ * The returned object is JSON-serializable directly — bigints are kept
+ * as bigints so the caller decides how to encode them on the wire.
+ */
+export declare const buildOffchainEasAttestation: (args: BuildOffchainEasAttestationArgs) => Promise<OffchainEasAttestation>;
+/**
+ * Convenience wrapper: resolve `eas` + `schemaUid` from the chainId via
+ * `getEasAddress` / `getSchemaUid`, then sign. Throws if either lookup
+ * fails (chain unknown, address not pinned, or schema not registered).
+ *
+ * Prefer this over the raw `buildOffchainEasAttestation` for any
+ * caller that can hand a `chainId` — it eliminates the chance of
+ * pairing the wrong EAS address with the wrong UID.
+ */
+export declare const buildOffchainEasAttestationForChain: (args: Omit<BuildOffchainEasAttestationArgs, "eas" | "schemaUid">) => Promise<OffchainEasAttestation>;
+/**
+ * Release claim destined for a gate-signed off-chain Ethereum Attestation
+ * Service attestation. The subject is a dapp release, not a user: `dappKey`
+ * keys the per-application timeline and `manifestHash` is the exact release
+ * proven via Transport-Layer-Security. There is no `expiresAt` field — a
+ * release attestation's freshness is the EAS-native `message.expirationTime`,
+ * set by the caller.
+ */
+export type ReleaseClaim = {
+    dappKey: Hex;
+    manifestHash: Hex;
+    domain: string;
+    version: string;
+};
+/**
+ * EAS-encoded `bytes data` for a Provex release claim. Pure and
+ * deterministic. Field order is load-bearing — it must match
+ * `PROVEX_RELEASE_SCHEMA` in `eas.ts` exactly.
+ */
+export declare const encodeReleaseClaim: (claim: ReleaseClaim) => Hex;
+export type BuildOffchainReleaseAttestationArgs = {
+    claim: ReleaseClaim;
+    attester: LocalAccount;
+    /** EAS contract address on the target chain (used in the EIP-712 domain). */
+    eas: Address;
+    /** Pinned EAS schema UID — must match `PROVEX_RELEASE_SCHEMA`. */
+    schemaUid: Hex;
+    /** EVM chain id the attestation is bound to. */
+    chainId: number;
+    /** EAS-native freshness horizon (Unix seconds). Use `attestationExpirationTime()`. */
+    expirationTime: bigint;
+};
+/**
+ * Build a fully-signed off-chain release attestation. The recipient is the
+ * zero address — the subject is the manifest (in the encoded data), not a
+ * wallet. Gate-signed: the attester is the gate's own account, vouching that
+ * it verified a Transport-Layer-Security proof of this release.
+ */
+export declare const buildOffchainReleaseAttestation: (args: BuildOffchainReleaseAttestationArgs) => Promise<OffchainEasAttestation>;
+/**
+ * Convenience wrapper: resolve `eas` + release `schemaUid` from the chainId,
+ * then sign. Throws if either lookup fails (chain unknown, address not
+ * pinned, or release schema not registered on that chain).
+ */
+export declare const buildOffchainReleaseAttestationForChain: (args: Omit<BuildOffchainReleaseAttestationArgs, "eas" | "schemaUid">) => Promise<OffchainEasAttestation>;
+/**
+ * Age + identity claim destined for an off-chain Ethereum Attestation Service
+ * attestation. `nullifier` is the one-way, domain-salted uniqueness marker;
+ * `overN` answers only "at least `threshold` years old"; `identityVerified`
+ * records that the capture proved possession of an identity-proofed account.
+ *
+ * No personal field is carried — by design. The date of birth, name, Social
+ * Security Number, and account identifier stay inside the issuer's trust
+ * boundary; only these derived facts escape it. The subject is bound by the
+ * attestation's `recipient` (the holder's wallet), not by anything here.
+ */
+export type AgeClaim = {
+    nullifier: Hex;
+    overN: boolean;
+    threshold: number;
+    identityVerified: boolean;
+    /** Unix seconds at which this claim expires; encoded as uint64. */
+    expiresAt: bigint;
+};
+/**
+ * EAS-encoded `bytes data` for a Provex age claim. Pure and deterministic —
+ * no I/O, no side effects, the same claim always produces the same hex.
+ *
+ * Field order is load-bearing — it must match `PROVEX_AGE_SCHEMA` in `eas.ts`
+ * exactly, because `decodeAgeClaim` reads positionally. A reorder here without
+ * a matching one there would decode `overN` out of the `identityVerified` slot.
+ */
+export declare const encodeAgeClaim: (claim: AgeClaim) => Hex;
+export type BuildOffchainAgeAttestationArgs = {
+    claim: AgeClaim;
+    attester: LocalAccount;
+    /** The holder's wallet — the subject this credential is bound to. */
+    recipient: Address;
+    /** EAS contract address on the target chain (used in the EIP-712 domain). */
+    eas: Address;
+    /** Pinned EAS schema UID — must match `PROVEX_AGE_SCHEMA`. */
+    schemaUid: Hex;
+    /** EVM chain id the attestation is bound to. */
+    chainId: number;
+};
+/**
+ * Build a fully-signed off-chain age + identity attestation.
+ *
+ * Unlike a release attestation (whose subject is a manifest, so its recipient
+ * is the zero address), the recipient here is the holder's wallet: the
+ * credential is ABOUT a person, and that wallet is how a consuming application
+ * knows whose credential it is. Gate-signed — the attester vouches that it
+ * derived these facts inside its trust boundary.
+ *
+ * There is deliberately no separate `expirationTime` parameter. The EAS-native
+ * `message.expirationTime` is DERIVED from `claim.expiresAt`, exactly as the
+ * identity builder derives it, so the two can never disagree. Accepting both
+ * would let a caller sign a credential whose envelope says "never expires"
+ * while its encoded data says otherwise — a consumer using standard Ethereum
+ * Attestation Service tooling and one decoding the claim would then reach
+ * opposite conclusions about the same credential, with nothing to flag it.
+ *
+ * `recipient` stays a separate parameter because {@link AgeClaim} carries no
+ * subject field by design — binding the holder inside the encoded data would
+ * put a personal identifier in the schema.
+ */
+export declare const buildOffchainAgeAttestation: (args: BuildOffchainAgeAttestationArgs) => Promise<OffchainEasAttestation>;
+/**
+ * Convenience wrapper: resolve `eas` + age `schemaUid` from the chainId, then
+ * sign. Throws if either lookup fails (chain unknown, address not pinned, or
+ * no age schema unique identifier pinned for that chain).
+ */
+export declare const buildOffchainAgeAttestationForChain: (args: Omit<BuildOffchainAgeAttestationArgs, "eas" | "schemaUid">) => Promise<OffchainEasAttestation>;
+/**
+ * Wire-shape delegated attestation signature suitable for the EAS
+ * contract's `attestByDelegation(DelegatedAttestationRequest)` call.
+ *
+ * Mirrors the on-chain `Signature` struct (`v, r, s`) plus the
+ * delegation envelope fields (`attester`, `deadline`, `nonce`) the
+ * contract needs to verify the signature without trusting `msg.sender`.
+ *
+ * Wire-safe: `deadline` and `nonce` are base-10 strings so the whole
+ * object survives `JSON.stringify` without bigint loss. Re-hydrate to
+ * bigint at the boundary that actually calls the contract.
+ *
+ * **Why this shape instead of the SDK's response shape:** the SDK
+ * returns a nested `{ message, signature, types, ... }` object intended
+ * for off-chain verification. We only need what `attestByDelegation`
+ * actually consumes — keeping the wire narrow makes the gate's
+ * attestationStore + the UI saved-proof both materially smaller and
+ * makes the contract-call site self-documenting.
+ */
+export type DelegatedAttestationSignature = {
+    signature: {
+        v: number;
+        r: Hex;
+        s: Hex;
+    };
+    attester: Address;
+    /** Base-10 stringified `uint64`. `'0'` = signature never expires. */
+    deadline: string;
+    /** Base-10 stringified `uint256`. EAS contract's nonce for `attester` at sign time. */
+    nonce: string;
+};
+/**
+ * Inputs to {@link buildDelegatedEasAttestationRequest}.
+ *
+ * `nonce` is required because we don't connect a provider to the SDK
+ * (server-side signing should not depend on the EAS contract being
+ * reachable mid-sign). Callers fetch it via viem `getNonce(attester)`
+ * before signing — see `notary-gate/src/lib/delegation-signer.ts`.
+ *
+ * `deadline: 0n` is the EAS sentinel for "no expiration"; recommended
+ * default since the Provex publish flow already enforces an
+ * `expirationTime` on the attestation itself.
+ */
+export type BuildDelegatedEasAttestationRequestArgs = {
+    attester: LocalAccount;
+    claim: IdentityClaim;
+    chainId: number;
+    eas: Address;
+    schemaUid: Hex;
+    /** EAS contract nonce for `attester.address`. Fetch via `getNonce`. */
+    nonce: bigint;
+    /** Use `0n` for no expiration (recommended). */
+    deadline: bigint;
+    /**
+     * EAS contract version string used in the EIP-712 domain. Must match
+     * the on-chain `eip712Domain().version` for `attestByDelegation` to
+     * verify. Same value as for off-chain attestations on the same chain.
+     */
+    contractVersion: string;
+};
+export declare const buildDelegatedEasAttestationRequest: (args: BuildDelegatedEasAttestationRequestArgs) => Promise<DelegatedAttestationSignature>;
+/**
+ * Convenience wrapper: resolve `eas` + `schemaUid` from the chainId,
+ * pair with the canonical contract version string for the chain, then
+ * sign. Throws if either chain lookup fails.
+ *
+ * Prefer this over the raw {@link buildDelegatedEasAttestationRequest}
+ * for any caller that has a chainId — eliminates the chance of pairing
+ * the wrong EAS address with the wrong schema UID with the wrong
+ * contract version.
+ */
+export declare const buildDelegatedEasAttestationRequestForChain: (args: Omit<BuildDelegatedEasAttestationRequestArgs, "eas" | "schemaUid" | "contractVersion"> & {
+    contractVersion?: string;
+}) => Promise<DelegatedAttestationSignature>;
+export type BuildDelegatedReleaseAttestationRequestArgs = {
+    attester: LocalAccount;
+    claim: ReleaseClaim;
+    chainId: number;
+    eas: Address;
+    schemaUid: Hex;
+    /** EAS contract nonce for `attester.address`. Fetch via `getNonce`. */
+    nonce: bigint;
+    /** Relayer submission deadline as a uint64; use `0n` for no deadline. */
+    deadline: bigint;
+    /** EAS contract version string used in the EIP-712 domain. */
+    contractVersion: string;
+    /** EAS-native freshness horizon (Unix seconds). Use `attestationExpirationTime()`. */
+    expirationTime: bigint;
+};
+/**
+ * Sign a delegated release attestation request — lets any caller submit
+ * `attestByDelegation` on-chain with the gate recorded as the attester. The
+ * recipient is the zero address (the subject is the manifest, not a wallet).
+ */
+export declare const buildDelegatedReleaseAttestationRequest: (args: BuildDelegatedReleaseAttestationRequestArgs) => Promise<DelegatedAttestationSignature>;
+/**
+ * Convenience wrapper: resolve `eas` + release `schemaUid` + the canonical
+ * contract version from the chainId, then sign. Throws if any lookup fails.
+ */
+export declare const buildDelegatedReleaseAttestationRequestForChain: (args: Omit<BuildDelegatedReleaseAttestationRequestArgs, "eas" | "schemaUid" | "contractVersion"> & {
+    contractVersion?: string;
+}) => Promise<DelegatedAttestationSignature>;
+export {};