lighstorm 0.0.15 → 0.0.16

data/controllers/lightning/secret/valid_proof.rb

@@ -0,0 +1,60 @@
+# 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 Secret
+        module ValidProof
+          def self.fetch(components, invoice_main_secret_hash)
+            { response: {
+              at: Time.now,
+              lookup_invoice: components[:grpc].lightning.lookup_invoice(r_hash_str: invoice_main_secret_hash).to_h
+            }, exception: nil }
+          rescue StandardError => e
+            { exception: e }
+          end
+
+          def self.adapt(raw)
+            {
+              lookup_invoice: Lighstorm::Adapter::Lightning::Invoice.lookup_invoice(
+                raw[:lookup_invoice],
+                raw[:at]
+              )
+            }
+          end
+
+          def self.transform(adapted, candidate_proof)
+            return true if adapted[:lookup_invoice][:secret][:proof] == candidate_proof
+
+            return false if adapted[:lookup_invoice][:payments].nil? ||
+                            adapted[:lookup_invoice][:payments].empty?
+
+            !adapted[:lookup_invoice][:payments].find do |payment|
+              next if payment[:secret].nil?
+
+              payment[:secret][:proof] == candidate_proof
+            end.nil?
+          end
+
+          def self.data(components, invoice_main_secret_hash, candidate_proof, &vcr)
+            raise 'Invalid proof' if candidate_proof.size != 64
+
+            raw = if vcr.nil?
+                    fetch(components, invoice_main_secret_hash)
+                  else
+                    vcr.call(-> { fetch(components, invoice_main_secret_hash) })
+                  end
+
+            adapted = adapt(raw[:response])
+
+            transform(adapted, candidate_proof)
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/lightning/secret.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative '../concerns/impersonatable'
+
+module Lighstorm
+  module Controller
+    module Lightning
+      module Secret
+        extend Impersonatable
+
+        class DSL < Impersonatable::DSL
+        end
+      end
+    end
+  end
+end

