@cityofzion/bs-ethereum 0.7.0

package/jest.config.ts

@@ -0,0 +1,13 @@
+import { JestConfigWithTsJest } from 'ts-jest'
+const config: JestConfigWithTsJest = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  clearMocks: true,
+  verbose: true,
+  bail: true,
+  testMatch: ['<rootDir>/**/*.spec.ts'],
+  setupFiles: ['<rootDir>/jest.setup.ts'],
+  detectOpenHandles: true,
+}
+
+export default config

package/jest.setup.ts

@@ -0,0 +1 @@
+import 'dotenv/config'

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "@cityofzion/bs-ethereum",
+  "version": "0.7.0",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "repository": "https://github.com/CityOfZion/blockchain-services",
+  "author": "Coz",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "test": "jest --config jest.config.ts"
+  },
+  "dependencies": {
+    "@cityofzion/blockchain-service": "0.7.0",
+    "ethers": "5.7.2",
+    "@urql/core": "~4.1.1",
+    "graphql": "~16.8.0",
+    "node-fetch": "2.6.4",
+    "dayjs": "~1.11.9",
+    "query-string": "7.1.3",
+    "@ethersproject/json-wallets": "5.7.0",
+    "@ethersproject/bytes": "5.7.0",
+    "@ethersproject/bignumber": "5.7.0"
+  },
+  "devDependencies": {
+    "@types/node-fetch": "2.6.4",
+    "ts-node": "10.9.1",
+    "typescript": "4.9.5",
+    "jest": "29.6.2",
+    "ts-jest": "29.1.1",
+    "@types/jest": "29.5.3",
+    "dotenv": "16.3.1"
+  }
+}

package/src/BSEthereum.ts

