@leofcoin/messages 1.6.4 → 2.0.0

package/exports/binary-format.d.ts

@@ -0,0 +1,22 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+type Kind = 'any' | 'bytes' | 'array' | 'bigint' | 'string' | 'number' | 'boolean' | 'object' | 'function' | 'symbol';
+type Field = {
+    key: string;
+    name: string;
+    kind: Kind;
+};
+/** Codec prefix + versioned binary tuple, in declared schema order. No proto-array JSON. */
+export declare class BinaryFormat extends FormatInterface {
+    protected field(key: string, value: any, kind?: Kind): any;
+    create(value: any): void;
+    protected tuple(value: any, fields: readonly Field[]): any[];
+    protoEncode(value: any): Uint8Array<ArrayBufferLike>;
+    encode(value?: any): Uint8Array;
+    protoDecode(bytes: Uint8Array): {
+        [k: string]: any;
+    };
+    decode(bytes?: Uint8Array): object;
+    fromUint8Array(bytes: Uint8Array): object;
+    fromArrayBuffer(buffer: ArrayBuffer): object;
+}
+export {};

package/exports/binary-format.js

@@ -0,0 +1,121 @@
+import { FormatInterface, Codec } from '@leofcoin/codec-format-interface';
+import { encodeValue, encodeValueWithPrefix, decodeValue } from '@leofcoin/binary';
+const schemas = new WeakMap();
+const kindOf = (value) => value === undefined ? 'any'
+    : value instanceof Uint8Array ? 'bytes' : Array.isArray(value) ? 'array' : typeof value;
+function schemaFor(proto) {
+    const cached = schemas.get(proto);
+    if (cached)
+        return cached;
+    const keys = Object.keys(proto);
+    const schema = {
+        fields: keys.map(key => ({
+            key, name: key.endsWith('?') ? key.slice(0, -1) : key, kind: kindOf(proto[key])
+        })),
+        prefixes: new Map()
+    };
+    // Only immutable declarations can safely reuse keys, types and codec framing.
+    // Caller-defined mutable schemas remain supported and are recompiled per operation.
+    if (Object.isFrozen(proto) && keys.every(key => 'value' in Object.getOwnPropertyDescriptor(proto, key)))
+        schemas.set(proto, schema);
+    return schema;
+}
+function codecPrefix(schema, name) {
+    let prefix = schema.prefixes.get(name);
+    if (!prefix) {
+        const codec = new Codec(name);
+        if (!codec.codecBuffer)
+            throw new Error('invalid codec');
+        prefix = new Uint8Array(codec.codecBuffer);
+        schema.prefixes.set(name, prefix);
+    }
+    return prefix;
+}
+/** Codec prefix + versioned binary tuple, in declared schema order. No proto-array JSON. */
+export class BinaryFormat extends FormatInterface {
+    field(key, value, kind) {
+        if (value === undefined)
+            return value;
+        kind ??= kindOf(this.proto[key]);
+        if (kind === 'any')
+            return value;
+        if (kind === 'bigint') {
+            if (typeof value === 'number' && !Number.isSafeInteger(value))
+                throw new TypeError('Unsafe integer message field');
+            if (!['number', 'string', 'bigint'].includes(typeof value))
+                throw new TypeError('Invalid BigInt message field');
+            return BigInt(value);
+        }
+        if (kind === 'bytes') {
+            if (!(value instanceof Uint8Array))
+                throw new TypeError('Message byte field must be Uint8Array');
+        }
+        else if (kind === 'array') {
+            if (!Array.isArray(value))
+                throw new TypeError('Message array field must be an array');
+        }
+        else if (typeof value !== kind || value === null)
+            throw new TypeError('Message field type mismatch');
+        return value;
+    }
+    create(value) {
+        const { fields } = schemaFor(this.proto);
+        // Content hashes are derived, never trusted from a caller-supplied cache field.
+        this.decoded = Object.fromEntries(fields.map(field => {
+            const input = value?.[field.name];
+            return [field.name, field.kind === 'bigint' ? this.field(field.key, input, field.kind) : input];
+        }));
+    }
+    tuple(value, fields) {
+        const tuple = new Array(fields.length);
+        for (let index = 0; index < fields.length; index++) {
+            const field = fields[index];
+            tuple[index] = this.field(field.key, value[field.name], field.kind);
+        }
+        return tuple;
+    }
+    protoEncode(value) {
+        return encodeValue(this.tuple(value, schemaFor(this.proto).fields));
+    }
+    encode(value) {
+        value = value || this.decoded;
+        const schema = schemaFor(this.proto);
+        const prefix = codecPrefix(schema, this.name);
+        if (value instanceof Uint8Array) {
+            // Preserve the base interface's already-encoded-content path.
+            const output = new Uint8Array(prefix.length + value.length);
+            output.set(prefix);
+            output.set(value, prefix.length);
+            this.encoded = output;
+        }
+        else {
+            this.encoded = encodeValueWithPrefix(this.tuple(value, schema.fields), prefix);
+        }
+        return this.encoded;
+    }
+    protoDecode(bytes) {
+        const values = decodeValue(bytes);
+        const { fields } = schemaFor(this.proto);
+        if (!Array.isArray(values) || values.length !== fields.length)
+            throw new TypeError('Binary message schema mismatch');
+        return Object.fromEntries(fields.map((field, index) => {
+            const value = this.field(field.key, values[index], field.kind);
+            if (typeof value !== typeof values[index])
+                throw new TypeError('Non-canonical message field type');
+            return [field.name, value];
+        }));
+    }
+    decode(bytes) {
+        bytes ??= this.encoded;
+        if (!(bytes instanceof Uint8Array))
+            throw new TypeError('Message payload must be Uint8Array');
+        const codec = new Codec(bytes);
+        if (codec.name !== this.name)
+            throw new TypeError('Wrong binary message codec');
+        // Parse the codec once and borrow its content view; decoded byte fields still own copies.
+        this.decoded = this.protoDecode(bytes.subarray(codec.codecBuffer.length));
+        return this.decoded;
+    }
+    fromUint8Array(bytes) { this.encoded = bytes; return this.decode(bytes); }
+    fromArrayBuffer(buffer) { return this.fromUint8Array(new Uint8Array(buffer)); }
+}

