trac-msb 0.1.76 → 0.1.78

package/dump/src/utils/msgUtils.js

@@ -1,137 +0,0 @@
-import { isHexString, createHash } from './functions.js';
-import { OperationType } from './constants.js';
-import fileUtils from './fileUtils.js';
-import b4a from 'b4a';
-import Wallet from 'trac-wallet';
-
-class MsgUtils {
-
-    static createMessage(...args) {
-        let buf = null;
-        if (args.length >= 1) {
-            buf = b4a.concat(
-                args.map(arg => b4a.from(arg, isHexString(arg) ? 'hex' : undefined))
-            );
-        }
-        return buf;
-    }
-
-    static async #assembleMessageBase(wallet, keyParam, operationType) {
-        let nonce = null;
-        let msg = null;
-        let hash = null;
-        let baseKey = wallet.publicKey;
-        let value = null;
-
-        switch (operationType) {
-            case OperationType.ADD_ADMIN:
-            case OperationType.ADD_WRITER:
-            case OperationType.REMOVE_WRITER:
-                nonce = Wallet.generateNonce().toString('hex');
-                msg = this.createMessage(wallet.publicKey, keyParam, nonce, operationType);
-                hash = await createHash('sha256', msg);
-                value = {
-                    pub : wallet.publicKey,
-                    wk: keyParam,
-                    nonce: nonce,
-                    sig: wallet.sign(hash)
-                };
-                break;
-            case OperationType.APPEND_WHITELIST:
-            case OperationType.WHITELISTED:
-            case OperationType.BAN_VALIDATOR:
-            case OperationType.ADD_INDEXER:
-            case OperationType.REMOVE_INDEXER:
-                nonce = Wallet.generateNonce().toString('hex');
-                msg = this.createMessage(keyParam, nonce, operationType);
-                hash = await createHash('sha256', msg);
-                baseKey = keyParam;
-                value = {
-                    nonce: nonce,
-                    sig: wallet.sign(hash)
-                };
-                break;
-
-            default:
-                return undefined;
-        }
-
-        return {
-            type: operationType,
-            key: baseKey,
-            value
-        };
-    }
-
-    static async assembleAdminMessage(adminEntry, writingKey, wallet, bootstrap) {
-        if ((!adminEntry && wallet && writingKey && writingKey === bootstrap) || // Admin entry doesn't exist yet, thus admin public key can only be associated with bootstrap writing key
-            (adminEntry && adminEntry.tracPublicKey === wallet.publicKey && writingKey && writingKey !== adminEntry.wk)) { // Admin entry exists and we have to update its writing key in base, so it can recover admin access
-
-            return await this.#assembleMessageBase(wallet, writingKey, OperationType.ADD_ADMIN);
-        }
-    }
-
-    static async assembleWhitelistMessages(adminEntry, wallet) {
-        try {
-            if (!adminEntry || !wallet || wallet.publicKey !== adminEntry.tracPublicKey) {
-                return null;
-            }
-
-            const messages = [];
-            const pubKeys = await fileUtils.readPublicKeysFromFile();
-
-            for (const pubKey of pubKeys) {
-                const assembledMessage = await this.#assembleMessageBase(wallet, pubKey, OperationType.APPEND_WHITELIST);
-                messages.push(assembledMessage);
-            }
-
-            return messages;
-        } catch (err) {
-            console.log(`Failed to create whitelist messages: ${err.message}`);
-        }
-    }
-
-    static async assembleAddWriterMessage(wallet, writingKey) {
-        return await this.#assembleMessageBase(wallet, writingKey, OperationType.ADD_WRITER);
-    }
-
-    static async assembleRemoveWriterMessage(wallet, writingKey) {
-        return await this.#assembleMessageBase(wallet, writingKey, OperationType.REMOVE_WRITER);
-    }
-
-    static async assembleAddIndexerMessage(wallet, writerTracPublicKey) {
-        return await this.#assembleMessageBase(wallet, writerTracPublicKey, OperationType.ADD_INDEXER);
-    }
-
-    static async assembleRemoveIndexerMessage(wallet, writerTracPublicKey) {
-        return await this.#assembleMessageBase(wallet, writerTracPublicKey, OperationType.REMOVE_INDEXER);
-    }
-
-    static async assembleBanValidatorMessage(wallet, writerTracPublicKey) {
-        return await this.#assembleMessageBase(wallet, writerTracPublicKey, OperationType.BAN_VALIDATOR);
-    }
-
-    static async assembleWhitelistedMessage(wallet, writerTracPublicKey) {
-        return await this.#assembleMessageBase(wallet, writerTracPublicKey, OperationType.WHITELISTED);
-    }
-
-    static async verifyEventMessage(parsedRequest, wallet, check) {
-        const { type, key, value } = parsedRequest;
-        if (
-            type !== OperationType.ADD_ADMIN &&
-            type !== OperationType.ADD_WRITER &&
-            type !== OperationType.REMOVE_WRITER
-        ) {
-            return false;
-        }
-        const sanitizationResult = check.sanitizeAdminAndWritersOperations(parsedRequest);
-        if (!sanitizationResult) return false;
-
-        const msg = this.createMessage(key, value.wk, value.nonce, type);
-        const hash = await createHash('sha256', msg);
-        return wallet.verify(value.sig, hash, key);
-    }
-
-}
-
-export default MsgUtils;

