lighstorm 0.0.8 → 0.0.10

data/controllers/invoice/actions/pay.rb

@@ -2,25 +2,91 @@
 
 require_relative '../../../ports/grpc'
 require_relative '../../../models/errors'
+require_relative '../../../models/edges/payment'
+require_relative '../../../adapters/edges/payment'
+require_relative '../../invoice'
+require_relative '../../action'
+require_relative '../../node/myself'
+
+require_relative '../../payment/actions/pay'
 
 module Lighstorm
   module Controllers
     module Invoice
       module Pay
-        def self.perform(_invoice, preview: false, fake: false)
-          raise Errors::ToDoError, self
-
-          LND.instance.middleware('router.send_payment_v2') do
-            result = []
-            LND.instance.client.router.send_payment_v2(
-              payment_request: request,
-              timeout_seconds: 5,
-              allow_self_payment: true
-            ) do |response|
-              result << response
-            end
-            result
+        def self.dispatch(grpc_request, &vcr)
+          Payment::Pay.dispatch(grpc_request, &vcr)
+        end
+
+        def self.fetch(code, &vcr)
+          Payment::Pay.fetch(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)
+        end
+
+        def self.prepare(code:, times_out_in:, amount: nil, fee: nil, message: nil)
+          request = {
+            service: :router,
+            method: :send_payment_v2,
+            params: {
+              payment_request: code,
+              timeout_seconds: Helpers::TimeExpression.seconds(times_out_in),
+              allow_self_payment: true,
+              dest_custom_records: {}
+            }
+          }
+
+          request[:params][:amt_msat] = amount[:millisatoshis] unless amount.nil?
+
+          unless fee.nil? || fee[:maximum].nil? || fee[:maximum][:millisatoshis].nil?
+            request[:params][:fee_limit_msat] = fee[:maximum][:millisatoshis]
+          end
+
+          if !message.nil? && !message.empty?
+            # https://github.com/satoshisstream/satoshis.stream/blob/main/TLV_registry.md
+            request[:params][:dest_custom_records][34_349_334] = message
           end
+
+          request[:params].delete(:dest_custom_records) if request[:params][:dest_custom_records].empty?
+
+          request
+        end
+
+        def self.perform(
+          times_out_in:, code:,
+          amount: nil, fee: nil,
+          message: nil,
+          preview: false, &vcr
+        )
+          grpc_request = prepare(
+            code: code,
+            amount: amount,
+            fee: fee,
+            message: message,
+            times_out_in: times_out_in
+          )
+
+          return grpc_request if preview
+
+          response = dispatch(grpc_request, &vcr)
+
+          Payment::Pay.raise_error_if_exists!(response)
+
+          data = fetch(code, &vcr)
+
+          adapted = adapt(response, data)
+
+          model = self.model(adapted)
+
+          Payment::Pay.raise_failure_if_exists!(model, response)
+
+          Action::Output.new({ response: response[:response], result: model })
         end
       end
     end

data/controllers/invoice/all.rb

@@ -8,7 +8,9 @@ module Lighstorm
   module Controllers
     module Invoice
       module All
-        def self.fetch(limit: nil)
+        def self.fetch(limit: nil, spontaneous: false)
+          at = Time.now
+
           last_offset = 0
 
           invoices = []
@@ -19,7 +21,9 @@ module Lighstorm
               num_max_invoices: 10
             )
 
-            response.invoices.each { |invoice| invoices << invoice.to_h }
+            response.invoices.each do |invoice|
+              invoices << invoice.to_h if spontaneous || !invoice.payment_request.empty?
+            end
 
             # TODO: How to optimize this?
             # break if !limit.nil? && invoices.size >= limit
@@ -33,13 +37,15 @@ module Lighstorm
 
           invoices = invoices[0..limit - 1] unless limit.nil?
 
-          { list_invoices: invoices }
+          { at: at, list_invoices: invoices }
         end
 
         def self.adapt(raw)
