@invisi-labs/sdk 1.1.5 → 1.1.7

package/dist/index.d.ts

@@ -1,187 +1,17 @@
-import { O as OperationRuntime, a as OperationPlan, G as GasReference, T as TransactionProveOptions, b as OperationAggregateMember, C as CancelCreditPreparation, c as CreateCreditPreparation, D as DrawCreditPreparation, S as ShieldPreparation, d as TopUpCreditPreparation, e as TransferPreparation, W as WalletSessionOptions, f as WalletSessionInfrastructure } from './operation-types-D7I405FX.js';
-export { g as CoinSelector, F as FundingAuthorizationVerifier, h as FundingSigner, i as FundingSource, j as FundingTypedData, k as GasBenchmarkCircuit, l as GasBenchmarkDeployment, m as GasBenchmarkProfile, n as GasBenchmarkSample, o as GasBenchmarkShape, P as PaymentOutput, p as TransactionExecution, q as defineGasBenchmarks } from './operation-types-D7I405FX.js';
-import * as _invisi_labs_core from '@invisi-labs/core';
-import { CreditDeliveryState, PublicWallet, Note, DisclosureOutput, Disclosure, DisclosureResult, ViewingCapability } from '@invisi-labs/core';
+import { DisclosureOutput, Disclosure, DisclosureResult, Wallet } from '@invisi-labs/core';
 export { Address, CreditDataV1, CreditDeliveryState, CreditNote, CreditOpening, CreditPolicy, Detector, Disclosure, DisclosureExport, DisclosureOutput, DisclosureResult, FundsDataV1, Hex, MAX_MEMO_BYTES, Memo, MissingCapabilityError, Note, NullifierCapability, PublicWallet, ReceivingKeys, SigningRequest, ViewingCapability, Wallet, WalletAuthorization, WalletAuthorizationProvider, computeCreditNullifier, creditPeriods, creditV1, decodeDeliveryHeader, decodeMemoText, encodeMemo, fundsV1 } from '@invisi-labs/core';
 import * as _invisi_labs_protocol from '@invisi-labs/protocol';
-import { TransactionCall, Protocol, CanonicalBlock, ChainReader, TokenProtocol, RegistrationPreparation, RegistrationOperation, AddressRegistry as AddressRegistry$1, CanonicalReceipt } from '@invisi-labs/protocol';
-export { AddressRegistryOptions, CanonicalBlock, CanonicalReceipt, ChainReader, FactoryReader, Membership, Protocol, ProtocolDataProvider, ProtocolDataStatus, ProtocolOptions, ProtocolUpdateRange, ProtocolUpdates, RegistrationOperation, RegistryContext, RegistryReader, TokenProtocol, TokenProtocolOptions, TransactionCall, TransactionContext } from '@invisi-labs/protocol';
-import { Prover, ProofBundle } from '@invisi-labs/prover';
+import { CanonicalBlock, ChainReader, TokenProtocol, Protocol as Protocol$1, AddressRegistry as AddressRegistry$1, RegistrationPreparation, TransactionCall, Membership } from '@invisi-labs/protocol';
+export { AddressRegistryOptions, CanonicalBlock, CanonicalReceipt, ChainReader, FactoryReader, Membership, ProtocolDataProvider, ProtocolDataStatus, ProtocolOptions, ProtocolUpdateRange, ProtocolUpdates, RegistrationOperation, RegistryContext, RegistryReader, TokenProtocol, TokenProtocolOptions, TransactionCall, TransactionContext } from '@invisi-labs/protocol';
 export { AggregateMember, AggregatorCapability, ProofBundle, ProofStatement, Prover, ProverOptions } from '@invisi-labs/prover';
-import { O as OperationStatus, B as BalanceSnapshot, R as ReceiptPosition, S as SpentState, C as Checkpoint, W as WalletScope, a as WalletState } from './state-AUnz7TG7.js';
-export { b as WalletStore, w as walletBalance } from './state-AUnz7TG7.js';
+import { N as NoteInput } from './receipt-logs-m0-bhaxW.js';
+export { C as CreditInput, D as DeliveryEventLog, a as DiscoveredCredit, b as DiscoveredNote, E as ExplicitCancelCreditPreparation, c as ExplicitCreateCreditPreparation, d as ExplicitDrawCreditPreparation, e as ExplicitShieldPreparation, f as ExplicitTopUpCreditPreparation, g as ExplicitTransferPreparation, I as Invisi, h as InvisiError, i as InvisiErrorCode, j as InvisiErrorDetails, k as InvisiOptions, P as PreparedTransaction, R as RegistrationPreparationOptions, T as TransactionIdentity, l as TransactionOutput, m as decryptCandidates, n as defineGasBenchmarks, r as readProtocolLogs } from './receipt-logs-m0-bhaxW.js';
 import { Hex, Address } from '@invisi-labs/protocol/contracts';
