wallet-svr/src/controllers/okx.controller.ts

import BaseController, { ROLE_ANON } from 'common/base.controller'
import { ZError } from 'common/ZError'
import { role, router } from 'decorators/router'
import logger from 'logger/logger'
import { TranRecord } from 'modules/TranRecord'
import { Wallet } from 'modules/Wallet'
import {
  addCoin,
  createWallet,
  ensureTxhash,
  getAddresses,
  getGasPrice,
  getSignInfo,
  queryCoin,
  queryTranDetail,
  queryTranHistory,
  sendTran,
} from 'service/okx.svr'

const DEFAULT_CHAINID = 42161
class OkxController extends BaseController {
  // @role(ROLE_ANON)
  // @router('post /wallet/okx/gasprice')
  async getPrice(req, res) {
    let { chain } = req.params
    chain = chain || DEFAULT_CHAINID
    let { data } = await getGasPrice(chain)
    if (data.code) {
      throw new ZError(data.code, data.message)
    }
    if (!data.data || data.data.length === 0) {
      throw new ZError(100, 'no data')
    }
    return data.data[0]
  }

  // @role(ROLE_ANON)
  // @router('post /wallet/okx/signinfo')
  async signInfo(req, res) {
    let { signData } = req.params
    let { data } = await getSignInfo(signData)
    return data
  }

  // @role(ROLE_ANON)
  // @router('post /wallet/okx/addcoin')
  async addCustomerCoin(req, res) {
    let { chainId, address } = req.params
    let reqData = {
      coins: [
        {
          chainId: chainId,
          tokenAddress: address,
        },
      ],
    }
    let { data } = await addCoin(reqData)
    return data
  }

  // @router('post /wallet/okx/bindwallet')
  async bindWallet(req, res) {
    let user = req.user
    let { chainId, address, walletId } = req.params
    chainId = chainId || DEFAULT_CHAINID
    let data = {
      addresses: [
        {
          chainId: chainId,
          address: address,
        },
      ],
      walletId,
    }
    let rep = await createWallet(data)
    return rep.data
  }

  @router('post /wallet/okx/walletaddress')
  async walletAddresses(req, res) {
    let { walletId } = req.params
    let result = await getAddresses(walletId)
    return result.data
  }

  @router('post /wallet/okx/walletassets')
  async queryWalletCoin(req, res) {
    let { coinIds, chainIds, walletId } = req.params
    let reqData: any = {
      walletId,
    }
    if (coinIds && coinIds.length > 0) {
      reqData.coinIds = coinIds
    }
    chainIds = chainIds || [DEFAULT_CHAINID]
    reqData.chainIds = chainIds
    let result = await queryCoin(reqData)
    return result.data
  }

  @router('post /wallet/okx/transhistory')
  async queryWalletTransHistory(req, res) {
    let { chainIds, walletId } = req.params
    let reqData: any = {
      walletId,
      limit: 10,
    }
    chainIds = chainIds || [DEFAULT_CHAINID]
    reqData.chainIds = chainIds
    let result = await queryTranHistory(reqData)
    return result.data
  }

  @router('post /wallet/okx/transinfo')
  async queryWalletTransInfo(req, res) {
    let { chainId, walletId, orderId } = req.params
    chainId = chainId || DEFAULT_CHAINID
    let result = await queryTranDetail({walletId, orderId, chainId})
    return result.data
  }

  @router('post /wallet/okx/sendtran')
  async sendWalletTran(req, res) {
    let { data } = req.params
    let user = req.user;
    let record = await Wallet.findOne({ account: user.id })
    if (!record || !record.address) {
      throw new ZError(11, 'no wallet found')
    }
    data.chainId = data.chainId || DEFAULT_CHAINID
    data.walletId = record.id;
    console.log('send trans: ' + JSON.stringify(data));
    let result = await sendTran(data)
    if (result.status !== 200) {
      throw new ZError(result.status, result.statusText)
    }
    if (result.data.code) {
      throw new ZError(result.data.code, result.data.msg)
    }
    if (result.data?.data) {
      setImmediate(async () => {
        try {
          await TranRecord.insertOrUpdate({
            transactionHash: data.txHash,
          }, {
            okxOrderId: result.data.data.orderId,
          })
          logger.log(`success update log: ${data.txHash}`)
        } catch (err) {
          logger.log(`error update log: ${data.txHash} with error: ${err}`)
        }
      });
    }
    return {txHash: data.txHash}
  }
}