stelar-sdk 12.3.0

package/lib/horizon/server_api.d.ts

@@ -0,0 +1,278 @@
+import { Asset } from "@stellar/stellar-base";
+import { HorizonApi } from "./horizon_api";
+import { AccountRecordSigners as AccountRecordSignersType } from "./types/account";
+import { AssetRecord as AssetRecordType } from "./types/assets";
+import * as Effects from "./types/effects";
+import { OfferRecord as OfferRecordType } from "./types/offer";
+import { Trade } from "./types/trade";
+export declare namespace ServerApi {
+    export type OfferRecord = OfferRecordType;
+    export type AccountRecordSigners = AccountRecordSignersType;
+    export type AssetRecord = AssetRecordType;
+    export interface CollectionPage<T extends HorizonApi.BaseResponse = HorizonApi.BaseResponse> {
+        records: T[];
+        next: () => Promise<CollectionPage<T>>;
+        prev: () => Promise<CollectionPage<T>>;
+    }
+    export interface CallFunctionTemplateOptions {
+        cursor?: string | number;
+        limit?: number;
+        order?: "asc" | "desc";
+    }
+    export type CallFunction<T extends HorizonApi.BaseResponse = HorizonApi.BaseResponse> = () => Promise<T>;
+    export type CallCollectionFunction<T extends HorizonApi.BaseResponse = HorizonApi.BaseResponse> = (options?: CallFunctionTemplateOptions) => Promise<CollectionPage<T>>;
+    type BaseEffectRecordFromTypes = Effects.AccountCreated | Effects.AccountCredited | Effects.AccountDebited | Effects.AccountThresholdsUpdated | Effects.AccountHomeDomainUpdated | Effects.AccountFlagsUpdated | Effects.DataCreated | Effects.DataRemoved | Effects.DataUpdated | Effects.SequenceBumped | Effects.SignerCreated | Effects.SignerRemoved | Effects.SignerUpdated | Effects.TrustlineCreated | Effects.TrustlineRemoved | Effects.TrustlineUpdated | Effects.TrustlineAuthorized | Effects.TrustlineDeauthorized | Effects.TrustlineAuthorizedToMaintainLiabilities | Effects.ClaimableBalanceCreated | Effects.ClaimableBalanceClaimed | Effects.ClaimableBalanceClaimantCreated | Effects.AccountSponsorshipCreated | Effects.AccountSponsorshipRemoved | Effects.AccountSponsorshipUpdated | Effects.TrustlineSponsorshipCreated | Effects.TrustlineSponsorshipUpdated | Effects.TrustlineSponsorshipRemoved | Effects.DateSponsorshipCreated | Effects.DateSponsorshipUpdated | Effects.DateSponsorshipRemoved | Effects.ClaimableBalanceSponsorshipCreated | Effects.ClaimableBalanceSponsorshipRemoved | Effects.ClaimableBalanceSponsorshipUpdated | Effects.SignerSponsorshipCreated | Effects.SignerSponsorshipUpdated | Effects.SignerSponsorshipRemoved | Effects.LiquidityPoolDeposited | Effects.LiquidityPoolWithdrew | Effects.LiquidityPoolCreated | Effects.LiquidityPoolRemoved | Effects.LiquidityPoolRevoked | Effects.LiquidityPoolTrade | Effects.ContractCredited | Effects.ContractDebited | Trade;
+    export type EffectRecord = BaseEffectRecordFromTypes & EffectRecordMethods;
+    export interface ClaimableBalanceRecord extends HorizonApi.BaseResponse {
+        id: string;
+        paging_token: string;
+        asset: string;
+        amount: string;
+        sponsor?: string;
+        last_modified_ledger: number;
+        claimants: HorizonApi.Claimant[];
+    }
+    export interface AccountRecord extends HorizonApi.BaseResponse {
+        id: string;
+        paging_token: string;
+        account_id: string;
+        sequence: string;
+        sequence_ledger?: number;
+        sequence_time?: string;
+        subentry_count: number;
+        home_domain?: string;
+        inflation_destination?: string;
+        last_modified_ledger: number;
+        last_modified_time: string;
+        thresholds: HorizonApi.AccountThresholds;
+        flags: HorizonApi.Flags;
+        balances: HorizonApi.BalanceLine[];
+        signers: AccountRecordSigners[];
+        data: (options: {
+            value: string;
+        }) => Promise<{
+            value: string;
+        }>;
+        data_attr: {
+            [key: string]: string;
+        };
+        sponsor?: string;
+        num_sponsoring: number;
+        num_sponsored: number;
+        effects: CallCollectionFunction<EffectRecord>;
+        offers: CallCollectionFunction<OfferRecord>;
+        operations: CallCollectionFunction<OperationRecord>;
+        payments: CallCollectionFunction<PaymentOperationRecord>;
+        trades: CallCollectionFunction<TradeRecord>;
+    }
+    export interface LiquidityPoolRecord extends HorizonApi.BaseResponse {
+        id: string;
+        paging_token: string;
+        fee_bp: number;
+        type: HorizonApi.LiquidityPoolType;
+        total_trustlines: string;
+        total_shares: string;
+        reserves: HorizonApi.Reserve[];
+    }
+    export enum TradeType {
+        all = "all",
+        liquidityPools = "liquidity_pool",
+        orderbook = "orderbook"
+    }
+    interface EffectRecordMethods {
+        operation?: CallFunction<OperationRecord>;
+        precedes?: CallFunction<EffectRecord>;
+        succeeds?: CallFunction<EffectRecord>;
+    }
+    export interface LedgerRecord extends HorizonApi.BaseResponse {
+        id: string;
+        paging_token: string;
+        hash: string;
+        prev_hash: string;
+        sequence: number;
+        successful_transaction_count: number;
+        failed_transaction_count: number;
+        operation_count: number;
+        tx_set_operation_count: number | null;
+        closed_at: string;
+        total_coins: string;
+        fee_pool: string;
+        max_tx_set_size: number;
+        protocol_version: number;
+        header_xdr: string;
+        base_fee_in_stroops: number;
+        base_reserve_in_stroops: number;
+        /**
+         * @deprecated  This will be removed in the next major version: the property
+         *     no longer exists on the Horizon API
+         */
+        transaction_count: number;
+        /**
+         * @deprecated  This will be removed in the next major version: the property
+         *     no longer exists on the Horizon API
+         */
+        base_fee: number;
+        /**
+         * @deprecated  This will be removed in the next major version: the property
+         *     no longer exists on the Horizon API
+         */
+        base_reserve: string;
+        effects: CallCollectionFunction<EffectRecord>;
+        operations: CallCollectionFunction<OperationRecord>;
+        self: CallFunction<LedgerRecord>;
+        transactions: CallCollectionFunction<TransactionRecord>;
+    }
+    import OperationResponseType = HorizonApi.OperationResponseType;
+    import OperationResponseTypeI = HorizonApi.OperationResponseTypeI;
+    export interface BaseOperationRecord<T extends OperationResponseType = OperationResponseType, TI extends OperationResponseTypeI = OperationResponseTypeI> extends HorizonApi.BaseOperationResponse<T, TI> {
+        self: CallFunction<OperationRecord>;
+        succeeds: CallFunction<OperationRecord>;
+        precedes: CallFunction<OperationRecord>;
+        effects: CallCollectionFunction<EffectRecord>;
+        transaction: CallFunction<TransactionRecord>;
+    }
+    export interface CreateAccountOperationRecord extends BaseOperationRecord<OperationResponseType.createAccount, OperationResponseTypeI.createAccount>, HorizonApi.CreateAccountOperationResponse {
+    }
+    export interface PaymentOperationRecord extends BaseOperationRecord<OperationResponseType.payment, OperationResponseTypeI.payment>, HorizonApi.PaymentOperationResponse {
+        sender: CallFunction<AccountRecord>;
+        receiver: CallFunction<AccountRecord>;
+    }
+    export interface PathPaymentOperationRecord extends BaseOperationRecord<OperationResponseType.pathPayment, OperationResponseTypeI.pathPayment>, HorizonApi.PathPaymentOperationResponse {
+    }
+    export interface PathPaymentStrictSendOperationRecord extends BaseOperationRecord<OperationResponseType.pathPaymentStrictSend, OperationResponseTypeI.pathPaymentStrictSend>, HorizonApi.PathPaymentStrictSendOperationResponse {
+    }
+    export interface ManageOfferOperationRecord extends BaseOperationRecord<OperationResponseType.manageOffer, OperationResponseTypeI.manageOffer>, HorizonApi.ManageOfferOperationResponse {
+    }
+    export interface PassiveOfferOperationRecord extends BaseOperationRecord<OperationResponseType.createPassiveOffer, OperationResponseTypeI.createPassiveOffer>, HorizonApi.PassiveOfferOperationResponse {
+    }
+    export interface SetOptionsOperationRecord extends BaseOperationRecord<OperationResponseType.setOptions, OperationResponseTypeI.setOptions>, HorizonApi.SetOptionsOperationResponse {
+    }
+    export interface ChangeTrustOperationRecord extends BaseOperationRecord<OperationResponseType.changeTrust, OperationResponseTypeI.changeTrust>, HorizonApi.ChangeTrustOperationResponse {
+    }
+    export interface AllowTrustOperationRecord extends BaseOperationRecord<OperationResponseType.allowTrust, OperationResponseTypeI.allowTrust>, HorizonApi.AllowTrustOperationResponse {
+    }
+    export interface AccountMergeOperationRecord extends BaseOperationRecord<OperationResponseType.accountMerge, OperationResponseTypeI.accountMerge>, HorizonApi.AccountMergeOperationResponse {
+    }
+    export interface InflationOperationRecord extends BaseOperationRecord<OperationResponseType.inflation, OperationResponseTypeI.inflation>, HorizonApi.InflationOperationResponse {
+    }
+    export interface ManageDataOperationRecord extends BaseOperationRecord<OperationResponseType.manageData, OperationResponseTypeI.manageData>, HorizonApi.ManageDataOperationResponse {
+    }
+    export interface BumpSequenceOperationRecord extends BaseOperationRecord<OperationResponseType.bumpSequence, OperationResponseTypeI.bumpSequence>, HorizonApi.BumpSequenceOperationResponse {
+    }
+    export interface CreateClaimableBalanceOperationRecord extends BaseOperationRecord<OperationResponseType.createClaimableBalance, OperationResponseTypeI.createClaimableBalance>, HorizonApi.CreateClaimableBalanceOperationResponse {
+    }
+    export interface ClaimClaimableBalanceOperationRecord extends BaseOperationRecord<OperationResponseType.claimClaimableBalance, OperationResponseTypeI.claimClaimableBalance>, HorizonApi.ClaimClaimableBalanceOperationResponse {
+    }
+    export interface BeginSponsoringFutureReservesOperationRecord extends BaseOperationRecord<OperationResponseType.beginSponsoringFutureReserves, OperationResponseTypeI.beginSponsoringFutureReserves>, HorizonApi.BeginSponsoringFutureReservesOperationResponse {
+    }
+    export interface EndSponsoringFutureReservesOperationRecord extends BaseOperationRecord<OperationResponseType.endSponsoringFutureReserves, OperationResponseTypeI.endSponsoringFutureReserves>, HorizonApi.EndSponsoringFutureReservesOperationResponse {
+    }
+    export interface RevokeSponsorshipOperationRecord extends BaseOperationRecord<OperationResponseType.revokeSponsorship, OperationResponseTypeI.revokeSponsorship>, HorizonApi.RevokeSponsorshipOperationResponse {
+    }
+    export interface ClawbackOperationRecord extends BaseOperationRecord<OperationResponseType.clawback, OperationResponseTypeI.clawback>, HorizonApi.ClawbackOperationResponse {
+    }
+    export interface ClawbackClaimableBalanceOperationRecord extends BaseOperationRecord<OperationResponseType.clawbackClaimableBalance, OperationResponseTypeI.clawbackClaimableBalance>, HorizonApi.ClawbackClaimableBalanceOperationResponse {
+    }
+    export interface SetTrustLineFlagsOperationRecord extends BaseOperationRecord<OperationResponseType.setTrustLineFlags, OperationResponseTypeI.setTrustLineFlags>, HorizonApi.SetTrustLineFlagsOperationResponse {
+    }
+    export interface DepositLiquidityOperationRecord extends BaseOperationRecord<OperationResponseType.liquidityPoolDeposit, OperationResponseTypeI.liquidityPoolDeposit>, HorizonApi.DepositLiquidityOperationResponse {
+    }
+    export interface WithdrawLiquidityOperationRecord extends BaseOperationRecord<OperationResponseType.liquidityPoolWithdraw, OperationResponseTypeI.liquidityPoolWithdraw>, HorizonApi.WithdrawLiquidityOperationResponse {
+    }
+    export interface InvokeHostFunctionOperationRecord extends BaseOperationRecord<OperationResponseType.invokeHostFunction, OperationResponseTypeI.invokeHostFunction>, HorizonApi.InvokeHostFunctionOperationResponse {
+    }
+    export interface BumpFootprintExpirationOperationRecord extends BaseOperationRecord<OperationResponseType.bumpFootprintExpiration, OperationResponseTypeI.bumpFootprintExpiration>, HorizonApi.BumpFootprintExpirationOperationResponse {
+    }
+    export interface RestoreFootprintOperationRecord extends BaseOperationRecord<OperationResponseType.restoreFootprint, OperationResponseTypeI.restoreFootprint>, HorizonApi.RestoreFootprintOperationResponse {
+    }
+    export type OperationRecord = CreateAccountOperationRecord | PaymentOperationRecord | PathPaymentOperationRecord | ManageOfferOperationRecord | PassiveOfferOperationRecord | SetOptionsOperationRecord | ChangeTrustOperationRecord | AllowTrustOperationRecord | AccountMergeOperationRecord | InflationOperationRecord | ManageDataOperationRecord | BumpSequenceOperationRecord | PathPaymentStrictSendOperationRecord | CreateClaimableBalanceOperationRecord | ClaimClaimableBalanceOperationRecord | BeginSponsoringFutureReservesOperationRecord | EndSponsoringFutureReservesOperationRecord | RevokeSponsorshipOperationRecord | ClawbackClaimableBalanceOperationRecord | ClawbackOperationRecord | SetTrustLineFlagsOperationRecord | DepositLiquidityOperationRecord | WithdrawLiquidityOperationRecord | InvokeHostFunctionOperationRecord | BumpFootprintExpirationOperationRecord | RestoreFootprintOperationRecord;
+    export namespace TradeRecord {
+        interface Base extends HorizonApi.BaseResponse {
+            id: string;
+            paging_token: string;
+            ledger_close_time: string;
+            trade_type: TradeType;
+            base_account?: string;
+            base_amount: string;
+            base_asset_type: string;
+            base_asset_code?: string;
+            base_asset_issuer?: string;
+            counter_account?: string;
+            counter_amount: string;
+            counter_asset_type: string;
+            counter_asset_code?: string;
+            counter_asset_issuer?: string;
+            base_is_seller: boolean;
+            price?: {
+                n: string;
+                d: string;
+            };
+            operation: CallFunction<OperationRecord>;
+        }
+        export interface Orderbook extends Base {
+            trade_type: TradeType.orderbook;
+            base_offer_id: string;
+            base_account: string;
+            counter_offer_id: string;
+            counter_account: string;
+            base: CallFunction<AccountRecord>;
+            counter: CallFunction<AccountRecord>;
+        }
+        export interface LiquidityPool extends Base {
+            trade_type: TradeType.liquidityPools;
+            base_liquidity_pool_id?: string;
+            counter_liquidity_pool_id?: string;
+            liquidity_pool_fee_bp: number;
+            base: CallFunction<AccountRecord | LiquidityPoolRecord>;
+            counter: CallFunction<AccountRecord | LiquidityPoolRecord>;
+        }
+        export {};
+    }
+    export type TradeRecord = TradeRecord.Orderbook | TradeRecord.LiquidityPool;
+    export interface TransactionRecord extends Omit<HorizonApi.TransactionResponse, "ledger"> {
+        ledger_attr: HorizonApi.TransactionResponse["ledger"];
+        account: CallFunction<AccountRecord>;
+        effects: CallCollectionFunction<EffectRecord>;
+        ledger: CallFunction<LedgerRecord>;
+        operations: CallCollectionFunction<OperationRecord>;
+        precedes: CallFunction<TransactionRecord>;
+        self: CallFunction<TransactionRecord>;
+        succeeds: CallFunction<TransactionRecord>;
+    }
+    export interface OrderbookRecord extends HorizonApi.BaseResponse {
+        bids: Array<{
+            price_r: {
+                d: number;
+                n: number;
+            };
+            price: string;
+            amount: string;
+        }>;
+        asks: Array<{
+            price_r: {
+                d: number;
+                n: number;
+            };
+            price: string;
+            amount: string;
+        }>;
+        base: Asset;
+        counter: Asset;
+    }
+    export interface PaymentPathRecord extends HorizonApi.BaseResponse {
+        path: Array<{
+            asset_code: string;
+            asset_issuer: string;
+            asset_type: string;
+        }>;
+        source_amount: string;
+        source_asset_type: string;
+        source_asset_code: string;
+        source_asset_issuer: string;
+        destination_amount: string;
+        destination_asset_type: string;
+        destination_asset_code: string;
+        destination_asset_issuer: string;
+    }
+    export {};
+}

