@peers-app/peers-sdk 0.7.17 → 0.7.19

package/dist/device/tx-encoding.test.js

@@ -0,0 +1,267 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tx_encoding_1 = require("./tx-encoding");
+describe('tx-encode-decode', () => {
+    describe('txEncode and txDecode', () => {
+        it('should encode and decode simple objects', () => {
+            const testObj = {
+                name: 'test',
+                number: 42,
+                bool: true,
+                str: 'hello world'
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            expect(encoded).toBeInstanceOf(Uint8Array);
+            expect(encoded.length).toBeGreaterThan(0);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testObj);
+        });
+        it('should encode and decode arrays', () => {
+            const testArray = [1, 2, 3, 'four', { five: 5 }];
+            const encoded = (0, tx_encoding_1.txEncode)(testArray);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testArray);
+        });
+        it('should encode and decode nested objects', () => {
+            const testObj = {
+                level1: {
+                    level2: {
+                        level3: {
+                            value: 'deep nested value',
+                            number: 123
+                        },
+                        array: [1, 2, 3]
+                    }
+                }
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testObj);
+        });
+        it('should encode and decode special types (dates, etc.)', () => {
+            const testObj = {
+                date: new Date('2023-01-01T00:00:00.000Z'),
+                nan: NaN,
+                infinity: Infinity,
+                negInfinity: -Infinity,
+                undef: undefined,
+                nullVal: null
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded.date).toBeInstanceOf(Date);
+            expect(decoded.date.toISOString()).toBe('2023-01-01T00:00:00.000Z');
+            expect(Number.isNaN(decoded.nan)).toBe(true);
+            expect(decoded.infinity).toBe(Infinity);
+            expect(decoded.negInfinity).toBe(-Infinity);
+            expect(decoded.undef).toBeUndefined();
+            expect(decoded.nullVal).toBeNull();
+        });
+        it('should encode and decode Uint8Array', () => {
+            const testObj = {
+                data: new Uint8Array([72, 101, 108, 108, 111]),
+                metadata: { size: 5 }
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded.data).toBeInstanceOf(Uint8Array);
+            expect(decoded.data).toEqual(testObj.data);
+            expect(decoded.metadata).toEqual(testObj.metadata);
+        });
+        it('should encode and decode Buffer', () => {
+            const testObj = {
+                buffer: Buffer.from('Hello Buffer'),
+                name: 'test'
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(Buffer.isBuffer(decoded.buffer)).toBe(true);
+            expect(decoded.buffer).toEqual(testObj.buffer);
+            expect(decoded.name).toBe('test');
+        });
+    });
+    describe('compression threshold', () => {
+        it('should not compress small payloads (< 1024 bytes)', () => {
+            const smallObj = { message: 'small' };
+            const encoded = (0, tx_encoding_1.txEncode)(smallObj);
+            // First byte is the flag
+            expect(encoded[0]).toBe(0); // flag = 0 means not compressed
+        });
+        it('should compress large payloads (> 1024 bytes)', () => {
+            // Create an object that will exceed 1024 bytes when encoded
+            const largeObj = {
+                data: 'x'.repeat(2000),
+                array: Array.from({ length: 100 }, (_, i) => ({ id: i, value: `item ${i}` }))
+            };
+            const jsonStr = JSON.stringify(largeObj);
+            expect(jsonStr.length).toBeGreaterThan(1024);
+            const encoded = (0, tx_encoding_1.txEncode)(largeObj);
+            // First byte is the flag
+            expect(encoded[0]).toBe(1); // flag = 1 means compressed
+            // Verify it can still be decoded correctly
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(largeObj);
+        });
+        it('should have smaller encoded size for large compressible data', () => {
+            const largeRepetitiveObj = {
+                data: 'repeat '.repeat(500),
+                values: Array.from({ length: 200 }, () => 'same string')
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(largeRepetitiveObj);
+            // Compressed size should be significantly smaller than the raw data
+            const rawDataSize = JSON.stringify(largeRepetitiveObj).length;
+            expect(encoded.length).toBeLessThan(rawDataSize / 2);
+            // Verify correctness
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(largeRepetitiveObj);
+        });
+    });
+    describe('error handling', () => {
+        it('should throw error on empty payload', () => {
+            const emptyPayload = new Uint8Array(0);
+            expect(() => (0, tx_encoding_1.txDecode)(emptyPayload)).toThrow('Empty payload');
+        });
+        it('should throw error on unknown flag', () => {
+            // Create a payload with an invalid flag (2)
+            const invalidPayload = new Uint8Array([2, 0, 0, 0]);
+            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow('Unknown tx flag: 2');
+        });
+        it('should throw error on unknown flag (255)', () => {
+            const invalidPayload = new Uint8Array([255, 0, 0, 0]);
+            expect(() => (0, tx_encoding_1.txDecode)(invalidPayload)).toThrow('Unknown tx flag: 255');
+        });
+    });
+    describe('round-trip consistency', () => {
+        it('should handle empty objects', () => {
+            const emptyObj = {};
+            const encoded = (0, tx_encoding_1.txEncode)(emptyObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(emptyObj);
+        });
+        it('should handle empty arrays', () => {
+            const emptyArray = [];
+            const encoded = (0, tx_encoding_1.txEncode)(emptyArray);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(emptyArray);
+        });
+        it('should handle strings with special characters', () => {
+            const testObj = {
+                emoji: '🚀🎉',
+                unicode: 'Hello 世界',
+                special: 'line1\nline2\ttab',
+                quotes: 'He said "hello"'
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testObj);
+        });
+        it('should handle very large numbers', () => {
+            const testObj = {
+                maxSafeInt: Number.MAX_SAFE_INTEGER,
+                minSafeInt: Number.MIN_SAFE_INTEGER,
+                large: 9007199254740991,
+                small: -9007199254740991
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testObj);
+        });
+        it('should handle mixed type arrays', () => {
+            const testArray = [
+                1,
+                'string',
+                true,
+                null,
+                undefined,
+                { obj: 'value' },
+                [1, 2, 3],
+                new Date('2023-01-01'),
+                new Uint8Array([1, 2, 3])
+            ];
+            const encoded = (0, tx_encoding_1.txEncode)(testArray);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded[0]).toBe(1);
+            expect(decoded[1]).toBe('string');
+            expect(decoded[2]).toBe(true);
+            expect(decoded[3]).toBeNull();
+            expect(decoded[4]).toBeUndefined();
+            expect(decoded[5]).toEqual({ obj: 'value' });
+            expect(decoded[6]).toEqual([1, 2, 3]);
+            expect(decoded[7]).toBeInstanceOf(Date);
+            expect(decoded[8]).toBeInstanceOf(Uint8Array);
+            expect(decoded[8]).toEqual(new Uint8Array([1, 2, 3]));
+        });
+        it('should handle objects with circular references removed by toJSON', () => {
+            // toJSON handles circular references, so this should work
+            const obj = { name: 'test' };
+            obj.self = obj; // circular reference
+            const encoded = (0, tx_encoding_1.txEncode)(obj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            // The circular reference should be handled by toJSON/fromJSON
+            expect(decoded).toHaveProperty('name', 'test');
+            expect(decoded).toHaveProperty('self');
+            expect(decoded.self).toBe(decoded); // self-reference restored
+        });
+        it('should preserve data integrity across multiple encode/decode cycles', () => {
+            const original = {
+                id: 123,
+                name: 'multi-cycle test',
+                data: new Uint8Array([1, 2, 3, 4, 5]),
+                timestamp: new Date('2023-06-15T12:00:00.000Z')
+            };
+            // Encode and decode multiple times
+            let current = original;
+            for (let i = 0; i < 5; i++) {
+                const encoded = (0, tx_encoding_1.txEncode)(current);
+                current = (0, tx_encoding_1.txDecode)(encoded);
+            }
+            expect(current.id).toBe(original.id);
+            expect(current.name).toBe(original.name);
+            expect(current.data).toEqual(original.data);
+            expect(current.timestamp).toEqual(original.timestamp);
+        });
+    });
+    describe('payload structure', () => {
+        it('should have flag byte as first byte', () => {
+            const testObj = { test: 'value' };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            // First byte should be 0 or 1
+            expect(encoded[0]).toBeGreaterThanOrEqual(0);
+            expect(encoded[0]).toBeLessThanOrEqual(1);
+        });
+        it('should have body after flag byte', () => {
+            const testObj = { test: 'value' };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            // Should have at least 2 bytes (flag + body)
+            expect(encoded.length).toBeGreaterThan(1);
+        });
+    });
+    describe('edge cases', () => {
+        it('should handle objects at exactly 1024 bytes threshold', () => {
+            // Create an object that when msgpack-encoded is very close to 1024 bytes
+            // This is tricky to get exact, so we just verify it works
+            const testObj = {
+                data: 'x'.repeat(1000)
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testObj);
+        });
+        it('should handle primitive values', () => {
+            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(42))).toBe(42);
+            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)('string'))).toBe('string');
+            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(true))).toBe(true);
+            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(false))).toBe(false);
+            expect((0, tx_encoding_1.txDecode)((0, tx_encoding_1.txEncode)(null))).toBe(null);
+        });
+        it('should handle objects with only undefined values', () => {
+            const testObj = {
+                a: undefined,
+                b: undefined
+            };
+            const encoded = (0, tx_encoding_1.txEncode)(testObj);
+            const decoded = (0, tx_encoding_1.txDecode)(encoded);
+            expect(decoded).toEqual(testObj);
+        });
+    });
+});

