lighstorm 0.0.3 → 0.0.4

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

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

data/models/edges/payment.rb

@@ -7,248 +7,63 @@ require_relative '../satoshis'
 
 require_relative '../connections/payment_channel'
 require_relative '../nodes/node'
+require_relative '../payment_request'
 
 module Lighstorm
   module Models
     class Payment
-      KIND = :edge
+      attr_reader :_key, :hash, :request, :status, :created_at, :settled_at, :purpose
 
-      attr_reader :data
+      def initialize(data)
+        @data = data
 
-      def self.all(limit: nil, purpose: nil, hops: true, info: true)
-        last_offset = 0
-
-        payments = []
-
-        loop do
-          response = Cache.for('lightning.list_payments', params: { index_offset: last_offset }) do
-            LND.instance.middleware('lightning.list_payments') do
-              LND.instance.client.lightning.list_payments(index_offset: last_offset)
-            end
-          end
-
-          response.payments.each do |raw_payment|
-            case purpose
-            when 'potential-submarine', 'submarine'
-              payments << raw_payment if raw_potential_submarine?(raw_payment)
-            when '!potential-submarine', '!submarine'
-              payments << raw_payment unless raw_potential_submarine?(raw_payment)
-            when 'rebalance'
-              payments << raw_payment if raw_rebalance?(raw_payment)
-            when '!rebalance'
-              payments << raw_payment unless raw_rebalance?(raw_payment)
-            when '!payment'
-              payments << raw_payment if raw_potential_submarine?(raw_payment) || raw_rebalance?(raw_payment)
-            when 'payment'
-              payments << raw_payment if !raw_potential_submarine?(raw_payment) && !raw_rebalance?(raw_payment)
-            else
-              payments << raw_payment
-            end
-          end
-
-          # Fortunately, payments are sorted in descending order. :)
-          break if !limit.nil? && payments.size >= limit
-
-          break if last_offset == response.last_index_offset || last_offset > response.last_index_offset
-
-          last_offset = response.last_index_offset
-        end
-
-        payments = payments.sort_by { |raw_payment| -raw_payment.creation_time_ns }
-
-        payments = payments[0..limit - 1] unless limit.nil?
-
-        payments.map do |raw_payment|
-          Payment.new(raw_payment, respond_hops: hops, respond_info: info)
-        end
-      end
-
-      def self.first
-        all(limit: 1).first
-      end
-
-      def self.last
-        all.last
-      end
-
-      def initialize(raw, respond_hops: true, respond_info: true)
-        @respond_hops = respond_hops
-        @respond_info = respond_info
-        @data = { list_payments: { payments: [raw] } }
-      end
-
-      def id
-        @id ||= @data[:list_payments][:payments].first.payment_hash
+        @_key = data[:_key]
+        @status = data[:status]
+        @created_at = data[:created_at]
+        @settled_at = data[:settled_at]
+        @purpose = data[:purpose]
       end
 
-      def hash
-        @hash ||= @data[:list_payments][:payments].first.payment_hash
-      end
-
-      def status
-        @status ||= @data[:list_payments][:payments].first.status
-      end
-
-      def created_at
-        @created_at ||= DateTime.parse(Time.at(@data[:list_payments][:payments].first.creation_date).to_s)
-      end
-
-      def amount
-        @amount ||= Satoshis.new(
-          milisatoshis: @data[:list_payments][:payments].first.value_msat
-        )
+      def request
+        @request ||= PaymentRequest.new(@data[:request])
       end
 
       def fee
-        @fee ||= Satoshis.new(
-          milisatoshis: @data[:list_payments][:payments].first.fee_msat
-        )
-      end
-
-      def purpose
-        @purpose ||= Payment.raw_purpose(@data[:list_payments][:payments].first)
+        @fee ||= Satoshis.new(milisatoshis: @data[:fee][:milisatoshis])
       end
 
-      def rebalance?
-        return @rebalance unless @rebalance.nil?
-
-        validated_htlcs_number!
-
-        @rebalance = Payment.raw_rebalance?(
-          @data[:list_payments][:payments].first
-        )
-
-        @rebalance
-      end
-
-      def self.raw_rebalance?(raw_payment)
-        return false if raw_payment.htlcs.first.route.hops.size <= 2
-
-        destination_public_key = raw_payment.htlcs.first.route.hops.last.pub_key
-
-        Node.myself.public_key == destination_public_key
-      end
-
-      def self.raw_purpose(raw_payment)
-        return 'potential-submarine' if raw_potential_submarine?(raw_payment)
-        return 'rebalance' if raw_rebalance?(raw_payment)
-
-        'payment'
-      end
-
-      def self.raw_potential_submarine?(raw_payment)
-        raw_payment.htlcs.first.route.hops.size == 1
-      end
-
-      def potential_submarine?
-        validated_htlcs_number!
-
-        @potential_submarine ||= Payment.raw_potential_submarine?(
-          @data[:list_payments][:payments].first
-        )
-      end
-
-      def validated_htlcs_number!
-        return unless @data[:list_payments][:payments].first.htlcs.size > 1
+      def hops
+        return @hops if @hops
 
-        raise "Unexpected number of HTLCs (#{@data[:list_payments][:payments].first.htlcs.size}) for Payment"
+        @data[:hops].last[:is_last] = true
+        @hops = @data[:hops].map do |hop|
+          PaymentChannel.new(hop, self)
+        end
       end
 
       def from
