@cityofzion/bs-neo3 0.10.0 → 0.11.1

package/src/GhostMarketNDSNeo3.ts

@@ -1,121 +0,0 @@
-import {
-  NftResponse,
-  NftsResponse,
-  NetworkType,
-  NftDataService,
-  GetNftParam,
-  GetNftsByAddressParams,
-} from '@cityofzion/blockchain-service'
-import qs from 'query-string'
-import axios from 'axios'
-
-import { GHOSTMARKET_CHAIN_BY_NETWORK_TYPE, GHOSTMARKET_URL_BY_NETWORK_TYPE } from './constants'
-
-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 GhostMarketNDSNeo3 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 { data } = await axios.get<GhostMarketAssets>(url)
-    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 { data } = await axios.get<GhostMarketAssets>(url)
-    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: Record<string, 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
-  }
-}

package/src/LedgerServiceNeo3.ts

@@ -1,107 +0,0 @@
-import { LedgerService } from '@cityofzion/blockchain-service'
-import Transport from '@ledgerhq/hw-transport'
-import { wallet, api, u } from '@cityofzion/neon-js'
-import { NeonParser } from '@cityofzion/neon-dappkit'
-
-export class LedgerServiceNeo3 implements LedgerService {
-  async getAddress(transport: Transport): Promise<string> {
-    const publicKey = await this.getPublicKey(transport)
-    const { address } = new wallet.Account(publicKey)
-
-    return address
-  }
-
-  getSigningCallback(transport: Transport): api.SigningFunction {
-    return async (transaction, { witnessIndex, network }) => {
-      const publicKey = await this.getPublicKey(transport)
-      const account = new wallet.Account(publicKey)
-
-      const witnessScriptHash = wallet.getScriptHashFromVerificationScript(
-        transaction.witnesses[witnessIndex].verificationScript.toString()
-      )
-
-      if (account.scriptHash !== witnessScriptHash) {
-        throw new Error('Invalid witness script hash')
-      }
-
-      const signature = await this.getSignature(transport, transaction.serialize(false), network, witnessIndex)
-
-      return signature
-    }
-  }
-
-  async getSignature(transport: Transport, serializedTransaction: string, networkMagic: number, addressIndex = 0) {
-    const bip44Buffer = this.toBip44Buffer(addressIndex)
-    await transport.send(0x80, 0x02, 0, 0x80, bip44Buffer, [0x9000])
-    await transport.send(0x80, 0x02, 1, 0x80, Buffer.from(NeonParser.numToHex(networkMagic, 4, true), 'hex'), [0x9000])
-
-    const chunks = serializedTransaction.match(/.{1,510}/g) || []
-
-    for (let i = 0; i < chunks.length - 1; i++) {
-      await transport.send(0x80, 0x02, 2 + i, 0x80, Buffer.from(chunks[i], 'hex'), [0x9000])
-    }
-
-    const response = await transport.send(
-      0x80,
-      0x02,
-      2 + chunks.length,
-      0x00,
-      Buffer.from(chunks[chunks.length - 1], 'hex'),
-      [0x9000]
-    )
-
-    if (response.length <= 2) {
-      throw new Error(`No more data but Ledger did not return signature!`)
-    }
-
-    return this.derSignatureToHex(response.toString('hex'))
-  }
-
-  async getPublicKey(transport: Transport, addressIndex = 0): Promise<string> {
-    const bip44Buffer = this.toBip44Buffer(addressIndex)
-
-    const result = await transport.send(0x80, 0x04, 0x00, 0x00, bip44Buffer, [0x9000])
-    const publicKey = result.toString('hex').substring(0, 130)
-
-    return publicKey
-  }
-
-  private toBip44Buffer(addressIndex = 0, changeIndex = 0, accountIndex = 0) {
-    const accountHex = this.to8BitHex(accountIndex + 0x80000000)
-    const changeHex = this.to8BitHex(changeIndex)
-    const addressHex = this.to8BitHex(addressIndex)
-
-    return Buffer.from('8000002C' + '80000378' + accountHex + changeHex + addressHex, 'hex')
-  }
-
-  private to8BitHex(num: number): string {
-    const hex = num.toString(16)
-    return '0'.repeat(8 - hex.length) + hex
-  }
-
-  private derSignatureToHex(response: string): string {
-    const ss = new u.StringStream(response)
-    // The first byte is format. It is usually 0x30 (SEQ) or 0x31 (SET)
-    // The second byte represents the total length of the DER module.
-    ss.read(2)
-    // Now we read each field off
-    // Each field is encoded with a type byte, length byte followed by the data itself
-    ss.read(1) // Read and drop the type
-    const r = ss.readVarBytes()
-    ss.read(1)
-    const s = ss.readVarBytes()
-
-    // We will need to ensure both integers are 32 bytes long
-    const integers = [r, s].map(i => {
-      if (i.length < 64) {
-        i = '0'.repeat(i.length - 64) + i
-      }
-      if (i.length > 64) {
-        i = i.substr(-64)
-      }
-      return i
-    })
-
-    return integers.join('')
-  }
-}

