lighstorm 0.0.3 → 0.0.5

data/controllers/node/actions/apply_gossip.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/errors'
+require_relative '../../../models/nodes/node'
+require_relative '../../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module ApplyGossip
+        SKIPABLE = %w[
+          _source
+          _key
+        ].freeze
+
+        NOT_ALLOWED = [
+          'public_key'
+        ].freeze
+
+        APPLICABLE = %w[
+          alias
+          color
+        ].freeze
+
+        def self.perform(actual, gossip)
+          updated = Models::Node.new(Adapter::Node.subscribe_channel_graph(gossip))
+
+          actual_dump = actual.dump
+          updated_dump = updated.dump
+
+          diff = generate_diff(actual_dump, updated_dump)
+
+          diff.each do |change|
+            key = change[:path].join('/')
+            next unless NOT_ALLOWED.include?(key)
+
+            raise IncoherentGossipError, "Gossip doesn't belong to this Node"
+          end
+
+          diff.filter do |change|
+            key = change[:path].join('/')
+            if SKIPABLE.include?(key)
+              false
+            elsif APPLICABLE.include?(key)
+              apply!(actual, key, change)
+              true
+            else
+              raise Lighstorm::Errors::MissingGossipHandlerError, "don't know how to apply '#{key}'"
+            end
+          end
+        end
+
+        def self.apply!(actual, key, change)
+          case key
+          when 'alias'
+            token = SecureRandom.hex
+            actual.prepare_token!(token)
+            actual.alias = {
+              value: change[:to],
+              token: token
+            }
+          when 'color'
+            token = SecureRandom.hex
+            actual.prepare_token!(token)
+            actual.color = {
+              value: change[:to],
+              token: token
+            }
+          else
+            raise Lighstorm::Errors::MissingGossipHandlerError, "don't know how to apply '#{key}'"
+          end
+        end
+
+        def self.generate_diff(actual, node, path = [], diff = [])
+          case node
+          when Hash
+            result = {}
+            node.each_key do |key|
+              result[key] = generate_diff(actual, node[key], path.dup.push(key), diff)
+            end
+          when Array
+            result = []
+            node.each_with_index do |value, i|
+              result << generate_diff(actual, value, path.dup.push(i), diff)
+            end
+          else
+            new_value = node
+
+            unless new_value.nil?
+              actual_value = actual
+              path.each do |key|
+                if actual_value[key]
+                  actual_value = actual_value[key]
+                else
+                  actual_value = nil
+                  break
+                end
+              end
+
+              diff << { path: path, from: actual_value, to: new_value } if actual_value != new_value
+            end
+          end
+
+          diff
+        end
+      end
+    end
+  end
+end

data/controllers/node/all.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module All
+        def self.fetch(limit: nil)
+          data = {
+            at: Time.now,
+            get_info: Ports::GRPC.lightning.get_info.to_h,
+            describe_graph: Ports::GRPC.lightning.describe_graph.nodes
+          }
+
+          data[:describe_graph] = data[:describe_graph][0..limit - 1] unless limit.nil?
+
+          data
+        end
+
+        def self.adapt(raw)
+          {
+            get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]),
+            describe_graph: raw[:describe_graph].map do |raw|
+              Lighstorm::Adapter::Node.describe_graph(raw.to_h)
+            end
+          }
+        end
+
+        def self.transform(describe_graph, get_info)
+          if get_info[:public_key] == describe_graph[:public_key]
+            get_info.merge(myself: true)
+          else
+            describe_graph.merge(
+              platform: {
+                blockchain: get_info[:platform][:blockchain],
+                network: get_info[:platform][:network]
+              },
+              myself: false
+            )
+          end
+        end
+
+        def self.data(limit: nil, &vcr)
+          raw = vcr.nil? ? fetch(limit: limit) : vcr.call(-> { fetch(limit: limit) })
+
+          adapted = adapt(raw)
+
+          adapted[:describe_graph].map do |data|
+            transform(data, adapted[:get_info])
+          end
+        end
+
+        def self.model(data)
+          data.map do |node_data|
+            Lighstorm::Models::Node.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/node/find_by_public_key.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module FindByPublicKey
+        def self.fetch(public_key)
+          {
+            at: Time.now,
+            get_info: Ports::GRPC.lightning.get_info.to_h,
+            get_node_info: Ports::GRPC.lightning.get_node_info(pub_key: public_key).to_h
+          }
+        end
+
+        def self.adapt(raw)
+          {
+            get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]),
+            get_node_info: Lighstorm::Adapter::Node.get_node_info(raw[:get_node_info])
+          }
+        end
+
+        def self.data(public_key, &vcr)
+          raw = vcr.nil? ? fetch(public_key) : vcr.call(-> { fetch(public_key) })
+
+          adapted = adapt(raw)
+
+          if adapted[:get_info][:public_key] == adapted[:get_node_info][:public_key]
+            adapted[:get_info].merge(myself: true)
+          else
+            adapted[:get_node_info].merge(
+              platform: {
+                blockchain: adapted[:get_info][:platform][:blockchain],
+                network: adapted[:get_info][:platform][:network]
+              },
+              myself: false
+            )
+          end
+        end
+
+        def self.model(data)
+          Lighstorm::Models::Node.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/node/myself.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module Myself
+        def self.fetch
+          {
+            at: Time.now,
+            get_info: Ports::GRPC.lightning.get_info.to_h
+          }
+        end
+
+        def self.adapt(raw)
+          { get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]) }
+        end
+
+        def self.data(&vcr)
+          raw = vcr.nil? ? fetch : vcr.call(-> { fetch })
+
+          adapted = adapt(raw)
+          adapted[:get_info].merge(myself: true)
+        end
+
+        def self.model(data)
+          Lighstorm::Models::Node.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/node.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_relative './node/myself'
+require_relative './node/all'
+require_relative './node/find_by_public_key'
+
+module Lighstorm
+  module Controllers
+    module Node
+      def self.myself
+        Myself.model(Myself.data)
+      end
+
+      def self.all(limit: nil)
+        All.model(All.data(limit: limit))
+      end
+
+      def self.find_by_public_key(public_key)
+        FindByPublicKey.model(FindByPublicKey.data(public_key))
+      end
+
+      def self.adapt(dump: nil, gossip: nil)
+        Models::Node.adapt(dump: dump, gossip: gossip)
+      end
+    end
+  end
+end

