lighstorm 0.0.15 → 0.0.16

data/controllers/lightning/invoice/all.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/invoice'
+require_relative '../../../models/lightning/invoice'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Invoice
+        module All
+          def self.fetch(components, limit: nil, spontaneous: false)
+            at = Time.now
+
+            last_offset = 0
+
+            invoices = []
+
+            loop do
+              response = components[:grpc].lightning.list_invoices(
+                index_offset: last_offset,
+                num_max_invoices: 10
+              )
+
+              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
+
+              break if last_offset == response.last_index_offset || last_offset > response.last_index_offset
+
+              last_offset = response.last_index_offset
+            end
+
+            invoices = invoices.sort_by { |raw_invoice| -raw_invoice[:creation_date] }
+
+            invoices = invoices[0..limit - 1] unless limit.nil?
+
+            { 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::Lightning::Invoice.list_invoices(raw_invoice, raw[:at])
+              end
+            }
+          end
+
+          def self.transform(adapted)
+            adapted[:list_invoices].map do |invoice|
+              invoice[:known] = true
+              invoice
+            end
+          end
+
+          def self.data(components, limit: nil, spontaneous: false, &vcr)
+            raw = if vcr.nil?
+                    fetch(components, limit: limit, spontaneous: spontaneous)
+                  else
+                    vcr.call(-> { fetch(components, limit: limit, spontaneous: spontaneous) })
+                  end
+
+            adapted = adapt(raw)
+
+            transform(adapted)
+          end
+
+          def self.model(data, components)
+            data.map do |node_data|
+              Lighstorm::Model::Lightning::Invoice.new(node_data, components)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/invoice/decode.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/invoice'
+require_relative '../../../models/lightning/invoice'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Invoice
+        module Decode
+          def self.fetch(components, code)
+            {
+              _code: code,
+              decode_pay_req: components[:grpc].lightning.decode_pay_req(pay_req: code).to_h
+            }
+          end
+
+          def self.adapt(raw)
+            {
+              decode_pay_req: Lighstorm::Adapter::Lightning::Invoice.decode_pay_req(
+                raw[:decode_pay_req], raw[:_code]
+              )
+            }
+          end
+
+          def self.transform(adapted)
+            adapted[:decode_pay_req]
+          end
+
+          def self.data(components, code, &vcr)
+            raw = if vcr.nil?
+                    fetch(components, code.sub('lightning:', ''))
+                  else
+                    vcr.call(-> { fetch(components, code.sub('lightning:', '')) })
+                  end
+
+            adapted = adapt(raw)
+
+            transform(adapted)
+          end
+
+          def self.model(data, components)
+            Lighstorm::Model::Lightning::Invoice.new(data, components)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/invoice/find_by_code.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/invoice'
+require_relative '../../../models/lightning/invoice'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Invoice
+        module FindByCode
+          def self.fetch(components, code)
+            at = Time.now
+
+            decoded = components[:grpc].lightning.decode_pay_req(pay_req: code).to_h
+
+            { response: {
+              at: at,
+              decode_pay_req: decoded,
+              lookup_invoice: components[:grpc].lightning.lookup_invoice(r_hash_str: decoded[:payment_hash]).to_h
+            }, exception: nil }
+          rescue StandardError => e
+            { exception: e }
+          end
+
+          def self.adapt(raw)
+            raise 'missing at' if raw[:at].nil?
+
+            {
+              lookup_invoice: Lighstorm::Adapter::Lightning::Invoice.lookup_invoice(
+                raw[:lookup_invoice],
+                raw[:at]
+              )
+            }
+          end
+
+          def self.transform(adapted)
+            adapted[:lookup_invoice][:known] = true
+            adapted[:lookup_invoice]
+          end
+
+          def self.data(components, code, &vcr)
+            raw = if vcr.nil?
+                    fetch(components, code.sub('lightning:', ''))
+                  else
+                    vcr.call(-> { fetch(components, code.sub('lightning:', '')) })
+                  end
+
+            raise_error_if_exists!(raw)
+
+            adapted = adapt(raw[:response])
+
+            transform(adapted)
+          end
+
+          def self.model(data, components)
+            Lighstorm::Model::Lightning::Invoice.new(data, components)
+          end
+
+          def self.raise_error_if_exists!(response)
+            return if response[:exception].nil?
+
+            if response[:exception].is_a?(GRPC::NotFound)
+              raise NoInvoiceFoundError.new(
+                "Invoice not found. Try using Invoice.decode if you don't own the invoice.",
+                grpc: response[:exception]
+              )
+            end
+
+            raise LighstormError.new(grpc: response[:exception])
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/invoice/find_by_secret_hash.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/invoice'
+require_relative '../../../models/lightning/invoice'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Invoice
+        module FindBySecretHash
+          def self.fetch(components, secret_hash)
+            { response: {
+              at: Time.now,
+              lookup_invoice: components[:grpc].lightning.lookup_invoice(r_hash_str: secret_hash).to_h
+            }, exception: nil }
+          rescue StandardError => e
+            { exception: e }
+          end
+
+          def self.adapt(raw)
+            raise 'missing at' if raw[:at].nil?
+
+            {
+              lookup_invoice: Lighstorm::Adapter::Lightning::Invoice.lookup_invoice(
+                raw[:lookup_invoice],
+                raw[:at]
+              )
+            }
+          end
+
+          def self.transform(adapted)
+            adapted[:lookup_invoice][:known] = true
+            adapted[:lookup_invoice]
+          end
+
+          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, components)
+            Lighstorm::Model::Lightning::Invoice.new(data, components)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/invoice.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../concerns/impersonatable'
+
+require_relative './invoice/all'
+require_relative './invoice/decode'
+require_relative './invoice/find_by_secret_hash'
+require_relative './invoice/find_by_code'
+require_relative './invoice/actions/create'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Invoice
+        extend Impersonatable
+
+        class DSL < Impersonatable::DSL
+          def all(limit: nil, spontaneous: false)
+            All.model(All.data(components, limit: limit, spontaneous: spontaneous), components)
+          end
+
+          def first
+            All.model(All.data(components), components).first
+          end
+
+          def last
+            All.model(All.data(components), components).last
+          end
+
+          def find_by_secret_hash(secret_hash, &vcr)
+            FindBySecretHash.model(FindBySecretHash.data(components, secret_hash, &vcr), components)
+          end
+
+          def find_by_code(code, &vcr)
+            FindByCode.model(FindByCode.data(components, code, &vcr), components)
+          end
+
+          def decode(code, &vcr)
+            Decode.model(Decode.data(components, code, &vcr), components)
+          end
+
+          def 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(
+              components,
+              payable: payable,
+              description: description,
+              amount: amount,
+              expires_in: expires_in,
+              preview: preview,
+              &vcr
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/node/actions/apply_gossip.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+require_relative '../../../../ports/grpc'
+require_relative '../../../../models/errors'
+require_relative '../../../../models/lightning/nodes/node'
+require_relative '../../../../adapters/lightning/nodes/node'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      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 = Model::Lightning::Node.new(Adapter::Lightning::Node.subscribe_channel_graph(gossip), nil)
+
+            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
+end

data/controllers/lightning/node/actions/pay.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'digest'
+
+require_relative '../../../../ports/grpc'
+require_relative '../../../../models/lightning/secret'
+require_relative '../../../../models/errors'
+require_relative '../../../../models/lightning/edges/payment'
+require_relative '../../../../adapters/lightning/edges/payment'
+require_relative '../../invoice'
+require_relative '../../../action'
+require_relative '../../node/myself'
+
+require_relative '../../payment/actions/pay'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Node
+        module Pay
+          def self.dispatch(components, grpc_request, &vcr)
+            Payment::Pay.dispatch(components, grpc_request, &vcr)
+          end
+
+          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, components)
+            Payment::Pay.model(data, components)
+          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[:proof]].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(
+            components,
+            public_key:, amount:, through:,
+            times_out_in:, fee: nil,
+            message: nil, secret: nil,
+            preview: false, &vcr
+          )
+            secret = Model::Lightning::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(components, grpc_request, &vcr)
+
+            Payment::Pay.raise_error_if_exists!(grpc_request, response)
+
+            data = fetch(components, &vcr)
+
+            adapted = adapt(response, data)
+
+            model = self.model(adapted, components)
+
+            Payment::Pay.raise_failure_if_exists!(model, grpc_request, response)
+
+            Action::Output.new({ request: grpc_request, response: response[:response], result: model })
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/node/all.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/nodes/node'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Node
+        module All
+          def self.fetch(components, limit: nil)
+            data = {
+              at: Time.now,
+              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?
+
+            data
+          end
+
+          def self.adapt(raw)
+            {
+              get_info: Lighstorm::Adapter::Lightning::Node.get_info(raw[:get_info]),
+              describe_graph: raw[:describe_graph].map do |raw|
+                Lighstorm::Adapter::Lightning::Node.describe_graph(raw.to_h)
+              end
+            }
+          end
+
+          def self.transform(describe_graph, get_info)
+            if get_info[:public_key] == describe_graph[:public_key]
+              get_info.merge(myself: true)
+            else
+              describe_graph.merge(
+                platform: {
+                  blockchain: get_info[:platform][:blockchain],
+                  network: get_info[:platform][:network]
+                },
+                myself: false
+              )
+            end
+          end
+
+          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)
+
+            adapted[:describe_graph].map do |data|
+              transform(data, adapted[:get_info])
+            end
+          end
+
+          def self.model(data, components)
+            data.map do |node_data|
+              Lighstorm::Model::Lightning::Node.new(node_data, components)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/node/find_by_public_key.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/nodes/node'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Node
+        module FindByPublicKey
+          def self.fetch(components, public_key)
+            {
+              at: Time.now,
+              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
+
+          def self.adapt(raw)
+            {
+              get_info: Lighstorm::Adapter::Lightning::Node.get_info(raw[:get_info]),
+              get_node_info: Lighstorm::Adapter::Lightning::Node.get_node_info(raw[:get_node_info])
+            }
+          end
+
+          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)
+
+            if adapted[:get_info][:public_key] == adapted[:get_node_info][:public_key]
+              adapted[:get_info].merge(myself: true)
+            else
+              adapted[:get_node_info].merge(
+                platform: {
+                  blockchain: adapted[:get_info][:platform][:blockchain],
+                  network: adapted[:get_info][:platform][:network]
+                },
+                myself: false
+              )
+            end
+          end
+
+          def self.model(data, components)
+            Lighstorm::Model::Lightning::Node.new(data, components)
+          end
+        end
+      end
+    end
+  end
+end