@cityofzion/bs-neo3 0.7.2 → 0.8.0

package/src/__tests__/BDSNeo3.spec.ts

@@ -1,126 +1,126 @@
-import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
-import { DoraBDSNeo3 } from '../DoraBDSNeo3'
-import { RPCBDSNeo3 } from '../RpcBDSNeo3'
-import { DEFAULT_URL_BY_NETWORK_TYPE, TOKENS } from '../constants'
-
-const gasToken = TOKENS.testnet.find(t => t.symbol === 'GAS')!
-let doraBDSNeo3 = new DoraBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
-let rpcBDSNeo3 = new RPCBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
-
-describe('BDSNeo3', () => {
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get transaction - %s',
-    async (bdsNeo3: BlockchainDataService) => {
-      const hash = '0x70e7381c5dee6e81becd02844e4e0199f6b3df834213bc89418dc4da32cf3f21'
-      const transaction = await bdsNeo3.getTransaction(hash)
-
-      expect(transaction).toEqual(
-        expect.objectContaining({
-          block: expect.any(Number),
-          hash,
-          notifications: [],
-          transfers: [],
-          time: expect.any(Number),
-          fee: expect.any(String),
-        })
-      )
-    }
-  )
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get transactions of address - %s',
-    async (bdsNeo3: BlockchainDataService) => {
-      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
-      try {
-        const response = await bdsNeo3.getTransactionsByAddress({ address, page: 1 })
-
-        response.transactions.forEach(transaction => {
-          expect(transaction).toEqual(
-            expect.objectContaining({
-              block: expect.any(Number),
-              hash: expect.any(String),
-              notifications: expect.arrayContaining([
-                expect.objectContaining({
-                  eventName: expect.any(String),
-                  state: expect.arrayContaining([
-                    {
-                      type: expect.any(String),
-                      value: expect.any(String),
-                    },
-                  ]),
-                }),
-              ]),
-              transfers: expect.arrayContaining([
-                expect.objectContaining({
-                  amount: expect.any(String),
-                  from: expect.any(String),
-                  to: expect.any(String),
-                  type: 'asset',
-                }),
-              ]),
-              time: expect.any(Number),
-              fee: expect.any(String),
-            })
-          )
-        })
-      } catch {}
-    }
-  )
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])('Should be able to get contract - %s', async (bdsNeo3: BlockchainDataService) => {
-    const hash = '0xd2a4cff31913016155e38e474a2c06d08be276cf'
-    const contract = await bdsNeo3.getContract(hash)
-    expect(contract).toEqual({
-      hash: hash,
-      name: 'GasToken',
-      methods: expect.arrayContaining([
-        expect.objectContaining({
-          name: expect.any(String),
-          parameters: expect.arrayContaining([
-            expect.objectContaining({ name: expect.any(String), type: expect.any(String) }),
-          ]),
-        }),
-      ]),
-    })
-  })
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get token info - %s',
-    async (bdsNeo3: BlockchainDataService) => {
-      const hash = '0xd2a4cff31913016155e38e474a2c06d08be276cf'
-      const token = await bdsNeo3.getTokenInfo(hash)
-
-      expect(token).toEqual({
-        decimals: 8,
-        hash: hash,
-        name: 'GasToken',
-        symbol: 'GAS',
-      })
-    }
-  )
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])('Should be able to get balance - %s', async (bdsNeo3: BlockchainDataService) => {
-    const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
-    const balance = await bdsNeo3.getBalance(address)
-    balance.forEach(balance => {
-      expect(balance).toEqual({
-        amount: expect.any(String),
-        token: {
-          hash: expect.any(String),
-          name: expect.any(String),
-          symbol: expect.any(String),
-          decimals: expect.any(Number),
-        },
-      })
-    })
-  })
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get unclaimed - %s',
-    async (bdsNeo3: BlockchainDataService & BDSClaimable) => {
-      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
-      const unclaimed = await bdsNeo3.getUnclaimed(address)
-      expect(unclaimed).toEqual(expect.any(String))
-    }
-  )
-})
+import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
+import { DoraBDSNeo3 } from '../DoraBDSNeo3'
+import { RPCBDSNeo3 } from '../RpcBDSNeo3'
+import { DEFAULT_URL_BY_NETWORK_TYPE, TOKENS } from '../constants'
+
+const gasToken = TOKENS.testnet.find(t => t.symbol === 'GAS')!
+let doraBDSNeo3 = new DoraBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
+let rpcBDSNeo3 = new RPCBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
+
+describe('BDSNeo3', () => {
+  it.each([doraBDSNeo3, rpcBDSNeo3])(
+    'Should be able to get transaction - %s',
+    async (bdsNeo3: BlockchainDataService) => {
+      const hash = '0x70e7381c5dee6e81becd02844e4e0199f6b3df834213bc89418dc4da32cf3f21'
+      const transaction = await bdsNeo3.getTransaction(hash)
+
+      expect(transaction).toEqual(
+        expect.objectContaining({
+          block: expect.any(Number),
+          hash,
+          notifications: [],
+          transfers: [],
+          time: expect.any(Number),
+          fee: expect.any(String),
+        })
+      )
+    }
+  )
+
+  it.each([doraBDSNeo3, rpcBDSNeo3])(
+    'Should be able to get transactions of address - %s',
+    async (bdsNeo3: BlockchainDataService) => {
+      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
+      try {
+        const response = await bdsNeo3.getTransactionsByAddress({ address, page: 1 })
+
+        response.transactions.forEach(transaction => {
+          expect(transaction).toEqual(
+            expect.objectContaining({
+              block: expect.any(Number),
+              hash: expect.any(String),
+              notifications: expect.arrayContaining([
+                expect.objectContaining({
+                  eventName: expect.any(String),
+                  state: expect.arrayContaining([
+                    {
+                      type: expect.any(String),
+                      value: expect.any(String),
+                    },
+                  ]),
+                }),
+              ]),
+              transfers: expect.arrayContaining([
+                expect.objectContaining({
+                  amount: expect.any(String),
+                  from: expect.any(String),
+                  to: expect.any(String),
+                  type: 'asset',
+                }),
+              ]),
+              time: expect.any(Number),
+              fee: expect.any(String),
+            })
+          )
+        })
+      } catch {}
+    }
+  )
+
+  it.each([doraBDSNeo3, rpcBDSNeo3])('Should be able to get contract - %s', async (bdsNeo3: BlockchainDataService) => {
+    const hash = '0xd2a4cff31913016155e38e474a2c06d08be276cf'
+    const contract = await bdsNeo3.getContract(hash)
+    expect(contract).toEqual({
+      hash: hash,
+      name: 'GasToken',
+      methods: expect.arrayContaining([
+        expect.objectContaining({
+          name: expect.any(String),
+          parameters: expect.arrayContaining([
+            expect.objectContaining({ name: expect.any(String), type: expect.any(String) }),
+          ]),
+        }),
+      ]),
+    })
+  })
+
+  it.each([doraBDSNeo3, rpcBDSNeo3])(
+    'Should be able to get token info - %s',
+    async (bdsNeo3: BlockchainDataService) => {
+      const hash = '0xd2a4cff31913016155e38e474a2c06d08be276cf'
+      const token = await bdsNeo3.getTokenInfo(hash)
+
+      expect(token).toEqual({
+        decimals: 8,
+        hash: hash,
+        name: 'GasToken',
+        symbol: 'GAS',
+      })
+    }
+  )
+
+  it.each([doraBDSNeo3, rpcBDSNeo3])('Should be able to get balance - %s', async (bdsNeo3: BlockchainDataService) => {
+    const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
+    const balance = await bdsNeo3.getBalance(address)
+    balance.forEach(balance => {
+      expect(balance).toEqual({
+        amount: expect.any(String),
+        token: {
+          hash: expect.any(String),
+          name: expect.any(String),
+          symbol: expect.any(String),
+          decimals: expect.any(Number),
+        },
+      })
+    })
+  })
+
+  it.each([doraBDSNeo3, rpcBDSNeo3])(
+    'Should be able to get unclaimed - %s',
+    async (bdsNeo3: BlockchainDataService & BDSClaimable) => {
+      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
+      const unclaimed = await bdsNeo3.getUnclaimed(address)
+      expect(unclaimed).toEqual(expect.any(String))
+    }
+  )
+})

