trac-msb 0.2.18 → 0.2.19

package/src/utils/cli.js

@@ -1,130 +0,0 @@
-import b4a from 'b4a';
-import { safeDecodeApplyOperation } from "./protobuf/operationHelpers.js";
-import { bigIntToDecimalString, bufferToBigInt } from "./amountSerialization.js";
-
-export async function verifyDag(state, network, wallet, writerKey) {
-    try {
-        console.log('---------- node & network stats ----------');
-        let dagView, lengthdagView, dagSystem, lengthdagSystem;
-
-        if (state?.base?.view?.core && state?.base?.system?.core) {
-            try {
-                dagView = await state.base.view.core.treeHash();
-                lengthdagView = state.base.view.core.length;
-                dagSystem = await state.base.system.core.treeHash();
-                lengthdagSystem = state.base.system.core.length;
-            } catch (e) {
-                console.log('Error getting DAG info:', e.message);
-            }
-        }
-
-        console.log('wallet.publicKey:', wallet?.publicKey?.toString('hex') ?? 'unset');
-        console.log('wallet.address:', (wallet && wallet.address) ? wallet.address : 'unset');
-        console.log('msb.writerKey:', writerKey ? writerKey.toString('hex') : 'unset');
-        console.log('swarm.connections.size:', network?.swarm?.connections?.size || 0);
-        if (state?.base?.view?.core) {
-            console.log('base.view.core.signedLength:', state.base.view.core.signedLength ?? 'unset');
-            console.log('base.view.core.length:', state.base.view.core.length ?? 'unset');
-        }
-
-        if (state?.base) {
-            console.log("base.signedLength", state.base.signedLength ?? 'unset');
-            console.log("base.indexedLength", state.base.indexedLength ?? 'unset');
-            console.log("base.linearizer.indexers.length", state.base.linearizer?.indexers?.length ?? 'unset');
-            console.log(`base.key: ${state.base.key ? state.base.key.toString('hex') : 'unset'}`);
-            console.log('discoveryKey:', state.base.discoveryKey ? b4a.toString(state.base.discoveryKey, 'hex') : 'unset');
-        }
-        console.log(`VIEW Dag: ${dagView ? dagView.toString('hex') : 'unset'} (length: ${lengthdagView || 0})`);
-        console.log(`SYSTEM Dag: ${dagSystem ? dagSystem.toString('hex') : 'unset'} (length: ${lengthdagSystem || 0})`);
-        const wl = await state.getWriterLength();
-        console.log('Total Registered Writers:', wl !== null ? wl : 0);
-
-        console.log("---------- flags ----------");
-        try {
-            console.log(`isIndexer: ${state?.isIndexer?.() ?? 'unset'}`);
-            console.log(`isWriter: ${state?.isWritable?.() ?? 'unset'}`);
-        } catch (e) {
-            console.log('Error getting flags:', e.message);
-        }
-
-    } catch (error) {
-        console.error('Error during DAG monitoring:', error.message);
-    }
-}
-
-export function printHelp(isAdminMode = false) {
-    if (isAdminMode) {
-        console.log('🚨 WARNING: IF YOU ARE NOT AN ADMIN, DO NOT USE THE COMMANDS BELOW! YOU RISK LOSING YOUR FUNDS! 🚨');
-        console.log('\nAdmin commands:');
-        console.log('- /add_admin: Register admin entry with bootstrap key (initial setup), or use --recovery flag to recover admin role');
-        console.log('- /balance_migration: Perform balance migration with the given initial balances CSV file');
-        console.log('- /add_whitelist: Add all specified whitelist addresses. If initialization is enabled, no fee is required.');
-        console.log('- /disable_initialization: Disable further balance initializations and whitelisting');
-        console.log('- /add_indexer <address>: Change a role of the selected writer node to indexer role. Charges a fee.');
-        console.log('- /remove_indexer <address>: Change a role of the selected indexer node to default role. Charges a fee.');
-        console.log('- /ban_writer <address>: Demote a whitelisted writer to default role and remove it from the whitelist. Charges a fee.');
-    }
-    console.log('Available commands:');
-    console.log('- /add_writer: Add yourself as a validator to this MSB once whitelisted. Requires a fee + 10x the fee as a stake in $TNK.');
-    console.log('- /remove_writer: Remove yourself from this MSB. Requires a fee, and the stake will be refunded.');
-    console.log('- /node_status <address>: Get network information about a node with the given address.');
-    console.log('- /stats: Check system stats such as writing key, DAG, etc.');
-    console.log('- /deployment <subnetwork_bootstrap> <channel>: Deploy a subnetwork with the given bootstrap. If channel is not provided, a random one will be generated. Requires a fee.');
-    console.log('- /get_deployment <subnetwork_bootstrap>: Get information about a subnetwork deployment with the given bootstrap.');
-    console.log('- /transfer <to_address> <amount>: Transfer the specified amount to the given address. Requires a fee.');
-    console.log('- /get_tx_info <tx_hash>: Get information about a transaction with the given hash.');
-    console.log('- /get_validator_addr <writing_key>: Get the validator address mapped to the given writing key.');
-    console.log('- /get_balance <address> <confirmed>: Get the balance of the node with specified address (confirmed = true is default)');
-    console.log('- /exit: Exit the program.');
-    console.log('- /help: Display this help.');
-}
-
-export const printWalletInfo = (address, writingKey) => {
-    console.log('');
-    console.log('#####################################################################################');
-    console.log('# MSB Address:   ', address, ' #');
-    console.log('# MSB Writer:    ', writingKey.toString('hex'), '#');
-    console.log('#####################################################################################');
-}
-
-export const printBalance = async (address, state, wallet_enabled) => {
-    if (wallet_enabled && state) {
-        const nodeEntry = await state.getNodeEntry(address);
-        const balance = nodeEntry ? bigIntToDecimalString(bufferToBigInt(nodeEntry.balance)) : '0';
-        console.log(`Balance: ${balance}`);
-    }
-}
-
-export const get_confirmed_tx_info = async (state_instance, txHash) => {
-    const payload = await state_instance.getSigned(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
-    }
-}
-
-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/cliCommands.js

