@stellaris-lab/por-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+export * from "./audit.js";
+export * from "./backend.js";
+export * from "./codec.js";
+export * from "./constants.js";
+export * from "./domain.js";
+export * from "./encoding.js";
+export * from "./errors.js";
+export * from "./events.js";
+export * from "./manifest.js";
+export * from "./operations.js";
+export * from "./persistence.js";
+export * from "./pipeline.js";
+export * from "./policy.js";
+export * from "./prove.js";
+export * from "./registry.js";
+export * from "./reconciler.js";
+export * from "./signals.js";
+export * from "./stellar.js";
+export * from "./transport.js";

package/dist/index.js

@@ -0,0 +1,19 @@
+export * from "./audit.js";
+export * from "./backend.js";
+export * from "./codec.js";
+export * from "./constants.js";
+export * from "./domain.js";
+export * from "./encoding.js";
+export * from "./errors.js";
+export * from "./events.js";
+export * from "./manifest.js";
+export * from "./operations.js";
+export * from "./persistence.js";
+export * from "./pipeline.js";
+export * from "./policy.js";
+export * from "./prove.js";
+export * from "./registry.js";
+export * from "./reconciler.js";
+export * from "./signals.js";
+export * from "./stellar.js";
+export * from "./transport.js";

package/dist/manifest.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Artifact and deployment manifest.
+ *
+ * Frontends, CLIs, backend services, and tests should consume a manifest rather
+ * than hardcoding wasm/zkey/contract IDs throughout the app.
+ */
+import { ContractDeployment, ProvingArtifacts, VerificationKeyDocument } from "./domain.js";
+export interface StellarisManifest {
+    readonly schemaVersion: "stellaris.manifest.v1";
+    readonly circuit: {
+        readonly name: "proof-of-reserves";
+        readonly curve: "bls12381";
+        readonly nReserves: number;
+        readonly nPublicSignals: number;
+        readonly publicSignalOrder: readonly ["solvent", "commitment", "liabilities", "period_id"];
+    };
+    readonly artifacts: ProvingArtifacts;
+    readonly deployment?: ContractDeployment;
+}
+export declare function createManifest(input: Omit<StellarisManifest, "schemaVersion">): StellarisManifest;
+export declare function validateManifest(manifest: StellarisManifest): void;
+export declare function assertVerificationKeyShape(vk: VerificationKeyDocument): void;

package/dist/manifest.js

@@ -0,0 +1,54 @@
+/**
+ * Artifact and deployment manifest.
+ *
+ * Frontends, CLIs, backend services, and tests should consume a manifest rather
+ * than hardcoding wasm/zkey/contract IDs throughout the app.
+ */
+import { StellarisError } from "./errors.js";
+export function createManifest(input) {
+    const manifest = {
+        schemaVersion: "stellaris.manifest.v1",
+        ...input,
+    };
+    validateManifest(manifest);
+    return manifest;
+}
+export function validateManifest(manifest) {
+    if (manifest.schemaVersion !== "stellaris.manifest.v1") {
+        throw StellarisError.configuration("unsupported manifest schema", { schemaVersion: manifest.schemaVersion });
+    }
+    if (manifest.circuit.curve !== "bls12381") {
+        throw StellarisError.configuration("Stellaris circuit must use BLS12-381", { curve: manifest.circuit.curve });
+    }
+    if (manifest.circuit.nPublicSignals !== 4) {
+        throw StellarisError.configuration("Stellaris circuit must expose exactly 4 public signals");
+    }
+    const expected = ["solvent", "commitment", "liabilities", "period_id"];
+    for (let i = 0; i < expected.length; i++) {
+        if (manifest.circuit.publicSignalOrder[i] !== expected[i]) {
+            throw StellarisError.configuration("public signal order mismatch", {
+                expected,
+                actual: manifest.circuit.publicSignalOrder,
+            });
+        }
+    }
+    if (!manifest.artifacts.wasmUrl || !manifest.artifacts.zkeyUrl) {
+        throw StellarisError.configuration("manifest must include wasmUrl and zkeyUrl");
+    }
+}
+export function assertVerificationKeyShape(vk) {
+    if (vk.curve && vk.curve !== "bls12381") {
+        throw StellarisError.configuration("verification key curve mismatch", { curve: vk.curve });
+    }
+    if (vk.protocol && vk.protocol !== "groth16") {
+        throw StellarisError.configuration("verification key protocol mismatch", { protocol: vk.protocol });
+    }
+    if (vk.nPublic !== undefined && vk.nPublic !== 4) {
+        throw StellarisError.configuration("verification key public signal count mismatch", { nPublic: vk.nPublic });
+    }
+    if (!Array.isArray(vk.IC) || vk.IC.length !== 5) {
+        throw StellarisError.configuration("verification key IC length must be public signals + 1", {
+            icLength: Array.isArray(vk.IC) ? vk.IC.length : "missing",
+        });
+    }
+}

