lighstorm 0.0.1

data/models/connections/channel_node/policy.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative 'fee'
+
+module Lighstorm
+  module Models
+    class Policy
+      def initialize(channel, node)
+        @channel = channel
+        @node = node
+      end
+
+      def data
+        @data ||= if @channel.data[:get_chan_info].node1_pub == @node.public_key
+                    @channel.data[:get_chan_info].node1_policy
+                  else
+                    @channel.data[:get_chan_info].node2_policy
+                  end
+      end
+
+      def fees
+        @fees ||= Fee.new(self, @channel, @node)
+      end
+
+      def to_h
+        { fee: fees.to_h }
+      end
+    end
+  end
+end

data/models/connections/channel_node.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require_relative 'channel_node/constraints'
+require_relative 'channel_node/policy'
+require_relative 'channel_node/accounting'
+
+module Lighstorm
+  module Models
+    class ChannelNode
+      KIND = :connection
+
+      attr_reader :node
+
+      def initialize(channel, node)
+        @channel = channel
+        @node = node
+      end
+
+      def policy
+        @policy ||= Policy.new(@channel, @node)
+      end
+
+      def constraints
+        @constraints ||= Constraints.new(@channel, @node)
+      end
+
+      def accounting
+        @accounting ||= ChannelNodeAccounting.new(@channel, @node)
+      end
+
+      def to_h
+        {
+          accounting: accounting.to_h,
+          node: @node.to_h,
+          policy: policy.to_h
+          # constraints: constraints.to_h
+        }
+      end
+    end
+  end
+end

