trac-msb 0.2.17 → 0.2.19

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

@@ -1,213 +0,0 @@
-import request from "supertest"
-import { buildRpcSelfTransferPayload, waitForConnection } from "../../../helpers/transactionPayloads.mjs"
-
-export const registerTxDetailsTests = (context) => {
-    describe("GET /v1/tx/details", () => {
-        it("returns 200 for broadcasted hash (confirmed and unconfirmed)", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            await waitForConnection(context.rpcMsb)
-            const broadcastRes = await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .set("Accept", "application/json")
-                .send(JSON.stringify({ payload }))
-            expect(broadcastRes.statusCode).toBe(200)
-
-            const resConfirmed = await request(context.server)
-                .get(`/v1/tx/details/${txHashHex}?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(context.server)
-                .get(`/v1/tx/details/${txHashHex}?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("handles null confirmed_length for unconfirmed transaction", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            const originalGetConfirmedLength = context.rpcMsb.state.getTransactionConfirmedLength
-            context.rpcMsb.state.getTransactionConfirmedLength = async () => null
-
-            try {
-
-                await waitForConnection(context.rpcMsb)
-                const broadcastRes = await request(context.server)
-                    .post("/v1/broadcast-transaction")
-                    .set("Accept", "application/json")
-                    .send(JSON.stringify({ payload }))
-                expect(broadcastRes.statusCode).toBe(200)
-
-                const res = await request(context.server)
-                    .get(`/v1/tx/details/${txHashHex}?confirmed=false`)
-                expect(res.statusCode).toBe(200)
-
-                expect(res.body).toMatchObject({
-                    txDetails: expect.any(Object),
-                    confirmed_length: 0,
-                    fee: '0'
-                })
-            } finally {
-                context.rpcMsb.state.getTransactionConfirmedLength = originalGetConfirmedLength
-            }
-        })
-
-        it("returns 404 for non-existent transaction hash", async () => {
-            const nonExistentHash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${nonExistentHash}`)
-
-            expect(res.statusCode).toBe(404)
-            expect(res.body).toEqual({
-                error: `No payload found for tx hash: ${nonExistentHash}`
-            })
-        })
-
-        it("returns 400 for invalid hash format (too short)", async () => {
-            const invalidHash = '0'.repeat(63)
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for invalid hash format (non-hex)", async () => {
-            const invalidHash = 'Z'.repeat(64)
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for invalid confirmed parameter", async () => {
-            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-
-            const res = await request(context.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("returns 400 for invalid confirmed parameter case (UPPERCASE)", async () => {
-            const hash = "0b4d1c1dac48af13212f616601d7399457476a0b644850875b7f4b79df6ff89c"
-            const res = await request(context.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("returns 400 when no hash provided", async () => {
-            const res = await request(context.server)
-                .get('/v1/tx/details')
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Transaction hash is required"
-            })
-        })
-
-        it("returns 400 for hash with invalid characters", async () => {
-            const invalidHash = '0b4d1c1dac48$af13212f6166017399457476a0b644850875b7f4b79df6ff89c'
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for hash with special characters", async () => {
-            const invalidHash = '!@#$%^&*'.repeat(8)
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for hash with spaces", async () => {
-            const invalidHash = '0b4d1c1dac48af13212f616601d7399457476a0b644850875b7 4b79df6ff89c'
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${invalidHash}`)
-
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({
-                error: "Invalid transaction hash format"
-            })
-        })
-
-        it("returns 400 for hash with 0x prefix", async () => {
-            const hash = "0x" + "0".repeat(62)
-            const res = await request(context.server).get(`/v1/tx/details/${hash}`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid transaction hash format" })
-        })
-
-        it("returns 400 for odd-length hex", async () => {
-            const hash = "a".repeat(63)
-            const res = await request(context.server).get(`/v1/tx/details/${hash}`)
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Invalid transaction hash format" })
-        })
-
-        it("accepts uppercase hex", async () => {
-            const { payload, txHashHex } = await buildRpcSelfTransferPayload(
-                context,
-                context.rpcMsb.state,
-                1n
-            );
-
-            await waitForConnection(context.rpcMsb);
-            await request(context.server)
-                .post("/v1/broadcast-transaction")
-                .send(JSON.stringify({ payload }));
-
-            const upperHash = txHashHex.toUpperCase();
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${upperHash}?confirmed=false`);
-
-            expect(res.statusCode).toBe(200);
-        });
-
-        it("returns 400 for trailing space hash", async () => {
-            const hash = "a".repeat(64) + " "; 
-            const res = await request(context.server)
-                .get(`/v1/tx/details/${encodeURIComponent(hash)}`);
-            
-            expect(res.statusCode).toBe(400);
-            expect(res.body).toEqual({ error: "Invalid transaction hash format" });
-        });
-    })
-}

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

@@ -1,72 +0,0 @@
-import request from "supertest"
-
-export const registerTxHashesTests = (context) => {
-    describe("GET /v1/tx-hashes", () => {
-        it("< 1000", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/1/1001")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({
-                hashes: expect.arrayContaining([
-                    expect.objectContaining({
-                        hash: expect.any(String),
-                        confirmed_length: expect.any(Number),
-                    })
-                ])
-            })
-        })
-
-        it("> 1000", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/1/1002")
-            expect(res.statusCode).toBe(400)
-        })
-
-        it("returns 400 for non-integer params", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/foo/bar")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Params must be integer" })
-        })
-
-        it("returns 400 for negative params", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/-1/10")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "Params must be non-negative" })
-        })
-
-        it("returns 400 when end < start", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/10/5")
-            expect(res.statusCode).toBe(400)
-            expect(res.body).toEqual({ error: "endSignedLength must be greater than or equal to startSignedLength." })
-        })
-
-        it("accepts boundary at exactly MAX_SIGNED_LENGTH", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/1/1001")
-            expect(res.statusCode).toBe(200)
-        })
-
-        it("trims range to current confirmed length", async () => {
-            const confirmed = await request(context.server).get("/v1/confirmed-length")
-            expect(confirmed.statusCode).toBe(200)
-            const beyond = confirmed.body.confirmed_length + 50
-            const res = await request(context.server).get(`/v1/tx-hashes/0/${beyond}`)
-            expect(res.statusCode).toBe(200)
-            const hashes = res.body.hashes || []
-            // last item confirmed_length should not exceed current confirmed length
-            const maxReturned = hashes.reduce((max, { confirmed_length }) => Math.max(max, confirmed_length || 0), 0)
-            expect(maxReturned).toBeLessThanOrEqual(confirmed.body.confirmed_length)
-        })
-
-        it("returns empty hashes when no data in range", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/0/0")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toHaveProperty("hashes")
-            expect(Array.isArray(res.body.hashes)).toBe(true)
-        })
-
-        it("returns empty hashes when start equals end", async () => {
-            const res = await request(context.server).get("/v1/tx-hashes/5/5")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toHaveProperty("hashes")
-            expect(res.body.hashes).toEqual([])
-        })
-    })
-}

package/tests/acceptance/v1/tx-payloads-bulk/tx-payloads-bulk.test.mjs

@@ -1,27 +0,0 @@
-import request from "supertest"
-
-export const registerTxPayloadsBulkTests = (context) => {
-    describe("POST /v1/tx-payloads-bulk", () => {
-        it("returns payloads for requested hashes", async () => {
-            const result = await context.rpcMsb.state.confirmedTransactionsBetween(0, 40) // Arbitrary range that should contain valid entries
-            const hashes = result.map(({ hash }) => hash)
-
-            const payload = { hashes }
-
-            const res = await request(context.server)
-                .post("/v1/tx-payloads-bulk")
-                .set("Accept", "application/json")
-                .send(JSON.stringify(payload))
-
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toMatchObject({
-                results: expect.arrayOf(
-                    expect.objectContaining({
-                        hash: expect.any(String),
-                    })
-                ),
-                missing: []
-            })
-        })
-    })
-}

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

@@ -1,11 +0,0 @@
-import request from "supertest"
-
-export const registerTxvTests = (context) => {
-    describe("GET /v1/txv", () => {
-        it("returns txv hash", async () => {
-            const res = await request(context.server).get("/v1/txv")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ txv: expect.stringMatching(/^[a-z0-9]{64}$/) })
-        })
-    })
-}

package/tests/acceptance/v1/unconfirmed-length/unconfirmed-length.test.mjs

@@ -1,11 +0,0 @@
-import request from "supertest"
-
-export const registerUnconfirmedLengthTests = (context) => {
-    describe("GET /v1/unconfirmed-length", () => {
-        it("returns unconfirmed length", async () => {
-            const res = await request(context.server).get("/v1/unconfirmed-length")
-            expect(res.statusCode).toBe(200)
-            expect(res.body).toEqual({ unconfirmed_length: expect.any(Number) })
-        })
-    })
-}

package/tests/fixtures/apply.fixtures.js

@@ -1,77 +0,0 @@
-export const testKeyPair1 = {
-    publicKey: '82f6c1f684f4e251dfe092155b8861a0625b596991810b2b80b9c65ccbec5ad3',
-    secretKey: '734aa8a4ff1506a502054f537c235d3fbe70452926bad869c3ab57e90d06df7382f6c1f684f4e251dfe092155b8861a0625b596991810b2b80b9c65ccbec5ad3',
-    mnemonic: 'slight wedding permit mention subject mask hawk awkward sniff leopard spider scatter close neutral deny apple wide category sick love sorry pupil then legal'
-}
-
-export const testKeyPair2 = {
-    publicKey: "8f17ec2862c7b3e4dbbedaf88a68a9b74d76e9d6acca6ca4a5fafb1b6c474616",
-    secretKey: "21b7f3c56eaa4d8114530258c79b8086bcca3e61d6c9edee589e8ca2f48688e98f17ec2862c7b3e4dbbedaf88a68a9b74d76e9d6acca6ca4a5fafb1b6c474616",
-    mnemonic: "century category maze cover student upset trip cup purchase area turtle keen minimum flee diagram romance stool absorb umbrella phone valve avocado fade window"
-}
-
-export const testKeyPair3 = {
-    publicKey: "3341b586cad305908b4ac0cf9176851d90c64a7b7d3ff74100262e383d63c6b8",
-    secretKey: "25178b87c194c3e84358323a2ec43069610a5b48fdd4ca88689155bbc5c180b13341b586cad305908b4ac0cf9176851d90c64a7b7d3ff74100262e383d63c6b8",
-    mnemonic: "inner pond duty corn danger board tragic penalty mad lounge excite lottery great current high exercise spin noble true curtain airport trend when decade"
-}
-
-export const testKeyPair4 = {
-    publicKey: "94bb26ad3449feb0039f201051ab7e0efb7e75cf6d919811b21b80ad7d111c68",
-    secretKey: "aaa800b8f5666f5a9e3036b22dff56d33f0da4d7dc09dad6319605b2312d022094bb26ad3449feb0039f201051ab7e0efb7e75cf6d919811b21b80ad7d111c68",
-    mnemonic: "blue moral east arch pistol episode misery garment spoil tip inflict mean seven improve doll loan artist you skill shoe aerobic decide border demand"
-}
-
-export const testKeyPair5 = {
-  publicKey: "6822a868e5a30c2c571e548f0807f3bd9760d04c4d6a32fe27d30c23c0eaa04b",
-  secretKey: "a573ec441c4f45a451ca615c5b31f4171e567c0c19e906cfe9af308826e6d37d6822a868e5a30c2c571e548f0807f3bd9760d04c4d6a32fe27d30c23c0eaa04b",
-  mnemonic: "walnut disagree toward verify shaft decade stage cactus very asset gasp recycle occur steel gorilla diamond slice sunset train train pill embrace senior clutch"
-}
-
-export const testKeyPair6 = {
-    publicKey: "362020e3249c6942d6ecfded6776820cf7c32242ee56ad169b97637fb32fa654",
-    secretKey: "6ab0b0102e31f1115b4e5a6d9de75aef64e83e3b98d683d09665789dd6811d52362020e3249c6942d6ecfded6776820cf7c32242ee56ad169b97637fb32fa654",
-    mnemonic: "marriage clean edit portion panic easy member worry cave elevator abuse math squirrel scorpion syrup eager horror human cruise robust duty trophy biology edit"
-}
-
-export const testKeyPair7 = {
-    publicKey: "e3d788961c2f0b9114e2545233c519bc3fc1c13ad0f8e00b624f308ce377e441",
-    secretKey: "9e7710867b2194fc06bfe72e2ceca043c045029edbf818a3538095b32f81f7cbe3d788961c2f0b9114e2545233c519bc3fc1c13ad0f8e00b624f308ce377e441",
-    mnemonic: "gift carry tackle motion siren ten hope slice danger wide miss abandon basic version nothing jar jeans coconut accuse lumber ocean swamp jump chef"
-}
-
-export const testKeyPair8 = {
-    publicKey: "ec72b40efcfabcf564766b7af17f3a3dc5a53d4c951eb826839ce2d0b1490e32",
-    secretKey: "485efdaad1cb695cd4d48af832826593c572f8373d55c3c4862ef8b293877e5dec72b40efcfabcf564766b7af17f3a3dc5a53d4c951eb826839ce2d0b1490e32",
-    mnemonic: "wide cram erupt possible buddy pause hole when spin exercise casino cruise panther hurdle cancel dutch time album pumpkin child report blind language birth"
-}
-
-export const testKeyPair9 = {
-    publicKey: "8198b64491c80430bb4c96bd81040a4e11531219c84e4834254a94c2b868ef6b",
-    secretKey: "8f86405b31f69e612f03087e0d58771e207b2cad69936c27a488edc528509e388198b64491c80430bb4c96bd81040a4e11531219c84e4834254a94c2b868ef6b",
-    mnemonic: "private eternal short purse rigid swim satoshi minor knock gauge energy project common avocado spell episode indicate repeat gentle permit defy stone pause hurdle"
-}
-
-export const testKeyPair10 = {
-    publicKey: "bfbb432d2ad0890590864e25a38112a0fd69fa09b82a12d61884c7c12fc47ddb",
-    secretKey: "e7f4375ae010685c28e96b970643fa4593090823fb652adc18a68a12e97b0a37bfbb432d2ad0890590864e25a38112a0fd69fa09b82a12d61884c7c12fc47ddb",
-    mnemonic: "increase spring lobster sound among leave champion help voyage debate thunder retreat venue easily open crouch boil fury burst bean weird survey dirt supply"
-}
-
-export const testKeyPair11 = {
-    publicKey: "bfbb432d2ad0890590864e25a38112a0fd69fa09b82a12d61884c7c12fc47ddb",
-    secretKey: "9b913cee5fd66c11eb29130cc80993ab5e889ae317b3016b58a2062836ff27e5e36ebd8d0ad007d0febca2794ce708e6483f9fa339f2eed9e8825b1d9bc455e0",
-    mnemonic: "fan exotic hill chronic cluster lucky heavy fury tell gym stone shrug guilt hamster achieve meat economy adjust young ignore tomorrow bachelor soft crumble"
-}
-
-export const testKeyPair12 = {
-    publicKey: "7a2d1329679d9631bcf8a5046e38e826c0bc2c1f1c17561907e7ab6d46c61158",
-    secretKey: "e1dde2b8793f8f25677bd29b49e074804dd63b19b236e5f69783c7ee6a8287dc7a2d1329679d9631bcf8a5046e38e826c0bc2c1f1c17561907e7ab6d46c61158",
-    mnemonic: "time token syrup try play renew circle mirror palace vapor vacant chronic theme pudding jelly pride actual tank broccoli sugar onion absurd muffin bar"
-}
-
-export const testKeyPair13 = {
-    publicKey: "fc13fa7f1df30d0e96d7ac80a208b5d738c501c0f7e7dab216a4d847fd9bd65c",
-    secretKey: "0d9aca8e607e9e07f69d80b372d5dcb152460fe4537a52edd87b0be231b0a9e6fc13fa7f1df30d0e96d7ac80a208b5d738c501c0f7e7dab216a4d847fd9bd65c",
-    mnemonic: "quality drop minimum teach present slogan electric hire home orange relax february race fragile actual prefer trade jealous sentence thrive orange grace royal tonight"
-}

package/tests/fixtures/assembleMessage.fixtures.js

@@ -1,41 +0,0 @@
-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";
-
-export const writingKeyAdmin = b4a.from("0768953b234c79eccc6306fdcba2d7c1f0b05b9af6815a3502e96a83a8878ff7", 'hex');
-export const writingKeyNonAdmin = b4a.from("1768953b234c79eccc6306fdcba2d7c1f0b05b9af6815a3502e96a83a8878ff8", 'hex');
-
-export const bootstrapAdmin = writingKeyAdmin;
-
-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,
-    wk: null,
-}
-
-export const initAll = async () => {
-    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;
-    }
-}
-
-export default {
-    mnemonicAdmin,
-    writingKeyAdmin,
-    writingKeyNonAdmin,
-    bootstrapAdmin,
-    walletAdmin,
-    walletNonAdmin,
-    walletPeer,
-    adminEntry,
-    initAll,
-}