chore: remove buffer dependency (#321)

Author: lenkan

package-lock.json

@@ -60,7 +60,7 @@
   "dependencies": {
     "@noble/curves": "^1.8.1",
     "@noble/hashes": "^1.3.2",
-    "buffer": "^6.0.3",
+    "base64-js": "^1.5.1",
     "libsodium-wrappers-sumo": "^0.7.9",
     "mathjs": "^12.4.0",
     "structured-headers": "^0.5.0"

package.json

@@ -1,15 +1,9 @@
-import { Buffer } from 'buffer';
-// base64url is supported by node Buffer, but not in buffer package for browser compatibility
-// https://github.com/feross/buffer/issues/309
+import { fromByteArray, toByteArray } from 'base64-js';
 
-// Instead of using a node.js-only module and forcing us to polyfill the Buffer global,
-// we insert code from https://gitlab.com/seangenabe/safe-base64 here
+export function encodeBase64Url(buffer: Uint8Array): string {
+    const input = Buffer.from(buffer);
 
-export function encodeBase64Url(buffer: Buffer | Uint8Array): string {
-    const input = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
-
-    return input
-        .toString('base64')
+    return fromByteArray(input)
         .replace(/\+/g, '-')
         .replace(/\//g, '_')
         .replace(/=+/, '');
@@ -23,5 +17,5 @@ export function decodeBase64Url(input: string): Uint8Array {
     const n = input.length % 4;
     const padded = input + '='.repeat(n > 0 ? 4 - n : n);
     const base64String = padded.replace(/-/g, '+').replace(/_/g, '/');
-    return Uint8Array.from(Buffer.from(base64String, 'base64'));
+    return toByteArray(base64String);
 }

src/keri/core/base64.ts

@@ -1,7 +1,7 @@
 import { BexDex, Matter, MatterArgs, MtrDex } from './matter.ts';
 import { EmptyMaterialError } from './kering.ts';
-import { Buffer } from 'buffer';
 import { decodeBase64Url, encodeBase64Url } from './base64.ts';
+import { concat } from './core.ts';
 
 const B64REX = '^[A-Za-z0-9\\-_]*$';
 export const Reb64 = new RegExp(B64REX);
@@ -123,7 +123,7 @@ export class Bexter extends Matter {
     get bext(): string {
         const sizage = Matter.Sizes.get(this.code);
         const wad = Uint8Array.from(new Array(sizage?.ls).fill(0));
-        const bext = encodeBase64Url(Buffer.from([...wad, ...this.raw]));
+        const bext = encodeBase64Url(concat(wad, this.raw));
 
         let ws = 0;
         if (sizage?.ls === 0 && bext !== undefined) {

src/keri/core/bexter.ts

@@ -1,6 +1,5 @@
 import { blake3 } from '@noble/hashes/blake3';
 import { Matter, MatterArgs, MtrDex } from './matter.ts';
-import { Buffer } from 'buffer';
 
 /**
  * @description : Diger is subset of Matter and is used to verify the digest of serialization
@@ -10,10 +9,7 @@ import { Buffer } from 'buffer';
  */
 
 export class Diger extends Matter {
-    private readonly _verify: (
-        a: Uint8Array,
-        b: Uint8Array | Buffer
-    ) => boolean;
+    private readonly _verify: (a: Uint8Array, b: Uint8Array) => boolean;
 
     // This constructor will assign digest verification function to ._verify
     constructor(
@@ -79,13 +75,11 @@ export class Diger extends Matter {
         return diger.verify(ser) && this.verify(ser);
     }
 
-    blake3_256(ser: Uint8Array, dig: Uint8Array | Buffer) {
+    blake3_256(ser: Uint8Array, dig: Uint8Array) {
         const digest = blake3.create({ dkLen: 32 }).update(ser).digest();
-        const other = Uint8Array.from(dig);
 
         return (
-            digest.length == other.length &&
-            digest.toString() === other.toString()
+            digest.length == dig.length && digest.toString() === dig.toString()
         );
     }
 }

src/keri/core/diger.ts

@@ -10,7 +10,6 @@ import { b } from './core.ts';
 import { Cigar } from './cigar.ts';
 import { nowUTC } from './utils.ts';
 import { Siger } from './siger.ts';
-import { Buffer } from 'buffer';
 import { encodeBase64Url } from './base64.ts';
 
 export const HEADER_SIG_INPUT = normalize('Signature-Input');
@@ -130,7 +129,7 @@ export class Unqualified {
     }
 
     get qb64(): string {
-        return encodeBase64Url(Buffer.from(this._raw));
+        return encodeBase64Url(this._raw);
     }
 
     get qb64b(): Uint8Array {

src/keri/core/httping.ts

@@ -1,6 +1,5 @@
 import { EmptyMaterialError } from './kering.ts';
 import { b, b64ToInt, d, intToB64, readInt } from './core.ts';
-import { Buffer } from 'buffer';
 import { decodeBase64Url, encodeBase64Url } from './base64.ts';
 
 export class IndexerCodex {
@@ -398,8 +397,7 @@ export class Indexer {
             bytes[odx] = raw[i];
         }
 
-        const full =
-            both + encodeBase64Url(Buffer.from(bytes)).slice(ps - xizage.ls);
+        const full = both + encodeBase64Url(bytes).slice(ps - xizage.ls);
         if (full.length != xizage.fs) {
             throw new Error(`Invalid code=${both} for raw size=${raw.length}.`);
         }

src/keri/core/indexer.ts

@@ -2,7 +2,6 @@ import { EmptyMaterialError } from './kering.ts';
 
 import { intToB64, readInt } from './core.ts';
 import { b, d } from './core.ts';
-import { Buffer } from 'buffer';
 import { decodeBase64Url, encodeBase64Url } from './base64.ts';
 
 export class Codex {
@@ -421,7 +420,7 @@ export class Matter {
                 bytes[odx] = raw[i];
             }
 
-            return both + encodeBase64Url(Buffer.from(bytes));
+            return both + encodeBase64Url(bytes);
         } else {
             const both = code;
             const cs = both.length;
@@ -443,7 +442,7 @@ export class Matter {
                 bytes[odx] = raw[i];
             }
 
-            return both + encodeBase64Url(Buffer.from(bytes)).slice(cs % 4);
+            return both + encodeBase64Url(bytes).slice(cs % 4);
         }
     }
 

src/keri/core/matter.ts

@@ -2,7 +2,6 @@ import { DigiDex, Matter, MatterArgs, MtrDex } from './matter.ts';
 import { deversify, Dict, Serials } from './core.ts';
 import { EmptyMaterialError } from './kering.ts';
 import { dumps, sizeify } from './serder.ts';
-import { Buffer } from 'buffer';
 import { blake3 } from '@noble/hashes/blake3';
 
 const Dummy = '#';
@@ -11,25 +10,7 @@ export enum Ids {
     d = 'd',
 }
 
-class Digestage {
-    public klas: any = undefined;
-    public size: number | undefined = 0;
-    public length: number | undefined = 0;
-    constructor(klas: any, size?: number, length?: number) {
-        this.klas = klas;
-        this.size = size;
-        this.length = length;
-    }
-}
-
 export class Saider extends Matter {
-    static Digests = new Map<string, Digestage>([
-        [
-            MtrDex.Blake3_256,
-            new Digestage(Saider._derive_blake3_256, undefined, undefined),
-        ],
-    ]);
-
     constructor(
         { raw, code, qb64b, qb64, qb2 }: MatterArgs,
         sad?: Dict<any>,
@@ -69,21 +50,13 @@ export class Saider extends Matter {
         }
     }
 
-    static _derive_blake3_256(
-        ser: Uint8Array,
-        _digest_size: number,
-        _length: number
-    ) {
-        return Buffer.from(blake3.create({ dkLen: 32 }).update(ser).digest());
-    }
-
     private static _derive(
         sad: Dict<any>,
         code: string,
         kind: Serials | undefined,
         label: string
     ): [Uint8Array, Dict<any>] {
-        if (!DigiDex.has(code) || !Saider.Digests.has(code)) {
+        if (!DigiDex.has(code)) {
             throw new Error(`Unsupported digest code = ${code}.`);
         }
 
@@ -95,19 +68,14 @@ export class Saider extends Matter {
 
         const ser = { ...sad };
 
-        const digestage = Saider.Digests.get(code);
-
         const cpa = Saider._serialze(ser, kind);
-        const args: any[] = [];
-        if (digestage!.size != undefined) {
-            args.push(digestage!.size);
-        }
 
-        if (digestage!.length != undefined) {
-            args.push(digestage!.length);
+        switch (code) {
+            case MtrDex.Blake3_256:
+                return [blake3.create({ dkLen: 32 }).update(cpa).digest(), sad];
+            default:
+                throw new Error(`Unsupported digest code = ${code}.`);
         }
-
-        return [digestage!.klas(cpa, ...args), sad];
     }
 
     public derive(

src/keri/core/saider.ts

@@ -3,14 +3,13 @@ import {
     decodeBase64Url,
     encodeBase64Url,
 } from '../../src/keri/core/base64.ts';
-import { Buffer } from 'buffer';
 
 test('encode', () => {
-    assert.equal(encodeBase64Url(Uint8Array.from(Buffer.from('f'))), 'Zg');
-    assert.equal(encodeBase64Url(Uint8Array.from(Buffer.from('fi'))), 'Zmk');
-    assert.equal(encodeBase64Url(Uint8Array.from(Buffer.from('fis'))), 'Zmlz');
+    assert.equal(encodeBase64Url(Uint8Array.from([102])), 'Zg');
+    assert.equal(encodeBase64Url(Uint8Array.from([102, 105])), 'Zmk');
+    assert.equal(encodeBase64Url(Uint8Array.from([102, 105, 115])), 'Zmlz');
     assert.equal(
-        encodeBase64Url(Uint8Array.from(Buffer.from('fish'))),
+        encodeBase64Url(Uint8Array.from([102, 105, 115, 104])),
         'ZmlzaA'
     );
     assert.equal(encodeBase64Url(Uint8Array.from([248])), '-A');
@@ -25,18 +24,17 @@ test('decode', () => {
         decodeBase64Url('ZmlzaA'),
         Uint8Array.from([102, 105, 115, 104])
     );
-    assert.deepEqual(Buffer.from([248]), decodeBase64Url('-A'));
-    assert.deepEqual(Buffer.from([252]), decodeBase64Url('_A'));
+    assert.deepEqual(Uint8Array.from([248]), decodeBase64Url('-A'));
+    assert.deepEqual(Uint8Array.from([252]), decodeBase64Url('_A'));
 });
 
 test('Test encode / decode compare with built in node Buffer', () => {
     const text = '🏳️🏳️';
     const b64url = '8J-Ps--4j_Cfj7PvuI8';
+    const data = Uint8Array.from([
+        240, 159, 143, 179, 239, 184, 143, 240, 159, 143, 179, 239, 184, 143,
+    ]);
 
-    assert.deepEqual(
-        Buffer.from(text).toString('base64url'),
-        encodeBase64Url(Buffer.from(text))
-    );
-
-    assert.deepEqual(Buffer.from(b64url, 'base64url'), decodeBase64Url(b64url));
+    assert.deepEqual(b64url, encodeBase64Url(new TextEncoder().encode(text)));
+    assert.deepEqual(data, decodeBase64Url(b64url));
 });