[CI Skip] release/stable 2.18.1

skip-checks: true

CHANGELOG.md

@@ -1,5 +1,18 @@
 # CHANGELOG
 
+## 2.18.1 Jul 13, 2020
+
+- Add `base64{Decode, Encode, Validate}` as crypto utils
+- Extract `base58Validate` from base58 decode checks
+- Add `isAscii` to allow detection of printable ASCII sequences (including tab, newline)
+- Add `isUtf8` to allow detection of valid Utf8 sequences
+
+## 2.17.1 Jul 6, 2020
+
+- Add `encode{Derived, Multi}Address` to encode derived/multi addresses
+- Correctly handle 0 inputs in `numberToU8a`
+- Simplify and flatten base58 dependencies
+
 ## 2.16.1 Jun 29, 2020
 
 - Adjust `addressCheck` and `encodeAddress` function to check for valid base58 alphabets (better error reporting)

lerna.json

@@ -9,5 +9,5 @@
   "packages": [
     "packages/*"
   ],
-  "version": "2.16.1"
+  "version": "2.18.1"
 }

package.json

@@ -21,10 +21,10 @@
     "test:one": "polkadot-dev-run-test"
   },
   "devDependencies": {
-    "@babel/core": "^7.10.3",
-    "@polkadot/dev": "^0.55.13",
-    "@polkadot/ts": "^0.3.26",
-    "@types/jest": "^26.0.3"
+    "@babel/core": "^7.10.4",
+    "@polkadot/dev": "^0.55.21",
+    "@polkadot/ts": "^0.3.27",
+    "@types/jest": "^26.0.4"
   },
-  "version": "2.16.1"
+  "version": "2.18.1"
 }

packages/keyring/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/keyring",
-  "version": "2.16.1",
+  "version": "2.18.1",
   "description": "Keyring management",
   "main": "index.js",
   "publishConfig": {
@@ -27,8 +27,8 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/keyring#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.3",
-    "@polkadot/util": "2.16.1",
-    "@polkadot/util-crypto": "2.16.1"
+    "@babel/runtime": "^7.10.4",
+    "@polkadot/util": "2.18.1",
+    "@polkadot/util-crypto": "2.18.1"
   }
 }

packages/util-crypto/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util-crypto",
-  "version": "2.16.1",
+  "version": "2.18.1",
   "description": "A collection of useful crypto utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,14 +25,13 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util-crypto#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.3",
-    "@polkadot/util": "2.16.1",
+    "@babel/runtime": "^7.10.4",
+    "@polkadot/util": "2.18.1",
     "@polkadot/wasm-crypto": "^1.2.1",
     "base-x": "^3.0.8",
     "bip39": "^3.0.2",
     "blakejs": "^1.1.0",
     "bn.js": "^5.1.2",
-    "bs58": "^4.0.1",
     "elliptic": "^6.5.3",
     "js-sha3": "^0.8.0",
     "pbkdf2": "^3.1.1",
@@ -41,7 +40,6 @@
   },
   "devDependencies": {
     "@types/bn.js": "^4.11.6",
-    "@types/bs58": "^4.0.1",
     "@types/elliptic": "^6.4.12",
     "@types/pbkdf2": "^3.0.0",
     "@types/xxhashjs": "^0.2.2"

packages/util-crypto/src/address/encodeDerived.spec.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import encodeDerivedAddress from './encodeDerived';
+
+describe('encodeDerivedAddress', (): void => {
+  it('creates a valid known derived address', (): void => {
+    expect(
+      encodeDerivedAddress('5GvUh7fGKsdBEh5XpypkfkGuf7j3vXLxH9BdxjxnJNVXRYi1', 0)
+    ).toEqual('5E5XxqPxm7QbEs6twYfp3tyjXidn4kqRrNPH4o6JK9JSLUeD');
+  });
+});

packages/util-crypto/src/address/encodeDerived.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Prefix } from './types';
+
+import BN from 'bn.js';
+
+import decode from './decode';
+import encode from './encode';
+import keyDerived from './keyDerived';
+
+/**
+ * @name encodeDerivedAddress
+ * @summary Creates a derived address.
+ * @description
+ * Creates a Substrate derived address based on the input address/publicKey and the index supplied.
+ */
+export default function encodeDerivedAddress (who: Uint8Array | string, index: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encode(keyDerived(decode(who), index), ss58Format);
+}

