@cityofzion/bs-neo-legacy 0.4.1 → 0.7.0

package/src/DoraBDSNeoLegacy.ts

@@ -0,0 +1,171 @@
+import {
+  BalanceResponse,
+  BlockchainDataService,
+  ContractResponse,
+  TransactionsByAddressParams,
+  TransactionsByAddressResponse,
+  TransactionResponse,
+  BDSClaimable,
+  TransactionTransferAsset,
+  Token,
+  NetworkType,
+  Network,
+} from '@cityofzion/blockchain-service'
+import { api } from '@cityofzion/dora-ts'
+import { TOKENS } from './constants'
+import { rpc } from '@cityofzion/neon-js'
+
+export class DoraBDSNeoLegacy implements BlockchainDataService, BDSClaimable {
+  readonly network: Network
+  private readonly claimToken: Token
+  private readonly feeToken: Token
+  private readonly tokenCache: Map<string, Token> = new Map()
+
+  constructor(network: Network, feeToken: Token, claimToken: Token) {
+    if (network.type === 'custom') throw new Error('Custom network is not supported for NEO Legacy')
+    this.network = network
+    this.claimToken = claimToken
+    this.feeToken = feeToken
+  }
+
+  async getTransaction(hash: string): Promise<TransactionResponse> {
+    const data = await api.NeoLegacyREST.transaction(hash, this.network.type)
+    if (!data || 'error' in data) throw new Error(`Transaction ${hash} not found`)
+
+    const vout: any[] = data.vout ?? []
+
+    const promises = vout.map<Promise<TransactionTransferAsset>>(async (transfer, _index, array) => {
+      const token = await this.getTokenInfo(transfer.asset)
+      return {
+        amount: String(transfer.value),
+        from: array[array.length - 1]?.address,
+        contractHash: transfer.asset,
+        to: transfer.address,
+        type: 'token',
+        token,
+      }
+    })
+    const transfers = await Promise.all(promises)
+
+    return {
+      hash: data.txid,
+      block: data.block,
+      fee: (Number(data.sys_fee ?? 0) + Number(data.net_fee ?? 0)).toFixed(this.feeToken.decimals),
+      time: Number(data.time),
+      notifications: [], //neoLegacy doesn't have notifications
+      transfers,
+    }
+  }
+
+  async getTransactionsByAddress({
+    address,
+    page = 1,
+  }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
+    const data = await api.NeoLegacyREST.getAddressAbstracts(address, page, this.network.type)
+    const transactions = new Map<string, TransactionResponse>()
+
+    const promises = data.entries.map(async entry => {
+      if (entry.address_from !== address && entry.address_to !== address) return
+
+      const token = await this.getTokenInfo(entry.asset)
+      const transfer: TransactionTransferAsset = {
+        amount: String(entry.amount),
+        from: entry.address_from ?? 'Mint',
+        to: entry.address_to ?? 'Burn',
+        type: 'token',
+        contractHash: entry.asset,
+        token,
+      }
+      const existingTransaction = transactions.get(entry.txid)
+      if (existingTransaction) {
+        existingTransaction.transfers.push(transfer)
+        return
+      }
+
+      transactions.set(entry.txid, {
+        block: entry.block_height,
+        hash: entry.txid,
+        time: entry.time,
+        transfers: [transfer],
+        notifications: [],
+      })
+    })
+    await Promise.all(promises)
+
+    return {
+      totalCount: data.total_entries,
+      limit: data.page_size,
+      transactions: Array.from(transactions.values()),
+    }
+  }
+
+  async getContract(contractHash: string): Promise<ContractResponse> {
+    const response = await api.NeoLegacyREST.contract(contractHash, this.network.type)
+    if (!response || 'error' in response) throw new Error(`Contract ${contractHash} not found`)
+
+    return {
+      hash: response.hash,
+      name: response.name,
+      methods: [],
+    }
+  }
+
+  async getTokenInfo(tokenHash: string): Promise<Token> {
+    const localToken = TOKENS[this.network.type].find(token => token.hash === tokenHash)
+    if (localToken) return localToken
+
+    if (this.tokenCache.has(tokenHash)) {
+      return this.tokenCache.get(tokenHash)!
+    }
+
+    const data = await api.NeoLegacyREST.asset(tokenHash, this.network.type)
+    if (!data || 'error' in data) throw new Error(`Token ${tokenHash} not found`)
+
+    const token = {
+      decimals: data.decimals,
+      symbol: data.symbol,
+      hash: data.scripthash,
+      name: data.name,
+    }
+
+    this.tokenCache.set(tokenHash, token)
+
+    return token
+  }
+
+  async getBalance(address: string): Promise<BalanceResponse[]> {
+    const data = await api.NeoLegacyREST.balance(address, this.network.type)
+
+    const promises = data.map<Promise<BalanceResponse>>(async balance => {
+      let token: Token = {
+        hash: balance.asset,
+        name: balance.asset_name,
+        symbol: balance.symbol,
+        decimals: 8,
+      }
+
+      try {
+        token = await this.getTokenInfo(balance.asset)
+      } catch {}
+
+      return {
+        amount: (Number(balance.balance) / 10 ** token.decimals).toFixed(token.decimals),
+        token,
+      }
+    })
+
+    const result = await Promise.all(promises)
+
+    return result
+  }
+
+  async getUnclaimed(address: string): Promise<string> {
+    const { unclaimed } = await api.NeoLegacyREST.getUnclaimed(address, this.network.type)
+    return (unclaimed / 10 ** this.claimToken.decimals).toFixed(this.claimToken.decimals)
+  }
+
+  async getBlockHeight(): Promise<number> {
+    const rpcClient = new rpc.RPCClient(this.network.url)
+    return await rpcClient.getBlockCount()
+  }
+}

