@stellar/stellar-sdk 12.2.0 → 13.0.0-beta.1

package/lib/contract/rust_result.d.ts

@@ -3,10 +3,11 @@
  * methods that return Results, to maintain their distinction from methods
  * that simply either return a value or throw.
  *
- * **Why is this needed?**
+ * #### Why is this needed?
  *
- * This is used by `ContractSpec` and `AssembledTransaction` when parsing
- * values return by contracts.
+ * This is used by {@link module:contract.Spec | `ContractSpec`} and
+ * {@link module:contract.AssembledTransaction | `AssembledTransaction`} when
+ * parsing values return by contracts.
  *
  * Contract methods can be implemented to return simple values, in which case
  * they can also throw errors. This matches JavaScript's most idiomatic
@@ -27,6 +28,8 @@
  * In the future, if this feels too un-idiomatic for JavaScript, we can always
  * remove this and flatten all JS calls to `try...catch`. Easier to remove this
  * logic later than it would be to add it.
+ *
+ * @memberof module:contract
  */
 export interface Result<T, E extends ErrorMessage = ErrorMessage> {
     unwrap(): T;
@@ -36,17 +39,22 @@ export interface Result<T, E extends ErrorMessage = ErrorMessage> {
 }
 /**
  * Error interface containing the error message. Matches Rust's implementation.
- * Part of implementing {@link Result}, a minimal implementation of Rust's
- * `Result` type. Used for contract methods that return Results, to maintain
- * their distinction from methods that simply either return a value or throw.
+ * Part of implementing {@link module:contract.Result | Result}, a minimal
+ * implementation of Rust's `Result` type. Used for contract methods that return
+ * Results, to maintain their distinction from methods that simply either return
+ * a value or throw.
+ *
+ * @memberof module:contract
  */
 export interface ErrorMessage {
     message: string;
 }
 /**
- * Part of implementing {@link Result}, a minimal implementation of Rust's
- * `Result` type. Used for contract methods that return Results, to maintain
- * their distinction from methods that simply either return a value or throw.
+ * Part of implementing {@link module:contract.Result | Result}, a minimal
+ * implementation of Rust's `Result` type. Used for contract methods that return
+ * Results, to maintain their distinction from methods that simply either return
+ * a value or throw.
+ * @private
  */
 export declare class Ok<T> implements Result<T, never> {
     readonly value: T;
@@ -57,9 +65,11 @@ export declare class Ok<T> implements Result<T, never> {
     isErr(): boolean;
 }
 /**
- * Part of implementing {@link Result}, a minimal implementation of Rust's
- * `Result` type. Used for contract methods that return Results, to maintain
- * their distinction from methods that simply either return a value or throw.
+ * Part of implementing {@link module:contract.Result | Result}, a minimal
+ * implementation of Rust's `Result` type. Used for contract methods that return
+ * Results, to maintain their distinction from methods that simply either return
+ * a value or throw.
+ * @private
  */
 export declare class Err<E extends ErrorMessage> implements Result<never, E> {
     readonly error: E;

package/lib/contract/sent_transaction.d.ts

@@ -1,4 +1,4 @@
-import { Server } from "../rpc/server";
+import { Server } from "../rpc";
 import { Api } from "../rpc/api";
 import type { AssembledTransaction } from "./assembled_transaction";
 /**
@@ -14,6 +14,12 @@ import type { AssembledTransaction } from "./assembled_transaction";
  *    {@link MethodOptions.timeoutInSeconds} seconds. See all attempts in
  *    `getTransactionResponseAll` and the most recent attempt in
  *    `getTransactionResponse`.
+ *
+ * @memberof module:contract
+ * @class
+ *
+ * @param {Function} signTransaction More info in {@link MethodOptions}
+ * @param {module:contract.AssembledTransaction<T>} assembled {@link AssembledTransaction} from which this SentTransaction was initialized
  */
 export declare class SentTransaction<T> {
     assembled: AssembledTransaction<T>;

package/lib/contract/sent_transaction.js

@@ -4,7 +4,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SentTransaction = void 0;
-var _server = require("../rpc/server");
+var _rpc = require("../rpc");
 var _api = require("../rpc/api");
 var _utils = require("./utils");
 var _types = require("./types");
@@ -75,7 +75,7 @@ var SentTransaction = exports.SentTransaction = function () {
       }, _callee);
     })));
     this.assembled = assembled;