package/lib/horizon/server_api.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ServerApi = void 0;
+var _horizon_api = require("./horizon_api");
+var ServerApi;
+(function (_ServerApi) {
+  var TradeType = function (TradeType) {
+    TradeType["all"] = "all";
+    TradeType["liquidityPools"] = "liquidity_pool";
+    TradeType["orderbook"] = "orderbook";
+    return TradeType;
+  }({});
+  _ServerApi.TradeType = TradeType;
+  var OperationResponseType = _horizon_api.HorizonApi.OperationResponseType;
+  var OperationResponseTypeI = _horizon_api.HorizonApi.OperationResponseTypeI;
+})(ServerApi || (exports.ServerApi = ServerApi = {}));

package/lib/horizon/strict_receive_path_call_builder.d.ts

@@ -0,0 +1,33 @@
+import { Asset } from "@stellar/stellar-base";
+import { CallBuilder } from "./call_builder";
+import { ServerApi } from "./server_api";
+/**
+ * The Stellar Network allows payments to be made across assets through path
+ * payments. A strict receive path payment specifies a series of assets to route
+ * a payment through, from source asset (the asset debited from the payer) to
+ * destination asset (the asset credited to the payee).
+ *
+ * A path search is specified using:
+ *
+ * * The source address or source assets.
+ * * The asset and amount that the destination account should receive
+ *
+ * As part of the search, horizon will load a list of assets available to the
+ * source address and will find any payment paths from those source assets to
+ * the desired destination asset. The search's amount parameter will be used to
+ * determine if there a given path can satisfy a payment of the desired amount.
+ *
+ * If a list of assets is passed as the source, horizon will find any payment
+ * paths from those source assets to the desired destination asset.
+ *
+ * Do not create this object directly, use {@link Server#strictReceivePaths}.
+ * @see [Find Payment Paths](https://developers.stellar.org/api/aggregations/paths/)
+ * @augments CallBuilder
+ * @param {string} serverUrl Horizon server URL.
+ * @param {string|Asset[]} source The sender's account ID or a list of Assets. Any returned path must use a source that the sender can hold.
+ * @param {Asset} destinationAsset The destination asset.
+ * @param {string} destinationAmount The amount, denominated in the destination asset, that any returned path should be able to satisfy.
+ */
+export declare class StrictReceivePathCallBuilder extends CallBuilder<ServerApi.CollectionPage<ServerApi.PaymentPathRecord>> {
+    constructor(serverUrl: URI, source: string | Asset[], destinationAsset: Asset, destinationAmount: string);
+}

