From 7ca9e4f580a882da569429e7e1a2b587e13355c4 Mon Sep 17 00:00:00 2001
From: Maxwell Lasky <mlasky46@gmail.com>
Date: Fri, 22 Sep 2023 10:07:11 -0600
Subject: [PATCH] Fixes regression (#2527)

---
 app/actions/nftGalleryActions.js              |  14 +-
 .../TransferNftModal/TransferNftModal.jsx     | 179 ++++----
 app/containers/NftGallery/NftGallery.jsx      |   7 +-
 app/util/N3Helper.js                          | 394 ++++++++++++++++++
 config/webpack.config.dev.js                  |   7 +
 5 files changed, 513 insertions(+), 88 deletions(-)
 create mode 100644 app/util/N3Helper.js

diff --git a/app/actions/nftGalleryActions.js b/app/actions/nftGalleryActions.js
index 04525f81f..8ed479193 100644
--- a/app/actions/nftGalleryActions.js
+++ b/app/actions/nftGalleryActions.js
@@ -23,14 +23,14 @@ export type NftGalleryItem = {
 
 export type NftGalleryResults = {
   results: NftGalleryItem[],
-  count: number,
   page: number,
+  hasMore: boolean,
 }
 
 const DEFAULT_NFT_GALLERY_RESULTS = (previousResults?: NftGalleryItem[]) => ({
   results: previousResults ?? [],
   page: 0,
-  count: 0,
+  hasMore: false,
 })
 
 export async function parseGhostMarketResults({
@@ -49,9 +49,9 @@ export async function parseGhostMarketResults({
       `https://api.ghostmarket.io/api/v2/assets?chain=n3&owners[]=${address}&size=${SIZE}&page=${page}&getTotal=true`,
     )
 
-    const { assets, total: count } = response?.data
+    const { assets, next } = response?.data
 
-    if (!assets || !assets.length || !count)
+    if (!assets || !assets.length)
       return DEFAULT_NFT_GALLERY_RESULTS(previousResults)
 
     const results = assets.map(
@@ -70,7 +70,11 @@ export async function parseGhostMarketResults({
       }),
     )
 
-    return { results: previousResults.concat(results), page, count }
+    return {
+      results: previousResults.concat(results),
+      page,
+      hasMore: !!next && assets.length === SIZE,
+    }
   } catch (e) {
     console.error('An error occurred fetching data for NFT gallery', { e })
     return DEFAULT_NFT_GALLERY_RESULTS(previousResults)
diff --git a/app/components/Modals/TransferNftModal/TransferNftModal.jsx b/app/components/Modals/TransferNftModal/TransferNftModal.jsx
index ec5717c03..a2a2eb536 100644
--- a/app/components/Modals/TransferNftModal/TransferNftModal.jsx
+++ b/app/components/Modals/TransferNftModal/TransferNftModal.jsx
@@ -4,7 +4,6 @@ import { FormattedMessage } from 'react-intl'
 import { wallet as n3Wallet } from '@cityofzion/neon-js'
 import { BSNeo3 } from '@cityofzion/bs-neo3'
 
-import { NeonInvoker } from '@cityofzion/neon-invoker'
 import { NFT } from '../../../containers/NftGallery/NftGallery'
 import Button from '../../Button'
 import SelectInput from '../../Inputs/SelectInput'
@@ -13,6 +12,8 @@ import N3Fees from '../../Send/N3Fees'
 import BaseModal from '../BaseModal'
 import styles from './TransferNftModal.scss'
 import { getNode, getRPCEndpoint } from '../../../actions/nodeStorageActions'
+import N3Helper from '../../../util/N3Helper'
+import { convertToArbitraryDecimals } from '../../../core/formatters'
 import { addPendingTransaction } from '../../../actions/pendingTransactionActions'
 import { useContactsContext } from '../../../context/contacts/ContactsContext'
 import { MODAL_TYPES } from '../../../core/constants'
@@ -30,10 +31,10 @@ type Props = {
   address: string,
   tokenId: string,
   wif: string,
-  showSuccessNotification({ message: string }): any,
-  showErrorNotification({ message: string }): any,
-  showInfoNotification({ message: string, autoDismiss: number }): any,
-  hideNotification(id: string): any,
+  showSuccessNotification: ({ message: string }) => any,
+  showErrorNotification: ({ message: string }) => any,
+  showInfoNotification: ({ message: string }) => any,
+  hideNotification: (id: string) => void,
   dispatch: any => any,
   isHardwareLogin: boolean,
   signingFunction: () => void,
@@ -51,14 +52,14 @@ export default function TransferNftModal(props: Props) {
     address,
     wif,
     dispatch,
+    isHardwareLogin,
+    signingFunction,
     showSuccessNotification,
     showErrorNotification,
     showInfoNotification,
     hideNotification,
     recipientAddressProp,
     publicKey,
-    isHardwareLogin,
-    signingFunction,
   } = props
   function handleSubmit() {}
 
@@ -71,7 +72,8 @@ export default function TransferNftModal(props: Props) {
     recipientAddressProp ?? '',
   )
   const [recipientAddressError, setRecipientAddressError] = useState('')
-  const [fees, setFees] = useState(DEFAULT_FEES)
+  const [gasFee, setGasFee] = useState(DEFAULT_FEES)
+  const [feesInitialized, setFeesInitialized] = useState(false)
   const [sendButtonDisabled, setSendButtonDisabled] = useState(false)
   const [loading, setLoading] = useState(true)
   const { contacts } = useContactsContext()
@@ -158,54 +160,53 @@ export default function TransferNftModal(props: Props) {
   async function transfer() {
     try {
       setLoading(true)
-      let rpcAddress = await getNode(net)
-      if (!rpcAddress) {
-        rpcAddress = await getRPCEndpoint(net)
+      let endpoint = await getNode(net)
+      if (!endpoint) {
+        endpoint = await getRPCEndpoint(net)
       }
       const account = new n3Wallet.Account(isHardwareLogin ? publicKey : wif)
-
-      const invoker = await NeonInvoker.init({
-        rpcAddress,
-        account,
-        signingCallback: signingFunction,
-      })
-
-      let notificationId
-
-      if (isHardwareLogin) {
-        notificationId = showInfoNotification({
-          message: 'Please sign the transaction on your hardware device',
-          autoDismiss: 0,
-        })
+      const testReq = {
+        params: {
+          request: {
+            method: 'multiInvoke',
+            params: {
+              invocations: [
+                {
+                  scriptHash: contract,
+                  operation: 'transfer',
+                  args: [
+                    {
+                      type: 'Hash160',
+                      value: recipientAddress,
+                    },
+                    { type: 'ByteArray', value: tokenId },
+                    { type: 'Any', value: null },
+                  ],
+                },
+              ],
+              signers: [{ scopes: 1 }],
+            },
+          },
+        },
       }
 
-      const hash = await invoker.invokeFunction({
-        invocations: [
-          {
-            scriptHash: contract,
-            operation: 'transfer',
-            args: [
-              {
-                type: 'Hash160',
-                value: recipientAddress,
-              },
-              { type: 'ByteArray', value: tokenId },
-              { type: 'Any', value: null },
-            ],
-          },
-        ],
-      })
+      const results = await new N3Helper(endpoint, 0).rpcCall(
+        account,
+        testReq,
+        isHardwareLogin,
+        signingFunction,
+        showInfoNotification,
+        hideNotification,
+      )
 
-      if (notificationId) {
-        hideNotification(notificationId)
-      }
+      const { result } = results
 
       dispatch(
         addPendingTransaction.call({
           address,
           net,
           tx: {
-            hash,
+            hash: result,
             sendEntries: [
               { amount: 1, address, contractHash: contract, symbol: 'N/A' },
             ],
@@ -216,52 +217,67 @@ export default function TransferNftModal(props: Props) {
       showSuccessNotification({
         message: 'Transaction pending! Your NFT will be transferred shortly.',
       })
+      setLoading(false)
+      hideModal()
     } catch (e) {
+      hideModal()
       showErrorNotification({
         message: e.message,
       })
-    } finally {
       setLoading(false)
-      hideModal()
     }
   }
 
-  useEffect(
-    () => {
-      ;(async () => {
-        let rpcAddress = await getNode(net)
-        if (!rpcAddress) {
-          rpcAddress = await getRPCEndpoint(net)
-        }
-        const account = new n3Wallet.Account(isHardwareLogin ? publicKey : wif)
-
-        const invoker = await NeonInvoker.init({ rpcAddress, account })
-        const { networkFee, systemFee } = await invoker.calculateFee({
-          invocations: [
-            {
-              scriptHash: contract,
-              operation: 'transfer',
-              args: [
+  useEffect(() => {
+    async function testInvoke() {
+      setLoading(true)
+      let endpoint = await getNode(net)
+      if (!endpoint) {
+        endpoint = await getRPCEndpoint(net)
+      }
+      const account = new n3Wallet.Account(address)
+      const testReq = {
+        params: {
+          request: {
+            method: 'testInvoke',
+            params: {
+              invocations: [
                 {
-                  type: 'Hash160',
-                  value: address,
+                  scriptHash: contract,
+                  operation: 'transfer',
+                  args: [
+                    {
+                      type: 'Hash160',
+                      value: address,
+                    },
+                    { type: 'ByteArray', value: tokenId },
+                    { type: 'Any', value: null },
+                  ],
                 },
-                { type: 'ByteArray', value: tokenId },
-                { type: 'Any', value: null },
               ],
+              signers: [{ scopes: 1 }],
             },
-          ],
-          signers: [{ scopes: 1 }],
-        })
-
-        setFees({
-          networkFee,
-          systemFee,
-        })
-      })()
-    },
-    [address, tokenId, isHardwareLogin, publicKey, wif, net, contract],
-  )
+          },
+        },
+      }
+      const results = await new N3Helper(endpoint, 0).rpcCall(
+        account,
+        testReq,
+        isHardwareLogin,
+        signingFunction,
+        showInfoNotification,
+        hideNotification,
+      )
+      const fee = convertToArbitraryDecimals(results.result.gasconsumed)
+      setGasFee({
+        networkFee: fee,
+        systemFee: 0,
+      })
+      setFeesInitialized(true)
+      setLoading(false)
+    }
+    testInvoke()
+  }, [])
 
   function createContactList(): Array<string> {
     const filteredContacts = Object.keys(contacts).filter(contact =>
@@ -298,7 +314,10 @@ export default function TransferNftModal(props: Props) {
             error={recipientAddressError}
           />
 
-          <N3Fees fees={fees} notEnoughGasCallback={toggleHasEnoughGas} />
+          <N3Fees
+            fees={loading && !feesInitialized ? DEFAULT_FEES : gasFee}
+            notEnoughGasCallback={toggleHasEnoughGas}
+          />
 
           <Button
             className={styles.submitButton}
diff --git a/app/containers/NftGallery/NftGallery.jsx b/app/containers/NftGallery/NftGallery.jsx
index 1f7dcb3c6..5e130b352 100644
--- a/app/containers/NftGallery/NftGallery.jsx
+++ b/app/containers/NftGallery/NftGallery.jsx
@@ -25,9 +25,10 @@ type Props = {
   networkId: string,
   net: string,
   page: number,
-  count: number,
+  // count: number,
   isWatchOnly: boolean,
   showModal: (type: string, props: any) => any,
+  hasMore: boolean,
 }
 
 export function NFT({
@@ -118,7 +119,7 @@ export default function NFTGallery({
   loading,
   page,
   fetchAddtionalNFTData,
-  count,
+  hasMore,
   isWatchOnly,
   showModal,
 }: Props) {
@@ -206,7 +207,7 @@ export default function NFTGallery({
                   )
                 })}
 
-                {count !== results.length && (
+                {hasMore && (
                   <div className={styles.loadMoreButton}>
                     <Button
                       onClick={() =>
diff --git a/app/util/N3Helper.js b/app/util/N3Helper.js
new file mode 100644
index 000000000..fab497828
--- /dev/null
+++ b/app/util/N3Helper.js
@@ -0,0 +1,394 @@
+// @flow
+import { u } from '@cityofzion/neon-js-legacy-latest'
+import Neon, { rpc, tx, sc, api, wallet } from '@cityofzion/neon-js'
+// eslint-disable-next-line
+
+import { randomBytes } from 'crypto'
+
+type WitnessScope = {
+  None: 0,
+  /**
+   * CalledByEntry means that this condition must hold: EntryScriptHash == CallingScriptHash
+   * No params is needed, as the witness/permission/signature given on first invocation will automatically expire if entering deeper internal invokes
+   * This can be default safe choice for native NEO/GAS (previously used on Neo 2 as "attach" mode)
+   */
+  CalledByEntry: 1,
+  /**
+   * Custom hash for contract-specific
+   */
+  CustomContracts: 16,
+  /**
+   * Custom pubkey for group members, group can be found in contract manifest
+   */
+  CustomGroups: 32,
+  /**
+   * Global allows this witness in all contexts (default Neo2 behavior)
+   * This cannot be combined with other flags
+   */
+  Global: 128,
+}
+
+type Signer = {
+  scopes: WitnessScope,
+  allowedContracts?: string[],
+  allowedGroups?: string[],
+}
+
+type ContractInvocation = {
+  scriptHash: string,
+  operation: string,
+  args: any[],
+  abortOnFail?: boolean,
+}
+
+export type ContractInvocationMulti = {
+  signers: Signer[],
+  invocations: ContractInvocation[],
+  extraSystemFee?: number,
+  systemFeeOverride?: number,
+  extraNetworkFee?: number,
+  networkFeeOverride?: number,
+}
+
+type SignedMessage = {
+  publicKey: string,
+  data: string,
+  salt: string,
+  messageHex: string,
+}
+
+type SignMessagePayload = {
+  message: string,
+  version: number,
+}
+
+class N3Helper {
+  rpcAddress: string
+
+  networkMagic: number
+
+  constructor(rpcAddress: string, networkMagic: number) {
+    this.rpcAddress = rpcAddress
+    this.networkMagic = networkMagic
+  }
+
+  static init = async (
+    rpcAddress: string,
+    networkMagic?: number,
+  ): Promise<N3Helper> =>
+    new N3Helper(
+      rpcAddress,
+      networkMagic || (await N3Helper.getMagicOfRpcAddress(rpcAddress)),
+    )
+
+  static getMagicOfRpcAddress = async (rpcAddress: string): Promise<number> => {
+    const resp: any = await new rpc.RPCClient(rpcAddress).execute(
+      Neon.create.query({
+        method: 'getversion',
+        params: [],
+        id: 1,
+        jsonrpc: '2.0',
+      }),
+    )
+    return resp.protocol.network
+  }
+
+  rpcCall = async (
+    account: any,
+    sessionRequest: any,
+    isHardwareLogin?: boolean,
+    signingFunction?: () => void,
+    showInfoNotification?: ({ message: string }) => any,
+    hideNotification?: (id: string) => void,
+  ): Promise<any> => {
+    let result: any
+    const {
+      params: { request },
+    } = sessionRequest
+
+    if (
+      request.method === 'multiInvoke' ||
+      request.method === 'invokeFunction'
+    ) {
+      result = await this.multiInvoke(
+        account,
+        request.params,
+        isHardwareLogin,
+        signingFunction,
+        showInfoNotification,
+        hideNotification,
+      )
+    }
+    if (
+      request.method === 'multiTestInvoke' ||
+      request.method === 'testInvoke'
+    ) {
+      result = await this.multiTestInvoke(account, request.params)
+      result.isTest = true
+    }
+    if (request.method === 'signMessage') {
+      if (!account) {
+        throw new Error('No account')
+      }
+      result = this.signMessage(account, request.params)
+    }
+    if (request.method === 'verifyMessage') {
+      result = this.verifyMessage(request.params)
+    }
+
+    if (request.method === 'traverseIterator') {
+      result = await new rpc.RPCClient(this.rpcAddress).traverseIterator(
+        ...request.params,
+      )
+    }
+
+    if (request.method === 'getWalletInfo') {
+      result = {
+        isLedger: isHardwareLogin ?? false,
+      }
+    }
+
+    if (request.method === 'getNetworkVersion') {
+      const response = await new rpc.RPCClient(this.rpcAddress).getVersion()
+      result = {
+        rpcAddress: this.rpcAddress,
+        ...response,
+      }
+    }
+
+    if (request.method === 'getapplicationlog') {
+      result = await new rpc.RPCClient(this.rpcAddress).getApplicationLog(
+        request.params[0],
+      )
+    } else if (!result) {
+      const { jsonrpc, ...queryLike } = request
+      result = await new rpc.RPCClient(this.rpcAddress).execute(
+        Neon.create.query({ ...queryLike, jsonrpc: '2.0' }),
+      )
+    }
+
+    return {
+      id: sessionRequest.id,
+      jsonrpc: '2.0',
+      result,
+      isMessage:
+        request.method === 'signMessage' || request.method === 'verifyMessage',
+    }
+  }
+
+  signMessage = (
+    account: any,
+    message: string | SignMessagePayload,
+  ): SignedMessage => {
+    if (typeof message === 'string') {
+      return this.signMessageLegacy(account, message)
+    }
+    if (message.version === 1) {
+      return this.signMessageLegacy(account, message.message)
+    }
+    if (message.version === 2) {
+      return this.signMessageNew(account, message.message)
+    }
+
+    throw new Error('Invalid signMessage version')
+  }
+
+  signMessageLegacy = (account: any, message: string): SignedMessage => {
+    const salt = randomBytes(16).toString('hex')
+    const parameterHexString = u.str2hexstring(salt + message)
+    const lengthHex = u.num2VarInt(parameterHexString.length / 2)
+    const messageHex = `010001f0${lengthHex}${parameterHexString}0000`
+
+    return {
+      publicKey: account.publicKey,
+      data: wallet.sign(messageHex, account.privateKey),
+      salt,
+      messageHex,
+    }
+  }
+
+  signMessageNew = (account: any, message: string): SignedMessage => {
+    const salt = randomBytes(16).toString('hex')
+    const messageHex = u.str2hexstring(message)
+
+    return {
+      publicKey: account.publicKey,
+      data: wallet.sign(messageHex, account.privateKey, salt),
+      salt,
+      messageHex,
+    }
+  }
+
+  verifyMessage = (verifyArgs: SignedMessage): boolean =>
+    wallet.verify(verifyArgs.messageHex, verifyArgs.data, verifyArgs.publicKey)
+
+  multiTestInvoke = async (
+    account: any,
+    cim: ContractInvocationMulti,
+  ): Promise<any> => {
+    const sb = Neon.create.scriptBuilder()
+
+    cim.invocations.forEach(c => {
+      sb.emitContractCall({
+        scriptHash: c.scriptHash,
+        operation: c.operation,
+        args: N3Helper.convertParams(c.args),
+      })
+
+      if (c.abortOnFail) {
+        sb.emit(0x39)
+      }
+    })
+
+    const script = sb.build()
+    return new rpc.RPCClient(this.rpcAddress).invokeScript(
+      Neon.u.HexString.fromHex(script),
+      N3Helper.buildMultipleSigner(account, cim.signers),
+    )
+  }
+
+  multiInvoke = async (
+    account: any,
+    cim: ContractInvocationMulti,
+    isHardwareLogin?: boolean,
+    signingFunction?: () => void,
+    showInfoNotification?: (*) => void,
+    hideNotification?: (*) => void,
+  ): Promise<any> => {
+    const sb = Neon.create.scriptBuilder()
+    const networkMagic = await N3Helper.getMagicOfRpcAddress(this.rpcAddress)
+
+    cim.invocations.forEach(c => {
+      sb.emitContractCall({
+        scriptHash: c.scriptHash,
+        operation: c.operation,
+        args: N3Helper.convertParams(c.args),
+      })
+      if (c.abortOnFail) {
+        sb.emit(0x39)
+      }
+    })
+
+    const script = sb.build()
+    const rpcClient = new rpc.RPCClient(this.rpcAddress)
+    const currentHeight = await rpcClient.getBlockCount()
+
+    let trx = new tx.Transaction({
+      script: Neon.u.HexString.fromHex(script),
+      validUntilBlock: currentHeight + 100,
+      signers: N3Helper.buildMultipleSigner(account, cim.signers),
+    })
+
+    trx.witnesses = [
+      new tx.Witness({
+        verificationScript: wallet.getVerificationScriptFromPublicKey(
+          account.publicKey,
+        ),
+        invocationScript: '',
+      }),
+    ]
+
+    const feeConfig = {
+      rpcAddress: this.rpcAddress,
+      networkMagic,
+      account,
+      systemFeeOverride: undefined,
+      networkFeeOverride: undefined,
+    }
+
+    if (cim.extraNetworkFee) {
+      feeConfig.networkFeeOverride = (await Neon.experimental.txHelpers.calculateNetworkFee(
+        trx,
+        account,
+        feeConfig,
+      )).add(cim.extraNetworkFee)
+    }
+
+    if (cim.extraSystemFee) {
+      feeConfig.systemFeeOverride = (await Neon.experimental.txHelpers.getSystemFee(
+        trx.script,
+        feeConfig,
+        trx.signers,
+      )).add(cim.extraSystemFee)
+    }
+
+    await Neon.experimental.txHelpers.addFees(trx, feeConfig)
+
+    if (isHardwareLogin) {
+      const facade = await api.NetworkFacade.fromConfig({
+        node: this.rpcAddress,
+      })
+      const signingConfig = {
+        signingCallback: signingFunction,
+      }
+
+      let notificationId
+      if (showInfoNotification)
+        notificationId = showInfoNotification({
+          message: 'Please sign the transaction on your hardware device',
+          autoDismiss: 0,
+        })
+
+      trx = await facade.sign(trx, signingConfig).catch(console.error)
+
+      if (hideNotification && notificationId) hideNotification(notificationId)
+    } else {
+      trx.sign(account, networkMagic)
+    }
+
+    return rpcClient.sendRawTransaction(trx)
+  }
+
+  static buildSigner(account: any, signerEntry?: Signer) {
+    const signer = new tx.Signer({
+      account: account.scriptHash,
+    })
+
+    signer.scopes = signerEntry
+      ? signerEntry.scopes
+      : tx.WitnessScope.CalledByEntry
+    if (signerEntry && signerEntry.allowedContracts) {
+      signer.allowedContracts = signerEntry.allowedContracts.map(ac =>
+        Neon.u.HexString.fromHex(ac),
+      )
+    }
+    if (signerEntry && signerEntry.allowedGroups) {
+      signer.allowedGroups = signerEntry.allowedGroups.map(ac =>
+        Neon.u.HexString.fromHex(ac),
+      )
+    }
+
+    return signer
+  }
+
+  static buildMultipleSigner(account: any, signers: Signer[] = []) {
+    return !signers.length
+      ? [N3Helper.buildSigner(account)]
+      : // $FlowFixMe
+        signers.map(s => N3Helper.buildSigner(account, s))
+  }
+
+  static convertParams(args: any[]): any[] {
+    return args.map(
+      a =>
+        // eslint-disable-next-line
+        a.value === undefined
+          ? a
+          : // eslint-disable-next-line
+            a.type === 'Address'
+            ? sc.ContractParam.hash160(a.value)
+            : // eslint-disable-next-line
+              a.type === 'ScriptHash'
+              ? sc.ContractParam.hash160(a.value)
+              : a.type === 'Array'
+                ? sc.ContractParam.array(...N3Helper.convertParams(a.value))
+                : a,
+    )
+  }
+
+  static convertError(e: any) {
+    return { error: { message: e.message, ...e } }
+  }
+}
+
+export default N3Helper
diff --git a/config/webpack.config.dev.js b/config/webpack.config.dev.js
index 7d634f725..2294ea5f1 100644
--- a/config/webpack.config.dev.js
+++ b/config/webpack.config.dev.js
@@ -81,6 +81,13 @@ module.exports = {
           presets: [['@babel/preset-env', { targets: 'defaults' }]],
         },
       },
+      {
+        test: /(@cityofzion\/wallet-connect-sdk-wallet-core\/node_modules).*\.(ts|js)x?$/,
+        loader: 'babel-loader',
+        options: {
+          presets: [['@babel/preset-env', { targets: 'defaults' }]],
+        },
+      },
       {
         test: /(@cityofzion\/neon-invoker).*\.(ts|js)x?$/,
         loader: 'babel-loader',