@digitalworld/digital-world-sdk 16.0.0

package/lib/cjs/base/numbers/sc_int.js

@@ -0,0 +1,54 @@
+'use strict';
+
+var xdr_large_int = require('./xdr_large_int.js');
+
+class ScInt extends xdr_large_int.XdrLargeInt {
+  /**
+   * @param 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 opts - an optional object controlling optional parameters
+   *   - `type`: specify a type ('i64', 'u64', 'i128', 'u128', 'i256',
+   *    or 'u256') to override the default type selection. If not specified, the
+   *    smallest type that fits the value is used.
+   */
+  constructor(value, opts) {
+    const bigValue = BigInt(value);
+    const signed = bigValue < 0n;
+    let type = opts?.type ?? "";
+    if (type.startsWith("u") && signed) {
+      throw TypeError(`specified type ${opts?.type} yet negative (${value})`);
+    }
+    if (type === "") {
+      type = signed ? "i" : "u";
+      const bitlen = nearestBigIntSize(bigValue);
+      switch (bitlen) {
+        case 64:
+        case 128:
+        case 256:
+          type += bitlen.toString();
+          break;
+        default:
+          throw RangeError(
+            `expected 64/128/256 bits for input (${value}), got ${bitlen}`
+          );
+      }
+    }
+    super(type, bigValue);
+  }
+}
+function nearestBigIntSize(bigI) {
+  if (bigI < 0n) {
+    const abs = -bigI;
+    const bitlen2 = (abs - 1n).toString(2).length + 1;
+    return [64, 128, 256].find((len) => bitlen2 <= len) ?? bitlen2;
+  }
+  const bitlen = bigI.toString(2).length;
+  return [64, 128, 256].find((len) => bitlen <= len) ?? bitlen;
+}
+
+exports.ScInt = ScInt;
+//# sourceMappingURL=sc_int.js.map

