@stellar/typescript-wallet-sdk 1.2.0 → 1.3.0

package/lib/walletSdk/Exceptions/index.d.ts

@@ -1,6 +1,7 @@
 import { Networks, Horizon } from "stellar-sdk";
-import { AnchorTransaction, FLOW_TYPE } from "../Types";
+import { AnchorTransaction, FLOW_TYPE, AxiosErrorData, GetCustomerParams } from "../Types";
 export declare class ServerRequestFailedError extends Error {
+    data: AxiosErrorData;
     constructor(e: Error);
 }
 export declare class AssetNotSupportedError extends Error {
@@ -25,7 +26,7 @@ export declare class AccountDoesNotExistError extends Error {
     constructor(network: Networks);
 }
 export declare class TransactionSubmitFailedError extends Error {
-    constructor(response: Horizon.SubmitTransactionResponse);
+    constructor(response: Horizon.HorizonApi.SubmitTransactionResponse);
 }
 export declare class InsufficientStartingBalanceError extends Error {
     constructor();
@@ -54,6 +55,48 @@ export declare class WithdrawalTxNotPendingUserTransferStartError extends Error
 export declare class WithdrawalTxMissingMemoError extends Error {
     constructor();
 }
+export declare class PathPayOnlyOneAmountError extends Error {
+    constructor();
+}
 export declare class WithdrawalTxMemoError extends Error {
     constructor();
 }
+export declare class Sep9InfoRequiredError extends Error {
+    constructor();
+}
+export declare class CustomerNotFoundError extends Error {
+    constructor(params: GetCustomerParams);
+}
+export declare class KYCServerNotFoundError extends Error {
+    constructor();
+}
+export declare class RecoveryServerNotFoundError extends Error {
+    constructor(serverKey: string);
+}
+export declare class RecoveryIdentityNotFoundError extends Error {
+    constructor(serverKey: string);
+}
+export declare class NotAllSignaturesFetchedError extends Error {
+    constructor();
+}
+export declare class LostSignerKeyNotFound extends Error {
+    constructor();
+}
+export declare class NoDeviceKeyForAccountError extends Error {
+    constructor();
+}
+export declare class UnableToDeduceKeyError extends Error {
+    constructor();
+}
+export declare class NoAccountSignersError extends Error {
+    constructor();
+}
+export declare class DeviceKeyEqualsMasterKeyError extends Error {
+    constructor();
+}
+export declare class NoAccountAndNoSponsorError extends Error {
+    constructor();
+}
+export declare class Sep38PriceOnlyOneAmountError extends Error {
+    constructor();
+}

package/lib/walletSdk/Horizon/AccountService.d.ts

@@ -1,47 +1,57 @@
 /// <reference types="node" />
-import { Server, ServerApi } from "stellar-sdk";
+import { Horizon } from "stellar-sdk";
 import { Config } from "walletSdk";
 import { SigningKeypair } from "./Account";
 import { HORIZON_ORDER } from "../Types";
+/**
+ * KYC management with Sep-12.
+ * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0012.md}
+ * Do not create this object directly, use the Stellar class.
+ * @class
+ */
 export declare class AccountService {
     private server;
     private network;
+    /**
+     * Creates a new instance of the AccountService class.
+     * @constructor
+     * @param {Config} cfg - Configuration for the service.
+     */
     constructor(cfg: Config);
     /**
      * Generate new account keypair (public and secret key). This key pair can be
      * used to create a Stellar account.
-     *
-     * @return public key and secret key
+     * @returns {SigningKeypair} Keypair capable of signing.
      */
     createKeypair(): SigningKeypair;
     /**
      * Generate new account keypair (public and secret key) from random bytes. This key pair can be
      * used to create a Stellar account.
-     *
-     * @return public key and secret key
+     * @param {Buffer} randomBytes - Random bytes to create keypair from.
+     * @returns {SigningKeypair} Keypair capable of signing.
      */
     createKeypairFromRandom(randomBytes: Buffer): SigningKeypair;
     /**
      * Get account information from the Stellar network.
-     *
-     * @param accountAddress Stellar address of the account
-     * @param serverInstance optional Horizon server instance when default doesn't work
-     * @return account information
+     * @param {object} params - The parameters for retrieving account information.
+     * @param {string} params.accountAddress - Stellar address of the account.
+     * @param {Horizon.HorizonApi.Server} [params.serverInstance=this.server] - Horizon server instance when default doesn't work.
+     * @returns {Promise<Horizon.ServerApi.AccountRecord>} Account information.
      */
     getInfo({ accountAddress, serverInstance, }: {
         accountAddress: string;
-        serverInstance?: Server;
-    }): Promise<ServerApi.AccountRecord>;
+        serverInstance?: Horizon.Server;
+    }): Promise<Horizon.ServerApi.AccountRecord>;
     /**
      * Get account operations for the specified Stellar address.
-     *
-     * @param accountAddress Stellar address of the account
-     * @param limit optional how many operations to fetch, maximum is 200, default is 10
-     * @param order optional data order, ascending or descending, defaults to descending
-     * @param cursor optional cursor to specify a starting point
-     * @param includeFailed optional flag to include failed operations, defaults to false
-     * @return a list of operations
-     * @throws [OperationsLimitExceededException] when maximum limit of 200 is exceeded
+     * @param {object} params - The parameters for retrieving account history.
+     * @param {string} params.accountAddress - Stellar address of the account
+     * @param {number} [params.limit=HORIZON_LIMIT_DEFAULT] - How many operations to fetch, maximum is 200, default is 10
+     * @param {HORIZON_ORDER} [params.order=HORIZON_ORDER.DESC] - Data order, ascending or descending, defaults to descending
+     * @param {string} [params.cursor] - Cursor to specify a starting point
+     * @param {boolean} [params.includeFailed=false] - Flag to include failed operations.
+     * @returns {Promise<Horizon.ServerApi.CollectionPage<Horizon.ServerApi.OperationRecord>>} A list of operations.
+     * @throws {OperationsLimitExceededError} when maximum limit of 200 is exceeded.
      */
     getHistory({ accountAddress, limit, order, cursor, includeFailed, }: {
         accountAddress: string;
@@ -49,5 +59,5 @@ export declare class AccountService {
         order?: HORIZON_ORDER;
         cursor?: string;
         includeFailed?: boolean;
-    }): Promise<ServerApi.CollectionPage<ServerApi.OperationRecord>>;
+    }): Promise<Horizon.ServerApi.CollectionPage<Horizon.ServerApi.OperationRecord>>;
 }

