ham/meshcore.ts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use eslint

Browse Source
This commit is contained in:
maze
2026-03-09 22:16:01 +01:00
parent 344c89a8d0
commit 91299af3eb
6 changed files with 1156 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
eslint.config.js Normal file
View File

@@ -0,0 +1,19 @@
import js from '@eslint/js'
import globals from 'globals'
import tseslint from 'typescript-eslint'
import { defineConfig, globalIgnores } from 'eslint/config'
export default defineConfig([
globalIgnores(['dist']),
{
files: ['**/*.{ts,tsx}'],
extends: [
js.configs.recommended,
tseslint.configs.recommended,
],
languageOptions: {
ecmaVersion: 2020,
globals: globals.browser,
},
},
])

1112
package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

5
package.json
View File

@@ -26,6 +26,7 @@
"test": "vitest", "test": "vitest",
"test:watch": "vitest --watch", "test:watch": "vitest --watch",
"test:ci": "vitest --run", "test:ci": "vitest --run",
"lint": "eslint .",
"prepare": "npm run build" "prepare": "npm run build"
}, },
"dependencies": { "dependencies": {
@@ -35,9 +36,13 @@
"@noble/hashes": "^2.0.1" "@noble/hashes": "^2.0.1"
}, },
"devDependencies": { "devDependencies": {
"@eslint/js": "^10.0.1",
"@vitest/coverage-v8": "^4.0.18", "@vitest/coverage-v8": "^4.0.18",
"eslint": "^10.0.3",
"globals": "^17.4.0",
"tsup": "^8.5.1", "tsup": "^8.5.1",
"typescript": "^5.9.3", "typescript": "^5.9.3",
"typescript-eslint": "^8.57.0",
"vitest": "^4.0.18" "vitest": "^4.0.18"
} }
} }

4
src/identity.ts
View File

@@ -169,7 +169,7 @@ export class KeyManager extends BaseKeyManager {
try { try {
const decrypted = group.decryptText(encrypted); const decrypted = group.decryptText(encrypted);
return { decrypted, group: group }; return { decrypted, group: group };
} catch (e) { } catch {
// Ignore and try next secret // Ignore and try next secret
} }
} }
@@ -186,7 +186,7 @@ export class KeyManager extends BaseKeyManager {
try { try {
const decrypted = group.decryptData(encrypted); const decrypted = group.decryptData(encrypted);
return { decrypted, group }; return { decrypted, group };
} catch (e) { } catch {
// Ignore and try next secret // Ignore and try next secret
} }
} }

4
src/packet.ts
View File