package/dist/operations.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Contract operation registry.
+ *
+ * A mature SDK keeps the contract ABI in one typed registry and derives client,
+ * transport, audit, and generated-binding adapters from it. This file is the
+ * source of truth for supported contract calls on the TypeScript side.
+ */
+import { ContractAttestArgs } from "./codec.js";
+import { Attestation, AttestationV2, AttestationV3, PublicKey, VerificationKeyDocument } from "./domain.js";
+export declare const CONTRACT_OPERATIONS: {
+    readonly init: {
+        readonly mutability: "write";
+        readonly auth: "admin";
+    };
+    readonly attest: {
+        readonly mutability: "write";
+        readonly auth: "issuer";
+    };
+    readonly get_attestation: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly list_periods: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly get_vk: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly get_admin: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly init_v2: {
+        readonly mutability: "write";
+        readonly auth: "admin";
+    };
+    readonly attest_v2: {
+        readonly mutability: "write";
+        readonly auth: "issuer";
+    };
+    readonly get_attestation_v2: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly get_vk_v2: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly init_v3: {
+        readonly mutability: "write";
+        readonly auth: "admin";
+    };
+    readonly attest_v3: {
+        readonly mutability: "write";
+        readonly auth: "issuer";
+    };
+    readonly get_attestation_v3: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly get_vk_v3: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly set_oracle: {
+        readonly mutability: "write";
+        readonly auth: "admin";
+    };
+    readonly publish_oracle_commitment: {
+        readonly mutability: "write";
+        readonly auth: "oracle";
+    };
+    readonly get_oracle: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly get_oracle_commitment: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+    readonly set_custodian: {
+        readonly mutability: "write";
+        readonly auth: "admin";
+    };
+    readonly attest_v3_signed: {
+        readonly mutability: "write";
+        readonly auth: "issuer";
+    };
+    readonly get_custodian: {
+        readonly mutability: "read";
+        readonly auth: "none";
+    };
+};
+export type ContractOperation = keyof typeof CONTRACT_OPERATIONS;
+export type OperationMutability = typeof CONTRACT_OPERATIONS[ContractOperation]["mutability"];
+export type OperationAuth = typeof CONTRACT_OPERATIONS[ContractOperation]["auth"];
+export interface OperationSpec<Name extends ContractOperation = ContractOperation> {
+    readonly name: Name;
+    readonly mutability: OperationMutability;
+    readonly auth: OperationAuth;
+}
+export type OperationArgs<Name extends ContractOperation> = Name extends "init" ? readonly [admin: PublicKey, verificationKey: VerificationKeyDocument] : Name extends "attest" ? readonly [issuer: PublicKey, proof: ContractAttestArgs["proof"], publicSignals: readonly string[]] : Name extends "get_attestation" ? readonly [issuer: PublicKey, periodId: string] : Name extends "list_periods" ? readonly [issuer: PublicKey] : Name extends "get_vk" ? readonly [] : Name extends "get_admin" ? readonly [] : Name extends "init_v2" ? readonly [verificationKey: VerificationKeyDocument] : Name extends "attest_v2" ? readonly [issuer: PublicKey, proof: ContractAttestArgs["proof"], publicSignals: readonly string[]] : Name extends "get_attestation_v2" ? readonly [issuer: PublicKey, periodId: string] : Name extends "get_vk_v2" ? readonly [] : Name extends "init_v3" ? readonly [verificationKey: VerificationKeyDocument] : Name extends "attest_v3" ? readonly [issuer: PublicKey, proof: ContractAttestArgs["proof"], publicSignals: readonly string[]] : Name extends "get_attestation_v3" ? readonly [issuer: PublicKey, periodId: string] : Name extends "get_vk_v3" ? readonly [] : Name extends "set_oracle" ? readonly [oracle: PublicKey] : Name extends "publish_oracle_commitment" ? readonly [periodId: string, commitment: string] : Name extends "get_oracle" ? readonly [] : Name extends "get_oracle_commitment" ? readonly [periodId: string] : Name extends "set_custodian" ? readonly [custodianPk: unknown] : Name extends "attest_v3_signed" ? readonly [issuer: PublicKey, proof: ContractAttestArgs["proof"], publicSignals: readonly string[], custodianSig: unknown] : Name extends "get_custodian" ? readonly [] : never;
+export type OperationResult<Name extends ContractOperation> = Name extends "init" ? void : Name extends "attest" ? Attestation : Name extends "get_attestation" ? Attestation | null : Name extends "list_periods" ? readonly bigint[] : Name extends "get_vk" ? VerificationKeyDocument | null : Name extends "get_admin" ? PublicKey | null : Name extends "init_v2" ? void : Name extends "attest_v2" ? AttestationV2 : Name extends "get_attestation_v2" ? AttestationV2 | null : Name extends "get_vk_v2" ? VerificationKeyDocument | null : Name extends "init_v3" ? void : Name extends "attest_v3" ? AttestationV3 : Name extends "get_attestation_v3" ? AttestationV3 | null : Name extends "get_vk_v3" ? VerificationKeyDocument | null : Name extends "set_oracle" ? void : Name extends "publish_oracle_commitment" ? void : Name extends "get_oracle" ? PublicKey | null : Name extends "get_oracle_commitment" ? string | null : Name extends "set_custodian" ? void : Name extends "attest_v3_signed" ? AttestationV3 : Name extends "get_custodian" ? string | null : never;
+export declare function getOperationSpec<Name extends ContractOperation>(name: Name): OperationSpec<Name>;
+export declare function isReadOperation(name: ContractOperation): boolean;
+export declare function assertOperationArgs(name: ContractOperation, args: readonly unknown[]): void;
+export declare function expectedArgCount(name: ContractOperation): number;