package/lib/walletSdk/Horizon/Stellar.d.ts

@@ -1,16 +1,93 @@
-import { Server, Transaction, FeeBumpTransaction } from "stellar-sdk";
+import { Horizon, Transaction, FeeBumpTransaction } from "stellar-sdk";
 import { Config } from "walletSdk";
 import { AccountService } from "./AccountService";
 import { TransactionBuilder } from "./Transaction/TransactionBuilder";
 import { TransactionParams, SubmitWithFeeIncreaseParams, FeeBumpTransactionParams } from "../Types";
+/**
+ * Interaction with the Stellar Network.
+ * Do not create this object directly, use the Wallet class.
+ * @class
+ */
 export declare class Stellar {
     private cfg;
-    server: Server;
+    server: Horizon.Server;
+    /**
+     * Creates a new instance of the Stellar class.
+     * @constructor
+     * @param {Config} cfg - Configuration object.
+     */
     constructor(cfg: Config);
+    /**
+     * Returns an AccountService instance for managing Stellar accounts.
+     * @returns {AccountService} An AccountService instance.
+     */
     account(): AccountService;
+    /**
+     * Construct a Stellar transaction.
+     * @param {TransactionParams} params - The Transaction params.
+     * @param {AccountKeypair} params.sourceAddress - The source account keypair.
+     * @param {Horizon.Server.Timebounds | number} [params.timebounds] - The timebounds for the transaction.
+     * If a number is given, then timebounds constructed from now to now + number in seconds.
+     * @param {number} [params.baseFee] - The base fee for the transaction. Defaults to the config base fee.
+     * @param {Memo} [params.memo] - The memo for the transaction.
+     * @returns {TransactionBuilder} A TransactionBuilder instance.
+     * @throws {AccountDoesNotExistError} If the source account does not exist.
+     */
     transaction({ sourceAddress, baseFee, memo, timebounds, }: TransactionParams): Promise<TransactionBuilder>;
+    /**
+     * Creates a FeeBumpTransaction instance for increasing the fee of an existing transaction.
+     * @param {FeeBumpTransactionParams} params - The Fee Bump Transaction params.
+     * @param {AccountKeypair} params.feeAddress - The account that will pay for the transaction's fee.
+     * @param {Transaction} params.transaction - The transaction to be fee bumped.
+     * @param {number} [params.baseFee] - The base fee (stroops) for the fee bump transaction. Defaults to the config base fee.
+     * @returns {FeeBumpTransaction} A FeeBumpTransaction instance.
+     */
     makeFeeBump({ feeAddress, transaction, baseFee, }: FeeBumpTransactionParams): FeeBumpTransaction;
+    /**
+     * Submits a signed transaction to the server. If the submission fails with status
+     * 504 indicating a timeout error, it will automatically retry.
+     * @param {Transaction|FeeBumpTransaction} signedTransaction - The signed transaction to submit.
+     * @returns {boolean} `true` if the transaction was successfully submitted.
+     * @throws {TransactionSubmitFailedError} If the transaction submission fails.
+     */
     submitTransaction(signedTransaction: Transaction | FeeBumpTransaction): Promise<boolean>;
+    /**
+     * Submits a signed transaction. If the submission fails with error code: tx_too_late,
+     * then resubmit with an increased base fee.
+     * @see {@link https://developers.stellar.org/docs/encyclopedia/error-handling#retrying-until-success-strategy}
+     * for more info on this strategy.
+     * @param {SubmitWithFeeIncreaseParams} params - The SubmitWithFeeIncrease params.
+     * @param {AccountKeypair} params.sourceAddress - The source account keypair.
+     * @param {number} params.timeout - The number of seconds from now the transaction is allowed to be submitted.
+     * @param {number} params.baseFeeIncrease - The amount to increase base fee (in stroops) if submission fails.
+     * @param {(builder: TransactionBuilder) => TransactionBuilder} params.buildingFunction - Function for building the
+     * operations of the transactions.
+     * @param {(builder: TransactionBuilder) => TransactionBuilder} [params.signerFunction] - Function for signing the transaction.
+     * If not given, will use the soure keypair to sign.
+     * @param {number} [params.baseFee] - The base fee (stroops) of the transaction.
+     * @param {Memo} [params.memo] - The memo of the transaction.
+     * @param {number} [params.maxFee] - The max fee allowed (stroops) of the transaction, afterward will stop submitting and throw error.
+     * @returns {Transaction} The submitted transaction.
+     * @throws {TransactionSubmitWithFeeIncreaseFailedError} If the transaction submission with fee increase fails.
+     */
     submitWithFeeIncrease({ sourceAddress, timeout, baseFeeIncrease, buildingFunction, signerFunction, baseFee, memo, maxFee, }: SubmitWithFeeIncreaseParams): Promise<Transaction>;
+    /**
+     * Decodes a Stellar transaction from xdr.
+     * @param {string} xdr - The XDR representation of the transaction.
+     * @returns {Transaction|FeeBumpTransaction} The decoded transaction.
+     */
     decodeTransaction(xdr: string): Transaction | FeeBumpTransaction;
+    /**
+     * Returns the recommended fee (stroops) to use in a transaction based on the current
+     * stellar network fee stats.
+     * @returns {string} The recommended fee amount in stroops.
+     */
+    getRecommendedFee(): Promise<string>;
+    /**
+     * Funds an account on the stellar test network. If it is already funded then call will error.
+     * Please note: only funds on the testnet network.
+     * @see {@link https://developers.stellar.org/docs/fundamentals-and-concepts/testnet-and-pubnet#friendbot}
+     * @param {string} address - The stellar address.
+     */
+    fundTestnetAccount(address: string): Promise<void>;
 }

