@arcanetech/privacy-sdk-stellar 0.2.0 → 0.2.3

package/dist/node.d.ts

@@ -0,0 +1,739 @@
+import * as _arcanetech_privacy_sdk_core from '@arcanetech/privacy-sdk-core';
+import { OperationKind, DepositIntent, TransferIntent, WithdrawIntent, createRejectedOperation } from '@arcanetech/privacy-sdk-core';
+export { isPreparedOperation } from '@arcanetech/privacy-sdk-core';
+import * as _arcanetech_privacy_sdk_core_state from '@arcanetech/privacy-sdk-core/state';
+import { StateBridgeAdapter } from '@arcanetech/privacy-sdk-core/state';
+import { OnboardingPayload } from 'contract';
+import { AuditPublicKey } from '@auditable/privacy-pool-zk-sdk';
+
+type StellarPrivateRecordStatus = 'pending' | 'finalized' | 'spent';
+interface StellarPrivateCoinNote {
+    value: string;
+    nullifier: string;
+    secret: string;
+    commitment: string;
+    asset_hi: string;
+    asset_lo: string;
+    application_id?: string;
+}
+type StellarRegistryStatus = 'registered' | 'unregistered';
+type StellarTrustlineStatus = 'active' | 'inactive' | 'none';
+type StellarTransactionConfirmationStatus = 'pending' | 'success' | 'failed';
+interface StellarAsset {
+    id: number;
+    assetId: StellarAssetId;
+    name: string;
+    logoUrl: string | null;
+    issuerAddress: string | null;
+    clientContract: string | null;
+    poolContracts: string[];
+    poolContract: string;
+    mintable: boolean;
+    mintAmount: string | null;
+    decimals?: number | null;
+}
+interface StellarAssetsCatalog {
+    byId: Record<StellarAssetId, StellarAsset>;
+    listOrder: StellarAssetId[];
+}
+interface StellarPublicBalance {
+    owner: StellarAddress;
+    asset: StellarAssetId;
+    balance: string;
+    trustlineStatus: StellarTrustlineStatus;
+}
+interface StellarRegistryLookup {
+    owner: StellarAddress;
+    status: StellarRegistryStatus;
+    privateAddressStpl1?: string;
+    publicKeyXHex?: string;
+    publicKeyYHex?: string;
+    updatedAtLedger?: number;
+    cachedAt?: string;
+}
+interface StellarWalletPrivateAddressScalar {
+    owner: StellarAddress;
+    nonce: string;
+    scalarHex: string;
+    updatedAt?: string;
+}
+interface StellarWalletPrivateAddressRecord {
+    owner: StellarAddress;
+    nonce: string;
+    privateAddress: string;
+    createdAt: number;
+}
+interface StellarPoolMerkleState {
+    poolContract: string;
+    commitments: string[];
+    commitmentCount: number;
+    merkleRootHex: string;
+    updatedAt: number;
+    syncedLedger?: number;
+}
+interface StellarLeafEphemeral {
+    poolContract: string;
+    leafIndex: number;
+    xHex: string;
+    yHex: string;
+    cachedAt?: string;
+}
+interface StellarPendingClaim {
+    id: string;
+    owner: StellarAddress;
+    asset: StellarAssetId;
+    amount: bigint;
+    createdAt: string;
+    poolTxId?: string;
+    commitmentHex?: string;
+    nullifierHex?: string;
+    futureNullifierHashHex?: string;
+    assetHiHex?: string;
+    assetLoHex?: string;
+    nullifierFieldHex?: string;
+    secretHex?: string;
+    tempPublicKeyXHex?: string;
+    tempPublicKeyYHex?: string;
+    encryptedRecoveryBase64?: string;
+    createdAtLedger?: number;
+}
+interface StellarPendingClaimsPagination {
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}
+interface StellarPendingClaimsState {
+    items: StellarPendingClaim[];
+    pagination?: StellarPendingClaimsPagination;
+}
+interface StellarIncomingDelivery {
+    id: number;
+    privateAddress: string;
+    asset: StellarAssetId;
+    ciphertextBase64: string;
+    ephemeralKey: string;
+    tagBase64: string;
+    createdAt: string;
+    processed?: boolean;
+}
+interface StellarDeliverySyncState {
+    privateAddress: string;
+    asset: StellarAssetId;
+    bloomM: number;
+    bloomK: number;
+    bloomBitsBase64?: string;
+    lastPage?: number;
+    lastPolledAt?: string;
+}
+interface StellarPrivateRecord {
+    id: string;
+    owner: StellarAddress;
+    asset: StellarAssetId;
+    amount: bigint;
+    consumed: boolean;
+    status?: StellarPrivateRecordStatus;
+    poolContract?: string;
+    commitmentHex?: string;
+    nullifierHex?: string;
+    amountDisplay?: number;
+    deliveryId?: number;
+    privateAddress?: string;
+    txHash?: string;
+    coinNote?: StellarPrivateCoinNote;
+    depositScalarHex?: string;
+    precommitementHex?: string;
+}
+interface StellarPrivateAssetRow {
+    assetId: StellarAssetId;
+    poolContract: string;
+    totalAmount: bigint;
+    totalAmountDisplay: number;
+}
+interface StellarTransactionStatus {
+    txHash: string;
+    status: StellarTransactionConfirmationStatus;
+    ledger?: number;
+    createdAt?: string;
+}
+interface StellarAvailablePrivateRecordsFilter {
+    owner?: StellarAddress;
+    privateAddress?: string;
+    asset?: StellarAssetId;
+}
+interface StellarPendingClaimsFilter {
+    owner?: StellarAddress;
+    asset?: StellarAssetId;
+}
+interface StellarIncomingDeliveriesFilter {
+    privateAddress: string;
+    asset?: StellarAssetId;
+    includeProcessed?: boolean;
+}
+
+type KytApplicationIdHints = [string, string, string, string];
+
+type StellarPendingClaimSource = {
+    kind: 'pendingClaim';
+    claimId: string;
+} | {
+    kind: 'pendingClaim';
+    claim: StellarPendingClaim;
+};
+type StellarTransferFromAddress = StellarAddress | StellarPendingClaimSource;
+
+interface PoolMerkleStatePort {
+    get(poolContract: string): Promise<StellarPoolMerkleState | undefined>;
+    set(state: StellarPoolMerkleState): Promise<void>;
+}
+interface LeafEphemeralStatePort {
+    get(input: {
+        poolContract: string;
+        leafIndex: number;
+    }): Promise<StellarLeafEphemeral | undefined>;
+    set(ephemeral: StellarLeafEphemeral): Promise<void>;
+}
+
+type StellarSignTransaction = (input: {
+    xdr: string;
+    networkPassphrase: string;
+    address: string;
+}) => Promise<{
+    signedTxXdr: string;
+}>;
+
+interface TransferTemporaryRecipientKey {
+    temporaryScalarHex: string;
+    temporaryPrivateAddressStpl1: string;
+}
+interface TransferOnboardingRecipientNoteInput {
+    tokenAddress: string;
+    nullifier: string;
+    secret: string;
+    value: string;
+}
+interface TransferRecipientExecutionContext {
+    recipientPrivateAddressStpl1: string;
+    recipientStellarAddress?: string;
+    temporaryRecipientKey?: TransferTemporaryRecipientKey;
+}
+interface BuildTransferOnboardingAtExecuteInput {
+    ownerStellarAddress: string;
+    temporaryRecipientKey: TransferTemporaryRecipientKey;
+    recipientNote: TransferOnboardingRecipientNoteInput;
+}
+interface StellarKytEnvironment {
+    apiBaseUrl: string;
+    kytPassageRegistryContract: string;
+    registerPassageOnChain?: boolean;
+}
+interface StellarTransactEnvironment {
+    network: StellarNetworkConfig;
+    auditPublicKey?: AuditPublicKey;
+    kyt: StellarKytEnvironment;
+    signTransaction?: StellarSignTransaction;
+    resolveTokenContractId?: (assetId: StellarAssetId) => string | Promise<string>;
+    resolveSenderPrivKeyScalarHex?: (privateAddressStpl1: string) => Promise<string>;
+    readSenderPrivKeyScalarHex?: (privateAddressStpl1: string) => Promise<string | undefined>;
+    ensureSenderPrivKeyScalarHex?: (privateAddressStpl1: string) => Promise<string>;
+    resolveSenderPrivKeyScalarFromState?: (input: {
+        owner: string;
+        privateAddressStpl1: string;
+    }) => Promise<string | undefined>;
+    resolveTransferRecipientAtExecute?: (input: {
+        recipientStellarAddress: string;
+        walletPublicKey: string;
+    }) => Promise<TransferRecipientExecutionContext>;
+    buildTransferOnboardingAtExecute?: (input: BuildTransferOnboardingAtExecuteInput) => Promise<OnboardingPayload>;
+    resolveWalletPublicKey?: () => Promise<string>;
+    poolMerkleState?: PoolMerkleStatePort;
+    leafEphemeral?: LeafEphemeralStatePort;
+}
+
+type StellarAddress = string;
+type StellarAssetId = string;
+
+type StellarTransferIntent = TransferIntent<StellarTransferFromAddress, StellarAssetId, bigint, StellarAddress>;
+
+interface StellarPreparedOperation {
+    kind: OperationKind;
+    intent: DepositIntent<StellarAddress, StellarAssetId, bigint> | StellarTransferIntent | WithdrawIntent<StellarAddress, StellarAssetId, bigint>;
+    consumedRecords: StellarPrivateRecord[];
+    outputRecords: StellarPrivateRecord[];
+    submissionPayload: StellarSubmissionPayload;
+    transactArtifacts?: StellarTransactArtifacts;
+}
+interface StellarSubmissionPayload {
+    operationId: string;
+    signed: boolean;
+    txHash?: string;
+}
+interface StellarTransactArtifacts {
+    proofHex?: string;
+    publicHex?: string;
+    applicationIdsPlaintext?: KytApplicationIdHints;
+    tokenAddress?: string;
+    depositScalarHex?: string;
+    precommitementHex?: string;
+    commitmentHex?: string;
+    walletPublicKey?: string;
+    onboarding?: OnboardingPayload;
+    executeFinalizeRequired?: boolean;
+    pendingClaim?: StellarPendingClaim;
+    spendSource?: 'privateAddress' | 'pendingClaim';
+}
+interface StellarOperationReceipt {
+    operationId: string;
+    confirmed: boolean;
+}
+interface StellarNetworkConfig {
+    id: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+    poolContract: string;
+    registryContract: string;
+    applicationId: string;
+}
+interface StellarBrowserAssets {
+    sdkWasm: ArrayBuffer;
+    circuitWasm: ArrayBuffer;
+    provingKey: ArrayBuffer;
+}
+interface StellarWalletAdapter {
+    getAddress(): Promise<StellarAddress>;
+    authorizeMessage(message: Uint8Array | string): Promise<Uint8Array>;
+    signTransactionPayload(payload: StellarSubmissionPayload): Promise<StellarSubmissionPayload>;
+}
+/** @internal Bridge-backed storage adapter; consumers pass {@link StateBridgeAdapter} instead. */
+type StellarStateAdapter = StateBridgeAdapter;
+interface StellarPolicyAdapter {
+    inspectOperation(kind: OperationKind, intent: DepositIntent<StellarAddress, StellarAssetId, bigint> | StellarTransferIntent | WithdrawIntent<StellarAddress, StellarAssetId, bigint>): Promise<void>;
+}
+interface StellarTransactEngine {
+    prepare(prepared: StellarPreparedOperation): Promise<StellarPreparedOperation>;
+    submit(prepared: StellarPreparedOperation, signedPayload: StellarSubmissionPayload): Promise<StellarOperationReceipt>;
+}
+interface StellarPrivacyClientConfigBase {
+    network: StellarNetworkConfig;
+    wallet: StellarWalletAdapter;
+    state: StellarStateAdapter;
+    auditPublicKeyHex?: string;
+    policy?: StellarPolicyAdapter;
+    transactEngine?: StellarTransactEngine;
+}
+
+interface StellarBrowserPrivacyClientConfig extends StellarPrivacyClientConfigBase {
+    assets: StellarBrowserAssets;
+    transactEnvironment?: StellarTransactEnvironment;
+}
+/** Browser entrypoint config alias. */
+type StellarPrivacyClientConfig = StellarBrowserPrivacyClientConfig;
+interface ResolvedStellarPrivacyClientConfig extends Omit<StellarPrivacyClientConfigBase, 'transactEngine'> {
+    transactEngine: StellarTransactEngine;
+    transactEnvironment?: StellarTransactEnvironment;
+}
+
+interface FetchContractMerkleResult {
+    commitmentCount: number;
+    commitments: string[];
+    merkleRootHex: string;
+    updatedAt: number;
+}
+
+type StellarTransactionDetails = {
+    txHash: string;
+    status: StellarTransactionConfirmationStatus;
+    ledger?: number;
+    createdAt?: string;
+    invokedPoolContractId?: string;
+    transferAmountRaw?: string;
+};
+
+interface StellarPublicBalanceInput {
+    owner: StellarAddress;
+    asset: StellarAssetId;
+    balance: string;
+    trustlineStatus: 'active' | 'inactive' | 'none';
+}
+
+declare function composeStellarStateService(adapter: StateBridgeAdapter): {
+    getTransactionStatus(txHash: string): Promise<StellarTransactionStatus | undefined>;
+    setTransactionStatus(status: StellarTransactionStatus): Promise<void>;
+    clearTransactionStatus(txHash: string): Promise<void>;
+    pruneConsumedPrivateRecords: () => Promise<void>;
+    getPrivateRecords: () => Promise<StellarPrivateRecord[]>;
+    getAvailablePrivateRecords: (filter: StellarAvailablePrivateRecordsFilter) => Promise<StellarPrivateRecord[]>;
+    listPrivateRecords: (filter: {
+        owner?: StellarAddress;
+        privateAddress?: string;
+        asset?: StellarAssetId;
+        amount?: bigint;
+    }) => Promise<StellarPrivateRecord[]>;
+    savePrivateRecords: (records: StellarPrivateRecord[]) => Promise<void>;
+    upsertPrivateRecords: (records: StellarPrivateRecord[]) => Promise<void>;
+    markPrivateRecordsUsed: (records: StellarPrivateRecord[]) => Promise<void>;
+    markPrivateRecordsStatus: (records: StellarPrivateRecord[], status: StellarPrivateRecordStatus) => Promise<void>;
+    getPrivateBalance: (input: {
+        owner: StellarAddress;
+        asset: StellarAssetId;
+    }) => Promise<bigint>;
+    getPrivateAssetRows: (owner: StellarAddress) => Promise<StellarPrivateAssetRow[]>;
+    getDeliverySyncState(input: {
+        privateAddress: string;
+        asset: StellarAssetId;
+    }): Promise<StellarDeliverySyncState | undefined>;
+    setDeliverySyncState(syncState: StellarDeliverySyncState): Promise<void>;
+    getIncomingDeliveries: (filter: StellarIncomingDeliveriesFilter) => Promise<StellarIncomingDelivery[]>;
+    upsertIncomingDeliveries: (deliveries: StellarIncomingDelivery[]) => Promise<void>;
+    markDeliveryProcessed(id: number): Promise<void>;
+    getPendingClaims: (filter?: StellarPendingClaimsFilter) => Promise<StellarPendingClaimsState>;
+    getPendingClaimsCount(owner: StellarAddress): Promise<number | undefined>;
+    appendPendingClaims: (claims: StellarPendingClaim[], paginationInfo: StellarPendingClaimsPagination) => Promise<void>;
+    replacePendingClaimsPage: (input: {
+        owner: StellarAddress;
+        claims: StellarPendingClaim[];
+        paginationInfo: StellarPendingClaimsPagination;
+        count?: number;
+    }) => Promise<void>;
+    upsertPendingClaims: (claims: StellarPendingClaim[]) => Promise<void>;
+    removePendingClaims: (ids: string[]) => Promise<void>;
+    clearPendingClaims: (input?: {
+        owner?: StellarAddress;
+        asset?: StellarAssetId;
+    }) => Promise<void>;
+    setPendingClaimsCount: (owner: StellarAddress, count: number) => Promise<void>;
+    getLeafEphemeral(input: {
+        poolContract: string;
+        leafIndex: number;
+    }): Promise<StellarLeafEphemeral | undefined>;
+    setLeafEphemeral(ephemeral: StellarLeafEphemeral): Promise<void>;
+    getPoolMerkleState(poolContract: string): Promise<StellarPoolMerkleState | undefined>;
+    setPoolMerkleState(state: StellarPoolMerkleState): Promise<void>;
+    appendPoolCommitments(input: {
+        poolContract: string;
+        commitments: string[];
+        merkleRootHex: string;
+        syncedLedger?: number;
+    }): Promise<void>;
+    getWalletPrivateAddressRecord(input: {
+        owner: StellarAddress;
+        nonce: string;
+    }): Promise<StellarWalletPrivateAddressRecord | undefined>;
+    saveWalletPrivateAddressRecord(record: StellarWalletPrivateAddressRecord): Promise<void>;
+    getWalletDefaultPrivateAddressNonce(owner: StellarAddress): Promise<string | undefined>;
+    setWalletDefaultPrivateAddressNonce(input: {
+        owner: StellarAddress;
+        nonce: string;
+    }): Promise<void>;
+    getWalletPrivateAddressScalar(input: {
+        owner: StellarAddress;
+        nonce: string;
+    }): Promise<StellarWalletPrivateAddressScalar | undefined>;
+    saveWalletPrivateAddressScalar(scalar: StellarWalletPrivateAddressScalar): Promise<void>;
+    deleteWalletPrivateAddressScalar(input: {
+        owner: StellarAddress;
+        nonce: string;
+    }): Promise<void>;
+    saveRegistryLookup(lookup: StellarRegistryLookup): Promise<void>;
+    saveRegisteredPrivateAddress(input: {
+        address: StellarAddress;
+        privateAddress: string;
+        registered: boolean;
+    }): Promise<void>;
+    invalidateRegistryLookup: (address: StellarAddress) => Promise<void>;
+    invalidateRegisteredAddress(address: StellarAddress): Promise<void>;
+    getRegistryLookup: (address: StellarAddress) => Promise<StellarRegistryLookup | undefined>;
+    isStellarAddressRegistered(address: StellarAddress): Promise<boolean | undefined>;
+    getCachedPrivateAddress: (address: StellarAddress) => Promise<string | undefined>;
+    getPublicBalance(input: {
+        owner: StellarAddress;
+        asset: StellarAssetId;
+    }): Promise<StellarPublicBalance | undefined>;
+    getPublicBalances(owner: StellarAddress): Promise<StellarPublicBalance[]>;
+    setPublicBalance(balance: StellarPublicBalanceInput): Promise<void>;
+    setPublicBalances(input: {
+        owner: StellarAddress;
+        balances: StellarPublicBalanceInput[];
+    }): Promise<void>;
+    upsertAssets(assets: StellarAsset[]): Promise<void>;
+    getAssetsCatalog: () => Promise<StellarAssetsCatalog>;
+    getAsset(assetId: StellarAssetId): Promise<StellarAsset | undefined>;
+    getAssets(): Promise<StellarAsset[]>;
+    getAssetsForPool(poolContract: string): Promise<StellarAsset[]>;
+    replaceAssets: (assets: StellarAsset[]) => Promise<void>;
+    bridge: _arcanetech_privacy_sdk_core_state.StateBridge;
+};
+type ComposedStellarStateService = ReturnType<typeof composeStellarStateService>;
+
+type StellarStateService = ComposedStellarStateService;
+
+declare function composeStellarPrivacyClient(config: ResolvedStellarPrivacyClientConfig): {
+    state: {
+        getTransactionStatus(txHash: string): Promise<StellarTransactionStatus | undefined>;
+        setTransactionStatus(status: StellarTransactionStatus): Promise<void>;
+        clearTransactionStatus(txHash: string): Promise<void>;
+        pruneConsumedPrivateRecords: () => Promise<void>;
+        getPrivateRecords: () => Promise<StellarPrivateRecord[]>;
+        getAvailablePrivateRecords: (filter: StellarAvailablePrivateRecordsFilter) => Promise<StellarPrivateRecord[]>;
+        listPrivateRecords: (filter: {
+            owner?: StellarAddress;
+            privateAddress?: string;
+            asset?: StellarAssetId;
+            amount?: bigint;
+        }) => Promise<StellarPrivateRecord[]>;
+        savePrivateRecords: (records: StellarPrivateRecord[]) => Promise<void>;
+        upsertPrivateRecords: (records: StellarPrivateRecord[]) => Promise<void>;
+        markPrivateRecordsUsed: (records: StellarPrivateRecord[]) => Promise<void>;
+        markPrivateRecordsStatus: (records: StellarPrivateRecord[], status: StellarPrivateRecordStatus) => Promise<void>;
+        getPrivateBalance: (input: {
+            owner: StellarAddress;
+            asset: StellarAssetId;
+        }) => Promise<bigint>;
+        getPrivateAssetRows: (owner: StellarAddress) => Promise<StellarPrivateAssetRow[]>;
+        getDeliverySyncState(input: {
+            privateAddress: string;
+            asset: StellarAssetId;
+        }): Promise<StellarDeliverySyncState | undefined>;
+        setDeliverySyncState(syncState: StellarDeliverySyncState): Promise<void>;
+        getIncomingDeliveries: (filter: StellarIncomingDeliveriesFilter) => Promise<StellarIncomingDelivery[]>;
+        upsertIncomingDeliveries: (deliveries: StellarIncomingDelivery[]) => Promise<void>;
+        markDeliveryProcessed(id: number): Promise<void>;
+        getPendingClaims: (filter?: StellarPendingClaimsFilter) => Promise<StellarPendingClaimsState>;
+        getPendingClaimsCount(owner: StellarAddress): Promise<number | undefined>;
+        appendPendingClaims: (claims: StellarPendingClaim[], paginationInfo: StellarPendingClaimsPagination) => Promise<void>;
+        replacePendingClaimsPage: (input: {
+            owner: StellarAddress;
+            claims: StellarPendingClaim[];
+            paginationInfo: StellarPendingClaimsPagination;
+            count?: number;
+        }) => Promise<void>;
+        upsertPendingClaims: (claims: StellarPendingClaim[]) => Promise<void>;
+        removePendingClaims: (ids: string[]) => Promise<void>;
+        clearPendingClaims: (input?: {
+            owner?: StellarAddress;
+            asset?: StellarAssetId;
+        }) => Promise<void>;
+        setPendingClaimsCount: (owner: StellarAddress, count: number) => Promise<void>;
+        getLeafEphemeral(input: {
+            poolContract: string;
+            leafIndex: number;
+        }): Promise<StellarLeafEphemeral | undefined>;
+        setLeafEphemeral(ephemeral: StellarLeafEphemeral): Promise<void>;
+        getPoolMerkleState(poolContract: string): Promise<StellarPoolMerkleState | undefined>;
+        setPoolMerkleState(state: StellarPoolMerkleState): Promise<void>;
+        appendPoolCommitments(input: {
+            poolContract: string;
+            commitments: string[];
+            merkleRootHex: string;
+            syncedLedger?: number;
+        }): Promise<void>;
+        getWalletPrivateAddressRecord(input: {
+            owner: StellarAddress;
+            nonce: string;
+        }): Promise<StellarWalletPrivateAddressRecord | undefined>;
+        saveWalletPrivateAddressRecord(record: StellarWalletPrivateAddressRecord): Promise<void>;
+        getWalletDefaultPrivateAddressNonce(owner: StellarAddress): Promise<string | undefined>;
+        setWalletDefaultPrivateAddressNonce(input: {
+            owner: StellarAddress;
+            nonce: string;
+        }): Promise<void>;
+        getWalletPrivateAddressScalar(input: {
+            owner: StellarAddress;
+            nonce: string;
+        }): Promise<StellarWalletPrivateAddressScalar | undefined>;
+        saveWalletPrivateAddressScalar(scalar: StellarWalletPrivateAddressScalar): Promise<void>;
+        deleteWalletPrivateAddressScalar(input: {
+            owner: StellarAddress;
+            nonce: string;
+        }): Promise<void>;
+        saveRegistryLookup(lookup: StellarRegistryLookup): Promise<void>;
+        saveRegisteredPrivateAddress(input: {
+            address: StellarAddress;
+            privateAddress: string;
+            registered: boolean;
+        }): Promise<void>;
+        invalidateRegistryLookup: (address: StellarAddress) => Promise<void>;
+        invalidateRegisteredAddress(address: StellarAddress): Promise<void>;
+        getRegistryLookup: (address: StellarAddress) => Promise<StellarRegistryLookup | undefined>;
+        isStellarAddressRegistered(address: StellarAddress): Promise<boolean | undefined>;
+        getCachedPrivateAddress: (address: StellarAddress) => Promise<string | undefined>;
+        getPublicBalance(input: {
+            owner: StellarAddress;
+            asset: StellarAssetId;
+        }): Promise<StellarPublicBalance | undefined>;
+        getPublicBalances(owner: StellarAddress): Promise<StellarPublicBalance[]>;
+        setPublicBalance(balance: StellarPublicBalanceInput): Promise<void>;
+        setPublicBalances(input: {
+            owner: StellarAddress;
+            balances: StellarPublicBalanceInput[];
+        }): Promise<void>;
+        upsertAssets(assets: StellarAsset[]): Promise<void>;
+        getAssetsCatalog: () => Promise<StellarAssetsCatalog>;
+        getAsset(assetId: StellarAssetId): Promise<StellarAsset | undefined>;
+        getAssets(): Promise<StellarAsset[]>;
+        getAssetsForPool(poolContract: string): Promise<StellarAsset[]>;
+        replaceAssets: (assets: StellarAsset[]) => Promise<void>;
+        bridge: _arcanetech_privacy_sdk_core_state.StateBridge;
+    };
+    operations: {
+        deposit: (intent: _arcanetech_privacy_sdk_core.DepositIntent<string, string, bigint>) => Promise<_arcanetech_privacy_sdk_core.OperationResult<"deposit", string, string, bigint, StellarPreparedOperation, StellarOperationReceipt>>;
+        withdraw: (intent: _arcanetech_privacy_sdk_core.WithdrawIntent<string, string, bigint>) => Promise<_arcanetech_privacy_sdk_core.OperationResult<"withdraw", string, string, bigint, StellarPreparedOperation, StellarOperationReceipt>>;
+        transfer: (intent: StellarTransferIntent) => Promise<_arcanetech_privacy_sdk_core.OperationResult<"transfer", string, string, bigint, StellarPreparedOperation, StellarOperationReceipt>>;
+    };
+    network: {
+        checkPrivateRecordSpendStatus: (spendInput: {
+            poolContractId?: string;
+            nullifier: string;
+            walletPublicKey: string;
+        }) => Promise<{
+            spent: boolean;
+            nullifierHashHex: string;
+        }>;
+        waitForTransactionConfirmation: (confirmationInput: {
+            txHash: string;
+            pollIntervalMs?: number;
+            timeoutMs?: number;
+        }) => Promise<StellarTransactionStatus>;
+        fetchTransactionConfirmationStatus: (txHash: string) => Promise<StellarTransactionStatus>;
+        getTransactionDetails: (txHash: string) => Promise<StellarTransactionDetails>;
+        checkRegistrationStatus: (registrationInput: {
+            address: StellarAddress;
+            walletPublicKey: string;
+        }) => Promise<StellarRegistryLookup>;
+        registerPrivateAddress: (registrationInput: {
+            owner: StellarAddress;
+            walletPublicKey: string;
+            privateAddressStpl1: string;
+        }) => Promise<StellarTransactionStatus>;
+        resolveTransferRecipient: (recipientInput: {
+            recipientStellarAddress: StellarAddress;
+            walletPublicKey: StellarAddress;
+        }) => Promise<TransferRecipientExecutionContext>;
+        syncPoolMerkleState: (poolInput: {
+            poolContractId: string;
+            walletPublicKey: string;
+        }) => Promise<FetchContractMerkleResult>;
+        syncPoolMerkleStates: (poolInput: {
+            poolContractIds: string[];
+            walletPublicKey: string;
+        }) => Promise<void>;
+        readPoolLeafEphemeralHex: (poolInput: {
+            poolContractId: string;
+            walletPublicKey: string;
+            leafIndex: number;
+        }) => Promise<{
+            xHex: string;
+            yHex: string;
+        }>;
+    };
+    transactEnvironment: StellarTransactEnvironment | undefined;
+};
+type ComposedStellarPrivacyClient = ReturnType<typeof composeStellarPrivacyClient>;
+
+interface LoadPendingClaimsFromBackendInput {
+    backendBaseUrl: string;
+    ownerAddress: StellarAddress;
+    asset?: StellarAssetId;
+    page?: number;
+    pageSize?: number;
+}
+interface LoadPendingClaimsCountFromBackendInput {
+    backendBaseUrl: string;
+    ownerAddress: StellarAddress;
+}
+
+declare function createStateDelegates(state: StellarStateService): {
+    getPrivateRecords: () => Promise<StellarPrivateRecord[]>;
+    getAvailablePrivateRecords: (filter: Parameters<StellarStateService["getAvailablePrivateRecords"]>[0]) => Promise<StellarPrivateRecord[]>;
+    getPrivateBalance: (input: Parameters<StellarStateService["getPrivateBalance"]>[0]) => Promise<bigint>;
+    getPrivateAssetRows: (owner: Parameters<StellarStateService["getPrivateAssetRows"]>[0]) => Promise<StellarPrivateAssetRow[]>;
+    upsertPrivateRecords: (records: Parameters<StellarStateService["upsertPrivateRecords"]>[0]) => Promise<void>;
+    markPrivateRecordsStatus: (records: Parameters<StellarStateService["markPrivateRecordsStatus"]>[0], status: Parameters<StellarStateService["markPrivateRecordsStatus"]>[1]) => Promise<void>;
+    pruneConsumedPrivateRecords: () => Promise<void>;
+    getTransactionStatus: (txHash: Parameters<StellarStateService["getTransactionStatus"]>[0]) => Promise<StellarTransactionStatus | undefined>;
+    setTransactionStatus: (status: Parameters<StellarStateService["setTransactionStatus"]>[0]) => Promise<void>;
+    clearTransactionStatus: (txHash: Parameters<StellarStateService["clearTransactionStatus"]>[0]) => Promise<void>;
+    getIncomingDeliveries: (filter: Parameters<StellarStateService["getIncomingDeliveries"]>[0]) => Promise<StellarIncomingDelivery[]>;
+    upsertIncomingDeliveries: (deliveries: Parameters<StellarStateService["upsertIncomingDeliveries"]>[0]) => Promise<void>;
+    markDeliveryProcessed: (id: Parameters<StellarStateService["markDeliveryProcessed"]>[0]) => Promise<void>;
+    getDeliverySyncState: (input: Parameters<StellarStateService["getDeliverySyncState"]>[0]) => Promise<StellarDeliverySyncState | undefined>;
+    setDeliverySyncState: (syncState: Parameters<StellarStateService["setDeliverySyncState"]>[0]) => Promise<void>;
+    appendPendingClaims: (claims: Parameters<StellarStateService["appendPendingClaims"]>[0], paginationInfo: Parameters<StellarStateService["appendPendingClaims"]>[1]) => Promise<void>;
+    loadPendingClaimsFromBackend: (input: LoadPendingClaimsFromBackendInput) => Promise<void>;
+    loadPendingClaimsCountFromBackend: (input: LoadPendingClaimsCountFromBackendInput) => Promise<void>;
+    replacePendingClaimsPage: (input: Parameters<StellarStateService["replacePendingClaimsPage"]>[0]) => Promise<void>;
+    upsertPendingClaims: (claims: Parameters<StellarStateService["upsertPendingClaims"]>[0]) => Promise<void>;
+    removePendingClaims: (ids: Parameters<StellarStateService["removePendingClaims"]>[0]) => Promise<void>;
+    clearPendingClaims: (input?: Parameters<StellarStateService["clearPendingClaims"]>[0]) => Promise<void>;
+    getPendingClaims: (filter?: Parameters<StellarStateService["getPendingClaims"]>[0]) => Promise<StellarPendingClaimsState>;
+    getPendingClaimsCount: (owner: Parameters<StellarStateService["getPendingClaimsCount"]>[0]) => Promise<number | undefined>;
+    setPendingClaimsCount: (owner: Parameters<StellarStateService["setPendingClaimsCount"]>[0], count: Parameters<StellarStateService["setPendingClaimsCount"]>[1]) => Promise<void>;
+    getPoolMerkleState: (poolContract: Parameters<StellarStateService["getPoolMerkleState"]>[0]) => Promise<StellarPoolMerkleState | undefined>;
+    setPoolMerkleState: (poolState: Parameters<StellarStateService["setPoolMerkleState"]>[0]) => Promise<void>;
+    appendPoolCommitments: (input: Parameters<StellarStateService["appendPoolCommitments"]>[0]) => Promise<void>;
+    getLeafEphemeral: (input: Parameters<StellarStateService["getLeafEphemeral"]>[0]) => Promise<StellarLeafEphemeral | undefined>;
+    setLeafEphemeral: (ephemeral: Parameters<StellarStateService["setLeafEphemeral"]>[0]) => Promise<void>;
+    getRegistryLookup: (address: Parameters<StellarStateService["getRegistryLookup"]>[0]) => Promise<StellarRegistryLookup | undefined>;
+    isStellarAddressRegistered: (address: Parameters<StellarStateService["isStellarAddressRegistered"]>[0]) => Promise<boolean | undefined>;
+    getCachedPrivateAddress: (address: Parameters<StellarStateService["getCachedPrivateAddress"]>[0]) => Promise<string | undefined>;
+    saveRegistryLookup: (lookup: Parameters<StellarStateService["saveRegistryLookup"]>[0]) => Promise<void>;
+    getWalletPrivateAddressScalar: (input: Parameters<StellarStateService["getWalletPrivateAddressScalar"]>[0]) => Promise<StellarWalletPrivateAddressScalar | undefined>;
+    saveWalletPrivateAddressScalar: (scalar: Parameters<StellarStateService["saveWalletPrivateAddressScalar"]>[0]) => Promise<void>;
+    getWalletPrivateAddressRecord: (input: Parameters<StellarStateService["getWalletPrivateAddressRecord"]>[0]) => Promise<StellarWalletPrivateAddressRecord | undefined>;
+    saveWalletPrivateAddressRecord: (record: Parameters<StellarStateService["saveWalletPrivateAddressRecord"]>[0]) => Promise<void>;
+    getWalletDefaultPrivateAddressNonce: (owner: Parameters<StellarStateService["getWalletDefaultPrivateAddressNonce"]>[0]) => Promise<string | undefined>;
+    setWalletDefaultPrivateAddressNonce: (input: Parameters<StellarStateService["setWalletDefaultPrivateAddressNonce"]>[0]) => Promise<void>;
+    deleteWalletPrivateAddressScalar: (input: Parameters<StellarStateService["deleteWalletPrivateAddressScalar"]>[0]) => Promise<void>;
+    saveRegisteredPrivateAddress: (input: Parameters<StellarStateService["saveRegisteredPrivateAddress"]>[0]) => Promise<void>;
+    invalidateRegistryLookup: (address: Parameters<StellarStateService["invalidateRegistryLookup"]>[0]) => Promise<void>;
+    invalidateRegisteredAddress: (address: Parameters<StellarStateService["invalidateRegisteredAddress"]>[0]) => Promise<void>;
+    getAssets: () => Promise<StellarAsset[]>;
+    getAssetsCatalog: () => Promise<StellarAssetsCatalog>;
+    getAsset: (assetId: Parameters<StellarStateService["getAsset"]>[0]) => Promise<StellarAsset | undefined>;
+    getAssetsForPool: (poolContract: string) => Promise<StellarAsset[]>;
+    replaceAssets: (assets: Parameters<StellarStateService["replaceAssets"]>[0]) => Promise<void>;
+    upsertAssets: (assets: Parameters<StellarStateService["upsertAssets"]>[0]) => Promise<void>;
+    getPublicBalance: (input: Parameters<StellarStateService["getPublicBalance"]>[0]) => Promise<StellarPublicBalance | undefined>;
+    getPublicBalances: (owner: Parameters<StellarStateService["getPublicBalances"]>[0]) => Promise<StellarPublicBalance[]>;
+    setPublicBalance: (balance: Parameters<StellarStateService["setPublicBalance"]>[0]) => Promise<void>;
+    setPublicBalances: (input: Parameters<StellarStateService["setPublicBalances"]>[0]) => Promise<void>;
+};
+type StellarPrivacyClientStateDelegates = ReturnType<typeof createStateDelegates>;
+
+type StellarPrivacyClientNetwork = ComposedStellarPrivacyClient['network'];
+type StellarPrivacyClientOperations = ComposedStellarPrivacyClient['operations'];
+type StellarPrivacyClient = {
+    readonly state: ComposedStellarPrivacyClient['state'];
+    deposit: StellarPrivacyClientOperations['deposit'];
+    transfer: (intent: StellarTransferIntent) => ReturnType<StellarPrivacyClientOperations['transfer']>;
+    withdraw: StellarPrivacyClientOperations['withdraw'];
+    syncPoolMerkleState: StellarPrivacyClientNetwork['syncPoolMerkleState'];
+    syncPoolMerkleStates: StellarPrivacyClientNetwork['syncPoolMerkleStates'];
+    readPoolLeafEphemeralHex: StellarPrivacyClientNetwork['readPoolLeafEphemeralHex'];
+    checkRegistrationStatus: StellarPrivacyClientNetwork['checkRegistrationStatus'];
+    registerPrivateAddress: StellarPrivacyClientNetwork['registerPrivateAddress'];
+    resolveTransferRecipient: StellarPrivacyClientNetwork['resolveTransferRecipient'];
+    checkPrivateRecordSpendStatus: StellarPrivacyClientNetwork['checkPrivateRecordSpendStatus'];
+    waitForTransactionConfirmation: StellarPrivacyClientNetwork['waitForTransactionConfirmation'];
+    fetchTransactionConfirmationStatus: StellarPrivacyClientNetwork['fetchTransactionConfirmationStatus'];
+    getTransactionDetails: StellarPrivacyClientNetwork['getTransactionDetails'];
+} & StellarPrivacyClientStateDelegates;
+
+declare function createStellarPrivacyClientFromResolvedConfig(config: ResolvedStellarPrivacyClientConfig): StellarPrivacyClient;
+
+interface StellarNodeAssets {
+    sdkWasmPath: string;
+    circuitWasmPath: string;
+    provingKeyPath: string;
+}
+interface StellarNodePrivacyClientConfig extends StellarPrivacyClientConfigBase {
+    assets: StellarNodeAssets;
+}
+
+type CreateStellarPrivacyClientResult = StellarPrivacyClient | ReturnType<typeof createRejectedOperation>;
+declare function isStellarPrivacyClient(result: CreateStellarPrivacyClientResult): result is StellarPrivacyClient;
+declare function createStellarPrivacyClient(config: StellarBrowserPrivacyClientConfig): Promise<CreateStellarPrivacyClientResult>;
+
+declare function createStellarPrivacyClientFromNodeConfig(config: StellarNodePrivacyClientConfig): Promise<ReturnType<typeof createStellarPrivacyClientFromResolvedConfig> | ReturnType<typeof createRejectedOperation>>;
+
+export { type CreateStellarPrivacyClientResult, type StellarBrowserPrivacyClientConfig, type StellarNodeAssets, type StellarNodePrivacyClientConfig, type StellarPrivacyClientConfig, createStellarPrivacyClient, createStellarPrivacyClientFromNodeConfig, isStellarPrivacyClient };