trac-msb 0.1.76 → 0.1.78

package/dump/src/network.js

@@ -1,295 +0,0 @@
-import w from 'protomux-wakeup';
-import b4a from 'b4a';
-import Hyperswarm from 'hyperswarm';
-import {
-    EventType,
-    TRAC_NAMESPACE,
-    MAX_PEERS,
-    MAX_PARALLEL,
-    MAX_SERVER_CONNECTIONS,
-    MAX_CLIENT_CONNECTIONS,
-    OperationType,
-    EntryType
-} from './utils/constants.js';
-import { sleep } from './utils/functions.js';
-import Check from './utils/check.js';
-import Wallet from 'trac-wallet';
-import Protomux from 'protomux'
-import c from 'compact-encoding'
-
-const wakeup = new w();
-
-class Network {
-    constructor(base) {
-        this.tx_pool = [];
-        this.pool(base);
-        this.check = new Check();
-        this.admin_stream = null
-        this.admin = null
-        this.validator_stream = null
-        this.validator = null;
-        this.custom_stream =  null;
-        this.custom_node = null
-    }
-
-    static async replicate(disable_rate_limit, msb, network, enable_txchannel, base, writingKey, bootstrap, swarm, walletEnabled, store, wallet, channel, isStreaming, handleIncomingEvent, emit) {
-        if (!swarm) {
-
-            let keyPair;
-            if (!walletEnabled) {
-                keyPair = await store.createKeyPair(TRAC_NAMESPACE);
-            } else {
-                keyPair = {
-                    publicKey: b4a.from(wallet.publicKey, 'hex'),
-                    secretKey: b4a.from(wallet.secretKey, 'hex')
-                };
-            }
-
-            let clean = Date.now();
-            let conns = {};
-
-            swarm = new Hyperswarm({ keyPair, bootstrap : bootstrap, maxPeers: MAX_PEERS, maxParallel: MAX_PARALLEL, maxServerConnections: MAX_SERVER_CONNECTIONS, maxClientConnections :  MAX_CLIENT_CONNECTIONS});
-
-            console.log(`Channel: ${b4a.toString(channel)}`);
-            swarm.on('connection', async (connection) => {
-
-                const mux = Protomux.from(connection)
-                connection.userData = mux
-
-                const message_channel = mux.createChannel({
-                    protocol: b4a.toString(channel, 'utf8'),
-                    onopen() {
-                    },
-                    onclose() {
-                    }
-                })
-                message_channel.open()
-                const message = message_channel.addMessage({
-                    encoding: c.json,
-                    async onmessage(msg) {
-                        try {
-                            
-                            if (msg === 'get_validator') {
-                                const nonce = Wallet.generateNonce().toString('hex');
-                                const _msg = {
-                                    op: 'validator',
-                                    key: writingKey,
-                                    address: wallet.publicKey,
-                                    channel: b4a.toString(channel, 'utf8')
-                                };
-                                const sig = wallet.sign(JSON.stringify(_msg) + nonce);
-                                message.send({response: _msg, sig, nonce})
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else if (msg === 'get_admin') {
-                                const res = await msb.get(EntryType.ADMIN);
-                                if (wallet.publicKey !== res.tracPublicKey) return;
-                                const nonce = Wallet.generateNonce().toString('hex');
-                                const _msg = {
-                                    op: 'admin',
-                                    key: writingKey,
-                                    address: wallet.publicKey,
-                                    channel: b4a.toString(channel, 'utf8')
-                                };
-                                const sig = wallet.sign(JSON.stringify(_msg) + nonce);
-                                message.send({response: _msg, sig, nonce})
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else  if (msg === 'get_node') {
-                     
-                                const nonce = Wallet.generateNonce().toString('hex');
-                                const _msg = {
-                                    op: 'node',
-                                    key: writingKey,
-                                    address: wallet.publicKey,
-                                    channel: b4a.toString(channel, 'utf8')
-                                };
-                                const sig = wallet.sign(JSON.stringify(_msg) + nonce);
-                                message.send({response: _msg, sig, nonce})
-                                swarm.leavePeer(connection.remotePublicKey)
-                            
-                            } else if (msg.response !== undefined && msg.response.op !== undefined && msg.response.op === 'validator') {
-                                const res = await msb.get(msg.response.address);
-                                if (res === null) return;
-                                const verified = wallet.verify(msg.sig, JSON.stringify(msg.response) + msg.nonce, msg.response.address)
-                                if (verified && msg.response.channel === b4a.toString(channel, 'utf8') && network.validator_stream === null) {
-                                    console.log('Validator stream established', msg.response.address)
-                                    network.validator_stream = connection;
-                                    network.validator = msg.response.address;
-                                }
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else if (msg.response !== undefined && msg.response.op !== undefined && msg.response.op === 'admin') {
-                                const res = await msb.get(EntryType.ADMIN);
-                                if (res === null || res.tracPublicKey !== msg.response.address) return;
-                                const verified = wallet.verify(msg.sig, JSON.stringify(msg.response) + msg.nonce, res.tracPublicKey)
-                                if (verified && msg.response.channel === b4a.toString(channel, 'utf8')) {
-                                    console.log('Admin stream established', res.tracPublicKey)
-                                    network.admin_stream = connection;
-                                    network.admin = res.tracPublicKey;
-                                }
-                                swarm.leavePeer(connection.remotePublicKey)
-                            }
-                            else if (msg.response !== undefined && msg.response.op !== undefined && msg.response.op === 'node'){
-
-                                const verified = wallet.verify(msg.sig, JSON.stringify(msg.response) + msg.nonce, msg.response.address)
-                                if (verified && msg.response.channel === b4a.toString(channel, 'utf8')) {
-
-                                    console.log('Node stream established', msg.response.address)
-                                    network.custom_stream = connection;
-                                    network.custom_node = msg.response.address;
-                                }
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else if (msg.type !== undefined && msg.key !== undefined && msg.value !== undefined && msg.type === 'addWriter') {
-                                const adminEntry = await msb.get(EntryType.ADMIN);
-                                if (null === adminEntry || (adminEntry.tracPublicKey !== wallet.publicKey)) return;
-                                const nodeEntry = await msb.get(msg.value.pub);
-                                const isAlreadyWriter = null !== nodeEntry && nodeEntry.isWriter;
-                                const isAllowedToRequestRole = await msb._isAllowedToRequestRole(msg.key, adminEntry);
-                                const canAddWriter = base.writable && !isAlreadyWriter && isAllowedToRequestRole;
-                                if (msg.key !== wallet.publicKey && canAddWriter) {
-                                    await handleIncomingEvent(msg);
-                                }
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else if (msg.type !== undefined && msg.key !== undefined && msg.value !== undefined && msg.type === 'removeWriter') {
-                                const adminEntry = await msb.get(EntryType.ADMIN);
-                                if (null === adminEntry || (adminEntry.tracPublicKey !== wallet.publicKey)) return;
-                                const nodeEntry = await msb.get(msg.value.pub);
-                                const isAlreadyWriter = null !== nodeEntry && nodeEntry.isWriter;
-                                const canRemoveWriter = base.writable && isAlreadyWriter
-                                if (msg.key !== wallet.publicKey && canRemoveWriter) {
-                                    await handleIncomingEvent(msg);
-                                }
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else if (msg.type !== undefined && msg.key !== undefined && msg.value !== undefined && msg.type === 'addAdmin') {
-                                const adminEntry = await msb.get(EntryType.ADMIN);
-                                if (null === adminEntry || (adminEntry.tracPublicKey !== msg.key)) return;
-                                await handleIncomingEvent(msg);
-                                swarm.leavePeer(connection.remotePublicKey)
-                            }
-                            else if (msg.type !== undefined && msg.key !== undefined && msg.value !== undefined && msg.type === 'whitelisted') {
-                                await handleIncomingEvent(msg);
-                                swarm.leavePeer(connection.remotePublicKey)
-                            } else {
-                                if (base.isIndexer || !base.writable) return;
-
-                                if (true !== disable_rate_limit) {
-                                    const peer = b4a.toString(connection.remotePublicKey, 'hex');
-                                    const _now = Date.now();
-
-                                    if (_now - clean >= 120_000) {
-                                        clean = _now;
-                                        conns = {};
-                                    }
-
-                                    if (conns[peer] === undefined) {
-                                        conns[peer] = {prev: _now, now: 0, tx_cnt: 0}
-                                    }
-
-                                    conns[peer].now = _now;
-                                    conns[peer].tx_cnt += 1;
-
-                                    if (conns[peer].now - conns[peer].prev >= 60_000) {
-                                        delete conns[peer];
-                                    }
-
-                                    if (conns[peer] !== undefined && conns[peer].now - conns[peer].prev >= 1000 && conns[peer].tx_cnt >= 50) {
-                                        swarm.leavePeer(connection.remotePublicKey);
-                                        connection.end()
-                                    }
-                                }
-
-                                if (network.tx_pool.length >= 1000) {
-                                    console.log('pool full');
-                                    return
-                                }
-
-                                if (b4a.byteLength(JSON.stringify(msg)) > 3072) return;
-
-                                const parsedPreTx = msg;
-
-                                if (network.check.sanitizePreTx(parsedPreTx) &&
-                                    wallet.verify(b4a.from(parsedPreTx.is, 'hex'), b4a.from(parsedPreTx.tx + parsedPreTx.in), b4a.from(parsedPreTx.ipk, 'hex')) &&
-                                    parsedPreTx.wp === wallet.publicKey &&
-                                    null === await base.view.get(parsedPreTx.tx)
-                                ) {
-                                    const nonce = Wallet.generateNonce().toString('hex');
-                                    const signature = wallet.sign(b4a.from(parsedPreTx.tx + nonce), b4a.from(wallet.secretKey, 'hex'));
-                                    const append_tx = {
-                                        op: OperationType.POST_TX,
-                                        tx: parsedPreTx.tx,
-                                        is: parsedPreTx.is,
-                                        w: writingKey,
-                                        i: parsedPreTx.i,
-                                        ipk: parsedPreTx.ipk,
-                                        ch: parsedPreTx.ch,
-                                        in: parsedPreTx.in,
-                                        bs: parsedPreTx.bs,
-                                        mbs: parsedPreTx.mbs,
-                                        ws: signature.toString('hex'),
-                                        wp: wallet.publicKey,
-                                        wn: nonce
-                                    };
-                                    network.tx_pool.push({tx: parsedPreTx.tx, append_tx: append_tx});
-                                }
-
-                                swarm.leavePeer(connection.remotePublicKey)
-                            }
-                        } catch (e) {
-                            console.log(e);
-                        }
-                    }
-                })
-
-                connection.messenger = message;
-
-                connection.on('close', () => {
-                    if (network.validator_stream === connection) {
-                        network.validator_stream = null;
-                        network.validator = null;
-                    }
-                    if (network.admin_stream === connection) {
-                        network.admin_stream = null;
-                        network.admin = null;
-                    }
-
-                    if (network.custom_stream === connection) {
-                        network.custom_stream = null;
-                        network.custom_node = null;
-                    }
-
-                    message_channel.close()
-                });
-
-                // must be called AFTER the protomux init above
-                const stream = store.replicate(connection);
-                wakeup.addStream(stream);
-
-                connection.on('error', (error) => { });
-
-                if (!isStreaming) {
-                    emit(EventType.READY_MSB);
-                }
-            });
-
-            swarm.join(channel, { server: true, client: true });
-            await swarm.flush();
-        }
-        return swarm;
-    }
-
-    async pool(base) {
-        while (true) {
-            if (this.tx_pool.length > 0) {
-                const length = this.tx_pool.length;
-                const batch = [];
-                for (let i = 0; i < length; i++) {
-                    if (i >= 10) break;
-                    batch.push({ type: OperationType.TX, key: this.tx_pool[i].tx, value: this.tx_pool[i].append_tx });
-                }
-                await base.append(batch);
-                this.tx_pool.splice(0, batch.length);
-            }
-            await sleep(5);
-        }
-    }
-}
-
-export default Network;

package/dump/src/utils/check.js

@@ -1,163 +0,0 @@
-import Validator from 'fastest-validator';
-import { isHexString } from './functions.js';
-import {OperationType} from './constants.js';
-class Check {
-    #_validator;
-    #_sanitizeAdminAndWritersOperations;
-    #_sanitizeIndexerOrWhitelistOperations;
-    #_sanitizePreTx;
-    #_sanitizePostTx;
-
-    constructor() {
-        this.#_validator = new Validator({
-            useNewCustomCheckerFunction: true,
-            messages: {
-                bufferedHex: "The '{field}' field must be a hex! Actual: {actual}",
-                hexString: "The '{field}' field must be a valid hex string! Actual: {actual}"
-            },
-            customFunctions: {
-                hexCheck: (value, errors) => {
-                    let buf = null;
-                    let result = false;
-                    try {
-                        buf = b4a.from(value, 'hex');
-                        result = value === b4a.toString(buf, 'hex');
-                    } catch (e) {
-                    }
-                    return result;
-                },
-                hexStringCheck: (value, errors) => {
-                    try {
-                        return isHexString(value);
-                    } catch (e) {
-                    }
-                    return false;
-                }
-            }
-        });
-
-        this.#_validator.add("is_hex", function ({ schema, messages }, path, context) {
-            return {
-                source: `
-                    const result = context.customFunctions.hexCheck(value, errors);
-                    if(false === result) ${this.makeError({ type: "bufferedHex", actual: "value", messages })}
-                    return value;
-                `
-            };
-        });
-
-        this.#_validator.add("is_hex_string", function ({ schema, messages }, path, context) {
-            return {
-                source: `
-                    const result = context.customFunctions.hexStringCheck(value, errors);
-                    if(false === result) ${this.makeError({ type: "hexString", actual: "value", messages })}
-                    return value;
-                `
-            };
-        });
-
-        this.#_sanitizeAdminAndWritersOperations = this.#compileSanitizationAdminAndWriterOperationsSchema();
-        this.#_sanitizeIndexerOrWhitelistOperations = this.#compileIndexerOrWhitelistOperationSchema();
-        this.#_sanitizePreTx = this.#compilePreTxSchema();
-        this.#_sanitizePostTx = this.#compilePostTxSchema();
-    }
-    //TODO: rename this function
-    #compileSanitizationAdminAndWriterOperationsSchema() {
-        // TODO: Create constants for int values below
-        const schema = {
-            $$strict: true,
-            type: { type: 'string', enum: [OperationType.ADD_ADMIN, OperationType.ADD_WRITER, OperationType.REMOVE_WRITER], required: true },
-            key: { type: "is_hex_string", length: 64, required: true },
-            value: {
-                $$strict: true,
-                $$type: "object",
-                pub: { type: 'is_hex_string', length: 64, required: true },
-                wk: { type: 'is_hex_string', length: 64, required: true },
-                nonce: { type: 'is_hex_string', length: 64, required: true },
-                sig: { type: 'is_hex_string', length: 128, required: true },
-
-            }
-        }
-        return this.#_validator.compile(schema);
-    }
-
-    sanitizeAdminAndWritersOperations(op) {
-        return this.#_sanitizeAdminAndWritersOperations(op) === true;
-    }
-    //TODO: rename this function
-    #compileIndexerOrWhitelistOperationSchema() {
-        // TODO: Create constants for int values below
-        const schema = {
-            $$strict: true,
-            type: { type: 'string', enum: [OperationType.ADD_INDEXER, OperationType.REMOVE_INDEXER, OperationType.APPEND_WHITELIST, OperationType.BAN_VALIDATOR], required: true },
-            key: { type: "is_hex_string", length: 64, required: true },
-            value: {
-                $$strict: true,
-                $$type: "object",
-                nonce: { type: 'is_hex_string', length: 64, required: true },
-                sig: { type: 'is_hex_string', length: 128, required: true },
-
-            }
-        }
-        return this.#_validator.compile(schema);
-    }
-
-    sanitizeIndexerOrWhitelistOperations(op) {
-        return this.#_sanitizeIndexerOrWhitelistOperations(op) === true;
-    }
-
-    #compilePreTxSchema() {
-        // TODO: Create constants for int values below
-        const schema = {
-            $$strict: true,
-            op: { type: 'string', enum: ['pre-tx'], required: true },
-            tx: { type: 'is_hex_string', required: true }, // TODO: if we will use only 256 bit hash then change to length: 64
-            is: { type: 'is_hex_string', length: 128, required: true },
-            wp: { type: 'is_hex_string', length: 64, required: true },
-            i: { type: 'is_hex_string', length: 64, required: true },
-            ipk: { type: 'is_hex_string', length: 64, required: true },
-            ch: { type: 'is_hex_string', required: true }, // TODO: if we will use only 256 bit hash then change to length: 64
-            in: { type: 'is_hex_string', length: 64,  required: true },
-            bs: { type: 'is_hex_string', length: 64, required: true },
-            mbs: { type: 'is_hex_string', length: 64, required: true },
-        };
-        return this.#_validator.compile(schema);
-    }
-
-    sanitizePreTx(op) {
-        return this.#_sanitizePreTx(op) === true;
-    }
-
-    #compilePostTxSchema() {
-        // TODO: Create constants for int values below
-        const schema = {
-            $$strict: true,
-            type: { type: 'string', enum: ['tx'], required: true },
-            key: { type: 'is_hex_string', required: true }, // TODO: if we will use only 256 bit hash then change to length: 64
-            value: {
-                $$strict: true,
-                $$type: "object",
-                op: { type: 'string', enum: ['post-tx'], required: true },
-                tx: { type: 'is_hex_string', required: true }, // TODO: if we will use only 256 bit hash then change to length: 64
-                is: { type: 'is_hex_string', length: 128, required: true },
-                w: { type: 'is_hex_string', length: 64, required: true },
-                i: { type: 'is_hex_string', length: 64, required: true },
-                ipk: { type: 'is_hex_string', length: 64, required: true },
-                ch: { type: 'is_hex_string', required: true }, // TODO: if we will use only 256 bit hash then change to length: 64
-                in: { type: 'is_hex_string', length: 64, required: true },
-                bs: { type: 'is_hex_string', length: 64, required: true },
-                mbs: { type: 'is_hex_string', length: 64, required: true },
-                ws: { type: 'is_hex_string', length: 128, required: true },
-                wp: { type: 'is_hex_string', length: 64, required: true },
-                wn: { type: 'is_hex_string', length: 64, required: true }
-            }
-        };
-        return this.#_validator.compile(schema);
-    }
-
-    sanitizePostTx(op) {
-        return this.#_sanitizePostTx(op) === true;
-    }
-}
-
-export default Check;

