astra-lightning 1.0.0

package/lnd_responses/rpc_channel_as_channel.js

@@ -0,0 +1,279 @@
+const {chanFormat} = require('bolt07');
+
+const {channelTypes} = require('./constants');
+const parseThawHeight = require('./parse_thaw_height');
+const rpcHtlcAsPayment = require('./rpc_htlc_as_payment');
+
+const {isArray} = Array;
+const msPerSec = 1e3;
+const outpointDelimiter = ':';
+
+/** Translate an RPC channel into a channel
+
+  {
+    active: <Channel Is Active Bool>
+    alias_scids: [<Channel Id Number String>]
+    capacity: <Capacity Tokens String>
+    chan_id: <Numeric Format Channel String>
+    channel_point: <Channel Funding Outpoint String>
+    chan_status_flags: <Channel Status Flags String>
+    close_address: <Pre-arranged Desired Future Close Address String>
+    commit_fee: <Force Close Transaction Fee Tokens String>
+    commit_weight: <Force Close Transaction Total Weight Units String>
+    commitment_type: <Channel Commitment Type String>
+    csv_delay: <Required Blocks Wait Time After Force Close Number>
+    fee_per_kw: <Force Close Transaction Tokens Per 1k Weight String>
+    initiator: <Is Channel Made By Local Node Bool>
+    lifetime: <Channel Internal Monitoring For Seconds Number>
+    local_balance: <Own Balance Tokens String>
+    local_constraints: {
+      chan_reserve_sat: <Reserve Minimum Limit Tokens String>
+      csv_delay: <Required Blocks Wait Time After Force Close Number>
+      dust_limit_sat: <Minimum Output Tokens String>
+      max_accepted_htlcs: <Maximum Number of HTLCS Number>
+      max_pending_amt_msat: <Max Millitokens Pending String>
+      min_htlc_msat: <Minimum Millitokens HTLC String>
+    }
+    num_updates: <Updated Channel Count String>
+    memo: <Channel Description String>
+    pending_htlcs: [{
+      amount: <HTLC Tokens Amount String>
+      expiration_height: <CLTV Timeout Block Height Number>
+      forwarding_channel: <Numeric Forward Paired Channel Id String>
+      forwarding_htlc_index: <Forward Channel Pair HTLC Index String>
+      hash_lock: <Payment Hash Buffer Object>
+      htlc_index: <HTLC Index String>
+      incoming: <HTLC Is Locally Incoming Bool>
+    }]
+    private: <Channel Is Not Globally Advertised Bool>
+    push_amount_sat: <Push Amount Tokens Number String>
+    remote_balance: <Peer Balance Tokens String>
+    remote_constraints: {
+      chan_reserve_sat: <Reserve Minimum Limit Tokens String>
+      csv_delay: <Required Blocks Wait Time After Force Close Number>
+      dust_limit_sat: <Minimum Output Tokens String>
+      max_accepted_htlcs: <Maximum Number of HTLCS Number>
+      max_pending_amt_msat: <Max Millitokens Pending String>
+      min_htlc_msat: <Minimum Millitokens HTLC String>
+    }
+    remote_pubkey: <Peer Public Key Hex String>
+    thaw_height: <Channel Cooperative Close Prevention Blocks Number>
+    total_satoshis_received: <Total Tokens Transferred Inbound String>
+    total_satoshis_sent: <Total Tokens Transferred Outbound String>
+    unsettled_balance: <Balance In Transaction Tokens String>
+    uptime: <Channel Internal Monitoring Channel Active Seconds Number>
+    zero_conf_confirmed_scid: <Trusted Channel Confirmed Id Number String>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    capacity: <Channel Token Capacity Number>
+    commit_transaction_fee: <Commit Transaction Fee Number>
+    commit_transaction_weight: <Commit Transaction Weight Number>
+    [cooperative_close_address]: <Coop Close Restricted to Address String>
+    [cooperative_close_delay_height]: <Prevent Coop Close Until Height Number>
+    [description]: <Channel Description String>
+    id: <Standard Format Channel Id String>
+    is_active: <Channel Active Bool>
+    is_closing: <Channel Is Closing Bool>
+    is_opening: <Channel Is Opening Bool>
+    is_partner_initiated: <Channel Partner Opened Channel Bool>
+    is_private: <Channel Is Private Bool>
+    [is_trusted_funding]: <Funding Output is Trusted Bool>
+    local_balance: <Local Balance Tokens Number>
+    local_csv: <Local CSV Blocks Delay Number>
+    local_dust: <Remote Non-Enforceable Amount Tokens Number>
+    local_given: <Local Initially Pushed Tokens Number>
+    local_max_htlcs: <Local Maximum Attached HTLCs Number>
+    local_max_pending_mtokens: <Local Maximum Pending Millitokens String>
+    local_min_htlc_mtokens: <Local Minimum HTLC Millitokens String>
+    local_reserve: <Local Reserved Tokens Number>
+    other_ids: [<Other Channel Id String>]
+    partner_public_key: <Channel Partner Public Key String>
+    past_states: <Total Count of Past States Number>
+    pending_payments: [{
+      id: <Payment Preimage Hash Hex String>
+      [in_channel]: <Forwarding from Channel Id String>
+      [in_payment]: <Forwarding from Channel Payment Id Number>
+      [is_forward]: <Payment is a Forward Bool>
+      is_outgoing: <Payment Is Outgoing Bool>
+      [out_channel]: <Forwarding to Channel Id String>
+      [out_payment]: <Forwarding to Channel Payment Id Number>
+      [payment]: <Payment Attempt Id Number>
+      timeout: <Chain Height Expiration Number>
+      tokens: <Payment Tokens Number>
+    }]
+    received: <Received Tokens Number>
+    remote_balance: <Remote Balance Tokens Number>
+    remote_csv: <Remote CSV Blocks Delay Number>
+    remote_dust: <Remote Non-Enforceable Amount Tokens Number>
+    remote_given: <Remote Initially Pushed Tokens Number>
+    remote_max_htlcs: <Remote Maximum Attached HTLCs Number>
+    remote_max_pending_mtokens: <Remote Maximum Pending Millitokens String>
+    remote_min_htlc_mtokens: <Remote Minimum HTLC Millitokens String>
+    remote_reserve: <Remote Reserved Tokens Number>
+    sent: <Sent Tokens Number>
+    time_offline: <Monitoring Uptime Channel Down Milliseconds Number>
+    time_online: <Monitoring Uptime Channel Up Milliseconds Number>
+    transaction_id: <Blockchain Transaction Id String>
+    transaction_vout: <Blockchain Transaction Vout Number>
+    [type]: <Channel Commitment Transaction Type String>
+    unsettled_balance: <Unsettled Balance Tokens Number>
+  }
+*/
+module.exports = args => {
+  if (args.active === undefined) {
+    throw new Error('ExpectedChannelActiveStateInChannelMessage');
+  }
+
+  if (!isArray(args.alias_scids)) {
+    throw new Error('ExpectedArrayOfAliasShortChannelIdsInChannelMessage');
+  }
+
+  if (args.capacity === undefined) {
+    throw new Error('ExpectedChannelCapacityInChannelMessage');
+  }
+
+  if (!args.chan_id) {
+    throw new Error('ExpectedChannelIdNumberInChannelsList');
+  }
+
+  if (!args.channel_point) {
+    throw new Error('ExpectedChannelPointInChannelMessage');
+  }
+
+  if (args.commit_fee === undefined) {
+    throw new Error('ExpectedCommitFeeInChannelMessage');
+  }
+
+  if (args.commit_weight === undefined) {
+    throw new Error('ExpectedCommitWeightInChannelMessage');
+  }
+
+  if (!args.commitment_type) {
+    throw new Error('ExpectedChannelCommitmentTypeInChannelMessage');
+  }
+
+  if (args.fee_per_kw === undefined) {
+    throw new Error('ExpectedFeePerKwInChannelMessage');
+  }
+
+  if (args.local_balance === undefined) {
+    throw new Error('ExpectedLocalBalanceInChannelMessage');
+  }
+
+  if (!args.local_chan_reserve_sat) {
+    throw new Error('ExpectedLocalChannelReserveAmountInChannelMessage');
+  }
+
+  if (args.num_updates === undefined) {
+    throw new Error('ExpectedNumUpdatesInChannelMessage');
+  }
+
+  if (!isArray(args.pending_htlcs)) {
+    throw new Error('ExpectedChannelPendingHtlcsInChannelMessage');
+  }
+
+  if (args.private !== true && args.private !== false) {
+    throw new Error('ExpectedChannelPrivateStatusInChannelMessage');
+  }
+
+  if (args.local_constraints === undefined) {
+    throw new Error('ExpectedLocalChannelConstraintsInChannelMessage');
+  }
+
+  if (args.remote_balance === undefined) {
+    throw new Error('ExpectedRemoteBalanceInChannelMessage');
+  }
+
+  if (!args.remote_chan_reserve_sat) {
+    throw new Error('ExpectedRemoteChannelReserveAmountInChannelMessage');
+  }
+
+  if (!args.remote_constraints) {
+    throw new Error('ExpectedRemoteChannelConstraintsInChannelMessage');
+  }
+
+  if (!args.remote_pubkey) {
+    throw new Error('ExpectedRemotePubkeyInChannelMessage');
+  }
+
+  if (args.thaw_height === undefined) {
+    throw new Error('ExpectedCooperativeCloseThawHeightInChannelMessage');
+  }
+
+  if (args.total_satoshis_received === undefined) {
+    throw new Error('ExpectedTotalSatoshisReceivedInChannelMessage');
+  }
+
+  if (args.total_satoshis_sent === undefined) {
+    throw new Error('ExpectedTotalSatoshisSentInChannelMessage');
+  }
+
+  if (args.unsettled_balance === undefined) {
+    throw new Error('ExpectedUnsettledBalanceInChannelMessage');
+  }
+
+  const commitWeight = Number(args.commit_weight);
+  const {height} = parseThawHeight({id: args.chan_id, thaw: args.thaw_height});
+  const own = args.local_constraints;
+  const peer = args.remote_constraints;
+  const pushAmount = Number(args.push_amount_sat) || Number();
+  const [transactionId, vout] = args.channel_point.split(outpointDelimiter);
+  const uptime = Number(args.uptime) * msPerSec;
+  const zeroConfRealId = args.zero_conf_confirmed_scid;
+
+  const channelId = !!Number(zeroConfRealId) ? zeroConfRealId : args.chan_id;
+  const downtime = Number(args.lifetime) * msPerSec - uptime;
+
+  const otherIds = args.alias_scids
+    .filter(n => n !== channelId)
+    .map(number => chanFormat({number}));
+
+  return {
+    capacity: Number(args.capacity),
+    commit_transaction_fee: Number(args.commit_fee),
+    commit_transaction_weight: commitWeight,
+    cooperative_close_address: args.close_address || undefined,
+    cooperative_close_delay_height: height,
+    description: args.memo || undefined,
+    id: chanFormat({number: channelId}).channel,
+    is_active: args.active,
+    is_closing: false,
+    is_opening: false,
+    is_partner_initiated: !args.initiator,
+    is_private: args.private,
+    is_trusted_funding: args.zero_conf || undefined,
+    local_balance: Number(args.local_balance),
+    local_csv: own.csv_delay,
+    local_dust: Number(own.dust_limit_sat),
+    local_given: !!args.initiator ? pushAmount : Number(),
+    local_max_htlcs: own.max_accepted_htlcs,
+    local_max_pending_mtokens: own.max_pending_amt_msat,
+    local_min_htlc_mtokens: own.min_htlc_msat,
+    local_reserve: Number(own.chan_reserve_sat),
+    other_ids: otherIds.map(n => n.channel),
+    partner_public_key: args.remote_pubkey,
+    past_states: Number(args.num_updates),
+    pending_payments: args.pending_htlcs.map(rpcHtlcAsPayment),
+    received: Number(args.total_satoshis_received),
+    remote_balance: Number(args.remote_balance),
+    remote_csv: peer.csv_delay,
+    remote_dust: Number(peer.dust_limit_sat),
+    remote_given: !args.initiator ? pushAmount : Number(),
+    remote_max_htlcs: peer.max_accepted_htlcs,
+    remote_max_pending_mtokens: peer.max_pending_amt_msat,
+    remote_min_htlc_mtokens: peer.min_htlc_msat,
+    remote_reserve: Number(peer.chan_reserve_sat),
+    sent: Number(args.total_satoshis_sent),
+    time_offline: downtime,
+    time_online: uptime,
+    transaction_id: transactionId,
+    transaction_vout: Number(vout),
+    type: channelTypes[args.commitment_type],
+    unsettled_balance: Number(args.unsettled_balance),
+  };
+};

