lighstorm 0.0.15 → 0.0.16

data/controllers/channel/actions/apply_gossip.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-require_relative '../../../models/errors'
-require_relative '../../../models/edges/channel'
-require_relative '../../../adapters/edges/channel'
-
-module Lighstorm
-  module Controllers
-    module Channel
-      module ApplyGossip
-        SKIPABLE = [
-          '_key',
-          '_source',
-          'partners/0/_source',
-          'partners/0/policy/_source',
-          'partners/1/_source',
-          'partners/1/policy/_source'
-        ].freeze
-
-        NOT_ALLOWED = [
-          'id'
-        ].freeze
-
-        APPLICABLE = [
-          'accounting/capacity/millisatoshis',
-          'partners/0/policy/fee/base/millisatoshis',
-          'partners/0/state',
-          'partners/1/policy/fee/base/millisatoshis',
-          'partners/1/state',
-          'partners/1/policy/fee/rate/parts_per_million',
-          'partners/0/policy/fee/rate/parts_per_million',
-          'partners/0/policy/htlc/minimum/millisatoshis',
-          'partners/1/policy/htlc/minimum/millisatoshis',
-          'partners/0/policy/htlc/maximum/millisatoshis',
-          'partners/1/policy/htlc/maximum/millisatoshis',
-          'partners/0/policy/htlc/blocks/delta/minimum',
-          'partners/1/policy/htlc/blocks/delta/minimum'
-        ].freeze
-
-        def self.perform(actual, gossip)
-          updated = Models::Channel.new(Adapter::Channel.subscribe_channel_graph(gossip), nil)
-
-          actual_dump = actual.dump
-          updated_dump = updated.dump
-
-          if actual.partners.first.node.public_key == updated.partners.last.node.public_key &&
-             actual.partners.last.node.public_key == updated.partners.first.node.public_key
-            a = updated_dump[:partners][0]
-            b = updated_dump[:partners][1]
-
-            updated_dump[:partners][0] = b
-            updated_dump[:partners][1] = a
-          end
-
-          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 Channel"
-          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 'accounting/capacity/millisatoshis'
-            token = SecureRandom.hex
-            actual.accounting.prepare_token!(token)
-            actual.accounting.capacity = {
-              value: Models::Satoshis.new(millisatoshis: change[:to]),
-              token: token
-            }
-          when 'partners/0/policy/htlc/maximum/millisatoshis',
-                 'partners/1/policy/htlc/maximum/millisatoshis' then
-            policy = actual.partners[change[:path][1]].policy
-
-            token = SecureRandom.hex
-            policy.htlc.prepare_token!(token)
-            policy.htlc.maximum = {
-              value: Models::Satoshis.new(millisatoshis: change[:to]),
-              token: token
-            }
-          when 'partners/0/policy/htlc/minimum/millisatoshis',
-                 'partners/1/policy/htlc/minimum/millisatoshis' then
-            if actual.partners[change[:path][1]].policy.nil?
-              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({}, nil)
-            end
-
-            policy = actual.partners[change[:path][1]].policy
-
-            token = SecureRandom.hex
-            policy.htlc.prepare_token!(token)
-            policy.htlc.minimum = {
-              value: Models::Satoshis.new(millisatoshis: change[:to]),
-              token: token
-            }
-          when 'partners/0/policy/htlc/blocks/delta/minimum',
-                'partners/1/policy/htlc/blocks/delta/minimum' then
-            if actual.partners[change[:path][1]].policy.nil?
-              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({}, nil)
-            end
-
-            policy = actual.partners[change[:path][1]].policy
-
-            token = SecureRandom.hex
-            policy.htlc.blocks.delta.prepare_token!(token)
-            policy.htlc.blocks.delta.minimum = {
-              value: change[:to],
-              token: token
-            }
-          when 'partners/0/policy/fee/rate/parts_per_million',
-                 'partners/1/policy/fee/rate/parts_per_million' then
-            policy = actual.partners[change[:path][1]].policy
-
-            token = SecureRandom.hex
-            policy.fee.prepare_token!(token)
-            policy.fee.rate = {
-              value: Models::Rate.new(parts_per_million: change[:to]),
-              token: token
-            }
-          when 'partners/0/policy/fee/base/millisatoshis',
-                 'partners/1/policy/fee/base/millisatoshis' then
-            policy = actual.partners[change[:path][1]].policy
-
-            token = SecureRandom.hex
-            policy.fee.prepare_token!(token)
-            policy.fee.base = {
-              value: Models::Satoshis.new(millisatoshis: change[:to]),
-              token: token
-            }
-          when 'partners/0/state',
-               'partners/1/state' then
-            partner = actual.partners[change[:path][1]]
-
-            token = SecureRandom.hex
-            partner.prepare_token!(token)
-            partner.state = { 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/channel/actions/update_fee.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../../ports/grpc'
-require_relative '../../../models/errors'
-require_relative '../../../models/satoshis'
-require_relative '../../../models/rate'
-require_relative '../../action'
-
-module Lighstorm
-  module Controllers
-    module Channel
-      module UpdateFee
-        def self.prepare(policy, transaction, params)
-          grpc_request = {
-            service: :lightning,
-            method: :update_channel_policy,
-            params: {
-              chan_point: {
-                funding_txid_str: transaction[:funding][:id],
-                output_index: transaction[:funding][:index]
-              },
-              base_fee_msat: policy[:fee][:base][:millisatoshis],
-              fee_rate_ppm: policy[:fee][:rate][:parts_per_million],
-              time_lock_delta: policy[:htlc][:blocks][:delta][:minimum],
-              max_htlc_msat: policy[:htlc][:maximum][:millisatoshis],
-              min_htlc_msat: policy[:htlc][:minimum][:millisatoshis]
-            }
-          }
-
-          if params[:rate] && params[:rate][:parts_per_million]
-            if (params[:rate][:parts_per_million]).negative?
-              raise Errors::NegativeNotAllowedError, "fee rate can't be negative: #{params[:rate][:parts_per_million]}"
-            end
-
-            grpc_request[:params][:fee_rate_ppm] = params[:rate][:parts_per_million]
-          end
-
-          if params[:base] && params[:base][:millisatoshis]
-            if (params[:base][:millisatoshis]).negative?
-              raise Errors::NegativeNotAllowedError, "fee base can't be negative: #{params[:base][:millisatoshis]}"
-            end
-
-            grpc_request[:params][:base_fee_msat] = params[:base][:millisatoshis]
-          end
-
-          grpc_request
-        end
-
-        def self.call(components, grpc_request)
-          components[:grpc].send(grpc_request[:service]).send(
-            grpc_request[:method], grpc_request[:params]
-          ).to_h
-        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.perform(components, policy, transaction, params, preview: false, &vcr)
-          grpc_request = prepare(policy.to_h, transaction.to_h, params)
-
-          return grpc_request if preview
-
-          response = dispatch(components, grpc_request, &vcr)
-
-          raise UpdateChannelPolicyError.new(nil, response) unless response[:failed_updates].empty?
-
-          token = SecureRandom.hex
-          policy.fee.prepare_token!(token)
-          policy.fee.base = {
-            value: Models::Satoshis.new(millisatoshis: grpc_request[:params][:base_fee_msat]),
-            token: token
-          }
-
-          token = SecureRandom.hex
-          policy.fee.prepare_token!(token)
-          policy.fee.rate = {
-            value: Models::Rate.new(parts_per_million: grpc_request[:params][:fee_rate_ppm]),
-            token: token
-          }
-
-          Action::Output.new({ request: grpc_request, response: response, result: policy })
-        end
-      end
-    end
-  end
-end

data/controllers/channel/all.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'mine'
-
-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 All
-        def self.fetch(components, limit: nil)
-          data = {
-            at: Time.now,
-            mine: Mine.fetch(components),
-            describe_graph: components[:grpc].lightning.describe_graph.edges
-          }
-
-          data[:describe_graph] = data[:describe_graph][0..limit - 1] unless limit.nil?
-
-          data
-        end
-
-        def self.adapt(raw)
-          mine_adapted = Mine.adapt(raw[:mine])
-
-          mine = mine_adapted[:list_channels].map do |data|
-            Mine.transform(data, mine_adapted)
-          end
-
-          adapted = {
-            mine: {},
-            describe_graph: raw[:describe_graph].map do |raw_channel|
-              Lighstorm::Adapter::Channel.describe_graph(raw_channel.to_h)
-            end
-          }
-
-          mine.each do |channel|
-            adapted[:mine][channel[:id]] = channel
-          end
-
-          adapted
-        end
-
-        def self.transform(data, adapted)
-          return adapted[:mine][data[:id]] if adapted[:mine][data[:id]]
-
-          data[:known] = true
-          data[:mine] = false
-
-          data[:partners].each do |partner|
-            partner[:node][:platform] = {
-              blockchain: adapted[:mine].first[1][:partners][0][:node][:platform][:blockchain],
-              network: adapted[:mine].first[1][:partners][0][:node][:platform][:network]
-            }
-          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[:describe_graph].map { |data| transform(data, adapted) }
-        end
-
-        def self.model(data, components)
-          data.map do |node_data|
-            Lighstorm::Models::Channel.new(node_data, components)
-          end
-        end
-      end
-    end
-  end
-end

data/controllers/channel/find_by_id.rb

@@ -1,153 +0,0 @@
-# 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(components, id)
-          data = {
-            at: Time.now,
-            get_info: components[:grpc].lightning.get_info.to_h,
-            # Ensure that we are getting fresh up-date data about our own fees.
-            fee_report: components[:grpc].lightning.fee_report.to_h,
-            get_chan_info: components[: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]] = components[: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]] = components[: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] = components[: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].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(components, id, &vcr)
-          raw = vcr.nil? ? fetch(components, id) : vcr.call(-> { fetch(components, id) })
-
-          adapted = adapt(raw)
-
-          transform(adapted[:get_chan_info], adapted)
-        end
-
-        def self.model(data, components)
-          Lighstorm::Models::Channel.new(data, components)
-        end
-      end
-    end
-  end
-end