+          raise 'missing at' if raw[:at].nil?
+
           {
             list_invoices: raw[:list_invoices].map do |raw_invoice|
-              Lighstorm::Adapter::Invoice.list_invoices(raw_invoice)
+              Lighstorm::Adapter::Invoice.list_invoices(raw_invoice, raw[:at])
             end
           }
         end
@@ -51,8 +57,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(limit: nil, spontaneous: false, &vcr)
+          raw = if vcr.nil?
+                  fetch(limit: limit, spontaneous: spontaneous)
+                else
+                  vcr.call(-> { fetch(limit: limit, spontaneous: spontaneous) })
+                end
 
           adapted = adapt(raw)
 

data/controllers/invoice/decode.rb

@@ -8,17 +8,17 @@ module Lighstorm
   module Controllers
     module Invoice
       module Decode
-        def self.fetch(request_code)
+        def self.fetch(code)
           {
-            _request_code: request_code,
-            decode_pay_req: Ports::GRPC.lightning.decode_pay_req(pay_req: request_code).to_h
+            _code: code,
+            decode_pay_req: Ports::GRPC.lightning.decode_pay_req(pay_req: code).to_h
           }
         end
 
         def self.adapt(raw)
           {
             decode_pay_req: Lighstorm::Adapter::Invoice.decode_pay_req(
-              raw[:decode_pay_req], raw[:_request_code]
+              raw[:decode_pay_req], raw[:_code]
             )
           }
         end
@@ -27,8 +27,8 @@ module Lighstorm
           adapted[:decode_pay_req]
         end
 
-        def self.data(request_code, &vcr)
-          raw = vcr.nil? ? fetch(request_code) : vcr.call(-> { fetch(request_code) })
+        def self.data(code, &vcr)
+          raw = vcr.nil? ? fetch(code) : vcr.call(-> { fetch(code) })
 
           adapted = adapt(raw)
 

data/controllers/invoice/find_by_secret_hash.rb

@@ -10,13 +10,19 @@ module Lighstorm
       module FindBySecretHash
         def self.fetch(secret_hash)
           {
+            at: Time.now,
             lookup_invoice: Ports::GRPC.lightning.lookup_invoice(r_hash_str: secret_hash).to_h
           }
         end
 
         def self.adapt(raw)
+          raise 'missing at' if raw[:at].nil?
+
           {
-            lookup_invoice: Lighstorm::Adapter::Invoice.lookup_invoice(raw[:lookup_invoice])
+            lookup_invoice: Lighstorm::Adapter::Invoice.lookup_invoice(
+              raw[:lookup_invoice],
+              raw[:at]
+            )
           }
         end
 

data/controllers/invoice.rb

@@ -8,8 +8,8 @@ require_relative './invoice/actions/create'
 module Lighstorm
   module Controllers
     module Invoice
-      def self.all(limit: nil)
-        All.model(All.data(limit: limit))
+      def self.all(limit: nil, spontaneous: false)
+        All.model(All.data(limit: limit, spontaneous: spontaneous))
       end
 
       def self.first
@@ -24,14 +24,23 @@ module Lighstorm
         FindBySecretHash.model(FindBySecretHash.data(secret_hash))
       end
 
-      def self.decode(request_code, &vcr)
-        Decode.model(Decode.data(request_code, &vcr))
+      def self.decode(code, &vcr)
+        Decode.model(Decode.data(code, &vcr))
       end
 
-      def self.create(description: nil, millisatoshis: nil, preview: false, &vcr)
+      def self.create(
+        payable:,
+        description: nil, amount: nil,
+        # Lightning Invoice Expiration: UX Considerations
+        # https://d.elor.me/2022/01/lightning-invoice-expiration-ux-considerations/
+        expires_in: { hours: 24 },
+        preview: false, &vcr
+      )
         Create.perform(
+          payable: payable,
           description: description,
-          millisatoshis: millisatoshis,
+          amount: amount,
+          expires_in: expires_in,
           preview: preview,
           &vcr
         )

