@cityofzion/bs-neo3 0.9.3 → 0.11.0

package/src/BSNeo3.ts

@@ -1,232 +0,0 @@
-import {
-  BlockchainDataService,
-  BlockchainService,
-  BSClaimable,
-  Account,
-  ExchangeDataService,
-  BDSClaimable,
-  Token,
-  BSWithNameService,
-  Network,
-  PartialBy,
-  TransferParam,
-  BSCalculableFee,
-  NftDataService,
-  BSWithNft,
-  AccountWithDerivationPath,
-  BSWithExplorerService,
-  ExplorerService,
-} from '@cityofzion/blockchain-service'
-import { api, u, wallet } from '@cityofzion/neon-js'
-import Neon from '@cityofzion/neon-core'
-import { NeonInvoker } from '@cityofzion/neon-invoker'
-import { NeonParser } from '@cityofzion/neon-parser'
-import { ABI_TYPES } from '@cityofzion/neo3-parser'
-import { ContractInvocation } from '@cityofzion/neo3-invoker'
-
-import { RPCBDSNeo3 } from './RpcBDSNeo3'
-import { DoraBDSNeo3 } from './DoraBDSNeo3'
-import { DEFAULT_URL_BY_NETWORK_TYPE, DERIVATION_PATH, NEO_NS_HASH, TOKENS } from './constants'
-import { FlamingoEDSNeo3 } from './FlamingoEDSNeo3'
-import { GhostMarketNDSNeo3 } from './GhostMarketNDSNeo3'
-import { keychain } from '@cityofzion/bs-asteroid-sdk'
-import { DoraESNeo3 } from './DoraESNeo3'
-
-export class BSNeo3<BSCustomName extends string = string>
-  implements BlockchainService, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft, BSWithExplorerService
-{
-  readonly blockchainName: BSCustomName
-  readonly feeToken: Token
-  readonly claimToken: Token
-  readonly burnToken: Token
-  readonly derivationPath: string
-
-  blockchainDataService!: BlockchainDataService & BDSClaimable
-  nftDataService!: NftDataService
-  exchangeDataService!: ExchangeDataService
-  explorerService!: ExplorerService
-  tokens: Token[]
-  network!: Network
-
-  constructor(blockchainName: BSCustomName, network: PartialBy<Network, 'url'>) {
-    this.blockchainName = blockchainName
-    this.tokens = TOKENS[network.type]
-
-    this.derivationPath = DERIVATION_PATH
-    this.feeToken = this.tokens.find(token => token.symbol === 'GAS')!
-    this.burnToken = this.tokens.find(token => token.symbol === 'NEO')!
-    this.claimToken = this.tokens.find(token => token.symbol === 'GAS')!
-    this.setNetwork(network)
-  }
-
-  setNetwork(param: PartialBy<Network, 'url'>) {
-    const network = {
-      type: param.type,
-      url: param.url ?? DEFAULT_URL_BY_NETWORK_TYPE[param.type],
-    }
-    this.network = network
-
-    if (network.type === 'custom') {
-      this.blockchainDataService = new RPCBDSNeo3(network, this.feeToken, this.claimToken)
-    } else {
-      this.blockchainDataService = new DoraBDSNeo3(network, this.feeToken, this.claimToken)
-    }
-
-    this.exchangeDataService = new FlamingoEDSNeo3(network.type)
-    this.nftDataService = new GhostMarketNDSNeo3(network.type)
-    this.explorerService = new DoraESNeo3(network.type)
-  }
-
-  validateAddress(address: string): boolean {
-    return wallet.isAddress(address, 53)
-  }
-
-  validateEncrypted(encryptedKey: string): boolean {
-    return wallet.isNEP2(encryptedKey)
-  }
-
-  validateKey(key: string): boolean {
-    return wallet.isWIF(key) || wallet.isPrivateKey(key)
-  }
-
-  validateNameServiceDomainFormat(domainName: string): boolean {
-    if (!domainName.endsWith('.neo')) return false
-    return true
-  }
-
-  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.decryptNeo3(encryptedKey, password)
-    return this.generateAccountFromKey(privateKey)
-  }
-
-  encrypt(key: string, password: string): Promise<string> {
-    return wallet.encrypt(key, password)
-  }
-
-  async calculateTransferFee(param: TransferParam): Promise<string> {
-    const account = new wallet.Account(param.senderAccount.key)
-    const invoker = await NeonInvoker.init({
-      rpcAddress: this.network.url,
-      account,
-    })
-
-    const invocations = this.buildTransferInvocation(param, account)
-
-    const { networkFee, systemFee } = await invoker.calculateFee({
-      invocations,
-      signers: [],
-    })
-
-    return networkFee.add(systemFee).toDecimal(this.feeToken.decimals)
-  }
-
-  async transfer(param: TransferParam): Promise<string> {
-    const account = new wallet.Account(param.senderAccount.key)
-    const invoker = await NeonInvoker.init({
-      rpcAddress: this.network.url,
-      account,
-    })
-
-    const invocations = this.buildTransferInvocation(param, account)
-
-    const transactionHash = await invoker.invokeFunction({
-      invocations,
-      signers: [],
-    })
-
-    return transactionHash
-  }
-
-  async claim(account: Account): Promise<string> {
-    const neoAccount = new wallet.Account(account.key)
-    const facade = await api.NetworkFacade.fromConfig({ node: this.network.url })
-
-    const transactionHash = await facade.claimGas(neoAccount, {
-      signingCallback: api.signWithAccount(neoAccount),
-    })
-
-    return transactionHash
-  }
-
-  async resolveNameServiceDomain(domainName: string): Promise<any> {
-    const parser = NeonParser
-    const invoker = await NeonInvoker.init({ rpcAddress: this.network.url })
-    const response = await invoker.testInvoke({
-      invocations: [
-        {
-          scriptHash: NEO_NS_HASH,
-          operation: 'ownerOf',
-          args: [{ type: 'String', value: domainName }],
-        },
-      ],
-    })
-
-    if (response.stack.length === 0) {
-      throw new Error(response.exception ?? 'unrecognized response')
-    }
-
-    const parsed = parser.parseRpcResponse(response.stack[0] as any, {
-      type: ABI_TYPES.HASH160.name,
-    })
-    const address = parser.accountInputToAddress(parsed.replace('0x', ''))
-    return address
-  }
-
-  private buildTransferInvocation(
-    { intent, tipIntent }: TransferParam,
-    account: Neon.wallet.Account
-  ): ContractInvocation[] {
-    const intents = [intent, ...(tipIntent ? [tipIntent] : [])]
-
-    const invocations: ContractInvocation[] = intents.map(intent => {
-      return {
-        operation: 'transfer',
-        scriptHash: intent.tokenHash,
-        args: [
-          { type: 'Hash160', value: account.address },
-          { type: 'Hash160', value: intent.receiverAddress },
-          {
-            type: 'Integer',
-            value: intent.tokenDecimals
-              ? u.BigInteger.fromDecimal(intent.amount, intent.tokenDecimals).toString()
-              : intent.amount,
-          },
-          { type: 'Any', value: '' },
-        ],
-      }
-    })
-
-    return invocations
-  }
-}

