@qubic.ts/core 0.1.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@qubic.ts/core",
+  "version": "0.1.0",
+  "type": "module",
+  "main": "./src/index.ts",
+  "types": "./src/index.ts",
+  "exports": {
+    ".": {
+      "types": "./src/index.ts",
+      "browser": "./src/index.browser.ts",
+      "import": "./src/index.ts",
+      "default": "./src/index.ts"
+    },
+    "./browser": {
+      "types": "./src/index.browser.ts",
+      "import": "./src/index.browser.ts",
+      "default": "./src/index.browser.ts"
+    },
+    "./node": {
+      "types": "./src/index.node.ts",
+      "import": "./src/index.node.ts",
+      "default": "./src/index.node.ts"
+    },
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@noble/hashes": "^1.8.0",
+    "@qubic-labs/schnorrq": "^1.0.2"
+  },
+  "scripts": {
+    "build": "echo \"qubic-ts-core build pending\"",
+    "check": "bun run verify:browser && bun run verify:node",
+    "verify:browser": "bun --conditions=browser ./scripts/verify-browser.mjs",
+    "verify:node": "bun ./scripts/verify-node.mjs",
+    "test": "bun test ./src/**/*.test.ts"
+  }
+}

package/scripts/verify-browser.mjs

@@ -0,0 +1,15 @@
+import { readFile } from "node:fs/promises";
+
+const browserModule = await import("@qubic.ts/core");
+
+if ("createTcpTransport" in browserModule) {
+  throw new Error("Browser entry must not export createTcpTransport.");
+}
+
+const browserEntry = await readFile(new URL("../src/index.browser.ts", import.meta.url), "utf8");
+if (browserEntry.includes("transport/tcp")) {
+  throw new Error("Browser entry must not reference transport/tcp.");
+}
+
+console.log("Browser boundary verification passed.");
+

package/scripts/verify-node.mjs

@@ -0,0 +1,11 @@
+const nodeModule = await import("@qubic.ts/core/node");
+
+if (typeof nodeModule.createTcpTransport !== "function") {
+  throw new Error("Node entry must export createTcpTransport.");
+}
+
+if (typeof nodeModule.createBridgeTransport !== "function") {
+  throw new Error("Node entry must export createBridgeTransport.");
+}
+
+console.log("Node boundary verification passed.");

package/src/crypto/k12.ts

@@ -0,0 +1,13 @@
+import { k12 as k12Hash } from "@qubic-labs/schnorrq";
+
+export async function k12(input: Uint8Array, dkLen: number): Promise<Uint8Array> {
+  if (!(input instanceof Uint8Array)) {
+    throw new TypeError("input must be a Uint8Array");
+  }
+  if (!Number.isSafeInteger(dkLen) || dkLen < 0) {
+    throw new RangeError("dkLen must be a non-negative integer");
+  }
+
+  return k12Hash(input, dkLen);
+}
+

package/src/crypto/schnorrq.ts

@@ -0,0 +1,3 @@
+export type { CreateSchnorrqParams, Schnorrq, SchnorrqSigner } from "@qubic-labs/schnorrq";
+export { generatePublicKey, sign, verify } from "@qubic-labs/schnorrq";
+

package/src/crypto/seed.test.ts

@@ -0,0 +1,11 @@
+import { describe, expect, it } from "bun:test";
+import { identityFromSeed } from "./seed.js";
+
+describe("seed", () => {
+  it("derives the expected identity from a known seed", async () => {
+    const seed = "jvhbyzjinlyutyuhsweuxiwootqoevjqwqmdhjeohrytxjxidpbcfyg";
+    const identity = await identityFromSeed(seed);
+    expect(identity).toBe("HZEBBDSKZRTAWGYMTTSDZQDXYWPBUKBEAIYZNFLVWARZJBEBIJRRFKUDVETA");
+  });
+});
+

package/src/crypto/seed.ts

