@mida-context/sdk 0.1.0

package/dist/types/protocol/types.d.ts

@@ -0,0 +1,215 @@
+import type { Address, Hex } from "viem";
+import type { ContextKind, Permission, ProvenancePolicy, ProvenanceSource, RecordRelation } from "./constants.js";
+export type { Address, Hex };
+/** §4.3 */
+export interface AgentRecord {
+    agentId: Hex;
+    operator: Address;
+    signer: Address;
+    encryptionPublicKey: Hex;
+    encryptionKeyVersion: number;
+    callbackOriginHash: Hex;
+    capabilityManifestHash: Hex;
+    capabilityManifestVersion: number;
+    active: boolean;
+}
+/** §7.2 */
+export interface ReadEpochState {
+    readEpoch: bigint;
+    publicKey: Hex;
+    writeDeadline: bigint;
+}
+/** §8.2 */
+export interface RecordReference {
+    relation: RecordRelation;
+    recordId: Hex;
+}
+/**
+ * Where a migrated record came from — sealed beside or inside the payload by `mida migrate`.
+ * Declared here because ContextPayload carries it; `@mida/checkpoint` holds an identical
+ * declaration beside StoredCheckpoint (that package stays dependency-free), and the two are
+ * structurally interchangeable.
+ */
+export interface MigrationEnvelope {
+    version: 1;
+    /** The chain the record was copied from, as a decimal string. */
+    originalChainId: string;
+    /** The ContextRegistry the record lived on before the move. */
+    originalContract: Address;
+    originalRecordId: Hex;
+    /** The old record's on-chain manifestHash. */
+    originalCommitment: Hex;
+    /** The old record's on-chain author id. */
+    originalAuthor: Hex;
+    /** When the record was first written — ISO-8601. */
+    originalCreatedAt: string;
+    /** When the move happened — ISO-8601; its day is what "(moved on …)" renders. */
+    migratedAt: string;
+}
+export interface ContextPayload {
+    v: 1;
+    value: string | Record<string, unknown>;
+    kind: ContextKind;
+    provenance: {
+        source: ProvenanceSource;
+        extractionConfidence?: number;
+        references?: RecordReference[];
+        sourceHash?: Hex;
+        sourceUri?: string;
+        retrievedAt?: number;
+        note?: string;
+    };
+    tags?: string[];
+    /**
+     * The migration envelope of a moved record whose `value` is a string — a string cannot carry
+     * the envelope inside, so it sits here, a sibling of `value`. An object `value` carries it at
+     * `value.migration` instead, and an ordinary record carries no `migration` key at all.
+     */
+    migration?: MigrationEnvelope;
+}
+/** §8.3 */
+export interface EpochDEKWrap {
+    v: 1;
+    contextId: Hex;
+    namespaceId: Hex;
+    readEpoch: string;
+    ephemeralPublicKey: Hex;
+    nonce: Hex;
+    wrappedDek: Hex;
+}
+/** §8.4 */
+export interface ReaderEpochWrap {
+    v: 1;
+    owner: Address;
+    namespaceId: Hex;
+    readEpoch: string;
+    agentId: Hex;
+    agentKeyVersion: number;
+    ephemeralPublicKey: Hex;
+    nonce: Hex;
+    wrappedEpochPrivateKey: Hex;
+    createdAt: string;
+}
+/** §9.1 */
+export interface ObjectManifest {
+    v: 1;
+    contextId: Hex;
+    ciphertextHash: Hex;
+    ciphertextSize: number;
+    payloadNonce: Hex;
+    cryptoVersion: "mida-crypto-v1";
+    readEpoch: string;
+    epochDekWrap: EpochDEKWrap;
+}
+/** §9.2 */
+export interface StorageRef {
+    provider: "memory" | "fs" | "mida-api" | "s3" | "ipfs";
+    locator: string;
+}
+/** §13.2. GrantScope (§10.4) has the same three fields. */
+export interface RequestedScope {
+    namespaceId: Hex;
+    permissions: number;
+    provenancePolicy: number;
+}
+export type GrantScope = RequestedScope;
+export type PurposeId = "general_assistance" | "career_coaching" | "project_assistance" | "travel_planning";
+export interface AccessRequest {
+    v: 1;
+    chainId: string;
+    capabilityRegistry: Address;
+    requestId: Hex;
+    nonce: Hex;
+    agentId: Hex;
+    purposeId: PurposeId;
+    callbackOrigin: string;
+    manifestHash: Hex;
+    manifestVersion: number;
+    policyVersion: "mida-grant-policy-v1";
+    namespaceTreeVersion: "mida-namespace-tree-v1";
+    scopes: RequestedScope[];
+    issuedAt: string;
+    requestExpiresAt: string;
+    capabilityExpiresAt: string;
+    agentSignature: Hex;
+}
+export interface GrantedCapability {
+    namespaceId: Hex;
+    permissions: number;
+    provenancePolicy: number;
+    expiresAt: string;
+    capabilityId: Hex;
+    transactionHash: Hex;
+}
+export interface AccessGrantResponse {
+    v: 1;
+    chainId: string;
+    capabilityRegistry: Address;
+    requestId: Hex;
+    nonce: Hex;
+    requestHash: Hex;
+    owner: Address;
+    agentId: Hex;
+    manifestHash: Hex;
+    manifestVersion: number;
+    policyVersion: "mida-grant-policy-v1";
+    namespaceTreeVersion: "mida-namespace-tree-v1";
+    capabilities: GrantedCapability[];
+}
+/** §14.1 */
+export interface PurposeDeclaration {
+    id: PurposeId;
+    description: string;
+}
+export interface ScopeDeclaration {
+    purposeId: PurposeId;
+    namespace: string;
+    permissions: Permission[];
+    provenancePolicies?: ProvenancePolicy[];
+    reason: string;
+}
+export interface AgentCapabilityManifestBody {
+    v: 1;
+    agentId: Hex;
+    manifestVersion: number;
+    name: string;
+    purposes: PurposeDeclaration[];
+    scopeDeclarations: ScopeDeclaration[];
+    issuedAt: number;
+}
+export interface SignedAgentCapabilityManifest {
+    manifest: AgentCapabilityManifestBody;
+    operatorSignature: Hex;
+}
+/** §14.5 */
+export interface EffectiveAuthority {
+    namespaceId: Hex;
+    permission: Permission;
+    provenancePolicy?: ProvenancePolicy;
+}
+export interface OwnerAgentHistory {
+    owner: Address;
+    agentId: Hex;
+    previouslyRevoked: boolean;
+    observedThroughBlock: bigint;
+}
+/** §14.6 */
+export type ScopeWarningCode = "SCOPE_NOT_DECLARED" | "SCOPE_UNCLASSIFIED" | "SCOPE_ELEVATED" | "SCOPE_SUSPICIOUS" | "HIGH_SENSITIVITY" | "BROAD_PARENT_SCOPE" | "SUPERSEDE_ANY_EXPLICIT" | "PERMISSION_NARROWED" | "PROVENANCE_POLICY_NARROWED" | "DURATION_NARROWED" | "PREVIOUSLY_REVOKED";
+export interface ScopeWarning {
+    code: ScopeWarningCode;
+    namespaceId?: Hex;
+    relatedNamespaceIds?: Hex[];
+    severity: "info" | "warning" | "critical";
+    messageKey: string;
+}
+export interface GrantAdvice {
+    policyVersion: "mida-grant-policy-v1";
+    namespaceTreeVersion: "mida-namespace-tree-v1";
+    requestHash: Hex;
+    manifestHash: Hex;
+    manifestVersion: number;
+    recommended: RequestedScope[];
+    recommendedExpiresAt: string;
+    warnings: ScopeWarning[];
+    risk: "low" | "medium" | "high";
+}