package/lnd_responses/rpc_channel_as_old_rpc_channel.js

@@ -0,0 +1,28 @@
+const {adjustedChannelTypes} = require('./constants');
+const {defaultChannelType} = require('./constants');
+const {oldChannelVersions} = require('./constants');
+
+const {assign} = Object;
+
+/** Map RPC channel fields into the legacy RPC channel fields as needed
+
+  {
+    channel: {
+      [commitment_type]: <Channel Commitment Type String>
+    }
+    [version]: <Wallet Version String>
+  }
+
+  @returns
+  <Updated Channel Object>
+*/
+module.exports = ({channel, version}) => {
+  if (!oldChannelVersions.includes(version)) {
+    return channel;
+  }
+
+  const type = adjustedChannelTypes[channel.commitment_type];
+
+  // Versions of LND 0.13.4 and before use a different channel type value
+  return assign(channel, {commitment_type: type || defaultChannelType});
+};

package/lnd_responses/rpc_channel_closed_as_closed.js

@@ -0,0 +1,79 @@
+const {chanFormat} = require('bolt07');
+
+const bufferAsHex = buffer => buffer.toString('hex');
+const emptyTxId = Buffer.alloc(32);
+const {isBuffer} = Buffer;
+
+/** Map RPC graph channel closed to a channel close update
+
+  {
+    [capacity]: <Channel Capacity Tokens String>
+    chan_id: <Numeric Format Channel Id String>
+    chan_point: {
+      funding_txid_bytes: <Funding Internal Byte Order Tx Id Buffer Object>
+      output_index: <Output Index Number>
+    }
+    closed_height: <Channel Closed At Height Number>
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    [capacity]: <Channel Capacity Tokens Number>
+    close_height: <Channel Close Confirmed Block Height Number>
+    id: <Standard Format Channel Id String>
+    [transaction_id]: <Channel Transaction Id String>
+    [transaction_vout]: <Channel Transaction Output Index Number>
+    updated_at: <Update Received At ISO 8601 Date String>
+  }
+*/
+module.exports = update => {
+  if (!update) {
+    throw new Error('ExpectedChannelClosedUpdateDetails');
+  }
+
+  if (!update.capacity) {
+    throw new Error('ExpectedChanCapacity');
+  }
+
+  if (!update.chan_id) {
+    throw new Error('ExpectedChannelId');
+  }
+
+  try {
+    chanFormat({number: update.chan_id});
+  } catch (err) {
+    throw new Error('ExpectedValidChannelId');
+  }
+
+  if (!update.chan_point) {
+    throw new Error('ExpectedChanOutpoint');
+  }
+
+  if (!isBuffer(update.chan_point.funding_txid_bytes)) {
+    throw new Error('ExpectedChannelTxId');
+  }
+
+  if (update.chan_point.output_index === undefined) {
+    throw new Error('ExpectedChanPointVout');
+  }
+
+  if (!update.closed_height) {
+    throw new Error('ExpectedCloseHeight');
+  }
+
+  const transactionId = update.chan_point.funding_txid_bytes.reverse();
+
+  const txId = !!transactionId.equals(emptyTxId) ? null : transactionId;
+
+  return {
+    capacity: Number(update.capacity) || undefined,
+    close_height: update.closed_height,
+    id: chanFormat({number: update.chan_id}).channel,
+    transaction_id: !!txId ? bufferAsHex(txId) : undefined,
+    transaction_vout: !!txId ? update.chan_point.output_index : undefined,
+    updated_at: new Date().toISOString(),
+  };
+};

