lighstorm 0.0.15 → 0.0.16

data/controllers/lightning/channel/actions/apply_gossip.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative '../../../../models/errors'
+require_relative '../../../../models/lightning/edges/channel'
+require_relative '../../../../adapters/lightning/edges/channel'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      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 = Model::Lightning::Channel.new(
+              Adapter::Lightning::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: Model::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: Model::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::Lightning::Model::Policy.new(
+                  {}, nil
+                )
+              end
+
+              policy = actual.partners[change[:path][1]].policy
+
+              token = SecureRandom.hex
+              policy.htlc.prepare_token!(token)
+              policy.htlc.minimum = {
+                value: Model::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::Lightning::Model::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: Model::Lightning::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: Model::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
+end

data/controllers/lightning/channel/actions/update_fee.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative '../../../../ports/grpc'
+require_relative '../../../../models/errors'
+require_relative '../../../../models/satoshis'
+require_relative '../../../../models/lightning/rate'
+require_relative '../../../action'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      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: Model::Satoshis.new(millisatoshis: grpc_request[:params][:base_fee_msat]),
+              token: token
+            }
+
+            token = SecureRandom.hex
+            policy.fee.prepare_token!(token)
+            policy.fee.rate = {
+              value: Model::Lightning::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
+end

data/controllers/lightning/channel/all.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative 'mine'
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/edges/channel'
+require_relative '../../../adapters/lightning/nodes/node'
+require_relative '../../../adapters/lightning/connections/channel_node/fee'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      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::Lightning::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::Model::Lightning::Channel.new(node_data, components)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/channel/find_by_id.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/edges/channel'
+require_relative '../../../adapters/lightning/nodes/node'
+require_relative '../../../adapters/lightning/connections/channel_node/fee'
+
+require_relative '../node/find_by_public_key'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      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::Lightning::Node.get_info(raw[:get_info]),
+              get_chan_info: Lighstorm::Adapter::Lightning::Channel.get_chan_info(raw[:get_chan_info]),
+              fee_report: raw[:fee_report][:channel_fees].map do |raw_fee|
+                Lighstorm::Adapter::Lightning::Fee.fee_report(raw_fee.to_h)
+              end,
+              list_channels: raw[:list_channels].map do |raw_channel|
+                Lighstorm::Adapter::Lightning::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::Lightning::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::Model::Lightning::Channel.new(data, components)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/channel/mine.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/edges/channel'
+require_relative '../../../adapters/lightning/nodes/node'
+require_relative '../../../adapters/lightning/connections/channel_node/fee'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      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::Lightning::Node.get_info(raw[:get_info]),
+              fee_report: raw[:fee_report][:channel_fees].map do |raw_fee|
+                Lighstorm::Adapter::Lightning::Fee.fee_report(raw_fee.to_h)
+              end,
+              list_channels: raw[:list_channels].map do |raw_channel|
+                Lighstorm::Adapter::Lightning::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::Lightning::Channel.get_chan_info(value.to_h)
+            end
+
+            raw[:get_node_info].each do |key, value|
+              adapted[:get_node_info][key] = Lighstorm::Adapter::Lightning::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::Model::Lightning::Channel.new(node_data, components)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/channel.rb

@@ -0,0 +1,43 @@
+# 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 Controller
+    module Lightning
+      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)
+            Model::Lightning::Channel.adapt(dump: dump, gossip: gossip)
+          end
+        end
+      end
+    end
+  end
+end