lighstorm 0.0.2 → 0.0.4

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

data/models/nodes/node/platform.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
-require_relative '../../../components/lnd'
-
 require_relative 'lightning'
 
+require_relative '../../..//ports/grpc'
+require_relative '../../../adapters/nodes/node'
+
 module Lighstorm
   module Models
     class Platform
@@ -11,26 +12,19 @@ module Lighstorm
 
       def initialize(node)
         @node = node
-
-        response = Cache.for('lightning.get_info') do
-          LND.instance.middleware('lightning.get_info') do
-            LND.instance.client.lightning.get_info
-          end
-        end
-
-        @data = { get_info: response }
+        @data = @node.data[:platform]
       end
 
       def blockchain
-        @blockchain ||= @data[:get_info].chains.first.chain
+        @blockchain ||= @data ? @data[:blockchain] : nil
       end
 
       def network
-        @network ||= @data[:get_info].chains.first.network
+        @network ||= @data ? @data[:network] : nil
       end
 
       def lightning
-        @lightning ||= Lightning.new(self, @node)
+        @lightning ||= Lightning.new(@node)
       end
 
       def to_h

data/models/nodes/node.rb

@@ -1,34 +1,26 @@
 # frozen_string_literal: true
 
-require_relative '../../components/lnd'
-
-require_relative '../edges/channel'
+require_relative '../../controllers/channel'
+require_relative '../errors'
 
 require_relative 'node/platform'
 
 module Lighstorm
   module Models
     class Node
-      KIND = :node
-
-      attr_reader :alias, :public_key, :color
-
-      def self.myself
-        response = Cache.for('lightning.get_info') do
-          LND.instance.middleware('lightning.get_info') do
-            LND.instance.client.lightning.get_info
-          end
-        end
+      attr_reader :data, :_key, :alias, :public_key, :color
 
-        Node.find_by_public_key(response.identity_pubkey, myself: true)
-      end
+      def initialize(data)
+        @data = data
 
-      def self.find_by_public_key(public_key, myself: false)
-        Node.new({ public_key: public_key }, myself: myself)
+        @_key = @data[:_key]
+        @alias = @data[:alias]
+        @public_key = @data[:public_key]
+        @color = @data[:color]
       end
 
       def myself?
-        @myself
+        @data[:myself] == true
       end
 
       def platform
@@ -36,52 +28,23 @@ module Lighstorm
       end
 
       def channels
-        raise 'cannot list channels from a node that is not yours' unless myself?
-
-        Channel.all
-      end
+        raise Errors::NotYourNodeError unless myself?
 
-      def raw
-        {
-          get_node_info: @data[:get_node_info].to_h
-        }
+        Controllers::Channel.mine
       end
 
       def to_h
-        {
-          alias: @alias,
-          public_key: @public_key,
-          color: @color,
-          platform: platform.to_h
+        result = {
+          _key: _key,
+          public_key: public_key
         }
-      end
-
-      private
-
-      def initialize(params, myself: false)
-        response = Cache.for('lightning.get_node_info', params: { pub_key: params[:public_key] }) do
-          LND.instance.middleware('lightning.get_node_info') do
-            LND.instance.client.lightning.get_node_info(pub_key: params[:public_key])
-          end
-        end
-
-        unless myself
-          response_get_info = Cache.for('lightning.get_info') do
-            LND.instance.middleware('lightning.get_info') do
-              LND.instance.client.lightning.get_info
-            end
-          end
-
-          myself = true if params[:public_key] == response_get_info.identity_pubkey
-        end
 
-        @data = { get_node_info: response }
+        result[:alias] = @alias unless self.alias.nil?
+        result[:color] = @color unless color.nil?
 
-        @myself = myself
+        result[:platform] = platform.to_h if @data[:platform]
 
-        @alias = @data[:get_node_info].node.alias
-        @public_key = @data[:get_node_info].node.pub_key
-        @color = @data[:get_node_info].node.color
+        result
       end
     end
   end