edge-currency-plugins 1.0.0-rc.1

package/lib/common/utxobased/keymanager/utxopicker/accumulative.js

@@ -0,0 +1,52 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+var _utils = require('./utils'); var utils = _interopRequireWildcard(_utils);
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+
+ function accumulative(args) {
+  const { utxos, targets, feeRate, changeScript } = args
+
+  if (!isFinite(utils.uintOrNaN(feeRate))) {
+    throw new Error('No rate provided')
+  }
+
+  const outputs = targets.map(target => ({
+    ...target,
+    script: Buffer.from(target.script, 'hex'),
+    scriptPubkey: Buffer.from(target.script, 'hex')
+  }))
+
+  let inValue = 0
+  const inputs = []
+  const targetValue = utils.sumOrNaN(targets)
+
+  for (let i = 0; i < utxos.length; ++i) {
+    const utxo = utxos[i]
+
+    // skip detrimental input
+    const utxoFee = feeRate * utils.inputBytes(utxo)
+    if (utxoFee > utxo.value) {
+      if (i === utxos.length - 1) {
+        break
+      } else {
+        continue
+      }
+    }
+
+    inputs.push(utxo)
+    inValue += utxo.value
+
+    const bytes = utils.transactionBytes(inputs, outputs)
+    const fee = bytes * feeRate
+
+    // go again?
+    if (inValue < targetValue + fee) continue
+
+    return utils.finalize(inputs, outputs, feeRate, changeScript)
+  }
+
+  return {
+    changeUsed: false,
+    fee: feeRate * utils.transactionBytes(inputs, outputs)
+  }
+} exports.accumulative = accumulative;

package/lib/common/utxobased/keymanager/utxopicker/forceUseUtxo.js

@@ -0,0 +1,59 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+var _utils = require('./utils'); var utils = _interopRequireWildcard(_utils);
+// implementation very similar to accumulative strategy
+// add inputs until we reach or surpass the target value (or deplete)
+// worst-case: O(n)
+
+ function forceUseUtxo(args) {
+  const { utxos, useUtxos, targets, feeRate, changeScript } = args
+
+  if (!isFinite(utils.uintOrNaN(feeRate))) {
+    throw new Error('No rate provided')
+  }
+
+  const outputs = targets.map(target => ({
+    ...target,
+    script: Buffer.from(target.script, 'hex'),
+    scriptPubkey: Buffer.from(target.script, 'hex')
+  }))
+
+  const inputs = _nullishCoalesce(useUtxos, () => ( []))
+  let inValue = inputs.reduce((n, { value }) => n + value, 0)
+  const targetValue = utils.sumOrNaN(targets)
+  const bytes = utils.transactionBytes(inputs, outputs)
+  const fee = bytes * feeRate
+  // if the new feeRate is already covered by lowering the change amount, return
+  if (inValue >= targetValue + fee) {
+    return utils.finalize(inputs, outputs, feeRate, changeScript)
+  }
+
+  for (let i = 0; i < utxos.length; ++i) {
+    const utxo = utxos[i]
+
+    // skip detrimental input
+    const utxoFee = feeRate * utils.inputBytes(utxo)
+    if (utxoFee > utxo.value) {
+      if (i === utxos.length - 1) {
+        break
+      } else {
+        continue
+      }
+    }
+
+    inputs.push(utxo)
+    inValue += utxo.value
+
+    const bytes = utils.transactionBytes(inputs, outputs)
+    const fee = bytes * feeRate
+
+    // go again?
+    if (inValue < targetValue + fee) continue
+
+    return utils.finalize(inputs, outputs, feeRate, changeScript)
+  }
+
+  return {
+    changeUsed: false,
+    fee: feeRate * utils.transactionBytes(inputs, outputs)
+  }
+} exports.forceUseUtxo = forceUseUtxo;

