lighstorm 0.0.2 → 0.0.4

data/models/connections/payment_channel.rb

@@ -1,71 +1,50 @@
 # frozen_string_literal: true
 
-require_relative '../edges/channel'
+require_relative '../edges/channel/hop'
 require_relative '../nodes/node'
 
 module Lighstorm
   module Models
     class PaymentChannel
-      KIND = :connection
+      attr_reader :hop
+
+      def initialize(data, payment)
+        @data = data
 
-      def initialize(raw_hop, hop_index, respond_info: true)
-        @respond_info = respond_info
-        @raw_hop = raw_hop
-        @hop = hop_index
+        @hop = data[:hop]
+        @payment = payment
       end
 
-      attr_reader :hop
+      def first?
+        @hop == 1
+      end
 
-      def channel
-        Channel.find_by_id(@raw_hop.chan_id)
+      def last?
+        @data[:is_last] == true
       end
 
       def amount
-        @amount ||= Satoshis.new(milisatoshis: @raw_hop.amt_to_forward_msat)
+        @amount ||= Satoshis.new(milisatoshis: @data[:amount][:milisatoshis])
       end
 
       def fee
-        @fee ||= Satoshis.new(milisatoshis: @raw_hop.fee_msat)
-      end
-
-      def raw
-        @raw_hop
+        @fee ||= Satoshis.new(milisatoshis: @data[:fee][:milisatoshis])
       end
 
-      def partner_node
-        Node.find_by_public_key(@raw_hop.pub_key)
+      def channel
+        @channel ||= HopChannel.new(@data, @payment)
       end
 
       def to_h
-        response = {
+        {
           hop: hop,
           amount: amount.to_h,
           fee: {
             milisatoshis: fee.milisatoshis,
             parts_per_million: fee.parts_per_million(amount.milisatoshis)
           },
-          channel: {
-            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
-            }
-          }
+          channel: channel.to_h
         }
-
-        response
       end
     end
   end

data/models/edges/channel/accounting.rb

@@ -1,43 +1,67 @@
 # frozen_string_literal: true
 
 require_relative '../../satoshis'
+require_relative '../../errors'
 
 module Lighstorm
   module Models
     class ChannelAccounting
-      def initialize(channel)
-        @channel = channel
+      def initialize(data, is_mine)
+        @data = data
+        @is_mine = is_mine
       end
 
       def capacity
-        @capacity ||= Satoshis.new(milisatoshis: @channel.data[:get_chan_info].capacity * 1000)
+        @capacity ||= if @data[:capacity]
+                        Satoshis.new(
+                          milisatoshis: @data[:capacity][:milisatoshis]
+                        )
+                      end
       end
 
       def sent
-        @sent ||= Satoshis.new(milisatoshis: (
-                         @channel.data[:list_channels][:channels].first.total_satoshis_sent.to_f * 1000.0
-                       ))
+        raise Errors::NotYourChannelError unless @is_mine
+
+        @sent ||= if @data[:sent]
+                    Satoshis.new(
+                      milisatoshis: @data[:sent][:milisatoshis]
+                    )
+                  end
       end
 
       def received
-        @received ||= Satoshis.new(milisatoshis: (
-                         @channel.data[:list_channels][:channels].first.total_satoshis_received.to_f * 1000.0
-                       ))
+        raise Errors::NotYourChannelError unless @is_mine
+
+        @received ||= if @data[:received]
+                        Satoshis.new(
+                          milisatoshis: @data[:received][:milisatoshis]
+                        )
+                      end
       end
 
       def unsettled
-        @unsettled ||= Satoshis.new(milisatoshis: (
-                         @channel.data[:list_channels][:channels].first.unsettled_balance.to_f * 1000.0
-                       ))
+        raise Errors::NotYourChannelError unless @is_mine
+
+        @unsettled ||= if @data[:unsettled]
+                         Satoshis.new(
+                           milisatoshis: @data[:unsettled][:milisatoshis]
+                         )
+                       end
       end
 
       def to_h
