Rename XdrLargeInt -> Int

Author: Shaptic

CHANGELOG.md

@@ -9,19 +9,19 @@
 new ScInt(value);
 new ScInt(value, { type: 'i128' });
 // after:
-XdrLargeInt.fromValue(value);
-new XdrLargeInt('i128', value);
+Int.fromValue(value);
+new Int('i128', value);
 
 // before:
 scValToBigInt(scv);
 // after:
-XdrLargeInt.fromScVal(scv).toBigInt();
+Int.fromScVal(scv).toBigInt();
 ```
 
 ### Added
-* `XdrLargeInt` has new features ([]()):
-  - `fromValue(x: number|string|BigInt)` will create an `XdrLargeInt` of an appopriate size for the given value
-  - `fromScVal(x: xdr.ScVal)` will create an `XdrLargeInt` from an `ScVal`
+* `XdrLargeInt` (renamed to `Int`) has new features ([]()):
+  - `fromValue(x: number|string|BigInt)` will create an `Int` of an appopriate size for the given value
+  - `fromScVal(x: xdr.ScVal)` will create an `Int` from an `ScVal`
   - `.toU32()` will return an `ScVal` of the type `scvU32`
   - `.toI32()` will return an `ScVal` of the type `scvI32`
   - the constructor now accepts `i32` and `u32` as the first `type` parameter

src/numbers/index.js

@@ -4,4 +4,4 @@ export { Uint128 } from './uint128';
 export { Uint256 } from './uint256';
 export { Int128 } from './int128';
 export { Int256 } from './int256';
-export { XdrLargeInt };
+export { XdrLargeInt as Int };

src/scval.js

@@ -3,7 +3,7 @@ import xdr from './xdr';
 import { Keypair } from './keypair';
 import { Address } from './address';
 import { Contract } from './contract';
-import { XdrLargeInt } from './numbers';
+import { Int } from './numbers';
 
 /**
  * Attempts to convert native types into smart contract values
@@ -21,7 +21,7 @@ import { XdrLargeInt } from './numbers';
  *  - boolean -> scvBool
  *
  *  - number/bigint -> the smallest possible XDR integer type that will fit the
- *    input value (if you want a specific type, use {@link XdrLargeInt})
+ *    input value (if you want a specific type, use {@link Int})
  *
  *  - {@link Address} or {@link Contract} -> scvAddress (for contracts and
  *    public keys)
@@ -46,7 +46,7 @@ import { XdrLargeInt } from './numbers';
  *    types for `val`:
  *
  *     - when `val` is an integer-like type (i.e. number|bigint), this will be
- *       forwarded to {@link XdrLargeInt}.
+ *       forwarded to {@link Int}.
  *
  *     - when `val` is an array type, this is forwarded to the recursion
  *
@@ -244,10 +244,10 @@ export function nativeToScVal(val, opts = {}) {
       }
 
       if ((opts?.type ?? '') !== '') {
-        return new XdrLargeInt(opts.type, val).toScVal();
+        return new Int(opts.type, val).toScVal();
       }
 
-      return XdrLargeInt.fromValue(val).toScVal();
+      return Int.fromValue(val).toScVal();
 
     case 'string': {
       const optType = opts?.type ?? 'string';
@@ -268,8 +268,8 @@ export function nativeToScVal(val, opts = {}) {
           return xdr.ScVal.scvI32(parseInt(val, 10));
 
         default:
-          if (XdrLargeInt.isType(optType)) {
-            return new XdrLargeInt(optType, val).toScVal();
+          if (Int.isType(optType)) {
+            return new Int(optType, val).toScVal();
           }
 
           throw new TypeError(
@@ -335,7 +335,7 @@ export function scValToNative(scv) {
     case xdr.ScValType.scvI128().value:
     case xdr.ScValType.scvU256().value:
     case xdr.ScValType.scvI256().value:
-      return XdrLargeInt.fromScVal(scv).toBigInt();
+      return Int.fromScVal(scv).toBigInt();
 
     case xdr.ScValType.scvVec().value:
       return (scv.vec() ?? []).map(scValToNative);

test/unit/int_test.js

@@ -2,7 +2,7 @@ const I128 = StellarBase.Int128;
 const U128 = StellarBase.Uint128;
 const I256 = StellarBase.Int256;
 const U256 = StellarBase.Uint256;
-const { xdr, XdrLargeInt } = StellarBase; // shorthand
+const { xdr, Int } = StellarBase; // shorthand
 
 describe('creating large integers', function () {
   describe('picks the right types', function () {
@@ -14,7 +14,7 @@ describe('creating large integers', function () {
     }).forEach(([type, values]) => {
       values.forEach((value) => {
         it(`picks ${type} for ${value}`, function () {
-          const bi = XdrLargeInt.fromValue(value);
+          const bi = Int.fromValue(value);
           expect(bi.type).to.equal(type);
           expect(bi.toBigInt()).to.equal(BigInt(value));
         });
@@ -25,7 +25,7 @@ describe('creating large integers', function () {
   it('has correct utility methods', function () {
     const v =
       123456789123456789123456789123456789123456789123456789123456789123456789n;
-    const i = XdrLargeInt.fromValue(v);
+    const i = Int.fromValue(v);
     expect(i.valueOf()).to.be.eql(new U256(v));
     expect(i.toString()).to.equal(v.toString());
     expect(i.toJSON()).to.be.eql({ value: v.toString(), type: 'u256' });
@@ -35,14 +35,14 @@ describe('creating large integers', function () {
     const sentinel = 800000085n;
 
     it('handles u64', function () {
-      let b = XdrLargeInt.fromValue(sentinel);
+      let b = Int.fromValue(sentinel);
       expect(b.toBigInt()).to.equal(sentinel);
       expect(b.toNumber()).to.equal(Number(sentinel));
       let u64 = b.toU64().u64();
       expect(u64.low).to.equal(Number(sentinel));
       expect(u64.high).to.equal(0);
 
-      b = XdrLargeInt.fromValue(-sentinel);
+      b = Int.fromValue(-sentinel);
       expect(b.toBigInt()).to.equal(-sentinel);
       expect(b.toNumber()).to.equal(Number(-sentinel));
       u64 = b.toU64().u64();
@@ -51,7 +51,7 @@ describe('creating large integers', function () {
     });
 
     it('handles i64', function () {
-      let b = XdrLargeInt.fromValue(sentinel);
+      let b = Int.fromValue(sentinel);
       expect(b.toBigInt()).to.equal(sentinel);
       expect(b.toNumber()).to.equal(Number(sentinel));
       let i64 = b.toI64().i64();
@@ -60,14 +60,14 @@ describe('creating large integers', function () {
     });
 
     it(`upscales u64 to 128`, function () {
-      const b = XdrLargeInt.fromValue(sentinel);
+      const b = Int.fromValue(sentinel);
       const i128 = b.toI128().i128();
       expect(i128.lo().toBigInt()).to.equal(sentinel);
       expect(i128.hi().toBigInt()).to.equal(0n);
     });
 
     it(`upscales i64 to 128`, function () {
-      const b = XdrLargeInt.fromValue(-sentinel);
+      const b = Int.fromValue(-sentinel);
       const i128 = b.toI128().i128();
       const hi = i128.hi().toBigInt();
       const lo = i128.lo().toBigInt();
@@ -77,7 +77,7 @@ describe('creating large integers', function () {
     });
 
     it(`upscales i64 to 256`, function () {
-      const b = XdrLargeInt.fromValue(sentinel);
+      const b = Int.fromValue(sentinel);
       const i = b.toI256().i256();
 
       const [hiHi, hiLo, loHi, loLo] = [
@@ -100,7 +100,7 @@ describe('creating large integers', function () {
     });
 
     it(`upscales i64 to 256`, function () {
-      const b = XdrLargeInt.fromValue(-sentinel);
+      const b = Int.fromValue(-sentinel);
       const i = b.toI256().i256();
 
       const [hiHi, hiLo, loHi, loLo] = [
@@ -127,7 +127,7 @@ describe('creating large integers', function () {
     const sentinel = 800000000000000000000085n; // 80 bits long
 
     it('handles inputs', function () {
-      let b = XdrLargeInt.fromValue(sentinel);
+      let b = Int.fromValue(sentinel);
       expect(b.toBigInt()).to.equal(sentinel);
       expect(() => b.toNumber()).to.throw(/not in range/i);
       expect(() => b.toU64()).to.throw(/too large/i);
@@ -143,7 +143,7 @@ describe('creating large integers', function () {
         ]).toBigInt()
       ).to.equal(sentinel);
 
-      b = XdrLargeInt.fromValue(-sentinel);
+      b = Int.fromValue(-sentinel);
       u128 = b.toU128().u128();
       expect(
         new U128([
@@ -154,7 +154,7 @@ describe('creating large integers', function () {
         ]).toBigInt()
       ).to.equal(BigInt.asUintN(128, -sentinel));
 
-      b = XdrLargeInt.fromValue(sentinel);
+      b = Int.fromValue(sentinel);
       let i128 = b.toI128().i128();
       expect(
         new I128([
@@ -165,7 +165,7 @@ describe('creating large integers', function () {
         ]).toBigInt()
       ).to.equal(sentinel);
 
-      b = XdrLargeInt.fromValue(-sentinel);
+      b = Int.fromValue(-sentinel);
       i128 = b.toI128().i128();
       expect(
         new I128([
@@ -178,7 +178,7 @@ describe('creating large integers', function () {
     });
 
     it('upscales to 256 bits', function () {
-      let b = XdrLargeInt.fromValue(-sentinel);
+      let b = Int.fromValue(-sentinel);
       let i256 = b.toI256().i256();
       let u256 = b.toU256().u256();
 
@@ -212,7 +212,7 @@ describe('creating large integers', function () {
 
   describe('conversion to/from ScVals', function () {
     const v = 80000085n;
-    const i = XdrLargeInt.fromValue(v);
+    const i = Int.fromValue(v);
 
     [
       [i.toI64(), 'i64'],
@@ -226,9 +226,9 @@ describe('creating large integers', function () {
         expect(scv.switch().name).to.equal(`scv${type.toUpperCase()}`);
         expect(typeof scv.toXDR('base64')).to.equal('string');
 
-        const bigi = StellarBase.XdrLargeInt.fromScVal(scv).toBigInt();
+        const bigi = StellarBase.Int.fromScVal(scv).toBigInt();
         expect(bigi).to.equal(v);
-        expect(new StellarBase.XdrLargeInt(type, bigi).toJSON()).to.eql({
+        expect(new StellarBase.Int(type, bigi).toJSON()).to.eql({
           ...i.toJSON(),
           type
         });
@@ -239,44 +239,44 @@ describe('creating large integers', function () {
       const i32 = new xdr.ScVal.scvI32(Number(v));
       const u32 = new xdr.ScVal.scvU32(Number(v));
 
-      expect(XdrLargeInt.fromScVal(i32).toBigInt()).to.equal(v);
-      expect(XdrLargeInt.fromScVal(u32).toBigInt()).to.equal(v);
+      expect(Int.fromScVal(i32).toBigInt()).to.equal(v);
+      expect(Int.fromScVal(u32).toBigInt()).to.equal(v);
     });
 
     it('throws for non-integers', function () {
       expect(() =>
-        XdrLargeInt.fromScVal(new xdr.ScVal.scvString('hello'))
+        Int.fromScVal(new xdr.ScVal.scvString('hello'))
       ).to.throw(/integer/i);
     });
   });
 
   describe('error handling', function () {
     ['u64', 'u128', 'u256'].forEach((type) => {
       it(`throws when signed parts and {type: '${type}'}`, function () {
-        expect(() => new StellarBase.XdrLargeInt(type, -2)).to.throw(
+        expect(() => new StellarBase.Int(type, -2)).to.throw(
           /positive/i
         );
       });
     });
 
     it('throws when too big', function () {
-      expect(() => XdrLargeInt.fromValue(1n << 400n)).to.throw(/expected/i);
+      expect(() => Int.fromValue(1n << 400n)).to.throw(/expected/i);
     });
 
     it('throws when big interpreted as small', function () {
       let big;
 
-      big = XdrLargeInt.fromValue(1n << 64n);
+      big = Int.fromValue(1n << 64n);
       expect(() => big.toNumber()).to.throw(/not in range/i);
 
-      big = XdrLargeInt.fromValue(Number.MAX_SAFE_INTEGER + 1);
+      big = Int.fromValue(Number.MAX_SAFE_INTEGER + 1);
       expect(() => big.toNumber()).to.throw(/not in range/i);
 
-      big = new XdrLargeInt('i128', 1);
+      big = new Int('i128', 1);
       expect(() => big.toU64()).to.throw(/too large/i);
       expect(() => big.toI64()).to.throw(/too large/i);
 
-      big = new XdrLargeInt('i256', 1);
+      big = new Int('i256', 1);
       expect(() => big.toU64()).to.throw(/too large/i);
       expect(() => big.toI64()).to.throw(/too large/i);
       expect(() => big.toI128()).to.throw(/too large/i);
@@ -294,7 +294,7 @@ describe('creating raw large XDR integers', function () {
     ].forEach(([type, count], idx) => {
       it(`works for ${type}`, function () {
         const input = new Array(count).fill(1n);
-        const xdrI = new StellarBase.XdrLargeInt(type, input);
+        const xdrI = new StellarBase.Int(type, input);
 
         let expected = input.reduce((accum, v, i) => {
           return (accum << 32n) | v;

test/unit/scval_test.js

@@ -2,7 +2,7 @@ const {
   xdr,
   Address,
   Keypair,
-  XdrLargeInt,
+  Int,
   scValToNative,
   nativeToScVal,
   scValToBigInt
@@ -16,10 +16,10 @@ describe('parsing and building ScVals', function () {
     i32: xdr.ScVal.scvI32(1),
     u64: BigInt(2 ** 33),
     i64: BigInt(-1 * 2 ** 33),
-    u128: XdrLargeInt.fromValue(1).toU128(),
-    i128: XdrLargeInt.fromValue(1).toI128(),
-    u256: XdrLargeInt.fromValue(1).toU256(),
-    i256: XdrLargeInt.fromValue(1).toI256(),
+    u128: Int.fromValue(1).toU128(),
+    i128: Int.fromValue(1).toI128(),
+    u256: Int.fromValue(1).toU256(),
+    i256: Int.fromValue(1).toI256(),
     map: {
       arbitrary: 1n,
       nested: 'values',
@@ -31,8 +31,8 @@ describe('parsing and building ScVals', function () {
   const targetScv = xdr.ScVal.scvMap(
     [
       ['bool', xdr.ScVal.scvBool(true)],
-      ['i128', new XdrLargeInt('i128', 1).toScVal()],
-      ['i256', new XdrLargeInt('i256', 1).toScVal()],
+      ['i128', new Int('i128', 1).toScVal()],
+      ['i256', new Int('i256', 1).toScVal()],
       ['i32', xdr.ScVal.scvI32(1)],
       ['i64', xdr.ScVal.scvI64(new xdr.Int64(-1 * 2 ** 33))],
       [
@@ -52,8 +52,8 @@ describe('parsing and building ScVals', function () {
           })
         ])
       ],
-      ['u128', new XdrLargeInt('u128', 1).toScVal()],
-      ['u256', new XdrLargeInt('u256', 1).toScVal()],
+      ['u128', new Int('u128', 1).toScVal()],
+      ['u256', new Int('u256', 1).toScVal()],
       ['u32', xdr.ScVal.scvU32(1)],
       ['u64', xdr.ScVal.scvU64(new xdr.Uint64(2 ** 33))],
       [
@@ -98,14 +98,14 @@ describe('parsing and building ScVals', function () {
       [xdr.ScVal.scvVoid(), null],
       [xdr.ScVal.scvBool(true), true],
       [xdr.ScVal.scvBool(false), false],
-      [XdrLargeInt.fromValue(1).toU32(), 1],
-      [XdrLargeInt.fromValue(1).toI32(), 1],
-      [XdrLargeInt.fromValue(11).toU64(), 11n],
-      [XdrLargeInt.fromValue(11).toI64(), 11n],
-      [XdrLargeInt.fromValue(22).toU128(), 22n],
-      [XdrLargeInt.fromValue(22).toI128(), 22n],
-      [XdrLargeInt.fromValue(33).toU256(), 33n],
-      [XdrLargeInt.fromValue(33).toI256(), 33n],
+      [Int.fromValue(1).toU32(), 1],
+      [Int.fromValue(1).toI32(), 1],
+      [Int.fromValue(11).toU64(), 11n],
+      [Int.fromValue(11).toI64(), 11n],
+      [Int.fromValue(22).toU128(), 22n],
+      [Int.fromValue(22).toI128(), 22n],
+      [Int.fromValue(33).toU256(), 33n],
+      [Int.fromValue(33).toI256(), 33n],
       [xdr.ScVal.scvTimepoint(new xdr.Uint64(44n)), 44n],
       [xdr.ScVal.scvDuration(new xdr.Uint64(55n)), 55n],
       [xdr.ScVal.scvBytes(Buffer.alloc(32, 123)), Buffer.from('{'.repeat(32))],
@@ -125,7 +125,7 @@ describe('parsing and building ScVals', function () {
       [
         xdr.ScVal.scvMap(
           [
-            [XdrLargeInt.fromValue(0).toI256(), xdr.ScVal.scvBool(true)],
+            [Int.fromValue(0).toI256(), xdr.ScVal.scvBool(true)],
             [xdr.ScVal.scvBool(false), xdr.ScVal.scvString('second')],
             [
               xdr.ScVal.scvU32(2),
@@ -238,8 +238,8 @@ describe('parsing and building ScVals', function () {
   it('lets strings be large integer ScVals', function () {
     ['i64', 'i128', 'i256', 'u64', 'u128', 'u256'].forEach((type) => {
       const scv = nativeToScVal('12345', { type });
-      expect(XdrLargeInt.getType(scv.switch().name)).to.equal(type);
-      expect(XdrLargeInt.fromScVal(scv).toBigInt()).to.equal(BigInt(12345));
+      expect(Int.getType(scv.switch().name)).to.equal(type);
+      expect(Int.fromScVal(scv).toBigInt()).to.equal(BigInt(12345));
     });
 
     expect(() => nativeToScVal('not a number', { type: 'i128' })).to.throw();