@totemsdk/core 1.0.8 → 1.0.10

package/src/__tests__/Streamable.parity.test.ts

@@ -1,422 +0,0 @@
-/**
- * Streamable.parity.test.ts - Byte-for-Byte Java Parity Tests
- * 
- * These tests validate that our TypeScript serialization produces
- * byte-exact output matching Minima's Java implementation.
- * 
- * JAVA REFERENCE FILES (from attached_assets):
- * - MiniNumber_1767465037473.java: MiniNumber.writeDataStream()
- * - MiniData_1767465051037.java: MiniData.writeDataStream(), writeHashToStream()
- * - MMRData_1768742834148.java: MMRData.writeDataStream()
- * - MMRProof_1768740810861.java: MMRProof.writeDataStream(), MMRProofChunk.writeDataStream()
- * - SignatureProof_1768848582024.java: SignatureProof.writeDataStream()
- * - Signature_1767887681489.java: Signature.writeDataStream()
- * - Witness_1766887812428.java: Witness.writeDataStream()
- * 
- * Created: 2026-01-26
- * Purpose: Gate all serialization changes with Java parity validation
- */
-
-// Jest test suite (SDK uses Jest, not Vitest)
-import {
-  hexToBytes,
-  bytesToHex,
-  concat,
-  writeMiniByte,
-  writeMiniData,
-  writeMiniNumber,
-  writeHashToStream,
-  writeMMREntryNumber,
-  bigIntToByteArray,
-  writeMMRData,
-  writeMMRProofChunk,
-  writeMMRProof,
-  writeSignatureProof,
-  writeSignature,
-  writeWitness,
-  writeHierarchicalWitness,
-  type MMRData,
-  type MMRProofChunk,
-  type MMRProof,
-  type SignatureProof,
-  type Signature,
-} from '../Streamable';
-
-/**
- * Helper to compare bytes and show diff on failure
- */
-function expectBytesEqual(actual: Uint8Array, expected: Uint8Array, context: string = '') {
-  const actualHex = bytesToHex(actual);
-  const expectedHex = bytesToHex(expected);
-  if (actualHex !== expectedHex) {
-    console.error(`${context} Mismatch:`);
-    console.error(`  Expected: ${expectedHex} (${expected.length} bytes)`);
-    console.error(`  Actual:   ${actualHex} (${actual.length} bytes)`);
-  }
-  expect(actualHex).toBe(expectedHex);
-}
-
-describe('MiniNumber Serialization (Java Parity)', () => {
-  /**
-   * Java MiniNumber.writeDataStream():
-   *   1 byte: scale (signed)
-   *   1 byte: length of unscaled BigInteger data
-   *   N bytes: unscaled BigInteger in two's complement
-   */
-
-  it('MiniNumber(0) → [0x00, 0x01, 0x00]', () => {
-    const result = writeMiniNumber(0n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x01, 0x00]), 'MiniNumber(0)');
-  });
-
-  it('MiniNumber(1) → [0x00, 0x01, 0x01]', () => {
-    const result = writeMiniNumber(1n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x01, 0x01]), 'MiniNumber(1)');
-  });
-
-  it('MiniNumber(127) → [0x00, 0x01, 0x7F]', () => {
-    const result = writeMiniNumber(127n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x01, 0x7F]), 'MiniNumber(127)');
-  });
-
-  it('MiniNumber(128) → [0x00, 0x02, 0x00, 0x80] (needs leading zero)', () => {
-    const result = writeMiniNumber(128n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x02, 0x00, 0x80]), 'MiniNumber(128)');
-  });
-
-  it('MiniNumber(255) → [0x00, 0x02, 0x00, 0xFF]', () => {
-    const result = writeMiniNumber(255n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x02, 0x00, 0xFF]), 'MiniNumber(255)');
-  });
-
-  it('MiniNumber(256) → [0x00, 0x02, 0x01, 0x00]', () => {
-    const result = writeMiniNumber(256n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x02, 0x01, 0x00]), 'MiniNumber(256)');
-  });
-
-  it('MiniNumber(65535) → [0x00, 0x03, 0x00, 0xFF, 0xFF]', () => {
-    const result = writeMiniNumber(65535n, 0);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x03, 0x00, 0xFF, 0xFF]), 'MiniNumber(65535)');
-  });
-
-  it('MiniNumber with scale=2 (e.g., 123 with 2 decimal places)', () => {
-    const result = writeMiniNumber(123n, 2);
-    expectBytesEqual(result, new Uint8Array([0x02, 0x01, 0x7B]), 'MiniNumber(123, scale=2)');
-  });
-});
-
-describe('MiniData Serialization (Java Parity)', () => {
-  /**
-   * Java MiniData.writeDataStream():
-   *   4 bytes: big-endian int length
-   *   N bytes: raw data
-   */
-
-  it('Empty MiniData → [0x00, 0x00, 0x00, 0x00]', () => {
-    const result = writeMiniData(new Uint8Array(0));
-    expectBytesEqual(result, new Uint8Array([0x00, 0x00, 0x00, 0x00]), 'Empty MiniData');
-  });
-
-  it('MiniData([0xAB]) → [0x00, 0x00, 0x00, 0x01, 0xAB]', () => {
-    const result = writeMiniData(new Uint8Array([0xAB]));
-    expectBytesEqual(result, new Uint8Array([0x00, 0x00, 0x00, 0x01, 0xAB]), 'MiniData(1 byte)');
-  });
-
-  it('MiniData(32-byte hash) → 4-byte len + 32 bytes', () => {
-    const hash = new Uint8Array(32).fill(0xAA);
-    const result = writeMiniData(hash);
-    expect(result.length).toBe(36);
-    expect(result[0]).toBe(0x00);
-    expect(result[1]).toBe(0x00);
-    expect(result[2]).toBe(0x00);
-    expect(result[3]).toBe(0x20); // 32 in hex
-    expect(result[4]).toBe(0xAA);
-    expect(result[35]).toBe(0xAA);
-  });
-});
-
-describe('writeHashToStream (Java Crypto.writeHashToStream Parity)', () => {
-  /**
-   * Java Crypto.writeHashToStream() is same as MiniData.writeDataStream()
-   */
-
-  it('32-byte hash → 4-byte len + 32 bytes', () => {
-    const hash = hexToBytes('0x' + 'AB'.repeat(32));
-    const result = writeHashToStream(hash);
-    expect(result.length).toBe(36);
-    expect(result[3]).toBe(0x20); // length = 32
-  });
-});
-
-describe('MiniByte Serialization (Java Parity)', () => {
-  /**
-   * Java MiniByte.writeDataStream(): single byte
-   */
-
-  it('MiniByte(false) → [0x00]', () => {
-    const result = writeMiniByte(false);
-    expectBytesEqual(result, new Uint8Array([0x00]), 'MiniByte(false)');
-  });
-
-  it('MiniByte(true) → [0x01]', () => {
-    const result = writeMiniByte(true);
-    expectBytesEqual(result, new Uint8Array([0x01]), 'MiniByte(true)');
-  });
-
-  it('MiniByte(0) → [0x00]', () => {
-    const result = writeMiniByte(0);
-    expectBytesEqual(result, new Uint8Array([0x00]), 'MiniByte(0)');
-  });
-
-  it('MiniByte(255) → [0xFF]', () => {
-    const result = writeMiniByte(255);
-    expectBytesEqual(result, new Uint8Array([0xFF]), 'MiniByte(255)');
-  });
-});
-
-describe('BigInt to ByteArray (Java BigInteger.toByteArray Parity)', () => {
-  /**
-   * Java BigInteger.toByteArray() uses two's complement:
-   * - Zero → [0x00]
-   * - Positive with high bit set → leading 0x00 byte
-   */
-
-  it('0n → [0x00]', () => {
-    const result = bigIntToByteArray(0n);
-    expectBytesEqual(result, new Uint8Array([0x00]), 'BigInt(0)');
-  });
-
-  it('1n → [0x01]', () => {
-    const result = bigIntToByteArray(1n);
-    expectBytesEqual(result, new Uint8Array([0x01]), 'BigInt(1)');
-  });
-
-  it('127n → [0x7F]', () => {
-    const result = bigIntToByteArray(127n);
-    expectBytesEqual(result, new Uint8Array([0x7F]), 'BigInt(127)');
-  });
-
-  it('128n → [0x00, 0x80] (two\'s complement needs leading zero)', () => {
-    const result = bigIntToByteArray(128n);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x80]), 'BigInt(128)');
-  });
-
-  it('255n → [0x00, 0xFF]', () => {
-    const result = bigIntToByteArray(255n);
-    expectBytesEqual(result, new Uint8Array([0x00, 0xFF]), 'BigInt(255)');
-  });
-
-  it('256n → [0x01, 0x00]', () => {
-    const result = bigIntToByteArray(256n);
-    expectBytesEqual(result, new Uint8Array([0x01, 0x00]), 'BigInt(256)');
-  });
-
-  it('32767n → [0x7F, 0xFF]', () => {
-    const result = bigIntToByteArray(32767n);
-    expectBytesEqual(result, new Uint8Array([0x7F, 0xFF]), 'BigInt(32767)');
-  });
-
-  it('32768n → [0x00, 0x80, 0x00] (needs leading zero)', () => {
-    const result = bigIntToByteArray(32768n);
-    expectBytesEqual(result, new Uint8Array([0x00, 0x80, 0x00]), 'BigInt(32768)');
-  });
-});
-
-describe('MMREntryNumber Serialization (Java Parity)', () => {
-  /**
-   * Java MMREntryNumber.writeDataStream():
-   *   MiniNumber for scale (always 0 for integers)
-   *   MiniData for unscaled BigInteger value
-   * 
-   * For value=0, scale=0:
-   *   [00 01 00]           - MiniNumber: scale=0, len=1, data=0x00
-   *   [00 00 00 01 00]     - MiniData: len=1, data=0x00
-   */
-
-  it('MMREntryNumber(0) → MiniNumber(0) + MiniData([0x00])', () => {
-    const result = writeMMREntryNumber(0n, 0);
-    const expected = concat(
-      new Uint8Array([0x00, 0x01, 0x00]),      // MiniNumber for scale=0
-      new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x00]) // MiniData for value=0
-    );
-    expectBytesEqual(result, expected, 'MMREntryNumber(0)');
-  });
-
-  it('MMREntryNumber(1) → MiniNumber(0) + MiniData([0x01])', () => {
-    const result = writeMMREntryNumber(1n, 0);
-    const expected = concat(
-      new Uint8Array([0x00, 0x01, 0x00]),      // MiniNumber for scale=0
-      new Uint8Array([0x00, 0x00, 0x00, 0x01, 0x01]) // MiniData for value=1
-    );
-    expectBytesEqual(result, expected, 'MMREntryNumber(1)');
-  });
-});
-
-// ============================================================
-// MMR STRUCTURE SERIALIZATION TESTS
-// ============================================================
-
-describe('MMRData Serialization (Java Parity)', () => {
-  it('MMRData with 32-byte hash and value=0', () => {
-    const hash = new Uint8Array(32).fill(0xAA);
-    const mmrData: MMRData = { data: hash, value: 0n };
-    const result = writeMMRData(mmrData);
-    
-    // Expected: writeHashToStream(32 bytes) + MiniNumber(0)
-    // = [00 00 00 20] + <32 bytes> + [00 01 00]
-    expect(result.length).toBe(4 + 32 + 3); // 39 bytes
-    expect(result[0]).toBe(0x00); // length high byte
-    expect(result[3]).toBe(0x20); // length = 32
-    expect(result[4]).toBe(0xAA); // first hash byte
-    expect(result[35]).toBe(0xAA); // last hash byte
-    expect(result[36]).toBe(0x00); // MiniNumber scale
-    expect(result[37]).toBe(0x01); // MiniNumber length
-    expect(result[38]).toBe(0x00); // MiniNumber value = 0
-  });
-
-  it('MMRData with value=1', () => {
-    const hash = new Uint8Array(32).fill(0x00);
-    const mmrData: MMRData = { data: hash, value: 1n };
-    const result = writeMMRData(mmrData);
-    
-    expect(result.length).toBe(39);
-    expect(result[38]).toBe(0x01); // MiniNumber value = 1
-  });
-});
-
-describe('MMRProofChunk Serialization (Java Parity)', () => {
-  it('MMRProofChunk(isLeft=true)', () => {
-    const hash = new Uint8Array(32).fill(0xBB);
-    const chunk: MMRProofChunk = {
-      isLeft: true,
-      mmrData: { data: hash, value: 0n }
-    };
-    const result = writeMMRProofChunk(chunk);
-    
-    // Expected: MiniByte(1) + MMRData
-    // = [01] + 39 bytes = 40 bytes
-    expect(result.length).toBe(40);
-    expect(result[0]).toBe(0x01); // isLeft = true
-    expect(result[1]).toBe(0x00); // MMRData hash length high byte
-  });
-
-  it('MMRProofChunk(isLeft=false)', () => {
-    const hash = new Uint8Array(32).fill(0xCC);
-    const chunk: MMRProofChunk = {
-      isLeft: false,
-      mmrData: { data: hash, value: 0n }
-    };
-    const result = writeMMRProofChunk(chunk);
-    
-    expect(result[0]).toBe(0x00); // isLeft = false
-  });
-});
-
-describe('MMRProof Serialization (Java Parity)', () => {
-  it('Empty MMRProof with blockTime=0', () => {
-    const proof: MMRProof = { blockTime: 0n, chunks: [] };
-    const result = writeMMRProof(proof);
-    
-    // Expected: MiniNumber(0) + MiniNumber(0)
-    // = [00 01 00] + [00 01 00] = 6 bytes
-    expectBytesEqual(result, concat(
-      new Uint8Array([0x00, 0x01, 0x00]), // blockTime = 0
-      new Uint8Array([0x00, 0x01, 0x00])  // length = 0
-    ), 'Empty MMRProof');
-  });
-
-  it('MMRProof with 1 chunk', () => {
-    const hash = new Uint8Array(32).fill(0xDD);
-    const proof: MMRProof = {
-      blockTime: 0n,
-      chunks: [{
-        isLeft: true,
-        mmrData: { data: hash, value: 0n }
-      }]
-    };
-    const result = writeMMRProof(proof);
-    
-    // Expected: MiniNumber(0) + MiniNumber(1) + chunk(40 bytes)
-    // = 3 + 3 + 40 = 46 bytes
-    expect(result.length).toBe(46);
-    expect(result[5]).toBe(0x01); // length = 1
-  });
-});
-
-describe('SignatureProof Serialization (Java Parity)', () => {
-  it('SignatureProof with 32-byte pubkey, empty proof', () => {
-    const pubKey = new Uint8Array(32).fill(0x11);
-    const signature = new Uint8Array(1088).fill(0x22);
-    const sigProof: SignatureProof = {
-      leafPubkey: pubKey,
-      signature: signature,
-      mmrProof: { blockTime: 0n, chunks: [] }
-    };
-    const result = writeSignatureProof(sigProof);
-    
-    // Expected: MiniData(32) + MiniData(1088) + MMRProof(6)
-    // = (4+32) + (4+1088) + 6 = 36 + 1092 + 6 = 1134 bytes
-    expect(result.length).toBe(1134);
-    expect(result[3]).toBe(0x20); // pubkey length = 32
-    // Signature length starts at byte 36 (after 4+32 pubkey bytes)
-    // 1088 = 0x00000440 in big-endian
-    expect(result[36]).toBe(0x00); // signature length byte 0
-    expect(result[37]).toBe(0x00); // signature length byte 1
-    expect(result[38]).toBe(0x04); // signature length byte 2 (1088 = 0x0440)
-    expect(result[39]).toBe(0x40); // signature length byte 3
-  });
-});
-
-describe('Signature Serialization (Java Parity)', () => {
-  it('Empty Signature (no proofs)', () => {
-    const sig: Signature = { proofs: [] };
-    const result = writeSignature(sig);
-    
-    // Expected: MiniNumber(0) = [00 01 00]
-    expectBytesEqual(result, new Uint8Array([0x00, 0x01, 0x00]), 'Empty Signature');
-  });
-
-  it('Signature with 1 proof', () => {
-    const pubKey = new Uint8Array(32).fill(0x33);
-    const signature = new Uint8Array(1088).fill(0x44);
-    const sig: Signature = {
-      proofs: [{
-        leafPubkey: pubKey,
-        signature: signature,
-        mmrProof: { blockTime: 0n, chunks: [] }
-      }]
-    };
-    const result = writeSignature(sig);
-    
-    // Expected: MiniNumber(1) + SignatureProof(1134)
-    // = 3 + 1134 = 1137 bytes
-    expect(result.length).toBe(1137);
-    expect(result[2]).toBe(0x01); // length = 1
-  });
-});
-
-describe('Witness/HierarchicalWitness Serialization (Java Parity)', () => {
-  it('Empty Witness (no proofs)', () => {
-    const witness = {
-      signatures: [],
-      coinProofs: [],
-      scriptProofs: []
-    };
-    const result = writeWitness(witness);
-    
-    // Expected: 3x MiniNumber(0) = [00 01 00] [00 01 00] [00 01 00]
-    expectBytesEqual(result, concat(
-      new Uint8Array([0x00, 0x01, 0x00]),
-      new Uint8Array([0x00, 0x01, 0x00]),
-      new Uint8Array([0x00, 0x01, 0x00])
-    ), 'Empty Witness');
-  });
-
-  it('Empty HierarchicalWitness', () => {
-    const bundle = { signatures: [] };
-    const result = writeHierarchicalWitness(bundle);
-    
-    // Expected: MiniNumber(0) = [00 01 00]
-    expectBytesEqual(result, new Uint8Array([0x00, 0x01, 0x00]), 'Empty HierarchicalWitness');
-  });
-});

