lighstorm 0.0.3 → 0.0.5

data/adapters/connections/channel_node/policy.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Adapter
+    class Policy
+      def self.get_chan_info(grpc)
+        {
+          fee: {
+            base: { milisatoshis: grpc[:fee_base_msat] },
+            rate: { parts_per_million: grpc[:fee_rate_milli_msat] }
+          },
+          htlc: {
+            minimum: { milisatoshis: grpc[:min_htlc] },
+            maximum: { milisatoshis: grpc[:max_htlc_msat] },
+            # https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#cltv_expiry_delta-selection
+            blocks: {
+              delta: {
+                minimum: grpc[:time_lock_delta] # aka cltv_expiry_delta
+              }
+            }
+          }
+        }
+      end
+
+      def self.subscribe_channel_graph(json)
+        result = {
+          _source: :subscribe_channel_graph,
+          fee: {
+            base: { milisatoshis: json['routingPolicy']['feeBaseMsat'].to_i },
+            rate: { parts_per_million: json['routingPolicy']['feeRateMilliMsat'].to_i }
+          },
+          htlc: {
+            minimum: { milisatoshis: json['routingPolicy']['minHtlc'].to_i },
+            maximum: { milisatoshis: json['routingPolicy']['maxHtlcMsat'].to_i },
+            # https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#cltv_expiry_delta-selection
+            blocks: {
+              delta: {
+                minimum: json['routingPolicy']['timeLockDelta'].to_i # aka cltv_expiry_delta
+              }
+            }
+          }
+        }
+
+        policy = json['routingPolicy']
+
+        result[:fee].delete(:base) unless policy.key?('feeBaseMsat') && !policy['feeBaseMsat'].nil?
+        result[:fee].delete(:rate) unless policy.key?('feeRateMilliMsat') && !policy['feeRateMilliMsat'].nil?
+        result.delete(:fee) if result[:fee].empty?
+
+        result[:htlc].delete(:minimum) unless policy.key?('minHtlc') && !policy['minHtlc'].nil?
+        result[:htlc].delete(:maximum) unless policy.key?('maxHtlcMsat') && !policy['maxHtlcMsat'].nil?
+        result[:htlc].delete(:blocks) unless policy.key?('timeLockDelta') && !policy['timeLockDelta'].nil?
+        result.delete(:htlc) if result[:htlc].empty?
+
+        return nil unless result.key?(:fee) || result.key?(:htlc)
+
+        result
+      end
+    end
+  end
+end

data/adapters/connections/channel_node.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative '../nodes/node'
+require_relative 'channel_node/policy'
+
+module Lighstorm
+  module Adapter
+    class ChannelNode
+      def self.list_channels(grpc, key)
+        data = {
+          _source: :list_channels,
+          state: grpc[:active] ? 'active' : 'inactive',
+          accounting: { balance: { milisatoshis: grpc[:"#{key}_balance"] * 1000 } },
+          node: Node.list_channels(grpc, key)
+        }
+
+        data.delete(:node) if data[:node].nil?
+
+        data
+      end
+
+      def self.get_chan_info(grpc, index)
+        data = {
+          _source: :get_chan_info,
+          node: Node.get_chan_info(grpc, index)
+        }
+
+        if grpc[:"node#{index}_policy"]
+          data[:state] = grpc[:"node#{index}_policy"][:disabled] ? 'inactive' : 'active'
+          data[:policy] = Policy.get_chan_info(grpc[:"node#{index}_policy"])
+        end
+
+        data.delete(:node) if data[:node].nil?
+
+        data
+      end
+
+      def self.describe_graph(grpc, index)
+        data = {
+          _source: :describe_graph,
+          node: Node.describe_graph_from_channel(grpc, index)
+        }
+
+        # TODO: No examples to validate the correctness of this scenario.
+        if grpc[:"node#{index}_policy"]
+          data[:state] = grpc[:"node#{index}_policy"][:disabled] ? 'inactive' : 'active'
+          data[:policy] = Policy.get_chan_info(grpc[:"node#{index}_policy"])
+        end
+
+        data.delete(:node) if data[:node].nil?
+
+        data
+      end
+
+      def self.subscribe_channel_graph(json)
+        data = {
+          _source: :subscribe_channel_graph,
+          node: {
+            public_key: json['advertisingNode']
+          },
+          policy: Policy.subscribe_channel_graph(json)
+        }
+
+        unless json['routingPolicy']['disabled'].nil?
+          data[:state] = json['routingPolicy']['disabled'] ? 'inactive' : 'active'
+        end
+
+        data.delete(:policy) if data[:policy].nil?
+
+        data
+      end
+    end
+  end
+end