package/exports/block.js

@@ -0,0 +1,52 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+import ValidatorMessage from './validator.js';
+import smartConcat from '@vandeurenglenn/typed-array-smart-concat';
+import smartDeconcat from '@vandeurenglenn/typed-array-smart-deconcat';
+
+var proto = {
+    index: BigInt(0),
+    previousHash: String(),
+    timestamp: Number(),
+    reward: BigInt(0),
+    fees: BigInt(0),
+    transactions: Array(),
+    validators: new Uint8Array(),
+    producer: String(),
+    producerProof: String(),
+    protocolVersion: String()
+};
+
+class BlockMessage extends FormatInterface {
+    get messageName() {
+        return 'BlockMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof BlockMessage)
+            return buffer;
+        const name = 'block-message';
+        super(buffer, proto, { name });
+    }
+    encode(decoded) {
+        decoded = decoded || this.decoded;
+        const validators = [];
+        for (const validator of decoded.validators) {
+            if (validator instanceof ValidatorMessage)
+                validators.push(validator.encode());
+            else
+                validators.push(new ValidatorMessage(validator).encode());
+        }
+        return super.encode({
+            ...decoded,
+            validators: smartConcat(validators)
+        });
+    }
+    decode(encoded) {
+        encoded = encoded || this.encoded;
+        super.decode(encoded);
+        // @ts-ignore
+        this.decoded.validators = smartDeconcat(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
+        return this.decoded;
+    }
+}
+
+export { BlockMessage as default };

package/exports/bw-request.js

@@ -0,0 +1,17 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {};
+
+class BWRequestMessage extends FormatInterface {
+    get messageName() {
+        return 'BWRequestMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof BWRequestMessage)
+            return buffer;
+        const name = 'bw-request-message';
+        super(buffer, proto, { name });
+    }
+}
+
+export { BWRequestMessage as default };

package/exports/bw.js

@@ -0,0 +1,20 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {
+    up: Number(),
+    down: Number()
+};
+
+class BWMessage extends FormatInterface {
+    get messageName() {
+        return 'BWMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof BWMessage)
+            return buffer;
+        const name = 'bw-message';
+        super(buffer, proto, { name });
+    }
+}
+
+export { BWMessage as default };

package/exports/contract.js

@@ -0,0 +1,20 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {
+    creator: String(),
+    contract: new Uint8Array(),
+    constructorParameters: Array()
+};
+
+class ContractMessage extends FormatInterface {
+    get messageName() {
+        return 'ContractMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof ContractMessage)
+            return buffer;
+        super(buffer, proto, { name: 'contract-message' });
+    }
+}
+
+export { ContractMessage as default };

package/exports/index.d.ts

@@ -14,3 +14,4 @@ export { default as StateMessage } from './messages/state.js';
 export { default as PrevoteMessage } from './messages/prevote.js';
 export { default as PrecommitMessage } from './messages/precommit.js';
 export { default as ProposalMessage } from './messages/proposal.js';
+export { BinaryFormat } from './binary-format.js';

package/exports/index.js

@@ -14,3 +14,4 @@ export { default as StateMessage } from './messages/state.js';
 export { default as PrevoteMessage } from './messages/prevote.js';
 export { default as PrecommitMessage } from './messages/precommit.js';
 export { default as ProposalMessage } from './messages/proposal.js';
+export { BinaryFormat } from './binary-format.js';

package/exports/last-block-request.js

@@ -0,0 +1,17 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {};
+
+class LastBlockRequestMessage extends FormatInterface {
+    get messageName() {
+        return 'LastBlockRequestMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof LastBlockRequestMessage)
+            return buffer;
+        const name = 'last-block-request-message';
+        super(buffer, proto, { name });
+    }
+}
+
+export { LastBlockRequestMessage as default };

package/exports/last-block.js

@@ -0,0 +1,20 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {
+    hash: String(),
+    index: BigInt(0)
+};
+
+class LastBlockMessage extends FormatInterface {
+    get messageName() {
+        return 'LastBlockMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof LastBlockMessage)
+            return buffer;
+        const name = 'last-block-message';
+        super(buffer, proto, { name });
+    }
+}
+
+export { LastBlockMessage as default };

package/exports/messages/beacon-activation.d.ts

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import proto from '../protos/beacon-activation.proto.js';
 import type { messageInput } from '../types.js';
 export default class BeaconActivationMessage extends FormatInterface {

package/exports/messages/beacon-activation.js

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import proto from '../protos/beacon-activation.proto.js';
 export default class BeaconActivationMessage extends FormatInterface {
     get messageName() {

package/exports/messages/beacon-commitment.d.ts

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import proto from '../protos/beacon-commitment.proto.js';
 import type { messageInput } from '../types.js';
 export default class BeaconCommitmentMessage extends FormatInterface {

package/exports/messages/beacon-commitment.js

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import proto from '../protos/beacon-commitment.proto.js';
 export default class BeaconCommitmentMessage extends FormatInterface {
     get messageName() {

package/exports/messages/beacon-share.d.ts

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import proto from '../protos/beacon-share.proto.js';
 import type { messageInput } from '../types.js';
 export default class BeaconShareMessage extends FormatInterface {

package/exports/messages/beacon-share.js

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import proto from '../protos/beacon-share.proto.js';
 export default class BeaconShareMessage extends FormatInterface {
     get messageName() {

package/exports/messages/block.d.ts

@@ -1,4 +1,4 @@
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import TransactionMessage from './transaction.js';
 import ValidatorMessage from './validator.js';
 import { messageInput } from '../types.js';

package/exports/messages/block.js

@@ -1,5 +1,5 @@
 import proto from '../protos/block.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import ValidatorMessage from './validator.js';
 import { encodeFrames, decodeFrames } from '@leofcoin/binary';
 export default class BlockMessage extends FormatInterface {
@@ -30,9 +30,8 @@ export default class BlockMessage extends FormatInterface {
         encoded = encoded || this.encoded;
         super.decode(encoded);
         // @ts-ignore
-        // Preserve historical acceptance of padded length prefixes. Tightening
-        // canonical protocol validation is a separate, versioned decision.
-        this.decoded.validators = decodeFrames(this.decoded.validators, 0, { canonical: false }).map((validator) => new ValidatorMessage(validator).decoded);
+        // Binary-only protocol also requires canonical validator frame lengths.
+        this.decoded.validators = decodeFrames(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
         return this.decoded;
     }
 }

package/exports/messages/bw-request.d.ts

@@ -1,5 +1,5 @@
 import proto from './../protos/bw-request.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class BWRequestMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/bw-request.js

@@ -1,5 +1,5 @@
 import proto from './../protos/bw-request.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class BWRequestMessage extends FormatInterface {
     get messageName() {
         return 'BWRequestMessage';

package/exports/messages/bw.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/bw.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class BWMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/bw.js

@@ -1,5 +1,5 @@
 import proto from '../protos/bw.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class BWMessage extends FormatInterface {
     get messageName() {
         return 'BWMessage';

package/exports/messages/contract.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/contract.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class ContractMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/contract.js

@@ -1,5 +1,5 @@
 import proto from '../protos/contract.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class ContractMessage extends FormatInterface {
     get messageName() {
         return 'ContractMessage';
@@ -7,6 +7,8 @@ export default class ContractMessage extends FormatInterface {
     constructor(buffer) {
         if (buffer instanceof ContractMessage)
             return buffer;
+        if (buffer && typeof buffer === 'object' && !(buffer instanceof Uint8Array) && typeof buffer.contract === 'string')
+            buffer = { ...buffer, contract: new TextEncoder().encode(buffer.contract) };
         super(buffer, proto, { name: 'contract-message' });
     }
 }

package/exports/messages/last-block-request.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/last-block-request.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class LastBlockRequestMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/last-block-request.js

@@ -1,5 +1,5 @@
 import proto from '../protos/last-block-request.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class LastBlockRequestMessage extends FormatInterface {
     get messageName() {
         return 'LastBlockRequestMessage';

package/exports/messages/last-block.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/last-block.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class LastBlockMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/last-block.js

@@ -1,5 +1,5 @@
 import proto from '../protos/last-block.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class LastBlockMessage extends FormatInterface {
     get messageName() {
         return 'LastBlockMessage';

package/exports/messages/precommit.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/precommit.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class PrecommitMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/precommit.js

@@ -1,5 +1,5 @@
 import proto from '../protos/precommit.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class PrecommitMessage extends FormatInterface {
     get messageName() {
         return 'PrecommitMessage';

package/exports/messages/prevote.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/prevote.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class PrevoteMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/prevote.js

@@ -1,5 +1,5 @@
 import proto from '../protos/prevote.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class PrevoteMessage extends FormatInterface {
     get messageName() {
         return 'PrevoteMessage';

package/exports/messages/proposal.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/proposal.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class ProposalMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/proposal.js

@@ -1,5 +1,5 @@
 import proto from '../protos/proposal.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class ProposalMessage extends FormatInterface {
     get messageName() {
         return 'ProposalMessage';

package/exports/messages/publish.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/publish.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class publishMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/publish.js

@@ -1,5 +1,5 @@
 import proto from '../protos/publish.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class publishMessage extends FormatInterface {
     get messageName() {
         return 'PublishMessage';

package/exports/messages/raw-transaction.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/raw-transaction.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class RawTransactionMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/raw-transaction.js

@@ -1,5 +1,5 @@
 import proto from '../protos/raw-transaction.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class RawTransactionMessage extends FormatInterface {
     get messageName() {
         return 'RawTransactionMessage';

package/exports/messages/state.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/state.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class StateMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/state.js

@@ -1,5 +1,5 @@
 import proto from '../protos/state.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class StateMessage extends FormatInterface {
     get messageName() {
         return 'StateMessage';

package/exports/messages/transaction.d.ts

@@ -1,5 +1,5 @@
 import proto from './../protos/transaction.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class TransactionMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/transaction.js

@@ -1,5 +1,5 @@
 import proto from './../protos/transaction.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class TransactionMessage extends FormatInterface {
     get messageName() {
         return 'TransactionMessage';

package/exports/messages/validator.d.ts

@@ -1,5 +1,5 @@
 import proto from '../protos/validator.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 import type { messageInput } from '../types.js';
 export default class ValidatorMessage extends FormatInterface {
     decoded: typeof proto;

package/exports/messages/validator.js

@@ -1,5 +1,5 @@
 import proto from '../protos/validator.proto.js';
-import { FormatInterface } from '@leofcoin/codec-format-interface';
+import { BinaryFormat as FormatInterface } from '../binary-format.js';
 export default class ValidatorMessage extends FormatInterface {
     get messageName() {
         return 'ValidatorMessage';

package/exports/protos/beacon-activation.proto.js

@@ -1,6 +1,7 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     epoch: BigInt(0),
     configDigest: String(),
     from: String(),
     signature: String()
-};
+});

package/exports/protos/beacon-commitment.proto.js

@@ -1,8 +1,9 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     epoch: BigInt(0),
     threshold: BigInt(0),
     participant: BigInt(0),
     from: String(),
     commitments: Array(),
     signature: String()
-};
+});

package/exports/protos/beacon-share.proto.js

@@ -1,8 +1,9 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     epoch: BigInt(0),
     round: BigInt(0),
     participant: BigInt(0),
     from: String(),
     signatureShare: String(),
     signature: String()
-};
+});

package/exports/protos/block.proto.js

@@ -1,4 +1,5 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     index: BigInt(0),
     previousHash: String(),
     timestamp: Number(),
@@ -9,4 +10,4 @@ export default {
     producer: String(),
     producerProof: String(),
     protocolVersion: String()
-};
+});

package/exports/protos/bw-request.proto.js

@@ -1 +1,2 @@
-export default {};
+import { defineSchema } from '../schema.js';
+export default defineSchema({});

package/exports/protos/bw.proto.js

@@ -1,4 +1,5 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     up: Number(),
     down: Number()
-};
+});

package/exports/protos/contract.proto.js

@@ -1,5 +1,6 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     creator: String(),
     contract: new Uint8Array(),
     constructorParameters: Array()
-};
+});

package/exports/protos/last-block-request.proto.js

@@ -1 +1,2 @@
-export default {};
+import { defineSchema } from '../schema.js';
+export default defineSchema({});

package/exports/protos/last-block.proto.js

@@ -1,4 +1,5 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     hash: String(),
     index: BigInt(0)
-};
+});

package/exports/protos/precommit.proto.js

@@ -1,7 +1,8 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     blockHash: String(),
     index: BigInt(0),
     round: BigInt(0),
     from: String(),
     signature: String()
-};
+});

package/exports/protos/prevote.proto.js

@@ -1,7 +1,8 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     blockHash: String(),
     index: BigInt(0),
     round: BigInt(0),
     from: String(),
     signature: String()
-};
+});