package/dist/types/protocol/webauthn-assertion.d.ts

@@ -0,0 +1,29 @@
+import type { Hex } from "viem";
+/** Order of the P256 (secp256r1) group. */
+export declare const P256_N = 115792089210356248762697446949407573529996955224135760342422259061068512044369n;
+/** Solidity `WebAuthn.WebAuthnAuth` from webauthn-sol v1.0.0, in field order. */
+export interface WebAuthnAuthStruct {
+    authenticatorData: Hex;
+    clientDataJSON: string;
+    challengeIndex: bigint;
+    typeIndex: bigint;
+    r: bigint;
+    s: bigint;
+}
+/**
+ * EIP-7951 accepts any 0 < s < n, but webauthn-sol rejects s > n/2 (spec §10.4). A valid signature with high s has an
+ * equally valid twin at n - s, so every adapter maps to that low-s form before contract submission.
+ */
+export declare function normalizeP256LowS(s: bigint): bigint;
+/**
+ * The shared assertion adapter (spec §10.4, §15): builds the struct `grantBatch` and `rotateP256Key` consume, with s
+ * normalized. It has no FakeVault or browser dependency, so Project 2's real passkey adapter uses exactly this.
+ */
+export declare function toWebAuthnAuthStruct(input: {
+    authenticatorData: Hex;
+    clientDataJSON: string;
+    challengeIndex: number | bigint;
+    typeIndex: number | bigint;
+    r: bigint;
+    s: bigint;
+}): WebAuthnAuthStruct;

