trac-msb 0.2.18 → 0.2.20

package/tests/unit/state/utils/balance.test.js

@@ -1,320 +0,0 @@
-import { test } from 'brittle';
-import b4a from 'b4a';
-import { randomBuffer, TEN_THOUSAND_VALUE, tokenUnits } from '../stateTestUtils.js';
-import { ZERO_BALANCE, decode, encode } from '../../../../src/core/state/utils/nodeEntry.js';
-import { WRITER_BYTE_LENGTH, ADMIN_INITIAL_BALANCE, BALANCE_BYTE_LENGTH } from '../../../../src/utils/constants.js';
-import { $TNK, toBalance, toTerm, percent } from '../../../../src/core/state/utils/balance.js';
-import { bufferToBigInt } from '../../../../src/utils/amountSerialization.js';
-import { ZERO_LICENSE } from '../../../../src/core/state/utils/nodeEntry.js';
-test('Balance#asHex explicit', t => {
-    const val = $TNK(1000n)
-    t.is(toBalance(val).asHex(), b4a.toString(val, 'hex'), 'hex matches')
-})
-
-test('Balance#add', () => {
-    test('with zero', t => {
-        const node = {
-            wk: randomBuffer(WRITER_BYTE_LENGTH),
-            isWhitelisted: true,
-            isWriter: true,
-            isIndexer: false,
-            balance: ZERO_BALANCE,
-            license: ZERO_LICENSE,
-            stakedBalance: ZERO_BALANCE
-        };
-
-        const balance = toBalance(node.balance)
-        const addedBalance = balance.add(toBalance(TEN_THOUSAND_VALUE))
-
-        const encoded = encode(node)
-        addedBalance.update(encoded)
-
-        const updated = decode(encoded)
-        console.log("updated", updated)
-        t.ok(b4a.equals(updated.balance, TEN_THOUSAND_VALUE), 'balance matches');
-    });
-
-    test('other stuff', t => {
-        const node = {
-            wk: randomBuffer(WRITER_BYTE_LENGTH),
-            isWhitelisted: true,
-            isWriter: true,
-            isIndexer: false,
-            balance: TEN_THOUSAND_VALUE
-        };
-
-        const balance = toBalance(node.balance)
-        const addedBalance = balance.add(toBalance(TEN_THOUSAND_VALUE))
-        t.is(addedBalance.asHex(), '00000000000000000000000000004e20', 'balance matches');
-    });
-
-    test('overflow returns NULL_BUFFER', t => {
-        const max = b4a.alloc(BALANCE_BYTE_LENGTH, 0xFF);
-        const balance = toBalance(max);
-
-        const oneRaw = b4a.alloc(BALANCE_BYTE_LENGTH);
-        oneRaw[oneRaw.length - 1] = 1; // +1
-
-        const result = balance.add(toBalance(oneRaw));
-
-        // Should return null-like buffer on overflow
-        t.is(result, null, 'overflow returns null');
-    });
-
-    test('edge case: max - 1 + 1 = max', t => {
-        const maxMinusOne = b4a.alloc(BALANCE_BYTE_LENGTH, 0xFF);
-        maxMinusOne[maxMinusOne.length - 1] = 0xFE;
-        const balance = toBalance(maxMinusOne);
-
-        const oneRaw = b4a.alloc(BALANCE_BYTE_LENGTH);
-        oneRaw[oneRaw.length - 1] = 1;
-
-        const result = balance.add(toBalance(oneRaw));
-
-        // Should equal max value
-        const expected = b4a.alloc(BALANCE_BYTE_LENGTH, 0xFF);
-        t.ok(b4a.equals(result.value, expected), 'max - 1 + 1 = max');
-    });
-})
-
-test('Balance#sub', () => {
-    test('with zero', t => {
-        const node = {
-            wk: randomBuffer(WRITER_BYTE_LENGTH),
-            isWhitelisted: true,
-            isWriter: true,
-            isIndexer: false,
-            balance: TEN_THOUSAND_VALUE,
-            license: ZERO_LICENSE,
-            stakedBalance: ZERO_BALANCE
-        };
-
-        const balance = toBalance(node.balance)
-        const subBalance = balance.sub(toBalance(ZERO_BALANCE))
-
-        const encoded = encode(node)
-        subBalance.update(encoded)
-
-        const updated = decode(encoded)
-        t.ok(b4a.equals(updated.balance, TEN_THOUSAND_VALUE), 'balance matches');
-    });
-
-    test('zero from value', t => {
-        const node = {
-            wk: randomBuffer(WRITER_BYTE_LENGTH),
-            isWhitelisted: true,
-            isWriter: true,
-            isIndexer: false,
-            balance: TEN_THOUSAND_VALUE,
-            license: ZERO_LICENSE,
-            stakedBalance: ZERO_BALANCE
-        };
-
-        const balance = toBalance(node.balance)
-        const subBalance = balance.sub(toBalance(ZERO_BALANCE))
-
-        const encoded = encode(node)
-        subBalance.update(encoded)
-
-        const updated = decode(encoded)
-        t.ok(b4a.equals(updated.balance, TEN_THOUSAND_VALUE), 'balance matches');
-    });
-
-    test('underflow returns NULL_BUFFER', t => {
-        const a = $TNK(1000n);
-        const b = $TNK(2000n);
-        const result = toBalance(a).sub(toBalance(b));
-
-        // Should return null-like buffer on underflow
-        t.is(result, null, 'overflow returns null');
-    });
-
-    test('edge case: equal amounts = zero', t => {
-        const a = $TNK(5000n);
-        const b = $TNK(5000n);
-        const result = toBalance(a).sub(toBalance(b));
-
-        const expected = b4a.alloc(BALANCE_BYTE_LENGTH); // all zeros
-        t.ok(b4a.equals(result.value, expected), 'equal amounts subtract to zero');
-    });
-
-    test('edge case: one less than a', t => {
-        const a = $TNK(1000n);
-        const b = $TNK(999n);
-        const result = toBalance(a).sub(toBalance(b));
-
-        const expected = $TNK(1n);
-        t.ok(b4a.equals(result.value, expected), 'subtracting 999 from 1000 gives 1');
-    });
-})
-
-test('Balance#mul', () => {
-    test('basic multiplication', t => {
-        const a = $TNK(1000n);
-        const result = toBalance(a).mul(toTerm(4n));
-
-        // Should return null-like buffer on underflow
-        t.ok(toBalance($TNK(4000n)).equals(result), 'equal 4000n');
-    })
-
-    test('zero multiplication', t => {
-        const a = $TNK(4000n);
-        const result = toBalance(a).mul(toTerm(0n));
-
-        // Should return null-like buffer on underflow
-        t.ok(result.equals(toBalance($TNK(0n))), 'returns zero');
-    })
-
-    test('zero value multiplication', t => {
-        const a = toBalance($TNK(0n));
-        const result = a.mul(toTerm(1000n));
-
-        // Should return null-like buffer on underflow
-        t.ok(result.equals(toBalance($TNK(0n))), 'returns zero');
-    })
-
-    test('zero value multiplication', t => {
-        const a = toBalance($TNK(0n));
-        const result = a.mul(toTerm(1000n));
-
-        // Should return null-like buffer on underflow
-        t.ok(result.equals(toBalance($TNK(0n))), 'returns zero');
-    })
-
-    test('overflow returns NULL_BUFFER', t => {
-        const max = b4a.alloc(BALANCE_BYTE_LENGTH, 0xFF);
-        const balance = toBalance(max);
-
-        const balance2 = toBalance(max);
-
-        const result = balance.mul(balance2);
-
-        // Should return null-like buffer on overflow
-        t.is(result, null, 'overflow returns null');
-    });
-})
-
-test('Balance#div', () => {
-    test('basic division', t => {
-        const a = $TNK(4000n);
-        const result = toBalance(a).div(toTerm(4n));
-
-        // Should return null-like buffer on underflow
-        t.ok(toBalance($TNK(1000n)).equals(result), 'equal 1000n');
-    })
-
-    test('zero division', t => {
-        const a = $TNK(4000n);
-        const result = toBalance(a).div(toTerm(0n));
-
-        // Should return null-like buffer on underflow
-        t.is(result, null, 'returns null');
-    })
-
-    test('zero value division', t => {
-        const a = toBalance($TNK(0n));
-        const result = a.div(toTerm(1000n));
-
-        // Should return null-like buffer on underflow
-        t.ok(result.equals(toBalance($TNK(0n))), 'returns 0');
-    })
-})
-
-test('Balance#percentage', () => {
-    test('basic percentage', t => {
-        const a = $TNK(1000n);
-        const result = toBalance(a).percentage(percent(4));
-
-        // Should return null-like buffer on underflow
-        t.ok(toBalance($TNK(40n)).equals(result), 'equal 40n');
-    })
-})
-
-test('toTerm', t => {
-    const converted = bufferToBigInt(toTerm(4n))
-    t.is(converted, 4n, 'overflow returns null');
-})
-
-test('Balance#asBigInt', t => {
-    const node = {
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: false,
-        balance: TEN_THOUSAND_VALUE
-    };
-
-    const balance = toBalance(node.balance)
-    const addedBalance = balance.add(toBalance(TEN_THOUSAND_VALUE))
-    t.is(addedBalance.asBigInt(), 20_000n, 'balance matches');
-});
-
-test('Balance#greaterThan', t => {
-    const $TNK1000 = $TNK(1000n)
-    const $TNK1001 = $TNK(1001n)
-
-    t.not(toBalance($TNK1000).greaterThan(toBalance($TNK1001)), '1000 not greater than 1001');
-    t.ok(toBalance($TNK1001).greaterThan(toBalance($TNK1000)), '1001 greater than 1000');
-    t.not(toBalance($TNK1000).greaterThan(toBalance($TNK1000)), '1000 not greater than 1000');
-});
-
-test('Balance#lowerThan', t => {
-    const $TNK1000 = $TNK(1000n)
-    const $TNK1001 = $TNK(1001n)
-
-    t.not(toBalance($TNK1001).lowerThan(toBalance($TNK1000)), '1001 not lower than 1000');
-    t.ok(toBalance($TNK1000).lowerThan(toBalance($TNK1001)), '1000 lower than 1001');
-    t.not(toBalance($TNK1000).lowerThan(toBalance($TNK1000)), '1000 not lower than 1000');
-});
-
-test('Balance#equals', t => {
-    const $TNK1000 = $TNK(1000n)
-
-    t.ok(toBalance($TNK1000).equals(toBalance($TNK1000)), '1000 equals 1000');
-});
-
-test('Balance $TNK', t => {
-    const $TNK300 = $TNK(300n)
-    const converted = toBalance($TNK300).asBigInt()
-    t.is(converted, tokenUnits(300n), 'balance matches');
-});
-
-test('Node entry integration', t => {
-    const entry = encode({
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: true,
-        balance: ADMIN_INITIAL_BALANCE,
-        license: b4a.from([0, 0, 0, 1]),
-        stakedBalance: TEN_THOUSAND_VALUE
-    });
-
-    const decoded = decode(entry)
-
-    const updated = toBalance(decoded.balance)
-        .add(toBalance($TNK(300n)))
-        .update(encode(decoded))
-
-    t.is(toBalance(decode(updated).balance).asBigInt(), tokenUnits(1300n), 'balance matches');
-});
-
-test('Balance#greaterThanOrEquals', t => {
-    const b1000 = toBalance($TNK(1000n))
-    const b1001 = toBalance($TNK(1001n))
-    const b1000Dup = toBalance($TNK(1000n))
-
-    t.ok(b1001.greaterThanOrEquals(b1000), '1001 >= 1000')
-    t.ok(b1000.greaterThanOrEquals(b1000Dup), '1000 >= 1000')
-    t.ok(!b1000.greaterThanOrEquals(b1001), '1000 !>= 1001')
-})
-
-test('Balance#lowerThanOrEquals', t => {
-    const b1000 = toBalance($TNK(1000n))
-    const b1001 = toBalance($TNK(1001n))
-    const b1000Dup = toBalance($TNK(1000n))
-
-    t.ok(b1000.lowerThanOrEquals(b1001), '1000 <= 1001')
-    t.ok(b1000.lowerThanOrEquals(b1000Dup), '1000 <= 1000')
-    t.ok(!b1001.lowerThanOrEquals(b1000), '1001 !<= 1000')
-})

