@cityofzion/bs-ethereum 0.8.0 → 0.8.2

package/src/BitqueryBDSEthereum.ts

@@ -1,220 +1,230 @@
-import {
-  BalanceResponse,
-  ContractResponse,
-  NetworkType,
-  Token,
-  TransactionsByAddressParams,
-  TransactionsByAddressResponse,
-  TransactionResponse,
-  TransactionTransferAsset,
-  TransactionTransferNft,
-  Network,
-} from '@cityofzion/blockchain-service'
-import { Client, fetchExchange } from '@urql/core'
-import fetch from 'node-fetch'
-import { BITQUERY_API_KEY, BITQUERY_NETWORK_BY_NETWORK_TYPE, BITQUERY_URL, TOKENS } from './constants'
-import {
-  BitqueryTransaction,
-  bitqueryGetBalanceQuery,
-  bitqueryGetTokenInfoQuery,
-  bitqueryGetTransactionQuery,
-  bitqueryGetTransactionsByAddressQuery,
-} from './graphql'
-import { RpcBDSEthereum } from './RpcBDSEthereum'
-
-export class BitqueryBDSEthereum extends RpcBDSEthereum {
-  private readonly client: Client
-  private readonly networkType: Exclude<NetworkType, 'custom'>
-
-  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 8
-
-  constructor(network: Network) {
-    super(network)
-
-    if (network.type === 'custom') throw new Error('Custom network not supported')
-    this.networkType = network.type
-
-    this.client = new Client({
-      url: BITQUERY_URL,
-      exchanges: [fetchExchange],
-      fetch,
-      fetchOptions: {
-        headers: {
-          'X-API-KEY': BITQUERY_API_KEY,
-        },
-      },
-    })
-  }
-
-  async getTransaction(hash: string): Promise<TransactionResponse> {
-    const result = await this.client
-      .query(bitqueryGetTransactionQuery, {
-        hash,
-        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
-      })
-      .toPromise()
-    if (result.error) throw new Error(result.error.message)
-    if (!result.data || !result.data.ethereum.transfers.length) throw new Error('Transaction not found')
-
-    const transfers = result.data.ethereum.transfers.map(this.parseTransactionTransfer)
-
-    const {
-      block: {
-        height,
-        timestamp: { unixtime },
-      },
-      transaction: { gasValue, hash: transactionHash },
-    } = result.data.ethereum.transfers[0]
-
-    return {
-      block: height,
-      time: unixtime,
-      hash: transactionHash,
-      fee: String(gasValue),
-      transfers,
-      notifications: [],
-    }
-  }
-
-  async getTransactionsByAddress({
-    address,
-    page = 1,
-  }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
-    const limit = 10
-    const offset = limit * (page - 1)
-
-    const result = await this.client
-      .query(bitqueryGetTransactionsByAddressQuery, {
-        address,
-        limit,
-        offset,
-        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
-      })
-      .toPromise()
-
-    if (result.error) throw new Error(result.error.message)
-    if (!result.data) throw new Error('Address does not have transactions')
-
-    const totalCount =
-      (result.data.ethereum.sentCount[0].count ?? 0) + (result.data.ethereum.receiverCount[0].count ?? 0)
-    const mixedTransfers = [...(result?.data?.ethereum?.sent ?? []), ...(result?.data?.ethereum?.received ?? [])]
-
-    const transactions = new Map<string, TransactionResponse>()
-
-    mixedTransfers.forEach(transfer => {
-      const transactionTransfer = this.parseTransactionTransfer(transfer)
-
-      const existingTransaction = transactions.get(transfer.transaction.hash)
-      if (existingTransaction) {
-        existingTransaction.transfers.push(transactionTransfer)
-        return
-      }
-
-      transactions.set(transfer.transaction.hash, {
-        block: transfer.block.height,
-        hash: transfer.transaction.hash,
-        time: transfer.block.timestamp.unixtime,
-        fee: String(transfer.transaction.gasValue),
-        transfers: [transactionTransfer],
-        notifications: [],
-      })
-    })
-
-    return {
-      totalCount,
-      limit: limit * 2,
-      transactions: Array.from(transactions.values()),
-    }
-  }
-
-  async getContract(): Promise<ContractResponse> {
-    throw new Error("Bitquery doesn't support contract info")
-  }
-
-  async getTokenInfo(hash: string): Promise<Token> {
-    const localToken = TOKENS[this.networkType].find(token => token.hash === hash)
-    if (localToken) return localToken
-
-    const result = await this.client
-      .query(bitqueryGetTokenInfoQuery, {
-        hash,
-        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
-      })
-      .toPromise()
-
-    if (result.error) throw new Error(result.error.message)
-    if (!result.data || result.data.ethereum.smartContractCalls.length <= 0) throw new Error('Token not found')
-
-    const {
-      address: { address },
-      currency: { decimals, name, symbol, tokenType },
-    } = result.data.ethereum.smartContractCalls[0].smartContract
-
-    if (tokenType !== 'ERC20') throw new Error('Token is not ERC20')
-
-    return {
-      hash: address,
-      name,
-      symbol,
-      decimals,
-    }
-  }
-
-  async getBalance(address: string): Promise<BalanceResponse[]> {
-    const result = await this.client
-      .query(bitqueryGetBalanceQuery, {
-        address,
-        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
-      })
-      .toPromise()
-
-    if (result.error) throw new Error(result.error.message)
-    const data = result.data?.ethereum.address[0].balances ?? []
-
-    const balances = data.map(
-      ({ value, currency: { address, decimals, name, symbol } }): BalanceResponse => ({
-        amount: value.toString(),
-        token: {
-          hash: address,
-          symbol,
-          name,
-          decimals,
-        },
-      })
-    )
-
-    return balances
-  }
-
-  private parseTransactionTransfer({
-    amount,
-    currency: { tokenType, address, decimals, name, symbol },
-    entityId,
-    sender,
-    receiver,
-  }: BitqueryTransaction): TransactionTransferAsset | TransactionTransferNft {
-    if (tokenType === 'ERC721') {
-      return {
-        from: sender.address,
-        to: receiver.address,
-        tokenId: entityId,
-        contractHash: address,
-        type: 'nft',
-      }
-    }
-
-    return {
-      from: sender.address,
-      to: receiver.address,
-      contractHash: address,
-      amount: amount.toString(),
-      token: {
-        decimals: decimals,
-        hash: address,
-        name: name,
-        symbol: symbol,
-      },
-      type: 'token',
-    }
-  }
-}
+import {
+  BalanceResponse,
+  ContractResponse,
+  NetworkType,
+  Token,
+  TransactionsByAddressParams,
+  TransactionsByAddressResponse,
+  TransactionResponse,
+  TransactionTransferAsset,
+  TransactionTransferNft,
+  Network,
+} from '@cityofzion/blockchain-service'
+import { Client, fetchExchange } from '@urql/core'
+import fetch from 'node-fetch'
+import { BITQUERY_API_KEY, BITQUERY_NETWORK_BY_NETWORK_TYPE, BITQUERY_URL, NATIVE_ASSETS, TOKENS } from './constants'
+import {
+  BitqueryTransaction,
+  bitqueryGetBalanceQuery,
+  bitqueryGetTokenInfoQuery,
+  bitqueryGetTransactionQuery,
+  bitqueryGetTransactionsByAddressQuery,
+} from './graphql'
+import { RpcBDSEthereum } from './RpcBDSEthereum'
+
+export class BitqueryBDSEthereum extends RpcBDSEthereum {
+  private readonly client: Client
+  private readonly networkType: Exclude<NetworkType, 'custom'>
+
+  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 8
+
+  constructor(network: Network) {
+    super(network)
+
+    if (network.type === 'custom') throw new Error('Custom network not supported')
+    this.networkType = network.type
+
+    this.client = new Client({
+      url: BITQUERY_URL,
+      exchanges: [fetchExchange],
+      fetch,
+      fetchOptions: {
+        headers: {
+          'X-API-KEY': BITQUERY_API_KEY,
+        },
+      },
+    })
+  }
+
+  async getTransaction(hash: string): Promise<TransactionResponse> {
+    const result = await this.client
+      .query(bitqueryGetTransactionQuery, {
+        hash,
+        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+      })
+      .toPromise()
+    if (result.error) throw new Error(result.error.message)
+    if (!result.data || !result.data.ethereum.transfers.length) throw new Error('Transaction not found')
+
+    const transfers = result.data.ethereum.transfers.map(this.parseTransactionTransfer)
+
+    const {
+      block: {
+        height,
+        timestamp: { unixtime },
+      },
+      transaction: { gasValue, hash: transactionHash },
+    } = result.data.ethereum.transfers[0]
+
+    return {
+      block: height,
+      time: unixtime,
+      hash: transactionHash,
+      fee: String(gasValue),
+      transfers,
+      notifications: [],
+    }
+  }
+
+  async getTransactionsByAddress({
+    address,
+    page = 1,
+  }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
+    const limit = 10
+    const offset = limit * (page - 1)
+
+    const result = await this.client
+      .query(bitqueryGetTransactionsByAddressQuery, {
+        address,
+        limit,
+        offset,
+        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+      })
+      .toPromise()
+
+    if (result.error) throw new Error(result.error.message)
+    if (!result.data) throw new Error('Address does not have transactions')
+
+    const totalCount =
+      (result.data.ethereum.sentCount[0].count ?? 0) + (result.data.ethereum.receiverCount[0].count ?? 0)
+    const mixedTransfers = [...(result?.data?.ethereum?.sent ?? []), ...(result?.data?.ethereum?.received ?? [])]
+
+    const transactions = new Map<string, TransactionResponse>()
+
+    mixedTransfers.forEach(transfer => {
+      const transactionTransfer = this.parseTransactionTransfer(transfer)
+
+      const existingTransaction = transactions.get(transfer.transaction.hash)
+      if (existingTransaction) {
+        existingTransaction.transfers.push(transactionTransfer)
+        return
+      }
+
+      transactions.set(transfer.transaction.hash, {
+        block: transfer.block.height,
+        hash: transfer.transaction.hash,
+        time: transfer.block.timestamp.unixtime,
+        fee: String(transfer.transaction.gasValue),
+        transfers: [transactionTransfer],
+        notifications: [],
+      })
+    })
+
+    return {
+      totalCount,
+      limit: limit * 2,
+      transactions: Array.from(transactions.values()),
+    }
+  }
+
+  async getContract(): Promise<ContractResponse> {
+    throw new Error("Bitquery doesn't support contract info")
+  }
+
+  async getTokenInfo(hash: string): Promise<Token> {
+    const localToken = TOKENS[this.networkType].find(token => token.hash === hash)
+    if (localToken) return localToken
+
+    const result = await this.client
+      .query(bitqueryGetTokenInfoQuery, {
+        hash,
+        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+      })
+      .toPromise()
+
+    if (result.error) throw new Error(result.error.message)
+    if (!result.data || result.data.ethereum.smartContractCalls.length <= 0) throw new Error('Token not found')
+
+    const {
+      address: { address },
+      currency: { decimals, name, symbol, tokenType },
+    } = result.data.ethereum.smartContractCalls[0].smartContract
+
+    if (tokenType !== 'ERC20') throw new Error('Token is not ERC20')
+
+    return {
+      hash: address,
+      name,
+      symbol,
+      decimals,
+    }
+  }
+
+  async getBalance(address: string): Promise<BalanceResponse[]> {
+    const result = await this.client
+      .query(bitqueryGetBalanceQuery, {
+        address,
+        network: BITQUERY_NETWORK_BY_NETWORK_TYPE[this.networkType],
+      })
+      .toPromise()
+
+    if (result.error) throw new Error(result.error.message)
+    const data = result.data?.ethereum.address[0].balances ?? []
+    const ethBalance = result.data?.ethereum.address[0].balance ?? 0
+
+    const balances: BalanceResponse[] = [
+      {
+        amount: ethBalance.toString(),
+        token: NATIVE_ASSETS.find(asset => asset.symbol === 'ETH')!,
+      },
+    ]
+
+    data.forEach(({ value, currency: { address, decimals, name, symbol } }) => {
+      if (value < 0) return
+
+      balances.push({
+        amount: value.toString(),
+        token: {
+          hash: address,
+          symbol,
+          name,
+          decimals,
+        },
+      })
+    })
+
+    return balances
+  }
+
+  private parseTransactionTransfer({
+    amount,
+    currency: { tokenType, address, decimals, name, symbol },
+    entityId,
+    sender,
+    receiver,
+  }: BitqueryTransaction): TransactionTransferAsset | TransactionTransferNft {
+    if (tokenType === 'ERC721') {
+      return {
+        from: sender.address,
+        to: receiver.address,
+        tokenId: entityId,
+        contractHash: address,
+        type: 'nft',
+      }
+    }
+
+    return {
+      from: sender.address,
+      to: receiver.address,
+      contractHash: address,
+      amount: amount.toString(),
+      token: {
+        decimals: decimals,
+        hash: address,
+        name: name,
+        symbol: symbol,
+      },
+      type: 'token',
+    }
+  }
+}

package/src/BitqueryEDSEthereum.ts

@@ -1,67 +1,67 @@
-import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service'
-import { Client, fetchExchange } from '@urql/core'
-import fetch from 'node-fetch'
-import { BITQUERY_API_KEY, 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) {
-    this.networkType = networkType
-
-    this.client = new Client({
-      url: BITQUERY_URL,
-      exchanges: [fetchExchange],
-      fetch,
-      fetchOptions: {
-        headers: {
-          'X-API-KEY': BITQUERY_API_KEY,
-        },
-      },
-    })
-  }
-
-  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
-  }
-}
+import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service'
+import { Client, fetchExchange } from '@urql/core'
+import fetch from 'node-fetch'
+import { BITQUERY_API_KEY, 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) {
+    this.networkType = networkType
+
+    this.client = new Client({
+      url: BITQUERY_URL,
+      exchanges: [fetchExchange],
+      fetch,
+      fetchOptions: {
+        headers: {
+          'X-API-KEY': BITQUERY_API_KEY,
+        },
+      },
+    })
+  }
+
+  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
+  }
+}