package/lib/walletSdk/Horizon/Transaction/CommonTransactionBuilder.d.ts

@@ -0,0 +1,57 @@
+import { xdr } from "stellar-sdk";
+import { IssuedAssetId } from "../../Asset";
+import { AccountKeypair } from "../Account";
+export declare abstract class CommonTransactionBuilder<T> {
+    protected sourceAddress: string;
+    protected operations: Array<xdr.Operation>;
+    constructor(sourceAddress: string, operations: Array<xdr.Operation>);
+    /**
+     * Add a trustline for an asset so can receive or send it.
+     * @param {IssuedAssetId} asset - The asset for which support is added.
+     * @param {string} [trustLimit] - The trust limit for the asset.
+     * @returns {T} The builder class instance called with.
+     */
+    addAssetSupport(asset: IssuedAssetId, trustLimit?: string): T;
+    /**
+     * Remove a trustline for an asset.
+     * @param {IssuedAssetId} asset - The asset for which support is added.
+     * @returns {T} The builder class instance called with.
+     */
+    removeAssetSupport(asset: IssuedAssetId): T;
+    /**
+     * Add a signer to the account.
+     * @see {@link https://developers.stellar.org/docs/encyclopedia/signatures-multisig}
+     * @param {AccountKeypair} signerAddress - The new account being added
+     * @param {number} signerWeight - The weight given to the new signer.
+     * @returns {T} The builder class instance called with.
+     */
+    addAccountSigner(signerAddress: AccountKeypair, signerWeight: number): T;
+    /**
+     * Removes a signer from an account.
+     * @see {@link https://developers.stellar.org/docs/encyclopedia/signatures-multisig}
+     * @param {AccountKeypair} signerAddress - The new account being added
+     * @returns {T} The builder class instance called with.
+     */
+    removeAccountSigner(signerAddress: AccountKeypair): T;
+    /**
+     * Locking an account by setting the master key weight to 0.
+     * Be careful, if no other signers then the account will be locked and unable to
+     * sign new transactions permanently.
+     * @returns {T} The builder class instance called with.
+     */
+    lockAccountMasterKey(): T;
+    /**
+     * Set thesholds for an account.
+     * @see {@link https://developers.stellar.org/docs/encyclopedia/signatures-multisig#thresholds}
+     * @param {object} options - The threshold options.
+     * @param {number} [options.low] - The low theshold level.
+     * @param {number} [options.medium] - The medium theshold level.
+     * @param {number} [options.high] - The high theshold level.
+     * @returns {T} The builder class instance called with.
+     */
+    setThreshold({ low, medium, high, }: {
+        low?: number;
+        medium?: number;
+        high?: number;
+    }): T;
+}