package/dump/src/utils/constants.js

@@ -1,63 +0,0 @@
-export const EntryType = Object.freeze({
-    ADMIN: 'admin',
-    WHITELIST: 'whitelist',
-    INDEXERS: 'indexers',
-});
-
-export const OperationType = Object.freeze({
-    ADD_ADMIN: 'addAdmin',
-    APPEND_WHITELIST: 'appendWhitelist',
-    ADD_WRITER: 'addWriter',
-    REMOVE_WRITER: 'removeWriter',
-    ADD_INDEXER: 'addIndexer',
-    REMOVE_INDEXER: 'removeIndexer',
-    BAN_VALIDATOR: 'banValidator',
-    WHITELISTED: 'whitelisted',
-    TX: 'tx',
-    PRE_TX: 'pre-tx',
-    POST_TX: 'post-tx',
-});
-
-export const EventType = Object.freeze({
-    ADMIN_EVENT: 'adminEvent',
-    WRITER_EVENT: 'writerEvent',
-    IS_INDEXER: 'is-indexer',
-    IS_NON_INDEXER: 'is-non-indexer',
-    READY_MSB: 'ready-msb',
-    WRITABLE: 'writable',
-    UNWRITABLE: 'unwritable',
-    WARNING: 'warning',
-});
-
-export const WHITELIST_FILEPATH = './Whitelist/pubkeys.csv';
-export const LISTENER_TIMEOUT = 10000;
-export const TRAC_NAMESPACE = 'TracNetwork';
-export const WHITELIST_PREFIX = 'whitelist/';
-export const MAX_INDEXERS = 3;
-export const MIN_INDEXERS = 1;
-export const WHITELIST_SLEEP_INTERVAL = 1000;
-export const MAX_PEERS = 64;
-export const MAX_PARALLEL = 64;
-export const MAX_SERVER_CONNECTIONS = Infinity;
-export const MAX_CLIENT_CONNECTIONS = Infinity;
-export const UPDATER_INTERVAL = 1_000;
-
-const constants = {
-    EntryType,
-    OperationType,
-    EventType,
-    WHITELIST_FILEPATH,
-    LISTENER_TIMEOUT,
-    TRAC_NAMESPACE,
-    MAX_INDEXERS,
-    MIN_INDEXERS,
-    WHITELIST_SLEEP_INTERVAL,
-    MAX_PEERS,
-    MAX_PARALLEL,
-    MAX_SERVER_CONNECTIONS,
-    UPDATER_INTERVAL,
-    WHITELIST_PREFIX
-};
-
-export default constants;
-

