nexa-wallet-sdk 0.1.2

package/tests/core/wallet/accountstore.test.ts

@@ -0,0 +1,341 @@
+import { describe, test, expect, beforeEach, vi } from 'vitest'
+import { HDPrivateKey, Networks } from 'libnexa-ts'
+import AccountStore from '../../../src/wallet/accounts/AccountStore'
+import { AccountType } from '../../../src/utils/WalletUtils'
+import { BaseAccount } from '../../../src/wallet/accounts/interfaces/BaseAccountInterface'
+import DAppAccount from '../../../src/wallet/accounts/models/DappAccount'
+import VaultAccount from '../../../src/wallet/accounts/models/VaultAccount'
+import DefaultAccount from '../../../src/wallet/accounts/models/DefaultAccount'
+
+// Mock the WalletUtils
+vi.mock('../../../src/utils/WalletUtils', () => ({
+    AccountType: {
+        NEXA_ACCOUNT: 0,
+        VAULT_ACCOUNT: 1,
+        DAPP_ACCOUNT: 2
+    },
+    getNextAccountIndex: vi.fn().mockResolvedValue(0),
+    generateAccountKey: vi.fn().mockReturnValue({
+        deriveChild: vi.fn().mockReturnValue({
+            privateKey: {
+                toAddress: vi.fn().mockReturnValue({
+                    toString: vi.fn().mockReturnValue('nexatest:address123')
+                })
+            }
+        })
+    }),
+    generateKeyAndAddress: vi.fn().mockReturnValue({
+        key: {
+            privateKey: {
+                toAddress: vi.fn().mockReturnValue({
+                    toString: vi.fn().mockReturnValue('nexatest:address123')
+                })
+            }
+        },
+        address: 'nexatest:address123',
+        balance: '0',
+        tokensBalance: {}
+    }),
+    generateKeysAndAddresses: vi.fn().mockReturnValue({
+        receiveKeys: [{
+            key: { privateKey: {} },
+            address: 'nexatest:receive123',
+            balance: '0',
+            tokensBalance: {}
+        }],
+        changeKeys: [{
+            key: { privateKey: {} },
+            address: 'nexatest:change123',
+            balance: '0',
+            tokensBalance: {}
+        }]
+    })
+}))
+
+// Mock the account classes
+vi.mock('../../../src/wallet/accounts/models/DappAccount', () => ({
+    default: vi.fn().mockImplementation((purpose, index, addressKey) => ({
+        purpose,
+        index,
+        addressKey,
+        accountKeys: {
+            receiveKeys: [addressKey],
+            changeKeys: []
+        },
+        loadBalances: vi.fn().mockResolvedValue(undefined),
+        getAccountStoreKey: vi.fn().mockReturnValue(`${purpose}.${index}`)
+    }))
+}))
+
+vi.mock('../../../src/wallet/accounts/models/VaultAccount', () => ({
+    default: vi.fn().mockImplementation((purpose, index, addressKey) => ({
+        purpose,
+        index,
+        addressKey,
+        accountKeys: {
+            receiveKeys: [addressKey],
+            changeKeys: []
+        },
+        loadBalances: vi.fn().mockResolvedValue(undefined),
+        getAccountStoreKey: vi.fn().mockReturnValue(`${purpose}.${index}`)
+    }))
+}))
+
+vi.mock('../../../src/wallet/accounts/models/DefaultAccount', () => ({
+    default: vi.fn().mockImplementation((index, indexes, keys) => ({
+        index,
+        indexes,
+        accountKeys: keys,
+        loadBalances: vi.fn().mockResolvedValue(undefined),
+        getAccountStoreKey: vi.fn().mockReturnValue(String(index))
+    }))
+}))
+
+describe('AccountStore', () => {
+    let accountStore: AccountStore
+    let mockMasterKey: HDPrivateKey
+
+    beforeEach(() => {
+        accountStore = new AccountStore()
+        mockMasterKey = {} as HDPrivateKey
+        vi.clearAllMocks()
+    })
+
+    describe('constructor', () => {
+        test('should create empty account store', () => {
+            expect(accountStore).toBeInstanceOf(AccountStore)
+            expect(accountStore.listAccounts().size).toBe(0)
+        })
+    })
+
+    describe('createAccount', () => {
+        test('should create DApp account', async () => {
+            const account = await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            
+            expect(account).toBeDefined()
+            expect(DAppAccount).toHaveBeenCalledWith(2, 0, expect.any(Object))
+            expect(accountStore.listAccounts().size).toBe(1)
+        })
+
+        test('should create Vault account', async () => {
+            const account = await accountStore.createAccount(AccountType.VAULT_ACCOUNT, mockMasterKey)
+            
+            expect(account).toBeDefined()
+            expect(VaultAccount).toHaveBeenCalledWith(1, 0, expect.any(Object))
+            expect(accountStore.listAccounts().size).toBe(1)
+        })
+
+        test('should create Default NEXA account', async () => {
+            const account = await accountStore.createAccount(AccountType.NEXA_ACCOUNT, mockMasterKey)
+            
+            expect(account).toBeDefined()
+            expect(DefaultAccount).toHaveBeenCalledWith(0, expect.any(Object), expect.any(Object))
+            expect(accountStore.listAccounts().size).toBe(1)
+        })
+
+        test('should return existing account if already created', async () => {
+            const account1 = await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            const account2 = await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            
+            expect(account1).toBe(account2)
+            expect(accountStore.listAccounts().size).toBe(1)
+        })
+    })
+
+    describe('getAccountStoreKey', () => {
+        test('should generate correct key for DApp account', () => {
+            const key = accountStore['getAccountStoreKey'](AccountType.DAPP_ACCOUNT, 0)
+            expect(key).toBe('2.0')
+        })
+
+        test('should generate correct key for Vault account', () => {
+            const key = accountStore['getAccountStoreKey'](AccountType.VAULT_ACCOUNT, 1)
+            expect(key).toBe('1.1')
+        })
+
+        test('should generate correct key for Default account', () => {
+            const key = accountStore['getAccountStoreKey'](AccountType.NEXA_ACCOUNT, 0)
+            expect(key).toBe('0')
+        })
+    })
+
+    describe('findKeyForAddress', () => {
+        test('should find key for existing address', async () => {
+            const mockAccount = {
+                accountKeys: {
+                    receiveKeys: [{
+                        address: 'nexatest:target123',
+                        key: { privateKey: 'mock-key' }
+                    }],
+                    changeKeys: [{
+                        address: 'nexatest:change123',
+                        key: { privateKey: 'mock-key-2' }
+                    }]
+                }
+            }
+            
+            accountStore['_accounts'].set('test', mockAccount as any)
+            
+            const result = accountStore.findKeyForAddress('nexatest:target123')
+            expect(result).toBeDefined()
+            expect(result?.address).toBe('nexatest:target123')
+        })
+
+        test('should return null for non-existent address', () => {
+            const result = accountStore.findKeyForAddress('nexatest:nonexistent')
+            expect(result).toBeNull()
+        })
+
+        test('should search through both receive and change keys', async () => {
+            const mockAccount = {
+                accountKeys: {
+                    receiveKeys: [{
+                        address: 'nexatest:receive123',
+                        key: { privateKey: 'mock-key' }
+                    }],
+                    changeKeys: [{
+                        address: 'nexatest:change123',
+                        key: { privateKey: 'mock-key-2' }
+                    }]
+                }
+            }
+            
+            accountStore['_accounts'].set('test', mockAccount as any)
+            
+            const receiveResult = accountStore.findKeyForAddress('nexatest:receive123')
+            const changeResult = accountStore.findKeyForAddress('nexatest:change123')
+            
+            expect(receiveResult?.address).toBe('nexatest:receive123')
+            expect(changeResult?.address).toBe('nexatest:change123')
+        })
+    })
+
+    describe('importAccount', () => {
+        test('should import new account', () => {
+            const mockAccount = {
+                getAccountStoreKey: vi.fn().mockReturnValue('imported.0')
+            } as any
+            
+            accountStore.importAccount(mockAccount)
+            
+            expect(accountStore.listAccounts().size).toBe(1)
+            expect(accountStore.getAccount('imported.0')).toBe(mockAccount)
+        })
+
+        test('should throw error for duplicate account', () => {
+            const mockAccount = {
+                getAccountStoreKey: vi.fn().mockReturnValue('duplicate.0')
+            } as any
+            
+            accountStore.importAccount(mockAccount)
+            
+            expect(() => {
+                accountStore.importAccount(mockAccount)
+            }).toThrow('Account already exists!')
+        })
+    })
+
+    describe('exportAccount', () => {
+        test('should export existing account', () => {
+            const mockAccount = {
+                getAccountStoreKey: vi.fn().mockReturnValue('export.0')
+            } as any
+            
+            accountStore['_accounts'].set('export.0', mockAccount)
+            
+            const exported = accountStore.exportAccount('export.0')
+            expect(exported).toBe(mockAccount)
+        })
+
+        test('should throw error for non-existent account', () => {
+            expect(() => {
+                accountStore.exportAccount('nonexistent')
+            }).toThrow('Cannot find account!')
+        })
+    })
+
+    describe('removeAccount', () => {
+        test('should remove existing account', () => {
+            const mockAccount = {
+                getAccountStoreKey: vi.fn().mockReturnValue('remove.0')
+            } as any
+            
+            accountStore['_accounts'].set('remove.0', mockAccount)
+            expect(accountStore.listAccounts().size).toBe(1)
+            
+            accountStore.removeAccount('remove.0')
+            expect(accountStore.listAccounts().size).toBe(0)
+        })
+
+        test('should throw error for non-existent account', () => {
+            expect(() => {
+                accountStore.removeAccount('nonexistent')
+            }).toThrow('Cannot find account!')
+        })
+    })
+
+    describe('listAccounts', () => {
+        test('should return all accounts', async () => {
+            await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            await accountStore.createAccount(AccountType.VAULT_ACCOUNT, mockMasterKey)
+            
+            const accounts = accountStore.listAccounts()
+            expect(accounts.size).toBe(2)
+        })
+
+        test('should return empty map when no accounts', () => {
+            const accounts = accountStore.listAccounts()
+            expect(accounts.size).toBe(0)
+            expect(accounts).toBeInstanceOf(Map)
+        })
+    })
+
+    describe('getAccount', () => {
+        test('should return account by index', async () => {
+            const account = await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            
+            const retrieved = accountStore.getAccount('2.0')
+            expect(retrieved).toBe(account)
+        })
+
+        test('should return undefined for non-existent account', () => {
+            const retrieved = accountStore.getAccount('nonexistent')
+            expect(retrieved).toBeUndefined()
+        })
+    })
+
+    describe('error handling', () => {
+        test('should handle account creation errors gracefully', async () => {
+            // Mock getNextAccountIndex to throw an error
+            const { getNextAccountIndex } = await import('../../../src/utils/WalletUtils')
+            vi.mocked(getNextAccountIndex).mockRejectedValueOnce(new Error('Network error'))
+            
+            await expect(
+                accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            ).rejects.toThrow('Network error')
+        })
+    })
+
+    describe('integration tests', () => {
+        test('should handle multiple account types', async () => {
+            const dappAccount = await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            const vaultAccount = await accountStore.createAccount(AccountType.VAULT_ACCOUNT, mockMasterKey)
+            const nexaAccount = await accountStore.createAccount(AccountType.NEXA_ACCOUNT, mockMasterKey)
+            
+            expect(accountStore.listAccounts().size).toBe(3)
+            expect(accountStore.getAccount('2.0')).toBe(dappAccount)
+            expect(accountStore.getAccount('1.0')).toBe(vaultAccount)
+            expect(accountStore.getAccount('0')).toBe(nexaAccount)
+        })
+
+        test('should maintain account independence', async () => {
+            const account1 = await accountStore.createAccount(AccountType.DAPP_ACCOUNT, mockMasterKey)
+            const account2 = await accountStore.createAccount(AccountType.VAULT_ACCOUNT, mockMasterKey)
+            
+            accountStore.removeAccount('2.0')
+            
+            expect(accountStore.getAccount('2.0')).toBeUndefined()
+            expect(accountStore.getAccount('1.0')).toBe(account2)
+        })
+    })
+})

