@cityofzion/bs-neo-legacy 0.9.3 → 0.10.0

package/src/BSNeoLegacy.ts

@@ -1,202 +0,0 @@
-import {
-  Account,
-  BDSClaimable,
-  BlockchainDataService,
-  BlockchainService,
-  BSClaimable,
-  ExchangeDataService,
-  Token,
-  Network,
-  PartialBy,
-  TransferParam,
-  AccountWithDerivationPath,
-  BSWithExplorerService,
-  ExplorerService,
-} from '@cityofzion/blockchain-service'
-import { api, sc, u, wallet } from '@cityofzion/neon-js'
-import {
-  DEFAULT_URL_BY_NETWORK_TYPE,
-  DERIVATION_PATH,
-  LEGACY_NETWORK_BY_NETWORK_TYPE,
-  NATIVE_ASSETS,
-  TOKENS,
-} from './constants'
-import { DoraBDSNeoLegacy } from './DoraBDSNeoLegacy'
-import { CryptoCompareEDSNeoLegacy } from './CryptoCompareEDSNeoLegacy'
-import { keychain } from '@cityofzion/bs-asteroid-sdk'
-import { DoraESNeoLegacy } from './DoraESNeoLegacy'
-
-export class BSNeoLegacy<BSCustomName extends string = string>
-  implements BlockchainService, BSClaimable, BSWithExplorerService
-{
-  readonly blockchainName: BSCustomName
-  readonly feeToken: Token
-  readonly claimToken: Token
-  readonly burnToken: Token
-  readonly derivationPath: string
-
-  blockchainDataService!: BlockchainDataService & BDSClaimable
-  exchangeDataService!: ExchangeDataService
-  explorerService!: ExplorerService
-  tokens: Token[]
-  network!: Network
-  legacyNetwork: string
-
-  constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>) {
-    if (network.type === 'custom') throw new Error('Custom network is not supported for NEO Legacy')
-
-    this.blockchainName = blockchainName
-    this.legacyNetwork = LEGACY_NETWORK_BY_NETWORK_TYPE[network.type]
-    this.derivationPath = DERIVATION_PATH
-    this.tokens = TOKENS[network.type]
-    this.claimToken = this.tokens.find(token => token.symbol === 'GAS')!
-    this.burnToken = this.tokens.find(token => token.symbol === 'NEO')!
-    this.feeToken = this.tokens.find(token => token.symbol === 'GAS')!
-    this.setNetwork(network)
-  }
-
-  setNetwork(param: PartialBy<Network, 'url'>) {
-    if (param.type === 'custom') throw new Error('Custom network is not supported for NEO Legacy')
-
-    const network = {
-      type: param.type,
-      url: param.url ?? DEFAULT_URL_BY_NETWORK_TYPE[param.type],
-    }
-    this.network = network
-    this.blockchainDataService = new DoraBDSNeoLegacy(network, this.feeToken, this.claimToken)
-    this.exchangeDataService = new CryptoCompareEDSNeoLegacy(network.type)
-    this.explorerService = new DoraESNeoLegacy(network.type)
-  }
-
-  validateAddress(address: string): boolean {
-    return wallet.isAddress(address)
-  }
-
-  validateEncrypted(key: string): boolean {
-    return wallet.isNEP2(key)
-  }
-
-  validateKey(key: string): boolean {
-    return wallet.isWIF(key) || wallet.isPrivateKey(key)
-  }
-
-  generateAccountFromMnemonic(mnemonic: string[] | string, index: number): AccountWithDerivationPath {
-    keychain.importMnemonic(Array.isArray(mnemonic) ? mnemonic.join(' ') : mnemonic)
-    const path = this.derivationPath.replace('?', index.toString())
-    const childKey = keychain.generateChildKey('neo', path)
-    const key = childKey.getWIF()
-    const { address } = new wallet.Account(key)
-    return { address, key, type: 'wif', derivationPath: path }
-  }
-
-  generateAccountFromKey(key: string): Account {
-    const type = wallet.isWIF(key) ? 'wif' : wallet.isPrivateKey(key) ? 'privateKey' : undefined
-    if (!type) throw new Error('Invalid key')
-
-    const { address } = new wallet.Account(key)
-    return { address, key, type }
-  }
-
-  async decrypt(encryptedKey: string, password: string): Promise<Account> {
-    let BsReactNativeDecrypt: any
-
-    try {
-      const { NativeModules } = require('react-native')
-      BsReactNativeDecrypt = NativeModules.BsReactNativeDecrypt
-
-      if (!BsReactNativeDecrypt) {
-        throw new Error('@CityOfZion/bs-react-native-decrypt is not installed')
-      }
-    } catch {
-      const key = await wallet.decrypt(encryptedKey, password)
-      return this.generateAccountFromKey(key)
-    }
-
-    const privateKey = await BsReactNativeDecrypt.decryptNeoLegacy(encryptedKey, password)
-    return this.generateAccountFromKey(privateKey)
-  }
-
-  encrypt(key: string, password: string): Promise<string> {
-    return wallet.encrypt(key, password)
-  }
-
-  async transfer({ intent: transferIntent, senderAccount, tipIntent, ...params }: TransferParam): Promise<string> {
-    const apiProvider = new api.neoCli.instance(this.network.url)
-    const account = new wallet.Account(senderAccount.key)
-    const priorityFee = Number(params.priorityFee ?? 0)
-
-    const nativeIntents: ReturnType<typeof api.makeIntent> = []
-    const nep5ScriptBuilder = new sc.ScriptBuilder()
-
-    const intents = [transferIntent, ...(tipIntent ? [tipIntent] : [])]
-
-    for (const intent of intents) {
-      const tokenHashFixed = intent.tokenHash.replace('0x', '')
-
-      const nativeAsset = NATIVE_ASSETS.find(asset => asset.hash === tokenHashFixed)
-      if (nativeAsset) {
-        nativeIntents.push(...api.makeIntent({ [nativeAsset.symbol]: Number(intent.amount) }, intent.receiverAddress))
-        continue
-      }
-
-      nep5ScriptBuilder.emitAppCall(tokenHashFixed, 'transfer', [
-        u.reverseHex(wallet.getScriptHashFromAddress(account.address)),
-        u.reverseHex(wallet.getScriptHashFromAddress(intent.receiverAddress)),
-        sc.ContractParam.integer(
-          new u.Fixed8(intent.amount)
-            .div(Math.pow(10, 8 - (intent.tokenDecimals ?? 8)))
-            .toRawNumber()
-            .toString()
-        ),
-      ])
-    }
-
-    let response
-
-    if (nep5ScriptBuilder.isEmpty()) {
-      response = await api.sendAsset({
-        account,
-        api: apiProvider,
-        url: this.network.url,
-        intents: nativeIntents,
-        fees: priorityFee,
-      })
-    } else {
-      response = await api.doInvoke({
-        intents: nativeIntents.length > 0 ? nativeIntents : undefined,
-        account,
-        api: apiProvider,
-        script: nep5ScriptBuilder.str,
-        url: this.network.url,
-        fees: priorityFee,
-      })
-    }
-
-    if (!response.tx) throw new Error('Failed to send transaction')
-    return response.tx.hash
-  }
-
-  async claim(account: Account): Promise<string> {
-    const neoAccount = new wallet.Account(account.key)
-
-    const balances = await this.blockchainDataService.getBalance(account.address)
-    const neoBalance = balances.find(balance => balance.token.symbol === 'NEO')
-    if (!neoBalance) throw new Error('It is necessary to have NEO to claim')
-
-    const unclaimed = await this.blockchainDataService.getUnclaimed(account.address)
-    if (Number(unclaimed) <= 0) throw new Error(`Doesn't have gas to claim`)
-
-    const apiProvider = new api.neoCli.instance(this.legacyNetwork)
-    const claims = await apiProvider.getClaims(account.address)
-
-    const response = await api.claimGas({
-      claims,
-      api: apiProvider,
-      account: neoAccount,
-      url: this.network.url,
-    })
-
-    if (!response.tx) throw new Error('Failed to claim')
-    return response.tx.hash
-  }
-}

