nwc-ruby 0.2.0

data/lib/nwc_ruby/test_runner.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'uri'
+
+module NwcRuby
+  # A diagnostic test runner for a live NWC connection string. Surfaces
+  # misbehavior with actionable error messages rather than cryptic failures.
+  #
+  # Exposed both as a class and through the convenience method
+  # `NwcRuby.test(...)`. Call it from IRB, a Rails console, a
+  # custom rake task in your own app, a spec — anywhere.
+  #
+  # Example:
+  #
+  #   NwcRuby.test(
+  #     nwc_url: "nostr+walletconnect://...",
+  #     pay_to_lightning_address: "you@getalby.com",
+  #     pay_to_satoshis_amount: 10
+  #   )
+  class TestRunner
+    PASS = "\e[32m✓\e[0m"
+    FAIL = "\e[31m✗\e[0m"
+    WARN = "\e[33m!\e[0m"
+    SKIP = "\e[90m—\e[0m"
+    BOLD = "\e[1m"
+    DIM  = "\e[90m"
+    CLR  = "\e[0m"
+
+    DEFAULT_SATOSHIS = 100
+
+    # @param nwc_url [String] the nostr+walletconnect:// connection string
+    # @param pay_to_lightning_address [String, nil] Lightning address to send
+    #   the write test payment to. Only used if the NWC code is read+write.
+    # @param pay_to_satoshis_amount [Integer] amount in sats used for both
+    #   the outbound write test (if applicable) and the inbound make_invoice
+    #   generated for the notification test. Defaults to 100.
+    # @param output [IO] where to print diagnostic output.
+    def initialize(nwc_url:,
+                   pay_to_lightning_address: nil,
+                   pay_to_satoshis_amount: DEFAULT_SATOSHIS,
+                   output: $stdout)
+      @nwc_url                  = nwc_url
+      @pay_to_lightning_address = pay_to_lightning_address
+      @pay_to_satoshis_amount   = Integer(pay_to_satoshis_amount)
+      @out                      = output
+      @failures                 = []
+    end
+
+    # Runs info + read tests + write tests (if applicable).
+    # Does NOT test notifications — run run_notifications in a separate process.
+    def run
+      return false unless preamble
+
+      run_read_tests
+
+      if @pay_to_lightning_address
+        if @info.read_only?
+          warn!("pay_to_lightning_address was provided but this is a READ-ONLY code — it does not support pay_invoice.")
+          warn!("  → Generate a read+write NWC code if you need to test outbound payments.")
+          @out.puts
+        else
+          run_write_tests
+        end
+      end
+
+      summary
+      @failures.empty?
+    end
+
+    # Subscribes to notifications and blocks forever, printing each one.
+    # Ctrl-C / SIGTERM cause a clean exit. Run in a separate process.
+    def run_notifications
+      return false unless preamble
+
+      @out.puts "#{BOLD}Listening for notifications...#{CLR}"
+      @out.puts "#{DIM}Press Ctrl-C to stop.#{CLR}"
+      @out.puts
+
+      @client.subscribe_to_notifications do |n|
+        @out.puts "  #{PASS} #{Time.now.strftime('%Y-%m-%d %H:%M:%S')} — #{n.type}"
+        @out.puts "    #{DIM}payment_hash=#{n.payment_hash}#{CLR}"
+        @out.puts "    #{DIM}amount=#{n.amount_msats} msats#{CLR}"
+        @out.puts
+      end
+      # subscribe_to_notifications blocks until SIGTERM/SIGINT
+      true
+    end
+
+    private
+
+    # Shared setup: header, parse, info, mode, encryption.
+    def preamble
+      header
+      return false unless validate_connection_string
+      return false unless fetch_info
+
+      announce_mode
+      check_encryption_support
+      true
+    end
+
+    def header
+      @out.puts "#{BOLD}NWC Ruby diagnostic#{CLR}"
+      @out.puts "#{DIM}gem version #{NwcRuby::VERSION}#{CLR}"
+      @out.puts
+    end
+
+    def validate_connection_string
+      if @nwc_url.to_s.empty?
+        fail!('No NWC URL provided. Pass nwc_url: to TestRunner.new or NwcRuby.test.')
+        return false
+      end
+      @conn_str = ConnectionString.parse(@nwc_url)
+      pass('Connection string parsed')
+      @out.puts "  #{DIM}wallet_pubkey: #{@conn_str.wallet_pubkey}#{CLR}"
+      @out.puts "  #{DIM}client_pubkey: #{@conn_str.client_pubkey}#{CLR}"
+      @out.puts "  #{DIM}relay:         #{@conn_str.relays.first}#{CLR}"
+      @out.puts
+      true
+    rescue InvalidConnectionStringError => e
+      fail!("Invalid NWC URL: #{e.message}")
+      false
+    end
+
+    def fetch_info
+      @client = Client.from_uri(@nwc_url)
+      @info   = @client.info
+      pass('Fetched info event (kind 13194)')
+      true
+    rescue TransportError => e
+      fail!("Could not fetch info event: #{e.message}")
+      fail!('  → Confirm the relay URL is reachable and that the wallet service has published its kind 13194 event.')
+      false
+    rescue StandardError => e
+      fail!("Unexpected error fetching info: #{e.class}: #{e.message}")
+      false
+    end
+
+    def announce_mode
+      @out.puts
+      if @info.read_write?
+        @out.puts "  #{BOLD}\e[33m⚠  This code is READ+WRITE and can allow payments. Be careful with it.#{CLR}"
+      else
+        @out.puts "  #{BOLD}\e[36mℹ  This is a READ-ONLY code. It cannot move funds.#{CLR}"
+      end
+      @out.puts
+      @out.puts '  Supported methods:'
+      NIP47::Methods::ALL.each do |method|
+        marker = @info.supports?(method) ? PASS : SKIP
+        mutates = NIP47::Methods::MUTATING.include?(method) ? "#{DIM}(mutating)#{CLR}" : ''
+        @out.puts "    #{marker} #{method} #{mutates}"
+      end
+      @out.puts
+      @out.puts "  Notifications: #{@info.notification_types.empty? ? '(none advertised)' : @info.notification_types.join(', ')}"
+      @out.puts
+    end
+
+    def check_encryption_support
+      schemes = @info.encryption_schemes.join(', ')
+      if @info.supports_nip44?
+        pass("Encryption: #{schemes} — will use NIP-44 v2")
+      else
+        warn!("Encryption: #{schemes} — wallet service does not advertise nip44_v2. Will fall back to NIP-04.")
+        warn!('  → NIP-04 is deprecated. Consider a wallet service that supports NIP-44 v2.')
+      end
+      @out.puts
+    end
+
+    def run_read_tests
+      @out.puts "#{BOLD}Read tests#{CLR}"
+
+      try('get_info', NIP47::Methods::GET_INFO) do
+        result = @client.get_info
+        @get_info_result = result
+        @out.puts "    #{DIM}alias=#{result['alias']} network=#{result['network']} pubkey=#{result['pubkey']}#{CLR}"
+        @out.puts "    #{DIM}lud16=#{result['lud16']}#{CLR}" if result['lud16']
+        sanity_check_get_info(result)
+      end
+
+      try('get_balance', NIP47::Methods::GET_BALANCE) do
+        result = @client.get_balance
+        @out.puts "    #{DIM}balance=#{result['balance']} msats#{CLR}"
+        fail!('get_balance: `balance` field missing or not an integer') unless result['balance'].is_a?(Integer)
+      end
+
+      try('list_transactions', NIP47::Methods::LIST_TRANSACTIONS) do
+        result = @client.list_transactions(limit: 5)
+        txs = result['transactions'] || []
+        @out.puts "    #{DIM}returned #{txs.size} transactions#{CLR}"
+        unless result['transactions'].is_a?(Array)
+          fail!('list_transactions: `transactions` field missing or not an array')
+        end
+      end
+
+      try('make_invoice (1000 msats)', NIP47::Methods::MAKE_INVOICE) do
+        result = @client.make_invoice(amount: 1_000, description: 'nwc_ruby gem test')
+        @out.puts "    #{DIM}invoice=#{truncate(result['invoice'], 40)}#{CLR}"
+        @out.puts "    #{DIM}payment_hash=#{result['payment_hash']}#{CLR}"
+        sanity_check_make_invoice(result)
+        @test_payment_hash = result['payment_hash']
+      end
+
+      if @test_payment_hash
+        try('lookup_invoice (payment_hash from previous step)', NIP47::Methods::LOOKUP_INVOICE) do
+          result = @client.lookup_invoice(payment_hash: @test_payment_hash)
+          @out.puts "    #{DIM}state=#{result['state']} amount=#{result['amount']} msats#{CLR}"
+          warn!("lookup_invoice: `state` is #{result['state'].inspect}, expected 'pending' for a fresh invoice (optional per NIP-47)") unless result['state'] == 'pending'
+        end
+      end
+
+      @out.puts
+    end
+
+    def run_write_tests
+      @out.puts "#{BOLD}Write tests#{CLR}  #{DIM}(read+write code detected, Lightning address provided)#{CLR}"
+
+      amount_msats        = @pay_to_satoshis_amount * 1_000
+      invoice_from_lnaddr = fetch_invoice_from_lightning_address(@pay_to_lightning_address, amount_msats)
+
+      if invoice_from_lnaddr.nil?
+        fail!("Could not resolve Lightning address #{@pay_to_lightning_address} — skipping pay_invoice test")
+        @out.puts
+        return
+      end
+
+      try("pay_invoice (#{@pay_to_satoshis_amount} sats to #{@pay_to_lightning_address})",
+          NIP47::Methods::PAY_INVOICE) do
+        result = @client.pay_invoice(invoice: invoice_from_lnaddr)
+        @out.puts "    #{DIM}preimage=#{result['preimage']}#{CLR}"
+        unless result['preimage']&.match?(/\A[0-9a-f]{64}\z/)
+          fail!("pay_invoice: `preimage` should be 64 hex chars, got #{result['preimage'].inspect}")
+        end
+      end
+      @out.puts
+    end
+
+    # --- Sanity checks ------------------------------------------------------
+
+    def sanity_check_get_info(result)
+      %w[alias pubkey network].each do |field|
+        fail!("get_info: `#{field}` field is missing") if result[field].nil?
+      end
+      return if %w[mainnet testnet signet regtest].include?(result['network'])
+
+      warn!("get_info: `network` is #{result['network'].inspect}, expected one of mainnet/testnet/signet/regtest")
+    end
+
+    def sanity_check_make_invoice(result)
+      fail!('make_invoice: `invoice` is missing or not a BOLT11 string') unless result['invoice'].to_s.start_with?('ln')
+      unless result['payment_hash'].to_s.match?(/\A[0-9a-f]{64}\z/)
+        fail!('make_invoice: `payment_hash` is not a 64-char hex')
+      end
+      fail!('make_invoice: `amount` should echo 1000') unless result['amount'] == 1_000
+      warn!("make_invoice: `type` is #{result['type'].inspect}, expected 'incoming' (optional per NIP-47)") unless result['type'] == 'incoming'
+      warn!("make_invoice: `state` is #{result['state'].inspect}, expected 'pending' (optional per NIP-47)") unless result['state'] == 'pending'
+    end
+
+    # --- Lightning address resolver ----------------------------------------
+
+    def fetch_invoice_from_lightning_address(address, amount_msats)
+      user, domain = address.split('@', 2)
+      return nil unless user && domain
+
+      lnurlp = URI.parse("https://#{domain}/.well-known/lnurlp/#{user}")
+      metadata = Net::HTTP.get_response(lnurlp)
+      return nil unless metadata.is_a?(Net::HTTPSuccess)
+
+      meta_json = JSON.parse(metadata.body)
+      callback  = URI.parse(meta_json['callback'])
+      callback.query = URI.encode_www_form(amount: amount_msats)
+      resp = Net::HTTP.get_response(callback)
+      return nil unless resp.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(resp.body)['pr']
+    rescue StandardError => e
+      @out.puts "  #{WARN} LNURL-pay resolution failed: #{e.class}: #{e.message}"
+      nil
+    end
+
+    # --- Output helpers -----------------------------------------------------
+
+    def try(label, method_name)
+      unless @info.supports?(method_name)
+        @out.puts "  #{SKIP} #{label}  #{DIM}(wallet service does not support this)#{CLR}"
+        return
+      end
+
+      start = Time.now
+      begin
+        yield
+        elapsed = ((Time.now - start) * 1000).round
+        @out.puts "  #{PASS} #{label}  #{DIM}(#{elapsed}ms)#{CLR}"
+      rescue WalletServiceError => e
+        fail!("#{label}: wallet returned #{e.code}: #{e.message}")
+      rescue TimeoutError => e
+        fail!("#{label}: #{e.message}")
+        fail!('  → The wallet service accepted the request but never responded. The service may be down or overloaded.')
+      rescue UnsupportedMethodError => e
+        fail!("#{label}: #{e.message}")
+      rescue EncryptionError => e
+        fail!("#{label}: decryption failed — #{e.message}")
+        fail!('  → This usually means the wallet service encrypted with an unexpected scheme, or the shared secret is wrong.')
+      rescue StandardError => e
+        fail!("#{label}: unexpected error #{e.class}: #{e.message}")
+      end
+    end
+
+    def pass(msg) = @out.puts("  #{PASS} #{msg}")
+    def warn!(msg) = @out.puts("  #{WARN} #{msg}")
+
+    def fail!(msg)
+      @out.puts "  #{FAIL} #{msg}"
+      @failures << msg
+    end
+
+    def truncate(str, n)
+      s = str.to_s
+      s.length > n ? "#{s[0, n]}..." : s
+    end
+
+    def summary
+      @out.puts
+      if @failures.empty?
+        @out.puts "#{BOLD}\e[32mAll tests passed.#{CLR}"
+      else
+        @out.puts "#{BOLD}\e[31m#{@failures.size} failure(s).#{CLR}"
+      end
+    end
+  end
+end