package/src/__tests__/BDSNeoLegacy.spec.ts

@@ -0,0 +1,120 @@
+import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
+import { DoraBDSNeoLegacy } from '../DoraBDSNeoLegacy'
+import { DEFAULT_URL_BY_NETWORK_TYPE, TOKENS } from '../constants'
+
+const gasToken = TOKENS.testnet.find(t => t.symbol === 'GAS')!
+let doraBDSNeoLegacy = new DoraBDSNeoLegacy(
+  { type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet },
+  gasToken,
+  gasToken
+)
+
+describe('BDSNeoLegacy', () => {
+  it.each([doraBDSNeoLegacy])('Should be able to get transaction - %s', async (bdsNeoLegacy: BlockchainDataService) => {
+    const hash = '0x6632e79b1e5182355bcc1f3ca0e91d11a426c893734cd266e7bf3d3f74618add'
+    const transaction = await bdsNeoLegacy.getTransaction(hash)
+    expect(transaction).toEqual(
+      expect.objectContaining({
+        block: expect.any(Number),
+        hash,
+        notifications: [],
+        transfers: expect.arrayContaining([
+          expect.objectContaining({
+            amount: expect.any(String),
+            from: expect.any(String),
+            to: expect.any(String),
+            type: 'token',
+          }),
+        ]),
+        time: expect.any(Number),
+        fee: expect.any(String),
+      })
+    )
+  })
+
+  it.each([doraBDSNeoLegacy])(
+    'Should be able to get history transactions - %s',
+    async (bdsNeoLegacy: BlockchainDataService) => {
+      const address = 'AeGgZTTWPzyVtNiQRcpngkV75Xip1hznmi'
+      try {
+        const response = await bdsNeoLegacy.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(Number),
+                  from: expect.any(String),
+                  to: expect.any(String),
+                  type: 'asset',
+                }),
+              ]),
+              time: expect.any(Number),
+              fee: expect.any(String),
+            })
+          )
+        })
+      } catch {}
+    }
+  )
+
+  it.each([doraBDSNeoLegacy])('Should be able to get contract - %s', async (bdsNeoLegacy: BlockchainDataService) => {
+    const hash = '0x998a0da7ec5f21c9a99ef5349f81af8af89f9644'
+    const contract = await bdsNeoLegacy.getContract(hash)
+    expect(contract).toEqual({
+      hash: hash,
+      name: 'Phantasma Stake',
+      methods: [],
+    })
+  })
+
+  it.each([doraBDSNeoLegacy])('Should be able to get token info - %s', async (bdsNeoLegacy: BlockchainDataService) => {
+    const hash = '0x602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7'
+    const token = await bdsNeoLegacy.getTokenInfo(hash)
+    expect(token).toEqual({
+      decimals: 8,
+      hash: hash,
+      name: 'GAS',
+      symbol: 'GAS',
+    })
+  })
+
+  it.each([doraBDSNeoLegacy])('Should be able to get balance - %s', async (bdsNeoLegacy: BlockchainDataService) => {
+    const address = 'AeGgZTTWPzyVtNiQRcpngkV75Xip1hznmi'
+    const balance = await bdsNeoLegacy.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([doraBDSNeoLegacy])(
+    'Should be able to get unclaimed - %s',
+    async (doraBDSNeoLegacy: BlockchainDataService & BDSClaimable) => {
+      const address = 'AeGgZTTWPzyVtNiQRcpngkV75Xip1hznmi'
+      const unclaimed = await doraBDSNeoLegacy.getUnclaimed(address)
+      expect(unclaimed).toEqual(expect.any(String))
+    }
+  )
+})