package/src/CryptoCompareEDSNeoLegacy.ts

@@ -1,50 +0,0 @@
-import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service'
-import axios, { AxiosInstance } from 'axios'
-import { TOKENS } from './constants'
-
-type CryptoCompareDataResponse = {
-  RAW: {
-    [symbol: string]: {
-      [currency: string]: {
-        PRICE: number
-      }
-    }
-  }
-}
-
-export class CryptoCompareEDSNeoLegacy implements ExchangeDataService {
-  networkType: NetworkType
-  private axiosInstance: AxiosInstance
-
-  constructor(network: NetworkType) {
-    this.networkType = network
-    this.axiosInstance = axios.create({ baseURL: 'https://min-api.cryptocompare.com' })
-  }
-
-  async getTokenPrices(currency: Currency): Promise<TokenPricesResponse[]> {
-    if (this.networkType !== 'mainnet') throw new Error('Exchange is only available on mainnet')
-
-    const tokens = TOKENS[this.networkType]
-    const tokenSymbols = tokens.map(token => token.symbol)
-    const { data: prices } = await this.axiosInstance.get<CryptoCompareDataResponse>('/data/pricemultifull', {
-      params: {
-        fsyms: tokenSymbols.join(','),
-        tsyms: currency,
-      },
-    })
-
-    return Object.entries(prices.RAW)
-      .map(([symbol, priceObject]) => {
-        const price = priceObject[currency].PRICE
-        const token = tokens.find(token => token.symbol === symbol)
-        if (!token || !price) return
-
-        return {
-          symbol,
-          price,
-          hash: token?.hash,
-        }
-      })
-      .filter((price): price is TokenPricesResponse => price !== undefined)
-  }
-}

