@cityofzion/bs-neo3 0.4.1 → 0.7.0

package/src/FlamingoEDSNeo3.ts

@@ -0,0 +1,45 @@
+import {
+  Currency,
+  ExchangeDataService,
+  Network,
+  NetworkType,
+  TokenPricesResponse,
+} from '@cityofzion/blockchain-service'
+import axios, { AxiosInstance } from 'axios'
+
+type FlamingoTokenInfoPricesResponse = {
+  symbol: string
+  usd_price: number
+}[]
+
+export class FlamingoEDSNeo3 implements ExchangeDataService {
+  readonly networkType: NetworkType
+  private axiosInstance: AxiosInstance
+
+  constructor(networkType: NetworkType) {
+    this.networkType = networkType
+    this.axiosInstance = axios.create({ baseURL: 'https://api.flamingo.finance' })
+  }
+
+  async getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]> {
+    if (this.networkType !== 'mainnet') throw new Error('Exchange is only available on mainnet')
+
+    const { data: prices } = await this.axiosInstance.get<FlamingoTokenInfoPricesResponse>('/token-info/prices')
+
+    let currencyRatio: number = 1
+
+    if (currency !== 'USD') {
+      currencyRatio = await this.getCurrencyRatio(currency)
+    }
+
+    return prices.map(price => ({
+      price: price.usd_price * currencyRatio,
+      symbol: price.symbol,
+    }))
+  }
+
+  private async getCurrencyRatio(currency: Currency): Promise<number> {
+    const { data } = await this.axiosInstance.get<number>(`/fiat/exchange-rate?pair=USD_${currency}`)
+    return data
+  }
+}

package/src/GhostMarketNDSNeo3.ts

@@ -0,0 +1,117 @@
+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, page }: 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: 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/RpcBDSNeo3.ts

@@ -0,0 +1,155 @@
+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 } from '@cityofzion/neon-invoker'
+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
+
+  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: [] },
+        ],
+      })
+
+      const decimals = Number(response.stack[0].value)
+      const symbol = u.base642utf8(response.stack[1].value as string)
+      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 {}
+
+      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

@@ -0,0 +1,126 @@
+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')!
+let doraBDSNeo3 = new DoraBDSNeo3({ type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet }, gasToken, gasToken)
+let 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, rpcBDSNeo3])(
+    'Should be able to get transactions of address - %s',
+    async (bdsNeo3: BlockchainDataService) => {
+      const address = 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6'
+      try {
+        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),
+              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: 'asset',
+                }),
+              ]),
+              time: expect.any(Number),
+              fee: expect.any(String),
+            })
+          )
+        })
+      } catch {}
+    }
+  )
+
+  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

@@ -0,0 +1,142 @@
+import { wallet } from '@cityofzion/neon-js'
+import { sleep } from './utils/sleep'
+import { BSNeo3 } from '../BSNeo3'
+import { generateMnemonic } from '@cityofzion/bs-asteroid-sdk'
+
+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 wallet.encrypt(account.key, password)
+    const decryptedAccount = await bsNeo3.decrypt(encryptedKey, password)
+    expect(account).toEqual(expect.objectContaining(decryptedAccount))
+  }, 20000)
+
+  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 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')
+  })
+})

package/src/__tests__/FlamingoEDSNeo3.spec.ts

@@ -0,0 +1,45 @@
+import { FlamingoEDSNeo3 } from '../FlamingoEDSNeo3'
+
+let flamingoEDSNeo3: FlamingoEDSNeo3
+
+describe('FlamingoEDSNeo3', () => {
+  beforeAll(() => {
+    flamingoEDSNeo3 = new FlamingoEDSNeo3('mainnet')
+  })
+  it('Should return a list with prices of tokens using USD', async () => {
+    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('USD')
+
+    tokenPriceList.forEach(tokenPrice => {
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+      })
+    })
+  })
+
+  it('Should return a list with prices of tokens using BRL', async () => {
+    const tokenPriceListInUSD = await flamingoEDSNeo3.getTokenPrices('USD')
+    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('BRL')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeGreaterThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+      })
+    })
+  })
+
+  it('Should return a list with prices of tokens using EUR', async () => {
+    const tokenPriceListInUSD = await flamingoEDSNeo3.getTokenPrices('USD')
+    const tokenPriceList = await flamingoEDSNeo3.getTokenPrices('EUR')
+
+    tokenPriceList.forEach((tokenPrice, index) => {
+      expect(tokenPrice.price).toBeLessThan(tokenPriceListInUSD[index].price)
+      expect(tokenPrice).toEqual({
+        price: expect.any(Number),
+        symbol: expect.any(String),
+      })
+    })
+  })
+})

package/src/__tests__/GhostMarketNDSNeo3.spec.ts

@@ -0,0 +1,43 @@
+import { GhostMarketNDSNeo3 } from '../GhostMarketNDSNeo3'
+
+let ghostMarketNDSNeo3: GhostMarketNDSNeo3
+
+describe('GhostMarketNDSNeo3', () => {
+  beforeAll(() => {
+    ghostMarketNDSNeo3 = new GhostMarketNDSNeo3('mainnet')
+  })
+
+  it('Get NFT', async () => {
+    const nft = await ghostMarketNDSNeo3.getNft({
+      contractHash: '0xaa4fb927b3fe004e689a278d188689c9f050a8b2',
+      tokenId: 'SVBLTUYxMTY1',
+    })
+    expect(nft).toEqual(
+      expect.objectContaining({
+        id: 'SVBLTUYxMTY1',
+        contractHash: '0xaa4fb927b3fe004e689a278d188689c9f050a8b2',
+        symbol: 'TTM',
+        collectionImage: expect.any(String),
+        collectionName: 'TOTHEMOON',
+        image: expect.any(String),
+        isSVG: expect.any(Boolean),
+        name: 'Pink Moon Fish',
+      })
+    )
+  })
+  it('Get NFTS by address', async () => {
+    const nfts = await ghostMarketNDSNeo3.getNftsByAddress({
+      address: 'NNmTVFrSPhe7zjgN6iq9cLgXJwLZziUKV6',
+    })
+    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__/utils/sleep.ts

@@ -0,0 +1 @@
+export const sleep = (ms: number) => new Promise(resolve => setTimeout(resolve, ms))

package/src/assets/tokens/common.json

@@ -0,0 +1,14 @@
+[
+  {
+    "symbol": "GAS",
+    "name": "GASToken",
+    "hash": "d2a4cff31913016155e38e474a2c06d08be276cf",
+    "decimals": 8
+  },
+  {
+    "symbol": "NEO",
+    "name": "NeoToken",
+    "hash": "ef4073a0f2b305a38ec4050e4d3d28bc40ea63f5",
+    "decimals": 0
+  }
+]