@stellar/stellar-base 10.0.0

package/lib/memo.js

@@ -0,0 +1,270 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MemoText = exports.MemoReturn = exports.MemoNone = exports.MemoID = exports.MemoHash = exports.Memo = void 0;
+var _jsXdr = require("@stellar/js-xdr");
+var _bignumber = _interopRequireDefault(require("bignumber.js"));
+var _xdr = _interopRequireDefault(require("./xdr"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * Type of {@link Memo}.
+ */
+var MemoNone = exports.MemoNone = 'none';
+/**
+ * Type of {@link Memo}.
+ */
+var MemoID = exports.MemoID = 'id';
+/**
+ * Type of {@link Memo}.
+ */
+var MemoText = exports.MemoText = 'text';
+/**
+ * Type of {@link Memo}.
+ */
+var MemoHash = exports.MemoHash = 'hash';
+/**
+ * Type of {@link Memo}.
+ */
+var MemoReturn = exports.MemoReturn = 'return';
+
+/**
+ * `Memo` represents memos attached to transactions.
+ *
+ * @param {string} type - `MemoNone`, `MemoID`, `MemoText`, `MemoHash` or `MemoReturn`
+ * @param {*} value - `string` for `MemoID`, `MemoText`, buffer of hex string for `MemoHash` or `MemoReturn`
+ * @see [Transactions concept](https://developers.stellar.org/docs/glossary/transactions/)
+ * @class Memo
+ */
+var Memo = exports.Memo = /*#__PURE__*/function () {
+  function Memo(type) {
+    var value = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    _classCallCheck(this, Memo);
+    this._type = type;
+    this._value = value;
+    switch (this._type) {
+      case MemoNone:
+        break;
+      case MemoID:
+        Memo._validateIdValue(value);
+        break;
+      case MemoText:
+        Memo._validateTextValue(value);
+        break;
+      case MemoHash:
+      case MemoReturn:
+        Memo._validateHashValue(value);
+        // We want MemoHash and MemoReturn to have Buffer as a value
+        if (typeof value === 'string') {
+          this._value = Buffer.from(value, 'hex');
+        }
+        break;
+      default:
+        throw new Error('Invalid memo type');
+    }
+  }
+
+  /**
+   * Contains memo type: `MemoNone`, `MemoID`, `MemoText`, `MemoHash` or `MemoReturn`
+   */
+  _createClass(Memo, [{
+    key: "type",
+    get: function get() {
+      return this._type;
+    },
+    set: function set(type) {
+      throw new Error('Memo is immutable');
+    }
+
+    /**
+     * Contains memo value:
+     * * `null` for `MemoNone`,
+     * * `string` for `MemoID`,
+     * * `Buffer` for `MemoText` after decoding using `fromXDRObject`, original value otherwise,
+     * * `Buffer` for `MemoHash`, `MemoReturn`.
+     */
+  }, {
+    key: "value",
+    get: function get() {
+      switch (this._type) {
+        case MemoNone:
+          return null;
+        case MemoID:
+        case MemoText:
+          return this._value;
+        case MemoHash:
+        case MemoReturn:
+          return Buffer.from(this._value);
+        default:
+          throw new Error('Invalid memo type');
+      }
+    },
+    set: function set(value) {
+      throw new Error('Memo is immutable');
+    }
+  }, {
+    key: "toXDRObject",
+    value:
+    /**
+     * Returns XDR memo object.
+     * @returns {xdr.Memo}
+     */
+    function toXDRObject() {
+      switch (this._type) {
+        case MemoNone:
+          return _xdr["default"].Memo.memoNone();
+        case MemoID:
+          return _xdr["default"].Memo.memoId(_jsXdr.UnsignedHyper.fromString(this._value));
+        case MemoText:
+          return _xdr["default"].Memo.memoText(this._value);
+        case MemoHash:
+          return _xdr["default"].Memo.memoHash(this._value);
+        case MemoReturn:
+          return _xdr["default"].Memo.memoReturn(this._value);
+        default:
+          return null;
+      }
+    }
+
+    /**
+     * Returns {@link Memo} from XDR memo object.
+     * @param {xdr.Memo} object XDR memo object
+     * @returns {Memo}
+     */
+  }], [{
+    key: "_validateIdValue",
+    value: function _validateIdValue(value) {
+      var error = new Error("Expects a int64 as a string. Got ".concat(value));
+      if (typeof value !== 'string') {
+        throw error;
+      }
+      var number;
+      try {
+        number = new _bignumber["default"](value);
+      } catch (e) {
+        throw error;
+      }
+
+      // Infinity
+      if (!number.isFinite()) {
+        throw error;
+      }
+
+      // NaN
+      if (number.isNaN()) {
+        throw error;
+      }
+    }
+  }, {
+    key: "_validateTextValue",
+    value: function _validateTextValue(value) {
+      if (!_xdr["default"].Memo.armTypeForArm('text').isValid(value)) {
+        throw new Error('Expects string, array or buffer, max 28 bytes');
+      }
+    }
+  }, {
+    key: "_validateHashValue",
+    value: function _validateHashValue(value) {
+      var error = new Error("Expects a 32 byte hash value or hex encoded string. Got ".concat(value));
+      if (value === null || typeof value === 'undefined') {
+        throw error;
+      }
+      var valueBuffer;
+      if (typeof value === 'string') {
+        if (!/^[0-9A-Fa-f]{64}$/g.test(value)) {
+          throw error;
+        }
+        valueBuffer = Buffer.from(value, 'hex');
+      } else if (Buffer.isBuffer(value)) {
+        valueBuffer = Buffer.from(value);
+      } else {
+        throw error;
+      }
+      if (!valueBuffer.length || valueBuffer.length !== 32) {
+        throw error;
+      }
+    }
+
+    /**
+     * Returns an empty memo (`MemoNone`).
+     * @returns {Memo}
+     */
+  }, {
+    key: "none",
+    value: function none() {
+      return new Memo(MemoNone);
+    }
+
+    /**
+     * Creates and returns a `MemoText` memo.
+     * @param {string} text - memo text
+     * @returns {Memo}
+     */
+  }, {
+    key: "text",
+    value: function text(_text) {
+      return new Memo(MemoText, _text);
+    }
+
+    /**
+     * Creates and returns a `MemoID` memo.
+     * @param {string} id - 64-bit number represented as a string
+     * @returns {Memo}
+     */
+  }, {
+    key: "id",
+    value: function id(_id) {
+      return new Memo(MemoID, _id);
+    }
+
+    /**
+     * Creates and returns a `MemoHash` memo.
+     * @param {array|string} hash - 32 byte hash or hex encoded string
+     * @returns {Memo}
+     */
+  }, {
+    key: "hash",
+    value: function hash(_hash) {
+      return new Memo(MemoHash, _hash);
+    }
+
+    /**
+     * Creates and returns a `MemoReturn` memo.
+     * @param {array|string} hash - 32 byte hash or hex encoded string
+     * @returns {Memo}
+     */
+  }, {
+    key: "return",
+    value: function _return(hash) {
+      return new Memo(MemoReturn, hash);
+    }
+  }, {
+    key: "fromXDRObject",
+    value: function fromXDRObject(object) {
+      switch (object.arm()) {
+        case 'id':
+          return Memo.id(object.value().toString());
+        case 'text':
+          return Memo.text(object.value());
+        case 'hash':
+          return Memo.hash(object.value());
+        case 'retHash':
+          return Memo["return"](object.value());
+        default:
+          break;
+      }
+      if (typeof object.value() === 'undefined') {
+        return Memo.none();
+      }
+      throw new Error('Unknown type');
+    }
+  }]);
+  return Memo;
+}();

package/lib/muxed_account.js

@@ -0,0 +1,159 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MuxedAccount = void 0;
+var _xdr = _interopRequireDefault(require("./xdr"));
+var _account = require("./account");
+var _strkey = require("./strkey");
+var _decode_encode_muxed_account = require("./util/decode_encode_muxed_account");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+/**
+ * Represents a muxed account for transactions and operations.
+ *
+ * A muxed (or *multiplexed*) account (defined rigorously in
+ * [CAP-27](https://stellar.org/protocol/cap-27) and briefly in
+ * [SEP-23](https://stellar.org/protocol/sep-23)) is one that resolves a single
+ * Stellar `G...`` account to many different underlying IDs.
+ *
+ * For example, you may have a single Stellar address for accounting purposes:
+ *   GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ
+ *
+ * Yet would like to use it for 4 different family members:
+ *   1: MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAAGZFQ
+ *   2: MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAALIWQ
+ *   3: MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAAPYHQ
+ *   4: MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAAQLQQ
+ *
+ * This object makes it easy to create muxed accounts from regular accounts,
+ * duplicate them, get/set the underlying IDs, etc. without mucking around with
+ * the raw XDR.
+ *
+ * Because muxed accounts are purely an off-chain convention, they all share the
+ * sequence number tied to their underlying G... account. Thus, this object
+ * *requires* an {@link Account} instance to be passed in, so that muxed
+ * instances of an account can collectively modify the sequence number whenever
+ * a muxed account is used as the source of a @{link Transaction} with {@link
+ * TransactionBuilder}.
+ *
+ * @constructor
+ *
+ * @param {Account}   account - the @{link Account} instance representing the
+ *                              underlying G... address
+ * @param {string}    id      - a stringified uint64 value that represents the
+ *                              ID of the muxed account
+ *
+ * @link https://developers.stellar.org/docs/glossary/muxed-accounts/
+ */
+var MuxedAccount = exports.MuxedAccount = /*#__PURE__*/function () {
+  function MuxedAccount(baseAccount, id) {
+    _classCallCheck(this, MuxedAccount);
+    var accountId = baseAccount.accountId();
+    if (!_strkey.StrKey.isValidEd25519PublicKey(accountId)) {
+      throw new Error('accountId is invalid');
+    }
+    this.account = baseAccount;
+    this._muxedXdr = (0, _decode_encode_muxed_account.encodeMuxedAccount)(accountId, id);
+    this._mAddress = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(this._muxedXdr);
+    this._id = id;
+  }
+
+  /**
+   * Parses an M-address into a MuxedAccount object.
+   *
+   * @param  {string} mAddress    - an M-address to transform
+   * @param  {string} sequenceNum - the sequence number of the underlying {@link
+   *     Account}, to use for the underlying base account (@link
+   *     MuxedAccount.baseAccount). If you're using the SDK, you can use
+   *     `server.loadAccount` to fetch this if you don't know it.
+   *
+   * @return {MuxedAccount}
+   */
+  _createClass(MuxedAccount, [{
+    key: "baseAccount",
+    value:
+    /**
+     * @return {Account} the underlying account object shared among all muxed
+     *     accounts with this Stellar address
+     */
+    function baseAccount() {
+      return this.account;
+    }
+
+    /**
+     * @return {string} the M-address representing this account's (G-address, ID)
+     */
+  }, {
+    key: "accountId",
+    value: function accountId() {
+      return this._mAddress;
+    }
+  }, {
+    key: "id",
+    value: function id() {
+      return this._id;
+    }
+  }, {
+    key: "setId",
+    value: function setId(id) {
+      if (typeof id !== 'string') {
+        throw new Error('id should be a string representing a number (uint64)');
+      }
+      this._muxedXdr.med25519().id(_xdr["default"].Uint64.fromString(id));
+      this._mAddress = (0, _decode_encode_muxed_account.encodeMuxedAccountToAddress)(this._muxedXdr);
+      this._id = id;
+      return this;
+    }
+
+    /**
+     * Accesses the underlying account's sequence number.
+     * @return {string}  strigified sequence number for the underlying account
+     */
+  }, {
+    key: "sequenceNumber",
+    value: function sequenceNumber() {
+      return this.account.sequenceNumber();
+    }
+
+    /**
+     * Increments the underlying account's sequence number by one.
+     * @return {void}
+     */
+  }, {
+    key: "incrementSequenceNumber",
+    value: function incrementSequenceNumber() {
+      return this.account.incrementSequenceNumber();
+    }
+
+    /**
+     * @return {xdr.MuxedAccount} the XDR object representing this muxed account's
+     *     G-address and uint64 ID
+     */
+  }, {
+    key: "toXDRObject",
+    value: function toXDRObject() {
+      return this._muxedXdr;
+    }
+  }, {
+    key: "equals",
+    value: function equals(otherMuxedAccount) {
+      return this.accountId() === otherMuxedAccount.accountId();
+    }
+  }], [{
+    key: "fromAddress",
+    value: function fromAddress(mAddress, sequenceNum) {
+      var muxedAccount = (0, _decode_encode_muxed_account.decodeAddressToMuxedAccount)(mAddress);
+      var gAddress = (0, _decode_encode_muxed_account.extractBaseAddress)(mAddress);
+      var id = muxedAccount.med25519().id().toString();
+      return new MuxedAccount(new _account.Account(gAddress, sequenceNum), id);
+    }
+  }]);
+  return MuxedAccount;
+}();

package/lib/network.js

@@ -0,0 +1,22 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Networks = void 0;
+/**
+ * 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 = exports.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'
+};

package/lib/numbers/index.js

@@ -0,0 +1,85 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Int128", {
+  enumerable: true,
+  get: function get() {
+    return _int.Int128;
+  }
+});
+Object.defineProperty(exports, "Int256", {
+  enumerable: true,
+  get: function get() {
+    return _int2.Int256;
+  }
+});
+Object.defineProperty(exports, "ScInt", {
+  enumerable: true,
+  get: function get() {
+    return _sc_int.ScInt;
+  }
+});
+Object.defineProperty(exports, "Uint128", {
+  enumerable: true,
+  get: function get() {
+    return _uint.Uint128;
+  }
+});
+Object.defineProperty(exports, "Uint256", {
+  enumerable: true,
+  get: function get() {
+    return _uint2.Uint256;
+  }
+});
+Object.defineProperty(exports, "XdrLargeInt", {
+  enumerable: true,
+  get: function get() {
+    return _xdr_large_int.XdrLargeInt;
+  }
+});
+exports.scValToBigInt = scValToBigInt;
+var _xdr_large_int = require("./xdr_large_int");
+var _uint = require("./uint128");
+var _uint2 = require("./uint256");
+var _int = require("./int128");
+var _int2 = require("./int256");
+var _sc_int = require("./sc_int");
+/**
+ * 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 = _xdr_large_int.XdrLargeInt.getType(scv["switch"]().name);
+  switch (scv["switch"]().name) {
+    case 'scvU32':
+    case 'scvI32':
+      return BigInt(scv.value());
+    case 'scvU64':
+    case 'scvI64':
+      return new _xdr_large_int.XdrLargeInt(scIntType, scv.value()).toBigInt();
+    case 'scvU128':
+    case 'scvI128':
+      return new _xdr_large_int.XdrLargeInt(scIntType, [scv.value().lo(), scv.value().hi()]).toBigInt();
+    case 'scvU256':
+    case 'scvI256':
+      return new _xdr_large_int.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"]()));
+  }
+}

package/lib/numbers/int128.js

@@ -0,0 +1,50 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Int128 = void 0;
+var _jsXdr = require("@stellar/js-xdr");
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var Int128 = exports.Int128 = /*#__PURE__*/function (_LargeInt) {
+  _inherits(Int128, _LargeInt);
+  var _super = _createSuper(Int128);
+  /**
+   * 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() {
+    _classCallCheck(this, Int128);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _super.call(this, args);
+  }
+  _createClass(Int128, [{
+    key: "unsigned",
+    get: function get() {
+      return false;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return 128;
+    }
+  }]);
+  return Int128;
+}(_jsXdr.LargeInt);
+Int128.defineIntBoundaries();

package/lib/numbers/int256.js

@@ -0,0 +1,50 @@
+"use strict";
+
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Int256 = void 0;
+var _jsXdr = require("@stellar/js-xdr");
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+var Int256 = exports.Int256 = /*#__PURE__*/function (_LargeInt) {
+  _inherits(Int256, _LargeInt);
+  var _super = _createSuper(Int256);
+  /**
+   * 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() {
+    _classCallCheck(this, Int256);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _super.call(this, args);
+  }
+  _createClass(Int256, [{
+    key: "unsigned",
+    get: function get() {
+      return false;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return 256;
+    }
+  }]);
+  return Int256;
+}(_jsXdr.LargeInt);
+Int256.defineIntBoundaries();