diff --git a/app/actions/nftGalleryActions.js b/app/actions/nftGalleryActions.js
index 8ed479193..04525f81f 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,
-  hasMore: false,
+  count: 0,
 })
 
 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, next } = response?.data
+    const { assets, total: count } = response?.data
 
-    if (!assets || !assets.length)
+    if (!assets || !assets.length || !count)
       return DEFAULT_NFT_GALLERY_RESULTS(previousResults)
 
     const results = assets.map(
@@ -70,11 +70,7 @@ export async function parseGhostMarketResults({
       }),
     )
 
-    return {
-      results: previousResults.concat(results),
-      page,
-      hasMore: !!next && assets.length === SIZE,
-    }
+    return { results: previousResults.concat(results), page, count }
   } 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 a2a2eb536..ec5717c03 100644
--- a/app/components/Modals/TransferNftModal/TransferNftModal.jsx
+++ b/app/components/Modals/TransferNftModal/TransferNftModal.jsx
@@ -4,6 +4,7 @@ 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'
@@ -12,8 +13,6 @@ 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'
@@ -31,10 +30,10 @@ type Props = {
   address: string,
   tokenId: string,
   wif: string,
-  showSuccessNotification: ({ message: string }) => any,
-  showErrorNotification: ({ message: string }) => any,
-  showInfoNotification: ({ message: string }) => any,
-  hideNotification: (id: string) => void,
+  showSuccessNotification({ message: string }): any,
+  showErrorNotification({ message: string }): any,
+  showInfoNotification({ message: string, autoDismiss: number }): any,
+  hideNotification(id: string): any,
   dispatch: any => any,
   isHardwareLogin: boolean,
   signingFunction: () => void,
@@ -52,14 +51,14 @@ export default function TransferNftModal(props: Props) {
     address,
     wif,
     dispatch,
-    isHardwareLogin,
-    signingFunction,
     showSuccessNotification,
     showErrorNotification,
     showInfoNotification,
     hideNotification,
     recipientAddressProp,
     publicKey,
+    isHardwareLogin,
+    signingFunction,
   } = props
   function handleSubmit() {}
 
@@ -72,8 +71,7 @@ export default function TransferNftModal(props: Props) {
     recipientAddressProp ?? '',
   )
   const [recipientAddressError, setRecipientAddressError] = useState('')
-  const [gasFee, setGasFee] = useState(DEFAULT_FEES)
-  const [feesInitialized, setFeesInitialized] = useState(false)
+  const [fees, setFees] = useState(DEFAULT_FEES)
   const [sendButtonDisabled, setSendButtonDisabled] = useState(false)
   const [loading, setLoading] = useState(true)
   const { contacts } = useContactsContext()
@@ -160,53 +158,54 @@ export default function TransferNftModal(props: Props) {
   async function transfer() {
     try {
       setLoading(true)
-      let endpoint = await getNode(net)
-      if (!endpoint) {
-        endpoint = await getRPCEndpoint(net)
+      let rpcAddress = await getNode(net)
+      if (!rpcAddress) {
+        rpcAddress = await getRPCEndpoint(net)
       }
       const account = new n3Wallet.Account(isHardwareLogin ? publicKey : wif)
-      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 results = await new N3Helper(endpoint, 0).rpcCall(
+      const invoker = await NeonInvoker.init({
+        rpcAddress,
         account,
-        testReq,
-        isHardwareLogin,
-        signingFunction,
-        showInfoNotification,
-        hideNotification,
-      )
+        signingCallback: signingFunction,
+      })
+
+      let notificationId
+
+      if (isHardwareLogin) {
+        notificationId = showInfoNotification({
+          message: 'Please sign the transaction on your hardware device',
+          autoDismiss: 0,
+        })
+      }
+
+      const hash = await invoker.invokeFunction({
+        invocations: [
+          {
+            scriptHash: contract,
+            operation: 'transfer',
+            args: [
+              {
+                type: 'Hash160',
+                value: recipientAddress,
+              },
+              { type: 'ByteArray', value: tokenId },
+              { type: 'Any', value: null },
+            ],
+          },
+        ],
+      })
 
-      const { result } = results
+      if (notificationId) {
+        hideNotification(notificationId)
+      }
 
       dispatch(
         addPendingTransaction.call({
           address,
           net,
           tx: {
-            hash: result,
+            hash,
             sendEntries: [
               { amount: 1, address, contractHash: contract, symbol: 'N/A' },
             ],
@@ -217,67 +216,52 @@ 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 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: [
+  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: [
                 {
-                  scriptHash: contract,
-                  operation: 'transfer',
-                  args: [
-                    {
-                      type: 'Hash160',
-                      value: address,
-                    },
-                    { type: 'ByteArray', value: tokenId },
-                    { type: 'Any', value: null },
-                  ],
+                  type: 'Hash160',
+                  value: address,
                 },
+                { type: 'ByteArray', value: tokenId },
+                { type: 'Any', value: null },
               ],
-              signers: [{ scopes: 1 }],
             },
-          },
-        },
-      }
-      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()
-  }, [])
+          ],
+          signers: [{ scopes: 1 }],
+        })
+
+        setFees({
+          networkFee,
+          systemFee,
+        })
+      })()
+    },
+    [address, tokenId, isHardwareLogin, publicKey, wif, net, contract],
+  )
 
   function createContactList(): Array<string> {
     const filteredContacts = Object.keys(contacts).filter(contact =>
@@ -314,10 +298,7 @@ export default function TransferNftModal(props: Props) {
             error={recipientAddressError}
           />
 
-          <N3Fees
-            fees={loading && !feesInitialized ? DEFAULT_FEES : gasFee}
-            notEnoughGasCallback={toggleHasEnoughGas}
-          />
+          <N3Fees fees={fees} notEnoughGasCallback={toggleHasEnoughGas} />
 
           <Button
             className={styles.submitButton}
diff --git a/app/containers/NftGallery/NftGallery.jsx b/app/containers/NftGallery/NftGallery.jsx
index 5e130b352..1f7dcb3c6 100644
--- a/app/containers/NftGallery/NftGallery.jsx
+++ b/app/containers/NftGallery/NftGallery.jsx
@@ -25,10 +25,9 @@ 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({
@@ -119,7 +118,7 @@ export default function NFTGallery({
   loading,
   page,
   fetchAddtionalNFTData,
-  hasMore,
+  count,
   isWatchOnly,
   showModal,
 }: Props) {
@@ -207,7 +206,7 @@ export default function NFTGallery({
                   )
                 })}
 
-                {hasMore && (
+                {count !== results.length && (
                   <div className={styles.loadMoreButton}>
                     <Button
                       onClick={() =>
diff --git a/app/util/N3Helper.js b/app/util/N3Helper.js
deleted file mode 100644
index fab497828..000000000
--- a/app/util/N3Helper.js
+++ /dev/null
@@ -1,394 +0,0 @@
-// @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 2294ea5f1..7d634f725 100644
--- a/config/webpack.config.dev.js
+++ b/config/webpack.config.dev.js
@@ -81,13 +81,6 @@ 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',