lighstorm 0.0.3 → 0.0.4

data/models/connections/forward_channel.rb

@@ -5,58 +5,23 @@ require_relative '../edges/channel'
 module Lighstorm
   module Models
     class ForwardChannel
-      KIND = :connection
-
-      def initialize(direction, forward, respond_info: true)
-        @respond_info = respond_info
-        @direction = direction
-        @forward = forward
+      def initialize(data)
+        @data = data
       end
 
-      def channel
-        @channel ||= Channel.find_by_id(channel_id)
+      def amount
+        @amount ||= Satoshis.new(milisatoshis: @data[:amount][:milisatoshis])
       end
 
-      def amount
-        @amount ||= if @direction == :in
-                      Satoshis.new(milisatoshis:
-                        @forward.data[:forwarding_history][:forwarding_events].first.amt_in_msat)
-                    else
-                      Satoshis.new(milisatoshis:
-                        @forward.data[:forwarding_history][:forwarding_events].first.amt_out_msat)
-                    end
+      def channel
+        @channel ||= Channel.new(@data[:channel])
       end
 
       def to_h
-        response = {
+        {
           amount: amount.to_h,
-          channel: { id: channel_id }
-        }
-
-        return response unless @respond_info
-
-        response[:channel] = {
-          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
         }
-
-        response
-      end
-
-      private
-
-      def channel_id
-        if @direction == :in
-          @forward.data[:forwarding_history][:forwarding_events].first.chan_id_in.to_s
-        else
-          @forward.data[:forwarding_history][:forwarding_events].first.chan_id_out.to_s
-        end
       end
     end
   end

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,48 +1,56 @@
 # 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
-        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
+        @capacity ||= if @data[:capacity]
+                        Satoshis.new(
+                          milisatoshis: @data[:capacity][:milisatoshis]
+                        )
+                      end
       end
 
       def sent
-        return nil unless @channel.data[:list_channels]
+        raise Errors::NotYourChannelError unless @is_mine
 
-        @sent ||= Satoshis.new(milisatoshis: (
-                         @channel.data[:list_channels][:channels].first.total_satoshis_sent.to_f * 1000.0
-                       ))
+        @sent ||= if @data[:sent]
+                    Satoshis.new(
+                      milisatoshis: @data[:sent][:milisatoshis]
+                    )
+                  end
       end
 
       def received
-        return nil unless @channel.data[:list_channels]
+        raise Errors::NotYourChannelError unless @is_mine
 
-        @received ||= Satoshis.new(milisatoshis: (
-                         @channel.data[:list_channels][:channels].first.total_satoshis_received.to_f * 1000.0
-                       ))
+        @received ||= if @data[:received]
+                        Satoshis.new(
+                          milisatoshis: @data[:received][:milisatoshis]
+                        )
+                      end
       end
 
       def unsettled
-        return nil unless @channel.data[:list_channels]
+        raise Errors::NotYourChannelError unless @is_mine
 
-        @unsettled ||= Satoshis.new(milisatoshis: (
-                         @channel.data[:list_channels][:channels].first.unsettled_balance.to_f * 1000.0
-                       ))
+        @unsettled ||= if @data[:unsettled]
+                         Satoshis.new(
+                           milisatoshis: @data[:unsettled][:milisatoshis]
+                         )
+                       end
       end
 
       def to_h
-        if @channel.data[:get_chan_info]
+        if @is_mine
           {
             capacity: capacity.to_h,
             sent: sent.to_h,

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,189 +15,114 @@ 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, :_key, :id, :opened_at, :up_at, :active, :exposure
 
-      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
-
-            @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!
-
-        fetch_from_list_channels!
-        calculate_times_after_list_channels!
-      end
+      def exposure
+        ensure_known!
 
-      def error?
-        !@data[:error].nil?
+        @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 'public' if @data[:describe_graph]
-
-        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
-        @accounting ||= ChannelAccounting.new(self)
+        ensure_known!
+
+        @accounting ||= @data[:accounting] ? ChannelAccounting.new(@data[:accounting], mine?) : nil
       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,
@@ -204,51 +132,31 @@ module Lighstorm
             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
 
-      # 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
-
-        response.channel_fees.map do |channel|
-          if channel.chan_id == @id
-            @data[:fee_report] = { channel_fees: [channel] }
-            break
-          end
-        end
-      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
-
-        response.channels.map do |channel|
-          if channel.chan_id == @id
-            @data[:list_channels] = { channels: [channel] }
-            break
-          end
-        end
+      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