-import { Provider, TransactionRequest, TransactionResponse } from 'ethers';
+import { Provider } from 'ethers';
+import { B as BroadcasterClient, P as PaymentRequest } from './broadcaster-preparation-DMxxZ_1Q.js';
+export { a as BroadcasterConfiguration, b as BroadcasterFeeSource, c as BroadcasterQuote, d as BroadcasterRpcError, e as BroadcasterStatus, f as BroadcasterTransport, g as BroadcasterTrust, C as CancelCreditPreparation, h as CreateCreditPreparation, D as DrawCreditPreparation, F as FundingAuthorizationVerifier, i as FundingSigner, j as FundingSource, k as FundingTypedData, G as GasBenchmarkCircuit, l as GasBenchmarkDeployment, m as GasBenchmarkProfile, n as GasBenchmarkSample, o as GasBenchmarkShape, p as GasReference, N as NoteOutput, q as NoteOutputContext, r as NoteOutputExecutionOptions, s as NoteOutputRecipient, O as OperationAggregateMember, S as ShieldPreparation, t as SignedBroadcasterQuote, T as TopUpCreditPreparation, u as TransactionExecution, v as TransactionProveOptions, w as TransferPreparation, W as WithBroadcasterOptions, x as broadcasterQuoteDomain, y as broadcasterQuoteTypes, z as broadcasterRequestHash, A as broadcasterTransactInterface, E as decodeBroadcasterIntent, H as verifyBroadcasterQuote } from './broadcaster-preparation-DMxxZ_1Q.js';
 import { ProtocolRpcClient as ProtocolRpcClient$1 } from '@invisi-labs/rpc';