@@ -0,0 +1,63 @@
+import { identityFromPublicKey } from "../primitives/identity.js";
+import { k12 } from "./k12.js";
+import { generatePublicKey } from "./schnorrq.js";
+
+export const SEED_LENGTH = 55;
+
+function assertSeed(seed: string) {
+  if (typeof seed !== "string") {
+    throw new TypeError("seed must be a string");
+  }
+  if (seed.length !== SEED_LENGTH) {
+    throw new RangeError(`seed must be ${SEED_LENGTH} characters`);
+  }
+  for (let i = 0; i < seed.length; i++) {
+    const c = seed.charCodeAt(i);
+    if (c < 97 || c > 122) {
+      throw new Error("seed must contain only lowercase letters a-z");
+    }
+  }
+}
+
+function seedToBytes(seed: string): Uint8Array {
+  const bytes = new Uint8Array(SEED_LENGTH);
+  for (let i = 0; i < SEED_LENGTH; i++) {
+    bytes[i] = seed.charCodeAt(i) - 97;
+  }
+  return bytes;
+}
+
+function applySeedIndex(preimage: Uint8Array, index: number) {
+  if (!Number.isSafeInteger(index) || index < 0) {
+    throw new RangeError("index must be a non-negative integer");
+  }
+  while (index-- > 0) {
+    for (let i = 0; i < preimage.length; i++) {
+      const next = (preimage[i] ?? 0) + 1;
+      if (next > 26) {
+        preimage[i] = 1;
+      } else {
+        preimage[i] = next;
+        break;
+      }
+    }
+  }
+}
+
+export async function privateKeyFromSeed(seed: string, index = 0): Promise<Uint8Array> {
+  assertSeed(seed);
+  const preimage = seedToBytes(seed);
+  applySeedIndex(preimage, index);
+  return k12(preimage, 32);
+}
+
+export async function publicKeyFromSeed(seed: string, index = 0): Promise<Uint8Array> {
+  const privateKey = await privateKeyFromSeed(seed, index);
+  return generatePublicKey(privateKey);
+}
+
+export async function identityFromSeed(seed: string, index = 0): Promise<string> {
+  const publicKey = await publicKeyFromSeed(seed, index);
+  return identityFromPublicKey(publicKey);
+}
+

package/src/index.browser.ts

@@ -0,0 +1,85 @@
+export {
+  identityFromSeed,
+  privateKeyFromSeed,
+  publicKeyFromSeed,
+  SEED_LENGTH,
+} from "./crypto/seed.js";
+export {
+  identityFromPublicKey,
+  publicKeyFromIdentity,
+  verifyIdentity,
+} from "./primitives/identity.js";
+export {
+  MAX_I64,
+  MAX_U64,
+  MIN_I64,
+  readI64LE,
+  readU64LE,
+  writeI64LE,
+  writeU64LE,
+} from "./primitives/number64.js";
+export type {
+  AssetRecord,
+  RespondAssets,
+  RespondAssetsWithSiblings,
+} from "./protocol/assets.js";
+export {
+  AssetRecordType,
+  decodeAssetRecord,
+  decodeRespondAssets,
+  decodeRespondAssetsWithSiblings,
+  encodeRequestAssetsByFilter,
+  encodeRequestAssetsByUniverseIndex,
+} from "./protocol/assets.js";
+export { encodeBroadcastTransactionPacket } from "./protocol/broadcast-transaction.js";
+export type { RequestContractFunctionParams } from "./protocol/contract-function.js";
+export {
+  decodeRespondContractFunction,
+  encodeRequestContractFunction,
+} from "./protocol/contract-function.js";
+export type { RespondEntity } from "./protocol/entity.js";
+export { decodeRespondEntity, encodeRequestEntity } from "./protocol/entity.js";
+export { NetworkMessageType } from "./protocol/message-types.js";
+export type { Packet, PacketFramer } from "./protocol/packet-framer.js";
+export { createPacketFramer } from "./protocol/packet-framer.js";
+export type { EncodeRequestPacketOptions } from "./protocol/request-packet.js";
+export { encodeRequestPacket } from "./protocol/request-packet.js";
+export type { RequestResponseHeaderFields } from "./protocol/request-response-header.js";
+export {
+  decodeRequestResponseHeader,
+  encodeRequestResponseHeader,
+  MAX_PACKET_SIZE,
+} from "./protocol/request-response-header.js";
+export { END_RESPONSE_TYPE, readUntilEndResponse } from "./protocol/stream.js";
+export type { SystemInfo } from "./protocol/system-info.js";
+export { decodeRespondSystemInfo, encodeRequestSystemInfo } from "./protocol/system-info.js";
+export type { TickDataView } from "./protocol/tick-data.js";
+export {
+  countNonZeroTransactionDigests,
+  decodeBroadcastFutureTickData,
+  encodeRequestTickData,
+  MAX_NUMBER_OF_CONTRACTS,
+  NUMBER_OF_TRANSACTIONS_PER_TICK,
+  TICK_DATA_PAYLOAD_SIZE,
+} from "./protocol/tick-data.js";
+export type { CurrentTickInfo } from "./protocol/tick-info.js";
+export {
+  decodeRespondCurrentTickInfo,
+  encodeRequestCurrentTickInfo,
+} from "./protocol/tick-info.js";
+export type { BuildUnsignedTransactionParams } from "./transactions/transaction.js";
+export {
+  buildSignedTransaction,
+  buildUnsignedTransaction,
+  MAX_INPUT_SIZE,
+  MAX_TRANSACTION_SIZE,
+  SIGNATURE_LENGTH,
+  signTransaction,
+  TRANSACTION_HEADER_SIZE,
+  transactionDigest,
+  transactionId,
+  unsignedTransactionDigest,
+} from "./transactions/transaction.js";
+export { createBridgeTransport } from "./transport/bridge.js";
+export type { Transport } from "./transport/transport.js";
+

