trac-msb 0.2.13 → 0.2.15

package/src/utils/protobuf/operationHelpers.js

@@ -1,17 +1,7 @@
 import applyOperations from './applyOperations.cjs';
-import networkV1Generated from './networkV1.generated.cjs';
+import networkV1Operations from './network.cjs';
 import b4a from 'b4a';
 
-const networkV1Operations = networkV1Generated.network.v1;
-const NETWORK_TO_OBJECT_OPTIONS = Object.freeze({
-    enums: Number,
-    longs: Number,
-    bytes: Buffer,
-    defaults: true,
-    arrays: true,
-    oneofs: false
-});
-
 /**
  * Safely encodes an operation using `applyOperations.Operation.encode`.
  * If the encoding fails (e.g., due to an invalid payload), returns an empty Buffer.
@@ -46,14 +36,6 @@ export const safeDecodeApplyOperation = (payload) => {
     return null;
 }
 
-export const unsafeDecodeApplyOperation= (payload) => {
-    return applyOperations.Operation.decode(payload);
-}
-
-export const unsafeEncodeApplyOperation = (payload) => {
-    return applyOperations.Operation.encode(payload);
-}
-
 export const normalizeIncomingMessage = (message) => {
     if (!message) return null;
     if (b4a.isBuffer(message)) {
@@ -69,13 +51,10 @@ export const normalizeIncomingMessage = (message) => {
 };
 
 export const encodeV1networkOperation = (payload) => {
-    return b4a.from(networkV1Operations.MessageHeader.encode(payload).finish());
+    return networkV1Operations.MessageHeader.encode(payload);
 }
 
 
 export const decodeV1networkOperation = (payload) => {
-    return networkV1Operations.MessageHeader.toObject(
-        networkV1Operations.MessageHeader.decode(payload),
-        NETWORK_TO_OBJECT_OPTIONS
-    );
+    return networkV1Operations.MessageHeader.decode(payload);
 }

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

@@ -108,17 +108,11 @@ export const registerAccountTests = (context) => {
 
         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)
-            }
+            context.rpcMsb.state.getNodeEntry = async () => { throw new Error("test") }
 
             try {
-                const res = await request(context.server).get(`/v1/account/${failingAddress}`)
+                const res = await request(context.server).get(`/v1/account/${context.wallet.address}`)
                 expect(res.statusCode).toBe(500)
                 expect(res.body).toEqual({ error: 'An error occurred processing the request.' })
             } finally {

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

@@ -1,24 +1,5 @@
 import request from "supertest"
 import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-import { sleep } from "../../../../src/utils/helpers.js"
-
-const TX_ENDPOINT_TIMEOUT_MS = 4000
-const TX_ENDPOINT_RETRY_INTERVAL_MS = 100
-
-const waitForStatusCode = async (requestFactory, expectedStatusCode, timeoutMs = TX_ENDPOINT_TIMEOUT_MS) => {
-    const startedAt = Date.now()
-    let response = null
-
-    while ((Date.now() - startedAt) < timeoutMs) {
-        response = await requestFactory()
-        if (response.statusCode === expectedStatusCode) {
-            return response
-        }
-        await sleep(TX_ENDPOINT_RETRY_INTERVAL_MS)
-    }
-
-    return response
-}
 
 export const registerTxTests = (context) => {
     describe("GET /v1/tx/:hash", () => {
@@ -36,10 +17,7 @@ export const registerTxTests = (context) => {
                 .send(JSON.stringify({ payload }))
             expect(broadcastRes.statusCode).toBe(200)
 
-            const res = await waitForStatusCode(
-                () => request(context.server).get(`/v1/tx/${txHashHex}`),
-                200
-            )
+            const res = await request(context.server).get(`/v1/tx/${txHashHex}`)
             expect(res.statusCode).toBe(200)
             expect(res.body).toMatchObject({ txDetails: expect.any(Object) })
         })

package/tests/acceptance/v1/tx-details/tx-details.test.mjs

@@ -1,24 +1,5 @@
 import request from "supertest"
 import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-import { sleep } from "../../../../src/utils/helpers.js"
-
-const TX_DETAILS_TIMEOUT_MS = 4000
-const TX_DETAILS_RETRY_INTERVAL_MS = 100
-
-const waitForStatusCode = async (requestFactory, expectedStatusCode, timeoutMs = TX_DETAILS_TIMEOUT_MS) => {
-    const startedAt = Date.now()
-    let response = null
-
-    while ((Date.now() - startedAt) < timeoutMs) {
-        response = await requestFactory()
-        if (response.statusCode === expectedStatusCode) {
-            return response
-        }
-        await sleep(TX_DETAILS_RETRY_INTERVAL_MS)
-    }
-
-    return response
-}
 
 export const registerTxDetailsTests = (context) => {
     describe("GET /v1/tx/details", () => {
@@ -36,11 +17,8 @@ export const registerTxDetailsTests = (context) => {
                 .send(JSON.stringify({ payload }))
             expect(broadcastRes.statusCode).toBe(200)
 
-            const resConfirmed = await waitForStatusCode(
-                () => request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=true`),
-                200
-            )
+            const resConfirmed = await request(context.server)
+                .get(`/v1/tx/details/${txHashHex}?confirmed=true`)
             expect(resConfirmed.statusCode).toBe(200)
 
             expect(resConfirmed.body).toMatchObject({
@@ -49,11 +27,8 @@ export const registerTxDetailsTests = (context) => {
                 fee: expect.any(String)
             })
 
-            const resUnconfirmed = await waitForStatusCode(
-                () => request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
-                200
-            )
+            const resUnconfirmed = await request(context.server)
+                .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
             expect(resUnconfirmed.statusCode).toBe(200)
 
             expect(resUnconfirmed.body).toMatchObject({
@@ -82,11 +57,8 @@ export const registerTxDetailsTests = (context) => {
                     .send(JSON.stringify({ payload }))
                 expect(broadcastRes.statusCode).toBe(200)
 
-                const res = await waitForStatusCode(
-                    () => request(context.server)
-                        .get(`/v1/tx/details/${txHashHex}?confirmed=false`),
-                    200
-                )
+                const res = await request(context.server)
+                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
                 expect(res.statusCode).toBe(200)
 
                 expect(res.body).toMatchObject({

package/tests/fixtures/assembleMessage.fixtures.js

@@ -1,5 +1,6 @@
 import PeerWallet from 'trac-wallet';
 import b4a from 'b4a';
+import { config } from '../helpers/config.js';
 
 export const mnemonicAdmin = "science edit ankle purity treat unable first express scatter depend also case nose regular rally area carbon wait power corn sibling metal crop farm";
 
@@ -8,9 +9,9 @@ export const writingKeyNonAdmin = b4a.from("1768953b234c79eccc6306fdcba2d7c1f0b0
 
 export const bootstrapAdmin = writingKeyAdmin;
 
-export const walletAdmin = new PeerWallet();
-export const walletNonAdmin = new PeerWallet();
-export const walletPeer = new PeerWallet();
+export const walletAdmin = new PeerWallet({ derivationPath: config.derivationPath });
+export const walletNonAdmin = new PeerWallet({ derivationPath: config.derivationPath });
+export const walletPeer = new PeerWallet({ derivationPath: config.derivationPath });
 
 export const adminEntry = {
     address: null,
@@ -18,9 +19,9 @@ export const adminEntry = {
 }
 
 export const initAll = async () => {
-    if (!walletAdmin.publicKey) await walletAdmin.generateKeyPair(mnemonicAdmin);
-    if (!walletNonAdmin.publicKey) await walletNonAdmin.generateKeyPair(walletNonAdmin.generateMnemonic());
-    if (!walletPeer.publicKey) await walletPeer.generateKeyPair(walletPeer.generateMnemonic());
+    if (!walletAdmin.publicKey) await walletAdmin.generateKeyPair(mnemonicAdmin, config.derivationPath);
+    if (!walletNonAdmin.publicKey) await walletNonAdmin.generateKeyPair(walletNonAdmin.generateMnemonic(), config.derivationPath);
+    if (!walletPeer.publicKey) await walletPeer.generateKeyPair(walletPeer.generateMnemonic(), config.derivationPath);
     if (!adminEntry.address && !adminEntry.wk) {
         adminEntry.address = walletAdmin.address;
         adminEntry.wk = writingKeyAdmin;
@@ -37,4 +38,4 @@ export default {
     walletPeer,
     adminEntry,
     initAll,
-}
+}

package/tests/fixtures/networkV1.fixtures.js

@@ -1,6 +1,32 @@
 import b4a from 'b4a';
 import { v7 as uuidv7 } from 'uuid';
 import { NetworkOperationType, ResultCode as NetworkResultCode } from '../../src/utils/constants.js';
+import { asAddress } from '../helpers/address.js';
+
+const payloadValidatorConnectionRequest = {
+    type: NetworkOperationType.VALIDATOR_CONNECTION_REQUEST,
+    id: uuidv7(),
+    timestamp: 123,
+    validator_connection_request: {
+        issuer_address: asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117'),
+        nonce: b4a.from('00', 'hex'),
+        signature: b4a.from('01', 'hex')
+    },
+    capabilities: ['cap:a', 'cap:b']
+};
+
+const payloadValidatorConnectionResponse = {
+    type: NetworkOperationType.VALIDATOR_CONNECTION_RESPONSE,
+    id: uuidv7(),
+    timestamp: 456,
+    validator_connection_response: {
+        issuer_address: asAddress('36fdaf941de4afe602cbb1e2f56dc582466ef23fad1da55c09fd6dd841cbd117'),
+        nonce: b4a.from('02', 'hex'),
+        signature: b4a.from('03', 'hex'),
+        result: NetworkResultCode.OK
+    },
+    capabilities: ['cap:a']
+};
 
 const payloadLivenessRequest = {
     type: NetworkOperationType.LIVENESS_REQUEST,
@@ -44,14 +70,14 @@ const payloadBroadcastTransactionResponse = {
     broadcast_transaction_response: {
         nonce: b4a.from('0a', 'hex'),
         signature: b4a.from('0b', 'hex'),
-        proof: b4a.from('0c', 'hex'),
-        timestamp: 161719,
         result: NetworkResultCode.OK
     },
     capabilities: ['cap:b']
 };
 
 export default {
+    payloadValidatorConnectionRequest,
+    payloadValidatorConnectionResponse,
     payloadLivenessRequest,
     payloadLivenessResponse,
     payloadBroadcastTransactionRequest,

package/tests/helpers/autobaseTestHelpers.js

@@ -170,8 +170,11 @@ export function defaultOpenHyperbeeView(store) {
 }
 
 export async function createWallet(mnemonic = null) {
-	const wallet = new PeerWallet({ networkPrefix: config.addressPrefix });
-	await wallet.generateKeyPair(mnemonic ?? undefined);
+	const wallet = new PeerWallet({
+		networkPrefix: config.addressPrefix,
+		derivationPath: config.derivationPath
+	});
+	await wallet.generateKeyPair(mnemonic, config.derivationPath);
 	return wallet;
 }
 

package/tests/helpers/createTestSignature.js

@@ -1,8 +1,9 @@
 import PeerWallet from 'trac-wallet';
+import { config } from './config.js';
 
 export async function createSignature(payloadBuffer) {
-    const wallet = new PeerWallet();
-    await wallet.generateKeyPair();
+    const wallet = new PeerWallet({ derivationPath: config.derivationPath });
+    await wallet.generateKeyPair(undefined, config.derivationPath);
     const signature = wallet.sign(payloadBuffer);
     return { signature, wallet };
 }

package/tests/helpers/transactionPayloads.mjs

@@ -23,10 +23,10 @@ export const waitForConnection = async node => {
 
 /**
  * Build a base64-encoded transfer payload and matching tx hash
- * that are compatible with MSB's PartialTransferValidator validator.
+ * that are compatible with MSB's PartialTransfer validator.
  *
  * This helper mirrors the hashing/signing logic used by
- * PartialOperationValidator.validateSignature, so that tests broadcast
+ * PartialOperation.validateSignature, so that tests broadcast
  * transactions the node will accept without touching consensus code.
  *
  * @param {object} context - General context