package/dist/operations.js

@@ -0,0 +1,164 @@
+/**
+ * Contract operation registry.
+ *
+ * A mature SDK keeps the contract ABI in one typed registry and derives client,
+ * transport, audit, and generated-binding adapters from it. This file is the
+ * source of truth for supported contract calls on the TypeScript side.
+ */
+import { StellarisError } from "./errors.js";
+export const CONTRACT_OPERATIONS = {
+    init: {
+        mutability: "write",
+        auth: "admin",
+    },
+    attest: {
+        mutability: "write",
+        auth: "issuer",
+    },
+    get_attestation: {
+        mutability: "read",
+        auth: "none",
+    },
+    list_periods: {
+        mutability: "read",
+        auth: "none",
+    },
+    get_vk: {
+        mutability: "read",
+        auth: "none",
+    },
+    get_admin: {
+        mutability: "read",
+        auth: "none",
+    },
+    // v2: solvency with SNARK-proven liabilities (5-signal statement).
+    init_v2: {
+        mutability: "write",
+        auth: "admin",
+    },
+    attest_v2: {
+        mutability: "write",
+        auth: "issuer",
+    },
+    get_attestation_v2: {
+        mutability: "read",
+        auth: "none",
+    },
+    get_vk_v2: {
+        mutability: "read",
+        auth: "none",
+    },
+    // v3: multi-asset solvency with oracle-priced aggregate (8-signal statement).
+    init_v3: {
+        mutability: "write",
+        auth: "admin",
+    },
+    attest_v3: {
+        mutability: "write",
+        auth: "issuer",
+    },
+    get_attestation_v3: {
+        mutability: "read",
+        auth: "none",
+    },
+    get_vk_v3: {
+        mutability: "read",
+        auth: "none",
+    },
+    // C3: designated price-oracle + per-period published commitments.
+    set_oracle: {
+        mutability: "write",
+        auth: "admin",
+    },
+    publish_oracle_commitment: {
+        mutability: "write",
+        auth: "oracle",
+    },
+    get_oracle: {
+        mutability: "read",
+        auth: "none",
+    },
+    get_oracle_commitment: {
+        mutability: "read",
+        auth: "none",
+    },
+    // C2: designated custodian + BLS-signed reserve attestation.
+    set_custodian: {
+        mutability: "write",
+        auth: "admin",
+    },
+    attest_v3_signed: {
+        mutability: "write",
+        auth: "issuer",
+    },
+    get_custodian: {
+        mutability: "read",
+        auth: "none",
+    },
+};
+export function getOperationSpec(name) {
+    const spec = CONTRACT_OPERATIONS[name];
+    return {
+        name,
+        mutability: spec.mutability,
+        auth: spec.auth,
+    };
+}
+export function isReadOperation(name) {
+    return CONTRACT_OPERATIONS[name].mutability === "read";
+}
+export function assertOperationArgs(name, args) {
+    const expected = expectedArgCount(name);
+    if (args.length !== expected) {
+        throw StellarisError.encoding(`operation ${name} expects ${expected} args, received ${args.length}`, {
+            operation: name,
+            expected,
+            actual: args.length,
+        });
+    }
+}
+export function expectedArgCount(name) {
+    switch (name) {
+        case "init":
+            return 2;
+        case "attest":
+            return 3;
+        case "get_attestation":
+            return 2;
+        case "list_periods":
+            return 1;
+        case "get_vk":
+        case "get_admin":
+            return 0;
+        case "init_v2":
+            return 1;
+        case "attest_v2":
+            return 3;
+        case "get_attestation_v2":
+            return 2;
+        case "get_vk_v2":
+            return 0;
+        case "init_v3":
+            return 1;
+        case "attest_v3":
+            return 3;
+        case "get_attestation_v3":
+            return 2;
+        case "get_vk_v3":
+            return 0;
+        case "set_oracle":
+            return 1;
+        case "publish_oracle_commitment":
+            return 2;
+        case "get_oracle":
+            return 0;
+        case "get_oracle_commitment":
+            return 1;
+        case "set_custodian":
+            return 1;
+        case "attest_v3_signed":
+            return 4;
+        case "get_custodian":
+            return 0;
+    }
+}