package/lib/cjs/base/numbers/sc_int.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sc_int.js","sources":["../../../../src/base/numbers/sc_int.ts"],"sourcesContent":["import { XdrLargeInt, type ScIntType } from \"./xdr_large_int.js\";\n\n/**\n * Provides an easier way to manipulate large numbers for Stellar operations.\n *\n * You can instantiate this \"**s**mart **c**ontract integer\" value either from\n * bigints, strings, or numbers (whole numbers, or this will throw).\n *\n * If you need to create a native BigInt from a list of integer \"parts\" (for\n * example, you have a series of encoded 32-bit integers that represent a larger\n * value), you can use the lower level abstraction {@link XdrLargeInt}. For\n * example, you could do `new XdrLargeInt('u128', bytes...).toBigInt()`.\n *\n * @example\n * ```ts\n * import { xdr, ScInt, scValToBigInt } from \"@stellar/stellar-base\";\n *\n * // You have an ScVal from a contract and want to parse it into JS native.\n * const value = xdr.ScVal.fromXDR(someXdr, \"base64\");\n * const bigi = scValToBigInt(value); // grab it as a BigInt\n * let sci = new ScInt(bigi);\n *\n * sci.toNumber(); // gives native JS type (w/ size check)\n * sci.toBigInt(); // gives the native BigInt value\n * sci.toU64();    // gives ScValType-specific XDR constructs (with size checks)\n *\n * // You have a number and want to shove it into a contract.\n * sci = new ScInt(0xdeadcafebabe);\n * sci.toBigInt() // returns 244838016400062n\n * sci.toNumber() // throws: too large\n *\n * // Pass any to e.g. a Contract.call(), conversion happens automatically\n * // regardless of the initial type.\n * const scValU128 = sci.toU128();\n * const scValI256 = sci.toI256();\n * const scValU64  = sci.toU64();\n *\n * // Lots of ways to initialize:\n * new ScInt(\"123456789123456789\")\n * new ScInt(123456789123456789n);\n * new ScInt(1n << 140n);\n * new ScInt(-42);\n * new ScInt(scValToBigInt(scValU128)); // from above\n *\n * // If you know the type ahead of time (accessing `.raw` is faster than\n * // conversions), you can specify the type directly (otherwise, it's\n * // interpreted from the numbers you pass in):\n * const i = new ScInt(123456789n, { type: \"u256\" });\n *\n * // For example, you can use the underlying `sdk.U256` and convert it to an\n * // `xdr.ScVal` directly like so:\n * const scv = new xdr.ScVal.scvU256(i.raw);\n *\n * // Or reinterpret it as a different type (size permitting):\n * const scv = i.toI64();\n * ```\n *\n * @throws if the `value` is invalid (e.g. floating point), too\n *    large (i.e. exceeds a 256-bit value), doesn't fit in the `opts.type`,\n *    the signedness of `opts.type` doesn't match the input `value`, or a\n *    string `value` can't be parsed as a big integer\n */\nexport class ScInt extends XdrLargeInt {\n  /**\n   * @param value - a single, integer-like value which will\n   *    be interpreted in the smallest appropriate XDR type supported by Stellar\n   *    (64, 128, or 256 bit integer values). signed values are supported, though\n   *    they are sanity-checked against `opts.type`. if you need 32-bit values,\n   *    you can construct them directly without needing this wrapper, e.g.\n   *    `xdr.ScVal.scvU32(1234)`.\n   * @param opts - an optional object controlling optional parameters\n   *   - `type`: specify a type ('i64', 'u64', 'i128', 'u128', 'i256',\n   *    or 'u256') to override the default type selection. If not specified, the\n   *    smallest type that fits the value is used.\n   */\n  constructor(\n    value: bigint | number | string,\n    opts?: { type?: ScIntType; [key: string]: unknown },\n  ) {\n    const bigValue = BigInt(value);\n    const signed = bigValue < 0n;\n\n    let type = opts?.type ?? \"\";\n    if (type.startsWith(\"u\") && signed) {\n      throw TypeError(`specified type ${opts?.type} yet negative (${value})`);\n    }\n\n    // If unspecified, we make a best guess at the type based on the bit length\n    // of the value, treating 64 as a minimum and 256 as a maximum.\n    if (type === \"\") {\n      type = signed ? \"i\" : \"u\";\n      const bitlen = nearestBigIntSize(bigValue);\n\n      switch (bitlen) {\n        case 64:\n        case 128:\n        case 256:\n          type += bitlen.toString();\n          break;\n\n        default:\n          throw RangeError(\n            `expected 64/128/256 bits for input (${value}), got ${bitlen}`,\n          );\n      }\n    }\n\n    super(type as ScIntType, bigValue);\n  }\n}\n\nfunction nearestBigIntSize(bigI: bigint): number {\n  if (bigI < 0n) {\n    // Two's complement: N bits represent -(2^(N-1)) to 2^(N-1)-1.\n    // For negative values, compute the signed bit width as\n    // (bitlen of abs-1) + 1 to account for the sign bit. This correctly\n    // classifies -(2^63) as 64 bits (fits i64) and -(2^63)-1 as 65 bits\n    // (needs i128).\n    const abs = -bigI;\n    const bitlen = (abs - 1n).toString(2).length + 1;\n    return [64, 128, 256].find((len) => bitlen <= len) ?? bitlen;\n  }\n\n  const bitlen = bigI.toString(2).length;\n  return [64, 128, 256].find((len) => bitlen <= len) ?? bitlen;\n}\n"],"names":["XdrLargeInt","bitlen"],"mappings":";;;;AA8DO,MAAM,cAAcA,yBAAA,CAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAarC,WAAA,CACE,OACA,IAAA,EACA;AACA,IAAA,MAAM,QAAA,GAAW,OAAO,KAAK,CAAA;AAC7B,IAAA,MAAM,SAAS,QAAA,GAAW,EAAA;AAE1B,IAAA,IAAI,IAAA,GAAO,MAAM,IAAA,IAAQ,EAAA;AACzB,IAAA,IAAI,IAAA,CAAK,UAAA,CAAW,GAAG,CAAA,IAAK,MAAA,EAAQ;AAClC,MAAA,MAAM,UAAU,CAAA,eAAA,EAAkB,IAAA,EAAM,IAAI,CAAA,eAAA,EAAkB,KAAK,CAAA,CAAA,CAAG,CAAA;AAAA,IACxE;AAIA,IAAA,IAAI,SAAS,EAAA,EAAI;AACf,MAAA,IAAA,GAAO,SAAS,GAAA,GAAM,GAAA;AACtB,MAAA,MAAM,MAAA,GAAS,kBAAkB,QAAQ,CAAA;AAEzC,MAAA,QAAQ,MAAA;AAAQ,QACd,KAAK,EAAA;AAAA,QACL,KAAK,GAAA;AAAA,QACL,KAAK,GAAA;AACH,UAAA,IAAA,IAAQ,OAAO,QAAA,EAAS;AACxB,UAAA;AAAA,QAEF;AACE,UAAA,MAAM,UAAA;AAAA,YACJ,CAAA,oCAAA,EAAuC,KAAK,CAAA,OAAA,EAAU,MAAM,CAAA;AAAA,WAC9D;AAAA;AACJ,IACF;AAEA,IAAA,KAAA,CAAM,MAAmB,QAAQ,CAAA;AAAA,EACnC;AACF;AAEA,SAAS,kBAAkB,IAAA,EAAsB;AAC/C,EAAA,IAAI,OAAO,EAAA,EAAI;AAMb,IAAA,MAAM,MAAM,CAAC,IAAA;AACb,IAAA,MAAMC,WAAU,GAAA,GAAM,EAAA,EAAI,QAAA,CAAS,CAAC,EAAE,MAAA,GAAS,CAAA;AAC/C,IAAA,OAAO,CAAC,EAAA,EAAI,GAAA,EAAK,GAAG,CAAA,CAAE,KAAK,CAAC,GAAA,KAAQA,OAAAA,IAAU,GAAG,CAAA,IAAKA,OAAAA;AAAA,EACxD;AAEA,EAAA,MAAM,MAAA,GAAS,IAAA,CAAK,QAAA,CAAS,CAAC,CAAA,CAAE,MAAA;AAChC,EAAA,OAAO,CAAC,EAAA,EAAI,GAAA,EAAK,GAAG,CAAA,CAAE,KAAK,CAAC,GAAA,KAAQ,MAAA,IAAU,GAAG,CAAA,IAAK,MAAA;AACxD;;;;"}

