@invisi-labs/sdk 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,363 @@
+import * as _invisi_labs_core from '@invisi-labs/core';
+import { WalletAuthorizationProvider, CreditDeliveryState, Wallet, Note, DisclosureOutput, Disclosure, DisclosureResult } from '@invisi-labs/core';
+export { Address, CreditDeliveryState, CreditNote, CreditOpening, Detector, Disclosure, DisclosureExport, DisclosureOutput, DisclosureResult, Hex, MissingCapabilityError, Note, NullifierCapability, ReceivingKeys, ViewingCapability, Wallet, WalletAuthorization, WalletAuthorizationProvider } from '@invisi-labs/core';
+import { O as OperationRuntime, a as OperationPlan, G as GasReference, F as FundingSigner, b as OperationAggregateMember, C as CancelCreditPreparation, c as CreateCreditPreparation, D as DrawCreditPreparation, S as ShieldPreparation, d as SweepPreparation, T as TopUpCreditPreparation, e as TransferPreparation, W as WithdrawalPreparation, f as WalletSessionOptions } from './gas-estimation-CUZXjsO7.js';
+export { g as CoinSelector, h as FundingAuthorizationVerifier, i as FundingSource, j as FundingTypedData, k as GasBenchmarkCircuit, l as GasBenchmarkDeployment, m as GasBenchmarkProfile, n as GasBenchmarkSample, o as GasBenchmarkShape, p as defineGasBenchmarks } from './gas-estimation-CUZXjsO7.js';
+import * as _invisi_labs_protocol from '@invisi-labs/protocol';
+import { TransactionCall, Protocol, CanonicalBlock, ChainReader, TokenProtocol, AddressRegistry as AddressRegistry$1, RegistrationPreparation } 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 { ProverOptions, Prover, ProofBundle } from '@invisi-labs/prover';
+export { AggregateMember, AggregatorCapability, ProofBundle, ProofStatement, Prover, ProverOptions } from '@invisi-labs/prover';
+import { O as OperationStatus, B as BalanceSnapshot, W as WalletScope, a as WalletState } from './state-DHl6j33x.js';
+export { b as WalletStore, w as walletBalance } from './state-DHl6j33x.js';
+import { Hex } from '@invisi-labs/protocol/contracts';
+import { Provider, TransactionRequest, TransactionResponse, Signer } from 'ethers';
+import { ProtocolRpcClient as ProtocolRpcClient$1 } from '@invisi-labs/rpc';
+export { ProtocolDeployment, ProtocolRpcChain, ProtocolRpcClientOptions, ProtocolRpcConnectionOptions, ProtocolRpcError, ProtocolRpcReader } from '@invisi-labs/rpc';
+import { W as WalletRecordCodec } from './store-Dlol1q1s.js';
+
+type Runtime = Omit<OperationRuntime, "store">;
+/** 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" | "transfer" | "withdraw" | "sweep" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+    estimateGas(): GasReference;
+    preview(): {
+        id: string;
+        kind: "shield" | "transfer" | "withdraw" | "sweep" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        status: OperationStatus;
+        context: {
+            tokenAddress: _invisi_labs_core.Address;
+            now?: 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;
+    authorize(options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    authorize(provider: WalletAuthorizationProvider, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    prove(options?: ProverOptions): Promise<PreparedTransaction>;
+    prove(backend: Prover, options?: ProverOptions): Promise<PreparedTransaction>;
+    private encode;
+    authorizeFunding(options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    authorizeFunding(signer: FundingSigner, options?: {
+        signal?: AbortSignal;
+    }): Promise<PreparedTransaction>;
+    /** 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" | "transfer" | "withdraw" | "sweep" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-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: Wallet;
+    protocol: Protocol;
+}
+interface ExplicitFunds {
+    inputs: readonly NoteInput[];
+    changeAddress?: string;
+}
+type ExplicitTransferPreparation = TransactionIdentity & TransferPreparation & ExplicitFunds;
+type ExplicitWithdrawalPreparation = TransactionIdentity & WithdrawalPreparation & ExplicitFunds;
+type ExplicitSweepPreparation = TransactionIdentity & SweepPreparation & 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[];
+};
+
+interface DisclosureReference {
+    transactionHash: Hex;
+    treeId: bigint;
+    leafIndex: number;
+    role: "funds" | "owner" | "spender";
+}
+type DisclosureReader = Pick<ChainReader, "getChainId" | "getCode" | "getReceipt" | "getBlock" | "getLatestBlockNumber">;
+interface DisclosureVerifierOptions {
+    protocol: TokenProtocol;
+    reader: DisclosureReader;
+    /** Minimum confirmations including the inclusion block; defaults to one. */
+    confirmations?: number;
+}
+interface DisclosureEvidence {
+    reference: Readonly<DisclosureReference>;
+    block: Readonly<CanonicalBlock>;
+    confirmations: bigint;
+    output: Readonly<DisclosureOutput>;
+}
+interface VerifiedDisclosure {
+    result: DisclosureResult;
+    block: Readonly<CanonicalBlock>;
+    confirmations: bigint;
+    output: Readonly<DisclosureReference & {
+        commitment: Hex;
+    }>;
+}
+/** Read-only verification against a trusted RPC and authenticated protocol deployment.
+ * Results establish output content/inclusion at a block, not payer identity, spent state or wallet completeness.
+ */
+declare class DisclosureVerifier {
+    #private;
+    constructor(options: DisclosureVerifierOptions | (Omit<DisclosureVerifierOptions, "reader"> & {
+        provider: Provider;
+    }));
+    private barrier;
+    /** Resolve the exact inserted output and its delivery from a successful canonical receipt. */
+    readOutput(value: DisclosureReference): Promise<DisclosureEvidence>;
+    verify(disclosure: Disclosure, value: DisclosureReference): Promise<VerifiedDisclosure>;
+    toJSON(): {
+        disclosureVerifier: boolean;
+        confirmations: string;
+    };
+}
+
+/** 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" | "transfer" | "withdraw" | "sweep" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        status: OperationStatus;
+        context: {
+            tokenAddress: _invisi_labs_core.Address;
+            now?: 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;
+    authorize(options?: {
+        signal?: AbortSignal;
+    }): Promise<Operation>;
+    prove(options?: ProverOptions): 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" | "transfer" | "withdraw" | "sweep" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        status: OperationStatus;
+    };
+}
+
+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;
+}
+
+/** 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;
+    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>;
+    prepareWithdraw(options: WithdrawalPreparation): Promise<Operation>;
+    prepareSweep(options: SweepPreparation): 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}`;
+    };
+}
+
+/** Compose independent Chain RPC and indexed Protocol RPC with local wallet capabilities. */
+type InvisiOptions = Omit<WalletSessionOptions, "wallet" | "protocol" | "namespace" | "viewing" | "authorization" | "chainReader"> & {
+    provider?: Provider;
+    signer?: Signer;
+    chainReader?: ChainReader;
+};
+/** Wallet identity and session permissions; shared infrastructure belongs to InvisiOptions. */
+type ConnectionOptions = Pick<WalletSessionOptions, "wallet" | "protocol" | "namespace" | "viewing" | "authorization">;
+/** 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;
+    prepareTransfer(options: ExplicitTransferPreparation): Promise<PreparedTransaction>;
+    prepareWithdraw(options: ExplicitWithdrawalPreparation): Promise<PreparedTransaction>;
+    prepareSweep(options: ExplicitSweepPreparation): 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>;
+}
+
+/** Caller-owned, nonextractable AES-GCM key. The SDK does not persist the key. */
+declare class EncryptedWalletCodec implements WalletRecordCodec {
+    #private;
+    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;
+    };
+}
+
+export { AddressRegistry, BalanceSnapshot, CancelCreditPreparation, type ConnectionOptions, CreateCreditPreparation, type CreditInput, type DisclosureEvidence, type DisclosureReader, type DisclosureReference, DisclosureVerifier, type DisclosureVerifierOptions, DrawCreditPreparation, EncryptedWalletCodec, type ExplicitCancelCreditPreparation, type ExplicitCreateCreditPreparation, type ExplicitDrawCreditPreparation, type ExplicitShieldPreparation, type ExplicitSweepPreparation, type ExplicitTopUpCreditPreparation, type ExplicitTransferPreparation, type ExplicitWithdrawalPreparation, FundingSigner, GasReference, Invisi, type InvisiOptions, type NoteInput, Operation, OperationAggregateMember, OperationStatus, PreparedTransaction, ProtocolRpcClient, type RefreshOptions, type RefreshResult, type SessionTransactionOptions, ShieldPreparation, SweepPreparation, TopUpCreditPreparation, type TransactionIdentity, TransferPreparation, type VerifiedDisclosure, WalletScope, WalletSession, WalletSessionOptions, WalletState, WithdrawalPreparation };