package/dist/index.d.ts

@@ -17,6 +17,7 @@ export * from "./device/device";
 export * from "./device/device-election";
 export * from "./device/get-trust-level";
 export * from "./device/socket.type";
+export * from "./device/tx-encoding";
 export * from "./package-loader";
 export * from "./events";
 export * from "./data";

package/dist/index.js

@@ -34,6 +34,7 @@ __exportStar(require("./device/device"), exports);
 __exportStar(require("./device/device-election"), exports);
 __exportStar(require("./device/get-trust-level"), exports);
 __exportStar(require("./device/socket.type"), exports);
+__exportStar(require("./device/tx-encoding"), exports);
 __exportStar(require("./package-loader"), exports);
 __exportStar(require("./events"), exports);
 __exportStar(require("./data"), exports);

package/dist/keys.js

@@ -22,12 +22,13 @@ exports.addSignatureToObject = addSignatureToObject;
 exports.verifyObjectSignature = verifyObjectSignature;
 exports.isObjectSignatureValid = isObjectSignatureValid;
 exports.getPublicKeyFromObjectSignature = getPublicKeyFromObjectSignature;
+const sha2_1 = require("@noble/hashes/sha2");
+const buffer_1 = require("buffer");
 const nacl = require("tweetnacl");
 const utils = require("tweetnacl-util");
 const tweetnacl_util_1 = require("tweetnacl-util");
