spacylabs-rhino/src/lib/stark/ledger/createSignedOrder.js

const Eth = require('@ledgerhq/hw-app-eth').default
const DVFError = require('../../dvf/DVFError')
const BN = require('bignumber.js')
const _findKey = require('lodash/findKey')
const selectTransport = require('../../ledger/selectTransport')
const provideContractData = require('../../ledger/provideContractData')
const getTokenAddressFromTokenInfoOrThrow = require('../../dvf/token/getTokenAddressFromTokenInfoOrThrow')
const swJS = require('@rhino.fi/starkware-crypto')
const {
  starkLimitOrderToMessageHash
} = require('@rhino.fi/dvf-utils')

const getPublicKey = async (eth, starkPath) => {
  const tempKey = (await eth.starkGetPublicKey(starkPath)).toString('hex')
  return {
    x: tempKey.substr(2, 64),
    y: tempKey.substr(66)
  }
}

// Use signing on the starkMessage only as a fallback
module.exports = async (dvf, path, starkOrder, { returnStarkPublicKey = true, starkMessage = null } = {}) => {
  const Transport = selectTransport(dvf.isBrowser)

  const buySymbol = _findKey(dvf.config.tokenRegistry, {
    starkTokenId: starkOrder.tokenBuy
  })

  const sellSymbol = _findKey(dvf.config.tokenRegistry, {
    starkTokenId: starkOrder.tokenSell
  })

  const buyTokenInfo = dvf.token.getTokenInfoOrThrow(buySymbol)
  const sellTokenInfo = dvf.token.getTokenInfoOrThrow(sellSymbol)
  const buyQuantization = new BN(buyTokenInfo.quantization)
  const sellQuantization = new BN(sellTokenInfo.quantization)

  const transport = await Transport.create()
  const eth = new Eth(transport)
  let address, starkPublicKey, starkPath
  try {
    ({ address } = await eth.getAddress(path))
    starkPath = dvf.stark.ledger.getPath(address)
    starkPublicKey = returnStarkPublicKey
      ? await getPublicKey(eth, starkPath)
      : null
  } catch (error) {
    await transport.close()
    throw error
  }

  let buyTokenAddress = null
  let sellTokenAddress = null
  try {
    buyTokenAddress = getTokenAddressFromTokenInfoOrThrow(buyTokenInfo, 'ETHEREUM')
    sellTokenAddress = getTokenAddressFromTokenInfoOrThrow(sellTokenInfo, 'ETHEREUM')
    const buySignature = await provideContractData(dvf, eth, buyTokenAddress, buyQuantization, true)
    const sellSignature = await provideContractData(dvf, eth, sellTokenAddress, sellQuantization, true)
    if ((buySignature && buySignature.unsafeSign) || (sellSignature && sellSignature.unsafeSign)) {
      const message = starkMessage || starkLimitOrderToMessageHash(swJS)(starkOrder)
      const paddedMessage = `0x${message.padEnd(64, '0').substr(-64)}`
      const starkSignature = await eth.starkUnsafeSign(
        starkPath,
        paddedMessage
      )
      await transport.close()
      return { starkSignature, starkPublicKey }
    }
  } catch (error) {
    await transport.close()
    throw new DVFError('LEDGER_TOKENINFO_ERR')
  }

  try {
    const starkSignature = await eth.starkSignOrder_v2(
      starkPath,
      sellTokenAddress,
      sellSymbol === 'ETH' ? 'eth' : 'erc20',
      new BN(sellTokenInfo.quantization),
      null,
      buyTokenAddress,
      buySymbol === 'ETH' ? 'eth' : 'erc20',
      new BN(buyTokenInfo.quantization),
      null,
      starkOrder.vaultIdSell,
      starkOrder.vaultIdBuy,
      new BN(starkOrder.amountSell),
      new BN(starkOrder.amountBuy),
      starkOrder.nonce,
      starkOrder.expirationTimestamp
    )
    await transport.close()
    return { starkPublicKey, starkSignature }
  } catch (error) {
    await transport.close()
    throw error
  }
}