paid-services 3.16.3 → 3.17.2

package/groups/assemble/coordinate_group.js

@@ -0,0 +1,383 @@
+const EventEmitter = require('events');
+const {randomBytes} = require('crypto');
+
+const assembleUnsignedPsbt = require('./assemble_unsigned_psbt');
+const {decodeGroupDetails} = require('./../messages');
+const {decodePendingProposal} = require('./../messages');
+const {decodeSignedFunding} = require('./../messages');
+const {encodeConnectedRecords} = require('./../messages');
+const {encodeGroupDetails} = require('./../messages');
+const {encodeSignedRecords} = require('./../messages');
+const {encodeUnsignedFunding} = require('./../messages');
+const {encodePartnersRecords} = require('./../messages');
+const {partnersFromMembers} = require('./../members');
+const {servicePeerRequests} = require('./../../p2p');
+const {serviceTypeConfirmConnected} = require('./../../service_types');
+const {serviceTypeFindGroupPartners} = require('./../../service_types');
+const {serviceTypeGetGroupDetails} = require('./../../service_types');
+const {serviceTypeRegisterPendingOpen} = require('./../../service_types');
+const {serviceTypeRegisterSignedOpen} = require('./../../service_types');
+
+const findRecord = (records, type) => records.find(n => n.type === type);
+const {isArray} = Array;
+const makeGroupId = () => randomBytes(16).toString('hex');
+const minGroupCount = 3;
+const now = () => new Date().toISOString();
+const staleDate = () => new Date(Date.now() - (1000 * 60 * 10)).toISOString();
+const typeGroupId = '1';
+
+/** Coordinate channel group
+
+  {
+    capacity: <Channel Capacity Tokens Number>
+    count: <Group Members Count Number>
+    identity: <Coordinator Identity Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+    rate: <Chain Fee Rate Number>
+  }
+
+  @returns
+  {
+    events: <Event Emitter Object>
+    id: <Group Id Hex String>
+    connected: <Add Connected Identity Public Key Hex String>
+    partners: <Get Channel Partners Function>
+    proposed: <Add Proposed Channel Function>
+    sign: <Add Signed Channel Function>
+    signed: <Get Signed PSBTs Function>
+    unsigned: <Get Unsigned PSBT Function>
+  }
+
+  // All members are connected
+  @event 'connected'
+
+  // A member was connected to their peers
+  @event 'connecting'
+  {
+    id: <Connected Member Public Key Hex String>
+  }
+
+  // All members have funded with their outbound peers
+  @event 'funded'
+
+  // A member has funded with their outbound peer
+  @event 'funding'
+  {
+    id: <Funding Member Public Key Hex String>
+  }
+
+  // A new member joined
+  @event 'joining'
+  {
+    id: <Joined Member Public Key Hex String>
+  }
+
+  // All members are joined
+  @event 'joined'
+  {
+    ids: [<Joined Member Public Key Hex String>]
+  }
+
+  // A member submitted their partial signature
+  @event 'signing'
+  {
+    id: <Member Public Key Hex String>
+  }
+
+  // All members have submitted their partial signatures
+  @event 'signed'
+*/
+module.exports = ({capacity, count, identity, lnd, rate}) => {
+  if (count < minGroupCount) {
+    throw new Error('ExpectedHigherGroupMembersCountToCoordinateGroup');
+  }
+
+  if (!identity) {
+    throw new Error('ExpectedSelfIdentityPublicKeyToCoordinateGroup');
+  }
+
+  if (!lnd) {
+    throw new Error('ExpectedAuthenticatedLndToCoordinateGroup');
+  }
+
+  // Instantiate the group with self as a member
+  const group = {
+    connected: [],
+    emitter: new EventEmitter(),
+    members: [{id: identity}],
+    proposed: [],
+    signed: [],
+  };
+
+  // The group has an identifier
+  const id = makeGroupId();
+
+  // Wait for peer requests
+  const service = servicePeerRequests({lnd});
+
+  // Listen for and respond to get group details requests
+  service.request({type: serviceTypeGetGroupDetails}, (req, res) => {
+    if (!isArray(req.records)) {
+      return res.failure([400, 'ExpectedArrayOfRecordsToGetGroupDetails']);
+    }
+
+    const idRecord = findRecord(req.records, typeGroupId);
+
+    if (!idRecord) {
+      return res.failure([400, 'ExpectedGroupIdRecordToGetGroupDetails']);
+    }
+
+    // Exit early when this request is for a different group
+    if (idRecord.value !== id) {
+      return;
+    }
+
+    return res.success(encodeGroupDetails({capacity, count, rate}));
+  });
+
+  // Listen for and respond to find member requests
+  service.request({type: serviceTypeFindGroupPartners}, (req, res) => {
+    if (!isArray(req.records)) {
+      return res.failure([400, 'ExpectedArrayOfRecordsToFindGroupPartners']);
+    }
+
+    const idRecord = findRecord(req.records, typeGroupId);
+
+    if (!idRecord) {
+      return res.failure([400, 'ExpectedGroupIdRecordToFindGroupPartners']);
+    }
+
+    // Exit early when this request is for a different group
+    if (idRecord.value !== id) {
+      return;
+    }
+
+    // Emit event that someone is joining
+    if (!group.members.find(n => n.id === req.from)) {
+      group.emitter.emit('joining', {id: req.from});
+    }
+
+    // Refresh the member list, evicting members who stopped pinging
+    group.members = group.members
+      .filter(n => !n.last_joined || n.last_joined > staleDate())
+      .filter(n => n.id !== req.from);
+
+    // Exit early with failure when the group is full
+    if (group.members.length === count) {
+      return res.failure([503, 'GroupIsCurrentlyFull']);
+    }
+
+    // Add the group member details to the group
+    group.members.push({id: req.from, last_joined: new Date().toISOString()});
+
+    // Exit with failure when a member dropped out after being locked in
+    if (!!group.ids && group.members.length < count) {
+      return res.failure([503, 'GroupMemberExited']);
+    }
+
+    // Exit early when still waiting for group to fill
+    if (group.members.length < count) {
+      return res.success({});
+    }
+
+    // Make sure members list is locked in
+    group.ids = group.ids || group.members.map(n => n.id);
+
+    // Emit event that everyone has joined
+    group.emitter.emit('joined', {ids: group.ids});
+
+    // Derive position in members list
+    const {inbound, outbound} = partnersFromMembers({group, id: req.from});
+
+    // Encode partners for wire
+    const {records} = encodePartnersRecords({inbound, outbound});
+
+    return res.success({records});
+  });
+
+  // Listen for and respond to connected confirmations
+  service.request({type: serviceTypeConfirmConnected}, (req, res) => {
+    if (!isArray(req.records)) {
+      return res.failure([400, 'ExpectedArrayOfRecordsToConfirmConnection']);
+    }
+
+    const idRecord = findRecord(req.records, typeGroupId);
+
+    if (!idRecord) {
+      return res.failure([400, 'ExpectedGroupIdRecordToConfirmConnection']);
+    }
+
+    // Exit early when this request is for a different group
+    if (idRecord.value !== id) {
+      return;
+    }
+
+    // Group ids must be locked in before connections start
+    if (!group.ids) {
+      return res.failure([503, 'GroupMembersAreNotLockedInToStartConnects']);
+    }
+
+    // Cannot confirm connected when not part of the locked in group
+    if (!group.ids.includes(req.from)) {
+      return res.failure([403, 'MembershipNotPresentInLockedInMembers']);
+    }
+
+    // Emit event that someone is connecting
+    if (!group.connected.find(n => n.id === req.from)) {
+      group.emitter.emit('connecting', {id: req.from});
+    }
+
+    // Refresh the connected list, evicting remote members who stopped pinging
+    group.connected = group.connected
+      .filter(n => !n.last_connected || n.last_connected > staleDate())
+      .filter(n => n.id !== req.from);
+
+    // Add the group connection details to the group
+    group.connected.push({id: req.from, last_connected: now()});
+
+    const {records} = encodeConnectedRecords({count: group.connected.length});
+
+    // Emit event that all members are connected
+    if (group.connected.length === count) {
+      group.emitter.emit('connected', {});
+    }
+
+    return res.success({records});
+  });
+
+  // Listen for and respond to pending open registrations
+  service.request({type: serviceTypeRegisterPendingOpen}, (req, res) => {
+    if (!isArray(req.records)) {
+      return res.failure([400, 'ExpectedArrayOfRecordsToRegisterPendingOpen']);
+    }
+
+    const idRecord = findRecord(req.records, typeGroupId);
+
+    if (!idRecord) {
+      return res.failure([400, 'ExpectedGroupIdRecordToRegisterPendingOpen']);
+    }
+
+    // Exit early when this request is for a different group
+    if (idRecord.value !== id) {
+      return;
+    }
+
+    // Cannot register pending when not part of the locked in group
+    if (!group.ids.includes(req.from)) {
+      return res.failure([403, 'MembershipNotPresentInLockedInMembers']);
+    }
+
+    try {
+      decodePendingProposal({records: req.records});
+    } catch (err) {
+      return res.failure([400, err.message]);
+    }
+
+    const proposal = decodePendingProposal({records: req.records});
+
+    // Register the proposal
+    if (!group.proposed.find(n => n.id === req.from)) {
+      group.emitter.emit('funding', {id: req.from});
+
+      group.proposed.push({
+        change: proposal.change,
+        funding: proposal.funding,
+        id: req.from,
+        utxos: proposal.utxos,
+      });
+    }
+
+    // Exit early when there are missing proposals
+    if (group.proposed.length !== group.ids.length) {
+      return res.success({});
+    }
+
+    const {failure, success} = res;
+
+    // Exit early when unsigned funding is already assembled
+    if (!!group.unsigned) {
+      return success(encodeUnsignedFunding({psbt: group.unsigned}));
+    }
+
+    // Put together the assembled PSBT
+    return assembleUnsignedPsbt({
+      capacity,
+      rate,
+      proposed: group.proposed,
+    },
+    (err, res) => {
+      if (!!err) {
+        return failure(err);
+      }
+
+      group.unsigned = res.psbt;
+
+      if (group.proposed.length === count) {
+        group.emitter.emit('funded', {});
+      }
+
+      const {records} = encodeUnsignedFunding({psbt: res.psbt});
+
+      return success({records});
+    });
+  });
+
+  // Listen for and respond to funding signatures
+  service.request({type: serviceTypeRegisterSignedOpen}, (req, res) => {
+    if (!isArray(req.records)) {
+      return res.failure([400, 'ExpectedArrayOfRecordsToRegisterSignedOpen']);
+    }
+
+    const idRecord = findRecord(req.records, typeGroupId);
+
+    if (!idRecord) {
+      return res.failure([400, 'ExpectedGroupIdRecordToRegisterSignedOpen']);
+    }
+
+    // Exit early when this request is for a different group
+    if (idRecord.value !== id) {
+      return;
+    }
+
+    // Cannot register signatures when not part of the locked in group
+    if (!group.ids.includes(req.from)) {
+      return res.failure([403, 'MembershipNotPresentInLockedInMembers']);
+    }
+
+    try {
+      decodeSignedFunding({records: req.records});
+    } catch (err) {
+      return res.failure([400, err.message]);
+    }
+
+    const signed = decodeSignedFunding({records: req.records});
+
+    // Register the signed funding
+    if (!group.signed.find(n => n.id === req.from)) {
+      // Emit event to indicate member has submitted their signed open
+      group.emitter.emit('signing', {id: req.from});
+
+      group.signed.push({id: req.from, signed: signed.psbt});
+    }
+
+    if (group.signed.length === count) {
+      group.emitter.emit('signed', {});
+    }
+
+    // Let the client know how many signatures are present
+    const {records} = encodeSignedRecords({count: group.signed.length});
+
+    return res.success({records});
+  });
+
+  return {
+    id,
+    connected: () => group.connected.push({id: identity}),
+    events: group.emitter,
+    partners: id => !!group.ids ? partnersFromMembers({group, id}) : undefined,
+    proposed: pending => group.proposed.push(pending),
+    sign: signed => group.signed.push(signed),
+    signed: () => group.signed,
+    unsigned: () => group.unsigned,
+  };
+};

