lighstorm 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 26ecb1df57331f4013bed69eabf7722b49b5fdfa40fdca48a38e0b3f07d032c5
-  data.tar.gz: ca0632d8d04671db004ce82acb73d35b92f3527f9cb4b4f5171031bf19dfe56b
+  metadata.gz: 9b600975d39699ef54c291ec8a06aa0d3f4284df248df2093ed85c3656dea685
+  data.tar.gz: 6d6373c5013c5ed9ad9f8479b26072da38f5847ba1e22b845132bd01167cacf2
 SHA512:
-  metadata.gz: 2c8b91eaa213a149be5da9af101dc0fc5bfa4add56b709f74d776cb20a96dd1020f2f33f6cb113ec24b257e55b2a2ded19ffa97776f4bf45dc4932760a990585
-  data.tar.gz: b3437b6dfa13b39eb761acd8cc6685d4c62ec9f388615de66d55e2e9afb7eb194ef6705a85cb401a0daa7af7c258329a51d50ed5d41aa423dd807325c0bb7bfc
+  metadata.gz: 66a0b3ea07b3201a388b68cf91f38aad7d98ceecf1bd9138f699830c3539ea6522cfdb9a23479bebd3f88563a265fa04bc10e510c033eeb228dbbd039e97cc52
+  data.tar.gz: 32c16160feef6212038150df78f539c4b4adca382f440729217f3916871912f20fdbe2add7d4c74be22d14e0f3bb5e5369e6788124b6e6ad879368ffad60c948

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    lighstorm (0.0.13)
+    lighstorm (0.0.14)
       dotenv (~> 2.8, >= 2.8.1)
-      lnd-client (~> 0.0.6)
+      lnd-client (~> 0.0.7)
       zache (~> 0.12.0)
 
 GEM
@@ -22,7 +22,7 @@ GEM
       google-protobuf (~> 3.21)
       googleapis-common-protos-types (~> 1.0)
     json (2.6.3)
-    lnd-client (0.0.6)
+    lnd-client (0.0.7)
       grpc (~> 1.52)
     method_source (1.0.0)
     parallel (1.22.1)

data/README.md