package/src/__tests__/BSNeoLegacy.spec.ts

@@ -0,0 +1,127 @@
+import { BSNeoLegacy } from '../BSNeoLegacy'
+import { wallet } from '@cityofzion/neon-js'
+import { generateMnemonic } from '@cityofzion/bs-asteroid-sdk'
+
+let bsNeoLegacy: BSNeoLegacy
+
+describe('BSNeoLegacy', () => {
+  beforeEach(() => {
+    bsNeoLegacy = new BSNeoLegacy('neoLegacy', { type: 'testnet', url: 'http://seed5.ngd.network:20332' })
+  })
+
+  it('Should be able to validate an address', () => {
+    const validAddress = 'AJDZ8QP7ydjFicpcXCkG7wczeWEAKxpF69'
+    const invalidAddress = 'invalid address'
+
+    expect(bsNeoLegacy.validateAddress(validAddress)).toBeTruthy()
+    expect(bsNeoLegacy.validateAddress(invalidAddress)).toBeFalsy()
+  })
+
+  it('Should be able to validate an encrypted key', () => {
+    const validEncryptedKey = '6PYSsRjFn1v5uu79h5vXGZEYvvRkioHmd1Fd5bUyVp9Gt2wJcLKWHgD6Hy'
+    const invalidEncryptedKey = 'invalid encrypted key'
+
+    expect(bsNeoLegacy.validateEncrypted(validEncryptedKey)).toBeTruthy()
+    expect(bsNeoLegacy.validateEncrypted(invalidEncryptedKey)).toBeFalsy()
+  })
+
+  it('Should be able to validate a wif', () => {
+    const validWif = 'L4ZnhLegkFV9FTys1wBJDHUykn5hLnr15cPqvfuy4E1kzWTE6iRM'
+    const invalidWif = 'invalid wif'
+
+    expect(bsNeoLegacy.validateKey(validWif)).toBeTruthy()
+    expect(bsNeoLegacy.validateKey(invalidWif)).toBeFalsy()
+  })
+
+  it('Should be able to gererate a account from mnemonic', () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeoLegacy.generateAccountFromMnemonic(mnemonic, 0)
+
+    expect(bsNeoLegacy.validateAddress(account.address)).toBeTruthy()
+    expect(bsNeoLegacy.validateKey(account.key)).toBeTruthy()
+  })
+
+  it('Should be able to generate a account from wif', () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeoLegacy.generateAccountFromMnemonic(mnemonic, 0)
+
+    const accountFromWif = bsNeoLegacy.generateAccountFromKey(account.key)
+    expect(account).toEqual(expect.objectContaining(accountFromWif))
+  })
+
+  it('Should be able to decrypt a encrypted key', async () => {
+    const mnemonic = generateMnemonic()
+    const account = bsNeoLegacy.generateAccountFromMnemonic(mnemonic, 0)
+    const password = 'TestPassword'
+    const encryptedKey = await wallet.encrypt(account.key, password)
+    const decryptedAccount = await bsNeoLegacy.decrypt(encryptedKey, password)
+    expect(account).toEqual(expect.objectContaining(decryptedAccount))
+  }, 10000)
+
+  it.skip('Should be able to transfer a native asset', async () => {
+    const account = bsNeoLegacy.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+    const balance = await bsNeoLegacy.blockchainDataService.getBalance(account.address)
+    const gasBalance = balance.find(b => b.token.symbol === 'GAS')!
+    expect(Number(gasBalance?.amount)).toBeGreaterThan(0.00000001)
+
+    const transactionHash = await bsNeoLegacy.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: 'AQEQdmCcitFbE6oJU5Epa7dNxhTkCmTZST',
+        tokenHash: gasBalance.token.hash,
+        tokenDecimals: gasBalance.token.decimals,
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  })
+
+  it.skip('Should be able to transfer a nep5 asset', async () => {
+    bsNeoLegacy.setNetwork({ type: 'mainnet', url: 'http://seed9.ngd.network:10332' })
+    const account = bsNeoLegacy.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+    const balance = await bsNeoLegacy.blockchainDataService.getBalance(account.address)
+    const LXBalance = balance.find(item => item.token.symbol === 'LX')!
+    expect(Number(LXBalance?.amount)).toBeGreaterThan(0.00000001)
+
+    const transactionHash = await bsNeoLegacy.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: 'AQEQdmCcitFbE6oJU5Epa7dNxhTkCmTZST',
+        tokenHash: LXBalance.token.hash,
+        tokenDecimals: LXBalance.token.decimals,
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  })
+
+  it.skip('Should be able to transfer a asset with tip', async () => {
+    bsNeoLegacy.setNetwork({ type: 'mainnet', url: 'http://seed9.ngd.network:10332' })
+    const account = bsNeoLegacy.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+    const balance = await bsNeoLegacy.blockchainDataService.getBalance(account.address)
+    const LXBalance = balance.find(item => item.token.symbol === 'LX')!
+    expect(Number(LXBalance?.amount)).toBeGreaterThan(0.00000001)
+    const gasBalance = balance.find(item => item.token.symbol === bsNeoLegacy.feeToken.symbol)!
+    expect(Number(gasBalance?.amount)).toBeGreaterThan(0.00000001)
+
+    const transactionHash = await bsNeoLegacy.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: 'AQEQdmCcitFbE6oJU5Epa7dNxhTkCmTZST',
+        tokenHash: LXBalance.token.hash,
+        tokenDecimals: LXBalance.token.decimals,
+      },
+      tipIntent: {
+        amount: '0.00000001',
+        receiverAddress: 'AQEQdmCcitFbE6oJU5Epa7dNxhTkCmTZST',
+        tokenHash: gasBalance.token.hash,
+        tokenDecimals: gasBalance.token.decimals,
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  })
+})