@@ -1,280 +0,0 @@
-import { ZERO_WK } from "./buffer.js";
-import { bigIntToDecimalString, bufferToBigInt } from "./amountSerialization.js";
-import { normalizeDecodedPayloadForJson } from "./normalizers.js";
-import { get_confirmed_tx_info, get_unconfirmed_tx_info } from "./cli.js";
-import { EntryType } from "./constants.js";
-import { bufferToAddress } from "../core/state/utils/address.js";
-import deploymentEntryUtils from "../core/state/utils/deploymentEntry.js";
-import { safeDecodeApplyOperation } from "./protobuf/operationHelpers.js";
-
-export async function getBalanceCommand(state, address, confirmedFlag) {
-    const unconfirmedBalance = confirmedFlag === "false";
-    const nodeEntry = unconfirmedBalance
-        ? await state.getNodeEntryUnsigned(address)
-        : await state.getNodeEntry(address);
-
-    if (nodeEntry) {
-        console.log({
-            Address: address,
-            Balance: bigIntToDecimalString(bufferToBigInt(nodeEntry.balance))
-        });
-        return {
-            address,
-            balance: bufferToBigInt(nodeEntry.balance).toString()
-        };
-    }
-
-    console.log("Node Entry:", {
-        WritingKey: ZERO_WK.toString("hex"),
-        IsWhitelisted: false,
-        IsWriter: false,
-        IsIndexer: false,
-        balance: bigIntToDecimalString(0n)
-    });
-}
-
-export async function nodeStatusCommand(state, address) {
-    const nodeEntry = await state.getNodeEntry(address);
-    if (nodeEntry) {
-        const licenseValue = nodeEntry.license.readUInt32BE(0);
-        const licenseDisplay = licenseValue === 0 ? "N/A" : licenseValue.toString();
-        console.log("Node Status:", {
-            Address: address,
-            WritingKey: nodeEntry.wk.toString("hex"),
-            IsWhitelisted: nodeEntry.isWhitelisted,
-            IsWriter: nodeEntry.isWriter,
-            IsIndexer: nodeEntry.isIndexer,
-            License: licenseDisplay,
-            StakedBalance: bigIntToDecimalString(bufferToBigInt(nodeEntry.stakedBalance)),
-            Balance: bigIntToDecimalString(bufferToBigInt(nodeEntry.balance))
-        });
-        return {
-            address,
-            writingKey: nodeEntry.wk.toString("hex"),
-            isWhitelisted: nodeEntry.isWhitelisted,
-            isWriter: nodeEntry.isWriter,
-            isIndexer: nodeEntry.isIndexer,
-            license: licenseDisplay,
-            stakedBalance: bigIntToDecimalString(bufferToBigInt(nodeEntry.stakedBalance))
-        };
-    }
-
-    console.log("Node Status:", {
-        WritingKey: ZERO_WK.toString("hex"),
-        IsWhitelisted: false,
-        IsWriter: false,
-        IsIndexer: false,
-        license: "N/A",
-        stakedBalance: "0"
-    });
-}
-
-export async function coreInfoCommand(state) {
-    const admin = await state.getAdminEntry();
-    console.log("Admin:", admin ? {
-        address: admin.address,
-        writingKey: admin.wk.toString("hex")
-    } : null);
-    const formattedIndexers = await state.getIndexersEntry().then(entry => entry ? entry : null);
-    if (!formattedIndexers || (Array.isArray(formattedIndexers) && formattedIndexers.length === 0)) {
-        console.log("Indexers: no indexers");
-    } else {
-        console.log("Indexers:", formattedIndexers);
-    }
-}
-
-export async function getValidatorAddressCommand(state, wkHexString, prefix) {
-    const payload = await state.getSigned(EntryType.WRITER_ADDRESS + wkHexString);
-    if (payload === null) {
-        console.log(`No address assigned to the writer key: ${wkHexString}`);
-    } else {
-        console.log(`Address assigned to the writer key: ${wkHexString} - ${bufferToAddress(payload, prefix)}`);
-    }
-}
-
-export async function getDeploymentCommand(state, bootstrapHex, addressLength) {
-    const deploymentEntry = await state.getRegisteredBootstrapEntry(bootstrapHex);
-    console.log(`Searching deployment for bootstrap: ${bootstrapHex}`);
-    if (deploymentEntry) {
-        const decodedDeploymentEntry = deploymentEntryUtils.decode(deploymentEntry, addressLength);
-        const txhash = decodedDeploymentEntry.txHash.toString("hex");
-        console.log(`Bootstrap deployed under transaction hash: ${txhash}`);
-        const payload = await state.getSigned(txhash);
-        if (payload) {
-            const decoded = safeDecodeApplyOperation(payload);
-            console.log("Decoded Bootstrap Deployment Payload:", decoded);
-        } else {
-            console.log(`No payload found for transaction hash: ${txhash}`);
-        }
-    } else {
-        console.log(`No deployment found for bootstrap: ${bootstrapHex}`);
-    }
-}
-
-export async function getTxInfoCommand(state, txHash) {
-    const txInfo = await get_confirmed_tx_info(state, txHash);
-    if (txInfo) {
-        console.log(`Payload for transaction hash ${txHash}:`);
-        console.log(txInfo.decoded);
-    } else {
-        console.log(`No information found for transaction hash: ${txHash}`);
-    }
-}
-
-export async function getLicenseNumberCommand(state, address) {
-    const nodeEntry = await state.getNodeEntry(address);
-    if (nodeEntry) {
-        console.log({
-            Address: address,
-            License: bufferToBigInt(nodeEntry.license).toString()
-        });
-    }
-}
-
-export async function getLicenseAddressCommand(state, licenseId) {
-    if (isNaN(licenseId) || licenseId < 0) {
-        console.log("Invalid license ID. Please provide a valid non-negative number.");
-        return;
-    }
-
-    const address = await state.getAddressByLicenseId(licenseId);
-    if (address) {
-        console.log({
-            LicenseId: licenseId,
-            Address: address
-        });
-    } else {
-        console.log(`No address found for license ID: ${licenseId}`);
-    }
-}
-
-export async function getLicenseCountCommand(state, isAdminFn) {
-    const adminEntry = await state.getAdminEntry();
-
-    if (!adminEntry) {
-        throw new Error("Cannot read license count. Admin does not exist");
-    }
-
-    if (!isAdminFn(adminEntry)) {
-        throw new Error("Cannot perform this operation - you are not the admin!.");
-    }
-
-    const licenseCount = await state.getLicenseCount();
-    console.log({
-        LicensesCount: licenseCount
-    });
-}
-
-export async function getTxvCommand(state) {
-    const txv = await state.getIndexerSequenceState();
-    console.log("Current TXV:", txv.toString("hex"));
-    return txv;
-}
-
-export function getFeeCommand(state) {
-    const fee = state.getFee();
-    console.log("Current FEE:", bigIntToDecimalString(bufferToBigInt(fee)));
-    return bufferToBigInt(fee).toString();
-}
-
-export function getConfirmedLengthCommand(state) {
-    const confirmedLength = state.getSignedLength();
-    console.log("Confirmed_length:", confirmedLength);
-    return confirmedLength;
-}
-
-export function getUnconfirmedLengthCommand(state) {
-    const unconfirmedLength = state.getUnsignedLength();
-    console.log("Unconfirmed_length:", unconfirmedLength);
-    return unconfirmedLength;
-}
-
-export async function getTxPayloadsBulkCommand(state, hashes, config) {
-    if (!Array.isArray(hashes) || hashes.length === 0) {
-        throw new Error("Missing hash list.");
-    }
-
-    if (hashes.length > 1500) {
-        throw new Error("Length of input tx hashes exceeded.");
-    }
-
-    const res = { results: [], missing: [] };
-
-    const promises = hashes.map(hash => get_confirmed_tx_info(state, hash));
-    const results = await Promise.all(promises);
-
-    results.forEach((result, index) => {
-        const hash = hashes[index];
-        if (result === null || result === undefined) {
-            res.missing.push(hash);
-        } else {
-            const decodedResult = normalizeDecodedPayloadForJson(result.decoded, config);
-            res.results.push({ hash, payload: decodedResult });
-        }
-    });
-
-    return res;
-}
-
-export async function getTxHashesCommand(state, start, end) {
-    try {
-        const hashes = await state.confirmedTransactionsBetween(start, end);
-        return { hashes };
-    } catch (error) {
-        throw new Error("Invalid params to perform the request.", error.message);
-    }
-}
-
-export async function getTxDetailsCommand(state, hash, config) {
-    try {
-        const rawPayload = await get_confirmed_tx_info(state, hash);
-        if (!rawPayload) {
-            console.log(`No payload found for tx hash: ${hash}`);
-            return null;
-        }
-        return normalizeDecodedPayloadForJson(rawPayload.decoded, config);
-    } catch (error) {
-        throw new Error("Invalid params to perform the request.", error.message);
-    }
-}
-
-export async function getExtendedTxDetailsCommand(state, hash, confirmed, config) {
-    if (confirmed) {
-        const rawPayload = await get_confirmed_tx_info(state, hash);
-        if (!rawPayload) {
-            throw new Error(`No payload found for tx hash: ${hash}`);
-        }
-        const confirmedLength = await state.getTransactionConfirmedLength(hash);
-        if (confirmedLength === null) {
-            throw new Error(`No confirmed length found for tx hash: ${hash} in confirmed mode`);
-        }
-        const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, config);
-        const fee = state.getFee();
-        return {
-            txDetails: normalizedPayload,
-            confirmed_length: confirmedLength,
-            fee: bufferToBigInt(fee).toString()
-        };
-    }
-
-    const rawPayload = await get_unconfirmed_tx_info(state, hash);
-    if (!rawPayload) {
-        throw new Error(`No payload found for tx hash: ${hash}`);
-    }
-    const normalizedPayload = normalizeDecodedPayloadForJson(rawPayload.decoded, config);
-    const length = await state.getTransactionConfirmedLength(hash);
-    if (length === null) {
-        return {
-            txDetails: normalizedPayload,
-            confirmed_length: 0,
-            fee: "0"
-        };
-    }
-
-    const fee = state.getFee();
-    return {
-        txDetails: normalizedPayload,
-        confirmed_length: length,
-        fee: bufferToBigInt(fee).toString()
-    };
-}

