lighstorm 0.0.3 → 0.0.5

data/models/edges/channel.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'date'
+
+require_relative '../../ports/grpc'
+require_relative '../../adapters/edges/channel'
 
 require_relative '../../components/lnd'
 require_relative '../../components/cache'
@@ -9,246 +11,186 @@ require_relative '../../components/cache'
 require_relative '../nodes/node'
 require_relative 'channel/accounting'
 
+require_relative '../../controllers/channel/actions/apply_gossip'
 require_relative '../connections/channel_node'
 require_relative '../satoshis'
 
+require_relative '../errors'
+
 module Lighstorm
   module Models
     class Channel
-      KIND = :edge
+      attr_reader :data, :_key, :id
 
-      attr_reader :data
-
-      def self.all
-        response = LND.instance.middleware('lightning.describe_graph') do
-          LND.instance.client.lightning.describe_graph
-        end
+      def initialize(data)
+        @data = data
 
-        response.edges.map do |raw_channel|
-          Channel.new({ describe_graph: raw_channel })
-        end
+        @_key = data[:_key]
+        @id = data[:id]
       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.to_s)
-        end
+      def known?
+        @data[:known] == true
       end
 
-      def self.find_by_id(id)
-        Channel.new({ id: id })
-      end
+      def mine?
+        ensure_known!
 
-      def id
-        # Standard JSON don't support BigInt, so, a String is safer.
-        @id.to_s
+        @data[:mine]
       end
 
-      def initialize(params)
-        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
+      def exposure
+        ensure_known!
 
-            @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
+        @data[:exposure]
+      end
 
-        fetch_from_fee_report!
+      def opened_at
+        ensure_mine!
 
-        fetch_from_list_channels!
-        calculate_times_after_list_channels!
+        @data[:opened_at]
       end
 
-      def error?
-        !@data[:error].nil?
-      end
+      def up_at
+        ensure_mine!
 
-      def error
-        @data[:error]
+        @data[:up_at]
       end
 
-      def active
-        @data[:list_channels] ? @data[:list_channels][:channels].first.active : nil
-      end
+      def active?
+        ensure_mine!
 
-      def exposure
-        return 'public' if @data[:describe_graph]
+        @data[:state] == 'active'
+      end
 
-        return unless @data[:list_channels]
+      def state
+        ensure_mine!
 
-        @data[:list_channels][:channels].first.private ? 'private' : 'public'
+        @data[:state]
       end
 
-      def opened_at
-        @opened_at ||= if @data[:list_channels]
-                         DateTime.parse(
-                           (Time.now - @data[:list_channels][:channels].first.lifetime).to_s
-                         )
-                       end
-      end
+      def accounting
+        ensure_known!
 
-      def up_at
-        @up_at ||= if @data[:list_channels]
-                     DateTime.parse(
-                       (Time.now - @data[:list_channels][:channels].first.uptime).to_s
-                     )
-                   end
+        @accounting ||= @data[:accounting] ? ChannelAccounting.new(@data[:accounting], mine?) : nil
       end
 
-      def accounting
-        @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)
-                          )
-                        ]
+      def partners
+        @partners ||= if @data[:partners]
+                        @data[:partners].map do |data|
+                          ChannelNode.new(data, known? ? mine? : nil, transaction)
+                        end
                       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
-        raise 'not your channel' unless mine?
+        ensure_mine!
 
-        @myself ||= ChannelNode.new(self, Node.myself)
+        @myself ||= partners.find { |partner| partner.node.myself? }
       end
 
       def partner
-        raise 'not your channel' unless mine?
+        ensure_mine!
 
-        key = @data[:get_chan_info] ? :get_chan_info : :describe_graph
+        @partner ||= partners.find { |partner| !partner.node.myself? }
+      end
 
-        public_key = if @data[key].node1_pub == myself.node.public_key
-                       @data[key].node2_pub
-                     else
-                       @data[key].node1_pub
-                     end
+      def transaction
+        Struct.new(:data) do
+          def funding
+            Struct.new(:data) do
+              def id
+                data[:id]
+              end
 
-        @partner ||= ChannelNode.new(self, Node.find_by_public_key(public_key))
-      end
+              def index
+                data[:index]
+              end
 
