trac-msb 0.2.17 → 0.2.19

package/tests/unit/messages/state/applyStateMessageBuilder.partial.test.js

@@ -1,237 +0,0 @@
-import { test } from 'brittle';
-import b4a from 'b4a';
-import PeerWallet from 'trac-wallet';
-
-import ApplyStateMessageBuilder from '../../../../src/messages/state/ApplyStateMessageBuilder.js';
-import { OperationType } from '../../../../src/utils/constants.js';
-import { isHexString } from '../../../../src/utils/helpers.js';
-import { config } from '../../../helpers/config.js';
-import { testKeyPair1, testKeyPair2 } from '../../../fixtures/apply.fixtures.js';
-import { isAddressValid } from '../../../../src/core/state/utils/address.js';
-
-const hex = (value, bytes) => value.repeat(bytes);
-
-async function createWallet(mnemonic) {
-    const wallet = new PeerWallet({
-        mnemonic,
-        networkPrefix: config.addressPrefix,
-        derivationPath: config.derivationPath
-    });
-    await wallet.ready;
-    return wallet;
-}
-
-function expectHexField(t, value, bytes, label) {
-    t.is(typeof value, 'string', `${label} type`);
-    t.is(value.length, bytes * 2, `${label} length`);
-    t.ok(isHexString(value), `${label} hex`);
-}
-
-function expectAddressField(t, value, label) {
-    t.is(typeof value, 'string', `${label} type`);
-    t.is(value.length, config.addressLength, `${label} length`);
-    t.ok(isAddressValid(value, config.addressPrefix), `${label} valid`);
-}
-
-function expectKeys(t, value, keys, label) {
-    t.alike(Object.keys(value).sort(), keys.slice().sort(), `${label} keys`);
-}
-
-function expectPayloadKeys(t, payload, bodyKey) {
-    expectKeys(t, payload, ['type', 'address', bodyKey], 'payload');
-}
-
-test('ApplyStateMessageBuilder partial add writer (rao)', async t => {
-    const wallet = await createWallet(testKeyPair1.mnemonic);
-    const txValidity = hex('11', 32);
-    const writingKey = hex('22', 32);
-
-    const builder = new ApplyStateMessageBuilder(wallet, config);
-    await builder
-        .setPhase('partial')
-        .setOutput('json')
-        .setOperationType(OperationType.ADD_WRITER)
-        .setAddress(wallet.address)
-        .setTxValidity(txValidity)
-        .setWriterKey(writingKey)
-        .build();
-
-    const payload = builder.getPayload();
-    t.is(payload.type, OperationType.ADD_WRITER);
-    t.is(payload.address, wallet.address);
-    expectAddressField(t, payload.address, 'address');
-    expectPayloadKeys(t, payload, 'rao');
-    expectKeys(t, payload.rao, ['tx', 'txv', 'iw', 'in', 'is'], 'rao');
-    expectHexField(t, payload.rao.tx, 32, 'rao.tx');
-    expectHexField(t, payload.rao.txv, 32, 'rao.txv');
-    expectHexField(t, payload.rao.iw, 32, 'rao.iw');
-    expectHexField(t, payload.rao.in, 32, 'rao.in');
-    expectHexField(t, payload.rao.is, 64, 'rao.is');
-    t.is(payload.rao.txv, txValidity);
-    t.is(payload.rao.iw, writingKey);
-});
-
-test('ApplyStateMessageBuilder partial remove writer (rao)', async t => {
-    const wallet = await createWallet(testKeyPair1.mnemonic);
-    const txValidity = hex('33', 32);
-    const writingKey = hex('44', 32);
-
-    const builder = new ApplyStateMessageBuilder(wallet, config);
-    await builder
-        .setPhase('partial')
-        .setOutput('json')
-        .setOperationType(OperationType.REMOVE_WRITER)
-        .setAddress(wallet.address)
-        .setTxValidity(txValidity)
-        .setWriterKey(writingKey)
-        .build();
-
-    const payload = builder.getPayload();
-    t.is(payload.type, OperationType.REMOVE_WRITER);
-    t.is(payload.address, wallet.address);
-    expectPayloadKeys(t, payload, 'rao');
-    expectKeys(t, payload.rao, ['tx', 'txv', 'iw', 'in', 'is'], 'rao');
-    expectHexField(t, payload.rao.tx, 32, 'rao.tx');
-    expectHexField(t, payload.rao.txv, 32, 'rao.txv');
-    expectHexField(t, payload.rao.iw, 32, 'rao.iw');
-    expectHexField(t, payload.rao.in, 32, 'rao.in');
-    expectHexField(t, payload.rao.is, 64, 'rao.is');
-    t.is(payload.rao.txv, txValidity);
-    t.is(payload.rao.iw, writingKey);
-});
-
-test('ApplyStateMessageBuilder partial admin recovery (rao)', async t => {
-    const wallet = await createWallet(testKeyPair1.mnemonic);
-    const txValidity = hex('55', 32);
-    const writingKey = hex('66', 32);
-
-    const builder = new ApplyStateMessageBuilder(wallet, config);
-    await builder
-        .setPhase('partial')
-        .setOutput('json')
-        .setOperationType(OperationType.ADMIN_RECOVERY)
-        .setAddress(wallet.address)
-        .setTxValidity(txValidity)
-        .setWriterKey(writingKey)
-        .build();
-
-    const payload = builder.getPayload();
-    t.is(payload.type, OperationType.ADMIN_RECOVERY);
-    t.is(payload.address, wallet.address);
-    expectPayloadKeys(t, payload, 'rao');
-    expectKeys(t, payload.rao, ['tx', 'txv', 'iw', 'in', 'is'], 'rao');
-    expectHexField(t, payload.rao.tx, 32, 'rao.tx');
-    expectHexField(t, payload.rao.txv, 32, 'rao.txv');
-    expectHexField(t, payload.rao.iw, 32, 'rao.iw');
-    expectHexField(t, payload.rao.in, 32, 'rao.in');
-    expectHexField(t, payload.rao.is, 64, 'rao.is');
-    t.is(payload.rao.txv, txValidity);
-    t.is(payload.rao.iw, writingKey);
-});
-
-test('ApplyStateMessageBuilder partial bootstrap deployment (bdo)', async t => {
-    const wallet = await createWallet(testKeyPair1.mnemonic);
-    const txValidity = hex('77', 32);
-    const externalBootstrap = hex('88', 32);
-    const channel = hex('99', 32);
-
-    const builder = new ApplyStateMessageBuilder(wallet, config);
-    await builder
-        .setPhase('partial')
-        .setOutput('json')
-        .setOperationType(OperationType.BOOTSTRAP_DEPLOYMENT)
-        .setAddress(wallet.address)
-        .setTxValidity(txValidity)
-        .setExternalBootstrap(externalBootstrap)
-        .setChannel(channel)
-        .build();
-
-    const payload = builder.getPayload();
-    t.is(payload.type, OperationType.BOOTSTRAP_DEPLOYMENT);
-    t.is(payload.address, wallet.address);
-    expectPayloadKeys(t, payload, 'bdo');
-    expectKeys(t, payload.bdo, ['tx', 'txv', 'bs', 'ic', 'in', 'is'], 'bdo');
-    expectHexField(t, payload.bdo.tx, 32, 'bdo.tx');
-    expectHexField(t, payload.bdo.txv, 32, 'bdo.txv');
-    expectHexField(t, payload.bdo.bs, 32, 'bdo.bs');
-    expectHexField(t, payload.bdo.ic, 32, 'bdo.ic');
-    expectHexField(t, payload.bdo.in, 32, 'bdo.in');
-    expectHexField(t, payload.bdo.is, 64, 'bdo.is');
-    t.is(payload.bdo.txv, txValidity);
-    t.is(payload.bdo.bs, externalBootstrap);
-    t.is(payload.bdo.ic, channel);
-});
-
-test('ApplyStateMessageBuilder partial transaction operation (txo)', async t => {
-    const wallet = await createWallet(testKeyPair1.mnemonic);
-    const txValidity = hex('aa', 32);
-    const writingKey = hex('bb', 32);
-    const contentHash = hex('cc', 32);
-    const externalBootstrap = hex('dd', 32);
-    const msbBootstrap = hex('ee', 32);
-
-    const builder = new ApplyStateMessageBuilder(wallet, config);
-    await builder
-        .setPhase('partial')
-        .setOutput('json')
-        .setOperationType(OperationType.TX)
-        .setAddress(wallet.address)
-        .setTxValidity(txValidity)
-        .setWriterKey(writingKey)
-        .setContentHash(contentHash)
-        .setExternalBootstrap(externalBootstrap)
-        .setMsbBootstrap(msbBootstrap)
-        .build();
-
-    const payload = builder.getPayload();
-    t.is(payload.type, OperationType.TX);
-    t.is(payload.address, wallet.address);
-    expectPayloadKeys(t, payload, 'txo');
-    expectKeys(t, payload.txo, ['tx', 'txv', 'iw', 'ch', 'bs', 'mbs', 'in', 'is'], 'txo');
-    expectHexField(t, payload.txo.tx, 32, 'txo.tx');
-    expectHexField(t, payload.txo.txv, 32, 'txo.txv');
-    expectHexField(t, payload.txo.iw, 32, 'txo.iw');
-    expectHexField(t, payload.txo.ch, 32, 'txo.ch');
-    expectHexField(t, payload.txo.bs, 32, 'txo.bs');
-    expectHexField(t, payload.txo.mbs, 32, 'txo.mbs');
-    expectHexField(t, payload.txo.in, 32, 'txo.in');
-    expectHexField(t, payload.txo.is, 64, 'txo.is');
-    t.is(payload.txo.txv, txValidity);
-    t.is(payload.txo.iw, writingKey);
-    t.is(payload.txo.ch, contentHash);
-    t.is(payload.txo.bs, externalBootstrap);
-    t.is(payload.txo.mbs, msbBootstrap);
-});
-
-test('ApplyStateMessageBuilder partial transfer operation (tro)', async t => {
-    const wallet = await createWallet(testKeyPair1.mnemonic);
-    const otherWallet = await createWallet(testKeyPair2.mnemonic);
-    const txValidity = hex('ab', 32);
-    const amount = hex('cd', 16);
-
-    const builder = new ApplyStateMessageBuilder(wallet, config);
-    await builder
-        .setPhase('partial')
-        .setOutput('json')
-        .setOperationType(OperationType.TRANSFER)
-        .setAddress(wallet.address)
-        .setTxValidity(txValidity)
-        .setIncomingAddress(otherWallet.address)
-        .setAmount(amount)
-        .build();
-
-    const payload = builder.getPayload();
-    t.is(payload.type, OperationType.TRANSFER);
-    t.is(payload.address, wallet.address);
-    expectPayloadKeys(t, payload, 'tro');
-    expectKeys(t, payload.tro, ['tx', 'txv', 'to', 'am', 'in', 'is'], 'tro');
-    expectHexField(t, payload.tro.tx, 32, 'tro.tx');
-    expectHexField(t, payload.tro.txv, 32, 'tro.txv');
-    expectAddressField(t, payload.tro.to, 'tro.to');
-    expectHexField(t, payload.tro.am, 16, 'tro.am');
-    expectHexField(t, payload.tro.in, 32, 'tro.in');
-    expectHexField(t, payload.tro.is, 64, 'tro.is');
-    t.is(payload.tro.txv, txValidity);
-    t.is(payload.tro.to, otherWallet.address);
-    t.is(payload.tro.am, amount);
-});