package/src/__tests__/perAddressDerivation.parity.test.ts

@@ -1,152 +0,0 @@
-/**
- * Parity test: Per-address key derivation matching Minima Wallet.java
- * 
- * Verifies that derivePerAddressSeed() matches Minima Wallet.createNewKey():
- *   MiniData modifier = new MiniData(new BigInteger(Integer.toString(numkeys)));
- *   MiniData privseed = Crypto.getInstance().hashObjects(baseSeed, modifier);
- *   TreeKey treekey = TreeKey.createDefault(privseed);
- * 
- * Created: 2026-02-05
- * Purpose: Validate per-address key derivation matches Minima Wallet.java
- */
-
-import { derivePerAddressSeed, indexToMiniDataBytes } from '../javaStreamables';
-import { TreeKey, createPerAddressTreeKey, deriveAddressPublicKey, getRootPublicKey, verifyTreeSignature } from '../treekey';
-
-// Test seed (same as Java test)
-const TEST_SEED = new Uint8Array([
-  0x51, 0xD9, 0xF4, 0x03, 0x27, 0x1E, 0x26, 0x72,
-  0x29, 0xB6, 0xC2, 0xA9, 0x5C, 0x5E, 0xAE, 0xD5,
-  0x27, 0x84, 0x6A, 0x1A, 0xF8, 0x9F, 0x8B, 0x1C,
-  0xF5, 0x57, 0x4B, 0x0E, 0x79, 0xA4, 0x9C, 0xF1
-]);
-
-function toHex(bytes: Uint8Array): string {
-  return '0x' + Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('').toUpperCase();
-}
-
-describe('Per-Address Key Derivation (Minima Wallet Parity)', () => {
-  // Expected values from Java TestPerAddressKeyDerivation.java
-  const javaExpected = [
-    { index: 0, modifier: '0x00', privSeed: '0x6DD2281FD93037819358EA2DCC27C8DE4F358EB2DC17D9C5907B500184DAA172', pubKey: '0x75C8EE428AC72E1D7A4A7A7E02A6E7B8BEE4F7281B73C0199BBC0CDD59B05C88' },
-    { index: 1, modifier: '0x01', privSeed: '0x3BAC5E60BA11049C1BAA2F065F9C21F736F3E30F37F7213EE9A37BF755AE83E5', pubKey: '0xD008FC735BC7A8FB4912584F61F7F8D9469E4146128985209B0EF5048BBEA215' },
-    { index: 2, modifier: '0x02', privSeed: '0xF63171651D6110F9DD086EB3AC3D35CFE41DA8B504DD81C9575781C02F8EC6B0', pubKey: '0xBBC3D6F727CFD1D413CE152830F626EC89AC3435144A86BF932E6D5C0DB67BDF' },
-    { index: 3, modifier: '0x03', privSeed: '0x65EFC1CC40BF30127B55F716860EDCB32A2C47F8434A44479A85CE0D2D2A07BA', pubKey: '0x75166F510C0457E3D1C94EA17A89D47EE4A90DBC71D94B06111C34E2AAC91D8C' },
-    { index: 4, modifier: '0x04', privSeed: '0xF9A21A47941E47C4F98D212D98E8D8CC2A5D3AD03D473379F037CF5914433DB7', pubKey: '0xBFB7AD971C3A665F96E2A8BADDF14301DC8EBA2E45AEEA34AF85EC428F39F835' },
-  ];
-
-  describe('indexToMiniDataBytes', () => {
-    it('converts index 0 to 0x00', () => {
-      expect(toHex(indexToMiniDataBytes(0))).toBe('0x00');
-    });
-
-    it('converts index 1 to 0x01', () => {
-      expect(toHex(indexToMiniDataBytes(1))).toBe('0x01');
-    });
-
-    it('converts index 63 to 0x3F', () => {
-      expect(toHex(indexToMiniDataBytes(63))).toBe('0x3F');
-    });
-
-    it('converts index 64 to 0x40', () => {
-      expect(toHex(indexToMiniDataBytes(64))).toBe('0x40');
-    });
-
-    it('converts index 255 to 0xFF', () => {
-      expect(toHex(indexToMiniDataBytes(255))).toBe('0xFF');
-    });
-
-    it('converts index 256 to 0x0100 (2 bytes)', () => {
-      expect(toHex(indexToMiniDataBytes(256))).toBe('0x0100');
-    });
-  });
-
-  describe('derivePerAddressSeed', () => {
-    javaExpected.forEach(({ index, modifier, privSeed }) => {
-      it(`derives correct private seed for address ${index}`, () => {
-        const modifierBytes = indexToMiniDataBytes(index);
-        expect(toHex(modifierBytes)).toBe(modifier);
-
-        const derivedSeed = derivePerAddressSeed(TEST_SEED, index);
-        expect(toHex(derivedSeed)).toBe(privSeed);
-      });
-    });
-  });
-
-  describe('Full address public key derivation', () => {
-    javaExpected.forEach(({ index, pubKey }) => {
-      it(`derives correct public key for address ${index}`, () => {
-        // Step 1: Derive private seed for this address
-        const privSeed = derivePerAddressSeed(TEST_SEED, index);
-        
-        // Step 2: Create TreeKey from private seed (size=64, depth=3 matches TreeKey.createDefault)
-        const treeKey = new TreeKey(privSeed, 64, 3);
-        
-        // Step 3: Get public key (MMR root)
-        const derivedPubKey = treeKey.getPublicKey();
-        
-        expect(toHex(derivedPubKey)).toBe(pubKey);
-      });
-    });
-  });
-
-  describe('createPerAddressTreeKey factory', () => {
-    javaExpected.forEach(({ index, pubKey }) => {
-      test(`factory creates correct TreeKey for address ${index}`, () => {
-        const treeKey = createPerAddressTreeKey(TEST_SEED, index);
-        
-        expect(toHex(treeKey.getPublicKey())).toBe(pubKey);
-        expect(treeKey.getMaxUses()).toBe(64 * 64 * 64);
-      });
-    });
-  });
-
-  describe('deriveAddressPublicKey helper', () => {
-    javaExpected.forEach(({ index, pubKey }) => {
-      test(`derives correct address pubkey for index ${index}`, () => {
-        const addressPubkey = deriveAddressPublicKey(TEST_SEED, index);
-        expect(toHex(addressPubkey)).toBe(pubKey);
-      });
-    });
-  });
-
-  describe('setUses + sign signing flow', () => {
-    test('setUses + sign produces 3 proofs with correct structure', () => {
-      const treeKey = createPerAddressTreeKey(TEST_SEED, 0);
-      const testData = new Uint8Array(32).fill(0xAB);
-      
-      treeKey.setUses(0 * 64 + 0);
-      const signature = treeKey.sign(testData);
-      
-      expect(signature.proofs).toHaveLength(3);
-      expect(signature.proofs[0].leafPubkey).toHaveLength(32);
-      expect(signature.proofs[0].signature).toHaveLength(1088);
-      expect(signature.proofs[1].leafPubkey).toHaveLength(32);
-      expect(signature.proofs[1].signature).toHaveLength(1088);
-      expect(signature.proofs[2].leafPubkey).toHaveLength(32);
-      expect(signature.proofs[2].signature).toHaveLength(1088);
-    });
-
-    test('sign first proof root matches TreeKey root public key', () => {
-      const treeKey = createPerAddressTreeKey(TEST_SEED, 0);
-      const testData = new Uint8Array(32).fill(0xCD);
-      
-      treeKey.setUses(0 * 64 + 0);
-      const signature = treeKey.sign(testData);
-      const proof0Root = getRootPublicKey(signature.proofs[0]);
-      
-      expect(toHex(proof0Root)).toBe(toHex(treeKey.getPublicKey()));
-    });
-
-    test('sign signature verifies correctly', () => {
-      const treeKey = createPerAddressTreeKey(TEST_SEED, 1);
-      const testData = new Uint8Array(32).fill(0xEF);
-      
-      treeKey.setUses(1 * 64 + 1);
-      const signature = treeKey.sign(testData);
-      const isValid = verifyTreeSignature(treeKey.getPublicKey(), testData, signature);
-      
-      expect(isValid).toBe(true);
-    });
-  });
-});

