@stellar/stellar-base 10.0.0

package/lib/numbers/sc_int.js

@@ -0,0 +1,134 @@
+"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.ScInt = void 0;
+var _xdr_large_int = require("./xdr_large_int");
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(arg) { var key = _toPrimitive(arg, "string"); return _typeof(key) === "symbol" ? key : String(key); }
+function _toPrimitive(input, hint) { if (_typeof(input) !== "object" || input === null) return input; var prim = input[Symbol.toPrimitive]; if (prim !== undefined) { var res = prim.call(input, hint || "default"); if (_typeof(res) !== "object") return res; throw new TypeError("@@toPrimitive must return a primitive value."); } return (hint === "string" ? String : Number)(input); }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); Object.defineProperty(subClass, "prototype", { writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+/**
+ * Provides an easier way to manipulate large numbers for Stellar operations.
+ *
+ * You can instantiate this value either from bigints, strings, or numbers
+ * (whole numbers, or this will throw).
+ *
+ * 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 } from "@stellar/stellar-base";
+ *
+ * // You have an ScVal from a contract and want to parse it into JS native.
+ * const value = xdr.ScVal.fromXDR(someXdr, "base64");
+ * const bigi = ScInt.fromScVal(value); // grab it as a BigInt
+ * 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.fromScVal(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 = exports.ScInt = /*#__PURE__*/function (_XdrLargeInt) {
+  _inherits(ScInt, _XdrLargeInt);
+  var _super = _createSuper(ScInt);
+  function ScInt(value, opts) {
+    var _opts$type;
+    _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, ")"));
+    }
+
+    // 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 _super.call(this, type, value);
+  }
+  return _createClass(ScInt);
+}(_xdr_large_int.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;
+}