package/lib/common/utxobased/keymanager/utxopicker/subtractFee.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } }
+var _utils = require('./utils'); var utils = _interopRequireWildcard(_utils);
+
+ function subtractFee(args) {
+  const { utxos, targets, feeRate } = args
+
+  const outputs = targets.map(target => ({
+    ...target,
+    script: Buffer.from(target.script, 'hex'),
+    scriptPubkey: Buffer.from(target.script, 'hex')
+  }))
+
+  const fee = feeRate * utils.transactionBytes(utxos, outputs)
+  targets[0].value -= fee
+  outputs[0].value -= fee
+  return { inputs: utxos, outputs, fee, changeUsed: false }
+} exports.subtractFee = subtractFee;

package/lib/common/utxobased/keymanager/utxopicker/types.js

@@ -0,0 +1,42 @@
+"use strict";
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

package/lib/common/utxobased/keymanager/utxopicker/utils.js

@@ -0,0 +1,159 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});/* eslint-disable no-fallthrough */
+/* eslint-disable no-duplicate-case */
+var _keymanager = require('../keymanager');
+
+
+/*
+Reference: https://bitcoinops.org/en/tools/calc-size/
+*/
+
+const WITNESS_SCALE = 4
+const OP_CODE_SIZE = 1
+const SIGNATURE_SIZE = 72
+const PUB_KEY_SIZE = 33
+const P2SH_SCRIPT_HASH_SIZE = 22
+const OUTPOINT_SIZE = 36
+const N_SEQUENCE_SIZE = 4
+
+// Measures the VarInt given a size
+ const compactSize = (num) =>
+  num < 0xfd ? 1 : num <= 0xffff ? 3 : num <= 0xffffffff ? 5 : 9; exports.compactSize = compactSize
+
+// Adds a VarInt to the size given
+ const withCompactSize = (num) => {
+  return exports.compactSize.call(void 0, num) + num
+}; exports.withCompactSize = withCompactSize
+
+const scriptSizeMap = (() => {
+  // VarInt OP_PUSH <signature> OP_PUSH <public key>
+  const p2pkh = exports.withCompactSize.call(void 0, 
+    OP_CODE_SIZE + SIGNATURE_SIZE + OP_CODE_SIZE + PUB_KEY_SIZE
+  )
+  // <p2pkh> <witness count (assumed to be 1)> (segwit)
+  const p2wpkh = (p2pkh + exports.compactSize.call(void 0, 1)) / WITNESS_SCALE
+  // VarInt <script hash>
+  const p2shOverhead = exports.withCompactSize.call(void 0, P2SH_SCRIPT_HASH_SIZE)
+  // <p2wpkh> <p2sh>
+  const p2wpkhp2sh = p2wpkh + p2shOverhead
+  // (fixed size)
+  const replayProtection = 284
+
+  // TOOD: support other p2sh (e.g. 2-3 multisig) and other p2wsh (taproot/lightning)
+  return {
+    p2pkh: p2pkh,
+    p2wpkh: p2wpkh,
+    p2wpkhp2sh: p2wpkhp2sh,
+    replayprotection: replayProtection,
+    replayprotectionp2sh: 284
+  }
+})()
+
+ function inputBytes(input) {
+  const scriptSigSize = scriptSizeMap[input.scriptType]
+
+  if (scriptSigSize == null)
+    throw new Error(`${input.scriptType} script type not supported, yet`)
+
+  return OUTPOINT_SIZE + scriptSigSize + N_SEQUENCE_SIZE
+} exports.inputBytes = inputBytes;
+
+ function outputBytes(output) {
+  const nValue = 8 // output value/amount
+  const scriptPubkeyLength = exports.compactSize.call(void 0, output.script.length) // scriptPubKey length varint
+  /*
+    scriptPubKey bytes:
+      p2pkh: 25
+      p2wpkh: 22
+      p2sh: 23
+      p2wsh: 34
+  */
+  const scriptPubkeySize = output.script.length
+
+  return nValue + scriptPubkeyLength + scriptPubkeySize
+} exports.outputBytes = outputBytes;
+
+ function dustThreshold(output, feeRate) {
+  return outputBytes(output) * feeRate
+} exports.dustThreshold = dustThreshold;
+
+function witnessCount(inputs) {
+  return inputs.reduce((sum, input) => {
+    if (
+      input.scriptType === _keymanager.ScriptTypeEnum.p2wsh ||
+      input.scriptType === _keymanager.ScriptTypeEnum.p2wpkhp2sh ||
+      input.scriptType === _keymanager.ScriptTypeEnum.p2wpkh
+    ) {
+      sum++
+    }
+
+    return sum
+  }, 0)
+}
+
+ function transactionBytes(inputs, outputs) {
+  // Overhead:
+  const nVersion = 4 // fixed 4 bytes
+  const inputCount = exports.compactSize.call(void 0, inputs.length) // varint
+  const outputCount = exports.compactSize.call(void 0, outputs.length) // varint
+  const nLockTime = 4 // fixed 4 bytes
+  let overhead = nVersion + inputCount + outputCount + nLockTime
+  const numWitnesses = witnessCount(inputs)
+  if (numWitnesses > 0) {
+    // <segwit marker> <segwit flag> (segwit)
+    overhead += Math.ceil(2 / WITNESS_SCALE)
+  }
+
+  // Inputs/Outputs:
+  const inputsSize = inputs.reduce((a, x) => a + inputBytes(x), 0)
+  const outputsSize = outputs.reduce((a, x) => a + outputBytes(x), 0)
+
+  return overhead + inputsSize + outputsSize
+} exports.transactionBytes = transactionBytes;
+
+ function uintOrNaN(v) {
+  if (!isFinite(v)) return NaN
+  if (Math.floor(v) !== v) return NaN
+  if (v < 0) return NaN
+  return v
+} exports.uintOrNaN = uintOrNaN;
+
+ function sumForgiving(range) {
+  return range.reduce((a, x) => a + (isFinite(x.value) ? x.value : 0), 0)
+} exports.sumForgiving = sumForgiving;
+
+ function sumOrNaN(range) {
+  return range.reduce((a, x) => a + uintOrNaN(x.value), 0)
+} exports.sumOrNaN = sumOrNaN;
+
+ function finalize(
+  inputs,
+  outputs,
+  feeRate,
+  changeScript
+) {
+  const inValue = sumOrNaN(inputs)
+  const outValue = sumOrNaN(outputs)
+  let txSize = transactionBytes(inputs, outputs)
+  let fee = Math.ceil(feeRate * txSize)
+
+  const changeValue = inValue - (outValue + fee)
+  const changeOutput = {
+    script: Buffer.from(changeScript, 'hex'),
+    scriptPubkey: Buffer.from(changeScript, 'hex'),
+    value: changeValue
+  }
+  const changeOutputSize = outputBytes(changeOutput)
+  txSize += changeOutputSize
+  const changeFee = feeRate * changeOutputSize
+  changeOutput.value -= changeFee
+  let changeUsed = false
+  if (changeOutput.value > dustThreshold(changeOutput, feeRate)) {
+    outputs.push(changeOutput)
+    fee += changeFee
+    changeUsed = true
+  } else {
+    fee += changeValue
+  }
+
+  return { inputs, outputs, changeUsed, fee }
+} exports.finalize = finalize;