package/lib/horizon/strict_receive_path_call_builder.js

@@ -0,0 +1,50 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StrictReceivePathCallBuilder = void 0;
+var _call_builder = require("./call_builder");
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var StrictReceivePathCallBuilder = exports.StrictReceivePathCallBuilder = function (_CallBuilder) {
+  function StrictReceivePathCallBuilder(serverUrl, source, destinationAsset, destinationAmount) {
+    var _this;
+    _classCallCheck(this, StrictReceivePathCallBuilder);
+    _this = _callSuper(this, StrictReceivePathCallBuilder, [serverUrl]);
+    _this.url.segment("paths/strict-receive");
+    if (typeof source === "string") {
+      _this.url.setQuery("source_account", source);
+    } else {
+      var assets = source.map(function (asset) {
+        if (asset.isNative()) {
+          return "native";
+        }
+        return "".concat(asset.getCode(), ":").concat(asset.getIssuer());
+      }).join(",");
+      _this.url.setQuery("source_assets", assets);
+    }
+    _this.url.setQuery("destination_amount", destinationAmount);
+    if (!destinationAsset.isNative()) {
+      _this.url.setQuery("destination_asset_type", destinationAsset.getAssetType());
+      _this.url.setQuery("destination_asset_code", destinationAsset.getCode());
+      _this.url.setQuery("destination_asset_issuer", destinationAsset.getIssuer());
+    } else {
+      _this.url.setQuery("destination_asset_type", "native");
+    }
+    return _this;
+  }
+  _inherits(StrictReceivePathCallBuilder, _CallBuilder);
+  return _createClass(StrictReceivePathCallBuilder);
+}(_call_builder.CallBuilder);