package/dump/test/all.test.js

@@ -1,18 +0,0 @@
-// This runner is auto-generated by Brittle
-
-import { default as test } from 'brittle';
-
-async function runTests() {
-  test.pause();
-
-  await import('./check.test.js');
-  await import('./fileUtils.test.js');
-  await import('./functions.test.js');
-
-  //TODO add test MsgUtils
-  //TODO add test Apply function
-
-  test.resume();
-}
-
-runTests();

package/dump/test/check.test.js

@@ -1,21 +0,0 @@
-import test from 'brittle'
-import Check from '../src/utils/check.js';
-
-test('preTx', function (t) {
-    const check = new Check();
-    const validData = {
-        op: 'pre-tx',
-        tx: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        is: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        wp: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        i: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        ipk: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        ch: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        in: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        bs: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234',
-        mbs: 'abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234abcd1234'
-    }
-    const result = check.sanitizePreTx(validData)
-    t.ok(result, 'Valid data should pass the sanitization')
-
-})

package/dump/test/fileUtils.test.js

@@ -1,16 +0,0 @@
-import test from 'brittle';
-import fileUtils from '../src/utils/fileUtils.js';
-
-test('readPublicKeysFromFile', async (t) => {
-    // TODO: This is reading the real whitelist file (which is not a good practice)
-    // -- In the future, this function should be generalized so we can mock the file reading
-    // -- and test the function without relying on the actual file.
-    // -- For now, we will just check if the file reading works and returns an array of public keys.
-    const pubKeys = await fileUtils.readPublicKeysFromFile(); 
-    t.ok(Array.isArray(pubKeys), 'Should return an array');
-    t.ok(pubKeys.length > 0, 'Should return a non-empty array'); // Assuming the file has at least one public key. Without being able to mock the file, we can't guarantee this.
-    pubKeys.forEach((key) => {
-        t.is(typeof key, 'string', 'Each public key should be a string');
-    });
-}
-);

package/dump/test/functions.test.js

@@ -1,22 +0,0 @@
-import test from 'brittle';
-import * as functions from '../src/utils/functions.js';
-
-test('isHexString', (t) => {
-    // t.ok(functions.isHexString('0x1234567890abcdef'), 'Valid hex string should return true'); // Deactivated. See TODO in functions.js
-    t.ok(functions.isHexString('1234567890abcdef'), 'Valid hex string should return true');
-    t.ok(functions.isHexString('1234567890xyz') === false, 'Invalid hex string should return false');
-    t.ok(functions.isHexString('123456789') === false, 'Invalid size hex string should return false');
-    // t.ok(functions.isHexString('') === false, 'Empty string should return false'); // Deactivated. See TODO in functions.js
-});
-
-test('createHash', async (t) => {
-    // TODO: Add tests for other supported hash types
-    t.test('sha256', async (k) => {
-        const hash = await functions.createHash('sha256', 'test');
-        k.is(typeof hash, 'string', 'Hash should be a string');
-        k.ok(hash.length === 64, 'Hash should be 64 characters long');
-        k.ok(hash.match(/^[a-f0-9]+$/), 'Hash should be a hex string');
-        k.ok(hash !== await functions.createHash('sha256', 'Test'), 'Hash should be different for different inputs');
-        k.ok(hash === await functions.createHash('sha256', 'test'), 'Hash should be the same for the same input');
-    });
-});