package/src/index.node.ts

@@ -0,0 +1,2 @@
+export * from "./index.js";
+

package/src/index.ts

@@ -0,0 +1,85 @@
+export {
+  identityFromPublicKey,
+  publicKeyFromIdentity,
+  verifyIdentity,
+} from "./primitives/identity.js";
+export {
+  MAX_I64,
+  MAX_U64,
+  MIN_I64,
+  readI64LE,
+  readU64LE,
+  writeI64LE,
+  writeU64LE,
+} from "./primitives/number64.js";
+export {
+  identityFromSeed,
+  privateKeyFromSeed,
+  publicKeyFromSeed,
+  SEED_LENGTH,
+} from "./crypto/seed.js";
+export type {
+  AssetRecord,
+  RespondAssets,
+  RespondAssetsWithSiblings,
+} from "./protocol/assets.js";
+export {
+  AssetRecordType,
+  decodeAssetRecord,
+  decodeRespondAssets,
+  decodeRespondAssetsWithSiblings,
+  encodeRequestAssetsByFilter,
+  encodeRequestAssetsByUniverseIndex,
+} from "./protocol/assets.js";
+export { encodeBroadcastTransactionPacket } from "./protocol/broadcast-transaction.js";
+export type { RequestContractFunctionParams } from "./protocol/contract-function.js";
+export {
+  decodeRespondContractFunction,
+  encodeRequestContractFunction,
+} from "./protocol/contract-function.js";
+export type { RespondEntity } from "./protocol/entity.js";
+export { decodeRespondEntity, encodeRequestEntity } from "./protocol/entity.js";
+export { NetworkMessageType } from "./protocol/message-types.js";
+export type { Packet, PacketFramer } from "./protocol/packet-framer.js";
+export { createPacketFramer } from "./protocol/packet-framer.js";
+export type { EncodeRequestPacketOptions } from "./protocol/request-packet.js";
+export { encodeRequestPacket } from "./protocol/request-packet.js";
+export type { RequestResponseHeaderFields } from "./protocol/request-response-header.js";
+export {
+  decodeRequestResponseHeader,
+  encodeRequestResponseHeader,
+  MAX_PACKET_SIZE,
+} from "./protocol/request-response-header.js";
+export { END_RESPONSE_TYPE, readUntilEndResponse } from "./protocol/stream.js";
+export type { SystemInfo } from "./protocol/system-info.js";
+export { decodeRespondSystemInfo, encodeRequestSystemInfo } from "./protocol/system-info.js";
+export type { TickDataView } from "./protocol/tick-data.js";
+export {
+  countNonZeroTransactionDigests,
+  decodeBroadcastFutureTickData,
+  encodeRequestTickData,
+  MAX_NUMBER_OF_CONTRACTS,
+  NUMBER_OF_TRANSACTIONS_PER_TICK,
+  TICK_DATA_PAYLOAD_SIZE,
+} from "./protocol/tick-data.js";
+export type { CurrentTickInfo } from "./protocol/tick-info.js";
+export {
+  decodeRespondCurrentTickInfo,
+  encodeRequestCurrentTickInfo,
+} from "./protocol/tick-info.js";
+export type { BuildUnsignedTransactionParams } from "./transactions/transaction.js";
+export {
+  buildSignedTransaction,
+  buildUnsignedTransaction,
+  MAX_INPUT_SIZE,
+  MAX_TRANSACTION_SIZE,
+  SIGNATURE_LENGTH,
+  signTransaction,
+  transactionDigest,
+  transactionId,
+  TRANSACTION_HEADER_SIZE,
+  unsignedTransactionDigest,
+} from "./transactions/transaction.js";
+export { createBridgeTransport } from "./transport/bridge.js";
+export { createTcpTransport } from "./transport/tcp.js";
+export type { Transport } from "./transport/transport.js";

