@cityofzion/bs-ethereum 0.7.0

package/src/RpcBDSEthereum.ts

@@ -0,0 +1,86 @@
+import {
+  BalanceResponse,
+  BlockchainDataService,
+  ContractResponse,
+  Network,
+  Token,
+  TransactionResponse,
+  TransactionsByAddressParams,
+  TransactionsByAddressResponse,
+} from '@cityofzion/blockchain-service'
+import { ethers } from 'ethers'
+import { TOKENS } from './constants'
+
+export class RpcBDSEthereum implements BlockchainDataService {
+  private readonly network: Network
+
+  constructor(network: Network) {
+    this.network = network
+  }
+
+  async getTransaction(hash: string): Promise<TransactionResponse> {
+    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
+
+    const transaction = await provider.getTransaction(hash)
+    if (!transaction || !transaction.blockHash || !transaction.to) throw new Error('Transaction not found')
+
+    const block = await provider.getBlock(transaction.blockHash)
+    if (!block) throw new Error('Block not found')
+
+    const tokens = TOKENS[this.network.type]
+    const token = tokens.find(token => token.symbol === 'ETH')!
+
+    return {
+      block: block.number,
+      time: block.timestamp,
+      hash: transaction.hash,
+      transfers: [
+        {
+          type: 'token',
+          amount: ethers.utils.formatEther(transaction.value),
+          contractHash: '-',
+          from: transaction.from,
+          to: transaction.to,
+          token,
+        },
+      ],
+      notifications: [],
+    }
+  }
+
+  async getTransactionsByAddress(_params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
+    throw new Error("RPC doesn't support get transactions history of address")
+  }
+
+  async getContract(): Promise<ContractResponse> {
+    throw new Error("RPC doesn't support contract info")
+  }
+
+  async getTokenInfo(hash: string): Promise<Token> {
+    const tokens = TOKENS[this.network.type]
+    const token = tokens.find(token => token.hash === hash)
+    if (!token) throw new Error('Token not found')
+
+    return token
+  }
+
+  async getBalance(address: string): Promise<BalanceResponse[]> {
+    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
+    const balance = await provider.getBalance(address)
+
+    const tokens = TOKENS[this.network.type]
+    const token = tokens.find(token => token.symbol === 'ETH')!
+
+    return [
+      {
+        amount: ethers.utils.formatEther(balance),
+        token,
+      },
+    ]
+  }
+
+  async getBlockHeight(): Promise<number> {
+    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
+    return await provider.getBlockNumber()
+  }
+}

package/src/__tests__/BDSEthereum.spec.ts

@@ -0,0 +1,122 @@
+import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
+import { BitqueryBDSEthereum } from '../BitqueryBDSEthereum'
+import { RpcBDSEthereum } from '../RpcBDSEthereum'
+import { DEFAULT_URL_BY_NETWORK_TYPE } from '../constants'
+
+const bitqueryBDSEthereum = new BitqueryBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
+const rpcBDSEthereum = new RpcBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
+
+describe('BDSEthereum', () => {
+  it.each([rpcBDSEthereum, bitqueryBDSEthereum])(
+    'Should be able to get transaction - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const hash = '0x43fa3015d077a13888409cfbd6228df8900abcd5314ff11ea6ce0c49e8b7c94d'
+      const transaction = await BDSEthereum.getTransaction(hash)
+
+      expect(transaction).toEqual(
+        expect.objectContaining({
+          block: expect.any(Number),
+          hash,
+          notifications: [],
+          time: expect.any(Number),
+        })
+      )
+      transaction.transfers.forEach(transfer => {
+        expect(transfer).toEqual(
+          expect.objectContaining({
+            from: expect.any(String),
+            to: expect.any(String),
+            contractHash: expect.any(String),
+            amount: expect.any(String),
+            type: expect.any(String),
+          })
+        )
+      })
+    },
+    10000
+  )
+
+  it.each([bitqueryBDSEthereum])(
+    'Should be able to get transactions of address - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
+      const response = await BDSEthereum.getTransactionsByAddress({ address: address, page: 1 })
+      response.transactions.forEach(transaction => {
+        expect(transaction).toEqual(
+          expect.objectContaining({
+            block: expect.any(Number),
+            hash: expect.any(String),
+            notifications: [],
+            time: expect.any(Number),
+            fee: expect.any(String),
+          })
+        )
+
+        transaction.transfers.forEach(transfer => {
+          expect(transfer).toEqual(
+            expect.objectContaining({
+              from: expect.any(String),
+              to: expect.any(String),
+              contractHash: expect.any(String),
+              amount: expect.any(String),
+              type: expect.any(String),
+            })
+          )
+        })
+      })
+    },
+    10000
+  )
+
+  it.each([bitqueryBDSEthereum, rpcBDSEthereum])(
+    'Should be able to get eth info - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const hash = '-'
+      const token = await BDSEthereum.getTokenInfo(hash)
+
+      expect(token).toEqual({
+        symbol: 'ETH',
+        name: 'Ethereum',
+        hash: '-',
+        decimals: 16,
+      })
+    }
+  )
+
+  it.each([bitqueryBDSEthereum])(
+    'Should be able to get token info - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const hash = '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc'
+      const token = await BDSEthereum.getTokenInfo(hash)
+
+      expect(token).toEqual({
+        hash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
+        name: 'FaucetToken',
+        symbol: 'FAU',
+        decimals: 18,
+      })
+    }
+  )
+
+  it.each([bitqueryBDSEthereum, rpcBDSEthereum])(
+    'Should be able to get balance - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
+      const balance = await BDSEthereum.getBalance(address)
+
+      balance.forEach(balance => {
+        expect(balance).toEqual(
+          expect.objectContaining({
+            amount: expect.any(String),
+            token: {
+              hash: expect.any(String),
+              name: expect.any(String),
+              symbol: expect.any(String),
+              decimals: expect.any(Number),
+            },
+          })
+        )
+      })
+    }
+  )
+})

