@cityofzion/bs-ethereum 1.1.0 → 1.2.1

package/src/BitqueryBDSEthereum.ts

@@ -1,231 +0,0 @@
-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_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, apiKey: string) {
-    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': apiKey,
-        },
-      },
-    })
-  }
-
-  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 ethToken = NATIVE_ASSETS.find(asset => asset.symbol === 'ETH')!
-
-    const balances: BalanceResponse[] = [
-      {
-        amount: ethBalance.toString(),
-        token: ethToken,
-      },
-    ]
-
-    data.forEach(({ value, currency: { address, decimals, name, symbol } }) => {
-      if (value < 0 || address === ethToken.hash) 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 +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()
-  }
-}