package/src/__tests__/CryptoCompareExchange.spec.ts

@@ -0,0 +1,46 @@
+import { CryptoCompareEDSNeoLegacy } from '../CryptoCompareEDSNeoLegacy'
+
+let cryptoCompareEDSNeoLegacy: CryptoCompareEDSNeoLegacy
+
+describe('FlamingoEDSNeo3', () => {
+  beforeAll(() => {
+    cryptoCompareEDSNeoLegacy = new CryptoCompareEDSNeoLegacy('mainnet')
+  })
+
+  it('Should return a list with prices of tokens using USD', async () => {
+    const tokenPriceList = await cryptoCompareEDSNeoLegacy.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 cryptoCompareEDSNeoLegacy.getTokenPrices('USD')
+    const tokenPriceList = await cryptoCompareEDSNeoLegacy.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 cryptoCompareEDSNeoLegacy.getTokenPrices('USD')
+    const tokenPriceList = await cryptoCompareEDSNeoLegacy.getTokenPrices('EUR')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+      })
+    })
+  })
+})

package/src/assets/tokens/common.json

@@ -0,0 +1,18 @@
+[
+  {
+    "symbol": "GAS",
+    "type": "UtilityToken",
+    "name": "GAS",
+    "hash": "602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7",
+    "decimals": 8,
+    "blockchain": "neoLegacy"
+  },
+  {
+    "symbol": "NEO",
+    "type": "GoverningToken",
+    "name": "NEO",
+    "hash": "c56f33fc6ecfcd0c225c4ab356fee59390af8560be0e930faebe74a6daff7c9b",
+    "decimals": 0,
+    "blockchain": "neoLegacy"
+  }
+]