data/controllers/payment/all.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+require_relative '../../adapters/edges/payment'
+require_relative '../../adapters/invoice'
+require_relative '../../adapters/edges/payment/purpose'
+
+require_relative '../../models/edges/payment'
+
+module Lighstorm
+  module Controllers
+    module Payment
+      module All
+        def self.fetch(purpose: nil, limit: nil, fetch: {})
+          at = Time.now
+
+          grpc = Ports::GRPC.session
+
+          get_info = grpc.lightning.get_info.to_h
+
+          last_offset = 0
+
+          payments = []
+
+          loop do
+            response = grpc.lightning.list_payments(
+              index_offset: last_offset
+            )
+
+            response.payments.each do |payment|
+              payment = payment.to_h
+
+              payment_purpose = Adapter::Purpose.list_payments(payment, get_info)
+
+              case purpose
+              when 'self-payment', 'self'
+                payments << payment if payment_purpose == 'self-payment'
+              when 'peer-to-peer', 'p2p'
+                payments << payment if payment_purpose == 'peer-to-peer'
+              when '!peer-to-peer', '!p2p'
+                payments << payment unless payment_purpose == 'peer-to-peer'
+              when 'rebalance'
+                payments << payment if payment_purpose == 'rebalance'
+              when '!rebalance'
+                payments << payment unless payment_purpose == 'rebalance'
+              when '!payment'
+                payments << payment unless payment_purpose == 'payment'
+              when 'payment'
+                payments << payment if payment_purpose == 'payment'
+              else
+                payments << payment
+              end
+            end
+
+            # TODO: How to optimize this?
+            # break if !limit.nil? && payments.size >= limit
+
+            break if last_offset == response.last_index_offset || last_offset > response.last_index_offset
+
+            last_offset = response.last_index_offset
+          end
+
+          payments = payments.sort_by { |raw_payment| -raw_payment[:creation_time_ns] }
+
+          payments = payments[0..limit - 1] unless limit.nil?
+
+          data = {
+            at: at,
+            get_info: get_info,
+            fee_report: grpc.lightning.fee_report.to_h,
+            list_payments: payments,
+            list_channels: {},
+            get_chan_info: {},
+            get_node_info: {},
+            lookup_invoice: {},
+            decode_pay_req: {}
+          }
+
+          payments.each do |payment|
+            unless fetch[:decode_pay_req] == false || payment[:payment_request] == '' || data[:decode_pay_req][payment[:payment_request]]
+              data[:decode_pay_req][payment[:payment_request]] = grpc.lightning.decode_pay_req(
+                pay_req: payment[:payment_request]
+              ).to_h
+            end
+
+            unless fetch[:lookup_invoice] == false || data[:lookup_invoice][payment[:payment_hash]]
+              begin
+                data[:lookup_invoice][payment[:payment_hash]] = grpc.lightning.lookup_invoice(
+                  r_hash_str: payment[:payment_hash]
+                ).to_h
+              rescue StandardError => e
+                data[:lookup_invoice][payment[:payment_hash]] = { _error: e }
+              end
+            end
+
+            payment[:htlcs].each do |htlc|
+              htlc[:route][:hops].each do |hop|
+                unless fetch[:get_chan_info] == false || data[:get_chan_info][hop[:chan_id]]
+                  begin
+                    data[:get_chan_info][hop[:chan_id]] = grpc.lightning.get_chan_info(
+                      chan_id: hop[:chan_id]
+                    ).to_h
+                  rescue GRPC::Unknown => e
+                    data[:get_chan_info][hop[:chan_id]] = { _error: e }
+                  end
+                end
+
+                next if fetch[:get_node_info] == false || data[:get_node_info][hop[:pub_key]]
+
+                data[:get_node_info][hop[:pub_key]] = grpc.lightning.get_node_info(
+                  pub_key: hop[:pub_key]
+                ).to_h
+              end
+            end
+          end
+
+          if fetch[:lookup_invoice] != false
+            data[:lookup_invoice].each_value do |invoice|
+              if fetch[:decode_pay_req] == false || invoice[:_error] || invoice[:payment_request] == '' || data[:decode_pay_req][invoice[:payment_request]]
+                next
+              end
+
+              data[:decode_pay_req][invoice[:payment_request]] = grpc.lightning.decode_pay_req(
+                pay_req: invoice[:payment_request]
+              ).to_h
+            end
+          end
+
+          list_channels_done = {}
+
+          data[:get_chan_info].each_value do |channel|
+            next if channel[:_error]
+
+            partners = [channel[:node1_pub], channel[:node2_pub]]
+
+            is_mine = partners.include?(data[:get_info][:identity_pubkey])
+
+            if is_mine
+              partner = partners.find { |p| p != data[:get_info][:identity_pubkey] }
+
+              unless list_channels_done[partner]
+                grpc.lightning.list_channels(
+                  peer: [partner].pack('H*')
+                ).channels.map(&:to_h).each do |list_channels|
+                  data[:list_channels][list_channels[:chan_id]] = list_channels
+                end
+
+                list_channels_done[partner] = true
+              end
+            end
+
+            unless fetch[:get_node_info] == false || data[:get_node_info][channel[:node1_pub]]
+              data[:get_node_info][channel[:node1_pub]] = grpc.lightning.get_node_info(
+                pub_key: channel[:node1_pub]
+              ).to_h
+            end
+
+            next if fetch[:get_node_info] == false || data[:get_node_info][channel[:node2_pub]]
+
+            data[:get_node_info][channel[:node2_pub]] = grpc.lightning.get_node_info(
+              pub_key: channel[:node2_pub]
+            ).to_h
+          end
+
+          data[:list_channels].each_value do |channel|
+            next if fetch[:get_node_info] == false || data[:get_node_info][channel[:remote_pubkey]]
+
+            data[:get_node_info][channel[:remote_pubkey]] = grpc.lightning.get_node_info(
+              pub_key: channel[:remote_pubkey]
+            ).to_h
+          end
+
+          data[:@meta] = { calls: grpc.calls }
+
+          data
+        end
+
+        def self.adapt(raw)
+          adapted = {
+            get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]),
+            list_payments: raw[:list_payments].map do |raw_payment|
+              Lighstorm::Adapter::Payment.list_payments(raw_payment, raw[:get_info])
+            end,
+            fee_report: raw[:fee_report][:channel_fees].map do |raw_fee|
+              Lighstorm::Adapter::Fee.fee_report(raw_fee.to_h)
+            end,
+            lookup_invoice: {},
+            list_channels: {},
+            get_chan_info: {},
+            get_node_info: {},
+            decode_pay_req: {}
+          }
+
+          raw[:decode_pay_req].each_key do |key|
+            next if raw[:decode_pay_req][key][:_error]
+
+            adapted[:decode_pay_req][key] = Lighstorm::Adapter::PaymentRequest.decode_pay_req(
+              raw[:decode_pay_req][key]
+            )
+          end
+
+          raw[:lookup_invoice].each_key do |key|
+            next if raw[:lookup_invoice][key][:_error]
+
+            adapted[:lookup_invoice][key] = Lighstorm::Adapter::Invoice.lookup_invoice(
+              raw[:lookup_invoice][key]
+            )
+          end
+
+          raw[:get_chan_info].each_key do |key|
+            next if raw[:get_chan_info][key][:_error]
+
+            adapted[:get_chan_info][key] = Lighstorm::Adapter::Channel.get_chan_info(
+              raw[:get_chan_info][key]
+            )
+          end
+
+          raw[:list_channels].each_key do |key|
+            adapted[:list_channels][key] = Lighstorm::Adapter::Channel.list_channels(
+              raw[:list_channels][key], raw[:at]
+            )
+          end
+
+          raw[:get_node_info].each_key do |key|
+            adapted[:get_node_info][key] = Lighstorm::Adapter::Node.get_node_info(
+              raw[:get_node_info][key]
+            )
+          end
+
+          adapted
+        end
+
+        def self.transform_channel(data, adapted)
+          if adapted[:get_chan_info][data[:id].to_i]
+            target = data[:target]
+            data = adapted[:get_chan_info][data[:id].to_i]
+            data[:target] = target
+            data[:known] = true
+          else
+            data[:_key] = Digest::SHA256.hexdigest(data[:id])
+          end
+
+          data[:mine] = true if data[:partners].size == 1
+
+          [0, 1].each do |i|
+            next unless data[:partners] && data[:partners][i]
+
+            if data[:partners][i][:node][:public_key] == adapted[:get_info][:public_key]
+              data[:partners][i][:node] = adapted[:get_info]
+            end
+
+            data[:partners].each do |partner|
+              if data[:partners][i][:node][:public_key] == partner[:node][:public_key]
+                data[:partners][i][:policy] = partner[:policy]
+              end
+            end
+
+            if data[:partners][i][:node][:public_key] == adapted[:get_info][:public_key]
+              data[:partners][i][:node][:platform] = adapted[:get_info][:platform]
+              data[:partners][i][:node][:myself] = true
+              data[:mine] = true
+              adapted[:fee_report].each do |channel|
+                next unless data[:id] == channel[:id]
+
+                if data[:partners][i][:policy].nil?
+                  data[:partners][i][:policy] = channel[:partner][:policy]
+                else
+                  data[:partners][i][:policy][:fee] = channel[:partner][:policy][:fee]
+                end
+                break
+              end
+            else
+              if adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+                data[:partners][i][:node] = adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+              end
+              data[:partners][i][:node][:platform] = {
+                blockchain: adapted[:get_info][:platform][:blockchain],
+                network: adapted[:get_info][:platform][:network]
+              }
+
+              data[:partners][i][:node][:myself] = false
+            end
+          end
+
+          channel = adapted[:list_channels][data[:id].to_i]
+
+          return data unless channel
+
+          channel.each_key do |key|
+            next if data.key?(key)
+
+            data[key] = channel[key]
+          end
+
+          data[:accounting] = channel[:accounting]
+
+          channel[:partners].each do |partner|
+            data[:partners].each_index do |i|
+              partner.each_key do |key|
+                next if data[:partners][i].key?(key)
+
+                data[:partners][i][key] = partner[key]
+              end
+            end
+          end
+
+          data
+        end
+
+        def self.transform(list_payments, adapted)
+          if adapted[:lookup_invoice][list_payments[:request][:secret][:hash]] &&
+             !adapted[:lookup_invoice][list_payments[:request][:secret][:hash]][:_error]
+
+            list_payments[:request] = adapted[:lookup_invoice][list_payments[:request][:secret][:hash]][:request]
+          else
+            list_payments[:request][:_key] = Digest::SHA256.hexdigest(
+              list_payments[:request][:code]
+            )
+          end
+          list_payments[:hops].each do |hop|
+            hop[:channel] = transform_channel(hop[:channel], adapted)
+          end
+
+          if adapted[:decode_pay_req][list_payments[:request][:code]]
+            decoded = adapted[:decode_pay_req][list_payments[:request][:code]]
+            request = list_payments[:request]
+
+            decoded.each_key do |key|
+              request[key] = decoded[key] unless request.key?(key)
+
+              next unless decoded[key].is_a?(Hash)
+
+              decoded[key].each_key do |sub_key|
+                request[key][sub_key] = decoded[key][sub_key] unless request[key].key?(sub_key)
+              end
+            end
+          end
+
+          list_payments
+        end
+
+        def self.data(purpose: nil, limit: nil, fetch: {}, &vcr)
+          raw = if vcr.nil?
+                  self.fetch(purpose: purpose, limit: limit, fetch: fetch)
+                else
+                  vcr.call(-> { self.fetch(purpose: purpose, limit: limit, fetch: fetch) })
+                end
+
+          adapted = adapt(raw)
+
+          {
+            data: adapted[:list_payments].map do |data|
+              transform(data, adapted)
+            end,
+            meta: raw[:@meta]
+          }
+        end
+
+        def self.model(data)
+          data[:data].map do |node_data|
+            Lighstorm::Models::Payment.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/payment.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative './payment/all'
+
+module Lighstorm
+  module Controllers
+    module Payment
+      def self.all(purpose: nil, limit: nil, fetch: {})
+        All.model(All.data(purpose: purpose, limit: limit, fetch: fetch))
+      end
+
+      def self.first(purpose: nil, fetch: {})
+        All.model(All.data(purpose: purpose, fetch: fetch)).first
+      end
+
+      def self.last(purpose: nil, fetch: {})
+        All.model(All.data(purpose: purpose, fetch: fetch)).last
+      end
+    end
+  end
+end