@invisi-labs/sdk 1.1.2 → 1.1.4

package/dist/index.d.ts

@@ -1,22 +1,70 @@
+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 { WalletAuthorizationProvider, CreditDeliveryState, Wallet, Note, DisclosureOutput, Disclosure, DisclosureResult } from '@invisi-labs/core';
-export { Address, CreditDeliveryState, CreditNote, CreditOpening, Detector, Disclosure, DisclosureExport, DisclosureOutput, DisclosureResult, Hex, MAX_MEMO_BYTES, Memo, MissingCapabilityError, Note, NullifierCapability, ReceivingKeys, ViewingCapability, Wallet, WalletAuthorization, WalletAuthorizationProvider, decodeMemoText, encodeMemo } 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-v9OjKMsL.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-v9OjKMsL.js';
+import { CreditDeliveryState, PublicWallet, Note, DisclosureOutput, Disclosure, DisclosureResult, ViewingCapability } 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, AddressRegistry as AddressRegistry$1, RegistrationPreparation } 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 { ProverOptions, Prover, ProofBundle } from '@invisi-labs/prover';
+import { 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 { 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 { Hex, Address } from '@invisi-labs/protocol/contracts';
+import { Provider, TransactionRequest, TransactionResponse } 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';
+export { ProtocolDeployment, ProtocolOutput, ProtocolRpcChain, ProtocolRpcClientOptions, ProtocolRpcConnectionOptions, ProtocolRpcError, ProtocolRpcReader, RegisteredReceivingAddress } from '@invisi-labs/rpc';
+import { W as WalletRecordCodec } from './store-BMN8kd0c.js';
 
-type Runtime = Omit<OperationRuntime, "store">;
+/** 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;
@@ -24,15 +72,16 @@ declare class PreparedTransaction {
     private constructor();
     static prepare(runtime: Runtime, plan: OperationPlan): PreparedTransaction;
     get id(): string;
-    get kind(): "transfer" | "withdraw" | "sweep" | "shield" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+    get kind(): "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
     estimateGas(): GasReference;
     preview(): {
         id: string;
-        kind: "transfer" | "withdraw" | "sweep" | "shield" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        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;
         };
@@ -64,21 +113,25 @@ declare class PreparedTransaction {
     };
     private current;
     private stage;
-    authorize(options?: {
+    /** Public EIP-712 request; signing transport and key custody belong to the caller. */
+    exportWalletAuthorization(options?: {
         signal?: AbortSignal;
-    }): Promise<PreparedTransaction>;
-    authorize(provider: WalletAuthorizationProvider, options?: {
+    }): 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>;
-    prove(options?: ProverOptions): Promise<PreparedTransaction>;
-    prove(backend: Prover, options?: ProverOptions): Promise<PreparedTransaction>;
-    private encode;
-    authorizeFunding(options?: {
+    /** Export only after proving when the funding authorization binds an actual proof hash. */
+    exportFundingAuthorization(options?: {
         signal?: AbortSignal;
-    }): Promise<PreparedTransaction>;
-    authorizeFunding(signer: FundingSigner, options?: {
+    }): 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>;
@@ -87,7 +140,7 @@ declare class PreparedTransaction {
     toJSON(): {
         transaction: boolean;
         id: string;
-        kind: "transfer" | "withdraw" | "sweep" | "shield" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
         status: OperationStatus;
     };
 }
@@ -106,7 +159,11 @@ interface CreditInput {
     role: "owner" | "spender";
 }
 interface TransactionIdentity {
-    wallet: Wallet;
+    wallet: PublicWallet & {
+        getViewer?: never;
+        getDetector?: never;
+        exportAuthorization?: never;
+    };
     protocol: Protocol;
 }
 interface ExplicitFunds {
@@ -114,8 +171,6 @@ interface ExplicitFunds {
     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 & {
@@ -185,11 +240,12 @@ declare class Operation {
     estimateGas(): GasReference;
     preview(): {
         id: string;
-        kind: "transfer" | "withdraw" | "sweep" | "shield" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        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;
         };
@@ -221,10 +277,27 @@ declare class Operation {
     };
     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?: {
+        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(options?: ProverOptions): Promise<Operation>;
+    prove(suppliedOptions?: TransactionProveOptions): Promise<Operation>;
     private encode;
     authorizeFunding(options?: {
         signal?: AbortSignal;
@@ -245,11 +318,57 @@ declare class Operation {
     }): Promise<Operation>;
     toJSON(): {
         id: string;
-        kind: "transfer" | "withdraw" | "sweep" | "shield" | "create-credit" | "draw-credit" | "top-up-credit" | "cancel-credit";
+        kind: "shield" | "create-credit" | "cancel-credit" | "top-up-credit" | "transfer" | "draw-credit";
         status: OperationStatus;
     };
 }
 
+interface DiscoveryContext {
+    chainId: bigint;
+    protocolAddress: Address;
+}
+/** 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 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 DiscoveredNote extends Omit<DeliveryCandidate, "delivery" | "role"> {
+    note: Note;
+}
+interface DiscoveredCredit extends Omit<DeliveryCandidate, "delivery"> {
+    role: "owner" | "spender";
+    state: CreditDeliveryState;
+}
+/** 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;
@@ -270,6 +389,79 @@ interface RefreshOptions {
     reset?: boolean;
 }
 
+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;
+    };
+};
+
+/** 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 {
+    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. */
@@ -282,13 +474,15 @@ declare class WalletSession {
     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>;
-    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>;
@@ -302,22 +496,28 @@ declare class WalletSession {
 }
 
 /** Compose independent Chain RPC and indexed Protocol RPC with local wallet capabilities. */
-type InvisiOptions = Omit<WalletSessionOptions, "wallet" | "protocol" | "namespace" | "viewing" | "authorization" | "chainReader"> & {
+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;
-    signer?: Signer;
     chainReader?: ChainReader;
 };
+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">;
+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>;
-    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>;
@@ -360,4 +560,7 @@ declare class EncryptedWalletCodec implements WalletRecordCodec {
     };
 }
 
-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 };
+/** Decode independently fetched canonical receipt bytes, never normalized service events. */
+declare function readProtocolLogs(receipt: CanonicalReceipt, protocolAddress: Address): DeliveryEventLog[];
+
+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 };