package/src/primitives/identity.test.ts

@@ -0,0 +1,41 @@
+import { describe, expect, it } from "bun:test";
+import { identityFromPublicKey, publicKeyFromIdentity, verifyIdentity } from "./identity.js";
+
+describe("identity", () => {
+  it("matches the known empty address for zero pubkey (uppercase)", () => {
+    const zero = new Uint8Array(32);
+    expect(identityFromPublicKey(zero)).toBe(
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFXIB",
+    );
+  });
+
+  it("supports lowercase identities", () => {
+    const zero = new Uint8Array(32);
+    expect(identityFromPublicKey(zero, { lowerCase: true })).toBe(
+      "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaafxib",
+    );
+  });
+
+  it("roundtrips identity -> pubkey -> identity", () => {
+    const ids = [
+      "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFXIB",
+      "AFZPUAIYVPNUYGJRQVLUKOPPVLHAZQTGLYAAUUNBXFTVTAMSBKQBLEIEPCVJ",
+      "XPXYKFLGSWRHRGAUKWFWVXCDVEYAPCPCNUTMUDWFGDYQCWZNJMWFZEEGCFFO",
+    ];
+
+    for (const id of ids) {
+      const pub = publicKeyFromIdentity(id);
+      const back = identityFromPublicKey(pub, { lowerCase: false });
+      expect(back).toBe(id);
+      expect(verifyIdentity(id)).toBe(true);
+    }
+  });
+
+  it("rejects checksum mismatch", () => {
+    const id = "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAFXIB";
+    const bad = `${id.slice(0, 59)}A`;
+    expect(verifyIdentity(bad)).toBe(false);
+    expect(() => publicKeyFromIdentity(bad)).toThrow();
+  });
+});
+

package/src/primitives/identity.ts

@@ -0,0 +1,108 @@
+import { k12 } from "@noble/hashes/sha3-addons";
+import { readU64LE, writeU64LE } from "./number64.js";
+
+export type IdentityOptions = Readonly<{
+  lowerCase?: boolean;
+}>;
+
+function assertUint8ArrayLength(bytes: Uint8Array, length: number, name: string) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new TypeError(`${name} must be a Uint8Array`);
+  }
+  if (bytes.byteLength !== length) {
+    throw new RangeError(`${name} must be ${length} bytes`);
+  }
+}
+
+function isAllUppercaseLetters(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 65 || c > 90) return false;
+  }
+  return true;
+}
+
+function isAllLowercaseLetters(s: string): boolean {
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 97 || c > 122) return false;
+  }
+  return true;
+}
+
+export function identityFromPublicKey(
+  publicKey32: Uint8Array,
+  options: IdentityOptions = {},
+): string {
+  assertUint8ArrayLength(publicKey32, 32, "publicKey32");
+
+  const letter = options.lowerCase ? 97 : 65;
+  const identityChars = new Uint8Array(60);
+
+  for (let i = 0; i < 4; i++) {
+    let fragment = readU64LE(publicKey32, i * 8);
+    for (let j = 0; j < 14; j++) {
+      identityChars[i * 14 + j] = Number((fragment % 26n) + BigInt(letter));
+      fragment /= 26n;
+    }
+  }
+
+  const checksum = k12(publicKey32, { dkLen: 3 });
+  let checksumInt =
+    ((checksum[0] ?? 0) | ((checksum[1] ?? 0) << 8) | ((checksum[2] ?? 0) << 16)) & 0x3ffff;
+
+  for (let i = 0; i < 4; i++) {
+    identityChars[56 + i] = (checksumInt % 26) + letter;
+    checksumInt = Math.floor(checksumInt / 26);
+  }
+
+  return new TextDecoder().decode(identityChars);
+}
+
+export function publicKeyFromIdentity(identity60: string): Uint8Array {
+  if (typeof identity60 !== "string") {
+    throw new TypeError("identity60 must be a string");
+  }
+  if (identity60.length !== 60) {
+    throw new RangeError("identity60 must be 60 characters");
+  }
+
+  const isUpper = isAllUppercaseLetters(identity60);
+  const isLower = isAllLowercaseLetters(identity60);
+  if (!isUpper && !isLower) {
+    throw new Error("identity60 must contain only A-Z or only a-z letters");
+  }
+
+  const base = isLower ? 97 : 65;
+  const publicKey = new Uint8Array(32);
+
+  for (let i = 0; i < 4; i++) {
+    let acc = 0n;
+    for (let j = 13; j >= 0; j--) {
+      const c = identity60.charCodeAt(i * 14 + j);
+      const v = c - base;
+      if (v < 0 || v > 25) {
+        throw new Error("identity60 contains invalid characters");
+      }
+      acc = acc * 26n + BigInt(v);
+    }
+    writeU64LE(acc, publicKey, i * 8);
+  }
+
+  const expected = identityFromPublicKey(publicKey, { lowerCase: isLower });
+  if (expected !== identity60) {
+    throw new Error("identity60 checksum mismatch");
+  }
+
+  return publicKey;
+}
+
+export function verifyIdentity(identity60: string): boolean {
+  try {
+    publicKeyFromIdentity(identity60);
+    return true;
+  } catch {
+    return false;
+  }
+}
+

