lighstorm 0.0.15 → 0.0.16

data/controllers/invoice/decode.rb

@@ -1,44 +0,0 @@
-# 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(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::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 = vcr.nil? ? fetch(components, code) : vcr.call(-> { fetch(components, code) })
-
-          adapted = adapt(raw)
-
-          transform(adapted)
-        end
-
-        def self.model(data, components)
-          Lighstorm::Models::Invoice.new(data, components)
-        end
-      end
-    end
-  end
-end

data/controllers/invoice/find_by_code.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/invoice'
-require_relative '../../models/invoice'
-
-module Lighstorm
-  module Controllers
-    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::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 = vcr.nil? ? fetch(components, code) : vcr.call(-> { fetch(components, code) })
-
-          raise_error_if_exists!(raw)
-
-          adapted = adapt(raw[:response])
-
-          transform(adapted)
-        end
-
-        def self.model(data, components)
-          Lighstorm::Models::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

data/controllers/invoice/find_by_secret_hash.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/invoice'
-require_relative '../../models/invoice'
-
-module Lighstorm
-  module Controllers
-    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::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::Models::Invoice.new(data, components)
-        end
-      end
-    end
-  end
-end

data/controllers/invoice.rb

@@ -1,62 +0,0 @@
-# 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 Controllers
-    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

data/controllers/node/actions/apply_gossip.rb

@@ -1,112 +0,0 @@
-# frozen_string_literal: true
-
-require 'securerandom'
-
-require_relative '../../../ports/grpc'
-require_relative '../../../models/errors'
-require_relative '../../../models/nodes/node'
-require_relative '../../../adapters/nodes/node'
-
-module Lighstorm
-  module Controllers
-    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 = Models::Node.new(Adapter::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

data/controllers/node/actions/pay.rb

@@ -1,115 +0,0 @@
-# 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(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[: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(
-          components,
-          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(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

data/controllers/node/all.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/nodes/node'
-
-module Lighstorm
-  module Controllers
-    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::Node.get_info(raw[:get_info]),
-            describe_graph: raw[:describe_graph].map do |raw|
-              Lighstorm::Adapter::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::Models::Node.new(node_data, components)
-          end
-        end
-      end
-    end
-  end
-end

data/controllers/node/find_by_public_key.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/nodes/node'
-
-module Lighstorm
-  module Controllers
-    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::Node.get_info(raw[:get_info]),
-            get_node_info: Lighstorm::Adapter::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::Models::Node.new(data, components)
-        end
-      end
-    end
-  end
-end

data/controllers/node/myself.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/nodes/node'
-
-module Lighstorm
-  module Controllers
-    module Node
-      module Myself
-        def self.fetch(components)
-          {
-            at: Time.now,
-            get_info: components[:grpc].lightning.get_info.to_h
-          }
-        end
-
-        def self.adapt(raw)
-          { get_info: Lighstorm::Adapter::Node.get_info(raw[:get_info]) }
-        end
-
-        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, components)
-          Lighstorm::Models::Node.new(data, components)
-        end
-      end
-    end
-  end
-end

data/controllers/node.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './concerns/impersonatable'
-
-require_relative './node/myself'
-require_relative './node/all'
-require_relative './node/find_by_public_key'
-
-module Lighstorm
-  module Controllers
-    module Node
-      extend Impersonatable
-
-      class DSL < Impersonatable::DSL
-        def myself
-          Myself.model(Myself.data(components), components)
-        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 adapt(dump: nil, gossip: nil)
-          Models::Node.adapt(dump: dump, gossip: gossip)
-        end
-      end
-    end
-  end
-end