cosmic-lib/src/action.js

A JavaScript implementation of the CosmicLink protocol for Stellar

"use strict"
/**
 * Contains the action methods for CosmicLink.
 *
 * @private
 * @exports action
 */
const action = exports

const axios = require("@cosmic-plus/base/es5/axios")
const env = require("@cosmic-plus/jsutils/es5/env")
const misc = require("@cosmic-plus/jsutils/es5/misc")

const convert = require("./convert")
const format = env.isBrowser && require("./format")
const resolve = require("./resolve")
const signersUtils = require("./signers-utils")
const status = require("./status")

/**
 * Lock a CosmicLink to a network/source pair. If the cosmicLink was created
 * from a query/uri/tdesc/json, it will create the corresponding
 * transaction/xdr/sep7 formats.
 *
 * This operation must be performed by the wallet before signing & sending the
 * transaction.
 *
 * @example
 * cosmicLib.config.network = "test"
 * const cosmicLink = new CosmicLink("?setOptions")
 * console.log(cosmicLink.network) // => undefined
 * console.log(cosmicLink.xdr)     // => undefined
 * await cosmicLink.lock()
 * console.log(cosmicLink.network) // => "test"
 * console.log(cosmicLink.xdr)     // => "AAAA...AA=="
 *
 *
 * @alias CosmicLink#lock
 * @async
 * @param {Object} [options]
 * @param {string} options.network Local fallback network
 * @param {string} options.horizon Local fallback horizon (overwrited by global configuration)
 * @param {string} options.callback Local fallback callback
 * @param {string} options.source Local fallback source
 */
action.lock = async function (cosmicLink, options = {}) {
  if (cosmicLink.status) throw new Error(cosmicLink.status)
  if (cosmicLink.locker) throw new Error("CosmicLink is already locked.")

  try {
    await applyLock(cosmicLink, options)
  } catch (error) {
    if (!cosmicLink.errors) {
      console.error(error)
      status.error(cosmicLink, error.message)
    }
    status.fail(cosmicLink, "Transaction build failed", "throw")
  }

  updateSignersNode(cosmicLink)

  return cosmicLink
}

async function applyLock (cosmicLink, options) {
  /**
   * The locker property tells that a CosmicLink have been locked, and exposes
   * the network & source values to which it have been locked.
   *
   * @alias CosmicLink#locker
   */
  cosmicLink.locker = {
    source:
      cosmicLink.tdesc.source || options.source || cosmicLink.config.source,
    network:
      cosmicLink.tdesc.network || options.network || cosmicLink.config.network,
    horizon: options.horizon || cosmicLink.horizon,
    callback:
      cosmicLink.tdesc.callback
      || options.callback
      || cosmicLink.config.callback
  }

  /// Preserve the underlying tdesc object.
  cosmicLink._tdesc = Object.assign({}, cosmicLink.tdesc, cosmicLink.locker)
  delete cosmicLink._query
  delete cosmicLink._json

  if (!cosmicLink._transaction) {
    // eslint-disable-next-line require-atomic-updates
    cosmicLink._transaction = await convert.tdescToTransaction(
      cosmicLink,
      cosmicLink.tdesc
    )
    delete cosmicLink._tdesc
  }

  delete cosmicLink._transaction._cosmicplus
  await signersUtils.extends(cosmicLink, cosmicLink._transaction)
}

/**
 * Sign CosmicLink's Transaction with **keypairs_or_preimage** and update the
 * other formats accordingly. Only legit signers are allowed to sign, and a
 * CosmicLink have to be [locked]{@link CosmicLink#lock} before signing.
 *
 * @alias CosmicLink#sign
 * @param {...Keypair|Buffer|string} ...keypairs_or_preimage
 */
