@qubic.ts/core 0.1.0

package/src/protocol/packet-framer.ts

@@ -0,0 +1,120 @@
+import type { RequestResponseHeaderFields } from "./request-response-header.js";
+import { decodeRequestResponseHeader } from "./request-response-header.js";
+
+export type Packet = Readonly<{
+  header: RequestResponseHeaderFields;
+  payload: Uint8Array; // excludes the 8-byte header
+}>;
+
+export type PacketFramer = Readonly<{
+  push(chunk: Uint8Array): void;
+  read(): Packet[];
+  bufferedBytes(): number;
+}>;
+
+function concatInto(
+  target: Uint8Array,
+  targetOffset: number,
+  source: Uint8Array,
+  sourceOffset: number,
+  length: number,
+) {
+  target.set(source.subarray(sourceOffset, sourceOffset + length), targetOffset);
+}
+
+export function createPacketFramer(): PacketFramer {
+  const chunks: Uint8Array[] = [];
+  let buffered = 0;
+  let headOffset = 0;
+
+  const peek = (length: number): Uint8Array => {
+    const out = new Uint8Array(length);
+    let remaining = length;
+    let outOffset = 0;
+
+    for (let i = 0; i < chunks.length && remaining > 0; i++) {
+      const chunk = chunks[i];
+      if (!chunk) continue;
+      const start = i === 0 ? headOffset : 0;
+      const available = chunk.byteLength - start;
+      const take = Math.min(available, remaining);
+      concatInto(out, outOffset, chunk, start, take);
+      outOffset += take;
+      remaining -= take;
+    }
+
+    return out;
+  };
+
+  const consume = (length: number): Uint8Array => {
+    if (length > buffered) {
+      throw new RangeError("Cannot consume more bytes than buffered");
+    }
+
+    const out = new Uint8Array(length);
+    let remaining = length;
+    let outOffset = 0;
+
+    while (remaining > 0) {
+      const chunk = chunks[0];
+      if (!chunk) break;
+
+      const start = headOffset;
+      const available = chunk.byteLength - start;
+      const take = Math.min(available, remaining);
+      concatInto(out, outOffset, chunk, start, take);
+      outOffset += take;
+      remaining -= take;
+
+      headOffset += take;
+      buffered -= take;
+
+      if (headOffset >= chunk.byteLength) {
+        chunks.shift();
+        headOffset = 0;
+      }
+    }
+
+    return out;
+  };
+
+  const read = (): Packet[] => {
+    const packets: Packet[] = [];
+
+    while (true) {
+      if (buffered < 8) break;
+
+      const headerBytes = peek(8);
+      const header = decodeRequestResponseHeader(headerBytes);
+
+      if (header.size < 8) {
+        throw new RangeError(`Invalid packet header: size must be >= 8, got ${header.size}`);
+      }
+
+      if (buffered < header.size) break;
+
+      const packetBytes = consume(header.size);
+      packets.push({
+        header,
+        payload: packetBytes.subarray(8),
+      });
+    }
+
+    return packets;
+  };
+
+  const push = (chunk: Uint8Array) => {
+    if (!(chunk instanceof Uint8Array)) {
+      throw new TypeError("chunk must be a Uint8Array");
+    }
+    if (chunk.byteLength === 0) return;
+    chunks.push(chunk);
+    buffered += chunk.byteLength;
+  };
+
+  return {
+    push,
+    read,
+    bufferedBytes: () => buffered,
+  };
+}

package/src/protocol/request-packet.ts

