@cityofzion/bs-ethereum 1.1.0 → 1.2.0

package/src/BitqueryEDSEthereum.ts

@@ -1,67 +0,0 @@
-import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service'
-import { Client, fetchExchange } from '@urql/core'
-import fetch from 'node-fetch'
-import { BITQUERY_URL } from './constants'
-import dayjs from 'dayjs'
-import utc from 'dayjs/plugin/utc'
-import { bitqueryGetPricesQuery } from './graphql'
-
-dayjs.extend(utc)
-export class BitqueryEDSEthereum implements ExchangeDataService {
-  private readonly client: Client
-  private readonly networkType: NetworkType
-
-  constructor(networkType: NetworkType, apiKey: string) {
-    this.networkType = networkType
-
-    this.client = new Client({
-      url: BITQUERY_URL,
-      exchanges: [fetchExchange],
-      fetch,
-      fetchOptions: {
-        headers: {
-          'X-API-KEY': apiKey,
-        },
-      },
-    })
-  }
-
-  async getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]> {
-    if (this.networkType !== 'mainnet') throw new Error('Exchange is only available on mainnet')
-
-    const twoDaysAgo = dayjs.utc().subtract(2, 'day').startOf('date').toISOString()
-
-    const result = await this.client
-      .query(bitqueryGetPricesQuery, { after: twoDaysAgo, network: 'ethereum' })
-      .toPromise()
-    if (result.error) {
-      throw new Error(result.error.message)
-    }
-    if (!result.data) {
-      throw new Error('There is no price data')
-    }
-
-    let currencyRatio: number = 1
-    if (currency !== 'USD') {
-      currencyRatio = await this.getCurrencyRatio(currency)
-    }
-
-    const prices = result.data.ethereum.dexTrades.map(
-      (trade): TokenPricesResponse => ({
-        symbol: trade.baseCurrency.symbol,
-        price: trade.quotePrice * currencyRatio,
-        hash: trade.baseCurrency.address,
-      })
-    )
-
-    return prices
-  }
-
-  private async getCurrencyRatio(currency: Currency): Promise<number> {
-    const request = await fetch(`https://api.flamingo.finance/fiat/exchange-rate?pair=USD_${currency}`, {
-      method: 'GET',
-    })
-    const data = await request.json()
-    return data
-  }
-}

package/src/GhostMarketNDSEthereum.ts

@@ -1,125 +0,0 @@
-import {
-  NftResponse,
-  NftsResponse,
-  NetworkType,
-  NftDataService,
-  GetNftParam,
-  GetNftsByAddressParams,
-} from '@cityofzion/blockchain-service'
-import qs from 'query-string'
-
-import { GHOSTMARKET_CHAIN_BY_NETWORK_TYPE, GHOSTMARKET_URL_BY_NETWORK_TYPE } from './constants'
-import fetch from 'node-fetch'
-
-type GhostMarketNFT = {
-  tokenId: string
-  contract: {
-    chain?: string
-    hash: string
-    symbol: string
-  }
-  creator: {
-    address: string
-    offchainName?: string
-  }
-  apiUrl?: string
-  ownerships: {
-    owner: {
-      address?: string
-    }
-  }[]
-  collection: {
-    name?: string
-    logoUrl?: string
-  }
-  metadata: {
-    description: string
-    mediaType: string
-    mediaUri: string
-    mintDate: number
-    mintNumber: number
-    name: string
-  }
-}
-
-type GhostMarketAssets = {
-  assets: GhostMarketNFT[]
-  next: string
-}
-export class GhostMarketNDSEthereum implements NftDataService {
-  private networkType: NetworkType
-
-  constructor(networkType: NetworkType) {
-    this.networkType = networkType
-  }
-
-  async getNftsByAddress({ address, size = 18, cursor }: GetNftsByAddressParams): Promise<NftsResponse> {
-    const url = this.getUrlWithParams({
-      size,
-      owners: [address],
-      cursor: cursor,
-    })
-
-    const request = await fetch(url, { method: 'GET' })
-    const data = (await request.json()) as GhostMarketAssets
-    const nfts = data.assets ?? []
-
-    return { nextCursor: data.next, items: nfts.map(this.parse.bind(this)) }
-  }
-
-  async getNft({ contractHash, tokenId }: GetNftParam): Promise<NftResponse> {
-    const url = this.getUrlWithParams({
-      contract: contractHash,
-      tokenIds: [tokenId],
-    })
-
-    const request = await fetch(url, { method: 'GET' })
-    const data = (await request.json()) as GhostMarketAssets
-
-    return this.parse(data.assets[0])
-  }
-
-  private treatGhostMarketImage(srcImage?: string) {
-    if (!srcImage) {
-      return
-    }
-
-    if (srcImage.startsWith('ipfs://')) {
-      const [, imageId] = srcImage.split('://')
-
-      return `https://ghostmarket.mypinata.cloud/ipfs/${imageId}`
-    }
-
-    return srcImage
-  }
-
-  private getUrlWithParams(params: any) {
-    const parameters = qs.stringify(
-      {
-        chain: GHOSTMARKET_CHAIN_BY_NETWORK_TYPE[this.networkType],
-        ...params,
-      },
-      { arrayFormat: 'bracket' }
-    )
-    return `${GHOSTMARKET_URL_BY_NETWORK_TYPE[this.networkType]}/assets?${parameters}`
-  }
-
-  private parse(data: GhostMarketNFT) {
-    const nftResponse: NftResponse = {
-      collectionImage: this.treatGhostMarketImage(data.collection?.logoUrl),
-      id: data.tokenId,
-      contractHash: data.contract.hash,
-      symbol: data.contract.symbol,
-      collectionName: data.collection?.name,
-      image: this.treatGhostMarketImage(data.metadata.mediaUri),
-      isSVG: String(data.metadata.mediaType).includes('svg+xml'),
-      name: data.metadata.name,
-      creator: {
-        address: data.creator.address,
-        name: data.creator.offchainName,
-      },
-    }
-
-    return nftResponse
-  }
-}

