lighstorm 0.0.2 → 0.0.4

data/controllers/invoice/actions/pay.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/errors'
+
+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
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/invoice/actions/pay_through_route.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/errors'
+
+module Lighstorm
+  module Controllers
+    module Invoice
+      module PayThroughRoute
+        def self.perform(_invoice, route:, preview: false, fake: false)
+          raise Errors::ToDoError, self
+
+          channels = route.map do |channel_id|
+            Channel.find_by_id(channel_id)
+          end
+
+          outgoing_channel_id = channels.first.id
+
+          hops_public_keys = []
+
+          hops_public_keys << if channels.first.mine?
+                                channels.first.partner.node.public_key
+                              else
+                                channels.first.partners.last.node.public_key
+                              end
+
+          channels[1..channels.size - 2].each do |channel|
+            hops_public_keys << channel.partners.last.node.public_key
+          end
+
+          hops_public_keys << if channels.last.mine?
+                                channels.last.myself.node.public_key
+                              else
+                                channels.last.partners.last.node.public_key
+                              end
+          begin
+            route = LND.instance.middleware('router.build_route') do
+              LND.instance.client.router.build_route(
+                amt_msat: amount.milisatoshis,
+                outgoing_chan_id: channels.first.id.to_i,
+                hop_pubkeys: hops_public_keys.map { |hpk| [hpk].pack('H*') },
+                payment_addr: [address].pack('H*')
+              )
+            end
+
+            if preview
+              return {
+                method: :send_to_route_v2,
+                params: {
+                  payment_hash: hash,
+                  route: route.to_h[:route],
+                  skip_temp_err: true
+                }
+              }
+            end
+
+            LND.instance.middleware('router.send_to_route_v2') do
+              LND.instance.client.router.send_to_route_v2(
+                payment_hash: [hash].pack('H*'),
+                route: route.to_h[:route],
+                skip_temp_err: true
+              )
+            end
+          rescue StandardError => e
+            e
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/invoice/all.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/invoice'
+require_relative '../../models/invoice'
+
+module Lighstorm
+  module Controllers
+    module Invoice
+      module All
+        def self.fetch(limit: nil)
+          last_offset = 0
+
+          invoices = []
+
+          loop do
+            response = Ports::GRPC.lightning.list_invoices(
+              index_offset: last_offset,
+              num_max_invoices: 10
+            )
+
+            response.invoices.each { |invoice| invoices << invoice.to_h }
+
+            # 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?
+
+          { list_invoices: invoices }
+        end
+
+        def self.adapt(raw)
+          {
+            list_invoices: raw[:list_invoices].map do |raw_invoice|
+              Lighstorm::Adapter::Invoice.list_invoices(raw_invoice)
+            end
+          }
+        end
+
+        def self.transform(adapted)
+          adapted[:list_invoices].map do |invoice|
+            invoice[:known] = true
+            invoice
+          end
+        end
+
+        def self.data(limit: nil, &vcr)
+          raw = vcr.nil? ? fetch(limit: limit) : vcr.call(-> { fetch(limit: limit) })
+
+          adapted = adapt(raw)
+
+          transform(adapted)
+        end
+
+        def self.model(data)
+          data.map do |node_data|
+            Lighstorm::Models::Invoice.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/invoice/find_by_secret_hash.rb

@@ -0,0 +1,42 @@
+# 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(secret_hash)
+          {
+            lookup_invoice: Ports::GRPC.lightning.lookup_invoice(r_hash_str: secret_hash).to_h
+          }
+        end
+
+        def self.adapt(raw)
+          {
+            lookup_invoice: Lighstorm::Adapter::Invoice.lookup_invoice(raw[:lookup_invoice])
+          }
+        end
+
+        def self.transform(adapted)
+          adapted[:lookup_invoice][:known] = true
+          adapted[:lookup_invoice]
+        end
+
+        def self.data(secret_hash, &vcr)
+          raw = vcr.nil? ? fetch(secret_hash) : vcr.call(-> { fetch(secret_hash) })
+
+          adapted = adapt(raw)
+
+          transform(adapted)
+        end
+
+        def self.model(data)
+          Lighstorm::Models::Invoice.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/invoice.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative './invoice/all'
+require_relative './invoice/find_by_secret_hash'
+require_relative './invoice/actions/create'
+
+module Lighstorm
+  module Controllers
+    module Invoice
+      def self.all(limit: nil)
+        All.model(All.data(limit: limit))
+      end
+
+      def self.first
+        All.model(All.data).first
+      end
+
+      def self.last
+        All.model(All.data).last
+      end
+
+      def self.find_by_secret_hash(secret_hash)
+        FindBySecretHash.model(FindBySecretHash.data(secret_hash))
+      end
+
+      def self.create(description: nil, milisatoshis: nil, preview: false, fake: false)
+        Create.perform(
+          description: description,
+          milisatoshis: milisatoshis,
+          preview: preview,
+          fake: fake
+        )
+      end
+    end
+  end
+end

data/controllers/node/all.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module All
+        def self.fetch(limit: nil)
+          data = {
+            at: Time.now,
+            get_info: Ports::GRPC.lightning.get_info.to_h,
+            describe_graph: Ports::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(limit: nil, &vcr)
+          raw = vcr.nil? ? fetch(limit: limit) : vcr.call(-> { fetch(limit: limit) })
+
+          adapted = adapt(raw)
+
+          adapted[:describe_graph].map do |data|
+            transform(data, adapted[:get_info])
+          end
+        end
+
+        def self.model(data)
+          data.map do |node_data|
+            Lighstorm::Models::Node.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/node/find_by_public_key.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module FindByPublicKey
+        def self.fetch(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
+          }
+        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(public_key, &vcr)
+          raw = vcr.nil? ? fetch(public_key) : vcr.call(-> { fetch(public_key) })
+
+          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)
+          Lighstorm::Models::Node.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/node/myself.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/nodes/node'
+
+module Lighstorm
+  module Controllers
+    module Node
+      module Myself
+        def self.fetch
+          {
+            at: Time.now,
+            get_info: Ports::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(&vcr)
+          raw = vcr.nil? ? fetch : vcr.call(-> { fetch })
+
+          adapted = adapt(raw)
+          adapted[:get_info].merge(myself: true)
+        end
+
+        def self.model(data)
+          Lighstorm::Models::Node.new(data)
+        end
+      end
+    end
+  end
+end

data/controllers/node.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative './node/myself'
+require_relative './node/all'
+require_relative './node/find_by_public_key'
+
+module Lighstorm
+  module Controllers
+    module Node
+      def self.myself
+        Myself.model(Myself.data)
+      end
+
+      def self.all(limit: nil)
+        All.model(All.data(limit: limit))
+      end
+
+      def self.find_by_public_key(public_key)
+        FindByPublicKey.model(FindByPublicKey.data(public_key))
+      end
+    end
+  end
+end