nwc-ruby 0.2.0

data/lib/nwc_ruby/client.rb

@@ -0,0 +1,344 @@
+# frozen_string_literal: true
+
+require 'async'
+require 'async/http/endpoint'
+require 'async/websocket/client'
+
+module NwcRuby
+  # The main public API.
+  #
+  #   client = NwcRuby::Client.from_uri(ENV["NWC_URL"])
+  #
+  #   # One-shot request/response (transparently opens a WS, sends, waits, closes):
+  #   info    = client.get_info
+  #   balance = client.get_balance
+  #   invoice = client.make_invoice(amount: 1_000, description: "tip")
+  #
+  #   # Long-running listener (transparently heartbeats, reconnects, resumes):
+  #   client.subscribe_to_notifications do |notification|
+  #     puts "Got #{notification.amount_msats} msats"
+  #   end
+  class Client
+    DEFAULT_TIMEOUT = 30
+
+    attr_reader :connection_string, :logger
+
+    def self.from_uri(uri_string, **)
+      new(ConnectionString.parse(uri_string), **)
+    end
+
+    def initialize(connection_string, logger: nil, request_timeout: DEFAULT_TIMEOUT)
+      @connection_string = connection_string
+      @logger            = logger || default_logger
+      @request_timeout   = request_timeout
+      @info              = nil
+    end
+
+    # -- Introspection --------------------------------------------------------
+
+    # Fetch and cache the kind 13194 info event. This tells us which methods
+    # the wallet service supports and which encryption schemes it accepts.
+    def info(refresh: false)
+      return @info if @info && !refresh
+
+      @info = fetch_info
+    end
+
+    def capabilities
+      info.methods
+    end
+
+    def read_only?
+      info.read_only?
+    end
+
+    def read_write?
+      info.read_write?
+    end
+
+    # -- NIP-47 methods -------------------------------------------------------
+
+    def pay_invoice(invoice:, amount: nil)
+      params = { 'invoice' => invoice }
+      params['amount'] = amount if amount
+      call(NIP47::Methods::PAY_INVOICE, params)
+    end
+
+    def multi_pay_invoice(invoices:)
+      call(NIP47::Methods::MULTI_PAY_INVOICE, { 'invoices' => invoices })
+    end
+
+    def pay_keysend(amount:, pubkey:, preimage: nil, tlv_records: nil)
+      params = { 'amount' => amount, 'pubkey' => pubkey }
+      params['preimage']    = preimage    if preimage
+      params['tlv_records'] = tlv_records if tlv_records
+      call(NIP47::Methods::PAY_KEYSEND, params)
+    end
+
+    def multi_pay_keysend(keysends:)
+      call(NIP47::Methods::MULTI_PAY_KEYSEND, { 'keysends' => keysends })
+    end
+
+    def make_invoice(amount:, description: nil, description_hash: nil, expiry: nil, metadata: nil)
+      params = { 'amount' => amount }
+      params['description']      = description      if description
+      params['description_hash'] = description_hash if description_hash
+      params['expiry']           = expiry           if expiry
+      params['metadata']         = metadata         if metadata
+      call(NIP47::Methods::MAKE_INVOICE, params)
+    end
+
+    def lookup_invoice(payment_hash: nil, invoice: nil)
+      raise ArgumentError, 'lookup_invoice requires payment_hash or invoice' if payment_hash.nil? && invoice.nil?
+
+      params = {}
+      params['payment_hash'] = payment_hash if payment_hash
+      params['invoice']      = invoice      if invoice
+      call(NIP47::Methods::LOOKUP_INVOICE, params)
+    end
+
+    def list_transactions(from: nil, until_ts: nil, limit: nil, offset: nil, unpaid: nil, type: nil)
+      params = {}
+      params['from']   = from       if from
+      params['until']  = until_ts   if until_ts
+      params['limit']  = limit      if limit
+      params['offset'] = offset     if offset
+      params['unpaid'] = unpaid unless unpaid.nil?
+      params['type']   = type if type
+      call(NIP47::Methods::LIST_TRANSACTIONS, params)
+    end
+
+    def get_balance
+      call(NIP47::Methods::GET_BALANCE, {})
+    end
+
+    def get_info
+      call(NIP47::Methods::GET_INFO, {})
+    end
+
+    def sign_message(message:)
+      call(NIP47::Methods::SIGN_MESSAGE, { 'message' => message })
+    end
+
+    # Stop a running subscribe_to_notifications listener.
+    def stop_notifications!
+      @notification_connection&.stop!
+    end
+
+    # -- Notification listener -----------------------------------------------
+
+    # Subscribe to payment_received / payment_sent notifications from the
+    # wallet service. Blocks forever, handling heartbeat and reconnect.
+    #
+    #   client.subscribe_to_notifications do |notification|
+    #     case notification.type
+    #     when "payment_received" then credit_invoice(notification.payment_hash, notification.amount_msats)
+    #     when "payment_sent"     then mark_outbound_settled(notification.payment_hash)
+    #     end
+    #   end
+    #
+    # @param since [Integer] unix timestamp for the `since:` filter on the
+    #   subscription; defaults to now. Pass the last-seen `created_at` on
+    #   reconnect to avoid replaying history.
+    # @param kinds [Array<Integer>] notification kinds to listen for. Defaults
+    #   to both NIP-04 (23196) and NIP-44 v2 (23197). The listener dedupes by
+    #   `payment_hash`, so receiving both is safe.
+    def subscribe_to_notifications(since: Time.now.to_i,
+                                   kinds: [NIP47::Methods::KIND_NOTIFICATION_NIP04,
+                                           NIP47::Methods::KIND_NOTIFICATION_NIP44],
+                                   sub_id: "nwc-#{SecureRandom.hex(4)}",
+                                   poll_interval: nil,
+                                   &block)
+      raise ArgumentError, 'block required' unless block
+
+      seen = {}
+      last_seen_at = since
+      filters = [{
+        'authors' => [@connection_string.wallet_pubkey],
+        '#p' => [@connection_string.client_pubkey],
+        'kinds' => kinds,
+        'since' => since
+      }]
+
+      conn = Transport::RelayConnection.new(
+        url: @connection_string.relays.first,
+        logger: @logger,
+        poll_interval: poll_interval
+      )
+      @notification_connection = conn
+
+      conn.on_open do |c|
+        @logger.info("[nwc] subscribing sub_id=#{sub_id} client_pubkey=#{@connection_string.client_pubkey} wallet_pubkey=#{@connection_string.wallet_pubkey} kinds=#{kinds.inspect} since=#{since}")
+        c.send_req(sub_id: sub_id, filters: filters)
+      end
+
+      # Periodic re-subscribe: some relays (e.g. strfry) store ephemeral
+      # events temporarily but never push them to existing subscriptions.
+      # Re-sending the REQ with the same sub_id forces the relay to return
+      # any newly-stored events.
+      conn.on_poll do |c|
+        filters[0]['since'] = last_seen_at
+        @logger.debug("[nwc] re-subscribing sub_id=#{sub_id} since=#{last_seen_at}")
+        c.send_req(sub_id: sub_id, filters: filters)
+      end
+
+      conn.on_event do |_sub, event_hash|
+        event = Event.from_hash(event_hash)
+        next unless event.valid_signature?
+        next unless event.pubkey == @connection_string.wallet_pubkey
+
+        # Advance the poll watermark so we don't re-fetch old events.
+        last_seen_at = event.created_at if event.created_at && event.created_at > last_seen_at
+
+        begin
+          notification = NIP47::Notification.parse(event, @connection_string.secret, @connection_string.wallet_pubkey)
+        rescue EncryptionError => e
+          @logger.warn("[nwc] could not decrypt notification: #{e.message}")
+          next
+        end
+
+        # Dedupe: wallets that support both encryption schemes publish both
+        # 23196 and 23197 for the same event.
+        key = notification.payment_hash || event.id
+        next if seen[key]
+
+        seen[key] = true
+        # Primitive GC to keep the hash bounded.
+        seen.shift while seen.size > 10_000
+
+        block.call(notification)
+      end
+
+      conn.run!
+    end
+
+    # -- Internals ------------------------------------------------------------
+
+    private
+
+    # rubocop:disable Metrics/MethodLength
+    def call(method, params)
+      ensure_supports!(method)
+      encryption = info.preferred_encryption
+
+      deadline = Time.now + @request_timeout
+      result   = nil
+
+      Async do
+        endpoint = Async::HTTP::Endpoint.parse(@connection_string.relays.first, alpn_protocols: ['http/1.1'])
+        Async::WebSocket::Client.connect(endpoint) do |conn|
+          request_event = NIP47::Request.build(
+            method: method,
+            params: params,
+            client_privkey: @connection_string.secret,
+            wallet_pubkey: @connection_string.wallet_pubkey,
+            encryption: encryption
+          )
+
+          sub_id = "rsp-#{SecureRandom.hex(4)}"
+          conn.write(Protocol::WebSocket::TextMessage.generate(['REQ', sub_id, {
+                                                                 'authors' => [@connection_string.wallet_pubkey],
+                                                                 'kinds' => [NIP47::Methods::KIND_RESPONSE],
+                                                                 '#e' => [request_event.id],
+                                                                 '#p' => [@connection_string.client_pubkey]
+                                                               }]))
+          conn.write(Protocol::WebSocket::TextMessage.generate(['EVENT', request_event.to_h]))
+          conn.flush
+
+          while (msg = conn.read)
+            break if Time.now > deadline
+
+            parsed = begin
+              JSON.parse(msg.buffer)
+            rescue JSON::ParserError
+              next
+            end
+
+            next unless parsed[0] == 'EVENT' && parsed[1] == sub_id
+
+            event = Event.from_hash(parsed[2])
+            next unless event.valid_signature?
+            next unless event.pubkey == @connection_string.wallet_pubkey
+
+            result = NIP47::Response.parse(event, @connection_string.secret, @connection_string.wallet_pubkey)
+            break
+          end
+        ensure
+          begin
+            conn&.close
+          rescue StandardError
+            nil
+          end
+        end
+      end.wait
+
+      raise TimeoutError, "no response to #{method} within #{@request_timeout}s" if result.nil?
+      raise WalletServiceError.new(result.error_code || 'UNKNOWN', result.error_message || '') unless result.success?
+
+      result.result
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    def fetch_info
+      endpoint  = Async::HTTP::Endpoint.parse(@connection_string.relays.first, alpn_protocols: ['http/1.1'])
+      deadline  = Time.now + @request_timeout
+      result    = nil
+
+      Async do
+        Async::WebSocket::Client.connect(endpoint) do |conn|
+          sub_id = "info-#{SecureRandom.hex(4)}"
+          conn.write(Protocol::WebSocket::TextMessage.generate(['REQ', sub_id, {
+                                                                 'authors' => [@connection_string.wallet_pubkey],
+                                                                 'kinds' => [NIP47::Methods::KIND_INFO],
+                                                                 'limit' => 1
+                                                               }]))
+          conn.flush
+
+          while (msg = conn.read)
+            break if Time.now > deadline
+
+            parsed = begin
+              JSON.parse(msg.buffer)
+            rescue JSON::ParserError
+              next
+            end
+
+            if parsed[0] == 'EVENT' && parsed[1] == sub_id
+              event  = Event.from_hash(parsed[2])
+              result = NIP47::Info.parse(event) if event.valid_signature?
+              break
+            elsif parsed[0] == 'EOSE' && parsed[1] == sub_id
+              break
+            end
+          end
+        ensure
+          begin
+            conn&.close
+          rescue StandardError
+            nil
+          end
+        end
+      end.wait
+
+      if result.nil?
+        raise TransportError,
+              "wallet service published no info event (kind 13194) on #{@connection_string.relays.first}"
+      end
+
+      result
+    end
+
+    def ensure_supports!(method)
+      return if info.supports?(method)
+
+      raise UnsupportedMethodError,
+            "wallet service does not advertise `#{method}`. Supported: #{info.methods.join(', ')}"
+    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