package/lib/numbers/uint128.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.Uint128 = 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 Uint128 = exports.Uint128 = /*#__PURE__*/function (_LargeInt) {
+  _inherits(Uint128, _LargeInt);
+  var _super = _createSuper(Uint128);
+  /**
+   * 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() {
+    _classCallCheck(this, Uint128);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _super.call(this, args);
+  }
+  _createClass(Uint128, [{
+    key: "unsigned",
+    get: function get() {
+      return true;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return 128;
+    }
+  }]);
+  return Uint128;
+}(_jsXdr.LargeInt);
+Uint128.defineIntBoundaries();

package/lib/numbers/uint256.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.Uint256 = 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 Uint256 = exports.Uint256 = /*#__PURE__*/function (_LargeInt) {
+  _inherits(Uint256, _LargeInt);
+  var _super = _createSuper(Uint256);
+  /**
+   * 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() {
+    _classCallCheck(this, Uint256);
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    return _super.call(this, args);
+  }
+  _createClass(Uint256, [{
+    key: "unsigned",
+    get: function get() {
+      return true;
+    }
+  }, {
+    key: "size",
+    get: function get() {
+      return 256;
+    }
+  }]);
+  return Uint256;
+}(_jsXdr.LargeInt);
+Uint256.defineIntBoundaries();

package/lib/numbers/xdr_large_int.js

@@ -0,0 +1,267 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.XdrLargeInt = void 0;
+var _jsXdr = require("@stellar/js-xdr");
+var _uint = require("./uint128");
+var _uint2 = require("./uint256");
+var _int = require("./int128");
+var _int2 = require("./int256");
+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 _defineProperty(obj, key, value) { key = _toPropertyKey(key); if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+function _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); } /* eslint no-bitwise: ["error", {"allow": [">>"]}] */
+/**
+ * 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 - force a specific data type. the type choices are:
+ *    'i64', 'u64', 'i128', 'u128', 'i256', and 'u256' (default: the smallest
+ *    one that fits the `value`) (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 = exports.XdrLargeInt = /*#__PURE__*/function () {
+  function XdrLargeInt(type, values) {
+    _classCallCheck(this, XdrLargeInt);
+    /** @type {xdr.LargeInt} */
+    _defineProperty(this, "int", void 0);
+    // child class of a jsXdr.LargeInt
+    /** @type {string} */
+    _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 (i instanceof XdrLargeInt) {
+        return i.toBigInt();
+      }
+      return BigInt(i);
+    });
+    switch (type) {
+      case 'i64':
+        this["int"] = new _jsXdr.Hyper(values);
+        break;
+      case 'i128':
+        this["int"] = new _int.Int128(values);
+        break;
+      case 'i256':
+        this["int"] = new _int2.Int256(values);
+        break;
+      case 'u64':
+        this["int"] = new _jsXdr.UnsignedHyper(values);
+        break;
+      case 'u128':
+        this["int"] = new _uint.Uint128(values);
+        break;
+      case 'u256':
+        this["int"] = new _uint2.Uint256(values);
+        break;
+      default:
+        throw TypeError("invalid type: ".concat(type));
+    }
+    this.type = type;
+  }
+
+  /**
+   * @returns {number}
+   * @throws {RangeError} if the value can't fit into a Number
+   */
+  _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);
+    }
+
+    /** @returns {bigint} */
+  }, {
+    key: "toBigInt",
+    value: function toBigInt() {
+      return this["int"].toBigInt();
+    }
+
+    /** @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 _xdr["default"].ScVal.scvI64(new _xdr["default"].Int64(v));
+    }
+
+    /** @returns {xdr.ScVal} the integer encoded with `ScValType = U64` */
+  }, {
+    key: "toU64",
+    value: function toU64() {
+      this._sizeCheck(64);
+      return _xdr["default"].ScVal.scvU64(new _xdr["default"].Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
+      );
+    }
+
+    /**
+     * @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
+
+      return _xdr["default"].ScVal.scvI128(new _xdr["default"].Int128Parts({
+        hi: new _xdr["default"].Int64(hi64),
+        lo: new _xdr["default"].Uint64(lo64)
+      }));
+    }
+
+    /**
+     * @returns {xdr.ScVal} the integer encoded with `ScValType = U128`
+     * @throws {RangeError} if the value cannot fit in 128 bits
+     */
+  }, {
+    key: "toU128",
+    value: function toU128() {
+      this._sizeCheck(128);
+      var v = this["int"].toBigInt();
+      return _xdr["default"].ScVal.scvU128(new _xdr["default"].UInt128Parts({
+        hi: new _xdr["default"].Uint64(BigInt.asUintN(64, v >> 64n)),
+        lo: new _xdr["default"].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 _xdr["default"].ScVal.scvI256(new _xdr["default"].Int256Parts({
+        hiHi: new _xdr["default"].Int64(hiHi64),
+        hiLo: new _xdr["default"].Uint64(hiLo64),
+        loHi: new _xdr["default"].Uint64(loHi64),
+        loLo: new _xdr["default"].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 _xdr["default"].ScVal.scvU256(new _xdr["default"].UInt256Parts({
+        hiHi: new _xdr["default"].Uint64(hiHi64),
+        hiLo: new _xdr["default"].Uint64(hiLo64),
+        loHi: new _xdr["default"].Uint64(loHi64),
+        loLo: new _xdr["default"].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();
+        default:
+          throw TypeError("invalid type: ".concat(this.type));
+      }
+    }
+  }, {
+    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':
+          return true;
+        default:
+          return false;
+      }
+    }
+
+    /**
+     * Convert the raw `ScValType` string (e.g. 'scvI128', generated by the XDR)
+     * to a type description for {@link XdrLargeInt} construction (e.g. 'i128')
+     *
+     * @param {string} scvType  the `xdr.ScValType` as a string
+     * @returns {string} a suitable equivalent type to construct this object
+     */
+  }, {
+    key: "getType",
+    value: function getType(scvType) {
+      return scvType.slice(3).toLowerCase();
+    }
+  }]);
+  return XdrLargeInt;
+}();