data/adapters/connections/payment_channel.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class PaymentChannel
+      def self.list_payments(grpc, index)
+        {
+          _source: :list_payments,
+          hop: index + 1,
+          amount: { milisatoshis: grpc[:amt_to_forward_msat] },
+          fee: { milisatoshis: grpc[:fee_msat] },
+          channel: {
+            _key: Digest::SHA256.hexdigest(grpc[:chan_id].to_s),
+            id: grpc[:chan_id].to_s,
+            partners: [
+              node: {
+                _key: Digest::SHA256.hexdigest(grpc[:pub_key].to_s),
+                public_key: grpc[:pub_key]
+              }
+            ]
+          }
+        }
+      end
+    end
+  end
+end

data/adapters/edges/channel.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative '../connections/channel_node'
+
+module Lighstorm
+  module Adapter
+    class Channel
+      def self._key(id, state)
+        Digest::SHA256.hexdigest(
+          [id, state].join('/')
+        )
+      end
+
+      def self.list_channels(grpc, at)
+        {
+          _source: :list_channels,
+          _key: _key(grpc[:chan_id], grpc[:active] ? 'active' : 'inactive'),
+          # Standard JSON don't support BigInt, so, a String is safer.
+          id: grpc[:chan_id].to_s,
+          transaction: {
+            funding: {
+              id: grpc[:channel_point].split(':').first,
+              index: grpc[:channel_point].split(':').last.to_i
+            }
+          },
+          opened_at: at - grpc[:lifetime],
+          up_at: at - grpc[:uptime],
+          state: grpc[:active] ? 'active' : 'inactive',
+          exposure: grpc[:private] ? 'private' : 'public',
+          accounting: {
+            capacity: { milisatoshis: grpc[:capacity] * 1000 },
+            sent: { milisatoshis: grpc[:total_satoshis_sent] * 1000 },
+            received: { milisatoshis: grpc[:total_satoshis_received] * 1000 },
+            unsettled: { milisatoshis: grpc[:unsettled_balance] * 1000 }
+          },
+          partners: [
+            ChannelNode.list_channels(grpc, :local),
+            ChannelNode.list_channels(grpc, :remote)
+          ]
+        }
+      end
+
+      def self.get_chan_info(grpc)
+        {
+          _source: :get_chan_info,
+          _key: _key(grpc[:channel_id], nil),
+          # Standard JSON don't support BigInt, so, a String is safer.
+          id: grpc[:channel_id].to_s,
+          accounting: {
+            capacity: { milisatoshis: grpc[:capacity] * 1000 }
+          },
+          partners: [
+            ChannelNode.get_chan_info(grpc, 1),
+            ChannelNode.get_chan_info(grpc, 2)
+          ]
+        }
+      end
+
+      def self.describe_graph(grpc)
+        {
+          _source: :describe_graph,
+          _key: _key(grpc[:channel_id], nil),
+          # Standard JSON don't support BigInt, so, a String is safer.
+          id: grpc[:channel_id].to_s,
+          exposure: 'public',
+          accounting: {
+            capacity: { milisatoshis: grpc[:capacity] * 1000 }
+          },
+          partners: [
+            ChannelNode.describe_graph(grpc, 1),
+            ChannelNode.describe_graph(grpc, 2)
+          ]
+        }
+      end
+
+      def self.subscribe_channel_graph(json)
+        {
+          _source: :subscribe_channel_graph,
+          _key: _key(json['chanId'], nil),
+          id: json['chanId'],
+          accounting: {
+            capacity: { milisatoshis: json['capacity'].to_i * 1000 }
+          },
+          partners: [
+            ChannelNode.subscribe_channel_graph(json),
+            { node: {
+              public_key: json['connectingNode']
+            } }
+          ]
+        }
+      end
+    end
+  end
+end

