@btc-vision/transaction 1.8.0-beta.3 → 1.8.0-beta.4

package/test/browser/transaction-signing.test.ts

@@ -0,0 +1,416 @@
+import { describe, expect, it, beforeAll } from 'vitest';
+import { networks, payments, toHex } from '@btc-vision/bitcoin';
+import { type UniversalSigner } from '@btc-vision/ecpair';
+import {
+    TransactionSerializer,
+    TransactionStateCapture,
+    TransactionReconstructor,
+    OfflineTransactionManager,
+    SERIALIZATION_FORMAT_VERSION,
+    isFundingSpecificData,
+    TransactionType,
+    FundingTransaction,
+    EcKeyPair,
+    createSignerMap,
+    createAddressRotation,
+    ChainId,
+    currentConsensus,
+    MessageSigner,
+} from '../../build/opnet.js';
+import type {
+    ReconstructionOptions,
+    ISerializableTransactionState,
+    FundingSpecificData,
+    UTXO,
+} from '../../build/opnet.js';
+
+describe('Browser Transaction Signing', () => {
+    const network = networks.regtest;
+
+    let signer1: UniversalSigner;
+    let signer2: UniversalSigner;
+    let signer3: UniversalSigner;
+    let defaultSigner: UniversalSigner;
+
+    let address1: string;
+    let address2: string;
+    let address3: string;
+    let defaultAddress: string;
+
+    beforeAll(() => {
+        signer1 = EcKeyPair.generateRandomKeyPair(network);
+        signer2 = EcKeyPair.generateRandomKeyPair(network);
+        signer3 = EcKeyPair.generateRandomKeyPair(network);
+        defaultSigner = EcKeyPair.generateRandomKeyPair(network);
+
+        address1 = EcKeyPair.getTaprootAddress(signer1, network);
+        address2 = EcKeyPair.getTaprootAddress(signer2, network);
+        address3 = EcKeyPair.getTaprootAddress(signer3, network);
+        defaultAddress = EcKeyPair.getTaprootAddress(defaultSigner, network);
+    });
+
+    const createTaprootUtxo = (
+        address: string,
+        value: bigint,
+        txId: string = '0'.repeat(64),
+        index: number = 0,
+    ): UTXO => {
+        const p2tr = payments.p2tr({ address, network });
+        return {
+            transactionId: txId,
+            outputIndex: index,
+            value,
+            scriptPubKey: {
+                hex: toHex(p2tr.output as Uint8Array),
+                address,
+            },
+        };
+    };
+
+    describe('Single Transaction Signing', () => {
+        it('should export and sign a funding transaction', async () => {
+            const params = {
+                signer: defaultSigner,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(defaultAddress, 100000n, 'a'.repeat(64), 0)],
+                from: defaultAddress,
+                to: address2,
+                feeRate: 10,
+                priorityFee: 1000n,
+                gasSatFee: 500n,
+                amount: 50000n,
+            };
+
+            const exportedState = OfflineTransactionManager.exportFunding(params);
+            expect(OfflineTransactionManager.validate(exportedState)).toBe(true);
+
+            const signedTxHex = await OfflineTransactionManager.importSignAndExport(
+                exportedState,
+                { signer: defaultSigner },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(typeof signedTxHex).toBe('string');
+            expect(signedTxHex.length).toBeGreaterThan(0);
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+
+        it('should sign using two-step import then sign', async () => {
+            const params = {
+                signer: signer1,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(address1, 80000n, 'b'.repeat(64), 0)],
+                from: address1,
+                to: address2,
+                feeRate: 15,
+                priorityFee: 500n,
+                gasSatFee: 300n,
+                amount: 40000n,
+            };
+
+            const exportedState = OfflineTransactionManager.exportFunding(params);
+
+            const builder = OfflineTransactionManager.importForSigning(exportedState, {
+                signer: signer1,
+            });
+
+            expect(builder).toBeDefined();
+            expect(builder.type).toBe(TransactionType.FUNDING);
+
+            const signedTxHex = await OfflineTransactionManager.signAndExport(builder);
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+    });
+
+    describe('Fee Bumping', () => {
+        it('should sign with bumped fee rate', async () => {
+            const params = {
+                signer: signer2,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(address2, 120000n, 'c'.repeat(64), 0)],
+                from: address2,
+                to: address3,
+                feeRate: 5,
+                priorityFee: 200n,
+                gasSatFee: 100n,
+                amount: 60000n,
+            };
+
+            const originalState = OfflineTransactionManager.exportFunding(params);
+            const bumpedState = OfflineTransactionManager.rebuildWithNewFees(originalState, 25);
+
+            const bumpedInspected = OfflineTransactionManager.inspect(bumpedState);
+            expect(bumpedInspected.baseParams.feeRate).toBeCloseTo(25, 3);
+
+            const signedTxHex = await OfflineTransactionManager.importSignAndExport(
+                bumpedState,
+                { signer: signer2 },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+
+        it('should sign with rebuildSignAndExport convenience method', async () => {
+            const params = {
+                signer: signer3,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(address3, 90000n, 'd'.repeat(64), 0)],
+                from: address3,
+                to: address1,
+                feeRate: 8,
+                priorityFee: 300n,
+                gasSatFee: 150n,
+                amount: 45000n,
+            };
+
+            const originalState = OfflineTransactionManager.exportFunding(params);
+
+            const signedTxHex = await OfflineTransactionManager.rebuildSignAndExport(
+                originalState,
+                40,
+                { signer: signer3 },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+    });
+
+    describe('Multi-UTXO Signing', () => {
+        it('should sign with multiple UTXOs', async () => {
+            const params = {
+                signer: defaultSigner,
+                mldsaSigner: null,
+                network,
+                utxos: [
+                    createTaprootUtxo(defaultAddress, 30000n, 'e'.repeat(64), 0),
+                    createTaprootUtxo(defaultAddress, 40000n, 'f'.repeat(64), 1),
+                    createTaprootUtxo(defaultAddress, 50000n, '1'.repeat(64), 2),
+                ],
+                from: defaultAddress,
+                to: address2,
+                feeRate: 12,
+                priorityFee: 600n,
+                gasSatFee: 400n,
+                amount: 100000n,
+            };
+
+            const exportedState = OfflineTransactionManager.exportFunding(params);
+            const inspected = OfflineTransactionManager.inspect(exportedState);
+            expect(inspected.utxos).toHaveLength(3);
+
+            const signedTxHex = await OfflineTransactionManager.importSignAndExport(
+                exportedState,
+                { signer: defaultSigner },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+    });
+
+    describe('Split Funding', () => {
+        it('should sign split funding transaction', async () => {
+            const params = {
+                signer: defaultSigner,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(defaultAddress, 200000n, '5'.repeat(64), 0)],
+                from: defaultAddress,
+                to: address2,
+                feeRate: 10,
+                priorityFee: 1000n,
+                gasSatFee: 500n,
+                amount: 150000n,
+                splitInputsInto: 3,
+            };
+
+            const exportedState = OfflineTransactionManager.exportFunding(params);
+            const inspected = OfflineTransactionManager.inspect(exportedState);
+            expect(isFundingSpecificData(inspected.typeSpecificData)).toBe(true);
+
+            const fundingData = inspected.typeSpecificData as FundingSpecificData;
+            expect(fundingData.splitInputsInto).toBe(3);
+
+            const signedTxHex = await OfflineTransactionManager.importSignAndExport(
+                exportedState,
+                { signer: defaultSigner },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+    });
+
+    describe('Address Rotation', () => {
+        it('should sign with address rotation', async () => {
+            const signerMap = createSignerMap([
+                [defaultAddress, defaultSigner],
+            ]);
+
+            const params = {
+                signer: defaultSigner,
+                mldsaSigner: null,
+                network,
+                utxos: [
+                    createTaprootUtxo(defaultAddress, 50000n, '2'.repeat(64), 0),
+                    createTaprootUtxo(defaultAddress, 60000n, '3'.repeat(64), 1),
+                ],
+                from: defaultAddress,
+                to: address3,
+                feeRate: 10,
+                priorityFee: 500n,
+                gasSatFee: 250n,
+                amount: 80000n,
+                addressRotation: createAddressRotation(signerMap),
+            };
+
+            const exportedState = OfflineTransactionManager.exportFunding(params);
+            const inspected = OfflineTransactionManager.inspect(exportedState);
+            expect(inspected.addressRotationEnabled).toBe(true);
+
+            const signedTxHex = await OfflineTransactionManager.importSignAndExport(
+                exportedState,
+                { signer: defaultSigner, signerMap },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+    });
+
+    describe('Format Round-Trip', () => {
+        it('should sign after base64 -> hex -> base64 conversion', async () => {
+            const params = {
+                signer: signer1,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(address1, 75000n, '6'.repeat(64), 0)],
+                from: address1,
+                to: address3,
+                feeRate: 20,
+                priorityFee: 800n,
+                gasSatFee: 400n,
+                amount: 35000n,
+            };
+
+            const base64State = OfflineTransactionManager.exportFunding(params);
+            const hexState = OfflineTransactionManager.toHex(base64State);
+            expect(/^[0-9a-f]+$/i.test(hexState)).toBe(true);
+
+            const backToBase64 = OfflineTransactionManager.fromHex(hexState);
+            expect(OfflineTransactionManager.validate(base64State)).toBe(true);
+            expect(OfflineTransactionManager.validate(backToBase64)).toBe(true);
+
+            const signedTxHex = await OfflineTransactionManager.importSignAndExport(
+                backToBase64,
+                { signer: signer1 },
+            );
+
+            expect(signedTxHex).toBeDefined();
+            expect(/^[0-9a-f]+$/i.test(signedTxHex)).toBe(true);
+        });
+    });
+
+    describe('State Capture and Reconstruction', () => {
+        it('should capture and reconstruct funding state', () => {
+            const params = {
+                signer: defaultSigner,
+                mldsaSigner: null,
+                network,
+                utxos: [createTaprootUtxo(address1, 100000n)],
+                from: address1,
+                to: address2,
+                feeRate: 10,
+                priorityFee: 1000n,
+                gasSatFee: 500n,
+                amount: 50000n,
+                splitInputsInto: 2,
+            };
+
+            const state = TransactionStateCapture.fromFunding(params);
+            expect(state.header.transactionType).toBe(TransactionType.FUNDING);
+            expect(state.baseParams.from).toBe(address1);
+            expect(isFundingSpecificData(state.typeSpecificData)).toBe(true);
+
+            const options: ReconstructionOptions = { signer: defaultSigner };
+            const builder = TransactionReconstructor.reconstruct(state, options);
+            expect(builder).toBeInstanceOf(FundingTransaction);
+            expect(builder.type).toBe(TransactionType.FUNDING);
+        });
+
+        it('should preserve data through serialize/deserialize round-trip', () => {
+            const originalState: ISerializableTransactionState = {
+                header: {
+                    formatVersion: SERIALIZATION_FORMAT_VERSION,
+                    consensusVersion: currentConsensus,
+                    transactionType: TransactionType.FUNDING,
+                    chainId: ChainId.Bitcoin,
+                    timestamp: 1700000000000,
+                },
+                baseParams: {
+                    from: address1,
+                    to: address2,
+                    feeRate: 12.5,
+                    priorityFee: '1500',
+                    gasSatFee: '750',
+                    networkName: 'regtest',
+                    txVersion: 2,
+                    note: 'deadbeef',
+                    anchor: true,
+                    debugFees: true,
+                },
+                utxos: [{
+                    transactionId: 'a'.repeat(64),
+                    outputIndex: 3,
+                    value: '123456',
+                    scriptPubKeyHex: 'aa',
+                    scriptPubKeyAddress: address1,
+                    redeemScript: 'bb',
+                    witnessScript: 'cc',
+                    nonWitnessUtxo: 'dd',
+                }],
+                optionalInputs: [],
+                optionalOutputs: [],
+                addressRotationEnabled: false,
+                signerMappings: [],
+                typeSpecificData: {
+                    type: TransactionType.FUNDING,
+                    amount: '99999',
+                    splitInputsInto: 3,
+                },
+                precomputedData: {
+                    compiledTargetScript: '1234',
+                    randomBytes: '5678',
+                    estimatedFees: '1000',
+                },
+            };
+
+            const serialized = TransactionSerializer.serialize(originalState);
+            expect(serialized).toBeInstanceOf(Uint8Array);
+
+            const deserialized = TransactionSerializer.deserialize(serialized);
+            expect(deserialized.header.formatVersion).toBe(originalState.header.formatVersion);
+            expect(deserialized.baseParams.from).toBe(originalState.baseParams.from);
+            expect(deserialized.baseParams.feeRate).toBeCloseTo(originalState.baseParams.feeRate, 3);
+            expect(deserialized.utxos).toEqual(originalState.utxos);
+            expect(deserialized.typeSpecificData).toEqual(originalState.typeSpecificData);
+            expect(deserialized.precomputedData).toEqual(originalState.precomputedData);
+        });
+    });
+
+    describe('Message Signing', () => {
+        it('should sign a message with a keypair', () => {
+            const signed = MessageSigner.signMessage(signer1, 'Hello from the browser!');
+
+            expect(signed).toBeDefined();
+            expect(signed.signature).toBeDefined();
+        });
+    });
+});

package/test/buffer-helper.test.ts

@@ -0,0 +1,287 @@
+import { describe, expect, it } from 'vitest';
+import { BufferHelper } from '../build/opnet.js';
+
+describe('BufferHelper', () => {
+    describe('bufferToUint8Array', () => {
+        it('should convert a Buffer to Uint8Array', () => {
+            const buf = Buffer.from([0x01, 0x02, 0x03]);
+            const result = BufferHelper.bufferToUint8Array(buf);
+
+            expect(result).toBeInstanceOf(Uint8Array);
+            expect(Array.from(result)).toEqual([0x01, 0x02, 0x03]);
+        });
+
+        it('should convert a Uint8Array to a new Uint8Array', () => {
+            const input = new Uint8Array([0xaa, 0xbb, 0xcc]);
+            const result = BufferHelper.bufferToUint8Array(input);
+
+            expect(result).toBeInstanceOf(Uint8Array);
+            expect(Array.from(result)).toEqual([0xaa, 0xbb, 0xcc]);
+            // Should be a copy, not the same reference
+            expect(result).not.toBe(input);
+        });
+
+        it('should handle empty input', () => {
+            const result = BufferHelper.bufferToUint8Array(new Uint8Array(0));
+
+            expect(result.length).toBe(0);
+        });
+    });
+
+    describe('uint8ArrayToHex', () => {
+        it('should convert bytes to hex string', () => {
+            const input = new Uint8Array([0xde, 0xad, 0xbe, 0xef]);
+            const result = BufferHelper.uint8ArrayToHex(input);
+
+            expect(result).toBe('deadbeef');
+        });
+
+        it('should handle single byte', () => {
+            const result = BufferHelper.uint8ArrayToHex(new Uint8Array([0x0a]));
+
+            expect(result).toBe('0a');
+        });
+
+        it('should handle empty array', () => {
+            const result = BufferHelper.uint8ArrayToHex(new Uint8Array(0));
+
+            expect(result).toBe('');
+        });
+
+        it('should handle all zeros', () => {
+            const result = BufferHelper.uint8ArrayToHex(new Uint8Array(4));
+
+            expect(result).toBe('00000000');
+        });
+    });
+
+    describe('hexToUint8Array', () => {
+        it('should convert hex string to Uint8Array', () => {
+            const result = BufferHelper.hexToUint8Array('deadbeef');
+
+            expect(Array.from(result)).toEqual([0xde, 0xad, 0xbe, 0xef]);
+        });
+
+        it('should strip 0x prefix', () => {
+            const result = BufferHelper.hexToUint8Array('0xdeadbeef');
+
+            expect(Array.from(result)).toEqual([0xde, 0xad, 0xbe, 0xef]);
+        });
+
+        it('should strip 0X prefix (uppercase)', () => {
+            const result = BufferHelper.hexToUint8Array('0Xabcd');
+
+            expect(Array.from(result)).toEqual([0xab, 0xcd]);
+        });
+
+        it('should pad odd-length hex with leading zero', () => {
+            const result = BufferHelper.hexToUint8Array('abc');
+
+            expect(Array.from(result)).toEqual([0x0a, 0xbc]);
+        });
+
+        it('should handle single character hex', () => {
+            const result = BufferHelper.hexToUint8Array('f');
+
+            expect(Array.from(result)).toEqual([0x0f]);
+        });
+
+        it('should handle empty string', () => {
+            const result = BufferHelper.hexToUint8Array('');
+
+            expect(result.length).toBe(0);
+        });
+
+        it('should handle 0x prefix with empty body', () => {
+            const result = BufferHelper.hexToUint8Array('0x');
+
+            expect(result.length).toBe(0);
+        });
+    });
+
+    describe('hexToUint8Array / uint8ArrayToHex round-trip', () => {
+        it('should round-trip arbitrary bytes', () => {
+            const original = new Uint8Array([0x00, 0xff, 0x80, 0x01, 0x7f]);
+            const hex = BufferHelper.uint8ArrayToHex(original);
+            const restored = BufferHelper.hexToUint8Array(hex);
+
+            expect(Array.from(restored)).toEqual(Array.from(original));
+        });
+
+        it('should round-trip 32-byte value', () => {
+            const hex = 'ab'.repeat(32);
+            const bytes = BufferHelper.hexToUint8Array(hex);
+            const backToHex = BufferHelper.uint8ArrayToHex(bytes);
+
+            expect(backToHex).toBe(hex);
+            expect(bytes.length).toBe(32);
+        });
+    });
+
+    describe('pointerToUint8Array', () => {
+        it('should convert zero pointer to 32-byte zero array', () => {
+            const result = BufferHelper.pointerToUint8Array(0n);
+
+            expect(result.length).toBe(32);
+            expect(Array.from(result)).toEqual(new Array(32).fill(0));
+        });
+
+        it('should convert pointer value 1 to right-padded array', () => {
+            const result = BufferHelper.pointerToUint8Array(1n);
+
+            expect(result.length).toBe(32);
+            expect(result[31]).toBe(1);
+            expect(result[0]).toBe(0);
+        });
+
+        it('should convert max u256 pointer', () => {
+            const maxU256 = (1n << 256n) - 1n;
+            const result = BufferHelper.pointerToUint8Array(maxU256);
+
+            expect(result.length).toBe(32);
+            expect(Array.from(result)).toEqual(new Array(32).fill(0xff));
+        });
+
+        it('should throw for negative pointer', () => {
+            expect(() => BufferHelper.pointerToUint8Array(-1n)).toThrow(
+                'Pointer cannot be negative',
+            );
+        });
+
+        it('should throw for pointer exceeding 256-bit range', () => {
+            const tooBig = 1n << 256n;
+            expect(() => BufferHelper.pointerToUint8Array(tooBig)).toThrow(
+                'Pointer exceeds 256-bit range',
+            );
+        });
+    });
+
+    describe('uint8ArrayToPointer', () => {
+        it('should convert 32-byte zero array to 0n', () => {
+            const result = BufferHelper.uint8ArrayToPointer(new Uint8Array(32));
+
+            expect(result).toBe(0n);
+        });
+
+        it('should convert single byte to bigint', () => {
+            const result = BufferHelper.uint8ArrayToPointer(new Uint8Array([0xff]));
+
+            expect(result).toBe(255n);
+        });
+
+        it('should convert multi-byte value', () => {
+            const result = BufferHelper.uint8ArrayToPointer(new Uint8Array([0x01, 0x00]));
+
+            expect(result).toBe(256n);
+        });
+
+        it('should handle empty array', () => {
+            const result = BufferHelper.uint8ArrayToPointer(new Uint8Array(0));
+
+            expect(result).toBe(0n);
+        });
+
+        it('should round-trip with pointerToUint8Array', () => {
+            const original = 123456789012345678901234567890n;
+            const bytes = BufferHelper.pointerToUint8Array(original);
+            const restored = BufferHelper.uint8ArrayToPointer(bytes);
+
+            expect(restored).toBe(original);
+        });
+
+        it('should round-trip max u256', () => {
+            const maxU256 = (1n << 256n) - 1n;
+            const bytes = BufferHelper.pointerToUint8Array(maxU256);
+            const restored = BufferHelper.uint8ArrayToPointer(bytes);
+
+            expect(restored).toBe(maxU256);
+        });
+    });
+
+    describe('valueToUint8Array', () => {
+        it('should convert zero with default length (32 bytes)', () => {
+            const result = BufferHelper.valueToUint8Array(0n);
+
+            expect(result.length).toBe(32);
+            expect(Array.from(result)).toEqual(new Array(32).fill(0));
+        });
+
+        it('should convert value 1 with default length', () => {
+            const result = BufferHelper.valueToUint8Array(1n);
+
+            expect(result.length).toBe(32);
+            expect(result[31]).toBe(1);
+        });
+
+        it('should convert value with custom length', () => {
+            const result = BufferHelper.valueToUint8Array(0xabcdn, 2);
+
+            expect(result.length).toBe(2);
+            expect(Array.from(result)).toEqual([0xab, 0xcd]);
+        });
+
+        it('should convert to 1-byte length', () => {
+            const result = BufferHelper.valueToUint8Array(255n, 1);
+
+            expect(result.length).toBe(1);
+            expect(result[0]).toBe(0xff);
+        });
+
+        it('should throw for negative value', () => {
+            expect(() => BufferHelper.valueToUint8Array(-1n)).toThrow('Value cannot be negative');
+        });
+
+        it('should throw when value exceeds specified length', () => {
+            expect(() => BufferHelper.valueToUint8Array(256n, 1)).toThrow(
+                'Value exceeds 1-byte range',
+            );
+        });
+
+        it('should throw when value exceeds 32-byte range', () => {
+            const tooBig = 1n << 256n;
+            expect(() => BufferHelper.valueToUint8Array(tooBig)).toThrow(
+                'Value exceeds 32-byte range',
+            );
+        });
+    });
+
+    describe('uint8ArrayToValue', () => {
+        it('should convert single byte', () => {
+            expect(BufferHelper.uint8ArrayToValue(new Uint8Array([0xff]))).toBe(255n);
+        });
+
+        it('should convert multi-byte big-endian', () => {
+            expect(BufferHelper.uint8ArrayToValue(new Uint8Array([0x01, 0x00]))).toBe(256n);
+        });
+
+        it('should convert 32 zero bytes to 0n', () => {
+            expect(BufferHelper.uint8ArrayToValue(new Uint8Array(32))).toBe(0n);
+        });
+
+        it('should handle empty array', () => {
+            expect(BufferHelper.uint8ArrayToValue(new Uint8Array(0))).toBe(0n);
+        });
+
+        it('should round-trip with valueToUint8Array', () => {
+            const original = 0xdeadbeefcafebabe1234567890n;
+            const bytes = BufferHelper.valueToUint8Array(original);
+            const restored = BufferHelper.uint8ArrayToValue(bytes);
+
+            expect(restored).toBe(original);
+        });
+
+        it('should round-trip with custom length', () => {
+            const original = 0xabcdn;
+            const bytes = BufferHelper.valueToUint8Array(original, 8);
+            const restored = BufferHelper.uint8ArrayToValue(bytes);
+
+            expect(restored).toBe(original);
+        });
+    });
+
+    describe('EXPECTED_BUFFER_LENGTH', () => {
+        it('should be 32', () => {
+            expect(BufferHelper.EXPECTED_BUFFER_LENGTH).toBe(32);
+        });
+    });
+});