package/exports/protos/proposal.proto.js

@@ -1,7 +1,8 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     blockHash: String(),
     index: BigInt(0),
     round: BigInt(0),
     from: String(),
     signature: String()
-};
+});

package/exports/protos/publish.proto.js

@@ -1,7 +1,8 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     name: String(),
     version: Number(),
     publisher: String(),
     entry: String(),
     files: new Uint8Array()
-};
+});

package/exports/protos/raw-transaction.proto.js

@@ -1,8 +1,9 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     timestamp: Number(),
     from: String(),
     to: String(),
     method: String(),
     params: Array(),
     'nonce?': Number()
-};
+});

package/exports/protos/state.proto.js

@@ -1,4 +1,5 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     lastblock: Object(),
     values: Object()
-};
+});

package/exports/protos/transaction.proto.js

@@ -1,4 +1,5 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     timestamp: Number(),
     from: String(),
     to: String(),
@@ -8,4 +9,4 @@ export default {
     'nonce?': Number(),
     'dependsOn?': Array(),
     'priority?': Boolean()
-};
+});

package/exports/protos/validator.proto.js

@@ -1,4 +1,5 @@
-export default {
+import { defineSchema } from '../schema.js';
+export default defineSchema({
     address: String(),
     reward: BigInt(0)
-};
+});