@@ -0,0 +1,48 @@
+import { encodeRequestResponseHeader, MAX_PACKET_SIZE } from "./request-response-header.js";
+
+export type EncodeRequestPacketOptions = Readonly<{
+  dejavu?: number;
+}>;
+
+function randomDejavu(): number {
+  // mimic go-node-connector: uint32(rand.Int31()) and ensure non-zero
+  let value = 0;
+
+  // Use WebCrypto if available
+  if (typeof globalThis.crypto?.getRandomValues === "function") {
+    const tmp = new Uint32Array(1);
+    globalThis.crypto.getRandomValues(tmp);
+    value = (tmp[0] ?? 0) & 0x7fffffff;
+  } else {
+    value = Math.floor(Math.random() * 0x80000000);
+  }
+
+  if (value === 0) value = 1;
+  return value >>> 0;
+}
+
+export function encodeRequestPacket(
+  type: number,
+  payload: Uint8Array = new Uint8Array(),
+  options: EncodeRequestPacketOptions = {},
+): Uint8Array {
+  if (!Number.isInteger(type) || type < 0 || type > 0xff) {
+    throw new RangeError("type must be a uint8");
+  }
+  if (!(payload instanceof Uint8Array)) {
+    throw new TypeError("payload must be a Uint8Array");
+  }
+
+  const size = 8 + payload.byteLength;
+  if (size > MAX_PACKET_SIZE) {
+    throw new RangeError(`packet size cannot exceed ${MAX_PACKET_SIZE}`);
+  }
+
+  const dejavu = options.dejavu ?? randomDejavu();
+  const header = encodeRequestResponseHeader({ size, type, dejavu });
+
+  const out = new Uint8Array(size);
+  out.set(header, 0);
+  out.set(payload, 8);
+  return out;
+}

package/src/protocol/request-response-header.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "bun:test";
+import {
+  decodeRequestResponseHeader,
+  encodeRequestResponseHeader,
+  MAX_PACKET_SIZE,
+} from "./request-response-header.js";
+
+describe("RequestResponseHeader", () => {
+  it("encodes and decodes roundtrip", () => {
+    const encoded = encodeRequestResponseHeader({ size: 8, type: 24, dejavu: 0 });
+    expect(encoded).toBeInstanceOf(Uint8Array);
+    expect(encoded.length).toBe(8);
+
+    const decoded = decodeRequestResponseHeader(encoded);
+    expect(decoded).toEqual({ size: 8, type: 24, dejavu: 0 });
+  });
+
+  it("encodes max size", () => {
+    const encoded = encodeRequestResponseHeader({
+      size: MAX_PACKET_SIZE,
+      type: 255,
+      dejavu: 0xffffffff,
+    });
+    const decoded = decodeRequestResponseHeader(encoded);
+    expect(decoded.size).toBe(MAX_PACKET_SIZE);
+    expect(decoded.type).toBe(255);
+    expect(decoded.dejavu).toBe(0xffffffff);
+  });
+
+  it("rejects invalid size", () => {
+    expect(() => encodeRequestResponseHeader({ size: 0, type: 0, dejavu: 0 })).toThrow();
+    expect(() =>
+      encodeRequestResponseHeader({ size: MAX_PACKET_SIZE + 1, type: 0, dejavu: 0 }),
+    ).toThrow();
+  });
+
+  it("rejects invalid type", () => {
+    expect(() => encodeRequestResponseHeader({ size: 8, type: -1, dejavu: 0 })).toThrow();
+    expect(() => encodeRequestResponseHeader({ size: 8, type: 256, dejavu: 0 })).toThrow();
+  });
+
+  it("rejects invalid dejavu", () => {
+    expect(() => encodeRequestResponseHeader({ size: 8, type: 0, dejavu: -1 })).toThrow();
+    expect(() =>
+      encodeRequestResponseHeader({ size: 8, type: 0, dejavu: 0x1_0000_0000 }),
+    ).toThrow();
+  });
+
+  it("rejects decode of short buffer", () => {
+    expect(() => decodeRequestResponseHeader(new Uint8Array(7))).toThrow();
+  });
+
+  it("rejects decode when size is 0", () => {
+    const b = new Uint8Array(8);
+    b[3] = 1;
+    expect(() => decodeRequestResponseHeader(b)).toThrow();
+  });
+
+  it("property-ish: random roundtrips", () => {
+    for (let i = 0; i < 500; i++) {
+      const size = 1 + Math.floor(Math.random() * MAX_PACKET_SIZE);
+      const type = Math.floor(Math.random() * 256);
+      const dejavu = Math.floor(Math.random() * 0x1_0000_0000);
+      const encoded = encodeRequestResponseHeader({ size, type, dejavu });
+      const decoded = decodeRequestResponseHeader(encoded);
+      expect(decoded).toEqual({ size, type, dejavu: dejavu >>> 0 });
+    }
+  });
+});

package/src/protocol/request-response-header.ts

