lighstorm 0.0.2 → 0.0.4

data/adapters/edges/channel.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'digest'
+
+require_relative '../connections/channel_node'
+
+module Lighstorm
+  module Adapter
+    class Channel
+      def self._key(id, active)
+        Digest::SHA256.hexdigest(
+          [id, active].join('/')
+        )
+      end
+
+      def self.list_channels(grpc, at)
+        {
+          _source: :list_channels,
+          _key: _key(grpc[:chan_id], grpc[:active]),
+          # Standard JSON don't support BigInt, so, a String is safer.
+          id: grpc[:chan_id].to_s,
+          transaction: {
+            funding: {
+              id: grpc[:channel_point].split(':').first,
+              index: grpc[:channel_point].split(':').last.to_i
+            }
+          },
+          opened_at: DateTime.parse((at - grpc[:lifetime]).to_s),
+          up_at: DateTime.parse((at - grpc[:uptime]).to_s),
+          active: grpc[:active],
+          exposure: grpc[:private] ? 'private' : 'public',
+          accounting: {
+            capacity: { milisatoshis: grpc[:capacity] * 1000 },
+            sent: { milisatoshis: grpc[:total_satoshis_sent] * 1000 },
+            received: { milisatoshis: grpc[:total_satoshis_received] * 1000 },
+            unsettled: { milisatoshis: grpc[:unsettled_balance] * 1000 }
+          },
+          partners: [
+            ChannelNode.list_channels(grpc, :local),
+            ChannelNode.list_channels(grpc, :remote)
+          ]
+        }
+      end
+
+      def self.get_chan_info(grpc)
+        {
+          _source: :get_chan_info,
+          _key: _key(grpc[:channel_id], nil),
+          # Standard JSON don't support BigInt, so, a String is safer.
+          id: grpc[:channel_id].to_s,
+          accounting: {
+            capacity: { milisatoshis: grpc[:capacity] * 1000 }
+          },
+          partners: [
+            ChannelNode.get_chan_info(grpc, 1),
+            ChannelNode.get_chan_info(grpc, 2)
+          ]
+        }
+      end
+
+      def self.describe_graph(grpc)
+        {
+          _source: :describe_graph,
+          _key: _key(grpc[:channel_id], nil),
+          # Standard JSON don't support BigInt, so, a String is safer.
+          id: grpc[:channel_id].to_s,
+          exposure: 'public',
+          accounting: {
+            capacity: { milisatoshis: grpc[:capacity] * 1000 }
+          },
+          partners: [
+            ChannelNode.describe_graph(grpc, 1),
+            ChannelNode.describe_graph(grpc, 2)
+          ]
+        }
+      end
+    end
+  end
+end

data/adapters/edges/forward.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class Forward
+      def self.forwarding_history(grpc)
+        {
+          _source: :forwarding_history,
+          _key: _key(grpc),
+          at: DateTime.parse(Time.at(grpc[:timestamp_ns] / 1e+9).to_s),
+          fee: { milisatoshis: grpc[:fee_msat] },
+          in: {
+            amount: { milisatoshis: grpc[:amt_in_msat] },
+            channel: {
+              id: grpc[:chan_id_in].to_s
+            }
+          },
+          out: {
+            amount: { milisatoshis: grpc[:amt_out_msat] },
+            channel: {
+              id: grpc[:chan_id_out].to_s
+            }
+          }
+        }
+      end
+
+      def self._key(grpc)
+        Digest::SHA256.hexdigest(
+          [
+            grpc[:timestamp_ns],
+            grpc[:chan_id_in], grpc[:chan_id_out],
+            grpc[:amt_in_msat], grpc[:fee_msat]
+          ].join('/')
+        )
+      end
+    end
+  end
+end

data/adapters/edges/payment/purpose.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Lighstorm
+  module Adapter
+    class Purpose
+      def self.list_payments(grpc, node_get_info)
+        return 'self-payment' if self_payment?(grpc)
+        return 'peer-to-peer' if peer_to_peer?(grpc)
+        return 'rebalance' if rebalance?(grpc, node_get_info)
+
+        'payment'
+      end
+
+      def self.self_payment?(grpc)
+        grpc[:htlcs].first[:route][:hops].size == 2 &&
+          grpc[:htlcs].first[:route][:hops][0][:chan_id] == grpc[:htlcs].first[:route][:hops][1][:chan_id]
+      end
+
+      def self.peer_to_peer?(grpc)
+        grpc[:htlcs].first[:route][:hops].size == 1
+      end
+
+      def self.rebalance?(grpc, node_get_info)
+        return false if grpc[:htlcs].first[:route][:hops].size <= 2
+
+        destination_public_key = grpc[:htlcs].first[:route][:hops].last[:pub_key]
+
+        node_get_info[:identity_pubkey] == destination_public_key
+      end
+    end
+  end
+end