data/adapters/edges/forward.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class Forward
+      def self.forwarding_history(grpc)
+        {
+          _source: :forwarding_history,
+          _key: _key(grpc),
+          at: Time.at(grpc[:timestamp_ns] / 1e+9),
+          fee: { milisatoshis: grpc[:fee_msat] },
+          in: {
+            amount: { milisatoshis: grpc[:amt_in_msat] },
+            channel: {
+              id: grpc[:chan_id_in].to_s
+            }
+          },
+          out: {
+            amount: { milisatoshis: grpc[:amt_out_msat] },
+            channel: {
+              id: grpc[:chan_id_out].to_s
+            }
+          }
+        }
+      end
+
+      def self._key(grpc)
+        Digest::SHA256.hexdigest(
+          [
+            grpc[:timestamp_ns],
+            grpc[:chan_id_in], grpc[:chan_id_out],
+            grpc[:amt_in_msat], grpc[:fee_msat]
+          ].join('/')
+        )
+      end
+    end
+  end
+end

data/adapters/edges/payment/purpose.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Adapter
+    class Purpose
+      def self.list_payments(grpc, node_get_info)
+        return 'self-payment' if self_payment?(grpc)
+        return 'peer-to-peer' if peer_to_peer?(grpc)
+        return 'rebalance' if rebalance?(grpc, node_get_info)
+
+        'payment'
+      end
+
+      def self.self_payment?(grpc)
+        grpc[:htlcs].first[:route][:hops].size == 2 &&
+          grpc[:htlcs].first[:route][:hops][0][:chan_id] == grpc[:htlcs].first[:route][:hops][1][:chan_id]
+      end
+
+      def self.peer_to_peer?(grpc)
+        grpc[:htlcs].first[:route][:hops].size == 1
+      end
+
+      def self.rebalance?(grpc, node_get_info)
+        return false if grpc[:htlcs].first[:route][:hops].size <= 2
+
+        destination_public_key = grpc[:htlcs].first[:route][:hops].last[:pub_key]
+
+        node_get_info[:identity_pubkey] == destination_public_key
+      end
+    end
+  end
+end

data/adapters/edges/payment.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative '../connections/payment_channel'
+require_relative 'payment/purpose'
+
+require_relative '../payment_request'
+
+require_relative '../../ports/dsl/lighstorm/errors'
+
+module Lighstorm
+  module Adapter
+    class Payment
+      def self._key(grpc)
+        Digest::SHA256.hexdigest(
+          [
+            grpc[:payment_request],
+            grpc[:creation_time_ns],
+            grpc[:resolve_time_ns],
+            grpc[:status]
+          ].join('/')
+        )
+      end
+
+      def self.list_payments(grpc, node_get_info)
+        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
+
+        data = {
+          _source: :list_payments,
+          _key: _key(grpc),
+          created_at: Time.at(grpc[:creation_time_ns] / 1e+9),
+          status: grpc[:status].to_s.downcase,
+          fee: { milisatoshis: grpc[:fee_msat] },
+          purpose: Purpose.list_payments(grpc, node_get_info),
+          request: PaymentRequest.list_payments(grpc),
+          hops: grpc[:htlcs].first[:route][:hops].map.with_index do |raw_hop, i|
+            hop = PaymentChannel.list_payments(raw_hop, i)
+            hop[:channel][:target] = { public_key: raw_hop[:pub_key] }
+            hop
+          end
+        }
+
+        data[:settled_at] = Time.at(grpc[:htlcs].first[:resolve_time_ns] / 1e+9) if grpc[:htlcs].first[:resolve_time_ns]
+
+        data
+      end
+    end
+  end
+end