package/lib/horizon/strict_send_path_call_builder.d.ts

@@ -0,0 +1,33 @@
+import { Asset } from "@stellar/stellar-base";
+import { CallBuilder } from "./call_builder";
+import { ServerApi } from "./server_api";
+/**
+ * The Stellar Network allows payments to be made across assets through path
+ * payments. A strict send path payment specifies a series of assets to route a
+ * payment through, from source asset (the asset debited from the payer) to
+ * destination asset (the asset credited to the payee).
+ *
+ * A strict send path search is specified using:
+ *
+ * The source asset
+ * The source amount
+ * The destination assets or destination account.
+ *
+ * As part of the search, horizon will load a list of assets available to the
+ * source address and will find any payment paths from those source assets to
+ * the desired destination asset. The search's source_amount parameter will be
+ * used to determine if there a given path can satisfy a payment of the desired
+ * amount.
+ *
+ * Do not create this object directly, use {@link Server#strictSendPaths}.
+ * @see [Find Payment Paths](https://developers.stellar.org/api/aggregations/paths/)
+ * @augments CallBuilder
+ * @param {string} serverUrl Horizon server URL.
+ * @param {Asset} sourceAsset The asset to be sent.
+ * @param {string} sourceAmount The amount, denominated in the source asset, that any returned path should be able to satisfy.
+ * @param {string|Asset[]} destination The destination account or the destination assets.
+ *
+ */
+export declare class StrictSendPathCallBuilder extends CallBuilder<ServerApi.CollectionPage<ServerApi.PaymentPathRecord>> {
+    constructor(serverUrl: URI, sourceAsset: Asset, sourceAmount: string, destination: string | Asset[]);
+}

