bsv-sdk 0.12.1 → 0.14.0

data/lib/bsv/network/protocol.rb

@@ -0,0 +1,321 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'net/http'
+require 'json'
+require 'uri'
+
+module BSV
+  module Network
+    # Protocol is the base class for all BSV network protocol definitions.
+    #
+    # Subclasses declare their commands via the +endpoint+ DSL macro. Each
+    # endpoint maps a command name (Symbol) to an HTTP method, a path template,
+    # and a response handler. The +subscription+ macro is a placeholder for future
+    # WebSocket support.
+    #
+    # Subclass isolation is enforced via an +inherited+ hook — each subclass
+    # receives its own empty +@endpoints+ and +@subscriptions+ hashes. Adding
+    # endpoints to a subclass never affects the parent.
+    #
+    # HTTP dispatch routes through +call+: if a +call_<name>+ escape hatch
+    # method exists on the instance, it is called; otherwise +default_call+
+    # interpolates the URL template, makes the HTTP request, and maps the
+    # response to a +Result+.
+    #
+    # == Example
+    #
+    #   class MyProtocol < BSV::Network::Protocol
+    #     endpoint :get_tx, :get, '/v1/tx/{txid}'
+    #     endpoint :broadcast, :post, '/v1/tx', response: :json
+    #   end
+    #
+    #   p = MyProtocol.new(base_url: 'https://api.example.com', network: 'main')
+    #   MyProtocol.commands #=> #<Set: {:get_tx, :broadcast}>
+    class Protocol
+      class << self
+        # Registers an endpoint definition for this protocol class.
+        #
+        # @param command_name [Symbol] the command name (e.g. +:broadcast+)
+        # @param http_method  [Symbol] +:get+ or +:post+
+        # @param path_template [String] path with +{param}+ placeholders
+        # @param response [Symbol, #call] response handler — +:raw+, +:json+,
+        #   +:json_array+, or a callable (lambda/proc)
+        def endpoint(command_name, http_method, path_template, response: :raw)
+          @endpoints[command_name] = {
+            method: http_method,
+            path: path_template,
+            response: response
+          }
+        end
+
+        # Registers a subscription definition. Placeholder for Phase C WebSocket
+        # support. Stored but not callable at runtime.
+        #
+        # @param event_name [Symbol] the event name
+        # @param path       [String] WebSocket path
+        # @param opts       [Hash]   additional options (reserved)
+        def subscription(event_name, path, **opts)
+          @subscriptions[event_name] = { path: path }.merge(opts)
+        end
+
+        # Returns a +Set+ of command names declared on this protocol class.
+        #
+        # @return [Set<Symbol>]
+        def commands
+          Set.new(@endpoints.keys)
+        end
+
+        # Returns a frozen copy of the endpoints hash for introspection.
+        #
+        # @return [Hash]
+        def endpoints
+          @endpoints.dup.freeze
+        end
+
+        # Returns a frozen copy of the subscriptions hash for introspection.
+        #
+        # @return [Hash]
+        def subscriptions
+          @subscriptions.dup.freeze
+        end
+
+        # Give each subclass its own isolated +@endpoints+ and +@subscriptions+
+        # hashes. Deep-copies the parent's endpoints so that existing declarations
+        # are inherited but mutations on the subclass do not affect the parent.
+        def inherited(subclass)
+          super
+          # Deep copy: each endpoint value is a plain hash of scalar values,
+          # so a one-level transform_values dup is sufficient.
+          parent_endpoints = @endpoints.each_with_object({}) do |(k, v), h|
+            h[k] = v.dup
+          end
+          parent_subscriptions = @subscriptions.each_with_object({}) do |(k, v), h|
+            h[k] = v.dup
+          end
+          subclass.instance_variable_set(:@endpoints,     parent_endpoints)
+          subclass.instance_variable_set(:@subscriptions, parent_subscriptions)
+        end
+      end
+
+      # Initialise the class-level hashes on Protocol itself so that the
+      # inherited hook works correctly for direct subclasses.
+      @endpoints     = {}
+      @subscriptions = {}
+
+      attr_reader :base_url, :api_key, :network, :http_client
+
+      # @param base_url    [String] base URL, may contain +{network}+ placeholder
+      # @param api_key     [String, nil] API key for authenticated requests
+      # @param network     [String, Symbol, nil] network name (e.g. 'main', 'test')
+      # @param http_client [Object, nil] injectable HTTP client (used in Task 3)
+      def initialize(base_url:, api_key: nil, network: nil, http_client: nil)
+        @api_key     = api_key
+        @network     = network
+        @http_client = http_client
+        @base_url    = build_base_url(base_url, network)
+      end
+
+      # Dispatches a command by name.
+      #
+      # If a method named +call_<command_name>+ exists on the instance it is
+      # used as an escape hatch — that method receives +args+ and +kwargs+
+      # and MUST return a +Result+. Otherwise +default_call+ is invoked.
+      #
+      # Subscriptions are not callable; calling one raises +NotImplementedError+.
+      #
+      # @param command_name [Symbol, String] command to invoke
+      # @param args   [Array]  positional arguments forwarded to path interpolation
+      # @param kwargs [Hash]   keyword arguments forwarded to path interpolation
+      # @return [Result::Success, Result::Error, Result::NotFound]
+      # @raise [ArgumentError] when command_name is not registered
+      def call(command_name, *args, **kwargs)
+        name = command_name.to_sym
+
+        if self.class.subscriptions.key?(name)
+          raise NotImplementedError,
+                "#{name} is a subscription — WebSocket dispatch is not yet implemented"
+        end
+
+        escape = :"call_#{name}"
+        if respond_to?(escape, true)
+          return kwargs.empty? ? send(escape, *args) : send(escape, *args, **kwargs)
+        end
+
+        default_call(name, *args, **kwargs)
+      end
+
+      # Dispatches a command directly via HTTP, bypassing any escape hatch.
+      #
+      # Path placeholders (+{param}+) are filled from +kwargs+ first; any
+      # remaining placeholders are filled positionally from +args+. Named
+      # kwargs take precedence over positional args for the same placeholder.
+      #
+      # POST body is taken from +kwargs.delete(:body)+ (removed before path
+      # interpolation).
+      #
+      # @param command_name [Symbol] registered command name
+      # @param args   [Array]  positional path parameters
+      # @param kwargs [Hash]   named path parameters (and optional +:body+)
+      # @return [Result::Success, Result::Error, Result::NotFound]
+      # @raise [ArgumentError] when command_name is not registered or a
+      #   required path parameter is missing
+      def default_call(command_name, *args, **kwargs)
+        name = command_name.to_sym
+        defn = self.class.endpoints[name]
+        raise ArgumentError, "unknown command: #{name}" unless defn
+
+        body       = kwargs.delete(:body)
+        path       = interpolate_path(defn[:path], args, kwargs)
+        uri        = URI("#{@base_url}#{path}")
+        request    = build_request(defn[:method], uri, body)
+        response   = execute(uri, request)
+
+        map_response(response, defn[:response])
+      end
+
+      private
+
+      # Resolves the final base URL by interpolating +{network}+ and stripping
+      # any trailing slash.
+      #
+      # @param url     [String]
+      # @param network [String, Symbol, nil]
+      # @return [String]
+      # @raise [ArgumentError] when +{network}+ placeholder is present but
+      #   +network+ was not provided
+      def build_base_url(url, network)
+        if url.include?('{network}')
+          raise ArgumentError, 'base_url contains {network} placeholder but no network: was provided' if network.nil?
+
+          url = url.gsub('{network}', network.to_s)
+        end
+
+        url.chomp('/')
+      end
+
+      # Interpolates +{placeholder}+ tokens in a path template.
+      #
+      # Named kwargs are matched first (removing matched keys from the hash).
+      # Remaining positional args fill placeholders in template order.
+      #
+      # @param template [String]  path template with +{name}+ tokens
+      # @param args     [Array]   positional substitution values
+      # @param kwargs   [Hash]    named substitution values (modified in place)
+      # @return [String]
+      # @raise [ArgumentError] when a placeholder cannot be filled
+      def interpolate_path(template, args, kwargs)
+        pos_args  = args.dup
+        remaining = kwargs.dup
+
+        # Extract ordered placeholder names from the template
+        names = template.scan(/\{(\w+)\}/).flatten.map(&:to_sym)
+
+        result = template.dup
+        names.each do |name|
+          value =
+            if remaining.key?(name)
+              remaining.delete(name)
+            elsif !pos_args.empty?
+              pos_args.shift
+            else
+              raise ArgumentError, "missing path parameter: #{name}"
+            end
+          result = result.sub("{#{name}}") { value.to_s }
+        end
+        result
+      end
+
+      # Builds a Net::HTTP request for the given method, URI, and optional body.
+      #
+      # @param http_method [Symbol] +:get+ or +:post+
+      # @param uri   [URI]
+      # @param body  [String, nil] raw body for POST requests
+      # @return [Net::HTTPRequest]
+      def build_request(http_method, uri, body)
+        request =
+          case http_method
+          when :get  then Net::HTTP::Get.new(uri)
+          when :post then Net::HTTP::Post.new(uri)
+          else raise ArgumentError, "unsupported HTTP method: #{http_method}"
+          end
+
+        request['Authorization'] = "Bearer #{@api_key}" if @api_key
+        if body && request.respond_to?(:body=)
+          request.body = body
+          request.content_type = 'application/json' unless request.content_type
+        end
+        request
+      end
+
+      # Executes the request via the injectable client or +Net::HTTP.start+.
+      #
+      # @param uri     [URI]
+      # @param request [Net::HTTPRequest]
+      # @return [Net::HTTPResponse]
+      def execute(uri, request)
+        if @http_client
+          @http_client.request(uri, request)
+        else
+          Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') do |http|
+            http.request(request)
+          end
+        end
+      end
+
+      # Maps an HTTP response to a Result type, applying the response handler
+      # on 2xx bodies.
+      #
+      # All non-2xx results carry +status_code:+ in their +metadata+ hash so
+      # that facades can construct domain exceptions with the original HTTP code.
+      #
+      # @param response [Net::HTTPResponse]
+      # @param handler  [Symbol, #call]
+      # @return [Result::Success, Result::Error, Result::NotFound]
+      def map_response(response, handler)
+        code = response.code.to_i
+
+        case code
+        when 200..299
+          data = apply_handler(response.body, handler)
+          return data if data.is_a?(Result::Error)
+
+          Result::Success.new(data: data)
+        when 404
+          Result::NotFound.new(message: response.body, metadata: { status_code: code })
+        when 429, 500..599
+          Result::Error.new(message: response.body, retryable: true, metadata: { status_code: code })
+        else
+          Result::Error.new(message: response.body, retryable: false, metadata: { status_code: code })
+        end
+      end
+
+      # Applies the response handler to a raw body string.
+      #
+      # @param body    [String, nil]
+      # @param handler [Symbol, #call]
+      # @return [Object, Result::Error]
+      def apply_handler(body, handler)
+        return body if body.nil?
+
+        case handler
+        when :raw
+          body
+        when :json
+          JSON.parse(body)
+        when :json_array
+          parsed = JSON.parse(body)
+          raise TypeError, "expected Array, got #{parsed.class}" unless parsed.is_a?(Array)
+
+          parsed
+        else
+          raise ArgumentError, "unsupported response handler: #{handler.inspect}" unless handler.respond_to?(:call)
+
+          handler.call(body)
+        end
+      rescue JSON::ParserError, TypeError => e
+        Result::Error.new(message: "JSON/response error: #{e.message}", retryable: false)
+      end
+    end
+  end
+end

