@arcanetech/privacy-sdk-stellar 0.2.0 → 0.2.3

package/dist/state/index.d.ts

@@ -0,0 +1,753 @@
+import { z } from 'zod';
+import * as _arcanetech_privacy_sdk_core_state from '@arcanetech/privacy-sdk-core/state';
+import { StateBridgeDefinition, StateBridgeAdapter } from '@arcanetech/privacy-sdk-core/state';
+
+declare const STELLAR_STATE_PATHS: {
+    readonly privateRecords: "$.privateRecords";
+    readonly pendingClaimsItems: "$.pendingClaims.items";
+    readonly pendingClaimsPagination: "$.pendingClaims.pagination";
+    readonly pendingClaimsCountByOwner: "$.pendingClaims.countByOwner";
+    readonly registryPrivateAddresses: "$.registry.privateAddresses";
+    readonly registryRegisteredAddresses: "$.registry.registeredAddresses";
+    readonly registryLookups: "$.registry.lookups";
+    readonly assets: "$.assets";
+    readonly assetsById: "$.assets.byId";
+    readonly assetsListOrder: "$.assets.listOrder";
+    readonly publicBalances: "$.balances.publicByOwnerAsset";
+    readonly poolsByContract: "$.pools.byContract";
+    readonly poolsLeafEphemeral: "$.pools.leafEphemeralByContractAndIndex";
+    readonly deliveriesIncomingById: "$.deliveries.incomingById";
+    readonly deliveriesSync: "$.deliveries.syncByPrivateAddressAsset";
+    readonly transactionsByHash: "$.transactions.byHash";
+    readonly walletPrivateAddressScalars: "$.wallet.privateAddressScalars";
+    readonly walletPrivateAddressRecords: "$.wallet.privateAddressRecords";
+    readonly walletDefaultPrivateAddressNonce: "$.wallet.defaultPrivateAddressNonce";
+};
+
+type StellarAddress = string;
+type StellarAssetId = string;
+
+interface StellarStorageAdapter {
+    listPrivateRecords(filter: {
+        owner?: StellarAddress;
+        privateAddress?: string;
+        asset?: StellarAssetId;
+        amount?: bigint;
+    }): Promise<StellarPrivateRecord[]>;
+    savePrivateRecords(records: StellarPrivateRecord[]): Promise<void>;
+    markPrivateRecordsUsed(records: StellarPrivateRecord[]): Promise<void>;
+}
+
+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;
+}
+
+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 pendingClaimSchema: z.ZodObject<{
+    id: z.ZodString;
+    owner: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodBigInt;
+    createdAt: z.ZodString;
+    poolTxId: z.ZodOptional<z.ZodString>;
+    commitmentHex: z.ZodOptional<z.ZodString>;
+    nullifierHex: z.ZodOptional<z.ZodString>;
+    futureNullifierHashHex: z.ZodOptional<z.ZodString>;
+    assetHiHex: z.ZodOptional<z.ZodString>;
+    assetLoHex: z.ZodOptional<z.ZodString>;
+    nullifierFieldHex: z.ZodOptional<z.ZodString>;
+    secretHex: z.ZodOptional<z.ZodString>;
+    tempPublicKeyXHex: z.ZodOptional<z.ZodString>;
+    tempPublicKeyYHex: z.ZodOptional<z.ZodString>;
+    encryptedRecoveryBase64: z.ZodOptional<z.ZodString>;
+    createdAtLedger: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    owner: string;
+    asset: string;
+    amount: bigint;
+    createdAt: string;
+    poolTxId?: string | undefined;
+    commitmentHex?: string | undefined;
+    nullifierHex?: string | undefined;
+    futureNullifierHashHex?: string | undefined;
+    assetHiHex?: string | undefined;
+    assetLoHex?: string | undefined;
+    nullifierFieldHex?: string | undefined;
+    secretHex?: string | undefined;
+    tempPublicKeyXHex?: string | undefined;
+    tempPublicKeyYHex?: string | undefined;
+    encryptedRecoveryBase64?: string | undefined;
+    createdAtLedger?: number | undefined;
+}, {
+    id: string;
+    owner: string;
+    asset: string;
+    amount: bigint;
+    createdAt: string;
+    poolTxId?: string | undefined;
+    commitmentHex?: string | undefined;
+    nullifierHex?: string | undefined;
+    futureNullifierHashHex?: string | undefined;
+    assetHiHex?: string | undefined;
+    assetLoHex?: string | undefined;
+    nullifierFieldHex?: string | undefined;
+    secretHex?: string | undefined;
+    tempPublicKeyXHex?: string | undefined;
+    tempPublicKeyYHex?: string | undefined;
+    encryptedRecoveryBase64?: string | undefined;
+    createdAtLedger?: number | undefined;
+}>;
+declare const paginationSchema: z.ZodObject<{
+    total: z.ZodNumber;
+    page: z.ZodNumber;
+    pageSize: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, "strip", z.ZodTypeAny, {
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}, {
+    total: number;
+    page: number;
+    pageSize: number;
+    hasMore: boolean;
+}>;
+declare const privateRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    owner: z.ZodString;
+    asset: z.ZodString;
+    amount: z.ZodBigInt;
+    consumed: z.ZodBoolean;
+    status: z.ZodOptional<z.ZodEnum<["pending", "finalized", "spent"]>>;
+    poolContract: z.ZodOptional<z.ZodString>;
+    commitmentHex: z.ZodOptional<z.ZodString>;
+    nullifierHex: z.ZodOptional<z.ZodString>;
+    amountDisplay: z.ZodOptional<z.ZodNumber>;
+    deliveryId: z.ZodOptional<z.ZodNumber>;
+    privateAddress: z.ZodOptional<z.ZodString>;
+    txHash: z.ZodOptional<z.ZodString>;
+    coinNote: z.ZodOptional<z.ZodObject<{
+        value: z.ZodString;
+        nullifier: z.ZodString;
+        secret: z.ZodString;
+        commitment: z.ZodString;
+        asset_hi: z.ZodString;
+        asset_lo: z.ZodString;
+        application_id: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        value: string;
+        nullifier: string;
+        secret: string;
+        commitment: string;
+        asset_hi: string;
+        asset_lo: string;
+        application_id?: string | undefined;
+    }, {
+        value: string;
+        nullifier: string;
+        secret: string;
+        commitment: string;
+        asset_hi: string;
+        asset_lo: string;
+        application_id?: string | undefined;
+    }>>;
+    depositScalarHex: z.ZodOptional<z.ZodString>;
+    precommitementHex: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    id: string;
+    owner: string;
+    asset: string;
+    amount: bigint;
+    consumed: boolean;
+    privateAddress?: string | undefined;
+    commitmentHex?: string | undefined;
+    nullifierHex?: string | undefined;
+    status?: "pending" | "finalized" | "spent" | undefined;
+    poolContract?: string | undefined;
+    amountDisplay?: number | undefined;
+    deliveryId?: number | undefined;
+    txHash?: string | undefined;
+    coinNote?: {
+        value: string;
+        nullifier: string;
+        secret: string;
+        commitment: string;
+        asset_hi: string;
+        asset_lo: string;
+        application_id?: string | undefined;
+    } | undefined;
+    depositScalarHex?: string | undefined;
+    precommitementHex?: string | undefined;
+}, {
+    id: string;
+    owner: string;
+    asset: string;
+    amount: bigint;
+    consumed: boolean;
+    privateAddress?: string | undefined;
+    commitmentHex?: string | undefined;
+    nullifierHex?: string | undefined;
+    status?: "pending" | "finalized" | "spent" | undefined;
+    poolContract?: string | undefined;
+    amountDisplay?: number | undefined;
+    deliveryId?: number | undefined;
+    txHash?: string | undefined;
+    coinNote?: {
+        value: string;
+        nullifier: string;
+        secret: string;
+        commitment: string;
+        asset_hi: string;
+        asset_lo: string;
+        application_id?: string | undefined;
+    } | undefined;
+    depositScalarHex?: string | undefined;
+    precommitementHex?: string | undefined;
+}>;
+declare const assetSchema: z.ZodObject<{
+    id: z.ZodNumber;
+    assetId: z.ZodString;
+    name: z.ZodString;
+    logoUrl: z.ZodNullable<z.ZodString>;
+    issuerAddress: z.ZodNullable<z.ZodString>;
+    clientContract: z.ZodNullable<z.ZodString>;
+    poolContracts: z.ZodArray<z.ZodString, "many">;
+    poolContract: z.ZodString;
+    mintable: z.ZodBoolean;
+    mintAmount: z.ZodNullable<z.ZodString>;
+    decimals: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    id: number;
+    poolContract: string;
+    assetId: string;
+    name: string;
+    logoUrl: string | null;
+    issuerAddress: string | null;
+    clientContract: string | null;
+    poolContracts: string[];
+    mintable: boolean;
+    mintAmount: string | null;
+    decimals?: number | null | undefined;
+}, {
+    id: number;
+    poolContract: string;
+    assetId: string;
+    name: string;
+    logoUrl: string | null;
+    issuerAddress: string | null;
+    clientContract: string | null;
+    poolContracts: string[];
+    mintable: boolean;
+    mintAmount: string | null;
+    decimals?: number | null | undefined;
+}>;
+declare const publicBalanceSchema: z.ZodObject<{
+    owner: z.ZodString;
+    asset: z.ZodString;
+    balance: z.ZodString;
+    trustlineStatus: z.ZodEnum<["active", "inactive", "none"]>;
+}, "strip", z.ZodTypeAny, {
+    owner: string;
+    asset: string;
+    balance: string;
+    trustlineStatus: "active" | "inactive" | "none";
+}, {
+    owner: string;
+    asset: string;
+    balance: string;
+    trustlineStatus: "active" | "inactive" | "none";
+}>;
+declare const registryLookupSchema: z.ZodObject<{
+    owner: z.ZodString;
+    status: z.ZodEnum<["registered", "unregistered"]>;
+    privateAddressStpl1: z.ZodOptional<z.ZodString>;
+    publicKeyXHex: z.ZodOptional<z.ZodString>;
+    publicKeyYHex: z.ZodOptional<z.ZodString>;
+    updatedAtLedger: z.ZodOptional<z.ZodNumber>;
+    cachedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    owner: string;
+    status: "registered" | "unregistered";
+    privateAddressStpl1?: string | undefined;
+    publicKeyXHex?: string | undefined;
+    publicKeyYHex?: string | undefined;
+    updatedAtLedger?: number | undefined;
+    cachedAt?: string | undefined;
+}, {
+    owner: string;
+    status: "registered" | "unregistered";
+    privateAddressStpl1?: string | undefined;
+    publicKeyXHex?: string | undefined;
+    publicKeyYHex?: string | undefined;
+    updatedAtLedger?: number | undefined;
+    cachedAt?: string | undefined;
+}>;
+declare const poolMerkleStateSchema: z.ZodObject<{
+    poolContract: z.ZodString;
+    commitments: z.ZodArray<z.ZodString, "many">;
+    commitmentCount: z.ZodNumber;
+    merkleRootHex: z.ZodString;
+    updatedAt: z.ZodNumber;
+    syncedLedger: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    poolContract: string;
+    updatedAt: number;
+    commitments: string[];
+    commitmentCount: number;
+    merkleRootHex: string;
+    syncedLedger?: number | undefined;
+}, {
+    poolContract: string;
+    updatedAt: number;
+    commitments: string[];
+    commitmentCount: number;
+    merkleRootHex: string;
+    syncedLedger?: number | undefined;
+}>;
+declare const leafEphemeralSchema: z.ZodObject<{
+    poolContract: z.ZodString;
+    leafIndex: z.ZodNumber;
+    xHex: z.ZodString;
+    yHex: z.ZodString;
+    cachedAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    poolContract: string;
+    leafIndex: number;
+    xHex: string;
+    yHex: string;
+    cachedAt?: string | undefined;
+}, {
+    poolContract: string;
+    leafIndex: number;
+    xHex: string;
+    yHex: string;
+    cachedAt?: string | undefined;
+}>;
+declare const incomingDeliverySchema: z.ZodObject<{
+    id: z.ZodNumber;
+    privateAddress: z.ZodString;
+    asset: z.ZodString;
+    ciphertextBase64: z.ZodString;
+    ephemeralKey: z.ZodString;
+    tagBase64: z.ZodString;
+    createdAt: z.ZodString;
+    processed: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    privateAddress: string;
+    id: number;
+    asset: string;
+    createdAt: string;
+    ciphertextBase64: string;
+    ephemeralKey: string;
+    tagBase64: string;
+    processed?: boolean | undefined;
+}, {
+    privateAddress: string;
+    id: number;
+    asset: string;
+    createdAt: string;
+    ciphertextBase64: string;
+    ephemeralKey: string;
+    tagBase64: string;
+    processed?: boolean | undefined;
+}>;
+declare const deliverySyncStateSchema: z.ZodObject<{
+    privateAddress: z.ZodString;
+    asset: z.ZodString;
+    bloomM: z.ZodNumber;
+    bloomK: z.ZodNumber;
+    bloomBitsBase64: z.ZodOptional<z.ZodString>;
+    lastPage: z.ZodOptional<z.ZodNumber>;
+    lastPolledAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    privateAddress: string;
+    asset: string;
+    bloomM: number;
+    bloomK: number;
+    bloomBitsBase64?: string | undefined;
+    lastPage?: number | undefined;
+    lastPolledAt?: string | undefined;
+}, {
+    privateAddress: string;
+    asset: string;
+    bloomM: number;
+    bloomK: number;
+    bloomBitsBase64?: string | undefined;
+    lastPage?: number | undefined;
+    lastPolledAt?: string | undefined;
+}>;
+declare const transactionStatusSchema: z.ZodObject<{
+    txHash: z.ZodString;
+    status: z.ZodEnum<["pending", "success", "failed"]>;
+    ledger: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    status: "pending" | "success" | "failed";
+    txHash: string;
+    createdAt?: string | undefined;
+    ledger?: number | undefined;
+}, {
+    status: "pending" | "success" | "failed";
+    txHash: string;
+    createdAt?: string | undefined;
+    ledger?: number | undefined;
+}>;
+
+declare const stellarStateDefinitions: StateBridgeDefinition[];
+
+declare const stellarStateCallTypes: {
+    readonly pendingClaims: "pendingClaims";
+    readonly clearPendingClaims: "clearPendingClaims";
+    readonly readPendingClaims: "readPendingClaims";
+    readonly replacePendingClaimsPage: "replacePendingClaimsPage";
+    readonly upsertPendingClaims: "upsertPendingClaims";
+    readonly removePendingClaims: "removePendingClaims";
+    readonly setPendingClaimsCount: "setPendingClaimsCount";
+    readonly readPendingClaimsCount: "readPendingClaimsCount";
+    readonly readStellarAddressRegistered: "readStellarAddressRegistered";
+    readonly readCachedPrivateAddress: "readCachedPrivateAddress";
+    readonly readRegistryLookup: "readRegistryLookup";
+    readonly saveRegisteredPrivateAddress: "saveRegisteredPrivateAddress";
+    readonly saveRegistryLookup: "saveRegistryLookup";
+    readonly invalidateRegisteredAddress: "invalidateRegisteredAddress";
+    readonly invalidateRegistryLookup: "invalidateRegistryLookup";
+    readonly readAssetsCatalog: "readAssetsCatalog";
+    readonly readAsset: "readAsset";
+    readonly replaceAssets: "replaceAssets";
+    readonly upsertAssets: "upsertAssets";
+    readonly readPublicBalance: "readPublicBalance";
+    readonly readPublicBalances: "readPublicBalances";
+    readonly setPublicBalance: "setPublicBalance";
+    readonly setPublicBalances: "setPublicBalances";
+    readonly readPoolMerkleState: "readPoolMerkleState";
+    readonly setPoolMerkleState: "setPoolMerkleState";
+    readonly readLeafEphemeral: "readLeafEphemeral";
+    readonly setLeafEphemeral: "setLeafEphemeral";
+    readonly listPrivateRecords: "listPrivateRecords";
+    readonly savePrivateRecords: "savePrivateRecords";
+    readonly replacePrivateRecords: "replacePrivateRecords";
+    readonly upsertPrivateRecords: "upsertPrivateRecords";
+    readonly pruneConsumedPrivateRecords: "pruneConsumedPrivateRecords";
+    readonly readIncomingDeliveries: "readIncomingDeliveries";
+    readonly upsertIncomingDeliveries: "upsertIncomingDeliveries";
+    readonly readDeliverySyncState: "readDeliverySyncState";
+    readonly setDeliverySyncState: "setDeliverySyncState";
+    readonly readTransactionStatus: "readTransactionStatus";
+    readonly setTransactionStatus: "setTransactionStatus";
+    readonly clearTransactionStatus: "clearTransactionStatus";
+    readonly saveWalletPrivateAddressScalar: "saveWalletPrivateAddressScalar";
+    readonly readWalletPrivateAddressScalar: "readWalletPrivateAddressScalar";
+    readonly saveWalletPrivateAddressRecord: "saveWalletPrivateAddressRecord";
+    readonly readWalletPrivateAddressRecord: "readWalletPrivateAddressRecord";
+    readonly setWalletDefaultPrivateAddressNonce: "setWalletDefaultPrivateAddressNonce";
+    readonly readWalletDefaultPrivateAddressNonce: "readWalletDefaultPrivateAddressNonce";
+    readonly deleteWalletPrivateAddressScalar: "deleteWalletPrivateAddressScalar";
+};
+type StellarStateDefinition = 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 createStellarStateService(adapter: StateBridgeAdapter): StellarStateService;
+declare function createStellarStorageAdapterFromState(state: StellarStateService): StellarStorageAdapter;
+
+export { STELLAR_STATE_PATHS, type StellarAsset, type StellarAssetsCatalog, type StellarAvailablePrivateRecordsFilter, type StellarDeliverySyncState, type StellarIncomingDeliveriesFilter, type StellarIncomingDelivery, type StellarLeafEphemeral, type StellarPendingClaim, type StellarPendingClaimsFilter, type StellarPendingClaimsPagination, type StellarPendingClaimsState, type StellarPoolMerkleState, type StellarPrivateAssetRow, type StellarPrivateRecordStatus, type StellarPublicBalance, type StellarPublicBalanceInput, type StellarRegistryLookup, type StellarStateDefinition, type StellarStateService, type StellarTransactionStatus, assetSchema, createStellarStateService, createStellarStorageAdapterFromState, deliverySyncStateSchema, incomingDeliverySchema, leafEphemeralSchema, listWalletPrivateAddressRecordsForOwnerFromStateSnapshot, listWalletPrivateAddressScalarsForOwnerFromStateSnapshot, paginationSchema, pendingClaimSchema, poolMerkleStateSchema, privateRecordSchema, publicBalanceSchema, readPrivateRecordsFromStateSnapshot, readWalletDefaultPrivateAddressNonceFromStateSnapshot, readWalletPrivateAddressRecordFromStateSnapshot, readWalletPrivateAddressScalarFromStateSnapshot, registryLookupSchema, stellarStateCallTypes, stellarStateDefinitions, transactionStatusSchema };