-    this.server = new _server.Server(this.assembled.options.rpcUrl, {
+    this.server = new _rpc.Server(this.assembled.options.rpcUrl, {
       allowHttp: (_this$assembled$optio2 = this.assembled.options.allowHttp) !== null && _this$assembled$optio2 !== void 0 ? _this$assembled$optio2 : false
     });
   }

package/lib/contract/spec.d.ts

@@ -8,8 +8,13 @@ export interface Union<T> {
  * Provides a ContractSpec class which can contains the XDR types defined by the contract.
  * This allows the class to be used to convert between native and raw `xdr.ScVal`s.
  *
+ * Constructs a new ContractSpec from an array of XDR spec entries.
+ *
+ * @memberof module:contract
+ * @param {xdr.ScSpecEntry[] | string[]} entries the XDR spec entries
+ * @throws {Error} if entries is invalid
+ *
  * @example
- * ```js
  * const specEntries = [...]; // XDR spec entries of a smart contract
  * const contractSpec = new ContractSpec(specEntries);
  *
@@ -27,23 +32,16 @@ export interface Union<T> {
  * const result = contractSpec.funcResToNative('funcName', resultScv);
  *
  * console.log(result); // {success: true}
- * ```
  */
 export declare class Spec {
-    entries: xdr.ScSpecEntry[];
     /**
-     * Constructs a new ContractSpec from an array of XDR spec entries.
-     *
-     * @param {xdr.ScSpecEntry[] | string[]} entries the XDR spec entries
-     *
-     * @throws {Error} if entries is invalid
+     * The XDR spec entries.
      */
+    entries: xdr.ScSpecEntry[];
     constructor(entries: xdr.ScSpecEntry[] | string[]);
     /**
      * Gets the XDR functions from the spec.
-     *
      * @returns {xdr.ScSpecFunctionV0[]} all contract functions
-     *
      */
     funcs(): xdr.ScSpecFunctionV0[];
     /**
@@ -65,13 +63,11 @@ export declare class Spec {
      * @throws {Error} if argument is missing or incorrect type
      *
      * @example
-     * ```js
      * const args = {
      *   arg1: 'value1',
      *   arg2: 1234
      * };
      * const scArgs = contractSpec.funcArgsToScVals('funcName', args);
-     * ```
      */
     funcArgsToScVals(name: string, args: object): xdr.ScVal[];
     /**
@@ -84,10 +80,8 @@ export declare class Spec {
      * @throws {Error} if return type mismatch or invalid input
      *
      * @example
-     * ```js
      * const resultScv = 'AAA=='; // Base64 encoded ScVal
      * const result = contractSpec.funcResToNative('funcName', resultScv);
-     * ```
      */
     funcResToNative(name: string, val_or_base64: xdr.ScVal | string): any;
     /**

package/lib/contract/types.d.ts

@@ -1,26 +1,64 @@
 import { Memo, MemoType, Operation, Transaction, xdr } from "@stellar/stellar-base";
 export type XDR_BASE64 = string;
+/**
+ * An unsigned 32-bit integer.
+ * @memberof module:contract
+ */
 export type u32 = number;
+/**
+ * A signed 32-bit integer.
+ * @memberof module:contract
+ */
 export type i32 = number;
+/**
+ * An unsigned 64-bit integer.
+ * @memberof module:contract
+ */
 export type u64 = bigint;
+/**
+ * A signed 64-bit integer.
+ * @memberof module:contract
+ */
 export type i64 = bigint;
+/**
+ * An unsigned 128-bit integer.
+ * @memberof module:contract
+ */
 export type u128 = bigint;
+/**
+ * A signed 128-bit integer.
+ * @memberof module:contract
+ */
 export type i128 = bigint;
+/**
+ * An unsigned 256-bit integer.
+ * @memberof module:contract
+ */
 export type u256 = bigint;
+/**
+ * A signed 256-bit integer.
+ * @memberof module:contract
+ */
 export type i256 = bigint;
 export type Option<T> = T | undefined;
 export type Typepoint = bigint;
 export type Duration = bigint;
 /**
  * A "regular" transaction, as opposed to a FeeBumpTransaction.
+ * @memberof module:contract
+ * @type {Transaction<Memo<MemoType>, Operation[]>}
  */
 export type Tx = Transaction<Memo<MemoType>, Operation[]>;
+/**
+ * Options for a smart contract client.
+ * @memberof module:contract
+ */
 export type ClientOptions = {
     /**
      * The public key of the account that will send this transaction. You can
      * override this for specific methods later, like
-     * {@link AssembledTransaction#signAndSend} and
-     * {@link AssembledTransaction#signAuthEntries}.
+     * [signAndSend]{@link module:contract.AssembledTransaction#signAndSend} and
+     * [signAuthEntries]{@link module:contract.AssembledTransaction#signAuthEntries}.
      */
     publicKey?: string;
     /**
@@ -29,7 +67,7 @@ export type ClientOptions = {
      * calls, which only need to be simulated. If you do not need to sign and
      * send, there is no need to provide this. If you do not provide it during
      * initialization, you can provide it later when you call
-     * {@link AssembledTransaction#signAndSend}.
+     * {@link module:contract.AssembledTransaction#signAndSend signAndSend}.
      *
      * Matches signature of `signTransaction` from Freighter.
      */
@@ -43,19 +81,29 @@ export type ClientOptions = {
      * private key corresponding to the provided `publicKey`. This is only needed
      * for multi-auth transactions, in which one transaction is signed by
      * multiple parties. If you do not provide it during initialization, you can
-     * provide it later when you call {@link AssembledTransaction#signAuthEntries}.
+     * provide it later when you call {@link module:contract.AssembledTransaction#signAuthEntries signAuthEntries}.
      *
      * Matches signature of `signAuthEntry` from Freighter.
      */
     signAuthEntry?: (entryXdr: XDR_BASE64, opts?: {
         accountToSign?: string;
     }) => Promise<XDR_BASE64>;
+    /** The address of the contract the client will interact with. */
     contractId: string;
+    /**
+     * The network passphrase for the Stellar network this contract is deployed
+     * to.
+     */
     networkPassphrase: string;
+    /**
+     * The URL of the RPC instance that will be used to interact with this
+     * contract.
+     */
     rpcUrl: string;
     /**
      * If true, will allow HTTP requests to the Soroban network. If false, will
-     * only allow HTTPS requests. @default false
+     * only allow HTTPS requests.
+     * @default false
      */
     allowHttp?: boolean;
     /**
@@ -67,11 +115,11 @@ export type ClientOptions = {
      * on-chain XDR that also describes your contract's methods. Each error will
      * have a specific number.
      *
-     * A Client makes method calls with an {@link AssembledTransaction}.
+     * A Client makes method calls with an {@link module:contract.AssembledTransaction AssembledTransaction}.
      * When one of these method calls encounters an error, `AssembledTransaction`
      * will first attempt to parse the error as an "official" `contracterror`
      * error, by using this passed-in `errorTypes` object. See
-     * {@link AssembledTransaction#parseError}. If `errorTypes` is blank or no
+     * {@link module:contract.AssembledTransaction#parseError parseError}. If `errorTypes` is blank or no
      * matching error is found, then it will throw the raw error.
      * @default {}
      */
@@ -79,24 +127,32 @@ export type ClientOptions = {
         message: string;
     }>;
 };
+/**
+ * Options for a smart contract method invocation.
+ * @memberof module:contract
+ */
 export type MethodOptions = {
     /**
-     * The fee to pay for the transaction. Default: {@link BASE_FEE}
+     * The fee to pay for the transaction.
+     * @default 100
      */
     fee?: string;
     /**
-     * The maximum amount of time to wait for the transaction to complete.
-     * Default: {@link DEFAULT_TIMEOUT}
+     * The timebounds which should be set for transactions generated by this
+     * contract client. {@link module:contract#.DEFAULT_TIMEOUT}
+     * @default 300
      */
     timeoutInSeconds?: number;
     /**
      * Whether to automatically simulate the transaction when constructing the
-     * AssembledTransaction. Default: true
+     * AssembledTransaction.
+     * @default true
      */
     simulate?: boolean;
     /**
      * If true, will automatically attempt to restore the transaction if there
-     * are archived entries that need renewal. @default false
+     * are archived entries that need renewal.
+     * @default false
      */
     restore?: boolean;
 };
@@ -106,7 +162,19 @@ export type AssembledTransactionOptions<T = string> = MethodOptions & ClientOpti
     parseResultXdr: (xdr: xdr.ScVal) => T;
 };
 /**
- * The default timeout for waiting for a transaction to be included in a block.
+ * The default timebounds, in seconds, during which a transaction will be valid.
+ * This is attached to the transaction _before_ transaction simulation (it is
+ * needed for simulation to succeed). It is also re-calculated and re-added
+ * _before_ transaction signing.
+ * @constant {number}
+ * @default 300
+ * @memberof module:contract
  */
 export declare const DEFAULT_TIMEOUT: number;
+/**
+ * An impossible account on the Stellar network
+ * @constant {string}
+ * @default GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF
+ * @memberof module:contract
+ */
 export declare const NULL_ACCOUNT = "GAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAWHF";

package/lib/contract/utils.d.ts

@@ -1,9 +1,10 @@
 import { xdr, Account } from "@stellar/stellar-base";
-import { Server } from "../rpc/server";
+import { Server } from "../rpc";
 import { AssembledTransactionOptions } from "./types";
 /**
  * Keep calling a `fn` for `timeoutInSeconds` seconds, if `keepWaitingIf` is
  * true. Returns an array of all attempts to call the function.
+ * @private
  */
 export declare function withExponentialBackoff<T>(
 /** Function to call repeatedly */
@@ -22,10 +23,15 @@ verbose?: boolean): Promise<T[]>;
  * methods. Each error will have a specific number. This Regular Expression
  * matches these "expected error types" that a contract may throw, and helps
  * {@link AssembledTransaction} parse these errors.
+ *
+ * @constant {RegExp}
+ * @default "/Error\(Contract, #(\d+)\)/"
+ * @memberof module:contract.Client
  */
 export declare const contractErrorPattern: RegExp;
 /**
  * A TypeScript type guard that checks if an object has a `toString` method.
+ * @private
  */
 export declare function implementsToString(
 /** some object that may or may not have a `toString` method */
@@ -34,6 +40,7 @@ obj: unknown): obj is {
 };
 /**
  * Reads a binary stream of ScSpecEntries into an array for processing by ContractSpec
+ * @private
  */
 export declare function processSpecEntryStream(buffer: Buffer): xdr.ScSpecEntry[];
 export declare function getAccount<T>(options: AssembledTransactionOptions<T>, server: Server): Promise<Account>;

package/lib/errors/account_requires_memo.d.ts

@@ -0,0 +1,24 @@
+/**
+ * AccountRequiresMemoError is raised when a transaction is trying to submit an
+ * operation to an account which requires a memo. See
+ * [SEP0029](https://github.com/stellar/stellar-protocol/blob/master/ecosystem/sep-0029.md)
+ * for more information.
+ *
+ * This error contains two attributes to help you identify the account requiring
+ * the memo and the operation where the account is the destination
+ * @category Errors
+ *
+ * @param {string} message Human-readable error message
+ * @param {string} accountId The account which requires a memo
+ * @param {number} operationIndex The index of the operation where `accountId` is the destination
+ *
+ * @example
+ * console.log('The following account requires a memo ', err.accountId)
+ * console.log('The account is used in operation: ', err.operationIndex)
+ */
+export declare class AccountRequiresMemoError extends Error {
+    __proto__: AccountRequiresMemoError;
+    accountId: string;
+    operationIndex: number;
+    constructor(message: string, accountId: string, operationIndex: number);
+}

package/lib/errors/account_requires_memo.js

@@ -0,0 +1,38 @@
+"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.AccountRequiresMemoError = void 0;
+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 _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 _wrapNativeSuper(t) { var r = "function" == typeof Map ? new Map() : void 0; return _wrapNativeSuper = function _wrapNativeSuper(t) { if (null === t || !_isNativeFunction(t)) return t; if ("function" != typeof t) throw new TypeError("Super expression must either be null or a function"); if (void 0 !== r) { if (r.has(t)) return r.get(t); r.set(t, Wrapper); } function Wrapper() { return _construct(t, arguments, _getPrototypeOf(this).constructor); } return Wrapper.prototype = Object.create(t.prototype, { constructor: { value: Wrapper, enumerable: !1, writable: !0, configurable: !0 } }), _setPrototypeOf(Wrapper, t); }, _wrapNativeSuper(t); }
+function _construct(t, e, r) { if (_isNativeReflectConstruct()) return Reflect.construct.apply(null, arguments); var o = [null]; o.push.apply(o, e); var p = new (t.bind.apply(t, o))(); return r && _setPrototypeOf(p, r.prototype), p; }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+function _isNativeFunction(t) { try { return -1 !== Function.toString.call(t).indexOf("[native code]"); } catch (n) { return "function" == typeof t; } }
+function _setPrototypeOf(t, e) { return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, _setPrototypeOf(t, e); }
+function _getPrototypeOf(t) { return _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, _getPrototypeOf(t); }
+var AccountRequiresMemoError = exports.AccountRequiresMemoError = function (_Error) {
+  function AccountRequiresMemoError(message, accountId, operationIndex) {
+    var _this;
+    _classCallCheck(this, AccountRequiresMemoError);
+    var trueProto = (this instanceof AccountRequiresMemoError ? this.constructor : void 0).prototype;
+    _this = _callSuper(this, AccountRequiresMemoError, [message]);
+    _this.__proto__ = trueProto;
+    _this.constructor = AccountRequiresMemoError;
+    _this.name = "AccountRequiresMemoError";
+    _this.accountId = accountId;
+    _this.operationIndex = operationIndex;
+    return _this;
+  }
+  _inherits(AccountRequiresMemoError, _Error);
+  return _createClass(AccountRequiresMemoError);
+}(_wrapNativeSuper(Error));

package/lib/errors/bad_request.d.ts

@@ -0,0 +1,14 @@
+import { NetworkError } from "./network";
+/**
+ * BadRequestError is raised when a request made to Horizon is invalid in some
+ * way (incorrect timebounds for trade call builders, for example.)
+ * @augments NetworkError
+ * @inheritdoc
+ * @category Errors
+ *
+ * @param {string} message Human-readable error message
+ * @param {any} response Response details, received from the Horizon server
+ */
+export declare class BadRequestError extends NetworkError {
+    constructor(message: string, response: any);
+}

package/lib/errors/bad_request.js

@@ -0,0 +1,34 @@
+"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.BadRequestError = void 0;
+var _network = require("./network");
+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 BadRequestError = exports.BadRequestError = function (_NetworkError) {
+  function BadRequestError(message, response) {
+    var _this;
+    _classCallCheck(this, BadRequestError);
+    var trueProto = (this instanceof BadRequestError ? this.constructor : void 0).prototype;
+    _this = _callSuper(this, BadRequestError, [message, response]);
+    _this.__proto__ = trueProto;
+    _this.constructor = BadRequestError;
+    _this.name = "BadRequestError";
+    return _this;
+  }
+  _inherits(BadRequestError, _NetworkError);
+  return _createClass(BadRequestError);
+}(_network.NetworkError);

package/lib/errors/bad_response.d.ts

@@ -0,0 +1,17 @@
+import { NetworkError } from "./network";
+/**
+ * BadResponseError is raised when a response from a
+ * {@link module:Horizon | Horizon} or {@link module:Federation | Federation}
+ * server is invalid in some way. For example, a federation response may exceed
+ * the maximum allowed size, or a transaction submission may have failed with
+ * Horizon.
+ * @augments NetworkError
+ * @inheritdoc
+ * @category Errors
+ *
+ * @param {string} message Human-readable error message.
+ * @param {any} response Response details, received from the server.
+ */
+export declare class BadResponseError extends NetworkError {
+    constructor(message: string, response: any);
+}

package/lib/errors/bad_response.js

@@ -0,0 +1,34 @@
+"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.BadResponseError = void 0;
+var _network = require("./network");
+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 BadResponseError = exports.BadResponseError = function (_NetworkError) {
+  function BadResponseError(message, response) {
+    var _this;
+    _classCallCheck(this, BadResponseError);
+    var trueProto = (this instanceof BadResponseError ? this.constructor : void 0).prototype;
+    _this = _callSuper(this, BadResponseError, [message, response]);
+    _this.__proto__ = trueProto;
+    _this.constructor = BadResponseError;
+    _this.name = "BadResponseError";
+    return _this;
+  }
+  _inherits(BadResponseError, _NetworkError);
+  return _createClass(BadResponseError);
+}(_network.NetworkError);

package/lib/errors/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./network";
+export * from "./not_found";
+export * from "./bad_request";
+export * from "./bad_response";
+export * from "./account_requires_memo";

package/lib/errors/index.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _network = require("./network");
+Object.keys(_network).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _network[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _network[key];
+    }
+  });
+});
+var _not_found = require("./not_found");
+Object.keys(_not_found).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _not_found[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _not_found[key];
+    }
+  });
+});
+var _bad_request = require("./bad_request");
+Object.keys(_bad_request).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bad_request[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _bad_request[key];
+    }
+  });
+});
+var _bad_response = require("./bad_response");
+Object.keys(_bad_response).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _bad_response[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _bad_response[key];
+    }
+  });
+});
+var _account_requires_memo = require("./account_requires_memo");
+Object.keys(_account_requires_memo).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _account_requires_memo[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function get() {
+      return _account_requires_memo[key];
+    }
+  });
+});