@@ -0,0 +1,56 @@
+export const MAX_PACKET_SIZE = 0xffffff; // 16,777,215 (3 bytes)
+
+export type RequestResponseHeaderFields = Readonly<{
+  size: number; // total packet size including this header
+  type: number; // uint8
+  dejavu: number; // uint32
+}>;
+
+function assertIntegerInRange(value: number, min: number, max: number, name: string) {
+  if (!Number.isInteger(value)) {
+    throw new TypeError(`${name} must be an integer`);
+  }
+  if (value < min || value > max) {
+    throw new RangeError(`${name} must be between ${min} and ${max}`);
+  }
+}
+
+export function encodeRequestResponseHeader(fields: RequestResponseHeaderFields): Uint8Array {
+  assertIntegerInRange(fields.size, 1, MAX_PACKET_SIZE, "size");
+  assertIntegerInRange(fields.type, 0, 0xff, "type");
+  assertIntegerInRange(fields.dejavu, 0, 0xffffffff, "dejavu");
+
+  const bytes = new Uint8Array(8);
+  bytes[0] = fields.size & 0xff;
+  bytes[1] = (fields.size >> 8) & 0xff;
+  bytes[2] = (fields.size >> 16) & 0xff;
+  bytes[3] = fields.type & 0xff;
+
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setUint32(4, fields.dejavu >>> 0, true);
+  return bytes;
+}
+
+export function decodeRequestResponseHeader(bytes: Uint8Array): RequestResponseHeaderFields {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new TypeError("bytes must be a Uint8Array");
+  }
+  if (bytes.byteLength < 8) {
+    throw new RangeError("bytes must be at least 8 bytes");
+  }
+
+  const size = ((bytes[0] ?? 0) | ((bytes[1] ?? 0) << 8) | ((bytes[2] ?? 0) << 16)) >>> 0;
+  const type = bytes[3] ?? 0;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const dejavu = view.getUint32(4, true);
+
+  // Core treats size=0 as broken; enforce invariant here to fail fast.
+  if (size === 0) {
+    throw new RangeError("Invalid header: size cannot be 0");
+  }
+  if (size > MAX_PACKET_SIZE) {
+    throw new RangeError(`Invalid header: size cannot exceed ${MAX_PACKET_SIZE}`);
+  }
+
+  return { size, type, dejavu };
+}

package/src/protocol/stream.test.ts

@@ -0,0 +1,74 @@
+import { describe, expect, it } from "bun:test";
+import type { Packet } from "./packet-framer.js";
+import { encodeRequestResponseHeader } from "./request-response-header.js";
+import { END_RESPONSE_TYPE, readUntilEndResponse } from "./stream.js";
+
+function makePacket(type: number, dejavu: number, payload: Uint8Array): Packet {
+  const headerBytes = encodeRequestResponseHeader({
+    size: 8 + payload.byteLength,
+    type,
+    dejavu,
+  });
+  const header = {
+    size: (headerBytes[0] ?? 0) | ((headerBytes[1] ?? 0) << 8) | ((headerBytes[2] ?? 0) << 16),
+    type: headerBytes[3] ?? 0,
+    dejavu: new DataView(
+      headerBytes.buffer,
+      headerBytes.byteOffset,
+      headerBytes.byteLength,
+    ).getUint32(4, true),
+  };
+  return { header, payload };
+}
+
+async function collect<T>(iter: AsyncIterable<T>): Promise<T[]> {
+  const out: T[] = [];
+  for await (const item of iter) out.push(item);
+  return out;
+}
+
+describe("readUntilEndResponse", () => {
+  it("yields packets until END_RESPONSE then stops (excluding end by default)", async () => {
+    async function* source() {
+      yield makePacket(24, 1, Uint8Array.from([1]));
+      yield makePacket(24, 2, Uint8Array.from([2]));
+      yield makePacket(END_RESPONSE_TYPE, 3, new Uint8Array(0));
+      yield makePacket(24, 4, Uint8Array.from([9])); // should never be seen
+    }
+
+    const packets = await collect(readUntilEndResponse(source()));
+    expect(packets.map((p) => p.header.type)).toEqual([24, 24]);
+    const packet0 = packets[0];
+    const packet1 = packets[1];
+    if (!packet0 || !packet1) throw new Error("Expected two packets");
+    expect([...packet0.payload]).toEqual([1]);
+    expect([...packet1.payload]).toEqual([2]);
+  });
+
+  it("can include END_RESPONSE when requested", async () => {
+    async function* source() {
+      yield makePacket(24, 1, Uint8Array.from([1]));
+      yield makePacket(END_RESPONSE_TYPE, 3, new Uint8Array(0));
+    }
+
+    const packets = await collect(readUntilEndResponse(source(), { includeEnd: true }));
+    expect(packets.map((p) => p.header.type)).toEqual([24, END_RESPONSE_TYPE]);
+  });
+
+  it("throws if EOF occurs before END_RESPONSE (default)", async () => {
+    async function* source() {
+      yield makePacket(24, 1, Uint8Array.from([1]));
+    }
+
+    await expect(collect(readUntilEndResponse(source()))).rejects.toBeTruthy();
+  });
+
+  it("allows EOF before END_RESPONSE when allowEof is true", async () => {
+    async function* source() {
+      yield makePacket(24, 1, Uint8Array.from([1]));
+    }
+
+    const packets = await collect(readUntilEndResponse(source(), { allowEof: true }));
+    expect(packets.map((p) => p.header.type)).toEqual([24]);
+  });
+});