package/lib/cjs/base/numbers/uint128.js

@@ -0,0 +1,31 @@
+'use strict';
+
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js');
+var largeInt = require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js');
+require('buffer');
+
+class Uint128 extends largeInt.LargeInt {
+  /**
+   * Construct an unsigned 128-bit integer that can be XDR-encoded.
+   *
+   * @param args - one or more slices to encode
+   *     in big-endian format (i.e. earlier elements are higher bits)
+   */
+  constructor(...args) {
+    super(args);
+  }
+  get unsigned() {
+    return true;
+  }
+  get size() {
+    return 128;
+  }
+}
+Uint128.defineIntBoundaries();
+
+exports.Uint128 = Uint128;
+//# sourceMappingURL=uint128.js.map

package/lib/cjs/base/numbers/uint128.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint128.js","sources":["../../../../src/base/numbers/uint128.ts"],"sourcesContent":["import { LargeInt } from \"@stellar/js-xdr\";\n\nexport class Uint128 extends LargeInt {\n  /**\n   * Construct an unsigned 128-bit integer that can be XDR-encoded.\n   *\n   * @param args - one or more slices to encode\n   *     in big-endian format (i.e. earlier elements are higher bits)\n   */\n  constructor(...args: Array<bigint | number | string>) {\n    super(args);\n  }\n\n  get unsigned(): boolean {\n    return true;\n  }\n\n  get size(): number {\n    return 128;\n  }\n}\n\nUint128.defineIntBoundaries();\n"],"names":["LargeInt"],"mappings":";;;;;;;;;;AAEO,MAAM,gBAAgBA,iBAAA,CAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOpC,eAAe,IAAA,EAAuC;AACpD,IAAA,KAAA,CAAM,IAAI,CAAA;AAAA,EACZ;AAAA,EAEA,IAAI,QAAA,GAAoB;AACtB,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEA,IAAI,IAAA,GAAe;AACjB,IAAA,OAAO,GAAA;AAAA,EACT;AACF;AAEA,OAAA,CAAQ,mBAAA,EAAoB;;;;"}

package/lib/cjs/base/numbers/uint256.js

@@ -0,0 +1,31 @@
+'use strict';
+
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js');
+var largeInt = require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js');
+require('buffer');
+
+class Uint256 extends largeInt.LargeInt {
+  /**
+   * Construct an unsigned 256-bit integer that can be XDR-encoded.
+   *
+   * @param args - one or more slices to encode
+   *     in big-endian format (i.e. earlier elements are higher bits)
+   */
+  constructor(...args) {
+    super(args);
+  }
+  get unsigned() {
+    return true;
+  }
+  get size() {
+    return 256;
+  }
+}
+Uint256.defineIntBoundaries();
+
+exports.Uint256 = Uint256;
+//# sourceMappingURL=uint256.js.map

