@stellar/stellar-base 10.0.1 → 10.0.2

package/dist/stellar-base.js

@@ -13248,8 +13248,8 @@ function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" ==
 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 _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(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); }
 /* eslint no-bitwise: ["error", {"allow": ["<<", ">>", "^", "&", "&="]}] */
 
 
@@ -13644,8 +13644,8 @@ function keypair_typeof(o) { "@babel/helpers - typeof"; return keypair_typeof =
 function keypair_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function keypair_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, keypair_toPropertyKey(descriptor.key), descriptor); } }
 function keypair_createClass(Constructor, protoProps, staticProps) { if (protoProps) keypair_defineProperties(Constructor.prototype, protoProps); if (staticProps) keypair_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function keypair_toPropertyKey(arg) { var key = keypair_toPrimitive(arg, "string"); return keypair_typeof(key) === "symbol" ? key : String(key); }
-function keypair_toPrimitive(input, hint) { if (keypair_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (keypair_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function keypair_toPropertyKey(t) { var i = keypair_toPrimitive(t, "string"); return "symbol" == keypair_typeof(i) ? i : String(i); }
+function keypair_toPrimitive(t, r) { if ("object" != keypair_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != keypair_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /* eslint no-bitwise: ["error", {"allow": ["^"]}] */
 
 
@@ -13950,8 +13950,8 @@ function asset_typeof(o) { "@babel/helpers - typeof"; return asset_typeof = "fun
 function asset_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function asset_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, asset_toPropertyKey(descriptor.key), descriptor); } }
 function asset_createClass(Constructor, protoProps, staticProps) { if (protoProps) asset_defineProperties(Constructor.prototype, protoProps); if (staticProps) asset_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function asset_toPropertyKey(arg) { var key = asset_toPrimitive(arg, "string"); return asset_typeof(key) === "symbol" ? key : String(key); }
-function asset_toPrimitive(input, hint) { if (asset_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (asset_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function asset_toPropertyKey(t) { var i = asset_toPrimitive(t, "string"); return "symbol" == asset_typeof(i) ? i : String(i); }
+function asset_toPrimitive(t, r) { if ("object" != asset_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != asset_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -14322,8 +14322,8 @@ function transaction_base_typeof(o) { "@babel/helpers - typeof"; return transact
 function transaction_base_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function transaction_base_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, transaction_base_toPropertyKey(descriptor.key), descriptor); } }
 function transaction_base_createClass(Constructor, protoProps, staticProps) { if (protoProps) transaction_base_defineProperties(Constructor.prototype, protoProps); if (staticProps) transaction_base_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function transaction_base_toPropertyKey(arg) { var key = transaction_base_toPrimitive(arg, "string"); return transaction_base_typeof(key) === "symbol" ? key : String(key); }
-function transaction_base_toPrimitive(input, hint) { if (transaction_base_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (transaction_base_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function transaction_base_toPropertyKey(t) { var i = transaction_base_toPrimitive(t, "string"); return "symbol" == transaction_base_typeof(i) ? i : String(i); }
+function transaction_base_toPrimitive(t, r) { if ("object" != transaction_base_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != transaction_base_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -14621,8 +14621,8 @@ function _defineProperty(obj, key, value) { key = liquidity_pool_asset_toPropert
 function liquidity_pool_asset_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function liquidity_pool_asset_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, liquidity_pool_asset_toPropertyKey(descriptor.key), descriptor); } }
 function liquidity_pool_asset_createClass(Constructor, protoProps, staticProps) { if (protoProps) liquidity_pool_asset_defineProperties(Constructor.prototype, protoProps); if (staticProps) liquidity_pool_asset_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function liquidity_pool_asset_toPropertyKey(arg) { var key = liquidity_pool_asset_toPrimitive(arg, "string"); return liquidity_pool_asset_typeof(key) === "symbol" ? key : String(key); }
-function liquidity_pool_asset_toPrimitive(input, hint) { if (liquidity_pool_asset_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (liquidity_pool_asset_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function liquidity_pool_asset_toPropertyKey(t) { var i = liquidity_pool_asset_toPrimitive(t, "string"); return "symbol" == liquidity_pool_asset_typeof(i) ? i : String(i); }
+function liquidity_pool_asset_toPrimitive(t, r) { if ("object" != liquidity_pool_asset_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != liquidity_pool_asset_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -14739,8 +14739,8 @@ function claimant_typeof(o) { "@babel/helpers - typeof"; return claimant_typeof
 function claimant_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function claimant_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, claimant_toPropertyKey(descriptor.key), descriptor); } }
 function claimant_createClass(Constructor, protoProps, staticProps) { if (protoProps) claimant_defineProperties(Constructor.prototype, protoProps); if (staticProps) claimant_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function claimant_toPropertyKey(arg) { var key = claimant_toPrimitive(arg, "string"); return claimant_typeof(key) === "symbol" ? key : String(key); }
-function claimant_toPrimitive(input, hint) { if (claimant_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (claimant_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function claimant_toPropertyKey(t) { var i = claimant_toPrimitive(t, "string"); return "symbol" == claimant_typeof(i) ? i : String(i); }
+function claimant_toPrimitive(t, r) { if ("object" != claimant_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != claimant_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -14927,8 +14927,8 @@ function liquidity_pool_id_typeof(o) { "@babel/helpers - typeof"; return liquidi
 function liquidity_pool_id_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function liquidity_pool_id_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, liquidity_pool_id_toPropertyKey(descriptor.key), descriptor); } }
 function liquidity_pool_id_createClass(Constructor, protoProps, staticProps) { if (protoProps) liquidity_pool_id_defineProperties(Constructor.prototype, protoProps); if (staticProps) liquidity_pool_id_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function liquidity_pool_id_toPropertyKey(arg) { var key = liquidity_pool_id_toPrimitive(arg, "string"); return liquidity_pool_id_typeof(key) === "symbol" ? key : String(key); }
-function liquidity_pool_id_toPrimitive(input, hint) { if (liquidity_pool_id_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (liquidity_pool_id_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function liquidity_pool_id_toPropertyKey(t) { var i = liquidity_pool_id_toPrimitive(t, "string"); return "symbol" == liquidity_pool_id_typeof(i) ? i : String(i); }
+function liquidity_pool_id_toPrimitive(t, r) { if ("object" != liquidity_pool_id_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != liquidity_pool_id_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 /**
@@ -16499,8 +16499,8 @@ function address_typeof(o) { "@babel/helpers - typeof"; return address_typeof =
 function address_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function address_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, address_toPropertyKey(descriptor.key), descriptor); } }
 function address_createClass(Constructor, protoProps, staticProps) { if (protoProps) address_defineProperties(Constructor.prototype, protoProps); if (staticProps) address_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function address_toPropertyKey(arg) { var key = address_toPrimitive(arg, "string"); return address_typeof(key) === "symbol" ? key : String(key); }
-function address_toPrimitive(input, hint) { if (address_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (address_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function address_toPropertyKey(t) { var i = address_toPrimitive(t, "string"); return "symbol" == address_typeof(i) ? i : String(i); }
+function address_toPrimitive(t, r) { if ("object" != address_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != address_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -16873,9 +16873,9 @@ function getSalty() {
 
 
 /**
- * Builds an operation to bump the expiration of a footprint (read and written
- * ledger keys). Its only parameter is the number of ledgers to extend
- * expiration for.
+ * Builds an operation to bump the time-to-live of a footprint (read and written
+ * ledger keys). Its only parameter is the new, absolute ledger sequence number
+ * at which the entry will expire.
  *
  * The footprint itself is derived from the transaction (see
  * {@link TransactionBuilder}'s `opts.sorobanData` parameter, which is a
@@ -16886,12 +16886,11 @@ function getSalty() {
  * @alias Operation.extendFootprintTtl
  *
  * @param {object} opts - object holding operation parameters
- * @param {number} opts.extendTo - the number of ledgers past the LCL
- *    (last closed ledger) by which to extend the validity of the ledger keys in
- *    this transaction
+ * @param {number} opts.extendTo - the absolute ledger sequence number at which
+ *     the transaction's ledger keys will now expire
  * @param {string} [opts.source] - an optional source account
  *
- * @returns {xdr.Operation} a Bump Footprint Expiration operation
+ * @returns {xdr.Operation} an Extend Footprint TTL operation
  *    (xdr.ExtendFootprintTTLOp)
  */
 function extendFootprintTtl(opts) {
@@ -16975,8 +16974,8 @@ function operation_typeof(o) { "@babel/helpers - typeof"; return operation_typeo
 function operation_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function operation_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, operation_toPropertyKey(descriptor.key), descriptor); } }
 function operation_createClass(Constructor, protoProps, staticProps) { if (protoProps) operation_defineProperties(Constructor.prototype, protoProps); if (staticProps) operation_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function operation_toPropertyKey(arg) { var key = operation_toPrimitive(arg, "string"); return operation_typeof(key) === "symbol" ? key : String(key); }
-function operation_toPrimitive(input, hint) { if (operation_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (operation_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function operation_toPropertyKey(t) { var i = operation_toPrimitive(t, "string"); return "symbol" == operation_typeof(i) ? i : String(i); }
+function operation_toPrimitive(t, r) { if ("object" != operation_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != operation_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /* eslint-disable no-bitwise */
 
 
@@ -17685,8 +17684,8 @@ function memo_typeof(o) { "@babel/helpers - typeof"; return memo_typeof = "funct
 function memo_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function memo_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, memo_toPropertyKey(descriptor.key), descriptor); } }
 function memo_createClass(Constructor, protoProps, staticProps) { if (protoProps) memo_defineProperties(Constructor.prototype, protoProps); if (staticProps) memo_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function memo_toPropertyKey(arg) { var key = memo_toPrimitive(arg, "string"); return memo_typeof(key) === "symbol" ? key : String(key); }
-function memo_toPrimitive(input, hint) { if (memo_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (memo_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function memo_toPropertyKey(t) { var i = memo_toPrimitive(t, "string"); return "symbol" == memo_typeof(i) ? i : String(i); }
+function memo_toPrimitive(t, r) { if ("object" != memo_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != memo_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -17951,15 +17950,15 @@ function transaction_typeof(o) { "@babel/helpers - typeof"; return transaction_t
 function transaction_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function transaction_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, transaction_toPropertyKey(descriptor.key), descriptor); } }
 function transaction_createClass(Constructor, protoProps, staticProps) { if (protoProps) transaction_defineProperties(Constructor.prototype, protoProps); if (staticProps) transaction_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function transaction_toPropertyKey(arg) { var key = transaction_toPrimitive(arg, "string"); return transaction_typeof(key) === "symbol" ? key : String(key); }
-function transaction_toPrimitive(input, hint) { if (transaction_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (transaction_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 transaction_toPropertyKey(t) { var i = transaction_toPrimitive(t, "string"); return "symbol" == transaction_typeof(i) ? i : String(i); }
+function transaction_toPrimitive(t, r) { if ("object" != transaction_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != transaction_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(self, call) { if (call && (transaction_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 _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+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); }
 
 
 
@@ -17989,7 +17988,6 @@ function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.g
  */
 var Transaction = /*#__PURE__*/function (_TransactionBase) {
   _inherits(Transaction, _TransactionBase);
-  var _super = _createSuper(Transaction);
   function Transaction(envelope, networkPassphrase) {
     var _this;
     transaction_classCallCheck(this, Transaction);
@@ -18005,7 +18003,7 @@ var Transaction = /*#__PURE__*/function (_TransactionBase) {
     var tx = txEnvelope.tx();
     var fee = tx.fee().toString();
     var signatures = (txEnvelope.signatures() || []).slice();
-    _this = _super.call(this, tx, signatures, fee, networkPassphrase);
+    _this = _callSuper(this, Transaction, [tx, signatures, fee, networkPassphrase]);
     _this._envelopeType = envelopeType;
     _this._memo = tx.memo();
     _this._sequence = tx.seqNum().toString();
@@ -18316,15 +18314,15 @@ function fee_bump_transaction_typeof(o) { "@babel/helpers - typeof"; return fee_
 function fee_bump_transaction_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function fee_bump_transaction_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, fee_bump_transaction_toPropertyKey(descriptor.key), descriptor); } }
 function fee_bump_transaction_createClass(Constructor, protoProps, staticProps) { if (protoProps) fee_bump_transaction_defineProperties(Constructor.prototype, protoProps); if (staticProps) fee_bump_transaction_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function fee_bump_transaction_toPropertyKey(arg) { var key = fee_bump_transaction_toPrimitive(arg, "string"); return fee_bump_transaction_typeof(key) === "symbol" ? key : String(key); }
-function fee_bump_transaction_toPrimitive(input, hint) { if (fee_bump_transaction_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (fee_bump_transaction_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function fee_bump_transaction_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) fee_bump_transaction_setPrototypeOf(subClass, superClass); }
-function fee_bump_transaction_setPrototypeOf(o, p) { fee_bump_transaction_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return fee_bump_transaction_setPrototypeOf(o, p); }
-function fee_bump_transaction_createSuper(Derived) { var hasNativeReflectConstruct = fee_bump_transaction_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = fee_bump_transaction_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = fee_bump_transaction_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return fee_bump_transaction_possibleConstructorReturn(this, result); }; }
+function fee_bump_transaction_toPropertyKey(t) { var i = fee_bump_transaction_toPrimitive(t, "string"); return "symbol" == fee_bump_transaction_typeof(i) ? i : String(i); }
+function fee_bump_transaction_toPrimitive(t, r) { if ("object" != fee_bump_transaction_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != fee_bump_transaction_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function fee_bump_transaction_callSuper(t, o, e) { return o = fee_bump_transaction_getPrototypeOf(o), fee_bump_transaction_possibleConstructorReturn(t, fee_bump_transaction_isNativeReflectConstruct() ? Reflect.construct(o, e || [], fee_bump_transaction_getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function fee_bump_transaction_possibleConstructorReturn(self, call) { if (call && (fee_bump_transaction_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 fee_bump_transaction_assertThisInitialized(self); }
 function fee_bump_transaction_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function fee_bump_transaction_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 fee_bump_transaction_isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (fee_bump_transaction_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function fee_bump_transaction_getPrototypeOf(o) { fee_bump_transaction_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return fee_bump_transaction_getPrototypeOf(o); }
+function fee_bump_transaction_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) fee_bump_transaction_setPrototypeOf(subClass, superClass); }
+function fee_bump_transaction_setPrototypeOf(o, p) { fee_bump_transaction_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return fee_bump_transaction_setPrototypeOf(o, p); }
 
 
 
@@ -18349,7 +18347,6 @@ function fee_bump_transaction_getPrototypeOf(o) { fee_bump_transaction_getProtot
  */
 var FeeBumpTransaction = /*#__PURE__*/function (_TransactionBase) {
   fee_bump_transaction_inherits(FeeBumpTransaction, _TransactionBase);
-  var _super = fee_bump_transaction_createSuper(FeeBumpTransaction);
   function FeeBumpTransaction(envelope, networkPassphrase) {
     var _this;
     fee_bump_transaction_classCallCheck(this, FeeBumpTransaction);
@@ -18366,7 +18363,7 @@ var FeeBumpTransaction = /*#__PURE__*/function (_TransactionBase) {
     var fee = tx.fee().toString();
     // clone signatures
     var signatures = (txEnvelope.signatures() || []).slice();
-    _this = _super.call(this, tx, signatures, fee, networkPassphrase);
+    _this = fee_bump_transaction_callSuper(this, FeeBumpTransaction, [tx, signatures, fee, networkPassphrase]);
     var innerTxEnvelope = src_xdr.TransactionEnvelope.envelopeTypeTx(tx.innerTx().v1());
     _this._feeSource = encodeMuxedAccountToAddress(_this.tx.feeSource());
     _this._innerTransaction = new Transaction(innerTxEnvelope, networkPassphrase);
@@ -18445,8 +18442,8 @@ function account_typeof(o) { "@babel/helpers - typeof"; return account_typeof =
 function account_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function account_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, account_toPropertyKey(descriptor.key), descriptor); } }
 function account_createClass(Constructor, protoProps, staticProps) { if (protoProps) account_defineProperties(Constructor.prototype, protoProps); if (staticProps) account_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function account_toPropertyKey(arg) { var key = account_toPrimitive(arg, "string"); return account_typeof(key) === "symbol" ? key : String(key); }
-function account_toPrimitive(input, hint) { if (account_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (account_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function account_toPropertyKey(t) { var i = account_toPrimitive(t, "string"); return "symbol" == account_typeof(i) ? i : String(i); }
+function account_toPrimitive(t, r) { if ("object" != account_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != account_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -18520,8 +18517,8 @@ function muxed_account_typeof(o) { "@babel/helpers - typeof"; return muxed_accou
 function muxed_account_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function muxed_account_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, muxed_account_toPropertyKey(descriptor.key), descriptor); } }
 function muxed_account_createClass(Constructor, protoProps, staticProps) { if (protoProps) muxed_account_defineProperties(Constructor.prototype, protoProps); if (staticProps) muxed_account_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function muxed_account_toPropertyKey(arg) { var key = muxed_account_toPrimitive(arg, "string"); return muxed_account_typeof(key) === "symbol" ? key : String(key); }
-function muxed_account_toPrimitive(input, hint) { if (muxed_account_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (muxed_account_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function muxed_account_toPropertyKey(t) { var i = muxed_account_toPrimitive(t, "string"); return "symbol" == muxed_account_typeof(i) ? i : String(i); }
+function muxed_account_toPrimitive(t, r) { if ("object" != muxed_account_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != muxed_account_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -18675,8 +18672,8 @@ function sorobandata_builder_classCallCheck(instance, Constructor) { if (!(insta
 function sorobandata_builder_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, sorobandata_builder_toPropertyKey(descriptor.key), descriptor); } }
 function sorobandata_builder_createClass(Constructor, protoProps, staticProps) { if (protoProps) sorobandata_builder_defineProperties(Constructor.prototype, protoProps); if (staticProps) sorobandata_builder_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function sorobandata_builder_defineProperty(obj, key, value) { key = sorobandata_builder_toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function sorobandata_builder_toPropertyKey(arg) { var key = sorobandata_builder_toPrimitive(arg, "string"); return sorobandata_builder_typeof(key) === "symbol" ? key : String(key); }
-function sorobandata_builder_toPrimitive(input, hint) { if (sorobandata_builder_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (sorobandata_builder_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function sorobandata_builder_toPropertyKey(t) { var i = sorobandata_builder_toPrimitive(t, "string"); return "symbol" == sorobandata_builder_typeof(i) ? i : String(i); }
+function sorobandata_builder_toPrimitive(t, r) { if ("object" != sorobandata_builder_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != sorobandata_builder_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 /**
@@ -18887,8 +18884,8 @@ function signerkey_typeof(o) { "@babel/helpers - typeof"; return signerkey_typeo
 function signerkey_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function signerkey_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, signerkey_toPropertyKey(descriptor.key), descriptor); } }
 function signerkey_createClass(Constructor, protoProps, staticProps) { if (protoProps) signerkey_defineProperties(Constructor.prototype, protoProps); if (staticProps) signerkey_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function signerkey_toPropertyKey(arg) { var key = signerkey_toPrimitive(arg, "string"); return signerkey_typeof(key) === "symbol" ? key : String(key); }
-function signerkey_toPrimitive(input, hint) { if (signerkey_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (signerkey_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function signerkey_toPropertyKey(t) { var i = signerkey_toPrimitive(t, "string"); return "symbol" == signerkey_typeof(i) ? i : String(i); }
+function signerkey_toPrimitive(t, r) { if ("object" != signerkey_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != signerkey_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -18994,8 +18991,8 @@ function transaction_builder_defineProperty(obj, key, value) { key = transaction
 function transaction_builder_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function transaction_builder_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, transaction_builder_toPropertyKey(descriptor.key), descriptor); } }
 function transaction_builder_createClass(Constructor, protoProps, staticProps) { if (protoProps) transaction_builder_defineProperties(Constructor.prototype, protoProps); if (staticProps) transaction_builder_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function transaction_builder_toPropertyKey(arg) { var key = transaction_builder_toPrimitive(arg, "string"); return transaction_builder_typeof(key) === "symbol" ? key : String(key); }
-function transaction_builder_toPrimitive(input, hint) { if (transaction_builder_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (transaction_builder_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function transaction_builder_toPropertyKey(t) { var i = transaction_builder_toPrimitive(t, "string"); return "symbol" == transaction_builder_typeof(i) ? i : String(i); }
+function transaction_builder_toPrimitive(t, r) { if ("object" != transaction_builder_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != transaction_builder_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -19045,7 +19042,7 @@ var TimeoutInfinite = 0;
  * source account.</p>
  *
  * <p><strong>Be careful about unsubmitted transactions!</strong> When you build
- * a transaction, stellar-sdk automatically increments the source account's
+ * a transaction, `stellar-sdk` automatically increments the source account's
  * sequence number. If you end up not submitting this transaction and submitting
  * another one instead, it'll fail due to the sequence number being wrong. So if
  * you decide not to use a built transaction, make sure to update the source
@@ -19756,8 +19753,8 @@ function soroban_arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
 function soroban_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function soroban_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, soroban_toPropertyKey(descriptor.key), descriptor); } }
 function soroban_createClass(Constructor, protoProps, staticProps) { if (protoProps) soroban_defineProperties(Constructor.prototype, protoProps); if (staticProps) soroban_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function soroban_toPropertyKey(arg) { var key = soroban_toPrimitive(arg, "string"); return soroban_typeof(key) === "symbol" ? key : String(key); }
-function soroban_toPrimitive(input, hint) { if (soroban_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (soroban_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function soroban_toPropertyKey(t) { var i = soroban_toPrimitive(t, "string"); return "symbol" == soroban_typeof(i) ? i : String(i); }
+function soroban_toPrimitive(t, r) { if ("object" != soroban_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != soroban_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /* Helper class to assist with formatting and parsing token amounts. */
 var Soroban = /*#__PURE__*/function () {
   function Soroban() {
@@ -19841,8 +19838,8 @@ function contract_typeof(o) { "@babel/helpers - typeof"; return contract_typeof
 function contract_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function contract_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, contract_toPropertyKey(descriptor.key), descriptor); } }
 function contract_createClass(Constructor, protoProps, staticProps) { if (protoProps) contract_defineProperties(Constructor.prototype, protoProps); if (staticProps) contract_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function contract_toPropertyKey(arg) { var key = contract_toPrimitive(arg, "string"); return contract_typeof(key) === "symbol" ? key : String(key); }
-function contract_toPrimitive(input, hint) { if (contract_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (contract_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function contract_toPropertyKey(t) { var i = contract_toPrimitive(t, "string"); return "symbol" == contract_typeof(i) ? i : String(i); }
+function contract_toPrimitive(t, r) { if ("object" != contract_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != contract_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -19949,19 +19946,18 @@ function uint128_typeof(o) { "@babel/helpers - typeof"; return uint128_typeof =
 function uint128_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function uint128_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, uint128_toPropertyKey(descriptor.key), descriptor); } }
 function uint128_createClass(Constructor, protoProps, staticProps) { if (protoProps) uint128_defineProperties(Constructor.prototype, protoProps); if (staticProps) uint128_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function uint128_toPropertyKey(arg) { var key = uint128_toPrimitive(arg, "string"); return uint128_typeof(key) === "symbol" ? key : String(key); }
-function uint128_toPrimitive(input, hint) { if (uint128_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (uint128_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function uint128_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) uint128_setPrototypeOf(subClass, superClass); }
-function uint128_setPrototypeOf(o, p) { uint128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return uint128_setPrototypeOf(o, p); }
-function uint128_createSuper(Derived) { var hasNativeReflectConstruct = uint128_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = uint128_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = uint128_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return uint128_possibleConstructorReturn(this, result); }; }
+function uint128_toPropertyKey(t) { var i = uint128_toPrimitive(t, "string"); return "symbol" == uint128_typeof(i) ? i : String(i); }
+function uint128_toPrimitive(t, r) { if ("object" != uint128_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != uint128_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function uint128_callSuper(t, o, e) { return o = uint128_getPrototypeOf(o), uint128_possibleConstructorReturn(t, uint128_isNativeReflectConstruct() ? Reflect.construct(o, e || [], uint128_getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function uint128_possibleConstructorReturn(self, call) { if (call && (uint128_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 uint128_assertThisInitialized(self); }
 function uint128_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function uint128_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 uint128_isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (uint128_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function uint128_getPrototypeOf(o) { uint128_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return uint128_getPrototypeOf(o); }
+function uint128_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) uint128_setPrototypeOf(subClass, superClass); }
+function uint128_setPrototypeOf(o, p) { uint128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return uint128_setPrototypeOf(o, p); }
 
 var Uint128 = /*#__PURE__*/function (_LargeInt) {
   uint128_inherits(Uint128, _LargeInt);
-  var _super = uint128_createSuper(Uint128);
   /**
    * Construct an unsigned 128-bit integer that can be XDR-encoded.
    *
@@ -19973,7 +19969,7 @@ var Uint128 = /*#__PURE__*/function (_LargeInt) {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return _super.call(this, args);
+    return uint128_callSuper(this, Uint128, [args]);
   }
   uint128_createClass(Uint128, [{
     key: "unsigned",
@@ -19994,19 +19990,18 @@ function uint256_typeof(o) { "@babel/helpers - typeof"; return uint256_typeof =
 function uint256_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function uint256_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, uint256_toPropertyKey(descriptor.key), descriptor); } }
 function uint256_createClass(Constructor, protoProps, staticProps) { if (protoProps) uint256_defineProperties(Constructor.prototype, protoProps); if (staticProps) uint256_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function uint256_toPropertyKey(arg) { var key = uint256_toPrimitive(arg, "string"); return uint256_typeof(key) === "symbol" ? key : String(key); }
-function uint256_toPrimitive(input, hint) { if (uint256_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (uint256_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function uint256_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) uint256_setPrototypeOf(subClass, superClass); }
-function uint256_setPrototypeOf(o, p) { uint256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return uint256_setPrototypeOf(o, p); }
-function uint256_createSuper(Derived) { var hasNativeReflectConstruct = uint256_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = uint256_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = uint256_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return uint256_possibleConstructorReturn(this, result); }; }
+function uint256_toPropertyKey(t) { var i = uint256_toPrimitive(t, "string"); return "symbol" == uint256_typeof(i) ? i : String(i); }
+function uint256_toPrimitive(t, r) { if ("object" != uint256_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != uint256_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function uint256_callSuper(t, o, e) { return o = uint256_getPrototypeOf(o), uint256_possibleConstructorReturn(t, uint256_isNativeReflectConstruct() ? Reflect.construct(o, e || [], uint256_getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function uint256_possibleConstructorReturn(self, call) { if (call && (uint256_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 uint256_assertThisInitialized(self); }
 function uint256_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function uint256_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 uint256_isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (uint256_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function uint256_getPrototypeOf(o) { uint256_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return uint256_getPrototypeOf(o); }
+function uint256_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) uint256_setPrototypeOf(subClass, superClass); }
+function uint256_setPrototypeOf(o, p) { uint256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return uint256_setPrototypeOf(o, p); }
 
 var Uint256 = /*#__PURE__*/function (_LargeInt) {
   uint256_inherits(Uint256, _LargeInt);
-  var _super = uint256_createSuper(Uint256);
   /**
    * Construct an unsigned 256-bit integer that can be XDR-encoded.
    *
@@ -20018,7 +20013,7 @@ var Uint256 = /*#__PURE__*/function (_LargeInt) {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return _super.call(this, args);
+    return uint256_callSuper(this, Uint256, [args]);
   }
   uint256_createClass(Uint256, [{
     key: "unsigned",
@@ -20039,19 +20034,18 @@ function int128_typeof(o) { "@babel/helpers - typeof"; return int128_typeof = "f
 function int128_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function int128_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, int128_toPropertyKey(descriptor.key), descriptor); } }
 function int128_createClass(Constructor, protoProps, staticProps) { if (protoProps) int128_defineProperties(Constructor.prototype, protoProps); if (staticProps) int128_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function int128_toPropertyKey(arg) { var key = int128_toPrimitive(arg, "string"); return int128_typeof(key) === "symbol" ? key : String(key); }
-function int128_toPrimitive(input, hint) { if (int128_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (int128_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function int128_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) int128_setPrototypeOf(subClass, superClass); }
-function int128_setPrototypeOf(o, p) { int128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return int128_setPrototypeOf(o, p); }
-function int128_createSuper(Derived) { var hasNativeReflectConstruct = int128_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = int128_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = int128_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return int128_possibleConstructorReturn(this, result); }; }
+function int128_toPropertyKey(t) { var i = int128_toPrimitive(t, "string"); return "symbol" == int128_typeof(i) ? i : String(i); }
+function int128_toPrimitive(t, r) { if ("object" != int128_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != int128_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function int128_callSuper(t, o, e) { return o = int128_getPrototypeOf(o), int128_possibleConstructorReturn(t, int128_isNativeReflectConstruct() ? Reflect.construct(o, e || [], int128_getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function int128_possibleConstructorReturn(self, call) { if (call && (int128_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 int128_assertThisInitialized(self); }
 function int128_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function int128_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 int128_isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (int128_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function int128_getPrototypeOf(o) { int128_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return int128_getPrototypeOf(o); }
+function int128_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) int128_setPrototypeOf(subClass, superClass); }
+function int128_setPrototypeOf(o, p) { int128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return int128_setPrototypeOf(o, p); }
 
 var Int128 = /*#__PURE__*/function (_LargeInt) {
   int128_inherits(Int128, _LargeInt);
-  var _super = int128_createSuper(Int128);
   /**
    * Construct a signed 128-bit integer that can be XDR-encoded.
    *
@@ -20063,7 +20057,7 @@ var Int128 = /*#__PURE__*/function (_LargeInt) {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return _super.call(this, args);
+    return int128_callSuper(this, Int128, [args]);
   }
   int128_createClass(Int128, [{
     key: "unsigned",
@@ -20084,19 +20078,18 @@ function int256_typeof(o) { "@babel/helpers - typeof"; return int256_typeof = "f
 function int256_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 function int256_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, int256_toPropertyKey(descriptor.key), descriptor); } }
 function int256_createClass(Constructor, protoProps, staticProps) { if (protoProps) int256_defineProperties(Constructor.prototype, protoProps); if (staticProps) int256_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function int256_toPropertyKey(arg) { var key = int256_toPrimitive(arg, "string"); return int256_typeof(key) === "symbol" ? key : String(key); }
-function int256_toPrimitive(input, hint) { if (int256_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (int256_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
-function int256_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) int256_setPrototypeOf(subClass, superClass); }
-function int256_setPrototypeOf(o, p) { int256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return int256_setPrototypeOf(o, p); }
-function int256_createSuper(Derived) { var hasNativeReflectConstruct = int256_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = int256_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = int256_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return int256_possibleConstructorReturn(this, result); }; }
+function int256_toPropertyKey(t) { var i = int256_toPrimitive(t, "string"); return "symbol" == int256_typeof(i) ? i : String(i); }
+function int256_toPrimitive(t, r) { if ("object" != int256_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != int256_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function int256_callSuper(t, o, e) { return o = int256_getPrototypeOf(o), int256_possibleConstructorReturn(t, int256_isNativeReflectConstruct() ? Reflect.construct(o, e || [], int256_getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function int256_possibleConstructorReturn(self, call) { if (call && (int256_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 int256_assertThisInitialized(self); }
 function int256_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function int256_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 int256_isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (int256_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function int256_getPrototypeOf(o) { int256_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return int256_getPrototypeOf(o); }
+function int256_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) int256_setPrototypeOf(subClass, superClass); }
+function int256_setPrototypeOf(o, p) { int256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return int256_setPrototypeOf(o, p); }
 
 var Int256 = /*#__PURE__*/function (_LargeInt) {
   int256_inherits(Int256, _LargeInt);
-  var _super = int256_createSuper(Int256);
   /**
    * Construct a signed 256-bit integer that can be XDR-encoded.
    *
@@ -20108,7 +20101,7 @@ var Int256 = /*#__PURE__*/function (_LargeInt) {
     for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
       args[_key] = arguments[_key];
     }
-    return _super.call(this, args);
+    return int256_callSuper(this, Int256, [args]);
   }
   int256_createClass(Int256, [{
     key: "unsigned",
@@ -20130,8 +20123,8 @@ function xdr_large_int_classCallCheck(instance, Constructor) { if (!(instance in
 function xdr_large_int_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, xdr_large_int_toPropertyKey(descriptor.key), descriptor); } }
 function xdr_large_int_createClass(Constructor, protoProps, staticProps) { if (protoProps) xdr_large_int_defineProperties(Constructor.prototype, protoProps); if (staticProps) xdr_large_int_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 function xdr_large_int_defineProperty(obj, key, value) { key = xdr_large_int_toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
-function xdr_large_int_toPropertyKey(arg) { var key = xdr_large_int_toPrimitive(arg, "string"); return xdr_large_int_typeof(key) === "symbol" ? key : String(key); }
-function xdr_large_int_toPrimitive(input, hint) { if (xdr_large_int_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (xdr_large_int_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function xdr_large_int_toPropertyKey(t) { var i = xdr_large_int_toPrimitive(t, "string"); return "symbol" == xdr_large_int_typeof(i) ? i : String(i); }
+function xdr_large_int_toPrimitive(t, r) { if ("object" != xdr_large_int_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != xdr_large_int_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 /* eslint no-bitwise: ["error", {"allow": [">>"]}] */
 
 
@@ -20391,23 +20384,23 @@ var XdrLargeInt = /*#__PURE__*/function () {
 function sc_int_typeof(o) { "@babel/helpers - typeof"; return sc_int_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; }, sc_int_typeof(o); }
 function sc_int_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, sc_int_toPropertyKey(descriptor.key), descriptor); } }
 function sc_int_createClass(Constructor, protoProps, staticProps) { if (protoProps) sc_int_defineProperties(Constructor.prototype, protoProps); if (staticProps) sc_int_defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
-function sc_int_toPropertyKey(arg) { var key = sc_int_toPrimitive(arg, "string"); return sc_int_typeof(key) === "symbol" ? key : String(key); }
-function sc_int_toPrimitive(input, hint) { if (sc_int_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (sc_int_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function sc_int_toPropertyKey(t) { var i = sc_int_toPrimitive(t, "string"); return "symbol" == sc_int_typeof(i) ? i : String(i); }
+function sc_int_toPrimitive(t, r) { if ("object" != sc_int_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != sc_int_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 function sc_int_classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-function sc_int_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) sc_int_setPrototypeOf(subClass, superClass); }
-function sc_int_setPrototypeOf(o, p) { sc_int_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return sc_int_setPrototypeOf(o, p); }
-function sc_int_createSuper(Derived) { var hasNativeReflectConstruct = sc_int_isNativeReflectConstruct(); return function _createSuperInternal() { var Super = sc_int_getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = sc_int_getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return sc_int_possibleConstructorReturn(this, result); }; }
+function sc_int_callSuper(t, o, e) { return o = sc_int_getPrototypeOf(o), sc_int_possibleConstructorReturn(t, sc_int_isNativeReflectConstruct() ? Reflect.construct(o, e || [], sc_int_getPrototypeOf(t).constructor) : o.apply(t, e)); }
 function sc_int_possibleConstructorReturn(self, call) { if (call && (sc_int_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 sc_int_assertThisInitialized(self); }
 function sc_int_assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-function sc_int_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 sc_int_isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (sc_int_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
 function sc_int_getPrototypeOf(o) { sc_int_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return sc_int_getPrototypeOf(o); }
+function sc_int_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) sc_int_setPrototypeOf(subClass, superClass); }
+function sc_int_setPrototypeOf(o, p) { sc_int_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return sc_int_setPrototypeOf(o, p); }
 
 
 /**
  * Provides an easier way to manipulate large numbers for Stellar operations.
  *
- * You can instantiate this value either from bigints, strings, or numbers
- * (whole numbers, or this will throw).
+ * You can instantiate this "**s**mart **c**ontract integer" value either from
+ * bigints, strings, or numbers (whole numbers, or this will throw).
  *
  * If you need to create a native BigInt from a list of integer "parts" (for
  * example, you have a series of encoded 32-bit integers that represent a larger
@@ -20415,11 +20408,11 @@ function sc_int_getPrototypeOf(o) { sc_int_getPrototypeOf = Object.setPrototypeO
  * example, you could do `new XdrLargeInt('u128', bytes...).toBigInt()`.
  *
  * @example
- * import { xdr, ScInt } from "@stellar/stellar-base";
+ * import { xdr, ScInt, scValToBigInt } from "@stellar/stellar-base";
  *
  * // You have an ScVal from a contract and want to parse it into JS native.
  * const value = xdr.ScVal.fromXDR(someXdr, "base64");
- * const bigi = ScInt.fromScVal(value); // grab it as a BigInt
+ * const bigi = scValToBigInt(value); // grab it as a BigInt
  * let sci = new ScInt(bigi);
  *
  * sci.toNumber(); // gives native JS type (w/ size check)
@@ -20442,7 +20435,7 @@ function sc_int_getPrototypeOf(o) { sc_int_getPrototypeOf = Object.setPrototypeO
  * ScInt(123456789123456789n);
  * ScInt(1n << 140n);
  * ScInt(-42);
- * ScInt.fromScVal(scValU128); // from above
+ * ScInt(scValToBigInt(scValU128)); // from above
  *
  * // If you know the type ahead of time (accessing `.raw` is faster than
  * // conversions), you can specify the type directly (otherwise, it's
@@ -20470,15 +20463,12 @@ function sc_int_getPrototypeOf(o) { sc_int_getPrototypeOf = Object.setPrototypeO
  *
  * @throws {RangeError} if the `value` is invalid (e.g. floating point), too
  *    large (i.e. exceeds a 256-bit value), or doesn't fit in the `opts.type`
- *
  * @throws {TypeError} on missing parameters, or if the "signedness" of `opts`
  *    doesn't match input `value`, e.g. passing `{type: 'u64'}` yet passing -1n
- *
  * @throws {SyntaxError} if a string `value` can't be parsed as a big integer
  */
 var ScInt = /*#__PURE__*/function (_XdrLargeInt) {
   sc_int_inherits(ScInt, _XdrLargeInt);
-  var _super = sc_int_createSuper(ScInt);
   function ScInt(value, opts) {
     var _opts$type;
     sc_int_classCallCheck(this, ScInt);
@@ -20503,7 +20493,7 @@ var ScInt = /*#__PURE__*/function (_XdrLargeInt) {
           throw RangeError("expected 64/128/256 bits for input (".concat(value, "), got ").concat(bitlen));
       }
     }
-    return _super.call(this, type, value);
+    return sc_int_callSuper(this, ScInt, [type, value]);
   }
   return sc_int_createClass(ScInt);
 }(XdrLargeInt);
@@ -20674,7 +20664,12 @@ function scval_typeof(o) { "@babel/helpers - typeof"; return scval_typeof = "fun
  * // ]
  *
  * @example
- * import { nativeToScVal, scValToNative, ScInt, xdr } from 'stellar-base';
+ * import {
+ *   nativeToScVal,
+ *   scValToNative,
+ *   ScInt,
+ *   xdr
+ * } from '@stellar/stellar-base';
  *
  * let gigaMap = {
  *   bool: true,
@@ -20928,6 +20923,12 @@ function scValToNative(scv) {
   }
 }
 ;// CONCATENATED MODULE: ./src/events.js
+function events_typeof(o) { "@babel/helpers - typeof"; return events_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; }, events_typeof(o); }
+function events_ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function events_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? events_ownKeys(Object(t), !0).forEach(function (r) { events_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : events_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function events_defineProperty(obj, key, value) { key = events_toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function events_toPropertyKey(t) { var i = events_toPrimitive(t, "string"); return "symbol" == events_typeof(i) ? i : String(i); }
+function events_toPrimitive(t, r) { if ("object" != events_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != events_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
 
 
 
@@ -20955,14 +20956,15 @@ function humanizeEvents(events) {
   });
 }
 function extractEvent(event) {
-  return {
-    contractId: event.contractId() === null ? '' : StrKey.encodeContract(event.contractId()),
+  return events_objectSpread(events_objectSpread({}, event.contractId() != null && {
+    contractId: StrKey.encodeContract(event.contractId())
+  }), {}, {
     type: event.type().name,
     topics: event.body().value().topics().map(function (t) {
       return scValToNative(t);
     }),
     data: scValToNative(event.body().value().data())
-  };
+  });
 }
 ;// CONCATENATED MODULE: ./src/auth.js
 /* provided dependency */ var auth_Buffer = __webpack_require__(8764)["Buffer"];
@@ -21029,7 +21031,12 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
  *
  * @see authorizeInvocation
  * @example
- * import { Server, Transaction, Networks, authorizeEntry } from 'soroban-client';
+ * import {
+ *   SorobanRpc,
+ *   Transaction,
+ *   Networks,
+ *   authorizeEntry
+ * } from '@stellar/stellar-sdk';
  *
  * // Assume signPayloadCallback is a well-formed signing callback.
  * //
@@ -21041,7 +21048,7 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
  * }
  *
  * function multiPartyAuth(
- *    server: Server,
+ *    server: SorobanRpc.Server,
  *    // assume this involves multi-party auth
  *    tx: Transaction,
  * ) {
@@ -21053,10 +21060,10 @@ function _asyncToGenerator(fn) { return function () { var self = this, args = ar
  *              entry,
  *              signPayloadCallback,
  *              currentLedger + 1000,
- *              Networks.FUTURENET);
+ *              Networks.TESTNET);
  *          ));
  *
- *          return server.prepareTransaction(tx, Networks.FUTURENET, simResult);
+ *          return server.prepareTransaction(tx, simResult);
  *      })
  *      .then((preppedTx) => {
  *        preppedTx.sign(source);
@@ -21275,7 +21282,7 @@ function bytesToInt64(bytes) {
  * `tx`, which we assume has an `Operation.invokeHostFunction` inside of it:
  *
  * ```typescript
- * import { Server, buildInvocationTree } from 'soroban-client';
+ * import { Server, buildInvocationTree } from '@stellar/stellar-sdk';
  *
  * const s = new Server("fill in accordingly");
  *
@@ -26165,6 +26172,9 @@ var gOPD = __webpack_require__(7296);
 var $TypeError = GetIntrinsic('%TypeError%');
 var $floor = GetIntrinsic('%Math.floor%');
 
+/** @typedef {(...args: unknown[]) => unknown} Func */
+
+/** @type {<T extends Func = Func>(fn: T, length: number, loose?: boolean) => T} */
 module.exports = function setFunctionLength(fn, length) {
 	if (typeof fn !== 'function') {
 		throw new $TypeError('`fn` is not a function');
@@ -26189,9 +26199,9 @@ module.exports = function setFunctionLength(fn, length) {
 
 	if (functionLengthIsConfigurable || functionLengthIsWritable || !loose) {
 		if (hasDescriptors) {
-			define(fn, 'length', length, true, true);
+			define(/** @type {Parameters<define>[0]} */ (fn), 'length', length, true, true);
 		} else {
-			define(fn, 'length', length);
+			define(/** @type {Parameters<define>[0]} */ (fn), 'length', length);
 		}
 	}
 	return fn;