lighstorm 0.0.12 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 026ad34b202b5f4367e287568b22126ba4850145b9d3e9398cdfd2f70d9e25d7
-  data.tar.gz: 63b0809d04e688ceab5c7a3ff5e9ee05588c8fece0a7b6323f96b8f0a871f9eb
+  metadata.gz: 9b600975d39699ef54c291ec8a06aa0d3f4284df248df2093ed85c3656dea685
+  data.tar.gz: 6d6373c5013c5ed9ad9f8479b26072da38f5847ba1e22b845132bd01167cacf2
 SHA512:
-  metadata.gz: 00ba8bf8fa6f5930abb796bdb00434401a31d30db6d26397ea1cebeb587ce404b942777dd0df6eed38d8e24fec5f6574afaf3d343108379f1d359f7def4a80ba
-  data.tar.gz: 39ebcc45331f332c5aa85e824245aec7e707bed958625d123cdb655f250610a361ae56a6dc0a8657ec34dcda977bd7e0630b47e82f0edb511b5cbf3a16b584bd
+  metadata.gz: 66a0b3ea07b3201a388b68cf91f38aad7d98ceecf1bd9138f699830c3539ea6522cfdb9a23479bebd3f88563a265fa04bc10e510c033eeb228dbbd039e97cc52
+  data.tar.gz: 32c16160feef6212038150df78f539c4b4adca382f440729217f3916871912f20fdbe2add7d4c74be22d14e0f3bb5e5369e6788124b6e6ad879368ffad60c948

data/.env.example

@@ -1,6 +1,21 @@
-LIGHSTORM_LND_ADDRESS=127.0.0.1:10009
-LIGHSTORM_CERTIFICATE_PATH=/lnd/tls.cert
-LIGHSTORM_MACAROON_PATH=/lnd/data/chain/bitcoin/mainnet/admin.macaroon
 LIGHSTORM_RUN_INTEGRATION_TESTS=false
 LIGHSTORM_RUN_INTEGRATION_TESTS_SLOW=false
 LIGHSTORM_DELETE_UNUSED_TEST_DATA=false
+
+# Option A: lndconnect
+# LIGHSTORM_LND_CONNECT=lndconnect://127.0.0.1:10009?cert=MIICJz...JBEERQ&macaroon=AgEDbG...45ukJ4
+
+# Option B: File Path
+# LIGHSTORM_LND_ADDRESS=127.0.0.1:10009
+# LIGHSTORM_LND_CERTIFICATE_PATH=/lnd/tls.cert
+# LIGHSTORM_LND_MACAROON_PATH=/lnd/data/chain/bitcoin/mainnet/admin.macaroon
+
+# Option C: Base64
+# LIGHSTORM_LND_ADDRESS=127.0.0.1:10009
+# LIGHSTORM_LND_CERTIFICATE=LS0tLS1CRU...UtLS0tLQo=
+# LIGHSTORM_LND_MACAROON=AgEDbG5kAv...inv45ukJ4=
+
+# Option D: Hex
+# LIGHSTORM_LND_ADDRESS=127.0.0.1:10009
+# LIGHSTORM_LND_CERTIFICATE=2d2d2d2d2d...2d2d2d2d0a
+# LIGHSTORM_LND_MACAROON=0201036c6e...bf8e6e909e

data/Gemfile.lock

@@ -1,9 +1,9 @@
 PATH
   remote: .
   specs:
-    lighstorm (0.0.12)
+    lighstorm (0.0.14)
       dotenv (~> 2.8, >= 2.8.1)
-      lnd-client (~> 0.0.5)
+      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.5)
+    lnd-client (0.0.7)
       grpc (~> 1.52)
     method_source (1.0.0)
     parallel (1.22.1)
@@ -51,7 +51,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
-    rubocop (1.48.0)
+    rubocop (1.48.1)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.2.0.0)

data/README.md