package/tests/unit/state/utils/lengthEntry.test.js

@@ -1,54 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-import lengthEntry from '../../../../src/core/state/utils/lengthEntry.js';
-
-// Test init()
-test('Length Entry - init returns a 4-byte buffer initialized to 0', t => {
-    const buf = lengthEntry.init();
-    t.ok(b4a.isBuffer(buf), 'should return a buffer');
-    t.is(buf.length, 4, 'buffer should be 4 bytes');
-    t.alike(buf, b4a.alloc(4, 0x00), 'buffer should be all zeros');
-});
-
-// Test encode()
-test('Length Entry - encode encodes integer to 4-byte buffer (Little Endian)', t => {
-    const value = 123456;
-    const buf = lengthEntry.encode(value);
-    t.ok(b4a.isBuffer(buf), 'should return a buffer');
-    t.is(buf.length, 4, 'buffer should be 4 bytes');
-    t.is(buf.readUInt32LE(), value, 'buffer should decode to original value');
-});
-
-test('Length Entry - encode(0) returns buffer of all zeros', t => {
-    const buf = lengthEntry.encode(0);
-    t.alike(buf, b4a.alloc(4, 0x00));
-});
-
-// Test decode()
-test('Length Entry - decode decodes 4-byte buffer to integer (LE)', t => {
-    const value = 987654;
-    const buf = b4a.alloc(4);
-    buf.writeUInt32LE(value);
-    t.is(lengthEntry.decode(buf), value);
-});
-
-// TODO: This test was deactivated because, currently, all function in lengthEntry.js can throw.
-// When this behaviour is corrected, we should reactivate this test
-// TODO: Also, implement other tests like this one for other functions in lengthEntry.js
-
-// test('Length Entry - decode doesn\'t throw if buffer is too short', t => {
-//     const shortBuf = b4a.alloc(2);
-//     t.is(lengthEntry.decode(shortBuf), 0);
-// });
-
-// Test increment()
-test('Length Entry - increment returns buffer with value+1', t => {
-    const value = 42;
-    const buf = lengthEntry.increment(value);
-    t.is(buf.readUInt32LE(), value + 1);
-});
-
-test('Length Entry - increment(0) returns buffer with value 1', t => {
-    const buf = lengthEntry.increment(0);
-    t.is(buf.readUInt32LE(), 1);
-});