package/tests/core/wallet/wallet.test.ts

@@ -0,0 +1,69 @@
+import {describe, test, expect} from "vitest";
+import {Wallet} from "../../../src";
+import {rostrumProvider} from "../../../src/network/RostrumProvider";
+import WatchOnlyWallet from "../../../src/wallet/WatchOnlyWallet";
+
+/**
+ * Test suite for the main Wallet class
+ * 
+ * Tests wallet initialization, account management, and transaction creation
+ * on the Nexa testnet.
+ */
+describe('#Wallet', {timeout: 100000}, function() {
+    
+    /**
+     * Test wallet initialization and basic transaction creation
+     * 
+     * This test:
+     * - Creates a wallet from a seed phrase
+     * - Initializes it to discover accounts
+     * - Creates a transaction with OP_RETURN data
+     * - Tests the full transaction flow
+     */
+    test('Init wallet', async () => {
+        await rostrumProvider.connect()
+        const wallet = new Wallet('mask wool cram snap cross wood rebuild among total vicious script diamond', 'testnet')
+        await wallet.initialize()
+
+        const defaultAccount = wallet.accountStore.getAccount('2.0')
+        expect(defaultAccount).toBeDefined()
+        if(!defaultAccount){
+            return;
+        }
+        
+        const transactions = await defaultAccount.getTransactions()
+        expect(transactions).toBeDefined()
+        
+        const newAddress = defaultAccount.getNewAddress()
+        expect(newAddress).toBeDefined()
+        
+        const tx = await wallet.newTransaction(defaultAccount)
+            .onNetwork('testnet')
+            .sendTo('nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc', '10000')
+            .addOpReturn("First wallet SDK transaction, Woo!!")
+            .populate()
+            .sign()
+            .build()
+        expect(tx).toBeDefined()
+
+        const watchOnlyWallet = new WatchOnlyWallet([{
+            address: 'nexatest:nqtsq5g5dsgh6mwjchqypn8hvdrjue0xpmz293fl7rm926xv',
+        }], 'testnet')
+
+        const tx2 = await watchOnlyWallet.newTransaction()
+            .sendTo('nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc', '100000')
+            .addOpReturn("Second wallet SDK transaction, Woo!!")
+            .populate()
+            .build()
+        expect(tx2).toBeDefined()
+
+        const parsedTx = await wallet.newTransaction(defaultAccount, tx2).sign().build()
+        expect(parsedTx).toBeDefined()
+
+
+
+        const walletData = wallet.export()
+        expect(walletData).toBeDefined()
+    });
+
+});

