lighstorm 0.0.14 → 0.0.16

data/models/edges/channel.rb

@@ -1,195 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-require_relative '../../ports/grpc'
-require_relative '../../adapters/edges/channel'
-
-require_relative '../nodes/node'
-require_relative './channel/accounting'
-
-require_relative '../../controllers/channel/actions/apply_gossip'
-require_relative '../connections/channel_node'
-require_relative '../satoshis'
-
-require_relative '../errors'
-
-module Lighstorm
-  module Models
-    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::Channel.subscribe_channel_graph(gossip), nil)
-        elsif !dump.nil?
-          new(dump, nil)
-        end
-      end
-
-      def apply!(gossip:)
-        Controllers::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

data/models/edges/forward.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'time'
-
-require_relative '../satoshis'
-
-require_relative '../connections/forward_channel'
-require_relative 'groups/channel_forwards'
-
-module Lighstorm
-  module Models
-    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

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

@@ -1,69 +0,0 @@
-# frozen_string_literal: true
-
-module Lighstorm
-  module Models
-    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

data/models/edges/groups/channel_forwards.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../../satoshis'
-require_relative 'channel_forwards/analysis'
-
-module Lighstorm
-  module Models
-    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

data/models/edges/payment.rb

@@ -1,102 +0,0 @@
-# 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 Models
-    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

data/models/invoice.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'satoshis'
-require 'securerandom'
-
-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, :expires_at, :settled_at, :state, :payable, :code
-
-      def initialize(data, components)
-        @data = data
-        @components = components
-
-        @_key = data[:_key]
-        @created_at = data[:created_at]
-        @expires_at = data[:expires_at]
-        @settled_at = data[:settled_at]
-        @state = data[:state]
-
-        @payable = data[:payable]
-
-        @code = data[:code]
-      end
-
-      def payment
-        if payable != 'once' || @data[:payments].size > 1
-          raise InvoiceMayHaveMultiplePaymentsError, "payable: #{payable}, payments: #{@data[:payments].size.size}"
-        end
-
-        @payment ||= payments.first
-      end
-
-      def payments
-        @payments ||= @data[:payments]&.map { |data| Payment.new(data, @components) }
-      end
-
-      def amount
-        @amount ||= @data[:amount] ? Satoshis.new(millisatoshis: @data[:amount][:millisatoshis]) : nil
-      end
-
-      def received
-        @received ||= @data[:received] ? Satoshis.new(millisatoshis: @data[:received][:millisatoshis]) : nil
-      end
-
-      def secret
-        @secret ||= Secret.new(@data[:secret], @components)
-      end
-
-      def description
-        @description ||= Struct.new(:data) do
-          def memo
-            data[:memo]
-          end
-
-          def hash
-            data[:hash]
-          end
-
-          def to_h
-            { memo: memo, hash: hash }
-          end
-        end.new(@data[:description] || {})
-      end
-
-      def to_h
-        result = {
-          _key: _key,
-          created_at: created_at,
-          expires_at: expires_at,
-          settled_at: settled_at,
-          payable: payable,
-          state: state,
-          code: code,
-          amount: amount&.to_h,
-          received: received&.to_h,
-          description: description.to_h,
-          secret: secret.to_h,
-          payments: payments&.map(&:to_h)
-        }
-      end
-
-      def pay(
-        amount: nil, message: nil, route: nil,
-        fee: nil,
-        times_out_in: { seconds: 5 },
-        preview: false
-      )
-        raise MissingComponentsError if @components.nil?
-
-        if route
-          Controllers::Invoice::PayThroughRoute.perform(
-            @components, self, route: route, preview: preview
-          )
-        else
-          Controllers::Invoice::Pay.perform(
-            @components,
-            code: code,
-            amount: amount,
-            fee: fee,
-            message: message,
-            times_out_in: times_out_in,
-            preview: preview
-          )
-        end
-      end
-    end
-  end
-end

data/models/nodes/node/lightning.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Lighstorm
-  module Models
-    class Lightning
-      IMPLEMENTATION = 'lnd'
-
-      attr_reader :implementation, :version
-
-      def initialize(node)
-        raise Errors::NotYourNodeError unless node.myself?
-
-        @implementation = IMPLEMENTATION
-        @version = node.data[:platform][:lightning][:version]
-      end
-
-      def to_h
-        {
-          implementation: implementation,
-          version: version
-        }
-      end
-
-      def dump
-        Marshal.load(
-          Marshal.dump({ implementation: implementation, version: version })
-        )
-      end
-    end
-  end
-end

data/models/nodes/node/platform.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'lightning'
-
-require_relative '../../..//ports/grpc'
-require_relative '../../../adapters/nodes/node'
-
-module Lighstorm
-  module Models
-    class Platform
-      attr_reader :data
-
-      def initialize(node)
-        @node = node
-        @data = @node.data[:platform]
-      end
-
-      def blockchain
-        @blockchain ||= @data ? @data[:blockchain] : nil
-      end
-
-      def network
-        @network ||= @data ? @data[:network] : nil
-      end
-
-      def lightning
-        @lightning ||= Lightning.new(@node)
-      end
-
-      def to_h
-        response = {
-          blockchain: blockchain,
-          network: network
-        }
-
-        response[:lightning] = lightning.to_h if @node.myself?
-
-        response
-      end
-
-      def dump
-        data = Marshal.load(Marshal.dump(@data))
-        data.merge(lightning: lightning.dump) if @node.myself?
-        data
-      end
-    end
-  end
-end