import { type Address, type Hex, type PublicClient, type WalletClient } from "viem";
export type SettlementRouteClass = "AIFP-1" | "AIFP-2";
/**
 * EVM networks supported for AIFP-1/AIFP-2 settlement.
 * @deprecated "botchain" is deprecated and will be removed in a future version. Use "robinhood" instead.
 */
export type SettlementEvmNetwork = "polygon" | "botchain" | "avalanche" | "arbitrum" | "bnb" | "base" | "unichain" | "optimism" | "robinhood" | "xrplevm" | "amoy";
export interface SettlementRoute {
    route_class: SettlementRouteClass;
    profile: {
        route_class: SettlementRouteClass;
        settlement_semantics: "gross-inclusive";
        treasury_bps: number;
        creator_bps: number;
        fee_on_top: false;
        required_splitter_version: "1.3";
    };
    network: SettlementEvmNetwork;
    chain_id: number;
    name: string;
    native_asset: string;
    stable_assets: Record<string, {
        address: Address;
        decimals: number;
        issuer: string;
    }>;
    explorer: string;
    live: boolean;
    testnet?: boolean;
    splitter?: Address;
    splitter_version?: "1.3";
    runtime_code_hash?: Hex;
    disabled_reason?: string;
}
/**
 * Independent release trust anchor. This value must come from a reviewed SDK
 * release/config artifact, not from the same backend response as the invoice.
 */
export interface TrustedSettlementRoutePin {
    route_class: SettlementRouteClass;
    chain: SettlementEvmNetwork;
    chain_id: number;
    splitter_version: "1.3";
    splitter: Address;
    runtime_code_hash: Hex;
    /** Must be explicitly true for Amoy signing; omitted means mainnet only. */
    testnet?: boolean;
    /** Independently reviewed asset identities; required for stable settlement. */
    stable_assets?: Readonly<Record<string, {
        address: Address;
        decimals: number;
    }>>;
}
export type TrustedSettlementRouteRegistry = Partial<Record<SettlementRouteClass, Partial<Record<SettlementEvmNetwork, TrustedSettlementRoutePin>>>>;
export interface SettlementInvoiceInput {
    route_class: SettlementRouteClass;
    chain: SettlementEvmNetwork;
    asset: string;
    gross_amount: string | bigint;
    merchant_wallet?: Address;
    provider_wallet?: Address;
    order_id: string;
    valid_until?: number;
}
interface SettlementBreakdown {
    gross_amount: string;
    merchant_amount: string;
    protocol_fee_amount: string;
    creator_amount: string;
    protocol_fee_bps: number;
    creator_bps: number;
}
interface SettlementInvoiceBase {
    route_class: SettlementRouteClass;
    chain: SettlementEvmNetwork;
    chain_id: number;
    splitter_version: "1.3";
    splitter: Address;
    runtime_code_hash: Hex;
    settlement_semantics: "gross-inclusive";
    fee_on_top: false;
    asset: string;
    payment_id: Hex;
    order_id: string;
    valid_until: number;
    merchant_wallet: Address;
    breakdown: SettlementBreakdown;
    authorization: string;
}
export interface NativeSettlementInvoice extends SettlementInvoiceBase {
    transaction: {
        kind: "evm_contract_call";
        function: "payNative((bytes32,address,uint256,address,uint256,string))";
        args: {
            paymentId: Hex;
            merchant: Address;
            grossAmount: string;
            ipCreator: Address;
            validUntil: number;
            orderId: string;
        };
        value: string;
    };
    token?: never;
}
export interface StableSettlementInvoice extends SettlementInvoiceBase {
    token: {
        address: Address;
        decimals: number;
        issuer: string;
    };
    transaction: {
        kind: "evm_erc20_then_contract_call";
        approve: {
            token: Address;
            function: "approve(address,uint256)";
            spender: Address;
            amount: string;
        };
        settle: {
            function: "payStable((bytes32,address,uint256,address,address,uint256,string))";
            args: {
                paymentId: Hex;
                token: Address;
                grossAmount: string;
                merchant: Address;
                ipCreator: Address;
                validUntil: number;
                orderId: string;
            };
            value: "0";
        };
    };
}
export type SettlementInvoice = NativeSettlementInvoice | StableSettlementInvoice;
export interface SettlementExecution {
    route_class: SettlementRouteClass;
    chain: SettlementEvmNetwork;
    payment_id: Hex;
    approval_txs: Hex[];
    settlement_tx: Hex;
    block_number: bigint;
}
export declare class SettlementProtocolError extends Error {
    readonly code: string;
    constructor(message: string, code?: string);
}
/** Broadcast succeeded but confirmation is unknown. Keep this hash and check
 * it before retrying; a timeout is not evidence that no money moved. */
export declare class SettlementConfirmationPendingError extends SettlementProtocolError {
    readonly txHash: Hex;
    readonly stage: "approval" | "settlement";
    constructor(txHash: Hex, stage: "approval" | "settlement");
}
/** Strictly validate an invoice before any wallet signs. */
export declare function validateSettlementInvoice(invoice: SettlementInvoice): void;
/** Verify that a backend invoice matches an independently trusted release pin. */
export declare function validateTrustedSettlementRoutePin(invoice: SettlementInvoice, pin: TrustedSettlementRoutePin): void;
export interface SettlementClientOptions {
    baseUrl?: string;
    /** Supply the caller's guarded transport, e.g. MCP's safe fetch. */
    fetchImpl?: typeof fetch;
    /** Covers the response body as well as the HTTP request. Default 15 seconds. */
    timeoutMs?: number;
}
export declare class SettlementClient {
    readonly baseUrl: string;
    private readonly fetchImpl;
    private readonly timeoutMs;
    constructor(options?: string | SettlementClientOptions);
    private request;
    routes(routeClass?: SettlementRouteClass): Promise<SettlementRoute[]>;
    invoice(input: SettlementInvoiceInput): Promise<SettlementInvoice>;
}
/** Verify trusted deployment evidence against chain immediately before signing. */
export declare function verifySettlementRouteOnChain(invoice: SettlementInvoice, publicClient: PublicClient, trustedPin: TrustedSettlementRoutePin): Promise<void>;
/** Execute a v1.3 invoice only after matching an independent trusted route pin. */
export declare function executeSettlementInvoice(invoice: SettlementInvoice, walletClient: WalletClient, publicClient: PublicClient, trustedPin: TrustedSettlementRoutePin): Promise<SettlementExecution>;
export declare const SETTLEMENT_CHAIN_IDS: Readonly<{
    amoy: number;
    arbitrum: number;
    avalanche: number;
    base: number;
    bnb: number;
    botchain: number;
    optimism: number;
    polygon: number;
    robinhood: number;
    unichain: number;
    xrplevm: number;
}>;
export declare const SETTLEMENT_EXPECTED_BPS: Readonly<{
    "AIFP-1": {
        treasury: number;
        creator: number;
    };
    "AIFP-2": {
        treasury: number;
        creator: number;
    };
}>;
export {};
//# sourceMappingURL=settlement.d.ts.map