lighstorm 0.0.15 → 0.0.16

data/controllers/forward/all.rb

@@ -1,248 +0,0 @@
-# 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(components, limit: nil)
-          at = Time.now
-
-          last_offset = 0
-
-          forwards = []
-
-          loop do
-            response = components[: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: components[:grpc].lightning.get_info.to_h,
-            fee_report: components[: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]] = components[: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]] = components[: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]
-                components[: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]] = components[: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]] = components[: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]] = components[: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(components, limit: nil, &vcr)
-          raw = if vcr.nil?
-                  fetch(components, limit: limit)
-                else
-                  vcr.call(-> { fetch(components, limit: limit) })
-                end
-
-          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

@@ -1,89 +0,0 @@
-# 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: { millisatoshis: 0 }, fee: { millisatoshis: 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][:millisatoshis] += forward[:in][:amount][:millisatoshis]
-            group[:analysis][:sums][:fee][:millisatoshis] += forward[:fee][:millisatoshis]
-          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(components, direction: :out, hours_ago: nil, limit: nil, &vcr)
-          data = All.data(components, &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

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './concerns/impersonatable'
-
-require_relative './forward/all'
-require_relative './forward/group_by_channel'
-
-module Lighstorm
-  module Controllers
-    module Forward
-      extend Impersonatable
-
-      class DSL < Impersonatable::DSL
-        def all(limit: nil)
-          All.model(All.data(components, limit: limit))
-        end
-
-        def first
-          All.model(All.data(components)).first
-        end
-
-        def last
-          All.model(All.data(components)).last
-        end
-
-        def group_by_channel(direction: :out, hours_ago: nil, limit: nil)
-          GroupByChannel.model(
-            GroupByChannel.data(components, direction: direction, hours_ago: hours_ago, limit: limit)
-          )
-        end
-      end
-    end
-  end
-end

data/controllers/invoice/actions/create.rb

@@ -1,88 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../ports/grpc'
-require_relative '../../../models/errors'
-require_relative '../../../helpers/time_expression'
-require_relative '../../invoice'
-require_relative '../../action'
-
-module Lighstorm
-  module Controllers
-    module Invoice
-      module Create
-        def self.call(components, grpc_request)
-          components[:grpc].send(grpc_request[:service]).send(
-            grpc_request[:method], grpc_request[:params]
-          ).to_h
-        end
-
-        def self.prepare(payable:, expires_in:, description: nil, amount: nil)
-          request = {
-            service: :lightning,
-            method: :add_invoice,
-            params: {
-              memo: description,
-              # Lightning Invoice Expiration: UX Considerations
-              # https://d.elor.me/2022/01/lightning-invoice-expiration-ux-considerations/
-              expiry: Helpers::TimeExpression.seconds(expires_in)
-            }
-          }
-
-          request[:params][:value_msat] = amount[:millisatoshis] unless amount.nil?
-
-          if payable.to_sym == :indefinitely
-            request[:params][:is_amp] = true
-          elsif payable.to_sym != :once
-            raise Errors::ArgumentError, "payable: accepts 'indefinitely' or 'once', '#{payable}' is not valid."
-          end
-
-          request
-        end
-
-        def self.dispatch(components, grpc_request, &vcr)
-          if vcr.nil?
-            call(components, grpc_request)
-          else
-            vcr.call(-> { call(components, grpc_request) }, :dispatch)
-          end
-        end
-
-        def self.adapt(response)
-          Lighstorm::Adapter::Invoice.add_invoice(response)
-        end
-
-        def self.fetch(components, adapted, &vcr)
-          FindBySecretHash.data(components, adapted[:secret][:hash], &vcr)
-        end
-
-        def self.model(data, components)
-          FindBySecretHash.model(data, components)
-        end
-
-        def self.perform(
-          components,
-          payable:, expires_in:, description: nil, amount: nil,
-          preview: false, &vcr
-        )
-          grpc_request = prepare(
-            description: description,
-            amount: amount,
-            expires_in: expires_in,
-            payable: payable
-          )
-
-          return grpc_request if preview
-
-          response = dispatch(components, grpc_request, &vcr)
-
-          adapted = adapt(response)
-
-          data = fetch(components, adapted, &vcr)
-          model = self.model(data, components)
-
-          Action::Output.new({ request: grpc_request, response: response, result: model })
-        end
-      end
-    end
-  end
-end

data/controllers/invoice/actions/pay.rb

@@ -1,95 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../ports/grpc'
-require_relative '../../../models/errors'
-require_relative '../../../models/edges/payment'
-require_relative '../../../adapters/edges/payment'
-require_relative '../../invoice'
-require_relative '../../action'
-require_relative '../../node/myself'
-
-require_relative '../../payment/actions/pay'
-
-module Lighstorm
-  module Controllers
-    module Invoice
-      module Pay
-        def self.dispatch(components, grpc_request, &vcr)
-          Payment::Pay.dispatch(components, grpc_request, &vcr)
-        end
-
-        def self.fetch(components, code, &vcr)
-          Payment::Pay.fetch(components, code, &vcr)
-        end
-
-        def self.adapt(data, node_get_info)
-          Payment::Pay.adapt(data, node_get_info)
-        end
-
-        def self.model(data, components)
-          Payment::Pay.model(data, components)
-        end
-
-        def self.prepare(code:, times_out_in:, amount: nil, fee: nil, message: nil)
-          request = {
-            service: :router,
-            method: :send_payment_v2,
-            params: {
-              payment_request: code,
-              timeout_seconds: Helpers::TimeExpression.seconds(times_out_in),
-              allow_self_payment: true,
-              dest_custom_records: {}
-            }
-          }
-
-          request[:params][:amt_msat] = amount[:millisatoshis] unless amount.nil?
-
-          unless fee.nil? || fee[:maximum].nil? || fee[:maximum][:millisatoshis].nil?
-            request[:params][:fee_limit_msat] = fee[:maximum][:millisatoshis]
-          end
-
-          if !message.nil? && !message.empty?
-            # https://github.com/satoshisstream/satoshis.stream/blob/main/TLV_registry.md
-            request[:params][:dest_custom_records][34_349_334] = message
-          end
-
-          request[:params].delete(:dest_custom_records) if request[:params][:dest_custom_records].empty?
-
-          request
-        end
-
-        def self.perform(
-          components,
-          times_out_in:, code:,
-          amount: nil, fee: nil,
-          message: nil,
-          preview: false, &vcr
-        )
-          grpc_request = prepare(
-            code: code,
-            amount: amount,
-            fee: fee,
-            message: message,
-            times_out_in: times_out_in
-          )
-
-          return grpc_request if preview
-
-          response = dispatch(components, grpc_request, &vcr)
-
-          Payment::Pay.raise_error_if_exists!(grpc_request, response)
-
-          data = fetch(components, code, &vcr)
-
-          adapted = adapt(response, data)
-
-          model = self.model(adapted, components)
-
-          Payment::Pay.raise_failure_if_exists!(model, grpc_request, response)
-
-          Action::Output.new({ request: grpc_request, response: response[:response], result: model })
-        end
-      end
-    end
-  end
-end

data/controllers/invoice/actions/pay_through_route.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../ports/grpc'
-require_relative '../../../models/errors'
-
-module Lighstorm
-  module Controllers
-    module Invoice
-      module PayThroughRoute
-        def self.perform(components, _invoice, route:, preview: false, fake: false)
-          raise Errors::ToDoError, self
-
-          channels = route.map do |channel_id|
-            Channel.find_by_id(channel_id, components)
-          end
-
-          outgoing_channel_id = channels.first.id
-
-          hops_public_keys = []
-
-          hops_public_keys << if channels.first.mine?
-                                channels.first.partner.node.public_key
-                              else
-                                channels.first.partners.last.node.public_key
-                              end
-
-          channels[1..channels.size - 2].each do |channel|
-            hops_public_keys << channel.partners.last.node.public_key
-          end
-
-          hops_public_keys << if channels.last.mine?
-                                channels.last.myself.node.public_key
-                              else
-                                channels.last.partners.last.node.public_key
-                              end
-          begin
-            route = LND.instance.middleware('router.build_route') do
-              LND.instance.client.router.build_route(
-                amt_msat: amount.millisatoshis,
-                outgoing_chan_id: channels.first.id.to_i,
-                hop_pubkeys: hops_public_keys.map { |hpk| [hpk].pack('H*') },
-                payment_addr: [address].pack('H*')
-              )
-            end
-
-            if preview
-              return {
-                method: :send_to_route_v2,
-                params: {
-                  payment_hash: hash,
-                  route: route.to_h[:route],
-                  skip_temp_err: true
-                }
-              }
-            end
-
-            LND.instance.middleware('router.send_to_route_v2') do
-              LND.instance.client.router.send_to_route_v2(
-                payment_hash: [hash].pack('H*'),
-                route: route.to_h[:route],
-                skip_temp_err: true
-              )
-            end
-          rescue StandardError => e
-            e
-          end
-        end
-      end
-    end
-  end
-end

data/controllers/invoice/all.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/invoice'
-require_relative '../../models/invoice'
-
-module Lighstorm
-  module Controllers
-    module Invoice
-      module All
-        def self.fetch(components, limit: nil, spontaneous: false)
-          at = Time.now
-
-          last_offset = 0
-
-          invoices = []
-
-          loop do
-            response = components[:grpc].lightning.list_invoices(
-              index_offset: last_offset,
-              num_max_invoices: 10
-            )
-
-            response.invoices.each do |invoice|
-              invoices << invoice.to_h if spontaneous || !invoice.payment_request.empty?
-            end
-
-            # TODO: How to optimize this?
-            # break if !limit.nil? && invoices.size >= limit
-
-            break if last_offset == response.last_index_offset || last_offset > response.last_index_offset
-
-            last_offset = response.last_index_offset
-          end
-
-          invoices = invoices.sort_by { |raw_invoice| -raw_invoice[:creation_date] }
-
-          invoices = invoices[0..limit - 1] unless limit.nil?
-
-          { at: at, list_invoices: invoices }
-        end
-
-        def self.adapt(raw)
-          raise 'missing at' if raw[:at].nil?
-
-          {
-            list_invoices: raw[:list_invoices].map do |raw_invoice|
-              Lighstorm::Adapter::Invoice.list_invoices(raw_invoice, raw[:at])
-            end
-          }
-        end
-
-        def self.transform(adapted)
-          adapted[:list_invoices].map do |invoice|
-            invoice[:known] = true
-            invoice
-          end
-        end
-
-        def self.data(components, limit: nil, spontaneous: false, &vcr)
-          raw = if vcr.nil?
-                  fetch(components, limit: limit, spontaneous: spontaneous)
-                else
-                  vcr.call(-> { fetch(components, limit: limit, spontaneous: spontaneous) })
-                end
-
-          adapted = adapt(raw)
-
-          transform(adapted)
-        end
-
-        def self.model(data, components)
-          data.map do |node_data|
-            Lighstorm::Models::Invoice.new(node_data, components)
-          end
-        end
-      end
-    end
-  end
-end