package/src/RpcBDSNeo3.ts

@@ -1,161 +0,0 @@
-import {
-  BDSClaimable,
-  BalanceResponse,
-  BlockchainDataService,
-  ContractMethod,
-  ContractParameter,
-  ContractResponse,
-  Network,
-  Token,
-  TransactionResponse,
-  TransactionsByAddressParams,
-  TransactionsByAddressResponse,
-} from '@cityofzion/blockchain-service'
-import { rpc, u } from '@cityofzion/neon-core'
-import { NeonInvoker, TypeChecker } from '@cityofzion/neon-dappkit'
-import { TOKENS } from './constants'
-
-export class RPCBDSNeo3 implements BlockchainDataService, BDSClaimable {
-  protected readonly tokenCache: Map<string, Token> = new Map()
-  protected readonly feeToken: Token
-  protected readonly claimToken: Token
-  readonly network: Network
-
-  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 2
-
-  constructor(network: Network, feeToken: Token, claimToken: Token) {
-    this.network = network
-    this.feeToken = feeToken
-    this.claimToken = claimToken
-  }
-
-  async getTransaction(hash: string): Promise<TransactionResponse> {
-    try {
-      const rpcClient = new rpc.RPCClient(this.network.url)
-      const response = await rpcClient.getRawTransaction(hash, true)
-
-      return {
-        hash: response.hash,
-        block: response.validuntilblock,
-        fee: u.BigInteger.fromNumber(response.netfee ?? 0)
-          .add(u.BigInteger.fromNumber(response.sysfee ?? 0))
-          .toDecimal(this.feeToken.decimals),
-        notifications: [],
-        transfers: [],
-        time: response.blocktime,
-      }
-    } catch {
-      throw new Error(`Transaction not found: ${hash}`)
-    }
-  }
-
-  async getTransactionsByAddress(_params: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
-    throw new Error('Method not supported.')
-  }
-
-  async getContract(contractHash: string): Promise<ContractResponse> {
-    try {
-      const rpcClient = new rpc.RPCClient(this.network.url)
-      const contractState = await rpcClient.getContractState(contractHash)
-
-      const methods = contractState.manifest.abi.methods.map<ContractMethod>(method => ({
-        name: method.name,
-        parameters: method.parameters.map<ContractParameter>(parameter => ({
-          name: parameter.name,
-          type: parameter.type,
-        })),
-      }))
-
-      return {
-        hash: contractState.hash,
-        name: contractState.manifest.name,
-        methods,
-      }
-    } catch {
-      throw new Error(`Contract not found: ${contractHash}`)
-    }
-  }
-
-  async getTokenInfo(tokenHash: string): Promise<Token> {
-    const localToken = TOKENS[this.network.type].find(token => token.hash === tokenHash)
-    if (localToken) return localToken
-
-    if (this.tokenCache.has(tokenHash)) {
-      return this.tokenCache.get(tokenHash)!
-    }
-    try {
-      const rpcClient = new rpc.RPCClient(this.network.url)
-      const contractState = await rpcClient.getContractState(tokenHash)
-
-      const invoker = await NeonInvoker.init({
-        rpcAddress: this.network.url,
-      })
-
-      const response = await invoker.testInvoke({
-        invocations: [
-          {
-            scriptHash: tokenHash,
-            operation: 'decimals',
-            args: [],
-          },
-          { scriptHash: tokenHash, operation: 'symbol', args: [] },
-        ],
-      })
-
-      if (!TypeChecker.isStackTypeInteger(response.stack[0])) throw new Error('Invalid decimals')
-      if (!TypeChecker.isStackTypeByteString(response.stack[1])) throw new Error('Invalid symbol')
-      const decimals = Number(response.stack[0].value)
-      const symbol = u.base642utf8(response.stack[1].value)
-      const token = {
-        name: contractState.manifest.name,
-        symbol,
-        hash: contractState.hash,
-        decimals,
-      }
-
-      this.tokenCache.set(tokenHash, token)
-
-      return token
-    } catch {
-      throw new Error(`Token not found: ${tokenHash}`)
-    }
-  }
-
-  async getBalance(address: string): Promise<BalanceResponse[]> {
-    const rpcClient = new rpc.RPCClient(this.network.url)
-    const response = await rpcClient.getNep17Balances(address)
-
-    const promises = response.balance.map<Promise<BalanceResponse>>(async balance => {
-      let token: Token = {
-        hash: balance.assethash,
-        name: '-',
-        symbol: '-',
-        decimals: 8,
-      }
-      try {
-        token = await this.getTokenInfo(balance.assethash)
-      } catch {
-        // Empty Block
-      }
-
-      return {
-        amount: u.BigInteger.fromNumber(balance.amount).toDecimal(token?.decimals ?? 8),
-        token,
-      }
-    })
-    const balances = await Promise.all(promises)
-
-    return balances
-  }
-
-  async getBlockHeight(): Promise<number> {
-    const rpcClient = new rpc.RPCClient(this.network.url)
-    return await rpcClient.getBlockCount()
-  }
-
-  async getUnclaimed(address: string): Promise<string> {
-    const rpcClient = new rpc.RPCClient(this.network.url)
-    const response = await rpcClient.getUnclaimedGas(address)
-    return u.BigInteger.fromNumber(response).toDecimal(this.claimToken.decimals)
-  }
-}

