@arcanetech/privacy-sdk-stellar 0.2.0 → 0.2.3

package/dist/testing/index.d.ts

@@ -0,0 +1,107 @@
+import { OperationKind, DepositIntent, TransferIntent, WithdrawIntent } from '@arcanetech/privacy-sdk-core';
+import { OnboardingPayload } from 'contract';
+export { createInMemoryStateAdapter } from '@arcanetech/privacy-sdk-state-memory';
+
+type StellarPrivateRecordStatus = 'pending' | 'finalized' | 'spent';
+interface StellarPrivateCoinNote {
+    value: string;
+    nullifier: string;
+    secret: string;
+    commitment: string;
+    asset_hi: string;
+    asset_lo: string;
+    application_id?: 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 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;
+}
+
+type KytApplicationIdHints = [string, string, string, string];
+
+type StellarPendingClaimSource = {
+    kind: 'pendingClaim';
+    claimId: string;
+} | {
+    kind: 'pendingClaim';
+    claim: StellarPendingClaim;
+};
+type StellarTransferFromAddress = StellarAddress | StellarPendingClaimSource;
+
+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 StellarTransactEngine {
+    prepare(prepared: StellarPreparedOperation): Promise<StellarPreparedOperation>;
+    submit(prepared: StellarPreparedOperation, signedPayload: StellarSubmissionPayload): Promise<StellarOperationReceipt>;
+}
+
+declare function createFakeTransactEngine(overrides?: Partial<StellarTransactEngine>): StellarTransactEngine;
+
+export { createFakeTransactEngine };

package/dist/testing/index.js