action.sign = async function (cosmicLink, ...keypairsOrPreimage) {
  if (!cosmicLink.locker) throw new Error("cosmicLink is not locked.")

  const transaction = cosmicLink.transaction
  let allFine = true

  if (typeof keypairsOrPreimage[0] !== "string") {
    for (let index in keypairsOrPreimage) {
      const keypair = keypairsOrPreimage[index]
      const publicKey = keypair.publicKey()

      if (!cosmicLink.transaction.hasSigner(publicKey)) {
        const short = misc.shorter(publicKey)
        status.error(cosmicLink, "Not a legit signer: " + short)
        allFine = false
        continue
      }

      if (cosmicLink.transaction.hasSigned(publicKey)) continue

      try {
        transaction.sign(keypair)
      } catch (error) {
        console.error(error)
        const short = misc.shorter(publicKey)
        status.error(cosmicLink, "Failed to sign with key: " + short)
        allFine = false
        continue
      }
    }
  } else {
    try {
      transaction.signHashX(keypairsOrPreimage[0])
    } catch (error) {
      console.error(error)
      const short = misc.shorter(keypairsOrPreimage[0])
      status.error(
        cosmicLink,
        "Failed to sign with preimage: " + short,
        "throw"
      )
    }
  }

  /// Update other formats.
  ["_query", "_xdr", "_sep7"].forEach(format => delete cosmicLink[format])
  updateSignersNode(cosmicLink)

  if (!allFine) throw new Error("Some signers where invalid")
  else return transaction
}

function updateSignersNode (cosmicLink) {
  if (cosmicLink._signersNode) {
    const signersNode = format.signatures(cosmicLink, cosmicLink._transaction)
    cosmicLink.htmlDescription.replaceChild(
      signersNode,
      cosmicLink._signersNode
    )
    cosmicLink._signersNode = signersNode
  }
}

/**
 * Send CosmicLink's transaction to a blockchain validator, or to
 * [StellarGuard]{@link https://stellarguard.me} when relevant. A
 * CosmicLink have to be [locked]{@link CosmicLink#lock} before sending.
 *
 * Returns a promise that resolve/reject to the horizon server response.
 *
 * @example
 * cosmicLink.send()
 *   .then(console.log)
 *   .catch(console.error)
 *
 * @alias CosmicLink#send
 * @param {horizon} [horizon] An horizon node URL
 * @return {Object} The server response
 */
action.send = async function (cosmicLink, horizon = cosmicLink.horizon) {
  if (!cosmicLink.locker) throw new Error("cosmicLink is not locked.")

  try {
    if (cosmicLink.transaction.hasSigner(STELLARGUARD_PUBKEY)) {
      return await sendToStellarGuard(cosmicLink)
    } else if (cosmicLink.callback) {
      return await axios.post(cosmicLink.callback, { xdr: cosmicLink.xdr })
    } else {
      return await sendToHorizon(cosmicLink, horizon)
    }
  } catch (error) {
    if (error.response) console.error(error.message, error.response)
    throw error
  }
}

async function sendToHorizon (cosmicLink, horizon) {
  const server = resolve.server(cosmicLink, horizon)

  // Keep connection alive until transaction gets validated or a non-504 error
  // is returned. 504 error means the transaction is still following the
  // validation process.
  // eslint-disable-next-line no-constant-condition
  while (true) {
    try {
      return await server.submitTransaction(cosmicLink.transaction)
    } catch (error) {
      if (error.response.status !== 504) throw error
    }
  }
}

function sendToStellarGuard (cosmicLink) {
  const url =
    cosmicLink.network === "test"
      ? "https://test.stellarguard.me/api/transactions"
      : "https://stellarguard.me/api/transactions"
  return axios
    .post(url, {
      xdr: cosmicLink.xdr,
      callback: cosmicLink.callback
    })
    .then(result => result.data)
}

const STELLARGUARD_PUBKEY =
  "GCVHEKSRASJBD6O2Z532LWH4N2ZLCBVDLLTLKSYCSMBLOYTNMEEGUARD"