lighstorm 0.0.14 → 0.0.16

data/adapters/invoice.rb

@@ -1,184 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-
-require_relative '../ports/dsl/lighstorm/errors'
-
-module Lighstorm
-  module Adapter
-    class Invoice
-      def self.add_invoice(grpc)
-        {
-          _source: :add_invoice,
-          code: grpc[:payment_request],
-          address: grpc[:payment_addr].unpack1('H*'),
-          secret: {
-            hash: grpc[:r_hash].unpack1('H*')
-          }
-        }
-      end
-
-      def self.decode_pay_req(grpc, code = nil)
-        adapted = {
-          _source: :decode_pay_req,
-          _key: Digest::SHA256.hexdigest(
-            [
-              grpc[:payment_hash],
-              grpc[:num_satoshis],
-              grpc[:timestamp],
-              grpc[:payment_addr]
-            ].join('/')
-          ),
-          payable: 'once',
-          created_at: Time.at(grpc[:timestamp]),
-          expires_at: Time.at(grpc[:timestamp] + grpc[:expiry]),
-          amount: (grpc[:num_msat]).zero? ? nil : { millisatoshis: grpc[:num_msat] },
-          description: {
-            memo: grpc[:description].empty? ? nil : grpc[:description],
-            hash: grpc[:description_hash] == '' ? nil : grpc[:description_hash]
-          },
-          address: grpc[:payment_addr].unpack1('H*'),
-          secret: {
-            hash: grpc[:payment_hash]
-          }
-        }
-
-        adapted[:code] = code unless code.nil?
-
-        if grpc[:features].key?(30) && grpc[:features][30][:is_required]
-          raise "unexpected feature[30] name #{grpc[:features][30][:name]}" if grpc[:features][30][:name] != 'amp'
-
-          adapted[:payable] = 'indefinitely'
-        end
-
-        adapted
-      end
-
-      def self.lookup_invoice(grpc, at)
-        adapted = list_or_lookup_invoice(grpc, at)
-        adapted[:_source] = :lookup_invoice
-        adapted
-      end
-
-      def self.list_invoices(grpc, at)
-        adapted = list_or_lookup_invoice(grpc, at)
-        adapted[:_source] = :list_invoices
-        adapted
-      end
-
-      def self.list_or_lookup_invoice(grpc, at)
-        raise 'missing at' if at.nil?
-
-        adapted = {
-          _key: _key(grpc),
-          created_at: Time.at(grpc[:creation_date]),
-          expires_at: Time.at(grpc[:creation_date] + grpc[:expiry]),
-          settled_at: grpc[:settle_date].nil? || !grpc[:settle_date].positive? ? nil : Time.at(grpc[:settle_date]),
-          state: grpc[:state].to_s.downcase,
-          code: grpc[:payment_request].empty? ? nil : grpc[:payment_request],
-          payable: grpc[:is_amp] == true ? 'indefinitely' : 'once',
-          description: {
-            memo: grpc[:memo].empty? ? nil : grpc[:memo],
-            hash: grpc[:description_hash].empty? ? nil : grpc[:description_hash]
-          },
-          address: grpc[:payment_addr].unpack1('H*'),
-          secret: {
-            preimage: grpc[:r_preimage].empty? ? nil : grpc[:r_preimage].unpack1('H*'),
-            hash: grpc[:r_hash].empty? ? nil : grpc[:r_hash].unpack1('H*')
-          }
-        }
-
-        adapted[:amount] = { millisatoshis: grpc[:value_msat] } if grpc[:value_msat] != 0
-
-        adapted[:received] = { millisatoshis: grpc[:amt_paid_msat] } if grpc[:amt_paid_msat] != 0
-
-        if adapted[:state] == 'settled' &&
-           adapted[:payable] == 'indefinitely' &&
-           adapted[:expires_at] > at
-          adapted[:state] = 'open'
-        end
-
-        raise 'todo: received with canceled' if !adapted[:received].nil? && adapted[:state] == 'canceled'
-
-        adapted[:payments] = []
-
-        grpc[:htlcs].each do |htlc|
-          next unless htlc[:state] == :SETTLED
-
-          payment = {
-            amount: { millisatoshis: htlc[:amt_msat] },
-            hops: [{ channel: { id: htlc[:chan_id] } }],
-            at: Time.at(htlc[:resolve_time])
-          }
-
-          if grpc[:is_amp]
-            payment[:secret] = {
-              preimage: htlc[:amp][:preimage].unpack1('H*'),
-              hash: htlc[:amp][:hash].unpack1('H*')
-            }
-          end
-
-          # https://github.com/satoshisstream/satoshis.stream/blob/main/TLV_registry.md
-          if htlc[:custom_records][34_349_334]
-            payment[:message] = htlc[:custom_records][34_349_334].dup
-
-            unless payment[:message].force_encoding('UTF-8').valid_encoding?
-              payment[:message] = payment[:message].unpack1('H*')
-
-              unless payment[:message].force_encoding('UTF-8').valid_encoding?
-                payment[:message] = payment[:message].scrub('?')
-              end
-            end
-          end
-
-          adapted[:payments] << payment
-        end
-
-        adapted[:payments] = adapted[:payments].sort_by { |payment| -payment[:at].to_i }
-
-        adapted.delete(:payments) if adapted[:payments].empty?
-
-        adapted
-      end
-
-      def self.list_payments(grpc, invoice_decode = nil)
-        data = {
-          _key: _key(grpc),
-          _source: :list_payments,
-          created_at: Time.at(grpc[:creation_date]),
-          settled_at: grpc[:settle_date].nil? || !grpc[:settle_date].positive? ? nil : Time.at(grpc[:settle_date]),
-          state: nil,
-          payable: grpc[:is_amp] == true ? 'indefinitely' : 'once',
-          code: grpc[:payment_request].empty? ? nil : grpc[:payment_request],
-          amount: { millisatoshis: grpc[:value_msat] },
-          description: {
-            memo: grpc[:memo],
-            hash: grpc[:description_hash] == '' ? nil : grpc[:description_hash]
-          },
-          secret: {
-            preimage: grpc[:payment_preimage],
-            hash: grpc[:payment_hash]
-          }
-        }
-
-        unless invoice_decode.nil?
-          data[:payable] = invoice_decode[:payable]
-          data[:expires_at] = invoice_decode[:expires_at]
-        end
-
-        data
-      end
-
-      def self._key(grpc)
-        Digest::SHA256.hexdigest(
-          [
-            grpc[:creation_date],
-            grpc[:settle_date],
-            grpc[:payment_request],
-            grpc[:state]
-          ].join('/')
-        )
-      end
-    end
-  end
-end