@@ -0,0 +1,184 @@
+import {
+  Account,
+  AccountWithDerivationPath,
+  BSCalculableFee,
+  BSWithNameService,
+  BSWithNft,
+  BlockchainDataService,
+  BlockchainService,
+  ExchangeDataService,
+  Network,
+  NftDataService,
+  PartialBy,
+  Token,
+  TransferParam,
+} from '@cityofzion/blockchain-service'
+import { ethers } from 'ethers'
+import * as ethersJsonWallets from '@ethersproject/json-wallets'
+import * as ethersBytes from '@ethersproject/bytes'
+import * as ethersBigNumber from '@ethersproject/bignumber'
+import { DEFAULT_URL_BY_NETWORK_TYPE, DERIVATION_PATH, NATIVE_ASSETS, TOKENS } from './constants'
+import { BitqueryEDSEthereum } from './BitqueryEDSEthereum'
+import { GhostMarketNDSEthereum } from './GhostMarketNDSEthereum'
+import { RpcBDSEthereum } from './RpcBDSEthereum'
+import { BitqueryBDSEthereum } from './BitqueryBDSEthereum'
+
+export class BSEthereum<BSCustomName extends string = string>
+  implements BlockchainService, BSWithNft, BSWithNameService, BSCalculableFee
+{
+  readonly blockchainName: BSCustomName
+  readonly feeToken: Token
+  readonly derivationPath: string
+
+  blockchainDataService!: BlockchainDataService
+  exchangeDataService!: ExchangeDataService
+  tokens: Token[]
+  nftDataService!: NftDataService
+  network!: Network
+
+  constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>) {
+    this.blockchainName = blockchainName
+    this.derivationPath = DERIVATION_PATH
+    this.tokens = TOKENS[network.type]
+
+    this.feeToken = this.tokens.find(token => token.symbol === 'ETH')!
+    this.setNetwork(network)
+  }
+
+  setNetwork(param: PartialBy<Network, 'url'>) {
+    const network = {
+      type: param.type,
+      url: param.url ?? DEFAULT_URL_BY_NETWORK_TYPE[param.type],
+    }
+    this.network = network
+
+    if (network.type === 'custom') {
+      this.blockchainDataService = new RpcBDSEthereum(network)
+    } else {
+      this.blockchainDataService = new BitqueryBDSEthereum(network)
+    }
+
+    this.exchangeDataService = new BitqueryEDSEthereum(network.type)
+    this.nftDataService = new GhostMarketNDSEthereum(network.type)
+  }
+
+  validateAddress(address: string): boolean {
+    return ethers.utils.isAddress(address)
+  }
+
+  validateEncrypted(json: string): boolean {
+    return ethersJsonWallets.isCrowdsaleWallet(json) || ethersJsonWallets.isKeystoreWallet(json)
+  }
+
+  validateKey(key: string): boolean {
+    try {
+      if (!key.startsWith('0x')) {
+        key = '0x' + key
+      }
+      if (ethersBytes.hexDataLength(key) !== 32) return false
+
+      return true
+    } catch (error) {
+      return false
+    }
+  }
+
+  validateNameServiceDomainFormat(domainName: string): boolean {
+    if (!domainName.endsWith('.eth')) return false
+    return true
+  }
+
+  generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath {
+    const path = this.derivationPath.replace('?', index.toString())
+    const wallet = ethers.Wallet.fromMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic, path)
+
+    return {
+      address: wallet.address,
+      key: wallet.privateKey,
+      type: 'privateKey',
+      derivationPath: path,
+    }
+  }
+
+  generateAccountFromKey(key: string): Account {
+    const wallet = new ethers.Wallet(key)
+    return {
+      address: wallet.address,
+      key,
+      type: 'privateKey',
+    }
+  }
+
+  async decrypt(json: string, password: string): Promise<Account> {
+    const wallet = await ethers.Wallet.fromEncryptedJson(json, password)
+    return {
+      address: wallet.address,
+      key: wallet.privateKey,
+      type: 'privateKey',
+    }
+  }
+
+  async transfer({ senderAccount, intent }: TransferParam): Promise<string> {
+    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
+    const wallet = new ethers.Wallet(senderAccount.key, provider)
+
+    let transaction: ethers.providers.TransactionResponse
+    const decimals = intent.tokenDecimals ?? 18
+    const amount = ethersBigNumber.parseFixed(intent.amount, decimals)
+
+    const isNative = NATIVE_ASSETS.some(asset => asset.hash === intent.tokenHash)
+    if (!isNative) {
+      const contract = new ethers.Contract(
+        intent.tokenHash,
+        ['function transfer(address to, uint amount) returns (bool)'],
+        wallet
+      )
+      transaction = await contract.transfer(intent.receiverAddress, amount)
+    } else {
+      transaction = await wallet.sendTransaction({
+        to: intent.receiverAddress,
+        value: amount,
+      })
+    }
+
+    const transactionMined = await transaction.wait()
+    if (!transactionMined) throw new Error('Transaction not mined')
+
+    return transactionMined.transactionHash
+  }
+
+  async calculateTransferFee({ senderAccount, intent }: TransferParam, details?: boolean | undefined): Promise<string> {
+    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
+    const wallet = new ethers.Wallet(senderAccount.key, provider)
+
+    let estimated: ethers.BigNumber
+
+    const isNative = NATIVE_ASSETS.some(asset => asset.hash === intent.tokenHash)
+    const decimals = intent.tokenDecimals ?? 18
+    const amount = ethersBigNumber.parseFixed(intent.amount, decimals)
+
+    if (!isNative) {
+      const contract = new ethers.Contract(
+        intent.tokenHash,
+        ['function transfer(address to, uint amount) returns (bool)'],
+        wallet
+      )
+
+      estimated = await contract.estimateGas.transfer(intent.receiverAddress, amount)
+    } else {
+      estimated = await wallet.estimateGas({
+        to: intent.receiverAddress,
+        value: amount,
+      })
+    }
+
+    return ethers.utils.formatEther(estimated)
+  }
+
+  async resolveNameServiceDomain(domainName: string): Promise<string> {
+    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
+    const address = await provider.resolveName(domainName)
+    if (!address) throw new Error('No address found for domain name')
+    return address
+  }
+}

package/src/BitqueryBDSEthereum.ts

@@ -0,0 +1,217 @@
+import {
+  BalanceResponse,
+  ContractResponse,
+  NetworkType,
+  Token,
+  TransactionsByAddressParams,
+  TransactionsByAddressResponse,
+  TransactionResponse,
+  TransactionTransferAsset,
+  TransactionTransferNft,
+  Network,
+} from '@cityofzion/blockchain-service'
+import { Client, cacheExchange, fetchExchange, gql } 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'>
+
+  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: [cacheExchange, 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.count ?? 0) + (result.data.ethereum.receiverCount.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',
+    }
+  }
+}

package/src/BitqueryEDSEthereum.ts

@@ -0,0 +1,66 @@
+import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service'
+import { Client, cacheExchange, fetchExchange, gql } 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: [cacheExchange, 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,
+      })
+    )
+
+    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

@@ -0,0 +1,122 @@
+import {
+  BlockchainService,
+  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, page }: 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,
+    }
+
+    return nftResponse
+  }
+}