data/adapters/edges/payment.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'date'
+
+require_relative '../connections/payment_channel'
+require_relative 'payment/purpose'
+
+require_relative '../payment_request'
+
+require_relative '../../ports/dsl/lighstorm/errors'
+
+module Lighstorm
+  module Adapter
+    class Payment
+      def self._key(grpc)
+        Digest::SHA256.hexdigest(
+          [
+            grpc[:payment_request],
+            grpc[:creation_time_ns],
+            grpc[:resolve_time_ns],
+            grpc[:status]
+          ].join('/')
+        )
+      end
+
+      def self.list_payments(grpc, node_get_info)
+        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
+
+        data = {
+          _source: :list_payments,
+          _key: _key(grpc),
+          created_at: DateTime.parse(Time.at(grpc[:creation_time_ns] / 1e+9).to_s),
+          status: grpc[:status].to_s.downcase,
+          fee: { milisatoshis: grpc[:fee_msat] },
+          purpose: Purpose.list_payments(grpc, node_get_info),
+          request: PaymentRequest.list_payments(grpc),
+          hops: grpc[:htlcs].first[:route][:hops].map.with_index do |raw_hop, i|
+            hop = PaymentChannel.list_payments(raw_hop, i)
+            hop[:channel][:target] = { public_key: raw_hop[:pub_key] }
+            hop
+          end
+        }
+
+        if grpc[:htlcs].first[:resolve_time_ns]
+          data[:settled_at] = DateTime.parse(Time.at(grpc[:htlcs].first[:resolve_time_ns] / 1e+9).to_s)
+        end
+
+        data
+      end
+    end
+  end
+end

data/adapters/invoice.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'digest'
+
+require_relative 'payment_request'
+
+module Lighstorm
+  module Adapter
+    class Invoice
+      def self.lookup_invoice(grpc)
+        adapted = list_or_lookup(grpc)
+
+        adapted[:_source] = :lookup_invoice
+        adapted[:request] = PaymentRequest.lookup_invoice(grpc)
+
+        adapted
+      end
+
+      def self.list_invoices(grpc)
+        adapted = list_or_lookup(grpc)
+
+        adapted[:_source] = :list_invoices
+        adapted[:request] = PaymentRequest.list_invoices(grpc)
+
+        adapted
+      end
+
+      def self.list_or_lookup(grpc)
+        {
+          _key: _key(grpc),
+          created_at: DateTime.parse(Time.at(grpc[:creation_date]).to_s),
+          settle_at: DateTime.parse(Time.at(grpc[:settle_date]).to_s),
+          state: grpc[:state].to_s.downcase
+        }
+      end
+
+      def self._key(grpc)
+        Digest::SHA256.hexdigest(
+          [
+            grpc[:creation_date],
+            grpc[:settle_date],
+            grpc[:payment_request],
+            grpc[:state]
+          ].join('/')
+        )
+      end
+    end
+  end
+end

data/adapters/nodes/node.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    class Node
+      def self._key(public_key)
+        Digest::SHA256.hexdigest(
+          [public_key].join('/')
+        )
+      end
+
+      def self.get_chan_info(grpc, index)
+        {
+          _source: :get_chan_info,
+          _key: _key(grpc[:"node#{index}_pub"]),
+          public_key: grpc[:"node#{index}_pub"]
+        }
+      end
+
+      def self.list_channels(grpc, key)
+        {
+          _source: :list_channels,
+          _key: _key(key == :remote ? grpc[:remote_pubkey] : nil),
+          public_key: key == :remote ? grpc[:remote_pubkey] : nil
+        }
+      end
+
+      def self.get_info(grpc)
+        {
+          _source: :get_info,
+          _key: _key(grpc[:identity_pubkey]),
+          public_key: grpc[:identity_pubkey],
+          alias: grpc[:alias],
+          color: grpc[:color],
+          platform: {
+            blockchain: grpc[:chains][0][:chain],
+            network: grpc[:chains][0][:network],
+            lightning: {
+              implementation: 'lnd',
+              version: grpc[:version]
+            }
+          }
+        }
+      end
+
+      def self.get_node_info(grpc)
+        {
+          _source: :get_node_info,
+          _key: _key(grpc[:node][:pub_key]),
+          public_key: grpc[:node][:pub_key],
+          alias: grpc[:node][:alias],
+          color: grpc[:node][:color]
+        }
+      end
+
+      def self.describe_graph(grpc)
+        {
+          _source: :describe_graph,
+          _key: _key(grpc[:pub_key]),
+          public_key: grpc[:pub_key],
+          alias: grpc[:alias],
+          color: grpc[:color]
+        }
+      end
+
+      def self.describe_graph_from_channel(grpc, index)
+        {
+          _source: :describe_graph,
+          _key: _key(grpc[:"node#{index}_pub"]),
+          public_key: grpc[:"node#{index}_pub"]
+        }
+      end
+    end
+  end
+end