data/lib/nwc_ruby/transport/relay_connection.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'async/clock'
+require 'async/http/endpoint'
+require 'async/websocket/client'
+
+module NwcRuby
+  module Transport
+    # A reliable long-running connection to a Nostr relay.
+    #
+    # This is the reliability layer: everything the developer shouldn't have to
+    # think about. It handles:
+    #
+    #   - RFC 6455 ping every `ping_interval` seconds (keeps middleboxes from
+    #     idle-closing the socket; the relay's pong reply is handled by the
+    #     protocol layer automatically)
+    #   - forced recycle every `recycle_interval` (belt-and-suspenders against
+    #     relay bugs or silent connection death)
+    #   - capped exponential backoff on reconnect (1s → 2 → 4 → ... → 60s)
+    #   - SIGTERM / SIGINT handling for clean Kamal deploys
+    #
+    # Usage:
+    #
+    #   conn = RelayConnection.new(url: "wss://relay.rizful.com")
+    #   conn.on_event { |event_hash| ... }
+    #   conn.on_open  { |c| c.send_req(sub_id: "foo", filters: [...]) }
+    #   conn.run!  # blocks until stop! or signal
+    class RelayConnection
+      DEFAULT_PING_INTERVAL    = 15
+      DEFAULT_RECYCLE_INTERVAL = 300
+      DEFAULT_MAX_BACKOFF      = 60
+
+      attr_reader :url, :logger
+
+      def initialize(url:,
+                     ping_interval: DEFAULT_PING_INTERVAL,
+                     recycle_interval: DEFAULT_RECYCLE_INTERVAL,
+                     max_backoff: DEFAULT_MAX_BACKOFF,
+                     poll_interval: nil,
+                     logger: default_logger,
+                     install_signal_traps: true)
+        @url              = url
+        @ping_interval    = ping_interval
+        @recycle_interval = recycle_interval
+        @max_backoff      = max_backoff
+        @poll_interval    = poll_interval
+        @logger           = logger
+
+        @event_cb         = nil
+        @open_cb          = nil
+        @error_cb         = nil
+        @poll_cb          = nil
+        @stop             = false
+        @signal_traps     = install_signal_traps
+        @top_task         = nil
+      end
+
+      def on_event(&block) = @event_cb = block
+      def on_open(&block) = @open_cb = block
+      def on_error(&block) = @error_cb = block
+      def on_poll(&block) = @poll_cb = block
+
+      def stop!
+        @stop = true
+        # Close the websocket to unblock the read loop. The @stop flag
+        # will cause the run loop to exit on its own. We avoid calling
+        # @top_task.stop here because stop! may be called from a
+        # different thread than the Async reactor.
+        begin
+          @conn&.close
+        rescue StandardError
+          nil
+        end
+      end
+
+      # Blocks forever, reconnecting as needed, until #stop! is called
+      # or SIGTERM / SIGINT is received.
+      def run!
+        install_traps if @signal_traps
+        backoff = 1
+
+        Async do |top|
+          @top_task = top
+          until @stop
+            begin
+              run_one_connection(top)
+              backoff = 1
+            rescue StandardError => e
+              break if @stop
+
+              @logger.warn("[nwc] connection failed: #{e.class}: #{e.message}")
+              @error_cb&.call(e)
+              sleep_seconds = [backoff, @max_backoff].min
+              @logger.info("[nwc] reconnecting in #{sleep_seconds}s")
+              sleep sleep_seconds
+              backoff *= 2
+            end
+          end
+        ensure
+          @top_task = nil
+        end
+      end
+
+      # Send raw client->relay message (e.g. REQ, EVENT, CLOSE). Safe to call
+      # from within on_open / on_event callbacks.
+      def send_message(message)
+        raise TransportError, 'not connected' unless @conn
+
+        @conn.write(Protocol::WebSocket::TextMessage.generate(message))
+        @conn.flush
+      end
+
+      # Helper: send ["REQ", sub_id, filter1, filter2, ...]
+      def send_req(sub_id:, filters:)
+        send_message(['REQ', sub_id, *Array(filters)])
+      end
+
+      # Helper: send ["EVENT", event_hash]
+      def send_event(event_hash)
+        send_message(['EVENT', event_hash])
+      end
+
+      # Helper: send ["CLOSE", sub_id]
+      def send_close(sub_id)
+        send_message(['CLOSE', sub_id])
+      end
+
+      private
+
+      def run_one_connection(top)
+        endpoint  = Async::HTTP::Endpoint.parse(@url, alpn_protocols: ['http/1.1'])
+        opened_at = Async::Clock.now
+        @logger.info("[nwc] connecting to #{@url}")
+
+        Async::WebSocket::Client.connect(endpoint) do |conn|
+          @conn = conn
+
+          heartbeat = top.async do
+            loop do
+              conn.send_ping
+              conn.flush
+              @logger.debug("[nwc] ping sent")
+
+              sleep @ping_interval
+              break if @stop
+
+              if Async::Clock.now - opened_at > @recycle_interval
+                raise TransportError, "recycle (#{@recycle_interval}s)"
+              end
+            end
+          end
+
+          # Some relays (e.g. strfry) store ephemeral events temporarily but
+          # do not push them to active subscriptions. Periodic re-subscribe
+          # forces the relay to return any newly-stored events.
+          poll = if @poll_interval && @poll_cb
+                   top.async do
+                     loop do
+                       sleep @poll_interval
+                       break if @stop
+
+                       begin
+                         @poll_cb.call(self)
+                       rescue StandardError => e
+                         @logger.warn("[nwc] poll error: #{e.message}")
+                       end
+                     end
+                   end
+                 end
+
+          @open_cb&.call(self)
+          read_loop(conn)
+        ensure
+          heartbeat&.stop
+          poll&.stop
+          @conn = nil
+          begin
+            conn&.close
+          rescue StandardError
+            nil
+          end
+        end
+      end
+
+      def read_loop(conn)
+        while (message = conn.read)
+          break if @stop
+
+          begin
+            parsed = JSON.parse(message.buffer)
+          rescue JSON::ParserError => e
+            @logger.warn("[nwc] malformed JSON from relay: #{e.message}")
+            next
+          end
+
+          dispatch(parsed)
+        end
+      end
+
+      # Relay -> client messages: ["EVENT", sub_id, event], ["EOSE", sub_id],
+      # ["OK", event_id, accepted_bool, message], ["NOTICE", message], ["CLOSED", sub_id, reason].
+      def dispatch(message)
+        case message[0]
+        when 'EVENT'
+          @event_cb&.call(message[1], message[2])
+        when 'OK'
+          @logger.debug("[nwc] OK #{message[1]} accepted=#{message[2]} msg=#{message[3]}")
+        when 'EOSE'
+          @logger.debug("[nwc] EOSE #{message[1]}")
+        when 'NOTICE'
+          @logger.info("[nwc] NOTICE #{message[1]}")
+        when 'CLOSED'
+          @logger.info("[nwc] CLOSED #{message[1]} #{message[2]}")
+        else
+          @logger.debug("[nwc] unknown message type: #{message[0]}")
+        end
+      end
+
+      def install_traps
+        %w[TERM INT].each do |sig|
+          trap(sig) do
+            @stop = true
+            # Close the socket to unblock the read loop.
+            begin
+              @conn&.close
+            rescue StandardError # rubocop:disable Lint/SuppressedException
+            end
+          end
+        end
+      end
+
+      def default_logger
+        logger = Logger.new($stdout)
+        logger.level = ENV['NWC_LOG_LEVEL'] ? Logger.const_get(ENV['NWC_LOG_LEVEL'].upcase) : Logger::INFO
+        logger
+      end
+    end
+  end
+end

