@cityofzion/bs-ethereum 1.1.0 → 1.2.1

package/src/__tests__/BSEthereum.spec.ts

@@ -1,172 +0,0 @@
-import { ethers } from 'ethers'
-import { BSEthereum } from '../BSEthereum'
-import { Account } from '@cityofzion/blockchain-service'
-import TransportNodeHid from '@ledgerhq/hw-transport-node-hid'
-
-let bsEthereum: BSEthereum
-let wallet: ethers.Wallet
-let account: Account
-
-describe('BSEthereum', () => {
-  beforeAll(() => {
-    bsEthereum = new BSEthereum('neo3', { type: 'testnet' }, process.env.BITQUERY_API_KEY as string)
-    wallet = ethers.Wallet.createRandom()
-    account = {
-      key: wallet.privateKey,
-      type: 'privateKey',
-      address: wallet.address,
-    }
-  })
-
-  it('Should be able to validate an address', () => {
-    const validAddress = '0xD81a8F3c3f8b006Ef1ae4a2Fd28699AD7E3e21C5'
-    const invalidAddress = 'invalid address'
-
-    expect(bsEthereum.validateAddress(validAddress)).toBeTruthy()
-    expect(bsEthereum.validateAddress(invalidAddress)).toBeFalsy()
-  })
-
-  it('Should be able to validate an encrypted key', async () => {
-    const validEncryptedJson = await wallet.encrypt('password')
-    const invalidEncryptedJson = '{ invalid: json }'
-
-    expect(bsEthereum.validateEncrypted(validEncryptedJson)).toBeTruthy()
-    expect(bsEthereum.validateEncrypted(invalidEncryptedJson)).toBeFalsy()
-  })
-
-  it('Should be able to validate a private key', () => {
-    const validKey = wallet.privateKey
-    const invalidKey = 'invalid key'
-
-    expect(bsEthereum.validateKey(validKey)).toBeTruthy()
-    expect(bsEthereum.validateKey(invalidKey)).toBeFalsy()
-  })
-
-  it('Should be able to validate an domain', () => {
-    const validDomain = 'alice.eth'
-    const invalidDomain = 'invalid domain'
-
-    expect(bsEthereum.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
-    expect(bsEthereum.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
-  })
-
-  it('Should be able to generate a account from mnemonic', () => {
-    const account = bsEthereum.generateAccountFromMnemonic(wallet.mnemonic.phrase, 0)
-
-    expect(bsEthereum.validateAddress(account.address)).toBeTruthy()
-    expect(bsEthereum.validateKey(account.key)).toBeTruthy()
-  })
-
-  it('Should be able to generate a account from wif', () => {
-    const accountFromWif = bsEthereum.generateAccountFromKey(wallet.privateKey)
-    expect(accountFromWif).toEqual(account)
-  })
-
-  it('Should be able to decrypt a encrypted key', async () => {
-    const password = 'TestPassword'
-    const validEncryptedJson = await bsEthereum.encrypt(wallet.privateKey, password)
-    const decryptedAccount = await bsEthereum.decrypt(validEncryptedJson, password)
-    expect(decryptedAccount).toEqual(account)
-  })
-
-  it('Should be able to encrypt key', async () => {
-    const password = 'TestPassword'
-    const validEncryptedJson = await bsEthereum.encrypt(wallet.privateKey, password)
-    expect(JSON.parse(validEncryptedJson)).toEqual(
-      expect.objectContaining({ address: wallet.address.replace('0x', '').toLowerCase() })
-    )
-  })
-
-  it.skip('Should be able to calculate transfer fee', async () => {
-    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const fee = await bsEthereum.calculateTransferFee({
-      senderAccount: account,
-      intent: {
-        amount: '0.1',
-        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
-        tokenDecimals: 18,
-        tokenHash: '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc',
-      },
-    })
-
-    expect(fee).toEqual(expect.any(String))
-  }, 50000)
-
-  it.skip('Should be able to transfer a native token', async () => {
-    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
-        tokenDecimals: 18,
-        tokenHash: '-',
-      },
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it.skip('Should be able to transfer a ERC20 token', async () => {
-    const account = bsEthereum.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0xFACf5446B71dB33E920aB1769d9427146183aEcd',
-        tokenDecimals: 18,
-        tokenHash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
-      },
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it.skip('Should be able to transfer a native token with ledger', async () => {
-    const transport = await TransportNodeHid.create()
-    const publicKey = await bsEthereum.ledgerService.getPublicKey(transport)
-    const account = bsEthereum.generateAccountFromPublicKey(publicKey)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89',
-        tokenDecimals: 18,
-        tokenHash: '-',
-      },
-      isLedger: true,
-      ledgerTransport: transport,
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it.skip('Should be able to transfer a ERC20 token with ledger', async () => {
-    const transport = await TransportNodeHid.create()
-    const publicKey = await bsEthereum.ledgerService.getPublicKey(transport)
-    const account = bsEthereum.generateAccountFromPublicKey(publicKey)
-
-    const transactionHash = await bsEthereum.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89',
-        tokenDecimals: 18,
-        tokenHash: '0xcf185f2F3Fe19D82bFdcee59E3330FD7ba5f27ce',
-      },
-      isLedger: true,
-      ledgerTransport: transport,
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 50000)
-
-  it('Should be able to resolve a name service domain', async () => {
-    const address = await bsEthereum.resolveNameServiceDomain('alice.eth')
-    expect(address).toEqual('0xa974890156A3649A23a6C0f2ebd77D6F7A7333d4')
-  }, 10000)
-})

package/src/__tests__/BitqueryBDSEthereum.spec.ts

@@ -1,106 +0,0 @@
-import { BitqueryBDSEthereum } from '../BitqueryBDSEthereum'
-import { DEFAULT_URL_BY_NETWORK_TYPE } from '../constants'
-
-const bitqueryBDSEthereum = new BitqueryBDSEthereum(
-  { type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet },
-  process.env.BITQUERY_API_KEY as string
-)
-
-describe('BitqueryBDSEthereum', () => {
-  it('Should be able to get transaction - %s', async () => {
-    const hash = '0x43fa3015d077a13888409cfbd6228df8900abcd5314ff11ea6ce0c49e8b7c94d'
-    const transaction = await bitqueryBDSEthereum.getTransaction(hash)
-
-    expect(transaction).toEqual(
-      expect.objectContaining({
-        block: expect.any(Number),
-        hash,
-        notifications: [],
-        time: expect.any(Number),
-      })
-    )
-    transaction.transfers.forEach(transfer => {
-      expect(transfer).toEqual(
-        expect.objectContaining({
-          from: expect.any(String),
-          to: expect.any(String),
-          contractHash: expect.any(String),
-          amount: expect.any(String),
-          type: expect.any(String),
-        })
-      )
-    })
-  }, 10000)
-
-  it('Should be able to get transactions of address - %s', async () => {
-    const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
-    const response = await bitqueryBDSEthereum.getTransactionsByAddress({ address: address, page: 1 })
-    expect(response.totalCount).toBeGreaterThan(0)
-    response.transactions.forEach(transaction => {
-      expect(transaction).toEqual(
-        expect.objectContaining({
-          block: expect.any(Number),
-          hash: expect.any(String),
-          notifications: [],
-          time: expect.any(Number),
-          fee: expect.any(String),
-        })
-      )
-
-      transaction.transfers.forEach(transfer => {
-        expect(transfer).toEqual(
-          expect.objectContaining({
-            from: expect.any(String),
-            to: expect.any(String),
-            contractHash: expect.any(String),
-            amount: expect.any(String),
-            type: expect.any(String),
-          })
-        )
-      })
-    })
-  }, 10000)
-
-  it('Should be able to get eth info - %s', async () => {
-    const hash = '-'
-    const token = await bitqueryBDSEthereum.getTokenInfo(hash)
-
-    expect(token).toEqual({
-      symbol: 'ETH',
-      name: 'Ethereum',
-      hash: '-',
-      decimals: 18,
-    })
-  })
-
-  it('Should be able to get token info - %s', async () => {
-    const hash = '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc'
-    const token = await bitqueryBDSEthereum.getTokenInfo(hash)
-
-    expect(token).toEqual({
-      hash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
-      name: 'FaucetToken',
-      symbol: 'FAU',
-      decimals: 18,
-    })
-  })
-
-  it('Should be able to get balance - %s', async () => {
-    const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
-    const balance = await bitqueryBDSEthereum.getBalance(address)
-
-    balance.forEach(balance => {
-      expect(balance).toEqual(
-        expect.objectContaining({
-          amount: expect.any(String),
-          token: {
-            hash: expect.any(String),
-            name: expect.any(String),
-            symbol: expect.any(String),
-            decimals: expect.any(Number),
-          },
-        })
-      )
-    })
-  })
-})

package/src/__tests__/BitqueryEDSEthereum.spec.ts

@@ -1,55 +0,0 @@
-import { BitqueryEDSEthereum } from '../BitqueryEDSEthereum'
-
-let bitqueryEDSEthereum: BitqueryEDSEthereum
-
-describe('FlamingoEDSNeo3', () => {
-  beforeAll(() => {
-    bitqueryEDSEthereum = new BitqueryEDSEthereum('mainnet', process.env.BITQUERY_API_KEY as string)
-  })
-
-  it('Should return a list with prices of tokens using USD', async () => {
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('USD')
-
-    tokenPriceList.forEach(tokenPrice => {
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-        hash: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return a list with prices of tokens using BRL', async () => {
-    const tokenPriceListInUSD = await bitqueryEDSEthereum.getTokenPrices('USD')
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('BRL')
-
-    tokenPriceList.forEach((tokenPrice, index) => {
-      expect(tokenPrice.price).toBeGreaterThan(tokenPriceListInUSD[index].price)
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-        hash: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return a list with prices of tokens using EUR', async () => {
-    const tokenPriceListInUSD = await bitqueryEDSEthereum.getTokenPrices('USD')
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('EUR')
-
-    tokenPriceList.forEach((tokenPrice, index) => {
-      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
-      expect(tokenPrice).toEqual({
-        price: expect.any(Number),
-        symbol: expect.any(String),
-        hash: expect.any(String),
-      })
-    })
-  })
-
-  it('Should return the ETH price in USD', async () => {
-    const tokenPriceList = await bitqueryEDSEthereum.getTokenPrices('USD')
-
-    expect(tokenPriceList).toEqual(expect.arrayContaining([{ symbol: 'ETH', hash: '-', price: expect.any(Number) }]))
-  })
-})

package/src/__tests__/GhostMarketNDSEthereum.spec.ts

@@ -1,49 +0,0 @@
-import { GhostMarketNDSEthereum } from '../GhostMarketNDSEthereum'
-
-let ghostMarketNDSEthereum: GhostMarketNDSEthereum
-
-describe('GhostMarketNDSEthereum', () => {
-  beforeAll(() => {
-    ghostMarketNDSEthereum = new GhostMarketNDSEthereum('mainnet')
-  })
-
-  it('Get NFT', async () => {
-    const nft = await ghostMarketNDSEthereum.getNft({
-      contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
-      tokenId: '379',
-    })
-
-    expect(nft).toEqual(
-      expect.objectContaining({
-        id: '379',
-        contractHash: '0xeb3a9a839dfeeaf71db1b4ed6a8ae0ccb171b227',
-        symbol: 'MOAR',
-        collectionImage: expect.any(String),
-        collectionName: '"MOAR" by Joan Cornella',
-        image: expect.any(String),
-        isSVG: expect.any(Boolean),
-        name: 'MOAR #379',
-        creator: {
-          address: '0xd71ef31e9d4e8674d9177c28cc2d0d633580615b',
-          name: undefined,
-        },
-      })
-    )
-  })
-
-  it('Get NFTS by address', async () => {
-    const nfts = await ghostMarketNDSEthereum.getNftsByAddress({
-      address: '0xd773c81a4a855556ce2f2372b12272710b95b26c',
-    })
-    expect(nfts.items.length).toBeGreaterThan(0)
-    nfts.items.forEach(nft => {
-      expect(nft).toEqual(
-        expect.objectContaining({
-          symbol: expect.any(String),
-          id: expect.any(String),
-          contractHash: expect.any(String),
-        })
-      )
-    })
-  })
-})

package/src/__tests__/RpcBDSEthereum.spec.ts

@@ -1,62 +0,0 @@
-import { RpcBDSEthereum } from '../RpcBDSEthereum'
-import { DEFAULT_URL_BY_NETWORK_TYPE } from '../constants'
-
-const rpcBDSEthereum = new RpcBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
-
-describe('RpcBDSEthereum', () => {
-  it('Should be able to get transaction', async () => {
-    const hash = '0x48eac645fac2280d7ac89a319372d7a38d52516f8b3003574bfaaed31b471ff3'
-    const transaction = await rpcBDSEthereum.getTransaction(hash)
-
-    expect(transaction).toEqual(
-      expect.objectContaining({
-        block: expect.any(Number),
-        hash,
-        notifications: [],
-        time: expect.any(Number),
-      })
-    )
-    transaction.transfers.forEach(transfer => {
-      expect(transfer).toEqual(
-        expect.objectContaining({
-          from: expect.any(String),
-          to: expect.any(String),
-          contractHash: expect.any(String),
-          amount: expect.any(String),
-          type: expect.any(String),
-        })
-      )
-    })
-  })
-
-  it('Should be able to get eth info', async () => {
-    const hash = '-'
-    const token = await rpcBDSEthereum.getTokenInfo(hash)
-
-    expect(token).toEqual({
-      symbol: 'ETH',
-      name: 'Ethereum',
-      hash: '-',
-      decimals: 18,
-    })
-  })
-
-  it('Should be able to get balance', async () => {
-    const address = '0xbA65F285D1F9E0bf76Ab01211547979a3b60011A'
-    const balance = await rpcBDSEthereum.getBalance(address)
-
-    balance.forEach(balance => {
-      expect(balance).toEqual(
-        expect.objectContaining({
-          amount: expect.any(String),
-          token: {
-            hash: expect.any(String),
-            name: expect.any(String),
-            symbol: expect.any(String),
-            decimals: expect.any(Number),
-          },
-        })
-      )
-    })
-  })
-})

package/src/assets/tokens/common.json

@@ -1,8 +0,0 @@
-[
-  {
-    "symbol": "ETH",
-    "name": "Ethereum",
-    "hash": "-",
-    "decimals": 18
-  }
-]

package/src/constants.ts

@@ -1,36 +0,0 @@
-import { NetworkType, Token } from '@cityofzion/blockchain-service'
-import commom from './assets/tokens/common.json'
-
-export type BitqueryNetwork = 'ethereum' | 'goerli'
-
-export const TOKENS: Record<NetworkType, Token[]> = {
-  mainnet: [...commom],
-  testnet: commom,
-  custom: commom,
-}
-
-export const NATIVE_ASSETS = commom
-
-export const DEFAULT_URL_BY_NETWORK_TYPE: Record<NetworkType, string> = {
-  mainnet: 'https://ethereum-mainnet-rpc.allthatnode.com',
-  testnet: 'https://ethereum-sepolia-rpc.publicnode.com',
-  custom: 'http://127.0.0.1:8545',
-}
-
-export const BITQUERY_URL = 'https://graphql.bitquery.io'
-export const BITQUERY_NETWORK_BY_NETWORK_TYPE: Record<Exclude<NetworkType, 'custom'>, BitqueryNetwork> = {
-  mainnet: 'ethereum',
-  testnet: 'goerli',
-}
-
-export const GHOSTMARKET_URL_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
-  mainnet: 'https://api.ghostmarket.io/api/v2',
-  testnet: 'https://api-testnet.ghostmarket.io/api/v2',
-}
-
-export const GHOSTMARKET_CHAIN_BY_NETWORK_TYPE: Partial<Record<NetworkType, string>> = {
-  mainnet: 'eth',
-  testnet: 'etht',
-}
-
-export const DERIVATION_PATH = "m/44'/60'/0'/0/?"