package/tests/unit/state/utils/nodeEntry.test.js

@@ -1,298 +0,0 @@
-import { test } from 'brittle';
-import b4a from 'b4a';
-import { WRITER_BYTE_LENGTH, LICENSE_BYTE_LENGTH } from '../../../../src/utils/constants.js';
-import { randomBuffer, TEN_THOUSAND_VALUE } from '../stateTestUtils.js';
-import { NodeRole } from '../../../../src/core/state/utils/roles.js';
-import {
-    ZERO_BALANCE,
-    ZERO_LICENSE,
-    NODE_ENTRY_SIZE,
-    init as initNodeEntry,
-    encode as encodeNodeEntry,
-    decode as decodeNodeEntry,
-    setRole as setNodeEntryRole,
-    setBalance as setNodeEntryBalance,
-    setLicense as setNodeEntryLicense,
-    setStakedBalance as setNodeEntryStakedBalance,
-} from '../../../../src/core/state/utils/nodeEntry.js';
-
-// Test init()
-test('Node Entry - init - Happy Path', t => {
-    const wk = randomBuffer(WRITER_BYTE_LENGTH)
-    const initialized = initNodeEntry(wk, NodeRole.WHITELISTED)
-
-    t.is(initialized.length, NODE_ENTRY_SIZE, "initialized has valid length");
-    const decoded = decodeNodeEntry(initialized);
-    t.ok(decoded, 'decoded should not be null');
-    t.ok(b4a.equals(decoded.wk, wk), 'wk matches');
-    t.is(decoded.isWhitelisted, true, 'isWhitelisted matches');
-    t.is(decoded.isWriter, false, 'isWriter matches');
-    t.is(decoded.isIndexer, false, 'isIndexer matches');
-    t.ok(b4a.equals(decoded.balance, ZERO_BALANCE), 'balance matches');
-    t.ok(b4a.equals(decoded.license, ZERO_LICENSE), 'license matches');
-    t.ok(b4a.equals(decoded.stakedBalance, ZERO_BALANCE), 'stakedBalance matches');
-});
-
-test('Node Entry - init - Happy Path with balance', t => {
-    const wk = randomBuffer(WRITER_BYTE_LENGTH)
-    const initialized = initNodeEntry(wk, NodeRole.WHITELISTED, TEN_THOUSAND_VALUE)
-
-    t.is(initialized.length, NODE_ENTRY_SIZE, "initialized has valid length");
-    const decoded = decodeNodeEntry(initialized);
-    t.ok(decoded, 'decoded should not be null');
-    t.ok(b4a.equals(decoded.wk, wk), 'wk matches');
-    t.is(decoded.isWhitelisted, true, 'isWhitelisted matches');
-    t.is(decoded.isWriter, false, 'isWriter matches');
-    t.is(decoded.isIndexer, false, 'isIndexer matches');
-    t.ok(b4a.equals(decoded.balance, TEN_THOUSAND_VALUE), 'balance matches');
-});
-
-test('Node Entry - init - Happy Path with licesnse', t => {
-    const wk = randomBuffer(WRITER_BYTE_LENGTH)
-    const license = randomBuffer(LICENSE_BYTE_LENGTH)
-    const initialized = initNodeEntry(wk, NodeRole.WHITELISTED, TEN_THOUSAND_VALUE, license)
-
-    t.is(initialized.length, NODE_ENTRY_SIZE, "initialized has valid length");
-    const decoded = decodeNodeEntry(initialized);
-    t.ok(decoded, 'decoded should not be null');
-    t.ok(b4a.equals(decoded.wk, wk), 'wk matches');
-    t.is(decoded.isWhitelisted, true, 'isWhitelisted matches');
-    t.is(decoded.isWriter, false, 'isWriter matches');
-    t.is(decoded.isIndexer, false, 'isIndexer matches');
-    t.ok(b4a.equals(decoded.balance, TEN_THOUSAND_VALUE), 'balance matches');
-    t.ok(b4a.equals(decoded.license, license), 'license matches');
-});
-
-test('Node Entry - init - Happy Path with staked balance', t => {
-    const wk = randomBuffer(WRITER_BYTE_LENGTH)
-    const license = randomBuffer(LICENSE_BYTE_LENGTH)
-    const initialized = initNodeEntry(wk, NodeRole.WHITELISTED, TEN_THOUSAND_VALUE, license, TEN_THOUSAND_VALUE)
-
-    t.is(initialized.length, NODE_ENTRY_SIZE, "initialized has valid length");
-    const decoded = decodeNodeEntry(initialized);
-    t.ok(decoded, 'decoded should not be null');
-    t.ok(b4a.equals(decoded.wk, wk), 'wk matches');
-    t.is(decoded.isWhitelisted, true, 'isWhitelisted matches');
-    t.is(decoded.isWriter, false, 'isWriter matches');
-    t.is(decoded.isIndexer, false, 'isIndexer matches');
-    t.ok(b4a.equals(decoded.balance, TEN_THOUSAND_VALUE), 'balance matches');
-    t.ok(b4a.equals(decoded.license, license), 'license matches');
-    t.ok(b4a.equals(decoded.stakedBalance, TEN_THOUSAND_VALUE), 'stakedBalance matches');
-
-});
-
-// Test encode()
-test('Node Entry - encode and decode - Happy Path', t => {
-    const node = {
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: ZERO_LICENSE,
-        stakedBalance: ZERO_BALANCE
-    };
-
-    const encoded = encodeNodeEntry(node);
-    t.is(encoded.length, NODE_ENTRY_SIZE, "encoding has valid length");
-
-    const decoded = decodeNodeEntry(encoded);
-    t.ok(decoded, 'decoded should not be null');
-    t.ok(b4a.equals(decoded.wk, node.wk), 'wk matches');
-    t.is(decoded.isWhitelisted, true, 'isWhitelisted matches');
-    t.is(decoded.isWriter, true, 'isWriter matches');
-    t.is(decoded.isIndexer, false, 'isIndexer matches');
-    t.ok(b4a.equals(decoded.balance, ZERO_BALANCE), 'balance matches');
-    t.ok(b4a.equals(decoded.license, ZERO_LICENSE), 'license matches');
-    t.ok(b4a.equals(decoded.stakedBalance, ZERO_BALANCE), 'stakedBalance matches');
-});
-
-test('Node Entry - encode returns empty buffer on invalid wk', t => {
-    const node = {
-        wk: randomBuffer(10), // invalid size
-        isWhitelisted: false,
-        isWriter: false,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: ZERO_LICENSE,
-        stakedBalance: ZERO_BALANCE
-
-    };
-    const encoded = encodeNodeEntry(node);
-    t.is(encoded.length, 0);
-});
-
-test('Node Entry - encode returns empty buffer on invalid node role', t => {
-    const node = {
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: false,
-        isWriter: true, // can't be a writer without being whitelisted
-        isIndexer: false,
-        balance: ZERO_BALANCE
-    };
-    const encoded = encodeNodeEntry(node);
-    t.is(encoded.length, 0);
-});
-
-test('Node Entry - encode returns empty buffer on invalid balance', t => {
-    const node = {
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: false,
-        balance: b4a.from([
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27,
-            0x10,
-        ])
-    };
-    const encoded = encodeNodeEntry(node);
-    t.is(encoded.length, 0);
-});
-
-test('Node Entry - encode returns empty buffer on invalid license', t => {
-    const node = {
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: randomBuffer(10), // invalid size
-        stakedBalance: ZERO_BALANCE
-
-    };
-    const encoded = encodeNodeEntry(node);
-    t.is(encoded.length, 0);
-});
-
-test('Node Entry - encode returns empty buffer on invalid staked balance', t => {
-    const node = {
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: true,
-        isWriter: true,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: ZERO_LICENSE,
-        stakedBalance: b4a.from([
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27,
-            0x10,
-        ])
-    };
-    const encoded = encodeNodeEntry(node);
-    t.is(encoded.length, 0);
-});
-
-// Test decode()
-test('Node Entry - decode returns null on invalid input', t => {
-    const buf = randomBuffer(10); // invalid size
-    const decoded = decodeNodeEntry(buf);
-    t.is(decoded, null);
-});
-
-test('Node Entry - setRole updates role flags', t => {
-    const TEN_THOUSAND_VALUE = b4a.from([
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x27, 0x10,
-    ])
-
-    let entry = encodeNodeEntry({
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: false,
-        isWriter: false,
-        isIndexer: false,
-        balance: TEN_THOUSAND_VALUE,
-        license: ZERO_LICENSE,
-        stakedBalance: ZERO_BALANCE
-    });
-
-    // Set maximum tier role (0x7)
-    entry = setNodeEntryRole(entry, NodeRole.INDEXER);
-    const decoded = decodeNodeEntry(entry);
-    t.ok(decoded.isWhitelisted, 'isWhitelisted should be true');
-    t.ok(decoded.isWriter, 'isWriter should be true');
-    t.ok(decoded.isIndexer, 'isIndexer should be true');
-    t.ok(b4a.equals(decoded.balance, TEN_THOUSAND_VALUE), 'balance should not change');
-
-    // Set to no roles (0x0)
-    entry = setNodeEntryRole(entry, NodeRole.READER);
-    const decoded2 = decodeNodeEntry(entry);
-    t.not(decoded2.isWhitelisted, 'isWhitelisted should be false');
-    t.not(decoded2.isWriter, 'isWriter should be false');
-    t.not(decoded2.isIndexer, 'isIndexer should be false');
-    t.ok(b4a.equals(decoded.balance, TEN_THOUSAND_VALUE), 'balance should not change');
-});
-
-test('Node Entry - setBalance updates the balance', t => {
-    let entry = encodeNodeEntry({
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: false,
-        isWriter: false,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: ZERO_LICENSE,
-        stakedBalance: ZERO_BALANCE
-    });
-
-    entry = setNodeEntryBalance(entry, TEN_THOUSAND_VALUE);
-    const decoded = decodeNodeEntry(entry);
-    t.not(decoded.isWhitelisted, 'isWhitelisted should be true');
-    t.not(decoded.isWriter, 'isWriter should be true');
-    t.not(decoded.isIndexer, 'isIndexer should be true');
-    t.ok(b4a.equals(decoded.balance, TEN_THOUSAND_VALUE), 'balance should be 10k');
-
-    const INVALID_BALANCE = b4a.from([
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x27,
-        0x10,
-    ])
-
-    // Set to no roles (0x0)
-    entry = setNodeEntryBalance(entry, INVALID_BALANCE);
-    const decoded2 = decodeNodeEntry(entry);
-    t.is(decoded2, null);
-});
-
-test('Node Entry - setLicense updates the license', t => {
-    let entry = encodeNodeEntry({
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: false,
-        isWriter: false,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: ZERO_LICENSE,
-        stakedBalance: ZERO_BALANCE
-    });
-    const randomLicense = randomBuffer(LICENSE_BYTE_LENGTH);
-    entry = setNodeEntryLicense(entry, randomLicense);
-    const decoded = decodeNodeEntry(entry);
-    t.not(decoded.isWhitelisted, 'isWhitelisted should be true');
-    t.not(decoded.isWriter, 'isWriter should be true');
-    t.not(decoded.isIndexer, 'isIndexer should be true');
-    t.ok(b4a.equals(decoded.balance, ZERO_BALANCE), 'balance should be 0');
-    t.ok(b4a.equals(decoded.license, randomLicense), 'license should be set');
-});
-
-// set staked balance
-
-test('Node Entry - setStakedBalance updates the staked balance', t => {
-    let entry = encodeNodeEntry({
-        wk: randomBuffer(WRITER_BYTE_LENGTH),
-        isWhitelisted: false,
-        isWriter: false,
-        isIndexer: false,
-        balance: ZERO_BALANCE,
-        license: ZERO_LICENSE,
-        stakedBalance: ZERO_BALANCE
-    });
-    entry = setNodeEntryStakedBalance(entry, TEN_THOUSAND_VALUE);
-    const decoded = decodeNodeEntry(entry);
-    t.not(decoded.isWhitelisted, 'isWhitelisted should be true');
-    t.not(decoded.isWriter, 'isWriter should be true');
-    t.not(decoded.isIndexer, 'isIndexer should be true');
-    t.ok(b4a.equals(decoded.balance, ZERO_BALANCE), 'balance should be 0');
-    t.ok(b4a.equals(decoded.license, ZERO_LICENSE), 'license should be set');
-    t.ok(b4a.equals(decoded.stakedBalance, TEN_THOUSAND_VALUE), 'staked balance should be 10k');
-});