-        {
-          capacity: capacity.to_h,
-          sent: sent.to_h,
-          received: received.to_h,
-          unsettled: unsettled.to_h
-        }
+        if @is_mine
+          {
+            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/hop.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require_relative '../channel'
+
+module Lighstorm
+  module Models
+    class HopChannel < Channel
+      def initialize(data, payment)
+        @hop_data = data
+        @payment = payment
+        super(data[:channel])
+      end
+
+      def target
+        partners.find do |partner|
+          partner.node.public_key == @hop_data[:channel][:target][:public_key]
+        end.node
+      end
+
+      def exit
+        @exit ||= if include_myself? && @hop_data[:hop] == 1
+                    partners.reverse.find do |partner|
+                      !partner.node.myself?
+                    end.node
+                  elsif @hop_data[:hop] == 1
+                    target
+                  end
+      end
+
+      def entry
+        return nil if @hop_data[:is_last] && @hop_data[:hop] == 1
+
+        @entry ||= if include_myself? && @hop_data[:is_last]
+                     if partners.size > 1
+                       partners.reverse.find do |partner|
+                         !partner.node.myself?
+                       end.node
+                     else
+                       @payment.hops[@payment.hops.size - 2].channel.target
+                     end
+                   end
+      end
+
+      def include_myself?
+        !partners.find { |partner| partner.node.myself? }.nil?
+      end
+
+      def to_h
+        if !known? && !partners.size.positive?
+          { _key: _key, id: id }
+        else
+          target_hash = target.to_h
+          target_hash.delete(:platform)
+
+          result = { _key: _key, id: id, target: target_hash }
+
+          result[:entry] = entry.to_h if entry
+          result[:exit] = self.exit.to_h if self.exit
+
+          result
+        end
+      end
+    end
+  end
+end

data/models/edges/channel.rb

@@ -3,6 +3,9 @@
 require 'time'
 require 'date'
 
+require_relative '../../ports/grpc'
+require_relative '../../adapters/edges/channel'
+
 require_relative '../../components/lnd'
 require_relative '../../components/cache'
 
@@ -12,173 +15,148 @@ require_relative 'channel/accounting'
 require_relative '../connections/channel_node'
 require_relative '../satoshis'
 
+require_relative '../errors'
+
 module Lighstorm
   module Models
     class Channel
-      KIND = :edge
-
-      attr_reader :data
-
-      def self.all
-        response = Cache.for('lightning.list_channels') do
-          LND.instance.middleware('lightning.list_channels') do
-            LND.instance.client.lightning.list_channels
-          end
-        end
+      attr_reader :data, :_key, :id, :opened_at, :up_at, :active, :exposure
 
-        response.channels.map do |channel|
-          Channel.find_by_id(channel.chan_id.to_s)
-        end
-      end
+      def initialize(data)
+        @data = data
 
-      def self.first
-        all.first
+        @_key = data[:_key]
+        @id = data[:id]
       end
 
-      def self.last
-        all.last
+      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)
-        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
-
-          @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
-
-        fetch_from_fee_report!
+      def exposure
+        ensure_known!
 
-        fetch_from_list_channels!
-        calculate_times_after_list_channels!
+        @data[:exposure]
       end
 
-      def error
-        @data[:error]
-      end
+      def opened_at
+        ensure_mine!
 
-      def active
-        @data[:list_channels] ? @data[:list_channels][:channels].first.active : nil
+        @data[:opened_at]
       end
 
-      def exposure
-        return unless @data[:list_channels]
+      def up_at
+        ensure_mine!
 
-        @data[:list_channels][:channels].first.private ? 'private' : 'public'
+        @data[:up_at]
       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 active
+        ensure_mine!
 
-      def up_at
-        @up_at ||= if @data[:list_channels]
-                     DateTime.parse(
-                       (Time.now - @data[:list_channels][:channels].first.uptime).to_s
-                     )
-                   end
+        @data[:active]
       end
 
       def accounting
-        return nil unless @data[:get_chan_info]
+        ensure_known!
+
+        @accounting ||= @data[:accounting] ? ChannelAccounting.new(@data[:accounting], mine?) : nil
+      end
 
-        @accounting ||= ChannelAccounting.new(self)
+      def partners
+        @partners ||= if @data[:partners]
+                        @data[:partners].map do |data|
+                          ChannelNode.new(data, known? ? mine? : nil, transaction)
+                        end
+                      else
+                        []
+                      end
       end
 
       def myself
-        return nil unless @data[:get_chan_info]
+        ensure_mine!
 
-        @myself ||= ChannelNode.new(self, Node.myself)
+        @myself ||= partners.find { |partner| partner.node.myself? }
       end
 
       def partner
-        return nil unless @data[:get_chan_info]
+        ensure_mine!
 
-        public_key = if @data[:get_chan_info].node1_pub == myself.node.public_key
-                       @data[:get_chan_info].node2_pub
-                     else
-                       @data[:get_chan_info].node1_pub
-                     end
-
-        @partner ||= ChannelNode.new(self, Node.find_by_public_key(public_key))
-      end
-
-      def raw
-        {
-          get_chan_info: @data[:get_chan_info].to_h,
-          list_channels: { channels: @data[:list_channels][:channels].map(&:to_h) }
-        }
+        @partner ||= partners.find { |partner| !partner.node.myself? }
       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
-        }
-      end
+      def transaction
+        Struct.new(:data) do
+          def funding
+            Struct.new(:data) do
+              def id
+                data[:id]
+              end
 
-      private
+              def index
+                data[:index]
+              end
 
-      # 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
+              def to_h
+                { id: id, index: index }
+              end
+            end.new(data[:funding])
           end
-        end
 
-        response.channel_fees.map do |channel|
-          if channel.chan_id == @id
-            @data[:fee_report] = { channel_fees: [channel] }
-            break
+          def to_h
+            { funding: funding.to_h }
           end
-        end
+        end.new(@data[:transaction])
       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
+      def to_h
+        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,
+            exposure: exposure,
+            accounting: accounting.to_h,
+            partner: partner.to_h,
+            myself: myself.to_h
+          }
+        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
 
-        response.channels.map do |channel|
-          if channel.chan_id == @id
-            @data[:list_channels] = { channels: [channel] }
-            break
-          end
-        end
+      private
+
+      def ensure_known!
+        raise Errors::UnknownChannelError unless known?
       end
 
-      def calculate_times_after_list_channels!
-        opened_at
-        up_at
+      def ensure_mine!
+        ensure_known!
+        raise Errors::NotYourChannelError if @data[:mine] == false
       end
     end
   end

data/models/edges/forward.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'digest'
 require 'time'
 require 'date'
 
@@ -12,130 +11,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 +44,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