data/adapters/payment_request.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'date'
+require 'digest'
+
+require_relative '../ports/dsl/lighstorm/errors'
+
+module Lighstorm
+  module Adapter
+    class PaymentRequest
+      def self.decode_pay_req(grpc)
+        {
+          _source: :decode_pay_req,
+          amount: { milisatoshis: grpc[:num_msat] },
+          description: {
+            memo: grpc[:description],
+            hash: grpc[:description_hash] == '' ? nil : grpc[:description_hash]
+          },
+          address: grpc[:payment_addr].unpack1('H*'),
+          secret: {
+            hash: grpc[:payment_hash]
+          }
+        }
+      end
+
+      def self.lookup_invoice(grpc)
+        adapted = list_or_lookup_invoice(grpc)
+        adapted[:_source] = :lookup_invoice
+        adapted
+      end
+
+      def self.list_invoices(grpc)
+        adapted = list_or_lookup_invoice(grpc)
+        adapted[:_source] = :list_invoices
+        adapted
+      end
+
+      def self.list_or_lookup_invoice(grpc)
+        {
+          code: grpc[:payment_request],
+          amount: { milisatoshis: grpc[:value_msat] },
+          description: {
+            memo: grpc[:memo],
+            hash: grpc[:description_hash] == '' ? nil : grpc[:description_hash]
+          },
+          address: grpc[:payment_addr].unpack1('H*'),
+          secret: {
+            preimage: grpc[:r_preimage].unpack1('H*'),
+            hash: grpc[:r_hash].unpack1('H*')
+          }
+        }
+      end
+
+      def self.list_payments(grpc)
+        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
+
+        data = {
+          _source: :list_payments,
+          code: grpc[:payment_request],
+          amount: { milisatoshis: grpc[:value_msat] },
+          secret: {
+            preimage: grpc[:payment_preimage],
+            hash: grpc[:payment_hash]
+          }
+        }
+
+        grpc[:htlcs].first[:route][:hops].map do |raw_hop|
+          if raw_hop[:mpp_record] && raw_hop[:mpp_record][:payment_addr]
+            data[:address] = raw_hop[:mpp_record][:payment_addr].unpack1('H*')
+          end
+        end
+
+        data
+      end
+    end
+  end
+end

data/components/cache.rb

@@ -5,6 +5,7 @@ require 'singleton'
 require 'zache'
 
 require_relative '../static/cache'
+require_relative '../ports/dsl/lighstorm/errors'
 
 module Lighstorm
   class Cache
@@ -23,7 +24,7 @@ module Lighstorm
     def for(key, ttl: nil, params: {}, &block)
       if ttl.nil?
         ttl = Lighstorm::Static::CACHE[key.sub('lightning.', '').to_sym]
-        raise "missing ttl for #{key}" if ttl.nil?
+        raise MissingTTLError, "missing ttl for #{key} static/cache.rb" if ttl.nil?
 
         ttl = ttl[:ttl]
       end
@@ -36,7 +37,7 @@ module Lighstorm
     end
 
     def build_key_for(key, params)
-      return key unless params.size.positive?
+      return key unless !params.nil? && params.size.positive?
 
       key_params = []
       params.keys.sort.each do |param_key|

data/components/lnd.rb

@@ -4,6 +4,8 @@ require 'singleton'
 
 require 'lnd-client'
 
+require_relative '../ports/dsl/lighstorm/errors'
+
 module Lighstorm
   class LND
     include Singleton
@@ -23,7 +25,9 @@ module Lighstorm
     def client
       return @client if @client
 
-      raise 'missing credentials' if @config.nil? && ENV.fetch('LIGHSTORM_CERTIFICATE_PATH', nil).nil?
+      raise MissingCredentialsError, 'missing credentials' if @config.nil? && ENV.fetch(
+        'LIGHSTORM_CERTIFICATE_PATH', nil
+      ).nil?
 
       @client = if @config
                   create_client_from_config