package/src/__tests__/BSNeo3.spec.ts

@@ -1,142 +1,142 @@
-import { wallet } from '@cityofzion/neon-js'
-import { sleep } from './utils/sleep'
-import { BSNeo3 } from '../BSNeo3'
-import { generateMnemonic } from '@cityofzion/bs-asteroid-sdk'
-
-let bsNeo3: BSNeo3
-
-describe('BSNeo3', () => {
-  beforeAll(() => {
-    bsNeo3 = new BSNeo3('neo3', { type: 'testnet', url: 'https://testnet1.neo.coz.io:443' })
-  })
-
-  it('Should be able to validate an address', () => {
-    const validAddress = 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe'
-    const invalidAddress = 'invalid address'
-
-    expect(bsNeo3.validateAddress(validAddress)).toBeTruthy()
-    expect(bsNeo3.validateAddress(invalidAddress)).toBeFalsy()
-  })
-
-  it('Should be able to validate an encrypted key', () => {
-    const validEncryptedKey = '6PYVPVe1fQznphjbUxXP9KZJqPMVnVwCx5s5pr5axRJ8uHkMtZg97eT5kL'
-    const invalidEncryptedKey = 'invalid encrypted key'
-
-    expect(bsNeo3.validateEncrypted(validEncryptedKey)).toBeTruthy()
-    expect(bsNeo3.validateEncrypted(invalidEncryptedKey)).toBeFalsy()
-  })
-
-  it('Should be able to validate a wif', () => {
-    const validWif = 'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP'
-    const invalidWif = 'invalid wif'
-
-    expect(bsNeo3.validateKey(validWif)).toBeTruthy()
-    expect(bsNeo3.validateKey(invalidWif)).toBeFalsy()
-  })
-
-  it('Should be able to validate an domain', () => {
-    const validDomain = 'test.neo'
-    const invalidDomain = 'invalid domain'
-
-    expect(bsNeo3.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
-    expect(bsNeo3.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
-  })
-
-  it('Should be able to generate a mnemonic', () => {
-    expect(() => {
-      const mnemonic = generateMnemonic()
-      expect(mnemonic).toHaveLength(12)
-    }).not.toThrowError()
-  })
-
-  it('Should be able to gererate a account from mnemonic', () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-
-    expect(bsNeo3.validateAddress(account.address)).toBeTruthy()
-    expect(bsNeo3.validateKey(account.key)).toBeTruthy()
-  })
-
-  it('Should be able to generate a account from wif', () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-
-    const accountFromWif = bsNeo3.generateAccountFromKey(account.key)
-    expect(account).toEqual(expect.objectContaining(accountFromWif))
-  })
-
-  it('Should be able to decrypt a encrypted key', async () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-    const password = 'TestPassword'
-    const encryptedKey = await wallet.encrypt(account.key, password)
-    const decryptedAccount = await bsNeo3.decrypt(encryptedKey, password)
-    expect(account).toEqual(expect.objectContaining(decryptedAccount))
-  }, 20000)
-
-  it.skip('Should be able to calculate transfer fee', async () => {
-    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const fee = await bsNeo3.calculateTransferFee({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
-        tokenHash: bsNeo3.feeToken.hash,
-        tokenDecimals: bsNeo3.feeToken.decimals,
-      },
-    })
-
-    expect(fee).toEqual({
-      total: expect.any(Number),
-      networkFee: expect.any(Number),
-      systemFee: expect.any(Number),
-    })
-  })
-
-  it.skip('Should be able to transfer', async () => {
-    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-    const balance = await bsNeo3.blockchainDataService.getBalance(account.address)
-    const gasBalance = balance.find(b => b.token.symbol === bsNeo3.feeToken.symbol)
-    expect(Number(gasBalance?.amount)).toBeGreaterThan(0.00000001)
-
-    const transactionHash = await bsNeo3.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
-        tokenHash: bsNeo3.feeToken.hash,
-        tokenDecimals: bsNeo3.feeToken.decimals,
-      },
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  })
-
-  it.skip('Should be able to claim', async () => {
-    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const maxTries = 10
-    let tries = 0
-
-    while (tries < maxTries) {
-      try {
-        const unclaimed = await bsNeo3.blockchainDataService.getUnclaimed(account.address)
-        if (Number(unclaimed) <= 0) continue
-
-        const transactionHash = await bsNeo3.claim(account)
-        expect(transactionHash).toEqual(expect.any(String))
-        break
-      } catch (error) {
-        await sleep(4000)
-      } finally {
-        tries++
-      }
-    }
-  }, 60000)
-
-  it('Should be able to resolve a name service domain', async () => {
-    const owner = await bsNeo3.resolveNameServiceDomain('neo.neo')
-    expect(owner).toEqual('Nj39M97Rk2e23JiULBBMQmvpcnKaRHqxFf')
-  })
-})
+import { wallet } from '@cityofzion/neon-js'
+import { sleep } from './utils/sleep'
+import { BSNeo3 } from '../BSNeo3'
+import { generateMnemonic } from '@cityofzion/bs-asteroid-sdk'
+
+let bsNeo3: BSNeo3
+
+describe('BSNeo3', () => {
+  beforeAll(() => {
+    bsNeo3 = new BSNeo3('neo3', { type: 'testnet', url: 'https://testnet1.neo.coz.io:443' })
+  })
+
+  it('Should be able to validate an address', () => {
+    const validAddress = 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe'
+    const invalidAddress = 'invalid address'
+
+    expect(bsNeo3.validateAddress(validAddress)).toBeTruthy()
+    expect(bsNeo3.validateAddress(invalidAddress)).toBeFalsy()
+  })
+
+  it('Should be able to validate an encrypted key', () => {
+    const validEncryptedKey = '6PYVPVe1fQznphjbUxXP9KZJqPMVnVwCx5s5pr5axRJ8uHkMtZg97eT5kL'
+    const invalidEncryptedKey = 'invalid encrypted key'
+
+    expect(bsNeo3.validateEncrypted(validEncryptedKey)).toBeTruthy()
+    expect(bsNeo3.validateEncrypted(invalidEncryptedKey)).toBeFalsy()
+  })
+
+  it('Should be able to validate a wif', () => {
+    const validWif = 'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP'
+    const invalidWif = 'invalid wif'
+
+    expect(bsNeo3.validateKey(validWif)).toBeTruthy()
+    expect(bsNeo3.validateKey(invalidWif)).toBeFalsy()
+  })
+
+  it('Should be able to validate an domain', () => {
+    const validDomain = 'test.neo'
+    const invalidDomain = 'invalid domain'
+
+    expect(bsNeo3.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
+    expect(bsNeo3.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
+  })
+
+  it('Should be able to generate a mnemonic', () => {
+    expect(() => {
+      const mnemonic = generateMnemonic()
+      expect(mnemonic).toHaveLength(12)
+    }).not.toThrowError()
+  })
+
+  it('Should be able to gererate a account from mnemonic', () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
+
+    expect(bsNeo3.validateAddress(account.address)).toBeTruthy()
+    expect(bsNeo3.validateKey(account.key)).toBeTruthy()
+  })
+
+  it('Should be able to generate a account from wif', () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
+
+    const accountFromWif = bsNeo3.generateAccountFromKey(account.key)
+    expect(account).toEqual(expect.objectContaining(accountFromWif))
+  })
+
+  it('Should be able to decrypt a encrypted key', async () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
+    const password = 'TestPassword'
+    const encryptedKey = await wallet.encrypt(account.key, password)
+    const decryptedAccount = await bsNeo3.decrypt(encryptedKey, password)
+    expect(account).toEqual(expect.objectContaining(decryptedAccount))
+  }, 20000)
+
+  it.skip('Should be able to calculate transfer fee', async () => {
+    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const fee = await bsNeo3.calculateTransferFee({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
+        tokenHash: bsNeo3.feeToken.hash,
+        tokenDecimals: bsNeo3.feeToken.decimals,
+      },
+    })
+
+    expect(fee).toEqual({
+      total: expect.any(Number),
+      networkFee: expect.any(Number),
+      systemFee: expect.any(Number),
+    })
+  })
+
+  it.skip('Should be able to transfer', async () => {
+    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+    const balance = await bsNeo3.blockchainDataService.getBalance(account.address)
+    const gasBalance = balance.find(b => b.token.symbol === bsNeo3.feeToken.symbol)
+    expect(Number(gasBalance?.amount)).toBeGreaterThan(0.00000001)
+
+    const transactionHash = await bsNeo3.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
+        tokenHash: bsNeo3.feeToken.hash,
+        tokenDecimals: bsNeo3.feeToken.decimals,
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  })
+
+  it.skip('Should be able to claim', async () => {
+    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const maxTries = 10
+    let tries = 0
+
+    while (tries < maxTries) {
+      try {
+        const unclaimed = await bsNeo3.blockchainDataService.getUnclaimed(account.address)
+        if (Number(unclaimed) <= 0) continue
+
+        const transactionHash = await bsNeo3.claim(account)
+        expect(transactionHash).toEqual(expect.any(String))
+        break
+      } catch (error) {
+        await sleep(4000)
+      } finally {
+        tries++
+      }
+    }
+  }, 60000)
+
+  it('Should be able to resolve a name service domain', async () => {
+    const owner = await bsNeo3.resolveNameServiceDomain('neo.neo')
+    expect(owner).toEqual('Nj39M97Rk2e23JiULBBMQmvpcnKaRHqxFf')
+  })
+})

