@arcanetech/privacy-sdk-stellar 0.2.0 → 0.2.3

package/dist/index.d.ts

@@ -0,0 +1,1051 @@
+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, StateBridgeDefinition } from '@arcanetech/privacy-sdk-core/state';
+import { OnboardingPayload } from 'contract';
+export { OnboardingPayload, PrivateAddressRegistration } from 'contract';
+import { DepositObject, CoinData, AuditPublicKey, PrivacyPoolSDK, StateFile, TransactionAuditParams, InspectKytPassageApproved } from '@auditable/privacy-pool-zk-sdk';
+export { DEFAULT_STEALTH_SIGN_NONCE as DEFAULT_PRIVATE_ADDRESS_SIGN_NONCE } from '@auditable/privacy-pool-zk-sdk';
+import { Buffer as Buffer$1 } from 'buffer';
+
+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 AlignedDepositSlot = {
+    deposit: DepositObject;
+    commitment_hex: string;
+    coin: CoinData;
+    depositScalarHex: string;
+    precommitementHex: string;
+};
+type KytApplicationIdHints = [string, string, string, string];
+type ProofResult = {
+    proof_hex: string;
+    public_hex: string;
+    applicationIdsPlaintext: KytApplicationIdHints;
+};
+type ProofWithChange = ProofResult & {
+    changeCoin?: {
+        commitment_hex: string;
+        coin: CoinData;
+        depositScalarHex: string;
+        precommitementHex: 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$1 {
+    tokenAddress: string;
+    nullifier: string;
+    secret: string;
+    value: string;
+}
+interface TransferRecipientExecutionContext {
+    recipientPrivateAddressStpl1: string;
+    recipientStellarAddress?: string;
+    temporaryRecipientKey?: TransferTemporaryRecipientKey;
+}
+interface BuildTransferOnboardingAtExecuteInput {
+    ownerStellarAddress: string;
+    temporaryRecipientKey: TransferTemporaryRecipientKey;
+    recipientNote: TransferOnboardingRecipientNoteInput$1;
+}
+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;
+}
+declare function fetchAndMergeMerkleState(parameters: {
+    poolContractId: string;
+    walletPublicKey: string;
+    transactEnvironment: StellarTransactEnvironment;
+    poolMerkleState?: PoolMerkleStatePort;
+}): Promise<FetchContractMerkleResult>;
+declare function readLeafEphemeralHex(parameters: {
+    poolContractId: string;
+    walletPublicKey: string;
+    leafIndex: number;
+    transactEnvironment: StellarTransactEnvironment;
+    leafEphemeral?: LeafEphemeralStatePort;
+}): Promise<{
+    xHex: string;
+    yHex: string;
+}>;
+
+type StellarTransactionDetails = {
+    txHash: string;
+    status: StellarTransactionConfirmationStatus;
+    ledger?: number;
+    createdAt?: string;
+    invokedPoolContractId?: string;
+    transferAmountRaw?: string;
+};
+
+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 readPrivateRecordsFromStateSnapshot(state: unknown): StellarPrivateRecord[];
+declare function readWalletPrivateAddressScalarFromStateSnapshot(input: {
+    state: unknown;
+    owner: string;
+    nonce: string;
+}): StellarWalletPrivateAddressScalar | undefined;
+declare function readWalletPrivateAddressRecordFromStateSnapshot(input: {
+    state: unknown;
+    owner: string;
+    nonce: string;
+}): StellarWalletPrivateAddressRecord | undefined;
+declare function readWalletDefaultPrivateAddressNonceFromStateSnapshot(input: {
+    state: unknown;
+    owner: string;
+}): string | undefined;
+declare function listWalletPrivateAddressScalarsForOwnerFromStateSnapshot(input: {
+    state: unknown;
+    owner: string;
+}): StellarWalletPrivateAddressScalar[];
+declare function listWalletPrivateAddressRecordsForOwnerFromStateSnapshot(input: {
+    state: unknown;
+    owner: string;
+}): StellarWalletPrivateAddressRecord[];
+
+declare const stellarStateDefinitions: StateBridgeDefinition[];
+
+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 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;
+
+type CreateStellarPrivacyClientResult = StellarPrivacyClient | ReturnType<typeof createRejectedOperation>;
+declare function isStellarPrivacyClient(result: CreateStellarPrivacyClientResult): result is StellarPrivacyClient;
+declare function createStellarPrivacyClient(config: StellarBrowserPrivacyClientConfig): Promise<CreateStellarPrivacyClientResult>;
+
+declare function resolveStellarPrivacyClientConfig<TConfig extends StellarPrivacyClientConfigBase>(config: TConfig, createEngine: (config: TConfig) => Promise<StellarTransactEngine>): Promise<{
+    ok: true;
+    config: ResolvedStellarPrivacyClientConfig & TConfig;
+} | {
+    ok: false;
+    result: ReturnType<typeof createRejectedOperation>;
+}>;
+declare function createStellarPrivacyClientFromResolvedConfig(config: ResolvedStellarPrivacyClientConfig): StellarPrivacyClient;
+
+declare function createDefaultTransactEngine(assets: StellarBrowserAssets, transactEnvironment?: StellarTransactEnvironment): Promise<StellarTransactEngine>;
+declare function createStellarPolicyAdapterFromEnvironment(transactEnvironment: StellarTransactEnvironment): {
+    inspectOperation: (_kind: StellarPreparedOperation["kind"], _intent: StellarPreparedOperation["intent"]) => Promise<void>;
+};
+
+declare class PrivacyPoolService {
+    private readonly assets?;
+    private readonly applicationId?;
+    private readonly auditPublicKey?;
+    private sdk;
+    private initPromise;
+    constructor(assets?: StellarBrowserAssets | undefined, applicationId?: string | undefined, auditPublicKey?: [string, string] | undefined);
+    private ensureInit;
+    getInitializedSdk(): Promise<PrivacyPoolSDK>;
+    getAuditPublicKey(): [string, string] | undefined;
+    getApplicationId(): string;
+    generatePrivateAddressFromStellarSignature(signature: string): Promise<string>;
+    sharedSecretX(recipientScalarHex: string, ephemeralKeyEncoded: string): Promise<string>;
+    buildAlignedDepositSlot(parameters: {
+        privateAddressStpl1: string;
+        amountStroops: bigint;
+        tokenAddress: string;
+    }): Promise<AlignedDepositSlot>;
+    createAlignedShieldCoinData(parameters: {
+        privateAddressStpl1: string;
+        amountStroops: bigint;
+        tokenAddress: string;
+    }): Promise<Omit<AlignedDepositSlot, 'deposit'>>;
+    prepareDepositTransactProof(parameters: {
+        privateAddressStpl1: string;
+        coin: CoinData;
+        depositScalarHex: string;
+        merkleRootBytes: Buffer$1;
+        tokenAddress: string;
+    }): Promise<ProofResult>;
+    calculateNullifierHash(nullifier: string): Promise<string>;
+    prepareWithdrawTransactProof(parameters: {
+        coin: CoinData;
+        state: StateFile;
+        destinationStellarAddress: string;
+        privKeyScalarHex: string;
+        depositorEphemeralKey: string;
+        withdrawAmountStroops: bigint;
+        changePrivateAddressStpl1: string | undefined;
+        tokenAddress: string;
+    }): Promise<ProofWithChange>;
+    prepareWithdrawTransactProofDual(parameters: {
+        coinA: CoinData;
+        coinB: CoinData;
+        state: StateFile;
+        destinationStellarAddress: string;
+        privKeyScalarHex: string;
+        depositorEphemeralAKey: string;
+        depositorEphemeralBKey: string;
+        withdrawAmountStroops: bigint;
+        changePrivateAddressStpl1: string | undefined;
+        tokenAddress: string;
+    }): Promise<ProofWithChange>;
+}
+
+declare function createPrivacyPoolService(input?: {
+    assets?: StellarBrowserAssets;
+    applicationId?: string;
+    auditPublicKey?: [string, string];
+}): PrivacyPoolService;
+declare function configurePrivacyPoolService(service: PrivacyPoolService): void;
+declare function getPrivacyPoolService(): PrivacyPoolService;
+
+declare function parseAuditPublicKeyFromEnvHex(raw: string): AuditPublicKey;
+declare function buildPoolTransactionAuditParameters(input: {
+    applicationId: string;
+    auditPublicKey?: AuditPublicKey;
+}): TransactionAuditParams;
+declare function resolvePoolApplicationId(applicationId: string | undefined): string;
+
+type DecodedPrivateAddress = {
+    x: string;
+    y: string;
+};
+type PrivateAddressGenerator = (signature: string) => string | Promise<string>;
+type PrivateAddressSdk = {
+    generatePrivateAddressFromStellarSignature: PrivateAddressGenerator;
+};
+declare function buildPrivateAddressSignMessage(publicKey: string, nonce: string): string;
+declare function decodePrivateAddress(value: string): DecodedPrivateAddress;
+declare function encodePrivateAddress(decoded: DecodedPrivateAddress): string;
+declare function encodePrivateAddressFromHexCoordinates(publicKeyXHex: string, publicKeyYHex: string): string;
+declare function recipientPublicKeysDecimalFromPrivateAddress(value: string): unknown;
+declare function privateAddressSdk(sdk: PrivacyPoolSDK): PrivateAddressSdk;
+
+interface LoadBrowserAssetsInput {
+    sdkWasmUrl: string;
+    circuitWasmUrl: string;
+    provingKeyUrl: string;
+    cacheBust?: boolean;
+}
+declare function loadStellarBrowserAssets(input: LoadBrowserAssetsInput): Promise<StellarBrowserAssets>;
+declare function loadDefaultStellarBrowserAssets(options?: {
+    cacheBust?: boolean;
+}): Promise<StellarBrowserAssets>;
+
+declare function generateTemporaryRecipientPrivateAddress(): Promise<{
+    temporaryScalarHex: string;
+    temporaryPrivateAddressStpl1: string;
+}>;
+
+type TransferOnboardingRecipientNoteInput = {
+    tokenAddress: string;
+    nullifier: string;
+    secret: string;
+    value: string;
+};
+type TemporaryRecipientKeyMaterial = {
+    temporaryScalarHex: string;
+    temporaryPrivateAddressStpl1: string;
+};
+declare function generateRandomDepositScalarHex(): Promise<string>;
+declare function buildOnboardingPayload(parameters: {
+    ownerStellarAddress: string;
+    temporaryKey: TemporaryRecipientKeyMaterial;
+    recipientNotes: TransferOnboardingRecipientNoteInput[];
+    permanentPrivateAddressStpl1?: string;
+}): OnboardingPayload;
+declare function buildTransferOnboardingAtExecute(input: BuildTransferOnboardingAtExecuteInput): Promise<OnboardingPayload>;
+
+declare class KytInspectError extends Error {
+    readonly reasonCode: string;
+    readonly decisionId?: string;
+    readonly detailAddress?: string;
+    constructor(parameters: {
+        message: string;
+        reasonCode: string;
+        decisionId?: string;
+        detailAddress?: string;
+    });
+}
+declare function parseKytReasonCode(reasonCode: string): {
+    code: string;
+    address?: string;
+};
+
+interface SubmitSorobanDepositInput {
+    contractId: string;
+    walletPublicKey: string;
+    privateAddressStpl1: string;
+    coin: CoinData;
+    depositScalarHex: string;
+    tokenAddress: string;
+    networkPassphrase: string;
+    sorobanRpcUrl: string;
+    privacyPoolService: PrivacyPoolService;
+    transactEnvironment: StellarTransactEnvironment;
+}
+declare function submitSorobanDeposit(input: SubmitSorobanDepositInput): Promise<string>;
+
+interface SubmitSorobanConfidentialTransferInput {
+    contractId: string;
+    walletPublicKey: string;
+    proofHex: string;
+    publicHex: string;
+    onboarding?: OnboardingPayload;
+    applicationIdsPlaintext?: KytApplicationIdHints;
+    networkPassphrase: string;
+    sorobanRpcUrl: string;
+    transactEnvironment: StellarTransactEnvironment;
+}
+declare function submitSorobanConfidentialTransfer(input: SubmitSorobanConfidentialTransferInput): Promise<string>;
+
+declare function tokenAddressToAssetLeg(tokenAddress: string): [string, string];
+declare function assetLegToTokenAddress(assetHi: string, assetLo: string): string;
+
+type GeneratedOutputCoin = {
+    commitment_hex: string;
+    coin: CoinData;
+    depositScalarHex: string;
+    precommitementHex: string;
+};
+
+type PrepareConfidentialTransferProofDualParameters = {
+    coinA: CoinData;
+    coinB: CoinData;
+    state: StateFile;
+    senderGAddress: string;
+    senderPrivKeyScalarHex: string;
+    ephemeralAKey: string;
+    ephemeralBKey: string;
+    transferStroops: bigint;
+    recipientPrivateAddressStpl1: string;
+    selfPrivateAddressStpl1ForChange: string | undefined;
+    tokenAddress: string;
+};
+type PrepareConfidentialTransferProofDualResult = {
+    proof_hex: string;
+    public_hex: string;
+    applicationIdsPlaintext: KytApplicationIdHints;
+    recipientCoin: GeneratedOutputCoin;
+    changeCoin?: GeneratedOutputCoin;
+};
+declare function prepareConfidentialTransferProofDual(parameters: PrepareConfidentialTransferProofDualParameters): Promise<PrepareConfidentialTransferProofDualResult>;
+
+type PrepareConfidentialTransferProofParameters = {
+    coin: CoinData;
+    state: StateFile;
+    senderGAddress: string;
+    senderPrivKeyScalarHex: string;
+    depositorEphemeralKey: string;
+    transferStroops: bigint;
+    recipientPrivateAddressStpl1: string;
+    selfPrivateAddressStpl1ForChange: string | undefined;
+    tokenAddress: string;
+};
+type PrepareConfidentialTransferProofResult = {
+    proof_hex: string;
+    public_hex: string;
+    applicationIdsPlaintext: KytApplicationIdHints;
+    recipientCoin: GeneratedOutputCoin;
+    changeCoin?: GeneratedOutputCoin;
+};
+declare function prepareConfidentialTransferProof(parameters: PrepareConfidentialTransferProofParameters): Promise<PrepareConfidentialTransferProofResult>;
+
+interface DecryptedKytAuditSlot {
+    slot: number;
+    decryptOk: boolean;
+    auditTagValid: boolean;
+    noteAuditPublicKey?: [string, string];
+    expectedAuditPublicKey?: [string, string];
+    plaintext?: string[];
+}
+interface RequestKytPassageForPoolInteractionInput {
+    owner: string;
+    poolContract: string;
+    proofHex: string;
+    publicHex: string;
+    onboarding?: OnboardingPayload;
+    decryptedAuditSlots?: DecryptedKytAuditSlot[];
+    applicationIdsPlaintext?: KytApplicationIdHints;
+    networkPassphrase: string;
+    sorobanRpcUrl: string;
+    transactEnvironment: StellarTransactEnvironment;
+}
+declare function requestKytPassageForPoolInteraction(input: RequestKytPassageForPoolInteractionInput): Promise<InspectKytPassageApproved>;
+
+declare const MIN_CONFIDENTIAL_TRANSFER_STROOPS = 1n;
+declare const ZERO_STROOPS = 0n;
+
+declare function frDecimalToPaddedBytes32(decimal: string): Buffer;
+
+declare function runTtlPreflight(assembledTransaction: unknown): Promise<void>;
+
+declare function attachPoolStatePorts(transactEnvironment: StellarTransactEnvironment | undefined, state: StateBridgeAdapter): StellarTransactEnvironment | undefined;
+
+export { type AlignedDepositSlot, type BuildTransferOnboardingAtExecuteInput, type CreateStellarPrivacyClientResult, type KytApplicationIdHints, KytInspectError, type LoadBrowserAssetsInput, type LoadPendingClaimsCountFromBackendInput, type LoadPendingClaimsFromBackendInput, MIN_CONFIDENTIAL_TRANSFER_STROOPS, PrivacyPoolService, type ProofResult, type ProofWithChange, type RequestKytPassageForPoolInteractionInput, type StellarAddress, type StellarAsset, type StellarAssetId, type StellarAssetsCatalog, type StellarAvailablePrivateRecordsFilter, type StellarBrowserAssets, type StellarBrowserPrivacyClientConfig, type StellarDeliverySyncState, type StellarIncomingDeliveriesFilter, type StellarIncomingDelivery, type StellarKytEnvironment, type StellarLeafEphemeral, type StellarNetworkConfig, type StellarOperationReceipt, type StellarPendingClaim, type StellarPendingClaimSource, type StellarPendingClaimsFilter, type StellarPendingClaimsPagination, type StellarPendingClaimsState, type StellarPolicyAdapter, type StellarPoolMerkleState, type StellarPreparedOperation, type StellarPrivacyClient, type StellarPrivacyClientConfig, type StellarPrivateAssetRow, type StellarPrivateRecord, type StellarPrivateRecordStatus, type StellarPublicBalance, type StellarPublicBalanceInput, type StellarRegistryLookup, type StellarStateAdapter, type StellarSubmissionPayload, type StellarTransactEngine, type StellarTransactEnvironment, type StellarTransactionDetails, type StellarTransactionStatus, type StellarTransferFromAddress, type StellarTransferIntent, type TemporaryRecipientKeyMaterial, type TransferOnboardingRecipientNoteInput$1 as TransferOnboardingRecipientNoteInput, type TransferRecipientExecutionContext, type TransferTemporaryRecipientKey, ZERO_STROOPS, assetLegToTokenAddress, attachPoolStatePorts, buildOnboardingPayload, buildPoolTransactionAuditParameters, buildPrivateAddressSignMessage, buildTransferOnboardingAtExecute, configurePrivacyPoolService, createDefaultTransactEngine, createPrivacyPoolService, createStellarPolicyAdapterFromEnvironment, createStellarPrivacyClient, createStellarPrivacyClientFromResolvedConfig, decodePrivateAddress, encodePrivateAddress, encodePrivateAddressFromHexCoordinates, fetchAndMergeMerkleState, frDecimalToPaddedBytes32, generateRandomDepositScalarHex, generateTemporaryRecipientPrivateAddress, getPrivacyPoolService, isStellarPrivacyClient, listWalletPrivateAddressRecordsForOwnerFromStateSnapshot, listWalletPrivateAddressScalarsForOwnerFromStateSnapshot, loadDefaultStellarBrowserAssets, loadStellarBrowserAssets, parseAuditPublicKeyFromEnvHex, parseKytReasonCode, prepareConfidentialTransferProof, prepareConfidentialTransferProofDual, privateAddressSdk, readLeafEphemeralHex, readPrivateRecordsFromStateSnapshot, readWalletDefaultPrivateAddressNonceFromStateSnapshot, readWalletPrivateAddressRecordFromStateSnapshot, readWalletPrivateAddressScalarFromStateSnapshot, recipientPublicKeysDecimalFromPrivateAddress, requestKytPassageForPoolInteraction, resolvePoolApplicationId, resolveStellarPrivacyClientConfig, runTtlPreflight, stellarStateDefinitions, submitSorobanConfidentialTransfer, submitSorobanDeposit, tokenAddressToAssetLeg };