lighstorm 0.0.6 → 0.0.8

data/controllers/invoice/actions/create.rb

@@ -3,33 +3,60 @@
 require_relative '../../../ports/grpc'
 require_relative '../../../models/errors'
 require_relative '../../invoice'
+require_relative '../../action'
 
 module Lighstorm
   module Controllers
     module Invoice
       module Create
-        def self.perform(description: nil, milisatoshis: nil, preview: false, fake: nil)
-          grpc_request = {
+        def self.call(grpc_request)
+          Lighstorm::Ports::GRPC.send(grpc_request[:service]).send(
+            grpc_request[:method], grpc_request[:params]
+          ).to_h
+        end
+
+        def self.prepare(description: nil, millisatoshis: nil)
+          {
             service: :lightning,
             method: :add_invoice,
             params: {
               memo: description,
-              value_msat: milisatoshis
+              value_msat: millisatoshis
             }
           }
+        end
+
+        def self.dispatch(grpc_request, &vcr)
+          vcr.nil? ? call(grpc_request) : vcr.call(-> { call(grpc_request) }, :dispatch)
+        end
+
+        def self.adapt(response)
+          Lighstorm::Adapter::Invoice.add_invoice(response)
+        end
+
+        def self.fetch(adapted, &vcr)
+          FindBySecretHash.data(adapted[:request][:secret][:hash], &vcr)
+        end
+
+        def self.model(data)
+          FindBySecretHash.model(data)
+        end
+
+        def self.perform(description: nil, millisatoshis: nil, preview: false, &vcr)
+          grpc_request = prepare(
+            description: description, millisatoshis: millisatoshis
+          )
 
           return grpc_request if preview
 
-          # expiry: Default is 86400 (24 hours).
-          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
+          response = dispatch(grpc_request, &vcr)
+
+          adapted = adapt(response)
+
+          data = fetch(adapted, &vcr)
+          model = self.model(data)
 
-          Invoice.find_by_secret_hash(response[:r_hash].unpack1('H*'))
+          Action::Output.new({ response: response, result: model })
         end
       end
     end

data/controllers/invoice/actions/pay_through_route.rb

@@ -36,7 +36,7 @@ module Lighstorm
           begin
             route = LND.instance.middleware('router.build_route') do
               LND.instance.client.router.build_route(
-                amt_msat: amount.milisatoshis,
+                amt_msat: amount.millisatoshis,
                 outgoing_chan_id: channels.first.id.to_i,
                 hop_pubkeys: hops_public_keys.map { |hpk| [hpk].pack('H*') },
                 payment_addr: [address].pack('H*')

data/controllers/invoice/decode.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/invoice'
+require_relative '../../models/invoice'
+
+module Lighstorm
+  module Controllers
+    module Invoice
+      module Decode
+        def self.fetch(request_code)
+          {
+            _request_code: request_code,
+            decode_pay_req: Ports::GRPC.lightning.decode_pay_req(pay_req: request_code).to_h
+          }
+        end
+
+        def self.adapt(raw)
+          {
+            decode_pay_req: Lighstorm::Adapter::Invoice.decode_pay_req(
+              raw[:decode_pay_req], raw[:_request_code]
+            )
+          }
+        end
+
+        def self.transform(adapted)
+          adapted[:decode_pay_req]
+        end
+
+        def self.data(request_code, &vcr)
+          raw = vcr.nil? ? fetch(request_code) : vcr.call(-> { fetch(request_code) })
+
+          adapted = adapt(raw)
+
+          transform(adapted)
+        end
+
+        def self.model(data)
+          Lighstorm::Models::Invoice.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/invoice.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative './invoice/all'
+require_relative './invoice/decode'
 require_relative './invoice/find_by_secret_hash'
 require_relative './invoice/actions/create'
 
@@ -23,12 +24,16 @@ module Lighstorm
         FindBySecretHash.model(FindBySecretHash.data(secret_hash))
       end
 
-      def self.create(description: nil, milisatoshis: nil, preview: false, fake: nil)
+      def self.decode(request_code, &vcr)
+        Decode.model(Decode.data(request_code, &vcr))
+      end
+
+      def self.create(description: nil, millisatoshis: nil, preview: false, &vcr)
         Create.perform(
           description: description,
-          milisatoshis: milisatoshis,
+          millisatoshis: millisatoshis,
           preview: preview,
-          fake: fake
+          &vcr
         )
       end
     end