data/controllers/wallet/activity/all.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+require_relative '../../lightning/invoice/all'
+require_relative '../../lightning/payment/all'
+require_relative '../../lightning/forward/all'
+require_relative '../../bitcoin/transaction/all'
+require_relative '../../../models/wallet/activity'
+
+module Lighstorm
+  module Controller
+    module Wallet
+      module Activity
+        module All
+          def self.bitcoin_how(transaction_label)
+            if transaction_label =~ /:openchannel:/
+              'opening-channel'
+            elsif transaction_label =~ /:closechannel:/
+              'closing-channel'
+            else
+              'spontaneously'
+            end
+          end
+
+          def self.fetch(components, direction: nil, layer: nil, how: nil, order: nil, limit: nil)
+            activities = []
+
+            # components[:grpc].lightning.list_channels.channels.each do |channel|
+            #   if (layer.nil? || layer == 'lightning')
+            #      activities << {
+            #         direction: 'out',
+            #         layer: 'lightning',
+            #         at: Time.now,
+            #         amount: {
+            #           millisatoshis: channel.to_h[:local_chan_reserve_sat] * 1000
+            #         },
+            #         how: 'reserve',
+            #         message: nil,
+            #         data: {}
+            #       }
+
+            #        activities << {
+            #         direction: 'out',
+            #         layer: 'lightning',
+            #         at: Time.now,
+            #         amount: {
+            #           millisatoshis: channel.to_h[:commit_fee] * 1000
+            #         },
+            #         how: 'commit',
+            #         message: nil,
+            #         data: {}
+            #       }
+            #     end
+            # end
+
+            Bitcoin::Transaction::All.data(components).each do |transaction|
+              transaction_how = bitcoin_how(transaction[:label])
+
+              if (layer.nil? || layer == 'bitcoin') && (how.nil? || transaction_how =~ /#{Regexp.escape(how)}/)
+                activities << {
+                  direction: (transaction[:amount][:millisatoshis]).positive? ? 'in' : 'out',
+                  layer: 'bitcoin',
+                  at: transaction[:at],
+                  amount: {
+                    millisatoshis: if (transaction[:amount][:millisatoshis]).positive?
+                                     transaction[:amount][:millisatoshis]
+                                   else
+                                     -transaction[:amount][:millisatoshis]
+                                   end
+                  },
+                  how: transaction_how,
+                  message: nil,
+                  data: { transaction: transaction }
+                }
+              end
+
+              next unless (layer.nil? || layer == 'lightning') && (how.nil? || transaction_how =~ /#{Regexp.escape(how)}/) && %w[
+                channel opening-channel closing-channel
+              ].include?(transaction_how)
+
+              activities << {
+                direction: (transaction[:amount][:millisatoshis]).positive? ? 'out' : 'in',
+                layer: 'lightning',
+                at: transaction[:at] + ((transaction[:amount][:millisatoshis]).positive? ? -1 : 1),
+                amount: {
+                  millisatoshis: if (transaction[:amount][:millisatoshis]).positive?
+                                   (transaction[:amount][:millisatoshis] - transaction[:fee][:millisatoshis])
+                                 else
+                                   -(transaction[:amount][:millisatoshis] + transaction[:fee][:millisatoshis])
+                                 end
+                },
+                how: transaction_how,
+                message: nil,
+                data: { transaction: transaction }
+              }
+            end
+
+            if (direction.nil? || direction == 'in') && (layer.nil? || layer == 'lightning')
+              Lightning::Invoice::All.data(components, spontaneous: true).filter do |invoice|
+                !invoice[:payments].nil? && invoice[:payments].size.positive?
+              end.each do |invoice|
+                activity_how = invoice[:code].nil? ? 'spontaneously' : 'with-invoice'
+
+                next if !how.nil? && how != activity_how
+
+                # TODO: Improve performance by reducing invoice fields and removing payments?
+                invoice[:payments].each do |payment|
+                  activities << {
+                    direction: 'in',
+                    layer: 'lightning',
+                    at: payment[:at],
+                    amount: payment[:amount],
+                    how: activity_how,
+                    message: payment[:message],
+                    data: { invoice: invoice }
+                  }
+                end
+              end
+
+              Lightning::Forward::All.data(components).each do |forward|
+                next if !how.nil? && how != 'forwarding'
+
+                activities << {
+                  direction: 'in',
+                  layer: 'lightning',
+                  at: forward[:at],
+                  amount: forward[:fee],
+                  how: 'forwarding',
+                  message: nil,
+                  data: {}
+                }
+              end
+            end
+
+            if (direction.nil? || direction == 'out') && (layer.nil? || layer == 'lightning')
+              Lightning::Payment::All.data(
+                components,
+                fetch: {
+                  get_node_info: false,
+                  lookup_invoice: false,
+                  decode_pay_req: true,
+                  get_chan_info: false
+                }
+              )[:data].each do |payment|
+                activity_how = payment[:invoice][:code].nil? ? 'spontaneously' : 'with-invoice'
+
+                next if !how.nil? && how != activity_how
+
+                # TODO: Improve performance by reducing invoice fields?
+                activities << {
+                  direction: 'out',
+                  layer: 'lightning',
+                  at: payment[:at],
+                  amount: payment[:amount],
+                  how: activity_how,
+                  message: payment[:message],
+                  data: { invoice: payment[:invoice] }
+                }
+              end
+            end
+
+            activities = if order.nil? || order == 'desc'
+                           activities.sort_by { |activity| -activity[:at].to_i }
+                         else
+                           activities.sort_by { |activity| activity[:at].to_i }
+                         end
+
+            activities = activities[0..limit - 1] unless limit.nil?
+
+            { activities: activities }
+          end
+
+          def self.transform(raw)
+            raw[:activities].map do |activity|
+              activity[:_key] = SecureRandom.hex
+              activity
+            end
+          end
+
+          def self.data(components, direction: nil, layer: nil, how: nil, order: nil, limit: nil, &vcr)
+            raw = if vcr.nil?
+                    fetch(components, direction: direction, layer: layer, how: how, order: order, limit: limit)
+                  else
+                    vcr.call(-> { fetch(components, direction: direction, how: how, order: order, limit: limit) })
+                  end
+
+            transform(raw)
+          end
+
+          def self.model(data)
+            data.map { |data| Model::Wallet::Activity.new(data) }
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/wallet/activity.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require_relative '../concerns/impersonatable'
+
+require_relative './activity/all'
+
+module Lighstorm
+  module Controller
+    module Wallet
+      module Activity
+        extend Impersonatable
+
+        class DSL < Impersonatable::DSL
+          def all(direction: nil, layer: nil, how: nil, order: nil, limit: nil)
+            All.model(All.data(
+                        components,
+                        direction: direction,
+                        how: how,
+                        layer: layer,
+                        order: order,
+                        limit: limit
+                      ))
+          end
+        end
+      end
+    end
+  end
+end

data/controllers/wallet/balance.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
 require_relative '../../adapters/wallet'
-require_relative '../../models/wallet'
+require_relative '../../models/wallet/balance'
 
 module Lighstorm
-  module Controllers
+  module Controller
     module Wallet
       module Balance
         def self.fetch(components)
@@ -26,7 +26,7 @@ module Lighstorm
         end
 
         def self.model(data)
-          Models::Wallet.new(data)
+          Model::Wallet::Balance.new(data)
         end
       end
     end

data/controllers/wallet.rb

@@ -5,7 +5,7 @@ require_relative './concerns/impersonatable'
 require_relative './wallet/balance'
 
 module Lighstorm
-  module Controllers
+  module Controller
     module Wallet
       extend Impersonatable