@cityofzion/bs-neo3 0.4.2 → 0.7.0

package/src/BSNeo3.ts

@@ -1,223 +1,223 @@
-import { BlockchainDataService, keychain, BlockchainService, CalculateTransferFeeDetails, SendTransactionParam, TokenInfo, Claimable, Account, Exchange, BDSClaimable, exchangeOptions, Token, IntentTransactionParam, NeoNameService, NNSRecordTypes, CalculateTransferFeeResponse } from '@cityofzion/blockchain-service'
-import { api, rpc, tx, u, wallet } from '@cityofzion/neon-js'
-import { gasInfoNeo3, neoInfoNeo3 } from './constants'
-import { claimGasExceptions } from './exceptions'
-import { explorerOptions } from './explorer'
-import tokens from './assets/tokens.json'
+import {
+  BlockchainDataService,
+  BlockchainService,
+  BSClaimable,
+  Account,
+  ExchangeDataService,
+  BDSClaimable,
+  Token,
+  BSWithNameService,
+  Network,
+  PartialBy,
+  TransferParam,
+  BSCalculableFee,
+  NftDataService,
+  BSWithNft,
+  AccountWithDerivationPath,
+} 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 { NeonParser } from '@cityofzion/neon-parser'
 import { ABI_TYPES } from '@cityofzion/neo3-parser'