package/tests/acceptance/v1/account/account.test.mjs

@@ -1,129 +0,0 @@
-import request from "supertest"
-import { bufferToBigInt, licenseBufferToBigInt } from "../../../../src/utils/amountSerialization.js"
-import { ZERO_WK } from "../../../../rpc/constants.js"
-import { ADMIN_INITIAL_STAKED_BALANCE } from "../../../../src/utils/constants.js"
-import { BALANCE_TO_STAKE } from "../../../../src/core/state/utils/balance.js"
-import { randomAddress } from "../../../unit/state/stateTestUtils.js"
-
-export const registerAccountTests = (context) => {
-    const formatNodeEntryResponse = (address, entry) => {
-        const licenseValue = licenseBufferToBigInt(entry.license)
-        return {
-            address,
-            writingKey: entry.wk.toString('hex'),
-            isWhitelisted: entry.isWhitelisted,
-            isValidator: entry.isWriter,
-            isIndexer: entry.isIndexer,
-            license: licenseValue === 0n ? null : licenseValue.toString(),
-            balance: bufferToBigInt(entry.balance).toString(),
-            stakedBalance: bufferToBigInt(entry.stakedBalance).toString(),
-        }
-    }
-
-    describe("GET /v1/account", () => {
-        it("returns admin account details", async () => {
-            const adminEntry = await context.rpcMsb.state.getNodeEntry(context.adminWallet.address)
-            expect(adminEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.adminWallet.address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.adminWallet.address, adminEntry))
-            expect(res.body).toMatchObject({
-                isWhitelisted: true,
-                isValidator: true,
-                isIndexer: true,
-                stakedBalance: bufferToBigInt(ADMIN_INITIAL_STAKED_BALANCE).toString(),
-                license: '1',
-            })
-        })
-
-        it("returns validator account details", async () => {
-            const writerEntry = await context.rpcMsb.state.getNodeEntry(context.wallet.address)
-            expect(writerEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.wallet.address, writerEntry))
-            expect(res.body).toMatchObject({
-                isWhitelisted: true,
-                isValidator: true,
-                stakedBalance: bufferToBigInt(BALANCE_TO_STAKE.value).toString(),
-            })
-            expect(res.body.license).not.toBeNull()
-            expect(res.body.license).not.toBe('1')
-        })
-
-        it("returns validator account details when confirmed=true", async () => {
-            const confirmedEntry = await context.rpcMsb.state.getNodeEntry(context.wallet.address)
-            expect(confirmedEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}?confirmed=true`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.wallet.address, confirmedEntry))
-        })
-
-        it("returns validator account details (unconfirmed view)", async () => {
-            const unsignedEntry = await context.rpcMsb.state.getNodeEntryUnsigned(context.wallet.address)
-            expect(unsignedEntry).toBeTruthy()
-
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}?confirmed=false`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual(formatNodeEntryResponse(context.wallet.address, unsignedEntry))
-        })
-
-        it("returns default state for non-existent node", async () => {
-            const address = randomAddress(context.rpcMsb.config.addressPrefix)
-
-            const res = await request(context.server).get(`/v1/account/${address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({
-                address: address,
-                writingKey: ZERO_WK.toString('hex'),
-                isWhitelisted: false,
-                isValidator: false,
-                isIndexer: false,
-                license: null,
-                balance: '0',
-                stakedBalance: '0',
-            })
-        })
-
-        it("returns 400 when address is missing", async () => {
-            const res = await request(context.server).get("/v1/account")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Account address is required" })
-        })
-
-        it("returns 400 for invalid address format", async () => {
-            const res = await request(context.server).get("/v1/account/not-a-valid-address")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid account address format" })
-        })
-
-        it("returns 400 for invalid confirmed parameter", async () => {
-            const res = await request(context.server).get(`/v1/account/${context.wallet.address}?confirmed=test`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: 'Parameter "confirmed" must be exactly "true" or "false"' })
-        })
-
-        it("returns 500 on internal error", async () => {
-            const originalGetNodeEntry = context.rpcMsb.state.getNodeEntry
-            const failingAddress = randomAddress(context.rpcMsb.config.addressPrefix)
-
-            context.rpcMsb.state.getNodeEntry = async (address) => {
-                if (address === failingAddress) {
-                    throw new Error("test")
-                }
-                return originalGetNodeEntry.call(context.rpcMsb.state, address)
-            }
-
-            try {
-                const res = await request(context.server).get(`/v1/account/${failingAddress}`)
-                expect(res.statusCode).toBe(500)
-                expect(res.body).toEqual({ error: 'An error occurred processing the request.' })
-            } finally {
-                context.rpcMsb.state.getNodeEntry = originalGetNodeEntry
-            }
-        })
-    })
-}

package/tests/acceptance/v1/balance/balance.test.mjs

@@ -1,54 +0,0 @@
-import request from "supertest"
-import { randomAddress } from "../../../unit/state/stateTestUtils.js"
-
-export const registerBalanceTests = (context) => {
-    let expectedBalance
-    describe("GET /v1/balance", () => {
-        it("returns balance for confirmed view by default", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body.address).toBe(context.wallet.address)
-            expect(typeof res.body.balance).toBe("string")
-            expectedBalance = res.body.balance
-        })
-
-        it("returns balance for unconfirmed view", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}?confirmed=false`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ address: context.wallet.address, balance: expectedBalance })
-        })
-
-        it("returns balance when confirmed flag is explicitly true", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}?confirmed=true`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ address: context.wallet.address, balance: expectedBalance })
-        })
-
-        it("falls back to unconfirmed view on invalid confirmed flag", async () => {
-            const res = await request(context.server).get(`/v1/balance/${context.wallet.address}?confirmed=test`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ address: context.wallet.address, balance: expectedBalance })
-        })
-
-        it("returns 400 when address is missing", async () => {
-            const res = await request(context.server).get("/v1/balance")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Wallet address is required" })
-        })
-
-        it("returns zero balance for an unknown address", async () => {
-            const address = randomAddress(context.rpcMsb.config.addressPrefix)
-            const res = await request(context.server).get(`/v1/balance/${address}`)
-            expect(res.statusCode).toBe(200)
-            expect(res.body.address).toBe(address)
-            expect(BigInt(res.body.balance)).toBe(0n)
-        })
-
-        it("returns 400 for an invalid address format", async () => {
-            const invalidAddress = "not-a-valid-address"
-            const res = await request(context.server).get(`/v1/balance/${invalidAddress}`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid account address format" })
-        })
-    })
-}