@stellar/stellar-sdk 11.0.0

package/lib/horizon/server_api.d.ts

@@ -0,0 +1,279 @@
+import { Asset } from "@stellar/stellar-base";
+import { Omit } from "utility-types";
+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,34 @@
+/// <reference types="urijs" />
+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/)
+ * @extends 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,51 @@
+"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(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var StrictReceivePathCallBuilder = exports.StrictReceivePathCallBuilder = function (_CallBuilder) {
+  _inherits(StrictReceivePathCallBuilder, _CallBuilder);
+  var _super = _createSuper(StrictReceivePathCallBuilder);
+  function StrictReceivePathCallBuilder(serverUrl, source, destinationAsset, destinationAmount) {
+    var _this;
+    _classCallCheck(this, StrictReceivePathCallBuilder);
+    _this = _super.call(this, 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;
+  }
+  return _createClass(StrictReceivePathCallBuilder);
+}(_call_builder.CallBuilder);

package/lib/horizon/strict_send_path_call_builder.d.ts

@@ -0,0 +1,34 @@
+/// <reference types="urijs" />
+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/)
+ * @extends 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,51 @@
+"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(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var StrictSendPathCallBuilder = exports.StrictSendPathCallBuilder = function (_CallBuilder) {
+  _inherits(StrictSendPathCallBuilder, _CallBuilder);
+  var _super = _createSuper(StrictSendPathCallBuilder);
+  function StrictSendPathCallBuilder(serverUrl, sourceAsset, sourceAmount, destination) {
+    var _this;
+    _classCallCheck(this, StrictSendPathCallBuilder);
+    _this = _super.call(this, 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;
+  }
+  return _createClass(StrictSendPathCallBuilder);
+}(_call_builder.CallBuilder);

package/lib/horizon/trade_aggregation_call_builder.d.ts

@@ -0,0 +1,48 @@
+/// <reference types="urijs" />
+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
+ * @extends CallBuilder
+ * @constructor
+ * @param {string} serverUrl serverUrl Horizon server URL.
+ * @param {Asset} base base asset
+ * @param {Asset} counter counter asset
+ * @param {long} start_time lower time boundary represented as millis since epoch
+ * @param {long} end_time upper time boundary represented as millis since epoch
+ * @param {long} 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 {long} 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 {long} resolution Trade data resolution in milliseconds
+     * @returns {boolean} true if the resolution is allowed
+     */
+    private isValidResolution;
+    /**
+     * @private
+     * @param {long} offset Time offset in milliseconds
+     * @param {long} 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,82 @@
+"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(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var allowedResolutions = [60000, 300000, 900000, 3600000, 86400000, 604800000];
+var TradeAggregationCallBuilder = exports.TradeAggregationCallBuilder = function (_CallBuilder) {
+  _inherits(TradeAggregationCallBuilder, _CallBuilder);
+  var _super = _createSuper(TradeAggregationCallBuilder);
+  function TradeAggregationCallBuilder(serverUrl, base, counter, start_time, end_time, resolution, offset) {
+    var _this;
+    _classCallCheck(this, TradeAggregationCallBuilder);
+    _this = _super.call(this, 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;
+  }
+  _createClass(TradeAggregationCallBuilder, [{
+    key: "isValidResolution",
+    value: function isValidResolution(resolution) {
+      for (var _i = 0, _allowedResolutions = allowedResolutions; _i < _allowedResolutions.length; _i++) {
+        var allowed = _allowedResolutions[_i];
+        if (allowed === resolution) {
+          return true;
+        }
+      }
+      return false;
+    }
+  }, {
+    key: "isValidOffset",
+    value: function isValidOffset(offset, resolution) {
+      var hour = 3600000;
+      return !(offset > resolution || offset >= 24 * hour || offset % hour !== 0);
+    }
+  }]);
+  return TradeAggregationCallBuilder;
+}(_call_builder.CallBuilder);