lighstorm 0.0.15 → 0.0.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1722bbe98bbd5a925f29fb5e172f04dec56ed8acc73eb9e6ef88eeb7200b94bd
-  data.tar.gz: f06cb3903370b567275814a9541db2ca0c7dea7febd75e9ec95eb76d758714ef
+  metadata.gz: '0004783b50e9d57b22b89d956b84e88176902be82e1a6b42f4e4c4d1a385405c'
+  data.tar.gz: a153b71845e699695777c5b062a51e398ebf5d444c634b63fb2b6fc4b1523e8b
 SHA512:
-  metadata.gz: 9cf1908d5809f4c2d8e3201926e3480b9e63b5958eee22ddfff6e210dac056f2f222bd9836fb4e7b98f316eace4c82ef44a579111afe283719b2cf268dc762e4
-  data.tar.gz: 37a3c2544ed50c25e839c41f441c684f282d4995f319ad81f428ae0fc1a6b30d7225208ecd886732264da723e33db17d2732019eb8f430907662a3f5eebaeda0
+  metadata.gz: abbeeace9a564c6cb06abc0a726dfa84e56907d4b92aaf4c6169945ff5f66fb82120046e5df233d5273034cf202e0230184554ba1f3a667522498907fae5095e
+  data.tar.gz: e7b887c4e3411621cdfc495f5b3026cf3b84f70b80bbca986c3b46f26f414eff0e7d02e99aab67659dd65dd5908e9ec6ca091ff7eae6c554d04e1b5eb1f04e85

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lighstorm (0.0.15)
+    lighstorm (0.0.16)
       dotenv (~> 2.8, >= 2.8.1)
       lnd-client (~> 0.0.9)
       zache (~> 0.12.0)

data/README.md

