lighstorm 0.0.3 → 0.0.5

data/models/edges/payment.rb

@@ -1,254 +1,68 @@
 # frozen_string_literal: true
 
 require 'time'
-require 'date'
 
 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,32 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Errors
+    class LighstormError < StandardError; end
+
+    class ToDoError < LighstormError; end
+
+    class TooManyArgumentsError < LighstormError; end
+    class IncoherentGossipError < LighstormError; end
+    class MissingGossipHandlerError < 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
@@ -31,6 +20,12 @@ module Lighstorm
           version: version
         }
       end
+
+      def dump
+        Marshal.load(
+          Marshal.dump({ implementation: implementation, version: version })
+        )
+      end
     end
   end
 end

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
@@ -43,6 +37,12 @@ module Lighstorm
 
         response
       end
+
+      def dump
+        data = Marshal.load(Marshal.dump(@data))
+        data.merge(lightning: lightning.dump) if @node.myself?
+        data
+      end
     end
   end
 end

data/models/nodes/node.rb

@@ -1,46 +1,31 @@
 # frozen_string_literal: true
 
-require_relative '../../components/lnd'
-
-require_relative '../edges/channel'
+require_relative '../../controllers/node/actions/apply_gossip'
+require_relative '../../controllers/channel'
+require_relative '../../adapters/nodes/node'
+require_relative '../concerns/protectable'
+require_relative '../errors'
 
 require_relative 'node/platform'
 
 module Lighstorm
   module Models
     class Node
-      KIND = :node
-
-      attr_reader :alias, :public_key, :color
+      include Protectable
 
-      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)
-      end
-
-      def self.all
-        response = LND.instance.middleware('lightning.describe_graph') do
-          LND.instance.client.lightning.describe_graph
-        end
-
-        myself_public_key = myself.public_key
-
-        response.nodes.map do |raw_node|
-          Node.new({ describe_graph: raw_node }, myself: raw_node.pub_key == myself_public_key)
-        end
+        @_key = @data[:_key]
+        @alias = @data[:alias]
+        @public_key = @data[:public_key]
+        @color = @data[:color]
       end
 
       def myself?
-        @myself
+        @data[:myself] == true
       end
 
       def platform
@@ -48,98 +33,69 @@ module Lighstorm
       end
 
       def channels
-        if myself?
-          Channel.mine
-        else
-          Channel.all
-        end
-      end
+        raise Errors::NotYourNodeError unless myself?
 
-      def raw
-        {
-          get_node_info: @data[:get_node_info].to_h,
-          describe_graph: @data[:describe_graph].to_h
-        }
+        Controllers::Channel.mine
       end
 
       def to_h
-        if (@data[:get_node_info] || @data[:describe_graph]) && myself?
-          {
-            alias: @alias,
-            public_key: @public_key,
-            color: @color,
-            platform: platform.to_h
-          }
-        elsif @data[:get_node_info] || @data[:describe_graph]
-          {
-            alias: @alias,
-            public_key: @public_key,
-            color: @color
-          }
-        else
-          {
-            public_key: @public_key
-          }
-        end
-      end
+        result = {
+          _key: _key,
+          public_key: public_key
+        }
 
-      def myself
-        return @myself unless @myself.nil?
+        result[:alias] = @alias unless self.alias.nil?
+        result[:color] = @color unless color.nil?
 
-        response_get_info = Cache.for('lightning.get_info') do
-          LND.instance.middleware('lightning.get_info') do
-            LND.instance.client.lightning.get_info
-          end
-        end
+        result[:platform] = platform.to_h if @data[:platform]
 
-        @myself = public_key == response_get_info.identity_pubkey
+        result
       end
 
-      def error?
-        !@data[:error].nil?
+      def dump
+        result = Marshal.load(Marshal.dump(@data))
+
+        result[:platform] = platform.dump if @data[:platform]
+
+        result
       end
 
-      def error
-        @data[:error]
+      def alias=(value)
+        protect!(value)
+
+        @alias = value[:value]
+
+        @data[:alias] = @alias
+
+        self.alias
       end
 
-      def initialize(params, myself: false, fetch: true)
-        if params[:public_key] && fetch
-          begin
-            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
-
-            @data = { get_node_info: response }
-            @raw_node = response.node
-          rescue StandardError => e
-            @data = { get_node_info: nil, error: e }
-            @public_key = params[:public_key]
-          end
-        elsif params[:describe_graph]
-          @data = { describe_graph: params[:describe_graph] }
-
-          @raw_node = params[:describe_graph]
-        else
-          @data = {}
-        end
+      def color=(value)
+        protect!(value)
 
-        @myself = myself
+        @color = value[:value]
 
-        if params[:public_key] && !fetch
-          @public_key = params[:public_key]
-          return
-        end
+        @data[:color] = @color
+
+        color
+      end
 
-        @myself = myself
+      def self.adapt(gossip: nil, dump: nil)
+        raise TooManyArgumentsError, 'you need to pass gossip: or dump:, not both' if !gossip.nil? && !dump.nil?
 
-        return unless @raw_node
+        raise ArgumentError, 'missing gossip: or dump:' if gossip.nil? && dump.nil?
+
+        if !gossip.nil?
+          new(Adapter::Node.subscribe_channel_graph(gossip))
+        elsif !dump.nil?
+          new(dump)
+        end
+      end
 
-        @alias = @raw_node.alias
-        @public_key = @raw_node.pub_key
-        @color = @raw_node.color
+      def apply!(gossip:)
+        Controllers::Node::ApplyGossip.perform(
+          self, gossip
+        )
       end
     end
   end