@digitalworld/digital-world-sdk 16.0.0

package/lib/esm/base/numbers/index.js

@@ -0,0 +1,59 @@
+import { XdrLargeInt } from './xdr_large_int.js';
+export { Uint128 } from './uint128.js';
+export { Uint256 } from './uint256.js';
+export { Int128 } from './int128.js';
+export { Int256 } from './int256.js';
+
+function scValToBigInt(scv) {
+  const switchName = scv.switch().name;
+  const scIntType = XdrLargeInt.getType(switchName);
+  const value = scv.value();
+  if (value === null) {
+    throw TypeError(`unexpected null value for ${switchName}`);
+  }
+  switch (switchName) {
+    case "scvU32":
+    case "scvI32":
+      return BigInt(value);
+    case "scvU64":
+    case "scvI64":
+    case "scvTimepoint":
+    case "scvDuration":
+      if (scIntType === void 0) {
+        throw TypeError(`invalid integer type for ${switchName}`);
+      }
+      return new XdrLargeInt(
+        scIntType,
+        value
+      ).toBigInt();
+    case "scvU128":
+    case "scvI128": {
+      if (scIntType === void 0) {
+        throw TypeError(`invalid integer type for ${switchName}`);
+      }
+      const int128Value = value;
+      return new XdrLargeInt(scIntType, [
+        int128Value.lo(),
+        int128Value.hi()
+      ]).toBigInt();
+    }
+    case "scvU256":
+    case "scvI256": {
+      if (scIntType === void 0) {
+        throw TypeError(`invalid integer type for ${switchName}`);
+      }
+      const int256Value = value;
+      return new XdrLargeInt(scIntType, [
+        int256Value.loLo(),
+        int256Value.loHi(),
+        int256Value.hiLo(),
+        int256Value.hiHi()
+      ]).toBigInt();
+    }
+    default:
+      throw TypeError(`expected integer type, got ${switchName}`);
+  }
+}
+
+export { XdrLargeInt, scValToBigInt };
+//# sourceMappingURL=index.js.map