package/exports/schema.d.ts

@@ -0,0 +1,2 @@
+/** Freeze declarations, not decoded messages. Keep existing consumer field types mutable. */
+export declare const defineSchema: <T extends object>(proto: T) => T;

package/exports/schema.js

@@ -0,0 +1,2 @@
+/** Freeze declarations, not decoded messages. Keep existing consumer field types mutable. */
+export const defineSchema = (proto) => Object.freeze(proto);

package/exports/state.js

@@ -0,0 +1,20 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {
+    lastblock: Object(),
+    values: Object()
+};
+
+class StateMessage extends FormatInterface {
+    get messageName() {
+        return 'StateMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof StateMessage)
+            return buffer;
+        const name = 'state-message';
+        super(buffer, proto, { name });
+    }
+}
+
+export { StateMessage as default };

package/exports/transaction.js

@@ -0,0 +1,34 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {
+    timestamp: Number(),
+    from: String(),
+    to: String(),
+    method: String(),
+    params: Array(),
+    signature: String(),
+    'nonce?': Number(),
+    'dependsOn?': Array(),
+    'priority?': Boolean()
+};
+
+class TransactionMessage extends FormatInterface {
+    get messageName() {
+        return 'TransactionMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof TransactionMessage)
+            return buffer;
+        const name = 'transaction-message';
+        super(buffer, proto, { name });
+    }
+    beforeHashing(decoded) {
+        decoded = super.beforeHashing(decoded);
+        delete decoded.signature;
+        delete decoded.priority;
+        delete decoded.dependsOn;
+        return decoded;
+    }
+}
+
+export { TransactionMessage as default };