package/tests/unit/network/ConnectionManager.test.js

@@ -1,191 +0,0 @@
-import sinon from "sinon";
-import { hook, test } from 'brittle'
-import { default as EventEmitter } from "bare-events"
-import { testKeyPair1, testKeyPair2, testKeyPair3, testKeyPair4, testKeyPair5, testKeyPair6, testKeyPair7, testKeyPair8, testKeyPair9 } from "../../fixtures/apply.fixtures.js";
-import ConnectionManager from "../../../src/core/network/services/ConnectionManager.js";
-import { tick } from "../../helpers/setupApplyTests.js";
-import b4a from 'b4a'
-import { createConfig, ENV } from "../../../src/config/env.js";
-
-const createConnection = (key) => {
-    const emitter = new EventEmitter()
-    emitter.protocolSession = {
-        has: (name) => name === 'legacy',
-        send: sinon.stub().resolves(),
-    };
-    emitter.connected = true
-    emitter.remotePublicKey = b4a.from(key, 'hex')
-    
-    return { key: b4a.from(key, 'hex'), connection: emitter }
-}
-
-const makeManager = (maxValidators = 6, conns = connections) => {
-    const merged = createConfig(ENV.DEVELOPMENT, { maxValidators })
-    const connectionManager = new ConnectionManager(merged)
-
-    conns.forEach(({ key, connection }) => {
-        connectionManager.addValidator(key, connection)
-    });
-
-    return connectionManager
-}
-
-const reset = () => {
-    sinon.restore()
-    connections.forEach(connection => {
-        connection.connection.protocolSession.send.resetHistory()
-    })
-}
-
-let connections
-hook('Initialize state', async () => {
-    connections = [
-        createConnection(testKeyPair1.publicKey),
-        createConnection(testKeyPair2.publicKey),
-        createConnection(testKeyPair3.publicKey),
-        createConnection(testKeyPair4.publicKey),
-    ]
-});
-
-test('ConnectionManager', () => {
-    test('addValidator', async t => {
-        test('adds a validator', async t => {
-            reset()
-            const connectionManager = makeManager()
-            t.is(connectionManager.connectionCount(), connections.length, 'should have the same length')
-            const data = createConnection(testKeyPair5.publicKey)
-            connectionManager.addValidator(data.key, data.connection)
-            t.is(connectionManager.connectionCount(), connections.length + 1, 'should have the same length')
-        })
-
-        test('dont surpass maxConnections', async t => {
-            reset()
-            const maxConnections = 5
-            const connectionManager = makeManager(maxConnections)
-            t.is(connectionManager.connectionCount(), connections.length, 'should have the same length')
-
-            const toAdd = createConnection(testKeyPair5.publicKey)
-            connectionManager.addValidator(toAdd.key, toAdd.connection)
-            t.is(connectionManager.connectionCount(), maxConnections, 'should match the max connections')
-
-            const toNotAdd = createConnection(testKeyPair6.publicKey)
-            connectionManager.addValidator(toNotAdd.key, toNotAdd.connection)
-            t.is(connectionManager.connectionCount(), maxConnections, 'should not increase length')
-        })
-
-        test('does not add new validator when pool is full', async t => {
-            reset()
-            const maxConnections = 2
-            const localConnections = [
-                createConnection(testKeyPair1.publicKey),
-                createConnection(testKeyPair2.publicKey),
-            ]
-
-            const connectionManager = makeManager(maxConnections)
-            localConnections.forEach(({ key, connection }) => {
-                connectionManager.addValidator(key, connection)
-            })
-
-            t.is(connectionManager.connectionCount(), maxConnections, 'pool should be full')
-
-            const newConn = createConnection(testKeyPair3.publicKey)
-            connectionManager.addValidator(newConn.key, newConn.connection)
-
-            t.is(connectionManager.connectionCount(), maxConnections, 'should stay at max size')
-            t.not(connectionManager.connected(newConn.key), 'new validator should not be in the pool')
-
-            const remainingOld = localConnections.filter(c => connectionManager.connected(c.key)).length
-            t.is(remainingOld, 2, 'all of the old validators should remain')
-        })
-    })
-
-    test('connected', async t => {
-        test('true', async t => {
-            reset()
-            const connectionManager = makeManager()
-            connections.forEach(con => {
-                t.ok(connectionManager.connected(con.key), 'should respond true')
-            })
-        })
-
-        test('false', async t => {
-            reset()
-            const connectionManager = makeManager()
-            t.ok(!connectionManager.connected(testKeyPair6.publicKey), 'should respond false')
-        })
-    })
-
-    test('send', async t => {
-        test('triggers send on messenger', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            const target = connectionManager.send([1,2,3,4])
-
-            const totalCalls = connections.reduce((sum, con) => sum + con.connection.protocolSession.send.callCount, 0)
-            t.is(totalCalls, 1, 'should send to exactly one validator')
-            t.ok(target, 'should return a target public key')
-        })
-
-        test('does not throw on individual send errors', async t => {
-            reset()
-            const errorConnections = [
-                createConnection(testKeyPair7.publicKey),
-                createConnection(testKeyPair8.publicKey),
-            ]
-
-            errorConnections.forEach(con => {
-                con.connection.protocolSession.send = sinon.stub().throws(new Error())
-            })
-
-            const connectionManager = makeManager(5, errorConnections)
-
-            t.is(errorConnections.length, 2, 'should have two connections')
-            connectionManager.send([1,2,3,4])
-            t.ok(true, 'send should not throw even if individual sends fail')
-        })
-    })
-
-    test('on close', async t => {
-        test('removes from list', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            const connectionCount = connectionManager.connectionCount()
-
-            connections[1].connection.connected = false
-            connections[1].connection.emit('close')
-            await tick()
-            t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
-        })
-    })
-
-    test('remove', async t => {
-        test('removes a validator by public key', async t => {
-            reset()
-            const connectionManager = makeManager()
-            const previousCount = connectionManager.connectionCount()
-            const lastValidator = connections.shift()
-            
-            t.ok(connectionManager.connected(lastValidator.key), 'should be connected')
-            connectionManager.remove(lastValidator.key)
-
-            t.is(connectionManager.connectionCount(), previousCount - 1, 'should reduce the connection count')
-            t.ok(!connectionManager.connected(lastValidator.key), 'should be connected')
-        })
-    })
-
-    test('on close', async t => {
-        test('removes from list', async t => {
-            reset()
-            const connectionManager = makeManager()
-
-            const connectionCount = connectionManager.connectionCount()
-
-            connections[1].connection.connected = false
-            connections[1].connection.emit('close')
-            await tick()
-            t.is(connectionCount, connectionManager.connectionCount() + 1, 'first on the list should have been called')
-        })
-    })
-})