packages/util-crypto/src/address/encodeMulti.spec.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import encodeMultiAddress from './encodeMulti';
+
+describe('encodeMultiAddress', (): void => {
+  it('creates a valid known multi address', (): void => {
+    expect(
+      encodeMultiAddress([
+        '5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY',
+        '5FHneW46xGXgs5mUiveU4sbTyGBzmstUspZC92UhjJM694ty',
+        '5FLSigC9HGRKVhB9FiEo4Y3koPsNmBmLJbpXg2mp1hXcS59Y'
+      ], 2)
+    ).toEqual('5DjYJStmdZ2rcqXbXGX7TW85JsrW6uG4y9MUcLq2BoPMpRA7');
+  });
+});

packages/util-crypto/src/address/encodeMulti.ts

@@ -0,0 +1,20 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { Prefix } from './types';
+
+import BN from 'bn.js';
+
+import encode from './encode';
+import keyMulti from './keyMulti';
+
+/**
+ * @name encodeMultiAddress
+ * @summary Creates a multisig address.
+ * @description
+ * Creates a Substrate multisig address based on the input address and the required threshold.
+ */
+export default function encodeMultiAddress (who: (Uint8Array | string)[], threshold: BigInt | BN | number, ss58Format?: Prefix): string {
+  return encode(keyMulti(who, threshold), ss58Format);
+}

packages/util-crypto/src/address/index.ts

@@ -8,6 +8,8 @@ import createKeyMulti from './keyMulti';
 import createKeyDerived from './keyDerived';
 import decodeAddress from './decode';
 import encodeAddress from './encode';
+import encodeDerivedAddress from './encodeDerived';
+import encodeMultiAddress from './encodeMulti';
 import addressEq from './eq';
 import setSS58Format from './setSS58Format';
 import sortAddresses from './sort';
@@ -20,6 +22,8 @@ export {
   createKeyMulti,
   decodeAddress,
   encodeAddress,
+  encodeDerivedAddress,
+  encodeMultiAddress,
   setSS58Format,
   sortAddresses
 };

packages/util-crypto/src/address/keyDerived.spec.ts

@@ -4,7 +4,7 @@
 
 import createKeyDerived from './keyDerived';
 
