@cityofzion/bs-neo3 0.10.0 → 0.11.1

package/CHANGELOG.json

@@ -1,83 +0,0 @@
-{
-  "name": "@cityofzion/bs-neo3",
-  "entries": [
-    {
-      "version": "0.10.0",
-      "tag": "@cityofzion/bs-neo3_v0.10.0",
-      "date": "Thu, 04 Apr 2024 19:52:20 GMT",
-      "comments": {
-        "minor": [
-          {
-            "comment": "Add ledger support"
-          }
-        ],
-        "dependency": [
-          {
-            "comment": "Updating dependency \"@cityofzion/blockchain-service\" to `0.10.0`"
-          }
-        ]
-      }
-    },
-    {
-      "version": "0.9.3",
-      "tag": "@cityofzion/bs-neo3_v0.9.3",
-      "date": "Wed, 28 Feb 2024 17:43:01 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Add creator infomations in nft methods return"
-          }
-        ],
-        "dependency": [
-          {
-            "comment": "Updating dependency \"@cityofzion/blockchain-service\" to `0.9.1`"
-          }
-        ]
-      }
-    },
-    {
-      "version": "0.9.2",
-      "tag": "@cityofzion/bs-neo3_v0.9.2",
-      "date": "Tue, 30 Jan 2024 18:26:00 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Fixed bug preventing decryption in dev mode in React Native"
-          },
-          {
-            "comment": "Fixed lint errors that were preventing the build"
-          }
-        ]
-      }
-    },
-    {
-      "version": "0.9.1",
-      "tag": "@cityofzion/bs-neo3_v0.9.1",
-      "date": "Wed, 06 Dec 2023 21:51:30 GMT",
-      "comments": {
-        "patch": [
-          {
-            "comment": "Prevent the getAllTransaction method from breaking when Dora returns data from v1"
-          }
-        ]
-      }
-    },
-    {
-      "version": "0.9.0",
-      "tag": "@cityofzion/bs-neo3_v0.9.0",
-      "date": "Tue, 05 Dec 2023 18:42:10 GMT",
-      "comments": {
-        "minor": [
-          {
-            "comment": "Inserted within the TokenPricesResponse type the token hash"
-          }
-        ],
-        "dependency": [
-          {
-            "comment": "Updating dependency \"@cityofzion/blockchain-service\" to `0.9.0`"
-          }
-        ]
-      }
-    }
-  ]
-}

package/CHANGELOG.md

@@ -1,40 +0,0 @@
-# Change Log - @cityofzion/bs-neo3
-
-This log was last generated on Thu, 04 Apr 2024 19:52:20 GMT and should not be manually modified.
-
-## 0.10.0
-Thu, 04 Apr 2024 19:52:20 GMT
-
-### Minor changes
-
-- Add ledger support
-
-## 0.9.3
-Wed, 28 Feb 2024 17:43:01 GMT
-
-### Patches
-
-- Add creator infomations in nft methods return
-
-## 0.9.2
-Tue, 30 Jan 2024 18:26:00 GMT
-
-### Patches
-
-- Fixed bug preventing decryption in dev mode in React Native
-- Fixed lint errors that were preventing the build
-
-## 0.9.1
-Wed, 06 Dec 2023 21:51:30 GMT
-
-### Patches
-
-- Prevent the getAllTransaction method from breaking when Dora returns data from v1
-
-## 0.9.0
-Tue, 05 Dec 2023 18:42:10 GMT
-
-### Minor changes
-
-- Inserted within the TokenPricesResponse type the token hash
-

package/bs-neo3.build.log

@@ -1 +0,0 @@
-Invoking: tsc --project tsconfig.build.json 

package/jest.config.ts

@@ -1,13 +0,0 @@
-import { JestConfigWithTsJest } from 'ts-jest'
-const config: JestConfigWithTsJest = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  clearMocks: true,
-  verbose: true,
-  bail: true,
-  testMatch: ['<rootDir>/**/*.spec.ts'],
-  setupFiles: ['<rootDir>/jest.setup.ts'],
-  detectOpenHandles: true,
-}
-
-export default config

package/jest.setup.ts

@@ -1 +0,0 @@
-import 'dotenv/config'

package/src/BSNeo3.ts

@@ -1,254 +0,0 @@
-import {
-  BlockchainDataService,
-  BlockchainService,
-  BSClaimable,
-  Account,
-  ExchangeDataService,
-  BDSClaimable,
-  Token,
-  BSWithNameService,
-  Network,
-  PartialBy,
-  TransferParam,
-  BSCalculableFee,
-  NftDataService,
-  BSWithNft,
-  AccountWithDerivationPath,
-  BSWithExplorerService,
-  ExplorerService,
-  BSWithLedger,
-} from '@cityofzion/blockchain-service'
-import { api, u, wallet } from '@cityofzion/neon-js'
-import Neon from '@cityofzion/neon-core'
-import { NeonInvoker, NeonParser } from '@cityofzion/neon-dappkit'
-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'
-import { ContractInvocation } from '@cityofzion/neon-dappkit-types'
-import { LedgerServiceNeo3 } from './LedgerServiceNeo3'
-
-export class BSNeo3<BSCustomName extends string = string>
-  implements
-    BlockchainService,
-    BSClaimable,
-    BSWithNameService,
-    BSCalculableFee,
-    BSWithNft,
-    BSWithExplorerService,
-    BSWithLedger
-{
-  readonly blockchainName: BSCustomName
-  readonly feeToken: Token
-  readonly claimToken: Token
-  readonly burnToken: Token
-  readonly derivationPath: string
-
-  blockchainDataService!: BlockchainDataService & BDSClaimable
-  nftDataService!: NftDataService
-  ledgerService: LedgerServiceNeo3 = new LedgerServiceNeo3()
-  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 }
-  }
-
-  generateAccountFromPublicKey(publicKey: string): Account {
-    if (!wallet.isPublicKey(publicKey)) throw new Error('Invalid public key')
-
-    const account = new wallet.Account(publicKey)
-
-    return {
-      address: account.address,
-      key: account.publicKey,
-      type: 'publicKey',
-    }
-  }
-
-  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 { total } = await invoker.calculateFee({
-      invocations,
-      signers: [],
-    })
-
-    return total.toString()
-  }
-
-  async transfer(param: TransferParam): Promise<string> {
-    const account = new wallet.Account(param.senderAccount.key)
-
-    const invoker = await NeonInvoker.init({
-      rpcAddress: this.network.url,
-      account,
-      signingCallback: param.isLedger ? this.ledgerService.getSigningCallback(param.ledgerTransport) : undefined,
-    })
-
-    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: 'Hash160',
-    })
-    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
-  }
-}