@cityofzion/bs-ethereum 1.0.4 → 1.2.0

package/CHANGELOG.md

@@ -1,57 +0,0 @@
-# Change Log - @cityofzion/bs-ethereum
-
-This log was last generated on Mon, 04 Mar 2024 21:53:09 GMT and should not be manually modified.
-
-## 1.0.4
-Mon, 04 Mar 2024 21:53:09 GMT
-
-### Patches
-
-- fix wrong calculated fee
-
-## 1.0.3
-Wed, 28 Feb 2024 17:43:01 GMT
-
-### Patches
-
-- Add creator infomations in nft methods return
-
-## 1.0.2
-Tue, 27 Feb 2024 20:29:09 GMT
-
-### Patches
-
-- Remove the mining wait in the transfer method to avoid long promises that take time to resolve.
-
-## 1.0.1
-Thu, 22 Feb 2024 16:49:56 GMT
-
-### Patches
-
-- Fix getTokenPrices that is returning a wrong price for ETH token address
-
-## 1.0.0
-Fri, 16 Feb 2024 16:13:22 GMT
-
-### Breaking changes
-
-- Change bitquery providers to receive apiKey on class initialization
-
-## 0.9.1
-Tue, 30 Jan 2024 18:26:00 GMT
-
-### Patches
-
-- Fixed bug with repeated ETH token in getBalance method
-
-## 0.9.0
-Tue, 05 Dec 2023 18:42:10 GMT
-
-### Minor changes
-
-- Inserted within the TokenPricesResponse type the token hash
-
-### Patches
-
-- Fixed issue with the getBalance method that returned negative numbers and the wrong ETH value
-

package/bs-ethereum.build.log

@@ -1 +0,0 @@
-Invoking: tsc --project tsconfig.build.json 

package/jest.config.ts

@@ -1,13 +0,0 @@
-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

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

package/src/BSEthereum.ts

@@ -1,190 +0,0 @@
-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
-  private readonly bitqueryApiKey: string
-
-  blockchainDataService!: BlockchainDataService
-  exchangeDataService!: ExchangeDataService
-  tokens: Token[]
-  nftDataService!: NftDataService
-  network!: Network
-
-  constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>, bitqueryApiKey: string) {
-    this.blockchainName = blockchainName
-    this.derivationPath = DERIVATION_PATH
-    this.tokens = TOKENS[network.type]
-    this.bitqueryApiKey = bitqueryApiKey
-
-    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.bitqueryApiKey)
-    }
-
-    this.exchangeDataService = new BitqueryEDSEthereum(network.type, this.bitqueryApiKey)
-    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 encrypt(key: string, password: string): Promise<string> {
-    const wallet = new ethers.Wallet(key)
-    return wallet.encrypt(password)
-  }
-
-  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,
-      })
-    }
-
-    return transaction.hash
-  }
-
-  async calculateTransferFee({ senderAccount, intent }: TransferParam): Promise<string> {
-    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
-    const wallet = new ethers.Wallet(senderAccount.key, provider)
-
-    const gasPrice = await provider.getGasPrice()
-
-    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(gasPrice.mul(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

@@ -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
-  }
-}