package/dump/src/utils/fileUtils.js

@@ -1,31 +0,0 @@
-import fs from 'fs';
-import {WHITELIST_FILEPATH} from '../utils/constants.js';
-
-// TODO: The methods in fileUtils need to be refactoed and generalized to improve code reusability
-// -- For example, the readPublicKeysFromFile method is specific to reading a whitelist file set in constants.
-// -- In the future, we might want to generalize this method to read any file and return its content.
-async function readPublicKeysFromFile() {
-    try {
-        const data = await fs.promises.readFile(WHITELIST_FILEPATH, 'utf8');
-        const pubKeys = data
-            .split('\n')
-            .map(line => line.trim())
-            .filter(line => line.length > 0);
-
-        if (pubKeys.length === 0) {
-            console.log('The file does not contain any public keys');
-        }
-
-        return pubKeys;
-    } catch (err) {
-        if (err.code === 'ENOENT') {
-            console.log('Whitelist file not found');
-        }
-        console.log(`Failed to read public keys from the whitelist file: ${err.message}`);
-    }
-}
-
-
-export default {
-    readPublicKeysFromFile
-}

package/dump/src/utils/functions.js

@@ -1,70 +0,0 @@
-import b4a from 'b4a';
-import sodium from 'sodium-native';
-import {peer} from "hyperdht/lib/messages.js";
-
-// TODO: (?) Should we allow 0x prefix?
-// TODO: (?) Should an mepty string be considered valid?
-export function isHexString(string) {
-    return typeof string === 'string' && /^[0-9a-fA-F]+$/.test(string) && string.length % 2 === 0;
-}
-
-export async function verifyDag(base, swarm, wallet, writerKey) {
-    try {
-        console.log('--- Stats ---');
-        const dagView = await base.view.core.treeHash();
-        const lengthdagView = base.view.core.length;
-        const dagSystem = await base.system.core.treeHash();
-        const lengthdagSystem = base.system.core.length;
-        console.log(`isIndexer: ${base.isIndexer}`);
-        console.log(`isWriter: ${base.writable}`);
-        console.log('wallet.publicKey:', wallet !== null ? wallet.publicKey : 'unset');
-        console.log('msb.writerKey:', writerKey);
-        console.log('swarm.connections.size:', swarm.connections.size);
-        console.log('base.view.core.signedLength:', base.view.core.signedLength);
-        console.log('base.view.core.length:', base.view.core.length);
-        console.log("base.signedLength", base.signedLength);
-        console.log("base.indexedLength", base.indexedLength);
-        console.log("base.linearizer.indexers.length", base.linearizer.indexers.length);
-        console.log(`base.key: ${base.key.toString('hex')}`);
-        console.log('discoveryKey:', b4a.toString(base.discoveryKey, 'hex'));
-        console.log(`VIEW Dag: ${dagView.toString('hex')} (length: ${lengthdagView})`);
-        console.log(`SYSTEM Dag: ${dagSystem.toString('hex')} (length: ${lengthdagSystem})`);
-        const wl = await base.view.get('wrl');
-        console.log('Total Registered Writers:', wl !== null ? wl.value : 0);
-
-    } catch (error) {
-        console.error('Error during DAG monitoring:', error.message);
-    }
-}
-
-export async function sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-export async function createHash(type, message) {
-    if (type === 'sha256') {
-        const out = b4a.alloc(sodium.crypto_hash_sha256_BYTES);
-        sodium.crypto_hash_sha256(out,!b4a.isBuffer(message) ? b4a.from(message) : message);
-        return b4a.toString(out, 'hex');
-    }
-    if (global.Pear !== undefined) {
-        let _type = '';
-        switch (type.toLowerCase()) {
-            case 'sha1': _type = 'SHA-1'; break;
-            case 'sha384': _type = 'SHA-384'; break;
-            case 'sha512': _type = 'SHA-512'; break;
-            default: throw new Error('Unsupported algorithm.');
-        }
-        const encoder = new TextEncoder();
-        const data = encoder.encode(b4a.isBuffer(message) ? b4a.toString(message, 'utf-8') : message);
-        const hash = await crypto.subtle.digest(_type, data);
-        const hashArray = Array.from(new Uint8Array(hash));
-        return hashArray
-            .map((b) => b.toString(16).padStart(2, "0"))
-            .join("");
-    } else {
-        // this is only available here for completeness and in fact will never be used in the MSB.
-        // just keep it as it is.
-        return crypto.createHash(type).update(!b4a.isBuffer(message) ? b4a.from(message) : message).digest('hex')
-    }
-}