Check sign flag for i{8, 16, 32, ...} conversions

CHANGELOG.md

@@ -1,5 +1,12 @@
 # CHANGELOG
 
+## master
+
+Changes:
+
+- Fix `u8aTo{BigInt, Bn, Number}` for non-negative `i{8, 16, 32...}` inputs
+
+
 ## 12.4.1 Aug 17, 2023
 
 Changes:

packages/util/src/bi/toU8a.spec.ts

@@ -4,12 +4,29 @@
 /// <reference types="@polkadot/dev-test/globals.d.ts" />
 
 import { arrayRange } from '../array/index.js';
+import { TESTS } from '../bn/toU8a.spec.js';
 import { perf } from '../test/index.js';
 import { nToU8a } from './index.js';
 
 const ptest = arrayRange(65536).map((v) => [v]);
 
 describe('nToU8a', (): void => {
+  describe('conversion tests', (): void => {
+    for (let i = 0, count = TESTS.length; i < count; i++) {
+      const [isLe, isNegative, numarr, strval] = TESTS[i];
+      const bitLength = numarr.length * 8;
+
+      it(`${i}: converts from ${strval} (bitLength=${bitLength}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
+        expect(
+          nToU8a(
+            BigInt(strval),
+            { bitLength, isLe, isNegative }
+          )
+        ).toEqual(new Uint8Array(numarr));
+      });
+    }
+  });
+
   it('converts null values to 0x00', (): void => {
     expect(
       nToU8a(null)
@@ -40,23 +57,5 @@ describe('nToU8a', (): void => {
     ).toEqual(new Uint8Array([0x56, 0x34, 0x12, 0x00]));
   });
 
-  it('converts negative numbers', (): void => {
-    expect(
-      nToU8a(-1234n, { isNegative: true })
-    ).toEqual(new Uint8Array([46, 251]));
-  });
-
-  it('converts negative numbers (BE)', (): void => {
-    expect(
-      nToU8a(-1234n, { isLe: false, isNegative: true })
-    ).toEqual(new Uint8Array([251, 46]));
-  });
-
-  it('converts negative numbers (bitLength)', (): void => {
-    expect(
-      nToU8a(-1234n, { bitLength: 32, isNegative: true })
-    ).toEqual(new Uint8Array([46, 251, 255, 255]));
-  });
-
   perf('nToU8a', 250000, ptest, nToU8a);
 });

packages/util/src/bi/toU8a.ts

@@ -14,15 +14,16 @@ const NEG_MASK = BigInt(0xff);
 
 function toU8a (value: bigint, isLe: boolean, isNegative: boolean): Uint8Array {
   const arr: number[] = [];
+  const withSigned = isNegative && (value < _0n);
 
-  if (isNegative) {
+  if (withSigned) {
     value = (value + _1n) * -_1n;
   }
 
   while (value !== _0n) {
     const mod = value % DIV;
     const val = Number(
-      isNegative
+      withSigned
         ? mod ^ NEG_MASK
         : mod
     );

packages/util/src/bn/toU8a.spec.ts

@@ -9,7 +9,63 @@ import { BN, bnToU8a } from './index.js';
 
 const ptest = arrayRange(65536).map((v) => [v]);
 
+// eslint-disable-next-line jest/no-export
+export const TESTS: [isLe: boolean, isNegative: boolean, numarr: number[], strval: string][] = [
+  // LE, positive numbers
+  [true, false, [0x12], '18'],
+  [true, false, [0x12, 0x34], '13330'],
+  [true, false, [0x12, 0x34, 0x56], '5649426'],
+  [true, false, [0x12, 0x34, 0x56, 0x78], '2018915346'],
+  [true, false, [0x12, 0x34, 0x56, 0x78, 0x9a], '663443878930'],
+  [true, false, [0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc], '207371629900818'],
+  [true, false, [0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78], '159954953172672629770948536149615195154'],
+  // LE, positive numbers (w/ signed flag)
+  [true, true, [12], '12'],
+  [true, true, [210, 4], '1234'],
+  [true, true, [64, 226, 1], '123456'],
+  [true, true, [21, 205, 91, 7], '123456789'],
+  [true, true, [203, 36, 104, 12, 8], '34567890123'],
+  [true, true, [255, 159, 114, 78, 24, 9], '9999999999999'],
+  // LE, negative numbers
+  [true, true, [244], '-12'],
+  [true, true, [46, 251], '-1234'],
+  [true, true, [192, 29, 254], '-123456'],
+  [true, true, [255, 255, 255, 255], '-1'],
+  [true, true, [254, 255, 255, 255], '-2'],
+  [true, true, [235, 50, 164, 248], '-123456789'],
+  [true, true, [0, 0, 0, 128], '-2147483648'],
+  [true, true, [0, 0, 0, 240], '-268435456'],
+  [true, true, [65, 86, 129, 173, 254], '-5678999999'],
+  [true, true, [1, 96, 141, 177, 231, 246], '-9999999999999'],
+  [true, true, [1, 0, 156, 88, 76, 73, 31, 242], '-999999999999999999'],
+  // BE
+  [false, false, [0x12], '18'],
+  [false, false, [0x12, 0x34], '4660'],
+  [false, false, [0x12, 0x34, 0x56], '1193046'],
+  [false, false, [0x12, 0x34, 0x56, 0x78], '305419896'],
+  [false, true, [0xf2, 0x34, 0x56, 0x78], '-231451016'],
+  [false, false, [0x12, 0x34, 0x56, 0x78, 0x9a], '78187493530'],
+  [false, false, [0x12, 0x34, 0x56, 0x78, 0x9a, 0xbc], '20015998343868'],
+  [false, false, [0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78, 0x12, 0x34, 0x56, 0x78], '24197857161011715162171839636988778104']
+];
+
 describe('bnToU8a', (): void => {
+  describe('conversion tests', (): void => {
+    for (let i = 0, count = TESTS.length; i < count; i++) {
+      const [isLe, isNegative, numarr, strval] = TESTS[i];
+      const bitLength = numarr.length * 8;
+
+      it(`${i}: converts from ${strval} (bitLength=${bitLength}, isLe=${isLe}, isNegative=${isNegative})`, (): void => {
+        expect(
+          bnToU8a(
+            new BN(strval),
+            { bitLength, isLe, isNegative }
+          )
+        ).toEqual(new Uint8Array(numarr));
+      });
+    }
+  });
+
   it('converts null values to 0x00', (): void => {
     expect(
       bnToU8a(null)
@@ -40,67 +96,5 @@ describe('bnToU8a', (): void => {
     ).toEqual(new Uint8Array([0x56, 0x34, 0x12, 0x00]));
   });
 
-  describe('signed', (): void => {
-    it('converts negative numbers (BE)', (): void => {
-      expect(
-        bnToU8a(new BN(-1234), { isLe: false, isNegative: true })
-      ).toEqual(new Uint8Array([251, 46]));
-    });
-
-    it('converts negative numbers (LE, i8)', (): void => {
-      expect(
-        bnToU8a(new BN(-12), { isNegative: true })
-      ).toEqual(new Uint8Array([244]));
-    });
-
-    it('converts negative numbers (LE, i16)', (): void => {
-      expect(
-        bnToU8a(new BN(-1234), { isNegative: true })
-      ).toEqual(new Uint8Array([46, 251]));
-    });
-
-    it('converts negative numbers (LE, i24)', (): void => {
-      expect(
-        bnToU8a(new BN(-123456), { isNegative: true })
-      ).toEqual(new Uint8Array([192, 29, 254]));
-    });
-
-    it('converts negative numbers (LE, i32)', (): void => {
-      expect(
-        bnToU8a(new BN(-123456789), { isNegative: true })
-      ).toEqual(new Uint8Array([235, 50, 164, 248]));
-    });
-
-    it('converts negative numbers (LE, i40)', (): void => {
-      expect(
-        bnToU8a(new BN(-5678999999), { isNegative: true })
-      ).toEqual(new Uint8Array([65, 86, 129, 173, 254]));
-    });
-
-    it('converts negative numbers (LE, i48)', (): void => {
-      expect(
-        bnToU8a(new BN(-9999999999999), { isNegative: true })
-      ).toEqual(new Uint8Array([1, 96, 141, 177, 231, 246]));
-    });
-
-    it('converts negative numbers (LE, i64)', (): void => {
-      expect(
-        bnToU8a(new BN('-999999999999999999'), { isNegative: true })
-      ).toEqual(new Uint8Array([1, 0, 156, 88, 76, 73, 31, 242]));
-    });
-
-    it('converts negative numbers (LE, bitLength)', (): void => {
-      expect(
-        bnToU8a(new BN(-1234), { bitLength: 32, isNegative: true })
-      ).toEqual(new Uint8Array([46, 251, 255, 255]));
-    });
-
-    it('converts negative numbers (LE, bitLength, check)', (): void => {
-      expect(
-        bnToU8a(new BN(-123456), { bitLength: 32, isNegative: true })
-      ).toEqual(new Uint8Array([192, 29, 254, 255]));
-    });
-  });
-
   perf('bnToU8a', 250000, ptest, bnToU8a);
 });