lighstorm 0.0.13 → 0.0.14

data/controllers/node/actions/apply_gossip.rb

@@ -26,7 +26,7 @@ module Lighstorm
         ].freeze
 
         def self.perform(actual, gossip)
-          updated = Models::Node.new(Adapter::Node.subscribe_channel_graph(gossip))
+          updated = Models::Node.new(Adapter::Node.subscribe_channel_graph(gossip), nil)
 
           actual_dump = actual.dump
           updated_dump = updated.dump

data/controllers/node/actions/pay.rb

@@ -18,20 +18,20 @@ module Lighstorm
   module Controllers
     module Node
       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(&vcr)
-          Payment::Pay.fetch(&vcr)
+        def self.fetch(components, &vcr)
+          Payment::Pay.fetch(components, &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(public_key:, amount:, times_out_in:, secret:, through:, fee: nil, message: nil)
@@ -75,6 +75,7 @@ module Lighstorm
         end
 
         def self.perform(
+          components,
           public_key:, amount:, through:,
           times_out_in:, fee: nil,
           message: nil, secret: nil,
@@ -94,19 +95,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(&vcr)
+          data = fetch(components, &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/node/all.rb

@@ -7,11 +7,11 @@ module Lighstorm
   module Controllers
     module Node
       module All
-        def self.fetch(limit: nil)
+        def self.fetch(components, limit: nil)
           data = {
             at: Time.now,
-            get_info: Ports::GRPC.lightning.get_info.to_h,
-            describe_graph: Ports::GRPC.lightning.describe_graph.nodes
+            get_info: components[:grpc].lightning.get_info.to_h,
+            describe_graph: components[:grpc].lightning.describe_graph.nodes
           }
 
           data[:describe_graph] = data[:describe_graph][0..limit - 1] unless limit.nil?
@@ -42,8 +42,12 @@ module Lighstorm
           end
         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)
 
@@ -52,9 +56,9 @@ module Lighstorm
           end
         end
 
-        def self.model(data)
+        def self.model(data, components)
           data.map do |node_data|
-            Lighstorm::Models::Node.new(node_data)
+            Lighstorm::Models::Node.new(node_data, components)
           end
         end
       end

data/controllers/node/find_by_public_key.rb

@@ -7,11 +7,11 @@ module Lighstorm
   module Controllers
     module Node
       module FindByPublicKey
-        def self.fetch(public_key)
+        def self.fetch(components, public_key)
           {
             at: Time.now,
-            get_info: Ports::GRPC.lightning.get_info.to_h,
-            get_node_info: Ports::GRPC.lightning.get_node_info(pub_key: public_key).to_h
+            get_info: components[:grpc].lightning.get_info.to_h,
+            get_node_info: components[:grpc].lightning.get_node_info(pub_key: public_key).to_h
           }
         end
 
@@ -22,8 +22,12 @@ module Lighstorm
           }
         end
 
-        def self.data(public_key, &vcr)
-          raw = vcr.nil? ? fetch(public_key) : vcr.call(-> { fetch(public_key) })
+        def self.data(components, public_key, &vcr)
+          raw = if vcr.nil?
+                  fetch(components, public_key)
+                else
+                  vcr.call(-> { fetch(components, public_key) })
+                end
 
           adapted = adapt(raw)
 
@@ -40,8 +44,8 @@ module Lighstorm
           end
         end
 
-        def self.model(data)
-          Lighstorm::Models::Node.new(data)
+        def self.model(data, components)
+          Lighstorm::Models::Node.new(data, components)
         end
       end
     end

data/controllers/node/myself.rb

@@ -7,10 +7,10 @@ module Lighstorm
   module Controllers
     module Node
       module Myself
-        def self.fetch
+        def self.fetch(components)
           {
             at: Time.now,
-            get_info: Ports::GRPC.lightning.get_info.to_h
+            get_info: components[:grpc].lightning.get_info.to_h
           }
         end
 
@@ -18,15 +18,15 @@ module Lighstorm
           { get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]) }
         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[:get_info].merge(myself: true)
         end
 