package/tests/core/watchonlywallet/watchonlywallet.test.ts

@@ -0,0 +1,251 @@
+import { describe, test, expect, beforeEach, vi } from 'vitest'
+import { Networks, TransactionBuilder } from 'libnexa-ts'
+import WatchOnlyWallet from '../../../src/wallet/WatchOnlyWallet'
+import { WatchOnlyAddress } from '../../../src/models/wallet.entities'
+
+// Mock the rostrumProvider
+vi.mock('../../../src/network/RostrumProvider', () => ({
+    rostrumProvider: {
+        broadcast: vi.fn().mockResolvedValue('txid123'),
+        subscribeToAddresses: vi.fn().mockResolvedValue(undefined)
+    }
+}))
+
+// Mock the ValidationUtils
+vi.mock('../../../src/utils/ValidationUtils', () => ({
+    default: {
+        validateArgument: vi.fn()
+    }
+}))
+
+// Mock the WalletUtils
+vi.mock('../../../src/utils/WalletUtils', () => ({
+    isValidNexaAddress: vi.fn().mockReturnValue(true)
+}))
+
+describe('WatchOnlyWallet', () => {
+    let mockAddresses: WatchOnlyAddress[]
+
+    beforeEach(() => {
+        mockAddresses = [
+            { address: 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc' },
+            { address: 'nexatest:nqtsq5g5dsgh6mwjchqypn8hvdrjue0xpmz293fl7rm926xv' }
+        ]
+    })
+
+    describe('constructor', () => {
+        test('should create wallet with valid addresses and default network', () => {
+            const wallet = new WatchOnlyWallet(mockAddresses)
+            
+            expect(wallet).toBeInstanceOf(WatchOnlyWallet)
+            expect(wallet.getWatchedAddresses()).toHaveLength(2)
+            expect(wallet.getWatchedAddresses()[0].address).toBe(mockAddresses[0].address)
+        })
+
+        test('should create wallet with custom network', () => {
+            const wallet = new WatchOnlyWallet(mockAddresses, 'testnet')
+            
+            expect(wallet).toBeInstanceOf(WatchOnlyWallet)
+            expect(wallet['_network']).toBe(Networks.testnet)
+        })
+
+        test('should throw error for invalid network type', () => {
+            expect(() => {
+                new WatchOnlyWallet(mockAddresses, 123 as any)
+            }).toThrow('Network must be a string')
+        })
+
+        test('should throw error for invalid network', () => {
+            expect(() => {
+                new WatchOnlyWallet(mockAddresses, 'invalidnetwork')
+            }).toThrow('Invalid network: invalidnetwork')
+        })
+
+        test('should throw error for null addresses', () => {
+            expect(() => {
+                new WatchOnlyWallet(null as any)
+            }).toThrow('addresesToWatch is required')
+        })
+
+        test('should throw error for non-array addresses', () => {
+            expect(() => {
+                new WatchOnlyWallet('not-an-array' as any)
+            }).toThrow('addressesToWatch must be an array')
+        })
+
+        test('should throw error for empty addresses array', () => {
+            expect(() => {
+                new WatchOnlyWallet([])
+            }).toThrow('addressesToWatch cannot be empty')
+        })
+
+        test('should throw error for invalid address object', () => {
+            expect(() => {
+                new WatchOnlyWallet(['invalid'] as any)
+            }).toThrow('addressesToWatch[0] must be an object')
+        })
+
+        test('should throw error for missing address property', () => {
+            expect(() => {
+                new WatchOnlyWallet([{ notAddress: 'test' }] as any)
+            }).toThrow('addressesToWatch[0].address must be a string')
+        })
+
+        test('should throw error for empty address string', () => {
+            expect(() => {
+                new WatchOnlyWallet([{ address: '' }])
+            }).toThrow('addressesToWatch[0].address cannot be empty')
+        })
+
+        test('should throw error for duplicate addresses', () => {
+            const duplicates = [
+                { address: 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc' },
+                { address: 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc' }
+            ]
+            expect(() => {
+                new WatchOnlyWallet(duplicates)
+            }).toThrow('Duplicate address found')
+        })
+
+        test('should handle optional xPub property', () => {
+            const addressesWithXPub = [
+                { 
+                    address: 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc',
+                    xPub: {} as any
+                }
+            ]
+            const wallet = new WatchOnlyWallet(addressesWithXPub)
+            
+            expect(wallet.getWatchedAddresses()[0].xPub).toBeDefined()
+        })
+
+        test('should handle optional derivationPath property', () => {
+            const addressesWithPath = [
+                { 
+                    address: 'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc',
+                    derivationPath: "m/44'/29223'/0'/0/0"
+                }
+            ]
+            const wallet = new WatchOnlyWallet(addressesWithPath)
+            
+            expect(wallet.getWatchedAddresses()[0].derivationPath).toBe("m/44'/29223'/0'/0/0")
+        })
+    })
+
+    describe('newTransaction', () => {
+        let wallet: WatchOnlyWallet
+
+        beforeEach(() => {
+            wallet = new WatchOnlyWallet(mockAddresses, 'testnet')
+        })
+
+        test('should create transaction without parameters', () => {
+            const tx = wallet.newTransaction()
+            
+            expect(tx).toBeDefined()
+            expect(tx.network).toBe(Networks.testnet)
+        })
+
+        test('should create transaction with TransactionBuilder', () => {
+            const txBuilder = new TransactionBuilder()
+            const tx = wallet.newTransaction(txBuilder)
+            
+            expect(tx).toBeDefined()
+        })
+
+        test('should create transaction with hex string', () => {
+            const hexTx = 'deadbeef'
+            const tx = wallet.newTransaction(hexTx)
+            
+            expect(tx).toBeDefined()
+        })
+
+        test('should create transaction with buffer', () => {
+            const bufferTx = Buffer.from('deadbeef', 'hex')
+            const tx = wallet.newTransaction(bufferTx)
+            
+            expect(tx).toBeDefined()
+        })
+    })
+
+    describe('sendTransaction', () => {
+        let wallet: WatchOnlyWallet
+
+        beforeEach(() => {
+            wallet = new WatchOnlyWallet(mockAddresses)
+        })
+
+        test('should broadcast transaction and return txid', async () => {
+            const txHex = 'deadbeef'
+            const result = await wallet.sendTransaction(txHex)
+            
+            expect(result).toBe('txid123')
+        })
+    })
+
+    describe('subscribeToAddressNotifications', () => {
+        let wallet: WatchOnlyWallet
+
+        beforeEach(() => {
+            wallet = new WatchOnlyWallet(mockAddresses)
+        })
+
+        test('should subscribe to address notifications', async () => {
+            const callback = vi.fn()
+            await wallet.subscribeToAddressNotifications(callback)
+            
+            // Should not throw and complete successfully
+            expect(callback).not.toHaveBeenCalled() // Callback is passed to provider, not called directly
+        })
+    })
+
+    describe('getWatchedAddresses', () => {
+        test('should return copy of watched addresses', () => {
+            const wallet = new WatchOnlyWallet(mockAddresses)
+            const addresses = wallet.getWatchedAddresses()
+            
+            expect(addresses).toHaveLength(2)
+            expect(addresses).not.toBe(wallet['_addressesToWatch']) // Should be a copy
+            expect(addresses[0].address).toBe(mockAddresses[0].address)
+        })
+    })
+
+    describe('validation edge cases', () => {
+        test('should trim whitespace from addresses', () => {
+            const addressesWithWhitespace = [
+                { address: '  nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc  ' }
+            ]
+            const wallet = new WatchOnlyWallet(addressesWithWhitespace)
+            
+            expect(wallet.getWatchedAddresses()[0].address).toBe('nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc')
+        })
+
+        test('should handle mixed address formats', () => {
+            const mixedAddresses = [
+                'nexatest:nqtsq5g5jsdmqqywaqd82lhnnk3a8wqunjz6gtxdtavnnekc',
+                { address: 'nexatest:nqtsq5g5dsgh6mwjchqypn8hvdrjue0xpmz293fl7rm926xv' }
+            ]
+            // This should work with the updated from() method in transaction creator
+            const wallet = new WatchOnlyWallet([
+                { address: mixedAddresses[0] as string },
+                mixedAddresses[1] as WatchOnlyAddress
+            ])
+            
+            expect(wallet.getWatchedAddresses()).toHaveLength(2)
+        })
+    })
+
+    describe('network handling', () => {
+        test('should default to mainnet when network is undefined', () => {
+            const wallet = new WatchOnlyWallet(mockAddresses, undefined)
+            
+            expect(wallet['_network']).toBe(Networks.mainnet)
+        })
+
+        test('should handle testnet correctly', () => {
+            const wallet = new WatchOnlyWallet(mockAddresses, 'testnet')
+            
+            expect(wallet['_network']).toBe(Networks.testnet)
+        })
+    })
+})

package/tests/index.test.ts

@@ -0,0 +1,12 @@
+import { describe, expect, test } from "vitest";
+import walletSdk from "../src/index";
+
+describe('#versionGuard', function() {
+  test('global._walletSdk_ver should be defined', () => {
+    expect(global._walletSdk_ver).toBe(walletSdk.version);
+  });
+
+  test('throw an error if version is already defined', () => {
+    expect(() => walletSdk.versionGuard('version')).toThrow('More than one instance of Wallet SDK');
+  });
+});