data/adapters/invoice.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative 'payment_request'
+
+module Lighstorm
+  module Adapter
+    class Invoice
+      def self.lookup_invoice(grpc)
+        adapted = list_or_lookup(grpc)
+
+        adapted[:_source] = :lookup_invoice
+        adapted[:request] = PaymentRequest.lookup_invoice(grpc)
+
+        adapted
+      end
+
+      def self.list_invoices(grpc)
+        adapted = list_or_lookup(grpc)
+
+        adapted[:_source] = :list_invoices
+        adapted[:request] = PaymentRequest.list_invoices(grpc)
+
+        adapted
+      end
+
+      def self.list_or_lookup(grpc)
+        {
+          _key: _key(grpc),
+          created_at: Time.at(grpc[:creation_date]),
+          settle_at: Time.at(grpc[:settle_date]),
+          state: grpc[:state].to_s.downcase
+        }
+      end
+
+      def self._key(grpc)
+        Digest::SHA256.hexdigest(
+          [
+            grpc[:creation_date],
+            grpc[:settle_date],
+            grpc[:payment_request],
+            grpc[:state]
+          ].join('/')
+        )
+      end
+    end
+  end
+end

data/adapters/nodes/node.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class Node
+      def self._key(public_key)
+        Digest::SHA256.hexdigest(
+          [public_key].join('/')
+        )
+      end
+
+      def self.get_chan_info(grpc, index)
+        {
+          _source: :get_chan_info,
+          _key: _key(grpc[:"node#{index}_pub"]),
+          public_key: grpc[:"node#{index}_pub"]
+        }
+      end
+
+      def self.list_channels(grpc, key)
+        data = {
+          _source: :list_channels,
+          _key: _key(key == :remote ? grpc[:remote_pubkey] : nil),
+          public_key: key == :remote ? grpc[:remote_pubkey] : nil
+        }
+
+        return nil if data[:public_key].nil?
+
+        data
+      end
+
+      def self.get_info(grpc)
+        data = {
+          _source: :get_info,
+          _key: _key(grpc[:identity_pubkey]),
+          public_key: grpc[:identity_pubkey],
+          alias: grpc[:alias],
+          color: grpc[:color],
+          platform: {
+            blockchain: grpc[:chains][0][:chain],
+            network: grpc[:chains][0][:network],
+            lightning: {
+              implementation: 'lnd',
+              version: grpc[:version]
+            }
+          }
+        }
+
+        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
+
+        data
+      end
+
+      def self.get_node_info(grpc)
+        data = {
+          _source: :get_node_info,
+          _key: _key(grpc[:node][:pub_key]),
+          public_key: grpc[:node][:pub_key],
+          alias: grpc[:node][:alias],
+          color: grpc[:node][:color]
+        }
+
+        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
+
+        data
+      end
+
+      def self.describe_graph(grpc)
+        data = {
+          _source: :describe_graph,
+          _key: _key(grpc[:pub_key]),
+          public_key: grpc[:pub_key],
+          alias: grpc[:alias],
+          color: grpc[:color]
+        }
+
+        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
+
+        data
+      end
+
+      def self.describe_graph_from_channel(grpc, index)
+        data = {
+          _source: :describe_graph,
+          _key: _key(grpc[:"node#{index}_pub"]),
+          public_key: grpc[:"node#{index}_pub"]
+        }
+
+        return nil if data[:public_key].nil?
+
+        data
+      end
+
+      def self.subscribe_channel_graph(json)
+        data = {
+          _source: :subscribe_channel_graph,
+          _key: _key(json['identityKey']),
+          public_key: json['identityKey'],
+          alias: json['alias'],
+          color: json['color']
+        }
+
+        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
+
+        data
+      end
+    end
+  end
+end