-        def self.model(data)
-          Lighstorm::Models::Node.new(data)
+        def self.model(data, components)
+          Lighstorm::Models::Node.new(data, components)
         end
       end
     end

data/controllers/node.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative './concerns/impersonatable'
+
 require_relative './node/myself'
 require_relative './node/all'
 require_relative './node/find_by_public_key'
@@ -7,20 +9,24 @@ require_relative './node/find_by_public_key'
 module Lighstorm
   module Controllers
     module Node
-      def self.myself
-        Myself.model(Myself.data)
-      end
+      extend Impersonatable
 
-      def self.all(limit: nil)
-        All.model(All.data(limit: limit))
-      end
+      class DSL < Impersonatable::DSL
+        def myself
+          Myself.model(Myself.data(components), components)
+        end
 
-      def self.find_by_public_key(public_key)
-        FindByPublicKey.model(FindByPublicKey.data(public_key))
-      end
+        def all(limit: nil)
+          All.model(All.data(components, limit: limit), components)
+        end
+
+        def find_by_public_key(public_key)
+          FindByPublicKey.model(FindByPublicKey.data(components, public_key), components)
+        end
 
-      def self.adapt(dump: nil, gossip: nil)
-        Models::Node.adapt(dump: dump, gossip: gossip)
+        def adapt(dump: nil, gossip: nil)
+          Models::Node.adapt(dump: dump, gossip: gossip)
+        end
       end
     end
   end

data/controllers/payment/actions/pay.rb

@@ -14,9 +14,9 @@ module Lighstorm
   module Controllers
     module Payment
       module Pay
-        def self.call(grpc_request)
+        def self.call(components, grpc_request)
           result = []
-          Lighstorm::Ports::GRPC.send(grpc_request[:service]).send(
+          components[:grpc].send(grpc_request[:service]).send(
             grpc_request[:method], grpc_request[:params]
           ) do |response|
             result << response.to_h
@@ -26,19 +26,23 @@ module Lighstorm
           { exception: e }
         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.fetch_all(code)
+        def self.fetch_all(components, code)
           {
-            invoice_decode: code.nil? ? nil : Invoice::Decode.data(code),
-            node_myself: Node::Myself.data
+            invoice_decode: code.nil? ? nil : Invoice::Decode.data(components, code),
+            node_myself: Node::Myself.data(components)
           }
         end
 
-        def self.fetch(code = nil, &vcr)
-          raw = vcr.nil? ? fetch_all(code) : vcr.call(-> { fetch_all(code) })
+        def self.fetch(components, code = nil, &vcr)
+          raw = vcr.nil? ? fetch_all(components, code) : vcr.call(-> { fetch_all(components, code) })
         end
 
         def self.adapt(grpc_data, fetch_data)
@@ -49,52 +53,52 @@ module Lighstorm
           )
         end
 
-        def self.model(data)
-          Models::Payment.new(data)
+        def self.model(data, components)
+          Models::Payment.new(data, components)
         end
 
-        def self.raise_error_if_exists!(response)
+        def self.raise_error_if_exists!(request, response)
           return if response[:exception].nil?
 
           if response[:exception].is_a?(GRPC::AlreadyExists)
             raise AlreadyPaidError.new(
               'The invoice is already paid.',
-              grpc: response[:exception]
+              request: request, grpc: response[:exception]
             )
           end
 
           if response[:exception].message =~ /amount must not be specified when paying a non-zero/
             raise AmountForNonZeroError.new(
               'Millisatoshis must not be specified when paying a non-zero amount invoice.',
-              grpc: response[:exception]
+              request: request, grpc: response[:exception]
             )
           end
 
           if response[:exception].message =~ /amount must be specified when paying a zero amount/
             raise MissingMillisatoshisError.new(
               'Millisatoshis must be specified when paying a zero amount invoice.',
-              grpc: response[:exception]
+              request: request, grpc: response[:exception]
             )
           end
 
           raise PaymentError.new(
             response[:exception].message,
-            grpc: response[:exception]
+            request: request, grpc: response[:exception]
           )
         end
 