package/groups/assemble/index.js

@@ -0,0 +1,3 @@
+const coordinateGroup = require('./coordinate_group');
+
+module.exports = {coordinateGroup};

package/groups/assemble_channel_group.js

@@ -0,0 +1,178 @@
+const EventEmitter = require('events');
+
+const asyncRetry = require('async/retry');
+const {broadcastChainTransaction} = require('ln-service');
+const {combinePsbts} = require('psbt');
+const {decodePsbt} = require('psbt');
+const {extractTransaction} = require('psbt');
+const {finalizePsbt} = require('psbt');
+const {Transaction} = require('bitcoinjs-lib');
+
+const {confirmIncomingChannel} = require('./funding');
+const {coordinateGroup} = require('./assemble');
+const {peerWithPartners} = require('./p2p');
+const {proposeGroupChannel} = require('./funding');
+const {signAndFundGroupChannel} = require('./funding');
+
+const {fromHex} = Transaction;
+const interval = 500;
+const times = 2 * 60 * 10;
+
+/** Assemble a channel group
+
+  {
+    capacity: <Channel Capacity Tokens Number>
+    count: <Channel Members Count Number>
+    ecp: <ECPair Library Object>
+    identity: <Coordinator Identity Public Key Hex String>
+    lnd: <Authenticated LND API Object>
+    rate: <Chain Fee Tokens Per VByte Number>
+  }
+
+  @returns
+  {
+    events: <EventEmitter Object>
+    id: <Group Id Hex String>
+  }
+
+  // Open was published
+  @event 'broadcast'
+  {
+    id: <Transaction Id Hex String>
+    transaction: <Transaction Hex String>
+  }
+
+  // Open is publishing
+  @event 'broadcasting'
+  {
+    id: <Transaction Id Hex String>
+    transaction: <Transaction Hex String>
+  }
+
+  // Members are peered
+  @event 'connected'
+  {}
+
+  // All members are present
+  @event 'filled'
+  {
+    ids: [<Group Member Identity Public Key Hex String>]
+  }
+
+  // Members proposed channels to each other
+  @event 'proposed'
+  {}
+
+  // Members have all signed
+  @event 'signed'
+  {}
+*/
+module.exports = ({capacity, count, ecp, identity, lnd, rate}) => {
+  const coordinator = coordinateGroup({capacity, count, identity, lnd, rate});
+  const emitter = new EventEmitter();
+  const pending = {};
+
+  const errored = err => {
+    coordinator.events.removeAllListeners();
+
+    return emitter.emit('error', err);
+  };
+
+  // Group members have registered themselves
+  coordinator.events.once('joined', async ({ids}) => {
+    emitter.emit('filled', {ids});
+
+    const {inbound, outbound} = coordinator.partners(identity);
+
+    // Connect to the inbound and outbound partners
+    try {
+      await peerWithPartners({inbound, lnd, outbound});
+
+      // Register as connected
+      return coordinator.connected();
+    } catch (err) {
+      return errored(err);
+    }
+  });
+
+  // Group members have connected to each other
+  coordinator.events.once('connected', async () => {
+    emitter.emit('connected', {});
+
+    try {
+      // Fund and propose the pending channel to the outbound partner
+      const {change, funding, id, utxos} = await proposeGroupChannel({
+        capacity,
+        lnd,
+        rate,
+        to: coordinator.partners(identity).outbound,
+      });
+
+      pending.id = id;
+      pending.utxos = utxos;
+
+      // Register as proposed
+      return coordinator.proposed({change, funding, utxos, id: identity});
+    } catch (err) {
+      return errored(err);
+    }
+  });
+
+  // Group members have proposed channels to each other
+  coordinator.events.once('funded', async () => {
+    emitter.emit('proposed', {});
+
+    const basePsbt = decodePsbt({ecp, psbt: coordinator.unsigned()});
+
+    // Sign the unsigned funding transaction
+    const signed = await signAndFundGroupChannel({
+      lnd,
+      id: pending.id,
+      psbt: coordinator.unsigned(),
+      utxos: pending.utxos,
+    });
+
+    // Make sure there is an incoming channel
+    await asyncRetry({interval, times}, async () => {
+      return await confirmIncomingChannel({
+        capacity,
+        lnd,
+        from: coordinator.partners(identity).inbound,
+        id: fromHex(basePsbt.unsigned_transaction).getId(),
+        to: coordinator.partners(identity).outbound,
+      });
+    });
+
+    // Register the signature with the coordinator
+    return coordinator.sign({id: identity, signed: signed.psbt});
+  });
+
+  // Group members have submitted their partial signatures
+  coordinator.events.once('signed', async () => {
+    emitter.emit('signed', {});
+
+    // Collect all the partially signed PSBTs
+    const psbts = coordinator.signed().map(n => n.signed);
+
+    // Merge partial PSBTs into a single PSBT
+    const combined = combinePsbts({ecp, psbts});
+
+    // Finalize the PSBT to convert partial signatures to full final signatures
+    const finalized = finalizePsbt({ecp, psbt: combined.psbt});
+
+    // Pull out the raw transaction from the PSBT
+    const {transaction} = extractTransaction({ecp, psbt: finalized.psbt});
+
+    try {
+      emitter.emit('broadcasting', ({transaction}));
+
+      const {id} = await broadcastChainTransaction({lnd, transaction});
+
+      return emitter.emit('broadcast', {id, transaction});
+    } catch (err) {
+      return errored(err);
+    }
+  });
+
+  return {events: emitter, id: coordinator.id};
+};