package/lnd_responses/rpc_channel_update_as_update.js

@@ -0,0 +1,143 @@
+const {chanFormat} = require('bolt07');
+
+const asDiscount = fee => !fee ? 0 : -fee;
+const bufferAsHex = buffer => buffer.toString('hex');
+const emptyTxId = Buffer.alloc(32);
+const {isBuffer} = Buffer;
+const now = () => new Date().toISOString();
+
+/** Derive channel update details from an rpc channel update
+
+  {
+    advertising_node: <Advertising Node Public Key Hex String>
+    capacity: <Channel Capacity Tokens String>
+    chan_id: <Numeric Format Channel Id String>
+    chan_point: {
+      funding_txid_bytes: <Funding Internal Byte Order Tx Id Buffer Object>
+      output_index: <Output Index Number>
+    }
+    connecting_node: <Connecting Node Public Key Hex String>
+    routing_policy: {
+      disabled: <Forwarding is Disabled Bool>
+      fee_base_msat: <Forwarding Base Fee Millitokens String>
+      fee_rate_milli_msat: <Forwarding Fee Rate Per Million String>
+      inbound_fee_base_msat: <Inbound Fee Base Number>
+      inbound_fee_rate_milli_msat: <Inbound Fee Base Number>
+      max_htlc_msat: <Maximum HTLC Size Millitokens String>
+      min_htlc: <Minimum HTLC Size Millitokens String>
+      time_lock_delta: <Forwarding CLTV Delta Number>
+    }
+  }
+
+  @throws
+  <Error>
+
+  @returns
+  {
+    base_fee_mtokens: <Channel Base Fee Millitokens String>
+    [capacity]: <Channel Capacity Tokens Number>
+    cltv_delta: <Channel CLTV Delta Number>
+    fee_rate: <Channel Fee Rate In Millitokens Per Million Number>
+    id: <Standard Format Channel Id String>
+    inbound_base_discount_mtokens: <Source Fee Discount Millitokens String>
+    inbound_rate_discount: <Source Based PPM Fee Discount Number>
+    is_disabled: <Channel Is Disabled Bool>
+    [max_htlc_mtokens]: <Channel Maximum HTLC Millitokens String>
+    min_htlc_mtokens: <Channel Minimum HTLC Millitokens String>
+    public_keys: [<Announcing Public Key>, <Target Public Key String>]
+    [transaction_id]: <Channel Transaction Id String>
+    [transaction_vout]: <Channel Transaction Output Index Number>
+    updated_at: <Update Received At ISO 8601 Date String>
+  }
+*/
+module.exports = update => {
+  if (!update) {
+    throw new Error('ExpectedChannelUpdateDetails');
+  }
+
+  if (!update.advertising_node) {
+    throw new Error('ExpectedAnnouncingKey');
+  }
+
+  if (!update.capacity) {
+    throw new Error('ExpectedChanCapacity');
+  }
+
+  if (!update.chan_id) {
+    throw new Error('ExpectedChannelId');
+  }
+
+  if (!update.chan_point) {
+    throw new Error('ExpectedChanPoint');
+  }
+
+  if (!isBuffer(update.chan_point.funding_txid_bytes)) {
+    throw new Error('ExpectedChanPointTxId');
+  }
+
+  if (update.chan_point.output_index === undefined) {
+    throw new Error('ExpectedChanPointVout');
+  }
+
+  if (!update.connecting_node) {
+    throw new Error('ExpectedConnectingNode');
+  }
+
+  if (!update.routing_policy) {
+    throw new Error('ExpectedRoutingPolicy');
+  }
+
+  if (update.routing_policy.disabled === undefined) {
+    throw new Error('ExpectedDisabledStatus');
+  }
+
+  if (!update.routing_policy.fee_base_msat) {
+    throw new Error('ExpectedFeeBaseMsat');
+  }
+
+  if (!update.routing_policy.fee_rate_milli_msat) {
+    throw new Error('ExpectedFeeRate');
+  }
+
+  if (!update.routing_policy.max_htlc_msat) {
+    throw new Error('ExpectedMaxHtlcInChannelUpdate');
+  }
+
+  if (!update.routing_policy.min_htlc) {
+    throw new Error('ExpectedMinHtlc');
+  }
+
+  if (update.routing_policy.time_lock_delta === undefined) {
+    throw new Error('ExpectedCltvDelta');
+  }
+
+  try {
+    chanFormat({number: update.chan_id});
+  } catch (err) {
+    throw new Error('ExpectedValidChannelId');
+  }
+
+  const inBase = asDiscount(update.routing_policy.inbound_fee_base_msat);
+  const inRate = asDiscount(update.routing_policy.inbound_fee_rate_milli_msat);
+  const maxHtlc = update.routing_policy.max_htlc_msat;
+  const transactionId = update.chan_point.funding_txid_bytes.reverse();
+
+  const txId = !!transactionId.equals(emptyTxId) ? null : transactionId;
+
+  return {
+    base_fee_mtokens: update.routing_policy.fee_base_msat,
+    capacity: Number(update.capacity) || undefined,
+    cltv_delta: update.routing_policy.time_lock_delta,
+    fee_rate: Number(update.routing_policy.fee_rate_milli_msat),
+    id: chanFormat({number: update.chan_id}).channel,
+    inbound_base_discount_mtokens: inBase.toString(),
+    inbound_rate_discount: inRate,
+    is_disabled: update.routing_policy.disabled,
+    max_htlc_mtokens: maxHtlc !== Number().toString() ? maxHtlc : undefined,
+    min_htlc_mtokens: update.routing_policy.min_htlc,
+    public_keys: [update.advertising_node, update.connecting_node],
+    transaction_id: !!txId ? bufferAsHex(txId) : undefined,
+    transaction_vout: !!txId ? update.chan_point.output_index : undefined,
+    updated_at: now(),
+  };
+};