-export { ProtocolCreditTransition, ProtocolDeployment, ProtocolOutput, ProtocolRpcChain, ProtocolRpcClientOptions, ProtocolRpcConnectionOptions, ProtocolRpcError, ProtocolRpcReader, ProtocolTransactionUpdates, RegisteredReceivingAddress } from '@invisi-labs/rpc';
-import { W as WalletRecordCodec } from './store-BMN8kd0c.js';
-
-/** Stable codes returned by public SDK prepare* methods; inspect details instead of matching messages. */
-type InvisiErrorCode = 
-/**
- * Other preparation failure, such as invalid amounts, expired deadlines,
- * or conflicting registration state. Inspect message and cause.
- */
-"PREPARATION_FAILED"
-/**
- * Required infrastructure or permissions were not supplied.
- * The capability field identifies what is missing.
- */
- | "MISSING_CAPABILITY"
-/**
- * The recipient string is not a valid full 0i address or nonzero EVM owner address.
- * No registration lookup is attempted for this invalid string.
- */
- | "INVALID_RECIPIENT"
-/**
- * A successful lookup found no receiving keys for this short 0x owner
- * at the queried state. Indexed data may lag behind the latest chain state.
- * Full 0i addresses contain receiving keys and do not require registration.
- */
- | "EVM_ADDRESS_NOT_REGISTERED"
-/**
- * Recipient lookup failed or returned invalid keys. Inspect cause.
- * Registration status is unknown; this does not mean the owner is unregistered.
- */
- | "RECIPIENT_LOOKUP_FAILED";
-interface InvisiErrorDetails {
-    operation?: string;
-    address?: string;
-    /** Zero-based index into the caller's outputs array, excluding automatic change. */
-    outputIndex?: number;
-    field?: string;
-    capability?: string;
-    cause?: unknown;
-}
-/** Stable application-facing preparation failure with the original cause. */
-declare class InvisiError extends Error {
-    readonly code: InvisiErrorCode;
-    readonly operation: string | undefined;
-    readonly address: string | undefined;
-    readonly outputIndex: number | undefined;
-    readonly field: string | undefined;
-    readonly capability: string | undefined;
-    constructor(code: InvisiErrorCode, message: string, details?: InvisiErrorDetails);
-}
-
-type Runtime = Omit<OperationRuntime, "store" | "authorization">;
-/** An immutable, local transaction handle. No wallet inventory, reservations or persistence. */
-declare class PreparedTransaction {
-    #private;
-    readonly status: OperationStatus;
-    private constructor();
-    static prepare(runtime: Runtime, plan: OperationPlan): PreparedTransaction;
-    get id(): string;
-    get kind(): "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
-    estimateGas(): GasReference;
-    preview(): {
-        id: string;
-        kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
-        status: OperationStatus;
-        context: {
-            tokenAddress: _invisi_labs_core.Address;
-            now?: bigint;
-            timestamp?: bigint;
-            chainId: bigint;
-            protocolAddress: _invisi_labs_core.Address;
-        };
-        inputs: number;
-        creditOutputs: {
-            amount: bigint;
-            expiry: bigint;
-            owner: `0x${string}`;
-            spender: `0x${string}`;
-            ownerPayout: bigint;
-            spenderPayout: bigint;
-        }[] | undefined;
-        outputs: {
-            to: string;
-            amount: bigint;
-            change: boolean;
-        }[];
-        capacity: number | undefined;
-        deadline: bigint;
-        fundingAmount: bigint;
-        fundingPayer: `0x${string}` | undefined;
-        withdrawalAmount: bigint;
-        withdrawalAddress: `0x${string}` | undefined;
-        permissions: {
-            walletAuthorization: boolean;
-            proof: boolean;
-            fundingAuthorization: boolean;
-        };
-    };
-    private current;
-    private stage;
-    /** Public EIP-712 request; signing transport and key custody belong to the caller. */
-    exportWalletAuthorization(options?: {
-        signal?: AbortSignal;
-    }): Promise<_invisi_labs_core.SigningRequest>;
-    /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
-    withWalletSignature(signature: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<PreparedTransaction>;
-    /** Export only after proving when the funding authorization binds an actual proof hash. */
-    exportFundingAuthorization(options?: {
-        signal?: AbortSignal;
-    }): Promise<_invisi_labs_core.SigningRequest>;
-    /** Verify an external signature against this handle's own frozen operation. */
-    withFundingSignature(signature: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<PreparedTransaction>;
-    prove(options?: TransactionProveOptions): Promise<PreparedTransaction>;
-    prove(backend: Prover, options?: TransactionProveOptions): Promise<PreparedTransaction>;
-    private encode;
-    /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
-    ready(): Promise<PreparedTransaction>;
-    exportTransaction(): Promise<TransactionCall>;
-    exportProof(): ProofBundle;
-    exportAggregateMember(): OperationAggregateMember;
-    toJSON(): {
-        transaction: boolean;
-        id: string;
-        kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
-        status: OperationStatus;
-    };
-}
-
-interface NoteInput {
-    note: Note;
-    commitment: Hex;
-    treeId: bigint;
-    leafIndex: number;
-}
-interface CreditInput {
-    state: CreditDeliveryState;
-    commitment: Hex;
-    treeId: bigint;
-    leafIndex: number;
-    role: "owner" | "spender";
-}
-interface TransactionIdentity {
-    wallet: PublicWallet & {
-        getViewer?: never;
-        getDetector?: never;
-        exportAuthorization?: never;
-    };
-    protocol: Protocol;
-}
-interface ExplicitFunds {
-    inputs: readonly NoteInput[];
-    changeAddress?: string;
-}
-type ExplicitTransferPreparation = TransactionIdentity & TransferPreparation & ExplicitFunds;
-type ExplicitShieldPreparation = TransactionIdentity & ShieldPreparation;
-type ExplicitCreateCreditPreparation = TransactionIdentity & CreateCreditPreparation & ExplicitFunds;
-type ExplicitDrawCreditPreparation = TransactionIdentity & DrawCreditPreparation & {
-    creditInputs: readonly CreditInput[];
-};
-type ExplicitTopUpCreditPreparation = TransactionIdentity & TopUpCreditPreparation & ExplicitFunds & {
-    creditInputs: readonly CreditInput[];
-};
-type ExplicitCancelCreditPreparation = TransactionIdentity & CancelCreditPreparation & {
-    creditInputs: readonly CreditInput[];
-};
+export { MAX_UPDATE_BLOCKS, ProtocolCreditTransition, ProtocolDeployment, ProtocolOutput, ProtocolRpcChain, ProtocolRpcClientOptions, ProtocolRpcConnectionOptions, ProtocolRpcError, ProtocolRpcReader, ProtocolTransactionUpdates, RegisteredReceivingAddress } from '@invisi-labs/rpc';
 
 interface DisclosureReference {
     transactionHash: Hex;
@@ -228,339 +58,127 @@ declare class DisclosureVerifier {
     };
 }
 
-/** Immutable operation handle. No private plan, witness, or transaction is logged implicitly. */
-declare class Operation {
-    #private;
-    readonly status: OperationStatus;
-    private constructor();
-    static prepare(runtime: OperationRuntime, plan: OperationPlan): Promise<Operation>;
-    static resume(runtime: OperationRuntime, id: string): Promise<Operation>;
-    get id(): string;
-    get kind(): OperationPlan["kind"];
-    estimateGas(): GasReference;
-    preview(): {
-        id: string;
-        kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
-        status: OperationStatus;
-        context: {
-            tokenAddress: _invisi_labs_core.Address;
-            now?: bigint;
-            timestamp?: bigint;
-            chainId: bigint;
-            protocolAddress: _invisi_labs_core.Address;
-        };
-        inputs: number;
-        creditOutputs: {
-            amount: bigint;
-            expiry: bigint;
-            owner: `0x${string}`;
-            spender: `0x${string}`;
-            ownerPayout: bigint;
-            spenderPayout: bigint;
-        }[] | undefined;
-        outputs: {
-            to: string;
-            amount: bigint;
-            change: boolean;
-        }[];
-        capacity: number | undefined;
-        deadline: bigint;
-        fundingAmount: bigint;
-        fundingPayer: `0x${string}` | undefined;
-        withdrawalAmount: bigint;
-        withdrawalAddress: `0x${string}` | undefined;
-        permissions: {
-            walletAuthorization: boolean;
-            proof: boolean;
-            fundingAuthorization: boolean;
-        };
-    };
-    private current;
-    private stage;
-    private signingCurrent;
-    /** Public EIP-712 request; signing transport and key custody belong to the caller. */
-    exportWalletAuthorization(options?: {
-        signal?: AbortSignal;
-    }): Promise<_invisi_labs_core.SigningRequest>;
-    /** Attach an external EOA signature, retaining its witness only at the private proving boundary. */
-    withWalletSignature(signature: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<Operation>;
-    /** Export only after proving when the funding authorization binds an actual proof hash. */
-    exportFundingAuthorization(options?: {
+/** Deployment operations and token-compatible broadcaster discovery. */
+declare class Protocol extends Protocol$1 {
+    static fromRpc(rpc: Pick<ProtocolRpcClient$1, "getDeployment"> & Partial<Pick<ProtocolRpcClient$1, "getBroadcasters" | "withReader">>, provider: Provider, options?: {
         signal?: AbortSignal;
-    }): Promise<_invisi_labs_core.SigningRequest>;
-    /** Verify an external signature against this handle's own frozen operation. */
-    withFundingSignature(signature: string, options?: {
-        signal?: AbortSignal;
-    }): Promise<Operation>;
-    authorize(options?: {
-        signal?: AbortSignal;
-    }): Promise<Operation>;
-    prove(suppliedOptions?: TransactionProveOptions): Promise<Operation>;
-    private encode;
-    authorizeFunding(options?: {
-        signal?: AbortSignal;
-    }): Promise<Operation>;
-    /** Shield caller funding needs no wallet signing or proof; this step only encodes its frozen request. */
-    ready(): Promise<Operation>;
-    private validateExport;
-    exportTransaction(options?: {
-        signal?: AbortSignal;
-    }): Promise<TransactionCall>;
-    exportAggregateMember(): Promise<OperationAggregateMember>;
-    abandon(): Promise<Operation>;
-    /** Record an application-owned signed/broadcast transaction. This never sends or waits. */
-    trackTransaction(transactionHash: string): Promise<Operation>;
-    reconcile(options?: {
-        transactionHash?: Hex;
-        signal?: AbortSignal;
-    }): Promise<Operation>;
-    toJSON(): {
-        id: string;
-        kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
-        status: OperationStatus;
-    };
+    }): Promise<Protocol>;
+    /** Returns enabled services that answer a token fee probe; final quotes are checked by prepared. */
+    getBroadcasters(options: {
+        tokenAddress: string;
+    }): Promise<BroadcasterClient[]>;
 }
 
-interface DiscoveryContext {
-    chainId: bigint;
-    protocolAddress: Address;
+/** Registry operations accept the application's existing ethers provider. */
+declare class AddressRegistry extends AddressRegistry$1 {
+    prepareRegistration(options: RegistrationPreparation | (Omit<RegistrationPreparation, "reader"> & {
+        provider: Provider;
+    })): Promise<_invisi_labs_protocol.RegistrationOperation>;
 }
-/** Decoded logs from complete canonical transaction receipts, including insertion logs. */
-interface DeliveryEventLog {
-    address: string;
-    eventName: string;
-    args?: Record<string, unknown>;
-    blockNumber?: bigint | null;
-    blockHash?: Hex | null;
-    transactionHash?: Hex | null;
-    logIndex?: number | null;
-    removed?: boolean;
+
+interface BroadcasterRegistration {
+    endpoint: string;
+    metadataURI?: string;
+    quoteSigner: Address;
+    feeRecipient: Address;
 }
-interface DeliveryCandidate {
-    tokenAddress: Address;
-    treeId: bigint;
-    leafIndex: number;
-    commitment: Hex;
-    role: "funds" | "owner" | "spender";
-    delivery: {
-        ciphertext: Hex;
-        clue: Hex;
-    };
-    blockNumber: bigint;
-    blockHash: Hex;
-    transactionHash: Hex;
+interface RegisteredBroadcaster extends Required<BroadcasterRegistration> {
+    operator: Address;
+    enabled: boolean;
 }
-interface DiscoveredNote extends Omit<DeliveryCandidate, "delivery" | "role"> {
-    note: Note;
+interface BroadcasterRegistryOptions {
+    provider: Provider;
+    address: Address;
+    chainId: bigint;
+    fromBlock: number;
+    runtimeCodeHash: string;
+    /** Maximum blocks per getLogs request. Defaults to 2,000. */
+    blockRange?: number;
 }
-interface DiscoveredCredit extends Omit<DeliveryCandidate, "delivery"> {
-    role: "owner" | "spender";
-    state: CreditDeliveryState;
+/** Optional on-chain discovery. Registry entries do not authorize spending or endorse operators. */
+declare class BroadcasterRegistry {
+    #private;
+    readonly address: Address;
+    constructor(options: BroadcasterRegistryOptions);
+    prepareRegistration(registration: BroadcasterRegistration): TransactionCall;
+    prepareAvailability(enabled: boolean): TransactionCall;
+    private call;
+    private validate;
+    get(operator: Address): Promise<RegisteredBroadcaster>;
+    private read;
+    /** Discover event operators, then read their latest entry; disabled services remain explicit. */
+    discover(options?: {
+        toBlock?: number;
+        signal?: AbortSignal;
+    }): Promise<RegisteredBroadcaster[]>;
 }
-/** Authenticate private deliveries from a single batch of canonical receipts. */
-declare function decryptCandidates(logs: readonly DeliveryEventLog[], options: {
-    context: DiscoveryContext;
-    viewing: Pick<ViewingCapability, "walletIdentity" | "decryptNote" | "decryptCredit">;
-    confirmedThrough: bigint;
-}): Promise<{
-    notes: DiscoveredNote[];
-    credits: DiscoveredCredit[];
-}>;
 
-interface RefreshResult {
-    block: CanonicalBlock;
-    notes: number;
-    credits: number;
-    balances: BalanceSnapshot[];
-}
-interface RefreshOptions {
-    /** Explicit history range; retain the returned block to request the next page later. */
-    fromBlock: bigint;
-    /** Defaults to the Protocol RPC's indexed head, independently checked against Chain RPC. */
-    toBlock?: bigint;
-    /** Explicit permission to delegate detection; never provide a viewing or spending key. */
-    detectionKey?: Uint8Array;
-    /** At most 100 blocks per service request. Reduce this on high-volume deployments. */
-    pageSize?: number;
-    signal?: AbortSignal;
-    /** Rebuild private inventory from these pages while retaining uncertain operations. */
-    reset?: boolean;
+/** Protocol RPC transport with ethers provider integration for independent chain checks. */
+declare class ProtocolRpcClient extends ProtocolRpcClient$1 {
+    withProvider(provider: Provider): ProtocolRpcClient$1;
 }
 
-declare function operationPreview(plan: OperationPlan, status: OperationStatus): {
-    id: string;
-    kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
-    status: OperationStatus;
-    context: {
-        tokenAddress: _invisi_labs_core.Address;
-        now?: bigint;
-        timestamp?: bigint;
-        chainId: bigint;
-        protocolAddress: _invisi_labs_core.Address;
-    };
-    inputs: number;
-    creditOutputs: {
-        amount: bigint;
-        expiry: bigint;
-        owner: `0x${string}`;
-        spender: `0x${string}`;
-        ownerPayout: bigint;
-        spenderPayout: bigint;
-    }[] | undefined;
-    outputs: {
-        to: string;
-        amount: bigint;
-        change: boolean;
-    }[];
-    capacity: number | undefined;
-    deadline: bigint;
-    fundingAmount: bigint;
-    fundingPayer: `0x${string}` | undefined;
-    withdrawalAmount: bigint;
-    withdrawalAddress: `0x${string}` | undefined;
-    permissions: {
-        walletAuthorization: boolean;
-        proof: boolean;
-        fundingAuthorization: boolean;
-    };
-};
+/** Encode only the request, never the current output nonce or local registry lookup choice. */
+declare function encodePaymentRequest(request: PaymentRequest): string;
+/** Decode a canonical Note request offline, with exact resource and byte-layout checks. */
+declare function decodePaymentRequest(encoded: string): PaymentRequest;
 
-/** Private application data. Never send this view to public analytics. */
-interface OutgoingHistoryEntry extends Omit<ReturnType<typeof operationPreview>, "outputs"> {
-    preparedAt: {
-        number: bigint;
-        hash: Hex;
-        timestamp: bigint;
-    };
-    transactionHash?: Hex;
-    outputs: {
-        to: string;
-        amount: bigint;
-        change: boolean;
-        commitment: Hex;
-        payload: Uint8Array;
-    }[];
-}
-interface IncomingHistoryEntry extends ReceiptPosition {
+/** Complete opening of one funds Note. Never contains wallet keys or application payload. */
+interface PaymentNoteData {
+    chainId: bigint;
+    protocolAddress: Hex;
     tokenAddress: Hex;
     amount: bigint;
-    payload: Uint8Array;
-    spent: SpentState;
-}
-interface WalletHistory {
-    revision: number;
-    checkedThrough: Checkpoint | null;
-    invalidated: boolean;
-    /** Local construction records; not proof of a mined payment or funding identity. */
-    outgoing: OutgoingHistoryEntry[];
-    /** Authenticated incoming funds outputs, including already consumed ones. */
-    incoming: IncomingHistoryEntry[];
-}
-interface HistoryOptions {
-    tokenAddress?: Hex;
-}
-
-/** Native ethers transaction options; the exported business call and session chain remain fixed. */
-type SessionTransactionOptions = Omit<TransactionRequest, "to" | "from" | "data" | "value" | "chainId">;
-/** Wallet state and operations, with infrastructure and permissions explicitly injected. */
-declare class WalletSession {
-    #private;
-    readonly scope: WalletScope;
-    readonly protocol: Protocol;
-    constructor(options: WalletSessionOptions);
-    sendTransaction(call: TransactionCall, options?: SessionTransactionOptions): Promise<TransactionResponse>;
-    sendTransaction(operation: Operation, options?: SessionTransactionOptions): Promise<TransactionResponse>;
-    private runtime;
-    private updater;
-    /** Local session commits only. Host applications own cross-tab/store subscriptions. */
-    subscribe(listener: () => void): () => void;
-    /** Detached history for wallet UI; construction records do not imply chain success. */
-    getHistory(options?: HistoryOptions): Promise<WalletHistory>;
-    balance(tokenAddress: `0x${string}`): Promise<BalanceSnapshot>;
-    /** Pull explicitly selected indexed pages; no chain scanning or public tree reconstruction. */
-    refresh(options: RefreshOptions): Promise<RefreshResult>;
-    private preparation;
-    prepareTransfer(options: TransferPreparation): Promise<Operation>;
-    prepareShield(options: ShieldPreparation): Promise<Operation>;
-    prepareCreateCredit(options: CreateCreditPreparation): Promise<Operation>;
-    prepareDrawCredit(options: DrawCreditPreparation): Promise<Operation>;
-    prepareTopUpCredit(options: TopUpCreditPreparation): Promise<Operation>;
-    prepareCancelCredit(options: CancelCreditPreparation): Promise<Operation>;
-    resume(operationId: string): Promise<Operation>;
-    toJSON(): {
-        walletSession: boolean;
-        walletIdentity: `0x${string}`;
-    };
+    ownerAddress: Hex;
+    nonce: bigint;
+    commitment: Hex;
 }
 
-/** Compose independent Chain RPC and indexed Protocol RPC with local wallet capabilities. */
-type InvisiInfrastructure = Omit<WalletSessionInfrastructure, "wallet" | "protocol" | "namespace" | "viewing" | "authorization" | "chainReader" | "signer" | "fundingSigner"> & {
-    /** Recipient discovery source; defaults to protocol-rpc. An explicit addressResolver takes precedence. */
-    addressLookup?: "chain" | "protocol-rpc";
-    provider?: Provider;
-    chainReader?: ChainReader;
+/** Supply connections for manually constructed Protocols; fromRpc connections are reused. */
+type PaymentNoteVerificationOptions = {
+    protocolRpc: Pick<ProtocolRpcClient$1, "withReader">;
+    confirmations?: number;
+} & ({
+    provider: Provider;
+    chainReader?: never;
+} | {
+    chainReader: ChainReader;
+    provider?: never;
+});
+type PaymentNoteVerificationSettings = {
+    confirmations?: number;
 };
-type InvisiOptions = InvisiInfrastructure;
-/** Public wallet and registry-specific inputs; signing remains external. */
-type RegistrationPreparationOptions = Pick<RegistrationPreparation, "update" | "deadline"> & Pick<TransactionIdentity, "wallet">;
-/** Wallet identity and session permissions; shared infrastructure belongs to InvisiOptions. */
-type ConnectionOptions = Pick<WalletSessionOptions, "wallet" | "protocol" | "namespace" | "viewing" | "authorization" | "signer" | "fundingSigner">;
-/** A neutral composition entry point; every resolved instance owns an independent session. */
-declare class Invisi {
-    #private;
-    constructor(options?: InvisiOptions);
-    connect(options: ConnectionOptions): Promise<WalletSession>;
-    private resolve;
-    /** Discover the selected chain's registry and prepare an independent signing request. */
-    prepareRegistration(options: RegistrationPreparationOptions): Promise<RegistrationOperation>;
-    private assertPublicIdentity;
-    private resolveExplicit;
-    prepareTransfer(options: ExplicitTransferPreparation): Promise<PreparedTransaction>;
-    prepareShield(options: ExplicitShieldPreparation): Promise<PreparedTransaction>;
-    prepareCreateCredit(options: ExplicitCreateCreditPreparation): Promise<PreparedTransaction>;
-    prepareDrawCredit(options: ExplicitDrawCreditPreparation): Promise<PreparedTransaction>;
-    prepareTopUpCredit(options: ExplicitTopUpCreditPreparation): Promise<PreparedTransaction>;
-    prepareCancelCredit(options: ExplicitCancelCreditPreparation): Promise<PreparedTransaction>;
-    toJSON(): {
-        invisi: boolean;
-    };
-}
 
-/** Protocol RPC transport with ethers provider integration for independent chain checks. */
-declare class ProtocolRpcClient extends ProtocolRpcClient$1 {
-    withProvider(provider: Provider): ProtocolRpcClient$1;
-}
-
-/** Registry operations accept the application's existing ethers provider. */
-declare class AddressRegistry extends AddressRegistry$1 {
-    prepareRegistration(options: RegistrationPreparation | (Omit<RegistrationPreparation, "reader"> & {
-        provider: Provider;
-    })): Promise<_invisi_labs_protocol.RegistrationOperation>;
+declare class VerifiedPaymentNote {
+    #private;
+    constructor(token: symbol, membership: Membership, checkedAt: CanonicalBlock);
+    get membership(): Membership;
+    get checkedAt(): CanonicalBlock;
 }
-
-/** Caller-owned, nonextractable AES-GCM key. The SDK does not persist the key. */
-declare class EncryptedWalletCodec implements WalletRecordCodec {
+declare class SpendablePaymentNote extends VerifiedPaymentNote {
     #private;
+    constructor(token: symbol, input: NoteInput, membership: Membership, checkedAt: CanonicalBlock, spendabilityCheckedAt: CanonicalBlock);
+    get spendabilityCheckedAt(): CanonicalBlock;
+    toInput(): NoteInput;
+}
+/** A validated Note opening, independent of an indexed wallet store. */
+declare class PaymentNote implements PaymentNoteData {
+    readonly chainId: bigint;
+    readonly protocolAddress: PaymentNoteData["protocolAddress"];
+    readonly tokenAddress: PaymentNoteData["tokenAddress"];
+    readonly amount: bigint;
+    readonly ownerAddress: PaymentNoteData["ownerAddress"];
+    readonly nonce: bigint;
+    readonly commitment: PaymentNoteData["commitment"];
+    readonly ipn: string;
     private constructor();
-    static fromKey(key: CryptoKey): EncryptedWalletCodec;
-    static fromBytes(key: Uint8Array): Promise<EncryptedWalletCodec>;
-    private aad;
-    encode(state: WalletState, context: {
-        key: string;
-        revision: number;
-    }): Promise<Uint8Array>;
-    decode(data: Uint8Array, context: {
-        key: string;
-        revision: number;
-    }): Promise<WalletState>;
-    toJSON(): {
-        walletRecordCodec: string;
-    };
+    static from(ipn: string): Promise<PaymentNote>;
+    verify(protocol: Protocol$1, options?: PaymentNoteVerificationOptions | PaymentNoteVerificationSettings): Promise<VerifiedPaymentNote>;
+    verifySpendable(protocol: Protocol$1, wallet: Wallet, options?: PaymentNoteVerificationOptions | PaymentNoteVerificationSettings): Promise<SpendablePaymentNote>;
+    private data;
 }
 
-/** Decode independently fetched canonical receipt bytes, never normalized service events. */
-declare function readProtocolLogs(receipt: CanonicalReceipt, protocolAddress: Address): DeliveryEventLog[];
+declare function encodePaymentNote(value: PaymentNoteData): string;
+declare function decodePaymentNote(encoded: string): PaymentNoteData;
 
-export { AddressRegistry, BalanceSnapshot, CancelCreditPreparation, type ConnectionOptions, CreateCreditPreparation, type CreditInput, type DeliveryEventLog, type DisclosureEvidence, type DisclosureReader, type DisclosureReference, DisclosureVerifier, type DisclosureVerifierOptions, type DiscoveredCredit, type DiscoveredNote, DrawCreditPreparation, EncryptedWalletCodec, type ExplicitCancelCreditPreparation, type ExplicitCreateCreditPreparation, type ExplicitDrawCreditPreparation, type ExplicitShieldPreparation, type ExplicitTopUpCreditPreparation, type ExplicitTransferPreparation, GasReference, type HistoryOptions, type IncomingHistoryEntry, Invisi, InvisiError, type InvisiErrorCode, type InvisiErrorDetails, type InvisiOptions, type NoteInput, Operation, OperationAggregateMember, OperationStatus, type OutgoingHistoryEntry, PreparedTransaction, ProtocolRpcClient, type RefreshOptions, type RefreshResult, type RegistrationPreparationOptions, type SessionTransactionOptions, ShieldPreparation, TopUpCreditPreparation, type TransactionIdentity, TransactionProveOptions, TransferPreparation, type VerifiedDisclosure, type WalletHistory, WalletScope, WalletSession, WalletSessionOptions, WalletState, decryptCandidates, readProtocolLogs };
+export { AddressRegistry, BroadcasterClient, type BroadcasterRegistration, BroadcasterRegistry, type BroadcasterRegistryOptions, type DisclosureEvidence, type DisclosureReader, type DisclosureReference, DisclosureVerifier, type DisclosureVerifierOptions, NoteInput, PaymentNote, type PaymentNoteData, type PaymentNoteVerificationOptions, type PaymentNoteVerificationSettings, PaymentRequest, Protocol, ProtocolRpcClient, type RegisteredBroadcaster, SpendablePaymentNote, type VerifiedDisclosure, VerifiedPaymentNote, decodePaymentNote, decodePaymentRequest, encodePaymentNote, encodePaymentRequest };