data/lib/bsv/network/protocols/arc.rb

@@ -0,0 +1,351 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'securerandom'
+
+module BSV
+  module Network
+    module Protocols
+      # ARC protocol implementation for submitting transactions to the BSV network.
+      #
+      # Extends Protocol with five endpoints and two escape hatches for broadcast
+      # logic: EF format preference, rejection detection, and custom headers.
+      #
+      # The protocol returns Result objects (never raises). The facade layer
+      # (Phase D) is responsible for translating Results to BroadcastResponse /
+      # BroadcastError as needed by consumer code.
+      #
+      # == Example
+      #
+      #   arc = BSV::Network::Protocols::ARC.new(
+      #     base_url: 'https://arc.taal.com',
+      #     api_key: 'my-api-key'
+      #   )
+      #   result = arc.call(:broadcast, tx)
+      #   result.success? # => true
+      #   result.data[:txid] # => "abc123..."
+      class ARC < Protocol
+        # ARC response statuses that indicate a transaction was NOT accepted.
+        # Matches the TypeScript SDK's ARC broadcaster failure set.
+        REJECTED_STATUSES = %w[
+          REJECTED
+          DOUBLE_SPEND_ATTEMPTED
+          INVALID
+          MALFORMED
+          MINED_IN_STALE_BLOCK
+        ].freeze
+
+        # Substring marker for orphan detection in txStatus or extraInfo fields.
+        ORPHAN_MARKER = 'ORPHAN'
+
+        endpoint :broadcast,      :post, '/v1/tx',          response: :json
+        endpoint :broadcast_many, :post, '/v1/txs',         response: :json_array
+        endpoint :get_tx_status,  :get,  '/v1/tx/{txid}',   response: :json
+        endpoint :get_policy,     :get,  '/v1/policy',      response: :json
+        endpoint :health,         :get,  '/v1/health',      response: :json
+
+        # @param base_url      [String]      ARC base URL (may contain {network})
+        # @param api_key       [String, nil] optional bearer token
+        # @param network       [String, nil] network name for base URL interpolation
+        # @param deployment_id [String, nil] deployment identifier for the
+        #   XDeployment-ID header; defaults to a per-instance random hex value
+        # @param callback_url  [String, nil] optional X-CallbackUrl header value
+        # @param callback_token [String, nil] optional X-CallbackToken header value
+        # @param http_client   [#request, nil] injectable HTTP client for testing
+        def initialize(base_url:, api_key: nil, network: nil, deployment_id: nil,
+                       callback_url: nil, callback_token: nil, http_client: nil)
+          super(base_url: base_url, api_key: api_key, network: network, http_client: http_client)
+          @deployment_id  = deployment_id || "bsv-ruby-sdk-#{SecureRandom.hex(8)}"
+          @callback_url   = callback_url
+          @callback_token = callback_token
+        end
+
+        private
+
+        # Broadcast escape hatch: EF format preference, custom headers, rejection
+        # detection, and malformed 2xx detection.
+        #
+        # @param tx [Transaction] the transaction to broadcast
+        # @param wait_for [String, nil] ARC wait condition
+        # @param skip_fee_validation [Boolean, nil]
+        # @param skip_script_validation [Boolean, nil]
+        # @param skip_tx_validation [Boolean, nil]
+        # @param callback_url [String, nil] per-call callback URL override
+        # @param callback_token [String, nil] per-call callback token override
+        # @param callback_batch [Boolean, nil] when truthy, sends X-CallbackBatch header
+        # @return [Result::Success, Result::Error]
+        def call_broadcast(tx, wait_for: nil, skip_fee_validation: nil,
+                           skip_script_validation: nil, skip_tx_validation: nil,
+                           callback_url: nil, callback_token: nil, callback_batch: nil, **)
+          hex  = ef_hex_with_fallback(tx)
+          body = JSON.generate(rawTx: hex)
+
+          extra_headers = build_broadcast_headers(
+            wait_for: wait_for,
+            skip_fee_validation: skip_fee_validation,
+            skip_script_validation: skip_script_validation,
+            skip_tx_validation: skip_tx_validation,
+            callback_url: callback_url || @callback_url,
+            callback_token: callback_token || @callback_token,
+            callback_batch: callback_batch
+          )
+
+          response = post_with_headers('/v1/tx', body, extra_headers)
+          parse_single_broadcast_response(response)
+        end
+
+        # Broadcast-many escape hatch: batch broadcast with per-item rejection detection.
+        #
+        # @param txs [Array<Transaction>]
+        # @param wait_for [String, nil]
+        # @param skip_fee_validation [Boolean, nil]
+        # @param skip_script_validation [Boolean, nil]
+        # @param skip_tx_validation [Boolean, nil]
+        # @param callback_url [String, nil]
+        # @param callback_token [String, nil]
+        # @param callback_batch [Boolean, nil]
+        # @return [Result::Success, Result::Error]
+        def call_broadcast_many(txs, wait_for: nil, skip_fee_validation: nil,
+                                skip_script_validation: nil, skip_tx_validation: nil,
+                                callback_url: nil, callback_token: nil, callback_batch: nil, **)
+          return Result::Success.new(data: []) if txs.empty?
+
+          body = JSON.generate(txs.map { |tx| { rawTx: ef_hex_with_fallback(tx) } })
+
+          extra_headers = build_broadcast_headers(
+            wait_for: wait_for,
+            skip_fee_validation: skip_fee_validation,
+            skip_script_validation: skip_script_validation,
+            skip_tx_validation: skip_tx_validation,
+            callback_url: callback_url || @callback_url,
+            callback_token: callback_token || @callback_token,
+            callback_batch: callback_batch
+          )
+
+          response = post_with_headers('/v1/txs', body, extra_headers)
+          parse_batch_broadcast_response(response)
+        end
+
+        # Override to always include XDeployment-ID on every ARC request.
+        def build_request(http_method, uri, body)
+          request = super
+          request['XDeployment-ID'] = @deployment_id
+          request
+        end
+
+        # Prefer Extended Format hex (BRC-30) so ARC can validate sighashes without
+        # fetching parent transactions. Falls back to plain raw-tx hex when any input
+        # lacks source_satoshis / source_locking_script.
+        def ef_hex_with_fallback(tx)
+          tx.to_ef_hex
+        rescue ArgumentError
+          tx.to_hex
+        end
+
+        # Build the hash of ARC-specific extra headers.
+        def build_broadcast_headers(wait_for:, skip_fee_validation:, skip_script_validation:,
+                                    skip_tx_validation:, callback_url:, callback_token:,
+                                    callback_batch:)
+          headers = { 'XDeployment-ID' => @deployment_id }
+          headers['X-WaitFor']              = wait_for                     if wait_for
+          headers['X-CallbackUrl']          = callback_url                 if callback_url
+          headers['X-CallbackToken']        = callback_token               if callback_token
+          headers['X-SkipFeeValidation']    = 'true'                       if skip_fee_validation
+          headers['X-SkipScriptValidation'] = 'true'                       if skip_script_validation
+          headers['X-SkipTxValidation']     = 'true'                       if skip_tx_validation
+          headers['X-CallbackBatch']        = 'true'                       if callback_batch
+          headers
+        end
+
+        # Perform a POST to the given path with a JSON body plus extra headers.
+        # Returns a Net::HTTPResponse-like object.
+        def post_with_headers(path, body, extra_headers)
+          uri     = URI("#{@base_url}#{path}")
+          request = build_request(:post, uri, body)
+          extra_headers.each { |k, v| request[k] = v }
+          execute(uri, request)
+        end
+
+        # Parse and validate a single-transaction ARC response.
+        def parse_single_broadcast_response(response)
+          code = response.code.to_i
+          body = safe_parse_json(response.body)
+
+          unless body.is_a?(Hash)
+            return Result::Error.new(
+              message: "HTTP #{code}",
+              retryable: retryable_code?(code),
+              metadata: { status_code: code }
+            )
+          end
+
+          unless (200..299).cover?(code)
+            return Result::Error.new(
+              message: body['detail'] || body['title'] || "HTTP #{code}",
+              retryable: retryable_code?(code),
+              metadata: { status_code: code, arc_status: body['txStatus'].to_s.upcase, txid: body['txid'] }
+            )
+          end
+
+          if rejected_status?(body)
+            return Result::Error.new(
+              message: body['detail'] || body['title'] || body['txStatus'],
+              retryable: false,
+              metadata: { status_code: code, arc_status: body['txStatus'].to_s.upcase, txid: body['txid'] }
+            )
+          end
+
+          unless body['txid']
+            return Result::Error.new(
+              message: 'ARC returned a malformed 2xx response',
+              retryable: false,
+              metadata: { status_code: code }
+            )
+          end
+
+          Result::Success.new(
+            data: arc_data_from(body),
+            metadata: { arc_status: body['txStatus'].to_s.upcase }
+          )
+        end
+
+        # Parse and validate a batch ARC response. HTTP-level errors return a
+        # single Result::Error; per-item rejections are embedded in the data array.
+        def parse_batch_broadcast_response(response)
+          code = response.code.to_i
+          body = safe_parse_json(response.body)
+
+          unless (200..299).cover?(code)
+            return Result::Error.new(
+              message: body.is_a?(Hash) ? (body['detail'] || body['title'] || "HTTP #{code}") : "HTTP #{code}",
+              retryable: retryable_code?(code),
+              metadata: { status_code: code }
+            )
+          end
+
+          unless body.is_a?(Array)
+            return Result::Error.new(
+              message: 'ARC returned a malformed batch response',
+              retryable: false,
+              metadata: { status_code: code }
+            )
+          end
+
+          items = body.map { |item| build_item_result(item) }
+          Result::Success.new(data: items, metadata: {})
+        end
+
+        # Build a per-item result for a batch response entry.
+        def build_item_result(item)
+          unless item.is_a?(Hash)
+            return Result::Error.new(
+              message: 'malformed batch item',
+              retryable: false,
+              metadata: {}
+            )
+          end
+
+          if rejected_status?(item)
+            Result::Error.new(
+              message: item['detail'] || item['title'] || item['txStatus'],
+              retryable: false,
+              metadata: { status_code: 200, arc_status: item['txStatus'].to_s.upcase, txid: item['txid'] }
+            )
+          elsif !item['txid']
+            Result::Error.new(
+              message: 'ARC returned a malformed 2xx response',
+              retryable: false,
+              metadata: { status_code: 200 }
+            )
+          else
+            Result::Success.new(
+              data: arc_data_from(item),
+              metadata: { arc_status: item['txStatus'].to_s.upcase }
+            )
+          end
+        end
+
+        # Escape hatch for get_tx_status: returns a normalised data hash using the
+        # same field set as broadcast responses rather than the raw parsed JSON.
+        # Also checks for rejection status and missing txid (malformed 2xx).
+        #
+        # @param txid [String] the transaction ID to query
+        # @return [Result::Success, Result::Error, Result::NotFound]
+        def call_get_tx_status(txid, **)
+          response = default_call(:get_tx_status, txid)
+          return response unless response.is_a?(Result::Success)
+
+          body = response.data
+
+          if rejected_status?(body)
+            return Result::Error.new(
+              message: body['detail'] || body['title'] || body['txStatus'],
+              retryable: false,
+              metadata: { arc_status: body['txStatus'].to_s.upcase, txid: body['txid'], status_code: 200 }
+            )
+          end
+
+          unless body['txid']
+            return Result::Error.new(
+              message: 'ARC returned a malformed 2xx response',
+              retryable: false,
+              metadata: { status_code: 200 }
+            )
+          end
+
+          Result::Success.new(
+            data: arc_data_from(body),
+            metadata: { arc_status: body['txStatus'].to_s.upcase }
+          )
+        end
+
+        # Build the normalised ARC data hash from a parsed JSON response body.
+        # Includes all 8 fields that BroadcastResponse expects.
+        #
+        # @param body [Hash] parsed ARC JSON response
+        # @return [Hash]
+        def arc_data_from(body)
+          {
+            txid: body['txid'],
+            tx_status: body['txStatus'],
+            message: body['title'],
+            extra_info: body['extraInfo'],
+            block_hash: body['blockHash'],
+            block_height: body['blockHeight'],
+            timestamp: body['timestamp'],
+            competing_txs: body['competingTxs']
+          }
+        end
+
+        # Determine whether a status code indicates a retryable failure.
+        def retryable_code?(code)
+          code == 429 || (500..599).cover?(code)
+        end
+
+        # Determine whether an ARC response body represents a rejected transaction.
+        # Case-insensitive match — the TypeScript reference SDK explicitly uppercases
+        # both fields before membership / substring checks. ARC has a documented
+        # history of emitting values outside its own OpenAPI enum, so case
+        # normalisation is the defensive choice.
+        def rejected_status?(body)
+          tx_status = body['txStatus'].to_s.upcase
+          return true if REJECTED_STATUSES.include?(tx_status)
+          return true if tx_status.include?(ORPHAN_MARKER)
+
+          extra_info = body['extraInfo'].to_s.upcase
+          return true if extra_info.include?(ORPHAN_MARKER)
+
+          false
+        end
+
+        # Parse JSON, returning a hash with a 'detail' key on parse failure.
+        # When the raw input is nil or empty the detail is nil (not an empty string).
+        def safe_parse_json(raw)
+          JSON.parse(raw.to_s)
+        rescue JSON::ParserError
+          { 'detail' => (raw.to_s.empty? ? nil : raw.to_s) }
+        end
+      end
+    end
+  end
+end