package/src/LedgerServiceEthereum.ts

@@ -1,44 +0,0 @@
-import { LedgerService } from '@cityofzion/blockchain-service'
-import Transport from '@ledgerhq/hw-transport'
-import LedgerEthereumApp, { ledgerService as LedgerEthereumAppService } from '@ledgerhq/hw-app-eth'
-import { ethers } from 'ethers'
-
-export class LedgerServiceEthereum implements LedgerService {
-  private readonly defaultPath = "44'/60'/0'/0/0"
-
-  async getAddress(transport: Transport): Promise<string> {
-    const ledgerApp = new LedgerEthereumApp(transport)
-    const { address } = await ledgerApp.getAddress(this.defaultPath)
-
-    return address
-  }
-
-  async getPublicKey(transport: Transport): Promise<string> {
-    const ledgerApp = new LedgerEthereumApp(transport)
-    const { publicKey } = await ledgerApp.getAddress(this.defaultPath)
-
-    return '0x' + publicKey
-  }
-
-  async getSignTransactionFunction(transport: Transport) {
-    return async (transaction: ethers.providers.TransactionRequest): Promise<string> => {
-      const ledgerApp = new LedgerEthereumApp(transport)
-
-      const unsignedTransaction: ethers.utils.UnsignedTransaction = {
-        ...transaction,
-        nonce: transaction.nonce ? ethers.BigNumber.from(transaction.nonce).toNumber() : undefined,
-      }
-
-      const serializedUnsignedTransaction = ethers.utils.serializeTransaction(unsignedTransaction).substring(2)
-
-      const resolution = await LedgerEthereumAppService.resolveTransaction(serializedUnsignedTransaction, {}, {})
-      const signature = await ledgerApp.signTransaction(this.defaultPath, serializedUnsignedTransaction, resolution)
-
-      return ethers.utils.serializeTransaction(unsignedTransaction, {
-        v: ethers.BigNumber.from('0x' + signature.v).toNumber(),
-        r: '0x' + signature.r,
-        s: '0x' + signature.s,
-      })
-    }
-  }
-}

package/src/RpcBDSEthereum.ts

@@ -1,88 +0,0 @@
-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
-
-  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 5
-
-  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__/BSEthereum.spec.ts