package/src/__tests__/BDSNeo3.spec.ts

@@ -1,124 +0,0 @@
-import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
-import { DoraBDSNeo3 } from '../DoraBDSNeo3'
-import { RPCBDSNeo3 } from '../RpcBDSNeo3'
-import { DEFAULT_URL_BY_NETWORK_TYPE, TOKENS } from '../constants'
-
-const gasToken = TOKENS.testnet.find(t => t.symbol === 'GAS')!
-const doraBDSNeo3 = new DoraBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
-const rpcBDSNeo3 = new RPCBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
-
-describe('BDSNeo3', () => {
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get transaction - %s',
-    async (bdsNeo3: BlockchainDataService) => {
-      const hash = '0x70e7381c5dee6e81becd02844e4e0199f6b3df834213bc89418dc4da32cf3f21'
-      const transaction = await bdsNeo3.getTransaction(hash)
-
-      expect(transaction).toEqual(
-        expect.objectContaining({
-          block: expect.any(Number),
-          hash,
-          notifications: [],
-          transfers: [],
-          time: expect.any(Number),
-          fee: expect.any(String),
-        })
-      )
-    }
-  )
-
-  it.each([doraBDSNeo3])(
-    'Should be able to get transactions of address - %s',
-    async (bdsNeo3: BlockchainDataService) => {
-      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
-      const response = await bdsNeo3.getTransactionsByAddress({ address, page: 1 })
-
-      response.transactions.forEach(transaction => {
-        expect(transaction).toEqual(
-          expect.objectContaining({
-            block: expect.any(Number),
-            hash: expect.any(String),
-            time: expect.any(Number),
-            fee: expect.any(String),
-            notifications: expect.arrayContaining([
-              expect.objectContaining({
-                eventName: expect.any(String),
-                state: expect.arrayContaining([
-                  {
-                    type: expect.any(String),
-                    value: expect.any(String),
-                  },
-                ]),
-              }),
-            ]),
-            transfers: expect.arrayContaining([
-              expect.objectContaining({
-                amount: expect.any(String),
-                from: expect.any(String),
-                to: expect.any(String),
-                type: 'token',
-              }),
-            ]),
-          })
-        )
-      })
-    }
-  )
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])('Should be able to get contract - %s', async (bdsNeo3: BlockchainDataService) => {
-    const hash = '0xd2a4cff31913016155e38e474a2c06d08be276cf'
-    const contract = await bdsNeo3.getContract(hash)
-    expect(contract).toEqual({
-      hash: hash,
-      name: 'GasToken',
-      methods: expect.arrayContaining([
-        expect.objectContaining({
-          name: expect.any(String),
-          parameters: expect.arrayContaining([
-            expect.objectContaining({ name: expect.any(String), type: expect.any(String) }),
-          ]),
-        }),
-      ]),
-    })
-  })
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get token info - %s',
-    async (bdsNeo3: BlockchainDataService) => {
-      const hash = '0xd2a4cff31913016155e38e474a2c06d08be276cf'
-      const token = await bdsNeo3.getTokenInfo(hash)
-
-      expect(token).toEqual({
-        decimals: 8,
-        hash: hash,
-        name: 'GasToken',
-        symbol: 'GAS',
-      })
-    }
-  )
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])('Should be able to get balance - %s', async (bdsNeo3: BlockchainDataService) => {
-    const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
-    const balance = await bdsNeo3.getBalance(address)
-    balance.forEach(balance => {
-      expect(balance).toEqual({
-        amount: expect.any(String),
-        token: {
-          hash: expect.any(String),
-          name: expect.any(String),
-          symbol: expect.any(String),
-          decimals: expect.any(Number),
-        },
-      })
-    })
-  })
-
-  it.each([doraBDSNeo3, rpcBDSNeo3])(
-    'Should be able to get unclaimed - %s',
-    async (bdsNeo3: BlockchainDataService & BDSClaimable) => {
-      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
-      const unclaimed = await bdsNeo3.getUnclaimed(address)
-      expect(unclaimed).toEqual(expect.any(String))
-    }
-  )
-})