-        def self.raise_failure_if_exists!(model, response)
+        def self.raise_failure_if_exists!(model, request, response)
           return unless model.state == 'failed'
 
           if response[:response].last[:failure_reason] == :FAILURE_REASON_NO_ROUTE
             raise NoRouteFoundError.new(
               response[:response].last[:failure_reason],
-              response: response[:response], result: model
+              request: request, response: response[:response], result: model
             )
           else
             raise PaymentError.new(
               response[:response].last[:failure_reason],
-              response: response[:response], result: model
+              request: request, response: response[:response], result: model
             )
           end
         end

data/controllers/payment/all.rb

@@ -12,10 +12,10 @@ module Lighstorm
   module Controllers
     module Payment
       module All
-        def self.fetch(purpose: nil, invoice_code: nil, secret_hash: nil, limit: nil, fetch: {})
+        def self.fetch(components, purpose: nil, invoice_code: nil, secret_hash: nil, limit: nil, fetch: {})
           at = Time.now
 
-          grpc = Ports::GRPC.session
+          grpc = components[:grpc].session
 
           get_info = grpc.lightning.get_info.to_h
 
@@ -396,17 +396,20 @@ module Lighstorm
         end
 
         def self.data(
+          components,
           purpose: nil, invoice_code: nil, secret_hash: nil, limit: nil,
           fetch: {}, &vcr
         )
           raw = if vcr.nil?
                   self.fetch(
+                    components,
                     purpose: purpose, invoice_code: invoice_code, secret_hash: secret_hash,
                     limit: limit, fetch: fetch
                   )
                 else
                   vcr.call(lambda {
                              self.fetch(
+                               components,
                                purpose: purpose, invoice_code: invoice_code, secret_hash: secret_hash,
                                limit: limit, fetch: fetch
                              )
@@ -423,9 +426,9 @@ module Lighstorm
           }
         end
 
-        def self.model(data)
+        def self.model(data, components)
           data[:data].map do |node_data|
-            Lighstorm::Models::Payment.new(node_data)
+            Lighstorm::Models::Payment.new(node_data, components)
           end
         end
       end

data/controllers/payment.rb

@@ -1,28 +1,34 @@
 # frozen_string_literal: true
 
+require_relative './concerns/impersonatable'
+
 require_relative './payment/all'
 
 module Lighstorm
   module Controllers
     module Payment
-      def self.all(purpose: nil, limit: nil, fetch: {})
-        All.model(All.data(purpose: purpose, limit: limit, fetch: fetch))
-      end
+      extend Impersonatable
 
-      def self.first(purpose: nil, fetch: {})
-        All.model(All.data(purpose: purpose, fetch: fetch)).first
-      end
+      class DSL < Impersonatable::DSL
+        def all(purpose: nil, limit: nil, fetch: {})
+          All.model(All.data(components, purpose: purpose, limit: limit, fetch: fetch), components)
+        end
 
-      def self.last(purpose: nil, fetch: {})
-        All.model(All.data(purpose: purpose, fetch: fetch)).last
-      end
+        def first(purpose: nil, fetch: {})
+          All.model(All.data(components, purpose: purpose, fetch: fetch), components).first
+        end
 
-      def self.find_by_secret_hash(secret_hash, &vcr)
-        All.model(All.data(secret_hash: secret_hash, &vcr)).first
-      end
+        def last(purpose: nil, fetch: {})
+          All.model(All.data(components, purpose: purpose, fetch: fetch), components).last
+        end
+
+        def find_by_secret_hash(secret_hash, &vcr)
+          All.model(All.data(components, secret_hash: secret_hash, &vcr), components).first
+        end
 
-      def self.find_by_invoice_code(invoice_code, &vcr)
-        All.model(All.data(invoice_code: invoice_code, &vcr)).first
+        def find_by_invoice_code(invoice_code, &vcr)
+          All.model(All.data(components, invoice_code: invoice_code, &vcr), components).first
+        end
       end
     end
   end

data/controllers/secret/valid_proof.rb

@@ -8,10 +8,10 @@ module Lighstorm
   module Controllers
     module Secret
       module ValidProof
-        def self.fetch(invoice_main_secret_hash)
+        def self.fetch(components, invoice_main_secret_hash)
           { response: {
             at: Time.now,
-            lookup_invoice: Ports::GRPC.lightning.lookup_invoice(r_hash_str: invoice_main_secret_hash).to_h
+            lookup_invoice: components[:grpc].lightning.lookup_invoice(r_hash_str: invoice_main_secret_hash).to_h
           }, exception: nil }
         rescue StandardError => e
           { exception: e }
@@ -39,13 +39,13 @@ module Lighstorm
           end.nil?
         end
 
-        def self.data(invoice_main_secret_hash, proof, &vcr)
+        def self.data(components, invoice_main_secret_hash, proof, &vcr)
           raise 'Invalid proof' if proof.size != 64
 
           raw = if vcr.nil?
-                  fetch(invoice_main_secret_hash)
+                  fetch(components, invoice_main_secret_hash)
                 else
-                  vcr.call(-> { fetch(invoice_main_secret_hash) })
+                  vcr.call(-> { fetch(components, invoice_main_secret_hash) })
                 end
 
           adapted = adapt(raw[:response])

data/controllers/transaction/all.rb

@@ -8,12 +8,12 @@ module Lighstorm
   module Controllers
     module Transaction
       module All
-        def self.fetch(limit: nil)
+        def self.fetch(components, limit: nil)
           at = Time.now
 
           transactions = []
 
-          response = Ports::GRPC.lightning.get_transactions
+          response = components[:grpc].lightning.get_transactions
 
           response.transactions.each do |transaction|
             transactions << transaction.to_h
@@ -38,12 +38,13 @@ module Lighstorm
           adapted[:get_transactions]
         end
 
-        def self.data(limit: nil, &vcr)
+        def self.data(components, limit: nil, &vcr)
           raw = if vcr.nil?
-                  fetch(limit: limit)
+                  fetch(components, limit: limit)
                 else
-                  vcr.call(-> { fetch(limit: limit) })
+                  vcr.call(-> { fetch(components, limit: limit) })
                 end
+
           adapted = adapt(raw)
 
           transform(adapted)

data/controllers/transaction.rb

@@ -1,16 +1,24 @@
 # frozen_string_literal: true
 
+require_relative './concerns/impersonatable'
+
 require_relative './transaction/all'
 
 module Lighstorm
   module Controllers
     module Transaction
-      def self.all(direction: nil, how: nil, limit: nil)
-        All.model(All.data(
-                    direction: direction,
-                    how: how,
-                    limit: limit
-                  ))
+      extend Impersonatable
+
+      class DSL < Impersonatable::DSL
+        def all(direction: nil, how: nil, layer: nil, limit: nil)
+          All.model(All.data(
+                      components,
+                      direction: direction,
+                      how: how,
+                      layer: layer,
+                      limit: limit
+                    ))
+        end
       end
     end
   end

data/controllers/wallet/balance.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../adapters/wallet'
+require_relative '../../models/wallet'
+
+module Lighstorm
+  module Controllers
+    module Wallet
+      module Balance
+        def self.fetch(components)
+          {
+            at: Time.now,
+            wallet_balance: components[:grpc].lightning.wallet_balance.to_h,
+            channel_balance: components[:grpc].lightning.channel_balance.to_h
+          }
+        end
+
+        def self.adapt(raw)
+          Adapter::Wallet.balance(raw)
+        end
+
+        def self.data(components, &vcr)
+          raw = vcr.nil? ? fetch(components) : vcr.call(-> { fetch(components) })
+
+          adapt(raw)
+        end
+
+        def self.model(data)
+          Models::Wallet.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/wallet.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require_relative './concerns/impersonatable'
+
+require_relative './wallet/balance'
+
+module Lighstorm
+  module Controllers
+    module Wallet
+      extend Impersonatable
+
+      class DSL < Impersonatable::DSL
+        def balance
+          Balance.model(Balance.data(components))
+        end
+      end
+    end
+  end
+end