package/src/DoraBDSNeoLegacy.ts

@@ -1,176 +0,0 @@
-import {
-  BalanceResponse,
-  BlockchainDataService,
-  ContractResponse,
-  TransactionsByAddressParams,
-  TransactionsByAddressResponse,
-  TransactionResponse,
-  BDSClaimable,
-  TransactionTransferAsset,
-  Token,
-  Network,
-} from '@cityofzion/blockchain-service'
-import { api } from '@cityofzion/dora-ts'
-import { TOKENS } from './constants'
-import { rpc } from '@cityofzion/neon-js'
-
-export class DoraBDSNeoLegacy implements BlockchainDataService, BDSClaimable {
-  readonly network: Network
-  private readonly claimToken: Token
-  private readonly feeToken: Token
-  private readonly tokenCache: Map<string, Token> = new Map()
-
-  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 2
-
-  constructor(network: Network, feeToken: Token, claimToken: Token) {
-    if (network.type === 'custom') throw new Error('Custom network is not supported for NEO Legacy')
-    this.network = network
-    this.claimToken = claimToken
-    this.feeToken = feeToken
-  }
-
-  async getTransaction(hash: string): Promise<TransactionResponse> {
-    const data = await api.NeoLegacyREST.transaction(hash, this.network.type)
-    if (!data || 'error' in data) throw new Error(`Transaction ${hash} not found`)
-
-    const vout: any[] = data.vout ?? []
-
-    const promises = vout.map<Promise<TransactionTransferAsset>>(async (transfer, _index, array) => {
-      const token = await this.getTokenInfo(transfer.asset)
-      return {
-        amount: String(transfer.value),
-        from: array[array.length - 1]?.address,
-        contractHash: transfer.asset,
-        to: transfer.address,
-        type: 'token',
-        token,
-      }
-    })
-    const transfers = await Promise.all(promises)
-
-    return {
-      hash: data.txid,
-      block: data.block,
-      fee: (Number(data.sys_fee ?? 0) + Number(data.net_fee ?? 0)).toFixed(this.feeToken.decimals),
-      time: Number(data.time),
-      notifications: [], //neoLegacy doesn't have notifications
-      transfers,
-    }
-  }
-
-  async getTransactionsByAddress({
-    address,
-    page = 1,
-  }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
-    const data = await api.NeoLegacyREST.getAddressAbstracts(address, page, this.network.type)
-    const transactions = new Map<string, TransactionResponse>()
-
-    const promises = data.entries.map(async entry => {
-      if (entry.address_from !== address && entry.address_to !== address) return
-
-      const token = await this.getTokenInfo(entry.asset)
-      const transfer: TransactionTransferAsset = {
-        amount: String(entry.amount),
-        from: entry.address_from ?? 'Mint',
-        to: entry.address_to ?? 'Burn',
-        type: 'token',
-        contractHash: entry.asset,
-        token,
-      }
-      const existingTransaction = transactions.get(entry.txid)
-      if (existingTransaction) {
-        existingTransaction.transfers.push(transfer)
-        return
-      }
-
-      transactions.set(entry.txid, {
-        block: entry.block_height,
-        hash: entry.txid,
-        time: entry.time,
-        transfers: [transfer],
-        notifications: [],
-      })
-    })
-    await Promise.all(promises)
-
-    return {
-      totalCount: data.total_entries,
-      limit: data.page_size,
-      transactions: Array.from(transactions.values()),
-    }
-  }
-
-  async getContract(contractHash: string): Promise<ContractResponse> {
-    const response = await api.NeoLegacyREST.contract(contractHash, this.network.type)
-    if (!response || 'error' in response) throw new Error(`Contract ${contractHash} not found`)
-
-    return {
-      hash: response.hash,
-      name: response.name,
-      methods: [],
-    }
-  }
-
-  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)!
-    }
-
-    const data = await api.NeoLegacyREST.asset(tokenHash, this.network.type)
-    if (!data || 'error' in data) throw new Error(`Token ${tokenHash} not found`)
-
-    const token = {
-      decimals: Number(data.decimals),
-      symbol: data.symbol,
-      hash: data.scripthash,
-      name: data.name,
-    }
-
-    this.tokenCache.set(tokenHash, token)
-
-    return token
-  }
-
-  async getBalance(address: string): Promise<BalanceResponse[]> {
-    const data = await api.NeoLegacyREST.balance(address, this.network.type)
-
-    const promises = data.map<Promise<BalanceResponse>>(async balance => {
-      const hash = balance.asset.replace('0x', '')
-
-      let token: Token = {
-        hash,
-        name: balance.asset_name,
-        symbol: balance.symbol,
-        decimals: 8,
-      }
-
-      try {
-        token = await this.getTokenInfo(hash)
-      } catch {
-        // Empty block
-      }
-
-      return {
-        amount: Number(balance.balance).toFixed(token.decimals),
-        token,
-      }
-    })
-
-    const result = await Promise.all(promises)
-
-    return result
-  }
-
-  async getUnclaimed(address: string): Promise<string> {
-    const { unclaimed } = await api.NeoLegacyREST.getUnclaimed(address, this.network.type)
-    return (unclaimed / 10 ** this.claimToken.decimals).toFixed(this.claimToken.decimals)
-  }
-
-  async getBlockHeight(): Promise<number> {
-    const rpcClient = new rpc.RPCClient(this.network.url)
-    return await rpcClient.getBlockCount()
-  }
-}