package/lib/horizon/strict_send_path_call_builder.js

@@ -0,0 +1,50 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.StrictSendPathCallBuilder = void 0;
+var _call_builder = require("./call_builder");
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var StrictSendPathCallBuilder = exports.StrictSendPathCallBuilder = function (_CallBuilder) {
+  function StrictSendPathCallBuilder(serverUrl, sourceAsset, sourceAmount, destination) {
+    var _this;
+    _classCallCheck(this, StrictSendPathCallBuilder);
+    _this = _callSuper(this, StrictSendPathCallBuilder, [serverUrl]);
+    _this.url.segment("paths/strict-send");
+    if (sourceAsset.isNative()) {
+      _this.url.setQuery("source_asset_type", "native");
+    } else {
+      _this.url.setQuery("source_asset_type", sourceAsset.getAssetType());
+      _this.url.setQuery("source_asset_code", sourceAsset.getCode());
+      _this.url.setQuery("source_asset_issuer", sourceAsset.getIssuer());
+    }
+    _this.url.setQuery("source_amount", sourceAmount);
+    if (typeof destination === "string") {
+      _this.url.setQuery("destination_account", destination);
+    } else {
+      var assets = destination.map(function (asset) {
+        if (asset.isNative()) {
+          return "native";
+        }
+        return "".concat(asset.getCode(), ":").concat(asset.getIssuer());
+      }).join(",");
+      _this.url.setQuery("destination_assets", assets);
+    }
+    return _this;
+  }
+  _inherits(StrictSendPathCallBuilder, _CallBuilder);
+  return _createClass(StrictSendPathCallBuilder);
+}(_call_builder.CallBuilder);

