Added multibase encoding and decoding feature and testing

Author: CMCDragonkai

package-lock.json

@@ -23,17 +23,17 @@
     "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@types/jest": "^26.0.20",
+    "@types/jest": "^27.0.2",
     "@types/node": "^14.14.35",
     "@types/node-forge": "^0.10.4",
     "@typescript-eslint/eslint-plugin": "^4.12.0",
     "@typescript-eslint/parser": "^4.12.0",
     "eslint": "^7.17.0",
     "eslint-config-prettier": "^7.1.0",
     "eslint-plugin-prettier": "^3.3.1",
-    "jest": "^26.6.3",
+    "jest": "^27.2.5",
     "prettier": "^2.2.1",
-    "ts-jest": "^26.4.4",
+    "ts-jest": "^27.0.5",
     "ts-node": "^9.1.1",
     "tsconfig-paths": "^3.9.0",
     "typedoc": "^0.21.5",

package.json

@@ -1,5 +1,8 @@
+import type { Codec } from 'multiformats/bases/base';
+
 import crypto from 'crypto';
 import { performance } from 'perf_hooks';
+import { bases } from 'multiformats/basics';
 
 /**
  * Gets random bytes as Uint8Array
@@ -82,6 +85,28 @@ function toUUID(bytes: Uint8Array): string {
   ].join('-');
 }
 
+type MultibaseFormats = keyof typeof bases;
+
+const basesByPrefix: Record<string, Codec<string, string>> = {};
+for (const k in bases) {
+  const codec = bases[k];
+  basesByPrefix[codec.prefix] = codec;
+}
+
+function toMultibase(idBytes: ArrayBuffer, format: MultibaseFormats): string {
+  const codec = bases[format];
+  return codec.encode(new Uint8Array(idBytes));
+}
+
+function fromMultibase(idString: string): ArrayBuffer | undefined {
+  const prefix = idString[0];
+  const codec = basesByPrefix[prefix];
+  if (codec == null) {
+    return;
+  }
+  return codec.decode(idString).buffer;
+}
+
 /**
  * Encodes Uint8Array to hex string
  */
@@ -199,6 +224,8 @@ export {
   timeSource,
   take,
   toUUID,
+  toMultibase,
+  fromMultibase,
   bytes2hex,
   hex2bytes,
   bytes2bin,
@@ -210,3 +237,5 @@ export {
   toFixedPoint,
   fromFixedPoint,
 };
+
+export type { MultibaseFormats };

src/utils.ts

@@ -13,6 +13,14 @@ describe('IdDeterministic', () => {
     const ids = [...utils.take(idGen, 10)];
     expect(ids).toHaveLength(10);
   });
+  test('ids can be encoded and decoded with multibase', () => {
+    const idGen = new IdDeterministic();
+    const id = idGen.get();
+    const encoded = utils.toMultibase(id, 'base58btc');
+    const id_ = utils.fromMultibase(encoded);
+    expect(id_).toBeDefined();
+    expect(Buffer.from(id).equals(Buffer.from(id_!))).toBe(true);
+  });
   test('ids are deterministic', () => {
     const id = new IdDeterministic();
     const id1 = Buffer.from(id.get());

tests/IdDeterministic.test.ts

@@ -13,6 +13,14 @@ describe('IdRandom', () => {
     const ids = [...utils.take(idGen, 10)];
     expect(ids).toHaveLength(10);
   });
+  test('ids can be encoded and decoded with multibase', () => {
+    const idGen = new IdRandom();
+    const id = idGen.get();
+    const encoded = utils.toMultibase(id, 'base58btc');
+    const id_ = utils.fromMultibase(encoded);
+    expect(id_).toBeDefined();
+    expect(Buffer.from(id).equals(Buffer.from(id_!))).toBe(true);
+  });
   test('ids are random', () => {
     const id = new IdRandom();
     const count = 10;

tests/IdRandom.test.ts

@@ -13,6 +13,14 @@ describe('IdSortable', () => {
     const ids = [...utils.take(idGen, 10)];
     expect(ids).toHaveLength(10);
   });
+  test('ids can be encoded and decoded with multibase', () => {
+    const idGen = new IdSortable();
+    const id = idGen.get();
+    const encoded = utils.toMultibase(id, 'base58btc');
+    const id_ = utils.fromMultibase(encoded);
+    expect(id_).toBeDefined();
+    expect(Buffer.from(id).equals(Buffer.from(id_!))).toBe(true);
+  });
   test('ids are lexically sortable', () => {
     const id = new IdSortable();
     const i1 = Buffer.from(id.get());

tests/IdSortable.test.ts

@@ -96,4 +96,12 @@ describe('utils', () => {
     expect(utils.toFixedPoint(0, 12, 3)).toStrictEqual([0, 0]);
     expect(utils.fromFixedPoint([0, 0], 12, 3)).toBe(0.0);
   });
+  test('multibase encoding and decoding', () => {
+    const bytes = new Uint8Array([123, 124]).buffer;
+    const encoded = utils.toMultibase(bytes, 'base58btc');
+    expect(encoded).toBe('zAQ3');
+    const bytes_ = utils.fromMultibase(encoded);
+    expect(bytes_).toBeDefined();
+    expect(Buffer.from(bytes_!).equals(Buffer.from(bytes))).toBe(true);
+  });
 });