package/src/DoraESNeoLegacy.ts

@@ -1,18 +0,0 @@
-import { BuildNftUrlParams, ExplorerService, NetworkType } from '@cityofzion/blockchain-service'
-
-export class DoraESNeoLegacy implements ExplorerService {
-  private networkType: NetworkType
-
-  constructor(networkType: NetworkType) {
-    this.networkType = networkType
-  }
-
-  buildTransactionUrl(hash: string): string {
-    if (this.networkType === 'custom') throw new Error('DoraESNeoLegacy does not support custom network')
-    return `https://dora.coz.io/transaction/neo2/${this.networkType}/${hash}`
-  }
-
-  buildNftUrl(_params: BuildNftUrlParams): string {
-    throw new Error('DoraESNeoLegacy does not support nft')
-  }
-}

package/src/__tests__/BDSNeoLegacy.spec.ts

@@ -1,123 +0,0 @@
-import { BDSClaimable, BlockchainDataService } from '@cityofzion/blockchain-service'
-import { DoraBDSNeoLegacy } from '../DoraBDSNeoLegacy'
-import { DEFAULT_URL_BY_NETWORK_TYPE, TOKENS } from '../constants'
-
-const gasToken = TOKENS.testnet.find(t => t.symbol === 'GAS')!
-const doraBDSNeoLegacy = new DoraBDSNeoLegacy(
-  { type: 'testnet', url: DEFAULT_URL_BY_NETWORK_TYPE.testnet },
-  gasToken,
-  gasToken
-)
-
-describe('BDSNeoLegacy', () => {
-  it.each([doraBDSNeoLegacy])('Should be able to get transaction - %s', async (bdsNeoLegacy: BlockchainDataService) => {
-    const hash = '0x6632e79b1e5182355bcc1f3ca0e91d11a426c893734cd266e7bf3d3f74618add'
-    const transaction = await bdsNeoLegacy.getTransaction(hash)
-    expect(transaction).toEqual(
-      expect.objectContaining({
-        block: expect.any(Number),
-        hash,
-        notifications: [],
-        transfers: expect.arrayContaining([
-          expect.objectContaining({
-            amount: expect.any(String),
-            from: expect.any(String),
-            to: expect.any(String),
-            type: 'token',
-          }),
-        ]),
-        time: expect.any(Number),
-        fee: expect.any(String),
-      })
-    )
-  })
-
-  it.each([doraBDSNeoLegacy])(
-    'Should be able to get history transactions - %s',
-    async (bdsNeoLegacy: BlockchainDataService) => {
-      const address = 'AeGgZTTWPzyVtNiQRcpngkV75Xip1hznmi'
-      try {
-        const response = await bdsNeoLegacy.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(Number),
-                  from: expect.any(String),
-                  to: expect.any(String),
-                  type: 'asset',
-                }),
-              ]),
-              time: expect.any(Number),
-              fee: expect.any(String),
-            })
-          )
-        })
-      } catch {
-        // Empty block
-      }
-    }
-  )
-
-  it.each([doraBDSNeoLegacy])('Should be able to get contract - %s', async (bdsNeoLegacy: BlockchainDataService) => {
-    const hash = '0x998a0da7ec5f21c9a99ef5349f81af8af89f9644'
-    const contract = await bdsNeoLegacy.getContract(hash)
-    expect(contract).toEqual({
-      hash: hash,
-      name: 'Phantasma Stake',
-      methods: [],
-    })
-  })
-
-  it.each([doraBDSNeoLegacy])('Should be able to get token info - %s', async (bdsNeoLegacy: BlockchainDataService) => {
-    const hash = '0x602c79718b16e442de58778e148d0b1084e3b2dffd5de6b7b16cee7969282de7'
-    const token = await bdsNeoLegacy.getTokenInfo(hash)
-    expect(token).toEqual({
-      decimals: 8,
-      hash: hash,
-      name: 'GAS',
-      symbol: 'GAS',
-    })
-  })
-
-  it.each([doraBDSNeoLegacy])('Should be able to get balance - %s', async (bdsNeoLegacy: BlockchainDataService) => {
-    const address = 'AeGgZTTWPzyVtNiQRcpngkV75Xip1hznmi'
-    const balance = await bdsNeoLegacy.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),
-        },
-      })
-      expect(balance.token.hash.startsWith('0x')).toBeFalsy()
-    })
-  })
-
-  it.each([doraBDSNeoLegacy])(
-    'Should be able to get unclaimed - %s',
-    async (doraBDSNeoLegacy: BlockchainDataService & BDSClaimable) => {
-      const address = 'AeGgZTTWPzyVtNiQRcpngkV75Xip1hznmi'
-      const unclaimed = await doraBDSNeoLegacy.getUnclaimed(address)
-      expect(unclaimed).toEqual(expect.any(String))
-    }
-  )
-})