data/adapters/nodes/node.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-
-module Lighstorm
-  module Adapter
-    class Node
-      def self._key(public_key)
-        Digest::SHA256.hexdigest(
-          [public_key].join('/')
-        )
-      end
-
-      def self.get_chan_info(grpc, index)
-        {
-          _source: :get_chan_info,
-          _key: _key(grpc[:"node#{index}_pub"]),
-          public_key: grpc[:"node#{index}_pub"]
-        }
-      end
-
-      def self.list_channels(grpc, key)
-        data = {
-          _source: :list_channels,
-          _key: _key(key == :remote ? grpc[:remote_pubkey] : nil),
-          public_key: key == :remote ? grpc[:remote_pubkey] : nil
-        }
-
-        return nil if data[:public_key].nil?
-
-        data
-      end
-
-      def self.get_info(grpc)
-        data = {
-          _source: :get_info,
-          _key: _key(grpc[:identity_pubkey]),
-          public_key: grpc[:identity_pubkey],
-          alias: grpc[:alias],
-          color: grpc[:color],
-          platform: {
-            blockchain: grpc[:chains][0][:chain],
-            network: grpc[:chains][0][:network],
-            lightning: {
-              implementation: 'lnd',
-              version: grpc[:version]
-            }
-          }
-        }
-
-        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
-
-        data
-      end
-
-      def self.get_node_info(grpc)
-        data = {
-          _source: :get_node_info,
-          _key: _key(grpc[:node][:pub_key]),
-          public_key: grpc[:node][:pub_key],
-          alias: grpc[:node][:alias],
-          color: grpc[:node][:color]
-        }
-
-        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
-
-        data
-      end
-
-      def self.describe_graph(grpc)
-        data = {
-          _source: :describe_graph,
-          _key: _key(grpc[:pub_key]),
-          public_key: grpc[:pub_key],
-          alias: grpc[:alias],
-          color: grpc[:color]
-        }
-
-        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
-
-        data
-      end
-
-      def self.describe_graph_from_channel(grpc, index)
-        data = {
-          _source: :describe_graph,
-          _key: _key(grpc[:"node#{index}_pub"]),
-          public_key: grpc[:"node#{index}_pub"]
-        }
-
-        return nil if data[:public_key].nil?
-
-        data
-      end
-
-      def self.subscribe_channel_graph(json)
-        data = {
-          _source: :subscribe_channel_graph,
-          _key: _key(json['identityKey']),
-          public_key: json['identityKey'],
-          alias: json['alias'],
-          color: json['color']
-        }
-
-        return nil if data[:public_key].nil? && data[:alias].nil? && data[:color].nil?
-
-        data
-      end
-    end
-  end
-end