package/tests/unit/network/NetworkWalletFactory.test.js

@@ -1,156 +0,0 @@
-import { test } from 'brittle';
-import sinon from 'sinon';
-import b4a from 'b4a';
-
-import PeerWallet from 'trac-wallet';
-import NetworkWalletFactory, { EphemeralWallet } from '../../../src/core/network/identity/NetworkWalletFactory.js';
-import { errorMessageIncludes } from '../../helpers/regexHelper.js';
-import { testKeyPair1, testKeyPair2 } from '../../fixtures/apply.fixtures.js';
-import { config } from '../../helpers/config.js';
-
-test('NetworkWalletFactory.provide returns wallet when enabled', async t => {
-    const publicKey = b4a.from(testKeyPair2.publicKey, 'hex');
-    const address = PeerWallet.encodeBech32m(config.addressPrefix, publicKey);
-    const signResult = b4a.from('abcd', 'hex');
-    const wallet = {
-        publicKey,
-        address,
-        sign: sinon.stub().returns(signResult),
-        verify: sinon.stub().returns(true)
-    };
-
-    const provider = NetworkWalletFactory.provide({ wallet, enableWallet: true, networkPrefix: config.addressPrefix });
-    const message = b4a.from('00112233', 'hex');
-    const signature = provider.sign(message);
-
-    t.alike(provider.publicKey, publicKey);
-    t.is(provider.address, address);
-    t.alike(signature, signResult);
-    t.ok(wallet.sign.calledOnceWithExactly(message));
-
-    const verifyResult = provider.verify(signature, message);
-    t.ok(verifyResult);
-    t.ok(wallet.verify.calledOnceWithExactly(signature, message));
-
-    sinon.restore();
-});
-
-test('NetworkWalletFactory.provide requires both public and secret keys when wallet disabled', async t => {
-    const publicKey = b4a.from(testKeyPair1.publicKey, 'hex');
-    await t.exception(
-        () => NetworkWalletFactory.provide({ enableWallet: false, keyPair: { publicKey }, networkPrefix: config.addressPrefix }),
-        errorMessageIncludes('keyPair with publicKey and secretKey is required')
-    );
-});
-
-test('NetworkWalletFactory.provide rejects non-buffer inputs', async t => {
-    const secretKey = b4a.from(testKeyPair1.secretKey, 'hex');
-    await t.exception(
-        () =>
-            NetworkWalletFactory.provide({
-                enableWallet: false,
-                keyPair: { publicKey: 'not-a-buffer', secretKey },
-                networkPrefix: config.addressPrefix
-            }),
-        errorMessageIncludes('must be a Buffer')
-    );
-});
-
-test('NetworkWalletFactory.provide propagates invalid public key length errors', async t => {
-    const secretKey = b4a.from(testKeyPair1.secretKey, 'hex');
-    const invalidPublicKey = b4a.alloc(10);
-
-    await t.exception(
-        () =>
-            NetworkWalletFactory.provide({
-                enableWallet: false,
-                keyPair: { publicKey: invalidPublicKey, secretKey },
-                networkPrefix: config.addressPrefix
-            }),
-        errorMessageIncludes('Invalid public key')
-    );
-});
-
-test('NetworkWalletFactory.provide derives address and signs payloads from keyPair', async t => {
-    const keyPair = {
-        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
-        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
-    };
-    const provider = NetworkWalletFactory.provide({
-        enableWallet: false,
-        keyPair,
-        networkPrefix: config.addressPrefix
-    });
-    const message = b4a.from('123455555', 'hex');
-    const signature = provider.sign(message);
-
-    t.is(
-        provider.address,
-        PeerWallet.encodeBech32m(config.addressPrefix, provider.publicKey)
-    );
-    t.ok(PeerWallet.verify(signature, message, provider.publicKey));
-    t.ok(provider.verify(signature, message));
-});
-
-test('NetworkWalletFactory handles falsy address derivation results', async t => {
-    const keyPair = {
-        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
-        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
-    };
-
-    const stub = sinon.stub(PeerWallet, 'encodeBech32m').returns(null);
-    await t.exception(
-        () =>
-            NetworkWalletFactory.provide({
-                enableWallet: false,
-                keyPair,
-                networkPrefix: config.addressPrefix
-            }),
-        errorMessageIncludes('failed to derive address')
-    );
-    stub.restore();
-    sinon.restore();
-});
-
-test('NetworkWalletFactory propagates encoder exceptions', async t => {
-    const keyPair = {
-        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
-        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
-    };
-
-    const stub = sinon.stub(PeerWallet, 'encodeBech32m').throws(new Error('test exception'));
-    await t.exception(
-        () =>
-            NetworkWalletFactory.provide({
-                enableWallet: false,
-                keyPair,
-                networkPrefix: config.addressPrefix
-            }),
-        errorMessageIncludes('test exception')
-    );
-    stub.restore();
-    sinon.restore();
-});
-
-test('EphemeralWallet exposes wallet like interface', async t => {
-    const keyPair = {
-        publicKey: b4a.from(testKeyPair1.publicKey, 'hex'),
-        secretKey: b4a.from(testKeyPair1.secretKey, 'hex')
-    };
-    const wallet = new EphemeralWallet(keyPair, config.addressPrefix);
-    const message = b4a.from('feedface', 'hex');
-    const signature = wallet.sign(message);
-
-    t.alike(wallet.publicKey, keyPair.publicKey);
-    t.is(wallet.address, PeerWallet.encodeBech32m(config.addressPrefix, keyPair.publicKey));
-    t.ok(PeerWallet.verify(signature, message, wallet.publicKey));
-    t.ok(wallet.verify(signature, message));
-});
-
-test('EphemeralWallet requires both public and secret keys', async t => {
-    const publicKey = b4a.from(testKeyPair1.publicKey, 'hex');
-    await t.exception(
-        () => new EphemeralWallet({ publicKey }, config.addressPrefix),
-        errorMessageIncludes('keyPair with publicKey and secretKey is required')
-    );
-});

