@forum-labs/payfetch 1.0.0

package/dist/src/payer/types.d.ts

@@ -0,0 +1,99 @@
+import type { SupportedNetwork } from "../core/constants.js";
+export type Rail = "x402" | "mpp";
+export type Eip712TypedData = {
+    domain: {
+        name?: string;
+        version?: string;
+        chainId?: number;
+        verifyingContract?: `0x${string}`;
+        salt?: `0x${string}`;
+    };
+    types: Record<string, ReadonlyArray<{
+        name: string;
+        type: string;
+    }>>;
+    primaryType: string;
+    message: Record<string, unknown>;
+};
+export interface WalletSigner {
+    kind: "local_key" | "cdp_server_wallet";
+    address(): Promise<string>;
+    signTypedData(td: Eip712TypedData): Promise<`0x${string}`>;
+}
+export type X402Terms = {
+    scheme: string;
+    network: string;
+    asset: string | null;
+    amountAtomic: string | null;
+    amountUsd: number | null;
+    payTo: string | null;
+    maxTimeoutSeconds: number | null;
+    mimeType: string | null;
+    hasOutputSchema: boolean;
+    outputSchemaSha256: string | null;
+    networkAsDeclared: string;
+    resource: string | null;
+    rawAccepts: unknown;
+};
+export type ParsedChallenge = {
+    rail: Rail | null;
+    x402Version: number | null;
+    terms: X402Terms[];
+    termsHash: string | null;
+    malformed: boolean;
+};
+export type PaymentQuote = {
+    rail: Rail;
+    scheme: "exact";
+    network: SupportedNetwork;
+    asset: string;
+    amountAtomic: string;
+    amountUsd: number;
+    payTo: string;
+    maxTimeoutSeconds: number | null;
+    resource: string | null;
+    mimeType: string | null;
+    outputSchemaSha256: string | null;
+    rawAccepts: unknown;
+    x402Version: number;
+    networkAsDeclared: string;
+};
+export type PaymentProof = {
+    headers: Record<string, string>;
+    validBeforeTs: number;
+    nonce: string;
+};
+export interface PaymentPayer {
+    rail: Rail;
+    detects(challenge: ParsedChallenge): boolean;
+    quotes(challenge: ParsedChallenge): PaymentQuote[];
+    buildPayment(quote: PaymentQuote, signer: WalletSigner, deps: PayfetchDeps): Promise<PaymentProof>;
+}
+export type ElicitRequest = {
+    host: string;
+    resource: string | null;
+    amountUsd: number;
+    networkLabel: string;
+    assetLabel: string;
+    guards: unknown[];
+    remainingBudgets: unknown;
+};
+export type ElicitDecision = {
+    approved: boolean;
+    cancelled?: boolean;
+};
+export type ElicitFn = (request: ElicitRequest) => Promise<ElicitDecision>;
+export type PayfetchDeps = {
+    fetch: typeof fetch;
+    signer: WalletSigner;
+    now: () => number;
+    random: () => Uint8Array;
+    dataDir: string;
+    log: (msg: string, fields?: Record<string, unknown>) => void;
+    elicit: ElicitFn | null;
+};
+export declare class UnsupportedRailError extends Error {
+    readonly rail: Rail;
+    readonly method: string;
+    constructor(rail: Rail, method: string);
+}

package/dist/src/payer/types.js

@@ -0,0 +1,10 @@
+export class UnsupportedRailError extends Error {
+    rail;
+    method;
+    constructor(rail, method) {
+        super(`Rail "${rail}" does not support ${method}() in v1 (SPEC §2 stub).`);
+        this.name = "UnsupportedRailError";
+        this.rail = rail;
+        this.method = method;
+    }
+}

package/dist/src/payer/x402.d.ts

@@ -0,0 +1,23 @@
+import type { Eip712TypedData, ParsedChallenge, PayfetchDeps, PaymentPayer, PaymentProof, PaymentQuote, WalletSigner } from "./types.js";
+export declare const AUTHORIZATION_TYPES: Eip712TypedData["types"];
+export declare const AUTHORIZATION_PRIMARY_TYPE = "TransferWithAuthorization";
+export type QuoteRejections = Record<string, number>;
+export declare function quoteWithRejections(challenge: ParsedChallenge): {
+    quotes: PaymentQuote[];
+    rejected: QuoteRejections;
+};
+export declare function selectQuote(quotes: readonly PaymentQuote[]): PaymentQuote | null;
+export declare function buildX402Payment(quote: PaymentQuote, signer: WalletSigner, deps: PayfetchDeps): Promise<PaymentProof>;
+export type SettlementResponse = {
+    success: boolean;
+    transaction?: string;
+    network?: string;
+    payer?: string;
+};
+export declare function parseSettlementResponse(headerValue: string): SettlementResponse | null;
+export declare class X402Payer implements PaymentPayer {
+    readonly rail: "x402";
+    detects(challenge: ParsedChallenge): boolean;
+    quotes(challenge: ParsedChallenge): PaymentQuote[];
+    buildPayment(quote: PaymentQuote, signer: WalletSigner, deps: PayfetchDeps): Promise<PaymentProof>;
+}