-        return @from if @from
-
-        if @hops
-          @from = @hops.first
-          return @from
-        end
-
-        validated_htlcs_number!
-
-        @from = PaymentChannel.new(
-          @data[:list_payments][:payments].first.htlcs.first.route.hops.first,
-          1, respond_info: @respond_info
-        )
-
-        @from
+        @from ||= hops.first
       end
 
       def to
-        return @to if @to
-
-        if @hops
-
-          @to = rebalance? ? @hops[@hops.size - 2] : @hops.last
-          return @to
-        end
-
-        validated_htlcs_number!
-
-        @to = if rebalance?
-                PaymentChannel.new(
-                  @data[:list_payments][:payments].first.htlcs.first.route.hops[
-                    @data[:list_payments][:payments].first.htlcs.first.route.hops.size - 2
-                  ],
-                  @data[:list_payments][:payments].first.htlcs.first.route.hops.size - 1,
-                  respond_info: @respond_info
-                )
-              else
-                PaymentChannel.new(
-                  @data[:list_payments][:payments].first.htlcs.first.route.hops.last,
-                  @data[:list_payments][:payments].first.htlcs.first.route.hops.size,
-                  respond_info: @respond_info
-                )
-              end
-
-        @to
-      end
-
-      def hops
-        return @hops if @hops
-
-        validated_htlcs_number!
-
-        @hops = @data[:list_payments][:payments].first.htlcs.first.route.hops.map.with_index do |raw_hop, i|
-          PaymentChannel.new(raw_hop, i + 1, respond_info: @respond_info)
-        end
-      end
-
-      def preload_hops!
-        hops
-        true
+        @to ||= hops.last
       end
 
       def to_h
         response = {
-          id: id,
-          hash: hash,
+          _key: _key,
+          status: status,
           created_at: created_at,
+          settled_at: settled_at,
           purpose: purpose,
-          status: status,
-          amount: amount.to_h,
           fee: {
             milisatoshis: fee.milisatoshis,
-            parts_per_million: fee.parts_per_million(amount.milisatoshis)
-          }
-        }
-
-        if @respond_hops
-          preload_hops!
-          response[:from] = from.to_h
-          response[:to] = to.to_h
-          response[:hops] = hops.map(&:to_h)
-        else
-          response[:from] = from.to_h
-          response[:to] = to.to_h
-        end
-
-        response
-      end
-
-      def raw
-        {
-          list_payments: {
-            payments: [@data[:list_payments][:payments].first.to_h]
-          }
+            parts_per_million: fee.parts_per_million(request.amount.milisatoshis)
+          },
+          request: request.to_h,
+          from: from.to_h,
+          to: to.to_h,
+          hops: hops.map(&:to_h)
         }
       end
     end

data/models/errors.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Errors
+    class LighstormError < StandardError; end
+
+    class ToDoError < LighstormError; end
+
+    class MissingCredentialsError < LighstormError; end
+    class MissingMilisatoshisError < LighstormError; end
+    class MissingPartsPerMillionError < LighstormError; end
+    class MissingTTLError < LighstormError; end
+    class NegativeNotAllowedError < LighstormError; end
+    class NotYourChannelError < LighstormError; end
+    class NotYourNodeError < LighstormError; end
+    class OperationNotAllowedError < LighstormError; end
+    class UnexpectedNumberOfHTLCsError < LighstormError; end
+    class UnknownChannelError < LighstormError; end
+
+    class UpdateChannelPolicyError < LighstormError
+      attr_reader :response
+
+      def initialize(message, response)
+        super(message)
+        @response = response
+      end
+    end
+  end
+end

data/models/invoice.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require_relative 'satoshis'
+require 'securerandom'
+
+require_relative 'payment_request'
+
+require_relative '../controllers/invoice/actions/create'
+require_relative '../controllers/invoice/actions/pay'
+require_relative '../controllers/invoice/actions/pay_through_route'
+
+module Lighstorm
+  module Models
+    class Invoice
+      attr_reader :_key, :created_at, :settle_at, :state
+
+      def initialize(data)
+        @data = data
+
+        @_key = data[:_key]
+        @created_at = data[:created_at]
+        @settle_at = data[:settle_at]
+        @state = data[:state]
+      end
+
+      def request
+        @request ||= PaymentRequest.new(@data[:request])
+      end
+
+      def to_h
+        {
+          _key: _key,
+          created_at: created_at,
+          settle_at: settle_at,
+          state: state,
+          request: request.to_h
+        }
+      end
+
+      def pay!(route: nil, preview: false)
+        if route
+          Controllers::Invoice::PayThroughRoute.perform(self, route: route, preview: preview)
+        else
+          Controllers::Invoice::Pay.perform(self, preview: preview)
+        end
+      end
+    end
+  end
+end

data/models/nodes/node/lightning.rb

@@ -1,28 +1,17 @@
 # frozen_string_literal: true
 
-require_relative '../../../components/lnd'
-
 module Lighstorm
   module Models
     class Lightning
       IMPLEMENTATION = 'lnd'
 
-      def initialize(platform, node)
-        raise 'cannot provide platform details for a node that is not yours' unless node.myself?
-
-        @platform = platform
-      end
-
-      def version
-        @version ||= @platform.data[:get_info].version
-      end
+      attr_reader :implementation, :version
 
-      def raw
-        { get_info: @data[:get_info].to_h }
-      end
+      def initialize(node)
+        raise Errors::NotYourNodeError unless node.myself?
 
-      def implementation
-        @implementation ||= IMPLEMENTATION
+        @implementation = IMPLEMENTATION
+        @version = node.data[:platform][:lightning][:version]
       end
 
       def to_h