package/tests/unit/network/networkModule.test.js

@@ -1,10 +0,0 @@
-import { default as test } from 'brittle';
-
-async function runNetworkModuleTests() {
-    test.pause();
-    await import('./ConnectionManager.test.js');
-    await import('./NetworkWalletFactory.test.js');
-    test.resume();
-}
-
-await runNetworkModuleTests();

package/tests/unit/state/State.test.js

@@ -1,80 +0,0 @@
-import { test, hook } from 'brittle';
-import { encode, decode, ZERO_BALANCE } from '../../src/core/state/utils/nodeEntry.js';
-import esmock from "esmock";
-import sinon from "sinon";
-import { randomBuffer, tokenUnits } from './stateTestUtils.js';
-import { WRITER_BYTE_LENGTH, ADMIN_INITIAL_BALANCE } from '../../src/utils/constants.js';
-import { $TNK, toBalance } from '../../src/core/state/utils/balance.js';
-import b4a from 'b4a'
-
-let state
-hook('Initialize state', async () => {
-    const checkout = sinon.stub().returns({ get: () => {
-            return { value: encode({
-                wk: randomBuffer(WRITER_BYTE_LENGTH),
-                isWhitelisted: true,
-                isWriter: true,
-                isIndexer: true,
-                balance: ADMIN_INITIAL_BALANCE })
-            }
-        }
-    });
-
-    const AutoBaseMock = sinon.stub().returns({ view: { checkout, core: { signedLength: 1 }} });
-    const State = await esmock('../../src/core/state/State.js', {
-        "autobase": AutoBaseMock
-    });
-    state = new State(null, null, null)
-});
-
-test('State#incrementBalance', () => {
-    test('adds two balances and produce a node entry', async t => {
-        const entry = await state.incrementBalance('adminAddress', $TNK(150n))
-        t.is(toBalance(decode(entry).balance).asBigInt(), tokenUnits(1150n), 'balance matches');
-    })
-
-    test('do not add zero', async t => {
-        const entry = await state.incrementBalance('adminAddress', $TNK(0n))
-        t.is(entry, null, 'entry is null');
-    })
-
-    test('null entry', async t => {
-        const AutoBaseMock = sinon.stub().returns({ view: { checkout: sinon.stub().returns({ get: () => ({ value: null }) }), core: { signedLength: 1 }} });
-        const State = await esmock('../../src/core/state/State.js', {
-            "autobase": AutoBaseMock
-        });
-        const entry = await new State(null, null, null).incrementBalance('adminAddress', $TNK(150n))
-        t.is(entry, null, 'entry is null');
-    })
-});
-
-test('State#derementBalance', async t => {
-    test('subtract two balances and produce a node entry', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(150n))
-        t.is(toBalance(decode(entry).balance).asBigInt(), tokenUnits(850n), 'balance matches');
-    })
-
-    test('do not subtract zero', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(0n))
-        t.is(entry, null, 'entry is null');
-    })
-
-    test('do not produce negative balance', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(1001n))
-        t.is(entry, null, 'entry is null');
-    })
-
-    test('can zero balance', async t => {
-        const entry = await state.decrementBalance('adminAddress', $TNK(1000n))
-        t.ok(b4a.equals(decode(entry).balance, ZERO_BALANCE), 'balance matches');
-    })
-
-    test('null entry', async t => {
-        const AutoBaseMock = sinon.stub().returns({ view: { checkout: sinon.stub().returns({ get: () => ({ value: null }) }), core: { signedLength: 1 }} });
-        const State = await esmock('../../src/core/state/State.js', {
-            "autobase": AutoBaseMock
-        });
-        const entry = await new State(null, null, null).decrementBalance('adminAddress', $TNK(150n))
-        t.is(entry, null, 'entry is null');
-    })
-});