lighstorm 0.0.15 → 0.0.16

data/models/lightning/edges/channel/accounting.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../../../satoshis'
+require_relative '../../../errors'
+require_relative '../../../concerns/protectable'
+
+module Lighstorm
+  module Model
+    module Lightning
+      class ChannelAccounting
+        include Protectable
+
+        def initialize(data, is_mine)
+          @data = data
+          @is_mine = is_mine
+        end
+
+        def capacity
+          @capacity ||= if @data[:capacity]
+                          Satoshis.new(
+                            millisatoshis: @data[:capacity][:millisatoshis]
+                          )
+                        end
+        end
+
+        def sent
+          raise Errors::NotYourChannelError unless @is_mine
+
+          @sent ||= if @data[:sent]
+                      Satoshis.new(
+                        millisatoshis: @data[:sent][:millisatoshis]
+                      )
+                    end
+        end
+
+        def received
+          raise Errors::NotYourChannelError unless @is_mine
+
+          @received ||= if @data[:received]
+                          Satoshis.new(
+                            millisatoshis: @data[:received][:millisatoshis]
+                          )
+                        end
+        end
+
+        def unsettled
+          raise Errors::NotYourChannelError unless @is_mine
+
+          @unsettled ||= if @data[:unsettled]
+                           Satoshis.new(
+                             millisatoshis: @data[:unsettled][:millisatoshis]
+                           )
+                         end
+        end
+
+        def 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
+
+        def dump
+          Marshal.load(Marshal.dump(@data))
+        end
+
+        def capacity=(value)
+          protect!(value)
+
+          @capacity = value[:value]
+
+          @data[:capacity][:millisatoshis] = @capacity.millisatoshis
+
+          capacity
+        end
+      end
+    end
+  end
+end

data/models/lightning/edges/channel/hop.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../channel'
+
+module Lighstorm
+  module Model
+    module Lightning
+      class HopChannel < Channel
+        def initialize(data, payment)
+          @hop_data = data
+          @payment = payment
+          super(data[:channel], nil)
+        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
+end

data/models/lightning/edges/channel.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative '../../../ports/grpc'
+require_relative '../../../adapters/lightning/edges/channel'
+
+require_relative '../nodes/node'
+require_relative './channel/accounting'
+
+require_relative '../../../controllers/lightning/channel/actions/apply_gossip'
+require_relative '../connections/channel_node'
+require_relative '../../satoshis'
+
+require_relative '../../errors'
+
+module Lighstorm
+  module Model
+    module Lightning
+      class Channel
+        attr_reader :data, :_key, :id
+
+        def initialize(data, components)
+          @data = data
+          @components = components
+
+          @_key = data[:_key]
+          @id = data[:id]
+        end
+
+        def known?
+          @data[:known] == true
+        end
+
+        def mine?
+          ensure_known!
+
+          @data[:mine]
+        end
+
+        def exposure
+          ensure_known!
+
+          @data[:exposure]
+        end
+
+        def opened_at
+          ensure_mine!
+
+          @data[:opened_at]
+        end
+
+        def up_at
+          ensure_mine!
+
+          @data[:up_at]
+        end
+
+        def active?
+          ensure_mine!
+
+          @data[:state] == 'active'
+        end
+
+        def state
+          ensure_mine!
+
+          @data[:state]
+        end
+
+        def accounting
+          ensure_known!
+
+          @accounting ||= @data[:accounting] ? ChannelAccounting.new(@data[:accounting], mine?) : nil
+        end
+
+        def partners
+          @partners ||= if @data[:partners]
+                          @data[:partners].map do |data|
+                            ChannelNode.new(data, @components, known? ? mine? : nil, transaction)
+                          end
+                        else
+                          []
+                        end
+        end
+
+        def myself
+          ensure_mine!
+
+          @myself ||= partners.find { |partner| partner.node.myself? }
+        end
+
+        def partner
+          ensure_mine!
+
+          @partner ||= partners.find { |partner| !partner.node.myself? }
+        end
+
+        def transaction
+          Struct.new(:data) do
+            def funding
+              Struct.new(:data) do
+                def id
+                  data[:id]
+                end
+
+                def index
+                  data[:index]
+                end
+
+                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 !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,
+              state: state,
+              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
+
+        def dump
+          result = Marshal.load(Marshal.dump(@data)).merge(
+            { partners: partners.map(&:dump) }
+          )
+
+          result[:accounting] = accounting.dump if known?
+
+          result
+        end
+
+        def self.adapt(gossip: nil, dump: nil)
+          raise TooManyArgumentsError, 'you need to pass gossip: or dump:, not both' if !gossip.nil? && !dump.nil?
+
+          raise ArgumentError, 'missing gossip: or dump:' if gossip.nil? && dump.nil?
+
+          if !gossip.nil?
+            new(Adapter::Lightning::Channel.subscribe_channel_graph(gossip), nil)
+          elsif !dump.nil?
+            new(dump, nil)
+          end
+        end
+
+        def apply!(gossip:)
+          Controller::Lightning::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
+  end
+end