package/src/__tests__/DoraESNeo3.spec.ts

@@ -0,0 +1,23 @@
+import { DoraESNeo3 } from '../DoraESNeo3'
+
+let doraESNeo3: DoraESNeo3
+
+describe('DoraESNeo3', () => {
+  beforeAll(() => {
+    doraESNeo3 = new DoraESNeo3('mainnet')
+  })
+  it('Should return a transaction url', async () => {
+    const hash = '0x775d824a54d4e9bebf3c522a7d8dede550348323d833ce68fbcf0ab953d579e8'
+    const url = doraESNeo3.buildTransactionUrl(hash)
+
+    expect(url).toEqual(`https://dora.coz.io/transaction/neo3/mainnet/${hash}`)
+  })
+
+  it('Should return a nft url', async () => {
+    const contractHash = '0x577a51f7d39162c9de1db12a6b319c848e4c54e5'
+    const tokenId = 'rAI='
+    const url = doraESNeo3.buildNftUrl({ contractHash, tokenId })
+
+    expect(url).toEqual(`https://dora.coz.io/nft/neo3/mainnet/${contractHash}/${tokenId}`)
+  })
+})

package/src/__tests__/FlamingoEDSNeo3.spec.ts

@@ -1,45 +1,48 @@
-import { FlamingoEDSNeo3 } from '../FlamingoEDSNeo3'
-
-let flamingoEDSNeo3: FlamingoEDSNeo3
-
-describe('FlamingoEDSNeo3', () => {
-  beforeAll(() => {
-    flamingoEDSNeo3 = new FlamingoEDSNeo3('mainnet')
-  })
-  it('Should return a list with prices of tokens using USD', async () => {
-    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('USD')
-
-    tokenPriceList.forEach(tokenPrice => {
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return a list with prices of tokens using BRL', async () => {
-    const tokenPriceListInUSD = await flamingoEDSNeo3.getTokenPrices('USD')
-    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('BRL')
-
-    tokenPriceList.forEach((tokenPrice, index) => {
-      expect(tokenPrice.price).toBeGreaterThan(tokenPriceListInUSD[index].price)
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return a list with prices of tokens using EUR', async () => {
-    const tokenPriceListInUSD = await flamingoEDSNeo3.getTokenPrices('USD')
-    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('EUR')
-
-    tokenPriceList.forEach((tokenPrice, index) => {
-      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-      })
-    })
-  })
-})
+import { FlamingoEDSNeo3 } from '../FlamingoEDSNeo3'
+
+let flamingoEDSNeo3: FlamingoEDSNeo3
+
+describe('FlamingoEDSNeo3', () => {
+  beforeAll(() => {
+    flamingoEDSNeo3 = new FlamingoEDSNeo3('mainnet')
+  })
+  it('Should return a list with prices of tokens using USD', async () => {
+    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('USD')
+
+    tokenPriceList.forEach(tokenPrice => {
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+        hash: expect.any(String),
+      })
+    })
+  })
+
+  it('Should return a list with prices of tokens using BRL', async () => {
+    const tokenPriceListInUSD = await flamingoEDSNeo3.getTokenPrices('USD')
+    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('BRL')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeGreaterThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+        hash: expect.any(String),
+      })
+    })
+  })
+
+  it('Should return a list with prices of tokens using EUR', async () => {
+    const tokenPriceListInUSD = await flamingoEDSNeo3.getTokenPrices('USD')
+    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('EUR')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+        hash: expect.any(String),
+      })
+    })
+  })
+})