lighstorm 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 643a80fa54f053a2f647dbeb4df8b959cb0d512a7aa220c338c136220775c960
-  data.tar.gz: 5fd770e41ad436cc920c4c3723eeddc4027feb0bb9a3ace19f3856e5f516b948
+  metadata.gz: 551ffb5be38f96d6c0bb4f7b8fbde5763c623f0d100f0a1b34acb90a6074fb23
+  data.tar.gz: 59451d54f2ad6d45c95c7649ab0a048a4adeb7a15f1af08f133d8eaae107d9bc
 SHA512:
-  metadata.gz: 403f808bf48235a765f8c50fb840cddd86c0c77ece348b3b907460c8f84cb932c91fc688ac8e7f488ced08974f1acabd0e5019661de6bdd0956178b657249ac7
-  data.tar.gz: 4dbbb229dbe1204dc189d179b2106e55ad45d3ed36f28ded6206674400aeac80595fd45f52f755bd118f90e6e14bfff5f4fc7e096a8b2dfab1bfa94da4ddc430
+  metadata.gz: 54e1e6929a1f5dc67f319461d6fc3799dd5cd5c349224c19198a6bffd203bd3e6431fb6bf571976c2a1c0d3d1d07ceb9cb272206f06794c52595c4ec8d5d57d3
+  data.tar.gz: a903325535c6c2e98b95c4e54cb51f7bbd7123b40dfb2b9143fc9d7a392290230f1bb026c7bd30a669c8f981286ef56acfe0a2bf3751ea9cce5a4d663e160d61

data/.env.example

@@ -3,3 +3,4 @@ LIGHSTORM_CERTIFICATE_PATH=/lnd/tls.cert
 LIGHSTORM_MACAROON_PATH=/lnd/data/chain/bitcoin/mainnet/admin.macaroon
 LIGHSTORM_RUN_INTEGRATION_TESTS=false
 LIGHSTORM_RUN_INTEGRATION_TESTS_SLOW=false
+LIGHSTORM_DELETE_UNUSED_TEST_DATA=false

data/.gitignore

@@ -1,2 +1,3 @@
 *.gem
 .env
+tags

data/.rubocop.yml

@@ -22,3 +22,4 @@ Security/MarshalLoad:
 
 require:
  - rubocop-rspec
+ - rubocop-rake

data/Gemfile

@@ -6,9 +6,11 @@ gemspec
 
 group :test, :development do
   gem 'babosa', '~> 2.0'
-  gem 'dotenv', '~> 2.8', '>= 2.8.1'
   gem 'pry-byebug', '~> 3.10', '>= 3.10.1'
+  gem 'rainbow', '~> 3.1', '>= 3.1.1'
+  gem 'rake', '~> 13.0', '>= 13.0.6'
   gem 'rspec', '~> 3.12'
-  gem 'rubocop', '~> 1.47'
-  gem 'rubocop-rspec', '~> 2.18', '>= 2.18.1'
+  gem 'rubocop', '~> 1.48'
+  gem 'rubocop-rake', '~> 0.6.0'
+  gem 'rubocop-rspec', '~> 2.19'
 end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lighstorm (0.0.8)
+    lighstorm (0.0.9)
       dotenv (~> 2.8, >= 2.8.1)
       lnd-client (~> 0.0.5)
       zache (~> 0.12.0)
@@ -15,7 +15,7 @@ GEM
     coderay (1.1.3)
     diff-lcs (1.5.0)
     dotenv (2.8.1)
-    google-protobuf (3.22.0-x86_64-linux)
+    google-protobuf (3.22.2-x86_64-linux)
     googleapis-common-protos-types (1.5.0)
       google-protobuf (~> 3.14)
     grpc (1.52.0-x86_64-linux)
@@ -26,7 +26,7 @@ GEM
       grpc (~> 1.52)
     method_source (1.0.0)
     parallel (1.22.1)
-    parser (3.2.1.0)
+    parser (3.2.1.1)
       ast (~> 2.4.1)
     pry (0.14.2)
       coderay (~> 1.1)
@@ -35,6 +35,7 @@ GEM
       byebug (~> 11.0)
       pry (>= 0.13, < 0.15)
     rainbow (3.1.1)
+    rake (13.0.6)
     regexp_parser (2.7.0)
     rexml (3.2.5)
     rspec (3.12.0)
@@ -50,7 +51,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.12.0)
     rspec-support (3.12.0)
-    rubocop (1.47.0)
+    rubocop (1.48.0)
       json (~> 2.3)
       parallel (~> 1.10)
       parser (>= 3.2.0.0)
@@ -64,7 +65,9 @@ GEM
       parser (>= 3.2.1.0)
     rubocop-capybara (2.17.1)
       rubocop (~> 1.41)