package/dist/src/payer/x402.js

@@ -0,0 +1,165 @@
+import { decodePaymentResponseHeader } from "@x402/core/http";
+import { safeBase64Encode } from "@x402/core/utils";
+import { getAddress, toHex } from "viem";
+import { CLOCK_SKEW_S, NONCE_BYTES, PAYMENT_VALIDITY_DEFAULT_S, PAYMENT_VALIDITY_MAX_S, RAILS_ENABLED, SUPPORTED_NETWORKS, SUPPORTED_SCHEMES, X_PAYMENT_HEADER, chainIdForNetwork, deriveAmountUsd, isKnownAsset, isSupportedX402Version, knownAssetNetwork, } from "../core/constants.js";
+export const AUTHORIZATION_TYPES = Object.freeze({
+    TransferWithAuthorization: [
+        { name: "from", type: "address" },
+        { name: "to", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "validAfter", type: "uint256" },
+        { name: "validBefore", type: "uint256" },
+        { name: "nonce", type: "bytes32" },
+    ],
+});
+export const AUTHORIZATION_PRIMARY_TYPE = "TransferWithAuthorization";
+function rejectReason(term, x402Version) {
+    if (!isSupportedX402Version(x402Version))
+        return "unsupported_x402_version";
+    if (!RAILS_ENABLED.includes("x402"))
+        return "unsupported_rail_x402";
+    if (!SUPPORTED_SCHEMES.includes(term.scheme)) {
+        return `unsupported_scheme_${term.scheme}`;
+    }
+    if (!SUPPORTED_NETWORKS.includes(term.network))
+        return "unsupported_network";
+    if (!isKnownAsset(term.asset))
+        return "unknown_asset";
+    const assetNetwork = knownAssetNetwork(term.asset);
+    if (assetNetwork !== null && assetNetwork !== term.network)
+        return "asset_network_mismatch";
+    if (term.payTo == null || term.payTo.length === 0)
+        return "missing_pay_to";
+    if (term.amountAtomic == null || !/^\d+$/.test(term.amountAtomic))
+        return "non_integer_amount";
+    return null;
+}
+function toQuote(term, x402Version) {
+    const asset = term.asset.toLowerCase();
+    const amountAtomic = term.amountAtomic;
+    const amountUsd = term.amountUsd ?? deriveAmountUsd(amountAtomic, asset) ?? 0;
+    return {
+        rail: "x402",
+        scheme: "exact",
+        network: term.network,
+        asset,
+        amountAtomic,
+        amountUsd,
+        payTo: term.payTo,
+        maxTimeoutSeconds: term.maxTimeoutSeconds,
+        resource: term.resource,
+        mimeType: term.mimeType,
+        outputSchemaSha256: term.outputSchemaSha256,
+        rawAccepts: term.rawAccepts,
+        x402Version,
+        networkAsDeclared: term.networkAsDeclared,
+    };
+}
+export function quoteWithRejections(challenge) {
+    const quotes = [];
+    const rejected = {};
+    for (const term of challenge.terms) {
+        const reason = rejectReason(term, challenge.x402Version);
+        if (reason !== null) {
+            rejected[reason] = (rejected[reason] ?? 0) + 1;
+            continue;
+        }
+        quotes.push(toQuote(term, challenge.x402Version));
+    }
+    return { quotes, rejected };
+}
+export function selectQuote(quotes) {
+    let best = null;
+    for (const q of quotes) {
+        if (best === null || q.amountUsd < best.amountUsd)
+            best = q;
+    }
+    return best;
+}
+function extractExtra(rawAccepts) {
+    if (rawAccepts == null || typeof rawAccepts !== "object")
+        return {};
+    const extra = rawAccepts.extra;
+    if (extra == null || typeof extra !== "object")
+        return {};
+    const e = extra;
+    return {
+        name: typeof e.name === "string" ? e.name : undefined,
+        version: typeof e.version === "string" ? e.version : undefined,
+    };
+}
+export async function buildX402Payment(quote, signer, deps) {
+    const nowSec = Math.floor(deps.now() / 1000);
+    const validAfter = nowSec - CLOCK_SKEW_S;
+    const timeoutS = Math.min(quote.maxTimeoutSeconds ?? PAYMENT_VALIDITY_DEFAULT_S, PAYMENT_VALIDITY_MAX_S);
+    const validBefore = nowSec + timeoutS;
+    const nonceBytes = deps.random();
+    if (nonceBytes.length !== NONCE_BYTES) {
+        throw new Error(`deps.random() must return ${NONCE_BYTES} bytes for the EIP-3009 nonce; got ${nonceBytes.length}`);
+    }
+    const nonceHex = toHex(nonceBytes);
+    const from = getAddress(await signer.address());
+    const to = getAddress(quote.payTo);
+    const verifyingContract = getAddress(quote.asset);
+    const { name, version } = extractExtra(quote.rawAccepts);
+    const chainId = chainIdForNetwork(quote.network);
+    if (chainId === null) {
+        throw new Error(`no EVM chainId for network "${quote.network}"`);
+    }
+    const authorization = {
+        from,
+        to,
+        value: quote.amountAtomic,
+        validAfter: String(validAfter),
+        validBefore: String(validBefore),
+        nonce: nonceHex,
+    };
+    const typedData = {
+        types: AUTHORIZATION_TYPES,
+        domain: { name, version, chainId, verifyingContract },
+        primaryType: AUTHORIZATION_PRIMARY_TYPE,
+        message: { ...authorization },
+    };
+    const signature = await signer.signTypedData(typedData);
+    const payment = quote.x402Version === 1
+        ? {
+            x402Version: 1,
+            scheme: quote.scheme,
+            network: quote.networkAsDeclared,
+            payload: { signature, authorization },
+        }
+        : {
+            x402Version: quote.x402Version,
+            accepted: quote.rawAccepts,
+            payload: { signature, authorization },
+        };
+    const header = safeBase64Encode(JSON.stringify(payment));
+    return {
+        headers: { [X_PAYMENT_HEADER]: header },
+        validBeforeTs: validBefore,
+        nonce: nonceHex,
+    };
+}
+export function parseSettlementResponse(headerValue) {
+    try {
+        const decoded = decodePaymentResponseHeader(headerValue);
+        if (decoded == null || typeof decoded !== "object")
+            return null;
+        return decoded;
+    }
+    catch {
+        return null;
+    }
+}
+export class X402Payer {
+    rail = "x402";
+    detects(challenge) {
+        return challenge.rail === "x402";
+    }
+    quotes(challenge) {
+        return quoteWithRejections(challenge).quotes;
+    }
+    buildPayment(quote, signer, deps) {
+        return buildX402Payment(quote, signer, deps);
+    }
+}

