lighstorm 0.0.1 → 0.0.3

data/models/connections/payment_channel.rb

@@ -8,13 +8,16 @@ module Lighstorm
     class PaymentChannel
       KIND = :connection
 
-      def initialize(raw_hop, hop_index)
+      def initialize(raw_hop, hop_index, respond_info: true)
+        @respond_info = respond_info
         @raw_hop = raw_hop
-        @index = hop_index
+        @hop = hop_index
       end
 
+      attr_reader :hop
+
       def channel
-        @channel ||= Channel.find_by_id(@raw_hop.chan_id)
+        Channel.find_by_id(@raw_hop.chan_id)
       end
 
       def amount
@@ -34,24 +37,35 @@ module Lighstorm
       end
 
       def to_h
-        {
-          hop: @index,
+        response = {
+          hop: hop,
           amount: amount.to_h,
           fee: {
             milisatoshis: fee.milisatoshis,
             parts_per_million: fee.parts_per_million(amount.milisatoshis)
           },
           channel: {
-            id: channel.id,
-            partner: {
-              node: {
-                alias: partner_node&.alias,
-                public_key: partner_node&.public_key,
-                color: partner_node&.color
-              }
+            id: @raw_hop.chan_id.to_s,
+            node: {
+              public_key: @raw_hop.pub_key
             }
           }
         }
+
+        return response unless @respond_info
+
+        response[:channel] = {
+          id: channel.id,
+          partner: {
+            node: {
+              alias: partner_node&.alias,
+              public_key: partner_node&.public_key,
+              color: partner_node&.color
+            }
+          }
+        }
+
+        response
       end
     end
   end

data/models/edges/channel/accounting.rb

@@ -10,34 +10,50 @@ module Lighstorm
       end
 
       def capacity
-        @capacity ||= Satoshis.new(milisatoshis: @channel.data[:get_chan_info].capacity * 1000)
+        if @channel.data[:get_chan_info]
+          @capacity ||= Satoshis.new(milisatoshis: @channel.data[:get_chan_info].capacity * 1000)
+        elsif @channel.data[:describe_graph]
+          @capacity ||= Satoshis.new(milisatoshis: @channel.data[:describe_graph].capacity * 1000)
+        end
       end
 
       def sent
+        return nil unless @channel.data[:list_channels]
+
         @sent ||= Satoshis.new(milisatoshis: (
                          @channel.data[:list_channels][:channels].first.total_satoshis_sent.to_f * 1000.0
                        ))
       end
 
       def received
+        return nil unless @channel.data[:list_channels]
+
         @received ||= Satoshis.new(milisatoshis: (
                          @channel.data[:list_channels][:channels].first.total_satoshis_received.to_f * 1000.0
                        ))
       end
 
       def unsettled
+        return nil unless @channel.data[:list_channels]
+
         @unsettled ||= Satoshis.new(milisatoshis: (
                          @channel.data[:list_channels][:channels].first.unsettled_balance.to_f * 1000.0
                        ))
       end
 
       def to_h
-        {
-          capacity: capacity.to_h,
-          sent: sent.to_h,
-          received: received.to_h,
-          unsettled: unsettled.to_h
-        }
+        if @channel.data[:get_chan_info]
+          {
+            capacity: capacity.to_h,
+            sent: sent.to_h,
+            received: received.to_h,
+            unsettled: unsettled.to_h
+          }
+        else
+          {
+            capacity: capacity.to_h
+          }
+        end
       end
     end
   end

data/models/edges/channel.rb

@@ -17,48 +17,57 @@ module Lighstorm
     class Channel
       KIND = :edge
 
-      attr_reader :id, :data
+      attr_reader :data
 
       def self.all
-        response = Cache.for('lightning.list_channels', ttl: 1) do
+        response = LND.instance.middleware('lightning.describe_graph') do
+          LND.instance.client.lightning.describe_graph
+        end
+
+        response.edges.map do |raw_channel|
+          Channel.new({ describe_graph: raw_channel })
+        end
+      end
+
+      def self.mine
+        response = Cache.for('lightning.list_channels') do
           LND.instance.middleware('lightning.list_channels') do
             LND.instance.client.lightning.list_channels
           end
         end
 
         response.channels.map do |channel|
-          Channel.find_by_id(channel.chan_id)
+          Channel.find_by_id(channel.chan_id.to_s)
         end
       end
 
-      def self.first
-        all.first
-      end
-
-      def self.last
-        all.last
-      end
-
       def self.find_by_id(id)
         Channel.new({ id: id })
       end
 
+      def id
+        # Standard JSON don't support BigInt, so, a String is safer.
+        @id.to_s
+      end
+
       def initialize(params)
-        begin
-          response = Cache.for(
-            'lightning.get_chan_info',
-            ttl: 1, params: { chan_id: params[:id] }
-          ) do
-            LND.instance.middleware('lightning.get_chan_info') do
-              LND.instance.client.lightning.get_chan_info(chan_id: params[:id])
+        if params[:id]
+          begin
+            response = Cache.for('lightning.get_chan_info', params: { chan_id: params[:id].to_i }) do
+              LND.instance.middleware('lightning.get_chan_info') do
+                LND.instance.client.lightning.get_chan_info(chan_id: params[:id].to_i)
+              end
             end
-          end
 
-          @data = { get_chan_info: response }
-          @id = @data[:get_chan_info].channel_id
-        rescue StandardError => _e
-          @data = { get_chan_info: nil }
-          @id = params[:id]
+            @data = { get_chan_info: response }
+            @id = @data[:get_chan_info].channel_id
+          rescue StandardError => e
+            @data = { get_chan_info: nil, error: e }
+            @id = params[:id]
+          end
+        elsif params[:describe_graph]
+          @data = { describe_graph: params[:describe_graph] }
+          @id = @data[:describe_graph].channel_id
         end
 
         fetch_from_fee_report!
@@ -67,11 +76,21 @@ module Lighstorm
         calculate_times_after_list_channels!
       end
 
+      def error?
+        !@data[:error].nil?
+      end
+
+      def error
+        @data[:error]
+      end
+
       def active
         @data[:list_channels] ? @data[:list_channels][:channels].first.active : nil
       end
 
       def exposure
+        return 'public' if @data[:describe_graph]
+
         return unless @data[:list_channels]
 
         @data[:list_channels][:channels].first.private ? 'private' : 'public'
@@ -94,24 +113,70 @@ module Lighstorm
       end
 
       def accounting
-        return nil unless @data[:get_chan_info]
-
         @accounting ||= ChannelAccounting.new(self)
       end
 
+      def partners(fetch: false)
+        @partners ||= if mine?
+                        [myself, partner]
+                      elsif @data[:describe_graph]
+                        [
+                          ChannelNode.new(
+                            self,
+                            Node.new({ public_key: @data[:describe_graph].node1_pub }, fetch: fetch)
+                          ),
+                          ChannelNode.new(
+                            self,
+                            Node.new({ public_key: @data[:describe_graph].node2_pub }, fetch: fetch)
+                          )
+                        ]
+                      elsif @data[:get_chan_info]
+                        [
+                          ChannelNode.new(
+                            self,
+                            Node.new({ public_key: @data[:get_chan_info].node1_pub }, fetch: fetch)
+                          ),
+                          ChannelNode.new(
+                            self,
+                            Node.new({ public_key: @data[:get_chan_info].node2_pub }, fetch: fetch)
+                          )
+                        ]
+                      else
+                        raise 'missing data'
+                      end
+      end
+
+      def mine?
+        my_node = Node.myself.public_key
+
+        if @data[:get_chan_info]
+          (
+            @data[:get_chan_info].node1_pub == my_node || @data[:get_chan_info].node2_pub == my_node
+          )
+        elsif @data[:describe_graph]
+          (
+            @data[:describe_graph].node1_pub == my_node || @data[:describe_graph].node2_pub == my_node
+          )
+        else
+          false
+        end
+      end
+
       def myself
-        return nil unless @data[:get_chan_info]
+        raise 'not your channel' unless mine?
 
         @myself ||= ChannelNode.new(self, Node.myself)
       end
 
       def partner
-        return nil unless @data[:get_chan_info]
+        raise 'not your channel' unless mine?
+
+        key = @data[:get_chan_info] ? :get_chan_info : :describe_graph
 
-        public_key = if @data[:get_chan_info].node1_pub == myself.node.public_key
-                       @data[:get_chan_info].node2_pub
+        public_key = if @data[key].node1_pub == myself.node.public_key
+                       @data[key].node2_pub
                      else
-                       @data[:get_chan_info].node1_pub
+                       @data[key].node1_pub
                      end
 
         @partner ||= ChannelNode.new(self, Node.find_by_public_key(public_key))
@@ -120,28 +185,39 @@ module Lighstorm
       def raw
         {
           get_chan_info: @data[:get_chan_info].to_h,
-          list_channels: { channels: @data[:list_channels][:channels].map(&:to_h) }
+          describe_graph: @data[:describe_graph].to_h,
+          list_channels: {
+            channels: @data[:list_channels] ? @data[:list_channels][:channels].map(&:to_h) : nil
+          }
         }
       end
 
       def to_h
-        {
-          id: id,
-          opened_at: opened_at,
-          up_at: up_at,
-          active: active,
-          exposure: exposure,
-          accounting: accounting.to_h,
-          partner: partner.to_h,
-          myself: myself.to_h
-        }
+        if @data[:get_chan_info]
+          {
+            id: id,
+            opened_at: opened_at,
+            up_at: up_at,
+            active: active,
+            exposure: exposure,
+            accounting: accounting.to_h,
+            partner: partner.to_h,
+            myself: myself.to_h
+          }
+        else
+          {
+            id: id,
+            accounting: accounting.to_h,
+            partners: partners.map(&:to_h)
+          }
+        end
       end
 
       private
 
       # Ensure that we are getting fresh up-date data about our own fees.
       def fetch_from_fee_report!
-        response = Cache.for('lightning.fee_report', ttl: 1) do
+        response = Cache.for('lightning.fee_report') do
           LND.instance.middleware('lightning.fee_report') do
             LND.instance.client.lightning.fee_report
           end
@@ -156,7 +232,7 @@ module Lighstorm
       end
 
       def fetch_from_list_channels!
-        response = Cache.for('lightning.list_channels', ttl: 1) do
+        response = Cache.for('lightning.list_channels') do
           LND.instance.middleware('lightning.list_channels') do
             LND.instance.client.lightning.list_channels
           end

data/models/edges/forward.rb

@@ -7,6 +7,7 @@ require 'date'
 require_relative '../satoshis'
 
 require_relative '../connections/forward_channel'
+require_relative 'groups/channel_forwards'
 
 module Lighstorm
   module Models
@@ -15,16 +16,21 @@ module Lighstorm
 
       attr_reader :data
 
-      def self.all(limit: nil)
+      def self.all(limit: nil, raw: false, info: true)
         last_offset = 0
 
         forwards = []
 
         loop do
-          response = LND.instance.middleware('lightning.forwarding_history') do
-            LND.instance.client.lightning.forwarding_history(
-              peer_alias_lookup: true, index_offset: last_offset
-            )
+          response = Cache.for(
+            'lightning.forwarding_history',
+            params: { peer_alias_lookup: true, index_offset: last_offset }
+          ) do
+            LND.instance.middleware('lightning.forwarding_history') do
+              LND.instance.client.lightning.forwarding_history(
+                peer_alias_lookup: true, index_offset: last_offset
+              )
+            end
           end
 
           response.forwarding_events.each { |raw_forward| forwards << raw_forward }
@@ -41,7 +47,9 @@ module Lighstorm
 
         forwards = forwards[0..limit - 1] unless limit.nil?
 
-        forwards.map { |raw_forward| Forward.new(raw_forward) }
+        return forwards if raw
+
+        forwards.map { |raw_forward| Forward.new(raw_forward, respond_info: info) }
       end
 
       def self.first
@@ -52,7 +60,52 @@ module Lighstorm
         all.last
       end
 
-      def initialize(raw)
+      def self.group_by_channel(direction: :out, hours_ago: nil, limit: nil, info: true)
+        raw_forwards = all(raw: true)
+
+        direction = direction.to_sym
+
+        groups = {}
+
+        raw_forwards.each do |raw_forward|
+          channel_id = direction == :in ? raw_forward.chan_id_in : raw_forward.chan_id_out
+
+          if hours_ago
+            forward_hours_ago = (
+              Time.now - Time.at(raw_forward.timestamp_ns / 1e+9)
+            ).to_f / 3600
+
+            next if forward_hours_ago > hours_ago
+          end
+
+          unless groups[channel_id]
+            groups[channel_id] = {
+              last_at: nil,
+              analysis: { count: 0, sums: { amount: 0, fee: 0 } },
+              direction => { id: channel_id }
+            }
+          end
+
+          groups[channel_id][:analysis][:count] += 1
+          groups[channel_id][:analysis][:sums][:amount] += raw_forward.amt_in_msat
+          groups[channel_id][:analysis][:sums][:fee] += raw_forward.fee_msat
+
+          if groups[channel_id][:last_at].nil? || raw_forward.timestamp_ns > groups[channel_id][:last_at]
+            groups[channel_id][:last_at] = raw_forward.timestamp_ns
+            groups[channel_id][:sample] = raw_forward
+          end
+        end
+
+        groups = groups.values.sort_by { |group| - group[:last_at] }
+                       .sort_by { |group| - group[:analysis][:count] }
+
+        groups = groups[0..limit - 1] unless limit.nil?
+
+        groups.map { |raw_group| ChannelForwardsGroup.new(direction, raw_group) }
+      end
+
+      def initialize(raw, respond_info: true)
+        @respond_info = respond_info
         @data = { forwarding_history: { forwarding_events: [raw] } }
       end
 
@@ -63,7 +116,9 @@ module Lighstorm
       end
 
       def at
-        DateTime.parse(Time.at(@data[:forwarding_history][:forwarding_events].first.timestamp).to_s)
+        DateTime.parse(Time.at(
+          @data[:forwarding_history][:forwarding_events].first.timestamp_ns / 1e+9
+        ).to_s)
       end
 
       def fee
@@ -71,11 +126,11 @@ module Lighstorm
       end
 
       def in
-        @in ||= ForwardChannel.new(:in, self)
+        @in ||= ForwardChannel.new(:in, self, respond_info: @respond_info)
       end
 
       def out
-        @out ||= ForwardChannel.new(:out, self)
+        @out ||= ForwardChannel.new(:out, self, respond_info: @respond_info)
       end
 
       def to_h

data/models/edges/groups/analysis.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Models
+    class ChannelForwardsGroup
+      Analysis = Struct.new(:analysis) do
+        def count
+          analysis[:count]
+        end
+
+        def sums
+          Struct.new(:sums) do
+            def amount
+              Satoshis.new(milisatoshis: sums[:amount])
+            end
+
+            def fee
+              Satoshis.new(milisatoshis: sums[:fee])
+            end
+
+            def to_h
+              {
+                amount: amount.to_h,
+                fee: {
+                  milisatoshis: fee.milisatoshis,
+                  parts_per_million: fee.parts_per_million(amount.milisatoshis)
+                }
+              }
+            end
+          end.new(analysis[:sums])
+        end
+
+        def averages
+          Struct.new(:analysis) do
+            def amount
+              Satoshis.new(
+                milisatoshis: analysis[:sums][:amount].to_f / analysis[:count]
+              )
+            end
+
+            def fee
+              Satoshis.new(
+                milisatoshis: analysis[:sums][:fee].to_f / analysis[:count]
+              )
+            end
+
+            def to_h
+              {
+                amount: amount.to_h,
+                fee: {
+                  milisatoshis: fee.milisatoshis,
+                  parts_per_million: fee.parts_per_million(amount.milisatoshis)
+                }
+              }
+            end
+          end.new(analysis)
+        end
+
+        def to_h
+          {
+            count: count,
+            sums: sums.to_h,
+            averages: averages.to_h
+          }
+        end
+      end
+    end
+  end
+end

data/models/edges/groups/channel_forwards.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require_relative '../../satoshis'
+require_relative 'analysis'
+
+module Lighstorm
+  module Models
+    class ChannelForwardsGroup
+      def initialize(direction, data)
+        @direction = direction
+        @data = data
+      end
+
+      def last_at
+        @last_at ||= DateTime.parse(Time.at(@data[:last_at].to_f / 1e+9).to_s)
+      end
+
+      def analysis
+        Analysis.new(@data[:analysis])
+      end
+
+      def in
+        return @in if @in
+
+        raise raise ArgumentError, "Method `in` doesn't exist." unless @direction == :in
+
+        @in = Channel.new({ id: @data[:in][:id] })
+      end
+
+      def out
+        return @out if @out
+
+        raise raise ArgumentError, "Method `out` doesn't exist." unless @direction == :out
+
+        @out = Channel.new({ id: @data[:out][:id] })
+      end
+
+      # def capacity
+      #   @capacity ||= Satoshis.new(milisatoshis: @channel.data[:get_chan_info].capacity * 1000)
+      # end
+
+      def to_h
+        {
+          last_at: last_at,
+          analysis: analysis.to_h,
+          @direction => {
+            id: channel.id,
+            partner: {
+              node: {
+                alias: channel&.partner&.node&.alias,
+                public_key: channel&.partner&.node&.public_key,
+                color: channel&.partner&.node&.color
+              }
+            }
+          }
+        }
+      end
+
+      private
+
+      def channel
+        @channel ||= @direction == :in ? self.in : out
+      end
+    end
+  end
+end

data/models/edges/payment.rb

@@ -15,14 +15,16 @@ module Lighstorm
 
       attr_reader :data
 
-      def self.all(limit: nil, purpose: nil, hops: true)
+      def self.all(limit: nil, purpose: nil, hops: true, info: true)
         last_offset = 0
 
         payments = []
 
         loop do
-          response = LND.instance.middleware('lightning.list_payments') do
-            LND.instance.client.lightning.list_payments(index_offset: last_offset)
+          response = Cache.for('lightning.list_payments', params: { index_offset: last_offset }) do
+            LND.instance.middleware('lightning.list_payments') do
+              LND.instance.client.lightning.list_payments(index_offset: last_offset)
+            end
           end
 
           response.payments.each do |raw_payment|
@@ -57,7 +59,7 @@ module Lighstorm
         payments = payments[0..limit - 1] unless limit.nil?
 
         payments.map do |raw_payment|
-          Payment.new(raw_payment, respond_hops: hops)
+          Payment.new(raw_payment, respond_hops: hops, respond_info: info)
         end
       end
 
@@ -69,8 +71,9 @@ module Lighstorm
         all.last
       end
 
-      def initialize(raw, respond_hops: true)
+      def initialize(raw, respond_hops: true, respond_info: true)
         @respond_hops = respond_hops
+        @respond_info = respond_info
         @data = { list_payments: { payments: [raw] } }
       end
 
@@ -163,7 +166,7 @@ module Lighstorm
 
         @from = PaymentChannel.new(
           @data[:list_payments][:payments].first.htlcs.first.route.hops.first,
-          1
+          1, respond_info: @respond_info
         )
 
         @from
@@ -185,12 +188,14 @@ module Lighstorm
                   @data[:list_payments][:payments].first.htlcs.first.route.hops[
                     @data[:list_payments][:payments].first.htlcs.first.route.hops.size - 2
                   ],
-                  @data[:list_payments][:payments].first.htlcs.first.route.hops.size - 1
+                  @data[:list_payments][:payments].first.htlcs.first.route.hops.size - 1,
+                  respond_info: @respond_info
                 )
               else
                 PaymentChannel.new(
                   @data[:list_payments][:payments].first.htlcs.first.route.hops.last,
-                  @data[:list_payments][:payments].first.htlcs.first.route.hops.size
+                  @data[:list_payments][:payments].first.htlcs.first.route.hops.size,
+                  respond_info: @respond_info
                 )
               end
 
@@ -203,7 +208,7 @@ module Lighstorm
         validated_htlcs_number!
 
         @hops = @data[:list_payments][:payments].first.htlcs.first.route.hops.map.with_index do |raw_hop, i|
-          PaymentChannel.new(raw_hop, i + 1)
+          PaymentChannel.new(raw_hop, i + 1, respond_info: @respond_info)
         end
       end