package/groups/attach_to_channel_group.js

@@ -0,0 +1,80 @@
+const asyncAuto = require('async/auto');
+const asyncMap = require('async/map');
+const {getNodeAlias} = require('ln-sync');
+const {returnResult} = require('asyncjs-util');
+
+const askToConfirmGroupJoin = require('./ask_to_confirm_group_join');
+const joinChannelGroup = require('./join_channel_group');
+
+const formatNodes = arr => arr.join(', ');
+const niceName = ({alias, id}) => `${alias} ${id}`.trim();
+
+/** Ask for a channel group to join and then join the group
+
+  {
+    ask: <Ask Function>
+    lnd: <Authenticated LND API Object>
+  }
+
+  @returns via cbk or Promise
+  {
+    id: <Transaction Id Hex String>
+  }
+*/
+module.exports = ({ask, lnd, logger}, cbk) => {
+  return new Promise((resolve, reject) => {
+    return asyncAuto({
+      // Check arguments
+      validate: cbk => {
+        if (!ask) {
+          return cbk([400, 'ExpectedAskFunctionToEnterChannelGroup']);
+        }
+
+        if (!lnd) {
+          return cbk([400, 'ExpectedAuthenticatedLndToEnterChannelGroup']);
+        }
+
+        if (!logger) {
+          return cbk([400, 'ExpectedWinstonLoggerToAttachToChannelGroup']);
+        }
+
+        return cbk();
+      },
+
+      // Ask for group details to parse and confirm
+      askForDetails: ['validate', ({}, cbk) => {
+        return askToConfirmGroupJoin({ask, lnd}, cbk);
+      }],
+
+      // Join the channel group
+      join: ['askForDetails', ({askForDetails}, cbk) => {
+        logger.info({waiting_for_other_members: true});
+
+        const join = joinChannelGroup({
+          lnd,
+          capacity: askForDetails.capacity,
+          coordinator: askForDetails.coordinator,
+          count: askForDetails.count,
+          id: askForDetails.id,
+          rate: askForDetails.rate,
+        });
+
+        join.once('end', ({id}) => cbk(null, {transaction_id: id}));
+        join.once('error', err => cbk(err));
+
+        join.once('peering', async ({inbound, outbound}) => {
+          const nodes = await asyncMap([inbound, outbound], async id => {
+            return niceName(await getNodeAlias({id, lnd}));
+          });
+
+          return logger.info({peering_with: formatNodes(nodes)});
+        });
+
+        join.once('publishing', ({signed}) => logger.info({signed}));
+
+        return;
+      }],
+    },
+    returnResult({reject, resolve, of: 'join'}, cbk));
+  });
+};