-describe('createKeySub', (): void => {
+describe('createKeyDerived', (): void => {
   it('matches sub accounts with Rust', (): void => {
     expect(
       createKeyDerived(new Uint8Array([1, 0, 0, 0, 0, 0, 0, 0]), 0)

packages/util-crypto/src/base58/bs58.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import baseX from 'base-x';
+
+// https://github.com/cryptocoinjs/base-x#alphabets
+const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+
+const bs58 = baseX(BASE58_ALPHABET);
+
+export {
+  BASE58_ALPHABET,
+  bs58
+};

packages/util-crypto/src/base58/decode.ts

@@ -2,11 +2,10 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import bs58 from 'bs58';
 import { bufferToU8a } from '@polkadot/util';
 
-// copied from bs58
-const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+import { bs58 } from './bs58';
+import validate from './validate';
 
 /**
  * @name base58Decode
@@ -15,11 +14,7 @@ const BASE58_ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvw
  * From the provided input, decode the base58 and return the result as an `Uint8Array`.
  */
 export default function base58Decode (value: string): Uint8Array {
-  for (let i = 0; i < value.length; i++) {
-    if (!BASE58_ALPHABET.includes(value[i])) {
-      throw new Error(`Invalid base58 character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
-    }
-  }
+  validate(value);
 
   return bufferToU8a(bs58.decode(value));
 }

packages/util-crypto/src/base58/encode.ts

@@ -2,9 +2,10 @@
 // This software may be modified and distributed under the terms
 // of the Apache-2.0 license. See the LICENSE file for details.
 
-import bs58 from 'bs58';
 import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
 
+import { bs58 } from './bs58';
+
 /**
  * @name base58Encode
  * @summary Creates a base58 value.

packages/util-crypto/src/base58/index.ts

@@ -8,3 +8,4 @@
 
 export { default as base58Decode } from './decode';
 export { default as base58Encode } from './encode';
+export { default as base58Validate } from './validate';

packages/util-crypto/src/base58/validate.ts

@@ -0,0 +1,21 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { BASE58_ALPHABET } from './bs58';
+
+/**
+ * @name base58Validate
+ * @summary Validates a base58 value.
+ * @description
+ * Validates the the supplied value is valid base58
+ */
+export default function base58Validate (value: string): true {
+  for (let i = 0; i < value.length; i++) {
+    if (!BASE58_ALPHABET.includes(value[i])) {
+      throw new TypeError(`Invalid base58 character "${value[i]}" (0x${value.charCodeAt(i).toString(16)}) at index ${i}`);
+    }
+  }
+
+  return true;
+}

packages/util-crypto/src/base64/decode.spec.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { stringToU8a } from '@polkadot/util';
+
+import { base64Decode } from '.';
+
+describe('base64Decode', (): void => {
+  it('decodes a mixed base64 utf8 string', (): void => {
+    expect(
+      base64Decode('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toEqual(
+      stringToU8a('hello world Приветствую ми 你好')
+    );
+  });
+});

packages/util-crypto/src/base64/decode.ts

@@ -0,0 +1,19 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { bufferToU8a } from '@polkadot/util';
+
+import validate from './validate';
+
+/**
+ * @name base64Decode
+ * @summary Decodes a base64 value.
+ * @description
+ * From the provided input, decode the base64 and return the result as an `Uint8Array`.
+ */
+export default function base64Decode (value: string): Uint8Array {
+  validate(value);
+
+  return bufferToU8a(Buffer.from(value, 'base64'));
+}

packages/util-crypto/src/base64/encode.spec.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { base64Encode } from '.';
+
+describe('base64Encode', (): void => {
+  it('encodes a mixed base64 utf8 string', (): void => {
+    expect(
+      base64Encode('hello world Приветствую ми 你好')
+    ).toEqual('aGVsbG8gd29ybGQg0J/RgNC40LLQtdGC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==');
+  });
+});

packages/util-crypto/src/base64/encode.ts

@@ -0,0 +1,15 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { u8aToBuffer, u8aToU8a } from '@polkadot/util';
+
+/**
+ * @name base64Encode
+ * @summary Creates a base64 value.
+ * @description
+ * From the provided input, create the base64 and return the result as a string.
+ */
+export default function base58Encode (value: Uint8Array | string | Buffer | number[]): string {
+  return u8aToBuffer(u8aToU8a(value)).toString('base64');
+}

packages/util-crypto/src/base64/index.ts

@@ -0,0 +1,11 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @summary Encode and decode base64 values
+ */
+
+export { default as base64Decode } from './decode';
+export { default as base64Encode } from './encode';
+export { default as base64Validate } from './validate';

packages/util-crypto/src/base64/validate.spec.ts

@@ -0,0 +1,13 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { base64Validate } from '.';
+
+describe('base64Validate', (): void => {
+  it('decodes a mixed base64 utf8 string', (): void => {
+    expect(
+      () => base64Validate('aGVsbG8gd29ybGQg0J/RgNC40LLQtd^GC0YHRgtCy0YPRjiDQvNC4IOS9oOWlvQ==')
+    ).toThrow(/Invalid base64 encoding/);
+  });
+});

packages/util-crypto/src/base64/validate.ts

@@ -0,0 +1,17 @@
+// Copyright 2017-2020 @polkadot/util-crypto authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+/**
+ * @name base64Validate
+ * @summary Validates a base64 value.
+ * @description
+ * Validates the the supplied value is valid base64
+ */
+export default function base64Validate (value: string): true {
+  if (!(/^(?:[A-Za-z0-9+/]{2}[A-Za-z0-9+/]{2})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(value))) {
+    throw new TypeError('Invalid base64 encoding');
+  }
+
+  return true;
+}

packages/util-crypto/src/index.ts

@@ -11,6 +11,7 @@ export * from './init';
 // all internal exports
 export * from './address';
 export * from './base58';
+export * from './base64';
 export * from './blake2';
 export * from './keccak';
 export * from './key';

packages/util/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@polkadot/util",
-  "version": "2.16.1",
+  "version": "2.18.1",
   "description": "A collection of useful utilities for @polkadot",
   "main": "index.js",
   "keywords": [
@@ -25,7 +25,7 @@
   },
   "homepage": "https://github.com/polkadot-js/common/tree/master/packages/util#readme",
   "dependencies": {
-    "@babel/runtime": "^7.10.3",
+    "@babel/runtime": "^7.10.4",
     "@types/bn.js": "^4.11.6",
     "bn.js": "^5.1.2",
     "camelcase": "^5.3.1",

packages/util/src/is/ascii.spec.ts

@@ -0,0 +1,31 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { isAscii } from '.';
+
+describe('isAscii', (): void => {
+  it('returns true for an ASCII string', (): void => {
+    expect(isAscii('Hello\tWorld!\n\rTesting')).toEqual(true);
+  });
+
+  it('returns true for ASCII bytes', (): void => {
+    expect(isAscii(new Uint8Array([0x31, 0x32, 0x20, 10]))).toEqual(true);
+  });
+
+  it('returns true for empty string inputs', (): void => {
+    expect(isAscii('')).toEqual(true);
+  });
+
+  it('returns true for empty U8a inputs', (): void => {
+    expect(isAscii(new Uint8Array())).toEqual(true);
+  });
+
+  it('returns false for empty undefined inputs', (): void => {
+    expect(isAscii()).toEqual(false);
+  });
+
+  it('returns false for non-printable characters', (): void => {
+    expect(isAscii(new Uint8Array([5]))).toEqual(false);
+  });
+});

packages/util/src/is/ascii.ts

@@ -0,0 +1,24 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import u8aToU8a from '../u8a/toU8a';
+import isString from './string';
+
+const FORMAT = [9, 10, 13];
+
+/**
+ * @name isAscii
+ * @summary Tests if the input is printable ASCII
+ * @description
+ * Checks to see if the input string or Uint8Array is printable ASCII, 32-127 + formatters
+ */
+export default function isAscii (value?: number[] | Buffer | Uint8Array | string | null): boolean {
+  if (!value) {
+    return isString(value);
+  }
+
+  const u8a = u8aToU8a(value);
+
+  return !u8a.some((byte) => (byte >= 127) || (byte < 32 && !FORMAT.includes(byte)));
+}

packages/util/src/is/index.ts

@@ -5,6 +5,7 @@
 /**
  * @summary Type checking utilities
  */
+export { default as isAscii } from './ascii';
 export { default as isBigInt } from './bigInt';
 export { default as isBn } from './bn';
 export { default as isBuffer } from './buffer';
@@ -25,3 +26,4 @@ export { default as isTestChain } from './testChain';
 export { default as isToBn } from './toBn';
 export { default as isU8a } from './u8a';
 export { default as isUndefined } from './undefined';
+export { default as isUtf8 } from './utf8';

packages/util/src/is/utf8.spec.ts

@@ -0,0 +1,41 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+import { isUtf8 } from '.';
+
+describe('isUtf8', (): void => {
+  it('returns true for an ASCII string', (): void => {
+    expect(isUtf8('Hello\tWorld!\n\rTesting')).toEqual(true);
+  });
+
+  it('returns true for ASCII bytes', (): void => {
+    expect(isUtf8(new Uint8Array([0x31, 0x32, 0x20, 10]))).toEqual(true);
+  });
+
+  it('returns true for empty string inputs', (): void => {
+    expect(isUtf8('')).toEqual(true);
+  });
+
+  it('returns true for empty U8a inputs', (): void => {
+    expect(isUtf8(new Uint8Array())).toEqual(true);
+  });
+
+  it('returns false for empty undefined inputs', (): void => {
+    expect(isUtf8()).toEqual(false);
+  });
+
+  it('it is valid for ru', (): void => {
+    expect(isUtf8('Приветствую, ми')).toEqual(true);
+  });
+
+  it('is valid for zh', (): void => {
+    expect(isUtf8('你好')).toEqual(true);
+  });
+
+  it('is invalid for something random', (): void => {
+    expect(isUtf8('0x7f07b1f87709608bee603bbc79a0dfc29cd315c1351a83aa31adf7458d7d3003')).toEqual(false);
+    expect(isUtf8('0xc9ec51351beec59b52db06b3dd4685004013035df080358c319553ced597ca05')).toEqual(false);
+    expect(isUtf8('0xd12cef06e90a05b63737d542aaee1389ff9f5c25e461b362180f025c3b2d5635')).toEqual(false);
+  });
+});

packages/util/src/is/utf8.ts

@@ -0,0 +1,208 @@
+// Copyright 2017-2020 @polkadot/util authors & contributors
+// This software may be modified and distributed under the terms
+// of the Apache-2.0 license. See the LICENSE file for details.
+
+// Adapted from https://github.com/JulienPalard/is_utf8/blob/master/is_utf8.c
+
+import u8aToU8a from '../u8a/toU8a';
+import isString from './string';
+
+/**
+ * @name isUtf8
+ * @summary Tests if the input is valid Utf8
+ * @description
+ * Checks to see if the input string or Uint8Array is valid Utf8
+ */
+export default function isUtf8 (value?: number[] | Buffer | Uint8Array | string | null): boolean {
+  if (!value) {
+    return isString(value);
+  }
+
+  const u8a = u8aToU8a(value);
+  const len = u8a.length;
+  let i = 0;
+
+  while (i < len) {
+    if (u8a[i] <= 0x7F) /* 00..7F */ {
+      i += 1;
+    } else if (u8a[i] >= 0xC2 && u8a[i] <= 0xDF) /* C2..DF 80..BF */ {
+      if (i + 1 < len) /* Expect a 2nd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte between C2 and DF, expecting a 2nd byte between 80 and BF";
+          // *faulty_bytes = 2;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte between C2 and DF, expecting a 2nd byte.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 2;
+    } else if (u8a[i] === 0xE0) /* E0 A0..BF 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0xA0 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte of E0, expecting a 2nd byte between A0 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of E0, expecting a 3nd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of E0, expecting two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] >= 0xE1 && u8a[i] <= 0xEC) /* E1..EC 80..BF 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte between E1 and EC, expecting the 2nd byte between 80 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte between E1 and EC, expecting the 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte between E1 and EC, expecting two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] === 0xED) /* ED 80..9F 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x9F) {
+          // *message = "After a first byte of ED, expecting 2nd byte between 80 and 9F.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of ED, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of ED, expecting two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] >= 0xEE && u8a[i] <= 0xEF) /* EE..EF 80..BF 80..BF */ {
+      if (i + 2 < len) /* Expect a 2nd and 3rd byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte between EE and EF, expecting 2nd byte between 80 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte between EE and EF, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte between EE and EF, two following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 3;
+    } else if (u8a[i] === 0xF0) /* F0 90..BF 80..BF 80..BF */ {
+      if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+        if (u8a[i + 1] < 0x90 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte of F0, expecting 2nd byte between 90 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of F0, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+
+        if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+          // *message = "After a first byte of F0, expecting 4th byte between 80 and BF.";
+          // *faulty_bytes = 4;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of F0, expecting three following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 4;
+    } else if (u8a[i] >= 0xF1 && u8a[i] <= 0xF3) /* F1..F3 80..BF 80..BF 80..BF */ {
+      if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0xBF) {
+          // *message = "After a first byte of F1, F2, or F3, expecting a 2nd byte between 80 and BF.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of F1, F2, or F3, expecting a 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+
+        if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+          // *message = "After a first byte of F1, F2, or F3, expecting a 4th byte between 80 and BF.";
+          // *faulty_bytes = 4;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of F1, F2, or F3, expecting three following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 4;
+    } else if (u8a[i] === 0xF4) /* F4 80..8F 80..BF 80..BF */ {
+      if (i + 3 < len) /* Expect a 2nd, 3rd 3th byte */ {
+        if (u8a[i + 1] < 0x80 || u8a[i + 1] > 0x8F) {
+          // *message = "After a first byte of F4, expecting 2nd byte between 80 and 8F.";
+          // *faulty_bytes = 2;
+          return false;
+        }
+
+        if (u8a[i + 2] < 0x80 || u8a[i + 2] > 0xBF) {
+          // *message = "After a first byte of F4, expecting 3rd byte between 80 and BF.";
+          // *faulty_bytes = 3;
+          return false;
+        }
+
+        if (u8a[i + 3] < 0x80 || u8a[i + 3] > 0xBF) {
+          // *message = "After a first byte of F4, expecting 4th byte between 80 and BF.";
+          // *faulty_bytes = 4;
+          return false;
+        }
+      } else {
+        // *message = "After a first byte of F4, expecting three following bytes.";
+        // *faulty_bytes = 1;
+        return false;
+      }
+
+      i += 4;
+    } else {
+      // *message = "Expecting bytes in the following ranges: 00..7F C2..F4.";
+      // *faulty_bytes = 1;
+      return false;
+    }
+  }
+
+  return true;
+}

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

@@ -5,12 +5,6 @@
 import { numberToU8a } from '.';
 
 describe('numberToU8a', (): void => {
-  it('converts 0 to empty', (): void => {
-    expect(
-      numberToU8a(0)
-    ).toEqual(new Uint8Array());
-  });
-
   it('converts undefined to empty', (): void => {
     expect(
       numberToU8a()
@@ -29,6 +23,18 @@ describe('numberToU8a', (): void => {
     ).toEqual(new Uint8Array());
   });
 
+  it('converts 0 to u8a', (): void => {
+    expect(
+      numberToU8a(0)
+    ).toEqual(new Uint8Array([0]));
+  });
+
+  it('converts 0 to u8a (with length)', (): void => {
+    expect(
+      numberToU8a(0, 16)
+    ).toEqual(new Uint8Array([0, 0]));
+  });
+
   it('converts values to the u8a', (): void => {
     expect(
       numberToU8a(0x3456)

packages/util/src/number/toU8a.ts

@@ -3,6 +3,8 @@
 // of the Apache-2.0 license. See the LICENSE file for details.
 
 import hexToU8a from '../hex/toU8a';
+import isNull from '../is/null';
+import isUndefined from '../is/undefined';
 import numberToHex from './toHex';
 
 /**
@@ -20,7 +22,7 @@ import numberToHex from './toHex';
  * ```
  */
 export default function numberToU8a (value?: number | null, bitLength = -1): Uint8Array {
-  if (!value || isNaN(value)) {
+  if (isUndefined(value) || isNull(value) || isNaN(value)) {
     return new Uint8Array();
   }