package/lib/walletSdk/Horizon/Transaction/SponsoringBuilder.d.ts

@@ -0,0 +1,38 @@
+import { xdr } from "stellar-sdk";
+import { CommonTransactionBuilder } from "./CommonTransactionBuilder";
+import { AccountKeypair } from "../Account";
+/**
+ * Used for building transactions that will include a sponsor.
+ * Do not create this object directly, use the TransactionBuilder class to create.
+ * @class
+ */
+export declare class SponsoringBuilder extends CommonTransactionBuilder<SponsoringBuilder> {
+    private sponsorAccount;
+    /**
+     * Creates a new instance of the SponsoringBuilder class.
+     * @constructor
+     * @param {string} sponsoredAddress - The address of the account being sponsored.
+     * @param {AccountKeypair} sponsorAccount - The sponsor account keypair.
+     * @param {xdr.Operation[]} operations - An array of Stellar operations.
+     * @param {(builder: SponsoringBuilder) => SponsoringBuilder} buildingFunction - Function for creating the
+     * operations that will be sponsored.
+     */
+    constructor(sponsoredAddress: string, sponsorAccount: AccountKeypair, operations: Array<xdr.Operation>, buildingFunction: (builder: SponsoringBuilder) => SponsoringBuilder);
+    /**
+     * Creates a Stellar account with sponsored reserves.
+     * @param {AccountKeypair} newAccount - The new account's keypair.
+     * @param {number} [startingBalance=0] - The starting balance for the new account (default is 0 XLM).
+     * @returns {SponsoringBuilder} The SponsoringBuilder instance.
+     */
+    createAccount(newAccount: AccountKeypair, startingBalance?: number): SponsoringBuilder;
+    /**
+     * Start sponsoring the future reserves of an account.
+     * @returns {void}
+     */
+    startSponsoring(): void;
+    /**
+     * Stop sponsoring the future reserves of an account.
+     * @returns {void}
+     */
+    stopSponsoring(): void;
+}