@@ -1,172 +0,0 @@
-import { ethers } from 'ethers'
-import { BSEthereum } from '../BSEthereum'
-import { Account } from '@cityofzion/blockchain-service'
-import TransportNodeHid from '@ledgerhq/hw-transport-node-hid'
-
-let bsEthereum: BSEthereum
-let wallet: ethers.Wallet
-let account: Account
-
-describe('BSEthereum', () => {
-  beforeAll(() => {
-    bsEthereum = new BSEthereum('neo3', { type: 'testnet' }, process.env.BITQUERY_API_KEY as string)
-    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 bsEthereum.encrypt(wallet.privateKey, password)
-    const decryptedAccount = await bsEthereum.decrypt(validEncryptedJson, password)
-    expect(decryptedAccount).toEqual(account)
-  })
-
-  it('Should be able to encrypt key', async () => {
-    const password = 'TestPassword'
-    const validEncryptedJson = await bsEthereum.encrypt(wallet.privateKey, password)
-    expect(JSON.parse(validEncryptedJson)).toEqual(
-      expect.objectContaining({ address: wallet.address.replace('0x', '').toLowerCase() })
-    )
-  })
-
-  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(String))
-  }, 50000)
-
-  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.skip('Should be able to transfer a native token with ledger', async () => {
-    const transport = await TransportNodeHid.create()
-    const publicKey = await bsEthereum.ledgerService.getPublicKey(transport)
-    const account = bsEthereum.generateAccountFromPublicKey(publicKey)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89',
-        tokenDecimals: 18,
-        tokenHash: '-',
-      },
-      isLedger: true,
-      ledgerTransport: transport,
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it.skip('Should be able to transfer a ERC20 token with ledger', async () => {
-    const transport = await TransportNodeHid.create()
-    const publicKey = await bsEthereum.ledgerService.getPublicKey(transport)
-    const account = bsEthereum.generateAccountFromPublicKey(publicKey)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89',
-        tokenDecimals: 18,
-        tokenHash: '0xcf185f2F3Fe19D82bFdcee59E3330FD7ba5f27ce',
-      },
-      isLedger: true,
-      ledgerTransport: transport,
-    })
-
-    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__/BitqueryBDSEthereum.spec.ts

@@ -1,106 +0,0 @@
-import { BitqueryBDSEthereum } from '../BitqueryBDSEthereum'
-import { DEFAULT_URL_BY_NETWORK_TYPE } from '../constants'
-
-const bitqueryBDSEthereum = new BitqueryBDSEthereum(
-  { type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet },
-  process.env.BITQUERY_API_KEY as string
-)
-
-describe('BitqueryBDSEthereum', () => {
-  it('Should be able to get transaction - %s', async () => {
-    const hash = '0x43fa3015d077a13888409cfbd6228df8900abcd5314ff11ea6ce0c49e8b7c94d'
-    const transaction = await bitqueryBDSEthereum.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('Should be able to get transactions of address - %s', async () => {
-    const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
-    const response = await bitqueryBDSEthereum.getTransactionsByAddress({ address: address, page: 1 })
-    expect(response.totalCount).toBeGreaterThan(0)
-    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('Should be able to get eth info - %s', async () => {
-    const hash = '-'
-    const token = await bitqueryBDSEthereum.getTokenInfo(hash)
-
-    expect(token).toEqual({
-      symbol: 'ETH',
-      name: 'Ethereum',
-      hash: '-',
-      decimals: 18,
-    })
-  })
-
-  it('Should be able to get token info - %s', async () => {
-    const hash = '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc'
-    const token = await bitqueryBDSEthereum.getTokenInfo(hash)
-
-    expect(token).toEqual({
-      hash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
-      name: 'FaucetToken',
-      symbol: 'FAU',
-      decimals: 18,
-    })
-  })
-
-  it('Should be able to get balance - %s', async () => {
-    const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
-    const balance = await bitqueryBDSEthereum.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__/BitqueryEDSEthereum.spec.ts

@@ -1,55 +0,0 @@
-import { BitqueryEDSEthereum } from '../BitqueryEDSEthereum'
-
-let bitqueryEDSEthereum: BitqueryEDSEthereum
-
-describe('FlamingoEDSNeo3', () => {
-  beforeAll(() => {
-    bitqueryEDSEthereum = new BitqueryEDSEthereum('mainnet', process.env.BITQUERY_API_KEY as string)
-  })
-
-  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),
-        hash: 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),
-        hash: 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),
-        hash: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return the ETH price in USD', async () => {
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('USD')
-
-    expect(tokenPriceList).toEqual(expect.arrayContaining([{ symbol: 'ETH', hash: '-', price: expect.any(Number) }]))
-  })
-})