package/lib/esm/base/numbers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../src/base/numbers/index.ts"],"sourcesContent":["import xdr from \"../xdr.js\";\nimport { XdrLargeInt, type ScIntType } from \"./xdr_large_int.js\";\n\nexport { Uint128 } from \"./uint128.js\";\nexport { Uint256 } from \"./uint256.js\";\nexport { Int128 } from \"./int128.js\";\nexport { Int256 } from \"./int256.js\";\nexport { ScInt } from \"./sc_int.js\";\nexport { XdrLargeInt };\nexport type { ScIntType };\n\n/**\n * Transforms an opaque {@link xdr.ScVal} into a native bigint, if possible.\n *\n * If you then want to use this in the abstractions provided by this module,\n * you can pass it to the constructor of {@link XdrLargeInt}.\n *\n * @example\n * ```ts\n * let scv = contract.call(\"add\", x, y); // assume it returns an xdr.ScVal\n * let bigi = scValToBigInt(scv);\n *\n * new ScInt(bigi);               // if you don't care about types, and\n * new XdrLargeInt('i128', bigi); // if you do\n * ```\n *\n * @param scv - the XDR smart contract value to convert\n *\n * @throws if the `scv` input value doesn't represent an integer\n */\nexport function scValToBigInt(scv: xdr.ScVal): bigint {\n  const switchName = scv.switch().name;\n  const scIntType = XdrLargeInt.getType(switchName);\n  const value = scv.value();\n\n  if (value === null) {\n    throw TypeError(`unexpected null value for ${switchName}`);\n  }\n\n  switch (switchName) {\n    case \"scvU32\":\n    case \"scvI32\":\n      return BigInt(value as number);\n\n    case \"scvU64\":\n    case \"scvI64\":\n    case \"scvTimepoint\":\n    case \"scvDuration\":\n      if (scIntType === undefined) {\n        throw TypeError(`invalid integer type for ${switchName}`);\n      }\n      return new XdrLargeInt(\n        scIntType,\n        value as xdr.Int64 | xdr.Uint64,\n      ).toBigInt();\n\n    case \"scvU128\":\n    case \"scvI128\": {\n      if (scIntType === undefined) {\n        throw TypeError(`invalid integer type for ${switchName}`);\n      }\n      const int128Value = value as xdr.Int128Parts | xdr.UInt128Parts;\n      return new XdrLargeInt(scIntType, [\n        int128Value.lo(),\n        int128Value.hi(),\n      ]).toBigInt();\n    }\n\n    case \"scvU256\":\n    case \"scvI256\": {\n      if (scIntType === undefined) {\n        throw TypeError(`invalid integer type for ${switchName}`);\n      }\n      const int256Value = value as xdr.Int256Parts | xdr.UInt256Parts;\n      return new XdrLargeInt(scIntType, [\n        int256Value.loLo(),\n        int256Value.loHi(),\n        int256Value.hiLo(),\n        int256Value.hiHi(),\n      ]).toBigInt();\n    }\n\n    default:\n      throw TypeError(`expected integer type, got ${switchName}`);\n  }\n}\n"],"names":[],"mappings":";;;;;;AA8BO,SAAS,cAAc,GAAA,EAAwB;AACpD,EAAA,MAAM,UAAA,GAAa,GAAA,CAAI,MAAA,EAAO,CAAE,IAAA;AAChC,EAAA,MAAM,SAAA,GAAY,WAAA,CAAY,OAAA,CAAQ,UAAU,CAAA;AAChD,EAAA,MAAM,KAAA,GAAQ,IAAI,KAAA,EAAM;AAExB,EAAA,IAAI,UAAU,IAAA,EAAM;AAClB,IAAA,MAAM,SAAA,CAAU,CAAA,0BAAA,EAA6B,UAAU,CAAA,CAAE,CAAA;AAAA,EAC3D;AAEA,EAAA,QAAQ,UAAA;AAAY,IAClB,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AACH,MAAA,OAAO,OAAO,KAAe,CAAA;AAAA,IAE/B,KAAK,QAAA;AAAA,IACL,KAAK,QAAA;AAAA,IACL,KAAK,cAAA;AAAA,IACL,KAAK,aAAA;AACH,MAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,QAAA,MAAM,SAAA,CAAU,CAAA,yBAAA,EAA4B,UAAU,CAAA,CAAE,CAAA;AAAA,MAC1D;AACA,MAAA,OAAO,IAAI,WAAA;AAAA,QACT,SAAA;AAAA,QACA;AAAA,QACA,QAAA,EAAS;AAAA,IAEb,KAAK,SAAA;AAAA,IACL,KAAK,SAAA,EAAW;AACd,MAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,QAAA,MAAM,SAAA,CAAU,CAAA,yBAAA,EAA4B,UAAU,CAAA,CAAE,CAAA;AAAA,MAC1D;AACA,MAAA,MAAM,WAAA,GAAc,KAAA;AACpB,MAAA,OAAO,IAAI,YAAY,SAAA,EAAW;AAAA,QAChC,YAAY,EAAA,EAAG;AAAA,QACf,YAAY,EAAA;AAAG,OAChB,EAAE,QAAA,EAAS;AAAA,IACd;AAAA,IAEA,KAAK,SAAA;AAAA,IACL,KAAK,SAAA,EAAW;AACd,MAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,QAAA,MAAM,SAAA,CAAU,CAAA,yBAAA,EAA4B,UAAU,CAAA,CAAE,CAAA;AAAA,MAC1D;AACA,MAAA,MAAM,WAAA,GAAc,KAAA;AACpB,MAAA,OAAO,IAAI,YAAY,SAAA,EAAW;AAAA,QAChC,YAAY,IAAA,EAAK;AAAA,QACjB,YAAY,IAAA,EAAK;AAAA,QACjB,YAAY,IAAA,EAAK;AAAA,QACjB,YAAY,IAAA;AAAK,OAClB,EAAE,QAAA,EAAS;AAAA,IACd;AAAA,IAEA;AACE,MAAA,MAAM,SAAA,CAAU,CAAA,2BAAA,EAA8B,UAAU,CAAA,CAAE,CAAA;AAAA;AAEhE;;;;"}

package/lib/esm/base/numbers/int128.d.ts