package/dist/persistence.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Registry persistence and checkpointing.
+ *
+ * BigInt-heavy protocol state is not JSON-safe by default. This module defines a
+ * deterministic wire format and a file-backed checkpoint store for backend/indexer
+ * processes while keeping the core registry storage interface pluggable.
+ */
+import { Attestation, ContractDeployment, PeriodId, PublicKey } from "./domain.js";
+import { AttestationStore, IndexedAttestation, RegistrySnapshot } from "./registry.js";
+export interface SerializedAttestation {
+    readonly commitment: string;
+    readonly liabilities: string;
+    readonly solvent: boolean;
+    readonly ledgerTs: string;
+    readonly periodId: string;
+    readonly issuer: PublicKey;
+}
+export interface SerializedIndexedAttestation {
+    readonly attestation: SerializedAttestation;
+    readonly deployment: ContractDeployment;
+    readonly indexedAt: string;
+    readonly source: IndexedAttestation["source"];
+}
+export interface RegistryCheckpoint {
+    readonly schemaVersion: "stellaris.registry.checkpoint.v1";
+    readonly deployment: ContractDeployment;
+    readonly writtenAt: string;
+    readonly records: readonly SerializedIndexedAttestation[];
+}
+export interface CheckpointCodec {
+    encode(snapshot: RegistrySnapshot): RegistryCheckpoint;
+    decode(checkpoint: RegistryCheckpoint): readonly IndexedAttestation[];
+}
+export declare class JsonCheckpointCodec implements CheckpointCodec {
+    encode(snapshot: RegistrySnapshot): RegistryCheckpoint;
+    decode(checkpoint: RegistryCheckpoint): readonly IndexedAttestation[];
+}
+export declare class CheckpointBackedAttestationStore implements AttestationStore {
+    private readonly inner;
+    constructor(records?: readonly IndexedAttestation[]);
+    put(record: IndexedAttestation): void;
+    get(issuer: PublicKey, periodId: PeriodId): IndexedAttestation | null;
+    list(issuer: PublicKey): readonly IndexedAttestation[];
+    clear(issuer?: PublicKey): void;
+    exportRecords(issuer: PublicKey): readonly IndexedAttestation[];
+}
+export interface FileCheckpointOptions {
+    readonly path: string;
+    readonly codec?: CheckpointCodec;
+}
+export declare class FileCheckpointRepository {
+    private readonly path;
+    private readonly codec;
+    constructor(options: FileCheckpointOptions);
+    load(): Promise<readonly IndexedAttestation[]>;
+    save(snapshot: RegistrySnapshot): Promise<void>;
+    saveRecords(deployment: ContractDeployment, records: readonly IndexedAttestation[]): Promise<void>;
+    createStore(): Promise<CheckpointBackedAttestationStore>;
+    private saveCheckpoint;
+}
+export declare function serializeIndexedAttestation(record: IndexedAttestation): SerializedIndexedAttestation;
+export declare function deserializeIndexedAttestation(record: SerializedIndexedAttestation): IndexedAttestation;
+export declare function serializeAttestation(attestation: Attestation): SerializedAttestation;
+export declare function deserializeAttestation(attestation: SerializedAttestation): Attestation;
+export declare function checkpointFromRecords(deployment: ContractDeployment, records: readonly IndexedAttestation[]): RegistryCheckpoint;
+export declare function recordsFromCheckpoint(checkpoint: RegistryCheckpoint): readonly IndexedAttestation[];
+export declare function indexReceiptLikeAttestation(attestation: Attestation, deployment: ContractDeployment): IndexedAttestation;