-      def raw
-        {
-          get_chan_info: @data[:get_chan_info].to_h,
-          describe_graph: @data[:describe_graph].to_h,
-          list_channels: {
-            channels: @data[:list_channels] ? @data[:list_channels][:channels].map(&:to_h) : nil
-          }
-        }
+              def to_h
+                { id: id, index: index }
+              end
+            end.new(data[:funding])
+          end
+
+          def to_h
+            { funding: funding.to_h }
+          end
+        end.new(@data[:transaction])
       end
 
       def to_h
-        if @data[:get_chan_info]
+        if !known? && partners.size.positive?
+          { _key: _key, id: id, partners: partners.map(&:to_h) }
+        elsif !known?
+          { _key: _key, id: id }
+        elsif mine?
           {
+            _key: _key,
             id: id,
             opened_at: opened_at,
             up_at: up_at,
-            active: active,
+            state: state,
             exposure: exposure,
             accounting: accounting.to_h,
             partner: partner.to_h,
             myself: myself.to_h
           }
-        else
+        elsif @data[:accounting]
           {
+            _key: _key,
             id: id,
             accounting: accounting.to_h,
             partners: partners.map(&:to_h)
           }
+        else
+          {
+            _key: _key,
+            id: id,
+            partners: partners.map(&:to_h)
+          }
         end
       end
 
-      private
+      def dump
+        result = Marshal.load(Marshal.dump(@data)).merge(
+          { partners: partners.map(&:dump) }
+        )
 
-      # Ensure that we are getting fresh up-date data about our own fees.
-      def fetch_from_fee_report!
-        response = Cache.for('lightning.fee_report') do
-          LND.instance.middleware('lightning.fee_report') do
-            LND.instance.client.lightning.fee_report
-          end
-        end
+        result[:accounting] = accounting.dump if known?
 
-        response.channel_fees.map do |channel|
-          if channel.chan_id == @id
-            @data[:fee_report] = { channel_fees: [channel] }
-            break
-          end
-        end
+        result
       end
 
-      def fetch_from_list_channels!
-        response = Cache.for('lightning.list_channels') do
-          LND.instance.middleware('lightning.list_channels') do
-            LND.instance.client.lightning.list_channels
-          end
-        end
+      def self.adapt(gossip: nil, dump: nil)
+        raise TooManyArgumentsError, 'you need to pass gossip: or dump:, not both' if !gossip.nil? && !dump.nil?
 
-        response.channels.map do |channel|
-          if channel.chan_id == @id
-            @data[:list_channels] = { channels: [channel] }
-            break
-          end
+        raise ArgumentError, 'missing gossip: or dump:' if gossip.nil? && dump.nil?
+
+        if !gossip.nil?
+          new(Adapter::Channel.subscribe_channel_graph(gossip))
+        elsif !dump.nil?
+          new(dump)
         end
       end
 
-      def calculate_times_after_list_channels!
-        opened_at
-        up_at
+      def apply!(gossip:)
+        Controllers::Channel::ApplyGossip.perform(
+          self, gossip
+        )
+      end
+
+      private
+
+      def ensure_known!
+        raise Errors::UnknownChannelError unless known?
+      end
+
+      def ensure_mine!
+        ensure_known!
+        raise Errors::NotYourChannelError if @data[:mine] == false
       end
     end
   end

data/models/edges/forward.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-require 'digest'
 require 'time'
-require 'date'
 
 require_relative '../satoshis'
 
@@ -12,130 +10,30 @@ require_relative 'groups/channel_forwards'
 module Lighstorm
   module Models
     class Forward
-      KIND = :edge
+      attr_reader :_key, :at
 
-      attr_reader :data
+      def initialize(data)
+        @data = data
 
-      def self.all(limit: nil, raw: false, info: true)
-        last_offset = 0
-
-        forwards = []
-
-        loop do
-          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 }
-
-          # Unfortunately, forwards aren't sorted in descending order. :(
-          # break if !limit.nil? && forwards.size >= limit
-
-          break if last_offset == response.last_offset_index || last_offset > response.last_offset_index
-
-          last_offset = response.last_offset_index
-        end
-
-        forwards = forwards.sort_by { |raw_forward| -raw_forward.timestamp_ns }
-
-        forwards = forwards[0..limit - 1] unless limit.nil?
-
-        return forwards if raw
-
-        forwards.map { |raw_forward| Forward.new(raw_forward, respond_info: info) }
-      end
-
-      def self.first
-        all(limit: 1).first
-      end
-
-      def self.last
-        all.last
-      end
-
-      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
-
-      def id
-        @id ||= Digest::SHA256.hexdigest(
-          @data[:forwarding_history][:forwarding_events].first.timestamp_ns.to_s
-        )
-      end
-
-      def at
-        DateTime.parse(Time.at(
-          @data[:forwarding_history][:forwarding_events].first.timestamp_ns / 1e+9
-        ).to_s)
+        @_key = data[:_key]
+        @at = data[:at]
       end
 
       def fee
