@invisi-labs/sdk 1.1.6 → 1.1.7

package/dist/{NoteOutput-DRkVnwlx.d.cts → broadcaster-preparation-DMxxZ_1Q.d.cts}

@@ -1,39 +1,223 @@
-import { Hex, Note, CreditDeliveryState, ViewingCapability, Wallet, PublicWallet, WalletAuthorizationProvider } from '@invisi-labs/core';
-import { Address, Hex as Hex$1, Delivery, ShieldParams, ShieldOutput, CreateCreditParams, CreditDrawParams, CancelCreditParams, TopUpCreditParams, TransactRequest } from '@invisi-labs/protocol/contracts';
-import { c as StoredNote, W as WalletScope, b as WalletStore } from './state-C4HZFotm.cjs';
-import { FundingInput, TransactionContext, CanonicalBlock, NoteMembership, TransactRequestParams, CreditMembership, Protocol, ChainReader, ProtocolDataProvider, TokenProtocol } from '@invisi-labs/protocol';
-import { Signer, Provider } from 'ethers';
+import { Note, CreditDeliveryState, ReceivingKeyLookup, Hex as Hex$2, Wallet, PublicWallet, AuthorizedStatement } from '@invisi-labs/core';
 import * as _invisi_labs_prover from '@invisi-labs/prover';
-import { Prover, ProverOptions, AggregateMember } from '@invisi-labs/prover';
+import { Hex, Prover, ProverOptions, AggregateMember, ProofBundle } from '@invisi-labs/prover';
+import * as _invisi_labs_protocol from '@invisi-labs/protocol';
+import { FundingInput, TransactionContext, CanonicalBlock, NoteMembership, TransactRequestParams, CreditMembership, Protocol, ChainReader, ProtocolDataProvider, TokenProtocol } from '@invisi-labs/protocol';
+import * as ethers from 'ethers';
+import { Interface, Provider } from 'ethers';
+import { Hex as Hex$1, Delivery, Address, ShieldParams, ShieldOutput, CreateCreditParams, CreditDrawParams, CancelCreditParams, TopUpCreditParams, TransactRequest } from '@invisi-labs/protocol/contracts';
 