package/lib/cjs/base/numbers/uint256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uint256.js","sources":["../../../../src/base/numbers/uint256.ts"],"sourcesContent":["import { LargeInt } from \"@stellar/js-xdr\";\n\nexport class Uint256 extends LargeInt {\n  /**\n   * Construct an unsigned 256-bit integer that can be XDR-encoded.\n   *\n   * @param args - one or more slices to encode\n   *     in big-endian format (i.e. earlier elements are higher bits)\n   */\n  constructor(...args: Array<bigint | number | string>) {\n    super(args);\n  }\n\n  get unsigned(): boolean {\n    return true;\n  }\n\n  get size(): number {\n    return 256;\n  }\n}\n\nUint256.defineIntBoundaries();\n"],"names":["LargeInt"],"mappings":";;;;;;;;;;AAEO,MAAM,gBAAgBA,iBAAA,CAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOpC,eAAe,IAAA,EAAuC;AACpD,IAAA,KAAA,CAAM,IAAI,CAAA;AAAA,EACZ;AAAA,EAEA,IAAI,QAAA,GAAoB;AACtB,IAAA,OAAO,IAAA;AAAA,EACT;AAAA,EAEA,IAAI,IAAA,GAAe;AACjB,IAAA,OAAO,GAAA;AAAA,EACT;AACF;AAEA,OAAA,CAAQ,mBAAA,EAAoB;;;;"}

package/lib/cjs/base/numbers/xdr_large_int.js