package/lib/horizon/trade_aggregation_call_builder.d.ts

@@ -0,0 +1,47 @@
+import { Asset } from "@stellar/stellar-base";
+import { CallBuilder } from "./call_builder";
+import { HorizonApi } from "./horizon_api";
+import { ServerApi } from "./server_api";
+/**
+ * Trade Aggregations facilitate efficient gathering of historical trade data.
+ * Do not create this object directly, use {@link Server#tradeAggregation}.
+ *
+ * @class TradeAggregationCallBuilder
+ * @augments CallBuilder
+ * @class
+ * @param {string} serverUrl serverUrl Horizon server URL.
+ * @param {Asset} base base asset
+ * @param {Asset} counter counter asset
+ * @param {number} start_time lower time boundary represented as millis since epoch
+ * @param {number} end_time upper time boundary represented as millis since epoch
+ * @param {number} resolution segment duration as millis since epoch. *Supported values are 1 minute (60000), 5 minutes (300000), 15 minutes (900000), 1 hour (3600000), 1 day (86400000) and 1 week (604800000).
+ * @param {number} offset segments can be offset using this parameter. Expressed in milliseconds. *Can only be used if the resolution is greater than 1 hour. Value must be in whole hours, less than the provided resolution, and less than 24 hours.
+ */
+export declare class TradeAggregationCallBuilder extends CallBuilder<ServerApi.CollectionPage<TradeAggregationRecord>> {
+    constructor(serverUrl: URI, base: Asset, counter: Asset, start_time: number, end_time: number, resolution: number, offset: number);
+    /**
+     * @private
+     * @param {number} resolution Trade data resolution in milliseconds
+     * @returns {boolean} true if the resolution is allowed
+     */
+    private isValidResolution;
+    /**
+     * @private
+     * @param {number} offset Time offset in milliseconds
+     * @param {number} resolution Trade data resolution in milliseconds
+     * @returns {boolean} true if the offset is valid
+     */
+    private isValidOffset;
+}
+interface TradeAggregationRecord extends HorizonApi.BaseResponse {
+    timestamp: number | string;
+    trade_count: number | string;
+    base_volume: string;
+    counter_volume: string;
+    avg: string;
+    high: string;
+    low: string;
+    open: string;
+    close: string;
+}
+export {};