package/lib/common/utxobased/keymanager/utxopicker.js

@@ -0,0 +1,17 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _createStarExport(obj) { Object.keys(obj) .filter((key) => key !== "default" && key !== "__esModule") .forEach((key) => { if (exports.hasOwnProperty(key)) { return; } Object.defineProperty(exports, key, {enumerable: true, get: () => obj[key]}); }); }var _accumulative = require('./utxopicker/accumulative');
+var _forceUseUtxo = require('./utxopicker/forceUseUtxo');
+var _subtractFee = require('./utxopicker/subtractFee');
+var _types = require('./utxopicker/types'); _createStarExport(_types);
+
+
+
+
+
+
+
+
+ const utxoPicker = {
+  forceUseUtxo: _forceUseUtxo.forceUseUtxo,
+  subtractFee: _subtractFee.subtractFee,
+  accumulative: _accumulative.accumulative
+}; exports.utxoPicker = utxoPicker

package/lib/common/utxobased/network/BlockBook.js

@@ -0,0 +1,200 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+
+var _makeEngineEmitter = require('../../plugin/makeEngineEmitter');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+var _BlockBookAPI = require('./BlockBookAPI');
+var _Deferred = require('./Deferred'); var _Deferred2 = _interopRequireDefault(_Deferred);
+
+var _Socket = require('./Socket');
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ function makeBlockBook(config) {
+  const {
+    wsAddress,
+    socketEmitter,
+    engineEmitter,
+    log,
+    onQueueSpaceCB,
+    walletId,
+    asAddress
+  } = config
+  log(`makeBlockBook with uri ${wsAddress}`)
+
+  const instance = {
+    isConnected: false,
+    connect,
+    disconnect,
+    onQueueSpace,
+    fetchInfo,
+    fetchAddress,
+    watchAddresses,
+    watchBlocks,
+    fetchAddressUtxos,
+    fetchTransaction,
+    broadcastTx
+  }
+
+  const socket = _Socket.makeSocket.call(void 0, wsAddress, {
+    healthCheck: ping,
+    onQueueSpaceCB,
+    log,
+    emitter: socketEmitter,
+    walletId
+  })
+
+  async function connect() {
+    log(`connecting to blockbook socket with uri ${wsAddress}`)
+    if (instance.isConnected) return
+
+    await socket.connect()
+    instance.isConnected = socket.isConnected()
+  }
+
+  async function disconnect() {
+    log(
+      `disconnecting from blockbook socket with uri ${wsAddress}, currently connected: ${instance.isConnected}`
+    )
+    if (!instance.isConnected) return
+
+    socket.disconnect()
+    instance.isConnected = false
+  }
+
+  function onQueueSpace(cb) {
+    socket.onQueueSpace(cb)
+  }
+
+  async function promisifyWsMessage(message) {
+    const deferred = new _Deferred2.default()
+    socket.submitTask({ ...message, deferred })
+    return await deferred.promise
+  }
+
+  async function ping() {
+    await promisifyWsMessage(_BlockBookAPI.pingMessage.call(void 0, ))
+  }
+
+  async function fetchInfo() {
+    return await promisifyWsMessage(_BlockBookAPI.infoMessage.call(void 0, ))
+  }
+
+  async function fetchAddressUtxos(
+    account
+  ) {
+    return await promisifyWsMessage(_BlockBookAPI.addressUtxosMessage.call(void 0, account))
+  }
+
+  async function fetchTransaction(hash) {
+    return await promisifyWsMessage(_BlockBookAPI.transactionMessage.call(void 0, hash))
+  }
+
+  async function fetchAddress(
+    address,
+    params = {}
+  ) {
+    return await promisifyWsMessage(_BlockBookAPI.addressMessage.call(void 0, address, asAddress, params))
+  }
+
+  async function watchBlocks(
+    deferredBlockSub
+  ) {
+    const socketCb = async (res) => {
+      engineEmitter.emit(
+        _makeEngineEmitter.EngineEvent.BLOCK_HEIGHT_CHANGED,
+        wsAddress,
+        res.height
+      )
+    }
+    socket.subscribe({
+      ..._BlockBookAPI.subscribeNewBlockMessage.call(void 0, ),
+      cb: socketCb,
+      deferred: deferredBlockSub,
+      subscribed: false
+    })
+  }
+
+  function watchAddresses(
+    addresses,
+    deferredAddressSub
+  ) {
+    const socketCb = async (res) => {
+      engineEmitter.emit(_makeEngineEmitter.EngineEvent.NEW_ADDRESS_TRANSACTION, wsAddress, res)
+    }
+    socket.subscribe({
+      ..._BlockBookAPI.subscribeAddressesMessage.call(void 0, addresses, asAddress),
+      cb: socketCb,
+      deferred: deferredAddressSub,
+      subscribed: false
+    })
+  }
+
+  async function broadcastTx(
+    transaction
+  ) {
+    return await promisifyWsMessage(_BlockBookAPI.broadcastTxMessage.call(void 0, transaction))
+  }
+
+  return instance
+} exports.makeBlockBook = makeBlockBook;