@cityofzion/bs-ethereum 1.1.0 → 1.2.0

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/?"

package/src/graphql.ts

@@ -1,288 +0,0 @@
-import { gql } from '@urql/core'
-
-type BitqueryNetwork = 'ethereum' | 'goerli'
-
-export type BitqueryTransaction = {
-  block: {
-    timestamp: {
-      unixtime: number
-    }
-    height: number
-  }
-  transaction: {
-    gasValue: number
-    hash: string
-  }
-  amount: number
-  currency: {
-    address: string
-    tokenType: string
-    decimals: number
-    symbol: string
-    name: string
-  }
-  sender: {
-    address: string
-  }
-  receiver: {
-    address: string
-  }
-  entityId: string
-}
-
-type BitQueryGetTransactionsByAddressResponse = {
-  ethereum: {
-    sent: BitqueryTransaction[]
-    received: BitqueryTransaction[]
-    sentCount: {
-      count: number
-    }[]
-    receiverCount: {
-      count: number
-    }[]
-  }
-}
-
-type BitQueryGetTransactionsByAddressVariables = {
-  address: string
-  limit: number
-  offset: number
-  network: BitqueryNetwork
-}
-
-export const bitqueryGetTransactionsByAddressQuery = gql<
-  BitQueryGetTransactionsByAddressResponse,
-  BitQueryGetTransactionsByAddressVariables
->`
-  query getTransactions($address: String!, $limit: Int!, $offset: Int!, $network: EthereumNetwork!) {
-    ethereum(network: $network) {
-      sent: transfers(
-        options: { limit: $limit, offset: $offset, desc: "block.timestamp.unixtime" }
-        sender: { is: $address }
-      ) {
-        block {
-          timestamp {
-            unixtime
-          }
-          height
-        }
-        amount
-        currency {
-          address
-          tokenType
-          symbol
-          decimals
-          name
-        }
-        sender {
-          address
-        }
-        receiver {
-          address
-        }
-        transaction {
-          gasValue
-          hash
-        }
-        entityId
-      }
-      received: transfers(
-        options: { limit: $limit, offset: $offset, desc: "block.timestamp.unixtime" }
-        receiver: { is: $address }
-      ) {
-        block {
-          timestamp {
-            unixtime
-          }
-          height
-        }
-        amount
-        currency {
-          address
-          tokenType
-        }
-        sender {
-          address
-        }
-        receiver {
-          address
-        }
-        transaction {
-          gasValue
-          hash
-        }
-        entityId
-      }
-      sentCount: transfers(sender: { is: $address }) {
-        count
-      }
-      receiverCount: transfers(receiver: { is: $address }) {
-        count
-      }
-    }
-  }
-`
-
-type BitQueryGetTransactionResponse = {
-  ethereum: {
-    transfers: BitqueryTransaction[]
-  }
-}
-type BitQueryGetTransactionVariables = {
-  hash: string
-  network: BitqueryNetwork
-}
-export const bitqueryGetTransactionQuery = gql<BitQueryGetTransactionResponse, BitQueryGetTransactionVariables>`
-  query getTransaction($hash: String!, $network: EthereumNetwork!) {
-    ethereum(network: $network) {
-      transfers(txHash: { is: $hash }) {
-        block {
-          timestamp {
-            unixtime
-          }
-          height
-        }
-        amount
-        currency {
-          address
-          tokenType
-        }
-        sender {
-          address
-        }
-        receiver {
-          address
-        }
-        transaction {
-          gasValue
-          hash
-        }
-        entityId
-      }
-    }
-  }
-`
-
-type BitQueryGetContractResponse = {
-  ethereum: {
-    smartContractCalls: {
-      smartContract: {
-        address: {
-          address: string
-        }
-        currency: {
-          symbol: string
-          name: string
-          decimals: number
-          tokenType: string
-        }
-      }
-    }[]
-  }
-}
-type BitQueryGetTokenInfoVariables = {
-  hash: string
-  network: BitqueryNetwork
-}
-export const bitqueryGetTokenInfoQuery = gql<BitQueryGetContractResponse, BitQueryGetTokenInfoVariables>`
-  query getTokenInfo($hash: String!, $network: EthereumNetwork!) {
-    ethereum(network: $network) {
-      smartContractCalls(smartContractAddress: { is: $hash }, options: { limit: 1 }) {
-        smartContract {
-          address {
-            address
-          }
-          currency {
-            symbol
-            name
-            decimals
-            tokenType
-          }
-        }
-      }
-    }
-  }
-`
-
-type BitQueryGetBalanceResponse = {
-  ethereum: {
-    address: {
-      balance: number
-      balances:
-        | {
-            currency: {
-              address: string
-              symbol: string
-              name: string
-              decimals: number
-            }
-            value: number
-          }[]
-        | null
-    }[]
-  }
-}
-type BitQueryGetBalanceVariables = {
-  address: string
-  network: BitqueryNetwork
-}
-export const bitqueryGetBalanceQuery = gql<BitQueryGetBalanceResponse, BitQueryGetBalanceVariables>`
-  query getBalance($address: String!, $network: EthereumNetwork!) {
-    ethereum(network: $network) {
-      address(address: { is: $address }) {
-        balance
-        balances {
-          currency {
-            address
-            symbol
-            name
-            decimals
-          }
-          value
-        }
-      }
-    }
-  }
-`
-type BitQueryGetTokenPricesResponse = {
-  ethereum: {
-    dexTrades: {
-      baseCurrency: {
-        address: string
-        symbol: string
-      }
-      quoteCurrency: {
-        address: string
-        symbol: string
-      }
-      date: {
-        date: string
-      }
-      quotePrice: number
-    }[]
-  }
-}
-export type BitQueryGetTokenPricesVariables = {
-  after: string
-  network: BitqueryNetwork
-}
-export const bitqueryGetPricesQuery = gql<BitQueryGetTokenPricesResponse, BitQueryGetTokenPricesVariables>`
-  query getPrice($after: ISO8601DateTime!, $network: EthereumNetwork!) {
-    ethereum(network: $network) {
-      dexTrades(options: { desc: "date.date" }, time: { after: $after }) {
-        quoteCurrency(quoteCurrency: { is: "0xdac17f958d2ee523a2206206994597c13d831ec7" }) {
-          symbol
-          address
-        }
-        baseCurrency {
-          symbol
-          address
-        }
-        date {
-          date
-        }
-        quotePrice
-      }
-    }
-  }
-`

package/src/index.ts

@@ -1,6 +0,0 @@
-export * from './BSEthereum'
-export * from './GhostMarketNDSEthereum'
-export * from './constants'
-export * from './BitqueryBDSEthereum'
-export * from './BitqueryEDSEthereum'
-export * from './RpcBDSEthereum'

package/tsconfig.build.json

@@ -1,4 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["src/__tests__"]
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "extends": "../../tsconfig.json",
-  "compilerOptions": {
-    "lib": ["ESNext"],
-    "outDir": "./dist",
-    "strict": true
-  },
-  "include": ["src"],
-  "exclude": ["node_modules"],
-  "typedocOptions": {
-    "entryPoints": ["./src/index.ts"],
-    "out": "docs",
-    "exclude": "**/node_modules/**"
-  }
-}