@@ -35,19 +35,25 @@ Although it tries to stay close to [Lightning's terminologies](https://docs.ligh
 Add to your `Gemfile`:
 
 ```ruby
-gem 'lighstorm', '~> 0.0.12'
+gem 'lighstorm', '~> 0.0.14'
 ```
 
 ```ruby
 require 'lighstorm'
 
-Lighstorm.config!(
-  lnd_address: '127.0.0.1:10009',
+# lndconnect
+Lighstorm.connect!(
+  'lndconnect://127.0.0.1:10009?cert=MIICJz...JBEERQ&macaroon=AgEDbG...45ukJ4'
+)
+
+# File Path
+Lighstorm.connect!(
+  address: '127.0.0.1:10009',
   certificate_path: '/lnd/tls.cert',
-  macaroon_path: '/lnd/data/chain/bitcoin/mainnet/admin.macaroon',
+  macaroon_path: '/lnd/data/chain/bitcoin/mainnet/admin.macaroon'
 )
 
-puts Lighstorm.version # => 0.0.12
+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/transaction.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class Transaction
+      def self.get_transactions(grpc)
+        {
+          _source: :get_transactions,
+          _key: Digest::SHA256.hexdigest(
+            [grpc[:time_stamp], grpc[:tx_hash], grpc[:amount], grpc[:total_fees]].join('/')
+          ),
+          at: Time.at(grpc[:time_stamp]),
+          amount: { millisatoshis: grpc[:amount] * 1000 },
+          fee: { millisatoshis: grpc[:total_fees] * 1000 },
+          hash: grpc[:tx_hash],
+          label: grpc[:label]
+        }
+      end
+    end
+  end
+end

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

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require 'singleton'
-
+require 'securerandom'
 require 'lnd-client'
 
 require_relative '../ports/dsl/lighstorm/errors'
@@ -10,50 +10,88 @@ module Lighstorm
   class LND
     include Singleton
 
-    attr_writer :config, :middleware
+    attr_writer :middleware
 
     def initialize
-      @config = nil
-      @client = nil
+      @default_key = SecureRandom.hex
       @middleware = ->(_key, &block) { block.call }
     end
 
+    def connect!(*params)
+      if params.last.is_a?(Hash)
+        unless params.last.key?(:lightning)
+          params.last[:lightning] = {
+            channel_args: { 'grpc.max_receive_message_length' => 1024 * 1024 * 50 }
+          }
+        end
+      else
+        params << {
+          lightning: { channel_args: { 'grpc.max_receive_message_length' => 1024 * 1024 * 50 } }
+        }
+      end
+
+      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
-      return @client if @client
+      try_to_connect_from_environment_variables! unless LNDClient.connections.include?(@default_key)
+      LNDClient.as(@default_key)
+    end
 
-      raise MissingCredentialsError, 'missing credentials' if @config.nil? && ENV.fetch(
-        'LIGHSTORM_CERTIFICATE_PATH', nil
-      ).nil?
+    def try_to_connect_from_environment_variables!
+      return connect!(ENV.fetch('LIGHSTORM_LND_CONNECT')) if ENV.fetch('LIGHSTORM_LND_CONNECT', nil)
 
-      @client = if @config
-                  create_client_from_config
-                else
-                  create_client_from_environment_variables
-                end
+      params = {}
 
-      @client.lightning(channel_args: { 'grpc.max_receive_message_length' => 1024 * 1024 * 50 })
+      raise MissingCredentialsError, 'missing credentials [address]' unless ENV.fetch('LIGHSTORM_LND_ADDRESS', nil)
 
-      @client
-    end
+      params[:address] = ENV.fetch('LIGHSTORM_LND_ADDRESS')
 
-    def create_client_from_config
-      LNDClient.new(
-        socket_address: @config[:lnd_address],
-        certificate_path: @config[:certificate_path],
-        macaroon_path: @config[:macaroon_path]
-      )
-    end
+      if ENV.fetch('LIGHSTORM_LND_CERTIFICATE', nil)
+        params[:certificate] = ENV.fetch('LIGHSTORM_LND_CERTIFICATE')
+      elsif ENV.fetch('LIGHSTORM_LND_CERTIFICATE_PATH', nil)
+        params[:certificate_path] = ENV.fetch('LIGHSTORM_LND_CERTIFICATE_PATH')
+      else
+        raise MissingCredentialsError, 'missing credentials [certificate]'
+      end
+
+      if ENV.fetch('LIGHSTORM_LND_MACAROON', nil)
+        params[:macaroon] = ENV.fetch('LIGHSTORM_LND_MACAROON')
+      elsif ENV.fetch('LIGHSTORM_LND_MACAROON_PATH', nil)
+        params[:macaroon_path] = ENV.fetch('LIGHSTORM_LND_MACAROON_PATH')
+      else
+        raise MissingCredentialsError, 'missing credentials [macaroon]'
+      end
 
-    def create_client_from_environment_variables
-      LNDClient.new(
-        socket_address: ENV.fetch('LIGHSTORM_LND_ADDRESS', nil),
-        certificate_path: ENV.fetch('LIGHSTORM_CERTIFICATE_PATH', nil),
-        macaroon_path: ENV.fetch('LIGHSTORM_MACAROON_PATH', nil)
-      )
+      connect!(params)
     end
   end
 end

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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require_relative '../invoice/all'
+require_relative '../payment/all'
+require_relative '../forward/all'
+require_relative '../transaction/all'
+require_relative '../../models/activity'
+
+module Lighstorm
+  module Controllers
+    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
+
+          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')
+            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
+
+            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')
+            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| Models::Activity.new(data) }
+        end
+      end
+    end
+  end
+end

data/controllers/activity.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative './concerns/impersonatable'
+
+require_relative './activity/all'
+
+module Lighstorm
+  module Controllers
+    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

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