data/adapters/payment_request.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative '../ports/dsl/lighstorm/errors'
+
+module Lighstorm
+  module Adapter
+    class PaymentRequest
+      def self.decode_pay_req(grpc)
+        {
+          _source: :decode_pay_req,
+          amount: { milisatoshis: grpc[:num_msat] },
+          description: {
+            memo: grpc[:description],
+            hash: grpc[:description_hash] == '' ? nil : grpc[:description_hash]
+          },
+          address: grpc[:payment_addr].unpack1('H*'),
+          secret: {
+            hash: grpc[:payment_hash]
+          }
+        }
+      end
+
+      def self.lookup_invoice(grpc)
+        adapted = list_or_lookup_invoice(grpc)
+        adapted[:_source] = :lookup_invoice
+        adapted
+      end
+
+      def self.list_invoices(grpc)
+        adapted = list_or_lookup_invoice(grpc)
+        adapted[:_source] = :list_invoices
+        adapted
+      end
+
+      def self.list_or_lookup_invoice(grpc)
+        {
+          code: grpc[:payment_request],
+          amount: { milisatoshis: grpc[:value_msat] },
+          description: {
+            memo: grpc[:memo],
+            hash: grpc[:description_hash] == '' ? nil : grpc[:description_hash]
+          },
+          address: grpc[:payment_addr].unpack1('H*'),
+          secret: {
+            preimage: grpc[:r_preimage].unpack1('H*'),
+            hash: grpc[:r_hash].unpack1('H*')
+          }
+        }
+      end
+
+      def self.list_payments(grpc)
+        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
+
+        data = {
+          _source: :list_payments,
+          code: grpc[:payment_request],
+          amount: { milisatoshis: grpc[:value_msat] },
+          secret: {
+            preimage: grpc[:payment_preimage],
+            hash: grpc[:payment_hash]
+          }
+        }
+
+        grpc[:htlcs].first[:route][:hops].map do |raw_hop|
+          if raw_hop[:mpp_record] && raw_hop[:mpp_record][:payment_addr]
+            data[:address] = raw_hop[:mpp_record][:payment_addr].unpack1('H*')
+          end
+        end
+
+        data
+      end
+    end
+  end
+end

data/components/cache.rb

@@ -5,6 +5,7 @@ require 'singleton'
 require 'zache'
 
 require_relative '../static/cache'
+require_relative '../ports/dsl/lighstorm/errors'
 
 module Lighstorm
   class Cache
@@ -23,7 +24,7 @@ module Lighstorm
     def for(key, ttl: nil, params: {}, &block)
       if ttl.nil?
         ttl = Lighstorm::Static::CACHE[key.sub('lightning.', '').to_sym]
-        raise "missing ttl for #{key}" if ttl.nil?
+        raise MissingTTLError, "missing ttl for #{key} static/cache.rb" if ttl.nil?
 
         ttl = ttl[:ttl]
       end
@@ -36,7 +37,7 @@ module Lighstorm
     end
 
     def build_key_for(key, params)
-      return key unless params.size.positive?
+      return key unless !params.nil? && params.size.positive?
 
       key_params = []
       params.keys.sort.each do |param_key|

data/components/lnd.rb

@@ -4,6 +4,8 @@ require 'singleton'
 
 require 'lnd-client'
 
+require_relative '../ports/dsl/lighstorm/errors'
+
 module Lighstorm
   class LND
     include Singleton
@@ -23,7 +25,9 @@ module Lighstorm
     def client
       return @client if @client
 
-      raise 'missing credentials' if @config.nil? && ENV.fetch('LIGHSTORM_CERTIFICATE_PATH', nil).nil?
+      raise MissingCredentialsError, 'missing credentials' if @config.nil? && ENV.fetch(
+        'LIGHSTORM_CERTIFICATE_PATH', nil
+      ).nil?
 
       @client = if @config
                   create_client_from_config