@stellar/stellar-base 14.0.4 → 14.1.0

package/dist/stellar-base.js

@@ -22002,1197 +22002,762 @@ var SignerKey = /*#__PURE__*/function () {
     }
   }]);
 }();
-;// ./src/transaction_builder.js
-function transaction_builder_typeof(o) { "@babel/helpers - typeof"; return transaction_builder_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; }, transaction_builder_typeof(o); }
-function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || transaction_builder_unsupportedIterableToArray(r) || _nonIterableSpread(); }
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function transaction_builder_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return transaction_builder_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? transaction_builder_arrayLikeToArray(r, a) : void 0; } }
-function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function _arrayWithoutHoles(r) { if (Array.isArray(r)) return transaction_builder_arrayLikeToArray(r); }
-function transaction_builder_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function transaction_builder_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 transaction_builder_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? transaction_builder_ownKeys(Object(t), !0).forEach(function (r) { transaction_builder_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : transaction_builder_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function transaction_builder_defineProperty(e, r, t) { return (r = transaction_builder_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function transaction_builder_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function transaction_builder_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, transaction_builder_toPropertyKey(o.key), o); } }
-function transaction_builder_createClass(e, r, t) { return r && transaction_builder_defineProperties(e.prototype, r), t && transaction_builder_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function transaction_builder_toPropertyKey(t) { var i = transaction_builder_toPrimitive(t, "string"); return "symbol" == transaction_builder_typeof(i) ? i : 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); }
-
-
-
-
-
-
-
-
-
-
+;// ./src/contract.js
+function contract_typeof(o) { "@babel/helpers - typeof"; return contract_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; }, contract_typeof(o); }
+function contract_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function contract_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, contract_toPropertyKey(o.key), o); } }
+function contract_createClass(e, r, t) { return r && contract_defineProperties(e.prototype, r), t && contract_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function contract_toPropertyKey(t) { var i = contract_toPrimitive(t, "string"); return "symbol" == contract_typeof(i) ? i : 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); }
 
 
 
-/**
- * Minimum base fee for transactions. If this fee is below the network
- * minimum, the transaction will fail. The more operations in the
- * transaction, the greater the required fee. Use {@link
- * Server#fetchBaseFee} to get an accurate value of minimum transaction
- * fee on the network.
- *
- * @constant
- * @see [Fees](https://developers.stellar.org/docs/glossary/fees/)
- */
-var BASE_FEE = '100'; // Stroops
 
-/**
- * @constant
- * @see {@link TransactionBuilder#setTimeout}
- * @see [Timeout](https://developers.stellar.org/api/resources/transactions/post/)
- */
-var TimeoutInfinite = 0;
 
 /**
- * <p>Transaction builder helps constructs a new `{@link Transaction}` using the
- * given {@link Account} as the transaction's "source account". The transaction
- * will use the current sequence number of the given account as its sequence
- * number and increment the given account's sequence number by one. The given
- * source account must include a private key for signing the transaction or an
- * error will be thrown.</p>
- *
- * <p>Operations can be added to the transaction via their corresponding builder
- * methods, and each returns the TransactionBuilder object so they can be
- * chained together. After adding the desired operations, call the `build()`
- * method on the `TransactionBuilder` to return a fully constructed `{@link
- * Transaction}` that can be signed. The returned transaction will contain the
- * sequence number of the source account and include the signature from the
- * source account.</p>
- *
- * <p><strong>Be careful about unsubmitted transactions!</strong> When you build
- * 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
- * account's sequence number with
- * [Server.loadAccount](https://stellar.github.io/js-stellar-sdk/Server.html#loadAccount)
- * before creating another transaction.</p>
- *
- * <p>The following code example creates a new transaction with {@link
- * Operation.createAccount} and {@link Operation.payment} operations. The
- * Transaction's source account first funds `destinationA`, then sends a payment
- * to `destinationB`. The built transaction is then signed by
- * `sourceKeypair`.</p>
- *
- * ```
- * var transaction = new TransactionBuilder(source, { fee, networkPassphrase: Networks.TESTNET })
- * .addOperation(Operation.createAccount({
- *     destination: destinationA,
- *     startingBalance: "20"
- * })) // <- funds and creates destinationA
- * .addOperation(Operation.payment({
- *     destination: destinationB,
- *     amount: "100",
- *     asset: Asset.native()
- * })) // <- sends 100 XLM to destinationB
- * .setTimeout(30)
- * .build();
+ * Create a new Contract object.
  *
- * transaction.sign(sourceKeypair);
- * ```
+ * `Contract` represents a single contract in the Stellar network, embodying the
+ * interface of the contract. See
+ * [Contracts](https://soroban.stellar.org/docs/learn/interacting-with-contracts)
+ * for more information about how contracts work in Stellar.
  *
  * @constructor
  *
- * @param {Account} sourceAccount - source account for this transaction
- * @param {object}  opts          - Options object
- * @param {string}  opts.fee      - max fee you're willing to pay per
- *     operation in this transaction (**in stroops**)
- *
- * @param {object}              [opts.timebounds] - timebounds for the
- *     validity of this transaction
- * @param {number|string|Date}  [opts.timebounds.minTime] - 64-bit UNIX
- *     timestamp or Date object
- * @param {number|string|Date}  [opts.timebounds.maxTime] - 64-bit UNIX
- *     timestamp or Date object
- * @param {object}              [opts.ledgerbounds] - ledger bounds for the
- *     validity of this transaction
- * @param {number}              [opts.ledgerbounds.minLedger] - number of the minimum
- *     ledger sequence
- * @param {number}              [opts.ledgerbounds.maxLedger] - number of the maximum
- *     ledger sequence
- * @param {string}              [opts.minAccountSequence] - number for
- *     the minimum account sequence
- * @param {number}              [opts.minAccountSequenceAge] - number of
- *     seconds for the minimum account sequence age
- * @param {number}              [opts.minAccountSequenceLedgerGap] - number of
- *     ledgers for the minimum account sequence ledger gap
- * @param {string[]}            [opts.extraSigners] - list of the extra signers
- *     required for this transaction
- * @param {Memo}                [opts.memo] - memo for the transaction
- * @param {string}              [opts.networkPassphrase] passphrase of the
- *     target Stellar network (e.g. "Public Global Stellar Network ; September
- *     2015" for the pubnet)
- * @param {xdr.SorobanTransactionData | string}  [opts.sorobanData] - an
- *     optional instance of {@link xdr.SorobanTransactionData} to be set as the
- *     internal `Transaction.Ext.SorobanData` field (either the xdr object or a
- *     base64 string). In the case of Soroban transactions, this can be obtained
- *     from a prior simulation of the transaction with a contract invocation and
- *     provides necessary resource estimations. You can also use
- *     {@link SorobanDataBuilder} to construct complicated combinations of
- *     parameters without mucking with XDR directly. **Note:** For
- *     non-contract(non-Soroban) transactions, this has no effect.
+ * @param {string} contractId - ID of the contract (ex.
+ *     `CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE`).
  */