package/src/primitives/number64.ts

@@ -0,0 +1,58 @@
+export const MIN_I64 = -(1n << 63n);
+export const MAX_I64 = (1n << 63n) - 1n;
+export const MAX_U64 = (1n << 64n) - 1n;
+
+function assertIsUint8Array(value: unknown, name: string): asserts value is Uint8Array {
+  if (!(value instanceof Uint8Array)) {
+    throw new TypeError(`${name} must be a Uint8Array`);
+  }
+}
+
+function assertSafeOffset(bytes: Uint8Array, offset: number, length: number) {
+  if (!Number.isInteger(offset)) {
+    throw new TypeError("offset must be an integer");
+  }
+  if (offset < 0) {
+    throw new RangeError("offset must be >= 0");
+  }
+  if (offset + length > bytes.byteLength) {
+    throw new RangeError("Not enough bytes available at offset");
+  }
+}
+
+function assertBigIntInRange(value: bigint, min: bigint, max: bigint, name: string) {
+  if (value < min || value > max) {
+    throw new RangeError(`${name} must be between ${min} and ${max}`);
+  }
+}
+
+export function readI64LE(bytes: Uint8Array, offset: number): bigint {
+  assertIsUint8Array(bytes, "bytes");
+  assertSafeOffset(bytes, offset, 8);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return view.getBigInt64(offset, true);
+}
+
+export function readU64LE(bytes: Uint8Array, offset: number): bigint {
+  assertIsUint8Array(bytes, "bytes");
+  assertSafeOffset(bytes, offset, 8);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return view.getBigUint64(offset, true);
+}
+
+export function writeI64LE(value: bigint, bytes: Uint8Array, offset: number): void {
+  assertIsUint8Array(bytes, "bytes");
+  assertSafeOffset(bytes, offset, 8);
+  assertBigIntInRange(value, MIN_I64, MAX_I64, "value");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setBigInt64(offset, value, true);
+}
+
+export function writeU64LE(value: bigint, bytes: Uint8Array, offset: number): void {
+  assertIsUint8Array(bytes, "bytes");
+  assertSafeOffset(bytes, offset, 8);
+  assertBigIntInRange(value, 0n, MAX_U64, "value");
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  view.setBigUint64(offset, value, true);
+}
+