data/controllers/channel/mine.rb

@@ -1,114 +0,0 @@
-# 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(components)
-          data = {
-            at: Time.now,
-            get_info: components[:grpc].lightning.get_info.to_h,
-            # Ensure that we are getting fresh up-date data about our own fees.
-            fee_report: components[:grpc].lightning.fee_report.to_h,
-            list_channels: components[: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]] = components[: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]] = 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]),
-            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].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(components, &vcr)
-          raw = vcr.nil? ? fetch(components) : vcr.call(-> { fetch(components) })
-
-          adapted = adapt(raw)
-
-          adapted[:list_channels].map { |data| transform(data, adapted) }
-        end
-
-        def self.model(data, components)
-          data.map do |node_data|
-            Lighstorm::Models::Channel.new(node_data, components)
-          end
-        end
-      end
-    end
-  end
-end

data/controllers/channel.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './concerns/impersonatable'
-
-require_relative './channel/mine'
-require_relative './channel/all'
-require_relative './channel/find_by_id'
-
-module Lighstorm
-  module Controllers
-    module Channel
-      extend Impersonatable
-
-      class DSL < Impersonatable::DSL
-        def mine(injected_components = nil)
-          if injected_components.nil?
-            Mine.model(Mine.data(components), components)
-          else
-            Mine.model(Mine.data(injected_components), injected_components)
-          end
-        end
-
-        def all(limit: nil)
-          All.model(All.data(components, limit: limit), components)
-        end
-
-        def find_by_id(id, injected_components = nil)
-          if injected_components.nil?
-            FindById.model(FindById.data(components, id), components)
-          else
-            FindById.model(FindById.data(injected_components, id), injected_components)
-          end
-        end
-
-        def adapt(dump: nil, gossip: nil)
-          Models::Channel.adapt(dump: dump, gossip: gossip)
-        end
-      end
-    end
-  end
-end