package/src/__tests__/roottree-prepare.test.ts

@@ -1,101 +0,0 @@
-/**
- * RootTree prepare() propagation tests
- *
- * Verifies that TransactionService.prepare() correctly forwards walletMode
- * and perAddressPublicKey in the POST body so the /prepare endpoint can
- * apply RootTree-specific validation and return perAddressScript.
- */
-
-import { TransactionService } from '../tx/TransactionService.js';
-import type { TransactionServiceConfig } from '../tx/TransactionService.js';
-import type { HttpClient } from '../adapters/index.js';
-
-function makeMockHttp(capturedBodies: any[]): HttpClient {
-  return {
-    post: async <T>(_url: string, body: any): Promise<{ ok: boolean; status: number; data: T }> => {
-      capturedBodies.push({ body });
-      return {
-        ok: true,
-        status: 200,
-        data: {
-          addressIndex: 0,
-          l1: 0,
-          l2: 0,
-          leaseToken: 'mock-lease-token',
-          digestTx: '0x' + 'ab'.repeat(32),
-          digestL2: null,
-          digestL3: null,
-          txId: 'tx-mock',
-          rootPublicKey: '0x' + 'ff'.repeat(32),
-          paramSet: 'v2-spec',
-          leaseId: 'lease-mock',
-          leaseTTL: 120000,
-          perAddressScript: 'RETURN SIGNEDBY(0x' + 'ff'.repeat(32) + ')',
-        } as T,
-      };
-    },
-    get: async <T>(): Promise<{ ok: boolean; status: number; data: T }> => ({
-      ok: true, status: 200, data: {} as T,
-    }),
-  };
-}
-
-const config: TransactionServiceConfig = {
-  baseUrl: 'https://api.example.com',
-  apiKey: 'test-api-key',
-  paramSet: 'v2-spec',
-};
-
-const MOCK_ROOT_PK = '0x' + 'aa'.repeat(32);
-const MOCK_PER_ADDR_PK = '0x' + 'bb'.repeat(32);
-
-describe('TransactionService.prepare() — RootTree propagation', () => {
-  it('sends walletMode=AnonTree by default', async () => {
-    const bodies: any[] = [];
-    const svc = new TransactionService(makeMockHttp(bodies), config);
-
-    await svc.prepare(
-      { to: 'MxABC', amount: '1', addressIndex: 0 },
-      MOCK_ROOT_PK
-    );
-
-    expect(bodies).toHaveLength(1);
-    expect(bodies[0].body.walletMode).toBe('AnonTree');
-    expect(bodies[0].body.perAddressPublicKey).toBeNull();
-  });
-
-  it('forwards walletMode=RootTree and perAddressPublicKey in POST body', async () => {
-    const bodies: any[] = [];
-    const svc = new TransactionService(makeMockHttp(bodies), config);
-
-    await svc.prepare(
-      {
-        to: 'MxABC',
-        amount: '1',
-        addressIndex: 0,
-        walletMode: 'RootTree',
-        perAddressPublicKey: MOCK_PER_ADDR_PK,
-      },
-      MOCK_ROOT_PK
-    );
-
-    expect(bodies).toHaveLength(1);
-    const sent = bodies[0].body;
-    expect(sent.walletMode).toBe('RootTree');
-    expect(sent.perAddressPublicKey).toBe(MOCK_PER_ADDR_PK);
-    expect(sent.rootPublicKey).toBe(MOCK_ROOT_PK);
-  });
-
-  it('PrepareResponse includes perAddressScript field from server', async () => {
-    const bodies: any[] = [];
-    const svc = new TransactionService(makeMockHttp(bodies), config);
-
-    const result = await svc.prepare(
-      { to: 'MxABC', amount: '1', addressIndex: 0, walletMode: 'RootTree', perAddressPublicKey: MOCK_PER_ADDR_PK },
-      MOCK_ROOT_PK
-    );
-
-    expect(result.perAddressScript).toBeDefined();
-    expect(typeof result.perAddressScript).toBe('string');
-  });
-});