data/adapters/transaction.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-
-module Lighstorm
-  module Adapter
-    class Transaction
-      def self.get_transactions(grpc)
-        {
-          _source: :get_transactions,
-          _key: Digest::SHA256.hexdigest(
-            [grpc[:time_stamp], grpc[:tx_hash], grpc[:amount], grpc[:total_fees]].join('/')
-          ),
-          at: Time.at(grpc[:time_stamp]),
-          amount: { millisatoshis: grpc[:amount] * 1000 },
-          fee: { millisatoshis: grpc[:total_fees] * 1000 },
-          hash: grpc[:tx_hash],
-          label: grpc[:label]
-        }
-      end
-    end
-  end
-end

data/controllers/activity/all.rb

@@ -1,194 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../invoice/all'
-require_relative '../payment/all'
-require_relative '../forward/all'
-require_relative '../transaction/all'
-require_relative '../../models/activity'
-
-module Lighstorm
-  module Controllers
-    module Activity
-      module All
-        def self.bitcoin_how(transaction_label)
-          if transaction_label =~ /:openchannel:/
-            'opening-channel'
-          elsif transaction_label =~ /:closechannel:/
-            'closing-channel'
-          else
-            'spontaneously'
-          end
-        end
-
-        def self.fetch(components, direction: nil, layer: nil, how: nil, order: nil, limit: nil)
-          activities = []
-
-          # components[:grpc].lightning.list_channels.channels.each do |channel|
-          #   if (layer.nil? || layer == 'lightning')
-          #      activities << {
-          #         direction: 'out',
-          #         layer: 'lightning',
-          #         at: Time.now,
-          #         amount: {
-          #           millisatoshis: channel.to_h[:local_chan_reserve_sat] * 1000
-          #         },
-          #         how: 'reserve',
-          #         message: nil,
-          #         data: {}
-          #       }
-
-          #        activities << {
-          #         direction: 'out',
-          #         layer: 'lightning',
-          #         at: Time.now,
-          #         amount: {
-          #           millisatoshis: channel.to_h[:commit_fee] * 1000
-          #         },
-          #         how: 'commit',
-          #         message: nil,
-          #         data: {}
-          #       }
-          #     end
-          # end
-
-          Transaction::All.data(components).each do |transaction|
-            transaction_how = bitcoin_how(transaction[:label])
-
-            if (layer.nil? || layer == 'bitcoin') && (how.nil? || transaction_how =~ /#{Regexp.escape(how)}/)
-              activities << {
-                direction: (transaction[:amount][:millisatoshis]).positive? ? 'in' : 'out',
-                layer: 'bitcoin',
-                at: transaction[:at],
-                amount: {
-                  millisatoshis: if (transaction[:amount][:millisatoshis]).positive?
-                                   transaction[:amount][:millisatoshis]
-                                 else
-                                   -transaction[:amount][:millisatoshis]
-                                 end
-                },
-                how: transaction_how,
-                message: nil,
-                data: { transaction: transaction }
-              }
-            end
-
-            next unless (layer.nil? || layer == 'lightning') && (how.nil? || transaction_how =~ /#{Regexp.escape(how)}/) && %w[
-              channel opening-channel closing-channel
-            ].include?(transaction_how)
-
-            activities << {
-              direction: (transaction[:amount][:millisatoshis]).positive? ? 'out' : 'in',
-              layer: 'lightning',
-              at: transaction[:at] + ((transaction[:amount][:millisatoshis]).positive? ? -1 : 1),
-              amount: {
-                millisatoshis: if (transaction[:amount][:millisatoshis]).positive?
-                                 (transaction[:amount][:millisatoshis] - transaction[:fee][:millisatoshis])
-                               else
-                                 -(transaction[:amount][:millisatoshis] + transaction[:fee][:millisatoshis])
-                               end
-              },
-              how: transaction_how,
-              message: nil,
-              data: { transaction: transaction }
-            }
-          end
-
-          if (direction.nil? || direction == 'in') && (layer.nil? || layer == 'lightning')
-            Invoice::All.data(components, spontaneous: true).filter do |invoice|
-              !invoice[:payments].nil? && invoice[:payments].size.positive?
-            end.each do |invoice|
-              activity_how = invoice[:code].nil? ? 'spontaneously' : 'with-invoice'
-
-              next if !how.nil? && how != activity_how
-
-              # TODO: Improve performance by reducing invoice fields and removing payments?
-              invoice[:payments].each do |payment|
-                activities << {
-                  direction: 'in',
-                  layer: 'lightning',
-                  at: payment[:at],
-                  amount: payment[:amount],
-                  how: activity_how,
-                  message: payment[:message],
-                  data: { invoice: invoice }
-                }
-              end
-            end
-
-            Forward::All.data(components).each do |forward|
-              next if !how.nil? && how != 'forwarding'
-
-              activities << {
-                direction: 'in',
-                layer: 'lightning',
-                at: forward[:at],
-                amount: forward[:fee],
-                how: 'forwarding',
-                message: nil,
-                data: {}
-              }
-            end
-          end
-
-          if (direction.nil? || direction == 'out') && (layer.nil? || layer == 'lightning')
-            Payment::All.data(
-              components,
-              fetch: {
-                get_node_info: false,
-                lookup_invoice: false,
-                decode_pay_req: true,
-                get_chan_info: false
-              }
-            )[:data].each do |payment|
-              activity_how = payment[:invoice][:code].nil? ? 'spontaneously' : 'with-invoice'
-
-              next if !how.nil? && how != activity_how
-
-              # TODO: Improve performance by reducing invoice fields?
-              activities << {
-                direction: 'out',
-                layer: 'lightning',
-                at: payment[:at],
-                amount: payment[:amount],
-                how: activity_how,
-                message: payment[:message],
-                data: { invoice: payment[:invoice] }
-              }
-            end
-          end
-
-          activities = if order.nil? || order == 'desc'
-                         activities.sort_by { |activity| -activity[:at].to_i }
-                       else
-                         activities.sort_by { |activity| activity[:at].to_i }
-                       end
-
-          activities = activities[0..limit - 1] unless limit.nil?
-
-          { activities: activities }
-        end
-
-        def self.transform(raw)
-          raw[:activities].map do |activity|
-            activity[:_key] = SecureRandom.hex
-            activity
-          end
-        end
-
-        def self.data(components, direction: nil, layer: nil, how: nil, order: nil, limit: nil, &vcr)
-          raw = if vcr.nil?
-                  fetch(components, direction: direction, layer: layer, how: how, order: order, limit: limit)
-                else
-                  vcr.call(-> { fetch(components, direction: direction, how: how, order: order, limit: limit) })
-                end
-
-          transform(raw)
-        end
-
-        def self.model(data)
-          data.map { |data| Models::Activity.new(data) }
-        end
-      end
-    end
-  end
-end

data/controllers/activity.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require_relative './concerns/impersonatable'
-
-require_relative './activity/all'
-
-module Lighstorm
-  module Controllers
-    module Activity
-      extend Impersonatable
-
-      class DSL < Impersonatable::DSL
-        def all(direction: nil, layer: nil, how: nil, order: nil, limit: nil)
-          All.model(All.data(
-                      components,
-                      direction: direction,
-                      how: how,
-                      layer: layer,
-                      order: order,
-                      limit: limit
-                    ))
-        end
-      end
-    end
-  end
-end