package/dist/types/protocol/wire.d.ts

@@ -0,0 +1,8 @@
+import type { Hex } from "viem";
+export declare const MAX_UINT64: bigint;
+export declare function encodeUint64(value: bigint): string;
+export declare function decodeUint64(value: string): bigint;
+export declare function assertHex(value: string, byteLength: number): Hex;
+export declare function isZeroBytes(bytes: Uint8Array): boolean;
+export declare function canonicalJson(value: unknown): string;
+export declare function canonicalBytes(value: unknown): Uint8Array;

package/dist/types/sdk/agent.d.ts

@@ -0,0 +1,279 @@
+import type { AccessGrantResponse, AccessRequest, Address, ContextKind, ContextPayload, GrantedCapability, Hex, LineagePolicy, ObjectManifest, PurposeId, RecordReference } from "../protocol/index.js";
+import type { LocalWriteContext } from "../chain/index.js";
+import type { ScopeInput } from "../grant-advisor/index.js";
+import type { BatchReceipt, ContextApiRoutes, ContextRecordView } from "../api/index.js";
+import type { AccessRequestStore } from "./request-store.js";
+/** §13.2 allows up to 600 seconds; the SDK uses 300 so a request stays valid through a normal consent screen. */
+export declare const REQUEST_LIFETIME_SECONDS = 300n;
+export interface AccessRequestInput {
+    purposeId: PurposeId;
+    /** Builder-supplied scopes; parents are expanded through the frozen tree before signing. */
+    scopes: readonly ScopeInput[];
+    /** Requested grant expiry in Unix seconds; omitted or 0n means no expiry is requested. */
+    capabilityExpiresAt?: bigint;
+}
+export interface Grant {
+    owner: Address;
+    agentId: Hex;
+    requestId: Hex;
+    capabilities: GrantedCapability[];
+}
+/** The only provenance an agent can write (§11.8). USER_ASSERTED and USER_CONFIRMED need the owner. */
+export type AgentProvenanceSource = "AGENT_INFERRED" | "IMPORTED" | "EXTERNAL_ATTESTATION";
+export interface CreateContextInput {
+    value: ContextPayload["value"];
+    kind: Exclude<ContextKind, "NONE">;
+    source: AgentProvenanceSource;
+    references?: RecordReference[];
+    tags?: string[];
+    note?: string;
+    extractionConfidence?: number;
+    expiresAt?: bigint;
+}
+export type SupersedeContextInput = CreateContextInput;
+export interface ReadOptions {
+    /**
+     * `false` skips the same-second placement scan entirely — for a read that never orders its
+     * objects (the save duplicate-check). Default: records stamped in the same second get one
+     * bounded ±64-block log scan per disjoint window to recover (block, index).
+     */
+    placements?: boolean;
+}
+export interface ProposalInput {
+    value: ContextPayload["value"];
+    kind?: Exclude<ContextKind, "NONE">;
+    references?: RecordReference[];
+    tags?: string[];
+    note?: string;
+    extractionConfidence?: number;
+}
+/**
+ * One record written exactly as given (migrate B1): the payload is sealed verbatim — every
+ * provenance field `create` drops survives — and the record type, kind, lineage policy, expiry,
+ * parent and nonce are all the caller's. The caller predicts the id with `predictContextId`.
+ */
+export interface ReplayInput {
+    namespaceId: Hex;
+    payload: ContextPayload;
+    recordType: "CONTEXT" | "EVIDENCE";
+    kind: ContextKind;
+    lineagePolicy: LineagePolicy;
+    expiresAt: bigint;
+    /** The parent record's contextId, or the zero hash for a root. */
+    expectedParentId: Hex;
+    /** Prepared by the caller; what makes a re-run land on the same id instead of duplicating. */
+    objectNonce: Hex;
+}
+export interface ContextObject {
+    contextId: Hex;
+    owner: Address;
+    namespace: string;
+    namespaceId: Hex;
+    authorId: Hex;
+    lineageId: Hex;
+    parentId: Hex;
+    version: number;
+    readEpoch: bigint;
+    recordType: "CONTEXT" | "EVIDENCE";
+    payload: ContextPayload;
+    transactionHash?: Hex;
+    /**
+     * The commitment the record's bytes were sealed under: the chain row's manifestHash for an
+     * anchored record, the signed batch message's for a pending one. A reader verifies the
+     * payload against it — it is never trusted on its own.
+     */
+    manifestHash?: Hex;
+    /**
+     * Monad's own placement of the save — set only on records the chain has actually recorded.
+     * `at` is the timestamp the chain stamped (the ContextRegistry row's createdAt for a direct
+     * save, the anchor block's time for a batched one); `block`, `transaction` and `index` are
+     * its position in the chain's order — the anchoring block, the anchoring transaction's index
+     * inside it, then the save's own position inside the transaction (the log index for a direct
+     * save, the batch's own position for a batched one). Absent entirely when no chain fact
+     * places the record — a pending batched save above all — and `block`/`transaction`/`index`
+     * are absent when only the stamp could be recovered. `batchId` names the one batch that
+     * anchored a batched-lane save: two rows sharing it share one transaction, so their `index`
+     * values are positions in the same ordering and comparable without asking the chain for the
+     * transaction index (in-14 F-1). Whatever an object claims inside its own payload never
+     * reaches this field.
+     */
+    chain?: {
+        at: bigint;
+        block?: bigint;
+        transaction?: number;
+        index?: number;
+        batchId?: Hex;
+    };
+}
+/**
+ * What `sealReplay` produces once and `sendSealed` may send any number of times (migrate B1b): the
+ * exact ciphertext and manifest the store's same-manifest repeat upload accepts, plus every field
+ * `register` needs. Ciphertext only — no plaintext — so a crash between upload and register
+ * resends identical bytes instead of re-sealing (a fresh seal draws a fresh key and a different
+ * manifestHash the store then refuses).
+ */
+export interface SealedRecord {
+    contextId: Hex;
+    namespaceId: Hex;
+    readEpoch: bigint;
+    manifest: ObjectManifest;
+    manifestHash: Hex;
+    ciphertext: Uint8Array;
+    onChain: {
+        recordType: "CONTEXT" | "EVIDENCE";
+        kind: ContextKind;
+        lineagePolicy: LineagePolicy;
+        expiresAt: bigint;
+        expectedParentId: Hex;
+        evidenceCommitment: Hex;
+        objectNonce: Hex;
+        provenanceSource: number;
+    };
+}
+/**
+ * What `sendSealed` can attest: the anchored record's view plus its transaction — `ContextObject`
+ * minus `payload`, because a `SealedRecord` holds no plaintext to put in it (`replay` recomposes
+ * the full object from its own input). `transactionHash` is absent when the identical record was
+ * already anchored — a resend is done, not sent again.
+ */
+export type SentRecord = Omit<ContextObject, "payload">;
+export interface MidaAgentConfig {
+    agentId: Hex;
+    callbackOrigin: string;
+    encryptionPrivateKey: Uint8Array;
+    /** Write context whose account is the agent's current registered signer. */
+    chain: LocalWriteContext;
+    /** Context API client bound to the same signer. */
+    api: ContextApiRoutes & {
+        account: {
+            address: Address;
+        };
+    };
+    requests?: AccessRequestStore;
+    /**
+     * Grants this agent completed in an earlier process. They only tell the agent which capabilityId to present:
+     * every read is still authorised by the API against Monad and every write by the contract, so a stale or forged
+     * entry buys nothing.
+     */
+    grants?: readonly Grant[];
+}
+/** §13.1 agent/server SDK. Every authority it relies on is re-read from Monad; nothing the API returns is trusted alone. */
+export declare class MidaAgent {
+    #private;
+    readonly agentId: Hex;
+    constructor(config: MidaAgentConfig);
+    get grants(): readonly Grant[];
+    /** The chain's own record for one contextId — null when the registry holds none. */
+    chainRecord(contextId: Hex): Promise<ContextRecordView | null>;
+    /**
+     * Whether Monad lists at least one currently-valid capability for this owner–agent pair —
+     * the contract's `isCapabilityValid` answer per id, not the local grant copy.
+     */
+    hasLiveCapability(owner: Address): Promise<boolean>;
+    /** §13.2: canonical, parent-expanded, sorted exact scopes, signed by the agent's current signer and persisted. */
+    createAccessRequest(input: AccessRequestInput): Promise<AccessRequest>;
+    /**
+     * §13.3: the response must match the stored original request, stay within its authority (Part C helper), and every
+     * capability must exist on Monad with identical fields, be currently valid, and be emitted by the named transaction.
+     * The chain proves a capability exists; the original request proves it is the one this agent asked for.
+     */
+    completeAccessRequest(request: AccessRequest, response: AccessGrantResponse): Promise<Grant>;
+    /**
+     * §12.3 read: API objects are re-checked against Monad commitments, then decrypted with this
+     * agent's own epoch wraps. A list the store could not fully verify is never returned as if it
+     * were complete — `read` refuses it outright; callers that can carry the flag use
+     * `readWithStatus` instead.
+     */
+    read(owner: Address, namespace: string, options?: ReadOptions): Promise<ContextObject[]>;
+    /**
+     * `read` plus the store's completeness flag, for callers that can surface it downstream (M3-D).
+     *
+     * Placement policy (in-9 R-1): `chain.at` is already chain truth on every record — the
+     * contract stores `block.timestamp` as createdAt — so no log scan runs for it. The event
+     * log's (block, index) is needed ONLY to order records stamped in the same second, and only
+     * then does the read scan: a bounded ±64-block window around the block that second implies,
+     * one getLogs per disjoint window. `{ placements: false }` skips even that (the save
+     * duplicate-check needs no ordering at all); a missed window falls back to the contextId
+     * tie-break, never to a whole-history scan.
+     */
+    readWithStatus(owner: Address, namespace: string, options?: ReadOptions): Promise<{
+        objects: ContextObject[];
+        partial: boolean;
+    }>;
+    /**
+     * The batched counterpart of `readWithStatus` (Task 4): lists the store's batch rows and verifies
+     * each one itself — an anchored row only survives if its proof reaches the on-chain batch root
+     * and it is the lineage's current head; a queued/submitted row is checked for everything except
+     * inclusion and comes back marked `PENDING_ANCHOR` with its author agentId. The store's word for
+     * a row's state is never trusted; every authority check reads the contracts.
+     */
+    readBatchedWithStatus(owner: Address, namespace: string): Promise<{
+        anchored: ContextObject[];
+        pending: (ContextObject & {
+            anchor: "PENDING_ANCHOR";
+            authorAgentId: Hex;
+            receivedAt: number;
+        })[];
+        skipped: {
+            contextId: Hex;
+            reason: string;
+        }[];
+        partial: boolean;
+    }>;
+    /**
+     * The duplicate check behind a save (in-12 N-6): whether this owner+namespace already holds a
+     * record whose decrypted payload satisfies `match`. Opening a row is local work — the epoch
+     * keys are fetched once per epoch and shared — so every listed row is opened and judged, and
+     * chain verification runs ONLY on the (normally zero or one) rows whose payload claims the
+     * match. That ordering is safe because a row the store invented cannot reach `match`: without
+     * the epoch key it cannot produce ciphertext that opens under the contextId binding, so a
+     * payload that opens was sealed honestly. A claimed match is then verified against Monad
+     * exactly as the full reads verify it — the store's word never decides "duplicate" — and a
+     * match whose record is not really there is skipped, not believed. A partial list still
+     * refuses outright: an incomplete view can never answer "not a duplicate" honestly. Returns
+     * the matching record's contextId, or undefined.
+     */
+    findDuplicate(owner: Address, namespace: string, match: (value: unknown) => boolean, options?: {
+        batched?: boolean;
+    }): Promise<Hex | undefined>;
+    create(owner: Address, namespace: string, input: CreateContextInput): Promise<ContextObject>;
+    /**
+     * The BatchAnchor write path (Task 4): seals the same checkpoint shape as `create` — a new
+     * STANDARD-lineage CONTEXT record, always AGENT_INFERRED — but signs it for the batch queue
+     * instead of calling `contexts.register`. The signature is the whole authorization; no
+     * transaction leaves this method.
+     */
+    createBatched(owner: Address, namespace: string, input: CreateContextInput): Promise<{
+        contextId: Hex;
+        state: "QUEUED";
+        receipt: BatchReceipt;
+    }>;
+    /** §11.6: SUPERSEDE_ANY on another author's STANDARD lineage, SUPERSEDE_OWN (or ANY) on this agent's own lineage. */
+    supersede(owner: Address, parentId: Hex, input: SupersedeContextInput): Promise<ContextObject>;
+    /** Always AGENT_INFERRED; the owner decides later whether to confirm it. */
+    propose(owner: Address, namespace: string, input: ProposalInput): Promise<ContextObject>;
+    /** The contextId a `replay` with this nonce will produce — computed before sending. */
+    predictContextId(owner: Address, namespaceId: Hex, objectNonce: Hex): Hex;
+    /**
+     * Writes one record exactly as given (migrate B1). Unlike `#write` it does not rebuild the
+     * payload — `sourceHash`, `sourceUri`, `retrievedAt`, `note`, `extractionConfidence`,
+     * `references` and `tags` all reach the seal — and it adds no provenance restriction of its
+     * own: the ordinary capability and epoch checks apply, and the contract stays the authority.
+     * Seal once, then send those bytes (migrate B1b).
+     */
+    replay(owner: Address, input: ReplayInput): Promise<ContextObject>;
+    /**
+     * Seals a replay exactly once and writes nothing (migrate B1b): the capability, epoch, id and
+     * every byte `sendSealed` needs, frozen so a retry — including after a crash between upload and
+     * register — resends identical bytes. The epoch is checked here and again at send: a seal that
+     * outlives its epoch is refused, never silently resealed under a different epoch.
+     */
+    sealReplay(owner: Address, input: ReplayInput): Promise<SealedRecord>;
+    /**
+     * Sends the bytes `sealReplay` produced — the same bytes on every call (migrate B1b). The store
+     * accepts a repeat upload only for an identical manifest, so a resend after an upload-only crash
+     * lands; a record already anchored with this exact manifestHash is done, not sent again; a stale
+     * epoch refuses `EPOCH_ROTATION_REQUIRED` before anything leaves this process.
+     */
+    sendSealed(owner: Address, sealed: SealedRecord): Promise<SentRecord>;
+}