data/controllers/node/actions/pay.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'digest'
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/secret'
+require_relative '../../../models/errors'
+require_relative '../../../models/edges/payment'
+require_relative '../../../adapters/edges/payment'
+require_relative '../../invoice'
+require_relative '../../action'
+require_relative '../../node/myself'
+
+require_relative '../../payment/actions/pay'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module Pay
+        def self.dispatch(grpc_request, &vcr)
+          Payment::Pay.dispatch(grpc_request, &vcr)
+        end
+
+        def self.fetch(&vcr)
+          Payment::Pay.fetch(&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)
+        end
+
+        def self.prepare(public_key:, amount:, times_out_in:, secret:, through:, fee: nil, message: nil)
+          # Appreciation note for people that suffered in the past and shared
+          # their knowledge, so we don't have to struggle the same:
+          # - https://github.com/lightningnetwork/lnd/discussions/6357
+          # - https://docs.lightning.engineering/lightning-network-tools/lnd/send-messages-with-keysend
+          # - https://peakd.com/@brianoflondon/lightning-keysend-is-strange-and-how-to-send-keysend-payment-in-lightning-with-the-lnd-rest-api-via-python
+          # We are standing on the shoulders of giants, thank you very much. :)
+          request = {
+            service: :router,
+            method: :send_payment_v2,
+            params: {
+              dest: [public_key].pack('H*'),
+              amt_msat: amount[:millisatoshis],
+              timeout_seconds: Helpers::TimeExpression.seconds(times_out_in),
+              allow_self_payment: true,
+              dest_custom_records: {}
+            }
+          }
+
+          if !message.nil? && !message.empty?
+            # https://github.com/satoshisstream/satoshis.stream/blob/main/TLV_registry.md
+            request[:params][:dest_custom_records][34_349_334] = message
+          end
+
+          unless fee.nil? || fee[:maximum].nil? || fee[:maximum][:millisatoshis].nil?
+            request[:params][:fee_limit_msat] = fee[:maximum][:millisatoshis]
+          end
+
+          if through.to_sym == :keysend
+            request[:params][:payment_hash] = [secret[:hash]].pack('H*')
+            request[:params][:dest_custom_records][5_482_373_484] = [secret[:preimage]].pack('H*')
+          elsif through.to_sym == :amp
+            request[:params][:amp] = true
+          end
+
+          request[:params].delete(:dest_custom_records) if request[:params][:dest_custom_records].empty?
+
+          request
+        end
+
+        def self.perform(
+          public_key:, amount:, through:,
+          times_out_in:, fee: nil,
+          message: nil, secret: nil,
+          preview: false, &vcr
+        )
+          secret = Models::Secret.create.to_h if secret.nil? && through.to_sym == :keysend
+
+          grpc_request = prepare(
+            public_key: public_key,
+            amount: amount,
+            fee: fee,
+            through: through,
+            times_out_in: times_out_in,
+            secret: secret,
+            message: message
+          )
+
+          return grpc_request if preview
+
+          response = dispatch(grpc_request, &vcr)
+
+          Payment::Pay.raise_error_if_exists!(response)
+
+          data = fetch(&vcr)
+
+          adapted = adapt(response, data)
+
+          model = self.model(adapted)
+
+          Payment::Pay.raise_failure_if_exists!(model, response)
+
+          Action::Output.new({ response: response[:response], result: model })
+        end
+      end
+    end
+  end
+end

