@cityofzion/bs-ethereum 0.8.2 → 0.9.1

package/src/GhostMarketNDSEthereum.ts

@@ -1,122 +1,121 @@
-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
-  }
-}
+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,
+    }
+
+    return nftResponse
+  }
+}

package/src/RpcBDSEthereum.ts

@@ -1,88 +1,88 @@
-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()
-  }
-}
+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()
+  }
+}

package/src/__tests__/BDSEthereum.spec.ts

@@ -1,123 +1,123 @@
-import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
-import { BitqueryBDSEthereum } from '../BitqueryBDSEthereum'
-import { RpcBDSEthereum } from '../RpcBDSEthereum'
-import { DEFAULT_URL_BY_NETWORK_TYPE } from '../constants'
-
-const bitqueryBDSEthereum = new BitqueryBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
-const rpcBDSEthereum = new RpcBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
-
-describe('BDSEthereum', () => {
-  it.each([rpcBDSEthereum, bitqueryBDSEthereum])(
-    'Should be able to get transaction - %s',
-    async (BDSEthereum: BlockchainDataService) => {
-      const hash = '0x43fa3015d077a13888409cfbd6228df8900abcd5314ff11ea6ce0c49e8b7c94d'
-      const transaction = await BDSEthereum.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.each([bitqueryBDSEthereum])(
-    'Should be able to get transactions of address - %s',
-    async (BDSEthereum: BlockchainDataService) => {
-      const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
-      const response = await BDSEthereum.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.each([bitqueryBDSEthereum, rpcBDSEthereum])(
-    'Should be able to get eth info - %s',
-    async (BDSEthereum: BlockchainDataService) => {
-      const hash = '-'
-      const token = await BDSEthereum.getTokenInfo(hash)
-
-      expect(token).toEqual({
-        symbol: 'ETH',
-        name: 'Ethereum',
-        hash: '-',
-        decimals: 16,
-      })
-    }
-  )
-
-  it.each([bitqueryBDSEthereum])(
-    'Should be able to get token info - %s',
-    async (BDSEthereum: BlockchainDataService) => {
-      const hash = '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc'
-      const token = await BDSEthereum.getTokenInfo(hash)
-
-      expect(token).toEqual({
-        hash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
-        name: 'FaucetToken',
-        symbol: 'FAU',
-        decimals: 18,
-      })
-    }
-  )
-
-  it.each([bitqueryBDSEthereum, rpcBDSEthereum])(
-    'Should be able to get balance - %s',
-    async (BDSEthereum: BlockchainDataService) => {
-      const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
-      const balance = await BDSEthereum.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),
-            },
-          })
-        )
-      })
-    }
-  )
-})
+import { BlockchainDataService } from '@cityofzion/blockchain-service'
+import { BitqueryBDSEthereum } from '../BitqueryBDSEthereum'
+import { RpcBDSEthereum } from '../RpcBDSEthereum'
+import { DEFAULT_URL_BY_NETWORK_TYPE } from '../constants'
+
+const bitqueryBDSEthereum = new BitqueryBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
+const rpcBDSEthereum = new RpcBDSEthereum({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet })
+
+describe('BDSEthereum', () => {
+  it.each([rpcBDSEthereum, bitqueryBDSEthereum])(
+    'Should be able to get transaction - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const hash = '0x43fa3015d077a13888409cfbd6228df8900abcd5314ff11ea6ce0c49e8b7c94d'
+      const transaction = await BDSEthereum.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.each([bitqueryBDSEthereum])(
+    'Should be able to get transactions of address - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
+      const response = await BDSEthereum.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.each([bitqueryBDSEthereum, rpcBDSEthereum])(
+    'Should be able to get eth info - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const hash = '-'
+      const token = await BDSEthereum.getTokenInfo(hash)
+
+      expect(token).toEqual({
+        symbol: 'ETH',
+        name: 'Ethereum',
+        hash: '-',
+        decimals: 16,
+      })
+    }
+  )
+
+  it.each([bitqueryBDSEthereum])(
+    'Should be able to get token info - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const hash = '0xBA62BCfcAaFc6622853cca2BE6Ac7d845BC0f2Dc'
+      const token = await BDSEthereum.getTokenInfo(hash)
+
+      expect(token).toEqual({
+        hash: '0xba62bcfcaafc6622853cca2be6ac7d845bc0f2dc',
+        name: 'FaucetToken',
+        symbol: 'FAU',
+        decimals: 18,
+      })
+    }
+  )
+
+  it.each([bitqueryBDSEthereum, rpcBDSEthereum])(
+    'Should be able to get balance - %s',
+    async (BDSEthereum: BlockchainDataService) => {
+      const address = '0x82B5Cd984880C8A821429cFFf89f36D35BaeBE89'
+      const balance = await BDSEthereum.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),
+            },
+          })
+        )
+      })
+    }
+  )
+})