package/src/protocol/stream.ts

@@ -0,0 +1,48 @@
+import type { Packet } from "./packet-framer.js";
+
+export const END_RESPONSE_TYPE = 35;
+
+export type ReadUntilEndResponseOptions = Readonly<{
+  endType?: number;
+  includeEnd?: boolean;
+  allowEof?: boolean;
+  signal?: AbortSignal;
+}>;
+
+function toAbortError(reason: unknown): Error {
+  if (reason instanceof Error) return reason;
+  const error = new Error("Aborted");
+  error.name = "AbortError";
+  return error;
+}
+
+export async function* readUntilEndResponse(
+  packets: AsyncIterable<Packet>,
+  options: ReadUntilEndResponseOptions = {},
+): AsyncGenerator<Packet> {
+  const endType = options.endType ?? END_RESPONSE_TYPE;
+  const includeEnd = options.includeEnd ?? false;
+  const allowEof = options.allowEof ?? false;
+  const signal = options.signal;
+
+  if (signal?.aborted) {
+    throw toAbortError(signal.reason);
+  }
+
+  for await (const packet of packets) {
+    if (signal?.aborted) {
+      throw toAbortError(signal.reason);
+    }
+
+    if (packet.header.type === endType) {
+      if (includeEnd) yield packet;
+      return;
+    }
+
+    yield packet;
+  }
+
+  if (!allowEof) {
+    throw new Error(`Stream ended before terminator (type=${endType})`);
+  }
+}

package/src/protocol/system-info.test.ts

@@ -0,0 +1,76 @@
+import { describe, expect, it } from "bun:test";
+import { NetworkMessageType } from "./message-types.js";
+import { decodeRequestResponseHeader } from "./request-response-header.js";
+import { decodeRespondSystemInfo, encodeRequestSystemInfo } from "./system-info.js";
+
+describe("system-info", () => {
+  it("encodes request system info packet", () => {
+    const packet = encodeRequestSystemInfo();
+    expect(packet.byteLength).toBe(8);
+    const header = decodeRequestResponseHeader(packet);
+    expect(header.size).toBe(8);
+    expect(header.type).toBe(NetworkMessageType.REQUEST_SYSTEM_INFO);
+    expect(header.dejavu).not.toBe(0);
+  });
+
+  it("decodes respond system info payload", () => {
+    const payload = new Uint8Array(128);
+    const view = new DataView(payload.buffer);
+
+    view.setInt16(0, 123, true);
+    view.setUint16(2, 42, true);
+    view.setUint32(4, 1001, true);
+    view.setUint32(8, 500, true);
+    view.setUint32(12, 999, true);
+
+    view.setUint16(16, 250, true);
+    view.setUint8(18, 1);
+    view.setUint8(19, 2);
+    view.setUint8(20, 3);
+    view.setUint8(21, 4);
+    view.setUint8(22, 5);
+    view.setUint8(23, 6);
+
+    view.setUint32(24, 10, true);
+    view.setUint32(28, 20, true);
+
+    payload.set(new Uint8Array(32).fill(9), 32);
+    view.setInt32(64, -7, true);
+
+    view.setBigUint64(68, 1234n, true);
+    view.setBigUint64(76, 5678n, true);
+    view.setUint32(84, 0xdeadbeef, true);
+    view.setBigUint64(88, 9999n, true);
+
+    view.setBigUint64(96, 1n, true);
+    view.setBigUint64(104, 2n, true);
+    view.setBigUint64(112, 3n, true);
+    view.setBigUint64(120, 4n, true);
+
+    const decoded = decodeRespondSystemInfo(payload);
+    expect(decoded.version).toBe(123);
+    expect(decoded.epoch).toBe(42);
+    expect(decoded.tick).toBe(1001);
+    expect(decoded.initialTick).toBe(500);
+    expect(decoded.latestCreatedTick).toBe(999);
+    expect(decoded.initialMillisecond).toBe(250);
+    expect(decoded.initialSecond).toBe(1);
+    expect(decoded.initialMinute).toBe(2);
+    expect(decoded.initialHour).toBe(3);
+    expect(decoded.initialDay).toBe(4);
+    expect(decoded.initialMonth).toBe(5);
+    expect(decoded.initialYear).toBe(6);
+    expect(decoded.numberOfEntities).toBe(10);
+    expect(decoded.numberOfTransactions).toBe(20);
+    expect(decoded.randomMiningSeed32).toEqual(new Uint8Array(32).fill(9));
+    expect(decoded.solutionThreshold).toBe(-7);
+    expect(decoded.totalSpectrumAmount).toBe(1234n);
+    expect(decoded.currentEntityBalanceDustThreshold).toBe(5678n);
+    expect(decoded.targetTickVoteSignature).toBe(0xdeadbeef);
+    expect(decoded.computorPacketSignature).toBe(9999n);
+    expect(decoded.reserve1).toBe(1n);
+    expect(decoded.reserve2).toBe(2n);
+    expect(decoded.reserve3).toBe(3n);
+    expect(decoded.reserve4).toBe(4n);
+  });
+});