@@ -0,0 +1,54 @@
+// src/testing/fake-transact-engine.ts
+function createFakeTransactEngine(overrides = {}) {
+  return {
+    prepare: async (prepared) => prepared,
+    submit: async (_prepared, signedPayload) => ({
+      operationId: signedPayload.operationId,
+      confirmed: true
+    }),
+    ...overrides
+  };
+}
+
+// ../state/memory/dist/index.js
+import {
+  applyStateOperations,
+  cloneStateTree,
+  createStateBridge
+} from "@arcanetech/privacy-sdk-core/state";
+function createInMemoryStateAdapter(initialState = {}) {
+  let stateTree = cloneStateTree(initialState);
+  const registeredTypes = /* @__PURE__ */ new Set();
+  const adapter = {
+    registerDefinition(definition) {
+      registeredTypes.add(definition.type);
+    },
+    async write(call) {
+      if (!registeredTypes.has(call.type)) {
+        throw new Error(`Unregistered in-memory state type: ${call.type}`);
+      }
+      const draft = cloneStateTree(stateTree);
+      applyStateOperations(draft, call.operations, "write");
+      stateTree = draft;
+    },
+    async read(call) {
+      if (!registeredTypes.has(call.type)) {
+        throw new Error(`Unregistered in-memory state type: ${call.type}`);
+      }
+      const draft = cloneStateTree(stateTree);
+      return applyStateOperations(draft, call.operations, "read");
+    },
+    getState() {
+      return cloneStateTree(stateTree);
+    },
+    resetState(nextState = {}) {
+      stateTree = cloneStateTree(nextState);
+    }
+  };
+  return adapter;
+}
+export {
+  createFakeTransactEngine,
+  createInMemoryStateAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/testing/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/testing/fake-transact-engine.ts","../../../state/memory/src/index.ts"],"sourcesContent":["import type { StellarOperationReceipt, StellarTransactEngine } from '../types.js';\n\nexport function createFakeTransactEngine(\n  overrides: Partial<StellarTransactEngine> = {},\n): StellarTransactEngine {\n  return {\n    prepare: async (prepared) => prepared,\n    submit: async (_prepared, signedPayload): Promise<StellarOperationReceipt> => ({\n      operationId: signedPayload.operationId,\n      confirmed: true,\n    }),\n    ...overrides,\n  };\n}\n","import {\n  applyStateOperations,\n  cloneStateTree,\n  createStateBridge,\n  type StateBridge,\n  type StateBridgeAdapter,\n  type StateBridgeCall,\n  type StateBridgeDefinition,\n} from '@arcanetech/privacy-sdk-core/state';\n\nexport interface InMemoryStateAdapter extends StateBridgeAdapter {\n  getState(): Record<string, unknown>;\n  resetState(nextState?: Record<string, unknown>): void;\n}\n\nexport function createInMemoryStateAdapter(\n  initialState: Record<string, unknown> = {},\n): InMemoryStateAdapter {\n  let stateTree = cloneStateTree(initialState);\n  const registeredTypes = new Set<string>();\n\n  const adapter: InMemoryStateAdapter = {\n    registerDefinition(definition: StateBridgeDefinition) {\n      registeredTypes.add(definition.type);\n    },\n    async write(call: StateBridgeCall) {\n      if (!registeredTypes.has(call.type)) {\n        throw new Error(`Unregistered in-memory state type: ${call.type}`);\n      }\n      const draft = cloneStateTree(stateTree);\n      applyStateOperations(draft, call.operations, 'write');\n      stateTree = draft;\n    },\n    async read<TResult>(call: StateBridgeCall): Promise<TResult> {\n      if (!registeredTypes.has(call.type)) {\n        throw new Error(`Unregistered in-memory state type: ${call.type}`);\n      }\n      const draft = cloneStateTree(stateTree);\n      return applyStateOperations(draft, call.operations, 'read') as TResult;\n    },\n    getState() {\n      return cloneStateTree(stateTree);\n    },\n    resetState(nextState: Record<string, unknown> = {}) {\n      stateTree = cloneStateTree(nextState);\n    },\n  };\n\n  return adapter;\n}\n\nexport function createInMemoryStateBridge(initialState?: Record<string, unknown>): {\n  adapter: InMemoryStateAdapter;\n  bridge: StateBridge;\n} {\n  const adapter = createInMemoryStateAdapter(initialState);\n  const bridge = createStateBridge(adapter);\n  return { adapter, bridge };\n}\n"],"mappings":";AAEO,SAAS,yBACd,YAA4C,CAAC,GACtB;AACvB,SAAO;AAAA,IACL,SAAS,OAAO,aAAa;AAAA,IAC7B,QAAQ,OAAO,WAAW,mBAAqD;AAAA,MAC7E,aAAa,cAAc;AAAA,MAC3B,WAAW;AAAA,IACb;AAAA,IACA,GAAG;AAAA,EACL;AACF;;;ACbA;EACE;EACA;EACA;OAKK;AAOA,SAAS,2BACd,eAAwC,CAAC,GACnB;AACtB,MAAI,YAAY,eAAe,YAAY;AAC3C,QAAM,kBAAkB,oBAAI,IAAY;AAExC,QAAM,UAAgC;IACpC,mBAAmB,YAAmC;AACpD,sBAAgB,IAAI,WAAW,IAAI;IACrC;IACA,MAAM,MAAM,MAAuB;AACjC,UAAI,CAAC,gBAAgB,IAAI,KAAK,IAAI,GAAG;AACnC,cAAM,IAAI,MAAM,sCAAsC,KAAK,IAAI,EAAE;MACnE;AACA,YAAM,QAAQ,eAAe,SAAS;AACtC,2BAAqB,OAAO,KAAK,YAAY,OAAO;AACpD,kBAAY;IACd;IACA,MAAM,KAAc,MAAyC;AAC3D,UAAI,CAAC,gBAAgB,IAAI,KAAK,IAAI,GAAG;AACnC,cAAM,IAAI,MAAM,sCAAsC,KAAK,IAAI,EAAE;MACnE;AACA,YAAM,QAAQ,eAAe,SAAS;AACtC,aAAO,qBAAqB,OAAO,KAAK,YAAY,MAAM;IAC5D;IACA,WAAW;AACT,aAAO,eAAe,SAAS;IACjC;IACA,WAAW,YAAqC,CAAC,GAAG;AAClD,kBAAY,eAAe,SAAS;IACtC;EACF;AAEA,SAAO;AACT;","names":[]}

package/dist/transact/index.d.ts

@@ -0,0 +1,399 @@
+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';
+import { OnboardingPayload } from 'contract';
+export { OnboardingPayload, PrivateAddressRegistration } from 'contract';
+import { StateBridgeAdapter } from '@arcanetech/privacy-sdk-core/state';
+
+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;
+}
+
+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;
+    };
+};
+
+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 StellarAssetId = string;
+
+interface StellarNetworkConfig {
+    id: string;
+    rpcUrl: string;
+    networkPassphrase: string;
+    poolContract: string;
+    registryContract: string;
+    applicationId: string;
+}
+interface StellarBrowserAssets {
+    sdkWasm: ArrayBuffer;
+    circuitWasm: ArrayBuffer;
+    provingKey: ArrayBuffer;
+}
+
+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 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;
+}>;
+
+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 KytApplicationIdHints, KytInspectError, type LoadBrowserAssetsInput, MIN_CONFIDENTIAL_TRANSFER_STROOPS, PrivacyPoolService, type ProofResult, type ProofWithChange, type RequestKytPassageForPoolInteractionInput, type StellarKytEnvironment, type StellarTransactEnvironment, type TemporaryRecipientKeyMaterial, type TransferOnboardingRecipientNoteInput$1 as TransferOnboardingRecipientNoteInput, type TransferRecipientExecutionContext, type TransferTemporaryRecipientKey, ZERO_STROOPS, assetLegToTokenAddress, attachPoolStatePorts, buildOnboardingPayload, buildPoolTransactionAuditParameters, buildPrivateAddressSignMessage, buildTransferOnboardingAtExecute, configurePrivacyPoolService, createPrivacyPoolService, decodePrivateAddress, encodePrivateAddress, encodePrivateAddressFromHexCoordinates, fetchAndMergeMerkleState, frDecimalToPaddedBytes32, generateRandomDepositScalarHex, generateTemporaryRecipientPrivateAddress, getPrivacyPoolService, loadDefaultStellarBrowserAssets, loadStellarBrowserAssets, parseAuditPublicKeyFromEnvHex, parseKytReasonCode, prepareConfidentialTransferProof, prepareConfidentialTransferProofDual, privateAddressSdk, readLeafEphemeralHex, recipientPublicKeysDecimalFromPrivateAddress, requestKytPassageForPoolInteraction, resolvePoolApplicationId, runTtlPreflight, submitSorobanConfidentialTransfer, submitSorobanDeposit, tokenAddressToAssetLeg };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcanetech/privacy-sdk-stellar",
-  "version": "0.2.0",
+  "version": "0.2.3",
   "description": "Stellar preset for the Arcane privacy SDK",
   "type": "module",
   "browser": "./dist/index.js",
@@ -48,7 +48,7 @@
     "typecheck": "tsc --noEmit -p tsconfig.json && tsc --noEmit -p tsconfig.test.json"
   },
   "dependencies": {
-    "@arcanetech/privacy-sdk-core": "0.1.0",
+    "@arcanetech/privacy-sdk-core": "*",
     "@auditable/privacy-pool-zk-sdk": "^0.6.1-rc.5",
     "@stellar/stellar-sdk": "^14.6.1",
     "buffer": "^6.0.3",
@@ -57,11 +57,16 @@
     "zod": "^3.24.2"
   },
   "devDependencies": {
-    "@arcanetech/privacy-sdk-state-memory": "0.1.0",
-    "@arcanetech/privacy-sdk-state-redux": "0.1.0",
+    "@arcanetech/privacy-sdk-state-memory": "0.2.1",
+    "@arcanetech/privacy-sdk-state-redux": "0.2.1",
     "@reduxjs/toolkit": "^2.6.1"
   },
   "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Polynom-Labs/privacy-layer-confidential-sdk.git",
+    "directory": "packages/stellar"
+  },
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"