@stellar/typescript-wallet-sdk 1.2.1 → 1.3.0

package/lib/walletSdk/Types/horizon.d.ts

@@ -1,6 +1,6 @@
-import { Memo, Server, Transaction } from "stellar-sdk";
+import { Memo, Horizon, Transaction } from "stellar-sdk";
 import { AccountKeypair } from "../Horizon/Account";
-import { TransactionBuilder } from "../Horizon/Transaction/TransactionBuilder";
+import { SponsoringBuilder, TransactionBuilder } from "walletSdk/Horizon";
 import { StellarAssetId } from "../Asset";
 export declare enum NETWORK_URLS {
     PUBLIC = "https://horizon.stellar.org",
@@ -10,7 +10,7 @@ export type TransactionParams = {
     sourceAddress: AccountKeypair;
     baseFee?: number;
     memo?: Memo;
-    timebounds?: Server.Timebounds | number;
+    timebounds?: Horizon.Server.Timebounds | number;
 };
 export type FeeBumpTransactionParams = {
     feeAddress: AccountKeypair;
@@ -21,8 +21,8 @@ export type SubmitWithFeeIncreaseParams = {
     sourceAddress: AccountKeypair;
     timeout: number;
     baseFeeIncrease: number;
-    buildingFunction: (TransactionBuilder: any) => TransactionBuilder;
-    signerFunction?: (Transaction: any) => Transaction;
+    buildingFunction: (builder: TransactionBuilder) => TransactionBuilder;
+    signerFunction?: (transaction: Transaction) => Transaction;
     baseFee?: number;
     memo?: Memo;
     maxFee?: number;
@@ -42,3 +42,4 @@ export type PathPayParams = {
     destMin?: string;
     sendMax?: string;
 };
+export type CommonBuilder = TransactionBuilder | SponsoringBuilder;

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

@@ -1,6 +1,7 @@
 import { RawAxiosRequestHeaders } from "axios";
-import { Server, Networks } from "stellar-sdk";
+import { Networks } from "stellar-sdk";
 import { ApplicationConfiguration, StellarConfiguration } from "walletSdk";
+import { RecoveryServerMap } from "./recovery";
 export type WalletParams = {
     stellarConfiguration: StellarConfiguration;
     applicationConfiguration?: ApplicationConfiguration;
@@ -10,8 +11,8 @@ export type WalletAnchor = {
     homeDomain: string;
     language?: string;
 };
-export type WalletRecovery = {
-    servers: Server[];
+export type WalletRecoveryServers = {
+    servers: RecoveryServerMap;
 };
 export type ConfigParams = {
     stellarConfiguration: StellarConfiguration;
@@ -32,6 +33,10 @@ export type AxiosErrorData = {
 export * from "./anchor";
 export * from "./auth";
 export * from "./horizon";
+export * from "./recovery";
+export * from "./sep6";
+export * from "./sep12";
 export * from "./sep24";
+export * from "./sep38";
 export * from "./utils";
 export * from "./watcher";

package/lib/walletSdk/Types/recovery.d.ts

@@ -0,0 +1,128 @@
+import { Transaction } from "stellar-sdk";
+import { WalletSigner } from "walletSdk/Auth";
+import { AccountKeypair, PublicKeypair } from "walletSdk/Horizon";
+import { AuthToken } from "./auth";
+import { CommonBuilder } from "./horizon";
+/**
+ * Configuration for recoverable wallet
+ * @param accountAddress Stellar address of the account that is registering
+ * @param deviceAddress Stellar address of the device that is added as a primary signer. It will
+ * replace the master key of [accountAddress]
+ * @param accountThreshold Low, medium, and high thresholds to set on the account
+ * @param accountIdentity A list of account identities to be registered with the recovery servers
+ * @param signerWeight Signer weight of the device and recovery keys to set
+ * @param sponsorAddress optional Stellar address of the account sponsoring this transaction
+ */
+export type RecoverableWalletConfig = {
+    accountAddress: AccountKeypair;
+    deviceAddress: AccountKeypair;
+    accountThreshold: AccountThreshold;
+    accountIdentity: RecoveryIdentityMap;
+    signerWeight: SignerWeight;
+    sponsorAddress?: AccountKeypair;
+    builderExtra?: (builder: CommonBuilder) => CommonBuilder;
+};
+export type RecoverableWallet = {
+    transaction: Transaction;
+    signers: string[];
+};
+export type AccountSigner = {
+    address: AccountKeypair;
+    weight: number;
+};
+/**
+ * Account weights threshold
+ * @param low Low threshold weight
+ * @param medium Medium threshold weight
+ * @param high High threshold weight
+ */
+export type AccountThreshold = {
+    low: number;
+    medium: number;
+    high: number;
+};
+export type SignerWeight = {
+    device: number;
+    recoveryServer: number;
+};
+/**
+ * Recovery server configuration
+ * @property {string} endpoint - Main endpoint (root domain) of SEP-30 recovery server. E.g. `https://testanchor.stellar.org`
+ * @property {string} authEndpoint - SEP-10 auth endpoint to be used. Should be in the format `<https://domain/auth>`. E.g. `https://testanchor.stellar.org/auth`
+ * @property {string} homeDomain - SEP-10 home domain. E.g. `testanchor.stellar.org`
+ * @property {WalletSigner} [walletSigner] - WalletSigner used to sign authentication
+ */
+export type RecoveryServer = {
+    endpoint: string;
+    authEndpoint: string;
+    homeDomain: string;
+    walletSigner?: WalletSigner;
+    clientDomain?: string;
+};
+export type RecoveryServerKey = string;
+export type RecoveryServerSigning = {
+    signerAddress: string;
+    authToken: AuthToken;
+};
+export type RecoveryServerSigningMap = {
+    [key: RecoveryServerKey]: RecoveryServerSigning;
+};
+export type RecoveryServerMap = {
+    [key: RecoveryServerKey]: RecoveryServer;
+};
+export type RecoveryAuthMap = {
+    [key: RecoveryServerKey]: AuthToken;
+};
+/**
+ * The role of the identity. This value is not used by the server and is stored and echoed back in
+ * responses as a way for a client to know conceptually who each identity represents
+ */
+export declare enum RecoveryRole {
+    OWNER = "owner",
+    SENDER = "sender",
+    RECEIVER = "receiver"
+}
+export declare enum RecoveryType {
+    STELLAR_ADDRESS = "stellar_address",
+    PHONE_NUMBER = "phone_number",
+    EMAIL = "email"
+}
+export type RecoveryAccountAuthMethod = {
+    type: RecoveryType;
+    value: string;
+};
+export type RecoveryAccountIdentity = {
+    role: RecoveryRole;
+    authMethods: RecoveryAccountAuthMethod[];
+};
+export type RecoveryIdentityMap = {
+    [key: RecoveryServerKey]: RecoveryAccountIdentity[];
+};
+export type RecoveryAccountRole = {
+    role: RecoveryRole;
+    authenticated?: boolean;
+};
+export type RecoveryAccountSigner = {
+    key: string;
+};
+export type RecoveryAccount = {
+    address: string;
+    identities: RecoveryAccountRole[];
+    signers: RecoveryAccountSigner[];
+};
+export type RecoverableIdentity = {
+    role: string;
+    authenticated?: boolean;
+};
+export type RecoverableSigner = {
+    key: PublicKeypair;
+    addedAt?: Date;
+};
+export type RecoverableAccountInfo = {
+    address: PublicKeypair;
+    identities: RecoverableIdentity[];
+    signers: RecoverableSigner[];
+};
+export type RecoveryAccountInfoMap = {
+    [key: RecoveryServerKey]: RecoverableAccountInfo;
+};

package/lib/walletSdk/Types/sep12.d.ts

@@ -0,0 +1,57 @@
+export type CustomerInfoMap = {
+    [key: string]: string;
+};
+export declare enum Sep12Status {
+    ACCEPTED = "ACCEPTED",
+    PROCESSING = "PROCESSING",
+    NEEDS_INFO = "NEEDS_INFO",
+    REJECTED = "REJECTED",
+    VERIFICATION_REQUIRED = "VERIFICATION_REQUIRED"
+}
+export declare enum Sep12Type {
+    string = "string",
+    binary = "binary",
+    number = "number",
+    date = "date"
+}
+export type Field = {
+    type: Sep12Type;
+    description: string;
+    choices?: Array<string>;
+    optional?: boolean;
+};
+export type ProvidedField = {
+    type: Sep12Type;
+    description: string;
+    choices?: Array<string>;
+    optional?: boolean;
+    status?: Sep12Status;
+    error?: string;
+};
+export type GetCustomerParams = {
+    id?: string;
+    type?: string;
+    memo?: string;
+    lang?: string;
+};
+export type GetCustomerResponse = {
+    id?: string;
+    status: Sep12Status;
+    fields?: {
+        [key: string]: Field;
+    };
+    provided_fields?: {
+        [key: string]: ProvidedField;
+    };
+    message?: string;
+};
+export type AddCustomerParams = {
+    sep9Info?: CustomerInfoMap;
+    sep9BinaryInfo?: CustomerInfoMap;
+    id?: string;
+    memo?: string;
+    type?: string;
+};
+export type AddCustomerResponse = {
+    id: string;
+};

package/lib/walletSdk/Types/sep38.d.ts

@@ -0,0 +1,93 @@
+import { AxiosInstance } from "axios";
+import { Anchor } from "../Anchor";
+import { AuthToken } from "./auth";
+export interface Sep38Info {
+    assets: Array<Sep38AssetInfo>;
+}
+export interface Sep38AssetInfo {
+    asset: string;
+    sell_delivery_methods?: Array<Sep38DeliveryMethod>;
+    buy_delivery_methods?: Array<Sep38DeliveryMethod>;
+    country_codes?: Array<string>;
+}
+export interface Sep38DeliveryMethod {
+    name: string;
+    description: string;
+}
+export type Sep38Params = {
+    anchor: Anchor;
+    httpClient: AxiosInstance;
+    authToken?: AuthToken;
+};
+export interface Sep38PricesParams {
+    sellAsset: string;
+    sellAmount: string;
+    sellDeliveryMethod?: string;
+    buyDeliveryMethod?: string;
+    countryCode?: string;
+}
+export interface Sep38PricesResponse {
+    buy_assets: Array<Sep38BuyAsset>;
+}
+export interface Sep38BuyAsset {
+    asset: string;
+    price: string;
+    decimals: number;
+}
+export interface Sep38PriceParams {
+    sellAsset: string;
+    buyAsset: string;
+    sellAmount?: string;
+    buyAmount?: string;
+    context: Sep38PriceContext;
+    sellDeliveryMethod?: string;
+    buyDeliveryMethod?: string;
+    countryCode?: string;
+}
+export declare enum Sep38PriceContext {
+    SEP6 = "sep6",
+    SEP24 = "sep24",
+    SEP31 = "sep31"
+}
+export interface Sep38PriceResponse {
+    total_price: string;
+    price: string;
+    sell_amount: string;
+    buy_amount: string;
+    fee: {
+        total: string;
+        asset: string;
+        details?: Array<Sep38FeeDetails>;
+    };
+}
+export interface Sep38FeeDetails {
+    name: string;
+    description?: string;
+    amount: string;
+}
+export interface Sep38PostQuoteParams {
+    sell_asset: string;
+    buy_asset: string;
+    sell_amount: string;
+    buy_amount: string;
+    context: Sep38PriceContext;
+    expire_after?: string;
+    sell_delivery_method?: string;
+    buy_delivery_method?: string;
+    country_code?: string;
+}
+export interface Sep38PostQuoteResponse {
+    id: string;
+    expires_at: string;
+    total_price: string;
+    price: string;
+    sell_asset: string;
+    sell_amount: string;
+    buy_asset: string;
+    buy_amount: string;
+    fee: {
+        total: string;
+        asset: string;
+        details?: Array<Sep38FeeDetails>;
+    };
+}

package/lib/walletSdk/Types/sep6.d.ts

@@ -0,0 +1,160 @@
+import { AxiosInstance } from "axios";
+import { Anchor } from "../Anchor";
+export interface Sep6EndpointInfo {
+    enabled: boolean;
+    authentication_required?: boolean;
+    description?: string;
+}
+export interface Sep6DepositInfo {
+    enabled: boolean;
+    authentication_required?: boolean;
+    fee_fixed?: number;
+    fee_percent?: number;
+    min_amount?: number;
+    max_amount?: number;
+    fields?: {
+        [key: string]: {
+            description: string;
+            optional?: boolean;
+            choices?: string[];
+        };
+    };
+}
+export interface Sep6WithdrawInfo {
+    enabled: boolean;
+    authentication_required?: boolean;
+    fee_fixed?: number;
+    fee_percent?: number;
+    min_amount?: number;
+    max_amount?: number;
+    types?: {
+        [key: string]: {
+            fields?: {
+                [key: string]: {
+                    description: string;
+                    optional?: boolean;
+                    choices?: string[];
+                };
+            };
+        };
+    };
+}
+export interface Sep6Info {
+    deposit: {
+        [key: string]: Sep6DepositInfo;
+    };
+    "deposit-exchange": {
+        [key: string]: Sep6DepositInfo;
+    };
+    withdraw: {
+        [key: string]: Sep6WithdrawInfo;
+    };
+    "withdraw-exchange": {
+        [key: string]: Sep6WithdrawInfo;
+    };
+    fee: {
+        enabled: boolean;
+        description: string;
+    };
+    transactions: Sep6EndpointInfo;
+    transaction: Sep6EndpointInfo;
+    features: {
+        account_creation: boolean;
+        claimable_balances: boolean;
+    };
+}
+export type Sep6Params = {
+    anchor: Anchor;
+    httpClient: AxiosInstance;
+};
+export interface Sep6DepositParams {
+    asset_code: string;
+    account: string;
+    memo_type?: string;
+    memo?: string;
+    email_address?: string;
+    type?: string;
+    lang?: string;
+    on_change_callback?: string;
+    amount?: string;
+    country_code?: string;
+    claimable_balance_supported?: string;
+    customer_id?: string;
+}
+export interface Sep6WithdrawParams {
+    asset_code: string;
+    type: string;
+    dest?: string;
+    dest_extra?: string;
+    account?: string;
+    memo?: string;
+    lang?: string;
+    on_change_callback?: string;
+    amount?: string;
+    country_code?: string;
+    refund_memo?: string;
+    refund_memo_type?: string;
+    customer_id?: string;
+}
+export type Sep6DepositResponse = Sep6DepositSuccess | Sep6MissingKYC | Sep6Pending;
+export interface Sep6DepositSuccess {
+    how?: string;
+    instructions?: {
+        [key: string]: {
+            value: string;
+            description: string;
+        };
+    };
+    id?: string;
+    eta?: number;
+    min_amoun?: number;
+    max_amount?: number;
+    fee_fixed?: number;
+    fee_percent?: number;
+    extra_info?: {
+        message?: string;
+    };
+}
+export interface Sep6MissingKYC {
+    type: string;
+    fields: Array<string>;
+}
+export interface Sep6Pending {
+    type: string;
+    status: string;
+    more_info_url?: string;
+    eta?: number;
+}
+export type Sep6WithdrawResponse = Sep6WithdrawSuccess | Sep6MissingKYC | Sep6Pending;
+export interface Sep6WithdrawSuccess {
+    account_id?: string;
+    memo_type?: string;
+    memo?: string;
+    id?: string;
+    eta?: number;
+    min_amount?: number;
+    max_amount?: number;
+    fee_fixed?: number;
+    fee_percent?: number;
+    extra_info?: {
+        message?: string;
+    };
+}
+export interface Sep6ExchangeParams {
+    destination_asset: string;
+    source_asset: string;
+    amount: string;
+    account?: string;
+    quote_id?: string;
+    memo_type?: string;
+    memo?: string;
+    email_address?: string;
+    type?: string;
+    lang?: string;
+    on_change_callback?: string;
+    country_code?: string;
+    claimable_balance_supported?: string;
+    customer_id?: string;
+    refund_memo?: string;
+    refund_memo_type?: string;
+}

package/lib/walletSdk/Types/watcher.d.ts

@@ -1,6 +1,7 @@
 import { AnchorTransaction } from "./anchor";
+import { AuthToken } from "./auth";
 export type WatchTransactionsParams = {
-    authToken: string;
+    authToken: AuthToken;
     assetCode: string;
     onMessage: (transaction: AnchorTransaction) => void;
     onError: (error: AnchorTransaction | Error) => void;
@@ -12,7 +13,7 @@ export type WatchTransactionsParams = {
     noOlderThan?: string;
 };
 export type WatchTransactionParams = {
-    authToken: string;
+    authToken: AuthToken;
     assetCode: string;
     id: string;
     onMessage: (transaction: AnchorTransaction) => void;
@@ -28,3 +29,7 @@ export interface WatcherResponse {
     refresh: WatcherRefreshFunction;
     stop: WatcherStopFunction;
 }
+export declare enum WatcherSepType {
+    SEP6 = "SEP6",
+    SEP24 = "SEP24"
+}

package/lib/walletSdk/Utils/toml.d.ts

@@ -1,3 +1,3 @@
-import { StellarTomlResolver } from "stellar-sdk";
+import { StellarToml } from "stellar-sdk";
 import { TomlInfo } from "../Types";
-export declare const parseToml: (toml: StellarTomlResolver.StellarToml) => TomlInfo;
+export declare const parseToml: (toml: StellarToml.Api.StellarToml) => TomlInfo;

package/lib/walletSdk/Watcher/getTransactions.d.ts

@@ -0,0 +1,8 @@
+import { AxiosInstance } from "axios";
+import { AuthToken } from "../Types";
+export declare const _getTransactionsForAsset: <T>(authToken: AuthToken, params: {
+    [key: string]: string | number;
+}, endpoint: string, client: AxiosInstance) => Promise<T[]>;
+export declare const _getTransactionBy: <T>(authToken: AuthToken, params: {
+    [key: string]: string | number;
+}, endpoint: string, client: AxiosInstance) => Promise<T>;

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

@@ -1,25 +1,50 @@
 import { Anchor } from "../Anchor";
-import { WatchTransactionParams, WatchTransactionsParams, WatcherResponse } from "../Types";
+import { WatchTransactionParams, WatchTransactionsParams, WatcherResponse, WatcherSepType } from "../Types";
+/**
+ * Used for watching transaction from an Anchor as part of sep-24.
+ * Do not create this object directly, use the Anchor class.
+ * @class
+ */
 export declare class Watcher {
     private anchor;
+    private sepType;
     private _oneTransactionWatcher;
     private _allTransactionsWatcher?;
     private _watchOneTransactionRegistry;
     private _watchAllTransactionsRegistry;
     private _transactionsRegistry;
     private _transactionsIgnoredRegistry;
-    constructor(anchor: Anchor);
+    /**
+     * Creates a new instance of the Watcher class.
+     *
+     * @param {Anchor} anchor - The Anchor to watch from.
+     * @param {WatcherSepType} sepType - The Sep type the anchor being polled is using
+     * (ie. Sep-6 or Sep-24).
+     */
+    constructor(anchor: Anchor, sepType: WatcherSepType);
     /**
      * Watch all transactions returned from a transfer server. When new or
      * updated transactions come in, run an `onMessage` callback.
      *
      * On initial load, it'll return ALL pending transactions via onMessage.
      * Subsequent messages will be any one of these events:
-     *  - Any new transaction appears
-     *  - Any of the initial pending transactions change any state
+     * - Any new transaction appears
+     * - Any of the initial pending transactions change any state
      *
      * You may also provide an array of transaction ids, `watchlist`, and this
      * watcher will always react to transactions whose ids are in the watchlist.
+     * @param {WatchTransactionsParams} params - The Watch Transactions params.
+     * @param {AuthToken} params.authToken - The authentication token used for authenticating with the anchor.
+     * @param {string} params.assetCode - The asset code to filter transactions by.
+     * @param {Function} params.onMessage - A callback function to handle incoming transaction messages.
+     * @param {Function} params.onError - A callback function to handle errors during transaction streaming.
+     * @param {Array<string>} [params.watchlist=[]] - An optional array of specific transaction IDs to watch.
+     * @param {number} [params.timeout=5000] - The timeout duration for the streaming connection (in milliseconds).
+     * @param {boolean} [params.isRetry=false] - Indicates whether this is a retry attempt (optional).
+     * @param {string} [params.lang=this.anchor.language] - The desired language (localization) for transaction messages.
+     * @param {string} params.kind - The kind of transaction to filter by.
+     * @param {string} [params.noOlderThan] - A date and time specifying that transactions older than this value should not be included.
+     * @returns {WatcherResponse} An object holding the refresh and stop functions for the watcher.
      */
     watchAllTransactions({ authToken, assetCode, onMessage, onError, watchlist, timeout, isRetry, lang, kind, noOlderThan, }: WatchTransactionsParams): WatcherResponse;
     /**
@@ -28,6 +53,18 @@ export declare class Watcher {
      * * onSuccess - When the transaction comes back as completed / refunded / expired.
      * * onError - When there's a runtime error, or the transaction comes back as
      * no_market / too_small / too_large / error.
+     * @param {WatchTransactionParams} params - The Watch Transaction params.
+     * @param {AuthToken} params.authToken - The authentication token used for authenticating with th anchor.
+     * @param {string} params.assetCode - The asset code to filter transactions by.
+     * @param {string} params.id - The id of the transaction to watch.
+     * @param {Function} params.onMessage - A callback function to handle incoming transaction messages.
+     * @param {Function} params.onSuccess - If a transaction status is in a end state (eg. completed, refunded, expired) then this callback is called.
+     * @param {Function} params.onError - A callback function to handle errors during transaction streaming.
+     * @param {number} [params.timeout=5000] - The timeout duration for the streaming connection (in milliseconds).
+     * @param {boolean} [params.isRetry=false] - Indicates whether this is a retry attempt (optional).
+     * @param {string} [params.lang=this.anchor.language] - The desired language (localization) for transaction messages.
+     * @returns {WatcherResponse} An object holding the refresh and stop functions for the watcher.
      */
     watchOneTransaction({ authToken, assetCode, id, onMessage, onSuccess, onError, timeout, isRetry, lang, }: WatchTransactionParams): WatcherResponse;
 }
+export * from "./getTransactions";

package/lib/walletSdk/index.d.ts

@@ -1,19 +1,56 @@
 import { AxiosInstance } from "axios";
-import { Networks, Server } from "stellar-sdk";
+import { Networks, Horizon } from "stellar-sdk";
 import { Anchor } from "./Anchor";
 import { WalletSigner } from "./Auth";
 import { Stellar } from "./Horizon";
 import { Recovery } from "./Recovery";
-import { ConfigParams, StellarConfigurationParams, WalletAnchor, WalletParams, WalletRecovery } from "./Types";
+import { ConfigParams, StellarConfigurationParams, WalletAnchor, WalletParams, WalletRecoveryServers } from "./Types";
+/**
+ * The Wallet SDK main entry point class. From these class methods you can create a
+ * wallet on the Stellar network.
+ * @class
+ */
 export declare class Wallet {
     private cfg;
     private language;
+    /**
+     * Creates a Wallet instance configured to the test network.
+     * @returns {Wallet} A Wallet instance configured to the test network.
+     */
     static TestNet: () => Wallet;
+    /**
+     * Creates a Wallet instance configured to the public network.
+     * @returns {Wallet} A Wallet instance configured to the public network.
+     */
     static MainNet: () => Wallet;
+    /**
+     * Creates a new Wallet instance.
+     * @param {WalletParams} params - The Wallet params.
+     * @param {StellarConfiguration} params.stellarConfiguration - The Stellar configuration.
+     * @param {ApplicationConfiguration} params.applicationConfiguration - The Application configuration.
+     * @param {string} [params.language] - The default langauge to use.
+     */
     constructor({ stellarConfiguration, applicationConfiguration, language, }: WalletParams);
+    /**
+     * Create an Anchor instance for interacting with an Anchor.
+     * @param {WalletAnchor} params - The anchor params.
+     * @param {string} params.homeDomain - The home domain of the anchor. This domain will be used for
+     * things like getting the toml info.
+     * @param {string} [params.language=this.language] - The language setting for the Anchor.
+     * @returns {Anchor} An Anchor instance.
+     */
     anchor({ homeDomain, language }: WalletAnchor): Anchor;
+    /**
+     * Create a Stellar instance for interacting with the Stellar network.
+     * @returns {Stellar} A Stellar instance.
+     */
     stellar(): Stellar;
-    recovery({ servers }: WalletRecovery): Recovery;
+    /**
+     * Create a Recovery instance for account recovery using SEP-30.
+     * @param {WalletRecoveryServers} servers - A map of recovery servers.
+     * @returns {Recovery} A Recovery instance.
+     */
+    recovery({ servers }: WalletRecoveryServers): Recovery;
 }
 export declare class Config {
     stellar: StellarConfiguration;
@@ -21,7 +58,7 @@ export declare class Config {
     constructor({ stellarConfiguration, applicationConfiguration, }: ConfigParams);
 }
 export declare class StellarConfiguration {
-    server: Server;
+    server: Horizon.Server;
     network: Networks;
     horizonUrl: string;
     baseFee: number;