@openzeppelin/miden-multisig-client 0.17.0-rc.2 → 0.17.0

package/src/transaction.test.ts

@@ -1,142 +0,0 @@
-import { describe, it, expect, vi, beforeAll } from 'vitest';
-
-// Mock Miden SDK before importing transaction module
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  AccountId: { fromHex: vi.fn() },
-  AdviceMap: vi.fn(),
-  Felt: vi.fn().mockImplementation((v) => ({ value: v })),
-  FeltArray: vi.fn().mockImplementation((arr) => arr),
-  Poseidon2: { hashElements: vi.fn() },
-  Signature: { deserialize: vi.fn() },
-  TransactionRequestBuilder: vi.fn().mockImplementation(() => ({
-    withCustomScript: vi.fn().mockReturnThis(),
-    withScriptArg: vi.fn().mockReturnThis(),
-    extendAdviceMap: vi.fn().mockReturnThis(),
-    withAuthArg: vi.fn().mockReturnThis(),
-    build: vi.fn().mockReturnValue({}),
-  })),
-  Word: {
-    fromHex: vi.fn().mockImplementation((hex: string) => ({
-      toHex: () => hex,
-      toFelts: () => [1, 2, 3, 4],
-    })),
-  },
-}));
-
-// Now import the module under test - use dynamic import to ensure mocks are in place
-let normalizeHexWord: typeof import('./utils/encoding.js').normalizeHexWord;
-let signatureHexToBytes: typeof import('./utils/signature.js').signatureHexToBytes;
-let hexToBytes: typeof import('./utils/encoding.js').hexToBytes;
-
-beforeAll(async () => {
-  const encoding = await import('./utils/encoding.js');
-  const sig = await import('./utils/signature.js');
-  normalizeHexWord = encoding.normalizeHexWord;
-  hexToBytes = encoding.hexToBytes;
-  signatureHexToBytes = sig.signatureHexToBytes;
-});
-
-describe('transaction utilities', () => {
-  describe('normalizeHexWord', () => {
-    it('should handle hex without 0x prefix', () => {
-      const result = normalizeHexWord('abc123');
-      expect(result).toBe('0x' + '0'.repeat(58) + 'abc123');
-    });
-
-    it('should handle hex with 0x prefix', () => {
-      const result = normalizeHexWord('0xabc123');
-      expect(result).toBe('0x' + '0'.repeat(58) + 'abc123');
-    });
-
-    it('should handle hex with 0X prefix', () => {
-      const result = normalizeHexWord('0Xabc123');
-      expect(result).toBe('0x' + '0'.repeat(58) + 'abc123');
-    });
-
-    it('should convert to lowercase', () => {
-      const result = normalizeHexWord('0xABC123DEF');
-      expect(result).toBe('0x' + '0'.repeat(55) + 'abc123def');
-    });
-
-    it('should pad to 64 characters', () => {
-      const result = normalizeHexWord('1');
-      expect(result).toBe('0x' + '0'.repeat(63) + '1');
-      expect(result.length).toBe(66); // 0x + 64 chars
-    });
-
-    it('should preserve full 64-char hex', () => {
-      const fullHex = 'a'.repeat(64);
-      const result = normalizeHexWord(fullHex);
-      expect(result).toBe('0x' + fullHex);
-    });
-
-    it('should preserve full 64-char hex with prefix', () => {
-      const fullHex = 'b'.repeat(64);
-      const result = normalizeHexWord('0x' + fullHex);
-      expect(result).toBe('0x' + fullHex);
-    });
-  });
-
-  describe('hexToBytes', () => {
-    it('should convert hex string to Uint8Array', () => {
-      const result = hexToBytes('deadbeef');
-      expect(result).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('should handle 0x prefix', () => {
-      const result = hexToBytes('0xdeadbeef');
-      expect(result).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('should handle empty string', () => {
-      const result = hexToBytes('');
-      expect(result).toEqual(new Uint8Array([]));
-    });
-
-    it('should handle single byte', () => {
-      const result = hexToBytes('ff');
-      expect(result).toEqual(new Uint8Array([0xff]));
-    });
-
-    it('should handle zeros', () => {
-      const result = hexToBytes('00000000');
-      expect(result).toEqual(new Uint8Array([0, 0, 0, 0]));
-    });
-
-    it('should handle mixed case', () => {
-      const result = hexToBytes('DeAdBeEf');
-      expect(result).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-  });
-
-  describe('signatureHexToBytes', () => {
-    it('should prepend auth scheme byte (2 = Falcon Poseidon2)', () => {
-      const result = signatureHexToBytes('deadbeef');
-      expect(result[0]).toBe(2);
-      expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('should prepend auth scheme byte (1 = ECDSA)', () => {
-      const result = signatureHexToBytes('deadbeef', 'ecdsa');
-      expect(result[0]).toBe(1);
-      expect(result.slice(1)).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('should handle 0x prefix', () => {
-      const result = signatureHexToBytes('0xaabbccdd');
-      expect(result[0]).toBe(2);
-      expect(result.slice(1)).toEqual(new Uint8Array([0xaa, 0xbb, 0xcc, 0xdd]));
-    });
-
-    it('should return correct length', () => {
-      const sigHex = 'a'.repeat(128); // 64 bytes
-      const result = signatureHexToBytes(sigHex);
-      expect(result.length).toBe(65); // 64 bytes + 1 prefix byte
-    });
-
-    it('should handle empty signature', () => {
-      const result = signatureHexToBytes('');
-      expect(result).toEqual(new Uint8Array([2]));
-    });
-  });
-});

package/src/types/proposal.test.ts

@@ -1,68 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import {
-  CONSUME_NOTES_METADATA_VERSION_V2,
-  type ConsumeNotesProposalMetadata,
-  MAX_CONSUME_NOTES_METADATA_BYTES,
-  isConsumeNotesV1,
-  isConsumeNotesV2,
-} from './proposal.js';
-
-describe('consume_notes metadata v1/v2 discriminator (issue #229)', () => {
-  it('v1 metadata omits metadataVersion and notes on the wire', () => {
-    const md: ConsumeNotesProposalMetadata = {
-      proposalType: 'consume_notes',
-      description: '',
-      noteIds: ['0xabc', '0xdef'],
-    };
-
-    const json = JSON.parse(JSON.stringify(md));
-    expect(json.metadataVersion).toBeUndefined();
-    expect(json.notes).toBeUndefined();
-    expect(isConsumeNotesV1(md)).toBe(true);
-    expect(isConsumeNotesV2(md)).toBe(false);
-  });
-
-  it('v2 metadata round-trips with discriminator and embedded notes', () => {
-    const md: ConsumeNotesProposalMetadata = {
-      proposalType: 'consume_notes',
-      description: '',
-      noteIds: ['0xabc'],
-      metadataVersion: CONSUME_NOTES_METADATA_VERSION_V2,
-      notes: ['YmFzZTY0Tm90ZQ=='],
-    };
-
-    const json = JSON.stringify(md);
-    const parsed = JSON.parse(json) as ConsumeNotesProposalMetadata;
-    expect(parsed.metadataVersion).toBe(2);
-    expect(parsed.notes).toEqual(['YmFzZTY0Tm90ZQ==']);
-    expect(isConsumeNotesV2(parsed)).toBe(true);
-    expect(isConsumeNotesV1(parsed)).toBe(false);
-  });
-
-  it('explicit metadataVersion === 1 is treated as v1', () => {
-    const md = {
-      proposalType: 'consume_notes',
-      description: '',
-      noteIds: ['0xabc'],
-      metadataVersion: 1 as unknown as 2, // legacy explicit-v1 case
-    } as ConsumeNotesProposalMetadata;
-    expect(isConsumeNotesV1(md)).toBe(true);
-    expect(isConsumeNotesV2(md)).toBe(false);
-  });
-
-  it('unknown future version is neither v1 nor v2; dispatch handles rejection', () => {
-    const md = {
-      proposalType: 'consume_notes',
-      description: '',
-      noteIds: ['0xabc'],
-      metadataVersion: 99 as unknown as 2,
-    } as ConsumeNotesProposalMetadata;
-    expect(isConsumeNotesV1(md)).toBe(false);
-    expect(isConsumeNotesV2(md)).toBe(false);
-  });
-
-  it('pins MAX_CONSUME_NOTES_METADATA_BYTES at 256 KiB', () => {
-    expect(MAX_CONSUME_NOTES_METADATA_BYTES).toBe(256 * 1024);
-    expect(MAX_CONSUME_NOTES_METADATA_BYTES).toBe(262_144);
-  });
-});

package/src/utils/digest.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it, vi, beforeEach } from 'vitest';
-import { AuthDigest } from './digest.js';
-
-vi.mock('@miden-sdk/miden-sdk', () => ({
-  AccountId: {
-    fromHex: vi.fn(() => ({
-      prefix: () => ({ label: 'prefix' }),
-      suffix: () => ({ label: 'suffix' }),
-    })),
-  },
-  Felt: vi.fn().mockImplementation((value: bigint) => ({ value })),
-  FeltArray: vi.fn().mockImplementation((elements: unknown[]) => elements),
-  Word: {
-    fromHex: vi.fn((hex: string) => ({
-      toHex: () => hex,
-      toFelts: () => [],
-    })),
-  },
-  Rpo256: {
-    hashElements: vi.fn().mockReturnValue({
-      toHex: () => '0x' + 'aa'.repeat(32),
-      toFelts: () => [],
-    }),
-  },
-}));
-
-describe('AuthDigest', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  it('uses the legacy 4-felt digest for account auth', async () => {
-    const { FeltArray, Rpo256 } = await import('@miden-sdk/miden-sdk');
-
-    AuthDigest.fromAccountIdWithTimestamp('0x' + 'ab'.repeat(15), 1700000000);
-
-    expect(FeltArray).toHaveBeenCalledWith([
-      { label: 'prefix' },
-      { label: 'suffix' },
-      { value: 1700000000n },
-      { value: 0n },
-    ]);
-    expect(Rpo256.hashElements).toHaveBeenCalledTimes(1);
-  });
-
-  it('includes the request payload hash for request-bound auth', async () => {
-    const { Rpo256 } = await import('@miden-sdk/miden-sdk');
-
-    AuthDigest.fromRequest('0x' + 'ab'.repeat(15), 1700000000, {
-      toBytes: () => new Uint8Array([1, 2, 3, 4]),
-    } as never);
-
-    expect(Rpo256.hashElements).toHaveBeenCalledTimes(2);
-  });
-});

package/src/utils/ecdsa.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { secp256k1 } from '@noble/curves/secp256k1';
-import { keccak_256 } from '@noble/hashes/sha3.js';
-import { EcdsaFormat } from './ecdsa.js';
-import { bytesToHex } from './encoding.js';
-
-describe('EcdsaFormat', () => {
-  describe('normalizeRecoveryByte', () => {
-    it('should normalize v=27 to recovery_id=0', () => {
-      const rHex = 'aa'.repeat(32);
-      const sHex = 'bb'.repeat(32);
-      const sig = `0x${rHex}${sHex}1b`;
-      const result = EcdsaFormat.normalizeRecoveryByte(sig);
-      expect(result).toBe(`0x${rHex}${sHex}00`);
-    });
-
-    it('should normalize v=28 to recovery_id=1', () => {
-      const rHex = 'aa'.repeat(32);
-      const sHex = 'bb'.repeat(32);
-      const sig = `0x${rHex}${sHex}1c`;
-      const result = EcdsaFormat.normalizeRecoveryByte(sig);
-      expect(result).toBe(`0x${rHex}${sHex}01`);
-    });
-
-    it('should pass through v=0 unchanged', () => {
-      const rHex = 'aa'.repeat(32);
-      const sHex = 'bb'.repeat(32);
-      const sig = `0x${rHex}${sHex}00`;
-      const result = EcdsaFormat.normalizeRecoveryByte(sig);
-      expect(result).toBe(sig);
-    });
-
-    it('should pass through 64-byte signature unchanged', () => {
-      const sig = `0x${'ab'.repeat(64)}`;
-      const result = EcdsaFormat.normalizeRecoveryByte(sig);
-      expect(result).toBe(sig);
-    });
-
-    it('should throw on invalid length', () => {
-      expect(() => EcdsaFormat.normalizeRecoveryByte('0x' + 'ab'.repeat(10))).toThrow(
-        'Invalid ECDSA signature length',
-      );
-    });
-
-    it('should handle input without 0x prefix', () => {
-      const rHex = 'aa'.repeat(32);
-      const sHex = 'bb'.repeat(32);
-      const sig = `${rHex}${sHex}1b`;
-      const result = EcdsaFormat.normalizeRecoveryByte(sig);
-      expect(result).toBe(`0x${rHex}${sHex}00`);
-    });
-  });
-
-  describe('compressPublicKey', () => {
-    it('should compress a 65-byte uncompressed key with even y', () => {
-      const x = 'aa'.repeat(32);
-      const yEven = 'bb'.repeat(31) + 'b0';
-      const uncompressed = `0x04${x}${yEven}`;
-      const result = EcdsaFormat.compressPublicKey(uncompressed);
-      expect(result).toBe(`0x02${x}`);
-    });
-
-    it('should compress a 65-byte uncompressed key with odd y', () => {
-      const x = 'aa'.repeat(32);
-      const yOdd = 'bb'.repeat(31) + 'b1';
-      const uncompressed = `0x04${x}${yOdd}`;
-      const result = EcdsaFormat.compressPublicKey(uncompressed);
-      expect(result).toBe(`0x03${x}`);
-    });
-
-    it('should pass through a 33-byte compressed key unchanged', () => {
-      const compressed = `0x02${'aa'.repeat(32)}`;
-      const result = EcdsaFormat.compressPublicKey(compressed);
-      expect(result).toBe(compressed);
-    });
-
-    it('should throw on invalid length', () => {
-      expect(() => EcdsaFormat.compressPublicKey('0x' + 'ab'.repeat(10))).toThrow(
-        'Expected 65-byte uncompressed public key',
-      );
-    });
-
-    it('should throw on 65 bytes without 04 prefix', () => {
-      expect(() => EcdsaFormat.compressPublicKey('0x05' + 'ab'.repeat(64))).toThrow(
-        'Expected 65-byte uncompressed public key',
-      );
-    });
-  });
-
-  describe('isValidPublicKeyPoint', () => {
-    // The secp256k1 generator point G, compressed — a known-valid point.
-    const G = '0x0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798';
-
-    it('accepts a valid compressed secp256k1 point', () => {
-      expect(EcdsaFormat.isValidPublicKeyPoint(G)).toBe(true);
-    });
-
-    it('rejects a valid-length key whose x is off-curve', () => {
-      expect(EcdsaFormat.isValidPublicKeyPoint('0x02' + 'ff'.repeat(32))).toBe(false);
-    });
-
-    it('rejects a valid-length key with a bad prefix byte', () => {
-      expect(EcdsaFormat.isValidPublicKeyPoint('0xff' + 'ab'.repeat(32))).toBe(false);
-    });
-  });
-
-  describe('keccakDigestHex', () => {
-    it('should return 0x-prefixed hex of keccak-256 hash', () => {
-      const result = EcdsaFormat.keccakDigestHex(new Uint8Array(0));
-      expect(result).toMatch(/^0x[a-f0-9]{64}$/);
-    });
-
-    it('should produce correct hash for empty input', () => {
-      const result = EcdsaFormat.keccakDigestHex(new Uint8Array(0));
-      expect(result).toBe('0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470');
-    });
-
-    it('should produce different hashes for different inputs', () => {
-      const a = EcdsaFormat.keccakDigestHex(new Uint8Array([1]));
-      const b = EcdsaFormat.keccakDigestHex(new Uint8Array([2]));
-      expect(a).not.toBe(b);
-    });
-  });
-
-  describe('recoverCompressedPublicKeyHex', () => {
-    const privateKey = new Uint8Array(32).fill(0x11);
-    const message = new Uint8Array([9, 8, 7, 6, 5]);
-
-    function sign(priv: Uint8Array, msg: Uint8Array): Uint8Array {
-      const sig = secp256k1.sign(keccak_256(msg), priv);
-      const out = new Uint8Array(65);
-      out.set(sig.toCompactRawBytes(), 0); // r || s
-      out[64] = sig.recovery; // v
-      return out;
-    }
-
-    it('recovers the compressed public key that produced the signature', () => {
-      const expected = bytesToHex(secp256k1.getPublicKey(privateKey, true));
-      const recovered = EcdsaFormat.recoverCompressedPublicKeyHex(message, sign(privateKey, message));
-      expect(recovered).toBe(expected);
-    });
-
-    it('accepts an Ethereum-style recovery byte (27/28)', () => {
-      const sig = sign(privateKey, message);
-      sig[64] += 27; // 0/1 -> 27/28
-      const expected = bytesToHex(secp256k1.getPublicKey(privateKey, true));
-      expect(EcdsaFormat.recoverCompressedPublicKeyHex(message, sig)).toBe(expected);
-    });
-
-    it('throws when the signature is not 65 bytes', () => {
-      expect(() => EcdsaFormat.recoverCompressedPublicKeyHex(message, new Uint8Array(64))).toThrow(
-        /65-byte signature/,
-      );
-    });
-
-    it('throws on an invalid recovery byte', () => {
-      const sig = sign(privateKey, message);
-      sig[64] = 5;
-      expect(() => EcdsaFormat.recoverCompressedPublicKeyHex(message, sig)).toThrow(
-        /recovery byte must be/,
-      );
-    });
-  });
-});

package/src/utils/encoding.test.ts

@@ -1,233 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  ensureHexPrefix,
-  normalizeHexWord,
-  bytesToHex,
-  hexToBytes,
-  uint8ArrayToBase64,
-  base64ToUint8Array,
-} from './encoding.js';
-
-describe('encoding utilities', () => {
-  describe('ensureHexPrefix', () => {
-    it('adds 0x prefix when missing', () => {
-      expect(ensureHexPrefix('abc123')).toBe('0xabc123');
-    });
-
-    it('preserves existing 0x prefix', () => {
-      expect(ensureHexPrefix('0xabc123')).toBe('0xabc123');
-    });
-
-    it('preserves existing 0X prefix', () => {
-      expect(ensureHexPrefix('0Xabc123')).toBe('0Xabc123');
-    });
-
-    it('handles empty string', () => {
-      expect(ensureHexPrefix('')).toBe('0x');
-    });
-
-    it('handles single character', () => {
-      expect(ensureHexPrefix('a')).toBe('0xa');
-    });
-  });
-
-  describe('normalizeHexWord', () => {
-    it('pads short hex to 64 characters', () => {
-      const result = normalizeHexWord('abc123');
-      expect(result).toBe('0x' + '0'.repeat(58) + 'abc123');
-      expect(result.length).toBe(66); // 0x + 64 chars
-    });
-
-    it('preserves full 64-char hex', () => {
-      const fullHex = 'a'.repeat(64);
-      expect(normalizeHexWord(fullHex)).toBe('0x' + fullHex);
-    });
-
-    it('handles 0x prefix', () => {
-      expect(normalizeHexWord('0xabc')).toBe('0x' + '0'.repeat(61) + 'abc');
-    });
-
-    it('handles 0X prefix', () => {
-      expect(normalizeHexWord('0Xabc')).toBe('0x' + '0'.repeat(61) + 'abc');
-    });
-
-    it('converts to lowercase', () => {
-      expect(normalizeHexWord('ABC')).toBe('0x' + '0'.repeat(61) + 'abc');
-    });
-
-    it('handles empty string', () => {
-      expect(normalizeHexWord('')).toBe('0x' + '0'.repeat(64));
-    });
-
-    it('handles single digit', () => {
-      expect(normalizeHexWord('1')).toBe('0x' + '0'.repeat(63) + '1');
-    });
-
-    it('handles full 64-char hex with prefix', () => {
-      const fullHex = 'b'.repeat(64);
-      expect(normalizeHexWord('0x' + fullHex)).toBe('0x' + fullHex);
-    });
-  });
-
-  describe('bytesToHex', () => {
-    it('converts Uint8Array to hex string', () => {
-      const bytes = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
-      expect(bytesToHex(bytes)).toBe('0xdeadbeef');
-    });
-
-    it('handles empty array', () => {
-      expect(bytesToHex(new Uint8Array([]))).toBe('0x');
-    });
-
-    it('handles single byte', () => {
-      expect(bytesToHex(new Uint8Array([0xff]))).toBe('0xff');
-    });
-
-    it('pads single digit bytes with zero', () => {
-      const bytes = new Uint8Array([0x0a, 0x0b, 0x0c]);
-      expect(bytesToHex(bytes)).toBe('0x0a0b0c');
-    });
-
-    it('handles zeros', () => {
-      const bytes = new Uint8Array([0x00, 0x00, 0x00]);
-      expect(bytesToHex(bytes)).toBe('0x000000');
-    });
-
-    it('handles max byte value', () => {
-      const bytes = new Uint8Array([0xff, 0xff]);
-      expect(bytesToHex(bytes)).toBe('0xffff');
-    });
-
-    it('handles long arrays', () => {
-      const bytes = new Uint8Array(32).fill(0xaa);
-      const result = bytesToHex(bytes);
-      expect(result).toBe('0x' + 'aa'.repeat(32));
-    });
-  });
-
-  describe('hexToBytes', () => {
-    it('converts hex string to Uint8Array', () => {
-      expect(hexToBytes('deadbeef')).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('handles 0x prefix', () => {
-      expect(hexToBytes('0xdeadbeef')).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('handles 0X prefix', () => {
-      expect(hexToBytes('0Xdeadbeef')).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('handles empty string', () => {
-      expect(hexToBytes('')).toEqual(new Uint8Array([]));
-    });
-
-    it('handles empty with prefix', () => {
-      expect(hexToBytes('0x')).toEqual(new Uint8Array([]));
-    });
-
-    it('handles single byte', () => {
-      expect(hexToBytes('ff')).toEqual(new Uint8Array([0xff]));
-    });
-
-    it('handles zeros', () => {
-      expect(hexToBytes('00000000')).toEqual(new Uint8Array([0, 0, 0, 0]));
-    });
-
-    it('handles mixed case', () => {
-      expect(hexToBytes('DeAdBeEf')).toEqual(new Uint8Array([0xde, 0xad, 0xbe, 0xef]));
-    });
-
-    it('handles long hex strings', () => {
-      const hex = 'aa'.repeat(32);
-      const result = hexToBytes(hex);
-      expect(result).toEqual(new Uint8Array(32).fill(0xaa));
-    });
-  });
-
-  describe('roundtrip bytesToHex/hexToBytes', () => {
-    it('survives roundtrip bytes -> hex -> bytes', () => {
-      const original = new Uint8Array([0xde, 0xad, 0xbe, 0xef, 0x01, 0x23, 0x45, 0x67]);
-      const hex = bytesToHex(original);
-      const roundtripped = hexToBytes(hex);
-      expect(roundtripped).toEqual(original);
-    });
-
-    it('survives roundtrip hex -> bytes -> hex', () => {
-      const original = '0xdeadbeef01234567';
-      const bytes = hexToBytes(original);
-      const roundtripped = bytesToHex(bytes);
-      expect(roundtripped).toBe(original);
-    });
-  });
-
-  describe('uint8ArrayToBase64', () => {
-    it('converts Uint8Array to base64', () => {
-      const bytes = new Uint8Array([72, 101, 108, 108, 111]); // "Hello"
-      expect(uint8ArrayToBase64(bytes)).toBe('SGVsbG8=');
-    });
-
-    it('handles empty array', () => {
-      expect(uint8ArrayToBase64(new Uint8Array([]))).toBe('');
-    });
-
-    it('handles binary data', () => {
-      const bytes = new Uint8Array([0xff, 0x00, 0xaa, 0x55]);
-      const base64 = uint8ArrayToBase64(bytes);
-      expect(base64).toBeTruthy();
-      // Verify by round-tripping
-      expect(base64ToUint8Array(base64)).toEqual(bytes);
-    });
-
-    it('handles single byte', () => {
-      const bytes = new Uint8Array([65]); // 'A'
-      expect(uint8ArrayToBase64(bytes)).toBe('QQ==');
-    });
-
-    it('handles bytes requiring padding', () => {
-      const bytes = new Uint8Array([1]);
-      const base64 = uint8ArrayToBase64(bytes);
-      expect(base64).toBe('AQ==');
-    });
-  });
-
-  describe('base64ToUint8Array', () => {
-    it('converts base64 to Uint8Array', () => {
-      const base64 = 'SGVsbG8='; // "Hello"
-      expect(base64ToUint8Array(base64)).toEqual(new Uint8Array([72, 101, 108, 108, 111]));
-    });
-
-    it('handles empty string', () => {
-      expect(base64ToUint8Array('')).toEqual(new Uint8Array([]));
-    });
-
-    it('handles binary data', () => {
-      const base64 = '/wCqVQ=='; // [0xff, 0x00, 0xaa, 0x55]
-      expect(base64ToUint8Array(base64)).toEqual(new Uint8Array([0xff, 0x00, 0xaa, 0x55]));
-    });
-
-    it('handles base64 without padding', () => {
-      const base64 = 'YWJj'; // "abc" - no padding needed
-      expect(base64ToUint8Array(base64)).toEqual(new Uint8Array([97, 98, 99]));
-    });
-  });
-
-  describe('roundtrip uint8ArrayToBase64/base64ToUint8Array', () => {
-    it('survives roundtrip bytes -> base64 -> bytes', () => {
-      const original = new Uint8Array([0, 1, 2, 3, 255, 254, 253, 252]);
-      const base64 = uint8ArrayToBase64(original);
-      const roundtripped = base64ToUint8Array(base64);
-      expect(roundtripped).toEqual(original);
-    });
-
-    it('survives roundtrip for large arrays', () => {
-      const original = new Uint8Array(1000);
-      for (let i = 0; i < 1000; i++) {
-        original[i] = i % 256;
-      }
-      const base64 = uint8ArrayToBase64(original);
-      const roundtripped = base64ToUint8Array(base64);
-      expect(roundtripped).toEqual(original);
-    });
-  });
-});