lighstorm 0.0.13 → 0.0.15

data/controllers/channel/mine.rb

@@ -9,27 +9,27 @@ module Lighstorm
   module Controllers
     module Channel
       module Mine
-        def self.fetch
+        def self.fetch(components)
           data = {
             at: Time.now,
-            get_info: Ports::GRPC.lightning.get_info.to_h,
+            get_info: components[:grpc].lightning.get_info.to_h,
             # Ensure that we are getting fresh up-date data about our own fees.
-            fee_report: Ports::GRPC.lightning.fee_report.to_h,
-            list_channels: Ports::GRPC.lightning.list_channels.channels.map(&:to_h),
+            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]] = Ports::GRPC.lightning.get_chan_info(
+              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]] = Ports::GRPC.lightning.get_node_info(
+            data[:get_node_info][channel[:remote_pubkey]] = components[:grpc].lightning.get_node_info(
               pub_key: channel[:remote_pubkey]
             ).to_h
           end
@@ -95,17 +95,17 @@ module Lighstorm
           data
         end
 
-        def self.data(&vcr)
-          raw = vcr.nil? ? fetch : vcr.call(-> { fetch })
+        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)
+        def self.model(data, components)
           data.map do |node_data|
-            Lighstorm::Models::Channel.new(node_data)
+            Lighstorm::Models::Channel.new(node_data, components)
           end
         end
       end

data/controllers/channel.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative './concerns/impersonatable'
+
 require_relative './channel/mine'
 require_relative './channel/all'
 require_relative './channel/find_by_id'
@@ -7,20 +9,32 @@ require_relative './channel/find_by_id'
 module Lighstorm
   module Controllers
     module Channel
-      def self.mine
-        Mine.model(Mine.data)
-      end
+      extend Impersonatable
 
-      def self.all(limit: nil)
-        All.model(All.data(limit: limit))
-      end
+      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 self.find_by_id(id)
-        FindById.model(FindById.data(id))
-      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 self.adapt(dump: nil, gossip: nil)
-        Models::Channel.adapt(dump: dump, gossip: gossip)
+        def adapt(dump: nil, gossip: nil)
+          Models::Channel.adapt(dump: dump, gossip: gossip)
+        end
       end
     end
   end

data/controllers/concerns/impersonatable.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+
+module Lighstorm
+  module Controllers
+    module Impersonatable
+      class DSL
+        attr_reader :components
+
+        def initialize(components = nil)
+          @components = components.nil? ? { grpc: Ports::GRPC } : components
+        end
+      end
+
+      def as(id)
+        self::DSL.new({ grpc: Ports::GRPC::Impersonatable.new(id) })
+      end
+
+      def method_missing(method_name, *args, &block)
+        if args.size == 1 && args.first.is_a?(Hash)
+          self::DSL.new.send(method_name, **args.first, &block)
+        else
+          self::DSL.new.send(method_name, *args, &block)
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        self::DSL.method_defined?(method_name) || super
+      end
+    end
+  end
+end

data/controllers/connection.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative './concerns/impersonatable'
+
+module Lighstorm
+  module Controllers
+    module Connection
+      def self.connect!(...)
+        LND.instance.connect!(...)
+      end
+
+      def self.add!(...)
+        LND.instance.add_connection!(...)
+      end
+
+      def self.all(...)
+        LND.instance.connections(...)
+      end
+
+      def self.default(...)
+        LND.instance.default(...)
+      end
+
+      def self.for(...)
+        LND.instance.for(...)
+      end
+
+      def self.remove!(...)
+        LND.instance.remove_connection!(...)
+      end
+    end
+  end
+end

data/controllers/forward/all.rb

@@ -14,7 +14,7 @@ module Lighstorm
   module Controllers
     module Forward
       module All
-        def self.fetch(limit: nil)
+        def self.fetch(components, limit: nil)
           at = Time.now
 
           last_offset = 0
@@ -22,7 +22,7 @@ module Lighstorm
           forwards = []
 
           loop do
-            response = Ports::GRPC.lightning.forwarding_history(index_offset: last_offset)
+            response = components[:grpc].lightning.forwarding_history(index_offset: last_offset)
 
             response.forwarding_events.each { |forward| forwards << forward.to_h }
 
@@ -40,8 +40,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: components[:grpc].lightning.get_info.to_h,
+            fee_report: components[:grpc].lightning.fee_report.to_h,
             forwarding_history: forwards,
             list_channels: {},
             get_chan_info: {},