-var TransactionBuilder = /*#__PURE__*/function () {
-  function TransactionBuilder(sourceAccount) {
-    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    transaction_builder_classCallCheck(this, TransactionBuilder);
-    if (!sourceAccount) {
-      throw new Error('must specify source account for the transaction');
-    }
-    if (opts.fee === undefined) {
-      throw new Error('must specify fee for the transaction (in stroops)');
+var Contract = /*#__PURE__*/function () {
+  function Contract(contractId) {
+    contract_classCallCheck(this, Contract);
+    try {
+      // First, try it as a strkey
+      this._id = StrKey.decodeContract(contractId);
+    } catch (_) {
+      throw new Error("Invalid contract ID: ".concat(contractId));
     }
-    this.source = sourceAccount;
-    this.operations = [];
-    this.baseFee = opts.fee;
-    this.timebounds = opts.timebounds ? transaction_builder_objectSpread({}, opts.timebounds) : null;
-    this.ledgerbounds = opts.ledgerbounds ? transaction_builder_objectSpread({}, opts.ledgerbounds) : null;
-    this.minAccountSequence = opts.minAccountSequence || null;
-    this.minAccountSequenceAge = opts.minAccountSequenceAge || null;
-    this.minAccountSequenceLedgerGap = opts.minAccountSequenceLedgerGap || null;
-    this.extraSigners = opts.extraSigners ? _toConsumableArray(opts.extraSigners) : null;
-    this.memo = opts.memo || Memo.none();
-    this.networkPassphrase = opts.networkPassphrase || null;
-    this.sorobanData = opts.sorobanData ? new SorobanDataBuilder(opts.sorobanData).build() : null;
   }
 
   /**
-   * Creates a builder instance using an existing {@link Transaction} as a
-   * template, ignoring any existing envelope signatures.
-   *
-   * Note that the sequence number WILL be cloned, so EITHER this transaction or
-   * the one it was cloned from will be valid. This is useful in situations
-   * where you are constructing a transaction in pieces and need to make
-   * adjustments as you go (for example, when filling out Soroban resource
-   * information).
-   *
-   * @param {Transaction} tx  a "template" transaction to clone exactly
-   * @param {object} [opts]   additional options to override the clone, e.g.
-   *    {fee: '1000'} will override the existing base fee derived from `tx` (see
-   *    the {@link TransactionBuilder} constructor for detailed options)
-   *
-   * @returns {TransactionBuilder} a "prepared" builder instance with the same
-   *    configuration and operations as the given transaction
-   *
-   * @warning This does not clone the transaction's
-   *    {@link xdr.SorobanTransactionData} (if applicable), use
-   *    {@link SorobanDataBuilder} and {@link TransactionBuilder.setSorobanData}
-   *    as needed, instead..
-   *
-   * @todo This cannot clone {@link FeeBumpTransaction}s, yet.
+   * Returns Stellar contract ID as a strkey, ex.
+   * `CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE`.
+   * @returns {string}
    */
-  return transaction_builder_createClass(TransactionBuilder, [{
-    key: "addOperation",
-    value:
-    /**
-     * Adds an operation to the transaction.
-     *
-     * @param {xdr.Operation} operation   The xdr operation object, use {@link
-     *     Operation} static methods.
-     *
-     * @returns {TransactionBuilder}
-     */
-    function addOperation(operation) {
-      this.operations.push(operation);
-      return this;
+  return contract_createClass(Contract, [{
+    key: "contractId",
+    value: function contractId() {
+      return StrKey.encodeContract(this._id);
     }
 
-    /**
-     * Adds an operation to the transaction at a specific index.
-     *
-     * @param {xdr.Operation} operation - The xdr operation object to add, use {@link Operation} static methods.
-     * @param {number} index - The index at which to insert the operation.
-     *
-     * @returns {TransactionBuilder} - The TransactionBuilder instance for method chaining.
-     */
+    /** @returns {string} the ID as a strkey (C...) */
   }, {
-    key: "addOperationAt",
-    value: function addOperationAt(operation, index) {
-      this.operations.splice(index, 0, operation);
-      return this;
+    key: "toString",
+    value: function toString() {
+      return this.contractId();
     }
 
-    /**
-     * Removes the operations from the builder (useful when cloning).
-     * @returns {TransactionBuilder} this builder instance
-     */
+    /** @returns {Address} the wrapped address of this contract */
   }, {
-    key: "clearOperations",
-    value: function clearOperations() {
-      this.operations = [];
-      return this;
+    key: "address",
+    value: function address() {
+      return Address.contract(this._id);
     }
 
     /**
-     * Removes the operation at the specified index from the transaction.
+     * Returns an operation that will invoke this contract call.
      *
-     * @param {number} index - The index of the operation to remove.
+     * @param {string}        method   name of the method to call
+     * @param {...xdr.ScVal}  params   arguments to pass to the function call
      *
-     * @returns {TransactionBuilder} The TransactionBuilder instance for method chaining.
+     * @returns {xdr.Operation}   an InvokeHostFunctionOp operation to call the
+     *    contract with the given method and parameters
+     *
+     * @see Operation.invokeHostFunction
+     * @see Operation.invokeContractFunction
+     * @see Operation.createCustomContract
+     * @see Operation.createStellarAssetContract
+     * @see Operation.uploadContractWasm
      */
   }, {
-    key: "clearOperationAt",
-    value: function clearOperationAt(index) {
-      this.operations.splice(index, 1);
-      return this;
-    }
-
-    /**
-     * Adds a memo to the transaction.
-     * @param {Memo} memo {@link Memo} object
-     * @returns {TransactionBuilder}
-     */
-  }, {
-    key: "addMemo",
-    value: function addMemo(memo) {
-      this.memo = memo;
-      return this;
-    }
-
-    /**
-     * Sets a timeout precondition on the transaction.
-     *
-     *  Because of the distributed nature of the Stellar network it is possible
-     *  that the status of your transaction will be determined after a long time
-     *  if the network is highly congested. If you want to be sure to receive the
-     *  status of the transaction within a given period you should set the {@link
-     *  TimeBounds} with `maxTime` on the transaction (this is what `setTimeout`
-     *  does internally; if there's `minTime` set but no `maxTime` it will be
-     *  added).
-     *
-     *  A call to `TransactionBuilder.setTimeout` is **required** if Transaction
-     *  does not have `max_time` set. If you don't want to set timeout, use
-     *  `{@link TimeoutInfinite}`. In general you should set `{@link
-     *  TimeoutInfinite}` only in smart contracts.
-     *
-     *  Please note that Horizon may still return <code>504 Gateway Timeout</code>
-     *  error, even for short timeouts. In such case you need to resubmit the same
-     *  transaction again without making any changes to receive a status. This
-     *  method is using the machine system time (UTC), make sure it is set
-     *  correctly.
-     *
-     * @param {number} timeoutSeconds   Number of seconds the transaction is good.
-     *     Can't be negative. If the value is {@link TimeoutInfinite}, the
-     *     transaction is good indefinitely.
-     *
-     * @returns {TransactionBuilder}
-     *
-     * @see {@link TimeoutInfinite}
-     * @see https://developers.stellar.org/docs/tutorials/handling-errors/
-     */
-  }, {
-    key: "setTimeout",
-    value: function setTimeout(timeoutSeconds) {
-      if (this.timebounds !== null && this.timebounds.maxTime > 0) {
-        throw new Error('TimeBounds.max_time has been already set - setting timeout would overwrite it.');
-      }
-      if (timeoutSeconds < 0) {
-        throw new Error('timeout cannot be negative');
-      }
-      if (timeoutSeconds > 0) {
-        var timeoutTimestamp = Math.floor(Date.now() / 1000) + timeoutSeconds;
-        if (this.timebounds === null) {
-          this.timebounds = {
-            minTime: 0,
-            maxTime: timeoutTimestamp
-          };
-        } else {
-          this.timebounds = {
-            minTime: this.timebounds.minTime,
-            maxTime: timeoutTimestamp
-          };
-        }
-      } else {
-        this.timebounds = {
-          minTime: 0,
-          maxTime: 0
-        };
+    key: "call",
+    value: function call(method) {
+      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        params[_key - 1] = arguments[_key];
       }
-      return this;
+      return Operation.invokeContractFunction({
+        contract: this.address().toString(),
+        "function": method,
+        args: params
+      });
     }
 
     /**
-     * If you want to prepare a transaction which will become valid at some point
-     * in the future, or be invalid after some time, you can set a timebounds
-     * precondition. Internally this will set the `minTime`, and `maxTime`
-     * preconditions. Conflicts with `setTimeout`, so use one or the other.
-     *
-     * @param {Date|number} minEpochOrDate  Either a JS Date object, or a number
-     *     of UNIX epoch seconds. The transaction is valid after this timestamp.
-     *     Can't be negative. If the value is `0`, the transaction is valid
-     *     immediately.
-     * @param {Date|number} maxEpochOrDate  Either a JS Date object, or a number
-     *     of UNIX epoch seconds. The transaction is valid until this timestamp.
-     *     Can't be negative. If the value is `0`, the transaction is valid
-     *     indefinitely.
+     * Returns the read-only footprint entries necessary for any invocations to
+     * this contract, for convenience when manually adding it to your
+     * transaction's overall footprint or doing bump/restore operations.
      *
-     * @returns {TransactionBuilder}
+     * @returns {xdr.LedgerKey} the ledger key for the deployed contract instance
      */
   }, {
-    key: "setTimebounds",
-    value: function setTimebounds(minEpochOrDate, maxEpochOrDate) {
-      // Force it to a date type
-      if (typeof minEpochOrDate === 'number') {
-        minEpochOrDate = new Date(minEpochOrDate * 1000);
-      }
-      if (typeof maxEpochOrDate === 'number') {
-        maxEpochOrDate = new Date(maxEpochOrDate * 1000);
-      }
-      if (this.timebounds !== null) {
-        throw new Error('TimeBounds has been already set - setting timebounds would overwrite it.');
-      }
-
-      // Convert that date to the epoch seconds
-      var minTime = Math.floor(minEpochOrDate.valueOf() / 1000);
-      var maxTime = Math.floor(maxEpochOrDate.valueOf() / 1000);
-      if (minTime < 0) {
-        throw new Error('min_time cannot be negative');
-      }
-      if (maxTime < 0) {
-        throw new Error('max_time cannot be negative');
-      }
-      if (maxTime > 0 && minTime > maxTime) {
-        throw new Error('min_time cannot be greater than max_time');
-      }
-      this.timebounds = {
-        minTime: minTime,
-        maxTime: maxTime
-      };
-      return this;
+    key: "getFootprint",
+    value: function getFootprint() {
+      return src_xdr.LedgerKey.contractData(new src_xdr.LedgerKeyContractData({
+        contract: this.address().toScAddress(),
+        key: src_xdr.ScVal.scvLedgerKeyContractInstance(),
+        durability: src_xdr.ContractDataDurability.persistent()
+      }));
     }
+  }]);
+}();
+;// ./src/numbers/uint128.js
+function uint128_typeof(o) { "@babel/helpers - typeof"; return uint128_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; }, uint128_typeof(o); }
+function uint128_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function uint128_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, uint128_toPropertyKey(o.key), o); } }
+function uint128_createClass(e, r, t) { return r && uint128_defineProperties(e.prototype, r), t && uint128_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function uint128_toPropertyKey(t) { var i = uint128_toPrimitive(t, "string"); return "symbol" == uint128_typeof(i) ? i : 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(t, e) { if (e && ("object" == uint128_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return uint128_assertThisInitialized(t); }
+function uint128_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+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(t) { return uint128_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, uint128_getPrototypeOf(t); }
+function uint128_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 && uint128_setPrototypeOf(t, e); }
+function uint128_setPrototypeOf(t, e) { return uint128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, uint128_setPrototypeOf(t, e); }
 
-    /**
-     * If you want to prepare a transaction which will only be valid within some
-     * range of ledgers, you can set a ledgerbounds precondition.
-     * Internally this will set the `minLedger` and `maxLedger` preconditions.
-     *
-     * @param {number} minLedger  The minimum ledger this transaction is valid at
-     *     or after. Cannot be negative. If the value is `0` (the default), the
-     *     transaction is valid immediately.
-     *
-     * @param {number} maxLedger  The maximum ledger this transaction is valid
-     *     before. Cannot be negative. If the value is `0`, the transaction is
-     *     valid indefinitely.
-     *
-     * @returns {TransactionBuilder}
-     */
-  }, {
-    key: "setLedgerbounds",
-    value: function setLedgerbounds(minLedger, maxLedger) {
-      if (this.ledgerbounds !== null) {
-        throw new Error('LedgerBounds has been already set - setting ledgerbounds would overwrite it.');
-      }
-      if (minLedger < 0) {
-        throw new Error('min_ledger cannot be negative');
-      }
-      if (maxLedger < 0) {
-        throw new Error('max_ledger cannot be negative');
-      }
-      if (maxLedger > 0 && minLedger > maxLedger) {
-        throw new Error('min_ledger cannot be greater than max_ledger');
-      }
-      this.ledgerbounds = {
-        minLedger: minLedger,
-        maxLedger: maxLedger
-      };
-      return this;
+var Uint128 = /*#__PURE__*/function (_LargeInt) {
+  /**
+   * Construct an unsigned 128-bit integer that can be XDR-encoded.
+   *
+   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
+   *     in big-endian format (i.e. earlier elements are higher bits)
+   */
+  function Uint128() {
+    uint128_classCallCheck(this, Uint128);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return uint128_callSuper(this, Uint128, [args]);
+  }
+  uint128_inherits(Uint128, _LargeInt);
+  return uint128_createClass(Uint128, [{
+    key: "unsigned",
+    get: function get() {
+      return true;
     }
-
-    /**
-     * If you want to prepare a transaction which will be valid only while the
-     * account sequence number is
-     *
-     *     minAccountSequence <= sourceAccountSequence < tx.seqNum
-     *
-     * Note that after execution the account's sequence number is always raised to
-     * `tx.seqNum`. Internally this will set the `minAccountSequence`
-     * precondition.
-     *
-     * @param {string} minAccountSequence   The minimum source account sequence
-     *     number this transaction is valid for. If the value is `0` (the
-     *     default), the transaction is valid when `sourceAccount's sequence
-     *     number == tx.seqNum- 1`.
-     *
-     * @returns {TransactionBuilder}
-     */
   }, {
-    key: "setMinAccountSequence",
-    value: function setMinAccountSequence(minAccountSequence) {
-      if (this.minAccountSequence !== null) {
-        throw new Error('min_account_sequence has been already set - setting min_account_sequence would overwrite it.');
-      }
-      this.minAccountSequence = minAccountSequence;
-      return this;
+    key: "size",
+    get: function get() {
+      return 128;
     }
+  }]);
+}(xdr.LargeInt);
+Uint128.defineIntBoundaries();
+;// ./src/numbers/uint256.js
+function uint256_typeof(o) { "@babel/helpers - typeof"; return uint256_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; }, uint256_typeof(o); }
+function uint256_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function uint256_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, uint256_toPropertyKey(o.key), o); } }
+function uint256_createClass(e, r, t) { return r && uint256_defineProperties(e.prototype, r), t && uint256_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function uint256_toPropertyKey(t) { var i = uint256_toPrimitive(t, "string"); return "symbol" == uint256_typeof(i) ? i : 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(t, e) { if (e && ("object" == uint256_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return uint256_assertThisInitialized(t); }
+function uint256_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+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(t) { return uint256_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, uint256_getPrototypeOf(t); }
+function uint256_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 && uint256_setPrototypeOf(t, e); }
+function uint256_setPrototypeOf(t, e) { return uint256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, uint256_setPrototypeOf(t, e); }
 
-    /**
-     * For the transaction to be valid, the current ledger time must be at least
-     * `minAccountSequenceAge` greater than sourceAccount's `sequenceTime`.
-     * Internally this will set the `minAccountSequenceAge` precondition.
-     *
-     * @param {number} durationInSeconds  The minimum amount of time between
-     *     source account sequence time and the ledger time when this transaction
-     *     will become valid. If the value is `0`, the transaction is unrestricted
-     *     by the account sequence age. Cannot be negative.
-     *
-     * @returns {TransactionBuilder}
-     */
-  }, {
-    key: "setMinAccountSequenceAge",
-    value: function setMinAccountSequenceAge(durationInSeconds) {
-      if (typeof durationInSeconds !== 'number') {
-        throw new Error('min_account_sequence_age must be a number');
-      }
-      if (this.minAccountSequenceAge !== null) {
-        throw new Error('min_account_sequence_age has been already set - setting min_account_sequence_age would overwrite it.');
-      }
-      if (durationInSeconds < 0) {
-        throw new Error('min_account_sequence_age cannot be negative');
-      }
-      this.minAccountSequenceAge = durationInSeconds;
-      return this;
+var Uint256 = /*#__PURE__*/function (_LargeInt) {
+  /**
+   * Construct an unsigned 256-bit integer that can be XDR-encoded.
+   *
+   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
+   *     in big-endian format (i.e. earlier elements are higher bits)
+   */
+  function Uint256() {
+    uint256_classCallCheck(this, Uint256);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return uint256_callSuper(this, Uint256, [args]);
+  }
+  uint256_inherits(Uint256, _LargeInt);
+  return uint256_createClass(Uint256, [{
+    key: "unsigned",
+    get: function get() {
+      return true;
     }
-
-    /**
-     * For the transaction to be valid, the current ledger number must be at least
-     * `minAccountSequenceLedgerGap` greater than sourceAccount's ledger sequence.
-     * Internally this will set the `minAccountSequenceLedgerGap` precondition.
-     *
-     * @param {number} gap  The minimum number of ledgers between source account
-     *     sequence and the ledger number when this transaction will become valid.
-     *     If the value is `0`, the transaction is unrestricted by the account
-     *     sequence ledger. Cannot be negative.
-     *
-     * @returns {TransactionBuilder}
-     */
   }, {
-    key: "setMinAccountSequenceLedgerGap",
-    value: function setMinAccountSequenceLedgerGap(gap) {
-      if (this.minAccountSequenceLedgerGap !== null) {
-        throw new Error('min_account_sequence_ledger_gap has been already set - setting min_account_sequence_ledger_gap would overwrite it.');
-      }
-      if (gap < 0) {
-        throw new Error('min_account_sequence_ledger_gap cannot be negative');
-      }
-      this.minAccountSequenceLedgerGap = gap;
-      return this;
+    key: "size",
+    get: function get() {
+      return 256;
     }
+  }]);
+}(xdr.LargeInt);
+Uint256.defineIntBoundaries();
+;// ./src/numbers/int128.js
+function int128_typeof(o) { "@babel/helpers - typeof"; return int128_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; }, int128_typeof(o); }
+function int128_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function int128_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, int128_toPropertyKey(o.key), o); } }
+function int128_createClass(e, r, t) { return r && int128_defineProperties(e.prototype, r), t && int128_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function int128_toPropertyKey(t) { var i = int128_toPrimitive(t, "string"); return "symbol" == int128_typeof(i) ? i : 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(t, e) { if (e && ("object" == int128_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return int128_assertThisInitialized(t); }
+function int128_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+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(t) { return int128_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, int128_getPrototypeOf(t); }
+function int128_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 && int128_setPrototypeOf(t, e); }
+function int128_setPrototypeOf(t, e) { return int128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, int128_setPrototypeOf(t, e); }
 
-    /**
-     * For the transaction to be valid, there must be a signature corresponding to
-     * every Signer in this array, even if the signature is not otherwise required
-     * by the sourceAccount or operations. Internally this will set the
-     * `extraSigners` precondition.
-     *
-     * @param {string[]} extraSigners   required extra signers (as {@link StrKey}s)
-     *
-     * @returns {TransactionBuilder}
-     */
+var Int128 = /*#__PURE__*/function (_LargeInt) {
+  /**
+   * Construct a signed 128-bit integer that can be XDR-encoded.
+   *
+   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
+   *     in big-endian format (i.e. earlier elements are higher bits)
+   */
+  function Int128() {
+    int128_classCallCheck(this, Int128);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return int128_callSuper(this, Int128, [args]);
+  }
+  int128_inherits(Int128, _LargeInt);
+  return int128_createClass(Int128, [{
+    key: "unsigned",
+    get: function get() {
+      return false;
+    }
   }, {
-    key: "setExtraSigners",
-    value: function setExtraSigners(extraSigners) {
-      if (!Array.isArray(extraSigners)) {
-        throw new Error('extra_signers must be an array of strings.');
-      }
-      if (this.extraSigners !== null) {
-        throw new Error('extra_signers has been already set - setting extra_signers would overwrite it.');
-      }
-      if (extraSigners.length > 2) {
-        throw new Error('extra_signers cannot be longer than 2 elements.');
-      }
-      this.extraSigners = _toConsumableArray(extraSigners);
-      return this;
+    key: "size",
+    get: function get() {
+      return 128;
     }
+  }]);
+}(xdr.LargeInt);
+Int128.defineIntBoundaries();
+;// ./src/numbers/int256.js
+function int256_typeof(o) { "@babel/helpers - typeof"; return int256_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; }, int256_typeof(o); }
+function int256_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function int256_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, int256_toPropertyKey(o.key), o); } }
+function int256_createClass(e, r, t) { return r && int256_defineProperties(e.prototype, r), t && int256_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function int256_toPropertyKey(t) { var i = int256_toPrimitive(t, "string"); return "symbol" == int256_typeof(i) ? i : 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(t, e) { if (e && ("object" == int256_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return int256_assertThisInitialized(t); }
+function int256_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+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(t) { return int256_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, int256_getPrototypeOf(t); }
+function int256_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 && int256_setPrototypeOf(t, e); }
+function int256_setPrototypeOf(t, e) { return int256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, int256_setPrototypeOf(t, e); }
 
-    /**
-     * Set network nassphrase for the Transaction that will be built.
-     *
-     * @param {string} networkPassphrase    passphrase of the target Stellar
-     *     network (e.g. "Public Global Stellar Network ; September 2015").
-     *
-     * @returns {TransactionBuilder}
-     */
+var Int256 = /*#__PURE__*/function (_LargeInt) {
+  /**
+   * Construct a signed 256-bit integer that can be XDR-encoded.
+   *
+   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
+   *     in big-endian format (i.e. earlier elements are higher bits)
+   */
+  function Int256() {
+    int256_classCallCheck(this, Int256);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return int256_callSuper(this, Int256, [args]);
+  }
+  int256_inherits(Int256, _LargeInt);
+  return int256_createClass(Int256, [{
+    key: "unsigned",
+    get: function get() {
+      return false;
+    }
   }, {
-    key: "setNetworkPassphrase",
-    value: function setNetworkPassphrase(networkPassphrase) {
-      this.networkPassphrase = networkPassphrase;
-      return this;
+    key: "size",
+    get: function get() {
+      return 256;
     }
+  }]);
+}(xdr.LargeInt);
+Int256.defineIntBoundaries();
+;// ./src/numbers/xdr_large_int.js
+function xdr_large_int_typeof(o) { "@babel/helpers - typeof"; return xdr_large_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; }, xdr_large_int_typeof(o); }
+function xdr_large_int_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function xdr_large_int_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, xdr_large_int_toPropertyKey(o.key), o); } }
+function xdr_large_int_createClass(e, r, t) { return r && xdr_large_int_defineProperties(e.prototype, r), t && xdr_large_int_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function xdr_large_int_defineProperty(e, r, t) { return (r = xdr_large_int_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function xdr_large_int_toPropertyKey(t) { var i = xdr_large_int_toPrimitive(t, "string"); return "symbol" == xdr_large_int_typeof(i) ? i : 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": [">>"]}] */
 
-    /**
-     * Sets the transaction's internal Soroban transaction data (resources,
-     * footprint, etc.).
-     *
-     * For non-contract(non-Soroban) transactions, this setting has no effect. In
-     * the case of Soroban transactions, this is either an instance of
-     * {@link xdr.SorobanTransactionData} or a base64-encoded string of said
-     * structure. This is usually obtained from the simulation response based on a
-     * transaction with a Soroban operation (e.g.
-     * {@link Operation.invokeHostFunction}, providing necessary resource
-     * and storage footprint estimations for contract invocation.
-     *
-     * @param {xdr.SorobanTransactionData | string} sorobanData    the
-     *    {@link xdr.SorobanTransactionData} as a raw xdr object or a base64
-     *    string to be decoded
-     *
-     * @returns {TransactionBuilder}
-     * @see {SorobanDataBuilder}
-     */
-  }, {
-    key: "setSorobanData",
-    value: function setSorobanData(sorobanData) {
-      this.sorobanData = new SorobanDataBuilder(sorobanData).build();
-      return this;
+
+
+
+
+
+
+/**
+ * A wrapper class to represent large XDR-encodable integers.
+ *
+ * This operates at a lower level than {@link ScInt} by forcing you to specify
+ * the type / width / size in bits of the integer you're targeting, regardless
+ * of the input value(s) you provide.
+ *
+ * @param {string}  type - specifies a data type to use to represent the, one
+ *    of: 'i64', 'u64', 'i128', 'u128', 'i256', and 'u256' (see
+ *    {@link XdrLargeInt.isType})
+ * @param {number|bigint|string|Array<number|bigint|string>} values   a list of
+ *    integer-like values interpreted in big-endian order
+ */
+var XdrLargeInt = /*#__PURE__*/function () {
+  function XdrLargeInt(type, values) {
+    xdr_large_int_classCallCheck(this, XdrLargeInt);
+    /** @type {xdr.LargeInt} */
+    xdr_large_int_defineProperty(this, "int", void 0);
+    // child class of a jsXdr.LargeInt
+    /** @type {string} */
+    xdr_large_int_defineProperty(this, "type", void 0);
+    if (!(values instanceof Array)) {
+      values = [values];
     }
 
-    /**
-     * This will build the transaction.
-     * It will also increment the source account's sequence number by 1.
-     * @returns {Transaction} This method will return the built {@link Transaction}.
-     */
-  }, {
-    key: "build",
-    value: function build() {
-      var sequenceNumber = new util_bignumber(this.source.sequenceNumber()).plus(1);
-      var fee = new util_bignumber(this.baseFee).times(this.operations.length).toNumber();
-      var attrs = {
-        fee: fee,
-        seqNum: src_xdr.SequenceNumber.fromString(sequenceNumber.toString()),
-        memo: this.memo ? this.memo.toXDRObject() : null
-      };
-      if (this.timebounds === null || typeof this.timebounds.minTime === 'undefined' || typeof this.timebounds.maxTime === 'undefined') {
-        throw new Error('TimeBounds has to be set or you must call setTimeout(TimeoutInfinite).');
-      }
-      if (isValidDate(this.timebounds.minTime)) {
-        this.timebounds.minTime = this.timebounds.minTime.getTime() / 1000;
-      }
-      if (isValidDate(this.timebounds.maxTime)) {
-        this.timebounds.maxTime = this.timebounds.maxTime.getTime() / 1000;
+    // normalize values to one type
+    values = values.map(function (i) {
+      // micro-optimization to no-op on the likeliest input value:
+      if (typeof i === 'bigint') {
+        return i;
       }
-      this.timebounds.minTime = xdr.UnsignedHyper.fromString(this.timebounds.minTime.toString());
-      this.timebounds.maxTime = xdr.UnsignedHyper.fromString(this.timebounds.maxTime.toString());
-      var timeBounds = new src_xdr.TimeBounds(this.timebounds);
-      if (this.hasV2Preconditions()) {
-        var ledgerBounds = null;
-        if (this.ledgerbounds !== null) {
-          ledgerBounds = new src_xdr.LedgerBounds(this.ledgerbounds);
-        }
-        var minSeqNum = this.minAccountSequence || '0';
-        minSeqNum = src_xdr.SequenceNumber.fromString(minSeqNum);
-        var minSeqAge = xdr.UnsignedHyper.fromString(this.minAccountSequenceAge !== null ? this.minAccountSequenceAge.toString() : '0');
-        var minSeqLedgerGap = this.minAccountSequenceLedgerGap || 0;
-        var extraSigners = this.extraSigners !== null ? this.extraSigners.map(SignerKey.decodeAddress) : [];
-        attrs.cond = src_xdr.Preconditions.precondV2(new src_xdr.PreconditionsV2({
-          timeBounds: timeBounds,
-          ledgerBounds: ledgerBounds,
-          minSeqNum: minSeqNum,
-          minSeqAge: minSeqAge,
-          minSeqLedgerGap: minSeqLedgerGap,
-          extraSigners: extraSigners
-        }));
-      } else {
-        attrs.cond = src_xdr.Preconditions.precondTime(timeBounds);
+      if (typeof i.toBigInt === 'function') {
+        return i.toBigInt();
       }
-      attrs.sourceAccount = decodeAddressToMuxedAccount(this.source.accountId());
+      return BigInt(i);
+    });
+    switch (type) {
+      case 'i64':
+        this["int"] = new xdr.Hyper(values);
+        break;
+      case 'i128':
+        this["int"] = new Int128(values);
+        break;
+      case 'i256':
+        this["int"] = new Int256(values);
+        break;
+      case 'u64':
+      case 'timepoint':
+      case 'duration':
+        this["int"] = new xdr.UnsignedHyper(values);
+        break;
+      case 'u128':
+        this["int"] = new Uint128(values);
+        break;
+      case 'u256':
+        this["int"] = new Uint256(values);
+        break;
+      default:
+        throw TypeError("invalid type: ".concat(type));
+    }
+    this.type = type;
+  }
 
-      // TODO - remove this workaround for TransactionExt ts constructor
-      //       and use the typescript generated static factory method once fixed
-      //       https://github.com/stellar/dts-xdr/issues/5
-      if (this.sorobanData) {
-        // @ts-ignore
-        attrs.ext = new src_xdr.TransactionExt(1, this.sorobanData);
-      } else {
-        // @ts-ignore
-        attrs.ext = new src_xdr.TransactionExt(0, src_xdr.Void);
+  /**
+   * @returns {number}
+   * @throws {RangeError} if the value can't fit into a Number
+   */
+  return xdr_large_int_createClass(XdrLargeInt, [{
+    key: "toNumber",
+    value: function toNumber() {
+      var bi = this["int"].toBigInt();
+      if (bi > Number.MAX_SAFE_INTEGER || bi < Number.MIN_SAFE_INTEGER) {
+        throw RangeError("value ".concat(bi, " not in range for Number ") + "[".concat(Number.MAX_SAFE_INTEGER, ", ").concat(Number.MIN_SAFE_INTEGER, "]"));
       }
-      var xtx = new src_xdr.Transaction(attrs);
-      xtx.operations(this.operations);
-      var txEnvelope = new src_xdr.TransactionEnvelope.envelopeTypeTx(new src_xdr.TransactionV1Envelope({
-        tx: xtx
-      }));
-      var tx = new Transaction(txEnvelope, this.networkPassphrase);
-      this.source.incrementSequenceNumber();
-      return tx;
+      return Number(bi);
     }
+
+    /** @returns {bigint} */
   }, {
-    key: "hasV2Preconditions",
-    value: function hasV2Preconditions() {
-      return this.ledgerbounds !== null || this.minAccountSequence !== null || this.minAccountSequenceAge !== null || this.minAccountSequenceLedgerGap !== null || this.extraSigners !== null && this.extraSigners.length > 0;
+    key: "toBigInt",
+    value: function toBigInt() {
+      return this["int"].toBigInt();
     }
 
-    /**
-     * Builds a {@link FeeBumpTransaction}, enabling you to resubmit an existing
-     * transaction with a higher fee.
-     *
-     * @param {Keypair|string}  feeSource - account paying for the transaction,
-     *     in the form of either a Keypair (only the public key is used) or
-     *     an account ID (in G... or M... form, but refer to `withMuxing`)
-     * @param {string}          baseFee   - max fee willing to pay per operation
-     *     in inner transaction (**in stroops**)
-     * @param {Transaction}     innerTx   - {@link Transaction} to be bumped by
-     *     the fee bump transaction
-     * @param {string}          networkPassphrase - passphrase of the target
-     *     Stellar network (e.g. "Public Global Stellar Network ; September 2015",
-     *     see {@link Networks})
-     *
-     * @todo Alongside the next major version bump, this type signature can be
-     *       changed to be less awkward: accept a MuxedAccount as the `feeSource`
-     *       rather than a keypair or string.
-     *
-     * @note Your fee-bump amount should be >= 10x the original fee.
-     * @see  https://developers.stellar.org/docs/glossary/fee-bumps/#replace-by-fee
-     *
-     * @returns {FeeBumpTransaction}
-     */
-  }], [{
-    key: "cloneFrom",
-    value: function cloneFrom(tx) {
-      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-      if (!(tx instanceof Transaction)) {
-        throw new TypeError("expected a 'Transaction', got: ".concat(tx));
-      }
-      var sequenceNum = (BigInt(tx.sequence) - 1n).toString();
-      var source;
-      // rebuild the source account based on the strkey
-      if (StrKey.isValidMed25519PublicKey(tx.source)) {
-        source = MuxedAccount.fromAddress(tx.source, sequenceNum);
-      } else if (StrKey.isValidEd25519PublicKey(tx.source)) {
-        source = new Account(tx.source, sequenceNum);
-      } else {
-        throw new TypeError("unsupported tx source account: ".concat(tx.source));
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = I64` */
+  }, {
+    key: "toI64",
+    value: function toI64() {
+      this._sizeCheck(64);
+      var v = this.toBigInt();
+      if (BigInt.asIntN(64, v) !== v) {
+        throw RangeError("value too large for i64: ".concat(v));
       }
+      return src_xdr.ScVal.scvI64(new src_xdr.Int64(v));
+    }
 
-      // the initial fee passed to the builder gets scaled up based on the number
-      // of operations at the end, so we have to down-scale first
-      var unscaledFee = parseInt(tx.fee, 10) / tx.operations.length;
-      var builder = new TransactionBuilder(source, transaction_builder_objectSpread({
-        fee: (unscaledFee || BASE_FEE).toString(),
-        memo: tx.memo,
-        networkPassphrase: tx.networkPassphrase,
-        timebounds: tx.timeBounds,
-        ledgerbounds: tx.ledgerBounds,
-        minAccountSequence: tx.minAccountSequence,
-        minAccountSequenceAge: tx.minAccountSequenceAge,
-        minAccountSequenceLedgerGap: tx.minAccountSequenceLedgerGap,
-        extraSigners: tx.extraSigners
-      }, opts));
-      tx._tx.operations().forEach(function (op) {
-        return builder.addOperation(op);
-      });
-      return builder;
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = U64` */
+  }, {
+    key: "toU64",
+    value: function toU64() {
+      this._sizeCheck(64);
+      return src_xdr.ScVal.scvU64(new src_xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
+      );
     }
+
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = Timepoint` */
   }, {
-    key: "buildFeeBumpTransaction",
-    value: function buildFeeBumpTransaction(feeSource, baseFee, innerTx, networkPassphrase) {
-      var innerOps = innerTx.operations.length;
-      var minBaseFee = new util_bignumber(BASE_FEE);
-      var innerInclusionFee = new util_bignumber(innerTx.fee).div(innerOps);
-      var resourceFee = new util_bignumber(0);
+    key: "toTimepoint",
+    value: function toTimepoint() {
+      this._sizeCheck(64);
+      return src_xdr.ScVal.scvTimepoint(new src_xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
+      );
+    }
 
-      // Do we need to do special Soroban fee handling? We only want the fee-bump
-      // requirement to match the inclusion fee, not the inclusion+resource fee.
-      var env = innerTx.toEnvelope();
-      switch (env["switch"]().value) {
-        case src_xdr.EnvelopeType.envelopeTypeTx().value:
-          {
-            var _sorobanData$resource;
-            var sorobanData = env.v1().tx().ext().value();
-            resourceFee = new util_bignumber((_sorobanData$resource = sorobanData === null || sorobanData === void 0 ? void 0 : sorobanData.resourceFee()) !== null && _sorobanData$resource !== void 0 ? _sorobanData$resource : 0);
-            innerInclusionFee = util_bignumber.max(minBaseFee, innerInclusionFee.minus(resourceFee));
-            break;
-          }
-        default:
-          break;
-      }
-      var base = new util_bignumber(baseFee);
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = Duration` */
+  }, {
+    key: "toDuration",
+    value: function toDuration() {
+      this._sizeCheck(64);
+      return src_xdr.ScVal.scvDuration(new src_xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
+      );
+    }
 
-      // The fee rate for fee bump is at least the fee rate of the inner transaction
-      if (base.lt(innerInclusionFee)) {
-        throw new Error("Invalid baseFee, it should be at least ".concat(innerInclusionFee, " stroops."));
-      }
+    /**
+     * @returns {xdr.ScVal} the integer encoded with `ScValType = I128`
+     * @throws {RangeError} if the value cannot fit in 128 bits
+     */
+  }, {
+    key: "toI128",
+    value: function toI128() {
+      this._sizeCheck(128);
+      var v = this["int"].toBigInt();
+      var hi64 = BigInt.asIntN(64, v >> 64n); // encode top 64 w/ sign bit
+      var lo64 = BigInt.asUintN(64, v); // grab btm 64, encode sign
 
-      // The fee rate is at least the minimum fee
-      if (base.lt(minBaseFee)) {
-        throw new Error("Invalid baseFee, it should be at least ".concat(minBaseFee, " stroops."));
-      }
-      var innerTxEnvelope = innerTx.toEnvelope();
-      if (innerTxEnvelope["switch"]() === src_xdr.EnvelopeType.envelopeTypeTxV0()) {
-        var v0Tx = innerTxEnvelope.v0().tx();
-        var v1Tx = new src_xdr.Transaction({
-          sourceAccount: new src_xdr.MuxedAccount.keyTypeEd25519(v0Tx.sourceAccountEd25519()),
-          fee: v0Tx.fee(),
-          seqNum: v0Tx.seqNum(),
-          cond: src_xdr.Preconditions.precondTime(v0Tx.timeBounds()),
-          memo: v0Tx.memo(),
-          operations: v0Tx.operations(),
-          ext: new src_xdr.TransactionExt(0)
-        });
-        innerTxEnvelope = new src_xdr.TransactionEnvelope.envelopeTypeTx(new src_xdr.TransactionV1Envelope({
-          tx: v1Tx,
-          signatures: innerTxEnvelope.v0().signatures()
-        }));
-      }
-      var feeSourceAccount;
-      if (typeof feeSource === 'string') {
-        feeSourceAccount = decodeAddressToMuxedAccount(feeSource);
-      } else {
-        feeSourceAccount = feeSource.xdrMuxedAccount();
-      }
-      var tx = new src_xdr.FeeBumpTransaction({
-        feeSource: feeSourceAccount,
-        fee: src_xdr.Int64.fromString(base.times(innerOps + 1).plus(resourceFee).toString()),
-        innerTx: src_xdr.FeeBumpTransactionInnerTx.envelopeTypeTx(innerTxEnvelope.v1()),
-        ext: new src_xdr.FeeBumpTransactionExt(0)
-      });
-      var feeBumpTxEnvelope = new src_xdr.FeeBumpTransactionEnvelope({
-        tx: tx,
-        signatures: []
-      });
-      var envelope = new src_xdr.TransactionEnvelope.envelopeTypeTxFeeBump(feeBumpTxEnvelope);
-      return new FeeBumpTransaction(envelope, networkPassphrase);
+      return src_xdr.ScVal.scvI128(new src_xdr.Int128Parts({
+        hi: new src_xdr.Int64(hi64),
+        lo: new src_xdr.Uint64(lo64)
+      }));
     }
 
     /**
-     * Build a {@link Transaction} or {@link FeeBumpTransaction} from an
-     * xdr.TransactionEnvelope.
-     *
-     * @param {string|xdr.TransactionEnvelope} envelope - The transaction envelope
-     *     object or base64 encoded string.
-     * @param {string} networkPassphrase - The network passphrase of the target
-     *     Stellar network (e.g. "Public Global Stellar Network ; September
-     *     2015"), see {@link Networks}.
-     *
-     * @returns {Transaction|FeeBumpTransaction}
+     * @returns {xdr.ScVal} the integer encoded with `ScValType = U128`
+     * @throws {RangeError} if the value cannot fit in 128 bits
      */
   }, {
-    key: "fromXDR",
-    value: function fromXDR(envelope, networkPassphrase) {
-      if (typeof envelope === 'string') {
-        envelope = src_xdr.TransactionEnvelope.fromXDR(envelope, 'base64');
-      }
-      if (envelope["switch"]() === src_xdr.EnvelopeType.envelopeTypeTxFeeBump()) {
-        return new FeeBumpTransaction(envelope, networkPassphrase);
-      }
-      return new Transaction(envelope, networkPassphrase);
+    key: "toU128",
+    value: function toU128() {
+      this._sizeCheck(128);
+      var v = this["int"].toBigInt();
+      return src_xdr.ScVal.scvU128(new src_xdr.UInt128Parts({
+        hi: new src_xdr.Uint64(BigInt.asUintN(64, v >> 64n)),
+        lo: new src_xdr.Uint64(BigInt.asUintN(64, v))
+      }));
     }
-  }]);
-}();
 
-/**
- * Checks whether a provided object is a valid Date.
- * @argument {Date} d date object
- * @returns {boolean}
- */
-function isValidDate(d) {
-  // isnan is okay here because it correctly checks for invalid date objects
-  // eslint-disable-next-line no-restricted-globals
-  return d instanceof Date && !isNaN(d);
-}
-;// ./src/network.js
-/**
- * Contains passphrases for common networks:
- * * `Networks.PUBLIC`: `Public Global Stellar Network ; September 2015`
- * * `Networks.TESTNET`: `Test SDF Network ; September 2015`
- * * `Networks.FUTURENET`: `Test SDF Future Network ; October 2022`
- * * `Networks.STANDALONE`: `Standalone Network ; February 2017`
- *
- * @type {{PUBLIC: string, TESTNET: string, FUTURENET: string, STANDALONE: string }}
- */
-var Networks = {
-  PUBLIC: 'Public Global Stellar Network ; September 2015',
-  TESTNET: 'Test SDF Network ; September 2015',
-  FUTURENET: 'Test SDF Future Network ; October 2022',
-  SANDBOX: 'Local Sandbox Stellar Network ; September 2022',
-  STANDALONE: 'Standalone Network ; February 2017'
-};
-;// ./src/soroban.js
-function soroban_typeof(o) { "@babel/helpers - typeof"; return soroban_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; }, soroban_typeof(o); }
-function _toArray(r) { return soroban_arrayWithHoles(r) || soroban_iterableToArray(r) || soroban_unsupportedIterableToArray(r) || soroban_nonIterableRest(); }
-function soroban_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function soroban_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return soroban_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? soroban_arrayLikeToArray(r, a) : void 0; } }
-function soroban_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function soroban_iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
-function soroban_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-function soroban_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function soroban_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, soroban_toPropertyKey(o.key), o); } }
-function soroban_createClass(e, r, t) { return r && soroban_defineProperties(e.prototype, r), t && soroban_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function soroban_toPropertyKey(t) { var i = soroban_toPrimitive(t, "string"); return "symbol" == soroban_typeof(i) ? i : 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() {
-    soroban_classCallCheck(this, Soroban);
-  }
-  return soroban_createClass(Soroban, null, [{
-    key: "formatTokenAmount",
-    value:
-    /**
-     * Given a whole number smart contract amount of a token and an amount of
-     * decimal places (if the token has any), it returns a "display" value.
-     *
-     * All arithmetic inside the contract is performed on integers to avoid
-     * potential precision and consistency issues of floating-point.
-     *
-     * @param {string} amount   the token amount you want to display
-     * @param {number} decimals specify how many decimal places a token has
-     *
-     * @returns {string} the display value
-     * @throws {TypeError} if the given amount has a decimal point already
-     * @example
-     * formatTokenAmount("123000", 4) === "12.3";
-     * formatTokenAmount("123000", 3) === "123.0";
-     * formatTokenAmount("123", 3) === "0.123";
-     */
-    function formatTokenAmount(amount, decimals) {
-      if (amount.includes('.')) {
-        throw new TypeError('No decimals are allowed');
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = I256` */
+  }, {
+    key: "toI256",
+    value: function toI256() {
+      var v = this["int"].toBigInt();
+      var hiHi64 = BigInt.asIntN(64, v >> 192n); // keep sign bit
+      var hiLo64 = BigInt.asUintN(64, v >> 128n);
+      var loHi64 = BigInt.asUintN(64, v >> 64n);
+      var loLo64 = BigInt.asUintN(64, v);
+      return src_xdr.ScVal.scvI256(new src_xdr.Int256Parts({
+        hiHi: new src_xdr.Int64(hiHi64),
+        hiLo: new src_xdr.Uint64(hiLo64),
+        loHi: new src_xdr.Uint64(loHi64),
+        loLo: new src_xdr.Uint64(loLo64)
+      }));
+    }
+
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = U256` */
+  }, {
+    key: "toU256",
+    value: function toU256() {
+      var v = this["int"].toBigInt();
+      var hiHi64 = BigInt.asUintN(64, v >> 192n); // encode sign bit
+      var hiLo64 = BigInt.asUintN(64, v >> 128n);
+      var loHi64 = BigInt.asUintN(64, v >> 64n);
+      var loLo64 = BigInt.asUintN(64, v);
+      return src_xdr.ScVal.scvU256(new src_xdr.UInt256Parts({
+        hiHi: new src_xdr.Uint64(hiHi64),
+        hiLo: new src_xdr.Uint64(hiLo64),
+        loHi: new src_xdr.Uint64(loHi64),
+        loLo: new src_xdr.Uint64(loLo64)
+      }));
+    }
+
+    /** @returns {xdr.ScVal} the smallest interpretation of the stored value */
+  }, {
+    key: "toScVal",
+    value: function toScVal() {
+      switch (this.type) {
+        case 'i64':
+          return this.toI64();
+        case 'i128':
+          return this.toI128();
+        case 'i256':
+          return this.toI256();
+        case 'u64':
+          return this.toU64();
+        case 'u128':
+          return this.toU128();
+        case 'u256':
+          return this.toU256();
+        case 'timepoint':
+          return this.toTimepoint();
+        case 'duration':
+          return this.toDuration();
+        default:
+          throw TypeError("invalid type: ".concat(this.type));
       }
-      var formatted = amount;
-      if (decimals > 0) {
-        if (decimals > formatted.length) {
-          formatted = ['0', formatted.toString().padStart(decimals, '0')].join('.');
-        } else {
-          formatted = [formatted.slice(0, -decimals), formatted.slice(-decimals)].join('.');
-        }
+    }
+  }, {
+    key: "valueOf",
+    value: function valueOf() {
+      return this["int"].valueOf();
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this["int"].toString();
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return {
+        value: this.toBigInt().toString(),
+        type: this.type
+      };
+    }
+  }, {
+    key: "_sizeCheck",
+    value: function _sizeCheck(bits) {
+      if (this["int"].size > bits) {
+        throw RangeError("value too large for ".concat(bits, " bits (").concat(this.type, ")"));
+      }
+    }
+  }], [{
+    key: "isType",
+    value: function isType(type) {
+      switch (type) {
+        case 'i64':
+        case 'i128':
+        case 'i256':
+        case 'u64':
+        case 'u128':
+        case 'u256':
+        case 'timepoint':
+        case 'duration':
+          return true;
+        default:
+          return false;
       }
-      return formatted.replace(/(\.\d*?)0+$/, '$1') // strip trailing zeroes
-      .replace(/\.$/, '.0') // but keep at least one
-      .replace(/^\./, '0.'); // and a leading one
     }
 
     /**
-     * Parse a token amount to use it on smart contract
-     *
-     * This function takes the display value and its decimals (if the token has
-     * any) and returns a string that'll be used within the smart contract.
-     *
-     * @param {string} value      the token amount you want to use it on smart
-     *    contract which you've been displaying in a UI
-     * @param {number} decimals   the number of decimal places expected in the
-     *    display value (different than the "actual" number, because suffix zeroes
-     *    might not be present)
-     *
-     * @returns {string}  the whole number token amount represented by the display
-     *    value with the decimal places shifted over
+     * Convert the raw `ScValType` string (e.g. 'scvI128', generated by the XDR)
+     * to a type description for {@link XdrLargeInt} construction (e.g. 'i128')
      *
-     * @example
-     * const displayValueAmount = "123.4560"
-     * const parsedAmtForSmartContract = parseTokenAmount(displayValueAmount, 5);
-     * parsedAmtForSmartContract === "12345600"
+     * @param {string} scvType  the `xdr.ScValType` as a string
+     * @returns {string} a suitable equivalent type to construct this object
      */
   }, {
-    key: "parseTokenAmount",
-    value: function parseTokenAmount(value, decimals) {
-      var _fraction$padEnd;
-      var _value$split$slice = value.split('.').slice(),
-        _value$split$slice2 = _toArray(_value$split$slice),
-        whole = _value$split$slice2[0],
-        fraction = _value$split$slice2[1],
-        rest = soroban_arrayLikeToArray(_value$split$slice2).slice(2);
-      if (rest.length) {
-        throw new Error("Invalid decimal value: ".concat(value));
-      }
-      var shifted = BigInt(whole + ((_fraction$padEnd = fraction === null || fraction === void 0 ? void 0 : fraction.padEnd(decimals, '0')) !== null && _fraction$padEnd !== void 0 ? _fraction$padEnd : '0'.repeat(decimals)));
-      return shifted.toString();
+    key: "getType",
+    value: function getType(scvType) {
+      return scvType.slice(3).toLowerCase();
     }
   }]);
 }();
-;// ./src/contract.js
-function contract_typeof(o) { "@babel/helpers - typeof"; return contract_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; }, contract_typeof(o); }
-function contract_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function contract_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, contract_toPropertyKey(o.key), o); } }
-function contract_createClass(e, r, t) { return r && contract_defineProperties(e.prototype, r), t && contract_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function contract_toPropertyKey(t) { var i = contract_toPrimitive(t, "string"); return "symbol" == contract_typeof(i) ? i : 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); }
-
-
-
+;// ./src/numbers/sc_int.js
+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(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, sc_int_toPropertyKey(o.key), o); } }
+function sc_int_createClass(e, r, t) { return r && sc_int_defineProperties(e.prototype, r), t && sc_int_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function sc_int_toPropertyKey(t) { var i = sc_int_toPrimitive(t, "string"); return "symbol" == sc_int_typeof(i) ? i : 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(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+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(t, e) { if (e && ("object" == sc_int_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return sc_int_assertThisInitialized(t); }
+function sc_int_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
+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(t) { return sc_int_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, sc_int_getPrototypeOf(t); }
+function sc_int_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 && sc_int_setPrototypeOf(t, e); }
+function sc_int_setPrototypeOf(t, e) { return sc_int_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, sc_int_setPrototypeOf(t, e); }
 
 
 /**
- * Create a new Contract object.
+ * Provides an easier way to manipulate large numbers for Stellar operations.
  *
- * `Contract` represents a single contract in the Stellar network, embodying the
- * interface of the contract. See
- * [Contracts](https://soroban.stellar.org/docs/learn/interacting-with-contracts)
- * for more information about how contracts work in Stellar.
+ * You can instantiate this "**s**mart **c**ontract integer" value either from
+ * bigints, strings, or numbers (whole numbers, or this will throw).
  *
- * @constructor
+ * 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
+ * value), you can use the lower level abstraction {@link XdrLargeInt}. For
+ * example, you could do `new XdrLargeInt('u128', bytes...).toBigInt()`.
  *
- * @param {string} contractId - ID of the contract (ex.
- *     `CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE`).
+ * @example
+ * 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 = scValToBigInt(value); // grab it as a BigInt
+ * let sci = new ScInt(bigi);
+ *
+ * sci.toNumber(); // gives native JS type (w/ size check)
+ * sci.toBigInt(); // gives the native BigInt value
+ * sci.toU64();    // gives ScValType-specific XDR constructs (with size checks)
+ *
+ * // You have a number and want to shove it into a contract.
+ * sci = ScInt(0xdeadcafebabe);
+ * sci.toBigInt() // returns 244838016400062n
+ * sci.toNumber() // throws: too large
+ *
+ * // Pass any to e.g. a Contract.call(), conversion happens automatically
+ * // regardless of the initial type.
+ * const scValU128 = sci.toU128();
+ * const scValI256 = sci.toI256();
+ * const scValU64  = sci.toU64();
+ *
+ * // Lots of ways to initialize:
+ * ScInt("123456789123456789")
+ * ScInt(123456789123456789n);
+ * ScInt(1n << 140n);
+ * ScInt(-42);
+ * 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
+ * // interpreted from the numbers you pass in):
+ * const i = ScInt(123456789n, { type: "u256" });
+ *
+ * // For example, you can use the underlying `sdk.U256` and convert it to an
+ * // `xdr.ScVal` directly like so:
+ * const scv = new xdr.ScVal.scvU256(i.raw);
+ *
+ * // Or reinterpret it as a different type (size permitting):
+ * const scv = i.toI64();
+ *
+ * @param {number|bigint|string} value - a single, integer-like value which will
+ *    be interpreted in the smallest appropriate XDR type supported by Stellar
+ *    (64, 128, or 256 bit integer values). signed values are supported, though
+ *    they are sanity-checked against `opts.type`. if you need 32-bit values,
+ *    you can construct them directly without needing this wrapper, e.g.
+ *    `xdr.ScVal.scvU32(1234)`.
+ *
+ * @param {object}  [opts] - an optional object controlling optional parameters
+ * @param {string}  [opts.type] - force a specific data type. the type choices
+ *    are: 'i64', 'u64', 'i128', 'u128', 'i256', and 'u256' (default: the
+ *    smallest one that fits the `value`)
+ *
+ * @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 Contract = /*#__PURE__*/function () {
-  function Contract(contractId) {
-    contract_classCallCheck(this, Contract);
-    try {
-      // First, try it as a strkey
-      this._id = StrKey.decodeContract(contractId);
-    } catch (_) {
-      throw new Error("Invalid contract ID: ".concat(contractId));
+var ScInt = /*#__PURE__*/function (_XdrLargeInt) {
+  function ScInt(value, opts) {
+    var _opts$type;
+    sc_int_classCallCheck(this, ScInt);
+    var signed = value < 0;
+    var type = (_opts$type = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type !== void 0 ? _opts$type : '';
+    if (type.startsWith('u') && signed) {
+      throw TypeError("specified type ".concat(opts.type, " yet negative (").concat(value, ")"));
     }
-  }
 
-  /**
-   * Returns Stellar contract ID as a strkey, ex.
-   * `CA3D5KRYM6CB7OWQ6TWYRR3Z4T7GNZLKERYNZGGA5SOAOPIFY6YQGAXE`.
-   * @returns {string}
-   */
-  return contract_createClass(Contract, [{
-    key: "contractId",
-    value: function contractId() {
-      return StrKey.encodeContract(this._id);
+    // If unspecified, we make a best guess at the type based on the bit length
+    // of the value, treating 64 as a minimum and 256 as a maximum.
+    if (type === '') {
+      type = signed ? 'i' : 'u';
+      var bitlen = nearestBigIntSize(value);
+      switch (bitlen) {
+        case 64:
+        case 128:
+        case 256:
+          type += bitlen.toString();
+          break;
+        default:
+          throw RangeError("expected 64/128/256 bits for input (".concat(value, "), got ").concat(bitlen));
+      }
     }
+    return sc_int_callSuper(this, ScInt, [type, value]);
+  }
+  sc_int_inherits(ScInt, _XdrLargeInt);
+  return sc_int_createClass(ScInt);
+}(XdrLargeInt);
+function nearestBigIntSize(bigI) {
+  var _find;
+  // Note: Even though BigInt.toString(2) includes the negative sign for
+  // negative values (???), the following is still accurate, because the
+  // negative sign would be represented by a sign bit.
+  var bitlen = bigI.toString(2).length;
+  return (_find = [64, 128, 256].find(function (len) {
+    return bitlen <= len;
+  })) !== null && _find !== void 0 ? _find : bitlen;
+}
+;// ./src/numbers/index.js
 
-    /** @returns {string} the ID as a strkey (C...) */
-  }, {
-    key: "toString",
-    value: function toString() {
-      return this.contractId();
-    }
 
-    /** @returns {Address} the wrapped address of this contract */
-  }, {
-    key: "address",
-    value: function address() {
-      return Address.contract(this._id);
-    }
 
-    /**
-     * Returns an operation that will invoke this contract call.
-     *
-     * @param {string}        method   name of the method to call
-     * @param {...xdr.ScVal}  params   arguments to pass to the function call
-     *
-     * @returns {xdr.Operation}   an InvokeHostFunctionOp operation to call the
-     *    contract with the given method and parameters
-     *
-     * @see Operation.invokeHostFunction
-     * @see Operation.invokeContractFunction
-     * @see Operation.createCustomContract
-     * @see Operation.createStellarAssetContract
-     * @see Operation.uploadContractWasm
-     */
-  }, {
-    key: "call",
-    value: function call(method) {
-      for (var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
-        params[_key - 1] = arguments[_key];
-      }
-      return Operation.invokeContractFunction({
-        contract: this.address().toString(),
-        "function": method,
-        args: params
-      });
-    }
 
-    /**
-     * Returns the read-only footprint entries necessary for any invocations to
-     * this contract, for convenience when manually adding it to your
-     * transaction's overall footprint or doing bump/restore operations.
-     *
-     * @returns {xdr.LedgerKey} the ledger key for the deployed contract instance
-     */
-  }, {
-    key: "getFootprint",
-    value: function getFootprint() {
-      return src_xdr.LedgerKey.contractData(new src_xdr.LedgerKeyContractData({
-        contract: this.address().toScAddress(),
-        key: src_xdr.ScVal.scvLedgerKeyContractInstance(),
-        durability: src_xdr.ContractDataDurability.persistent()
-      }));
-    }
-  }]);
-}();
-;// ./src/numbers/uint128.js
-function uint128_typeof(o) { "@babel/helpers - typeof"; return uint128_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; }, uint128_typeof(o); }
-function uint128_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function uint128_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, uint128_toPropertyKey(o.key), o); } }
-function uint128_createClass(e, r, t) { return r && uint128_defineProperties(e.prototype, r), t && uint128_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function uint128_toPropertyKey(t) { var i = uint128_toPrimitive(t, "string"); return "symbol" == uint128_typeof(i) ? i : 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(t, e) { if (e && ("object" == uint128_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return uint128_assertThisInitialized(t); }
-function uint128_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-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(t) { return uint128_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, uint128_getPrototypeOf(t); }
-function uint128_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 && uint128_setPrototypeOf(t, e); }
-function uint128_setPrototypeOf(t, e) { return uint128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, uint128_setPrototypeOf(t, e); }
 
-var Uint128 = /*#__PURE__*/function (_LargeInt) {
-  /**
-   * Construct an unsigned 128-bit integer that can be XDR-encoded.
-   *
-   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
-   *     in big-endian format (i.e. earlier elements are higher bits)
-   */
-  function Uint128() {
-    uint128_classCallCheck(this, Uint128);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return uint128_callSuper(this, Uint128, [args]);
-  }
-  uint128_inherits(Uint128, _LargeInt);
-  return uint128_createClass(Uint128, [{
-    key: "unsigned",
-    get: function get() {
-      return true;
-    }
-  }, {
-    key: "size",
-    get: function get() {
-      return 128;
-    }
-  }]);
-}(xdr.LargeInt);
-Uint128.defineIntBoundaries();
-;// ./src/numbers/uint256.js
-function uint256_typeof(o) { "@babel/helpers - typeof"; return uint256_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; }, uint256_typeof(o); }
-function uint256_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function uint256_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, uint256_toPropertyKey(o.key), o); } }
-function uint256_createClass(e, r, t) { return r && uint256_defineProperties(e.prototype, r), t && uint256_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function uint256_toPropertyKey(t) { var i = uint256_toPrimitive(t, "string"); return "symbol" == uint256_typeof(i) ? i : 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(t, e) { if (e && ("object" == uint256_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return uint256_assertThisInitialized(t); }
-function uint256_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-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(t) { return uint256_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, uint256_getPrototypeOf(t); }
-function uint256_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 && uint256_setPrototypeOf(t, e); }
-function uint256_setPrototypeOf(t, e) { return uint256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, uint256_setPrototypeOf(t, e); }
 
-var Uint256 = /*#__PURE__*/function (_LargeInt) {
-  /**
-   * Construct an unsigned 256-bit integer that can be XDR-encoded.
-   *
-   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
-   *     in big-endian format (i.e. earlier elements are higher bits)
-   */
-  function Uint256() {
-    uint256_classCallCheck(this, Uint256);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return uint256_callSuper(this, Uint256, [args]);
-  }
-  uint256_inherits(Uint256, _LargeInt);
-  return uint256_createClass(Uint256, [{
-    key: "unsigned",
-    get: function get() {
-      return true;
-    }
-  }, {
-    key: "size",
-    get: function get() {
-      return 256;
-    }
-  }]);
-}(xdr.LargeInt);
-Uint256.defineIntBoundaries();
-;// ./src/numbers/int128.js
-function int128_typeof(o) { "@babel/helpers - typeof"; return int128_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; }, int128_typeof(o); }
-function int128_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function int128_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, int128_toPropertyKey(o.key), o); } }
-function int128_createClass(e, r, t) { return r && int128_defineProperties(e.prototype, r), t && int128_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function int128_toPropertyKey(t) { var i = int128_toPrimitive(t, "string"); return "symbol" == int128_typeof(i) ? i : 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(t, e) { if (e && ("object" == int128_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return int128_assertThisInitialized(t); }
-function int128_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-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(t) { return int128_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, int128_getPrototypeOf(t); }
-function int128_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 && int128_setPrototypeOf(t, e); }
-function int128_setPrototypeOf(t, e) { return int128_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, int128_setPrototypeOf(t, e); }
 
-var Int128 = /*#__PURE__*/function (_LargeInt) {
-  /**
-   * Construct a signed 128-bit integer that can be XDR-encoded.
-   *
-   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
-   *     in big-endian format (i.e. earlier elements are higher bits)
-   */
-  function Int128() {
-    int128_classCallCheck(this, Int128);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return int128_callSuper(this, Int128, [args]);
-  }
-  int128_inherits(Int128, _LargeInt);
-  return int128_createClass(Int128, [{
-    key: "unsigned",
-    get: function get() {
-      return false;
-    }
-  }, {
-    key: "size",
-    get: function get() {
-      return 128;
-    }
-  }]);
-}(xdr.LargeInt);
-Int128.defineIntBoundaries();
-;// ./src/numbers/int256.js
-function int256_typeof(o) { "@babel/helpers - typeof"; return int256_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; }, int256_typeof(o); }
-function int256_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function int256_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, int256_toPropertyKey(o.key), o); } }
-function int256_createClass(e, r, t) { return r && int256_defineProperties(e.prototype, r), t && int256_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function int256_toPropertyKey(t) { var i = int256_toPrimitive(t, "string"); return "symbol" == int256_typeof(i) ? i : 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(t, e) { if (e && ("object" == int256_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return int256_assertThisInitialized(t); }
-function int256_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-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(t) { return int256_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, int256_getPrototypeOf(t); }
-function int256_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 && int256_setPrototypeOf(t, e); }
-function int256_setPrototypeOf(t, e) { return int256_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, int256_setPrototypeOf(t, e); }
 
-var Int256 = /*#__PURE__*/function (_LargeInt) {
-  /**
-   * Construct a signed 256-bit integer that can be XDR-encoded.
-   *
-   * @param  {Array<number|bigint|string>}  args - one or more slices to encode
-   *     in big-endian format (i.e. earlier elements are higher bits)
-   */
-  function Int256() {
-    int256_classCallCheck(this, Int256);
-    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
-      args[_key] = arguments[_key];
-    }
-    return int256_callSuper(this, Int256, [args]);
+/**
+ * Transforms an opaque {@link xdr.ScVal} into a native bigint, if possible.
+ *
+ * If you then want to use this in the abstractions provided by this module,
+ * you can pass it to the constructor of {@link XdrLargeInt}.
+ *
+ * @example
+ * let scv = contract.call("add", x, y); // assume it returns an xdr.ScVal
+ * let bigi = scValToBigInt(scv);
+ *
+ * new ScInt(bigi);               // if you don't care about types, and
+ * new XdrLargeInt('i128', bigi); // if you do
+ *
+ * @param {xdr.ScVal} scv - the raw XDR value to parse into an integer
+ * @returns {bigint} the native value of this input value
+ *
+ * @throws {TypeError} if the `scv` input value doesn't represent an integer
+ */
+function scValToBigInt(scv) {
+  var scIntType = XdrLargeInt.getType(scv["switch"]().name);
+  switch (scv["switch"]().name) {
+    case 'scvU32':
+    case 'scvI32':
+      return BigInt(scv.value());
+    case 'scvU64':
+    case 'scvI64':
+    case 'scvTimepoint':
+    case 'scvDuration':
+      return new XdrLargeInt(scIntType, scv.value()).toBigInt();
+    case 'scvU128':
+    case 'scvI128':
+      return new XdrLargeInt(scIntType, [scv.value().lo(), scv.value().hi()]).toBigInt();
+    case 'scvU256':
+    case 'scvI256':
+      return new XdrLargeInt(scIntType, [scv.value().loLo(), scv.value().loHi(), scv.value().hiLo(), scv.value().hiHi()]).toBigInt();
+    default:
+      throw TypeError("expected integer type, got ".concat(scv["switch"]()));
   }
-  int256_inherits(Int256, _LargeInt);
-  return int256_createClass(Int256, [{
-    key: "unsigned",
-    get: function get() {
-      return false;
-    }
-  }, {
-    key: "size",
-    get: function get() {
-      return 256;
-    }
-  }]);
-}(xdr.LargeInt);
-Int256.defineIntBoundaries();
-;// ./src/numbers/xdr_large_int.js
-function xdr_large_int_typeof(o) { "@babel/helpers - typeof"; return xdr_large_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; }, xdr_large_int_typeof(o); }
-function xdr_large_int_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-function xdr_large_int_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, xdr_large_int_toPropertyKey(o.key), o); } }
-function xdr_large_int_createClass(e, r, t) { return r && xdr_large_int_defineProperties(e.prototype, r), t && xdr_large_int_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function xdr_large_int_defineProperty(e, r, t) { return (r = xdr_large_int_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function xdr_large_int_toPropertyKey(t) { var i = xdr_large_int_toPrimitive(t, "string"); return "symbol" == xdr_large_int_typeof(i) ? i : 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": [">>"]}] */
-
+}
+;// ./src/scval.js
+/* provided dependency */ var scval_Buffer = __webpack_require__(8287)["Buffer"];
+function scval_slicedToArray(r, e) { return scval_arrayWithHoles(r) || scval_iterableToArrayLimit(r, e) || scval_unsupportedIterableToArray(r, e) || scval_nonIterableRest(); }
+function scval_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function scval_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return scval_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? scval_arrayLikeToArray(r, a) : void 0; } }
+function scval_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function scval_iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
+function scval_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function scval_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 scval_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? scval_ownKeys(Object(t), !0).forEach(function (r) { scval_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : scval_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function scval_defineProperty(e, r, t) { return (r = scval_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function scval_toPropertyKey(t) { var i = scval_toPrimitive(t, "string"); return "symbol" == scval_typeof(i) ? i : i + ""; }
+function scval_toPrimitive(t, r) { if ("object" != scval_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != scval_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+function scval_typeof(o) { "@babel/helpers - typeof"; return scval_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; }, scval_typeof(o); }
 
 
 
@@ -23200,879 +22765,1473 @@ function xdr_large_int_toPrimitive(t, r) { if ("object" != xdr_large_int_typeof(
 
 
 /**
- * A wrapper class to represent large XDR-encodable integers.
+ * Attempts to convert native types into smart contract values
+ * ({@link xdr.ScVal}).
  *
- * This operates at a lower level than {@link ScInt} by forcing you to specify
- * the type / width / size in bits of the integer you're targeting, regardless
- * of the input value(s) you provide.
+ * Provides conversions from smart contract XDR values ({@link xdr.ScVal}) to
+ * native JavaScript types.
  *
- * @param {string}  type - specifies a data type to use to represent the, one
- *    of: 'i64', 'u64', 'i128', 'u128', 'i256', and 'u256' (see
- *    {@link XdrLargeInt.isType})
- * @param {number|bigint|string|Array<number|bigint|string>} values   a list of
- *    integer-like values interpreted in big-endian order
- */
-var XdrLargeInt = /*#__PURE__*/function () {
-  function XdrLargeInt(type, values) {
-    xdr_large_int_classCallCheck(this, XdrLargeInt);
-    /** @type {xdr.LargeInt} */
-    xdr_large_int_defineProperty(this, "int", void 0);
-    // child class of a jsXdr.LargeInt
-    /** @type {string} */
-    xdr_large_int_defineProperty(this, "type", void 0);
-    if (!(values instanceof Array)) {
-      values = [values];
-    }
-
-    // normalize values to one type
-    values = values.map(function (i) {
-      // micro-optimization to no-op on the likeliest input value:
-      if (typeof i === 'bigint') {
-        return i;
-      }
-      if (typeof i.toBigInt === 'function') {
-        return i.toBigInt();
-      }
-      return BigInt(i);
-    });
-    switch (type) {
-      case 'i64':
-        this["int"] = new xdr.Hyper(values);
-        break;
-      case 'i128':
-        this["int"] = new Int128(values);
-        break;
-      case 'i256':
-        this["int"] = new Int256(values);
-        break;
-      case 'u64':
-      case 'timepoint':
-      case 'duration':
-        this["int"] = new xdr.UnsignedHyper(values);
-        break;
-      case 'u128':
-        this["int"] = new Uint128(values);
-        break;
-      case 'u256':
-        this["int"] = new Uint256(values);
-        break;
-      default:
-        throw TypeError("invalid type: ".concat(type));
+ * The conversions are as follows:
+ *
+ *  - xdr.ScVal -> passthrough
+ *  - null/undefined -> scvVoid
+ *  - string -> scvString (a copy is made)
+ *  - UintArray8 -> scvBytes (a copy is made)
+ *  - boolean -> scvBool
+ *
+ *  - number/bigint -> the smallest possible XDR integer type that will fit the
+ *    input value (if you want a specific type, use {@link ScInt})
+ *
+ *  - {@link Address} or {@link Contract} -> scvAddress (for contracts and
+ *    public keys)
+ *
+ *  - Array<T> -> scvVec after attempting to convert each item of type `T` to an
+ *    xdr.ScVal (recursively). note that all values must be the same type!
+ *
+ *  - object -> scvMap after attempting to convert each key and value to an
+ *    xdr.ScVal (recursively). note that there is no restriction on types
+ *    matching anywhere (unlike arrays)
+ *
+ * When passing an integer-like native value, you can also optionally specify a
+ * type which will force a particular interpretation of that value.
+ *
+ * Note that not all type specifications are compatible with all `ScVal`s, e.g.
+ * `toScVal("a string", {type: "i256"})` will throw.
+ *
+ * @param {any} val -       a native (or convertible) input value to wrap
+ * @param {object} [opts] - an optional set of hints around the type of
+ *    conversion you'd like to see
+ * @param {string} [opts.type] - there is different behavior for different input
+ *    types for `val`:
+ *
+ *     - when `val` is an integer-like type (i.e. number|bigint), this will be
+ *       forwarded to {@link ScInt} or forced to be u32/i32.
+ *
+ *     - when `val` is an array type, this is forwarded to the recursion
+ *
+ *     - when `val` is an object type (key-value entries), this should be an
+ *       object in which each key has a pair of types (to represent forced types
+ *       for the key and the value), where `null` (or a missing entry) indicates
+ *       the default interpretation(s) (refer to the examples, below)
+ *
+ *     - when `val` is a string type, this can be 'string' or 'symbol' to force
+ *       a particular interpretation of `val`.
+ *
+ *     - when `val` is a bytes-like type, this can be 'string', 'symbol', or
+ *       'bytes' to force a particular interpretation
+ *
+ *    As a simple example, `nativeToScVal("hello", {type: 'symbol'})` will
+ *    return an `scvSymbol`, whereas without the type it would have been an
+ *    `scvString`.
+ *
+ * @returns {xdr.ScVal} a wrapped, smart, XDR version of the input value
+ * @throws {TypeError} if...
+ *  - there are arrays with more than one type in them
+ *  - there are values that do not have a sensible conversion (e.g. random XDR
+ *    types, custom classes)
+ *  - the type of the input object (or some inner value of said object) cannot
+ *    be determined (via `typeof`)
+ *  - the type you specified (via `opts.type`) is incompatible with the value
+ *    you passed in (`val`), e.g. `nativeToScVal("a string", { type: 'i128' })`,
+ *    though this does not apply for types that ignore `opts` (e.g. addresses).
+ * @see scValToNative
+ *
+ * @example
+ * nativeToScVal(1000);                   // gives ScValType === scvU64
+ * nativeToScVal(1000n);                  // gives ScValType === scvU64
+ * nativeToScVal(1n << 100n);             // gives ScValType === scvU128
+ * nativeToScVal(1000, { type: 'u32' });  // gives ScValType === scvU32
+ * nativeToScVal(1000, { type: 'i125' }); // gives ScValType === scvI256
+ * nativeToScVal("a string");                     // gives ScValType === scvString
+ * nativeToScVal("a string", { type: 'symbol' }); // gives scvSymbol
+ * nativeToScVal(new Uint8Array(5));                      // scvBytes
+ * nativeToScVal(new Uint8Array(5), { type: 'symbol' });  // scvSymbol
+ * nativeToScVal(null); // scvVoid
+ * nativeToScVal(true); // scvBool
+ * nativeToScVal([1, 2, 3]);                    // gives scvVec with each element as scvU64
+ * nativeToScVal([1, 2, 3], { type: 'i128' });  // scvVec<scvI128>
+ * nativeToScVal([1, '2'], { type: ['i128', 'symbol'] });  // scvVec with diff types
+ * nativeToScVal([1, '2', 3], { type: ['i128', 'symbol'] });
+ *    // scvVec with diff types, using the default when omitted
+ * nativeToScVal({ 'hello': 1, 'world': [ true, false ] }, {
+ *   type: {
+ *     'hello': [ 'symbol', 'i128' ],
+ *   }
+ * })
+ * // gives scvMap with entries: [
+ * //     [ scvSymbol, scvI128 ],
+ * //     [ scvString, scvArray<scvBool> ]
+ * // ]
+ *
+ * @example
+ * import {
+ *   nativeToScVal,
+ *   scValToNative,
+ *   ScInt,
+ *   xdr
+ * } from '@stellar/stellar-base';
+ *
+ * let gigaMap = {
+ *   bool: true,
+ *   void: null,
+ *   u32: xdr.ScVal.scvU32(1),
+ *   i32: xdr.ScVal.scvI32(1),
+ *   u64: 1n,
+ *   i64: -1n,
+ *   u128: new ScInt(1).toU128(),
+ *   i128: new ScInt(1).toI128(),
+ *   u256: new ScInt(1).toU256(),
+ *   i256: new ScInt(1).toI256(),
+ *   map: {
+ *     arbitrary: 1n,
+ *     nested: 'values',
+ *     etc: false
+ *   },
+ *   vec: ['same', 'type', 'list'],
+ *   vec: ['diff', 1, 'type', 2, 'list'],
+ * };
+ *
+ * // then, simply:
+ * let scv = nativeToScVal(gigaMap);    // scv.switch() == xdr.ScValType.scvMap()
+ *
+ * // then...
+ * someContract.call("method", scv);
+ *
+ * // Similarly, the inverse should work:
+ * scValToNative(scv) == gigaMap;       // true
+ */
+function nativeToScVal(val) {
+  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  switch (scval_typeof(val)) {
+    case 'object':
+      {
+        var _val$constructor$name, _val$constructor;
+        if (val === null) {
+          return src_xdr.ScVal.scvVoid();
+        }
+        if (val instanceof src_xdr.ScVal) {
+          return val; // should we copy?
+        }
+        if (val instanceof Address) {
+          return val.toScVal();
+        }
+        if (val instanceof Keypair) {
+          return nativeToScVal(val.publicKey(), {
+            type: 'address'
+          });
+        }
+        if (val instanceof Contract) {
+          return val.address().toScVal();
+        }
+        if (val instanceof Uint8Array || scval_Buffer.isBuffer(val)) {
+          var _opts$type;
+          var copy = Uint8Array.from(val);
+          switch ((_opts$type = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type !== void 0 ? _opts$type : 'bytes') {
+            case 'bytes':
+              return src_xdr.ScVal.scvBytes(copy);
+            case 'symbol':
+              return src_xdr.ScVal.scvSymbol(copy);
+            case 'string':
+              return src_xdr.ScVal.scvString(copy);
+            default:
+              throw new TypeError("invalid type (".concat(opts.type, ") specified for bytes-like value"));
+          }
+        }
+        if (Array.isArray(val)) {
+          return src_xdr.ScVal.scvVec(val.map(function (v, idx) {
+            // There may be different type specifications for each element in
+            // the array, so we need to apply those accordingly.
+            if (Array.isArray(opts.type)) {
+              return nativeToScVal(v, // only include a `{ type: ... }` if it's present (safer than
+              // `{type: undefined}`)
+              scval_objectSpread({}, opts.type.length > idx && {
+                type: opts.type[idx]
+              }));
+            }
+
+            // Otherwise apply a generic (or missing) type specifier on it.
+            return nativeToScVal(v, opts);
+          }));
+        }
+        if (((_val$constructor$name = (_val$constructor = val.constructor) === null || _val$constructor === void 0 ? void 0 : _val$constructor.name) !== null && _val$constructor$name !== void 0 ? _val$constructor$name : '') !== 'Object') {
+          var _val$constructor2;
+          throw new TypeError("cannot interpret ".concat((_val$constructor2 = val.constructor) === null || _val$constructor2 === void 0 ? void 0 : _val$constructor2.name, " value as ScVal (").concat(JSON.stringify(val), ")"));
+        }
+        return src_xdr.ScVal.scvMap(Object.entries(val)
+        // The Soroban runtime expects maps to have their keys in sorted
+        // order, so let's do that here as part of the conversion to prevent
+        // confusing error messages on execution.
+        .sort(function (_ref, _ref2) {
+          var _ref3 = scval_slicedToArray(_ref, 1),
+            key1 = _ref3[0];
+          var _ref4 = scval_slicedToArray(_ref2, 1),
+            key2 = _ref4[0];
+          return key1.localeCompare(key2);
+        }).map(function (_ref5) {
+          var _k, _opts$type2;
+          var _ref6 = scval_slicedToArray(_ref5, 2),
+            k = _ref6[0],
+            v = _ref6[1];
+          // the type can be specified with an entry for the key and the value,
+          // e.g. val = { 'hello': 1 } and opts.type = { hello: [ 'symbol',
+          // 'u128' ]} or you can use `null` for the default interpretation
+          var _ref7 = (_k = ((_opts$type2 = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type2 !== void 0 ? _opts$type2 : {})[k]) !== null && _k !== void 0 ? _k : [null, null],
+            _ref8 = scval_slicedToArray(_ref7, 2),
+            keyType = _ref8[0],
+            valType = _ref8[1];
+          var keyOpts = keyType ? {
+            type: keyType
+          } : {};
+          var valOpts = valType ? {
+            type: valType
+          } : {};
+          return new src_xdr.ScMapEntry({
+            key: nativeToScVal(k, keyOpts),
+            val: nativeToScVal(v, valOpts)
+          });
+        }));
+      }
+    case 'number':
+    case 'bigint':
+      switch (opts === null || opts === void 0 ? void 0 : opts.type) {
+        case 'u32':
+          return src_xdr.ScVal.scvU32(val);
+        case 'i32':
+          return src_xdr.ScVal.scvI32(val);
+        default:
+          break;
+      }
+      return new ScInt(val, {
+        type: opts === null || opts === void 0 ? void 0 : opts.type
+      }).toScVal();
+    case 'string':
+      {
+        var _opts$type3;
+        var optType = (_opts$type3 = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type3 !== void 0 ? _opts$type3 : 'string';
+        switch (optType) {
+          case 'string':
+            return src_xdr.ScVal.scvString(val);
+          case 'symbol':
+            return src_xdr.ScVal.scvSymbol(val);
+          case 'address':
+            return new Address(val).toScVal();
+          case 'u32':
+            return src_xdr.ScVal.scvU32(parseInt(val, 10));
+          case 'i32':
+            return src_xdr.ScVal.scvI32(parseInt(val, 10));
+          default:
+            if (XdrLargeInt.isType(optType)) {
+              return new XdrLargeInt(optType, val).toScVal();
+            }
+            throw new TypeError("invalid type (".concat(opts.type, ") specified for string value"));
+        }
+      }
+    case 'boolean':
+      return src_xdr.ScVal.scvBool(val);
+    case 'undefined':
+      return src_xdr.ScVal.scvVoid();
+    case 'function':
+      // FIXME: Is this too helpful?
+      return nativeToScVal(val());
+    default:
+      throw new TypeError("failed to convert typeof ".concat(scval_typeof(val), " (").concat(val, ")"));
+  }
+}
+
+/**
+ * Given a smart contract value, attempt to convert it to a native type.
+ * Possible conversions include:
+ *
+ *  - void -> `null`
+ *  - u32, i32 -> `number`
+ *  - u64, i64, u128, i128, u256, i256, timepoint, duration -> `bigint`
+ *  - vec -> `Array` of any of the above (via recursion)
+ *  - map -> key-value object of any of the above (via recursion)
+ *  - bool -> `boolean`
+ *  - bytes -> `Uint8Array`
+ *  - symbol -> `string`
+ *  - string -> `string` IF the underlying buffer can be decoded as ascii/utf8,
+ *              `Uint8Array` of the raw contents in any error case
+ *
+ * If no viable conversion can be determined, this just "unwraps" the smart
+ * value to return its underlying XDR value.
+ *
+ * @param {xdr.ScVal} scv - the input smart contract value
+ *
+ * @returns {any}
+ * @see nativeToScVal
+ */
+function scValToNative(scv) {
+  var _scv$vec, _scv$map;
+  // we use the verbose xdr.ScValType.<type>.value form here because it's faster
+  // than string comparisons and the underlying constants never need to be
+  // updated
+  switch (scv["switch"]().value) {
+    case src_xdr.ScValType.scvVoid().value:
+      return null;
+
+    // these can be converted to bigints directly
+    case src_xdr.ScValType.scvU64().value:
+    case src_xdr.ScValType.scvI64().value:
+      return scv.value().toBigInt();
+
+    // these can be parsed by internal abstractions note that this can also
+    // handle the above two cases, but it's not as efficient (another
+    // type-check, parsing, etc.)
+    case src_xdr.ScValType.scvU128().value:
+    case src_xdr.ScValType.scvI128().value:
+    case src_xdr.ScValType.scvU256().value:
+    case src_xdr.ScValType.scvI256().value:
+      return scValToBigInt(scv);
+    case src_xdr.ScValType.scvVec().value:
+      return ((_scv$vec = scv.vec()) !== null && _scv$vec !== void 0 ? _scv$vec : []).map(scValToNative);
+    case src_xdr.ScValType.scvAddress().value:
+      return Address.fromScVal(scv).toString();
+    case src_xdr.ScValType.scvMap().value:
+      return Object.fromEntries(((_scv$map = scv.map()) !== null && _scv$map !== void 0 ? _scv$map : []).map(function (entry) {
+        return [scValToNative(entry.key()), scValToNative(entry.val())];
+      }));
+
+    // these return the primitive type directly
+    case src_xdr.ScValType.scvBool().value:
+    case src_xdr.ScValType.scvU32().value:
+    case src_xdr.ScValType.scvI32().value:
+    case src_xdr.ScValType.scvBytes().value:
+      return scv.value();
+
+    // Symbols are limited to [a-zA-Z0-9_]+, so we can safely make ascii strings
+    //
+    // Strings, however, are "presented" as strings and we treat them as such
+    // (in other words, string = bytes with a hint that it's text). If the user
+    // encoded non-printable bytes in their string value, that's on them.
+    //
+    // Note that we assume a utf8 encoding (ascii-compatible). For other
+    // encodings, you should probably use bytes anyway. If it cannot be decoded,
+    // the raw bytes are returned.
+    case src_xdr.ScValType.scvSymbol().value:
+    case src_xdr.ScValType.scvString().value:
+      {
+        var v = scv.value(); // string|Buffer
+        if (scval_Buffer.isBuffer(v) || ArrayBuffer.isView(v)) {
+          try {
+            return new TextDecoder().decode(v);
+          } catch (e) {
+            return new Uint8Array(v.buffer); // copy of bytes
+          }
+        }
+        return v; // string already
+      }
+
+    // these can be converted to bigint
+    case src_xdr.ScValType.scvTimepoint().value:
+    case src_xdr.ScValType.scvDuration().value:
+      return new src_xdr.Uint64(scv.value()).toBigInt();
+    case src_xdr.ScValType.scvError().value:
+      switch (scv.error()["switch"]().value) {
+        // Distinguish errors from the user contract.
+        case src_xdr.ScErrorType.sceContract().value:
+          return {
+            type: 'contract',
+            code: scv.error().contractCode()
+          };
+        default:
+          {
+            var err = scv.error();
+            return {
+              type: 'system',
+              code: err.code().value,
+              value: err.code().name
+            };
+          }
+      }
+
+    // in the fallthrough case, just return the underlying value directly
+    default:
+      return scv.value();
+  }
+}
+
+/// Inject a sortable map builder into the xdr module.
+src_xdr.scvSortedMap = function (items) {
+  var sorted = Array.from(items).sort(function (a, b) {
+    // Both a and b are `ScMapEntry`s, so we need to sort by underlying key.
+    //
+    // We couldn't possibly handle every combination of keys since Soroban
+    // maps don't enforce consistent types, so we do a best-effort and try
+    // sorting by "number-like" or "string-like."
+    var nativeA = scValToNative(a.key());
+    var nativeB = scValToNative(b.key());
+    switch (scval_typeof(nativeA)) {
+      case 'number':
+      case 'bigint':
+        return nativeA < nativeB ? -1 : 1;
+      default:
+        return nativeA.toString().localeCompare(nativeB.toString());
+    }
+  });
+  return src_xdr.ScVal.scvMap(sorted);
+};
+;// ./src/transaction_builder.js
+function transaction_builder_typeof(o) { "@babel/helpers - typeof"; return transaction_builder_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; }, transaction_builder_typeof(o); }
+function _toConsumableArray(r) { return _arrayWithoutHoles(r) || _iterableToArray(r) || transaction_builder_unsupportedIterableToArray(r) || _nonIterableSpread(); }
+function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function transaction_builder_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return transaction_builder_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? transaction_builder_arrayLikeToArray(r, a) : void 0; } }
+function _iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function _arrayWithoutHoles(r) { if (Array.isArray(r)) return transaction_builder_arrayLikeToArray(r); }
+function transaction_builder_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function transaction_builder_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 transaction_builder_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? transaction_builder_ownKeys(Object(t), !0).forEach(function (r) { transaction_builder_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : transaction_builder_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+function transaction_builder_defineProperty(e, r, t) { return (r = transaction_builder_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
+function transaction_builder_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function transaction_builder_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, transaction_builder_toPropertyKey(o.key), o); } }
+function transaction_builder_createClass(e, r, t) { return r && transaction_builder_defineProperties(e.prototype, r), t && transaction_builder_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function transaction_builder_toPropertyKey(t) { var i = transaction_builder_toPrimitive(t, "string"); return "symbol" == transaction_builder_typeof(i) ? i : 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); }
+
+
+
+
+
+
+
+
+
+
+
+
+// eslint-disable-next-line no-unused-vars
+
+
+
+
+
+
+/**
+ * Minimum base fee for transactions. If this fee is below the network
+ * minimum, the transaction will fail. The more operations in the
+ * transaction, the greater the required fee. Use {@link
+ * Server#fetchBaseFee} to get an accurate value of minimum transaction
+ * fee on the network.
+ *
+ * @constant
+ * @see [Fees](https://developers.stellar.org/docs/glossary/fees/)
+ */
+var BASE_FEE = '100'; // Stroops
+
+/**
+ * @constant
+ * @see {@link TransactionBuilder#setTimeout}
+ * @see [Timeout](https://developers.stellar.org/api/resources/transactions/post/)
+ */
+var TimeoutInfinite = 0;
+
+/**
+ * @typedef {object} SorobanFees
+ * @property {number} instructions - the number of instructions executed by the transaction
+ * @property {number} readBytes - the number of bytes read from the ledger by the transaction
+ * @property {number} writeBytes - the number of bytes written to the ledger by the transaction
+ * @property {bigint} resourceFee - the fee to be paid for the transaction, in stroops
+ */
+
+/**
+ * <p>Transaction builder helps constructs a new `{@link Transaction}` using the
+ * given {@link Account} as the transaction's "source account". The transaction
+ * will use the current sequence number of the given account as its sequence
+ * number and increment the given account's sequence number by one. The given
+ * source account must include a private key for signing the transaction or an
+ * error will be thrown.</p>
+ *
+ * <p>Operations can be added to the transaction via their corresponding builder
+ * methods, and each returns the TransactionBuilder object so they can be
+ * chained together. After adding the desired operations, call the `build()`
+ * method on the `TransactionBuilder` to return a fully constructed `{@link
+ * Transaction}` that can be signed. The returned transaction will contain the
+ * sequence number of the source account and include the signature from the
+ * source account.</p>
+ *
+ * <p><strong>Be careful about unsubmitted transactions!</strong> When you build
+ * 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
+ * account's sequence number with
+ * [Server.loadAccount](https://stellar.github.io/js-stellar-sdk/Server.html#loadAccount)
+ * before creating another transaction.</p>
+ *
+ * <p>The following code example creates a new transaction with {@link
+ * Operation.createAccount} and {@link Operation.payment} operations. The
+ * Transaction's source account first funds `destinationA`, then sends a payment
+ * to `destinationB`. The built transaction is then signed by
+ * `sourceKeypair`.</p>
+ *
+ * ```
+ * var transaction = new TransactionBuilder(source, { fee, networkPassphrase: Networks.TESTNET })
+ * .addOperation(Operation.createAccount({
+ *     destination: destinationA,
+ *     startingBalance: "20"
+ * })) // <- funds and creates destinationA
+ * .addOperation(Operation.payment({
+ *     destination: destinationB,
+ *     amount: "100",
+ *     asset: Asset.native()
+ * })) // <- sends 100 XLM to destinationB
+ * .setTimeout(30)
+ * .build();
+ *
+ * transaction.sign(sourceKeypair);
+ * ```
+ *
+ * @constructor
+ *
+ * @param {Account} sourceAccount - source account for this transaction
+ * @param {object}  opts          - Options object
+ * @param {string}  opts.fee      - max fee you're willing to pay per
+ *     operation in this transaction (**in stroops**)
+ *
+ * @param {object}              [opts.timebounds] - timebounds for the
+ *     validity of this transaction
+ * @param {number|string|Date}  [opts.timebounds.minTime] - 64-bit UNIX
+ *     timestamp or Date object
+ * @param {number|string|Date}  [opts.timebounds.maxTime] - 64-bit UNIX
+ *     timestamp or Date object
+ * @param {object}              [opts.ledgerbounds] - ledger bounds for the
+ *     validity of this transaction
+ * @param {number}              [opts.ledgerbounds.minLedger] - number of the minimum
+ *     ledger sequence
+ * @param {number}              [opts.ledgerbounds.maxLedger] - number of the maximum
+ *     ledger sequence
+ * @param {string}              [opts.minAccountSequence] - number for
+ *     the minimum account sequence
+ * @param {number}              [opts.minAccountSequenceAge] - number of
+ *     seconds for the minimum account sequence age
+ * @param {number}              [opts.minAccountSequenceLedgerGap] - number of
+ *     ledgers for the minimum account sequence ledger gap
+ * @param {string[]}            [opts.extraSigners] - list of the extra signers
+ *     required for this transaction
+ * @param {Memo}                [opts.memo] - memo for the transaction
+ * @param {string}              [opts.networkPassphrase] passphrase of the
+ *     target Stellar network (e.g. "Public Global Stellar Network ; September
+ *     2015" for the pubnet)
+ * @param {xdr.SorobanTransactionData | string}  [opts.sorobanData] - an
+ *     optional instance of {@link xdr.SorobanTransactionData} to be set as the
+ *     internal `Transaction.Ext.SorobanData` field (either the xdr object or a
+ *     base64 string). In the case of Soroban transactions, this can be obtained
+ *     from a prior simulation of the transaction with a contract invocation and
+ *     provides necessary resource estimations. You can also use
+ *     {@link SorobanDataBuilder} to construct complicated combinations of
+ *     parameters without mucking with XDR directly. **Note:** For
+ *     non-contract(non-Soroban) transactions, this has no effect.
+ */
+var TransactionBuilder = /*#__PURE__*/function () {
+  function TransactionBuilder(sourceAccount) {
+    var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    transaction_builder_classCallCheck(this, TransactionBuilder);
+    if (!sourceAccount) {
+      throw new Error('must specify source account for the transaction');
     }
-    this.type = type;
+    if (opts.fee === undefined) {
+      throw new Error('must specify fee for the transaction (in stroops)');
+    }
+    this.source = sourceAccount;
+    this.operations = [];
+    this.baseFee = opts.fee;
+    this.timebounds = opts.timebounds ? transaction_builder_objectSpread({}, opts.timebounds) : null;
+    this.ledgerbounds = opts.ledgerbounds ? transaction_builder_objectSpread({}, opts.ledgerbounds) : null;
+    this.minAccountSequence = opts.minAccountSequence || null;
+    this.minAccountSequenceAge = opts.minAccountSequenceAge || null;
+    this.minAccountSequenceLedgerGap = opts.minAccountSequenceLedgerGap || null;
+    this.extraSigners = opts.extraSigners ? _toConsumableArray(opts.extraSigners) : null;
+    this.memo = opts.memo || Memo.none();
+    this.networkPassphrase = opts.networkPassphrase || null;
+    this.sorobanData = opts.sorobanData ? new SorobanDataBuilder(opts.sorobanData).build() : null;
   }
 
   /**
-   * @returns {number}
-   * @throws {RangeError} if the value can't fit into a Number
+   * Creates a builder instance using an existing {@link Transaction} as a
+   * template, ignoring any existing envelope signatures.
+   *
+   * Note that the sequence number WILL be cloned, so EITHER this transaction or
+   * the one it was cloned from will be valid. This is useful in situations
+   * where you are constructing a transaction in pieces and need to make
+   * adjustments as you go (for example, when filling out Soroban resource
+   * information).
+   *
+   * @param {Transaction} tx  a "template" transaction to clone exactly
+   * @param {object} [opts]   additional options to override the clone, e.g.
+   *    {fee: '1000'} will override the existing base fee derived from `tx` (see
+   *    the {@link TransactionBuilder} constructor for detailed options)
+   *
+   * @returns {TransactionBuilder} a "prepared" builder instance with the same
+   *    configuration and operations as the given transaction
+   *
+   * @warning This does not clone the transaction's
+   *    {@link xdr.SorobanTransactionData} (if applicable), use
+   *    {@link SorobanDataBuilder} and {@link TransactionBuilder.setSorobanData}
+   *    as needed, instead..
+   *
+   * @todo This cannot clone {@link FeeBumpTransaction}s, yet.
    */
-  return xdr_large_int_createClass(XdrLargeInt, [{
-    key: "toNumber",
-    value: function toNumber() {
-      var bi = this["int"].toBigInt();
-      if (bi > Number.MAX_SAFE_INTEGER || bi < Number.MIN_SAFE_INTEGER) {
-        throw RangeError("value ".concat(bi, " not in range for Number ") + "[".concat(Number.MAX_SAFE_INTEGER, ", ").concat(Number.MIN_SAFE_INTEGER, "]"));
-      }
-      return Number(bi);
+  return transaction_builder_createClass(TransactionBuilder, [{
+    key: "addOperation",
+    value:
+    /**
+     * Adds an operation to the transaction.
+     *
+     * @param {xdr.Operation} operation   The xdr operation object, use {@link
+     *     Operation} static methods.
+     *
+     * @returns {TransactionBuilder}
+     */
+    function addOperation(operation) {
+      this.operations.push(operation);
+      return this;
     }
 
-    /** @returns {bigint} */
+    /**
+     * Adds an operation to the transaction at a specific index.
+     *
+     * @param {xdr.Operation} operation - The xdr operation object to add, use {@link Operation} static methods.
+     * @param {number} index - The index at which to insert the operation.
+     *
+     * @returns {TransactionBuilder} - The TransactionBuilder instance for method chaining.
+     */
   }, {
-    key: "toBigInt",
-    value: function toBigInt() {
-      return this["int"].toBigInt();
+    key: "addOperationAt",
+    value: function addOperationAt(operation, index) {
+      this.operations.splice(index, 0, operation);
+      return this;
     }
 
-    /** @returns {xdr.ScVal} the integer encoded with `ScValType = I64` */
+    /**
+     * Removes the operations from the builder (useful when cloning).
+     * @returns {TransactionBuilder} this builder instance
+     */
   }, {
-    key: "toI64",
-    value: function toI64() {
-      this._sizeCheck(64);
-      var v = this.toBigInt();
-      if (BigInt.asIntN(64, v) !== v) {
-        throw RangeError("value too large for i64: ".concat(v));
-      }
-      return src_xdr.ScVal.scvI64(new src_xdr.Int64(v));
+    key: "clearOperations",
+    value: function clearOperations() {
+      this.operations = [];
+      return this;
     }
 
-    /** @returns {xdr.ScVal} the integer encoded with `ScValType = U64` */
+    /**
+     * Removes the operation at the specified index from the transaction.
+     *
+     * @param {number} index - The index of the operation to remove.
+     *
+     * @returns {TransactionBuilder} The TransactionBuilder instance for method chaining.
+     */
   }, {
-    key: "toU64",
-    value: function toU64() {
-      this._sizeCheck(64);
-      return src_xdr.ScVal.scvU64(new src_xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
-      );
+    key: "clearOperationAt",
+    value: function clearOperationAt(index) {
+      this.operations.splice(index, 1);
+      return this;
     }
 
-    /** @returns {xdr.ScVal} the integer encoded with `ScValType = Timepoint` */
+    /**
+     * Adds a memo to the transaction.
+     * @param {Memo} memo {@link Memo} object
+     * @returns {TransactionBuilder}
+     */
   }, {
-    key: "toTimepoint",
-    value: function toTimepoint() {
-      this._sizeCheck(64);
-      return src_xdr.ScVal.scvTimepoint(new src_xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
-      );
+    key: "addMemo",
+    value: function addMemo(memo) {
+      this.memo = memo;
+      return this;
     }
 
-    /** @returns {xdr.ScVal} the integer encoded with `ScValType = Duration` */
+    /**
+     * Sets a timeout precondition on the transaction.
+     *
+     *  Because of the distributed nature of the Stellar network it is possible
+     *  that the status of your transaction will be determined after a long time
+     *  if the network is highly congested. If you want to be sure to receive the
+     *  status of the transaction within a given period you should set the {@link
+     *  TimeBounds} with `maxTime` on the transaction (this is what `setTimeout`
+     *  does internally; if there's `minTime` set but no `maxTime` it will be
+     *  added).
+     *
+     *  A call to `TransactionBuilder.setTimeout` is **required** if Transaction
+     *  does not have `max_time` set. If you don't want to set timeout, use
+     *  `{@link TimeoutInfinite}`. In general you should set `{@link
+     *  TimeoutInfinite}` only in smart contracts.
+     *
+     *  Please note that Horizon may still return <code>504 Gateway Timeout</code>
+     *  error, even for short timeouts. In such case you need to resubmit the same
+     *  transaction again without making any changes to receive a status. This
+     *  method is using the machine system time (UTC), make sure it is set
+     *  correctly.
+     *
+     * @param {number} timeoutSeconds   Number of seconds the transaction is good.
+     *     Can't be negative. If the value is {@link TimeoutInfinite}, the
+     *     transaction is good indefinitely.
+     *
+     * @returns {TransactionBuilder}
+     *
+     * @see {@link TimeoutInfinite}
+     * @see https://developers.stellar.org/docs/tutorials/handling-errors/
+     */
   }, {
-    key: "toDuration",
-    value: function toDuration() {
-      this._sizeCheck(64);
-      return src_xdr.ScVal.scvDuration(new src_xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
-      );
+    key: "setTimeout",
+    value: function setTimeout(timeoutSeconds) {
+      if (this.timebounds !== null && this.timebounds.maxTime > 0) {
+        throw new Error('TimeBounds.max_time has been already set - setting timeout would overwrite it.');
+      }
+      if (timeoutSeconds < 0) {
+        throw new Error('timeout cannot be negative');
+      }
+      if (timeoutSeconds > 0) {
+        var timeoutTimestamp = Math.floor(Date.now() / 1000) + timeoutSeconds;
+        if (this.timebounds === null) {
+          this.timebounds = {
+            minTime: 0,
+            maxTime: timeoutTimestamp
+          };
+        } else {
+          this.timebounds = {
+            minTime: this.timebounds.minTime,
+            maxTime: timeoutTimestamp
+          };
+        }
+      } else {
+        this.timebounds = {
+          minTime: 0,
+          maxTime: 0
+        };
+      }
+      return this;
     }
 
     /**
-     * @returns {xdr.ScVal} the integer encoded with `ScValType = I128`
-     * @throws {RangeError} if the value cannot fit in 128 bits
+     * If you want to prepare a transaction which will become valid at some point
+     * in the future, or be invalid after some time, you can set a timebounds
+     * precondition. Internally this will set the `minTime`, and `maxTime`
+     * preconditions. Conflicts with `setTimeout`, so use one or the other.
+     *
+     * @param {Date|number} minEpochOrDate  Either a JS Date object, or a number
+     *     of UNIX epoch seconds. The transaction is valid after this timestamp.
+     *     Can't be negative. If the value is `0`, the transaction is valid
+     *     immediately.
+     * @param {Date|number} maxEpochOrDate  Either a JS Date object, or a number
+     *     of UNIX epoch seconds. The transaction is valid until this timestamp.
+     *     Can't be negative. If the value is `0`, the transaction is valid
+     *     indefinitely.
+     *
+     * @returns {TransactionBuilder}
      */
   }, {
-    key: "toI128",
-    value: function toI128() {
-      this._sizeCheck(128);
-      var v = this["int"].toBigInt();
-      var hi64 = BigInt.asIntN(64, v >> 64n); // encode top 64 w/ sign bit
-      var lo64 = BigInt.asUintN(64, v); // grab btm 64, encode sign
+    key: "setTimebounds",
+    value: function setTimebounds(minEpochOrDate, maxEpochOrDate) {
+      // Force it to a date type
+      if (typeof minEpochOrDate === 'number') {
+        minEpochOrDate = new Date(minEpochOrDate * 1000);
+      }
+      if (typeof maxEpochOrDate === 'number') {
+        maxEpochOrDate = new Date(maxEpochOrDate * 1000);
+      }
+      if (this.timebounds !== null) {
+        throw new Error('TimeBounds has been already set - setting timebounds would overwrite it.');
+      }
 
-      return src_xdr.ScVal.scvI128(new src_xdr.Int128Parts({
-        hi: new src_xdr.Int64(hi64),
-        lo: new src_xdr.Uint64(lo64)
-      }));
+      // Convert that date to the epoch seconds
+      var minTime = Math.floor(minEpochOrDate.valueOf() / 1000);
+      var maxTime = Math.floor(maxEpochOrDate.valueOf() / 1000);
+      if (minTime < 0) {
+        throw new Error('min_time cannot be negative');
+      }
+      if (maxTime < 0) {
+        throw new Error('max_time cannot be negative');
+      }
+      if (maxTime > 0 && minTime > maxTime) {
+        throw new Error('min_time cannot be greater than max_time');
+      }
+      this.timebounds = {
+        minTime: minTime,
+        maxTime: maxTime
+      };
+      return this;
     }
 
     /**
-     * @returns {xdr.ScVal} the integer encoded with `ScValType = U128`
-     * @throws {RangeError} if the value cannot fit in 128 bits
+     * If you want to prepare a transaction which will only be valid within some
+     * range of ledgers, you can set a ledgerbounds precondition.
+     * Internally this will set the `minLedger` and `maxLedger` preconditions.
+     *
+     * @param {number} minLedger  The minimum ledger this transaction is valid at
+     *     or after. Cannot be negative. If the value is `0` (the default), the
+     *     transaction is valid immediately.
+     *
+     * @param {number} maxLedger  The maximum ledger this transaction is valid
+     *     before. Cannot be negative. If the value is `0`, the transaction is
+     *     valid indefinitely.
+     *
+     * @returns {TransactionBuilder}
      */
   }, {
-    key: "toU128",
-    value: function toU128() {
-      this._sizeCheck(128);
-      var v = this["int"].toBigInt();
-      return src_xdr.ScVal.scvU128(new src_xdr.UInt128Parts({
-        hi: new src_xdr.Uint64(BigInt.asUintN(64, v >> 64n)),
-        lo: new src_xdr.Uint64(BigInt.asUintN(64, v))
-      }));
-    }
-
-    /** @returns {xdr.ScVal} the integer encoded with `ScValType = I256` */
-  }, {
-    key: "toI256",
-    value: function toI256() {
-      var v = this["int"].toBigInt();
-      var hiHi64 = BigInt.asIntN(64, v >> 192n); // keep sign bit
-      var hiLo64 = BigInt.asUintN(64, v >> 128n);
-      var loHi64 = BigInt.asUintN(64, v >> 64n);
-      var loLo64 = BigInt.asUintN(64, v);
-      return src_xdr.ScVal.scvI256(new src_xdr.Int256Parts({
-        hiHi: new src_xdr.Int64(hiHi64),
-        hiLo: new src_xdr.Uint64(hiLo64),
-        loHi: new src_xdr.Uint64(loHi64),
-        loLo: new src_xdr.Uint64(loLo64)
-      }));
+    key: "setLedgerbounds",
+    value: function setLedgerbounds(minLedger, maxLedger) {
+      if (this.ledgerbounds !== null) {
+        throw new Error('LedgerBounds has been already set - setting ledgerbounds would overwrite it.');
+      }
+      if (minLedger < 0) {
+        throw new Error('min_ledger cannot be negative');
+      }
+      if (maxLedger < 0) {
+        throw new Error('max_ledger cannot be negative');
+      }
+      if (maxLedger > 0 && minLedger > maxLedger) {
+        throw new Error('min_ledger cannot be greater than max_ledger');
+      }
+      this.ledgerbounds = {
+        minLedger: minLedger,
+        maxLedger: maxLedger
+      };
+      return this;
     }
 
-    /** @returns {xdr.ScVal} the integer encoded with `ScValType = U256` */
+    /**
+     * If you want to prepare a transaction which will be valid only while the
+     * account sequence number is
+     *
+     *     minAccountSequence <= sourceAccountSequence < tx.seqNum
+     *
+     * Note that after execution the account's sequence number is always raised to
+     * `tx.seqNum`. Internally this will set the `minAccountSequence`
+     * precondition.
+     *
+     * @param {string} minAccountSequence   The minimum source account sequence
+     *     number this transaction is valid for. If the value is `0` (the
+     *     default), the transaction is valid when `sourceAccount's sequence
+     *     number == tx.seqNum- 1`.
+     *
+     * @returns {TransactionBuilder}
+     */
   }, {
-    key: "toU256",
-    value: function toU256() {
-      var v = this["int"].toBigInt();
-      var hiHi64 = BigInt.asUintN(64, v >> 192n); // encode sign bit
-      var hiLo64 = BigInt.asUintN(64, v >> 128n);
-      var loHi64 = BigInt.asUintN(64, v >> 64n);
-      var loLo64 = BigInt.asUintN(64, v);
-      return src_xdr.ScVal.scvU256(new src_xdr.UInt256Parts({
-        hiHi: new src_xdr.Uint64(hiHi64),
-        hiLo: new src_xdr.Uint64(hiLo64),
-        loHi: new src_xdr.Uint64(loHi64),
-        loLo: new src_xdr.Uint64(loLo64)
-      }));
+    key: "setMinAccountSequence",
+    value: function setMinAccountSequence(minAccountSequence) {
+      if (this.minAccountSequence !== null) {
+        throw new Error('min_account_sequence has been already set - setting min_account_sequence would overwrite it.');
+      }
+      this.minAccountSequence = minAccountSequence;
+      return this;
     }
 
-    /** @returns {xdr.ScVal} the smallest interpretation of the stored value */
+    /**
+     * For the transaction to be valid, the current ledger time must be at least
+     * `minAccountSequenceAge` greater than sourceAccount's `sequenceTime`.
+     * Internally this will set the `minAccountSequenceAge` precondition.
+     *
+     * @param {number} durationInSeconds  The minimum amount of time between
+     *     source account sequence time and the ledger time when this transaction
+     *     will become valid. If the value is `0`, the transaction is unrestricted
+     *     by the account sequence age. Cannot be negative.
+     *
+     * @returns {TransactionBuilder}
+     */
   }, {
-    key: "toScVal",
-    value: function toScVal() {
-      switch (this.type) {
-        case 'i64':
-          return this.toI64();
-        case 'i128':
-          return this.toI128();
-        case 'i256':
-          return this.toI256();
-        case 'u64':
-          return this.toU64();
-        case 'u128':
-          return this.toU128();
-        case 'u256':
-          return this.toU256();
-        case 'timepoint':
-          return this.toTimepoint();
-        case 'duration':
-          return this.toDuration();
-        default:
-          throw TypeError("invalid type: ".concat(this.type));
+    key: "setMinAccountSequenceAge",
+    value: function setMinAccountSequenceAge(durationInSeconds) {
+      if (typeof durationInSeconds !== 'number') {
+        throw new Error('min_account_sequence_age must be a number');
       }
-    }
-  }, {
-    key: "valueOf",
-    value: function valueOf() {
-      return this["int"].valueOf();
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      return this["int"].toString();
-    }
-  }, {
-    key: "toJSON",
-    value: function toJSON() {
-      return {
-        value: this.toBigInt().toString(),
-        type: this.type
-      };
-    }
-  }, {
-    key: "_sizeCheck",
-    value: function _sizeCheck(bits) {
-      if (this["int"].size > bits) {
-        throw RangeError("value too large for ".concat(bits, " bits (").concat(this.type, ")"));
+      if (this.minAccountSequenceAge !== null) {
+        throw new Error('min_account_sequence_age has been already set - setting min_account_sequence_age would overwrite it.');
       }
-    }
-  }], [{
-    key: "isType",
-    value: function isType(type) {
-      switch (type) {
-        case 'i64':
-        case 'i128':
-        case 'i256':
-        case 'u64':
-        case 'u128':
-        case 'u256':
-        case 'timepoint':
-        case 'duration':
-          return true;
-        default:
-          return false;
+      if (durationInSeconds < 0) {
+        throw new Error('min_account_sequence_age cannot be negative');
       }
+      this.minAccountSequenceAge = durationInSeconds;
+      return this;
     }
 
     /**
-     * Convert the raw `ScValType` string (e.g. 'scvI128', generated by the XDR)
-     * to a type description for {@link XdrLargeInt} construction (e.g. 'i128')
+     * For the transaction to be valid, the current ledger number must be at least
+     * `minAccountSequenceLedgerGap` greater than sourceAccount's ledger sequence.
+     * Internally this will set the `minAccountSequenceLedgerGap` precondition.
      *
-     * @param {string} scvType  the `xdr.ScValType` as a string
-     * @returns {string} a suitable equivalent type to construct this object
+     * @param {number} gap  The minimum number of ledgers between source account
+     *     sequence and the ledger number when this transaction will become valid.
+     *     If the value is `0`, the transaction is unrestricted by the account
+     *     sequence ledger. Cannot be negative.
+     *
+     * @returns {TransactionBuilder}
      */
   }, {
-    key: "getType",
-    value: function getType(scvType) {
-      return scvType.slice(3).toLowerCase();
-    }
-  }]);
-}();
-;// ./src/numbers/sc_int.js
-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(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, sc_int_toPropertyKey(o.key), o); } }
-function sc_int_createClass(e, r, t) { return r && sc_int_defineProperties(e.prototype, r), t && sc_int_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
-function sc_int_toPropertyKey(t) { var i = sc_int_toPrimitive(t, "string"); return "symbol" == sc_int_typeof(i) ? i : 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(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
-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(t, e) { if (e && ("object" == sc_int_typeof(e) || "function" == typeof e)) return e; if (void 0 !== e) throw new TypeError("Derived constructors may only return object or undefined"); return sc_int_assertThisInitialized(t); }
-function sc_int_assertThisInitialized(e) { if (void 0 === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); return e; }
-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(t) { return sc_int_getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function (t) { return t.__proto__ || Object.getPrototypeOf(t); }, sc_int_getPrototypeOf(t); }
-function sc_int_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 && sc_int_setPrototypeOf(t, e); }
-function sc_int_setPrototypeOf(t, e) { return sc_int_setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) { return t.__proto__ = e, t; }, sc_int_setPrototypeOf(t, e); }
-
-
-/**
- * Provides an easier way to manipulate large numbers for Stellar operations.
- *
- * 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
- * value), you can use the lower level abstraction {@link XdrLargeInt}. For
- * example, you could do `new XdrLargeInt('u128', bytes...).toBigInt()`.
- *
- * @example
- * 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 = scValToBigInt(value); // grab it as a BigInt
- * let sci = new ScInt(bigi);
- *
- * sci.toNumber(); // gives native JS type (w/ size check)
- * sci.toBigInt(); // gives the native BigInt value
- * sci.toU64();    // gives ScValType-specific XDR constructs (with size checks)
- *
- * // You have a number and want to shove it into a contract.
- * sci = ScInt(0xdeadcafebabe);
- * sci.toBigInt() // returns 244838016400062n
- * sci.toNumber() // throws: too large
- *
- * // Pass any to e.g. a Contract.call(), conversion happens automatically
- * // regardless of the initial type.
- * const scValU128 = sci.toU128();
- * const scValI256 = sci.toI256();
- * const scValU64  = sci.toU64();
- *
- * // Lots of ways to initialize:
- * ScInt("123456789123456789")
- * ScInt(123456789123456789n);
- * ScInt(1n << 140n);
- * ScInt(-42);
- * 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
- * // interpreted from the numbers you pass in):
- * const i = ScInt(123456789n, { type: "u256" });
- *
- * // For example, you can use the underlying `sdk.U256` and convert it to an
- * // `xdr.ScVal` directly like so:
- * const scv = new xdr.ScVal.scvU256(i.raw);
- *
- * // Or reinterpret it as a different type (size permitting):
- * const scv = i.toI64();
- *
- * @param {number|bigint|string} value - a single, integer-like value which will
- *    be interpreted in the smallest appropriate XDR type supported by Stellar
- *    (64, 128, or 256 bit integer values). signed values are supported, though
- *    they are sanity-checked against `opts.type`. if you need 32-bit values,
- *    you can construct them directly without needing this wrapper, e.g.
- *    `xdr.ScVal.scvU32(1234)`.
- *
- * @param {object}  [opts] - an optional object controlling optional parameters
- * @param {string}  [opts.type] - force a specific data type. the type choices
- *    are: 'i64', 'u64', 'i128', 'u128', 'i256', and 'u256' (default: the
- *    smallest one that fits the `value`)
- *
- * @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) {
-  function ScInt(value, opts) {
-    var _opts$type;
-    sc_int_classCallCheck(this, ScInt);
-    var signed = value < 0;
-    var type = (_opts$type = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type !== void 0 ? _opts$type : '';
-    if (type.startsWith('u') && signed) {
-      throw TypeError("specified type ".concat(opts.type, " yet negative (").concat(value, ")"));
+    key: "setMinAccountSequenceLedgerGap",
+    value: function setMinAccountSequenceLedgerGap(gap) {
+      if (this.minAccountSequenceLedgerGap !== null) {
+        throw new Error('min_account_sequence_ledger_gap has been already set - setting min_account_sequence_ledger_gap would overwrite it.');
+      }
+      if (gap < 0) {
+        throw new Error('min_account_sequence_ledger_gap cannot be negative');
+      }
+      this.minAccountSequenceLedgerGap = gap;
+      return this;
     }
 
-    // If unspecified, we make a best guess at the type based on the bit length
-    // of the value, treating 64 as a minimum and 256 as a maximum.
-    if (type === '') {
-      type = signed ? 'i' : 'u';
-      var bitlen = nearestBigIntSize(value);
-      switch (bitlen) {
-        case 64:
-        case 128:
-        case 256:
-          type += bitlen.toString();
-          break;
-        default:
-          throw RangeError("expected 64/128/256 bits for input (".concat(value, "), got ").concat(bitlen));
+    /**
+     * For the transaction to be valid, there must be a signature corresponding to
+     * every Signer in this array, even if the signature is not otherwise required
+     * by the sourceAccount or operations. Internally this will set the
+     * `extraSigners` precondition.
+     *
+     * @param {string[]} extraSigners   required extra signers (as {@link StrKey}s)
+     *
+     * @returns {TransactionBuilder}
+     */
+  }, {
+    key: "setExtraSigners",
+    value: function setExtraSigners(extraSigners) {
+      if (!Array.isArray(extraSigners)) {
+        throw new Error('extra_signers must be an array of strings.');
+      }
+      if (this.extraSigners !== null) {
+        throw new Error('extra_signers has been already set - setting extra_signers would overwrite it.');
+      }
+      if (extraSigners.length > 2) {
+        throw new Error('extra_signers cannot be longer than 2 elements.');
       }
+      this.extraSigners = _toConsumableArray(extraSigners);
+      return this;
     }
-    return sc_int_callSuper(this, ScInt, [type, value]);
-  }
-  sc_int_inherits(ScInt, _XdrLargeInt);
-  return sc_int_createClass(ScInt);
-}(XdrLargeInt);
-function nearestBigIntSize(bigI) {
-  var _find;
-  // Note: Even though BigInt.toString(2) includes the negative sign for
-  // negative values (???), the following is still accurate, because the
-  // negative sign would be represented by a sign bit.
-  var bitlen = bigI.toString(2).length;
-  return (_find = [64, 128, 256].find(function (len) {
-    return bitlen <= len;
-  })) !== null && _find !== void 0 ? _find : bitlen;
-}
-;// ./src/numbers/index.js
-
-
-
-
-
-
-
-
-/**
- * Transforms an opaque {@link xdr.ScVal} into a native bigint, if possible.
- *
- * If you then want to use this in the abstractions provided by this module,
- * you can pass it to the constructor of {@link XdrLargeInt}.
- *
- * @example
- * let scv = contract.call("add", x, y); // assume it returns an xdr.ScVal
- * let bigi = scValToBigInt(scv);
- *
- * new ScInt(bigi);               // if you don't care about types, and
- * new XdrLargeInt('i128', bigi); // if you do
- *
- * @param {xdr.ScVal} scv - the raw XDR value to parse into an integer
- * @returns {bigint} the native value of this input value
- *
- * @throws {TypeError} if the `scv` input value doesn't represent an integer
- */
-function scValToBigInt(scv) {
-  var scIntType = XdrLargeInt.getType(scv["switch"]().name);
-  switch (scv["switch"]().name) {
-    case 'scvU32':
-    case 'scvI32':
-      return BigInt(scv.value());
-    case 'scvU64':
-    case 'scvI64':
-    case 'scvTimepoint':
-    case 'scvDuration':
-      return new XdrLargeInt(scIntType, scv.value()).toBigInt();
-    case 'scvU128':
-    case 'scvI128':
-      return new XdrLargeInt(scIntType, [scv.value().lo(), scv.value().hi()]).toBigInt();
-    case 'scvU256':
-    case 'scvI256':
-      return new XdrLargeInt(scIntType, [scv.value().loLo(), scv.value().loHi(), scv.value().hiLo(), scv.value().hiHi()]).toBigInt();
-    default:
-      throw TypeError("expected integer type, got ".concat(scv["switch"]()));
-  }
-}
-;// ./src/scval.js
-/* provided dependency */ var scval_Buffer = __webpack_require__(8287)["Buffer"];
-function scval_slicedToArray(r, e) { return scval_arrayWithHoles(r) || scval_iterableToArrayLimit(r, e) || scval_unsupportedIterableToArray(r, e) || scval_nonIterableRest(); }
-function scval_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
-function scval_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return scval_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? scval_arrayLikeToArray(r, a) : void 0; } }
-function scval_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
-function scval_iterableToArrayLimit(r, l) { var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (null != t) { var e, n, i, u, a = [], f = !0, o = !1; try { if (i = (t = t.call(r)).next, 0 === l) { if (Object(t) !== t) return; f = !1; } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0); } catch (r) { o = !0, n = r; } finally { try { if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return; } finally { if (o) throw n; } } return a; } }
-function scval_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
-function scval_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 scval_objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? scval_ownKeys(Object(t), !0).forEach(function (r) { scval_defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : scval_ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-function scval_defineProperty(e, r, t) { return (r = scval_toPropertyKey(r)) in e ? Object.defineProperty(e, r, { value: t, enumerable: !0, configurable: !0, writable: !0 }) : e[r] = t, e; }
-function scval_toPropertyKey(t) { var i = scval_toPrimitive(t, "string"); return "symbol" == scval_typeof(i) ? i : i + ""; }
-function scval_toPrimitive(t, r) { if ("object" != scval_typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != scval_typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
-function scval_typeof(o) { "@babel/helpers - typeof"; return scval_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; }, scval_typeof(o); }
-
-
-
 
+    /**
+     * Set network nassphrase for the Transaction that will be built.
+     *
+     * @param {string} networkPassphrase    passphrase of the target Stellar
+     *     network (e.g. "Public Global Stellar Network ; September 2015").
+     *
+     * @returns {TransactionBuilder}
+     */
+  }, {
+    key: "setNetworkPassphrase",
+    value: function setNetworkPassphrase(networkPassphrase) {
+      this.networkPassphrase = networkPassphrase;
+      return this;
+    }
 
+    /**
+     * Sets the transaction's internal Soroban transaction data (resources,
+     * footprint, etc.).
+     *
+     * For non-contract(non-Soroban) transactions, this setting has no effect. In
+     * the case of Soroban transactions, this is either an instance of
+     * {@link xdr.SorobanTransactionData} or a base64-encoded string of said
+     * structure. This is usually obtained from the simulation response based on a
+     * transaction with a Soroban operation (e.g.
+     * {@link Operation.invokeHostFunction}, providing necessary resource
+     * and storage footprint estimations for contract invocation.
+     *
+     * @param {xdr.SorobanTransactionData | string} sorobanData    the
+     *    {@link xdr.SorobanTransactionData} as a raw xdr object or a base64
+     *    string to be decoded
+     *
+     * @returns {TransactionBuilder}
+     * @see {SorobanDataBuilder}
+     */
+  }, {
+    key: "setSorobanData",
+    value: function setSorobanData(sorobanData) {
+      this.sorobanData = new SorobanDataBuilder(sorobanData).build();
+      return this;
+    }
 
-/**
- * Attempts to convert native types into smart contract values
- * ({@link xdr.ScVal}).
- *
- * Provides conversions from smart contract XDR values ({@link xdr.ScVal}) to
- * native JavaScript types.
- *
- * The conversions are as follows:
- *
- *  - xdr.ScVal -> passthrough
- *  - null/undefined -> scvVoid
- *  - string -> scvString (a copy is made)
- *  - UintArray8 -> scvBytes (a copy is made)
- *  - boolean -> scvBool
- *
- *  - number/bigint -> the smallest possible XDR integer type that will fit the
- *    input value (if you want a specific type, use {@link ScInt})
- *
- *  - {@link Address} or {@link Contract} -> scvAddress (for contracts and
- *    public keys)
- *
- *  - Array<T> -> scvVec after attempting to convert each item of type `T` to an
- *    xdr.ScVal (recursively). note that all values must be the same type!
- *
- *  - object -> scvMap after attempting to convert each key and value to an
- *    xdr.ScVal (recursively). note that there is no restriction on types
- *    matching anywhere (unlike arrays)
- *
- * When passing an integer-like native value, you can also optionally specify a
- * type which will force a particular interpretation of that value.
- *
- * Note that not all type specifications are compatible with all `ScVal`s, e.g.
- * `toScVal("a string", {type: "i256"})` will throw.
- *
- * @param {any} val -       a native (or convertible) input value to wrap
- * @param {object} [opts] - an optional set of hints around the type of
- *    conversion you'd like to see
- * @param {string} [opts.type] - there is different behavior for different input
- *    types for `val`:
- *
- *     - when `val` is an integer-like type (i.e. number|bigint), this will be
- *       forwarded to {@link ScInt} or forced to be u32/i32.
- *
- *     - when `val` is an array type, this is forwarded to the recursion
- *
- *     - when `val` is an object type (key-value entries), this should be an
- *       object in which each key has a pair of types (to represent forced types
- *       for the key and the value), where `null` (or a missing entry) indicates
- *       the default interpretation(s) (refer to the examples, below)
- *
- *     - when `val` is a string type, this can be 'string' or 'symbol' to force
- *       a particular interpretation of `val`.
- *
- *     - when `val` is a bytes-like type, this can be 'string', 'symbol', or
- *       'bytes' to force a particular interpretation
- *
- *    As a simple example, `nativeToScVal("hello", {type: 'symbol'})` will
- *    return an `scvSymbol`, whereas without the type it would have been an
- *    `scvString`.
- *
- * @returns {xdr.ScVal} a wrapped, smart, XDR version of the input value
- * @throws {TypeError} if...
- *  - there are arrays with more than one type in them
- *  - there are values that do not have a sensible conversion (e.g. random XDR
- *    types, custom classes)
- *  - the type of the input object (or some inner value of said object) cannot
- *    be determined (via `typeof`)
- *  - the type you specified (via `opts.type`) is incompatible with the value
- *    you passed in (`val`), e.g. `nativeToScVal("a string", { type: 'i128' })`,
- *    though this does not apply for types that ignore `opts` (e.g. addresses).
- * @see scValToNative
- *
- * @example
- * nativeToScVal(1000);                   // gives ScValType === scvU64
- * nativeToScVal(1000n);                  // gives ScValType === scvU64
- * nativeToScVal(1n << 100n);             // gives ScValType === scvU128
- * nativeToScVal(1000, { type: 'u32' });  // gives ScValType === scvU32
- * nativeToScVal(1000, { type: 'i125' }); // gives ScValType === scvI256
- * nativeToScVal("a string");                     // gives ScValType === scvString
- * nativeToScVal("a string", { type: 'symbol' }); // gives scvSymbol
- * nativeToScVal(new Uint8Array(5));                      // scvBytes
- * nativeToScVal(new Uint8Array(5), { type: 'symbol' });  // scvSymbol
- * nativeToScVal(null); // scvVoid
- * nativeToScVal(true); // scvBool
- * nativeToScVal([1, 2, 3]);                    // gives scvVec with each element as scvU64
- * nativeToScVal([1, 2, 3], { type: 'i128' });  // scvVec<scvI128>
- * nativeToScVal([1, '2'], { type: ['i128', 'symbol'] });  // scvVec with diff types
- * nativeToScVal([1, '2', 3], { type: ['i128', 'symbol'] });
- *    // scvVec with diff types, using the default when omitted
- * nativeToScVal({ 'hello': 1, 'world': [ true, false ] }, {
- *   type: {
- *     'hello': [ 'symbol', 'i128' ],
- *   }
- * })
- * // gives scvMap with entries: [
- * //     [ scvSymbol, scvI128 ],
- * //     [ scvString, scvArray<scvBool> ]
- * // ]
- *
- * @example
- * import {
- *   nativeToScVal,
- *   scValToNative,
- *   ScInt,
- *   xdr
- * } from '@stellar/stellar-base';
- *
- * let gigaMap = {
- *   bool: true,
- *   void: null,
- *   u32: xdr.ScVal.scvU32(1),
- *   i32: xdr.ScVal.scvI32(1),
- *   u64: 1n,
- *   i64: -1n,
- *   u128: new ScInt(1).toU128(),
- *   i128: new ScInt(1).toI128(),
- *   u256: new ScInt(1).toU256(),
- *   i256: new ScInt(1).toI256(),
- *   map: {
- *     arbitrary: 1n,
- *     nested: 'values',
- *     etc: false
- *   },
- *   vec: ['same', 'type', 'list'],
- *   vec: ['diff', 1, 'type', 2, 'list'],
- * };
- *
- * // then, simply:
- * let scv = nativeToScVal(gigaMap);    // scv.switch() == xdr.ScValType.scvMap()
- *
- * // then...
- * someContract.call("method", scv);
- *
- * // Similarly, the inverse should work:
- * scValToNative(scv) == gigaMap;       // true
- */
-function nativeToScVal(val) {
-  var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  switch (scval_typeof(val)) {
-    case 'object':
-      {
-        var _val$constructor$name, _val$constructor;
-        if (val === null) {
-          return src_xdr.ScVal.scvVoid();
-        }
-        if (val instanceof src_xdr.ScVal) {
-          return val; // should we copy?
+    /**
+     * Creates and adds an invoke host function operation for transferring SAC tokens.
+     * This method removes the need for simulation by handling the creation of the
+     * appropriate authorization entries and ledger footprint for the transfer operation.
+     *
+     * @param {string} destination - the address of the recipient of the SAC transfer (should be a valid Stellar address or contract ID)
+     * @param {Asset} asset - the SAC asset to be transferred
+     * @param  {BigInt} amount - the amount of tokens to be transferred in 7 decimals. IE 1 token with 7 decimals of precision would be represented as "1_0000000"
+     * @param {SorobanFees} [sorobanFees] - optional Soroban fees for the transaction to override the default fees used
+     *
+     * @returns {TransactionBuilder}
+     */
+  }, {
+    key: "addSacTransferOperation",
+    value: function addSacTransferOperation(destination, asset, amount, sorobanFees) {
+      if (BigInt(amount) <= 0n) {
+        throw new Error('Amount must be a positive integer');
+      } else if (BigInt(amount) > xdr.Hyper.MAX_VALUE) {
+        // The largest supported value for SAC is i64 however the contract interface uses i128 which is why we convert it to i128
+        throw new Error('Amount exceeds maximum value for i64');
+      }
+      if (sorobanFees) {
+        var instructions = sorobanFees.instructions,
+          readBytes = sorobanFees.readBytes,
+          writeBytes = sorobanFees.writeBytes,
+          resourceFee = sorobanFees.resourceFee;
+        var U32_MAX = 4294967295;
+        if (instructions <= 0 || instructions > U32_MAX) {
+          throw new Error("instructions must be greater than 0 and at most ".concat(U32_MAX));
         }
-        if (val instanceof Address) {
-          return val.toScVal();
+        if (readBytes <= 0 || readBytes > U32_MAX) {
+          throw new Error("readBytes must be greater than 0 and at most ".concat(U32_MAX));
         }
-        if (val instanceof Keypair) {
-          return nativeToScVal(val.publicKey(), {
-            type: 'address'
-          });
+        if (writeBytes <= 0 || writeBytes > U32_MAX) {
+          throw new Error("writeBytes must be greater than 0 and at most ".concat(U32_MAX));
         }
-        if (val instanceof Contract) {
-          return val.address().toScVal();
+        if (resourceFee <= 0n || resourceFee > xdr.Hyper.MAX_VALUE) {
+          throw new Error('resourceFee must be greater than 0 and at most i64 max');
         }
-        if (val instanceof Uint8Array || scval_Buffer.isBuffer(val)) {
-          var _opts$type;
-          var copy = Uint8Array.from(val);
-          switch ((_opts$type = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type !== void 0 ? _opts$type : 'bytes') {
-            case 'bytes':
-              return src_xdr.ScVal.scvBytes(copy);
-            case 'symbol':
-              return src_xdr.ScVal.scvSymbol(copy);
-            case 'string':
-              return src_xdr.ScVal.scvString(copy);
-            default:
-              throw new TypeError("invalid type (".concat(opts.type, ") specified for bytes-like value"));
-          }
+      }
+      var isDestinationContract = StrKey.isValidContract(destination);
+      if (!isDestinationContract) {
+        if (!StrKey.isValidEd25519PublicKey(destination) && !StrKey.isValidMed25519PublicKey(destination)) {
+          throw new Error('Invalid destination address. Must be a valid Stellar address or contract ID.');
         }
-        if (Array.isArray(val)) {
-          return src_xdr.ScVal.scvVec(val.map(function (v, idx) {
-            // There may be different type specifications for each element in
-            // the array, so we need to apply those accordingly.
-            if (Array.isArray(opts.type)) {
-              return nativeToScVal(v, // only include a `{ type: ... }` if it's present (safer than
-              // `{type: undefined}`)
-              scval_objectSpread({}, opts.type.length > idx && {
-                type: opts.type[idx]
-              }));
-            }
+      }
+      if (destination === this.source.accountId()) {
+        throw new Error('Destination cannot be the same as the source account.');
+      }
+      var contractId = asset.contractId(this.networkPassphrase);
+      var functionName = 'transfer';
+      var source = this.source.accountId();
+      var args = [nativeToScVal(source, {
+        type: 'address'
+      }), nativeToScVal(destination, {
+        type: 'address'
+      }), nativeToScVal(amount, {
+        type: 'i128'
+      })];
+      var isAssetNative = asset.isNative();
+      var auths = new src_xdr.SorobanAuthorizationEntry({
+        credentials: src_xdr.SorobanCredentials.sorobanCredentialsSourceAccount(),
+        rootInvocation: new src_xdr.SorobanAuthorizedInvocation({
+          "function": src_xdr.SorobanAuthorizedFunction.sorobanAuthorizedFunctionTypeContractFn(new src_xdr.InvokeContractArgs({
+            contractAddress: Address.fromString(contractId).toScAddress(),
+            functionName: functionName,
+            args: args
+          })),
+          subInvocations: []
+        })
+      });
+      var footprint = new src_xdr.LedgerFootprint({
+        readOnly: [src_xdr.LedgerKey.contractData(new src_xdr.LedgerKeyContractData({
+          contract: Address.fromString(contractId).toScAddress(),
+          key: src_xdr.ScVal.scvLedgerKeyContractInstance(),
+          durability: src_xdr.ContractDataDurability.persistent()
+        }))],
+        readWrite: []
+      });
 
-            // Otherwise apply a generic (or missing) type specifier on it.
-            return nativeToScVal(v, opts);
-          }));
+      // Ledger entries for the destination account
+      if (isDestinationContract) {
+        footprint.readWrite().push(src_xdr.LedgerKey.contractData(new src_xdr.LedgerKeyContractData({
+          contract: Address.fromString(contractId).toScAddress(),
+          key: src_xdr.ScVal.scvVec([nativeToScVal('Balance', {
+            type: 'symbol'
+          }), nativeToScVal(destination, {
+            type: 'address'
+          })]),
+          durability: src_xdr.ContractDataDurability.persistent()
+        })));
+        if (!isAssetNative) {
+          footprint.readOnly().push(src_xdr.LedgerKey.account(new src_xdr.LedgerKeyAccount({
+            accountId: Keypair.fromPublicKey(asset.getIssuer()).xdrPublicKey()
+          })));
         }
-        if (((_val$constructor$name = (_val$constructor = val.constructor) === null || _val$constructor === void 0 ? void 0 : _val$constructor.name) !== null && _val$constructor$name !== void 0 ? _val$constructor$name : '') !== 'Object') {
-          var _val$constructor2;
-          throw new TypeError("cannot interpret ".concat((_val$constructor2 = val.constructor) === null || _val$constructor2 === void 0 ? void 0 : _val$constructor2.name, " value as ScVal (").concat(JSON.stringify(val), ")"));
+      } else if (isAssetNative) {
+        footprint.readWrite().push(src_xdr.LedgerKey.account(new src_xdr.LedgerKeyAccount({
+          accountId: Keypair.fromPublicKey(destination).xdrPublicKey()
+        })));
+      } else if (asset.getIssuer() !== destination) {
+        footprint.readWrite().push(src_xdr.LedgerKey.trustline(new src_xdr.LedgerKeyTrustLine({
+          accountId: Keypair.fromPublicKey(destination).xdrPublicKey(),
+          asset: asset.toTrustLineXDRObject()
+        })));
+      }
+
+      // Ledger entries for the source account
+      if (asset.isNative()) {
+        footprint.readWrite().push(src_xdr.LedgerKey.account(new src_xdr.LedgerKeyAccount({
+          accountId: Keypair.fromPublicKey(source).xdrPublicKey()
+        })));
+      } else if (asset.getIssuer() !== source) {
+        footprint.readWrite().push(src_xdr.LedgerKey.trustline(new src_xdr.LedgerKeyTrustLine({
+          accountId: Keypair.fromPublicKey(source).xdrPublicKey(),
+          asset: asset.toTrustLineXDRObject()
+        })));
+      }
+      var defaultPaymentFees = {
+        instructions: 400000,
+        readBytes: 1000,
+        writeBytes: 1000,
+        resourceFee: BigInt(5000000)
+      };
+      var sorobanData = new src_xdr.SorobanTransactionData({
+        resources: new src_xdr.SorobanResources({
+          footprint: footprint,
+          instructions: sorobanFees ? sorobanFees.instructions : defaultPaymentFees.instructions,
+          diskReadBytes: sorobanFees ? sorobanFees.readBytes : defaultPaymentFees.readBytes,
+          writeBytes: sorobanFees ? sorobanFees.writeBytes : defaultPaymentFees.writeBytes
+        }),
+        ext: new src_xdr.SorobanTransactionDataExt(0),
+        resourceFee: new src_xdr.Int64(sorobanFees ? sorobanFees.resourceFee : defaultPaymentFees.resourceFee)
+      });
+      var operation = Operation.invokeContractFunction({
+        contract: contractId,
+        "function": functionName,
+        args: args,
+        auth: [auths]
+      });
+      this.setSorobanData(sorobanData);
+      return this.addOperation(operation);
+    }
+
+    /**
+     * This will build the transaction.
+     * It will also increment the source account's sequence number by 1.
+     * @returns {Transaction} This method will return the built {@link Transaction}.
+     */
+  }, {
+    key: "build",
+    value: function build() {
+      var sequenceNumber = new util_bignumber(this.source.sequenceNumber()).plus(1);
+      var fee = new util_bignumber(this.baseFee).times(this.operations.length).toNumber();
+      var attrs = {
+        fee: fee,
+        seqNum: src_xdr.SequenceNumber.fromString(sequenceNumber.toString()),
+        memo: this.memo ? this.memo.toXDRObject() : null
+      };
+      if (this.timebounds === null || typeof this.timebounds.minTime === 'undefined' || typeof this.timebounds.maxTime === 'undefined') {
+        throw new Error('TimeBounds has to be set or you must call setTimeout(TimeoutInfinite).');
+      }
+      if (isValidDate(this.timebounds.minTime)) {
+        this.timebounds.minTime = this.timebounds.minTime.getTime() / 1000;
+      }
+      if (isValidDate(this.timebounds.maxTime)) {
+        this.timebounds.maxTime = this.timebounds.maxTime.getTime() / 1000;
+      }
+      this.timebounds.minTime = xdr.UnsignedHyper.fromString(this.timebounds.minTime.toString());
+      this.timebounds.maxTime = xdr.UnsignedHyper.fromString(this.timebounds.maxTime.toString());
+      var timeBounds = new src_xdr.TimeBounds(this.timebounds);
+      if (this.hasV2Preconditions()) {
+        var ledgerBounds = null;
+        if (this.ledgerbounds !== null) {
+          ledgerBounds = new src_xdr.LedgerBounds(this.ledgerbounds);
         }
-        return src_xdr.ScVal.scvMap(Object.entries(val)
-        // The Soroban runtime expects maps to have their keys in sorted
-        // order, so let's do that here as part of the conversion to prevent
-        // confusing error messages on execution.
-        .sort(function (_ref, _ref2) {
-          var _ref3 = scval_slicedToArray(_ref, 1),
-            key1 = _ref3[0];
-          var _ref4 = scval_slicedToArray(_ref2, 1),
-            key2 = _ref4[0];
-          return key1.localeCompare(key2);
-        }).map(function (_ref5) {
-          var _k, _opts$type2;
-          var _ref6 = scval_slicedToArray(_ref5, 2),
-            k = _ref6[0],
-            v = _ref6[1];
-          // the type can be specified with an entry for the key and the value,
-          // e.g. val = { 'hello': 1 } and opts.type = { hello: [ 'symbol',
-          // 'u128' ]} or you can use `null` for the default interpretation
-          var _ref7 = (_k = ((_opts$type2 = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type2 !== void 0 ? _opts$type2 : {})[k]) !== null && _k !== void 0 ? _k : [null, null],
-            _ref8 = scval_slicedToArray(_ref7, 2),
-            keyType = _ref8[0],
-            valType = _ref8[1];
-          var keyOpts = keyType ? {
-            type: keyType
-          } : {};
-          var valOpts = valType ? {
-            type: valType
-          } : {};
-          return new src_xdr.ScMapEntry({
-            key: nativeToScVal(k, keyOpts),
-            val: nativeToScVal(v, valOpts)
-          });
+        var minSeqNum = this.minAccountSequence || '0';
+        minSeqNum = src_xdr.SequenceNumber.fromString(minSeqNum);
+        var minSeqAge = xdr.UnsignedHyper.fromString(this.minAccountSequenceAge !== null ? this.minAccountSequenceAge.toString() : '0');
+        var minSeqLedgerGap = this.minAccountSequenceLedgerGap || 0;
+        var extraSigners = this.extraSigners !== null ? this.extraSigners.map(SignerKey.decodeAddress) : [];
+        attrs.cond = src_xdr.Preconditions.precondV2(new src_xdr.PreconditionsV2({
+          timeBounds: timeBounds,
+          ledgerBounds: ledgerBounds,
+          minSeqNum: minSeqNum,
+          minSeqAge: minSeqAge,
+          minSeqLedgerGap: minSeqLedgerGap,
+          extraSigners: extraSigners
         }));
+      } else {
+        attrs.cond = src_xdr.Preconditions.precondTime(timeBounds);
       }
-    case 'number':
-    case 'bigint':
-      switch (opts === null || opts === void 0 ? void 0 : opts.type) {
-        case 'u32':
-          return src_xdr.ScVal.scvU32(val);
-        case 'i32':
-          return src_xdr.ScVal.scvI32(val);
+      attrs.sourceAccount = decodeAddressToMuxedAccount(this.source.accountId());
+
+      // TODO - remove this workaround for TransactionExt ts constructor
+      //       and use the typescript generated static factory method once fixed
+      //       https://github.com/stellar/dts-xdr/issues/5
+      if (this.sorobanData) {
+        // @ts-ignore
+        attrs.ext = new src_xdr.TransactionExt(1, this.sorobanData);
+        // Soroban transactions pay the resource fee in addition to the regular fee, so we need to add it here.
+        attrs.fee = new util_bignumber(attrs.fee).plus(this.sorobanData.resourceFee()).toNumber();
+      } else {
+        // @ts-ignore
+        attrs.ext = new src_xdr.TransactionExt(0, src_xdr.Void);
+      }
+      var xtx = new src_xdr.Transaction(attrs);
+      xtx.operations(this.operations);
+      var txEnvelope = new src_xdr.TransactionEnvelope.envelopeTypeTx(new src_xdr.TransactionV1Envelope({
+        tx: xtx
+      }));
+      var tx = new Transaction(txEnvelope, this.networkPassphrase);
+      this.source.incrementSequenceNumber();
+      return tx;
+    }
+  }, {
+    key: "hasV2Preconditions",
+    value: function hasV2Preconditions() {
+      return this.ledgerbounds !== null || this.minAccountSequence !== null || this.minAccountSequenceAge !== null || this.minAccountSequenceLedgerGap !== null || this.extraSigners !== null && this.extraSigners.length > 0;
+    }
+
+    /**
+     * Builds a {@link FeeBumpTransaction}, enabling you to resubmit an existing
+     * transaction with a higher fee.
+     *
+     * @param {Keypair|string}  feeSource - account paying for the transaction,
+     *     in the form of either a Keypair (only the public key is used) or
+     *     an account ID (in G... or M... form, but refer to `withMuxing`)
+     * @param {string}          baseFee   - max fee willing to pay per operation
+     *     in inner transaction (**in stroops**)
+     * @param {Transaction}     innerTx   - {@link Transaction} to be bumped by
+     *     the fee bump transaction
+     * @param {string}          networkPassphrase - passphrase of the target
+     *     Stellar network (e.g. "Public Global Stellar Network ; September 2015",
+     *     see {@link Networks})
+     *
+     * @todo Alongside the next major version bump, this type signature can be
+     *       changed to be less awkward: accept a MuxedAccount as the `feeSource`
+     *       rather than a keypair or string.
+     *
+     * @note Your fee-bump amount should be >= 10x the original fee.
+     * @see  https://developers.stellar.org/docs/glossary/fee-bumps/#replace-by-fee
+     *
+     * @returns {FeeBumpTransaction}
+     */
+  }], [{
+    key: "cloneFrom",
+    value: function cloneFrom(tx) {
+      var opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+      if (!(tx instanceof Transaction)) {
+        throw new TypeError("expected a 'Transaction', got: ".concat(tx));
+      }
+      var sequenceNum = (BigInt(tx.sequence) - 1n).toString();
+      var source;
+      // rebuild the source account based on the strkey
+      if (StrKey.isValidMed25519PublicKey(tx.source)) {
+        source = MuxedAccount.fromAddress(tx.source, sequenceNum);
+      } else if (StrKey.isValidEd25519PublicKey(tx.source)) {
+        source = new Account(tx.source, sequenceNum);
+      } else {
+        throw new TypeError("unsupported tx source account: ".concat(tx.source));
+      }
+
+      // the initial fee passed to the builder gets scaled up based on the number
+      // of operations at the end, so we have to down-scale first
+      var unscaledFee = parseInt(tx.fee, 10) / tx.operations.length;
+      var builder = new TransactionBuilder(source, transaction_builder_objectSpread({
+        fee: (unscaledFee || BASE_FEE).toString(),
+        memo: tx.memo,
+        networkPassphrase: tx.networkPassphrase,
+        timebounds: tx.timeBounds,
+        ledgerbounds: tx.ledgerBounds,
+        minAccountSequence: tx.minAccountSequence,
+        minAccountSequenceAge: tx.minAccountSequenceAge,
+        minAccountSequenceLedgerGap: tx.minAccountSequenceLedgerGap,
+        extraSigners: tx.extraSigners
+      }, opts));
+      tx._tx.operations().forEach(function (op) {
+        return builder.addOperation(op);
+      });
+      return builder;
+    }
+  }, {
+    key: "buildFeeBumpTransaction",
+    value: function buildFeeBumpTransaction(feeSource, baseFee, innerTx, networkPassphrase) {
+      var innerOps = innerTx.operations.length;
+      var minBaseFee = new util_bignumber(BASE_FEE);
+      var resourceFee = new util_bignumber(0);
+
+      // Do we need to do special Soroban fee handling? We only want the fee-bump
+      // requirement to match the inclusion fee, not the inclusion+resource fee.
+      var env = innerTx.toEnvelope();
+      switch (env["switch"]().value) {
+        case src_xdr.EnvelopeType.envelopeTypeTx().value:
+          {
+            var _sorobanData$resource;
+            var sorobanData = env.v1().tx().ext().value();
+            resourceFee = new util_bignumber((_sorobanData$resource = sorobanData === null || sorobanData === void 0 ? void 0 : sorobanData.resourceFee()) !== null && _sorobanData$resource !== void 0 ? _sorobanData$resource : 0);
+            break;
+          }
         default:
           break;
       }
-      return new ScInt(val, {
-        type: opts === null || opts === void 0 ? void 0 : opts.type
-      }).toScVal();
-    case 'string':
-      {
-        var _opts$type3;
-        var optType = (_opts$type3 = opts === null || opts === void 0 ? void 0 : opts.type) !== null && _opts$type3 !== void 0 ? _opts$type3 : 'string';
-        switch (optType) {
-          case 'string':
-            return src_xdr.ScVal.scvString(val);
-          case 'symbol':
-            return src_xdr.ScVal.scvSymbol(val);
-          case 'address':
-            return new Address(val).toScVal();
-          case 'u32':
-            return src_xdr.ScVal.scvU32(parseInt(val, 10));
-          case 'i32':
-            return src_xdr.ScVal.scvI32(parseInt(val, 10));
-          default:
-            if (XdrLargeInt.isType(optType)) {
-              return new XdrLargeInt(optType, val).toScVal();
-            }
-            throw new TypeError("invalid type (".concat(opts.type, ") specified for string value"));
-        }
+      var innerInclusionFee = new util_bignumber(innerTx.fee).minus(resourceFee).div(innerOps);
+      var base = new util_bignumber(baseFee);
+
+      // The fee rate for fee bump is at least the fee rate of the inner transaction
+      if (base.lt(innerInclusionFee)) {
+        throw new Error("Invalid baseFee, it should be at least ".concat(innerInclusionFee, " stroops."));
+      }
+
+      // The fee rate is at least the minimum fee
+      if (base.lt(minBaseFee)) {
+        throw new Error("Invalid baseFee, it should be at least ".concat(minBaseFee, " stroops."));
+      }
+      var innerTxEnvelope = innerTx.toEnvelope();
+      if (innerTxEnvelope["switch"]() === src_xdr.EnvelopeType.envelopeTypeTxV0()) {
+        var v0Tx = innerTxEnvelope.v0().tx();
+        var v1Tx = new src_xdr.Transaction({
+          sourceAccount: new src_xdr.MuxedAccount.keyTypeEd25519(v0Tx.sourceAccountEd25519()),
+          fee: v0Tx.fee(),
+          seqNum: v0Tx.seqNum(),
+          cond: src_xdr.Preconditions.precondTime(v0Tx.timeBounds()),
+          memo: v0Tx.memo(),
+          operations: v0Tx.operations(),
+          ext: new src_xdr.TransactionExt(0)
+        });
+        innerTxEnvelope = new src_xdr.TransactionEnvelope.envelopeTypeTx(new src_xdr.TransactionV1Envelope({
+          tx: v1Tx,
+          signatures: innerTxEnvelope.v0().signatures()
+        }));
+      }
+      var feeSourceAccount;
+      if (typeof feeSource === 'string') {
+        feeSourceAccount = decodeAddressToMuxedAccount(feeSource);
+      } else {
+        feeSourceAccount = feeSource.xdrMuxedAccount();
+      }
+      var tx = new src_xdr.FeeBumpTransaction({
+        feeSource: feeSourceAccount,
+        fee: src_xdr.Int64.fromString(base.times(innerOps + 1).plus(resourceFee).toString()),
+        innerTx: src_xdr.FeeBumpTransactionInnerTx.envelopeTypeTx(innerTxEnvelope.v1()),
+        ext: new src_xdr.FeeBumpTransactionExt(0)
+      });
+      var feeBumpTxEnvelope = new src_xdr.FeeBumpTransactionEnvelope({
+        tx: tx,
+        signatures: []
+      });
+      var envelope = new src_xdr.TransactionEnvelope.envelopeTypeTxFeeBump(feeBumpTxEnvelope);
+      return new FeeBumpTransaction(envelope, networkPassphrase);
+    }
+
+    /**
+     * Build a {@link Transaction} or {@link FeeBumpTransaction} from an
+     * xdr.TransactionEnvelope.
+     *
+     * @param {string|xdr.TransactionEnvelope} envelope - The transaction envelope
+     *     object or base64 encoded string.
+     * @param {string} networkPassphrase - The network passphrase of the target
+     *     Stellar network (e.g. "Public Global Stellar Network ; September
+     *     2015"), see {@link Networks}.
+     *
+     * @returns {Transaction|FeeBumpTransaction}
+     */
+  }, {
+    key: "fromXDR",
+    value: function fromXDR(envelope, networkPassphrase) {
+      if (typeof envelope === 'string') {
+        envelope = src_xdr.TransactionEnvelope.fromXDR(envelope, 'base64');
       }
-    case 'boolean':
-      return src_xdr.ScVal.scvBool(val);
-    case 'undefined':
-      return src_xdr.ScVal.scvVoid();
-    case 'function':
-      // FIXME: Is this too helpful?
-      return nativeToScVal(val());
-    default:
-      throw new TypeError("failed to convert typeof ".concat(scval_typeof(val), " (").concat(val, ")"));
-  }
-}
+      if (envelope["switch"]() === src_xdr.EnvelopeType.envelopeTypeTxFeeBump()) {
+        return new FeeBumpTransaction(envelope, networkPassphrase);
+      }
+      return new Transaction(envelope, networkPassphrase);
+    }
+  }]);
+}();
 
 /**
- * Given a smart contract value, attempt to convert it to a native type.
- * Possible conversions include:
- *
- *  - void -> `null`
- *  - u32, i32 -> `number`
- *  - u64, i64, u128, i128, u256, i256, timepoint, duration -> `bigint`
- *  - vec -> `Array` of any of the above (via recursion)
- *  - map -> key-value object of any of the above (via recursion)
- *  - bool -> `boolean`
- *  - bytes -> `Uint8Array`
- *  - symbol -> `string`
- *  - string -> `string` IF the underlying buffer can be decoded as ascii/utf8,
- *              `Uint8Array` of the raw contents in any error case
- *
- * If no viable conversion can be determined, this just "unwraps" the smart
- * value to return its underlying XDR value.
- *
- * @param {xdr.ScVal} scv - the input smart contract value
+ * Checks whether a provided object is a valid Date.
+ * @argument {Date} d date object
+ * @returns {boolean}
+ */
+function isValidDate(d) {
+  // isnan is okay here because it correctly checks for invalid date objects
+  // eslint-disable-next-line no-restricted-globals
+  return d instanceof Date && !isNaN(d);
+}
+;// ./src/network.js
+/**
+ * Contains passphrases for common networks:
+ * * `Networks.PUBLIC`: `Public Global Stellar Network ; September 2015`
+ * * `Networks.TESTNET`: `Test SDF Network ; September 2015`
+ * * `Networks.FUTURENET`: `Test SDF Future Network ; October 2022`
+ * * `Networks.STANDALONE`: `Standalone Network ; February 2017`
  *
- * @returns {any}
- * @see nativeToScVal
+ * @type {{PUBLIC: string, TESTNET: string, FUTURENET: string, STANDALONE: string }}
  */
-function scValToNative(scv) {
-  var _scv$vec, _scv$map;
-  // we use the verbose xdr.ScValType.<type>.value form here because it's faster
-  // than string comparisons and the underlying constants never need to be
-  // updated
-  switch (scv["switch"]().value) {
-    case src_xdr.ScValType.scvVoid().value:
-      return null;
-
-    // these can be converted to bigints directly
-    case src_xdr.ScValType.scvU64().value:
-    case src_xdr.ScValType.scvI64().value:
-      return scv.value().toBigInt();
-
-    // these can be parsed by internal abstractions note that this can also
-    // handle the above two cases, but it's not as efficient (another
-    // type-check, parsing, etc.)
-    case src_xdr.ScValType.scvU128().value:
-    case src_xdr.ScValType.scvI128().value:
-    case src_xdr.ScValType.scvU256().value:
-    case src_xdr.ScValType.scvI256().value:
-      return scValToBigInt(scv);
-    case src_xdr.ScValType.scvVec().value:
-      return ((_scv$vec = scv.vec()) !== null && _scv$vec !== void 0 ? _scv$vec : []).map(scValToNative);
-    case src_xdr.ScValType.scvAddress().value:
-      return Address.fromScVal(scv).toString();
-    case src_xdr.ScValType.scvMap().value:
-      return Object.fromEntries(((_scv$map = scv.map()) !== null && _scv$map !== void 0 ? _scv$map : []).map(function (entry) {
-        return [scValToNative(entry.key()), scValToNative(entry.val())];
-      }));
-
-    // these return the primitive type directly
-    case src_xdr.ScValType.scvBool().value:
-    case src_xdr.ScValType.scvU32().value:
-    case src_xdr.ScValType.scvI32().value:
-    case src_xdr.ScValType.scvBytes().value:
-      return scv.value();
-
-    // Symbols are limited to [a-zA-Z0-9_]+, so we can safely make ascii strings
-    //
-    // Strings, however, are "presented" as strings and we treat them as such
-    // (in other words, string = bytes with a hint that it's text). If the user
-    // encoded non-printable bytes in their string value, that's on them.
-    //
-    // Note that we assume a utf8 encoding (ascii-compatible). For other
-    // encodings, you should probably use bytes anyway. If it cannot be decoded,
-    // the raw bytes are returned.
-    case src_xdr.ScValType.scvSymbol().value:
-    case src_xdr.ScValType.scvString().value:
-      {
-        var v = scv.value(); // string|Buffer
-        if (scval_Buffer.isBuffer(v) || ArrayBuffer.isView(v)) {
-          try {
-            return new TextDecoder().decode(v);
-          } catch (e) {
-            return new Uint8Array(v.buffer); // copy of bytes
-          }
+var Networks = {
+  PUBLIC: 'Public Global Stellar Network ; September 2015',
+  TESTNET: 'Test SDF Network ; September 2015',
+  FUTURENET: 'Test SDF Future Network ; October 2022',
+  SANDBOX: 'Local Sandbox Stellar Network ; September 2022',
+  STANDALONE: 'Standalone Network ; February 2017'
+};
+;// ./src/soroban.js
+function soroban_typeof(o) { "@babel/helpers - typeof"; return soroban_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; }, soroban_typeof(o); }
+function _toArray(r) { return soroban_arrayWithHoles(r) || soroban_iterableToArray(r) || soroban_unsupportedIterableToArray(r) || soroban_nonIterableRest(); }
+function soroban_nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
+function soroban_unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return soroban_arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? soroban_arrayLikeToArray(r, a) : void 0; } }
+function soroban_arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+function soroban_iterableToArray(r) { if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r); }
+function soroban_arrayWithHoles(r) { if (Array.isArray(r)) return r; }
+function soroban_classCallCheck(a, n) { if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function"); }
+function soroban_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, soroban_toPropertyKey(o.key), o); } }
+function soroban_createClass(e, r, t) { return r && soroban_defineProperties(e.prototype, r), t && soroban_defineProperties(e, t), Object.defineProperty(e, "prototype", { writable: !1 }), e; }
+function soroban_toPropertyKey(t) { var i = soroban_toPrimitive(t, "string"); return "symbol" == soroban_typeof(i) ? i : 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() {
+    soroban_classCallCheck(this, Soroban);
+  }
+  return soroban_createClass(Soroban, null, [{
+    key: "formatTokenAmount",
+    value:
+    /**
+     * Given a whole number smart contract amount of a token and an amount of
+     * decimal places (if the token has any), it returns a "display" value.
+     *
+     * All arithmetic inside the contract is performed on integers to avoid
+     * potential precision and consistency issues of floating-point.
+     *
+     * @param {string} amount   the token amount you want to display
+     * @param {number} decimals specify how many decimal places a token has
+     *
+     * @returns {string} the display value
+     * @throws {TypeError} if the given amount has a decimal point already
+     * @example
+     * formatTokenAmount("123000", 4) === "12.3";
+     * formatTokenAmount("123000", 3) === "123.0";
+     * formatTokenAmount("123", 3) === "0.123";
+     */
+    function formatTokenAmount(amount, decimals) {
+      if (amount.includes('.')) {
+        throw new TypeError('No decimals are allowed');
+      }
+      var formatted = amount;
+      if (decimals > 0) {
+        if (decimals > formatted.length) {
+          formatted = ['0', formatted.toString().padStart(decimals, '0')].join('.');
+        } else {
+          formatted = [formatted.slice(0, -decimals), formatted.slice(-decimals)].join('.');
         }
-        return v; // string already
       }
+      return formatted.replace(/(\.\d*?)0+$/, '$1') // strip trailing zeroes
+      .replace(/\.$/, '.0') // but keep at least one
+      .replace(/^\./, '0.'); // and a leading one
+    }
 
-    // these can be converted to bigint
-    case src_xdr.ScValType.scvTimepoint().value:
-    case src_xdr.ScValType.scvDuration().value:
-      return new src_xdr.Uint64(scv.value()).toBigInt();
-    case src_xdr.ScValType.scvError().value:
-      switch (scv.error()["switch"]().value) {
-        // Distinguish errors from the user contract.
-        case src_xdr.ScErrorType.sceContract().value:
-          return {
-            type: 'contract',
-            code: scv.error().contractCode()
-          };
-        default:
-          {
-            var err = scv.error();
-            return {
-              type: 'system',
-              code: err.code().value,
-              value: err.code().name
-            };
-          }
+    /**
+     * Parse a token amount to use it on smart contract
+     *
+     * This function takes the display value and its decimals (if the token has
+     * any) and returns a string that'll be used within the smart contract.
+     *
+     * @param {string} value      the token amount you want to use it on smart
+     *    contract which you've been displaying in a UI
+     * @param {number} decimals   the number of decimal places expected in the
+     *    display value (different than the "actual" number, because suffix zeroes
+     *    might not be present)
+     *
+     * @returns {string}  the whole number token amount represented by the display
+     *    value with the decimal places shifted over
+     *
+     * @example
+     * const displayValueAmount = "123.4560"
+     * const parsedAmtForSmartContract = parseTokenAmount(displayValueAmount, 5);
+     * parsedAmtForSmartContract === "12345600"
+     */
+  }, {
+    key: "parseTokenAmount",
+    value: function parseTokenAmount(value, decimals) {
+      var _fraction$padEnd;
+      var _value$split$slice = value.split('.').slice(),
+        _value$split$slice2 = _toArray(_value$split$slice),
+        whole = _value$split$slice2[0],
+        fraction = _value$split$slice2[1],
+        rest = soroban_arrayLikeToArray(_value$split$slice2).slice(2);
+      if (rest.length) {
+        throw new Error("Invalid decimal value: ".concat(value));
       }
-
-    // in the fallthrough case, just return the underlying value directly
-    default:
-      return scv.value();
-  }
-}
-
-/// Inject a sortable map builder into the xdr module.
-src_xdr.scvSortedMap = function (items) {
-  var sorted = Array.from(items).sort(function (a, b) {
-    // Both a and b are `ScMapEntry`s, so we need to sort by underlying key.
-    //
-    // We couldn't possibly handle every combination of keys since Soroban
-    // maps don't enforce consistent types, so we do a best-effort and try
-    // sorting by "number-like" or "string-like."
-    var nativeA = scValToNative(a.key());
-    var nativeB = scValToNative(b.key());
-    switch (scval_typeof(nativeA)) {
-      case 'number':
-      case 'bigint':
-        return nativeA < nativeB ? -1 : 1;
-      default:
-        return nativeA.toString().localeCompare(nativeB.toString());
+      var shifted = BigInt(whole + ((_fraction$padEnd = fraction === null || fraction === void 0 ? void 0 : fraction.padEnd(decimals, '0')) !== null && _fraction$padEnd !== void 0 ? _fraction$padEnd : '0'.repeat(decimals)));
+      return shifted.toString();
     }
-  });
-  return src_xdr.ScVal.scvMap(sorted);
-};
+  }]);
+}();
 ;// ./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; }
@@ -24141,10 +24300,8 @@ function _asyncToGenerator(n) { return function () { var t = this, e = arguments
  *    whose hash you should sign, so that you can inspect the entire structure
  *    if necessary (rather than blindly signing a hash)
  *
- * @returns {
- *    Promise<Uint8Array> |
- *    Promise<{signature: Uint8Array, publicKey: string}
- * }  the signature of the raw payload (which is the sha256 hash of the preimage
+ * @returns {Promise<Uint8Array | {signature: Uint8Array, publicKey: string}>}
+ *    the signature of the raw payload (which is the sha256 hash of the preimage
  *    bytes, so `hash(preimage.toXDR())`) either naked, implying it is signed
  *    by the key corresponding to the public key in the entry you pass to
  *    {@link authorizeEntry} (decipherable from its