@@ -0,0 +1,273 @@
+'use strict';
+
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js');
+var hyper = require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js');
+var unsignedHyper = require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js');
+require('../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js');
+require('buffer');
+var uint128 = require('./uint128.js');
+var uint256 = require('./uint256.js');
+var int128 = require('./int128.js');
+var int256 = require('./int256.js');
+var curr_generated = require('../generated/curr_generated.js');
+
+class XdrLargeInt {
+  int;
+  type;
+  /**
+   * @param type - specifies a data type to use to represent the integer, one
+   *    of: 'i64', 'u64', 'i128', 'u128', 'i256', 'u256', 'timepoint', and 'duration'
+   *    (see {@link XdrLargeInt.isType})
+   * @param values - a list of integer-like values interpreted in big-endian order
+   */
+  constructor(type, values) {
+    if (!(values instanceof Array)) {
+      values = [values];
+    }
+    const normalizedValues = values.map((i) => {
+      if (typeof i === "bigint") {
+        return i;
+      }
+      if (typeof i === "object" && i !== null && "toBigInt" in i && typeof i.toBigInt === "function") {
+        return i.toBigInt();
+      }
+      return BigInt(i);
+    });
+    switch (type) {
+      case "i64":
+        this.int = new hyper.Hyper(normalizedValues);
+        break;
+      case "i128":
+        this.int = new int128.Int128(...normalizedValues);
+        break;
+      case "i256":
+        this.int = new int256.Int256(...normalizedValues);
+        break;
+      case "u64":
+      case "timepoint":
+      case "duration":
+        this.int = new unsignedHyper.UnsignedHyper(normalizedValues);
+        break;
+      case "u128":
+        this.int = new uint128.Uint128(...normalizedValues);
+        break;
+      case "u256":
+        this.int = new uint256.Uint256(...normalizedValues);
+        break;
+      default:
+        throw TypeError(`invalid type: ${type}`);
+    }
+    this.type = type;
+  }
+  /**
+   * Converts to a native JS number.
+   *
+   * @throws if the value can't fit into a Number
+   */
+  toNumber() {
+    const bi = this.int.toBigInt();
+    if (bi > Number.MAX_SAFE_INTEGER || bi < Number.MIN_SAFE_INTEGER) {
+      throw RangeError(
+        `value ${bi} not in range for Number [${Number.MAX_SAFE_INTEGER}, ${Number.MIN_SAFE_INTEGER}]`
+      );
+    }
+    return Number(bi);
+  }
+  /** Converts to a native BigInt. */
+  toBigInt() {
+    return this.int.toBigInt();
+  }
+  /**
+   * The integer encoded with `ScValType = I64`.
+   *
+   * @throws if the value cannot fit in 64 bits
+   */
+  toI64() {
+    this._sizeCheck(64);
+    const v = this.toBigInt();
+    if (BigInt.asIntN(64, v) !== v) {
+      throw RangeError(`value too large for i64: ${v}`);
+    }
+    return curr_generated.default.ScVal.scvI64(new curr_generated.default.Int64(v));
+  }
+  /** The integer encoded with `ScValType = U64` */
+  toU64() {
+    this._sizeCheck(64);
+    return curr_generated.default.ScVal.scvU64(
+      new curr_generated.default.Uint64(BigInt.asUintN(64, this.toBigInt()))
+      // reiterpret as unsigned
+    );
+  }
+  /** The integer encoded with `ScValType = Timepoint` */
+  toTimepoint() {
+    this._sizeCheck(64);
+    return curr_generated.default.ScVal.scvTimepoint(
+      new curr_generated.default.Uint64(BigInt.asUintN(64, this.toBigInt()))
+      // reiterpret as unsigned
+    );
+  }
+  /** The integer encoded with `ScValType = Duration` */
+  toDuration() {
+    this._sizeCheck(64);
+    return curr_generated.default.ScVal.scvDuration(
+      new curr_generated.default.Uint64(BigInt.asUintN(64, this.toBigInt()))
+      // reiterpret as unsigned
+    );
+  }
+  /**
+   * The integer encoded with `ScValType = I128`.
+   *
+   * @throws if the value cannot fit in 128 bits
+   */
+  toI128() {
+    this._sizeCheck(128);
+    const v = this.int.toBigInt();
+    if (BigInt.asIntN(128, v) !== v) {
+      throw RangeError(`value too large for i128: ${v}`);
+    }
+    const hi64 = BigInt.asIntN(64, v >> 64n);
+    const lo64 = BigInt.asUintN(64, v);
+    return curr_generated.default.ScVal.scvI128(
+      new curr_generated.default.Int128Parts({
+        hi: new curr_generated.default.Int64(hi64),
+        lo: new curr_generated.default.Uint64(lo64)
+      })
+    );
+  }
+  /**
+   * The integer encoded with `ScValType = U128`.
+   *
+   * @throws if the value cannot fit in 128 bits
+   */
+  toU128() {
+    this._sizeCheck(128);
+    const v = this.int.toBigInt();
+    return curr_generated.default.ScVal.scvU128(
+      new curr_generated.default.UInt128Parts({
+        hi: new curr_generated.default.Uint64(BigInt.asUintN(64, v >> 64n)),
+        lo: new curr_generated.default.Uint64(BigInt.asUintN(64, v))
+      })
+    );
+  }
+  /**
+   * The integer encoded with `ScValType = I256`
+   *
+   * @throws if the value cannot fit in a signed 256-bit integer
+   */
+  toI256() {
+    const v = this.int.toBigInt();
+    if (BigInt.asIntN(256, v) !== v) {
+      throw RangeError(`value too large for i256: ${v}`);
+    }
+    const hiHi64 = BigInt.asIntN(64, v >> 192n);
+    const hiLo64 = BigInt.asUintN(64, v >> 128n);
+    const loHi64 = BigInt.asUintN(64, v >> 64n);
+    const loLo64 = BigInt.asUintN(64, v);
+    return curr_generated.default.ScVal.scvI256(
+      new curr_generated.default.Int256Parts({
+        hiHi: new curr_generated.default.Int64(hiHi64),
+        hiLo: new curr_generated.default.Uint64(hiLo64),
+        loHi: new curr_generated.default.Uint64(loHi64),
+        loLo: new curr_generated.default.Uint64(loLo64)
+      })
+    );
+  }
+  /**
+   * The integer encoded with `ScValType = U256`
+   *
+   * Note: No size check needed - U256 is the largest unsigned type.
+   */
+  toU256() {
+    const v = this.int.toBigInt();
+    const hiHi64 = BigInt.asUintN(64, v >> 192n);
+    const hiLo64 = BigInt.asUintN(64, v >> 128n);
+    const loHi64 = BigInt.asUintN(64, v >> 64n);
+    const loLo64 = BigInt.asUintN(64, v);
+    return curr_generated.default.ScVal.scvU256(
+      new curr_generated.default.UInt256Parts({
+        hiHi: new curr_generated.default.Uint64(hiHi64),
+        hiLo: new curr_generated.default.Uint64(hiLo64),
+        loHi: new curr_generated.default.Uint64(loHi64),
+        loLo: new curr_generated.default.Uint64(loLo64)
+      })
+    );
+  }
+  /** The smallest interpretation of the stored value */
+  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: ${this.type}`);
+    }
+  }
+  /** Returns the primitive value of this integer. */
+  valueOf() {
+    return this.int.valueOf();
+  }
+  /** Returns the string representation of this integer. */
+  toString() {
+    return this.int.toString();
+  }
+  /** Returns a JSON-friendly representation with `value` and `type` fields. */
+  toJSON() {
+    return {
+      value: this.toBigInt().toString(),
+      type: this.type
+    };
+  }
+  _sizeCheck(bits) {
+    if (this.int.size > bits) {
+      throw RangeError(`value too large for ${bits} bits (${this.type})`);
+    }
+  }
+  /** Returns true if the given string is a valid XDR large integer type name. */
+  static 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;
+    }
+  }
+  /**
+   * Convert the raw `ScValType` string (e.g. 'scvI128', generated by the XDR)
+   * to a type description for {@link XdrLargeInt} construction (e.g. 'i128')
+   *
+   * @param scvType - the `xdr.ScValType` as a string
+   * @returns the corresponding {@link ScIntType} if it's an integer type, or
+   *    `undefined` if it's not an integer type
+   */
+  static getType(scvType) {
+    const type = scvType.slice(3).toLowerCase();
+    if (this.isType(type)) {
+      return type;
+    }
+    return void 0;
+  }
+}
+
+exports.XdrLargeInt = XdrLargeInt;
+//# sourceMappingURL=xdr_large_int.js.map

package/lib/cjs/base/numbers/xdr_large_int.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"xdr_large_int.js","sources":["../../../../src/base/numbers/xdr_large_int.ts"],"sourcesContent":["import { Hyper, LargeInt, UnsignedHyper } from \"@stellar/js-xdr\";\n\nimport { Uint128 } from \"./uint128.js\";\nimport { Uint256 } from \"./uint256.js\";\nimport { Int128 } from \"./int128.js\";\nimport { Int256 } from \"./int256.js\";\n\nimport xdr from \"../xdr.js\";\n\ntype BigIntLike = { toBigInt(): bigint };\ntype XdrLargeIntValues =\n  | Array<BigIntLike | bigint | number | string>\n  | BigIntLike\n  | bigint\n  | number\n  | string;\n\nexport type ScIntType =\n  | \"duration\"\n  | \"i64\"\n  | \"i128\"\n  | \"i256\"\n  | \"timepoint\"\n  | \"u64\"\n  | \"u128\"\n  | \"u256\";\n\n/**\n * A wrapper class to represent large XDR-encodable integers.\n *\n * This operates at a lower level than {@link ScInt} by forcing you to specify\n * the type / width / size in bits of the integer you're targeting, regardless\n * of the input value(s) you provide.\n */\nexport class XdrLargeInt {\n  int: LargeInt;\n  type: ScIntType;\n\n  /**\n   * @param type - specifies a data type to use to represent the integer, one\n   *    of: 'i64', 'u64', 'i128', 'u128', 'i256', 'u256', 'timepoint', and 'duration'\n   *    (see {@link XdrLargeInt.isType})\n   * @param values - a list of integer-like values interpreted in big-endian order\n   */\n  constructor(type: ScIntType, values: XdrLargeIntValues) {\n    if (!(values instanceof Array)) {\n      values = [values];\n    }\n\n    // normalize values to one type\n    const normalizedValues: bigint[] = values.map((i) => {\n      // micro-optimization to no-op on the likeliest input value:\n      if (typeof i === \"bigint\") {\n        return i;\n      }\n      if (\n        typeof i === \"object\" &&\n        i !== null &&\n        \"toBigInt\" in i &&\n        typeof i.toBigInt === \"function\"\n      ) {\n        return i.toBigInt();\n      }\n      return BigInt(i as number | string);\n    });\n\n    // Note: API difference in XDR constructors:\n    // - Hyper/UnsignedHyper accept an array parameter\n    // - Int128/Uint128/Int256/Uint256 accept rest parameters (require spread operator)\n    switch (type) {\n      case \"i64\":\n        this.int = new Hyper(normalizedValues);\n        break;\n      case \"i128\":\n        this.int = new Int128(...normalizedValues);\n        break;\n      case \"i256\":\n        this.int = new Int256(...normalizedValues);\n        break;\n      case \"u64\":\n      case \"timepoint\":\n      case \"duration\":\n        this.int = new UnsignedHyper(normalizedValues);\n        break;\n      case \"u128\":\n        this.int = new Uint128(...normalizedValues);\n        break;\n      case \"u256\":\n        this.int = new Uint256(...normalizedValues);\n        break;\n      default:\n        throw TypeError(`invalid type: ${type as string}`);\n    }\n\n    this.type = type;\n  }\n\n  /**\n   * Converts to a native JS number.\n   *\n   * @throws if the value can't fit into a Number\n   */\n  toNumber(): number {\n    const bi = this.int.toBigInt();\n    if (bi > Number.MAX_SAFE_INTEGER || bi < Number.MIN_SAFE_INTEGER) {\n      throw RangeError(\n        `value ${bi} not in range for Number ` +\n          `[${Number.MAX_SAFE_INTEGER}, ${Number.MIN_SAFE_INTEGER}]`,\n      );\n    }\n\n    return Number(bi);\n  }\n\n  /** Converts to a native BigInt. */\n  toBigInt(): bigint {\n    return this.int.toBigInt();\n  }\n\n  /**\n   * The integer encoded with `ScValType = I64`.\n   *\n   * @throws if the value cannot fit in 64 bits\n   */\n  toI64(): xdr.ScVal {\n    this._sizeCheck(64);\n    const v = this.toBigInt();\n    if (BigInt.asIntN(64, v) !== v) {\n      throw RangeError(`value too large for i64: ${v}`);\n    }\n\n    return xdr.ScVal.scvI64(new xdr.Int64(v));\n  }\n\n  /** The integer encoded with `ScValType = U64` */\n  toU64(): xdr.ScVal {\n    this._sizeCheck(64);\n    return xdr.ScVal.scvU64(\n      new xdr.Uint64(BigInt.asUintN(64, this.toBigInt())), // reiterpret as unsigned\n    );\n  }\n\n  /** The integer encoded with `ScValType = Timepoint` */\n  toTimepoint(): xdr.ScVal {\n    this._sizeCheck(64);\n    return xdr.ScVal.scvTimepoint(\n      new xdr.Uint64(BigInt.asUintN(64, this.toBigInt())), // reiterpret as unsigned\n    );\n  }\n\n  /** The integer encoded with `ScValType = Duration` */\n  toDuration(): xdr.ScVal {\n    this._sizeCheck(64);\n    return xdr.ScVal.scvDuration(\n      new xdr.Uint64(BigInt.asUintN(64, this.toBigInt())), // reiterpret as unsigned\n    );\n  }\n\n  /**\n   * The integer encoded with `ScValType = I128`.\n   *\n   * @throws if the value cannot fit in 128 bits\n   */\n  toI128(): xdr.ScVal {\n    this._sizeCheck(128);\n\n    const v = this.int.toBigInt();\n    if (BigInt.asIntN(128, v) !== v) {\n      throw RangeError(`value too large for i128: ${v}`);\n    }\n    const hi64 = BigInt.asIntN(64, v >> 64n); // encode top 64 w/ sign bit\n    const lo64 = BigInt.asUintN(64, v); // grab btm 64, encode sign\n\n    return xdr.ScVal.scvI128(\n      new xdr.Int128Parts({\n        hi: new xdr.Int64(hi64),\n        lo: new xdr.Uint64(lo64),\n      }),\n    );\n  }\n\n  /**\n   * The integer encoded with `ScValType = U128`.\n   *\n   * @throws if the value cannot fit in 128 bits\n   */\n  toU128(): xdr.ScVal {\n    this._sizeCheck(128);\n    const v = this.int.toBigInt();\n\n    return xdr.ScVal.scvU128(\n      new xdr.UInt128Parts({\n        hi: new xdr.Uint64(BigInt.asUintN(64, v >> 64n)),\n        lo: new xdr.Uint64(BigInt.asUintN(64, v)),\n      }),\n    );\n  }\n\n  /**\n   * The integer encoded with `ScValType = I256`\n   *\n   * @throws if the value cannot fit in a signed 256-bit integer\n   */\n  toI256(): xdr.ScVal {\n    const v = this.int.toBigInt();\n    if (BigInt.asIntN(256, v) !== v) {\n      throw RangeError(`value too large for i256: ${v}`);\n    }\n    const hiHi64 = BigInt.asIntN(64, v >> 192n); // keep sign bit\n    const hiLo64 = BigInt.asUintN(64, v >> 128n);\n    const loHi64 = BigInt.asUintN(64, v >> 64n);\n    const loLo64 = BigInt.asUintN(64, v);\n\n    return xdr.ScVal.scvI256(\n      new xdr.Int256Parts({\n        hiHi: new xdr.Int64(hiHi64),\n        hiLo: new xdr.Uint64(hiLo64),\n        loHi: new xdr.Uint64(loHi64),\n        loLo: new xdr.Uint64(loLo64),\n      }),\n    );\n  }\n\n  /**\n   * The integer encoded with `ScValType = U256`\n   *\n   * Note: No size check needed - U256 is the largest unsigned type.\n   */\n  toU256(): xdr.ScVal {\n    const v = this.int.toBigInt();\n    const hiHi64 = BigInt.asUintN(64, v >> 192n); // encode sign bit\n    const hiLo64 = BigInt.asUintN(64, v >> 128n);\n    const loHi64 = BigInt.asUintN(64, v >> 64n);\n    const loLo64 = BigInt.asUintN(64, v);\n\n    return xdr.ScVal.scvU256(\n      new xdr.UInt256Parts({\n        hiHi: new xdr.Uint64(hiHi64),\n        hiLo: new xdr.Uint64(hiLo64),\n        loHi: new xdr.Uint64(loHi64),\n        loLo: new xdr.Uint64(loLo64),\n      }),\n    );\n  }\n\n  /** The smallest interpretation of the stored value */\n  toScVal(): xdr.ScVal {\n    switch (this.type) {\n      case \"i64\":\n        return this.toI64();\n      case \"i128\":\n        return this.toI128();\n      case \"i256\":\n        return this.toI256();\n      case \"u64\":\n        return this.toU64();\n      case \"u128\":\n        return this.toU128();\n      case \"u256\":\n        return this.toU256();\n      case \"timepoint\":\n        return this.toTimepoint();\n      case \"duration\":\n        return this.toDuration();\n      default:\n        // This should be unreachable if the compiler enforces valid types\n        // This serves as a runtime check if the type is somehow invalid\n        // (e.g. from user input or a future extension)\n        throw TypeError(`invalid type: ${this.type as string}`);\n    }\n  }\n\n  /** Returns the primitive value of this integer. */\n  valueOf(): unknown {\n    return this.int.valueOf();\n  }\n\n  /** Returns the string representation of this integer. */\n  toString(): string {\n    return this.int.toString();\n  }\n\n  /** Returns a JSON-friendly representation with `value` and `type` fields. */\n  toJSON(): { value: string; type: string } {\n    return {\n      value: this.toBigInt().toString(),\n      type: this.type,\n    };\n  }\n\n  private _sizeCheck(bits: number): void {\n    if (this.int.size > bits) {\n      throw RangeError(`value too large for ${bits} bits (${this.type})`);\n    }\n  }\n\n  /** Returns true if the given string is a valid XDR large integer type name. */\n  static isType(type: string): type is ScIntType {\n    switch (type) {\n      case \"i64\":\n      case \"i128\":\n      case \"i256\":\n      case \"u64\":\n      case \"u128\":\n      case \"u256\":\n      case \"timepoint\":\n      case \"duration\":\n        return true;\n      default:\n        return false;\n    }\n  }\n\n  /**\n   * Convert the raw `ScValType` string (e.g. 'scvI128', generated by the XDR)\n   * to a type description for {@link XdrLargeInt} construction (e.g. 'i128')\n   *\n   * @param scvType - the `xdr.ScValType` as a string\n   * @returns the corresponding {@link ScIntType} if it's an integer type, or\n   *    `undefined` if it's not an integer type\n   */\n  static getType(scvType: string): ScIntType | undefined {\n    const type = scvType.slice(3).toLowerCase();\n    if (this.isType(type)) {\n      return type;\n    }\n\n    return undefined;\n  }\n}\n"],"names":["Hyper","Int128","Int256","UnsignedHyper","Uint128","Uint256","xdr"],"mappings":"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"}