package/dist/persistence.js

@@ -0,0 +1,154 @@
+/**
+ * Registry persistence and checkpointing.
+ *
+ * BigInt-heavy protocol state is not JSON-safe by default. This module defines a
+ * deterministic wire format and a file-backed checkpoint store for backend/indexer
+ * processes while keeping the core registry storage interface pluggable.
+ */
+import { StellarisError } from "./errors.js";
+import { InMemoryAttestationStore, indexAttestation, } from "./registry.js";
+export class JsonCheckpointCodec {
+    encode(snapshot) {
+        return {
+            schemaVersion: "stellaris.registry.checkpoint.v1",
+            deployment: snapshot.deployment,
+            writtenAt: new Date().toISOString(),
+            records: snapshot.attestations.map(serializeIndexedAttestation),
+        };
+    }
+    decode(checkpoint) {
+        assertCheckpointShape(checkpoint);
+        return checkpoint.records.map(deserializeIndexedAttestation);
+    }
+}
+export class CheckpointBackedAttestationStore {
+    inner;
+    constructor(records = []) {
+        this.inner = new InMemoryAttestationStore();
+        for (const record of records) {
+            this.inner.put(record);
+        }
+    }
+    put(record) {
+        this.inner.put(record);
+    }
+    get(issuer, periodId) {
+        return this.inner.get(issuer, periodId);
+    }
+    list(issuer) {
+        return this.inner.list(issuer);
+    }
+    clear(issuer) {
+        this.inner.clear(issuer);
+    }
+    exportRecords(issuer) {
+        return this.inner.list(issuer);
+    }
+}
+export class FileCheckpointRepository {
+    path;
+    codec;
+    constructor(options) {
+        this.path = options.path;
+        this.codec = options.codec ?? new JsonCheckpointCodec();
+    }
+    async load() {
+        const fs = await import("node:fs/promises");
+        try {
+            const raw = await fs.readFile(this.path, "utf8");
+            const parsed = JSON.parse(raw);
+            return this.codec.decode(parsed);
+        }
+        catch (cause) {
+            if (isNodeNotFound(cause)) {
+                return [];
+            }
+            throw StellarisError.configuration("failed to load registry checkpoint", {
+                cause,
+                context: { path: this.path },
+            });
+        }
+    }
+    async save(snapshot) {
+        await this.saveCheckpoint(this.codec.encode(snapshot));
+    }
+    async saveRecords(deployment, records) {
+        await this.saveCheckpoint(checkpointFromRecords(deployment, records));
+    }
+    async createStore() {
+        return new CheckpointBackedAttestationStore(await this.load());
+    }
+    async saveCheckpoint(checkpoint) {
+        const fs = await import("node:fs/promises");
+        const body = `${JSON.stringify(checkpoint, null, 2)}\n`;
+        await fs.mkdir(parentDir(this.path), { recursive: true });
+        await fs.writeFile(this.path, body, "utf8");
+    }
+}
+export function serializeIndexedAttestation(record) {
+    return {
+        attestation: serializeAttestation(record.attestation),
+        deployment: record.deployment,
+        indexedAt: record.indexedAt,
+        source: record.source,
+    };
+}
+export function deserializeIndexedAttestation(record) {
+    return {
+        attestation: deserializeAttestation(record.attestation),
+        deployment: record.deployment,
+        indexedAt: record.indexedAt,
+        source: record.source,
+    };
+}
+export function serializeAttestation(attestation) {
+    return {
+        commitment: attestation.commitment,
+        liabilities: attestation.liabilities.toString(),
+        solvent: attestation.solvent,
+        ledgerTs: attestation.ledgerTs.toString(),
+        periodId: attestation.periodId.toString(),
+        issuer: attestation.issuer,
+    };
+}
+export function deserializeAttestation(attestation) {
+    return {
+        commitment: attestation.commitment,
+        liabilities: BigInt(attestation.liabilities),
+        solvent: attestation.solvent,
+        ledgerTs: BigInt(attestation.ledgerTs),
+        periodId: BigInt(attestation.periodId),
+        issuer: attestation.issuer,
+    };
+}
+export function checkpointFromRecords(deployment, records) {
+    return {
+        schemaVersion: "stellaris.registry.checkpoint.v1",
+        deployment,
+        writtenAt: new Date().toISOString(),
+        records: records.map(serializeIndexedAttestation),
+    };
+}
+export function recordsFromCheckpoint(checkpoint) {
+    return new JsonCheckpointCodec().decode(checkpoint);
+}
+export function indexReceiptLikeAttestation(attestation, deployment) {
+    return indexAttestation(attestation, deployment, "receipt");
+}
+function assertCheckpointShape(checkpoint) {
+    if (checkpoint.schemaVersion !== "stellaris.registry.checkpoint.v1") {
+        throw StellarisError.configuration("unsupported registry checkpoint schema", {
+            schemaVersion: checkpoint.schemaVersion,
+        });
+    }
+    if (!Array.isArray(checkpoint.records)) {
+        throw StellarisError.configuration("registry checkpoint records must be an array");
+    }
+}
+function isNodeNotFound(cause) {
+    return typeof cause === "object" && cause !== null && "code" in cause && cause.code === "ENOENT";
+}
+function parentDir(path) {
+    const index = path.lastIndexOf("/");
+    return index <= 0 ? "." : path.slice(0, index);
+}