data/controllers/channel/actions/update_fee.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require_relative '../../../ports/grpc'
+require_relative '../../../models/errors'
+require_relative '../../../models/satoshis'
+require_relative '../../../models/rate'
+
+module Lighstorm
+  module Controllers
+    module Channel
+      module UpdateFee
+        def self.perform(policy, params, preview: false, fake: false)
+          grpc_request = {
+            service: :lightning,
+            method: :update_channel_policy,
+            params: {
+              chan_point: {
+                funding_txid_str: policy.transaction.funding.id,
+                output_index: policy.transaction.funding.index
+              },
+              base_fee_msat: policy.fee.base.milisatoshis,
+              fee_rate_ppm: policy.fee.rate.parts_per_million,
+              time_lock_delta: policy.htlc.blocks.delta.minimum,
+              max_htlc_msat: policy.htlc.maximum.milisatoshis,
+              min_htlc_msat: policy.htlc.minimum.milisatoshis
+            }
+          }
+
+          if params[:rate] && params[:rate][:parts_per_million]
+            if (params[:rate][:parts_per_million]).negative?
+              raise Errors::NegativeNotAllowedError, "fee rate can't be negative: #{params[:rate][:parts_per_million]}"
+            end
+
+            grpc_request[:params][:fee_rate_ppm] = params[:rate][:parts_per_million]
+          end
+
+          if params[:base] && params[:base][:milisatoshis]
+            if (params[:base][:milisatoshis]).negative?
+              raise Errors::NegativeNotAllowedError, "fee base can't be negative: #{params[:base][:milisatoshis]}"
+            end
+
+            grpc_request[:params][:base_fee_msat] = params[:base][:milisatoshis]
+          end
+
+          return grpc_request if preview
+
+          response = if fake
+                       :fake
+                     else
+                       LND.instance.middleware("lightning.#{grpc_request[:method]}") do
+                         LND.instance.client.lightning.send(grpc_request[:method], grpc_request[:params])
+                       end
+                     end
+
+          raise UpdateChannelPolicyError.new(nil, response) unless fake || response.failed_updates.empty?
+
+          token = SecureRandom.hex
+          policy.fee.prepare_token!(token)
+          policy.fee.base = {
+            value: Models::Satoshis.new(milisatoshis: grpc_request[:params][:base_fee_msat]),
+            token: token
+          }
+
+          token = SecureRandom.hex
+          policy.fee.prepare_token!(token)
+          policy.fee.rate = {
+            value: Models::Rate.new(parts_per_million: grpc_request[:params][:fee_rate_ppm]),
+            token: token
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/controllers/channel/all.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require_relative 'mine'
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/edges/channel'
+require_relative '../../adapters/nodes/node'
+require_relative '../../adapters/connections/channel_node/fee'
+
+module Lighstorm
+  module Controllers
+    module Channel
+      module All
+        def self.fetch(limit: nil)
+          data = {
+            at: Time.now,
+            mine: Mine.fetch,
+            describe_graph: Ports::GRPC.lightning.describe_graph.edges
+          }
+
+          data[:describe_graph] = data[:describe_graph][0..limit - 1] unless limit.nil?
+
+          data
+        end
+
+        def self.adapt(raw)
+          mine_adapted = Mine.adapt(raw[:mine])
+
+          mine = mine_adapted[:list_channels].map do |data|
+            Mine.transform(data, mine_adapted)
+          end
+
+          adapted = {
+            mine: {},
+            describe_graph: raw[:describe_graph].map do |raw_channel|
+              Lighstorm::Adapter::Channel.describe_graph(raw_channel.to_h)
+            end
+          }
+
+          mine.each do |channel|
+            adapted[:mine][channel[:id]] = channel
+          end
+
+          adapted
+        end
+
+        def self.transform(data, adapted)
+          return adapted[:mine][data[:id]] if adapted[:mine][data[:id]]
+
+          data[:known] = true
+          data[:mine] = false
+
+          data[:partners].each do |partner|
+            partner[:node][:platform] = {
+              blockchain: adapted[:mine].first[1][:partners][0][:node][:platform][:blockchain],
+              network: adapted[:mine].first[1][:partners][0][:node][:platform][:network]
+            }
+          end
+
+          data
+        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 { |data| transform(data, adapted) }
+        end
+
+        def self.model(data)
+          data.map do |node_data|
+            Lighstorm::Models::Channel.new(node_data)
+          end
+        end
+      end
+    end
+  end
+end