numbers/xdr_large_int.js

  1. /* eslint no-bitwise: ["error", {"allow": [">>"]}] */
  2. import { Hyper, UnsignedHyper } from '@stellar/js-xdr';
  4. import { Uint128 } from './uint128';
  5. import { Uint256 } from './uint256';
  6. import { Int128 } from './int128';
  7. import { Int256 } from './int256';
  9. import xdr from '../xdr';
  11. /**
  12.  * A wrapper class to represent large XDR-encodable integers.
  13.  *
  14.  * This operates at a lower level than {@link ScInt} by forcing you to specify
  15.  * the type / width / size in bits of the integer you're targeting, regardless
  16.  * of the input value(s) you provide.
  17.  *
  18.  * @param {string}  type - force a specific data type. the type choices are:
  19.  *    'i64', 'u64', 'i128', 'u128', 'i256', and 'u256' (default: the smallest
  20.  *    one that fits the `value`) (see {@link XdrLargeInt.isType})
  21.  * @param {number|bigint|string|Array<number|bigint|string>} values   a list of
  22.  *    integer-like values interpreted in big-endian order
  23.  */
  24. export class XdrLargeInt {
  25.   /** @type {xdr.LargeInt} */
  26.   int; // child class of a jsXdr.LargeInt
  28.   /** @type {string} */
  29.   type;
  31.   constructor(type, values) {
  32.     if (!(values instanceof Array)) {
  33.       values = [values];
  34.     }
  36.     // normalize values to one type
  37.     values = values.map((i) => {
  38.       // micro-optimization to no-op on the likeliest input value:
  39.       if (typeof i === 'bigint') {
  40.         return i;
  41.       }
  42.       if (i instanceof XdrLargeInt) {
  43.         return i.toBigInt();
  44.       }
  45.       return BigInt(i);
  46.     });
  48.     switch (type) {
  49.       case 'i64':
  50.         this.int = new Hyper(values);
  51.         break;
  52.       case 'i128':
  53.         this.int = new Int128(values);
  54.         break;
  55.       case 'i256':
  56.         this.int = new Int256(values);
  57.         break;
  58.       case 'u64':
  59.         this.int = new UnsignedHyper(values);
  60.         break;
  61.       case 'u128':
  62.         this.int = new Uint128(values);
  63.         break;
  64.       case 'u256':
  65.         this.int = new Uint256(values);
  66.         break;
  67.       default:
  68.         throw TypeError(`invalid type: ${type}`);
  69.     }
  71.     this.type = type;
  72.   }
  74.   /**
  75.    * @returns {number}
  76.    * @throws {RangeError} if the value can't fit into a Number
  77.    */
  78.   toNumber() {
  79.     const bi = this.int.toBigInt();
  80.     if (bi > Number.MAX_SAFE_INTEGER || bi < Number.MIN_SAFE_INTEGER) {
  81.       throw RangeError(
  82.         `value ${bi} not in range for Number ` +
  83.           `[${Number.MAX_SAFE_INTEGER}, ${Number.MIN_SAFE_INTEGER}]`
  84.       );
  85.     }
  87.     return Number(bi);
  88.   }
  90.   /** @returns {bigint} */
  91.   toBigInt() {
  92.     return this.int.toBigInt();
  93.   }
  95.   /** @returns {xdr.ScVal} the integer encoded with `ScValType = I64` */
  96.   toI64() {
  97.     this._sizeCheck(64);
  98.     const v = this.toBigInt();
  99.     if (BigInt.asIntN(64, v) !== v) {
  100.       throw RangeError(`value too large for i64: ${v}`);
  101.     }
  103.     return xdr.ScVal.scvI64(new xdr.Int64(v));
  104.   }
  106.   /** @returns {xdr.ScVal} the integer encoded with `ScValType = U64` */
  107.   toU64() {
  108.     this._sizeCheck(64);
  109.     return xdr.ScVal.scvU64(
  110.       new xdr.Uint64(BigInt.asUintN(64, this.toBigInt())) // reiterpret as unsigned
  111.     );
  112.   }
  114.   /**
  115.    * @returns {xdr.ScVal} the integer encoded with `ScValType = I128`
  116.    * @throws {RangeError} if the value cannot fit in 128 bits
  117.    */
  118.   toI128() {
  119.     this._sizeCheck(128);
  121.     const v = this.int.toBigInt();
  122.     const hi64 = BigInt.asIntN(64, v >> 64n); // encode top 64 w/ sign bit
  123.     const lo64 = BigInt.asUintN(64, v); // grab btm 64, encode sign
  125.     return xdr.ScVal.scvI128(
  126.       new xdr.Int128Parts({
  127.         hi: new xdr.Int64(hi64),
  128.         lo: new xdr.Uint64(lo64)
  129.       })
  130.     );
  131.   }
  133.   /**
  134.    * @returns {xdr.ScVal} the integer encoded with `ScValType = U128`
  135.    * @throws {RangeError} if the value cannot fit in 128 bits
  136.    */
  137.   toU128() {
  138.     this._sizeCheck(128);
  139.     const v = this.int.toBigInt();
  141.     return xdr.ScVal.scvU128(
  142.       new xdr.UInt128Parts({
  143.         hi: new xdr.Uint64(BigInt.asUintN(64, v >> 64n)),
  144.         lo: new xdr.Uint64(BigInt.asUintN(64, v))
  145.       })
  146.     );
  147.   }
  149.   /** @returns {xdr.ScVal} the integer encoded with `ScValType = I256` */
  150.   toI256() {
  151.     const v = this.int.toBigInt();
  152.     const hiHi64 = BigInt.asIntN(64, v >> 192n); // keep sign bit
  153.     const hiLo64 = BigInt.asUintN(64, v >> 128n);
  154.     const loHi64 = BigInt.asUintN(64, v >> 64n);
  155.     const loLo64 = BigInt.asUintN(64, v);
  157.     return xdr.ScVal.scvI256(
  158.       new xdr.Int256Parts({
  159.         hiHi: new xdr.Int64(hiHi64),
  160.         hiLo: new xdr.Uint64(hiLo64),
  161.         loHi: new xdr.Uint64(loHi64),
  162.         loLo: new xdr.Uint64(loLo64)
  163.       })
  164.     );
  165.   }
  167.   /** @returns {xdr.ScVal} the integer encoded with `ScValType = U256` */
  168.   toU256() {
  169.     const v = this.int.toBigInt();
  170.     const hiHi64 = BigInt.asUintN(64, v >> 192n); // encode sign bit
  171.     const hiLo64 = BigInt.asUintN(64, v >> 128n);
  172.     const loHi64 = BigInt.asUintN(64, v >> 64n);
  173.     const loLo64 = BigInt.asUintN(64, v);
  175.     return xdr.ScVal.scvU256(
  176.       new xdr.UInt256Parts({
  177.         hiHi: new xdr.Uint64(hiHi64),
  178.         hiLo: new xdr.Uint64(hiLo64),
  179.         loHi: new xdr.Uint64(loHi64),
  180.         loLo: new xdr.Uint64(loLo64)
  181.       })
  182.     );
  183.   }
  185.   /** @returns {xdr.ScVal} the smallest interpretation of the stored value */
  186.   toScVal() {
  187.     switch (this.type) {
  188.       case 'i64':
  189.         return this.toI64();
  190.       case 'i128':
  191.         return this.toI128();
  192.       case 'i256':
  193.         return this.toI256();
  194.       case 'u64':
  195.         return this.toU64();
  196.       case 'u128':
  197.         return this.toU128();
  198.       case 'u256':
  199.         return this.toU256();
  200.       default:
  201.         throw TypeError(`invalid type: ${this.type}`);
  202.     }
  203.   }
  205.   valueOf() {
  206.     return this.int.valueOf();
  207.   }
  209.   toString() {
  210.     return this.int.toString();
  211.   }
  213.   toJSON() {
  214.     return {
  215.       value: this.toBigInt().toString(),
  216.       type: this.type
  217.     };
  218.   }
  220.   _sizeCheck(bits) {
  221.     if (this.int.size > bits) {
  222.       throw RangeError(`value too large for ${bits} bits (${this.type})`);
  223.     }
  224.   }
  226.   static isType(type) {
  227.     switch (type) {
  228.       case 'i64':
  229.       case 'i128':
  230.       case 'i256':
  231.       case 'u64':
  232.       case 'u128':
  233.       case 'u256':
  234.         return true;
  235.       default:
  236.         return false;
  237.     }
  238.   }
  240.   /**
  241.    * Convert the raw `ScValType` string (e.g. 'scvI128', generated by the XDR)
  242.    * to a type description for {@link XdrLargeInt} construction (e.g. 'i128')
  243.    *
  244.    * @param {string} scvType  the `xdr.ScValType` as a string
  245.    * @returns {string} a suitable equivalent type to construct this object
  246.    */
  247.   static getType(scvType) {
  248.     return scvType.slice(3).toLowerCase();
  249.   }
  250. }