@cityofzion/bs-neo3 0.7.3 → 0.8.0

package/src/GhostMarketNDSNeo3.ts

@@ -1,117 +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
-  }
-}
+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

@@ -1,157 +1,157 @@
-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
-
-  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 2
-
-  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)
-  }
-}
+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
+
+  maxTimeToConfirmTransactionInMs: number = 1000 * 60 * 2
+
+  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)
+  }
+}