data/controllers/payment/actions/pay.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'digest'
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/errors'
+require_relative '../../../models/edges/payment'
+require_relative '../../../adapters/edges/payment'
+require_relative '../../node/myself'
+require_relative '../../invoice/decode'
+
+module Lighstorm
+  module Controllers
+    module Payment
+      module Pay
+        def self.call(grpc_request)
+          result = []
+          Lighstorm::Ports::GRPC.send(grpc_request[:service]).send(
+            grpc_request[:method], grpc_request[:params]
+          ) do |response|
+            result << response.to_h
+          end
+          { response: result, exception: nil }
+        rescue StandardError => e
+          { exception: e }
+        end
+
+        def self.dispatch(grpc_request, &vcr)
+          vcr.nil? ? call(grpc_request) : vcr.call(-> { call(grpc_request) }, :dispatch)
+        end
+
+        def self.fetch_all(code)
+          {
+            invoice_decode: code.nil? ? nil : Invoice::Decode.data(code),
+            node_myself: Node::Myself.data
+          }
+        end
+
+        def self.fetch(code = nil, &vcr)
+          raw = vcr.nil? ? fetch_all(code) : vcr.call(-> { fetch_all(code) })
+        end
+
+        def self.adapt(grpc_data, fetch_data)
+          Adapter::Payment.send_payment_v2(
+            grpc_data[:response].last,
+            fetch_data[:node_myself],
+            fetch_data[:invoice_decode]
+          )
+        end
+
+        def self.model(data)
+          Models::Payment.new(data)
+        end
+
+        def self.raise_error_if_exists!(response)
+          return if response[:exception].nil?
+
+          if response[:exception].is_a?(GRPC::AlreadyExists)
+            raise AlreadyPaidError.new(
+              'The invoice is already paid.',
+              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]
+            )
+          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]
+            )
+          end
+
+          raise PaymentError.new(
+            response[:exception].message,
+            grpc: response[:exception]
+          )
+        end
+
+        def self.raise_failure_if_exists!(model, 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
+            )
+          else
+            raise PaymentError.new(
+              response[:response].last[:failure_reason],
+              response: response[:response], result: model
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/payment/all.rb

@@ -108,9 +108,13 @@ module Lighstorm
 
                 next if fetch[:get_node_info] == false || data[:get_node_info][hop[:pub_key]]
 
-                data[:get_node_info][hop[:pub_key]] = grpc.lightning.get_node_info(
-                  pub_key: hop[:pub_key]
-                ).to_h
+                begin
+                  data[:get_node_info][hop[:pub_key]] = grpc.lightning.get_node_info(
+                    pub_key: hop[:pub_key]
+                  ).to_h
+                rescue StandardError => e
+                  data[:get_node_info][hop[:pub_key]] = { _error: e }
+                end
               end
             end
           end
@@ -151,24 +155,36 @@ module Lighstorm
             end
 
             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
+              begin
+                data[:get_node_info][channel[:node1_pub]] = grpc.lightning.get_node_info(
+                  pub_key: channel[:node1_pub]
+                ).to_h
+              rescue StandardError => e
+                data[:get_node_info][channel[:node1_pub]] = { _error: e }
+              end
             end
 
             next if fetch[:get_node_info] == false || data[:get_node_info][channel[:node2_pub]]
 
-            data[:get_node_info][channel[:node2_pub]] = grpc.lightning.get_node_info(
-              pub_key: channel[:node2_pub]
-            ).to_h
+            begin
+              data[:get_node_info][channel[:node2_pub]] = grpc.lightning.get_node_info(
+                pub_key: channel[:node2_pub]
+              ).to_h
+            rescue StandardError => e
+              data[:get_node_info][channel[:node2_pub]] = { _error: e }
+            end
           end
 
           data[:list_channels].each_value do |channel|
             next if fetch[:get_node_info] == false || data[:get_node_info][channel[:remote_pubkey]]
 
-            data[:get_node_info][channel[:remote_pubkey]] = grpc.lightning.get_node_info(
-              pub_key: channel[:remote_pubkey]
-            ).to_h
+            begin
+              data[:get_node_info][channel[:remote_pubkey]] = grpc.lightning.get_node_info(
+                pub_key: channel[:remote_pubkey]
+              ).to_h
+            rescue StandardError => e
+              data[:get_node_info][channel[:remote_pubkey]] = { _error: e }
+            end
           end
 
           data[:@meta] = { calls: grpc.calls }
@@ -195,7 +211,7 @@ module Lighstorm
           raw[:decode_pay_req].each_key do |key|
             next if raw[:decode_pay_req][key][:_error]
 
-            adapted[:decode_pay_req][key] = Lighstorm::Adapter::PaymentRequest.decode_pay_req(
+            adapted[:decode_pay_req][key] = Lighstorm::Adapter::Invoice.decode_pay_req(
               raw[:decode_pay_req][key]
             )
           end
@@ -204,7 +220,7 @@ module Lighstorm
             next if raw[:lookup_invoice][key][:_error]
 
             adapted[:lookup_invoice][key] = Lighstorm::Adapter::Invoice.lookup_invoice(
-              raw[:lookup_invoice][key]
+              raw[:lookup_invoice][key], raw[:at]
             )
           end
 
@@ -223,6 +239,8 @@ module Lighstorm
           end
 
           raw[:get_node_info].each_key do |key|
+            next if raw[:get_node_info][key][:_error]
+
             adapted[:get_node_info][key] = Lighstorm::Adapter::Node.get_node_info(
               raw[:get_node_info][key]
             )
@@ -309,34 +327,67 @@ module Lighstorm
         end
 
         def self.transform(list_payments, adapted)
-          if adapted[:lookup_invoice][list_payments[:request][:secret][:hash]] &&
-             !adapted[:lookup_invoice][list_payments[:request][:secret][:hash]][:_error]
+          if adapted[:lookup_invoice][list_payments[:secret][:hash]] &&
+             !adapted[:lookup_invoice][list_payments[:secret][:hash]][:_error]
 
-            list_payments[:request] = adapted[:lookup_invoice][list_payments[:request][:secret][:hash]][:request]
-          else
-            list_payments[:request][:_key] = Digest::SHA256.hexdigest(
-              list_payments[:request][:code]
-            )
+            if list_payments[:invoice]
+              lookup = adapted[:lookup_invoice][list_payments[:secret][:hash]]
+
+              list_payments[:invoice][:description] = lookup[:description]
+
+              lookup.each_key do |key|
+                if lookup[key].is_a?(Hash)
+                  unless list_payments[:invoice].key?(key) && !list_payments[:invoice][key].nil?
+                    list_payments[:invoice][key] = lookup[:key]
+                  end
+
+                  next
+                end
+
+                unless list_payments[:invoice].key?(key) && !list_payments[:invoice][key].nil? &&
+                       (!list_payments[:invoice][key].is_a?(String) || !list_payments[:invoice][key].empty?)
+                  list_payments[:invoice][key] = lookup[key]
+                end
+              end
+            else
+              list_payments[:invoice] = adapted[:lookup_invoice][list_payments[:secret][:hash]]
+            end
           end
+
           list_payments[:hops].each do |hop|
             hop[:channel] = transform_channel(hop[:channel], adapted)
           end
 
-          if adapted[:decode_pay_req][list_payments[:request][:code]]
-            decoded = adapted[:decode_pay_req][list_payments[:request][:code]]
-            request = list_payments[:request]
+          if adapted[:decode_pay_req][list_payments[:invoice][:code]]
+            decoded = adapted[:decode_pay_req][list_payments[:invoice][:code]]
+            invoice = list_payments[:invoice]
 
             decoded.each_key do |key|
-              request[key] = decoded[key] unless request.key?(key)
+              if !decoded[key].is_a?(Hash)
+                invoice[key] = decoded[key]
+              elsif decoded[key].is_a?(Hash)
+                invoice[key] = {} unless invoice.key?(key)
 
-              next unless decoded[key].is_a?(Hash)
+                next if key == :secret
 
-              decoded[key].each_key do |sub_key|
-                request[key][sub_key] = decoded[key][sub_key] unless request[key].key?(sub_key)
+                decoded[key].each_key do |sub_key|
+                  next if decoded[key][sub_key].nil? ||
+                          (decoded[key][sub_key].is_a?(String) && decoded[key][sub_key].empty?)
+
+                  invoice[key][sub_key] = decoded[key][sub_key]
+                end
               end
             end
           end
 
+          if list_payments[:invoice][:code]
+            if list_payments[:invoice][:payable] == 'once'
+              list_payments[:through] = 'non-amp'
+            elsif list_payments[:invoice][:payable] == 'indefinitely'
+              list_payments[:through] = 'amp'
+            end
+          end
+
           list_payments
         end