+const tx_encoding_1 = require("./device/tx-encoding");
 const serial_json_1 = require("./serial-json");
-const sha2_1 = require("@noble/hashes/sha2");
-const buffer_1 = require("buffer");
 globalThis.Buffer = buffer_1.Buffer; // shim for browsers/RN
 const _stableStringify = require('fast-json-stable-stringify');
 function setPRNG(fn) {
@@ -114,10 +115,10 @@ function signObjectWithSecretKey(obj, secretKey) {
     }
     const objStr = (0, serial_json_1.toJSONString)(obj);
     const objDecoded = (0, tweetnacl_util_1.decodeUTF8)(objStr);
-    const objSigned = nacl.sign.detached(objDecoded, _secretKey);
+    const signatureByteArray = nacl.sign.detached(objDecoded, _secretKey);
     return {
         contents: obj,
-        signature: encodeBase64(objSigned),
+        signature: encodeBase64(signatureByteArray),
         publicKey: encodeBase64(_secretKey.slice(32)),
     };
 }
@@ -146,9 +147,8 @@ function boxDataWithKeys(data, toPublicBoxKey, mySecretKey) {
     const boxKeyPair = nacl.box.keyPair.fromSecretKey(_secretKey.slice(0, 32));
     const _toPublicBoxKey = decodeBase64(toPublicBoxKey);
     const nonce = nacl.randomBytes(24);
-    data = (0, serial_json_1.toJSONString)(data);
-    const dataDecoded = (0, tweetnacl_util_1.decodeUTF8)(data);
-    const dataBoxed = nacl.box(dataDecoded, nonce, _toPublicBoxKey, boxKeyPair.secretKey);
+    const dataByteArray = (0, tx_encoding_1.txEncode)(data);
+    const dataBoxed = nacl.box(dataByteArray, nonce, _toPublicBoxKey, boxKeyPair.secretKey);
     return {
         contents: encodeBase64(dataBoxed),
         nonce: encodeBase64(nonce),
@@ -161,12 +161,11 @@ function openBoxWithSecretKey(box, mySecretKey) {
     const boxedData = decodeBase64(box.contents);
     const nonce = decodeBase64(box.nonce);
     const _fromPublicBoxKey = decodeBase64(box.fromPublicKey);
-    const dataAry = nacl.box.open(boxedData, nonce, _fromPublicBoxKey, boxKeyPair.secretKey);
-    if (dataAry === null) {
+    const dataByteArray = nacl.box.open(boxedData, nonce, _fromPublicBoxKey, boxKeyPair.secretKey);
+    if (dataByteArray === null) {
         throw new Error('Message was null or verification failed');
     }
-    const dataStr = (0, tweetnacl_util_1.encodeUTF8)(dataAry);
-    return (0, serial_json_1.fromJSONString)(dataStr);
+    return (0, tx_encoding_1.txDecode)(dataByteArray);
 }
 function encryptString(data, secretKey) {
     let _secretKey = decodeBase64(secretKey);

package/dist/logging/console-logger.d.ts

@@ -8,3 +8,56 @@ export declare function setupConsoleProxy(processName: string): Promise<void>;
  * Restore original console methods
  */
 export declare function restoreConsole(): void;
+/**
+ * Extract core message by removing common prefixes that might be added by different processes
+ * This helps detect cross-process loops where each process adds its own prefix
+ * @internal Exported for testing
+ */
+export declare function extractCoreMessage(message: string): string;
+/**
+ * Mark the logging system as initialized and flush any pending logs
+ */
+export declare function markLoggingInitialized(): void;
+/**
+ * Reset logging initialization state (primarily for testing)
+ * @internal
+ */
+export declare function resetLoggingState(): void;
+/**
+ * Logger class for creating source-specific loggers
+ *
+ * Usage:
+ * ```typescript
+ * const logger = new Logger('MyModule');
+ * logger.log('Something happened');
+ * logger.error('An error occurred');
+ * ```
+ */
+export declare class Logger {
+    private source;
+    constructor(source?: string);
+    /**
+     * Log a debug message
+     */
+    debug(...args: any[]): void;
+    /**
+     * Log an info message
+     */
+    info(...args: any[]): void;
+    /**
+     * Log a general message
+     */
+    log(...args: any[]): void;
+    /**
+     * Log a warning message
+     */
+    warn(...args: any[]): void;
+    /**
+     * Log an error message
+     */
+    error(...args: any[]): void;
+    /**
+     * Internal method to write log to database
+     */
+    private writeLog;
+}