@totemsdk/txpow 0.1.3 → 0.1.4

package/src/__tests__/serialization.test.ts

@@ -1,347 +0,0 @@
-/**
- * Parity tests for @totemsdk/txpow serialization.
- *
- * These tests verify byte-exact output against known reference vectors derived
- * from the extension's private serializeTxHeader / serializeTxBody / serializeTxPoW
- * and from TxHeaderTests_1768991294482.java.
- *
- * GATE: serializeTxPoW output must be byte-identical to the extension's functions
- * for the same inputs before the extension's private copies are deleted (Task #130).
- */
-
-import { sha3_256 } from '@noble/hashes/sha3';
-import {
-  serializeTxHeader,
-  serializeTxBody,
-  serializeTxPoW,
-  computeTxPoWId,
-  TX_POW_MIN_DIFFICULTY,
-  MAX_HASH,
-  ZERO_HASH,
-  CASCADE_LEVELS,
-  serializeMagic,
-} from '../index.js';
-import { writeMiniNumber, writeMiniData, writeHashToStream, concat } from '@totemsdk/core';
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Helpers
-// ─────────────────────────────────────────────────────────────────────────────
-
-function bytesToHex(b: Uint8Array): string {
-  return Array.from(b).map(x => x.toString(16).padStart(2, '0')).join('');
-}
-
-function hexToBytes(hex: string): Uint8Array {
-  const h = hex.startsWith('0x') ? hex.slice(2) : hex;
-  const out = new Uint8Array(h.length / 2);
-  for (let i = 0; i < h.length; i += 2) out[i / 2] = parseInt(h.slice(i, i + 2), 16);
-  return out;
-}
-
-// Known 32-byte body hash (all 0xAB for determinism)
-const MOCK_BODY_HASH = new Uint8Array(32).fill(0xab);
-
-// Deterministic PRNG for test reproducibility
-const MOCK_PRNG = new Uint8Array(32).fill(0xcd);
-
-// Empty pre-serialized transaction and witness (smallest valid inputs)
-const EMPTY_TX_BYTES = concat(
-  writeMiniNumber(0n),
-  writeMiniNumber(0n),
-  writeMiniNumber(0n),
-  writeHashToStream(new Uint8Array([0x00]))
-);
-const EMPTY_WITNESS_BYTES = concat(
-  writeMiniNumber(0n),
-  writeMiniNumber(0n),
-  writeMiniNumber(0n)
-);
-
-// ─────────────────────────────────────────────────────────────────────────────
-// TX_POW_MIN_DIFFICULTY constant
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('TX_POW_MIN_DIFFICULTY', () => {
-  it('is 32 bytes', () => {
-    expect(TX_POW_MIN_DIFFICULTY.length).toBe(32);
-  });
-
-  it('is less than MAX_HASH (big-endian 256-bit compare)', () => {
-    for (let i = 0; i < 32; i++) {
-      if (TX_POW_MIN_DIFFICULTY[i] < MAX_HASH[i]) return;
-      if (TX_POW_MIN_DIFFICULTY[i] > MAX_HASH[i]) throw new Error('TX_POW_MIN_DIFFICULTY > MAX_HASH');
-    }
-    throw new Error('TX_POW_MIN_DIFFICULTY === MAX_HASH');
-  });
-
-  it('equals floor((2^256 - 1) / 1_000_000)', () => {
-    const expected = ((2n ** 256n) - 1n) / 1_000_000n;
-    let hex = expected.toString(16);
-    if (hex.length % 2 !== 0) hex = '0' + hex;
-    while (hex.length < 64) hex = '00' + hex;
-    expect(bytesToHex(TX_POW_MIN_DIFFICULTY)).toBe(hex);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// computeTxPoWId
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('computeTxPoWId', () => {
-  it('returns SHA3-256 of the provided bytes', () => {
-    const input = new Uint8Array([1, 2, 3, 4]);
-    const result = computeTxPoWId(input);
-    const expected = sha3_256(input);
-    expect(result).toEqual(expected);
-  });
-
-  it('returns 32 bytes', () => {
-    const result = computeTxPoWId(MOCK_BODY_HASH);
-    expect(result.length).toBe(32);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// serializeMagic
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('serializeMagic', () => {
-  it('produces a non-empty byte array', () => {
-    const magic = serializeMagic();
-    expect(magic.length).toBeGreaterThan(0);
-  });
-
-  it('contains expected MiniNumber values for maxTxPoWSize=65536', () => {
-    const magic = serializeMagic();
-    const hex = bytesToHex(magic);
-    // writeMiniNumber(65536n): scale=0 [00], len=3 [03], bytes=[01,00,00]
-    // so "000301 0000" — confirm first 6 bytes contain expected value
-    expect(hex.startsWith('000301')).toBe(true);
-  });
-
-  it('is deterministic', () => {
-    expect(serializeMagic()).toEqual(serializeMagic());
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// serializeTxHeader
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('serializeTxHeader', () => {
-  const FIXED_TIME = 1700000000000n;
-  const FIXED_NONCE = 0n;
-
-  it('is deterministic for fixed nonce + timeMilli', () => {
-    const h1 = serializeTxHeader(MOCK_BODY_HASH, { nonce: FIXED_NONCE, timeMilli: FIXED_TIME });
-    const h2 = serializeTxHeader(MOCK_BODY_HASH, { nonce: FIXED_NONCE, timeMilli: FIXED_TIME });
-    expect(h1).toEqual(h2);
-  });
-
-  it('starts with nonce=0 MiniNumber [00 01 00]', () => {
-    const h = serializeTxHeader(MOCK_BODY_HASH, { nonce: 0n, timeMilli: FIXED_TIME });
-    expect(Array.from(h.slice(0, 3))).toEqual([0x00, 0x01, 0x00]);
-  });
-
-  it('starts with nonce=1 MiniNumber [00 01 01] for nonce=1', () => {
-    const h = serializeTxHeader(MOCK_BODY_HASH, { nonce: 1n, timeMilli: FIXED_TIME });
-    expect(Array.from(h.slice(0, 3))).toEqual([0x00, 0x01, 0x01]);
-  });
-
-  it('encodes nonce=128 with 4 bytes (MiniNumber boundary)', () => {
-    const h = serializeTxHeader(MOCK_BODY_HASH, { nonce: 128n, timeMilli: FIXED_TIME });
-    // writeMiniNumber(128n): scale=0 [00], len=2 [02], bytes=[00,80]
-    expect(Array.from(h.slice(0, 4))).toEqual([0x00, 0x02, 0x00, 0x80]);
-  });
-
-  it('encodes nonce=32768 with 5 bytes (MiniNumber boundary)', () => {
-    const h = serializeTxHeader(MOCK_BODY_HASH, { nonce: 32768n, timeMilli: FIXED_TIME });
-    // writeMiniNumber(32768n): scale=0 [00], len=3 [03], bytes=[00,80,00]
-    expect(Array.from(h.slice(0, 5))).toEqual([0x00, 0x03, 0x00, 0x80, 0x00]);
-  });
-
-  it('includes CASCADE_LEVELS=32 as single byte in super-parents section', () => {
-    const h = serializeTxHeader(MOCK_BODY_HASH, { nonce: 0n, timeMilli: FIXED_TIME });
-    const hex = bytesToHex(h);
-    // After nonce[3] + chainID[5] + timeMilli[?] + blockNum[3] + blockDiff[36] = starts with 00 01 00
-    // We check that the byte 0x20 (=32=CASCADE_LEVELS) appears exactly once in isolation
-    expect(h).toContain(CASCADE_LEVELS);
-    const idx = h.indexOf(CASCADE_LEVELS);
-    expect(idx).toBeGreaterThan(0);
-    expect(hex).toContain('20'); // 0x20 = 32
-  });
-
-  it('ends with the txBodyHash via writeHashToStream (last 36 bytes = 4-byte len + 32 bytes)', () => {
-    const h = serializeTxHeader(MOCK_BODY_HASH, { nonce: 0n, timeMilli: FIXED_TIME });
-    const tail = h.slice(h.length - 36);
-    // writeHashToStream produces: 00 00 00 20 + 32 bytes
-    expect(Array.from(tail.slice(0, 4))).toEqual([0x00, 0x00, 0x00, 0x20]);
-    expect(tail.slice(4)).toEqual(MOCK_BODY_HASH);
-  });
-
-  it('changes when nonce changes (mining loop property)', () => {
-    const h0 = serializeTxHeader(MOCK_BODY_HASH, { nonce: 0n, timeMilli: FIXED_TIME });
-    const h1 = serializeTxHeader(MOCK_BODY_HASH, { nonce: 1n, timeMilli: FIXED_TIME });
-    expect(h0).not.toEqual(h1);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// serializeTxBody
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('serializeTxBody', () => {
-  it('is deterministic when prng is provided', () => {
-    const b1 = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    const b2 = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    expect(b1).toEqual(b2);
-  });
-
-  it('starts with writeHashToStream(prng): [00 00 00 20] + 32 prng bytes', () => {
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    expect(Array.from(body.slice(0, 4))).toEqual([0x00, 0x00, 0x00, 0x20]);
-    expect(body.slice(4, 36)).toEqual(MOCK_PRNG);
-  });
-
-  it('uses MAX_HASH as default txnDifficulty (36 bytes after PRNG)', () => {
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    // After PRNG (36 bytes): writeMiniData(MAX_HASH) = [00 00 00 20] + 32×FF
-    const diffStart = 36;
-    expect(Array.from(body.slice(diffStart, diffStart + 4))).toEqual([0x00, 0x00, 0x00, 0x20]);
-    expect(Array.from(body.slice(diffStart + 4, diffStart + 36))).toEqual(Array(32).fill(0xff));
-  });
-
-  it('uses provided txnDifficulty correctly', () => {
-    const customDiff = new Uint8Array(32).fill(0x11);
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, {
-      prng: MOCK_PRNG,
-      txnDifficulty: customDiff,
-    });
-    const diffStart = 36;
-    expect(Array.from(body.slice(diffStart + 4, diffStart + 36))).toEqual(Array(32).fill(0x11));
-  });
-
-  it('includes the pre-serialized txBytes verbatim', () => {
-    const mockTx = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
-    const body = serializeTxBody(mockTx, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    const bodyHex = bytesToHex(body);
-    expect(bodyHex).toContain('deadbeef');
-  });
-
-  it('includes the pre-serialized witnessBytes verbatim', () => {
-    const mockWitness = new Uint8Array([0xca, 0xfe, 0xba, 0xbe]);
-    const body = serializeTxBody(EMPTY_TX_BYTES, mockWitness, { prng: MOCK_PRNG });
-    const bodyHex = bytesToHex(body);
-    expect(bodyHex).toContain('cafebabe');
-  });
-
-  it('ends with MiniNumber(0) for empty txpowid list', () => {
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    // Last 3 bytes: writeMiniNumber(0n) = [00, 01, 00]
-    expect(Array.from(body.slice(body.length - 3))).toEqual([0x00, 0x01, 0x00]);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// serializeTxPoW — structure tests
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('serializeTxPoW', () => {
-  it('byte at header.length is 0x01 (hasBody flag)', () => {
-    const FIXED_TIME = 1700000000000n;
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    const bodyHash = sha3_256(body);
-    const header = serializeTxHeader(bodyHash, { nonce: 0n, timeMilli: FIXED_TIME });
-
-    const txpow = serializeTxPoW(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, {
-      nonce: 0n,
-      timeMilli: FIXED_TIME,
-      prng: MOCK_PRNG,
-    });
-
-    expect(txpow[header.length]).toBe(0x01);
-  });
-
-  it('header prefix matches standalone serializeTxHeader output', () => {
-    const FIXED_TIME = 1700000000000n;
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    const bodyHash = sha3_256(body);
-    const expectedHeader = serializeTxHeader(bodyHash, { nonce: 0n, timeMilli: FIXED_TIME });
-
-    const txpow = serializeTxPoW(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, {
-      nonce: 0n,
-      timeMilli: FIXED_TIME,
-      prng: MOCK_PRNG,
-    });
-
-    expect(txpow.slice(0, expectedHeader.length)).toEqual(expectedHeader);
-  });
-
-  it('txpowId derived from first headerLen bytes matches computeTxPoWId', () => {
-    const FIXED_TIME = 1700000000000n;
-    const body = serializeTxBody(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, { prng: MOCK_PRNG });
-    const bodyHash = sha3_256(body);
-    const header = serializeTxHeader(bodyHash, { nonce: 0n, timeMilli: FIXED_TIME });
-
-    const txpow = serializeTxPoW(EMPTY_TX_BYTES, EMPTY_WITNESS_BYTES, {
-      nonce: 0n,
-      timeMilli: FIXED_TIME,
-      prng: MOCK_PRNG,
-    });
-
-    const idFromTxPoW = computeTxPoWId(txpow.slice(0, header.length));
-    const idFromHeader = computeTxPoWId(header);
-    expect(idFromTxPoW).toEqual(idFromHeader);
-  });
-});
-
-// ─────────────────────────────────────────────────────────────────────────────
-// Nonce MiniNumber encoding boundaries
-// ─────────────────────────────────────────────────────────────────────────────
-
-describe('nonce MiniNumber encoding boundaries', () => {
-  const BODY_HASH = new Uint8Array(32).fill(0x77);
-  const TIME = 1700000000000n;
-
-  it('nonce=0 encodes as 3 bytes [00 01 00]', () => {
-    const n = writeMiniNumber(0n);
-    expect(n.length).toBe(3);
-    expect(Array.from(n)).toEqual([0x00, 0x01, 0x00]);
-  });
-
-  it('nonce=127 encodes as 3 bytes (still 1-byte unscaled)', () => {
-    const n = writeMiniNumber(127n);
-    expect(n.length).toBe(3);
-    expect(Array.from(n)).toEqual([0x00, 0x01, 0x7f]);
-  });
-
-  it('nonce=128 encodes as 4 bytes (2-byte unscaled: leading zero + 0x80)', () => {
-    const n = writeMiniNumber(128n);
-    expect(n.length).toBe(4);
-    expect(Array.from(n)).toEqual([0x00, 0x02, 0x00, 0x80]);
-  });
-
-  it('nonce=32767 encodes as 4 bytes', () => {
-    const n = writeMiniNumber(32767n);
-    expect(n.length).toBe(4);
-    expect(Array.from(n)).toEqual([0x00, 0x02, 0x7f, 0xff]);
-  });
-
-  it('nonce=32768 encodes as 5 bytes (3-byte unscaled: leading zero + 0x80 0x00)', () => {
-    const n = writeMiniNumber(32768n);
-    expect(n.length).toBe(5);
-    expect(Array.from(n)).toEqual([0x00, 0x03, 0x00, 0x80, 0x00]);
-  });
-
-  it('header byte length changes at nonce 128 boundary', () => {
-    const h127 = serializeTxHeader(BODY_HASH, { nonce: 127n, timeMilli: TIME });
-    const h128 = serializeTxHeader(BODY_HASH, { nonce: 128n, timeMilli: TIME });
-    expect(h128.length).toBe(h127.length + 1);
-  });
-
-  it('header byte length changes at nonce 32768 boundary', () => {
-    const h32767 = serializeTxHeader(BODY_HASH, { nonce: 32767n, timeMilli: TIME });
-    const h32768 = serializeTxHeader(BODY_HASH, { nonce: 32768n, timeMilli: TIME });
-    expect(h32768.length).toBe(h32767.length + 1);
-  });
-});

package/src/calibrate.ts

@@ -1,86 +0,0 @@
-/**
- * calibrate.ts — Hash rate measurement and mining cost estimation.
- *
- * calibrateHashRate() measures how many SHA3-256 hashes/sec the current
- * environment can produce. Used by the extension UX to show a warning
- * before starting a mine on slow devices.
- *
- * estimateMiningCost() converts a difficulty target + hash rate into an
- * expected time and confidence label.
- */
-
-import { sha3_256 } from '@noble/hashes/sha3.js';
-
-export interface MiningEstimate {
-  expectedHashes: bigint;
-  expectedSeconds: number;
-  confidence: 'fast' | 'normal' | 'slow';
-}
-
-/**
- * Run 100K trial SHA3-256 hashes and return the measured hash rate (hashes/sec).
- *
- * Call once per session and cache the result — the cost is ~50ms on a
- * typical desktop and ~300ms on a mid-range mobile.
- */
-export async function calibrateHashRate(): Promise<number> {
-  const TRIAL_COUNT = 100_000;
-  const data = new Uint8Array(150).fill(0xab);
-
-  const start = typeof performance !== 'undefined'
-    ? performance.now()
-    : Date.now();
-
-  for (let i = 0; i < TRIAL_COUNT; i++) {
-    sha3_256(data);
-  }
-
-  const elapsed = (typeof performance !== 'undefined' ? performance.now() : Date.now()) - start;
-  return Math.round(TRIAL_COUNT / (elapsed / 1000));
-}
-
-/**
- * Given a difficulty target and a measured hash rate, return the expected
- * number of hashes, expected wall-clock time, and a confidence label.
- *
- * expectedHashes ≈ MAX_HASH / txnDifficulty
- *   (geometric distribution: each hash has P(valid) = txnDifficulty / MAX_HASH)
- *
- * Confidence labels:
- *   fast   < 2 s
- *   normal 2 – 15 s
- *   slow   > 15 s
- */
-export function estimateMiningCost(
-  txnDifficulty: Uint8Array,
-  hashRatePerSec: number
-): MiningEstimate {
-  if (hashRatePerSec <= 0) {
-    throw new Error('hashRatePerSec must be positive');
-  }
-
-  const diffBigInt = txnDifficulty.reduce(
-    (acc, b) => (acc << 8n) | BigInt(b),
-    0n
-  );
-
-  if (diffBigInt === 0n) {
-    return { expectedHashes: 0n, expectedSeconds: 0, confidence: 'fast' };
-  }
-
-  const MAX_HASH_BIGINT = (2n ** 256n) - 1n;
-  const expectedHashes = MAX_HASH_BIGINT / diffBigInt;
-
-  const expectedSeconds = Number(expectedHashes) / hashRatePerSec;
-
-  let confidence: 'fast' | 'normal' | 'slow';
-  if (expectedSeconds < 2) {
-    confidence = 'fast';
-  } else if (expectedSeconds < 15) {
-    confidence = 'normal';
-  } else {
-    confidence = 'slow';
-  }
-
-  return { expectedHashes, expectedSeconds, confidence };
-}

package/src/constants.ts

@@ -1,49 +0,0 @@
-/**
- * constants.ts — TxPoW-level constants matching Minima Java protocol values.
- *
- * ZERO_HASH:              32-byte all-zeros — used for MMRRoot, CustomHash, super-parent slot.
- * MAX_HASH:               32-byte all-0xFF — default mBlockDifficulty / mTxnDifficulty for
- *                         MEG-side-mined paths. Rejected by checkTxPoWSimple() at block level.
- * TX_POW_MIN_DIFFICULTY:  Safe transaction difficulty target.
- *                         ≈ MAX_HASH / 1,000,000 = Magic.getMinTxPowWork() floor.
- *                         Local-mining paths MUST use a target ≤ this value.
- * MAIN_NET_CHAIN_ID:      1-byte [0x00] — Java MiniData("0x00") = MAIN_NET chain ID.
- * CASCADE_LEVELS:         32 — number of super-parent slots in a fresh TxPoW header.
- */
-
-export const CASCADE_LEVELS = 32;
-
-export const ZERO_HASH = new Uint8Array(32);
-
-export const MAX_HASH: Uint8Array = (() => {
-  const b = new Uint8Array(32);
-  b.fill(0xff);
-  return b;
-})();
-
-/**
- * TX_POW_MIN_DIFFICULTY = floor((2^256 - 1) / 1_000_000)
- *
- * This is the hardcoded floor constant matching Magic.getMinTxPowWork().
- * Any locally mined TxPoW must have mTxnDifficulty ≤ this value to pass
- * TxPoWChecker.checkTxPoWSimple() at block inclusion.
- *
- * Computed: (2n**256n - 1n) / 1_000_000n
- * Hex: 0x000010C6F7A0B5ED8538AACDD46595F0C7AC73E0E9DBF12F70000000000000000
- */
-export const TX_POW_MIN_DIFFICULTY: Uint8Array = (() => {
-  const maxHashBigInt = (2n ** 256n) - 1n;
-  const minDiffBigInt = maxHashBigInt / 1_000_000n;
-
-  let hex = minDiffBigInt.toString(16);
-  if (hex.length % 2 !== 0) hex = '0' + hex;
-  while (hex.length < 64) hex = '00' + hex;
-
-  const bytes = new Uint8Array(32);
-  for (let i = 0; i < 32; i++) {
-    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
-  }
-  return bytes;
-})();
-
-export const MAIN_NET_CHAIN_ID = new Uint8Array([0x00]);

package/src/difficulty.ts

@@ -1,69 +0,0 @@
-/**
- * difficulty.ts — Fetch and manage the TxPoW difficulty target.
- *
- * The live value comes from `GET /v1/wallet/txpow-params` on the Axia API.
- * On any error (timeout, network failure, invalid response) we fall back to
- * the hardcoded TX_POW_MIN_DIFFICULTY constant, which is the protocol floor.
- */
-
-import { TX_POW_MIN_DIFFICULTY } from './constants.js';
-
-export interface TxPowParams {
-  minTxPowWork: string;
-}
-
-function hexToBytes(hex: string): Uint8Array {
-  const h = hex.startsWith('0x') ? hex.slice(2) : hex;
-  const out = new Uint8Array(h.length / 2);
-  for (let i = 0; i < h.length; i += 2) {
-    out[i / 2] = parseInt(h.slice(i, i + 2), 16);
-  }
-  return out;
-}
-
-/**
- * Fetch the current minimum TxPoW work from the Axia API.
- *
- * Falls back to TX_POW_MIN_DIFFICULTY (the hardcoded protocol floor) on any
- * error: network failure, timeout, or malformed response.
- *
- * @param axiaBaseUrl  Base URL of the Axia API, e.g. "https://api.axia.to"
- * @param timeoutMs    Request timeout in ms (default: 3000)
- */
-export async function fetchTxPowTarget(
-  axiaBaseUrl: string,
-  timeoutMs = 3000
-): Promise<Uint8Array> {
-  try {
-    const base = axiaBaseUrl.replace(/\/$/, '');
-    const url = `${base}/v1/wallet/txpow-params`;
-
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-
-    let response: Response;
-    try {
-      response = await fetch(url, { signal: controller.signal });
-    } finally {
-      clearTimeout(timer);
-    }
-
-    if (!response.ok) {
-      throw new Error(`HTTP ${response.status}`);
-    }
-
-    const data = (await response.json()) as TxPowParams;
-    if (typeof data.minTxPowWork !== 'string') {
-      throw new Error('Missing minTxPowWork field');
-    }
-
-    const clean = data.minTxPowWork.replace('0x', '').replace(/\s/g, '');
-    if (clean.length !== 64) {
-      throw new Error(`Invalid minTxPowWork length: ${clean.length} (expected 64 hex chars)`);
-    }
-
-    return hexToBytes(clean);
-  } catch {
-    return new Uint8Array(TX_POW_MIN_DIFFICULTY);
-  }
-}

package/src/index.ts

@@ -1,56 +0,0 @@
-/**
- * @totemsdk/txpow
- *
- * TxPoW envelope serialization and proof-of-work mining for the Minima protocol.
- *
- * USAGE — MEG-side mining (byte-identical to extension current behaviour):
- *   const txpow = serializeTxPoW(txBytes, witnessBytes);
- *   // Submit to Axia: node re-mines with correct difficulty
- *
- * USAGE — Local mining:
- *   const target  = await fetchTxPowTarget(axiaBaseUrl);
- *   const txBody  = serializeTxBody(txBytes, witnessBytes, { txnDifficulty: target });
- *   const result  = await mineTxPoW(txBody, target);
- *   const txpow   = concat(result.minedHeaderBytes, new Uint8Array([0x01]), txBody);
- *
- * USAGE — Verify (relay nodes):
- *   const check = verifyProofOfWork(txpowId, mTxnDifficulty);
- *   if (!check.valid) drop(check.reason);
- */
-
-export {
-  serializeTxHeader,
-  serializeTxBody,
-  serializeTxPoW,
-  computeTxPoWId,
-  type TxHeaderOptions,
-  type TxBodyOptions,
-  type TxPoWOptions,
-} from './serialization.js';
-
-export {
-  MAX_HASH,
-  ZERO_HASH,
-  TX_POW_MIN_DIFFICULTY,
-  CASCADE_LEVELS,
-  MAIN_NET_CHAIN_ID,
-} from './constants.js';
-
-export { serializeMagic } from './magic.js';
-
-export {
-  mineTxPoW,
-  isLessThan,
-  type MineResult,
-  type MineOptions,
-} from './mine.js';
-
-export { fetchTxPowTarget, type TxPowParams } from './difficulty.js';
-
-export { verifyProofOfWork, verifyTxPoWWork, type VerifyResult } from './verify.js';
-
-export {
-  calibrateHashRate,
-  estimateMiningCost,
-  type MiningEstimate,
-} from './calibrate.js';

package/src/magic.ts

@@ -1,37 +0,0 @@
-/**
- * magic.ts — Serialize the Minima Magic struct.
- *
- * Ported from the extension's MinimaTransactionBuilder.ts::serializeMagic().
- * Matches Magic.writeDataStream() in Java exactly.
- *
- * Magic contains two copies of 4 fields (current + desired parameters):
- *   maxTxPoWSize  (MiniNumber)
- *   maxKISSVMOps  (MiniNumber)
- *   maxTxnPerBlock(MiniNumber)
- *   minTxPoWWork  (MiniData — 32 bytes)
- *
- * Default values from Magic.java:
- *   maxTxPoWSize  = 65536
- *   maxKISSVMOps  = 1024
- *   maxTxnPerBlock = 256
- *   minTxPoWWork  = MAX_HASH (all 0xFF, 32 bytes) — placeholder in fresh TxPoW
- */
-
-import { writeMiniNumber, writeMiniData, concat } from '@totemsdk/core';
-import { MAX_HASH } from './constants.js';
-
-export function serializeMagic(): Uint8Array {
-  const parts: Uint8Array[] = [];
-
-  parts.push(writeMiniNumber(65536n));
-  parts.push(writeMiniNumber(1024n));
-  parts.push(writeMiniNumber(256n));
-  parts.push(writeMiniData(MAX_HASH));
-
-  parts.push(writeMiniNumber(65536n));
-  parts.push(writeMiniNumber(1024n));
-  parts.push(writeMiniNumber(256n));
-  parts.push(writeMiniData(MAX_HASH));
-
-  return concat(...parts);
-}