lighstorm 0.0.4 → 0.0.6

data/controllers/channel/actions/apply_gossip.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative '../../../ports/grpc'
+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/milisatoshis',
+          'partners/0/policy/fee/base/milisatoshis',
+          'partners/0/state',
+          'partners/1/policy/fee/base/milisatoshis',
+          'partners/1/state',
+          'partners/1/policy/fee/rate/parts_per_million',
+          'partners/0/policy/fee/rate/parts_per_million',
+          'partners/0/policy/htlc/minimum/milisatoshis',
+          'partners/1/policy/htlc/minimum/milisatoshis',
+          'partners/0/policy/htlc/maximum/milisatoshis',
+          'partners/1/policy/htlc/maximum/milisatoshis',
+          '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))
+
+          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/milisatoshis'
+            token = SecureRandom.hex
+            actual.accounting.prepare_token!(token)
+            actual.accounting.capacity = {
+              value: Models::Satoshis.new(milisatoshis: change[:to]),
+              token: token
+            }
+          when 'partners/0/policy/htlc/maximum/milisatoshis',
+                 'partners/1/policy/htlc/maximum/milisatoshis' then
+            policy = actual.partners[change[:path][1]].policy
+
+            token = SecureRandom.hex
+            policy.htlc.prepare_token!(token)
+            policy.htlc.maximum = {
+              value: Models::Satoshis.new(milisatoshis: change[:to]),
+              token: token
+            }
+          when 'partners/0/policy/htlc/minimum/milisatoshis',
+                 'partners/1/policy/htlc/minimum/milisatoshis' then
+            if actual.partners[change[:path][1]].policy.nil?
+              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({})
+            end
+
+            policy = actual.partners[change[:path][1]].policy
+
+            token = SecureRandom.hex
+            policy.htlc.prepare_token!(token)
+            policy.htlc.minimum = {
+              value: Models::Satoshis.new(milisatoshis: 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({})
+            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/milisatoshis',
+                 'partners/1/policy/fee/base/milisatoshis' then
+            policy = actual.partners[change[:path][1]].policy
+
+            token = SecureRandom.hex
+            policy.fee.prepare_token!(token)
+            policy.fee.base = {
+              value: Models::Satoshis.new(milisatoshis: 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/find_by_id.rb

@@ -73,7 +73,7 @@ module Lighstorm
         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?
+              if adapted[:list_channels][c][:partners][i][:node].nil?
                 adapted[:list_channels][c][:partners][i][:node] = adapted[:get_info]
               end
             end

data/controllers/channel/mine.rb

@@ -63,7 +63,7 @@ module Lighstorm
 
         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?
+            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/controllers/channel.rb

@@ -18,6 +18,10 @@ module Lighstorm
       def self.find_by_id(id)
         FindById.model(FindById.data(id))
       end
+
+      def self.adapt(dump: nil, gossip: nil)
+        Models::Channel.adapt(dump: dump, gossip: gossip)
+      end
     end
   end
 end

data/controllers/invoice/actions/create.rb

@@ -2,14 +2,13 @@
 
 require_relative '../../../ports/grpc'
 require_relative '../../../models/errors'
+require_relative '../../invoice'
 
 module Lighstorm
   module Controllers
     module Invoice
       module Create
-        def self.perform(description: nil, milisatoshis: nil, preview: false, fake: false)
-          raise Errors::ToDoError, self
-
+        def self.perform(description: nil, milisatoshis: nil, preview: false, fake: nil)
           grpc_request = {
             service: :lightning,
             method: :add_invoice,
@@ -22,13 +21,15 @@ module Lighstorm
           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
+          response = if fake.nil?
+                       LND.instance.middleware("lightning.#{grpc_request[:method]}") do
+                         LND.instance.client.lightning.send(grpc_request[:method], grpc_request[:params])
+                       end.to_h
+                     else
+                       fake
+                     end
 
-          # TODO
-          # find_by_secret_hash(invoice.r_hash.unpack1('H*'))
-          # response
+          Invoice.find_by_secret_hash(response[:r_hash].unpack1('H*'))
         end
       end
     end

data/controllers/invoice.rb

@@ -23,7 +23,7 @@ module Lighstorm
         FindBySecretHash.model(FindBySecretHash.data(secret_hash))
       end
 
-      def self.create(description: nil, milisatoshis: nil, preview: false, fake: false)
+      def self.create(description: nil, milisatoshis: nil, preview: false, fake: nil)
         Create.perform(
           description: description,
           milisatoshis: milisatoshis,

data/controllers/node/actions/apply_gossip.rb

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

data/controllers/node.rb

@@ -18,6 +18,10 @@ module Lighstorm
       def self.find_by_public_key(public_key)
         FindByPublicKey.model(FindByPublicKey.data(public_key))
       end
+
+      def self.adapt(dump: nil, gossip: nil)
+        Models::Node.adapt(dump: dump, gossip: gossip)
+      end
     end
   end
 end

data/controllers/payment/all.rb

@@ -12,16 +12,19 @@ module Lighstorm
   module Controllers
     module Payment
       module All
-        def self.fetch(purpose: nil, limit: nil)
+        def self.fetch(purpose: nil, limit: nil, fetch: {})
           at = Time.now
-          get_info = Ports::GRPC.lightning.get_info.to_h
+
+          grpc = Ports::GRPC.session
+
+          get_info = grpc.lightning.get_info.to_h
 
           last_offset = 0
 
           payments = []
 
           loop do
-            response = Ports::GRPC.lightning.list_payments(
+            response = grpc.lightning.list_payments(
               index_offset: last_offset
             )
 
@@ -64,8 +67,8 @@ module Lighstorm
 
           data = {
             at: at,
-            get_info: Ports::GRPC.lightning.get_info.to_h,
-            fee_report: Ports::GRPC.lightning.fee_report.to_h,
+            get_info: get_info,
+            fee_report: grpc.lightning.fee_report.to_h,
             list_payments: payments,
             list_channels: {},
             get_chan_info: {},
@@ -75,15 +78,15 @@ module Lighstorm
           }
 
           payments.each do |payment|
-            unless payment[:payment_request] == '' || data[:decode_pay_req][payment[:payment_request]]
-              data[:decode_pay_req][payment[:payment_request]] = Ports::GRPC.lightning.decode_pay_req(
+            unless fetch[:decode_pay_req] == false || payment[:payment_request] == '' || data[:decode_pay_req][payment[:payment_request]]
+              data[:decode_pay_req][payment[:payment_request]] = grpc.lightning.decode_pay_req(
                 pay_req: payment[:payment_request]
               ).to_h
             end
 
-            unless data[:lookup_invoice][payment[:payment_hash]]
+            unless fetch[:lookup_invoice] == false || data[:lookup_invoice][payment[:payment_hash]]
               begin
-                data[:lookup_invoice][payment[:payment_hash]] = Ports::GRPC.lightning.lookup_invoice(
+                data[:lookup_invoice][payment[:payment_hash]] = grpc.lightning.lookup_invoice(
                   r_hash_str: payment[:payment_hash]
                 ).to_h
               rescue StandardError => e
@@ -93,9 +96,9 @@ module Lighstorm
 
             payment[:htlcs].each do |htlc|
               htlc[:route][:hops].each do |hop|
-                unless data[:get_chan_info][hop[:chan_id]]
+                unless fetch[:get_chan_info] == false || data[:get_chan_info][hop[:chan_id]]
                   begin
-                    data[:get_chan_info][hop[:chan_id]] = Ports::GRPC.lightning.get_chan_info(
+                    data[:get_chan_info][hop[:chan_id]] = grpc.lightning.get_chan_info(
                       chan_id: hop[:chan_id]
                     ).to_h
                   rescue GRPC::Unknown => e
@@ -103,23 +106,25 @@ module Lighstorm
                   end
                 end
 
-                next if data[:get_node_info][hop[:pub_key]]
+                next if fetch[:get_node_info] == false || data[:get_node_info][hop[:pub_key]]
 
-                data[:get_node_info][hop[:pub_key]] = Ports::GRPC.lightning.get_node_info(
+                data[:get_node_info][hop[:pub_key]] = grpc.lightning.get_node_info(
                   pub_key: hop[:pub_key]
                 ).to_h
               end
             end
           end
 
-          data[:lookup_invoice].each_value do |invoice|
-            if invoice[:_error] || invoice[:payment_request] == '' || data[:decode_pay_req][invoice[:payment_request]]
-              next
-            end
+          if fetch[:lookup_invoice] != false
+            data[:lookup_invoice].each_value do |invoice|
+              if fetch[:decode_pay_req] == false || invoice[:_error] || invoice[:payment_request] == '' || data[:decode_pay_req][invoice[:payment_request]]
+                next
+              end
 
-            data[:decode_pay_req][invoice[:payment_request]] = Ports::GRPC.lightning.decode_pay_req(
-              pay_req: invoice[:payment_request]
-            ).to_h
+              data[:decode_pay_req][invoice[:payment_request]] = grpc.lightning.decode_pay_req(
+                pay_req: invoice[:payment_request]
+              ).to_h
+            end
           end
 
           list_channels_done = {}
@@ -135,7 +140,7 @@ module Lighstorm
               partner = partners.find { |p| p != data[:get_info][:identity_pubkey] }
 
               unless list_channels_done[partner]
-                Ports::GRPC.lightning.list_channels(
+                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
@@ -145,27 +150,29 @@ module Lighstorm
               end
             end
 
-            unless data[:get_node_info][channel[:node1_pub]]
-              data[:get_node_info][channel[:node1_pub]] = Ports::GRPC.lightning.get_node_info(
+            unless fetch[:get_node_info] == false || data[:get_node_info][channel[:node1_pub]]
+              data[:get_node_info][channel[:node1_pub]] = grpc.lightning.get_node_info(
                 pub_key: channel[:node1_pub]
               ).to_h
             end
 
-            next if data[:get_node_info][channel[:node2_pub]]
+            next if fetch[:get_node_info] == false || data[:get_node_info][channel[:node2_pub]]
 
-            data[:get_node_info][channel[:node2_pub]] = Ports::GRPC.lightning.get_node_info(
+            data[:get_node_info][channel[:node2_pub]] = grpc.lightning.get_node_info(
               pub_key: channel[:node2_pub]
             ).to_h
           end
 
           data[:list_channels].each_value do |channel|
-            next if data[:get_node_info][channel[:remote_pubkey]]
+            next if fetch[:get_node_info] == false || data[:get_node_info][channel[:remote_pubkey]]
 
-            data[:get_node_info][channel[:remote_pubkey]] = Ports::GRPC.lightning.get_node_info(
+            data[:get_node_info][channel[:remote_pubkey]] = grpc.lightning.get_node_info(
               pub_key: channel[:remote_pubkey]
             ).to_h
           end
 
+          data[:@meta] = { calls: grpc.calls }
+
           data
         end
 
@@ -256,11 +263,17 @@ module Lighstorm
               adapted[:fee_report].each do |channel|
                 next unless data[:id] == channel[:id]
 
-                data[:partners][i][:policy][:fee] = channel[:partner][:policy][:fee]
+                if data[:partners][i][:policy].nil?
+                  data[:partners][i][:policy] = channel[:partner][:policy]
+                else
+                  data[:partners][i][:policy][:fee] = channel[:partner][:policy][:fee]
+                end
                 break
               end
             else
-              data[:partners][i][:node] = adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+              if adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+                data[:partners][i][:node] = adapted[:get_node_info][data[:partners][i][:node][:public_key]]
+              end
               data[:partners][i][:node][:platform] = {
                 blockchain: adapted[:get_info][:platform][:blockchain],
                 network: adapted[:get_info][:platform][:network]
@@ -327,22 +340,25 @@ module Lighstorm
           list_payments
         end
 
-        def self.data(purpose: nil, limit: nil, &vcr)
+        def self.data(purpose: nil, limit: nil, fetch: {}, &vcr)
           raw = if vcr.nil?
-                  fetch(purpose: purpose, limit: limit)
+                  self.fetch(purpose: purpose, limit: limit, fetch: fetch)
                 else
-                  vcr.call(-> { fetch(purpose: purpose, limit: limit) })
+                  vcr.call(-> { self.fetch(purpose: purpose, limit: limit, fetch: fetch) })
                 end
 
           adapted = adapt(raw)
 
-          adapted[:list_payments].map do |data|
-            transform(data, adapted)
-          end
+          {
+            data: adapted[:list_payments].map do |data|
+              transform(data, adapted)
+            end,
+            meta: raw[:@meta]
+          }
         end
 
         def self.model(data)
-          data.map do |node_data|
+          data[:data].map do |node_data|
             Lighstorm::Models::Payment.new(node_data)
           end
         end

data/controllers/payment.rb

@@ -5,16 +5,16 @@ require_relative './payment/all'
 module Lighstorm
   module Controllers
     module Payment
-      def self.all(purpose: nil, limit: nil)
-        All.model(All.data(purpose: purpose, limit: limit))
+      def self.all(purpose: nil, limit: nil, fetch: {})
+        All.model(All.data(purpose: purpose, limit: limit, fetch: fetch))
       end
 
-      def self.first(purpose: nil)
-        All.model(All.data(purpose: purpose)).first
+      def self.first(purpose: nil, fetch: {})
+        All.model(All.data(purpose: purpose, fetch: fetch)).first
       end
 
-      def self.last(purpose: nil)
-        All.model(All.data(purpose: purpose)).last
+      def self.last(purpose: nil, fetch: {})
+        All.model(All.data(purpose: purpose, fetch: fetch)).last
       end
     end
   end