-
-const NEO_NS_HASH = "0x50ac1c37690cc2cfc594472833cf57505d5f46de";
-
-export class BSNeo3<BSCustomName extends string = string> implements BlockchainService, Claimable, NeoNameService {
-    blockchainName: BSCustomName
-    dataService: BlockchainDataService & BDSClaimable = explorerOptions.dora
-    feeToken: TokenInfo = gasInfoNeo3
-    exchange: Exchange = exchangeOptions.flamingo
-    tokenClaim: TokenInfo = neoInfoNeo3
-    tokens: Token[] = tokens
-
-    private derivationPath: string = "m/44'/888'/0'/0/?"
-
-    constructor(blockchainName: BSCustomName) {
-        this.blockchainName = blockchainName
-    }
-    validateAddress(address: string): boolean {
-        return wallet.isAddress(address, 53)
-    }
-    validateEncryptedKey(encryptedKey: string): boolean {
-        return wallet.isNEP2(encryptedKey)
-    }
-    validateWif(wif: string): boolean {
-        return wallet.isWIF(wif)
-    }
-    validateNNSFormat(domainName: string): boolean {
-        if (!domainName.endsWith('.neo')) return false
-        return true
-    }
-    generateMnemonic(): string[] {
-        keychain.generateMnemonic(128)
-        if (!keychain.mnemonic) throw new Error("Failed to generate mnemonic")
-        return keychain.mnemonic.toString().split(' ')
-    }
-    generateAccount(mnemonic: string[], index: number): Account {
-        keychain.importMnemonic(mnemonic.join(' '))
-        const childKey = keychain.generateChildKey("neo", this.derivationPath.replace('?', index.toString()))
-        const wif =  childKey.getWIF()
-        const { address } = new wallet.Account(wif)
-        return { address, wif }
-    }
-    generateAccountFromWif(wif: string): Account {
-        const { address } = new wallet.Account(wif)
-        return { address, wif }
-    }
-    async decryptKey(encryptedKey: string, password: string): Promise<Account> {
-        const wif = await wallet.decrypt(encryptedKey, password)
-        const { address } = new wallet.Account(wif)
-        return { address, wif }
-    }
-    async calculateTransferFee(param: SendTransactionParam): Promise<CalculateTransferFeeResponse> {
-        const node = await this.dataService.getHigherNode()
-        const url = node.url
-        const rpcClient = new rpc.NeoServerRpcClient(url)
-        const intents = this.buildTransfer(param.transactionIntents, param.senderAccount)
-        const txBuilder = new api.TransactionBuilder()
-        for (const intent of intents) {
-            if (intent.decimalAmt) {
-                const [tokenInfo] = await api.getTokenInfos(
-                    [intent.contractHash],
-                    rpcClient
-                )
-                const amt = u.BigInteger.fromDecimal(
-                    intent.decimalAmt,
-                    tokenInfo.decimals
-                )
-                txBuilder.addNep17Transfer(
-                    intent.from,
-                    intent.to,
-                    intent.contractHash,
-                    amt
-                )
-            }
-        }
-        const txn = txBuilder.build()
-        const accountScriptHash = wallet.getScriptHashFromAddress(param.senderAccount.address)
-        const invokeFunctionResponse = await rpcClient.invokeScript(
-            u.HexString.fromHex(txn.script),
-            [
-                {
-                    account: accountScriptHash,
-                    scopes: String(tx.WitnessScope.CalledByEntry)
-                }
-            ]
-        )
-        const systemFee = u.BigInteger.fromNumber(
-            invokeFunctionResponse.gasconsumed
-        ).toDecimal(gasInfoNeo3.decimals)
-
-        const networkFeeResponse = await rpcClient.calculateNetworkFee(txn)
-
-        const networkFee = (Number(networkFeeResponse) / 10 ** gasInfoNeo3.decimals)
-
-        const sumFee = Number(systemFee) + networkFee
-
-        const result: { result: number, details?: CalculateTransferFeeDetails } = {
-            result: sumFee,
-            details: {
-                networkFee: networkFee.toString(),
-                systemFee
-            }
-        }
-        return result
-    }
-    async sendTransaction(param: SendTransactionParam): Promise<string> {
-        try {
-            const { senderAccount, transactionIntents } = param
-            const node = await this.dataService.getHigherNode()
-            const facade = await api.NetworkFacade.fromConfig({ node: node.url })
-            const intents = this.buildTransfer(transactionIntents, senderAccount)
-            const signing = this.signTransfer(senderAccount)
-            const result = await facade.transferToken(intents, signing)
-            return result;
-        } catch (error) {
-            throw error;
-        }
-    }
-    //Claimable interface implementation
-    async claim(account: Account): Promise<{ txid: string; symbol: string; hash: string; }> {
-        const balance = await this.dataService.getBalance(account.address)
-        const neoHash = neoInfoNeo3.hash
-        const neoBalance = balance.find(balance => balance.hash === neoHash)
-        const gasBalance = balance.find(balance => balance.hash === gasInfoNeo3.hash)
-        const neoAccount = new wallet.Account(account.wif)
-
-        if (!neoBalance || !gasBalance) throw new Error(`Problem to claim`);
-
-        const dataToClaim: SendTransactionParam = {
-            transactionIntents: [{ amount: neoBalance.amount, receiverAddress: account.address, tokenHash: neoBalance.hash }],
-            senderAccount: account
-        }
-
-        const feeToClaim = await this.calculateTransferFee(dataToClaim)
-
-        if (gasBalance.amount < feeToClaim.result) {
-            claimGasExceptions.InsuficientGas(String(gasBalance.amount), String(feeToClaim.result))
-        }
-        const url = (await this.dataService.getHigherNode()).url
-        const facade = await api.NetworkFacade.fromConfig({ node: url })
-        const signing = this.signTransfer(account)
-        const txid = await facade.claimGas(neoAccount, signing)
-        const result: { txid: string; symbol: string; hash: string; } = {
-            hash: gasInfoNeo3.hash,
-            symbol: gasInfoNeo3.symbol,
-            txid
-        }
-        return result;
-    }
-    // Gets the record of a second-level domain or its subdomains with the specific type.
-    async getNNSRecord(
-      domainName: string,
-      type: NNSRecordTypes
-    ): Promise<any> {
-        const higherNode = await this.dataService.getHigherNode()
-        const parser = NeonParser
-        const invoker = await NeonInvoker.init(higherNode.url)
-        const response = await invoker.testInvoke({
-            invocations: [{
-                scriptHash: NEO_NS_HASH,
-                operation: "getRecord",
-                args: [{ type: "String", value: domainName }, { type: "Integer", value: type }]
-            }]
-        })
-
-        if (response.stack.length === 0) {
-            throw new Error(response.exception ?? 'unrecognized response')
-        }
-
-        const parsed = parser.parseRpcResponse(response.stack[0] as any)
-        return parsed
-    }
-
-    async getOwnerOfNNS(domainName: string): Promise<any> {
-        const higherNode = await this.dataService.getHigherNode()
-        const parser = NeonParser
-        const invoker = await NeonInvoker.init(higherNode.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 buildTransfer(transactionIntents: IntentTransactionParam[], account: Account) {
-        const intents: api.Nep17TransferIntent[] = []
-        const neoAccount = new wallet.Account(account.wif)
-        for (const transactionIntent of transactionIntents) {
-            const { amount, receiverAddress, tokenHash } = transactionIntent
-            intents.push({
-                to: receiverAddress,
-                contractHash: tokenHash,
-                from: neoAccount,
-                decimalAmt: amount,
-            })
-        }
-        return intents
-    }
-    private signTransfer(account: Account) {
-        const neoAccount = new wallet.Account(account.address)
-        const result: api.signingConfig = {
-            signingCallback: api.signWithAccount(neoAccount)
-        }
-        return result
-    }
-}
+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'
+
+export class BSNeo3<BSCustomName extends string = string>
+  implements BlockchainService, BSClaimable, BSWithNameService, BSCalculableFee, BSWithNft
+{
+  readonly blockchainName: BSCustomName
+  readonly feeToken: Token
+  readonly claimToken: Token
+  readonly burnToken: Token
+  readonly derivationPath: string
+
+  blockchainDataService!: BlockchainDataService & BDSClaimable
+  nftDataService!: NftDataService
+  exchangeDataService!: ExchangeDataService
+  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)
+  }
+
+  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
+    } catch {
+      const key = await wallet.decrypt(encryptedKey, password)
+      return this.generateAccountFromKey(key)
+    }
+
+    if (!BsReactNativeDecrypt) {
+      throw new Error('@CityOfZion/bs-react-native-decrypt is not installed')
+    }
+
+    const privateKey = await BsReactNativeDecrypt.decryptNeo3(encryptedKey, password)
+    return this.generateAccountFromKey(privateKey)
+  }
+
+  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

@@ -0,0 +1,180 @@
+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 transactions = await Promise.all(
+      data.items.map(async (item): Promise<TransactionResponse> => {
+        const filteredTransfers = item.notifications.filter(
+          item => item.event_name === 'Transfer' && (item.state.value.length === 3 || item.state.value.length === 4)
+        )
+        const transferPromises = filteredTransfers.map<Promise<TransactionTransferAsset | TransactionTransferNft>>(
+          async ({ contract: contractHash, state: { value: properties } }) => {
+            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',
+            }
+          }
+        )
+        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,
+        }
+      })
+    )
+
+    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: u.BigInteger.fromNumber(balance.balance).toDecimal(token.decimals),
+          token,
+        }
+      } catch {}
+    })
+    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
+  }
+}