package/src/protocol/system-info.ts

@@ -0,0 +1,111 @@
+import { readU64LE } from "../primitives/number64.js";
+import { NetworkMessageType } from "./message-types.js";
+import { encodeRequestPacket } from "./request-packet.js";
+
+export const RESPOND_SYSTEM_INFO_PAYLOAD_SIZE = 128;
+
+export type SystemInfo = Readonly<{
+  version: number; // int16
+  epoch: number; // uint16
+  tick: number; // uint32
+  initialTick: number; // uint32
+  latestCreatedTick: number; // uint32
+
+  initialMillisecond: number; // uint16
+  initialSecond: number; // uint8
+  initialMinute: number; // uint8
+  initialHour: number; // uint8
+  initialDay: number; // uint8
+  initialMonth: number; // uint8
+  initialYear: number; // uint8
+
+  numberOfEntities: number; // uint32
+  numberOfTransactions: number; // uint32
+
+  randomMiningSeed32: Uint8Array;
+  solutionThreshold: number; // int32
+
+  totalSpectrumAmount: bigint; // uint64
+  currentEntityBalanceDustThreshold: bigint; // uint64
+
+  targetTickVoteSignature: number; // uint32
+  computorPacketSignature: bigint; // uint64
+
+  reserve1: bigint;
+  reserve2: bigint;
+  reserve3: bigint;
+  reserve4: bigint;
+}>;
+
+export function encodeRequestSystemInfo(): Uint8Array {
+  return encodeRequestPacket(NetworkMessageType.REQUEST_SYSTEM_INFO);
+}
+
+export function decodeRespondSystemInfo(payload: Uint8Array): SystemInfo {
+  if (!(payload instanceof Uint8Array)) {
+    throw new TypeError("payload must be a Uint8Array");
+  }
+  if (payload.byteLength !== RESPOND_SYSTEM_INFO_PAYLOAD_SIZE) {
+    throw new RangeError(`payload must be ${RESPOND_SYSTEM_INFO_PAYLOAD_SIZE} bytes`);
+  }
+
+  const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+
+  const version = view.getInt16(0, true);
+  const epoch = view.getUint16(2, true);
+  const tick = view.getUint32(4, true);
+  const initialTick = view.getUint32(8, true);
+  const latestCreatedTick = view.getUint32(12, true);
+
+  const initialMillisecond = view.getUint16(16, true);
+  const initialSecond = view.getUint8(18);
+  const initialMinute = view.getUint8(19);
+  const initialHour = view.getUint8(20);
+  const initialDay = view.getUint8(21);
+  const initialMonth = view.getUint8(22);
+  const initialYear = view.getUint8(23);
+
+  const numberOfEntities = view.getUint32(24, true);
+  const numberOfTransactions = view.getUint32(28, true);
+
+  const randomMiningSeed32 = payload.slice(32, 64);
+  const solutionThreshold = view.getInt32(64, true);
+
+  const totalSpectrumAmount = readU64LE(payload, 68);
+  const currentEntityBalanceDustThreshold = readU64LE(payload, 76);
+
+  const targetTickVoteSignature = view.getUint32(84, true);
+  const computorPacketSignature = readU64LE(payload, 88);
+
+  const reserve1 = readU64LE(payload, 96);
+  const reserve2 = readU64LE(payload, 104);
+  const reserve3 = readU64LE(payload, 112);
+  const reserve4 = readU64LE(payload, 120);
+
+  return {
+    version,
+    epoch,
+    tick,
+    initialTick,
+    latestCreatedTick,
+    initialMillisecond,
+    initialSecond,
+    initialMinute,
+    initialHour,
+    initialDay,
+    initialMonth,
+    initialYear,
+    numberOfEntities,
+    numberOfTransactions,
+    randomMiningSeed32,
+    solutionThreshold,
+    totalSpectrumAmount,
+    currentEntityBalanceDustThreshold,
+    targetTickVoteSignature,
+    computorPacketSignature,
+    reserve1,
+    reserve2,
+    reserve3,
+    reserve4,
+  };
+}