package/dist/src/report/report.d.ts

@@ -0,0 +1,162 @@
+import type { Eip712TypedData, WalletSigner } from "../payer/types.js";
+import type { Receipt } from "../core/ledger.js";
+export declare const OUTCOME_REPORT_SCHEMA_ID: "p3f.outcome-report.v1";
+export declare const REPORT_CLASSES_V1: readonly ["paid_not_delivered", "paid_delivered"];
+export type ReportClass = (typeof REPORT_CLASSES_V1)[number];
+export declare const AMOUNT_BANDS: readonly ["lt_0.01", "0.01_0.10", "0.10_1", "gte_1"];
+export type AmountBand = (typeof AMOUNT_BANDS)[number];
+export declare const HTTP_STATUS_CLASSES: readonly ["2xx", "3xx", "4xx", "5xx"];
+export type HttpStatusClass = (typeof HTTP_STATUS_CLASSES)[number];
+export type ReportChecks = {
+    settlementConfirmed: boolean;
+    httpStatusClass: HttpStatusClass | null;
+    contentTypeOk: boolean | null;
+    nonEmpty: boolean;
+};
+export type OutcomeReport = {
+    schema: typeof OUTCOME_REPORT_SCHEMA_ID;
+    endpoint: {
+        method: string;
+        url: string;
+    };
+    outcome: ReportClass;
+    checks: ReportChecks;
+    termsHash: string;
+    payTo: string | null;
+    amountBand: AmountBand;
+    utcDay: string;
+    test: boolean;
+    clientVersion: string;
+    payer: string;
+    sig: string;
+    anchor?: {
+        kind: "tx";
+        txRef: string;
+        network: string;
+    };
+};
+export declare class NotReportableError extends Error {
+    readonly outcome: string;
+    constructor(outcome: string);
+}
+export declare function amountBandFor(usd: number): AmountBand;
+export declare function httpStatusClassOf(status: number | null | undefined): HttpStatusClass | null;
+export declare function stripQuery(rawUrl: string): string;
+export declare function buildReportFromReceipt(receipt: Receipt): Omit<OutcomeReport, "payer" | "sig">;
+export declare const OUTCOME_REPORT_DOMAIN: {
+    readonly name: "Forum Labs Outcome Report";
+    readonly version: "1";
+};
+export declare const OUTCOME_REPORT_TYPES: {
+    readonly OutcomeReport: readonly [{
+        readonly name: "schema";
+        readonly type: "string";
+    }, {
+        readonly name: "endpointMethod";
+        readonly type: "string";
+    }, {
+        readonly name: "endpointUrl";
+        readonly type: "string";
+    }, {
+        readonly name: "outcome";
+        readonly type: "string";
+    }, {
+        readonly name: "settlementConfirmed";
+        readonly type: "bool";
+    }, {
+        readonly name: "httpStatusClass";
+        readonly type: "string";
+    }, {
+        readonly name: "contentTypeOk";
+        readonly type: "string";
+    }, {
+        readonly name: "nonEmpty";
+        readonly type: "bool";
+    }, {
+        readonly name: "termsHash";
+        readonly type: "string";
+    }, {
+        readonly name: "payTo";
+        readonly type: "string";
+    }, {
+        readonly name: "amountBand";
+        readonly type: "string";
+    }, {
+        readonly name: "utcDay";
+        readonly type: "string";
+    }, {
+        readonly name: "test";
+        readonly type: "bool";
+    }, {
+        readonly name: "clientVersion";
+        readonly type: "string";
+    }, {
+        readonly name: "payer";
+        readonly type: "address";
+    }, {
+        readonly name: "anchorKind";
+        readonly type: "string";
+    }, {
+        readonly name: "anchorNetwork";
+        readonly type: "string";
+    }, {
+        readonly name: "anchorTxRef";
+        readonly type: "string";
+    }];
+};
+export type OutcomeReportSignedMessage = {
+    schema: string;
+    endpointMethod: string;
+    endpointUrl: string;
+    outcome: string;
+    settlementConfirmed: boolean;
+    httpStatusClass: string;
+    contentTypeOk: string;
+    nonEmpty: boolean;
+    termsHash: string;
+    payTo: string;
+    amountBand: string;
+    utcDay: string;
+    test: boolean;
+    clientVersion: string;
+    payer: `0x${string}`;
+    anchorKind: string;
+    anchorNetwork: string;
+    anchorTxRef: string;
+};
+export declare function outcomeReportMessage(report: Omit<OutcomeReport, "sig">): OutcomeReportSignedMessage;
+export declare function outcomeReportTypedData(report: Omit<OutcomeReport, "sig">): Eip712TypedData;
+export declare function signReport(unsigned: Omit<OutcomeReport, "payer" | "sig">, signer: WalletSigner): Promise<OutcomeReport>;
+export declare const OUTCOME_REPORT_PATH = "/v1/outcomes/report";
+export type SubmitResult = {
+    status: number;
+    ok: boolean;
+    body: unknown;
+};
+export declare function submitReport(report: OutcomeReport, baseUrl: string, fetchImpl: typeof fetch): Promise<SubmitResult>;
+export type RunReportDeps = {
+    readReceipts: () => Receipt[];
+    receiptId: string;
+    signer: WalletSigner;
+    fetchImpl: typeof fetch;
+    baseUrl: string;
+    confirm: () => Promise<boolean>;
+    out: (line: string) => void;
+    err: (line: string) => void;
+};
+export type RunReportOutcome = {
+    kind: "not_found";
+} | {
+    kind: "not_reportable";
+    outcome: string;
+} | {
+    kind: "aborted";
+} | {
+    kind: "submit_failed";
+    status: number;
+} | {
+    kind: "submitted";
+    status: number;
+    report: OutcomeReport;
+};
+export declare function runReport(deps: RunReportDeps): Promise<RunReportOutcome>;