package/src/DoraBDSNeo3.ts

@@ -1,188 +0,0 @@
-import {
-  BalanceResponse,
-  ContractResponse,
-  TransactionsByAddressParams,
-  TransactionsByAddressResponse,
-  TransactionResponse,
-  TransactionNotifications,
-  Network,
-  Token,
-  TransactionTransferNft,
-  TransactionTransferAsset,
-} from '@cityofzion/blockchain-service'
-import { wallet, u } from '@cityofzion/neon-js'
-import { NeoRESTApi } from '@cityofzion/dora-ts/dist/api'
-import { RPCBDSNeo3 } from './RpcBDSNeo3'
-import { TOKENS } from './constants'
-
-const NeoRest = new NeoRESTApi({
-  doraUrl: 'https://dora.coz.io',
-  endpoint: '/api/v2/neo3',
-})
-
-export class DoraBDSNeo3 extends RPCBDSNeo3 {
-  readonly network: Network
-
-  constructor(network: Network, feeToken: Token, claimToken: Token) {
-    if (network.type === 'custom') {
-      throw new Error('DoraBDSNeo3 does not support custom networks')
-    }
-
-    super(network, feeToken, claimToken)
-    this.network = network
-  }
-
-  async getTransaction(hash: string): Promise<TransactionResponse> {
-    try {
-      const data = await NeoRest.transaction(hash, this.network.type)
-      return {
-        block: data.block,
-        time: Number(data.time),
-        hash: data.hash,
-        fee: u.BigInteger.fromNumber(data.netfee ?? 0)
-          .add(u.BigInteger.fromNumber(data.sysfee ?? 0))
-          .toDecimal(this.feeToken.decimals),
-        notifications: [],
-        transfers: [],
-      }
-    } catch {
-      throw new Error(`Transaction not found: ${hash}`)
-    }
-  }
-
-  async getTransactionsByAddress({
-    address,
-    page = 1,
-  }: TransactionsByAddressParams): Promise<TransactionsByAddressResponse> {
-    const data = await NeoRest.addressTXFull(address, page, this.network.type)
-
-    const promises = data.items.map(async (item): Promise<TransactionResponse> => {
-      const transferPromises: Promise<TransactionTransferAsset | TransactionTransferNft>[] = []
-
-      item.notifications.forEach(({ contract: contractHash, state, event_name: eventName }) => {
-        const properties = Array.isArray(state) ? state : state.value
-        if (eventName !== 'Transfer' || (properties.length !== 3 && properties.length !== 4)) return
-
-        const promise = async (): Promise<TransactionTransferAsset | TransactionTransferNft> => {
-          const isAsset = properties.length === 3
-
-          const from = properties[0].value
-          const to = properties[1].value
-          const convertedFrom = from ? this.convertByteStringToAddress(from) : 'Mint'
-          const convertedTo = to ? this.convertByteStringToAddress(to) : 'Burn'
-
-          if (isAsset) {
-            const token = await this.getTokenInfo(contractHash)
-            const [, , { value: amount }] = properties
-            return {
-              amount: u.BigInteger.fromNumber(amount).toDecimal(token.decimals ?? 0),
-              from: convertedFrom,
-              to: convertedTo,
-              contractHash,
-              type: 'token',
-              token,
-            }
-          }
-
-          return {
-            from: convertedFrom,
-            to: convertedTo,
-            tokenId: properties[3].value,
-            contractHash,
-            type: 'nft',
-          }
-        }
-
-        transferPromises.push(promise())
-      })
-
-      const transfers = await Promise.all(transferPromises)
-
-      const notifications = item.notifications.map<TransactionNotifications>(notification => ({
-        eventName: notification.event_name,
-        state: notification.state as any,
-      }))
-
-      return {
-        block: item.block,
-        time: Number(item.time),
-        hash: item.hash,
-        fee: u.BigInteger.fromNumber(item.netfee ?? 0)
-          .add(u.BigInteger.fromNumber(item.sysfee ?? 0))
-          .toDecimal(this.feeToken.decimals),
-        transfers,
-        notifications,
-      }
-    })
-
-    const transactions = await Promise.all(promises)
-
-    return {
-      totalCount: data.totalCount,
-      transactions,
-      limit: 15,
-    }
-  }
-
-  async getContract(contractHash: string): Promise<ContractResponse> {
-    try {
-      const data = await NeoRest.contract(contractHash, this.network.type)
-      return {
-        hash: data.hash,
-        methods: data.manifest.abi?.methods ?? [],
-        name: data.manifest.name,
-      }
-    } 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 { decimals, symbol, name, scripthash } = await NeoRest.asset(tokenHash, this.network.type)
-      const token = {
-        decimals: Number(decimals),
-        symbol,
-        name,
-        hash: scripthash,
-      }
-      this.tokenCache.set(tokenHash, token)
-
-      return token
-    } catch {
-      throw new Error(`Token not found: ${tokenHash}`)
-    }
-  }
-
-  async getBalance(address: string): Promise<BalanceResponse[]> {
-    const response = await NeoRest.balance(address, this.network.type)
-
-    const promises = response.map<Promise<BalanceResponse | undefined>>(async balance => {
-      try {
-        const token = await this.getTokenInfo(balance.asset)
-        return {
-          amount: balance.balance.toString(),
-          token,
-        }
-      } catch {
-        // Empty block
-      }
-    })
-    const balances = await Promise.all(promises)
-    const filteredBalances = balances.filter(balance => balance !== undefined) as BalanceResponse[]
-    return filteredBalances
-  }
-
-  private convertByteStringToAddress(byteString: string): string {
-    const account = new wallet.Account(u.reverseHex(u.HexString.fromBase64(byteString).toString()))
-
-    return account.address
-  }
-}

package/src/DoraESNeo3.ts

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

package/src/FlamingoEDSNeo3.ts

@@ -1,41 +0,0 @@
-import { Currency, ExchangeDataService, NetworkType, TokenPricesResponse } from '@cityofzion/blockchain-service'
-import axios, { AxiosInstance } from 'axios'
-
-type FlamingoTokenInfoPricesResponse = {
-  symbol: string
-  usd_price: number
-  hash: string
-}[]
-
-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,
-      hash: price.hash,
-    }))
-  }
-
-  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

@@ -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
-  }
-}