@trezor/utxo-lib/lib/compose/request.js

Client-side Bitcoin-like JavaScript library

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.validateAndParseRequest = validateAndParseRequest;
const address_1 = require("../address");
const coinselectUtils_1 = require("../coinselect/coinselectUtils");
const embed_1 = require("../payments/embed");
function validateAndParseFeeRate(rate) {
  const feeRate = typeof rate === 'string' ? Number(rate) : rate;
  if (typeof feeRate !== 'number' || Number.isNaN(feeRate) || !Number.isFinite(feeRate) || feeRate > Number.MAX_SAFE_INTEGER || feeRate <= 0) {
    return;
  }
  return feeRate;
}
function transformInput(i, utxo, txType) {
  if (typeof utxo.coinbase !== 'boolean') {
    throw new Error('Missing coinbase');
  }
  if (typeof utxo.own !== 'boolean') {
    throw new Error('Missing own');
  }
  if (typeof utxo.confirmations !== 'number') {
    throw new Error('Missing confirmations');
  }
  const value = (0, coinselectUtils_1.bignumberOrNaN)(utxo.amount);
  if (!value) {
    throw new Error('Invalid amount');
  }
  return {
    ...utxo,
    type: txType,
    i,
    script: {
      length: coinselectUtils_1.INPUT_SCRIPT_LENGTH[txType]
    },
    value
  };
}
function validateAndParseUtxos(txType, {
  utxos
}) {
  if (utxos.length === 0) {
    return {
      type: 'error',
      error: 'MISSING-UTXOS'
    };
  }
  const incorrectUtxoError = (index, message) => ({
    type: 'error',
    error: 'INCORRECT-UTXO',
    message: `${message} at index ${index}`
  });
  const result = [];
  for (let i = 0; i < utxos.length; i++) {
    try {
      const csInput = transformInput(i, utxos[i], txType);
      csInput.weight = (0, coinselectUtils_1.inputWeight)(csInput);
      result.push(csInput);
    } catch (error) {
      return incorrectUtxoError(i, error.message);
    }
  }
  return result;
}
function transformOutput(output, txType, network) {
  const script = {
    length: coinselectUtils_1.OUTPUT_SCRIPT_LENGTH[txType]
  };
  if (output.type === 'payment') {
    const value = (0, coinselectUtils_1.bignumberOrNaN)(output.amount);
    if (!value) throw new Error('Invalid amount');
    return {
      value,
      script: (0, address_1.toOutputScript)(output.address, network)
    };
  }
  if (output.type === 'payment-noaddress') {
    const value = (0, coinselectUtils_1.bignumberOrNaN)(output.amount);
    if (!value) throw new Error('Invalid amount');
    return {
      value,
      script
    };
  }
  if (output.type === 'opreturn') {
    return {
      value: (0, coinselectUtils_1.bignumberOrNaN)('0', true),
      script: (0, embed_1.p2data)({
        data: [Buffer.from(output.dataHex, 'hex')]
      }).output
    };
  }
  if (output.type === 'send-max') {
    return {
      script: (0, address_1.toOutputScript)(output.address, network)
    };
  }
  if (output.type === 'send-max-noaddress') {
    return {
      script
    };
  }
  throw new Error('Unknown output type');
}
function validateAndParseOutputs(txType, {
  outputs,
  network
}) {
  if (outputs.length === 0) {
    return {
      type: 'error',
      error: 'MISSING-OUTPUTS'
    };
  }
  const incorrectOutputError = (index, message) => ({
    type: 'error',
    error: 'INCORRECT-OUTPUT',
    message: `${message} at index ${index}`
  });
  let sendMaxOutputIndex = -1;
  const result = [];
  for (let i = 0; i < outputs.length; i++) {
    const output = outputs[i];
    if (output.type === 'send-max-noaddress' || output.type === 'send-max') {
      if (sendMaxOutputIndex >= 0) {
        return incorrectOutputError(i, 'Multiple send-max');
      }
      sendMaxOutputIndex = i;
    }
    try {
      const csOutput = transformOutput(output, txType, network);
      csOutput.weight = (0, coinselectUtils_1.outputWeight)(csOutput);
      result.push(csOutput);
    } catch (error) {
      return incorrectOutputError(i, error.message);
    }
  }
  return {
    outputs: result,
    sendMaxOutputIndex
  };
}
function validateAndParseChangeOutput(txType, {
  changeAddress,
  network
}) {
  try {
    return transformOutput({
      type: 'send-max',
      ...changeAddress
    }, txType, network);
  } catch (error) {
    return {
      type: 'error',
      error: 'INCORRECT-OUTPUT',
      message: error.message
    };
  }
}
function validateAndParseRequest(request) {
  const feeRate = validateAndParseFeeRate(request.feeRate);
  if (!feeRate) {
    return {
      type: 'error',
      error: 'INCORRECT-FEE-RATE'
    };
  }
  const longTermFeeRate = validateAndParseFeeRate(request.longTermFeeRate);
  if (request.longTermFeeRate != null && !longTermFeeRate) {
    return {
      type: 'error',
      error: 'INCORRECT-FEE-RATE'
    };
  }
  const txType = request.txType || 'p2pkh';
  const inputs = validateAndParseUtxos(txType, request);
  if ('error' in inputs) {
    return inputs;
  }
  const outputs = validateAndParseOutputs(txType, request);
  if ('error' in outputs) {
    return outputs;
  }
  const changeOutput = validateAndParseChangeOutput(txType, request);
  if ('error' in changeOutput) {
    return changeOutput;
  }
  const feePolicy = (0, coinselectUtils_1.getFeePolicy)(request.network);
  return {
    txType,
    inputs,
    ...outputs,
    changeOutput,
    feeRate,
    feePolicy,
    longTermFeeRate,
    dustThreshold: request.dustThreshold,
    baseFee: request.baseFee,
    floorBaseFee: request.floorBaseFee,
    sortingStrategy: request.sortingStrategy
  };
}
//# sourceMappingURL=request.js.map