@@ -35,7 +35,7 @@ Although it tries to stay close to [Lightning's terminologies](https://docs.ligh
 Add to your `Gemfile`:
 
 ```ruby
-gem 'lighstorm', '~> 0.0.13'
+gem 'lighstorm', '~> 0.0.14'
 ```
 
 ```ruby
@@ -53,7 +53,7 @@ Lighstorm.connect!(
   macaroon_path: '/lnd/data/chain/bitcoin/mainnet/admin.macaroon'
 )
 
-puts Lighstorm.version # => 0.0.13
+puts Lighstorm.version # => 0.0.14
 
 Lighstorm::Node.myself.alias # => icebaker/old-stone
 

data/adapters/connections/channel_node.rb

@@ -10,6 +10,7 @@ module Lighstorm
         data = {
           _source: :list_channels,
           state: grpc[:active] ? 'active' : 'inactive',
+          initiator: grpc[:initiator] && key == :local,
           accounting: { balance: { millisatoshis: grpc[:"#{key}_balance"] * 1000 } },
           node: Node.list_channels(grpc, key)
         }

data/adapters/edges/payment/purpose.rb

@@ -16,9 +16,9 @@ module Lighstorm
       def self.list_payments(grpc, node_get_info)
         return 'unknown' if grpc[:htlcs].empty?
 
-        return 'self-payment' if self_payment?(grpc[:htlcs].first[:route][:hops])
-        return 'peer-to-peer' if peer_to_peer?(grpc[:htlcs].first[:route][:hops])
-        return 'rebalance' if rebalance?(grpc[:htlcs].first[:route][:hops], node_get_info)
+        return 'self-payment' if self_payment?(grpc[:htlcs].last[:route][:hops])
+        return 'peer-to-peer' if peer_to_peer?(grpc[:htlcs].last[:route][:hops])
+        return 'rebalance' if rebalance?(grpc[:htlcs].last[:route][:hops], node_get_info)
 
         'payment'
       end

data/adapters/edges/payment.rb

@@ -30,8 +30,6 @@ module Lighstorm
       end
 
       def self.list_payments(grpc, node_myself, invoice_decode = nil)
-        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
-
         data = {
           _source: :list_payments,
           _key: _key(grpc),
@@ -45,7 +43,7 @@ module Lighstorm
 
         data[:secret] = data[:invoice][:secret]
 
-        htlc = grpc[:htlcs].first
+        htlc = grpc[:htlcs].last
 
         return data if htlc.nil?
 

data/adapters/invoice.rb

@@ -142,8 +142,6 @@ module Lighstorm
       end
 
       def self.list_payments(grpc, invoice_decode = nil)
-        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
-
         data = {
           _key: _key(grpc),
           _source: :list_payments,

data/adapters/wallet.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class Wallet
+      def self.balance(raw)
+        {
+          _key: Digest::SHA256.hexdigest(
+            [
+              raw[:at],
+              channel_balance(raw[:channel_balance])[:amount],
+              wallet_balance(raw[:wallet_balance])[:amount]
+            ].join('/')
+          ),
+          at: raw[:at],
+          bitcoin: wallet_balance(raw[:wallet_balance])[:amount],
+          lightning: channel_balance(raw[:channel_balance])[:amount],
+          total: { millisatoshis: (
+            wallet_balance(raw[:wallet_balance])[:amount][:millisatoshis] +
+            channel_balance(raw[:channel_balance])[:amount][:millisatoshis]
+          ) }
+        }
+      end
+
+      def self.wallet_balance(grpc)
+        {
+          _source: :wallet_balance,
+          amount: { millisatoshis: grpc[:total_balance] * 1000 }
+        }
+      end
+
+      def self.channel_balance(grpc)
+        {
+          _source: :channel_balance,
+          amount: { millisatoshis: grpc[:local_balance][:msat] }
+        }
+      end
+    end
+  end
+end

data/components/cache.rb

@@ -22,7 +22,7 @@ module Lighstorm
     end
 
     def safety_key(key)
-      key.gsub('.', '_').to_sym
+      key.gsub('.', '_').sub(/^\[.*\]:/, '').to_sym
     end
 
     def for(key, ttl: nil, params: {}, &block)

data/components/lnd.rb

@@ -33,23 +33,39 @@ module Lighstorm
       LNDClient.add_connection!(@default_key, *params)
     end
 
+    def as(id)
+      LNDClient.as(id)
+    end
+
+    def add_connection!(...)
+      LNDClient.add_connection!(...)
+    end
+
+    def connections(...)
+      LNDClient.connections(...)
+    end
+
+    def remove_connection!(...)
+      LNDClient.remove_connection!(...)
+    end
+
     def middleware(key, &block)
       @middleware.call(key, &block)
     end
 
+    def for(id)
+      as(id)&.connection
+    end
+
+    def default
+      client.connection.merge(id: @default_key)
+    end
+
     def client
       try_to_connect_from_environment_variables! unless LNDClient.connections.include?(@default_key)
       LNDClient.as(@default_key)
     end
 
-    def create_client_from_config
-      LNDClient.new(
-        socket_address: @config[:lnd_address],
-        certificate_path: @config[:certificate_path],
-        macaroon_path: @config[:macaroon_path]
-      )
-    end
-
     def try_to_connect_from_environment_variables!
       return connect!(ENV.fetch('LIGHSTORM_LND_CONNECT')) if ENV.fetch('LIGHSTORM_LND_CONNECT', nil)
 

data/controllers/action.rb

@@ -4,6 +4,10 @@ module Lighstorm
   module Controllers
     module Action
       Output = Struct.new(:data) do
+        def request
+          data[:request]
+        end
+
         def response
           data[:response]
         end
@@ -14,6 +18,7 @@ module Lighstorm
 
         def to_h
           {
+            request: request,
             response: response,
             result: result.to_h
           }

data/controllers/activity/all.rb

@@ -10,31 +10,91 @@ module Lighstorm
   module Controllers
     module Activity
       module All
-        def self.fetch(direction: nil, how: nil, limit: nil)
+        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 = []
 
-          Transaction::All.data.each do |transaction|
-            next if !how.nil? && how != 'on-chain'
+          # 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
+
+          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? ? 'in' : 'out',
-              layer: 'on-chain',
-              at: transaction[:at],
+              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[:amount][:millisatoshis] - transaction[:fee][:millisatoshis])
                                else
-                                 -transaction[:amount][:millisatoshis]
+                                 -(transaction[:amount][:millisatoshis] + transaction[:fee][:millisatoshis])
                                end
               },
-              how: 'on-chain',
+              how: transaction_how,
               message: nil,
               data: { transaction: transaction }
             }
           end
 
-          if direction.nil? || direction == 'in'
-            Invoice::All.data(spontaneous: true).filter do |invoice|
+          if (direction.nil? || direction == 'in') && (layer.nil? || layer == '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'
@@ -45,7 +105,7 @@ module Lighstorm
               invoice[:payments].each do |payment|
                 activities << {
                   direction: 'in',
-                  layer: 'off-chain',
+                  layer: 'lightning',
                   at: payment[:at],
                   amount: payment[:amount],
                   how: activity_how,
@@ -55,12 +115,12 @@ module Lighstorm
               end
             end
 
-            Forward::All.data.each do |forward|
+            Forward::All.data(components).each do |forward|
               next if !how.nil? && how != 'forwarding'
 
               activities << {
                 direction: 'in',
-                layer: 'off-chain',
+                layer: 'lightning',
                 at: forward[:at],
                 amount: forward[:fee],
                 how: 'forwarding',
@@ -70,8 +130,9 @@ module Lighstorm
             end
           end
 
-          if direction.nil? || direction == 'out'
+          if (direction.nil? || direction == 'out') && (layer.nil? || layer == 'lightning')
             Payment::All.data(
+              components,
               fetch: {
                 get_node_info: false,
                 lookup_invoice: false,
@@ -86,7 +147,7 @@ module Lighstorm
               # TODO: Improve performance by reducing invoice fields?
               activities << {
                 direction: 'out',
-                layer: 'off-chain',
+                layer: 'lightning',
                 at: payment[:at],
                 amount: payment[:amount],
                 how: activity_how,
@@ -96,7 +157,11 @@ module Lighstorm
             end
           end
 
-          activities = activities.sort_by { |activity| -activity[:at].to_i }
+          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?
 
@@ -110,11 +175,11 @@ module Lighstorm
           end
         end
 
-        def self.data(direction: nil, how: nil, limit: nil, &vcr)
+        def self.data(components, direction: nil, layer: nil, how: nil, order: nil, limit: nil, &vcr)
           raw = if vcr.nil?
-                  fetch(direction: direction, how: how, limit: limit)
+                  fetch(components, direction: direction, layer: layer, how: how, order: order, limit: limit)
                 else
-                  vcr.call(-> { fetch(direction: direction, how: how, limit: limit) })
+                  vcr.call(-> { fetch(components, direction: direction, how: how, order: order, limit: limit) })
                 end
 
           transform(raw)

data/controllers/activity.rb

@@ -1,16 +1,25 @@
 # frozen_string_literal: true
 
+require_relative './concerns/impersonatable'
+
 require_relative './activity/all'
 
 module Lighstorm
   module Controllers
     module Activity
-      def self.all(direction: nil, how: nil, limit: nil)
-        All.model(All.data(
-                    direction: direction,
-                    how: how,
-                    limit: limit
-                  ))
+      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

data/controllers/channel/actions/apply_gossip.rb

@@ -2,7 +2,6 @@
 
 require 'securerandom'
 
-require_relative '../../../ports/grpc'
 require_relative '../../../models/errors'
 require_relative '../../../models/edges/channel'
 require_relative '../../../adapters/edges/channel'
@@ -41,7 +40,7 @@ module Lighstorm
         ].freeze
 
         def self.perform(actual, gossip)
-          updated = Models::Channel.new(Adapter::Channel.subscribe_channel_graph(gossip))
+          updated = Models::Channel.new(Adapter::Channel.subscribe_channel_graph(gossip), nil)
 
           actual_dump = actual.dump
           updated_dump = updated.dump
@@ -99,7 +98,7 @@ module Lighstorm
           when 'partners/0/policy/htlc/minimum/millisatoshis',
                  'partners/1/policy/htlc/minimum/millisatoshis' then
             if actual.partners[change[:path][1]].policy.nil?
-              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({})
+              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({}, nil)
             end
 
             policy = actual.partners[change[:path][1]].policy
@@ -113,7 +112,7 @@ module Lighstorm
           when 'partners/0/policy/htlc/blocks/delta/minimum',
                 'partners/1/policy/htlc/blocks/delta/minimum' then
             if actual.partners[change[:path][1]].policy.nil?
-              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({})
+              actual.partners[change[:path][1]].policy = Lighstorm::Models::Policy.new({}, nil)
             end
 
             policy = actual.partners[change[:path][1]].policy

data/controllers/channel/actions/update_fee.rb

@@ -46,22 +46,26 @@ module Lighstorm
           grpc_request
         end
 
-        def self.call(grpc_request)
-          Lighstorm::Ports::GRPC.send(grpc_request[:service]).send(
+        def self.call(components, grpc_request)
+          components[:grpc].send(grpc_request[:service]).send(
             grpc_request[:method], grpc_request[:params]
           ).to_h
         end
 
-        def self.dispatch(grpc_request, &vcr)
-          vcr.nil? ? call(grpc_request) : vcr.call(-> { call(grpc_request) }, :dispatch)
+        def self.dispatch(components, grpc_request, &vcr)
+          if vcr.nil?
+            call(components, grpc_request)
+          else
+            vcr.call(-> { call(components, grpc_request) }, :dispatch)
+          end
         end
 
-        def self.perform(policy, transaction, params, preview: false, &vcr)
+        def self.perform(components, policy, transaction, params, preview: false, &vcr)
           grpc_request = prepare(policy.to_h, transaction.to_h, params)
 
           return grpc_request if preview
 
-          response = dispatch(grpc_request, &vcr)
+          response = dispatch(components, grpc_request, &vcr)
 
           raise UpdateChannelPolicyError.new(nil, response) unless response[:failed_updates].empty?
 
@@ -79,7 +83,7 @@ module Lighstorm
             token: token
           }
 
-          Action::Output.new({ response: response, result: policy })
+          Action::Output.new({ request: grpc_request, response: response, result: policy })
         end
       end
     end

data/controllers/channel/all.rb

@@ -11,11 +11,11 @@ module Lighstorm
   module Controllers
     module Channel
       module All
-        def self.fetch(limit: nil)
+        def self.fetch(components, limit: nil)
           data = {
             at: Time.now,
-            mine: Mine.fetch,
-            describe_graph: Ports::GRPC.lightning.describe_graph.edges
+            mine: Mine.fetch(components),
+            describe_graph: components[:grpc].lightning.describe_graph.edges
           }
 
           data[:describe_graph] = data[:describe_graph][0..limit - 1] unless limit.nil?
@@ -60,17 +60,21 @@ module Lighstorm
           data
         end
 
-        def self.data(limit: nil, &vcr)
-          raw = vcr.nil? ? fetch(limit: limit) : vcr.call(-> { fetch(limit: limit) })
+        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 { |data| transform(data, adapted) }
         end
 
-        def self.model(data)
+        def self.model(data, components)
           data.map do |node_data|
-            Lighstorm::Models::Channel.new(node_data)
+            Lighstorm::Models::Channel.new(node_data, components)
           end
         end
       end

data/controllers/channel/find_by_id.rb

@@ -11,22 +11,22 @@ module Lighstorm
   module Controllers
     module Channel
       module FindById
-        def self.fetch(id)
+        def self.fetch(components, id)
           data = {
             at: Time.now,
-            get_info: Ports::GRPC.lightning.get_info.to_h,
+            get_info: components[:grpc].lightning.get_info.to_h,
             # Ensure that we are getting fresh up-date data about our own fees.
-            fee_report: Ports::GRPC.lightning.fee_report.to_h,
-            get_chan_info: Ports::GRPC.lightning.get_chan_info(chan_id: id.to_i).to_h,
+            fee_report: components[:grpc].lightning.fee_report.to_h,
+            get_chan_info: components[:grpc].lightning.get_chan_info(chan_id: id.to_i).to_h,
             get_node_info: {},
             list_channels: []
           }
 
-          data[:get_node_info][data[:get_chan_info][:node1_pub]] = Ports::GRPC.lightning.get_node_info(
+          data[:get_node_info][data[:get_chan_info][:node1_pub]] = components[:grpc].lightning.get_node_info(
             pub_key: data[:get_chan_info][:node1_pub]
           ).to_h
 
-          data[:get_node_info][data[:get_chan_info][:node2_pub]] = Ports::GRPC.lightning.get_node_info(
+          data[:get_node_info][data[:get_chan_info][:node2_pub]] = components[:grpc].lightning.get_node_info(
             pub_key: data[:get_chan_info][:node2_pub]
           ).to_h
 
@@ -40,7 +40,7 @@ module Lighstorm
           if is_mine
             partner = partners.find { |p| p != data[:get_info][:identity_pubkey] }
 
-            data[:list_channels] = Ports::GRPC.lightning.list_channels(
+            data[:list_channels] = components[:grpc].lightning.list_channels(
               peer: [partner].pack('H*')
             ).channels.map(&:to_h)
           end
@@ -136,16 +136,16 @@ module Lighstorm
           data
         end
 
-        def self.data(id, &vcr)
-          raw = vcr.nil? ? fetch(id) : vcr.call(-> { fetch(id) })
+        def self.data(components, id, &vcr)
+          raw = vcr.nil? ? fetch(components, id) : vcr.call(-> { fetch(components, id) })
 
           adapted = adapt(raw)
 
           transform(adapted[:get_chan_info], adapted)
         end
 
-        def self.model(data)
-          Lighstorm::Models::Channel.new(data)
+        def self.model(data, components)
+          Lighstorm::Models::Channel.new(data, components)
         end
       end
     end

data/controllers/channel/mine.rb

@@ -9,27 +9,27 @@ module Lighstorm
   module Controllers
     module Channel
       module Mine
-        def self.fetch
+        def self.fetch(components)
           data = {
             at: Time.now,
-            get_info: Ports::GRPC.lightning.get_info.to_h,
+            get_info: components[:grpc].lightning.get_info.to_h,
             # Ensure that we are getting fresh up-date data about our own fees.
-            fee_report: Ports::GRPC.lightning.fee_report.to_h,
-            list_channels: Ports::GRPC.lightning.list_channels.channels.map(&:to_h),
+            fee_report: components[:grpc].lightning.fee_report.to_h,
+            list_channels: components[:grpc].lightning.list_channels.channels.map(&:to_h),
             get_chan_info: {},
             get_node_info: {}
           }
 
           data[:list_channels].each do |channel|
             unless data[:get_chan_info][channel[:chan_id]]
-              data[:get_chan_info][channel[:chan_id]] = Ports::GRPC.lightning.get_chan_info(
+              data[:get_chan_info][channel[:chan_id]] = components[:grpc].lightning.get_chan_info(
                 chan_id: channel[:chan_id]
               ).to_h
             end
 
             next if data[:get_node_info][channel[:remote_pubkey]]
 
-            data[:get_node_info][channel[:remote_pubkey]] = Ports::GRPC.lightning.get_node_info(
+            data[:get_node_info][channel[:remote_pubkey]] = components[:grpc].lightning.get_node_info(
               pub_key: channel[:remote_pubkey]
             ).to_h
           end
@@ -95,17 +95,17 @@ module Lighstorm
           data
         end
 
-        def self.data(&vcr)
-          raw = vcr.nil? ? fetch : vcr.call(-> { fetch })
+        def self.data(components, &vcr)
+          raw = vcr.nil? ? fetch(components) : vcr.call(-> { fetch(components) })
 
           adapted = adapt(raw)
 
           adapted[:list_channels].map { |data| transform(data, adapted) }
         end
 
-        def self.model(data)
+        def self.model(data, components)
           data.map do |node_data|
-            Lighstorm::Models::Channel.new(node_data)
+            Lighstorm::Models::Channel.new(node_data, components)
           end
         end
       end