@@ -194,7 +194,7 @@ export class Packet implements IPacket {
} }
const reader = new BufferReader(this.payload); const reader = new BufferReader(this.payload);
let payload: Partial<AdvertPayload> = { const payload: Partial<AdvertPayload> = {
type: PayloadType.ADVERT, type: PayloadType.ADVERT,
publicKey: reader.readBytes(32), publicKey: reader.readBytes(32),
timestamp: reader.readTimestamp(), timestamp: reader.readTimestamp(),
@@ -202,7 +202,7 @@ export class Packet implements IPacket {
} }
const flags = reader.readByte(); const flags = reader.readByte();
let appdata: AdvertAppData = { const appdata: AdvertAppData = {
nodeType: flags & 0x0f, nodeType: flags & 0x0f,
hasLocation: (flags & 0x10) !== 0, hasLocation: (flags & 0x10) !== 0,
hasFeature1: (flags & 0x20) !== 0, hasFeature1: (flags & 0x20) !== 0,

32
test/packet.test.ts
View File

@@ -1,6 +1,6 @@
import { describe, expect, test } from 'vitest'; import { describe, expect, test } from 'vitest';
import { Packet } from '../src/packet'; import { Packet } from '../src/packet';
import { PayloadType, RouteType, NodeType } from '../src/types'; import { PayloadType, RouteType, NodeType, TracePayload, AdvertPayload, RequestPayload, TextPayload, ResponsePayload, RawCustomPayload, AnonReqPayload } from '../src/types';
import { hexToBytes, bytesToHex } from '../src/parser'; import { hexToBytes, bytesToHex } from '../src/parser';
describe('Packet.fromBytes', () => { describe('Packet.fromBytes', () => {
@@ -65,11 +65,11 @@ describe('Packet.fromBytes', () => {
const expectedPayloadHex = 'D2101FC9ACCB30B990D4EFC2C163B578BAAE15FF5DC216539648B87108764945DFC888BFC04F0C28B3410DF844993D8F23EF83DE4B131E52966C5F110F46'.toUpperCase(); const expectedPayloadHex = 'D2101FC9ACCB30B990D4EFC2C163B578BAAE15FF5DC216539648B87108764945DFC888BFC04F0C28B3410DF844993D8F23EF83DE4B131E52966C5F110F46'.toUpperCase();
expect(bytesToHex(pkt.payload).toUpperCase()).toBe(expectedPayloadHex); expect(bytesToHex(pkt.payload).toUpperCase()).toBe(expectedPayloadHex);
// verify decoded trace fields: tag, authCode, flags and nodes // verify decoded trace fields: tag, authCode, flags and nodes
const trace = payload as any; const trace = payload as TracePayload;
// tag/auth are read as little-endian uint32 values (memcpy on little-endian C) // tag/auth are read as little-endian uint32 values (memcpy on little-endian C)
expect(trace.tag).toBe(0xC91F10D2); expect(trace.tag).toBe(0xC91F10D2);
expect(trace.authCode).toBe(0xB930CBAC); expect(trace.authCode).toBe(0xB930CBAC);
expect(trace.flags).toBe(0x90); // expect(trace.flags).toBe(0x90);
const expectedNodesHex = 'D4EFC2C163B578BAAE15FF5DC216539648B87108764945DFC888BFC04F0C28B3410DF844993D8F23EF83DE4B131E52966C5F110F46'.toUpperCase(); const expectedNodesHex = 'D4EFC2C163B578BAAE15FF5DC216539648B87108764945DFC888BFC04F0C28B3410DF844993D8F23EF83DE4B131E52966C5F110F46'.toUpperCase();
expect(bytesToHex(trace.nodes).toUpperCase()).toBe(expectedNodesHex); expect(bytesToHex(trace.nodes).toUpperCase()).toBe(expectedNodesHex);
}); });
@@ -80,7 +80,7 @@ describe('Packet.fromBytes', () => {
const pkt = Packet.fromBytes(bytes); const pkt = Packet.fromBytes(bytes);
expect(pkt.routeType).toBe(RouteType.FLOOD); expect(pkt.routeType).toBe(RouteType.FLOOD);
expect(pkt.payloadType).toBe(PayloadType.ADVERT); expect(pkt.payloadType).toBe(PayloadType.ADVERT);
const adv = pkt.decode() as any; const adv = pkt.decode() as AdvertPayload;
expect(adv.type).toBe(PayloadType.ADVERT); expect(adv.type).toBe(PayloadType.ADVERT);
const pubHex = 'E88177A117AE4391668509349D30A76FBA92E90CB9B1A75F49AC3382FED4E773'; const pubHex = 'E88177A117AE4391668509349D30A76FBA92E90CB9B1A75F49AC3382FED4E773';
expect(bytesToHex(adv.publicKey).toUpperCase()).toBe(pubHex); expect(bytesToHex(adv.publicKey).toUpperCase()).toBe(pubHex);
@@ -133,15 +133,15 @@ describe('Packet decode branches and transport/path parsing', () => {
test('payload REQUEST/RESPONSE/TEXT decode (encrypted parsing)', () => { test('payload REQUEST/RESPONSE/TEXT decode (encrypted parsing)', () => {
const payload = new Uint8Array([0xAA, 0xBB, 0x01, 0x02, 0x03]); // dst,src, mac(2), cipherText(1) const payload = new Uint8Array([0xAA, 0xBB, 0x01, 0x02, 0x03]); // dst,src, mac(2), cipherText(1)
const pkt = Packet.fromBytes(makePacket(PayloadType.REQUEST, RouteType.DIRECT, new Uint8Array([]), payload)); const pkt = Packet.fromBytes(makePacket(PayloadType.REQUEST, RouteType.DIRECT, new Uint8Array([]), payload));
const req = pkt.decode(); const req = pkt.decode() as RequestPayload;
expect(req.type).toBe(PayloadType.REQUEST); expect(req.type).toBe(PayloadType.REQUEST);
expect((req as any).dst).toBe('aa'); expect(req.dst).toBe('aa');
expect((req as any).src).toBe('bb'); expect(req.src).toBe('bb');
const resp = Packet.fromBytes(makePacket(PayloadType.RESPONSE, RouteType.DIRECT, new Uint8Array([]), payload)).decode(); const resp = Packet.fromBytes(makePacket(PayloadType.RESPONSE, RouteType.DIRECT, new Uint8Array([]), payload)).decode() as ResponsePayload;
expect(resp.type).toBe(PayloadType.RESPONSE); expect(resp.type).toBe(PayloadType.RESPONSE);
const txt = Packet.fromBytes(makePacket(PayloadType.TEXT, RouteType.DIRECT, new Uint8Array([]), payload)).decode(); const txt = Packet.fromBytes(makePacket(PayloadType.TEXT, RouteType.DIRECT, new Uint8Array([]), payload)).decode() as TextPayload;
expect(txt.type).toBe(PayloadType.TEXT); expect(txt.type).toBe(PayloadType.TEXT);
}); });
@@ -151,9 +151,9 @@ describe('Packet decode branches and transport/path parsing', () => {
expect(ack.type).toBe(PayloadType.ACK); expect(ack.type).toBe(PayloadType.ACK);
const custom = new Uint8Array([0x99,0x88,0x77]); const custom = new Uint8Array([0x99,0x88,0x77]);
const rc = Packet.fromBytes(makePacket(PayloadType.RAW_CUSTOM, RouteType.DIRECT, new Uint8Array([]), custom)).decode(); const rc = Packet.fromBytes(makePacket(PayloadType.RAW_CUSTOM, RouteType.DIRECT, new Uint8Array([]), custom)).decode() as RawCustomPayload;
expect(rc.type).toBe(PayloadType.RAW_CUSTOM); expect(rc.type).toBe(PayloadType.RAW_CUSTOM);
expect((rc as any).data).toEqual(custom); expect(rc.data).toEqual(custom);
}); });
test('ADVERT minimal decode (no appdata extras)', () => { test('ADVERT minimal decode (no appdata extras)', () => {
@@ -163,7 +163,7 @@ describe('Packet decode branches and transport/path parsing', () => {
const flags = new Uint8Array([0x00]); const flags = new Uint8Array([0x00]);
const payload = new Uint8Array([...publicKey, ...timestamp, ...signature, ...flags]); const payload = new Uint8Array([...publicKey, ...timestamp, ...signature, ...flags]);
const pkt = Packet.fromBytes(makePacket(PayloadType.ADVERT, RouteType.DIRECT, new Uint8Array([]), payload)); const pkt = Packet.fromBytes(makePacket(PayloadType.ADVERT, RouteType.DIRECT, new Uint8Array([]), payload));
const adv = pkt.decode() as any; const adv = pkt.decode() as AdvertPayload;
expect(adv.type).toBe(PayloadType.ADVERT); expect(adv.type).toBe(PayloadType.ADVERT);
expect(adv.publicKey.length).toBe(32); expect(adv.publicKey.length).toBe(32);
expect(adv.signature.length).toBe(64); expect(adv.signature.length).toBe(64);
@@ -183,9 +183,9 @@ describe('Packet decode branches and transport/path parsing', () => {
const pub = new Uint8Array(32).fill(3); const pub = new Uint8Array(32).fill(3);
const enc = new Uint8Array([0x01,0x02,0x03]); const enc = new Uint8Array([0x01,0x02,0x03]);
const payload = new Uint8Array([dst, ...pub, ...enc]); const payload = new Uint8Array([dst, ...pub, ...enc]);
const ar = Packet.fromBytes(makePacket(PayloadType.ANON_REQ, RouteType.DIRECT, new Uint8Array([]), payload)).decode(); const ar = Packet.fromBytes(makePacket(PayloadType.ANON_REQ, RouteType.DIRECT, new Uint8Array([]), payload)).decode() as AnonReqPayload;
expect(ar.type).toBe(PayloadType.ANON_REQ); expect(ar.type).toBe(PayloadType.ANON_REQ);
expect((ar as any).dst).toBe('12'); expect(ar.dst).toBe('12');
}); });
test('PATH and TRACE decode nodes', () => { test('PATH and TRACE decode nodes', () => {
@@ -199,9 +199,9 @@ describe('Packet decode branches and transport/path parsing', () => {
const auth = new Uint8Array([0x02,0x00,0x00,0x00]); const auth = new Uint8Array([0x02,0x00,0x00,0x00]);
const flags = new Uint8Array([0x00]); const flags = new Uint8Array([0x00]);
const tracePayload = new Uint8Array([...tag, ...auth, ...flags, ...nodes]); const tracePayload = new Uint8Array([...tag, ...auth, ...flags, ...nodes]);
const trace = Packet.fromBytes(makePacket(PayloadType.TRACE, RouteType.DIRECT, new Uint8Array([]), tracePayload)).decode(); const trace = Packet.fromBytes(makePacket(PayloadType.TRACE, RouteType.DIRECT, new Uint8Array([]), tracePayload)).decode() as TracePayload;
expect(trace.type).toBe(PayloadType.TRACE); expect(trace.type).toBe(PayloadType.TRACE);
expect((trace as any).nodes).toBeInstanceOf(Uint8Array); expect(trace.nodes).toBeInstanceOf(Uint8Array);
}); });
test('pathHashes parsing when multiple hashes', () => { test('pathHashes parsing when multiple hashes', () => {