lighstorm 0.0.2 → 0.0.4

data/controllers/channel/find_by_id.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/edges/channel'
+require_relative '../../adapters/nodes/node'
+require_relative '../../adapters/connections/channel_node/fee'
+
+require_relative '../node/find_by_public_key'
+
+module Lighstorm
+  module Controllers
+    module Channel
+      module FindById
+        def self.fetch(id)
+          data = {
+            at: Time.now,
+            get_info: Ports::GRPC.lightning.get_info.to_h,
+            # Ensure that we are getting fresh up-date data about our own fees.
+            fee_report: Ports::GRPC.lightning.fee_report.to_h,
+            get_chan_info: Ports::GRPC.lightning.get_chan_info(chan_id: id.to_i).to_h,
+            get_node_info: {},
+            list_channels: []
+          }
+
+          data[:get_node_info][data[:get_chan_info][:node1_pub]] = Ports::GRPC.lightning.get_node_info(
+            pub_key: data[:get_chan_info][:node1_pub]
+          ).to_h
+
+          data[:get_node_info][data[:get_chan_info][:node2_pub]] = Ports::GRPC.lightning.get_node_info(
+            pub_key: data[:get_chan_info][:node2_pub]
+          ).to_h
+
+          partners = [
+            data[:get_chan_info][:node1_pub],
+            data[:get_chan_info][:node2_pub]
+          ]
+
+          is_mine = partners.include?(data[:get_info][:identity_pubkey])
+
+          if is_mine
+            partner = partners.find { |p| p != data[:get_info][:identity_pubkey] }
+
+            data[:list_channels] = Ports::GRPC.lightning.list_channels(
+              peer: [partner].pack('H*')
+            ).channels.map(&:to_h)
+          end
+
+          data
+        end
+
+        def self.adapt(raw)
+          adapted = {
+            get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]),
+            get_chan_info: Lighstorm::Adapter::Channel.get_chan_info(raw[:get_chan_info]),
+            fee_report: raw[:fee_report][:channel_fees].map do |raw_fee|
+              Lighstorm::Adapter::Fee.fee_report(raw_fee.to_h)
+            end,
+            list_channels: raw[:list_channels].map do |raw_channel|
+              Lighstorm::Adapter::Channel.list_channels(raw_channel.to_h, raw[:at])
+            end,
+            get_node_info: {}
+          }
+
+          raw[:get_node_info].each_key do |public_key|
+            adapted[:get_node_info][public_key] = Lighstorm::Adapter::Node.get_node_info(
+              raw[:get_node_info][public_key]
+            )
+          end
+
+          adapted
+        end
+
+        def self.transform(data, adapted)
+          [0, 1].each do |i|
+            adapted[:list_channels].each_index do |c|
+              if adapted[:list_channels][c][:partners][i][:node][:public_key].nil?
+                adapted[:list_channels][c][:partners][i][:node] = adapted[:get_info]
+              end
+            end
+          end
+
+          data[:known] = true
+          data[:mine] = false
+          data[:exposure] = 'public'
+
+          [0, 1].each do |i|
+            data[:partners][i][:node] = adapted[:get_info] if data[:partners][i][:node][:public_key].nil?
+
+            if data[:partners][i][:node][:public_key] == adapted[:get_info][:public_key]
+              data[:partners][i][:node] = adapted[:get_info]
+              data[:partners][i][:node][:myself] = true
+              data[:mine] = true
+              adapted[:fee_report].each do |channel|
+                next unless data[:id] == channel[:id]
+
+                data[:partners][i][:policy][:fee] = channel[:partner][:policy][:fee]
+                break
+              end
+            else
+              data[:partners][i][:node] = adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+              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
+
+          adapted[:list_channels].each do |channel|
+            next unless channel[:id] == data[:id]
+
+            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|
+                next unless data[:partners][i][:node][:public_key] == partner[:node][:public_key]
+
+                partner.each_key do |key|
+                  next if data[:partners][i].key?(key)
+
+                  data[:partners][i][key] = partner[key]
+                end
+              end
+            end
+
+            break
+          end
+
+          data
+        end
+
+        def self.data(id, &vcr)
+          raw = vcr.nil? ? fetch(id) : vcr.call(-> { fetch(id) })
+
+          adapted = adapt(raw)
+
+          transform(adapted[:get_chan_info], adapted)
+        end
+
+        def self.model(data)
+          Lighstorm::Models::Channel.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/channel/mine.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/edges/channel'
+require_relative '../../adapters/nodes/node'
+require_relative '../../adapters/connections/channel_node/fee'
+
+module Lighstorm
+  module Controllers
+    module Channel
+      module Mine
+        def self.fetch
+          data = {
+            at: Time.now,
+            get_info: Ports::GRPC.lightning.get_info.to_h,
+            # Ensure that we are getting fresh up-date data about our own fees.
+            fee_report: Ports::GRPC.lightning.fee_report.to_h,
+            list_channels: Ports::GRPC.lightning.list_channels.channels.map(&:to_h),
+            get_chan_info: {},
+            get_node_info: {}
+          }
+
+          data[:list_channels].each do |channel|
+            unless data[:get_chan_info][channel[:chan_id]]
+              data[:get_chan_info][channel[:chan_id]] = Ports::GRPC.lightning.get_chan_info(
+                chan_id: channel[:chan_id]
+              ).to_h
+            end
+
+            next if data[:get_node_info][channel[:remote_pubkey]]
+
+            data[:get_node_info][channel[:remote_pubkey]] = Ports::GRPC.lightning.get_node_info(
+              pub_key: channel[:remote_pubkey]
+            ).to_h
+          end
+
+          data
+        end
+
+        def self.adapt(raw)
+          adapted = {
+            get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]),
+            fee_report: raw[:fee_report][:channel_fees].map do |raw_fee|
+              Lighstorm::Adapter::Fee.fee_report(raw_fee.to_h)
+            end,
+            list_channels: raw[:list_channels].map do |raw_channel|
+              Lighstorm::Adapter::Channel.list_channels(raw_channel.to_h, raw[:at])
+            end,
+            get_chan_info: {},
+            get_node_info: {}
+          }
+
+          raw[:get_chan_info].each do |key, value|
+            adapted[:get_chan_info][key] = Lighstorm::Adapter::Channel.get_chan_info(value.to_h)
+          end
+
+          raw[:get_node_info].each do |key, value|
+            adapted[:get_node_info][key] = Lighstorm::Adapter::Node.get_node_info(value.to_h)
+          end
+
+          adapted
+        end
+
+        def self.transform(data, adapted)
+          [0, 1].each do |i|
+            data[:partners][i][:node] = adapted[:get_info] if data[:partners][i][:node][:public_key].nil?
+
+            adapted[:get_chan_info][data[:id].to_i][: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[:known] = true
+              data[:mine] = true
+              adapted[:fee_report].each do |channel|
+                next unless data[:id] == channel[:id]
+
+                data[:partners][i][:policy][:fee] = channel[:partner][:policy][:fee]
+                break
+              end
+            else
+              data[:partners][i][:node] = adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+              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
+          data
+        end
+
+        def self.data(&vcr)
+          raw = vcr.nil? ? fetch : vcr.call(-> { fetch })
+
+          adapted = adapt(raw)
+
+          adapted[:list_channels].map { |data| transform(data, adapted) }
+        end
+
+        def self.model(data)
+          data.map do |node_data|
+            Lighstorm::Models::Channel.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/channel.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative './channel/mine'
+require_relative './channel/all'
+require_relative './channel/find_by_id'
+
+module Lighstorm
+  module Controllers
+    module Channel
+      def self.mine
+        Mine.model(Mine.data)
+      end
+
+      def self.all(limit: nil)
+        All.model(All.data(limit: limit))
+      end
+
+      def self.find_by_id(id)
+        FindById.model(FindById.data(id))
+      end
+    end
+  end
+end

data/controllers/forward/all.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+require_relative '../../adapters/edges/channel'
+require_relative '../../adapters/edges/forward'
+require_relative '../../adapters/connections/channel_node/fee'
+
+require_relative '../../models/edges/forward'
+
+module Lighstorm
+  module Controllers
+    module Forward
+      module All
+        def self.fetch(limit: nil)
+          at = Time.now
+
+          last_offset = 0
+
+          forwards = []
+
+          loop do
+            response = Ports::GRPC.lightning.forwarding_history(index_offset: last_offset)
+
+            response.forwarding_events.each { |forward| forwards << forward.to_h }
+
+            # TODO: How to optimize this?
+            # break if !limit.nil? && forwards.size >= limit
+
+            break if last_offset == response.last_offset_index || last_offset > response.last_offset_index
+
+            last_offset = response.last_offset_index
+          end
+
+          forwards = forwards.sort_by { |raw_forward| -raw_forward[:timestamp_ns] }
+
+          forwards = forwards[0..limit - 1] unless limit.nil?
+
+          data = {
+            at: at,
+            get_info: Ports::GRPC.lightning.get_info.to_h,
+            fee_report: Ports::GRPC.lightning.fee_report.to_h,
+            forwarding_history: forwards,
+            list_channels: {},
+            get_chan_info: {},
+            get_node_info: {}
+          }
+
+          forwards.each do |forward|
+            unless data[:get_chan_info][forward[:chan_id_in]]
+              begin
+                data[:get_chan_info][forward[:chan_id_in]] = Ports::GRPC.lightning.get_chan_info(
+                  chan_id: forward[:chan_id_in]
+                ).to_h
+              rescue GRPC::Unknown => e
+                data[:get_chan_info][forward[:chan_id_in]] = { _error: e }
+              end
+            end
+
+            next if data[:get_chan_info][forward[:chan_id_out]]
+
+            begin
+              data[:get_chan_info][forward[:chan_id_out]] = Ports::GRPC.lightning.get_chan_info(
+                chan_id: forward[:chan_id_out]
+              ).to_h
+            rescue GRPC::Unknown => e
+              data[:get_chan_info][forward[:chan_id_out]] = { _error: e }
+            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]
+                Ports::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 data[:get_node_info][channel[:node1_pub]]
+              data[:get_node_info][channel[:node1_pub]] = Ports::GRPC.lightning.get_node_info(
+                pub_key: channel[:node1_pub]
+              ).to_h
+            end
+
+            next if data[:get_node_info][channel[:node2_pub]]
+
+            data[:get_node_info][channel[:node2_pub]] = Ports::GRPC.lightning.get_node_info(
+              pub_key: channel[:node2_pub]
+            ).to_h
+          end
+
+          data[:list_channels].each_value do |channel|
+            next if data[:get_node_info][channel[:remote_pubkey]]
+
+            data[:get_node_info][channel[:remote_pubkey]] = Ports::GRPC.lightning.get_node_info(
+              pub_key: channel[:remote_pubkey]
+            ).to_h
+          end
+
+          data
+        end
+
+        def self.adapt(raw)
+          adapted = {
+            get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]),
+            forwarding_history: raw[:forwarding_history].map do |raw_forward|
+              Lighstorm::Adapter::Forward.forwarding_history(raw_forward)
+            end,
+            fee_report: raw[:fee_report][:channel_fees].map do |raw_fee|
+              Lighstorm::Adapter::Fee.fee_report(raw_fee.to_h)
+            end,
+            list_channels: {},
+            get_chan_info: {},
+            get_node_info: {}
+          }
+
+          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(data, adapted)
+          unless adapted[:get_chan_info][data[:id].to_i]
+            data[:_key] = Digest::SHA256.hexdigest(data[:id])
+            return data
+          end
+
+          data = adapted[:get_chan_info][data[:id].to_i]
+          data[:known] = true
+
+          [0, 1].each do |i|
+            if data[:partners][i][:node][:public_key] == adapted[:get_info][:public_key]
+              data[:partners][i][:node] =
+                adapted[:get_info]
+            end
+
+            adapted[:get_chan_info][data[:id].to_i][: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]
+
+                data[:partners][i][:policy][:fee] = channel[:partner][:policy][:fee]
+                break
+              end
+            else
+              data[:partners][i][:node] = adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+              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.data(limit: nil, &vcr)
+          raw = vcr.nil? ? fetch(limit: limit) : vcr.call(-> { fetch(limit: limit) })
+
+          adapted = adapt(raw)
+
+          adapted[:forwarding_history].map do |data|
+            data[:in][:channel] = transform(data[:in][:channel], adapted)
+            data[:out][:channel] = transform(data[:out][:channel], adapted)
+            data
+          end
+        end
+
+        def self.model(data)
+          data.map do |node_data|
+            Lighstorm::Models::Forward.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/forward/group_by_channel.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative 'all'
+
+require_relative '../../models/edges/groups/channel_forwards'
+
+module Lighstorm
+  module Controllers
+    module Forward
+      module GroupByChannel
+        def self.filter(forwards, hours_ago)
+          return forwards if hours_ago.nil?
+
+          forwards.filter do |forward|
+            forward_hours_ago = (Time.now - Time.parse(forward[:at].to_s)).to_f / 3600
+            forward_hours_ago <= hours_ago
+          end
+        end
+
+        def self.group(forwards, direction)
+          groups = {}
+
+          forwards.each do |forward|
+            key = forward[direction][:channel][:id]
+            groups[key] = [] unless groups.key?(key)
+            groups[key] << forward
+          end
+
+          groups.values
+        end
+
+        def self.analyze(forwards, direction)
+          group = {
+            last_at: nil,
+            analysis: {
+              count: 0,
+              sums: { amount: { milisatoshis: 0 }, fee: { milisatoshis: 0 } }
+            },
+            channel: nil
+          }
+
+          forwards.each do |forward|
+            group[:last_at] = forward[:at] if group[:last_at].nil? || forward[:at] > group[:last_at]
+
+            group[:channel] = forward[direction][:channel] if group[:channel].nil?
+
+            group[:analysis][:count] += 1
+            group[:analysis][:sums][:amount][:milisatoshis] += forward[:in][:amount][:milisatoshis]
+            group[:analysis][:sums][:fee][:milisatoshis] += forward[:fee][:milisatoshis]
+          end
+
+          group[:_key] = _key(group)
+
+          group
+        end
+
+        def self._key(group)
+          Digest::SHA256.hexdigest(
+            [group[:last_at], group[:analysis][:count], group[:channel][:id]].join('/')
+          )
+        end
+
+        def self.sort(groups)
+          groups.sort_by { |group| - Time.parse(group[:last_at].to_s).to_f }
+                .sort_by { |group| - group[:analysis][:count] }
+        end
+
+        def self.data(direction: :out, hours_ago: nil, limit: nil, &vcr)
+          data = All.data(&vcr)
+
+          filtered = filter(data, hours_ago)
+          groups = group(filtered, direction)
+          analyzed = groups.map { |group| analyze(group, direction) }
+          sorted = sort(analyzed)
+
+          sorted = sorted[0..limit - 1] unless limit.nil?
+
+          sorted
+        end
+
+        def self.model(data)
+          data.map { |group| Models::ChannelForwardsGroup.new(group) }
+        end
+      end
+    end
+  end
+end