package/dist/pipeline.d.ts

@@ -0,0 +1,37 @@
+/**
+ * End-to-end attestation pipeline.
+ *
+ * This is the orchestration layer an exchange/backend service would use: it
+ * normalizes a snapshot, evaluates issuer policy, generates a local proof,
+ * optionally verifies it locally, and submits the attestation on-chain.
+ */
+import { StellarisClient } from "./stellar.js";
+import { AuditSink, AttestationAuditLog } from "./audit.js";
+import { AttestationReceipt, ProofBundle, ProvingArtifacts, ReserveSnapshot } from "./domain.js";
+import { PolicyReport, SnapshotPolicy } from "./policy.js";
+import { TransactionSigner } from "./transport.js";
+export interface AttestationPipelineOptions {
+    readonly client: StellarisClient;
+    readonly artifacts: ProvingArtifacts;
+    readonly signer: TransactionSigner;
+    readonly policy?: SnapshotPolicy;
+    readonly auditSink?: AuditSink;
+    readonly requireLocalVerification?: boolean;
+}
+export interface AttestationPipelineResult {
+    readonly proof: ProofBundle;
+    readonly policyReport: PolicyReport;
+    readonly receipt: AttestationReceipt;
+    readonly auditLog: AttestationAuditLog;
+}
+export declare class AttestationPipeline {
+    private readonly client;
+    private readonly artifacts;
+    private readonly signer;
+    private readonly policy?;
+    private readonly auditSink;
+    private readonly requireLocalVerification;
+    constructor(options: AttestationPipelineOptions);
+    run(snapshot: ReserveSnapshot): Promise<AttestationPipelineResult>;
+}
+export declare function createAttestationPipeline(options: AttestationPipelineOptions): AttestationPipeline;