@supercuts-walrus/backend 0.0.0-stage → 0.1.0

package/dist/hosted-seller-repository.js

@@ -0,0 +1,214 @@
+import { createCipheriv, createDecipheriv, createHash, randomBytes } from "node:crypto";
+import { DatabaseSync } from "node:sqlite";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { Pool } from "pg";
+import { fail } from "./errors.js";
+const hash = (bytes) => createHash("sha256").update(bytes).digest("hex");
+function keyBytes(encoded) {
+    const key = Buffer.from(encoded, "base64url");
+    if (key.length !== 32)
+        fail("SELLER_STATE_KEY_INVALID", "seller wrapping key must contain 32 bytes");
+    return key;
+}
+function seal(key, aad, bytes) {
+    const nonce = randomBytes(12), cipher = createCipheriv("aes-256-gcm", key, nonce);
+    cipher.setAAD(Buffer.from(aad));
+    const ciphertext = Buffer.concat([cipher.update(bytes), cipher.final()]);
+    return { nonce: nonce.toString("base64url"), tag: cipher.getAuthTag().toString("base64url"), ciphertext: ciphertext.toString("base64url") };
+}
+function open(key, aad, value) {
+    try {
+        const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(value.nonce, "base64url"));
+        decipher.setAAD(Buffer.from(aad));
+        decipher.setAuthTag(Buffer.from(value.tag, "base64url"));
+        return Buffer.concat([decipher.update(Buffer.from(value.ciphertext, "base64url")), decipher.final()]);
+    }
+    catch (error) {
+        return fail("SELLER_STATE_DECRYPT_FAILED", "hosted seller row could not be authenticated", error);
+    }
+}
+const encodeRow = (row) => Buffer.from(JSON.stringify(Object.fromEntries(Object.entries(row).map(([key, value]) => [key, value instanceof Uint8Array ? { __sellerBytes: Buffer.from(value).toString("base64url") } : value]))));
+const decodeRow = (bytes) => JSON.parse(bytes.toString(), (_key, value) => value && typeof value === "object" && !Array.isArray(value) && "__sellerBytes" in value
+    ? Buffer.from(String(value.__sellerBytes), "base64url") : value);
+/** Direct Postgres connection used only by owner-side migration and seller processes. */
+export class HostedSellerRepository {
+    wrappingKey;
+    #pool;
+    constructor(connectionString, wrappingKey) {
+        this.wrappingKey = wrappingKey;
+        const url = new URL(connectionString);
+        if (!["postgres:", "postgresql:"].includes(url.protocol) || !url.hostname || !url.username || !url.password || url.searchParams.get("sslmode") === "disable" || url.searchParams.get("sslmode") === "no-verify")
+            fail("SELLER_DB_INVALID", "SUPABASE_DB_URL must be a credentialed Postgres URL with verified TLS");
+        // Use parsed fields so URL options cannot override the TLS policy.
+        this.#pool = new Pool({ host: url.hostname, port: url.port ? Number(url.port) : 5432,
+            user: decodeURIComponent(url.username), password: decodeURIComponent(url.password),
+            database: decodeURIComponent(url.pathname.slice(1)), ssl: { rejectUnauthorized: true }, max: 4 });
+        keyBytes(wrappingKey);
+    }
+    async close() { await this.#pool.end(); }
+    async verifyLegacyCollections(catalog, claims) {
+        const remoteCatalog = await this.#pool.query("SELECT capability_id,seller_id,blob_id,signature,transport_public_key FROM public.seller_catalog ORDER BY capability_id");
+        const reduced = catalog.map((row) => ({ capability_id: row.capability_id, seller_id: row.seller_id, blob_id: row.blob_id, signature: row.signature, transport_public_key: row.transport_public_key }));
+        if (JSON.stringify(remoteCatalog.rows) !== JSON.stringify(reduced))
+            fail("SELLER_IMPORT_MISMATCH", "direct Postgres catalog differs from snapshot source");
+        const remoteClaims = await this.#pool.query("SELECT digest,request_id,seller_id FROM public.seller_payment_claims ORDER BY digest");
+        if (JSON.stringify(remoteClaims.rows) !== JSON.stringify(claims))
+            fail("SELLER_IMPORT_MISMATCH", "direct Postgres payment claims differ from snapshot source");
+    }
+    /** Durable intent; the caller performs the network action after this returns. */
+    async claimOperation(sellerId, operationId, action, inputHash) {
+        if (!/^[a-zA-Z0-9._:-]{1,128}$/.test(operationId) || !/^[0-9a-f]{64}$/.test(inputHash) || !action)
+            fail("SELLER_REQUEST_INVALID", "operation identity is invalid");
+        const result = await this.#pool.query("INSERT INTO public.seller_operation_intents(seller_id,operation_id,action,input_hash,status) VALUES($1,$2,$3,$4,'prepared') ON CONFLICT(seller_id,operation_id) DO UPDATE SET updated_at=seller_operation_intents.updated_at RETURNING action,input_hash,status", [sellerId, operationId, action, inputHash]);
+        const row = result.rows[0];
+        if (row.action !== action || row.input_hash !== inputHash)
+            fail("OPERATION_ID_CONFLICT", "operation ID already identifies another seller action");
+        return row.status;
+    }
+    async transitionOperation(sellerId, operationId, status, evidenceHash) {
+        if (evidenceHash !== undefined && !/^[0-9a-f]{64}$/.test(evidenceHash))
+            fail("SELLER_REQUEST_INVALID", "operation evidence hash is invalid");
+        if (status === "confirmed" && !evidenceHash)
+            fail("SELLER_REQUEST_INVALID", "confirmed operation needs finalized evidence");
+        const client = await this.#pool.connect();
+        try {
+            await client.query("BEGIN");
+            const result = await client.query("SELECT status,evidence_hash FROM public.seller_operation_intents WHERE seller_id=$1 AND operation_id=$2 FOR UPDATE", [sellerId, operationId]);
+            const row = result.rows[0] ?? fail("OPERATION_NOT_FOUND", "seller operation intent is missing");
+            if (row.status === "confirmed" && (status !== "confirmed" || row.evidence_hash !== evidenceHash))
+                fail("OPERATION_DIGEST_CONFLICT", "confirmed operation evidence cannot change");
+            if (row.status !== "confirmed")
+                await client.query("UPDATE public.seller_operation_intents SET status=$3,evidence_hash=$4,updated_at=now() WHERE seller_id=$1 AND operation_id=$2", [sellerId, operationId, status, evidenceHash ?? null]);
+            await client.query("COMMIT");
+        }
+        catch (error) {
+            await client.query("ROLLBACK");
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    /** Payment digest and request ID are both unique across all hosted sellers. */
+    async claimPayment(digest, requestId, sellerId) {
+        const client = await this.#pool.connect();
+        try {
+            await client.query("BEGIN");
+            const result = await client.query("INSERT INTO public.seller_payment_claims(digest,request_id,seller_id) VALUES($1,$2,$3) ON CONFLICT DO NOTHING RETURNING digest,request_id,seller_id", [digest, requestId, sellerId]);
+            if (!result.rows.length) {
+                const existing = await client.query("SELECT digest,request_id,seller_id FROM public.seller_payment_claims WHERE digest=$1 OR request_id=$2", [digest, requestId]);
+                if (existing.rows.length !== 1 || existing.rows[0].digest !== digest || existing.rows[0].request_id !== requestId || existing.rows[0].seller_id !== sellerId)
+                    fail("PAYMENT_CONSUMED", "payment digest or request ID is already claimed");
+            }
+            await client.query("COMMIT");
+        }
+        catch (error) {
+            await client.query("ROLLBACK");
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    /** Import is one transaction. Replays must match the original source exactly. */
+    async importSnapshot(snapshot, sourceRevision) {
+        if (snapshot.version !== 1 || !/^0x[0-9a-f]{64}$/i.test(snapshot.sellerId))
+            fail("SELLER_STATE_INVALID", "seller snapshot identity is invalid");
+        const sellerId = snapshot.sellerId, wrapping = keyBytes(this.wrappingKey);
+        const stateKey = Buffer.from(snapshot.files["state.key"], "base64url");
+        if (stateKey.length !== 32)
+            fail("SELLER_STATE_KEY_INVALID", "imported role key must contain 32 bytes");
+        const profile = Buffer.from(snapshot.files["profile.json"], "base64url"), mandate = Buffer.from(snapshot.files["mandate.json"], "base64url");
+        const sourceHash = hash(Buffer.from(JSON.stringify(snapshot)));
+        const temporary = mkdtempSync(join(tmpdir(), "supercuts-seller-import-"));
+        const sqlitePath = join(temporary, "state.sqlite");
+        writeFileSync(sqlitePath, Buffer.from(snapshot.files["state.sqlite"], "base64url"), { mode: 0o600, flag: "wx" });
+        const sqlite = new DatabaseSync(sqlitePath, { readOnly: true });
+        let records = [];
+        try {
+            // The owner-only temporary file is removed before any database connection.
+            const tables = sqlite.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%' ORDER BY name").all();
+            for (const { name } of tables) {
+                const columns = sqlite.prepare(`PRAGMA table_info("${name.replaceAll('"', '""')}")`).all();
+                const pk = columns.filter((column) => column.pk).sort((a, b) => a.pk - b.pk);
+                const rows = sqlite.prepare(`SELECT * FROM "${name.replaceAll('"', '""')}" ORDER BY rowid`).all();
+                for (let index = 0; index < rows.length; index++) {
+                    const row = rows[index], bytes = encodeRow(row), recordId = pk.length ? JSON.stringify(pk.map((column) => row[column.name])) : `row:${index}`;
+                    records.push({ kind: name, recordId, plaintextHash: hash(bytes), ciphertext: seal(wrapping, `seller:${sellerId}:row:${name}:${recordId}`, bytes) });
+                }
+            }
+        }
+        finally {
+            sqlite.close();
+            rmSync(temporary, { recursive: true, force: true });
+        }
+        records = records.sort((a, b) => a.kind.localeCompare(b.kind) || a.recordId.localeCompare(b.recordId));
+        const artifacts = Object.entries(snapshot.artifacts).sort(([a], [b]) => a.localeCompare(b)).map(([artifactKey, encoded]) => {
+            const bytes = Buffer.from(encoded, "base64url");
+            return { artifactKey, plaintextHash: hash(bytes), ciphertext: seal(wrapping, `seller:${sellerId}:artifact:${artifactKey}`, bytes) };
+        });
+        const client = await this.#pool.connect();
+        try {
+            await client.query("BEGIN");
+            const current = await client.query("SELECT source_hash,source_revision FROM public.seller_roles WHERE seller_id=$1 FOR UPDATE", [sellerId]);
+            if (current.rows.length) {
+                if (current.rows[0].source_hash !== sourceHash || Number(current.rows[0].source_revision) !== sourceRevision)
+                    fail("SELLER_STATE_CONFLICT", "import source differs from the existing seller rows");
+            }
+            else {
+                await client.query("INSERT INTO public.seller_roles(seller_id,profile_ciphertext,mandate_ciphertext,wrapped_state_key,source_revision,source_hash) VALUES($1,$2,$3,$4,$5,$6)", [sellerId, seal(wrapping, `seller:${sellerId}:profile`, profile), seal(wrapping, `seller:${sellerId}:mandate`, mandate), seal(wrapping, `seller:${sellerId}:state-key`, stateKey), sourceRevision, sourceHash]);
+            }
+            await this.insertRecords(client, sellerId, records, artifacts);
+            const count = await client.query("SELECT (SELECT count(*) FROM public.seller_records WHERE seller_id=$1)::text AS records,(SELECT count(*) FROM public.seller_artifacts WHERE seller_id=$1)::text AS artifacts", [sellerId]);
+            if (Number(count.rows[0]?.records) !== records.length || Number(count.rows[0]?.artifacts) !== artifacts.length)
+                fail("SELLER_IMPORT_MISMATCH", "Postgres row count differs from snapshot");
+            await client.query("COMMIT");
+            return { records: records.length, artifacts: artifacts.length, sourceHash };
+        }
+        catch (error) {
+            await client.query("ROLLBACK");
+            throw error;
+        }
+        finally {
+            client.release();
+        }
+    }
+    async insertRecords(client, sellerId, records, artifacts) {
+        for (const row of records) {
+            const result = await client.query("INSERT INTO public.seller_records(seller_id,kind,record_id,plaintext_hash,ciphertext) VALUES($1,$2,$3,$4,$5) ON CONFLICT(seller_id,kind,record_id) DO UPDATE SET plaintext_hash=seller_records.plaintext_hash RETURNING plaintext_hash", [sellerId, row.kind, row.recordId, row.plaintextHash, row.ciphertext]);
+            if (result.rows[0]?.plaintext_hash !== row.plaintextHash)
+                fail("SELLER_IMPORT_MISMATCH", "existing seller row differs from snapshot");
+        }
+        for (const row of artifacts) {
+            const result = await client.query("INSERT INTO public.seller_artifacts(seller_id,artifact_key,plaintext_hash,ciphertext) VALUES($1,$2,$3,$4) ON CONFLICT(seller_id,artifact_key) DO UPDATE SET plaintext_hash=seller_artifacts.plaintext_hash RETURNING plaintext_hash", [sellerId, row.artifactKey, row.plaintextHash, row.ciphertext]);
+            if (result.rows[0]?.plaintext_hash !== row.plaintextHash)
+                fail("SELLER_IMPORT_MISMATCH", "existing seller artifact differs from snapshot");
+        }
+    }
+    /** Readback authenticates every encrypted row and returns only safe counts. */
+    async verifyImport(sellerId) {
+        const wrapping = keyBytes(this.wrappingKey);
+        const role = await this.#pool.query("SELECT source_hash,profile_ciphertext,mandate_ciphertext,wrapped_state_key FROM public.seller_roles WHERE seller_id=$1", [sellerId]);
+        if (role.rows.length !== 1)
+            fail("SELLER_STATE_MISSING", "seller role was not imported");
+        const value = role.rows[0];
+        for (const [kind, envelope] of [["profile", value.profile_ciphertext], ["mandate", value.mandate_ciphertext], ["state-key", value.wrapped_state_key]])
+            open(wrapping, `seller:${sellerId}:${kind}`, envelope);
+        const rows = await this.#pool.query("SELECT kind,record_id,plaintext_hash,ciphertext FROM public.seller_records WHERE seller_id=$1", [sellerId]);
+        const counts = {};
+        for (const row of rows.rows) {
+            const bytes = open(wrapping, `seller:${sellerId}:row:${row.kind}:${row.record_id}`, row.ciphertext);
+            if (hash(bytes) !== row.plaintext_hash)
+                fail("SELLER_IMPORT_MISMATCH", "seller row hash differs after readback");
+            decodeRow(bytes);
+            counts[row.kind] = (counts[row.kind] ?? 0) + 1;
+        }
+        const artifacts = await this.#pool.query("SELECT artifact_key,plaintext_hash,ciphertext FROM public.seller_artifacts WHERE seller_id=$1", [sellerId]);
+        for (const row of artifacts.rows)
+            if (hash(open(wrapping, `seller:${sellerId}:artifact:${row.artifact_key}`, row.ciphertext)) !== row.plaintext_hash)
+                fail("SELLER_IMPORT_MISMATCH", "seller artifact hash differs after readback");
+        return { sourceHash: value.source_hash, records: counts, artifacts: artifacts.rows.length };
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+export * from "./config.js";
+export * from "./deal.js";
+export * from "./deal-engine.js";
+export * from "./deal-adapter.js";
+export * from "./capability.js";
+export * from "./claude.js";
+export * from "./events.js";
+export * from "./dashboard.js";
+export * from "./mandate.js";
+export * from "./procurement.js";
+export * from "./audit.js";
+export * from "./backend.js";
+export * from "./errors.js";
+export * from "./indexer.js";
+export * from "./memory.js";
+export * from "./settlement.js";
+export * from "./seller-runtime.js";
+export * from "./seller-stdio.js";
+export * from "./live-index.js";
+export * from "./live-runtime.js";
+export * from "./protocol-engine.js";
+export * from "./prover.js";
+export * from "./phase3.js";
+export * from "./memwal.js";
+export * from "./negotiation.js";
+export * from "./notes.js";
+export * from "./resource.js";
+export * from "./relayer.js";
+export * from "./store.js";
+export * from "./sui.js";
+export * from "./tatum.js";
+export * from "./transcript.js";
+export * from "./x402.js";
+export * from "./x402-resource-service.js";
+export * from "./facilitator.js";
+export * from "./wallet.js";
+export * from "./workflow-memory.js";

package/dist/index.js

@@ -0,0 +1,37 @@
+export * from "./config.js";
+export * from "./deal.js";
+export * from "./deal-engine.js";
+export * from "./deal-adapter.js";
+export * from "./capability.js";
+export * from "./claude.js";
+export * from "./events.js";
+export * from "./dashboard.js";
+export * from "./mandate.js";
+export * from "./procurement.js";
+export * from "./audit.js";
+export * from "./backend.js";
+export * from "./errors.js";
+export * from "./indexer.js";
+export * from "./memory.js";
+export * from "./settlement.js";
+export * from "./seller-runtime.js";
+export * from "./seller-stdio.js";
+export * from "./live-index.js";
+export * from "./live-runtime.js";
+export * from "./protocol-engine.js";
+export * from "./prover.js";
+export * from "./phase3.js";
+export * from "./memwal.js";
+export * from "./negotiation.js";
+export * from "./notes.js";
+export * from "./resource.js";
+export * from "./relayer.js";
+export * from "./store.js";
+export * from "./sui.js";
+export * from "./tatum.js";
+export * from "./transcript.js";
+export * from "./x402.js";
+export * from "./x402-resource-service.js";
+export * from "./facilitator.js";
+export * from "./wallet.js";
+export * from "./workflow-memory.js";

package/dist/indexer.d.ts

@@ -0,0 +1,63 @@
+export type PoolEvent = {
+    kind: "deposit";
+    checkpoint: bigint;
+    transactionIndex: bigint;
+    eventIndex: number;
+    oldRoot: string;
+    newRoot: string;
+    leafIndex: bigint;
+    noteCommitment: string;
+} | {
+    kind: "transfer";
+    checkpoint: bigint;
+    transactionIndex: bigint;
+    eventIndex: number;
+    oldRoot: string;
+    newRoot: string;
+    firstLeafIndex: bigint;
+    paymentCommitment: string;
+    changeCommitment: string;
+    dealNullifier: string;
+    inputNullifier: string;
+} | {
+    kind: "withdraw";
+    checkpoint: bigint;
+    transactionIndex: bigint;
+    eventIndex: number;
+    root: string;
+    noteNullifier: string;
+    recipient: string;
+    amount: bigint;
+} | {
+    kind: "withdraw_v2";
+    checkpoint: bigint;
+    transactionIndex: bigint;
+    eventIndex: number;
+    oldRoot: string;
+    newRoot: string;
+    leafIndex: bigint;
+    noteNullifier: string;
+    changeCommitment: string;
+    recipient: string;
+    amount: bigint;
+    exactExit: boolean;
+};
+export interface PoolIndex {
+    root: string;
+    nextLeaf: bigint;
+    spent: Set<string>;
+    deals: Set<string>;
+    checkpoint: bigint;
+    acceptedRoots: Set<string>;
+    lastPosition?: {
+        checkpoint: bigint;
+        transactionIndex: bigint;
+        eventIndex: number;
+    };
+}
+export declare function createPoolIndex(root: string, checkpoint: bigint): PoolIndex;
+export declare function applyPoolEvent(index: PoolIndex, event: PoolEvent): void;
+export declare function assertPoolState(index: PoolIndex, state: {
+    root: string;
+    nextLeaf: bigint;
+}): void;

package/dist/indexer.js

@@ -0,0 +1,60 @@
+import { fail } from "./errors.js";
+export function createPoolIndex(root, checkpoint) { return { root, nextLeaf: 0n, spent: new Set(), deals: new Set(), acceptedRoots: new Set([root]), checkpoint }; }
+function assertEventOrder(index, event) {
+    if (event.checkpoint < index.checkpoint || event.transactionIndex < 0n || !Number.isSafeInteger(event.eventIndex) || event.eventIndex < 0)
+        fail("CHAIN_ORDER_INVALID", "event position is invalid or precedes the deployment anchor");
+    const previous = index.lastPosition;
+    if (previous) {
+        const ordered = event.checkpoint > previous.checkpoint
+            || (event.checkpoint === previous.checkpoint && event.transactionIndex > previous.transactionIndex)
+            || (event.checkpoint === previous.checkpoint && event.transactionIndex === previous.transactionIndex && event.eventIndex > previous.eventIndex);
+        if (!ordered)
+            fail("CHAIN_ORDER_INVALID", "event positions must be unique and strictly increasing");
+    }
+}
+export function applyPoolEvent(index, event) {
+    assertEventOrder(index, event);
+    if (event.kind === "deposit") {
+        if (event.oldRoot !== index.root || event.leafIndex !== index.nextLeaf)
+            fail("POOL_TRANSITION_INVALID", "deposit root or leaf index does not match index");
+        index.root = event.newRoot;
+        index.acceptedRoots.add(event.newRoot);
+        index.nextLeaf += 1n;
+    }
+    else if (event.kind === "transfer") {
+        if (event.oldRoot !== index.root || event.firstLeafIndex !== index.nextLeaf)
+            fail("POOL_TRANSITION_INVALID", "transfer root or leaf index does not match index");
+        if (index.spent.has(event.inputNullifier) || index.deals.has(event.dealNullifier))
+            fail("POOL_REPLAY", "pool event reuses a consumed identity");
+        index.root = event.newRoot;
+        index.acceptedRoots.add(event.newRoot);
+        index.nextLeaf += 2n;
+        index.spent.add(event.inputNullifier);
+        index.deals.add(event.dealNullifier);
+    }
+    else if (event.kind === "withdraw_v2") {
+        if (event.oldRoot !== index.root || event.leafIndex !== index.nextLeaf)
+            fail("POOL_TRANSITION_INVALID", "v2 exit root or leaf index does not match index");
+        if (index.spent.has(event.noteNullifier))
+            fail("POOL_REPLAY", "v2 exit reuses a spent nullifier");
+        if (!event.exactExit && event.amount !== 1000000n)
+            fail("POOL_TRANSITION_INVALID", "v2 standard exit amount is invalid");
+        index.root = event.newRoot;
+        index.acceptedRoots.add(event.newRoot);
+        index.nextLeaf += 1n;
+        index.spent.add(event.noteNullifier);
+    }
+    else {
+        if (!index.acceptedRoots.has(event.root))
+            fail("POOL_TRANSITION_INVALID", "withdrawal references a root that was never accepted");
+        if (index.spent.has(event.noteNullifier))
+            fail("POOL_REPLAY", "withdrawal reuses a spent nullifier");
+        index.spent.add(event.noteNullifier);
+    }
+    index.checkpoint = event.checkpoint;
+    index.lastPosition = { checkpoint: event.checkpoint, transactionIndex: event.transactionIndex, eventIndex: event.eventIndex };
+}
+export function assertPoolState(index, state) {
+    if (index.root !== state.root || index.nextLeaf !== state.nextLeaf)
+        fail("POOL_STATE_MISMATCH", "event-derived tree does not match the pool object");
+}

package/dist/live-deal-ports.d.ts

@@ -0,0 +1,41 @@
+import { type SignedCapabilityRegistration } from "./capability.js";
+import type { DealArtifact, DealNegotiation, DealPayment, DealPorts } from "./deal-engine.js";
+import type { ExecuteDealInput } from "./deal.js";
+import { type AgentMandate } from "./mandate.js";
+import type { Phase3App } from "./phase3.js";
+import { type SettlementPlanV1 } from "./settlement.js";
+type LiveNegotiation = DealNegotiation & {
+    sessionId: string;
+    agreementHash: string;
+    agreedAmount: string;
+    resourceUrl?: string;
+    sellerOrigin: string;
+    sellerTransportPublicKey: string;
+};
+/** Built-in live buyer adapter. The owner supplies only seller catalog origins;
+ * signing, payment, Walrus and memory stay in the buyer role home. */
+export declare class LiveDealPorts implements DealPorts {
+    #private;
+    private readonly app;
+    private readonly mandate;
+    private readonly http;
+    constructor(app: Phase3App, mandate: AgentMandate, http?: typeof fetch);
+    readBlob(blobId: string): Promise<Uint8Array>;
+    private signer;
+    private request;
+    catalog(): Promise<Array<{
+        origin: string;
+        registration: SignedCapabilityRegistration;
+    }>>;
+    discover(input: ExecuteDealInput): Promise<SignedCapabilityRegistration>;
+    plan(input: ExecuteDealInput, registration: SignedCapabilityRegistration, paymentOperationId: string): Promise<SettlementPlanV1>;
+    negotiate(input: ExecuteDealInput, registration: SignedCapabilityRegistration, plan: SettlementPlanV1, agreementOperationId: string): Promise<LiveNegotiation>;
+    pay(input: ExecuteDealInput, plan: SettlementPlanV1, negotiation: DealNegotiation, paymentOperationId: string): Promise<DealPayment>;
+    deliver(input: ExecuteDealInput, plan: SettlementPlanV1, negotiation: DealNegotiation, payment: DealPayment, _deliveryOperationId: string): Promise<DealArtifact>;
+    rememberOutcome(input: ExecuteDealInput, plan: SettlementPlanV1, payment: DealPayment, artifact: DealArtifact, _outcomeOperationId: string): Promise<{
+        queued: true;
+        payloadHash: string;
+    }>;
+    inventory(blobId: string): Promise<boolean>;
+}
+export {};