package/lib/horizon/trade_aggregation_call_builder.js

@@ -0,0 +1,76 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TradeAggregationCallBuilder = void 0;
+var _call_builder = require("./call_builder");
+var _errors = require("../errors");
+function _classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function _defineProperties(e, r) { for (var t = 0; t < r.length; t++) { var o = r[t]; o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o); } }
+function _createClass(e, r, t) { return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : i + ""; }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _possibleConstructorReturn(t, e) { if (e && ("object" == _typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return _assertThisInitialized(t); }
+function _assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+function _inherits(t, e) { if ("function" != typeof e && null !== e) throw new TypeError("Super expression must either be null or a function"); t.prototype = Object.create(e && e.prototype, { constructor: { value: t, writable: !0, configurable: !0 } }), Object.defineProperty(t, "prototype", { writable: !1 }), e && _setPrototypeOf(t, e); }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+var allowedResolutions = [60000, 300000, 900000, 3600000, 86400000, 604800000];
+var TradeAggregationCallBuilder = exports.TradeAggregationCallBuilder = function (_CallBuilder) {
+  function TradeAggregationCallBuilder(serverUrl, base, counter, start_time, end_time, resolution, offset) {
+    var _this;
+    _classCallCheck(this, TradeAggregationCallBuilder);
+    _this = _callSuper(this, TradeAggregationCallBuilder, [serverUrl]);
+    _this.url.segment("trade_aggregations");
+    if (!base.isNative()) {
+      _this.url.setQuery("base_asset_type", base.getAssetType());
+      _this.url.setQuery("base_asset_code", base.getCode());
+      _this.url.setQuery("base_asset_issuer", base.getIssuer());
+    } else {
+      _this.url.setQuery("base_asset_type", "native");
+    }
+    if (!counter.isNative()) {
+      _this.url.setQuery("counter_asset_type", counter.getAssetType());
+      _this.url.setQuery("counter_asset_code", counter.getCode());
+      _this.url.setQuery("counter_asset_issuer", counter.getIssuer());
+    } else {
+      _this.url.setQuery("counter_asset_type", "native");
+    }
+    if (typeof start_time !== "number" || typeof end_time !== "number") {
+      throw new _errors.BadRequestError("Invalid time bounds", [start_time, end_time]);
+    } else {
+      _this.url.setQuery("start_time", start_time.toString());
+      _this.url.setQuery("end_time", end_time.toString());
+    }
+    if (!_this.isValidResolution(resolution)) {
+      throw new _errors.BadRequestError("Invalid resolution", resolution);
+    } else {
+      _this.url.setQuery("resolution", resolution.toString());
+    }
+    if (!_this.isValidOffset(offset, resolution)) {
+      throw new _errors.BadRequestError("Invalid offset", offset);
+    } else {
+      _this.url.setQuery("offset", offset.toString());
+    }
+    return _this;
+  }
+  _inherits(TradeAggregationCallBuilder, _CallBuilder);
+  return _createClass(TradeAggregationCallBuilder, [{
+    key: "isValidResolution",
+    value: function isValidResolution(resolution) {
+      return allowedResolutions.some(function (allowed) {
+        return allowed === resolution;
+      });
+    }
+  }, {
+    key: "isValidOffset",
+    value: function isValidOffset(offset, resolution) {
+      var hour = 3600000;
+      return !(offset > resolution || offset >= 24 * hour || offset % hour !== 0);
+    }
+  }]);
+}(_call_builder.CallBuilder);

package/lib/horizon/trades_call_builder.d.ts

@@ -0,0 +1,49 @@
+import { Asset } from "@stellar/stellar-base";
+import { CallBuilder } from "./call_builder";
+import { ServerApi } from "./server_api";
+/**
+ * Creates a new {@link TradesCallBuilder} pointed to server defined by serverUrl.
+ * Do not create this object directly, use {@link Server#trades}.
+ *
+ * @class TradesCallBuilder
+ * @augments CallBuilder
+ * @class
+ * @see [Trades](https://developers.stellar.org/api/resources/trades/)
+ * @param {string} serverUrl serverUrl Horizon server URL.
+ */
+export declare class TradesCallBuilder extends CallBuilder<ServerApi.CollectionPage<ServerApi.TradeRecord>> {
+    constructor(serverUrl: URI);
+    /**
+     * Filter trades for a specific asset pair (orderbook)
+     * @param {Asset} base asset
+     * @param {Asset} counter asset
+     * @returns {TradesCallBuilder} current TradesCallBuilder instance
+     */
+    forAssetPair(base: Asset, counter: Asset): this;
+    /**
+     * Filter trades for a specific offer
+     * @param {string} offerId ID of the offer
+     * @returns {TradesCallBuilder} current TradesCallBuilder instance
+     */
+    forOffer(offerId: string): this;
+    /**
+     * Filter trades by a specific type.
+     * @param {ServerApi.TradeType} tradeType the trade type to filter by.
+     * @returns {TradesCallBuilder} current TradesCallBuilder instance.
+     */
+    forType(tradeType: ServerApi.TradeType): this;
+    /**
+     * Filter trades for a specific account
+     * @see [Trades for Account](https://developers.stellar.org/api/resources/accounts/trades/)
+     * @param {string} accountId For example: `GBYTR4MC5JAX4ALGUBJD7EIKZVM7CUGWKXIUJMRSMK573XH2O7VAK3SR`
+     * @returns {TradesCallBuilder} current TradesCallBuilder instance
+     */
+    forAccount(accountId: string): this;
+    /**
+     * Filter trades for a specific liquidity pool
+     * @see [Trades for Liquidity Pool](https://developers.stellar.org/api/resources/liquiditypools/trades/)
+     * @param {string} liquidityPoolId For example: `3b476aff8a406a6ec3b61d5c038009cef85f2ddfaf616822dc4fec92845149b4`
+     * @returns {TradesCallBuilder} current TradesCallBuilder instance
+     */
+    forLiquidityPool(liquidityPoolId: string): this;
+}