package/src/protocol/assets.test.ts

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "bun:test";
+import {
+  ASSETS_DEPTH,
+  AssetRecordType,
+  decodeAssetRecord,
+  decodeRespondAssets,
+  decodeRespondAssetsWithSiblings,
+  encodeRequestAssetsByFilter,
+  encodeRequestAssetsByUniverseIndex,
+  RESPOND_ASSETS_PAYLOAD_SIZE,
+  RESPOND_ASSETS_WITH_SIBLINGS_PAYLOAD_SIZE,
+  RequestAssetsFlag,
+  RequestAssetsType,
+} from "./assets.js";
+import { NetworkMessageType } from "./message-types.js";
+import { decodeRequestResponseHeader } from "./request-response-header.js";
+
+describe("assets", () => {
+  it("encodes RequestAssets by universe index", () => {
+    const packet = encodeRequestAssetsByUniverseIndex({ universeIndex: 123, getSiblings: true });
+    const header = decodeRequestResponseHeader(packet.subarray(0, 8));
+    expect(header.type).toBe(NetworkMessageType.REQUEST_ASSETS);
+
+    const payload = packet.subarray(8);
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    expect(view.getUint16(0, true)).toBe(RequestAssetsType.BY_UNIVERSE_INDEX);
+    expect(view.getUint16(2, true) & RequestAssetsFlag.GET_SIBLINGS).toBe(
+      RequestAssetsFlag.GET_SIBLINGS,
+    );
+    expect(view.getUint32(4, true)).toBe(123);
+  });
+
+  it("encodes RequestAssets issuance by filter with anyIssuer/anyAssetName flags", () => {
+    const packet = encodeRequestAssetsByFilter({
+      requestType: RequestAssetsType.ISSUANCE,
+      getSiblings: false,
+    });
+    const payload = packet.subarray(8);
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    expect(view.getUint16(0, true)).toBe(RequestAssetsType.ISSUANCE);
+    const flags = view.getUint16(2, true);
+    expect((flags & RequestAssetsFlag.ANY_ISSUER) !== 0).toBe(true);
+    expect((flags & RequestAssetsFlag.ANY_ASSET_NAME) !== 0).toBe(true);
+  });
+
+  it("decodes issuance AssetRecord", () => {
+    const record = new Uint8Array(48);
+    record.set(new Uint8Array(32).fill(1), 0);
+    record[32] = AssetRecordType.ISSUANCE;
+    record.set(Uint8Array.from([65, 66, 67, 0, 0, 0, 0]), 33); // "ABC"
+    record[40] = 8;
+    record.set(new Uint8Array(7).fill(2), 41);
+
+    const decoded = decodeAssetRecord(record);
+    expect(decoded.type).toBe(AssetRecordType.ISSUANCE);
+    if (decoded.type === AssetRecordType.ISSUANCE) {
+      expect(decoded.name7).toEqual(Uint8Array.from([65, 66, 67, 0, 0, 0, 0]));
+      expect(decoded.numberOfDecimalPlaces).toBe(8);
+    }
+  });
+
+  it("decodes RespondAssets and RespondAssetsWithSiblings", () => {
+    const payload = new Uint8Array(RESPOND_ASSETS_PAYLOAD_SIZE);
+    payload[32] = AssetRecordType.OWNERSHIP;
+    const view = new DataView(payload.buffer, payload.byteOffset, payload.byteLength);
+    view.setUint16(34, 10, true);
+    view.setUint32(36, 20, true);
+    view.setBigInt64(40, 30n, true);
+    view.setUint32(48, 111, true);
+    view.setUint32(52, 222, true);
+
+    const decoded = decodeRespondAssets(payload);
+    expect(decoded.tick).toBe(111);
+    expect(decoded.universeIndex).toBe(222);
+    expect(decoded.asset.type).toBe(AssetRecordType.OWNERSHIP);
+
+    const payload2 = new Uint8Array(RESPOND_ASSETS_WITH_SIBLINGS_PAYLOAD_SIZE);
+    payload2.set(payload, 0);
+    for (let i = 0; i < ASSETS_DEPTH; i++)
+      payload2.set(new Uint8Array(32).fill(i), RESPOND_ASSETS_PAYLOAD_SIZE + i * 32);
+    const decoded2 = decodeRespondAssetsWithSiblings(payload2);
+    expect(decoded2.siblings).toHaveLength(ASSETS_DEPTH);
+    expect(decoded2.siblings[0]).toEqual(new Uint8Array(32).fill(0));
+    expect(decoded2.siblings[23]).toEqual(new Uint8Array(32).fill(23));
+  });
+});