@@ -51,7 +51,7 @@ module Lighstorm
           forwards.each do |forward|
             unless data[:get_chan_info][forward[:chan_id_in]]
               begin
-                data[:get_chan_info][forward[:chan_id_in]] = Ports::GRPC.lightning.get_chan_info(
+                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
@@ -62,7 +62,7 @@ module Lighstorm
             next if data[:get_chan_info][forward[:chan_id_out]]
 
             begin
-              data[:get_chan_info][forward[:chan_id_out]] = Ports::GRPC.lightning.get_chan_info(
+              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
@@ -83,7 +83,7 @@ module Lighstorm
               partner = partners.find { |p| p != data[:get_info][:identity_pubkey] }
 
               unless list_channels_done[partner]
-                Ports::GRPC.lightning.list_channels(
+                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
@@ -94,14 +94,14 @@ module Lighstorm
             end
 
             unless data[:get_node_info][channel[:node1_pub]]
-              data[:get_node_info][channel[:node1_pub]] = Ports::GRPC.lightning.get_node_info(
+              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]] = Ports::GRPC.lightning.get_node_info(
+            data[:get_node_info][channel[:node2_pub]] = components[:grpc].lightning.get_node_info(
               pub_key: channel[:node2_pub]
             ).to_h
           end
@@ -109,7 +109,7 @@ module Lighstorm
           data[:list_channels].each_value do |channel|
             next if data[:get_node_info][channel[:remote_pubkey]]
 
-            data[:get_node_info][channel[:remote_pubkey]] = Ports::GRPC.lightning.get_node_info(
+            data[:get_node_info][channel[:remote_pubkey]] = components[:grpc].lightning.get_node_info(
               pub_key: channel[:remote_pubkey]
             ).to_h
           end
@@ -221,8 +221,12 @@ module Lighstorm
           data
         end
 
-        def self.data(limit: nil, &vcr)
-          raw = vcr.nil? ? fetch(limit: limit) : vcr.call(-> { fetch(limit: limit) })
+        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)
 

data/controllers/forward/group_by_channel.rb

@@ -67,8 +67,8 @@ module Lighstorm
                 .sort_by { |group| - group[:analysis][:count] }
         end
 
-        def self.data(direction: :out, hours_ago: nil, limit: nil, &vcr)
-          data = All.data(&vcr)
+        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)

data/controllers/forward.rb

@@ -1,27 +1,33 @@
 # frozen_string_literal: true
 
+require_relative './concerns/impersonatable'
+
 require_relative './forward/all'
 require_relative './forward/group_by_channel'
 
 module Lighstorm
   module Controllers
     module Forward
-      def self.all(limit: nil)
-        All.model(All.data(limit: limit))
-      end
+      extend Impersonatable
 
-      def self.first
-        All.model(All.data).first
-      end
+      class DSL < Impersonatable::DSL
+        def all(limit: nil)
+          All.model(All.data(components, limit: limit))
+        end
 
-      def self.last
-        All.model(All.data).last
-      end
+        def first
+          All.model(All.data(components)).first
+        end
+
+        def last
+          All.model(All.data(components)).last
+        end
 
-      def self.group_by_channel(direction: :out, hours_ago: nil, limit: nil)
-        GroupByChannel.model(
-          GroupByChannel.data(direction: direction, hours_ago: hours_ago, limit: limit)
-        )
+        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

data/controllers/invoice/actions/create.rb

@@ -10,8 +10,8 @@ module Lighstorm
   module Controllers
     module Invoice
       module Create
-        def self.call(grpc_request)
-          Lighstorm::Ports::GRPC.send(grpc_request[:service]).send(
+        def self.call(components, grpc_request)
+          components[:grpc].send(grpc_request[:service]).send(
             grpc_request[:method], grpc_request[:params]
           ).to_h
         end
@@ -39,23 +39,31 @@ module Lighstorm
           request
         end
 
-        def self.dispatch(grpc_request, &vcr)
-          vcr.nil? ? call(grpc_request) : vcr.call(-> { call(grpc_request) }, :dispatch)
+        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(adapted, &vcr)
-          FindBySecretHash.data(adapted[:secret][:hash], &vcr)
+        def self.fetch(components, adapted, &vcr)
+          FindBySecretHash.data(components, adapted[:secret][:hash], &vcr)
         end
 
-        def self.model(data)
-          FindBySecretHash.model(data)
+        def self.model(data, components)
+          FindBySecretHash.model(data, components)
         end
 
-        def self.perform(payable:, expires_in:, description: nil, amount: nil, preview: false, &vcr)
+        def self.perform(
+          components,
+          payable:, expires_in:, description: nil, amount: nil,
+          preview: false, &vcr
+        )
           grpc_request = prepare(
             description: description,
             amount: amount,
@@ -65,14 +73,14 @@ module Lighstorm
 
           return grpc_request if preview
 
-          response = dispatch(grpc_request, &vcr)
+          response = dispatch(components, grpc_request, &vcr)
 
           adapted = adapt(response)
 
-          data = fetch(adapted, &vcr)
-          model = self.model(data)
+          data = fetch(components, adapted, &vcr)
+          model = self.model(data, components)
 
-          Action::Output.new({ response: response, result: model })
+          Action::Output.new({ request: grpc_request, response: response, result: model })
         end
       end
     end

data/controllers/invoice/actions/pay.rb

@@ -14,20 +14,20 @@ module Lighstorm
   module Controllers
     module Invoice
       module Pay
-        def self.dispatch(grpc_request, &vcr)
-          Payment::Pay.dispatch(grpc_request, &vcr)
+        def self.dispatch(components, grpc_request, &vcr)
+          Payment::Pay.dispatch(components, grpc_request, &vcr)
         end
 
-        def self.fetch(code, &vcr)
-          Payment::Pay.fetch(code, &vcr)
+        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)
-          Payment::Pay.model(data)
+        def self.model(data, components)
+          Payment::Pay.model(data, components)
         end
 
         def self.prepare(code:, times_out_in:, amount: nil, fee: nil, message: nil)
@@ -59,6 +59,7 @@ module Lighstorm
         end
 
         def self.perform(
+          components,
           times_out_in:, code:,
           amount: nil, fee: nil,
           message: nil,
@@ -74,19 +75,19 @@ module Lighstorm
 
           return grpc_request if preview
 
-          response = dispatch(grpc_request, &vcr)
+          response = dispatch(components, grpc_request, &vcr)
 
-          Payment::Pay.raise_error_if_exists!(response)
+          Payment::Pay.raise_error_if_exists!(grpc_request, response)
 
-          data = fetch(code, &vcr)
+          data = fetch(components, code, &vcr)
 
           adapted = adapt(response, data)
 
-          model = self.model(adapted)
+          model = self.model(adapted, components)
 
-          Payment::Pay.raise_failure_if_exists!(model, response)
+          Payment::Pay.raise_failure_if_exists!(model, grpc_request, response)
 
-          Action::Output.new({ response: response[:response], result: model })
+          Action::Output.new({ request: grpc_request, response: response[:response], result: model })
         end
       end
     end

data/controllers/invoice/actions/pay_through_route.rb

@@ -7,11 +7,11 @@ module Lighstorm
   module Controllers
     module Invoice
       module PayThroughRoute
-        def self.perform(_invoice, route:, preview: false, fake: false)
+        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)
+            Channel.find_by_id(channel_id, components)
           end
 
           outgoing_channel_id = channels.first.id

data/controllers/invoice/all.rb

@@ -8,7 +8,7 @@ module Lighstorm
   module Controllers
     module Invoice
       module All
-        def self.fetch(limit: nil, spontaneous: false)
+        def self.fetch(components, limit: nil, spontaneous: false)
           at = Time.now
 
           last_offset = 0
@@ -16,7 +16,7 @@ module Lighstorm
           invoices = []
 
           loop do
-            response = Ports::GRPC.lightning.list_invoices(
+            response = components[:grpc].lightning.list_invoices(
               index_offset: last_offset,
               num_max_invoices: 10
             )
@@ -57,11 +57,11 @@ module Lighstorm
           end
         end
 
-        def self.data(limit: nil, spontaneous: false, &vcr)
+        def self.data(components, limit: nil, spontaneous: false, &vcr)
           raw = if vcr.nil?
-                  fetch(limit: limit, spontaneous: spontaneous)
+                  fetch(components, limit: limit, spontaneous: spontaneous)
                 else
-                  vcr.call(-> { fetch(limit: limit, spontaneous: spontaneous) })
+                  vcr.call(-> { fetch(components, limit: limit, spontaneous: spontaneous) })
                 end
 
           adapted = adapt(raw)
@@ -69,9 +69,9 @@ module Lighstorm
           transform(adapted)
         end
 
-        def self.model(data)
+        def self.model(data, components)
           data.map do |node_data|
-            Lighstorm::Models::Invoice.new(node_data)
+            Lighstorm::Models::Invoice.new(node_data, components)
           end
         end
       end

data/controllers/invoice/decode.rb

@@ -8,10 +8,10 @@ module Lighstorm
   module Controllers
     module Invoice
       module Decode
-        def self.fetch(code)
+        def self.fetch(components, code)
           {
             _code: code,
-            decode_pay_req: Ports::GRPC.lightning.decode_pay_req(pay_req: code).to_h
+            decode_pay_req: components[:grpc].lightning.decode_pay_req(pay_req: code).to_h
           }
         end
 
@@ -27,16 +27,16 @@ module Lighstorm
           adapted[:decode_pay_req]
         end
 
-        def self.data(code, &vcr)
-          raw = vcr.nil? ? fetch(code) : vcr.call(-> { fetch(code) })
+        def self.data(components, code, &vcr)
+          raw = vcr.nil? ? fetch(components, code) : vcr.call(-> { fetch(components, code) })
 
           adapted = adapt(raw)
 
           transform(adapted)
         end
 
-        def self.model(data)
-          Lighstorm::Models::Invoice.new(data)
+        def self.model(data, components)
+          Lighstorm::Models::Invoice.new(data, components)
         end
       end
     end

data/controllers/invoice/find_by_code.rb

@@ -8,15 +8,15 @@ module Lighstorm
   module Controllers
     module Invoice
       module FindByCode
-        def self.fetch(code)
+        def self.fetch(components, code)
           at = Time.now
 
-          decoded = Ports::GRPC.lightning.decode_pay_req(pay_req: code).to_h
+          decoded = components[:grpc].lightning.decode_pay_req(pay_req: code).to_h
 
           { response: {
             at: at,
             decode_pay_req: decoded,
-            lookup_invoice: Ports::GRPC.lightning.lookup_invoice(r_hash_str: decoded[:payment_hash]).to_h
+            lookup_invoice: components[:grpc].lightning.lookup_invoice(r_hash_str: decoded[:payment_hash]).to_h
           }, exception: nil }
         rescue StandardError => e
           { exception: e }
@@ -38,8 +38,8 @@ module Lighstorm
           adapted[:lookup_invoice]
         end
 
-        def self.data(code, &vcr)
-          raw = vcr.nil? ? fetch(code) : vcr.call(-> { fetch(code) })
+        def self.data(components, code, &vcr)
+          raw = vcr.nil? ? fetch(components, code) : vcr.call(-> { fetch(components, code) })
 
           raise_error_if_exists!(raw)
 
@@ -48,8 +48,8 @@ module Lighstorm
           transform(adapted)
         end
 
-        def self.model(data)
-          Lighstorm::Models::Invoice.new(data)
+        def self.model(data, components)
+          Lighstorm::Models::Invoice.new(data, components)
         end
 
         def self.raise_error_if_exists!(response)

data/controllers/invoice/find_by_secret_hash.rb

@@ -8,10 +8,10 @@ module Lighstorm
   module Controllers
     module Invoice
       module FindBySecretHash
-        def self.fetch(secret_hash)
+        def self.fetch(components, secret_hash)
           { response: {
             at: Time.now,
-            lookup_invoice: Ports::GRPC.lightning.lookup_invoice(r_hash_str: secret_hash).to_h
+            lookup_invoice: components[:grpc].lightning.lookup_invoice(r_hash_str: secret_hash).to_h
           }, exception: nil }
         rescue StandardError => e
           { exception: e }
@@ -33,16 +33,20 @@ module Lighstorm
           adapted[:lookup_invoice]
         end
 
-        def self.data(secret_hash, &vcr)
-          raw = vcr.nil? ? fetch(secret_hash) : vcr.call(-> { fetch(secret_hash) })
+        def self.data(components, secret_hash, &vcr)
+          raw = if vcr.nil?
+                  fetch(components, secret_hash)
+                else
+                  vcr.call(-> { fetch(components, secret_hash) })
+                end
 
           adapted = adapt(raw[:response])
 
           transform(adapted)
         end
 
-        def self.model(data)
-          Lighstorm::Models::Invoice.new(data)
+        def self.model(data, components)
+          Lighstorm::Models::Invoice.new(data, components)
         end
       end
     end