package/src/protocol/tick-data.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "bun:test";
+import { NetworkMessageType } from "./message-types.js";
+import { decodeRequestResponseHeader } from "./request-response-header.js";
+import {
+  countNonZeroTransactionDigests,
+  decodeBroadcastFutureTickData,
+  encodeRequestTickData,
+  MAX_NUMBER_OF_CONTRACTS,
+  NUMBER_OF_TRANSACTIONS_PER_TICK,
+  TICK_DATA_PAYLOAD_SIZE,
+} from "./tick-data.js";
+
+describe("tick-data", () => {
+  it("encodes request tick data packet", () => {
+    const packet = encodeRequestTickData(1234);
+    expect(packet.byteLength).toBe(8 + 4);
+    const header = decodeRequestResponseHeader(packet.subarray(0, 8));
+    expect(header.type).toBe(NetworkMessageType.REQUEST_TICK_DATA);
+
+    const tick = new DataView(packet.buffer, packet.byteOffset + 8, 4).getUint32(0, true);
+    expect(tick).toBe(1234);
+  });
+
+  it("decodes broadcast future tick data payload with accessors", () => {
+    const payload = new Uint8Array(TICK_DATA_PAYLOAD_SIZE);
+    const view = new DataView(payload.buffer);
+    view.setUint16(0, 1, true);
+    view.setUint16(2, 2, true);
+    view.setUint32(4, 3, true);
+    view.setUint16(8, 4, true);
+    view.setUint8(10, 5);
+    view.setUint8(11, 6);
+    view.setUint8(12, 7);
+    view.setUint8(13, 8);
+    view.setUint8(14, 9);
+    view.setUint8(15, 10);
+
+    // timelock
+    payload.set(new Uint8Array(32).fill(11), 16);
+
+    // set one non-zero tx digest at index 0
+    payload[16 + 32 + 0] = 1;
+
+    // set one contract fee
+    const contractFeesOffset = 16 + 32 + NUMBER_OF_TRANSACTIONS_PER_TICK * 32;
+    view.setBigInt64(contractFeesOffset + 5 * 8, 123n, true);
+
+    const signatureOffset = contractFeesOffset + MAX_NUMBER_OF_CONTRACTS * 8;
+    payload.set(new Uint8Array(64).fill(12), signatureOffset);
+
+    const decoded = decodeBroadcastFutureTickData(payload);
+    expect(decoded.computorIndex).toBe(1);
+    expect(decoded.epoch).toBe(2);
+    expect(decoded.tick).toBe(3);
+    expect(decoded.millisecond).toBe(4);
+    expect(decoded.second).toBe(5);
+    expect(decoded.timelock32).toEqual(new Uint8Array(32).fill(11));
+    expect(decoded.signature64).toEqual(new Uint8Array(64).fill(12));
+    expect(decoded.getContractFee(5)).toBe(123n);
+
+    expect(countNonZeroTransactionDigests(decoded)).toBe(1);
+  });
+});