data/models/connections/forward_channel.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative '../edges/channel'
+
+module Lighstorm
+  module Models
+    class ForwardChannel
+      KIND = :connection
+
+      def initialize(direction, forward)
+        @direction = direction
+        @forward = forward
+      end
+
+      def channel
+        @channel ||= if @direction == :in
+                       Channel.find_by_id(
+                         @forward.data[:forwarding_history][:forwarding_events].first.chan_id_in
+                       )
+                     else
+                       Channel.find_by_id(
+                         @forward.data[:forwarding_history][:forwarding_events].first.chan_id_out
+                       )
+                     end
+      end
+
+      def amount
+        @amount ||= if @direction == :in
+                      Satoshis.new(milisatoshis:
+                        @forward.data[:forwarding_history][:forwarding_events].first.amt_in_msat)
+                    else
+                      Satoshis.new(milisatoshis:
+                        @forward.data[:forwarding_history][:forwarding_events].first.amt_out_msat)
+                    end
+      end
+
+      def to_h
+        {
+          amount: amount.to_h,
+          channel: {
+            id: channel.id,
+            partner: {
+              node: {
+                alias: channel.partner&.node&.alias,
+                public_key: channel.partner&.node&.public_key,
+                color: channel.partner&.node&.color
+              }
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/models/connections/payment_channel.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative '../edges/channel'
+require_relative '../nodes/node'
+
+module Lighstorm
+  module Models
+    class PaymentChannel
+      KIND = :connection
+
+      def initialize(raw_hop, hop_index)
+        @raw_hop = raw_hop
+        @index = hop_index
+      end
+
+      def channel
+        @channel ||= Channel.find_by_id(@raw_hop.chan_id)
+      end
+
+      def amount
+        @amount ||= Satoshis.new(milisatoshis: @raw_hop.amt_to_forward_msat)
+      end
+
+      def fee
+        @fee ||= Satoshis.new(milisatoshis: @raw_hop.fee_msat)
+      end
+
+      def raw
+        @raw_hop
+      end
+
+      def partner_node
+        Node.find_by_public_key(@raw_hop.pub_key)
+      end
+
+      def to_h
+        {
+          hop: @index,
+          amount: amount.to_h,
+          fee: {
+            milisatoshis: fee.milisatoshis,
+            parts_per_million: fee.parts_per_million(amount.milisatoshis)
+          },
+          channel: {
+            id: channel.id,
+            partner: {
+              node: {
+                alias: partner_node&.alias,
+                public_key: partner_node&.public_key,
+                color: partner_node&.color
+              }
+            }
+          }
+        }
+      end
+    end
+  end
+end

data/models/edges/channel/accounting.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative '../../satoshis'
+
+module Lighstorm
+  module Models
+    class ChannelAccounting
+      def initialize(channel)
+        @channel = channel
+      end
+
+      def capacity
+        @capacity ||= Satoshis.new(milisatoshis: @channel.data[:get_chan_info].capacity * 1000)
+      end
+
+      def sent
+        @sent ||= Satoshis.new(milisatoshis: (
+                         @channel.data[:list_channels][:channels].first.total_satoshis_sent.to_f * 1000.0
+                       ))
+      end
+
+      def received
+        @received ||= Satoshis.new(milisatoshis: (
+                         @channel.data[:list_channels][:channels].first.total_satoshis_received.to_f * 1000.0
+                       ))
+      end
+
+      def unsettled
+        @unsettled ||= Satoshis.new(milisatoshis: (
+                         @channel.data[:list_channels][:channels].first.unsettled_balance.to_f * 1000.0
+                       ))
+      end
+
+      def to_h
+        {
+          capacity: capacity.to_h,
+          sent: sent.to_h,
+          received: received.to_h,
+          unsettled: unsettled.to_h
+        }
+      end
+    end
+  end
+end

data/models/edges/channel.rb

@@ -0,0 +1,179 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+
+require_relative '../../components/lnd'
+require_relative '../../components/cache'
+
+require_relative '../nodes/node'
+require_relative 'channel/accounting'
+
+require_relative '../connections/channel_node'
+require_relative '../satoshis'
+
+module Lighstorm
+  module Models
+    class Channel
+      KIND = :edge
+
+      attr_reader :id, :data
+
+      def self.all
+        response = Cache.for('lightning.list_channels', ttl: 1) do
+          LND.instance.middleware('lightning.list_channels') do
+            LND.instance.client.lightning.list_channels
+          end
+        end
+
+        response.channels.map do |channel|
+          Channel.find_by_id(channel.chan_id)
+        end
+      end
+
+      def self.first
+        all.first
+      end
+
+      def self.last
+        all.last
+      end
+
+      def self.find_by_id(id)
+        Channel.new({ id: id })
+      end
+
+      def initialize(params)
+        begin
+          response = Cache.for(
+            'lightning.get_chan_info',
+            ttl: 1, params: { chan_id: params[:id] }
+          ) do
+            LND.instance.middleware('lightning.get_chan_info') do
+              LND.instance.client.lightning.get_chan_info(chan_id: params[:id])
+            end
+          end
+
+          @data = { get_chan_info: response }
+          @id = @data[:get_chan_info].channel_id
+        rescue StandardError => _e
+          @data = { get_chan_info: nil }
+          @id = params[:id]
+        end
+
+        fetch_from_fee_report!
+
+        fetch_from_list_channels!
+        calculate_times_after_list_channels!
+      end
+
+      def active
+        @data[:list_channels] ? @data[:list_channels][:channels].first.active : nil
+      end
+
+      def exposure
+        return unless @data[:list_channels]
+
+        @data[:list_channels][:channels].first.private ? 'private' : 'public'
+      end
+
+      def opened_at
+        @opened_at ||= if @data[:list_channels]
+                         DateTime.parse(
+                           (Time.now - @data[:list_channels][:channels].first.lifetime).to_s
+                         )
+                       end
+      end
+
+      def up_at
+        @up_at ||= if @data[:list_channels]
+                     DateTime.parse(
+                       (Time.now - @data[:list_channels][:channels].first.uptime).to_s
+                     )
+                   end
+      end
+
+      def accounting
+        return nil unless @data[:get_chan_info]
+
+        @accounting ||= ChannelAccounting.new(self)
+      end
+
+      def myself
+        return nil unless @data[:get_chan_info]
+
+        @myself ||= ChannelNode.new(self, Node.myself)
+      end
+
+      def partner
+        return nil unless @data[:get_chan_info]
+
+        public_key = if @data[:get_chan_info].node1_pub == myself.node.public_key
+                       @data[:get_chan_info].node2_pub
+                     else
+                       @data[:get_chan_info].node1_pub
+                     end
+
+        @partner ||= ChannelNode.new(self, Node.find_by_public_key(public_key))
+      end
+
+      def raw
+        {
+          get_chan_info: @data[:get_chan_info].to_h,
+          list_channels: { channels: @data[:list_channels][:channels].map(&:to_h) }
+        }
+      end
+
+      def to_h
+        {
+          id: id,
+          opened_at: opened_at,
+          up_at: up_at,
+          active: active,
+          exposure: exposure,
+          accounting: accounting.to_h,
+          partner: partner.to_h,
+          myself: myself.to_h
+        }
+      end
+
+      private
+
+      # Ensure that we are getting fresh up-date data about our own fees.
+      def fetch_from_fee_report!
+        response = Cache.for('lightning.fee_report', ttl: 1) do
+          LND.instance.middleware('lightning.fee_report') do
+            LND.instance.client.lightning.fee_report
+          end
+        end
+
+        response.channel_fees.map do |channel|
+          if channel.chan_id == @id
+            @data[:fee_report] = { channel_fees: [channel] }
+            break
+          end
+        end
+      end
+
+      def fetch_from_list_channels!
+        response = Cache.for('lightning.list_channels', ttl: 1) do
+          LND.instance.middleware('lightning.list_channels') do
+            LND.instance.client.lightning.list_channels
+          end
+        end
+
+        response.channels.map do |channel|
+          if channel.chan_id == @id
+            @data[:list_channels] = { channels: [channel] }
+            break
+          end
+        end
+      end
+
+      def calculate_times_after_list_channels!
+        opened_at
+        up_at
+      end
+    end
+  end
+end

data/models/edges/forward.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'time'
+require 'date'
+
+require_relative '../satoshis'
+
+require_relative '../connections/forward_channel'
+
+module Lighstorm
+  module Models
+    class Forward
+      KIND = :edge
+
+      attr_reader :data
+
+      def self.all(limit: nil)
+        last_offset = 0
+
+        forwards = []
+
+        loop do
+          response = LND.instance.middleware('lightning.forwarding_history') do
+            LND.instance.client.lightning.forwarding_history(
+              peer_alias_lookup: true, index_offset: last_offset
+            )
+          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?
+
+        forwards.map { |raw_forward| Forward.new(raw_forward) }
+      end
+
+      def self.first
+        all(limit: 1).first
+      end
+
+      def self.last
+        all.last
+      end
+
+      def initialize(raw)
+        @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).to_s)
+      end
+
+      def fee
+        Satoshis.new(milisatoshis: @data[:forwarding_history][:forwarding_events].first.fee_msat)
+      end
+
+      def in
+        @in ||= ForwardChannel.new(:in, self)
+      end
+
+      def out
+        @out ||= ForwardChannel.new(:out, self)
+      end
+
+      def to_h
+        {
+          id: id,
+          at: at,
+          fee: {
+            milisatoshis: fee.milisatoshis,
+            parts_per_million: fee.parts_per_million(self.in.amount.milisatoshis)
+          },
+          in: self.in.to_h,
+          out: out.to_h
+        }
+      end
+
+      def raw
+        {
+          forwarding_history: {
+            forwarding_events: [@data[:forwarding_history][:forwarding_events].first.to_h]
+          }
+        }
+      end
+    end
+  end
+end