package/src/__tests__/BSNeo3.spec.ts

@@ -1,175 +0,0 @@
-import { sleep } from './utils/sleep'
-import { BSNeo3 } from '../BSNeo3'
-import { generateMnemonic } from '@cityofzion/bs-asteroid-sdk'
-import TransportNodeHid from '@ledgerhq/hw-transport-node-hid'
-
-let bsNeo3: BSNeo3
-
-describe('BSNeo3', () => {
-  beforeAll(() => {
-    bsNeo3 = new BSNeo3('neo3', { type: 'testnet', url: 'https://testnet1.neo.coz.io:443' })
-  })
-
-  it('Should be able to validate an address', () => {
-    const validAddress = 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe'
-    const invalidAddress = 'invalid address'
-
-    expect(bsNeo3.validateAddress(validAddress)).toBeTruthy()
-    expect(bsNeo3.validateAddress(invalidAddress)).toBeFalsy()
-  })
-
-  it('Should be able to validate an encrypted key', () => {
-    const validEncryptedKey = '6PYVPVe1fQznphjbUxXP9KZJqPMVnVwCx5s5pr5axRJ8uHkMtZg97eT5kL'
-    const invalidEncryptedKey = 'invalid encrypted key'
-
-    expect(bsNeo3.validateEncrypted(validEncryptedKey)).toBeTruthy()
-    expect(bsNeo3.validateEncrypted(invalidEncryptedKey)).toBeFalsy()
-  })
-
-  it('Should be able to validate a wif', () => {
-    const validWif = 'L44B5gGEpqEDRS9vVPz7QT35jcBG2r3CZwSwQ4fCewXAhAhqGVpP'
-    const invalidWif = 'invalid wif'
-
-    expect(bsNeo3.validateKey(validWif)).toBeTruthy()
-    expect(bsNeo3.validateKey(invalidWif)).toBeFalsy()
-  })
-
-  it('Should be able to validate an domain', () => {
-    const validDomain = 'test.neo'
-    const invalidDomain = 'invalid domain'
-
-    expect(bsNeo3.validateNameServiceDomainFormat(validDomain)).toBeTruthy()
-    expect(bsNeo3.validateNameServiceDomainFormat(invalidDomain)).toBeFalsy()
-  })
-
-  it('Should be able to generate a mnemonic', () => {
-    expect(() => {
-      const mnemonic = generateMnemonic()
-      expect(mnemonic).toHaveLength(12)
-    }).not.toThrowError()
-  })
-
-  it('Should be able to gererate a account from mnemonic', () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-
-    expect(bsNeo3.validateAddress(account.address)).toBeTruthy()
-    expect(bsNeo3.validateKey(account.key)).toBeTruthy()
-  })
-
-  it('Should be able to generate a account from wif', () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-
-    const accountFromWif = bsNeo3.generateAccountFromKey(account.key)
-    expect(account).toEqual(expect.objectContaining(accountFromWif))
-  })
-
-  it('Should be able to decrypt a encrypted key', async () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-    const password = 'TestPassword'
-    const encryptedKey = await bsNeo3.encrypt(account.key, password)
-    const decryptedAccount = await bsNeo3.decrypt(encryptedKey, password)
-    expect(account).toEqual(expect.objectContaining(decryptedAccount))
-  }, 20000)
-
-  it('Should be able to encrypt a key', async () => {
-    const mnemonic = generateMnemonic()
-    const account = bsNeo3.generateAccountFromMnemonic(mnemonic, 0)
-    const password = 'TestPassword'
-    const encryptedKey = await bsNeo3.encrypt(account.key, password)
-    expect(encryptedKey).toEqual(expect.any(String))
-  })
-
-  it.skip('Should be able to calculate transfer fee', async () => {
-    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const fee = await bsNeo3.calculateTransferFee({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
-        tokenHash: bsNeo3.feeToken.hash,
-        tokenDecimals: bsNeo3.feeToken.decimals,
-      },
-    })
-
-    expect(fee).toEqual({
-      total: expect.any(Number),
-      networkFee: expect.any(Number),
-      systemFee: expect.any(Number),
-    })
-  })
-
-  it.skip('Should be able to transfer', async () => {
-    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-    const balance = await bsNeo3.blockchainDataService.getBalance(account.address)
-    const gasBalance = balance.find(b => b.token.symbol === bsNeo3.feeToken.symbol)
-    expect(Number(gasBalance?.amount)).toBeGreaterThan(0.00000001)
-
-    const transactionHash = await bsNeo3.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '0.00000001',
-        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
-        tokenHash: bsNeo3.feeToken.hash,
-        tokenDecimals: bsNeo3.feeToken.decimals,
-      },
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  })
-
-  it.skip('Should be able to transfer with ledger', async () => {
-    const transport = await TransportNodeHid.create()
-    const publicKey = await bsNeo3.ledgerService.getPublicKey(transport)
-
-    const account = bsNeo3.generateAccountFromPublicKey(publicKey)
-
-    const balance = await bsNeo3.blockchainDataService.getBalance(account.address)
-    const gasBalance = balance.find(b => b.token.symbol === bsNeo3.feeToken.symbol)
-    expect(Number(gasBalance?.amount)).toBeGreaterThan(0.00000001)
-
-    const transactionHash = await bsNeo3.transfer({
-      senderAccount: account,
-      intent: {
-        amount: '1',
-        receiverAddress: 'NPRMF5bmYuW23DeDJqsDJenhXkAPSJyuYe',
-        tokenHash: bsNeo3.feeToken.hash,
-        tokenDecimals: bsNeo3.feeToken.decimals,
-      },
-      isLedger: true,
-      ledgerTransport: transport,
-    })
-
-    expect(transactionHash).toEqual(expect.any(String))
-  }, 60000)
-
-  it.skip('Should be able to claim', async () => {
-    const account = bsNeo3.generateAccountFromKey(process.env.TESTNET_PRIVATE_KEY as string)
-
-    const maxTries = 10
-    let tries = 0
-
-    while (tries < maxTries) {
-      try {
-        const unclaimed = await bsNeo3.blockchainDataService.getUnclaimed(account.address)
-        if (Number(unclaimed) <= 0) continue
-
-        const transactionHash = await bsNeo3.claim(account)
-        expect(transactionHash).toEqual(expect.any(String))
-        break
-      } catch (error) {
-        await sleep(4000)
-      } finally {
-        tries++
-      }
-    }
-  }, 60000)
-
-  it('Should be able to resolve a name service domain', async () => {
-    const owner = await bsNeo3.resolveNameServiceDomain('neo.neo')
-    expect(owner).toEqual('Nj39M97Rk2e23JiULBBMQmvpcnKaRHqxFf')
-  })
-})