trac-msb 0.2.0 → 0.2.1

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "trac-msb",
   "main": "msb.mjs",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "pear": {
     "name": "trac-msb",
     "type": "terminal"

package/rpc/create_server.mjs

@@ -32,9 +32,23 @@ export const createServer = (msbInstance) => {
 
     // Find the matching route
     let foundRoute = false;
-    for (const route of routes) {
-        // Simple path matching
-        if (req.method === route.method && req.url.startsWith(route.path)) {
+    
+    // Extract the path without query parameters
+    const requestPath = req.url.split('?')[0];
+    
+    // Sort routes by path length (longest first) to ensure more specific routes match first
+    const sortedRoutes = [...routes].sort((a, b) => b.path.length - a.path.length);
+    
+    for (const route of sortedRoutes) {
+        // Exact path matching for base route, allow parameters after base path
+        const routeBase = route.path.endsWith('/') ? route.path.slice(0, -1) : route.path;
+        const requestParts = requestPath.split('/');
+        const routeParts = routeBase.split('/');
+        
+        if (req.method === route.method && 
+            requestParts.length >= routeParts.length &&
+            routeParts.every((part, i) => part === requestParts[i])) {
+            
             foundRoute = true;
             try {
                 // This try/catch covers synchronous errors and errors from awaited promises
@@ -43,8 +57,6 @@ export const createServer = (msbInstance) => {
             } catch (error) {
                 // Catch errors thrown directly from the handler (or its awaited parts)
                 console.error(`Error on ${route.path}:`, error);
-                
-                // FIX: Pass an object payload
                 respond(500, { error: 'An error occurred processing the request.' });
             }
             break;

package/rpc/handlers.mjs

@@ -1,5 +1,6 @@
-import {decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure} from "./utils/helpers.mjs"
+import { decodeBase64Payload, isBase64, sanitizeBulkPayloadsRequestBody, sanitizeTransferPayload, validatePayloadStructure } from "./utils/helpers.mjs"
 import { MAX_SIGNED_LENGTH } from "./constants.mjs";
+import { isHexString } from "../src/utils/helpers";
 
 export async function handleBalance({ req, respond, msbInstance }) {
     const [path, queryString] = req.url.split("?");
@@ -198,4 +199,47 @@ export async function handleFetchBulkTxPayloads({ msbInstance, respond, req }) {
         console.error('Stream error in handleFetchBulkTxPayloads:', err);
         respond(500, { error: 'Request stream failed during body transfer.' });
     });
+}
+
+export async function handleTransactionExtendedDetails({ msbInstance, respond, req }) {
+    const [path, queryString] = req.url.split("?");
+    const pathParts = path.split('/');
+    const hash = pathParts[4];
+    
+    if (!hash) {
+        return respond(400, { error: "Transaction hash is required" });
+    }
+    
+    if (isHexString(hash) === false || hash.length !== 64) {
+        return respond(400, { error: "Invalid transaction hash format" });
+    }
+    let confirmed = true; // default
+    if (queryString) {
+        const params = new URLSearchParams(queryString);
+        if (params.has("confirmed")) {
+            const confirmedParam = params.get("confirmed");
+            if (confirmedParam !== "true" && confirmedParam !== "false") {
+                return respond(400, { error: 'Parameter "confirmed" must be exactly "true" or "false"' });
+            }
+            confirmed = confirmedParam === "true";
+        }
+    }
+    
+    try {
+        let txDetails;
+        const commandString = `/get_extended_tx_details ${hash} ${confirmed}`;
+        txDetails = await msbInstance.handleCommand(commandString);
+        if (txDetails === null) {
+            respond(404, { error: `No payload found for tx hash: ${hash}` });
+        } else {
+            respond(200, txDetails);
+        }
+    } catch (error) {
+        if (error.message?.includes('No payload found for tx hash')) {
+            respond(404, { error: error.message });
+        } else {
+            console.error('Error in handleTransactionDetails:', error);
+            respond(500, { error: 'An error occurred processing the request.' });
+        }
+    }
 }

package/rpc/routes/v1.mjs

@@ -7,7 +7,8 @@ import {
     handleTxHashes,
     handleUnconfirmedLength,
     handleTransactionDetails,
-    handleFetchBulkTxPayloads
+    handleFetchBulkTxPayloads,
+    handleTransactionExtendedDetails
 } from '../handlers.mjs';
 
 export const v1Routes = [
@@ -20,4 +21,5 @@ export const v1Routes = [
     { method: 'GET', path: '/unconfirmed-length', handler: handleUnconfirmedLength },
     { method: 'GET', path: '/tx', handler: handleTransactionDetails },
     { method: 'POST', path: '/tx-payloads-bulk', handler: handleFetchBulkTxPayloads },
+    { method: 'GET', path: '/tx/details', handler: handleTransactionExtendedDetails },
 ];

package/rpc/rpc_server.mjs

@@ -5,6 +5,6 @@ export function startRpcServer(msbInstance, host, port) {
     const server = createServer(msbInstance)
 
     return server.listen(port, host, () => {
-        console.log(`Running RPC with https at https://${host}:${port}`);
+        console.log(`Running RPC with http at http://${host}:${port}`);
     });
 }

package/src/core/state/State.js

@@ -17,7 +17,7 @@ import {
     TRAC_NAMESPACE,
     CustomEventType
 } from '../../utils/constants.js';
-import { isHexString, sleep } from '../../utils/helpers.js';
+import { isHexString, sleep, isTransactionRecordPut } from '../../utils/helpers.js';
 import PeerWallet from 'trac-wallet';
 import Check from '../../utils/check.js';
 import { safeDecodeApplyOperation } from '../../utils/protobuf/operationHelpers.js';
@@ -265,6 +265,24 @@ class State extends ReadyResource {
             return b4a.equals(initialization, safeWriteUInt32BE(0, 0))
         }
     }
+    async getTransactionConfirmedLength(hash) {
+        if (!isHexString(hash) || hash.length !== 64) {
+            throw new Error("Invalid hash format");
+        }
+
+        const confirmedLength = this.getSignedLength();
+        const historyStream = this.#base.view.createHistoryStream({
+            gte: 0,
+            lte: confirmedLength
+        });
+
+        for await (const entry of historyStream) {
+            if (isTransactionRecordPut(entry) && entry.key === hash) {
+                return entry.seq;
+            }
+        }
+        return null;
+    }
 
     async confirmedTransactionsBetween(startSignedLength, endSignedLength) {
         if (!Number.isInteger(startSignedLength) || !Number.isInteger(endSignedLength)) {

package/src/index.js

@@ -8,7 +8,7 @@ import readline from "readline";
 import tty from "tty";
 
 import { sleep, getFormattedIndexersWithAddresses, isHexString, convertAdminCoreOperationPayloadToHex } from "./utils/helpers.js";
-import { verifyDag, printHelp, printWalletInfo, get_tx_info, printBalance } from "./utils/cli.js";
+import { verifyDag, printHelp, printWalletInfo, get_confirmed_tx_info, printBalance, get_unconfirmed_tx_info } from "./utils/cli.js";
 import CompleteStateMessageOperations from "./messages/completeStateMessages/CompleteStateMessageOperations.js";
 import { safeDecodeApplyOperation } from "./utils/protobuf/operationHelpers.js";
 import { bufferToAddress, isAddressValid } from "./core/state/utils/address.js";
@@ -821,11 +821,11 @@ export class MainSettlementBus extends ReadyResource {
         }
 
         const { addressBalancePair, totalBalance, totalAddresses, addresses } = await fileUtils.readBalanceMigrationFile();
-        
+
         for (let i = 0; i < addresses.length; i++) {
             await migrationUtils.validateAddressFromIncomingFile(this.#state, addresses[i].address, adminEntry);
         }
-        
+
         await fileUtils.validateBalanceMigrationData(addresses);
         const migrationNumber = await fileUtils.getNextMigrationNumber();
         await fileUtils.createMigrationEntryFile(addressBalancePair, migrationNumber);
@@ -1070,7 +1070,7 @@ export class MainSettlementBus extends ReadyResource {
                 } else if (input.startsWith("/get_tx_info")) {
                     const splitted = input.split(" ");
                     const txHash = splitted[1];
-                    const txInfo = await get_tx_info(this.#state, txHash);
+                    const txInfo = await get_confirmed_tx_info(this.#state, txHash);
                     if (txInfo) {
                         console.log(`Payload for transaction hash ${txHash}:`);
                         console.log(txInfo.decoded);
@@ -1218,7 +1218,7 @@ export class MainSettlementBus extends ReadyResource {
                             throw new Error("Length of input tx hashes exceeded.");
                         }
 
-                        const promises = hashes.map(hash => get_tx_info(this.#state, hash));
+                        const promises = hashes.map(hash => get_confirmed_tx_info(this.#state, hash));
                         const results = await Promise.all(promises);
 
                         // Iterate and categorize
@@ -1251,9 +1251,8 @@ export class MainSettlementBus extends ReadyResource {
                 } else if (input.startsWith("/get_tx_details")) {
                     const splitted = input.split(' ')
                     const hash = splitted[1];
-
                     try {
-                        const rawPayload = await get_tx_info(this.#state, hash);
+                        const rawPayload = await get_confirmed_tx_info(this.#state, hash);
                         if (!rawPayload) {
                             console.log(`No payload found for tx hash: ${hash}`)
                             return null
@@ -1264,6 +1263,52 @@ export class MainSettlementBus extends ReadyResource {
                         throw new Error("Invalid params to perform the request.", error.message);
                     }
                 }
+                else if (input.startsWith("/get_extended_tx_details")) {
+                    const splitted = input.split(' ');
+                    const hash = splitted[1];
+                    const confirmed = splitted[2] === 'true';
+
+                    if (confirmed) {
+                        const rawPayload = await get_confirmed_tx_info(this.#state, hash);
+                        if (!rawPayload) {
+                            throw new Error(`No payload found for tx hash: ${hash}`);
+                        }
+                        const confirmedLength = await this.#state.getTransactionConfirmedLength(hash);
+                        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+                        if (confirmedLength === null) {
+                            throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
+                        }
+                        const fee = this.#state.getFee();
+                        return {
+                            txDetails: normalizedPayload,
+                            confirmed_length: confirmedLength,
+                            fee: bufferToBigInt(fee).toString()
+                        }
+                    }
+                    else {
+                        const rawPayload = await get_unconfirmed_tx_info(this.#state, hash);
+                        if (!rawPayload) {
+                            throw new Error(`No payload found for tx hash: ${hash}`);
+                        }
+                        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, true);
+                        const length = await this.#state.getTransactionConfirmedLength(hash)
+                        if (length === null) {
+                            return {
+                                txDetails: normalizedPayload,
+                                confirmed_length: 0,
+                                fee: '0'
+                            }
+                        }
+
+                        const fee = this.#state.getFee();
+                        return {
+                            txDetails: normalizedPayload,
+                            confirmed_length: length,
+                            fee: bufferToBigInt(fee).toString()
+                        }
+
+                    }
+                }
         }
         if (rl) rl.prompt();
     }

package/src/utils/cli.js

@@ -103,7 +103,7 @@ export const printBalance = async (address, state, wallet_enabled) => {
     }
 }
 
-export const get_tx_info = async (state_instance, txHash) => {
+export const get_confirmed_tx_info = async (state_instance, txHash) => {
     const payload = await state_instance.getSigned(txHash);
     if (!payload) {
         return null
@@ -119,3 +119,20 @@ export const get_tx_info = async (state_instance, txHash) => {
         decoded
     }
 }
+
+export const get_unconfirmed_tx_info = async (state_instance, txHash) => {
+    const payload = await state_instance.get(txHash);
+    if (!payload) {
+        return null
+    }
+
+    const decoded = safeDecodeApplyOperation(payload);
+    if (!decoded) {
+        throw new Error(`Failed to decode payload for transaction hash: ${txHash}`);
+    }
+
+    return {
+        payload,
+        decoded
+    }
+}

package/src/utils/helpers.js

@@ -97,3 +97,10 @@ export function convertAdminCoreOperationPayloadToHex(payload) {
         },
     };
 }
+
+export function isTransactionRecordPut(entry) {
+    const isPut = entry.type === "put";
+    const isHex = isHexString(entry.key);
+    const is64 = entry.key.length === 64;
+    return isPut && isHex && is64;
+}

package/test/acceptance/v1/rpc.test.mjs

@@ -28,7 +28,7 @@ const setupNetwork = async () => {
         store_name: '/admin'
     }
 
-    const peer =await setupMsbAdmin(testKeyPair1, tmpDirectory, rpcOpts)
+    const peer = await setupMsbAdmin(testKeyPair1, tmpDirectory, rpcOpts)
     const writer = await setupMsbWriter(peer, 'writer', testKeyPair2, tmpDirectory, peer.options);
     return { writer, peer }
 }
@@ -76,7 +76,7 @@ describe("API acceptance tests", () => {
         it("< 1000", async () => {
             const res = await request(server).get("/v1/tx-hashes/1/1001")
             expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ 
+            expect(res.body).toEqual({
                 hashes: expect.arrayContaining([
                     expect.objectContaining({
                         hash: expect.any(String),
@@ -137,8 +137,8 @@ describe("API acceptance tests", () => {
         const res = await request(server)
             .post("/v1/tx-payloads-bulk")
             .set("Accept", "application/json")
-            .send(JSON.stringify( payload ))
-        
+            .send(JSON.stringify(payload))
+
         expect(res.statusCode).toBe(200)
         expect(res.body).toMatchObject({
             results: expect.arrayOf(
@@ -146,7 +146,177 @@ describe("API acceptance tests", () => {
                     hash: expect.any(String),
                 })
             ),
-            missing:[]
+            missing: []
         })
     })
+
+    describe('GET /v1/tx/details', () => {
+
+        it("positive case - should return 200 for valid already broadcasted hash confirmed and unconfirmed", async () => {
+            const txData = await tracCrypto.transaction.preBuild(
+                wallet.address,
+                wallet.address,
+                b4a.toString($TNK(1n), 'hex'),
+                b4a.toString(await msb.state.getIndexerSequenceState(), 'hex')
+            );
+
+            const payload = tracCrypto.transaction.build(txData, b4a.from(wallet.secretKey, 'hex'));
+            const broadcastRes = await request(server)
+                .post("/v1/broadcast-transaction")
+                .set("Accept", "application/json")
+                .send(JSON.stringify({ payload }));
+            expect(broadcastRes.statusCode).toBe(200);
+
+            const resConfirmed = await request(server)
+                .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=true`);
+            expect(resConfirmed.statusCode).toBe(200);
+
+            expect(resConfirmed.body).toMatchObject({
+                txDetails: expect.any(Object),
+                confirmed_length: expect.any(Number),
+                fee: expect.any(String)
+            })
+
+            const resUnconfirmed = await request(server)
+                .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=false`);
+            expect(resUnconfirmed.statusCode).toBe(200);
+
+            expect(resUnconfirmed.body).toMatchObject({
+                txDetails: expect.any(Object),
+                confirmed_length: expect.any(Number),
+                fee: expect.any(String)
+            })
+        });
+
+        it("should handle null confirmed_length for unconfirmed transaction", async () => {
+            const txData = await tracCrypto.transaction.preBuild(
+                wallet.address,
+                wallet.address,
+                b4a.toString($TNK(1n), 'hex'),
+                b4a.toString(await msb.state.getIndexerSequenceState(), 'hex')
+            );
+
+            const payload = tracCrypto.transaction.build(txData, b4a.from(wallet.secretKey, 'hex'));
+            
+            const originalGetConfirmedLength = msb.state.getTransactionConfirmedLength;
+            msb.state.getTransactionConfirmedLength = async () => null;
+
+            try {
+                const broadcastRes = await request(server)
+                    .post("/v1/broadcast-transaction")
+                    .set("Accept", "application/json")
+                    .send(JSON.stringify({ payload }));
+                expect(broadcastRes.statusCode).toBe(200);
+
+                const res = await request(server)
+                    .get(`/v1/tx/details/${txData.hash.toString('hex')}?confirmed=false`);
+                expect(res.statusCode).toBe(200);
+
+                expect(res.body).toMatchObject({
+                    txDetails: expect.any(Object),
+                    confirmed_length: 0,
+                    fee: '0'
+                });
+            } finally {
+                msb.state.getTransactionConfirmedLength = originalGetConfirmedLength;
+            }
+        });
+
+        it("should return 404 for non-existent transaction hash", async () => {
+            const nonExistentHash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c";
+            const res = await request(server)
+                .get(`/v1/tx/details/${nonExistentHash}`);
+
+            expect(res.statusCode).toBe(404);
+            expect(res.body).toEqual({
+                error: `No payload found for tx hash: ${nonExistentHash}`
+            });
+        });
+
+        it("should return 400 for invalid hash format (too short)", async () => {
+            const invalidHash = '0'.repeat(63);
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for invalid hash format (non-hex)", async () => {
+            const invalidHash = 'Z'.repeat(64);
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for invalid confirmed parameter", async () => {
+            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c";
+
+            const res = await request(server)
+                .get(`/v1/tx/details/${hash}?confirmed=invalid`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: 'Parameter "confirmed" must be exactly "true" or "false"'
+            });
+        });
+
+        it("should return 400 for invalid confirmed parameter case (UPPERCASE)", async () => {
+            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c";
+            const res = await request(server).get(`/v1/tx/details/${hash}?confirmed=TRUE`);
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: 'Parameter "confirmed" must be exactly "true" or "false"'
+            });
+        });
+
+        it("should return 400 when no hash provided", async () => {
+            const res = await request(server)
+                .get('/v1/tx/details');
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Transaction hash is required"
+            });
+        });
+
+        it("should return 400 for hash with invalid characters", async () => {
+            const invalidHash = '0b4d1c1dac48$af13212f6166017399457476a0b644850875b7f4b79df6ff89c';
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for hash with special characters", async () => {
+            const invalidHash = '!@#$%^&*'.repeat(8);
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+
+        it("should return 400 for hash with spaces", async () => {
+            const invalidHash = '0b4d1c1dac48af13212f616601d7399457476a0b644850875b7 4b79df6ff89c';
+            const res = await request(server)
+                .get(`/v1/tx/details/${invalidHash}`);
+
+            expect(res.statusCode).toBe(400);
+            expect(res.body).toEqual({
+                error: "Invalid transaction hash format"
+            });
+        });
+    })
 })

package/test/all.test.js

@@ -6,15 +6,16 @@ async function runTests() {
   test.pause();
 
   await import('./state/stateTests.test.js');
-  await import('./check/check.test.js');
-  await import('./protobuf/protobuf.test.js');
-  await import('./functions/functions.test.js');
-  await import('./fileUtils/readAddressesFromWhitelistFile.test.js');
-  await import('./fileUtils/readBalanceMigrationFile.test.js');
-  await import('./migrationUtils/validateAddressFromIncomingFile.test.js');
+  // await import('./state/apply.addAdmin.basic.test.js');
+  // await import('./check/check.test.js');
+  // await import('./protobuf/protobuf.test.js');
+  // await import('./functions/functions.test.js');
+  // await import('./fileUtils/readAddressesFromWhitelistFile.test.js');
+  // await import('./fileUtils/readBalanceMigrationFile.test.js');
+  // await import('./migrationUtils/validateAddressFromIncomingFile.test.js');
   // await import('./messageOperations/stateMessageOperations.test.js');
-  await import('./buffer/buffer.test.js')
-  await import('./network/connectionManagerTests.test.js')
+  // await import('./buffer/buffer.test.js')
+  // await import('./network/connectionManagerTests.test.js')
   // await import('./apply/apply.test.js'); // This test has been disabled because Github CI fails due to lack of resources. This test can still be run locally but sometimes it hangs when destroying resources.
   test.resume();
 }

package/test/state/apply.addAdmin.basic.test.js

@@ -0,0 +1,111 @@
+import { test, hook } from '../utils/wrapper.js'
+import Corestore from 'corestore'
+import path from 'path'
+import os from 'os'
+import { promises as fsp } from 'fs'
+import b4a from 'b4a'
+
+import PeerWallet from 'trac-wallet'
+import State from '../../src/core/state/State.js'
+import CompleteStateMessageOperations from '../../src/messages/completeStateMessages/CompleteStateMessageOperations.js'
+import { ADMIN_INITIAL_BALANCE } from '../../src/utils/constants.js'
+
+// Prosty, szybki test apply(add_admin) inspirowany stylem Autobase/test/basic.js
+// Minimalny setup: Corestore + State + Wallet, bez sieci i dodatkowych warstw
+
+let tmpDir
+let store
+let wallet
+let state
+
+const STATE_OPTIONS = {
+  enable_tx_apply_logs: false,
+  enable_error_apply_logs: false
+}
+
+async function createTempStore() {
+  const base = path.join(os.tmpdir(), `msb-state-test-${Date.now()}-${Math.random().toString(16).slice(2)}`)
+  await fsp.mkdir(base, { recursive: true })
+  return { base, db: path.join(base, 'db') }
+}
+
+async function createWalletFromFixture({ mnemonic }) {
+  const w = new PeerWallet({ mnemonic })
+  await w.ready
+  return w
+}
+
+hook('setup state for add_admin', async () => {
+  const paths = await createTempStore()
+  tmpDir = paths.base
+
+  const { testKeyPair1 } = await import('../fixtures/apply.fixtures.js')
+  wallet = await createWalletFromFixture(testKeyPair1)
+
+  // wyciągnij writing key bootstrapu (== klucz lokalnego writera)
+  const bootstrapKey = await deriveBootstrapWriterKey(paths.db, wallet)
+
+  // właściwy store + stan testowy
+  store = new Corestore(paths.db)
+  await store.ready()
+
+  state = new State(store, bootstrapKey, wallet, STATE_OPTIONS)
+  await state.ready()
+
+  // pierwszy pusty append zapewnia, że widok/indexery są zainicjalizowane
+  await state.append(null)
+  await fastForwardIfAvailable(state)
+  await state.base.view.update()
+})
+
+test('State.apply(add_admin) – podstawowy scenariusz', async t => {
+  // preconditions
+  const beforeAdmin = await state.getAdminEntry()
+  t.is(beforeAdmin, null, 'admin entry nie istnieje przed operacją')
+
+  // assemble + append
+  const validity = await state.getIndexerSequenceState()
+  const msg = await CompleteStateMessageOperations.assembleAddAdminMessage(
+    wallet,
+    state.writingKey,
+    validity
+  )
+
+  await state.append(msg)
+  // wymuś natychmiastowe przetworzenie apply i aktualizację widoku
+  await fastForwardIfAvailable(state)
+  await state.base.view.update()
+
+  // assertions
+  const adminEntry = await state.getAdminEntry()
+  t.ok(adminEntry, 'admin entry powinien zostać dodany')
+  t.ok(b4a.equals(adminEntry.wk, state.writingKey), 'wk admina == writingKey')
+
+  const node = await state.getNodeEntry(adminEntry.address)
+  t.ok(node?.isWriter, 'admin powinien być writerem')
+  t.ok(node?.isIndexer, 'admin powinien być indexerem')
+  t.ok(b4a.equals(node.balance, ADMIN_INITIAL_BALANCE), 'admin powinien mieć saldo początkowe')
+})
+
+hook('teardown state for add_admin', async () => {
+  try { if (state) await state.close() } catch {}
+  try { if (store) await store.close() } catch {}
+  try { if (tmpDir) await fsp.rm(tmpDir, { recursive: true, force: true }) } catch {}
+})
+
+async function deriveBootstrapWriterKey(dbPath, walletInstance) {
+  const bootstrapStore = new Corestore(dbPath)
+  await bootstrapStore.ready()
+  const bootstrapState = new State(bootstrapStore, null, walletInstance, STATE_OPTIONS)
+  await bootstrapState.ready()
+  const wk = bootstrapState.writingKey
+  await bootstrapState.close()
+  await bootstrapStore.close()
+  return wk
+}
+
+async function fastForwardIfAvailable(testState) {
+  if (typeof testState.base.forceFastForward === 'function') {
+    await testState.base.forceFastForward()
+  }
+}