@@ -0,0 +1,12 @@
+import { LargeInt } from "@stellar/js-xdr";
+export declare class Int128 extends LargeInt {
+    /**
+     * Construct a signed 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: Array<bigint | number | string>);
+    get unsigned(): boolean;
+    get size(): number;
+}

package/lib/esm/base/numbers/int128.js

@@ -0,0 +1,29 @@
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js';
+import { LargeInt } from '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js';
+import 'buffer';
+
+class Int128 extends LargeInt {
+  /**
+   * Construct a signed 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 false;
+  }
+  get size() {
+    return 128;
+  }
+}
+Int128.defineIntBoundaries();
+
+export { Int128 };
+//# sourceMappingURL=int128.js.map

package/lib/esm/base/numbers/int128.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"int128.js","sources":["../../../../src/base/numbers/int128.ts"],"sourcesContent":["import { LargeInt } from \"@stellar/js-xdr\";\n\nexport class Int128 extends LargeInt {\n  /**\n   * Construct a signed 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 false;\n  }\n\n  get size(): number {\n    return 128;\n  }\n}\n\nInt128.defineIntBoundaries();\n"],"names":[],"mappings":";;;;;;;;AAEO,MAAM,eAAe,QAAA,CAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOnC,eAAe,IAAA,EAAuC;AACpD,IAAA,KAAA,CAAM,IAAI,CAAA;AAAA,EACZ;AAAA,EAEA,IAAI,QAAA,GAAoB;AACtB,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,IAAI,IAAA,GAAe;AACjB,IAAA,OAAO,GAAA;AAAA,EACT;AACF;AAEA,MAAA,CAAO,mBAAA,EAAoB;;;;"}

package/lib/esm/base/numbers/int256.d.ts

@@ -0,0 +1,12 @@
+import { LargeInt } from "@stellar/js-xdr";
+export declare class Int256 extends LargeInt {
+    /**
+     * Construct a signed 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: Array<bigint | number | string>);
+    get unsigned(): boolean;
+    get size(): number;
+}

package/lib/esm/base/numbers/int256.js

@@ -0,0 +1,29 @@
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js';
+import { LargeInt } from '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js';
+import 'buffer';
+
+class Int256 extends LargeInt {
+  /**
+   * Construct a signed 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 false;
+  }
+  get size() {
+    return 256;
+  }
+}
+Int256.defineIntBoundaries();
+
+export { Int256 };
+//# sourceMappingURL=int256.js.map

package/lib/esm/base/numbers/int256.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"int256.js","sources":["../../../../src/base/numbers/int256.ts"],"sourcesContent":["import { LargeInt } from \"@stellar/js-xdr\";\n\nexport class Int256 extends LargeInt {\n  /**\n   * Construct a signed 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 false;\n  }\n\n  get size(): number {\n    return 256;\n  }\n}\n\nInt256.defineIntBoundaries();\n"],"names":[],"mappings":";;;;;;;;AAEO,MAAM,eAAe,QAAA,CAAS;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAOnC,eAAe,IAAA,EAAuC;AACpD,IAAA,KAAA,CAAM,IAAI,CAAA;AAAA,EACZ;AAAA,EAEA,IAAI,QAAA,GAAoB;AACtB,IAAA,OAAO,KAAA;AAAA,EACT;AAAA,EAEA,IAAI,IAAA,GAAe;AACjB,IAAA,OAAO,GAAA;AAAA,EACT;AACF;AAEA,MAAA,CAAO,mBAAA,EAAoB;;;;"}

package/lib/esm/base/numbers/sc_int.d.ts

@@ -0,0 +1,79 @@
+import { XdrLargeInt, type ScIntType } from "./xdr_large_int.js";
+/**
+ * Provides an easier way to manipulate large numbers for Stellar operations.
+ *
+ * You can instantiate this "**s**mart **c**ontract integer" value either from
+ * bigints, strings, or numbers (whole numbers, or this will throw).
+ *
+ * If you need to create a native BigInt from a list of integer "parts" (for
+ * example, you have a series of encoded 32-bit integers that represent a larger
+ * value), you can use the lower level abstraction {@link XdrLargeInt}. For
+ * example, you could do `new XdrLargeInt('u128', bytes...).toBigInt()`.
+ *
+ * @example
+ * ```ts
+ * import { xdr, ScInt, scValToBigInt } from "@stellar/stellar-base";
+ *
+ * // You have an ScVal from a contract and want to parse it into JS native.
+ * const value = xdr.ScVal.fromXDR(someXdr, "base64");
+ * const bigi = scValToBigInt(value); // grab it as a BigInt
+ * let sci = new ScInt(bigi);
+ *
+ * sci.toNumber(); // gives native JS type (w/ size check)
+ * sci.toBigInt(); // gives the native BigInt value
+ * sci.toU64();    // gives ScValType-specific XDR constructs (with size checks)
+ *
+ * // You have a number and want to shove it into a contract.
+ * sci = new 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:
+ * new ScInt("123456789123456789")
+ * new ScInt(123456789123456789n);
+ * new ScInt(1n << 140n);
+ * new ScInt(-42);
+ * new ScInt(scValToBigInt(scValU128)); // from above
+ *
+ * // If you know the type ahead of time (accessing `.raw` is faster than
+ * // conversions), you can specify the type directly (otherwise, it's
+ * // interpreted from the numbers you pass in):
+ * const i = new 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();
+ * ```
+ *
+ * @throws if the `value` is invalid (e.g. floating point), too
+ *    large (i.e. exceeds a 256-bit value), doesn't fit in the `opts.type`,
+ *    the signedness of `opts.type` doesn't match the input `value`, or a
+ *    string `value` can't be parsed as a big integer
+ */
+export declare class ScInt extends 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: bigint | number | string, opts?: {
+        type?: ScIntType;
+        [key: string]: unknown;
+    });
+}

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