data/lib/nwc_ruby/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module NwcRuby
+  VERSION = '0.2.0'
+end

data/lib/nwc_ruby.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'base64'
+require 'securerandom'
+require 'openssl'
+require 'uri'
+require 'logger'
+
+require_relative 'nwc_ruby/version'
+require_relative 'nwc_ruby/errors'
+require_relative 'nwc_ruby/crypto/keys'
+require_relative 'nwc_ruby/crypto/schnorr'
+require_relative 'nwc_ruby/crypto/ecdh'
+require_relative 'nwc_ruby/nip04/cipher'
+require_relative 'nwc_ruby/nip44/cipher'
+require_relative 'nwc_ruby/event'
+require_relative 'nwc_ruby/connection_string'
+require_relative 'nwc_ruby/nip47/methods'
+require_relative 'nwc_ruby/nip47/request'
+require_relative 'nwc_ruby/nip47/response'
+require_relative 'nwc_ruby/nip47/notification'
+require_relative 'nwc_ruby/nip47/info'
+require_relative 'nwc_ruby/transport/relay_connection'
+require_relative 'nwc_ruby/client'
+require_relative 'nwc_ruby/test_runner'
+
+# NwcRuby is a Ruby client for NIP-47 (Nostr Wallet Connect).
+#
+# Quick start:
+#
+#   client = NwcRuby::Client.from_uri(ENV["NWC_URL"])
+#   invoice = client.make_invoice(amount: 1_000) # msats
+#   puts invoice["invoice"]
+#
+#   client.subscribe_to_notifications do |n|
+#     puts "Got paid: #{n['amount']} msats for #{n['payment_hash']}"
+#   end
+#
+# To exercise a connection string end-to-end (from IRB, a Rails console, a
+# spec, or a rake task in your own app), use the top-level test method:
+#
+#   NwcRuby.test(
+#     nwc_url: ENV["NWC_URL"],
+#     pay_to_lightning_address: "you@getalby.com", # optional — only used for write tests
+#     pay_to_satoshis_amount: 10                    # used for both outbound and inbound tests
+#   )
+#
+# Returns true if every check passed, false otherwise. Output is streamed to
+# $stdout by default; pass `output: some_io` to redirect.
+module NwcRuby
+  # Run the diagnostic: info, read tests, and (if the code is read+write and
+  # a Lightning address is provided) a write test. Does NOT test notifications
+  # — run test_notifications in a separate process for that.
+  #
+  # If pay_to_lightning_address is provided but the code is read-only, a
+  # helpful warning is printed instead of attempting the payment.
+  #
+  # @return [Boolean] true if all checks passed.
+  def self.test(nwc_url:,
+                pay_to_lightning_address: nil,
+                pay_to_satoshis_amount: TestRunner::DEFAULT_SATOSHIS,
+                output: $stdout)
+    TestRunner.new(
+      nwc_url: nwc_url,
+      pay_to_lightning_address: pay_to_lightning_address,
+      pay_to_satoshis_amount: pay_to_satoshis_amount,
+      output: output
+    ).run
+  end
+
+  # Subscribe to notifications and block forever, printing each one.
+  # Run this in a separate process / terminal. Ctrl-C to stop.
+  #
+  # @return [Boolean] true (only returns on clean shutdown).
+  def self.test_notifications(nwc_url:, output: $stdout)
+    TestRunner.new(
+      nwc_url: nwc_url,
+      output: output
+    ).run_notifications
+  end
+end