@@ -7,7 +7,7 @@ API for interacting with a [Lightning Node](https://lightning.network).
 ![Lighstorm text written stylized with an illustration of a Graph connecting two Nodes.](https://raw.githubusercontent.com/icebaker/assets/main/lighstorm/lighstorm.png)
 
 ```ruby
-Lighstorm::Channel.mine.first.myself.node.alias
+Lighstorm::Lightning::Channel.mine.first.myself.node.alias
 ```
 
 ## Index
@@ -35,7 +35,7 @@ Although it tries to stay close to [Lightning's terminologies](https://docs.ligh
 Add to your `Gemfile`:
 
 ```ruby
-gem 'lighstorm', '~> 0.0.15'
+gem 'lighstorm', '~> 0.0.16'
 ```
 
 ```ruby
@@ -53,19 +53,19 @@ Lighstorm.connect!(
   macaroon_path: '/lnd/data/chain/bitcoin/mainnet/admin.macaroon'
 )
 
-puts Lighstorm.version # => 0.0.15
+puts Lighstorm.version # => 0.0.16
 
-Lighstorm::Node.myself.alias # => icebaker/old-stone
+Lighstorm::Lightning::Node.myself.alias # => icebaker/old-stone
 
-Lighstorm::Invoice.create(
+Lighstorm::Lightning::Invoice.create(
   description: 'Coffee',
   amount: { millisatoshis: 1_000 },
   payable: 'once'
 )
 
-Lighstorm::Invoice.decode('lnbc20m1pv...qqdhhwkj').pay
+Lighstorm::Lightning::Invoice.decode('lnbc20m1pv...qqdhhwkj').pay
 
-Lighstorm::Invoice.decode('lnbc20m1pv...qqdhhwkj').pay(
+Lighstorm::Lightning::Invoice.decode('lnbc20m1pv...qqdhhwkj').pay(
   fee: { maximum: { millisatoshis: 1000 } }
 )
 

data/adapters/bitcoin/address.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    module Bitcoin
+      class Address
+        def self.new_address(grpc)
+          {
+            _source: :new_address,
+            _key: Digest::SHA256.hexdigest([grpc[:address]].join('/')),
+            code: grpc[:address]
+          }
+        end
+      end
+    end
+  end
+end

data/adapters/bitcoin/transaction.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    module Bitcoin
+      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) + ((grpc[:amount].positive? ? -1 : 1) * (grpc[:total_fees] * 1000)) },
+            fee: { millisatoshis: grpc[:total_fees] * 1000 },
+            hash: grpc[:tx_hash],
+            description: grpc[:label] == '' ? nil : grpc[:label],
+            to: { address: { code: grpc[:dest_addresses].first } }
+          }
+        end
+
+        def self.send_coins(grpc)
+          {
+            _source: :send_coins,
+            _key: Digest::SHA256.hexdigest([grpc[:txid]].join('/')),
+            hash: grpc[:txid]
+          }
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/connections/channel_node/fee.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class Fee
+        def self.fee_report(grpc)
+          {
+            _source: :fee_report,
+            id: grpc[:chan_id].to_s,
+            partner: {
+              policy: {
+                fee: {
+                  base: {
+                    millisatoshis: grpc[:base_fee_msat]
+                  },
+                  rate: {
+                    parts_per_million: grpc[:fee_per_mil]
+                  }
+                }
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/connections/channel_node/policy.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class Policy
+        def self.get_chan_info(grpc)
+          {
+            fee: {
+              base: { millisatoshis: grpc[:fee_base_msat] },
+              rate: { parts_per_million: grpc[:fee_rate_milli_msat] }
+            },
+            htlc: {
+              minimum: { millisatoshis: grpc[:min_htlc] },
+              maximum: { millisatoshis: grpc[:max_htlc_msat] },
+              # https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#cltv_expiry_delta-selection
+              blocks: {
+                delta: {
+                  minimum: grpc[:time_lock_delta] # aka cltv_expiry_delta
+                }
+              }
+            }
+          }
+        end
+
+        def self.subscribe_channel_graph(json)
+          result = {
+            _source: :subscribe_channel_graph,
+            fee: {
+              base: { millisatoshis: json['routingPolicy']['feeBaseMsat'].to_i },
+              rate: { parts_per_million: json['routingPolicy']['feeRateMilliMsat'].to_i }
+            },
+            htlc: {
+              minimum: { millisatoshis: json['routingPolicy']['minHtlc'].to_i },
+              maximum: { millisatoshis: json['routingPolicy']['maxHtlcMsat'].to_i },
+              # https://github.com/lightning/bolts/blob/master/02-peer-protocol.md#cltv_expiry_delta-selection
+              blocks: {
+                delta: {
+                  minimum: json['routingPolicy']['timeLockDelta'].to_i # aka cltv_expiry_delta
+                }
+              }
+            }
+          }
+
+          policy = json['routingPolicy']
+
+          result[:fee].delete(:base) unless policy.key?('feeBaseMsat') && !policy['feeBaseMsat'].nil?
+          result[:fee].delete(:rate) unless policy.key?('feeRateMilliMsat') && !policy['feeRateMilliMsat'].nil?
+          result.delete(:fee) if result[:fee].empty?
+
+          result[:htlc].delete(:minimum) unless policy.key?('minHtlc') && !policy['minHtlc'].nil?
+          result[:htlc].delete(:maximum) unless policy.key?('maxHtlcMsat') && !policy['maxHtlcMsat'].nil?
+          result[:htlc].delete(:blocks) unless policy.key?('timeLockDelta') && !policy['timeLockDelta'].nil?
+          result.delete(:htlc) if result[:htlc].empty?
+
+          return nil unless result.key?(:fee) || result.key?(:htlc)
+
+          result
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/connections/channel_node.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative '../nodes/node'
+require_relative 'channel_node/policy'
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class ChannelNode
+        def self.list_channels(grpc, key)
+          data = {
+            _source: :list_channels,
+            state: grpc[:active] ? 'active' : 'inactive',
+            initiator: grpc[:initiator] && key == :local,
+            accounting: { balance: { millisatoshis: grpc[:"#{key}_balance"] * 1000 } },
+            node: Node.list_channels(grpc, key)
+          }
+
+          data.delete(:node) if data[:node].nil?
+
+          data
+        end
+
+        def self.get_chan_info(grpc, index)
+          data = {
+            _source: :get_chan_info,
+            node: Node.get_chan_info(grpc, index)
+          }
+
+          if grpc[:"node#{index}_policy"]
+            data[:state] = grpc[:"node#{index}_policy"][:disabled] ? 'inactive' : 'active'
+            data[:policy] = Policy.get_chan_info(grpc[:"node#{index}_policy"])
+          end
+
+          data.delete(:node) if data[:node].nil?
+
+          data
+        end
+
+        def self.describe_graph(grpc, index)
+          data = {
+            _source: :describe_graph,
+            node: Node.describe_graph_from_channel(grpc, index)
+          }
+
+          # TODO: No examples to validate the correctness of this scenario.
+          if grpc[:"node#{index}_policy"]
+            data[:state] = grpc[:"node#{index}_policy"][:disabled] ? 'inactive' : 'active'
+            data[:policy] = Policy.get_chan_info(grpc[:"node#{index}_policy"])
+          end
+
+          data.delete(:node) if data[:node].nil?
+
+          data
+        end
+
+        def self.subscribe_channel_graph(json)
+          data = {
+            _source: :subscribe_channel_graph,
+            node: {
+              public_key: json['advertisingNode']
+            },
+            policy: Policy.subscribe_channel_graph(json)
+          }
+
+          unless json['routingPolicy']['disabled'].nil?
+            data[:state] = json['routingPolicy']['disabled'] ? 'inactive' : 'active'
+          end
+
+          data.delete(:policy) if data[:policy].nil?
+
+          data
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/connections/payment_channel.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class PaymentChannel
+        def self.list_payments(grpc, index)
+          {
+            _source: :list_payments,
+            hop: index + 1,
+            amount: { millisatoshis: grpc[:amt_to_forward_msat] },
+            fee: { millisatoshis: grpc[:fee_msat] },
+            channel: {
+              _key: Digest::SHA256.hexdigest(grpc[:chan_id].to_s),
+              id: grpc[:chan_id].to_s,
+              partners: [
+                node: {
+                  _key: Digest::SHA256.hexdigest(grpc[:pub_key].to_s),
+                  public_key: grpc[:pub_key]
+                }
+              ]
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/edges/channel.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative '../connections/channel_node'
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class Channel
+        def self._key(id, state)
+          Digest::SHA256.hexdigest(
+            [id, state].join('/')
+          )
+        end
+
+        def self.list_channels(grpc, at)
+          {
+            _source: :list_channels,
+            _key: _key(grpc[:chan_id], grpc[:active] ? 'active' : 'inactive'),
+            # Standard JSON don't support BigInt, so, a String is safer.
+            id: grpc[:chan_id].to_s,
+            transaction: {
+              funding: {
+                id: grpc[:channel_point].split(':').first,
+                index: grpc[:channel_point].split(':').last.to_i
+              }
+            },
+            opened_at: at - grpc[:lifetime],
+            up_at: at - grpc[:uptime],
+            state: grpc[:active] ? 'active' : 'inactive',
+            exposure: grpc[:private] ? 'private' : 'public',
+            accounting: {
+              capacity: { millisatoshis: grpc[:capacity] * 1000 },
+              sent: { millisatoshis: grpc[:total_satoshis_sent] * 1000 },
+              received: { millisatoshis: grpc[:total_satoshis_received] * 1000 },
+              unsettled: { millisatoshis: grpc[:unsettled_balance] * 1000 }
+            },
+            partners: [
+              ChannelNode.list_channels(grpc, :local),
+              ChannelNode.list_channels(grpc, :remote)
+            ]
+          }
+        end
+
+        def self.get_chan_info(grpc)
+          {
+            _source: :get_chan_info,
+            _key: _key(grpc[:channel_id], nil),
+            # Standard JSON don't support BigInt, so, a String is safer.
+            id: grpc[:channel_id].to_s,
+            accounting: {
+              capacity: { millisatoshis: grpc[:capacity] * 1000 }
+            },
+            partners: [
+              ChannelNode.get_chan_info(grpc, 1),
+              ChannelNode.get_chan_info(grpc, 2)
+            ]
+          }
+        end
+
+        def self.describe_graph(grpc)
+          {
+            _source: :describe_graph,
+            _key: _key(grpc[:channel_id], nil),
+            # Standard JSON don't support BigInt, so, a String is safer.
+            id: grpc[:channel_id].to_s,
+            exposure: 'public',
+            accounting: {
+              capacity: { millisatoshis: grpc[:capacity] * 1000 }
+            },
+            partners: [
+              ChannelNode.describe_graph(grpc, 1),
+              ChannelNode.describe_graph(grpc, 2)
+            ]
+          }
+        end
+
+        def self.subscribe_channel_graph(json)
+          {
+            _source: :subscribe_channel_graph,
+            _key: _key(json['chanId'], nil),
+            id: json['chanId'],
+            accounting: {
+              capacity: { millisatoshis: json['capacity'].to_i * 1000 }
+            },
+            partners: [
+              ChannelNode.subscribe_channel_graph(json),
+              { node: {
+                public_key: json['connectingNode']
+              } }
+            ]
+          }
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/edges/forward.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class Forward
+        def self.forwarding_history(grpc)
+          {
+            _source: :forwarding_history,
+            _key: _key(grpc),
+            at: Time.at(grpc[:timestamp_ns] / 1e+9),
+            fee: { millisatoshis: grpc[:fee_msat] },
+            in: {
+              amount: { millisatoshis: grpc[:amt_in_msat] },
+              channel: {
+                id: grpc[:chan_id_in].to_s
+              }
+            },
+            out: {
+              amount: { millisatoshis: grpc[:amt_out_msat] },
+              channel: {
+                id: grpc[:chan_id_out].to_s
+              }
+            }
+          }
+        end
+
+        def self._key(grpc)
+          Digest::SHA256.hexdigest(
+            [
+              grpc[:timestamp_ns],
+              grpc[:chan_id_in], grpc[:chan_id_out],
+              grpc[:amt_in_msat], grpc[:fee_msat]
+            ].join('/')
+          )
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/edges/payment/purpose.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class Purpose
+        def self.send_payment_v2(grpc, node_get_info)
+          return 'unknown' if grpc[:payment_route][:hops].empty?
+
+          return 'self-payment' if self_payment?(grpc[:payment_route][:hops])
+          return 'peer-to-peer' if peer_to_peer?(grpc[:payment_route][:hops])
+          return 'rebalance' if rebalance?(grpc[:payment_route][:hops], node_get_info)
+
+          'payment'
+        end
+
+        def self.list_payments(grpc, node_get_info)
+          return 'unknown' if grpc[:htlcs].empty?
+
+          return 'self-payment' if self_payment?(grpc[:htlcs].last[:route][:hops])
+          return 'peer-to-peer' if peer_to_peer?(grpc[:htlcs].last[:route][:hops])
+          return 'rebalance' if rebalance?(grpc[:htlcs].last[:route][:hops], node_get_info)
+
+          'payment'
+        end
+
+        def self.self_payment?(hops)
+          hops.size == 2 && hops[0][:chan_id] == hops[1][:chan_id]
+        end
+
+        def self.peer_to_peer?(hops)
+          hops.size == 1
+        end
+
+        def self.rebalance?(hops, node_get_info)
+          return false if hops.size <= 2
+
+          destination_public_key = hops.last[:pub_key]
+
+          node_get_info[:identity_pubkey] == destination_public_key
+        end
+      end
+    end
+  end
+end

data/adapters/lightning/edges/payment.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+require_relative '../connections/payment_channel'
+require_relative 'payment/purpose'
+
+require_relative '../invoice'
+
+require_relative '../../../ports/dsl/lighstorm/errors'
+
+module Lighstorm
+  module Adapter
+    module Lightning
+      class Payment
+        def self._key(grpc)
+          Digest::SHA256.hexdigest(
+            [
+              grpc[:payment_request],
+              grpc[:creation_time_ns],
+              grpc[:resolve_time_ns],
+              grpc[:status]
+            ].join('/')
+          )
+        end
+
+        def self.send_payment_v2(grpc, node_myself, invoice_decode)
+          adapted = list_payments(grpc, node_myself, invoice_decode)
+          adapted[:_source] = :send_payment_v2
+          adapted
+        end
+
+        def self.list_payments(grpc, node_myself, invoice_decode = nil)
+          data = {
+            _source: :list_payments,
+            _key: _key(grpc),
+            at: Time.at(grpc[:creation_time_ns] / 1e+9),
+            state: grpc[:status].to_s.downcase,
+            fee: { millisatoshis: grpc[:fee_msat] },
+            amount: { millisatoshis: grpc[:value_msat] },
+            purpose: Purpose.list_payments(grpc, node_myself),
+            invoice: Invoice.list_payments(grpc, invoice_decode)
+          }
+
+          data[:secret] = data[:invoice][:secret]
+
+          htlc = grpc[:htlcs].last
+
+          return data if htlc.nil?
+
+          data[:hops] = htlc[:route][:hops].map.with_index do |raw_hop, i|
+            hop = PaymentChannel.list_payments(raw_hop, i)
+            hop[:channel][:target] = { public_key: raw_hop[:pub_key] }
+            hop
+          end
+
+          data[:invoice][:settled_at] = Time.at(htlc[:resolve_time_ns] / 1e+9) if htlc[:resolve_time_ns]
+
+          last_hop = htlc[:route][:hops].last
+
+          return data if last_hop.nil?
+
+          # https://github.com/satoshisstream/satoshis.stream/blob/main/TLV_registry.md
+          if last_hop[:custom_records][34_349_334]
+            data[:message] = last_hop[:custom_records][34_349_334].dup
+
+            unless data[:message].force_encoding('UTF-8').valid_encoding?
+              data[:message] = data[:message].unpack1('H*')
+
+              data[:message] = data[:message].scrub('?') unless data[:message].force_encoding('UTF-8').valid_encoding?
+            end
+          end
+
+          if data[:invoice] && data[:invoice][:code] && !data[:invoice][:code].nil? && !data[:invoice][:code].empty?
+            data[:through] = if data[:invoice][:payable] == 'indefinitely'
+                               'amp'
+                             else
+                               'non-amp'
+                             end
+          else
+            data[:through] = last_hop[:mpp_record] ? 'amp' : 'keysend'
+          end
+
+          data
+        end
+      end
+    end
+  end
+end