package/exports/validator.js

@@ -0,0 +1,20 @@
+import { FormatInterface } from '@leofcoin/codec-format-interface';
+
+var proto = {
+    address: String(),
+    reward: BigInt(0)
+};
+
+class ValidatorMessage extends FormatInterface {
+    get messageName() {
+        return 'ValidatorMessage';
+    }
+    constructor(buffer) {
+        if (buffer instanceof ValidatorMessage)
+            return buffer;
+        const name = 'validator-message';
+        super(buffer, proto, { name });
+    }
+}
+
+export { ValidatorMessage as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leofcoin/messages",
-  "version": "1.6.4",
+  "version": "2.0.0",
   "description": "",
   "private": false,
   "exports": {
@@ -272,16 +272,16 @@
   "license": "MIT",
   "devDependencies": {
     "@leofcoin/types": "^1.0.26",
-    "@rollup/plugin-typescript": "^12.3.0",
+    "@rollup/plugin-typescript": "^12.3.1",
     "@typescript/native": "npm:typescript@^7.0.2",
-    "rollup": "^4.62.4",
+    "rollup": "^4.66.0",
     "rollup-plugin-auto-exports": "^1.1.1",
     "tslib": "^2.8.1",
     "typescript": "npm:@typescript/typescript6@^6.0.2"
   },
   "dependencies": {
-    "@leofcoin/binary": "^1.0.1",
-    "@leofcoin/codec-format-interface": "^1.8.2",
+    "@leofcoin/binary": "^1.1.0",
+    "@leofcoin/codec-format-interface": "^2.0.0",
     "@leofcoin/utils": "^1.1.45"
   },
   "repository": {