data/models/lightning/edges/forward.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative '../../satoshis'
+
+require_relative '../connections/forward_channel'
+require_relative 'groups/channel_forwards'
+
+module Lighstorm
+  module Model
+    module Lightning
+      class Forward
+        attr_reader :_key, :at
+
+        def initialize(data, components)
+          @data = data
+          @components = components
+
+          @_key = data[:_key]
+          @at = data[:at]
+        end
+
+        def fee
+          @fee ||= Satoshis.new(millisatoshis: @data[:fee][:millisatoshis])
+        end
+
+        def in
+          @in ||= ForwardChannel.new(@data[:in], @components)
+        end
+
+        def out
+          @out ||= ForwardChannel.new(@data[:out], @components)
+        end
+
+        def to_h
+          {
+            _key: _key,
+            at: at,
+            fee: {
+              millisatoshis: fee.millisatoshis,
+              parts_per_million: fee.parts_per_million(self.in.amount.millisatoshis)
+            },
+            in: self.in.to_h,
+            out: out.to_h
+          }
+        end
+      end
+    end
+  end
+end

data/models/lightning/edges/groups/channel_forwards/analysis.rb

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

data/models/lightning/edges/groups/channel_forwards.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative '../../../satoshis'
+require_relative 'channel_forwards/analysis'
+
+module Lighstorm
+  module Model
+    module Lightning
+      class ChannelForwardsGroup
+        attr_reader :_key, :last_at
+
+        def initialize(data, components)
+          @data = data
+          @components = components
+
+          @_key = data[:_key]
+          @last_at = data[:last_at]
+        end
+
+        def analysis
+          Analysis.new(@data[:analysis])
+        end
+
+        def channel
+          @channel ||= Channel.new(@data[:channel], @components)
+        end
+
+        def to_h
+          {
+            _key: _key,
+            last_at: last_at,
+            analysis: analysis.to_h,
+            channel: channel.to_h
+          }
+        end
+      end
+    end
+  end
+end

data/models/lightning/edges/payment.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require 'time'
+
+require_relative '../../satoshis'
+
+require_relative '../connections/payment_channel'
+require_relative '../nodes/node'
+require_relative '../invoice'
+require_relative '../secret'
+
+module Lighstorm
+  module Model
+    module Lightning
+      class Payment
+        attr_reader :_key, :at, :state, :secret, :purpose, :through, :message
+
+        def initialize(data, components)
+          @data = data
+          @components = components
+
+          @_key = data[:_key]
+          @at = data[:at]
+          @state = data[:state]
+          @purpose = data[:purpose]
+          @through = data[:through]
+          @message = data[:message]
+        end
+
+        def how
+          @how ||= spontaneous? ? 'spontaneously' : 'with-invoice'
+        end
+
+        def invoice
+          @invoice ||= !spontaneous? && @data[:invoice] ? Invoice.new(@data[:invoice], @components) : nil
+        end
+
+        def amount
+          @amount ||= @data[:amount] ? Satoshis.new(millisatoshis: @data[:amount][:millisatoshis]) : nil
+        end
+
+        def fee
+          @fee ||= @data[:fee] ? Satoshis.new(millisatoshis: @data[:fee][:millisatoshis]) : nil
+        end
+
+        def secret
+          @secret ||= @data[:secret] ? Secret.new(@data[:secret], @components) : nil
+        end
+
+        def hops
+          return @hops if @hops
+          return nil if @data[:hops].nil?
+
+          @data[:hops].last[:is_last] = true
+          @hops = @data[:hops].map do |hop|
+            PaymentChannel.new(hop, self)
+          end
+        end
+
+        def from
+          @from ||= @data[:hops].nil? ? nil : hops.first
+        end
+
+        def to
+          @to ||= @data[:hops].nil? ? nil : hops.last
+        end
+
+        def to_h
+          response = {
+            _key: _key,
+            at: at,
+            state: state,
+            through: through,
+            purpose: purpose,
+            how: how,
+            message: message,
+            invoice: invoice&.to_h,
+            from: from.to_h,
+            to: to.to_h
+          }
+
+          response[:secret] = secret.to_h if secret
+          response[:amount] = amount.to_h if amount
+          if fee
+            response[:fee] = {
+              millisatoshis: fee.millisatoshis,
+              parts_per_million: fee.parts_per_million(amount.millisatoshis)
+            }
+          end
+
+          response[:hops] = hops.map(&:to_h) unless hops.nil?
+
+          response
+        end
+
+        private
+
+        def spontaneous?
+          !@data[:invoice] || @data[:invoice][:code].nil?
+        end
+      end
+    end
+  end
+end