-type PreparationIntent = {
-    kind: "transfer";
-    options: TransferPreparation;
-} | {
-    kind: "shield";
-    options: ShieldPreparation;
+declare const broadcasterQuoteTypes: {
+    Quote: {
+        name: string;
+        type: string;
+    }[];
+};
+interface BroadcasterQuote {
+    token: string;
+    feeRecipient: string;
+    feeAmount: string;
+    deadline: string;
+    maxGas: string;
+    requestHash: string;
+}
+interface SignedBroadcasterQuote {
+    quote: BroadcasterQuote;
+    signature: string;
+    context?: {
+        chainId: bigint;
+        protocol: string;
+    };
+}
+interface BroadcasterTrust {
+    chainId: bigint;
+    protocol: string;
+    signer: string;
+}
+declare function broadcasterQuoteDomain(trust: BroadcasterTrust): {
+    name: string;
+    version: string;
+    chainId: bigint;
+    verifyingContract: string;
+};
+declare const broadcasterTransactInterface: Interface;
+/** Decode a canonical supported direct public intent. Draw, registry and aggregates are excluded. */
+declare function decodeBroadcasterIntent(data: string): {
+    fragment: ethers.FunctionFragment;
+    method: string;
+    args: ethers.Result;
+    proof: string;
+    request: {
+        params: any;
+        funding: any;
+        deliveries: any;
+    };
+};
+/** Domain-separated final public intent: omit only proof bytes and funding.signature. */
+declare function broadcasterRequestHash(data: string): string;
+declare function verifyBroadcasterQuote(signed: SignedBroadcasterQuote, trust: BroadcasterTrust, data: string, now?: bigint): BroadcasterQuote;
+interface BroadcasterStatus {
+    id: string;
+    state: "pending" | "submitted" | "confirmed" | "reverted" | "uncertain";
+    transactionHash?: string;
+}
+type BroadcasterTransport = (request: {
+    jsonrpc: "2.0";
+    id: number;
+    method: string;
+    params: unknown;
+}) => Promise<unknown>;
+interface BroadcasterConfiguration {
+    endpoint: string;
+    quoteSigner: string;
+    feeRecipient: string;
+}
+declare class BroadcasterClient {
+    readonly configuration: Readonly<BroadcasterConfiguration>;
+    readonly url: string;
+    readonly transport: BroadcasterTransport;
+    private requestId;
+    constructor(configuration: BroadcasterConfiguration, transport?: BroadcasterTransport);
+    private call;
+    fee(token: string, data?: string): Promise<{
+        feeRecipient: string;
+        feeAmount: string;
+        maxGas: string;
+    }>;
+    quote(data: string, context: {
+        chainId: bigint;
+        protocol: string;
+    }): Promise<SignedBroadcasterQuote>;
+    submit(data: string, signed: SignedBroadcasterQuote, idempotencyKey: string): Promise<BroadcasterStatus>;
+    status(id: string): Promise<BroadcasterStatus>;
+}
+declare class BroadcasterRpcError extends Error {
+    readonly code: number;
+    constructor(code: number, message: string);
+}
+
+interface WalletScope {
+    namespace: string;
+    chainId: bigint;
+    protocolAddress: Hex;
+    ownerAddress: Hex;
+}
+declare function creditReservationKey(commitment: string): string;
+interface Checkpoint {
+    number: bigint;
+    hash: Hex;
+}
+type SpentState = "unknown" | "unspent" | "spent";
+interface ReceiptPosition {
+    commitment: Hex;
+    treeId: bigint;
+    leafIndex: number;
+    blockNumber: bigint;
+    blockHash: Hex;
+    transactionHash?: Hex;
+}
+interface NoteRecord extends ReceiptPosition {
+    note: Note;
+    spent: SpentState;
+    checkedThrough?: Checkpoint;
+}
+interface CreditRecord extends ReceiptPosition {
+    receivingKeySource?: {
+        kind: "draw" | "top-up";
+        commitment: Hex;
+    };
+    state: CreditDeliveryState;
+    role: "owner" | "spender";
+    spent: SpentState;
+    checkedThrough?: Checkpoint;
+}
+type OperationStatus = "prepared" | "authorized" | "proved" | "ready" | "submitted" | "confirmed" | "failed" | "expired" | "uncertain" | "reorged";
+
+/** Minimal input count by descending amount, with deterministic tree/position/commitment ties. */
+type SelectableNote = Pick<NoteRecord, "note" | "commitment" | "treeId" | "leafIndex" | "spent">;
+
+type AddressLookup = "chain" | "protocol-rpc";
+/** Capture deployment pins before a Protocol is bound to an operation's token. */
+declare function configureRecipientInfrastructure<T extends TransactionInfrastructure>(options: T): T;
+/** Internal lookup plumbing; public APIs never accept resolver functions. */
+declare function recipientLookup(options: object, source?: AddressLookup): ReceivingKeyLookup;
+
+interface NoteOutputContext {
+    chainId: bigint;
+    protocolAddress: Hex$1;
+    tokenAddress: Hex$1;
+}
+type NoteOutputRecipient = {
+    type: "evm";
+    address: string;
+    envelope?: boolean;
+    addressLookup?: AddressLookup;
+    nonce?: bigint | undefined;
 } | {
-    kind: "create-credit";
-    options: CreateCreditPreparation;
+    type: "invisi";
+    address: string;
+    nonce?: bigint | undefined;
 } | {
-    kind: "top-up-credit";
-    options: TopUpCreditPreparation;
+    type: "identity";
+    identity: Hex$1;
+};
+type EncryptedRecipient = {
+    type: "evm";
+    address: string;
+    envelope?: true;
+    addressLookup?: AddressLookup;
+    nonce?: bigint | undefined;
 } | {
-    kind: "cancel-credit";
-    options: CancelCreditPreparation;
+    type: "invisi";
+    address: string;
+    nonce?: bigint | undefined;
 };
-type BroadcasterFeeSource = "public-funding" | "private-inputs" | "payout";
-interface WithBroadcasterOptions {
-    maxFeeAmount: bigint;
-    feeSource?: BroadcasterFeeSource;
-    maxAttempts?: number;
-    /** Optional app-owned permit signing, requested once for the final gross funding amount. */
-    fundingPermit?: (request: {
-        payer: `0x${string}`;
-        amount: bigint;
-        tokenAddress: `0x${string}`;
-        protocolAddress: `0x${string}`;
-    }) => Promise<NonNullable<TransferPreparation["funding"]>["permit"]>;
+type PaymentRequest = NoteOutputContext & {
+    amount: bigint;
+} & ({
+    recipient: EncryptedRecipient;
+    payload?: Uint8Array;
+} | {
+    recipient: {
+        type: "evm";
+        address: string;
+        envelope: false;
+        addressLookup?: AddressLookup;
+        nonce?: bigint | undefined;
+    } | {
+        type: "identity";
+        identity: Hex$1;
+    };
+    payload?: never;
+});
+/** Local payment choices; these never rewrite the encoded request. */
+interface NoteOutputExecutionOptions {
+    nonce?: bigint;
+    addressLookup?: AddressLookup;
+}
+
+/** Immutable output statement and optional recoverable opening. */
+declare class NoteOutput {
+    readonly to: string;
+    readonly ipp: string;
+    readonly amount: bigint;
+    readonly identity: Hex$1;
+    readonly commitment: Hex$1;
+    readonly deliveryFingerprint: Hex$1;
+    /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
+    readonly deliveryPending: boolean;
+    readonly context: NoteOutputContext;
+    readonly recipient: NoteOutputRecipient;
+    readonly nonce: bigint | undefined;
+    readonly payload: Uint8Array;
+    readonly preparedOutput: PreparedOutput;
+    private constructor();
+    /** Private offline delivery data; does not assert that the output has been mined. */
+    exportPaymentNote(): string;
+    static create(input: PaymentRequest | string, execution?: NoteOutputExecutionOptions): Promise<NoteOutput>;
+    assertCommitment(expectedHex: Hex$1): void;
+    get note(): Note | undefined;
+    get delivery(): Delivery;
 }
 
 interface GasBenchmarkShape {
@@ -52,9 +236,9 @@ interface GasBenchmarkShape {
 }
 interface GasBenchmarkDeployment {
     chainId: string;
-    protocolAddress: Hex;
-    runtimeCodeHash: Hex | null;
-    tokenAddress: Hex;
+    protocolAddress: Hex$2;
+    runtimeCodeHash: Hex$2 | null;
+    tokenAddress: Hex$2;
 }
 interface GasBenchmarkCircuit {
     circuitName: string;
@@ -64,9 +248,9 @@ interface GasBenchmarkCircuit {
 }
 interface GasBenchmarkSample {
     gasUsed: string;
-    transactionHash: Hex;
+    transactionHash: Hex$2;
     blockNumber: string;
-    blockHash: Hex;
+    blockHash: Hex$2;
     calldataBytes: number;
 }
 interface GasBenchmarkProfile {
@@ -93,8 +277,8 @@ interface GasBenchmarkProfile {
         };
         blockGasLimit?: string;
         runtimeContracts?: Record<string, {
-            address: Hex;
-            runtimeCodeHash: Hex;
+            address: Hex$2;
+            runtimeCodeHash: Hex$2;
         }>;
         measuredAt: string;
         chain: string;
@@ -110,15 +294,37 @@ interface GasBenchmarkProfile {
         samples: GasBenchmarkSample[];
     }>;
 }
-/** Parse a trusted, JSON-compatible benchmark catalog. No network access or publisher authentication. */
-declare function defineGasBenchmarks(input: unknown): GasBenchmarkProfile[];
+interface GasEstimateRequest {
+    deployment: GasBenchmarkDeployment;
+    shape: GasBenchmarkShape;
+    circuit: GasBenchmarkCircuit | null;
+}
+type BenchmarkGasEstimate = {
+    source: "benchmark";
+    request: GasEstimateRequest;
+} & ({
+    available: false;
+    reason: "deployment-not-covered" | "shape-not-covered" | "recursive-member-only";
+} | {
+    available: true;
+    gasUnits: bigint;
+    range: {
+        min: bigint;
+        max: bigint;
+        kind: "observed";
+    };
+    samples: number;
+    profileId: string;
+    measurementId: string;
+    evidence: GasBenchmarkProfile["source"];
+});
 /** Pre-proof reference only; ethers must estimate the final transaction independently. */
 interface GasReference {
     gasUnits: bigint;
 }
 
 interface CoinSelector {
-    select(candidates: readonly StoredNote[], requiredAmount: bigint): readonly Hex$1[] | Promise<readonly Hex$1[]>;
+    select(candidates: readonly NoteRecord[], requiredAmount: bigint): readonly Hex$1[] | Promise<readonly Hex$1[]>;
 }
 interface FundingTypedData {
     domain: Record<string, unknown>;
@@ -288,111 +494,94 @@ interface OperationPlan {
     credit?: CreditPlan;
     statement?: _invisi_labs_prover.ProofStatement;
 }
-type WalletSessionOptions = WalletSessionInfrastructure;
-/** Shared runtime fields; public options separately enforce the custom registry requirement. */
-interface WalletSessionInfrastructure {
+interface SavedOperation {
+    plan: OperationPlan;
+    broadcasterQuote?: SignedBroadcasterQuote;
+    proof?: ProofBundle;
+    call?: _invisi_labs_protocol.TransactionCall;
+    externalized?: boolean;
+    generation: number;
+    claim?: {
+        stage: string;
+        token: string;
+    };
+}
+interface TransactionInfrastructure {
     gasBenchmarks?: readonly GasBenchmarkProfile[];
-    /** Optional ethers gas/funding signer; distinct from the Invisi wallet authority. */
-    signer?: Signer;
-    viewing?: Pick<ViewingCapability, "ownerAddress" | "decryptNote" | "decryptCredit">;
     wallet: Wallet | PublicWallet;
     protocol: Protocol;
-    namespace?: string;
-    store?: WalletStore;
     chainReader?: ChainReader;
     protocolRpc?: ProtocolDataProvider;
-    authorization?: WalletAuthorizationProvider;
     prover?: Prover;
-    fundingSigner?: FundingSigner;
     fundingVerifier?: FundingAuthorizationVerifier;
     /** Optional ethers provider used by per-output direct-chain receiving-key lookup. */
     provider?: Provider;
     coinSelector?: CoinSelector;
     transactionTTL?: bigint;
 }
-interface OperationRuntime {
-    options: Omit<WalletSessionOptions, "protocol"> & {
+interface TransactionRuntime {
+    options: Omit<TransactionInfrastructure, "protocol"> & {
         protocol: TokenProtocol;
     };
     scope: WalletScope;
-    store: WalletStore;
     reader: ChainReader;
-    authorization: () => WalletAuthorizationProvider;
+}
+interface LocalOperationSecrets {
+    authorization?: AuthorizedStatement;
 }
 interface OperationAggregateMember extends AggregateMember {
     context: TransactionContext;
     request: TransactRequest;
 }
-
-type AddressLookup = "chain" | "protocol-rpc";
-
-interface NoteOutputContext {
-    chainId: bigint;
-    protocolAddress: Hex$1;
-    tokenAddress: Hex$1;
+/** Data required while preparing an operation; it does not own persistence or reservations. */
+interface PreparationRuntime<Result> extends TransactionRuntime {
+    readInventory(): Promise<PreparationInventory>;
+    complete(plan: OperationPlan): Promise<Result>;
+    explicitInputs?: boolean;
+    inputSelection?: readonly Hex$1[];
+    changeAddress?: string;
 }
-type NoteOutputRecipient = {
-    type: "evm";
-    address: string;
-    envelope?: boolean;
-    addressLookup?: AddressLookup;
-    nonce?: bigint | undefined;
+interface PreparationInventory {
+    reservations: Record<string, string>;
+    invalidated?: string;
+    observedThrough?: Checkpoint;
+    notes: Record<string, SelectableNote>;
+    credits: Record<string, Pick<CreditRecord, "state" | "commitment" | "treeId" | "leafIndex" | "role" | "spent">>;
+}
+
+type PreparationIntent = {
+    kind: "transfer";
+    options: TransferPreparation;
 } | {
-    type: "invisi";
-    address: string;
-    nonce?: bigint | undefined;
+    kind: "shield";
+    options: ShieldPreparation;
 } | {
-    type: "identity";
-    identity: Hex$1;
-};
-type EncryptedRecipient = {
-    type: "evm";
-    address: string;
-    envelope?: true;
-    addressLookup?: AddressLookup;
-    nonce?: bigint | undefined;
+    kind: "create-credit";
+    options: CreateCreditPreparation;
 } | {
-    type: "invisi";
-    address: string;
-    nonce?: bigint | undefined;
-};
-type NoteOutputOptions = NoteOutputContext & {
-    amount: bigint;
-} & ({
-    recipient: EncryptedRecipient;
-    payload?: Uint8Array;
+    kind: "top-up-credit";
+    options: TopUpCreditPreparation;
 } | {
-    recipient: {
-        type: "evm";
-        address: string;
-        envelope: false;
-        addressLookup?: AddressLookup;
-        nonce?: bigint | undefined;
-    } | {
-        type: "identity";
-        identity: Hex$1;
-    };
-    payload?: never;
-});
-/** Immutable output statement and optional recoverable opening. */
-declare class NoteOutput {
-    readonly to: string;
-    readonly amount: bigint;
-    readonly identity: Hex$1;
-    readonly commitment: Hex$1;
-    readonly deliveryFingerprint: Hex$1;
-    /** Encrypted EVM delivery is resolved by preparation; the original offline intent stays pending. */
-    readonly deliveryPending: boolean;
-    readonly context: NoteOutputContext;
-    readonly recipient: NoteOutputRecipient;
-    readonly nonce: bigint | undefined;
-    readonly payload: Uint8Array;
-    readonly preparedOutput: PreparedOutput;
-    private constructor();
-    static create(options: NoteOutputOptions): Promise<NoteOutput>;
-    assertCommitment(expectedHex: Hex$1): void;
-    get note(): Note | undefined;
-    get delivery(): Delivery;
+    kind: "cancel-credit";
+    options: CancelCreditPreparation;
+};
+type BroadcasterFeeSource = "public-funding" | "private-inputs" | "payout";
+interface WithBroadcasterOptions {
+    maxFeeAmount: bigint;
+    feeSource?: BroadcasterFeeSource;
+    maxAttempts?: number;
+    /** Optional app-owned permit signing, requested once for the final gross funding amount. */
+    fundingPermit?: (request: {
+        payer: `0x${string}`;
+        amount: bigint;
+        tokenAddress: `0x${string}`;
+        protocolAddress: `0x${string}`;
+    }) => Promise<NonNullable<TransferPreparation["funding"]>["permit"]>;
 }
+declare function prepareIntent(runtime: PreparationRuntime<OperationPlan>, intent: PreparationIntent): Promise<OperationPlan>;
+declare function prepareBroadcasterPlan(plan: OperationPlan, reprepare: (intent: PreparationIntent) => Promise<OperationPlan>, client: BroadcasterClient, options: WithBroadcasterOptions): Promise<{
+    plan: OperationPlan;
+    quote: SignedBroadcasterQuote;
+}>;
 
-export { type BroadcasterFeeSource as B, type CancelCreditPreparation as C, type DrawCreditPreparation as D, type FundingAuthorizationVerifier as F, type GasReference as G, NoteOutput as N, type OperationRuntime as O, type PreparationIntent as P, type ShieldPreparation as S, type TransactionProveOptions as T, type WithBroadcasterOptions as W, type OperationPlan as a, type OperationAggregateMember as b, type CreateCreditPreparation as c, type TopUpCreditPreparation as d, type TransferPreparation as e, type WalletSessionOptions as f, type WalletSessionInfrastructure as g, type CoinSelector as h, type FundingSigner as i, type FundingSource as j, type FundingTypedData as k, type GasBenchmarkCircuit as l, type GasBenchmarkDeployment as m, type GasBenchmarkProfile as n, type GasBenchmarkSample as o, type GasBenchmarkShape as p, type NoteOutputContext as q, type NoteOutputOptions as r, type NoteOutputRecipient as s, type TransactionExecution as t, defineGasBenchmarks as u };
+export { type LocalOperationSecrets as $, broadcasterTransactInterface as A, BroadcasterClient as B, type CancelCreditPreparation as C, type DrawCreditPreparation as D, decodeBroadcasterIntent as E, type FundingAuthorizationVerifier as F, type GasBenchmarkCircuit as G, verifyBroadcasterQuote as H, type GasEstimateRequest as I, type OperationPlan as J, type BenchmarkGasEstimate as K, type SavedOperation as L, type TransactionRuntime as M, NoteOutput as N, type OperationAggregateMember as O, type PaymentRequest as P, type OperationStatus as Q, type PreparationRuntime as R, type ShieldPreparation as S, type TopUpCreditPreparation as T, type TransactionInfrastructure as U, type AddressLookup as V, type WithBroadcasterOptions as W, type Checkpoint as X, type CoinSelector as Y, type CreditPlan as Z, type CreditRecord as _, type BroadcasterConfiguration as a, type NoteRecord as a0, type PreparationIntent as a1, type PreparationInventory as a2, type PreparedCreditInput as a3, type PreparedCreditOutput as a4, type PreparedOutput as a5, type ReceiptPosition as a6, type SpentState as a7, type WalletScope as a8, configureRecipientInfrastructure as a9, creditReservationKey as aa, prepareBroadcasterPlan as ab, prepareIntent as ac, recipientLookup as ad, type BroadcasterFeeSource as b, type BroadcasterQuote as c, BroadcasterRpcError as d, type BroadcasterStatus as e, type BroadcasterTransport as f, type BroadcasterTrust as g, type CreateCreditPreparation as h, type FundingSigner as i, type FundingSource as j, type FundingTypedData as k, type GasBenchmarkDeployment as l, type GasBenchmarkProfile as m, type GasBenchmarkSample as n, type GasBenchmarkShape as o, type GasReference as p, type NoteOutputContext as q, type NoteOutputExecutionOptions as r, type NoteOutputRecipient as s, type SignedBroadcasterQuote as t, type TransactionExecution as u, type TransactionProveOptions as v, type TransferPreparation as w, broadcasterQuoteDomain as x, broadcasterQuoteTypes as y, broadcasterRequestHash as z };