@cityofzion/bs-ethereum 1.1.0 → 1.2.0

package/CHANGELOG.json

@@ -1,126 +0,0 @@
-{
-  "name": "@cityofzion/bs-ethereum",
-  "entries": [
-    {
-      "version": "1.1.0",
-      "tag": "@cityofzion/bs-ethereum_v1.1.0",
-      "date": "Thu, 04 Apr 2024 19:52:20 GMT",
-      "comments": {
-        "minor": [
-          {
-            "comment": "Add ledger support"
-          }
-        ],
-        "patch": [
-          {
-            "comment": "Change Goerli to Sepolia and call RPC using testnet instead of Bitquery"
-          }
-        ],
-        "dependency": [
-          {
-            "comment": "Updating dependency \"@cityofzion/blockchain-service\" to `0.10.0`"
-          }
-        ]
-      }
-    },
-    {
-      "version": "1.0.4",
-      "tag": "@cityofzion/bs-ethereum_v1.0.4",
-      "date": "Mon, 04 Mar 2024 21:53:09 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "fix wrong calculated fee"
-          }
-        ]
-      }
-    },
-    {
-      "version": "1.0.3",
-      "tag": "@cityofzion/bs-ethereum_v1.0.3",
-      "date": "Wed, 28 Feb 2024 17:43:01 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Add creator infomations in nft methods return"
-          }
-        ],
-        "dependency": [
-          {
-            "comment": "Updating dependency \"@cityofzion/blockchain-service\" to `0.9.1`"
-          }
-        ]
-      }
-    },
-    {
-      "version": "1.0.2",
-      "tag": "@cityofzion/bs-ethereum_v1.0.2",
-      "date": "Tue, 27 Feb 2024 20:29:09 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Remove the mining wait in the transfer method to avoid long promises that take time to resolve."
-          }
-        ]
-      }
-    },
-    {
-      "version": "1.0.1",
-      "tag": "@cityofzion/bs-ethereum_v1.0.1",
-      "date": "Thu, 22 Feb 2024 16:49:56 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Fix getTokenPrices that is returning a wrong price for ETH token address"
-          }
-        ]
-      }
-    },
-    {
-      "version": "1.0.0",
-      "tag": "@cityofzion/bs-ethereum_v1.0.0",
-      "date": "Fri, 16 Feb 2024 16:13:22 GMT",
-      "comments": {
-        "major": [
-          {
-            "comment": "Change bitquery providers to receive apiKey on class initialization"
-          }
-        ]
-      }
-    },
-    {
-      "version": "0.9.1",
-      "tag": "@cityofzion/bs-ethereum_v0.9.1",
-      "date": "Tue, 30 Jan 2024 18:26:00 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Fixed bug with repeated ETH token in getBalance method"
-          }
-        ]
-      }
-    },
-    {
-      "version": "0.9.0",
-      "tag": "@cityofzion/bs-ethereum_v0.9.0",
-      "date": "Tue, 05 Dec 2023 18:42:10 GMT",
-      "comments": {
-        "minor": [
-          {
-            "comment": "Inserted within the TokenPricesResponse type the token hash"
-          }
-        ],
-        "patch": [
-          {
-            "comment": "Fixed issue with the getBalance method that returned negative numbers and the wrong ETH value"
-          }
-        ],
-        "dependency": [
-          {
-            "comment": "Updating dependency \"@cityofzion/blockchain-service\" to `0.9.0`"
-          }
-        ]
-      }
-    }
-  ]
-}

package/CHANGELOG.md

@@ -1,68 +0,0 @@
-# Change Log - @cityofzion/bs-ethereum
-
-This log was last generated on Thu, 04 Apr 2024 19:52:20 GMT and should not be manually modified.
-
-## 1.1.0
-Thu, 04 Apr 2024 19:52:20 GMT
-
-### Minor changes
-
-- Add ledger support
-
-### Patches
-
-- Change Goerli to Sepolia and call RPC using testnet instead of Bitquery
-
-## 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,208 +0,0 @@
-import {
-  Account,
-  AccountWithDerivationPath,
-  BSCalculableFee,
-  BSWithLedger,
-  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'
-import { LedgerServiceEthereum } from './LedgerServiceEthereum'
-export class BSEthereum<BSCustomName extends string = string>
-  implements BlockchainService, BSWithNft, BSWithNameService, BSCalculableFee, BSWithLedger
-{
-  readonly blockchainName: BSCustomName
-  readonly feeToken: Token
-  readonly derivationPath: string
-  private readonly bitqueryApiKey: string
-
-  blockchainDataService!: BlockchainDataService
-  exchangeDataService!: ExchangeDataService
-  ledgerService: LedgerServiceEthereum = new LedgerServiceEthereum()
-  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 !== 'mainnet') {
-      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',
-    }
-  }
-
-  generateAccountFromPublicKey(publicKey: string): Account {
-    const address = ethers.utils.computeAddress(publicKey)
-    return {
-      address,
-      key: publicKey,
-      type: 'publicKey',
-    }
-  }
-
-  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(param: TransferParam): Promise<string> {
-    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
-
-    const signTransactionFunction = param.isLedger
-      ? await this.ledgerService.getSignTransactionFunction(param.ledgerTransport)
-      : new ethers.Wallet(param.senderAccount.key, provider).signTransaction
-
-    const decimals = param.intent.tokenDecimals ?? 18
-    const amount = ethersBigNumber.parseFixed(param.intent.amount, decimals)
-
-    let transactionParams: ethers.utils.Deferrable<ethers.providers.TransactionRequest>
-
-    const isNative = NATIVE_ASSETS.some(asset => asset.hash === param.intent.tokenHash)
-    if (isNative) {
-      transactionParams = {
-        to: param.intent.receiverAddress,
-        value: amount,
-      }
-    } else {
-      const contract = new ethers.Contract(param.intent.tokenHash, [
-        'function transfer(address to, uint amount) returns (bool)',
-      ])
-      transactionParams = await contract.populateTransaction.transfer(param.intent.receiverAddress, amount)
-    }
-
-    const voidSigner = new ethers.VoidSigner(param.senderAccount.address, provider)
-    const transaction = await voidSigner.populateTransaction(transactionParams)
-
-    const signedTransaction = await signTransactionFunction(transaction)
-    const transactionResponse = await provider.sendTransaction(signedTransaction)
-    return transactionResponse.hash
-  }
-
-  async calculateTransferFee({ intent }: TransferParam): Promise<string> {
-    const provider = new ethers.providers.JsonRpcProvider(this.network.url)
-
-    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)'],
-        provider
-      )
-
-      estimated = await contract.estimateGas.transfer(intent.receiverAddress, amount)
-    } else {
-      estimated = await provider.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',
-    }
-  }
-}