bitbadgesjs-sdk 0.31.0 → 0.31.2

package/dist/esm/core/transfers.spec.js

@@ -1,6 +1,8 @@
 import { genTestAddress } from './addressLists.spec.js';
-import { createBalanceMapForOffChainBalances, getAllTokenIdsToBeTransferred, getAllBalancesToBeTransferred, getBalancesAfterTransfers } from './transfers.js';
+import { createBalanceMapForOffChainBalances, convertOffChainBalancesMap, getAllTokenIdsToBeTransferred, getAllBalancesToBeTransferred, getBalancesAfterTransfers, getBalanceAfterTransfer, getTransfersFromTransfersWithIncrements, Transfer, TransferWithIncrements } from './transfers.js';
 import { UintRangeArray } from './uintRanges.js';
+import { BigIntify, Stringify } from '../common/string-numbers.js';
+import { ApprovalIdentifierDetails, MerkleProof, ETHSignatureProof } from './misc.js';
 BigInt.prototype.toJSON = function () {
     return this.toString();
 };
@@ -383,6 +385,651 @@ describe('Transfers', () => {
             const allBalances = getAllBalancesToBeTransferred(transfersWithIncrements, currentTime);
             expect(allBalances.length).toBeGreaterThan(0);
         });
+        it('should compute end time as blockTime + duration - 1 (matching on-chain behavior) via slow path', () => {
+            const blockTime = 1000000n;
+            const duration = 50000n;
+            const expectedEnd = blockTime + duration - 1n;
+            const startingBalances = [
+                {
+                    amount: 1n,
+                    tokenIds: [{ start: 1n, end: 10n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            const transfersWithIncrements = [
+                {
+                    from: 'Mint',
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 2n }],
+                            ownershipTimes: [{ start: blockTime, end: expectedEnd }]
+                        }
+                    ],
+                    toAddresses: [genTestAddress(), genTestAddress(), genTestAddress()],
+                    incrementTokenIdsBy: 3n,
+                    incrementOwnershipTimesBy: 0n,
+                    durationFromTimestamp: duration
+                }
+            ];
+            const balancesAfterTransfers = getBalancesAfterTransfers(startingBalances, transfersWithIncrements, blockTime);
+            const remaining = balancesAfterTransfers.filterZeroBalances();
+            expect(remaining.length).toBeGreaterThan(0);
+        });
+        it('should compute end time as blockTime + duration - 1 via fast path', () => {
+            const blockTime = 1000000n;
+            const duration = 50000n;
+            const expectedEnd = blockTime + duration - 1n;
+            const startingBalances = [
+                {
+                    amount: 1n,
+                    tokenIds: [{ start: 1n, end: 100n }],
+                    ownershipTimes: [{ start: blockTime, end: expectedEnd }]
+                }
+            ];
+            const transfersWithIncrements = [
+                {
+                    from: 'Mint',
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: [{ start: 0n, end: 100000n }]
+                        }
+                    ],
+                    toAddresses: [],
+                    toAddressesLength: 100n,
+                    incrementTokenIdsBy: 1n,
+                    incrementOwnershipTimesBy: 0n,
+                    durationFromTimestamp: duration
+                }
+            ];
+            const allBalances = getAllBalancesToBeTransferred(transfersWithIncrements, blockTime);
+            expect(allBalances.length).toBeGreaterThan(0);
+            for (const balance of allBalances) {
+                for (const ownershipTime of balance.ownershipTimes) {
+                    expect(ownershipTime.start).toBe(blockTime);
+                    expect(ownershipTime.end).toBe(expectedEnd);
+                }
+            }
+            const balancesAfterTransfers = getBalancesAfterTransfers(startingBalances, transfersWithIncrements, blockTime);
+            expect(balancesAfterTransfers.filterZeroBalances().length).toBe(0);
+        });
+        it('should NOT match if end time were blockTime + duration (without -1)', () => {
+            const blockTime = 1000000n;
+            const duration = 50000n;
+            const wrongEnd = blockTime + duration;
+            const allBalances = getAllBalancesToBeTransferred([
+                {
+                    from: 'Mint',
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: [{ start: 0n, end: 100000n }]
+                        }
+                    ],
+                    toAddresses: [genTestAddress()],
+                    incrementTokenIdsBy: 0n,
+                    incrementOwnershipTimesBy: 0n,
+                    durationFromTimestamp: duration
+                }
+            ], blockTime);
+            for (const balance of allBalances) {
+                for (const ownershipTime of balance.ownershipTimes) {
+                    expect(ownershipTime.end).not.toBe(wrongEnd);
+                    expect(ownershipTime.end).toBe(wrongEnd - 1n);
+                }
+            }
+        });
+        it('should give all recipients the same duration-based ownership times', () => {
+            const blockTime = 1000000n;
+            const duration = 86400000n;
+            const recipients = [genTestAddress(), genTestAddress(), genTestAddress()];
+            const transfers = getTransfersFromTransfersWithIncrements([
+                {
+                    from: 'Mint',
+                    toAddresses: recipients,
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: [{ start: 0n, end: 100000n }]
+                        }
+                    ],
+                    durationFromTimestamp: duration
+                }
+            ], blockTime);
+            expect(transfers.length).toBe(3);
+            const expectedStart = blockTime;
+            const expectedEnd = blockTime + duration - 1n;
+            for (let i = 0; i < transfers.length; i++) {
+                expect(transfers[i].balances[0].ownershipTimes[0].start).toBe(expectedStart);
+                expect(transfers[i].balances[0].ownershipTimes[0].end).toBe(expectedEnd);
+            }
+        });
+    });
+    describe('Transfer class', () => {
+        it('should construct a Transfer with required fields', () => {
+            const addr1 = genTestAddress();
+            const addr2 = genTestAddress();
+            const transfer = new Transfer({
+                from: addr1,
+                toAddresses: [addr2],
+                balances: [
+                    {
+                        amount: 10n,
+                        tokenIds: [{ start: 1n, end: 5n }],
+                        ownershipTimes: UintRangeArray.FullRanges()
+                    }
+                ]
+            });
+            expect(transfer.from).toBe(addr1);
+            expect(transfer.toAddresses).toEqual([addr2]);
+            expect(transfer.balances.length).toBe(1);
+            expect(transfer.balances[0].amount).toBe(10n);
+        });
+        it('should construct with optional memo', () => {
+            const transfer = new Transfer({
+                from: genTestAddress(),
+                toAddresses: [genTestAddress()],
+                balances: [],
+                memo: 'test memo'
+            });
+            expect(transfer.memo).toBe('test memo');
+        });
+        it('should return empty number field names', () => {
+            const transfer = new Transfer({
+                from: genTestAddress(),
+                toAddresses: [],
+                balances: []
+            });
+            expect(transfer.getNumberFieldNames()).toEqual([]);
+        });
+        it('should convert between number types', () => {
+            const transfer = new Transfer({
+                from: genTestAddress(),
+                toAddresses: [genTestAddress()],
+                balances: [
+                    {
+                        amount: 100n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: [{ start: 1n, end: 1000n }]
+                    }
+                ]
+            });
+            const stringified = transfer.convert(Stringify);
+            expect(stringified.balances[0].amount).toBe('100');
+            expect(stringified.balances[0].tokenIds[0].start).toBe('1');
+            expect(stringified.balances[0].tokenIds[0].end).toBe('10');
+        });
+        it('should handle optional fields being undefined', () => {
+            const transfer = new Transfer({
+                from: genTestAddress(),
+                toAddresses: [],
+                balances: []
+            });
+            expect(transfer.precalculateBalancesFromApproval).toBeUndefined();
+            expect(transfer.merkleProofs).toBeUndefined();
+            expect(transfer.ethSignatureProofs).toBeUndefined();
+            expect(transfer.memo).toBeUndefined();
+            expect(transfer.prioritizedApprovals).toBeUndefined();
+            expect(transfer.onlyCheckPrioritizedCollectionApprovals).toBeUndefined();
+            expect(transfer.onlyCheckPrioritizedIncomingApprovals).toBeUndefined();
+            expect(transfer.onlyCheckPrioritizedOutgoingApprovals).toBeUndefined();
+        });
+    });
+    describe('TransferWithIncrements class', () => {
+        it('should construct with increment fields', () => {
+            const twi = new TransferWithIncrements({
+                from: genTestAddress(),
+                toAddresses: [genTestAddress()],
+                balances: [
+                    {
+                        amount: 1n,
+                        tokenIds: [{ start: 1n, end: 1n }],
+                        ownershipTimes: UintRangeArray.FullRanges()
+                    }
+                ],
+                incrementTokenIdsBy: 1n,
+                incrementOwnershipTimesBy: 0n,
+                toAddressesLength: 100n,
+                durationFromTimestamp: 0n
+            });
+            expect(twi.incrementTokenIdsBy).toBe(1n);
+            expect(twi.incrementOwnershipTimesBy).toBe(0n);
+            expect(twi.toAddressesLength).toBe(100n);
+            expect(twi.durationFromTimestamp).toBe(0n);
+        });
+        it('should return correct number field names', () => {
+            const twi = new TransferWithIncrements({
+                from: genTestAddress(),
+                toAddresses: [],
+                balances: []
+            });
+            expect(twi.getNumberFieldNames()).toEqual([
+                'toAddressesLength',
+                'incrementTokenIdsBy',
+                'incrementOwnershipTimesBy',
+                'durationFromTimestamp'
+            ]);
+        });
+        it('should convert between number types', () => {
+            const twi = new TransferWithIncrements({
+                from: genTestAddress(),
+                toAddresses: [],
+                balances: [
+                    {
+                        amount: 50n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: UintRangeArray.FullRanges()
+                    }
+                ],
+                incrementTokenIdsBy: 5n,
+                toAddressesLength: 20n
+            });
+            const stringified = twi.convert(Stringify);
+            expect(stringified.incrementTokenIdsBy).toBe('5');
+            expect(stringified.toAddressesLength).toBe('20');
+            expect(stringified.balances[0].amount).toBe('50');
+        });
+        it('should handle undefined optional increment fields', () => {
+            const twi = new TransferWithIncrements({
+                from: genTestAddress(),
+                toAddresses: [],
+                balances: []
+            });
+            expect(twi.incrementTokenIdsBy).toBeUndefined();
+            expect(twi.incrementOwnershipTimesBy).toBeUndefined();
+            expect(twi.toAddressesLength).toBeUndefined();
+            expect(twi.durationFromTimestamp).toBeUndefined();
+        });
+    });
+    describe('getBalanceAfterTransfer (single)', () => {
+        it('should subtract a single transfer from balance', () => {
+            const startBalance = [
+                {
+                    amount: 100n,
+                    tokenIds: [{ start: 1n, end: 10n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            const result = getBalanceAfterTransfer(startBalance, 1n, 10n, 1n, 18446744073709551615n, 10n, 1n);
+            expect(result[0].amount).toBe(90n);
+        });
+        it('should multiply amount by numRecipients', () => {
+            const startBalance = [
+                {
+                    amount: 100n,
+                    tokenIds: [{ start: 1n, end: 1n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            const result = getBalanceAfterTransfer(startBalance, 1n, 1n, 1n, 18446744073709551615n, 10n, 5n);
+            expect(result[0].amount).toBe(50n);
+        });
+        it('should throw on underflow without allowUnderflow', () => {
+            const startBalance = [
+                {
+                    amount: 10n,
+                    tokenIds: [{ start: 1n, end: 1n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            expect(() => getBalanceAfterTransfer(startBalance, 1n, 1n, 1n, 18446744073709551615n, 20n, 1n, false)).toThrow();
+        });
+        it('should allow underflow when flag is set', () => {
+            const startBalance = [
+                {
+                    amount: 10n,
+                    tokenIds: [{ start: 1n, end: 1n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            const result = getBalanceAfterTransfer(startBalance, 1n, 1n, 1n, 18446744073709551615n, 20n, 1n, true);
+            expect(result[0].amount).toBe(-10n);
+        });
+        it('should return empty array when balance is fully depleted', () => {
+            const startBalance = [
+                {
+                    amount: 50n,
+                    tokenIds: [{ start: 1n, end: 1n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            const result = getBalanceAfterTransfer(startBalance, 1n, 1n, 1n, 18446744073709551615n, 50n, 1n);
+            const filtered = result.filter((b) => b.amount > 0n);
+            expect(filtered.length).toBe(0);
+        });
+        it('should only subtract from matching token ID range', () => {
+            const startBalance = [
+                {
+                    amount: 100n,
+                    tokenIds: [{ start: 1n, end: 10n }],
+                    ownershipTimes: UintRangeArray.FullRanges()
+                }
+            ];
+            const result = getBalanceAfterTransfer(startBalance, 5n, 5n, 1n, 18446744073709551615n, 50n, 1n);
+            const totalNonZero = result.filter((b) => b.amount > 0n);
+            expect(totalNonZero.length).toBeGreaterThan(0);
+        });
+    });
+    describe('convertOffChainBalancesMap', () => {
+        it('should convert balances map between number types', () => {
+            const bigintMap = {
+                [genTestAddress()]: [
+                    {
+                        amount: 100n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: [{ start: 1n, end: 1000n }]
+                    }
+                ]
+            };
+            const stringMap = convertOffChainBalancesMap(bigintMap, Stringify);
+            const keys = Object.keys(stringMap);
+            expect(keys.length).toBe(1);
+            expect(stringMap[keys[0]][0].amount).toBe('100');
+            expect(stringMap[keys[0]][0].tokenIds[0].start).toBe('1');
+        });
+        it('should handle empty map', () => {
+            const result = convertOffChainBalancesMap({}, Stringify);
+            expect(Object.keys(result).length).toBe(0);
+        });
+        it('should handle map with multiple addresses', () => {
+            const addr1 = genTestAddress();
+            const addr2 = genTestAddress();
+            const bigintMap = {
+                [addr1]: [
+                    {
+                        amount: 50n,
+                        tokenIds: [{ start: 1n, end: 5n }],
+                        ownershipTimes: UintRangeArray.FullRanges()
+                    }
+                ],
+                [addr2]: [
+                    {
+                        amount: 200n,
+                        tokenIds: [{ start: 10n, end: 20n }],
+                        ownershipTimes: UintRangeArray.FullRanges()
+                    }
+                ]
+            };
+            const stringMap = convertOffChainBalancesMap(bigintMap, Stringify);
+            expect(stringMap[addr1][0].amount).toBe('50');
+            expect(stringMap[addr2][0].amount).toBe('200');
+        });
+    });
+    describe('createBalanceMapForOffChainBalances - error paths', () => {
+        it('should throw when durationFromTimestamp is used', () => {
+            const transfers = [
+                {
+                    from: 'Mint',
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: UintRangeArray.FullRanges()
+                        }
+                    ],
+                    toAddresses: [genTestAddress()],
+                    durationFromTimestamp: 86400000n
+                }
+            ];
+            expect(() => createBalanceMapForOffChainBalances(transfers)).toThrow('durationFromTimestamp is not supported in createBalanceMapForOffChainBalances');
+        });
+    });
+    describe('getTransfersFromTransfersWithIncrements', () => {
+        it('should return single transfer when no increments', () => {
+            const addr1 = genTestAddress();
+            const addr2 = genTestAddress();
+            const transfers = getTransfersFromTransfersWithIncrements([
+                {
+                    from: addr1,
+                    toAddresses: [addr2],
+                    balances: [
+                        {
+                            amount: 10n,
+                            tokenIds: [{ start: 1n, end: 10n }],
+                            ownershipTimes: UintRangeArray.FullRanges()
+                        }
+                    ]
+                }
+            ], 0n);
+            expect(transfers.length).toBe(1);
+            expect(transfers[0].toAddresses).toEqual([addr2]);
+        });
+        it('should create N transfers when incrementTokenIdsBy is set', () => {
+            const recipients = [genTestAddress(), genTestAddress(), genTestAddress()];
+            const transfers = getTransfersFromTransfersWithIncrements([
+                {
+                    from: 'Mint',
+                    toAddresses: recipients,
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: UintRangeArray.FullRanges()
+                        }
+                    ],
+                    incrementTokenIdsBy: 1n
+                }
+            ], 0n);
+            expect(transfers.length).toBe(3);
+            expect(transfers[0].balances[0].tokenIds[0].start).toBe(1n);
+            expect(transfers[0].balances[0].tokenIds[0].end).toBe(1n);
+            expect(transfers[1].balances[0].tokenIds[0].start).toBe(2n);
+            expect(transfers[2].balances[0].tokenIds[0].start).toBe(3n);
+        });
+        it('should create N transfers when incrementOwnershipTimesBy is set', () => {
+            const recipients = [genTestAddress(), genTestAddress()];
+            const transfers = getTransfersFromTransfersWithIncrements([
+                {
+                    from: 'Mint',
+                    toAddresses: recipients,
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: [{ start: 1000n, end: 2000n }]
+                        }
+                    ],
+                    incrementOwnershipTimesBy: 5000n
+                }
+            ], 0n);
+            expect(transfers.length).toBe(2);
+            expect(transfers[0].balances[0].ownershipTimes[0].start).toBe(1000n);
+            expect(transfers[0].balances[0].ownershipTimes[0].end).toBe(2000n);
+            expect(transfers[1].balances[0].ownershipTimes[0].start).toBe(6000n);
+            expect(transfers[1].balances[0].ownershipTimes[0].end).toBe(7000n);
+        });
+        it('should handle empty transfers array', () => {
+            const transfers = getTransfersFromTransfersWithIncrements([], 0n);
+            expect(transfers.length).toBe(0);
+        });
+        it('should use toAddressesLength over toAddresses.length when both are set', () => {
+            const addr = genTestAddress();
+            const transfers = getTransfersFromTransfersWithIncrements([
+                {
+                    from: 'Mint',
+                    toAddresses: [addr],
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: UintRangeArray.FullRanges()
+                        }
+                    ]
+                }
+            ], 0n);
+            expect(transfers.length).toBe(1);
+        });
+    });
+    describe('Transfer class - proto/JSON serialization', () => {
+        it('should convert to proto and back via fromProto', () => {
+            const addr1 = genTestAddress();
+            const addr2 = genTestAddress();
+            const original = new Transfer({
+                from: addr1,
+                toAddresses: [addr2],
+                balances: [
+                    {
+                        amount: 42n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: [{ start: 1n, end: 1000n }]
+                    }
+                ]
+            });
+            const proto = original.toProto();
+            expect(proto).toBeTruthy();
+            const restored = Transfer.fromProto(proto, BigIntify);
+            expect(restored.from).toBe(addr1);
+            expect(restored.toAddresses).toEqual([addr2]);
+            expect(restored.balances[0].amount).toBe(42n);
+            expect(restored.balances[0].tokenIds[0].start).toBe(1n);
+            expect(restored.balances[0].tokenIds[0].end).toBe(10n);
+        });
+        it('should round-trip through fromJson', () => {
+            const addr1 = genTestAddress();
+            const addr2 = genTestAddress();
+            const original = new Transfer({
+                from: addr1,
+                toAddresses: [addr2],
+                balances: [
+                    {
+                        amount: 10n,
+                        tokenIds: [{ start: 5n, end: 5n }],
+                        ownershipTimes: [{ start: 1n, end: 100n }]
+                    }
+                ],
+                memo: 'hello'
+            });
+            const proto = original.toProto();
+            const jsonVal = proto.toJson();
+            const restored = Transfer.fromJson(jsonVal, BigIntify);
+            expect(restored.from).toBe(addr1);
+            expect(restored.balances[0].amount).toBe(10n);
+            expect(restored.memo).toBe('hello');
+        });
+        it('should round-trip through fromJsonString', () => {
+            const addr1 = genTestAddress();
+            const original = new Transfer({
+                from: addr1,
+                toAddresses: [],
+                balances: [
+                    {
+                        amount: 7n,
+                        tokenIds: [{ start: 3n, end: 3n }],
+                        ownershipTimes: UintRangeArray.FullRanges()
+                    }
+                ]
+            });
+            const jsonStr = original.toProto().toJsonString();
+            const restored = Transfer.fromJsonString(jsonStr, BigIntify);
+            expect(restored.from).toBe(addr1);
+            expect(restored.balances[0].amount).toBe(7n);
+        });
+        it('should construct Transfer with prioritizedApprovals', () => {
+            const addr1 = genTestAddress();
+            const transfer = new Transfer({
+                from: addr1,
+                toAddresses: [],
+                balances: [],
+                prioritizedApprovals: [
+                    new ApprovalIdentifierDetails({
+                        approvalId: 'approval-1',
+                        approvalLevel: 'collection',
+                        approverAddress: '',
+                        version: 0n
+                    })
+                ],
+                onlyCheckPrioritizedCollectionApprovals: true,
+                onlyCheckPrioritizedIncomingApprovals: false,
+                onlyCheckPrioritizedOutgoingApprovals: true
+            });
+            expect(transfer.prioritizedApprovals).toBeDefined();
+            expect(transfer.prioritizedApprovals.length).toBe(1);
+            expect(transfer.prioritizedApprovals[0].approvalId).toBe('approval-1');
+            expect(transfer.onlyCheckPrioritizedCollectionApprovals).toBe(true);
+            expect(transfer.onlyCheckPrioritizedOutgoingApprovals).toBe(true);
+        });
+        it('should convert Transfer with prioritizedApprovals to proto and back', () => {
+            const addr1 = genTestAddress();
+            const transfer = new Transfer({
+                from: addr1,
+                toAddresses: [],
+                balances: [],
+                prioritizedApprovals: [
+                    new ApprovalIdentifierDetails({
+                        approvalId: 'approval-x',
+                        approvalLevel: 'outgoing',
+                        approverAddress: addr1,
+                        version: 0n
+                    })
+                ]
+            });
+            const proto = transfer.toProto();
+            const restored = Transfer.fromProto(proto, BigIntify);
+            expect(restored.prioritizedApprovals).toBeDefined();
+            expect(restored.prioritizedApprovals[0].approvalId).toBe('approval-x');
+        });
+        it('should toBech32Addresses convert address formats', () => {
+            const addr = genTestAddress();
+            const transfer = new Transfer({
+                from: addr,
+                toAddresses: [addr],
+                balances: []
+            });
+            const converted = transfer.toBech32Addresses('bb');
+            expect(converted.from).toBeTruthy();
+            expect(converted.toAddresses.length).toBe(1);
+        });
+        it('should toBech32Addresses with prioritizedApprovals (covers line 107)', () => {
+            const addr = genTestAddress();
+            const transfer = new Transfer({
+                from: addr,
+                toAddresses: [],
+                balances: [],
+                prioritizedApprovals: [
+                    new ApprovalIdentifierDetails({
+                        approvalId: 'test',
+                        approvalLevel: 'collection',
+                        approverAddress: '',
+                        version: 0n
+                    })
+                ]
+            });
+            const converted = transfer.toBech32Addresses('bb');
+            expect(converted.prioritizedApprovals).toBeDefined();
+            expect(converted.prioritizedApprovals.length).toBe(1);
+        });
+        it('should round-trip Transfer with merkleProofs through proto (covers lines 88-89)', () => {
+            const addr = genTestAddress();
+            const transfer = new Transfer({
+                from: addr,
+                toAddresses: [],
+                balances: [],
+                merkleProofs: [
+                    new MerkleProof({
+                        aunts: [],
+                        leaf: 'leaf-value',
+                        leafSignature: 'sig'
+                    })
+                ],
+                ethSignatureProofs: [
+                    new ETHSignatureProof({
+                        nonce: 'nonce-123',
+                        signature: '0x1234'
+                    })
+                ]
+            });
+            const proto = transfer.toProto();
+            const restored = Transfer.fromProto(proto, BigIntify);
+            expect(restored.merkleProofs).toBeDefined();
+            expect(restored.merkleProofs.length).toBe(1);
+            expect(restored.merkleProofs[0].leaf).toBe('leaf-value');
+            expect(restored.ethSignatureProofs).toBeDefined();
+            expect(restored.ethSignatureProofs[0].nonce).toBe('nonce-123');
+        });
     });
 });
 //# sourceMappingURL=transfers.spec.js.map