package/src/__tests__/BSEthereum.spec.ts

@@ -0,0 +1,123 @@
+import { ethers } from 'ethers'
+import { BSEthereum } from '../BSEthereum'
+import { Account } from '@cityofzion/blockchain-service'
+
+let bsEthereum: BSEthereum
+let wallet: ethers.Wallet
+let account: Account
+
+describe('BSEthereum', () => {
+  beforeAll(() => {
+    bsEthereum = new BSEthereum('neo3', { type: 'testnet' })
+    wallet = ethers.Wallet.createRandom()
+    account = {
+      key: wallet.privateKey,
+      type: 'privateKey',
+      address: wallet.address,
+    }
+  })
+
+  it('Should be able to validate an address', () => {
+    const validAddress = '0xD81a8F3c3f8b006Ef1ae4a2Fd28699AD7E3e21C5'
+    const invalidAddress = 'invalid address'
+
+    expect(bsEthereum.validateAddress(validAddress)).toBeTruthy()
+    expect(bsEthereum.validateAddress(invalidAddress)).toBeFalsy()
+  })
+
+  it('Should be able to validate an encrypted key', async () => {
+    const validEncryptedJson = await wallet.encrypt('password')
+    const invalidEncryptedJson = '{ invalid: json }'
+
+    expect(bsEthereum.validateEncrypted(validEncryptedJson)).toBeTruthy()
+    expect(bsEthereum.validateEncrypted(invalidEncryptedJson)).toBeFalsy()
+  })
+
+  it('Should be able to validate a private key', () => {
+    const validKey = wallet.privateKey
+    const invalidKey = 'invalid key'
+
+    expect(bsEthereum.validateKey(validKey)).toBeTruthy()
+    expect(bsEthereum.validateKey(invalidKey)).toBeFalsy()
+  })
+
+  it('Should be able to validate an domain', () => {
+    const validDomain = 'alice.eth'
+    const invalidDomain = 'invalid domain'
+
+    expect(bsEthereum.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
+    expect(bsEthereum.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
+  })
+
+  it('Should be able to generate a account from mnemonic', () => {
+    const account = bsEthereum.generateAccountFromMnemonic(wallet.mnemonic.phrase, 0)
+
+    expect(bsEthereum.validateAddress(account.address)).toBeTruthy()
+    expect(bsEthereum.validateKey(account.key)).toBeTruthy()
+  })
+
+  it('Should be able to generate a account from wif', () => {
+    const accountFromWif = bsEthereum.generateAccountFromKey(wallet.privateKey)
+    expect(accountFromWif).toEqual(account)
+  })
+
+  it('Should be able to decrypt a encrypted key', async () => {
+    const password = 'TestPassword'
+    const validEncryptedJson = await wallet.encrypt(password)
+    const decryptedAccount = await bsEthereum.decrypt(validEncryptedJson, password)
+    expect(decryptedAccount).toEqual(account)
+  })
+
+  it.skip('Should be able to calculate transfer fee', async () => {
+    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const fee = await bsEthereum.calculateTransferFee({
+      senderAccount: account,
+      intent: {
+        amount: '0.1',
+        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
+        tokenDecimals: 18,
+        tokenHash: '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc',
+      },
+    })
+
+    expect(fee).toEqual(expect.any(Number))
+  })
+
+  it.skip('Should be able to transfer a native token', async () => {
+    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const transactionHash = await bsEthereum.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
+        tokenDecimals: 18,
+        tokenHash: '-',
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  }, 50000)
+
+  it.skip('Should be able to transfer a ERC20 token', async () => {
+    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
+
+    const transactionHash = await bsEthereum.transfer({
+      senderAccount: account,
+      intent: {
+        amount: '0.00000001',
+        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
+        tokenDecimals: 18,
+        tokenHash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
+      },
+    })
+
+    expect(transactionHash).toEqual(expect.any(String))
+  }, 50000)
+
+  it('Should be able to resolve a name service domain', async () => {
+    const address = await bsEthereum.resolveNameServiceDomain('alice.eth')
+    expect(address).toEqual('0xa974890156A3649A23a6C0f2ebd77D6F7A7333d4')
+  }, 10000)
+})

package/src/__tests__/BitqueryEDSEthereum.spec.ts

@@ -0,0 +1,46 @@
+import { BitqueryEDSEthereum } from '../BitqueryEDSEthereum'
+
+let bitqueryEDSEthereum: BitqueryEDSEthereum
+
+describe('FlamingoEDSNeo3', () => {
+  beforeAll(() => {
+    bitqueryEDSEthereum = new BitqueryEDSEthereum('mainnet')
+  })
+
+  it('Should return a list with prices of tokens using USD', async () => {
+    const tokenPriceList = await bitqueryEDSEthereum.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 bitqueryEDSEthereum.getTokenPrices('USD')
+    const tokenPriceList = await bitqueryEDSEthereum.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 bitqueryEDSEthereum.getTokenPrices('USD')
+    const tokenPriceList = await bitqueryEDSEthereum.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/__tests__/GhostMarketNDSEthereum.spec.ts

@@ -0,0 +1,45 @@
+import { GhostMarketNDSEthereum } from '../GhostMarketNDSEthereum'
+
+let ghostMarketNDSEthereum: GhostMarketNDSEthereum
+
+describe('GhostMarketNDSEthereum', () => {
+  beforeAll(() => {
+    ghostMarketNDSEthereum = new GhostMarketNDSEthereum('mainnet')
+  })
+
+  it('Get NFT', async () => {
+    const nft = await ghostMarketNDSEthereum.getNft({
+      contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
+      tokenId: '379',
+    })
+
+    expect(nft).toEqual(
+      expect.objectContaining({
+        id: '379',
+        contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
+        symbol: 'MOAR',
+        collectionImage: expect.any(String),
+        collectionName: '"MOAR" by Joan Cornella',
+        image: expect.any(String),
+        isSVG: expect.any(Boolean),
+        name: 'MOAR #379',
+      })
+    )
+  })
+
+  it('Get NFTS by address', async () => {
+    const nfts = await ghostMarketNDSEthereum.getNftsByAddress({
+      address: '0xd773c81a4a855556ce2f2372b12272710b95b26c',
+    })
+    expect(nfts.items.length).toBeGreaterThan(0)
+    nfts.items.forEach(nft => {
+      expect(nft).toEqual(
+        expect.objectContaining({
+          symbol: expect.any(String),
+          id: expect.any(String),
+          contractHash: expect.any(String),
+        })
+      )
+    })
+  })
+})

package/src/assets/tokens/common.json

@@ -0,0 +1,8 @@
+[
+  {
+    "symbol": "ETH",
+    "name": "Ethereum",
+    "hash": "-",
+    "decimals": 16
+  }
+]

package/src/constants.ts

@@ -0,0 +1,37 @@
+import { NetworkType, Token } from '@cityofzion/blockchain-service'
+import commom from './assets/tokens/common.json'
+
+export type BitqueryNetwork = 'ethereum' | 'goerli'
+
+export const TOKENS: Record<NetworkType, Token[]> = {
+  mainnet: [...commom],
+  testnet: commom,
+  custom: commom,
+}
+
+export const NATIVE_ASSETS = commom
+
+export const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string> = {
+  mainnet: 'https://ethereum-mainnet-rpc.allthatnode.com',
+  testnet: 'https://ethereum-goerli-rpc.allthatnode.com',
+  custom: 'http://127.0.0.1:8545',
+}
+
+export const BITQUERY_API_KEY = 'BQYMp76Ny15C8ORbI2BOstFUhoMCahLI'
+export const BITQUERY_URL = 'https://graphql.bitquery.io'
+export const BITQUERY_NETWORK_BY_NETWORK_TYPE: Record<Exclude<NetworkType, 'custom'>, BitqueryNetwork> = {
+  mainnet: 'ethereum',
+  testnet: 'goerli',
+}
+
+export const GHOSTMARKET_URL_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
+  mainnet: 'https://api.ghostmarket.io/api/v2',
+  testnet: 'https://api-testnet.ghostmarket.io/api/v2',
+}
+
+export const GHOSTMARKET_CHAIN_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
+  mainnet: 'eth',
+  testnet: 'etht',
+}
+
+export const DERIVATION_PATH = "m/44'/60'/0'/0/?"