package/lib/walletSdk/Horizon/Transaction/TransactionBuilder.d.ts

@@ -1,20 +1,121 @@
-import { Account as StellarAccount, Transaction, Server, Memo, xdr } from "stellar-sdk";
+import { Account as StellarAccount, Transaction, Horizon, Memo, xdr } from "stellar-sdk";
 import { Config } from "walletSdk";
 import { AccountKeypair } from "../Account";
-import { IssuedAssetId, StellarAssetId } from "../../Asset";
-import { WithdrawTransaction } from "../../Types";
-export declare class TransactionBuilder {
-    private network;
-    private operations;
+import { StellarAssetId } from "../../Asset";
+import { WithdrawTransaction, PathPayParams } from "../../Types";
+import { CommonTransactionBuilder } from "./CommonTransactionBuilder";
+import { SponsoringBuilder } from "./SponsoringBuilder";
+/**
+ * Used for building transactions.
+ * Do not create this object directly, use the Stellar class to create a transaction.
+ * @class
+ */
+export declare class TransactionBuilder extends CommonTransactionBuilder<TransactionBuilder> {
+    private cfg;
     private builder;
-    sourceAccount: string;
-    constructor(cfg: Config, sourceAccount: StellarAccount, baseFee?: number, memo?: Memo, timebounds?: Server.Timebounds);
+    /**
+     * Creates a new instance of the TransactionBuilder class for constructing Stellar transactions.
+     * @constructor
+     * @param {Config} cfg - Configuration object for Stellar operations.
+     * @param {StellarAccount} sourceAccount - The source account for the transaction.
+     * @param {number} [baseFee] - The base fee for the transaction. If not given will use the config base fee.
+     * @param {Memo} [memo] - The memo for the transaction.
+     * @param {Horizon.Server.Timebounds} [timebounds] - The timebounds for the transaction. If not given will use the config timebounds.
+     */
+    constructor(cfg: Config, sourceAccount: StellarAccount, baseFee?: number, memo?: Memo, timebounds?: Horizon.Server.Timebounds);
+    /**
+     * Sponsoring a transaction.
+     * @param {AccountKeypair} sponsorAccount - The account doing the sponsoring.
+     * @param {(builder: SponsoringBuilder) => SponsoringBuilder} buildingFunction - Function for creating the
+     * operations that will be sponsored.
+     * @see {@link ./SponsoringBuilder.ts} or {@link ./CommonTransactionBuilder.ts} for operations that can be sponsored.
+     * @param {AccountKeypair} [sponsoredAccount] - The account that will be sponsored.
+     * @returns {TransactionBuilder} The transaction builder to build the transaction before submitting.
+     */
+    sponsoring(sponsorAccount: AccountKeypair, buildingFunction: (builder: SponsoringBuilder) => SponsoringBuilder, sponsoredAccount?: AccountKeypair): TransactionBuilder;
+    /**
+     * Creates a Stellar account.
+     * @param {AccountKeypair} newAccount - The new account's keypair.
+     * @param {number} [startingBalance=1] - The starting balance for the new account (default is 1 XLM).
+     * @throws {InsufficientStartingBalanceError} If the starting balance is less than 1.
+     * @returns {TransactionBuilder} The TransactionBuilder instance.
+     */
     createAccount(newAccount: AccountKeypair, startingBalance?: number): TransactionBuilder;
+    /**
+     * Adds a payment operation to transfer an amount of an asset to a destination address.
+     * @param {string} destinationAddress - The destination account's public key.
+     * @param {StellarAssetId} assetId - The asset to transfer.
+     * @param {string} amount - The amount to transfer.
+     * @returns {TransactionBuilder} The TransactionBuilder instance.
+     */
     transfer(destinationAddress: string, assetId: StellarAssetId, amount: string): TransactionBuilder;
+    /**
+     * Creates and adds a path payment operation to the transaction builder.
+     * @param {PathPayParams} params - The path payment parameters.
+     * @param {string} params.destinationAddress - The destination Stellar address to which the payment is sent.
+     * @param {StellarAssetId} params.sendAsset - The asset to be sent.
+     * @param {StellarAssetId} params.destAsset - The asset the destination will receive.
+     * @param {string} [params.sendAmount] - The amount to be sent. Must specify either sendAmount or destAmount,
+     * but not both.
+     * @param {string} [params.destAmount] - The amount to be received by the destination. Must specify either sendAmount or destAmount,
+     * but not both.
+     * @param {string} [params.destMin] - The minimum amount of the destination asset to be receive. This is a
+     * protective measure, it allows you to specify a lower bound for an acceptable conversion. Only used
+     * if using sendAmount.
+     * (optional, default is ".0000001").
+     * @param {string} [params.sendMax] - The maximum amount of the destination asset to be sent. This is a
+     * protective measure, it allows you to specify an upper bound for an acceptable conversion. Only used
+     * if using destAmount.
+     * (optional, default is int64 max).
+     *
+     * @returns {TransactionBuilder} - Returns the current TransactionBuilder instance for method chaining.
+     */
+    pathPay({ destinationAddress, sendAsset, destAsset, sendAmount, destAmount, destMin, sendMax, }: PathPayParams): TransactionBuilder;
+    /**
+     * Swap assets using the Stellar network. This swaps using the
+     * pathPaymentStrictReceive operation.
+     * @param {StellarAssetId} fromAsset - The source asset to be sent.
+     * @param {StellarAssetId} toAsset - The destination asset to receive.
+     * @param {string} amount - The amount of the source asset to be sent.
+     * @param {string} [destMin] - (Optional) The minimum amount of the destination asset to be received.
+     * @returns {TransactionBuilder} Returns the current instance of the TransactionBuilder for method chaining.
+     */
+    swap(fromAsset: StellarAssetId, toAsset: StellarAssetId, amount: string, destMin?: string): TransactionBuilder;
+    /**
+     * Adds an operation to the transaction.
+     * @param {xdr.Operation} op - The operation to add.
+     * @returns {TransactionBuilder} The TransactionBuilder instance.
+     */
     addOperation(op: xdr.Operation): TransactionBuilder;
+    /**
+     * Add a memo for the transaction.
+     * @param {Memo} memo - The memo to add to the transaction.
+     * @returns {TransactionBuilder} The TransactionBuilder instance.
+     */
     setMemo(memo: Memo): TransactionBuilder;
-    addAssetSupport(asset: IssuedAssetId, trustLimit?: string): TransactionBuilder;
-    removeAssetSupport(asset: IssuedAssetId): TransactionBuilder;
-    build(): Transaction;
+    /**
+     * Add a transfer operation to the builder from a sep-24 withdrawal transaction.
+     * @param {WithdrawTransaction} transaction - The withdrawal transaction.
+     * @param {StellarAssetId} assetId - The asset ID to transfer.
+     * @throws {WithdrawalTxNotPendingUserTransferStartError} If the withdrawal transaction status is not pending_user_transfer_start.
+     * @throws {WithdrawalTxMissingMemoError} If the withdrawal transaction is missing a memo.
+     * @throws {WithdrawalTxMemoError} If there is an issue with the withdrawal transaction memo.
+     * @returns {TransactionBuilder} The TransactionBuilder instance.
+     */
     transferWithdrawalTransaction(transaction: WithdrawTransaction, assetId: StellarAssetId): TransactionBuilder;
+    /**
+     * Merges account into a destination account.
+     * **Warning**: This operation will give full control of the account to the destination account,
+     * effectively removing the merged account from the network.
+     * @param {string} destination - The stellar account merging into.
+     * @param {string} [source] - Account that is being merged. If not given then will default to
+     * the TransactionBuilder source account.
+     * @returns {TransactionBuilder} The TransactionBuilder instance.
+     */
+    accountMerge(destination: string, source?: string): TransactionBuilder;
+    /**
+     * Builds the Stellar transaction so can be submitted.
+     * @returns {Transaction} The built Stellar transaction.
+     */
+    build(): Transaction;
 }

package/lib/walletSdk/Horizon/index.d.ts

@@ -1,4 +1,6 @@
-export { PublicKeypair, SigningKeypair } from "./Account";
+export { AccountKeypair, PublicKeypair, SigningKeypair } from "./Account";
 export { AccountService } from "./AccountService";
 export { Stellar } from "./Stellar";
+export { CommonTransactionBuilder } from "./Transaction/CommonTransactionBuilder";
 export { TransactionBuilder } from "./Transaction/TransactionBuilder";
+export { SponsoringBuilder } from "./Transaction/SponsoringBuilder";

package/lib/walletSdk/Recovery/AccountRecover.d.ts

@@ -0,0 +1,58 @@
+import { AxiosInstance } from "axios";
+import { Transaction } from "stellar-sdk";
+import { RecoveryServer, RecoveryServerKey, RecoveryServerMap, RecoveryServerSigningMap } from "walletSdk/Types";
+import { AccountKeypair, Stellar } from "../Horizon";
+/**
+ * Used for Account Recovery using Sep-30.
+ * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0030.md}
+ * @class
+ */
+export declare abstract class AccountRecover {
+    protected stellar: Stellar;
+    protected httpClient: AxiosInstance;
+    protected servers: RecoveryServerMap;
+    /**
+     * Creates a new instance of the AccountRecover class.
+     * @constructor
+     * @param {Stellar} stellar - The stellar instance used to interact with Horizon server.
+     * @param {AxiosInstance} httpClient - The client used to make http calls.
+     * @param {RecoveryServerMap} servers - The recovery servers to use.
+     */
+    constructor(stellar: Stellar, httpClient: AxiosInstance, servers: RecoveryServerMap);
+    /**
+     * Sign transaction with recovery servers. It is used to recover an account using
+     * [SEP-30](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0030.md).
+     * @param {Transaction} transaction - The transaction with new signer to be signed by recovery servers.
+     * @param {AccountKeypair} account - The keypair of the account that will be recovered.
+     * @param {RecoveryServerSigningMap} serverAuth - The map of recovery servers to use.
+     * @returns {Transaction} - The transaction with recovery server signatures
+     * @throws {NotAllSignaturesFetchedError} when all recovery servers don't return signatures
+     */
+    signWithRecoveryServers(transaction: Transaction, account: AccountKeypair, serverAuth: RecoveryServerSigningMap): Promise<Transaction>;
+    /**
+     * Replace a lost device key with a new key.
+     * @param {AccountKeypair} account - The target account.
+     * @param {AccountKeypair} newKey - The key to replace the lost key with.
+     * @param {RecoveryServerSigningMap} serverAuth - A map of recovery servers to use.
+     * @param {AccountKeypair} [lostKey] - The lost device key. If not specified, try to deduce the key from the account signers list.
+     * @param {AccountKeypair} [sponsorAddress] - The sponsor address of the transaction. Please note that not all SEP-30 servers support signing sponsored transactions.
+     * @returns {Promise<Transaction>} The transaction with operations for replacing the device key.
+     */
+    replaceDeviceKey(account: AccountKeypair, newKey: AccountKeypair, serverAuth: RecoveryServerSigningMap, lostKey?: AccountKeypair, sponsorAddress?: AccountKeypair): Promise<Transaction>;
+    protected getServer: (serverKey: RecoveryServerKey) => RecoveryServer;
+    /**
+     * Try to deduce the lost key. If any of these criteria match, one of the signers
+     * from the account will be recognized as the lost device key:
+     * 1. Only signer that's not in [serverAuth]
+     * 2. All signers in [serverAuth] have the same weight, and the potential signer is
+     * the only one with a different weight.
+     * @private
+     * @param {Horizon.ServerApi.AccountRecord} stellarAccount - The Stellar account to lookup existing signers on account.
+     * @param {RecoveryServerSigningMap} serverAuth - A map of recovery servers to use.
+     * @returns {Horizon.ServerApi.AccountRecordSigners} The deduced account signer.
+     * @throws {NoDeviceKeyForAccountError} When no existing ("lost") device key is found.
+     * @throws {UnableToDeduceKeyError} When no criteria match.
+     */
+    private deduceKey;
+    private addRecoveryServerTxnSignature;
+}

package/lib/walletSdk/Recovery/index.d.ts

@@ -1,18 +1,80 @@
 import { AxiosInstance } from "axios";
-import { Server } from "stellar-sdk";
+import { Transaction } from "stellar-sdk";
 import { Config } from "walletSdk";
-import { Stellar } from "../Horizon";
+import { AccountSigner, AccountThreshold, CommonBuilder, RecoverableWallet, RecoverableWalletConfig, RecoveryAccountInfoMap, RecoveryAuthMap, RecoveryServerKey, RecoveryServerMap } from "walletSdk/Types";
+import { AccountRecover } from "./AccountRecover";
+import { Sep10 } from "../Auth";
+import { AccountKeypair, Stellar } from "../Horizon";
 type RecoveryParams = {
     cfg: Config;
     stellar: Stellar;
     httpClient: AxiosInstance;
-    servers: Server[];
+    servers: RecoveryServerMap;
 };
-export declare class Recovery {
+/**
+ * Used for Account Recovery using Sep-30.
+ * @see {@link https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0030.md}
+ * Do not create this object directly, use the Wallet class.
+ * @class
+ */
+export declare class Recovery extends AccountRecover {
     private cfg;
-    private stellar;
-    private httpClient;
-    private servers;
+    /**
+     * Creates a new instance of the Recovery class.
+     * @constructor
+     * @param {RecoveryParams} params - The params used for the Recovery instance.
+     */
     constructor(params: RecoveryParams);
+    /**
+     * Create new auth object to authenticate account with the recovery server using SEP-10.
+     * @param {RecoveryServerKey} key - The key mapping to a recovery server.
+     * @returns {Sep10} - The Sep-10 auth object.
+     */
+    sep10Auth(key: RecoveryServerKey): Sep10;
+    /**
+     * Create new recoverable wallet using
+     * [SEP-30](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0030.md). It
+     * registers the account with recovery servers, adds recovery servers and device account as new
+     * account signers, and sets threshold weights on the account.
+     *
+     * **Warning**: This transaction will lock master key of the account. Make sure you have access to
+     * specified [RecoverableWalletConfig.deviceAddress]
+     *
+     * This transaction can be sponsored.
+     * @param {RecoverableWalletConfig} config - The configuration for recoverable wallet.
+     * @returns {Promise<RecoverableWallet>} The wallet.
+     */
+    createRecoverableWallet(config: RecoverableWalletConfig): Promise<RecoverableWallet>;
+    /**
+     * Retrieves account information from multiple recovery servers for a specified account address.
+     * @param {AccountKeypair} accountAddress - The account address for which to retrieve information.
+     * @param {RecoveryAuthMap} auth - A map of recovery server keys to their respective authentication tokens.
+     * @throws {ServerRequestFailedError} If any of the requests to recovery servers fail.
+     * @returns {Promise<RecoveryAccountInfoMap>} A map of recovery server keys to their respective account information.
+     */
+    getAccountInfo(accountAddress: AccountKeypair, auth: RecoveryAuthMap): Promise<RecoveryAccountInfoMap>;
+    /**
+     * Add recovery servers and device account as new account signers, and set new threshold weights
+     * on the account.
+     *
+     * This transaction can be sponsored.
+     * @param {AccountKeypair} account - Stellar address of the account that is receiving new signers.
+     * @param {AccountSigner[]} accountSigners - A list of account signers and their weights.
+     * @param {AccountThreshold} accountThreshold - Low, medium, and high thresholds to set on the account.
+     * @param {AccountKeypair} [sponsorAddress] - Stellar address of the account sponsoring this transaction.
+     * @param {(builder: CommonBuilder) => CommonBuilder} [builderExtra] - Stellar address of the account sponsoring this transaction.
+     * @returns {Promise<Transaction>}  The built transaction.
+     */
+    registerRecoveryServerSigners(account: AccountKeypair, accountSigners: AccountSigner[], accountThreshold: AccountThreshold, sponsorAddress?: AccountKeypair, builderExtra?: (builder: CommonBuilder) => CommonBuilder): Promise<Transaction>;
+    /**
+     * Register account with recovery servers using
+     * [SEP-30](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0030.md).
+     * @param {AccountKeypair} account - Account being registerd.
+     * @param {RecoveryIdentityMap} identityMap - map of identities to recovery keys.
+     * @returns {Promise<string[]>}  List of recovery signer public keys.
+     */
+    private enrollWithRecoveryServer;
+    private getLatestRecoverySigner;
+    private register;
 }
 export {};