nexa-wallet-sdk 0.1.2

package/tests/core/tx/transactioncreator.test.ts

@@ -0,0 +1,455 @@
+import { describe, test, expect, beforeEach, vi } from 'vitest'
+import { TransactionBuilder, Networks, Transaction } from 'libnexa-ts'
+import { TransactionCreator } from '../../../src/wallet/transactions/interfaces/TransactionCreator'
+import { PermissionLabel } from '../../../src/models/transaction.entities'
+
+// Mock the rostrumProvider
+vi.mock('../../../src/network/RostrumProvider', () => ({
+    rostrumProvider: {
+        broadcast: vi.fn().mockResolvedValue('txid123')
+    }
+}))
+
+// Mock the WalletUtils
+vi.mock('../../../src/utils/WalletUtils', () => ({
+    isValidNexaAddress: vi.fn().mockReturnValue(true)
+}))
+
+// Create a concrete implementation of TransactionCreator for testing
+class TestTransactionCreator extends TransactionCreator {
+    constructor(tx?: TransactionBuilder | string | Buffer) {
+        super(tx)
+    }
+
+    public parseTxHex(tx: string): this {
+        // Mock implementation
+        return this
+    }
+
+    public parseTxBuffer(tx: Buffer): this {
+        // Mock implementation
+        return this
+    }
+
+    public populate(): this {
+        // Mock implementation
+        return this
+    }
+}
+
+describe('TransactionCreator', () => {
+    let creator: TestTransactionCreator
+
+    beforeEach(() => {
+        creator = new TestTransactionCreator()
+    })
+
+    describe('constructor', () => {
+        test('should create instance without transaction builder', () => {
+            const creator = new TestTransactionCreator()
+            expect(creator).toBeInstanceOf(TransactionCreator)
+            expect(creator.network).toBe(Networks.mainnet)
+            expect(creator.totalValue).toBe(BigInt(0))
+        })
+
+        test('should create instance with transaction builder', () => {
+            const txBuilder = new TransactionBuilder()
+            const creator = new TestTransactionCreator(txBuilder)
+            expect(creator).toBeInstanceOf(TransactionCreator)
+        })
+    })
+
+    describe('onNetwork', () => {
+        test('should set network by string', () => {
+            const result = creator.onNetwork('testnet')
+            expect(result).toBe(creator)
+            expect(creator.network).toBe(Networks.testnet)
+        })
+
+        test('should set network by Networkish object', () => {
+            const result = creator.onNetwork(Networks.testnet)
+            expect(result).toBe(creator)
+            expect(creator.network).toBe(Networks.testnet)
+        })
+
+        test('should be chainable', () => {
+            const result = creator
+                .onNetwork('testnet')
+                .onNetwork('mainnet')
+            expect(result).toBe(creator)
+            expect(creator.network).toBe(Networks.mainnet)
+        })
+    })
+
+    describe('property getters and setters', () => {
+        test('should get and set txOptions', () => {
+            const options = { feeFromAmount: true }
+            creator.txOptions = options
+            expect(creator.txOptions).toEqual(options)
+        })
+
+        test('should get and set network', () => {
+            creator.network = Networks.testnet
+            expect(creator.network).toBe(Networks.testnet)
+        })
+
+        test('should get and set totalValue', () => {
+            const value = BigInt(1000)
+            creator.totalValue = value
+            expect(creator.totalValue).toBe(value)
+        })
+
+        test('should get and set builder', () => {
+            const mockFn = vi.fn()
+            creator.builder = [mockFn]
+            expect(creator.builder).toHaveLength(1)
+            expect(creator.builder[0]).toBe(mockFn)
+        })
+
+        test('should get and set tokens', () => {
+            const tokenAction = {
+                token: 'test-token',
+                amount: BigInt(100),
+                action: 'send'
+            }
+            creator.tokens.add(tokenAction)
+            expect(creator.tokens.size).toBe(1)
+            expect(creator.tokens.has(tokenAction)).toBe(true)
+        })
+    })
+
+    describe('consolidate', () => {
+        test('should add consolidate operation to builder', () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const result = creator.consolidate(toAddr)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const result = creator
+                .consolidate(toAddr)
+                .consolidate(toAddr)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('feeFromAmount', () => {
+        test('should add feeFromAmount operation to builder', () => {
+            const result = creator.feeFromAmount()
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const result = creator
+                .feeFromAmount()
+                .feeFromAmount()
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('sendToToken', () => {
+        test('should add token send operation to builder', () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const amount = '1000'
+            const token = 'nexatest:tqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+
+            const result = creator.sendToToken(toAddr, amount, token)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const amount = '1000'
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+
+            const result = creator
+                .sendToToken(toAddr, amount, token)
+                .sendToToken(toAddr, amount, token)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('sendTo', () => {
+        test('should add NEXA send operation to builder', () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const amount = '1000'
+
+            const result = creator.sendTo(toAddr, amount)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const amount = '1000'
+
+            const result = creator
+                .sendTo(toAddr, amount)
+                .sendTo(toAddr, amount)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('renewAuthority', () => {
+        test('should add renew authority operation to builder', () => {
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const perms: PermissionLabel[] = ['mint', 'melt']
+
+            const result = creator.renewAuthority(token, perms)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should add renew authority operation with address', () => {
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const perms: PermissionLabel[] = ['mint', 'melt']
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+
+            const result = creator.renewAuthority(token, perms, toAddr)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+    })
+
+    describe('deleteAuthority', () => {
+        test('should add delete authority operation to builder', () => {
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const outpoint = 'abc123:0'
+
+            const result = creator.deleteAuthority(token, outpoint)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const outpoint = 'abc123:0'
+
+            const result = creator
+                .deleteAuthority(token, outpoint)
+                .deleteAuthority(token, outpoint)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('legacy methods', () => {
+        test('legacyToken should add operation to builder', () => {
+            const result = creator.legacyToken('Test Token', 'TEST', 2, 'https://test.com', 'hash123')
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('legacyGroup should add operation to builder', () => {
+            const result = creator.legacyGroup('Test Group', 'TGRP', 'https://group.com', 'hash456')
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const result = creator
+                .legacyToken('Test Token', 'TEST', 2, 'https://test.com', 'hash123')
+                .legacyGroup('Test Group', 'TGRP', 'https://group.com', 'hash456')
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('token', () => {
+        test('should add token creation to builder', () => {
+            const result = creator.token('Test Token', 'TEST', 2, 'https://test.com', 'hash123')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const result = creator
+                .token('Test Token', 'TEST', 2, 'https://test.com', 'hash123')
+                .token('Test Token 2', 'TEST2', 4, 'https://test2.com', 'hash456')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('collection', () => {
+        test('should add collection creation to builder', () => {
+            const result = creator.collection('Test Collection', 'TCOL', 'https://collection.com', 'hash123')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const result = creator
+                .collection('Test Collection', 'TCOL', 'https://collection.com', 'hash123')
+                .collection('Test Collection 2', 'TCOL2', 'https://collection2.com', 'hash456')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('NFT', () => {
+        test('should add NFT creation to builder', () => {
+            const parent = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const result = creator.nft(parent, 'https://nft.com/content.zip', 'hash123')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const parent = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const result = creator
+                .nft(parent, 'https://nft1.com/content.zip', 'hash123')
+                .nft(parent, 'https://nft2.com/content.zip', 'hash456')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('addOpReturn', () => {
+        test('should add OP_RETURN with string data', () => {
+            const data = 'Hello World'
+            const result = creator.addOpReturn(data)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should add OP_RETURN with buffer data', () => {
+            const data = Buffer.from('Hello World')
+            const result = creator.addOpReturn(data)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should add OP_RETURN with full script', () => {
+            const data = 'Hello World'
+            const result = creator.addOpReturn(data, true)
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(1)
+        })
+
+        test('should be chainable', () => {
+            const result = creator
+                .addOpReturn('Hello')
+                .addOpReturn('World')
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2)
+        })
+    })
+
+    describe('build', () => {
+        test('should execute all builder functions and return serialized transaction', async () => {
+            const mockFunction = vi.fn().mockResolvedValue(undefined)
+            creator.builder = [mockFunction]
+
+            const result = await creator.build()
+
+            expect(mockFunction).toHaveBeenCalledTimes(1)
+            expect(typeof result).toBe('string')
+        })
+
+        test('should execute multiple builder functions in order', async () => {
+            const mockFunction1 = vi.fn().mockResolvedValue(undefined)
+            const mockFunction2 = vi.fn().mockResolvedValue(undefined)
+            creator.builder = [mockFunction1, mockFunction2]
+
+            await creator.build()
+
+            expect(mockFunction1).toHaveBeenCalledTimes(1)
+            expect(mockFunction2).toHaveBeenCalledTimes(1)
+        })
+    })
+
+    describe('integration tests', () => {
+        test('should handle complete transaction flow', async () => {
+            const toAddr = 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc'
+            const amount = '1000'
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+
+            const result = creator
+                .onNetwork('testnet')
+                .sendTo(toAddr, amount)
+                .sendToToken(toAddr, amount, token)
+                .addOpReturn('Transaction data')
+                .feeFromAmount()
+                .populate()
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(4) // sendTo, sendToToken, addOpReturn, feeFromAmount (populate not called yet)
+            expect(creator.network).toBe(Networks.testnet)
+
+            const tx = await creator.build()
+            expect(typeof tx).toBe('string')
+        })
+
+        test('should handle token authority operations', async () => {
+            const token = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+            const perms: PermissionLabel[] = ['mint', 'melt']
+            const outpoint = 'abc123:0'
+
+            const result = creator
+                .renewAuthority(token, perms)
+                .deleteAuthority(token, outpoint)
+                .populate()
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(2) // renewAuthority, deleteAuthority (populate not called yet)
+
+            const tx = await creator.build()
+            expect(typeof tx).toBe('string')
+        })
+
+        test('should handle token and collection creation', async () => {
+            const parent = 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+
+            const result = creator
+                .token('Test Token', 'TEST', 2, 'https://test.com', 'hash123')
+                .collection('Test Collection', 'TCOL', 'https://collection.com', 'hash456')
+                .nft(parent, 'https://nft.com/content.zip', 'hash789')
+                .populate()
+
+            expect(result).toBe(creator)
+            expect(creator.builder).toHaveLength(3) // token, collection, NFT (populate not called yet)
+
+            const tx = await creator.build()
+            expect(typeof tx).toBe('string')
+        })
+    })
+
+    describe('error handling', () => {
+        test('should handle async errors in builder functions', async () => {
+            const errorFunction = vi.fn().mockRejectedValue(new Error('Test error'))
+            creator.builder = [errorFunction]
+
+            await expect(creator.build()).rejects.toThrow('Test error')
+        })
+    })
+})