shelley-trezor-crypto-provider.ts

// eslint-disable-next-line import/no-unresolved
import CachedDeriveXpubFactory from '../helpers/CachedDeriveXpubFactory'
import {ADALITE_SUPPORT_EMAIL} from '../constants'
import derivationSchemes from '../helpers/derivation-schemes'
import NamedError from '../../helpers/NamedError'
import debugLog from '../../helpers/debugLog'

const CardanoTrezorCryptoProvider = ({network, config}) => {
  const derivationScheme = derivationSchemes.v2

  const TrezorConnect = require('../../libs/trezor-connect-local').default

  TrezorConnect.manifest({
    email: ADALITE_SUPPORT_EMAIL,
    appUrl: config.ADALITE_SERVER_URL,
  })

  const isHwWallet = () => true
  const getHwWalletName = () => 'Trezor'

  const deriveXpub = CachedDeriveXpubFactory(derivationScheme, async (absDerivationPath) => {
    const response = await TrezorConnect.cardanoGetPublicKey({
      path: absDerivationPath,
      showOnTrezor: false,
    })
    throwIfNotSuccess(response)
    return Buffer.from(response.payload.publicKey, 'hex')
  })

  function deriveHdNode(childIndex) {
    throw NamedError(
      'UnsupportedOperationError',
      'This operation is not supported on TrezorCryptoProvider!'
    )
  }

  function sign(message, absDerivationPath) {
    throw NamedError('UnsupportedOperationError', 'Operation not supported')
  }

  async function displayAddressForPath(absDerivationPath) {
    const response = await TrezorConnect.cardanoGetAddress({
      path: absDerivationPath,
      showOnTrezor: true,
    })

    throwIfNotSuccess(response)
  }

  type CardanoTxInputType = {
    address_n: Array<number>
    prev_hash: Buffer
    prev_index: number
  }

  type CardanoAddressParametersType = {
    address_type: number // 0 for base address etc.
    address_n: Array<number> // BIP32
    address_n_staking: Array<number>
    staking_key_hash?: Buffer
    certificate_pointer?: any // TODO: CardanoBlockchainPointerType
  }

  type CardanoTxOutputType = {
    address: string
    amount: number
    address_parameters?: CardanoAddressParametersType
  }

  type CardanoTxCertificateType = {
    type: number
    path: Array<number>
    pool: Buffer
  }

  function prepareInput(input, addressToAbsPathMapper): CardanoTxInputType {
    const data = {
      address_n: addressToAbsPathMapper(input.address),
      prev_hash: Buffer.from(input.txid, 'hex'),
      prev_index: input.outputIndex,
    }

    return data
  }

  function prepareOutput(output, addressToAbsPathMapper): CardanoTxOutputType {
    const data: CardanoTxOutputType = {
      address: output.address,
      amount: output.coins,
    }
    let addressParameters: CardanoAddressParametersType
    if (output.isChange) {
      addressParameters = {
        address_type: 0, // TODO: 0 for base address
        address_n: output.spendingPath,
        address_n_staking: output.stakingPath,
      }
      data.address_parameters = addressParameters
    }
    return data
  }

  function prepareCertificate(cert, addressToAbsPathMapper): CardanoTxCertificateType {
    return {
      type: cert.type,
      path: addressToAbsPathMapper(cert.accountAddress),
      pool: cert.poolHash ? Buffer.from(cert.poolHash, 'hex') : null,
    }
  }

  async function signTx(unsignedTx, rawInputTxs, addressToAbsPathMapper) {
    const _inputs = []
    for (const input of unsignedTx.inputs) {
      const data = prepareInput(input, addressToAbsPathMapper)
      _inputs.push(data)
    }
    const inputs = await Promise.all(_inputs)

    const _outputs = []
    for (const output of unsignedTx.outputs) {
      const data = prepareOutput(output, addressToAbsPathMapper)
      _outputs.push(data)
    }
    const outputs = await Promise.all(_outputs)

    const certificates = []
    for (const cert of unsignedTx.certs) {
      const data = prepareCertificate(cert, addressToAbsPathMapper)
      certificates.push(data)
    }

    const fee = `${unsignedTx.fee.fee}`
    const ttl = `${unsignedTx.ttl.ttl}`
    const withdrawals = []
    const metadata = null

    // inputs: List[CardanoTxInputType] = None,
    // outputs: List[CardanoTxOutputType] = None,
    // protocol_magic: int = None,
    // fee: int = None,
    // ttl: int = None,
    // network_id: int = None,
    // certificates: List[CardanoTxCertificateType] = None,
    // withdrawals: List[CardanoTxWithdrawalType] = None,
    // metadata: bytes = None,

    console.log('\n\n\n\n\n\n\n', {
      inputs,
      outputs,
      protocol_magic: network.protocolMagic,
      fee: unsignedTx.fee,
      ttl: unsignedTx.ttl,
      network_id: network.networkId,
      certificates,
      withdrawals,
    })

    const response = await TrezorConnect.cardanoSignTransaction({
      inputs,
      outputs,
      protocolMagic: network.protocolMagic,
      fee,
      ttl,
      networkId: network.networkId,
      // certificates,
      // withdrawals,
      // metadata,
    }).catch((e) =>
      console.log(e, {
        inputs,
        outputs,
        protocolMagic: network.protocolMagic,
        fee: unsignedTx.fee.fee,
        ttl: unsignedTx.ttl.ttl,
        networkId: network.networkId,
        certificates,
        // withdrawals,
        // metadata,
      })
    )

    if (response.error || !response.success) {
      debugLog(response)
      throw NamedError('TrezorSignTxError', response.payload.error)
    }

    return {
      txHash: response.payload.hash,
      txBody: response.payload.body,
    }
  }

  function getWalletSecret() {
    throw NamedError('UnsupportedOperationError', 'Unsupported operation!')
  }

  function getDerivationScheme() {
    return derivationScheme
  }

  function throwIfNotSuccess(response) {
    if (response.error || !response.success) {
      debugLog(response)
      throw NamedError(
        'TrezorError',
        'Trezor operation failed, please make sure ad blockers are switched off for this site'
      )
    }
  }

  return {
    getWalletSecret,
    getDerivationScheme,
    signTx,
    displayAddressForPath,
    deriveXpub,
    isHwWallet,
    getHwWalletName,
    _sign: sign,
    _deriveHdNode: deriveHdNode,
    network,
  }
}

export default CardanoTrezorCryptoProvider