-        Satoshis.new(milisatoshis: @data[:forwarding_history][:forwarding_events].first.fee_msat)
+        @fee ||= Satoshis.new(milisatoshis: @data[:fee][:milisatoshis])
       end
 
       def in
-        @in ||= ForwardChannel.new(:in, self, respond_info: @respond_info)
+        @in ||= ForwardChannel.new(@data[:in])
       end
 
       def out
-        @out ||= ForwardChannel.new(:out, self, respond_info: @respond_info)
+        @out ||= ForwardChannel.new(@data[:out])
       end
 
       def to_h
         {
-          id: id,
+          _key: _key,
           at: at,
           fee: {
             milisatoshis: fee.milisatoshis,
@@ -145,14 +43,6 @@ module Lighstorm
           out: out.to_h
         }
       end
-
-      def raw
-        {
-          forwarding_history: {
-            forwarding_events: [@data[:forwarding_history][:forwarding_events].first.to_h]
-          }
-        }
-      end
     end
   end
 end

data/models/edges/groups/{analysis.rb → channel_forwards/analysis.rb}

@@ -3,19 +3,19 @@
 module Lighstorm
   module Models
     class ChannelForwardsGroup
-      Analysis = Struct.new(:analysis) do
+      Analysis = Struct.new(:data) do
         def count
-          analysis[:count]
+          data[:count]
         end
 
         def sums
           Struct.new(:sums) do
             def amount
-              Satoshis.new(milisatoshis: sums[:amount])
+              Satoshis.new(milisatoshis: sums[:amount][:milisatoshis])
             end
 
             def fee
-              Satoshis.new(milisatoshis: sums[:fee])
+              Satoshis.new(milisatoshis: sums[:fee][:milisatoshis])
             end
 
             def to_h
@@ -27,20 +27,20 @@ module Lighstorm
                 }
               }
             end
-          end.new(analysis[:sums])
+          end.new(data[:sums])
         end
 
         def averages
-          Struct.new(:analysis) do
+          Struct.new(:data) do
             def amount
               Satoshis.new(
-                milisatoshis: analysis[:sums][:amount].to_f / analysis[:count]
+                milisatoshis: data[:sums][:amount][:milisatoshis].to_f / data[:count]
               )
             end
 
             def fee
               Satoshis.new(
-                milisatoshis: analysis[:sums][:fee].to_f / analysis[:count]
+                milisatoshis: data[:sums][:fee][:milisatoshis].to_f / data[:count]
               )
             end
 
@@ -53,7 +53,7 @@ module Lighstorm
                 }
               }
             end
-          end.new(analysis)
+          end.new(data)
         end
 
         def to_h

data/models/edges/groups/channel_forwards.rb

@@ -1,66 +1,36 @@
 # frozen_string_literal: true
 
 require_relative '../../satoshis'
-require_relative 'analysis'
+require_relative 'channel_forwards/analysis'
 
 module Lighstorm
   module Models
     class ChannelForwardsGroup
-      def initialize(direction, data)
-        @direction = direction
+      attr_reader :_key, :last_at
+
+      def initialize(data)
         @data = data
-      end
 
-      def last_at
-        @last_at ||= DateTime.parse(Time.at(@data[:last_at].to_f / 1e+9).to_s)
+        @_key = data[:_key]
+        @last_at = data[:last_at]
       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] })
+      def channel
+        @channel ||= Channel.new(@data[:channel])
       end
 
-      # def capacity
-      #   @capacity ||= Satoshis.new(milisatoshis: @channel.data[:get_chan_info].capacity * 1000)
-      # end
-
       def to_h
         {
+          _key: _key,
           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
-              }
-            }
-          }
+          channel: channel.to_h
         }
       end
-
-      private
-
-      def channel
-        @channel ||= @direction == :in ? self.in : out
-      end
     end
   end
 end