package/dist/types/sdk/batched.d.ts

@@ -0,0 +1,68 @@
+import type { Address, BatchSaveMessage, Hex } from "../protocol/index.js";
+import type { Deployment } from "../chain/index.js";
+import type { LocalAccount, PublicClient } from "viem";
+import type { BatchedReadItem } from "../api/index.js";
+export type { BatchedItemState, BatchedReadItem, BatchedSaveWire, BatchReceipt } from "../api/index.js";
+/** Every way `verifyBatchedItem` can refuse, in the order the checks run. */
+export type BatchedVerifyReason = "ciphertext" | "manifest" | "signature" | "author" | "not-anchored" | "unknown-batch" | "proof" | "stale";
+/** Every way `verifyPendingItem` can refuse, in the order the checks run. */
+export type PendingVerifyReason = "not-pending" | "ciphertext" | "manifest" | "signature" | "author" | "no-authority";
+/**
+ * `anchorBlock` is the block `batchOf` reports for the save's batch — the block the anchor
+ * transaction mined in, read from the contract during verification, never the store's word.
+ */
+export type BatchedVerdict = {
+    ok: true;
+    agentId: Hex;
+    anchorBlock: bigint;
+} | {
+    ok: false;
+    reason: BatchedVerifyReason;
+};
+export type PendingVerdict = {
+    ok: true;
+    agentId: Hex;
+    anchorBlock?: never;
+} | {
+    ok: false;
+    reason: PendingVerifyReason;
+};
+/**
+ * §BatchAnchor write path: the agent signs one `MidaBatchSaveV1` typed message per save under the
+ * BatchAnchor domain; the contract re-derives this digest, so the signature alone is the whole
+ * authorization — no transaction leaves this call.
+ */
+export declare function signBatchSave(input: {
+    account: LocalAccount;
+    chainId: bigint;
+    batchAnchor: Address;
+    message: BatchSaveMessage;
+}): Promise<Hex>;
+/**
+ * The five-check anchored read. Chain state is the only authority: the signer→agent lookup, the
+ * batch root, and the lineage head all come from the contracts through `client`; the store supplies
+ * only the bytes being checked. A non-ANCHORED item can never pass — pending saves go through
+ * `verifyPendingItem` instead.
+ */
+export declare function verifyBatchedItem(input: {
+    item: BatchedReadItem;
+    chainId: bigint;
+    deployment: Deployment;
+    client: PublicClient;
+    requireLatest: boolean;
+}): Promise<BatchedVerdict>;
+/**
+ * Amendment B.2 pending read: everything checkable without anchor inclusion — bytes, signature,
+ * registered author, contextId — plus the one live check that matters most for a not-yet-anchored
+ * save: the author's current authority, chosen exactly as `BatchAnchor._checkAndApply` chooses it.
+ * A new lineage needs CREATE+INFERENCE; a replacement needs SUPERSEDE_OWN when the signer authored
+ * the lineage root, SUPERSEDE_ANY otherwise — a save queued before a revocation must not survive
+ * this. Inclusion and freshness are deliberately unchecked: the contract will run them at anchor
+ * time.
+ */
+export declare function verifyPendingItem(input: {
+    item: BatchedReadItem;
+    chainId: bigint;
+    deployment: Deployment;
+    client: PublicClient;
+}): Promise<PendingVerdict>;