package/dist/src/report/report.js

@@ -0,0 +1,220 @@
+import { hashTerms } from "../payer/parse402.js";
+export const OUTCOME_REPORT_SCHEMA_ID = "p3f.outcome-report.v1";
+export const REPORT_CLASSES_V1 = ["paid_not_delivered", "paid_delivered"];
+export const AMOUNT_BANDS = ["lt_0.01", "0.01_0.10", "0.10_1", "gte_1"];
+export const HTTP_STATUS_CLASSES = ["2xx", "3xx", "4xx", "5xx"];
+export class NotReportableError extends Error {
+    outcome;
+    constructor(outcome) {
+        super(`payfetch: receipt outcome "${outcome}" is not reportable — only settled payment ` +
+            `outcomes (paid_delivered / paid_not_delivered) can be reported in this version.`);
+        this.outcome = outcome;
+        this.name = "NotReportableError";
+    }
+}
+export function amountBandFor(usd) {
+    if (!(usd >= 0.01))
+        return "lt_0.01";
+    if (usd < 0.1)
+        return "0.01_0.10";
+    if (usd < 1)
+        return "0.10_1";
+    return "gte_1";
+}
+export function httpStatusClassOf(status) {
+    if (status == null || !Number.isFinite(status))
+        return null;
+    if (status >= 200 && status < 300)
+        return "2xx";
+    if (status >= 300 && status < 400)
+        return "3xx";
+    if (status >= 400 && status < 500)
+        return "4xx";
+    if (status >= 500 && status < 600)
+        return "5xx";
+    return null;
+}
+export function stripQuery(rawUrl) {
+    let s = rawUrl;
+    const hash = s.indexOf("#");
+    if (hash >= 0)
+        s = s.slice(0, hash);
+    const q = s.indexOf("?");
+    if (q >= 0)
+        s = s.slice(0, q);
+    return s;
+}
+function termsHashFromReceipt(receipt) {
+    const q = receipt.quote;
+    if (q === null)
+        return "";
+    const term = {
+        scheme: q.scheme,
+        network: q.network,
+        asset: q.asset,
+        amountAtomic: q.amountAtomic,
+        amountUsd: q.amountUsd,
+        payTo: q.payTo,
+        maxTimeoutSeconds: q.maxTimeoutSeconds,
+        mimeType: q.mimeType,
+        hasOutputSchema: q.outputSchemaSha256 !== null,
+        outputSchemaSha256: q.outputSchemaSha256,
+        networkAsDeclared: q.networkAsDeclared,
+        resource: q.resource,
+        rawAccepts: q.rawAccepts,
+    };
+    return hashTerms([term]);
+}
+function utcDayOf(ts) {
+    return new Date(ts).toISOString().slice(0, 10);
+}
+const REPORTABLE = new Set(REPORT_CLASSES_V1);
+export function buildReportFromReceipt(receipt) {
+    if (!REPORTABLE.has(receipt.outcome))
+        throw new NotReportableError(receipt.outcome);
+    if (receipt.payment === null)
+        throw new NotReportableError(receipt.outcome);
+    const status = receipt.http?.status ?? null;
+    const advertisedMime = receipt.quote?.mimeType ?? null;
+    const gotType = receipt.http?.contentType ?? null;
+    const contentTypeOk = advertisedMime !== null && gotType !== null
+        ? gotType.toLowerCase().includes(advertisedMime.toLowerCase())
+        : null;
+    const amountUsd = receipt.payment.settledAmountUsd ?? receipt.quote?.amountUsd ?? 0;
+    const report = {
+        schema: OUTCOME_REPORT_SCHEMA_ID,
+        endpoint: { method: receipt.method.toUpperCase(), url: stripQuery(receipt.url) },
+        outcome: receipt.outcome,
+        checks: {
+            settlementConfirmed: receipt.payment.settlementConfirmed,
+            httpStatusClass: httpStatusClassOf(status),
+            contentTypeOk,
+            nonEmpty: (receipt.http?.bodyBytes ?? 0) > 0,
+        },
+        termsHash: termsHashFromReceipt(receipt),
+        payTo: receipt.quote?.payTo ?? null,
+        amountBand: amountBandFor(amountUsd),
+        utcDay: utcDayOf(receipt.ts),
+        test: receipt.test,
+        clientVersion: receipt.clientVersion,
+    };
+    if (receipt.payment.txRef !== null) {
+        report.anchor = { kind: "tx", txRef: receipt.payment.txRef, network: receipt.quote?.network ?? "base" };
+    }
+    return report;
+}
+export const OUTCOME_REPORT_DOMAIN = {
+    name: "Forum Labs Outcome Report",
+    version: "1",
+};
+export const OUTCOME_REPORT_TYPES = {
+    OutcomeReport: [
+        { name: "schema", type: "string" },
+        { name: "endpointMethod", type: "string" },
+        { name: "endpointUrl", type: "string" },
+        { name: "outcome", type: "string" },
+        { name: "settlementConfirmed", type: "bool" },
+        { name: "httpStatusClass", type: "string" },
+        { name: "contentTypeOk", type: "string" },
+        { name: "nonEmpty", type: "bool" },
+        { name: "termsHash", type: "string" },
+        { name: "payTo", type: "string" },
+        { name: "amountBand", type: "string" },
+        { name: "utcDay", type: "string" },
+        { name: "test", type: "bool" },
+        { name: "clientVersion", type: "string" },
+        { name: "payer", type: "address" },
+        { name: "anchorKind", type: "string" },
+        { name: "anchorNetwork", type: "string" },
+        { name: "anchorTxRef", type: "string" },
+    ],
+};
+function triBool(v) {
+    return v === null ? "" : v ? "true" : "false";
+}
+export function outcomeReportMessage(report) {
+    return {
+        schema: report.schema,
+        endpointMethod: report.endpoint.method.toUpperCase(),
+        endpointUrl: report.endpoint.url,
+        outcome: report.outcome,
+        settlementConfirmed: report.checks.settlementConfirmed,
+        httpStatusClass: report.checks.httpStatusClass ?? "",
+        contentTypeOk: triBool(report.checks.contentTypeOk),
+        nonEmpty: report.checks.nonEmpty,
+        termsHash: report.termsHash,
+        payTo: report.payTo ?? "",
+        amountBand: report.amountBand,
+        utcDay: report.utcDay,
+        test: report.test,
+        clientVersion: report.clientVersion,
+        payer: report.payer,
+        anchorKind: report.anchor?.kind ?? "",
+        anchorNetwork: report.anchor?.network ?? "",
+        anchorTxRef: report.anchor?.txRef ?? "",
+    };
+}
+export function outcomeReportTypedData(report) {
+    return {
+        domain: OUTCOME_REPORT_DOMAIN,
+        types: OUTCOME_REPORT_TYPES,
+        primaryType: "OutcomeReport",
+        message: outcomeReportMessage(report),
+    };
+}
+export async function signReport(unsigned, signer) {
+    const payer = (await signer.address()).toLowerCase();
+    const withPayer = { ...unsigned, payer };
+    const sig = await signer.signTypedData(outcomeReportTypedData(withPayer));
+    return { ...withPayer, sig };
+}
+export const OUTCOME_REPORT_PATH = "/v1/outcomes/report";
+export async function submitReport(report, baseUrl, fetchImpl) {
+    const res = await fetchImpl(`${baseUrl}${OUTCOME_REPORT_PATH}`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(report),
+    });
+    let body = null;
+    try {
+        body = await res.json();
+    }
+    catch {
+        body = null;
+    }
+    return { status: res.status, ok: res.ok, body };
+}
+export async function runReport(deps) {
+    const receipt = deps.readReceipts().find((r) => r.receiptId === deps.receiptId);
+    if (receipt === undefined) {
+        deps.err(`payfetch: no receipt found with id ${deps.receiptId}.`);
+        return { kind: "not_found" };
+    }
+    let unsigned;
+    try {
+        unsigned = buildReportFromReceipt(receipt);
+    }
+    catch (e) {
+        if (e instanceof NotReportableError) {
+            deps.err(e.message);
+            return { kind: "not_reportable", outcome: e.outcome };
+        }
+        throw e;
+    }
+    const report = await signReport(unsigned, deps.signer);
+    deps.out("This is the wallet-signed outcome report that will be submitted:");
+    deps.out(JSON.stringify(report, null, 2));
+    deps.out("It contains NO query string, request/response body, exact amount, exact " +
+        "timestamp, or receiptId — and no install-id. Reporting is opt-in and manual.");
+    if (!(await deps.confirm())) {
+        deps.out("Aborted — nothing was submitted.");
+        return { kind: "aborted" };
+    }
+    const result = await submitReport(report, deps.baseUrl, deps.fetchImpl);
+    if (!result.ok) {
+        deps.err(`payfetch: report submission failed (HTTP ${result.status}): ${JSON.stringify(result.body)}`);
+        return { kind: "submit_failed", status: result.status };
+    }
+    deps.out(`Report accepted (HTTP ${result.status}): ${JSON.stringify(result.body)}`);
+    return { kind: "submitted", status: result.status, report };
+}