NearRequestHandlerUtil.ts

import { NEAR_SIGNING_METHODS, NEAR_TEST_CHAINS } from '@/data/NEARData'
import { formatJsonRpcError, formatJsonRpcResult } from '@json-rpc-tools/utils'
import { SignClientTypes } from '@walletconnect/types'
import { getSdkError } from '@walletconnect/utils'
import { nearWallet } from '@/utils/NearWalletUtil'
import { InMemorySigner, transactions, utils, Connection } from 'near-api-js'
import { Transaction } from '@near-wallet-selector/core'
import { createAction } from '@near-wallet-selector/wallet-utils'

export async function approveNearRequest(
  requestEvent: SignClientTypes.EventArguments['session_request']
) {
  const { params, id, topic } = requestEvent
  const { chainId, request } = params

  switch (request.method) {
    case NEAR_SIGNING_METHODS.NEAR_SIGN_IN: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const accounts = await nearWallet.signIn({
        chainId,
        topic,
        permission: request.params.permission,
        accounts: request.params.accounts
      })

      return formatJsonRpcResult(id, accounts)
    }
    case NEAR_SIGNING_METHODS.NEAR_SIGN_OUT: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const accounts = await nearWallet.signOut({
        chainId,
        topic,
        accounts: request.params.accounts
      })

      return formatJsonRpcResult(id, accounts)
    }
    case NEAR_SIGNING_METHODS.NEAR_GET_ACCOUNTS: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const accounts = await nearWallet.getAccounts({ topic })

      return formatJsonRpcResult(id, accounts)
    }
    case NEAR_SIGNING_METHODS.NEAR_SIGN_TRANSACTION: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const isBuffer = request.params.transaction?.type === 'Buffer'
      const txValue = isBuffer
        ? request.params.transaction
        : Object.values(request.params.transaction)

      const [signedTx] = await nearWallet.signTransactions({
        chainId,
        topic,
        transactions: [transactions.Transaction.decode(Buffer.from(txValue))]
      })

      const txResultValue = isBuffer ? Buffer.from(signedTx.encode()) : signedTx.encode()

      return formatJsonRpcResult(id, txResultValue)
    }
    case NEAR_SIGNING_METHODS.NEAR_SIGN_AND_SEND_TRANSACTION: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const [transaction] = await nearWallet.createTransactions({
        chainId,
        transactions: [
          {
            ...params.request.params.transaction,
            actions: params.request.params.transaction.actions.map(createAction)
          }
        ]
      })

      const result = await nearWallet.signAndSendTransaction({
        chainId,
        topic,
        transaction
      })

      return formatJsonRpcResult(id, result)
    }
    case NEAR_SIGNING_METHODS.NEAR_SIGN_TRANSACTIONS: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const isBuffer = params.request.params.transactions[0]?.type === 'Buffer'

      const signedTxs = await nearWallet.signTransactions({
        chainId,
        topic,
        transactions: params.request.params.transactions.map((tx: Uint8Array) => {
          // @ts-ignore
          const txValue = isBuffer ? tx : Object.values(tx)
          return transactions.Transaction.decode(Buffer.from(txValue))
        })
      })

      return formatJsonRpcResult(
        id,
        signedTxs.map(x => {
          return isBuffer ? Buffer.from(x.encode()) : x.encode()
        })
      )
    }
    case NEAR_SIGNING_METHODS.NEAR_VERIFY_OWNER: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const accounts = await nearWallet.getAllAccounts()
      const account = accounts.find(acc => acc.accountId === params.request.params.accountId)

      if (!account) {
        throw new Error(`Did not find account with id: ${params.request.params.accountId}`)
      }

      if (!NEAR_TEST_CHAINS[chainId]) {
        throw new Error('Invalid chain id')
      }

      const signer = new InMemorySigner(nearWallet.getKeyStore())
      const networkId = chainId.split(':')[1]
      const connection = Connection.fromConfig({
        networkId,
        provider: { type: 'JsonRpcProvider', args: { url: NEAR_TEST_CHAINS[chainId].rpc } },
        signer
      })

      const blockInfo = await connection.provider.block({ finality: 'final' })
      const publicKey = utils.PublicKey.from(account.publicKey)

      const data = {
        accountId: account.accountId,
        message: params.request.params.message,
        blockId: blockInfo.header.hash,
        publicKey: Buffer.from(publicKey.data).toString('base64'),
        keyType: publicKey.keyType
      }

      const encoded = new Uint8Array(Buffer.from(JSON.stringify(data)))
      const signed = await signer.signMessage(encoded, account.accountId, networkId)

      return formatJsonRpcResult(id, {
        ...data,
        signature: Buffer.from(signed.signature).toString('base64'),
        keyType: signed.publicKey.keyType
      })
    }
    case NEAR_SIGNING_METHODS.NEAR_SIGN_MESSAGE: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const { accountId, publicKey, signature } = await nearWallet.signMessage({
        chainId,
        messageParams: params.request.params
      })

      return formatJsonRpcResult(id, {
        accountId,
        publicKey,
        signature
      })
    }
    case NEAR_SIGNING_METHODS.NEAR_SIGN_AND_SEND_TRANSACTIONS: {
      console.log('approve', { id, params })

      if (!chainId) {
        throw new Error('Invalid chain id')
      }

      const transactions = await nearWallet.createTransactions({
        chainId,
        transactions: params.request.params.transactions.map((transaction: Transaction) => ({
          ...transaction,
          actions: transaction.actions.map(createAction)
        }))
      })

      const result = await nearWallet.signAndSendTransactions({
        chainId,
        topic,
        transactions
      })

      return formatJsonRpcResult(id, result)
    }
    default:
      throw new Error(getSdkError('INVALID_METHOD').message)
  }
}

export function rejectNearRequest(request: SignClientTypes.EventArguments['session_request']) {
  const { id } = request

  return formatJsonRpcError(id, getSdkError('USER_REJECTED_METHODS').message)
}