trac-msb 0.2.24 → 0.3.0-beta.1

package/src/codecs/network/v1/networkV1OperationCodec.js

@@ -0,0 +1,25 @@
+import b4a from 'b4a';
+import networkV1Generated from './networkV1.generated.cjs';
+
+const networkV1Operations = networkV1Generated.network.v1;
+
+// Options for converting protobuf messages to plain objects, ensuring that bytes are returned as Buffers and enums as numbers.
+
+const NETWORK_TO_OBJECT_OPTIONS = Object.freeze({
+    enums: Number,
+    longs: Number,
+    defaults: true,
+    arrays: true,
+    oneofs: false
+});
+
+export const encodeV1networkOperation = (payload) => {
+    return b4a.from(networkV1Operations.MessageHeader.encode(payload).finish());
+}
+
+export const decodeV1networkOperation = (payload) => {
+    return networkV1Operations.MessageHeader.toObject(
+        networkV1Operations.MessageHeader.decode(payload),
+        NETWORK_TO_OBJECT_OPTIONS
+    );
+}

package/src/codecs/protobufRuntime.cjs

@@ -0,0 +1,95 @@
+"use strict";
+
+// protobufjs looks for `self` when running outside Node.js and browsers.
+if (typeof globalThis.self === 'undefined') {
+    globalThis.self = globalThis;
+}
+
+const b4a = require('b4a');
+const protobuf = require('protobufjs/minimal');
+
+function isBytes(value) {
+    return b4a.isBuffer(value) || Array.isArray(value) || protobuf.util.isString(value);
+}
+
+function bytesFrom(value) {
+    if (b4a.isBuffer(value)) return b4a.toBuffer(value);
+    if (Array.isArray(value)) return b4a.from(value);
+    if (protobuf.util.isString(value)) return b4a.from(String(value), 'base64');
+    throw TypeError('bytes must be a buffer, array or base64 string');
+}
+
+function bytesTo(value, options) {
+    const bytes = bytesFrom(value);
+    if (options.bytes === String) return b4a.toString(bytes, 'base64');
+    if (options.bytes === Array) return Array.from(bytes);
+    return bytes;
+}
+
+class Reader extends protobuf.Reader {
+    constructor(buffer) {
+        if (!b4a.isBuffer(buffer) && !Array.isArray(buffer)) {
+            throw TypeError('illegal buffer');
+        }
+        super(bytesFrom(buffer));
+    }
+
+    static create(buffer) {
+        // Keep a caller-supplied reader's position and length semantics.
+        return buffer instanceof protobuf.Reader ? buffer : new Reader(buffer);
+    }
+
+    bytes() {
+        const length = this.uint32();
+        const start = this.pos;
+        const end = start + length;
+        if (end > this.len) {
+            throw RangeError(`index out of range: ${start} + ${length} > ${this.len}`);
+        }
+        this.pos = end;
+        return b4a.toBuffer(this.buf.subarray(start, end));
+    }
+}
+
+const adaptedWriters = new WeakSet();
+
+class Writer extends protobuf.Writer {
+    static alloc(size) {
+        return b4a.allocUnsafe(size);
+    }
+
+    static create(writer) {
+        if (!writer) return new Writer();
+        if (writer instanceof Writer || adaptedWriters.has(writer)) return writer;
+
+        // Adapt only the supplied instance, never protobufjs's shared prototypes.
+        const bytes = writer.bytes;
+        const finish = writer.finish;
+        writer.bytes = function (value) {
+            return bytes.call(this, bytesFrom(value));
+        };
+        writer.finish = function () {
+            return bytesFrom(finish.call(this));
+        };
+        adaptedWriters.add(writer);
+        return writer;
+    }
+
+    bytes(value) {
+        return super.bytes(bytesFrom(value));
+    }
+}
+
+// Each generated module uses this facade; other protobufjs consumers are unchanged.
+module.exports = {
+    ...protobuf,
+    Reader,
+    Writer,
+    util: {
+        ...protobuf.util,
+        newBuffer: value => typeof value === 'number' ? b4a.alloc(value) : bytesFrom(value),
+        isBytes,
+        bytesFrom,
+        bytesTo
+    }
+};

package/src/codecs/state/escrowEntryCodec.js

@@ -0,0 +1,45 @@
+import b4a from 'b4a';
+import _ from 'lodash';
+import stateGenerated from './state.generated.cjs';
+
+const {EscrowEntry} = stateGenerated.state;
+const TO_OBJECT_OPTIONS = Object.freeze({
+    enums: Number,
+    defaults: false,
+});
+
+// These wrappers validate protobuf structure; settlement rules remain in the state helper.
+export const encodeEscrowEntry = entry => {
+    if (!_.isPlainObject(entry)) throw new Error('Escrow entry must be an object.');
+    const error = EscrowEntry.verify(entry);
+    if (error) throw new Error(error);
+    return b4a.from(EscrowEntry.encode(entry).finish());
+};
+
+export const decodeEscrowEntry = encoded => {
+    if (!b4a.isBuffer(encoded) || encoded.length === 0) {
+        throw new Error('Encoded escrow entry must be a non-empty buffer.');
+    }
+    const decoded = EscrowEntry.toObject(EscrowEntry.decode(encoded), TO_OBJECT_OPTIONS);
+    // Generated byte fields may alias the input; return independent buffers.
+    for (const [field, value] of Object.entries(decoded)) {
+        if (b4a.isBuffer(value)) decoded[field] = b4a.from(value);
+    }
+    return decoded;
+};
+
+export const safeEncodeEscrowEntry = entry => {
+    try {
+        return encodeEscrowEntry(entry);
+    } catch {
+        return b4a.alloc(0);
+    }
+};
+
+export const safeDecodeEscrowEntry = encoded => {
+    try {
+        return decodeEscrowEntry(encoded);
+    } catch {
+        return null;
+    }
+};