data/lib/nwc_ruby/connection_string.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module NwcRuby
+  # Parses a `nostr+walletconnect://` URI.
+  #
+  # Canonical form:
+  #   nostr+walletconnect://<wallet_service_pubkey_hex>?
+  #     relay=wss://...
+  #    &secret=<32_byte_hex>
+  #    &lud16=<optional>
+  #
+  # `relay` may repeat. `secret` is the CLIENT private key (32 bytes hex); the
+  # derived client pubkey is what the wallet encrypts responses to.
+  class ConnectionString
+    attr_reader :wallet_pubkey, :relays, :secret, :lud16
+
+    def self.parse(uri_string)
+      new(uri_string)
+    end
+
+    def initialize(uri_string)
+      raise InvalidConnectionStringError, 'connection string is empty' if uri_string.nil? || uri_string.empty?
+
+      # The built-in URI parser chokes on `nostr+walletconnect://` because of
+      # the `+`, so normalize the scheme before parsing.
+      normalized = uri_string.sub(%r{\Anostr\+walletconnect://}, 'https://')
+      uri = URI.parse(normalized)
+
+      unless uri_string.start_with?('nostr+walletconnect://') ||
+             uri_string.start_with?('nostrwalletconnect://')
+        raise InvalidConnectionStringError,
+              'expected nostr+walletconnect:// scheme'
+      end
+
+      @wallet_pubkey = uri.host&.downcase
+      Crypto::Keys.validate_hex32!(@wallet_pubkey, 'wallet service pubkey (host)')
+
+      params = decode_query(uri.query || '')
+
+      @relays = Array(params['relay'])
+      raise InvalidConnectionStringError, 'at least one `relay` parameter is required' if @relays.empty?
+
+      @secret = params['secret']&.first&.downcase
+      Crypto::Keys.validate_hex32!(@secret, 'secret')
+
+      @lud16 = params['lud16']&.first
+    rescue URI::InvalidURIError => e
+      raise InvalidConnectionStringError, "malformed URI: #{e.message}"
+    end
+
+    # The client's own x-only pubkey, derived from `secret`.
+    def client_pubkey
+      @client_pubkey ||= Crypto::Keys.public_key_from_private(@secret)
+    end
+
+    def to_s
+      params = { 'relay' => @relays, 'secret' => [@secret] }
+      params['lud16'] = [@lud16] if @lud16
+      "nostr+walletconnect://#{@wallet_pubkey}?#{encode_query(params)}"
+    end
+
+    private
+
+    def decode_query(query)
+      result = Hash.new { |h, k| h[k] = [] }
+      query.split('&').each do |pair|
+        next if pair.empty?
+
+        k, v = pair.split('=', 2)
+        result[URI.decode_www_form_component(k)] << URI.decode_www_form_component(v.to_s)
+      end
+      result
+    end
+
+    def encode_query(params)
+      params.flat_map do |k, values|
+        Array(values).map { |v| "#{URI.encode_www_form_component(k)}=#{URI.encode_www_form_component(v)}" }
+      end.join('&')
+    end
+  end
+end

data/lib/nwc_ruby/crypto/ecdh.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'rbsecp256k1'
+require 'ecdsa'
+
+module NwcRuby
+  module Crypto
+    # ECDH for Nostr: compute the shared secret between our private key and
+    # their x-only public key.
+    #
+    # CRITICAL: Nostr ECDH returns the **X coordinate of the shared point only**
+    # (32 bytes). This differs from libsecp256k1's default `ecdh()` function,
+    # which returns SHA256(compressed_point). We have to do the multiplication
+    # ourselves using the `ecdsa` gem.
+    #
+    # This is used by both NIP-04 (as the AES key directly) and NIP-44 v2 (as
+    # the IKM for HKDF).
+    module ECDH
+      module_function
+
+      GROUP = ::ECDSA::Group::Secp256k1
+
+      # Returns the raw 32-byte X coordinate of the shared point.
+      #
+      # @param privkey_hex [String] our 32-byte private key (hex)
+      # @param xonly_pubkey_hex [String] their 32-byte x-only public key (hex)
+      # @return [String] 32 raw bytes (binary-encoded)
+      def shared_x(privkey_hex, xonly_pubkey_hex)
+        Keys.validate_hex32!(privkey_hex, 'private key')
+        Keys.validate_hex32!(xonly_pubkey_hex, 'public key')
+
+        # BIP-340 x-only pubkeys always correspond to the even-Y lifted point.
+        pubkey_point = lift_x(Keys.hex_to_bytes(xonly_pubkey_hex).unpack1('H*').to_i(16))
+        priv_int     = privkey_hex.to_i(16)
+
+        shared_point = pubkey_point.multiply_by_scalar(priv_int)
+        [shared_point.x.to_s(16).rjust(64, '0')].pack('H*')
+      end
+
+      # BIP-340 "lift_x": given an x coordinate, return the point with even Y.
+      def lift_x(x)
+        raise EncryptionError, 'x out of range' if x.zero? || x >= GROUP.field.prime
+
+        p   = GROUP.field.prime
+        c   = (x.pow(3, p) + 7) % p
+        y   = c.pow((p + 1) / 4, p)
+        raise EncryptionError, 'x is not on the curve' unless y.pow(2, p) == c
+
+        y = p - y if y.odd?
+        GROUP.new_point([x, y])
+      end
+    end
+  end
+end

data/lib/nwc_ruby/crypto/keys.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'rbsecp256k1'
+
+module NwcRuby
+  module Crypto
+    # Key helpers: hex <-> bytes, private key -> x-only pubkey, validation.
+    #
+    # Nostr uses BIP-340 Schnorr signatures over secp256k1. Public keys are
+    # "x-only" — just the 32-byte X coordinate. We use rbsecp256k1 (which wraps
+    # libsecp256k1) to derive them correctly.
+    module Keys
+      module_function
+
+      # Generate a new 32-byte private key as a lowercase hex string.
+      def generate_private_key
+        SecureRandom.bytes(32).unpack1('H*')
+      end
+
+      # Derive the 32-byte x-only public key (hex) from a private key (hex).
+      def public_key_from_private(privkey_hex)
+        validate_hex32!(privkey_hex, 'private key')
+        ctx = ::Secp256k1::Context.create
+        kp  = ctx.key_pair_from_private_key(hex_to_bytes(privkey_hex))
+        # rbsecp256k1 gives us a compressed public key (33 bytes, 02/03 prefix).
+        # X-only pubkey is just bytes 1..32.
+        compressed = kp.public_key.compressed
+        bytes_to_hex(compressed[1, 32])
+      end
+
+      def hex_to_bytes(hex)
+        [hex].pack('H*')
+      end
+
+      def bytes_to_hex(bytes)
+        bytes.unpack1('H*')
+      end
+
+      def validate_hex32!(hex, label = 'value')
+        return if hex.is_a?(String) && hex.match?(/\A[0-9a-fA-F]{64}\z/)
+
+        raise InvalidConnectionStringError, "#{label} must be 64 hex characters (32 bytes)"
+      end
+    end
+  end
+end

data/lib/nwc_ruby/crypto/schnorr.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require 'rbsecp256k1'
+
+module NwcRuby
+  module Crypto
+    # BIP-340 Schnorr signatures for Nostr events.
+    #
+    # Nostr event IDs are 32-byte SHA-256 hashes. The event signature is a
+    # 64-byte BIP-340 Schnorr signature over that hash, verifiable against the
+    # event's 32-byte x-only public key.
+    module Schnorr
+      module_function
+
+      # Sign a 32-byte digest with a private key. Returns 64-byte signature
+      # as a lowercase hex string (128 chars).
+      def sign(digest_bytes, privkey_hex)
+        raise ArgumentError, 'digest must be 32 bytes' unless digest_bytes.bytesize == 32
+
+        ctx = ::Secp256k1::Context.create
+        kp  = ctx.key_pair_from_private_key(Keys.hex_to_bytes(privkey_hex))
+        sig = ctx.sign_schnorr(kp, digest_bytes)
+        Keys.bytes_to_hex(sig.serialized)
+      end
+
+      # Verify a 64-byte Schnorr signature. Returns true / false.
+      def verify(digest_bytes, sig_hex, xonly_pubkey_hex)
+        return false unless sig_hex.is_a?(String) && sig_hex.length == 128
+
+        xonly_pub = ::Secp256k1::XOnlyPublicKey.from_data(Keys.hex_to_bytes(xonly_pubkey_hex))
+        sig_obj   = ::Secp256k1::SchnorrSignature.from_data(Keys.hex_to_bytes(sig_hex))
+        sig_obj.verify(digest_bytes, xonly_pub)
+      rescue ::Secp256k1::Error, ::Secp256k1::DeserializationError, ArgumentError
+        false
+      end
+    end
+  end
+end

data/lib/nwc_ruby/errors.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module NwcRuby
+  # Base class for all gem errors. Rescue this to catch anything the gem raises.
+  class Error < StandardError; end
+
+  # The connection string is missing or malformed.
+  class InvalidConnectionStringError < Error; end
+
+  # Encryption / decryption failed (bad MAC, bad padding, unknown version byte).
+  class EncryptionError < Error; end
+
+  # Signature verification failed on an inbound event.
+  class InvalidSignatureError < Error; end
+
+  # The relay could not be reached, or the connection died and did not recover
+  # within the configured timeout.
+  class TransportError < Error; end
+
+  # The wallet service returned an error envelope. `#code` is the NIP-47 error
+  # code (one of RATE_LIMITED, NOT_IMPLEMENTED, INSUFFICIENT_BALANCE,
+  # QUOTA_EXCEEDED, RESTRICTED, UNAUTHORIZED, INTERNAL, UNSUPPORTED_ENCRYPTION,
+  # PAYMENT_FAILED, NOT_FOUND, or OTHER).
+  class WalletServiceError < Error
+    attr_reader :code
+
+    def initialize(code, message)
+      @code = code
+      super("#{code}: #{message}")
+    end
+  end
+
+  # A request was sent but no response arrived within the timeout window.
+  class TimeoutError < Error; end
+
+  # The wallet service does not support the method we tried to call. Check
+  # `Client#capabilities` first, or use a read+write NWC string.
+  class UnsupportedMethodError < Error; end
+end

data/lib/nwc_ruby/event.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module NwcRuby
+  # A Nostr event (NIP-01).
+  #
+  # The canonical serialization for ID computation is a JSON array with no
+  # whitespace between elements:
+  #   [0, pubkey, created_at, kind, tags, content]
+  # SHA-256 of that JSON is the event id; the event id is signed with BIP-340
+  # Schnorr against the author's private key.
+  class Event
+    attr_accessor :id, :pubkey, :created_at, :kind, :tags, :content, :sig
+
+    def initialize(pubkey:, kind:, content:, tags: [], created_at: Time.now.to_i)
+      @pubkey     = pubkey
+      @kind       = kind
+      @content    = content
+      @tags       = tags
+      @created_at = created_at
+    end
+
+    # Build from a hash as received from the relay.
+    def self.from_hash(h)
+      e = allocate
+      e.id         = h['id']
+      e.pubkey     = h['pubkey']
+      e.created_at = h['created_at']
+      e.kind       = h['kind']
+      e.tags       = h['tags'] || []
+      e.content    = h['content'] || ''
+      e.sig        = h['sig']
+      e
+    end
+
+    # JSON used for ID computation. MUST NOT contain whitespace between tokens
+    # and MUST use the array form below.
+    def serialize_for_id
+      JSON.generate([0, @pubkey, @created_at, @kind, @tags, @content])
+    end
+
+    def compute_id!
+      @id = OpenSSL::Digest::SHA256.hexdigest(serialize_for_id)
+      self
+    end
+
+    def sign!(privkey_hex)
+      compute_id!
+      digest_bytes = Crypto::Keys.hex_to_bytes(@id)
+      @sig = Crypto::Schnorr.sign(digest_bytes, privkey_hex)
+      self
+    end
+
+    def valid_signature?
+      return false unless @id && @sig && @pubkey
+
+      digest_bytes = Crypto::Keys.hex_to_bytes(@id)
+      Crypto::Schnorr.verify(digest_bytes, @sig, @pubkey)
+    end
+
+    def to_h
+      {
+        'id' => @id,
+        'pubkey' => @pubkey,
+        'created_at' => @created_at,
+        'kind' => @kind,
+        'tags' => @tags,
+        'content' => @content,
+        'sig' => @sig
+      }
+    end
+  end
+end