bitbadgesjs-sdk 0.31.0 → 0.31.2

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

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const addressLists_spec_js_1 = require("./addressLists.spec.js");
 const transfers_js_1 = require("./transfers.js");
 const uintRanges_js_1 = require("./uintRanges.js");
+const string_numbers_js_1 = require("../common/string-numbers.js");
+const misc_js_1 = require("./misc.js");
 BigInt.prototype.toJSON = function () {
     return this.toString();
 };
@@ -385,6 +387,651 @@ describe('Transfers', () => {
             const allBalances = (0, transfers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            const transfersWithIncrements = [
+                {
+                    from: 'Mint',
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 2n }],
+                            ownershipTimes: [{ start: blockTime, end: expectedEnd }]
+                        }
+                    ],
+                    toAddresses: [(0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)()],
+                    incrementTokenIdsBy: 3n,
+                    incrementOwnershipTimesBy: 0n,
+                    durationFromTimestamp: duration
+                }
+            ];
+            const balancesAfterTransfers = (0, transfers_js_1.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 = (0, transfers_js_1.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 = (0, transfers_js_1.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 = (0, transfers_js_1.getAllBalancesToBeTransferred)([
+                {
+                    from: 'Mint',
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: [{ start: 0n, end: 100000n }]
+                        }
+                    ],
+                    toAddresses: [(0, addressLists_spec_js_1.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 = [(0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)()];
+            const transfers = (0, transfers_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const addr2 = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfer = new transfers_js_1.Transfer({
+                from: addr1,
+                toAddresses: [addr2],
+                balances: [
+                    {
+                        amount: 10n,
+                        tokenIds: [{ start: 1n, end: 5n }],
+                        ownershipTimes: uintRanges_js_1.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 transfers_js_1.Transfer({
+                from: (0, addressLists_spec_js_1.genTestAddress)(),
+                toAddresses: [(0, addressLists_spec_js_1.genTestAddress)()],
+                balances: [],
+                memo: 'test memo'
+            });
+            expect(transfer.memo).toBe('test memo');
+        });
+        it('should return empty number field names', () => {
+            const transfer = new transfers_js_1.Transfer({
+                from: (0, addressLists_spec_js_1.genTestAddress)(),
+                toAddresses: [],
+                balances: []
+            });
+            expect(transfer.getNumberFieldNames()).toEqual([]);
+        });
+        it('should convert between number types', () => {
+            const transfer = new transfers_js_1.Transfer({
+                from: (0, addressLists_spec_js_1.genTestAddress)(),
+                toAddresses: [(0, addressLists_spec_js_1.genTestAddress)()],
+                balances: [
+                    {
+                        amount: 100n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: [{ start: 1n, end: 1000n }]
+                    }
+                ]
+            });
+            const stringified = transfer.convert(string_numbers_js_1.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 transfers_js_1.Transfer({
+                from: (0, addressLists_spec_js_1.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 transfers_js_1.TransferWithIncrements({
+                from: (0, addressLists_spec_js_1.genTestAddress)(),
+                toAddresses: [(0, addressLists_spec_js_1.genTestAddress)()],
+                balances: [
+                    {
+                        amount: 1n,
+                        tokenIds: [{ start: 1n, end: 1n }],
+                        ownershipTimes: uintRanges_js_1.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 transfers_js_1.TransferWithIncrements({
+                from: (0, addressLists_spec_js_1.genTestAddress)(),
+                toAddresses: [],
+                balances: []
+            });
+            expect(twi.getNumberFieldNames()).toEqual([
+                'toAddressesLength',
+                'incrementTokenIdsBy',
+                'incrementOwnershipTimesBy',
+                'durationFromTimestamp'
+            ]);
+        });
+        it('should convert between number types', () => {
+            const twi = new transfers_js_1.TransferWithIncrements({
+                from: (0, addressLists_spec_js_1.genTestAddress)(),
+                toAddresses: [],
+                balances: [
+                    {
+                        amount: 50n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: uintRanges_js_1.UintRangeArray.FullRanges()
+                    }
+                ],
+                incrementTokenIdsBy: 5n,
+                toAddressesLength: 20n
+            });
+            const stringified = twi.convert(string_numbers_js_1.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 transfers_js_1.TransferWithIncrements({
+                from: (0, addressLists_spec_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            const result = (0, transfers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            const result = (0, transfers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            expect(() => (0, transfers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            const result = (0, transfers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            const result = (0, transfers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                }
+            ];
+            const result = (0, transfers_js_1.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 = {
+                [(0, addressLists_spec_js_1.genTestAddress)()]: [
+                    {
+                        amount: 100n,
+                        tokenIds: [{ start: 1n, end: 10n }],
+                        ownershipTimes: [{ start: 1n, end: 1000n }]
+                    }
+                ]
+            };
+            const stringMap = (0, transfers_js_1.convertOffChainBalancesMap)(bigintMap, string_numbers_js_1.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 = (0, transfers_js_1.convertOffChainBalancesMap)({}, string_numbers_js_1.Stringify);
+            expect(Object.keys(result).length).toBe(0);
+        });
+        it('should handle map with multiple addresses', () => {
+            const addr1 = (0, addressLists_spec_js_1.genTestAddress)();
+            const addr2 = (0, addressLists_spec_js_1.genTestAddress)();
+            const bigintMap = {
+                [addr1]: [
+                    {
+                        amount: 50n,
+                        tokenIds: [{ start: 1n, end: 5n }],
+                        ownershipTimes: uintRanges_js_1.UintRangeArray.FullRanges()
+                    }
+                ],
+                [addr2]: [
+                    {
+                        amount: 200n,
+                        tokenIds: [{ start: 10n, end: 20n }],
+                        ownershipTimes: uintRanges_js_1.UintRangeArray.FullRanges()
+                    }
+                ]
+            };
+            const stringMap = (0, transfers_js_1.convertOffChainBalancesMap)(bigintMap, string_numbers_js_1.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: uintRanges_js_1.UintRangeArray.FullRanges()
+                        }
+                    ],
+                    toAddresses: [(0, addressLists_spec_js_1.genTestAddress)()],
+                    durationFromTimestamp: 86400000n
+                }
+            ];
+            expect(() => (0, transfers_js_1.createBalanceMapForOffChainBalances)(transfers)).toThrow('durationFromTimestamp is not supported in createBalanceMapForOffChainBalances');
+        });
+    });
+    describe('getTransfersFromTransfersWithIncrements', () => {
+        it('should return single transfer when no increments', () => {
+            const addr1 = (0, addressLists_spec_js_1.genTestAddress)();
+            const addr2 = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfers = (0, transfers_js_1.getTransfersFromTransfersWithIncrements)([
+                {
+                    from: addr1,
+                    toAddresses: [addr2],
+                    balances: [
+                        {
+                            amount: 10n,
+                            tokenIds: [{ start: 1n, end: 10n }],
+                            ownershipTimes: uintRanges_js_1.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 = [(0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)()];
+            const transfers = (0, transfers_js_1.getTransfersFromTransfersWithIncrements)([
+                {
+                    from: 'Mint',
+                    toAddresses: recipients,
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: uintRanges_js_1.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 = [(0, addressLists_spec_js_1.genTestAddress)(), (0, addressLists_spec_js_1.genTestAddress)()];
+            const transfers = (0, transfers_js_1.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 = (0, transfers_js_1.getTransfersFromTransfersWithIncrements)([], 0n);
+            expect(transfers.length).toBe(0);
+        });
+        it('should use toAddressesLength over toAddresses.length when both are set', () => {
+            const addr = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfers = (0, transfers_js_1.getTransfersFromTransfersWithIncrements)([
+                {
+                    from: 'Mint',
+                    toAddresses: [addr],
+                    balances: [
+                        {
+                            amount: 1n,
+                            tokenIds: [{ start: 1n, end: 1n }],
+                            ownershipTimes: uintRanges_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const addr2 = (0, addressLists_spec_js_1.genTestAddress)();
+            const original = new transfers_js_1.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 = transfers_js_1.Transfer.fromProto(proto, string_numbers_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const addr2 = (0, addressLists_spec_js_1.genTestAddress)();
+            const original = new transfers_js_1.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 = transfers_js_1.Transfer.fromJson(jsonVal, string_numbers_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const original = new transfers_js_1.Transfer({
+                from: addr1,
+                toAddresses: [],
+                balances: [
+                    {
+                        amount: 7n,
+                        tokenIds: [{ start: 3n, end: 3n }],
+                        ownershipTimes: uintRanges_js_1.UintRangeArray.FullRanges()
+                    }
+                ]
+            });
+            const jsonStr = original.toProto().toJsonString();
+            const restored = transfers_js_1.Transfer.fromJsonString(jsonStr, string_numbers_js_1.BigIntify);
+            expect(restored.from).toBe(addr1);
+            expect(restored.balances[0].amount).toBe(7n);
+        });
+        it('should construct Transfer with prioritizedApprovals', () => {
+            const addr1 = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfer = new transfers_js_1.Transfer({
+                from: addr1,
+                toAddresses: [],
+                balances: [],
+                prioritizedApprovals: [
+                    new misc_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfer = new transfers_js_1.Transfer({
+                from: addr1,
+                toAddresses: [],
+                balances: [],
+                prioritizedApprovals: [
+                    new misc_js_1.ApprovalIdentifierDetails({
+                        approvalId: 'approval-x',
+                        approvalLevel: 'outgoing',
+                        approverAddress: addr1,
+                        version: 0n
+                    })
+                ]
+            });
+            const proto = transfer.toProto();
+            const restored = transfers_js_1.Transfer.fromProto(proto, string_numbers_js_1.BigIntify);
+            expect(restored.prioritizedApprovals).toBeDefined();
+            expect(restored.prioritizedApprovals[0].approvalId).toBe('approval-x');
+        });
+        it('should toBech32Addresses convert address formats', () => {
+            const addr = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfer = new transfers_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfer = new transfers_js_1.Transfer({
+                from: addr,
+                toAddresses: [],
+                balances: [],
+                prioritizedApprovals: [
+                    new misc_js_1.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 = (0, addressLists_spec_js_1.genTestAddress)();
+            const transfer = new transfers_js_1.Transfer({
+                from: addr,
+                toAddresses: [],
+                balances: [],
+                merkleProofs: [
+                    new misc_js_1.MerkleProof({
+                        aunts: [],
+                        leaf: 'leaf-value',
+                        leafSignature: 'sig'
+                    })
+                ],
+                ethSignatureProofs: [
+                    new misc_js_1.ETHSignatureProof({
+                        nonce: 'nonce-123',
+                        signature: '0x1234'
+                    })
+                ]
+            });
+            const proto = transfer.toProto();
+            const restored = transfers_js_1.Transfer.fromProto(proto, string_numbers_js_1.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