lighstorm 0.0.3 → 0.0.5

data/models/connections/channel_node/policy.rb

@@ -6,36 +6,33 @@ require_relative 'htlc'
 module Lighstorm
   module Models
     class Policy
-      def initialize(channel, node)
-        @channel = channel
-        @node = node
-      end
-
-      def data
-        return @data if @data
-
-        return if !@channel.data[:get_chan_info] && !@channel.data[:describe_graph]
-
-        key = @channel.data[:get_chan_info] ? :get_chan_info : :describe_graph
+      attr_reader :transaction
 
-        @data ||= if @channel.data[key].node1_pub == @node.public_key
-                    @channel.data[key].node1_policy
-                  else
-                    @channel.data[key].node2_policy
-                  end
+      def initialize(data, transaction)
+        @data = data
+        @transaction = transaction
       end
 
       def fee
-        @fee ||= Fee.new(self, @channel, @node)
+        @fee ||= Fee.new(self, @data ? @data[:fee] : {})
       end
 
       def htlc
-        @htlc ||= HTLC.new(self, @channel, @node)
+        @htlc ||= HTLC.new(@data ? @data[:htlc] : {})
       end
 
       def to_h
         { fee: fee.to_h, htlc: htlc.to_h }
       end
+
+      def dump
+        result = Marshal.load(Marshal.dump(@data))
+
+        result = result.merge({ fee: fee.dump }) if @data && @data[:fee]
+        result = result.merge({ htlc: htlc.dump }) if @data && @data[:htlc]
+
+        result
+      end
     end
   end
 end

data/models/connections/channel_node.rb

@@ -1,47 +1,73 @@
 # frozen_string_literal: true
 
-require_relative 'channel_node/constraints'
 require_relative 'channel_node/policy'
 require_relative 'channel_node/accounting'
 
+require_relative '../nodes/node'
+require_relative '../errors'
+
 module Lighstorm
   module Models
     class ChannelNode
-      KIND = :connection
+      include Protectable
 
-      attr_reader :node
+      attr_reader :state
 
-      def initialize(channel, node)
-        @channel = channel
-        @node = node
+      def initialize(data, is_mine, transaction)
+        @data = data
+        @state = data[:state]
+        @is_mine = is_mine
+        @transaction = transaction
       end
 
-      def policy
-        @policy ||= Policy.new(@channel, @node)
+      def active?
+        state == 'active'
       end
 
-      def constraints
-        @constraints ||= Constraints.new(@channel, @node)
+      def node
+        @node ||= Node.new(@data[:node])
+      end
+
+      def policy
+        @policy ||= Policy.new(@data[:policy], @transaction)
       end
 
       def accounting
-        @accounting ||= ChannelNodeAccounting.new(@channel, @node)
+        raise Errors::NotYourChannelError unless @is_mine
+
+        @accounting ||= @data[:accounting] ? ChannelNodeAccounting.new(@data[:accounting]) : nil
       end
 
       def to_h
-        if @channel.data[:get_chan_info]
-          {
-            accounting: accounting.to_h,
-            node: @node.to_h,
-            policy: policy.to_h
-            # constraints: constraints.to_h
-          }
-        else
+        restult = { state: state, node: node.to_h }
+
+        restult[:accounting] = accounting.to_h if @is_mine
+        restult[:policy] = policy.to_h if @data[:policy]
+
+        restult
+      end
+
+      def dump
+        result = Marshal.load(Marshal.dump(@data)).merge(
           {
-            node: @node.to_h,
-            policy: policy.to_h
+            node: node.dump,
+            policy: policy.dump
           }
-        end
+        )
+
+        result[:accounting] = accounting.dump if @is_mine
+        result.delete(:policy) if result[:policy].nil?
+
+        result
+      end
+
+      def state=(value)
+        protect!(value)
+
+        @state = value[:value]
+        @data[:state] = @state
+
+        state
       end
     end
   end

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,59 @@
 # frozen_string_literal: true
 
 require_relative '../../satoshis'
+require_relative '../../errors'
+require_relative '../../concerns/protectable'
 
 module Lighstorm
   module Models
     class ChannelAccounting
-      def initialize(channel)
-        @channel = channel
+      include Protectable
+
+      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,
@@ -55,6 +66,20 @@ module Lighstorm
           }
         end
       end
+
+      def dump
+        Marshal.load(Marshal.dump(@data))
+      end
+
+      def capacity=(value)
+        protect!(value)
+
+        @capacity = value[:value]
+
+        @data[:capacity][:milisatoshis] = @capacity.milisatoshis
+
+        capacity
+      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