-    rubocop-rspec (2.18.1)
+    rubocop-rake (0.6.0)
+      rubocop (~> 1.0)
+    rubocop-rspec (2.19.0)
       rubocop (~> 1.33)
       rubocop-capybara (~> 2.17)
     ruby-progressbar (1.13.0)
@@ -76,12 +79,14 @@ PLATFORMS
 
 DEPENDENCIES
   babosa (~> 2.0)
-  dotenv (~> 2.8, >= 2.8.1)
   lighstorm!
   pry-byebug (~> 3.10, >= 3.10.1)
+  rainbow (~> 3.1, >= 3.1.1)
+  rake (~> 13.0, >= 13.0.6)
   rspec (~> 3.12)
-  rubocop (~> 1.47)
-  rubocop-rspec (~> 2.18, >= 2.18.1)
+  rubocop (~> 1.48)
+  rubocop-rake (~> 0.6.0)
+  rubocop-rspec (~> 2.19)
 
 BUNDLED WITH
    2.4.4

data/README.md

@@ -34,7 +34,7 @@ Although it tries to stay close to [Lightning's terminologies](https://docs.ligh
 Add to your `Gemfile`:
 
 ```ruby
-gem 'lighstorm', '~> 0.0.8'
+gem 'lighstorm', '~> 0.0.9'
 ```
 
 ```ruby
@@ -46,12 +46,13 @@ Lighstorm.config!(
   macaroon_path: '/lnd/data/chain/bitcoin/mainnet/admin.macaroon',
 )
 
-puts Lighstorm.version # => 0.0.8
+puts Lighstorm.version # => 0.0.9
 
 Lighstorm::Node.myself.alias # => icebaker/old-stone
 
 Lighstorm::Invoice.create(
-  description: 'Coffee', millisatoshis: 1_000
+  description: 'Coffee', millisatoshis: 1_000,
+  payable: 'once'
 )
 
 Lighstorm::Satoshis.new(

data/Rakefile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative './spec/helpers/tasks/contracts'
+
+# rspec --format json | bundle exec rake contracts:fix
+namespace :contracts do
+  desc 'Fix Contract Tests Hash'
+  task :fix do
+    Tasks::Contracts.fix($stdin.gets)
+  end
+end

data/adapters/edges/payment/purpose.rb

@@ -3,27 +3,38 @@
 module Lighstorm
   module Adapter
     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 'self-payment' if self_payment?(grpc)
-        return 'peer-to-peer' if peer_to_peer?(grpc)
-        return 'rebalance' if rebalance?(grpc, node_get_info)
+        return 'unknown' if grpc[:htlcs].empty?
+
+        return 'self-payment' if self_payment?(grpc[:htlcs].first[:route][:hops])
+        return 'peer-to-peer' if peer_to_peer?(grpc[:htlcs].first[:route][:hops])
+        return 'rebalance' if rebalance?(grpc[:htlcs].first[:route][:hops], node_get_info)
 
         'payment'
       end
 
-      def self.self_payment?(grpc)
-        grpc[:htlcs].first[:route][:hops].size == 2 &&
-          grpc[:htlcs].first[:route][:hops][0][:chan_id] == grpc[:htlcs].first[:route][:hops][1][:chan_id]
+      def self.self_payment?(hops)
+        hops.size == 2 && hops[0][:chan_id] == hops[1][:chan_id]
       end
 
-      def self.peer_to_peer?(grpc)
-        grpc[:htlcs].first[:route][:hops].size == 1
+      def self.peer_to_peer?(hops)
+        hops.size == 1
       end
 
-      def self.rebalance?(grpc, node_get_info)
-        return false if grpc[:htlcs].first[:route][:hops].size <= 2
+      def self.rebalance?(hops, node_get_info)
+        return false if hops.size <= 2
 
-        destination_public_key = grpc[:htlcs].first[:route][:hops].last[:pub_key]
+        destination_public_key = hops.last[:pub_key]
 
         node_get_info[:identity_pubkey] == destination_public_key
       end

data/adapters/edges/payment.rb

@@ -5,7 +5,7 @@ require 'digest'
 require_relative '../connections/payment_channel'
 require_relative 'payment/purpose'
 
-require_relative '../payment_request'
+require_relative '../invoice'
 
 require_relative '../../ports/dsl/lighstorm/errors'
 
@@ -23,25 +23,64 @@ module Lighstorm
         )
       end
 
-      def self.list_payments(grpc, node_get_info)
+      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)
         raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
 
         data = {
           _source: :list_payments,
           _key: _key(grpc),
-          created_at: Time.at(grpc[:creation_time_ns] / 1e+9),
-          status: grpc[:status].to_s.downcase,
+          at: Time.at(grpc[:creation_time_ns] / 1e+9),
+          state: grpc[:status].to_s.downcase,
           fee: { millisatoshis: grpc[:fee_msat] },
-          purpose: Purpose.list_payments(grpc, node_get_info),
-          request: PaymentRequest.list_payments(grpc),
-          hops: grpc[:htlcs].first[: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
+          amount: { millisatoshis: grpc[:value_msat] },
+          purpose: Purpose.list_payments(grpc, node_myself),
+          invoice: Invoice.list_payments(grpc, invoice_decode)
         }
 
-        data[:settled_at] = Time.at(grpc[:htlcs].first[:resolve_time_ns] / 1e+9) if grpc[:htlcs].first[:resolve_time_ns]
+        data[:secret] = data[:invoice][:secret]
+
+        htlc = grpc[:htlcs].first
+
+        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

data/adapters/invoice.rb

@@ -2,11 +2,22 @@
 
 require 'digest'
 
-require_relative 'payment_request'
+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, request_code = nil)
         adapted = {
           _source: :decode_pay_req,
@@ -18,55 +29,146 @@ module Lighstorm
               grpc[:payment_addr]
             ].join('/')
           ),
+          payable: 'once',
           created_at: Time.at(grpc[:timestamp]),
-          request: PaymentRequest.decode_pay_req(grpc)
+          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[:request][:code] = request_code unless request_code.nil?
+        adapted[:code] = request_code unless request_code.nil?
 
-        adapted
-      end
+        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'
 
-      def self.add_invoice(grpc)
-        {
-          _source: :add_invoice,
-          _key: Digest::SHA256.hexdigest(
-            [
-              grpc[:r_hash],
-              grpc[:add_index],
-              grpc[:payment_request],
-              grpc[:payment_addr]
-            ].join('/')
-          ),
-          request: PaymentRequest.add_invoice(grpc)
-        }
-      end
+          adapted[:payable] = 'indefinitely'
+        end
 
-      def self.lookup_invoice(grpc)
-        adapted = list_or_lookup(grpc)
+        adapted
+      end
 
+      def self.lookup_invoice(grpc, at)
+        adapted = list_or_lookup_invoice(grpc, at)
         adapted[:_source] = :lookup_invoice
-        adapted[:request] = PaymentRequest.lookup_invoice(grpc)
+        adapted
+      end
 
+      def self.list_invoices(grpc, at)
+        adapted = list_or_lookup_invoice(grpc, at)
+        adapted[:_source] = :list_invoices
         adapted
       end
 
-      def self.list_invoices(grpc)
-        adapted = list_or_lookup(grpc)
+      def self.list_or_lookup_invoice(grpc, at)
+        raise 'missing at' if at.nil?
 
-        adapted[:_source] = :list_invoices
-        adapted[:request] = PaymentRequest.list_invoices(grpc)
+        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_or_lookup(grpc)
-        {
+      def self.list_payments(grpc, invoice_decode = nil)
+        raise UnexpectedNumberOfHTLCsError, "htlcs: #{grpc[:htlcs].size}" if grpc[:htlcs].size > 1
+
+        data = {
           _key: _key(grpc),
+          _source: :list_payments,
           created_at: Time.at(grpc[:creation_date]),
-          settle_at: grpc[:settle_date].nil? || !grpc[:settle_date].positive? ? nil : Time.at(grpc[:settle_date]),
-          state: grpc[:state].to_s.downcase
+          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)

data/components/cache.rb

@@ -21,10 +21,15 @@ module Lighstorm
       @client = Zache.new
     end
 
+    def safety_key(key)
+      key.gsub('.', '_').to_sym
+    end
+
     def for(key, ttl: nil, params: {}, &block)
       if ttl.nil?
-        ttl = Lighstorm::Static::CACHE[key.sub('lightning.', '').to_sym]
-        raise MissingTTLError, "missing ttl for #{key.sub('lightning.', '')} static/cache.rb" if ttl.nil?
+        safety_key = self.safety_key(key)
+        ttl = Lighstorm::Static::CACHE[safety_key]
+        raise MissingTTLError, "missing ttl for #{safety_key} static/cache.rb" if ttl.nil?
 
         ttl = ttl == false ? false : ttl[:ttl]
       end

data/controllers/forward/group_by_channel.rb

@@ -2,7 +2,7 @@
 
 require 'digest'
 
-require_relative 'all'
+require_relative './all'
 
 require_relative '../../models/edges/groups/channel_forwards'
 

data/controllers/invoice/actions/create.rb

@@ -2,6 +2,7 @@
 
 require_relative '../../../ports/grpc'
 require_relative '../../../models/errors'
+require_relative '../../../helpers/time_expression'
 require_relative '../../invoice'
 require_relative '../../action'
 
@@ -15,15 +16,27 @@ module Lighstorm
           ).to_h
         end
 
-        def self.prepare(description: nil, millisatoshis: nil)
-          {
+        def self.prepare(payable:, expires_in:, description: nil, millisatoshis: nil)
+          request = {
             service: :lightning,
             method: :add_invoice,
             params: {
               memo: description,
-              value_msat: millisatoshis
+              # Lightning Invoice Expiration: UX Considerations
+              # https://d.elor.me/2022/01/lightning-invoice-expiration-ux-considerations/
+              expiry: Helpers::TimeExpression.seconds(expires_in)
             }
           }
+
+          request[:params][:value_msat] = millisatoshis unless millisatoshis.nil?
+
+          if payable.to_sym == :indefinitely
+            request[:params][:is_amp] = true
+          elsif payable.to_sym != :once
+            raise Errors::ArgumentError, "payable: accepts 'indefinitely' or 'once', '#{payable}' is not valid."
+          end
+
+          request
         end
 
         def self.dispatch(grpc_request, &vcr)
@@ -35,16 +48,19 @@ module Lighstorm
         end
 
         def self.fetch(adapted, &vcr)
-          FindBySecretHash.data(adapted[:request][:secret][:hash], &vcr)
+          FindBySecretHash.data(adapted[:secret][:hash], &vcr)
         end
 
         def self.model(data)
           FindBySecretHash.model(data)
         end
 
-        def self.perform(description: nil, millisatoshis: nil, preview: false, &vcr)
+        def self.perform(payable:, expires_in:, description: nil, millisatoshis: nil, preview: false, &vcr)
           grpc_request = prepare(
-            description: description, millisatoshis: millisatoshis
+            description: description,
+            millisatoshis: millisatoshis,
+            expires_in: expires_in,
+            payable: payable
           )
 
           return grpc_request if preview

data/controllers/invoice/actions/pay.rb

@@ -2,25 +2,83 @@
 
 require_relative '../../../ports/grpc'
 require_relative '../../../models/errors'
+require_relative '../../../models/edges/payment'
+require_relative '../../../adapters/edges/payment'
+require_relative '../../invoice'
+require_relative '../../action'
+require_relative '../../node/myself'
+
+require_relative '../../payment/actions/pay'
 
 module Lighstorm
   module Controllers
     module Invoice
       module Pay
-        def self.perform(_invoice, preview: false, fake: false)
-          raise Errors::ToDoError, self
-
-          LND.instance.middleware('router.send_payment_v2') do
-            result = []
-            LND.instance.client.router.send_payment_v2(
-              payment_request: request,
-              timeout_seconds: 5,
-              allow_self_payment: true
-            ) do |response|
-              result << response
-            end
-            result
+        def self.dispatch(grpc_request, &vcr)
+          Payment::Pay.dispatch(grpc_request, &vcr)
+        end
+
+        def self.fetch(request_code, &vcr)
+          Payment::Pay.fetch(request_code, &vcr)
+        end
+
+        def self.adapt(data, node_get_info)
+          Payment::Pay.adapt(data, node_get_info)
+        end
+
+        def self.model(data)
+          Payment::Pay.model(data)
+        end
+
+        def self.prepare(request_code:, times_out_in:, millisatoshis: nil, message: nil)
+          request = {
+            service: :router,
+            method: :send_payment_v2,
+            params: {
+              payment_request: request_code,
+              timeout_seconds: Helpers::TimeExpression.seconds(times_out_in),
+              allow_self_payment: true,
+              dest_custom_records: {}
+            }
+          }
+
+          request[:params][:amt_msat] = millisatoshis unless millisatoshis.nil?
+
+          if !message.nil? && !message.empty?
+            # https://github.com/satoshisstream/satoshis.stream/blob/main/TLV_registry.md
+            request[:params][:dest_custom_records][34_349_334] = message
           end
+
+          request[:params].delete(:dest_custom_records) if request[:params][:dest_custom_records].empty?
+
+          request
+        end
+
+        def self.perform(
+          times_out_in:, request_code:, millisatoshis: nil, message: nil, preview: false, &vcr
+        )
+          grpc_request = prepare(
+            request_code: request_code,
+            millisatoshis: millisatoshis,
+            message: message,
+            times_out_in: times_out_in
+          )
+
+          return grpc_request if preview
+
+          response = dispatch(grpc_request, &vcr)
+
+          Payment::Pay.raise_error_if_exists!(response)
+
+          data = fetch(request_code, &vcr)
+
+          adapted = adapt(response, data)
+
+          model = self.model(adapted)
+
+          Payment::Pay.raise_failure_if_exists!(model, response)
+
+          Action::Output.new({ response: response[:response], result: model })
         end
       end
     end