@@ -0,0 +1,52 @@
+import { XdrLargeInt } from './xdr_large_int.js';
+
+class ScInt extends 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;
+}
+
+export { ScInt };
+//# sourceMappingURL=sc_int.js.map

package/lib/esm/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":["bitlen"],"mappings":";;AA8DO,MAAM,cAAc,WAAA,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,MAAMA,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/esm/base/numbers/uint128.d.ts

@@ -0,0 +1,12 @@
+import { LargeInt } from "@stellar/js-xdr";
+export declare class Uint128 extends 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: Array<bigint | number | string>);
+    get unsigned(): boolean;
+    get size(): number;
+}

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

@@ -0,0 +1,29 @@
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js';
+import { LargeInt } from '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js';
+import 'buffer';
+
+class Uint128 extends 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();
+
+export { Uint128 };
+//# sourceMappingURL=uint128.js.map

package/lib/esm/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":[],"mappings":";;;;;;;;AAEO,MAAM,gBAAgB,QAAA,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/esm/base/numbers/uint256.d.ts

@@ -0,0 +1,12 @@
+import { LargeInt } from "@stellar/js-xdr";
+export declare class Uint256 extends 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: Array<bigint | number | string>);
+    get unsigned(): boolean;
+    get size(): number;
+}

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

@@ -0,0 +1,29 @@
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/hyper.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/unsigned-hyper.js';
+import { LargeInt } from '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/large-int.js';
+import '../../node_modules/.pnpm/@stellar_js-xdr@4.0.0/node_modules/@stellar/js-xdr/src/xdr-type.js';
+import 'buffer';
+
+class Uint256 extends 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();
+
+export { Uint256 };
+//# sourceMappingURL=uint256.js.map

package/lib/esm/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":[],"mappings":";;;;;;;;AAEO,MAAM,gBAAgB,QAAA,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/esm/base/numbers/xdr_large_int.d.ts

@@ -0,0 +1,93 @@
+import { LargeInt } from "@stellar/js-xdr";
+import xdr from "../xdr.js";
+type BigIntLike = {
+    toBigInt(): bigint;
+};
+type XdrLargeIntValues = Array<BigIntLike | bigint | number | string> | BigIntLike | bigint | number | string;
+export type ScIntType = "duration" | "i64" | "i128" | "i256" | "timepoint" | "u64" | "u128" | "u256";
+/**
+ * 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.
+ */
+export declare class XdrLargeInt {
+    int: LargeInt;
+    type: ScIntType;
+    /**
+     * @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: ScIntType, values: XdrLargeIntValues);
+    /**
+     * Converts to a native JS number.
+     *
+     * @throws if the value can't fit into a Number
+     */
+    toNumber(): number;
+    /** Converts to a native BigInt. */
+    toBigInt(): bigint;
+    /**
+     * The integer encoded with `ScValType = I64`.
+     *
+     * @throws if the value cannot fit in 64 bits
+     */
+    toI64(): xdr.ScVal;
+    /** The integer encoded with `ScValType = U64` */
+    toU64(): xdr.ScVal;
+    /** The integer encoded with `ScValType = Timepoint` */
+    toTimepoint(): xdr.ScVal;
+    /** The integer encoded with `ScValType = Duration` */
+    toDuration(): xdr.ScVal;
+    /**
+     * The integer encoded with `ScValType = I128`.
+     *
+     * @throws if the value cannot fit in 128 bits
+     */
+    toI128(): xdr.ScVal;
+    /**
+     * The integer encoded with `ScValType = U128`.
+     *
+     * @throws if the value cannot fit in 128 bits
+     */
+    toU128(): xdr.ScVal;
+    /**
+     * The integer encoded with `ScValType = I256`
+     *
+     * @throws if the value cannot fit in a signed 256-bit integer
+     */
+    toI256(): xdr.ScVal;
+    /**
+     * The integer encoded with `ScValType = U256`
+     *
+     * Note: No size check needed - U256 is the largest unsigned type.
+     */
+    toU256(): xdr.ScVal;
+    /** The smallest interpretation of the stored value */
+    toScVal(): xdr.ScVal;
+    /** Returns the primitive value of this integer. */
+    valueOf(): unknown;
+    /** Returns the string representation of this integer. */
+    toString(): string;
+    /** Returns a JSON-friendly representation with `value` and `type` fields. */
+    toJSON(): {
+        value: string;
+        type: string;
+    };
+    private _sizeCheck;
+    /** Returns true if the given string is a valid XDR large integer type name. */
+    static isType(type: string): type is ScIntType;
+    /**
+     * 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: string): ScIntType | undefined;
+}
+export {};