data/controllers/forward.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative './forward/all'
+require_relative './forward/group_by_channel'
+
+module Lighstorm
+  module Controllers
+    module Forward
+      def self.all(limit: nil)
+        All.model(All.data(limit: limit))
+      end
+
+      def self.first
+        All.model(All.data).first
+      end
+
+      def self.last
+        All.model(All.data).last
+      end
+
+      def self.group_by_channel(direction: :out, hours_ago: nil, limit: nil)
+        GroupByChannel.model(
+          GroupByChannel.data(direction: direction, hours_ago: hours_ago, limit: limit)
+        )
+      end
+    end
+  end
+end

data/controllers/invoice/actions/create.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/errors'
+
+module Lighstorm
+  module Controllers
+    module Invoice
+      module Create
+        def self.perform(description: nil, milisatoshis: nil, preview: false, fake: false)
+          raise Errors::ToDoError, self
+
+          grpc_request = {
+            service: :lightning,
+            method: :add_invoice,
+            params: {
+              memo: description,
+              value_msat: milisatoshis
+            }
+          }
+
+          return grpc_request if preview
+
+          # expiry: Default is 86400 (24 hours).
+          response = LND.instance.middleware("lightning.#{grpc_request[:method]}") do
+            LND.instance.client.lightning.send(grpc_request[:method], grpc_request[:params])
+          end
+
+          # TODO
+          # find_by_secret_hash(invoice.r_hash.unpack1('H*'))
+          # response
+        end
+      end
+    end
+  end
+end