bsv-sdk 0.19.1 → 0.22.0

data/lib/bsv/wallet/serializer/prove_certificate.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +prove_certificate+ call (call byte 19).
+      #
+      # Args wire layout (matches go-sdk SerializeProveCertificateArgs):
+      #   [32 bytes: cert.type]
+      #   [33 bytes: cert.subject pubkey]
+      #   [32 bytes: cert.serial_number]
+      #   [33 bytes: cert.certifier pubkey]
+      #   [36 bytes: cert.revocation_outpoint]
+      #   [varint-int: cert.signature bytes] (0-length if nil)
+      #   [varint: field_count] per field: [varint-int name_bytes][varint-int value_bytes]
+      #   [varint: fields_to_reveal_count] per field: [varint-int name_bytes]
+      #   [33 bytes: verifier pubkey]
+      #   [privileged params]
+      #
+      # Result wire layout:
+      #   [varint: keyring_count] per entry: [varint-int key_bytes][varint-int base64 bytes]
+      module ProveCertificate
+        CERT_TYPE_SIZE = 32
+        SERIAL_SIZE    = 32
+        PUBKEY_SIZE    = 33
+
+        module_function
+
+        def serialize_args(args)
+          w = Wire::Writer.new
+          cert = args[:certificate] || {}
+
+          type_bytes = Base64.strict_decode64(cert[:type].to_s)
+          w.write_bytes(type_bytes.ljust(CERT_TYPE_SIZE, "\x00").byteslice(0, CERT_TYPE_SIZE))
+          w.write_bytes([cert[:subject].to_s].pack('H*'))
+
+          serial_bytes = Base64.strict_decode64(cert[:serial_number].to_s)
+          w.write_bytes(serial_bytes.ljust(SERIAL_SIZE, "\x00").byteslice(0, SERIAL_SIZE))
+          w.write_bytes([cert[:certifier].to_s].pack('H*'))
+
+          outpoint_str = cert[:revocation_outpoint].to_s
+          if outpoint_str.empty? || outpoint_str == '.'
+            w.write_outpoint(Certificate::NULL_TXID_HEX, 0)
+          else
+            txid_hex, vout = outpoint_str.split('.', 2)
+            w.write_outpoint(txid_hex.to_s, vout.to_i)
+          end
+
+          sig = cert[:signature]
+          if sig && !sig.to_s.empty?
+            w.write_int_bytes([sig.to_s].pack('H*'))
+          else
+            w.write_int_bytes(''.b)
+          end
+
+          fields = cert[:fields] || {}
+          w.write_varint(fields.length)
+          fields.keys.sort.each do |k|
+            w.write_int_bytes(k.b)
+            w.write_int_bytes(fields[k].to_s.b)
+          end
+
+          fields_to_reveal = args[:fields_to_reveal] || []
+          w.write_varint(fields_to_reveal.length)
+          fields_to_reveal.each { |f| w.write_int_bytes(f.to_s.b) }
+
+          w.write_bytes([args[:verifier].to_s].pack('H*'))
+
+          Common.write_privileged_params(w, args[:privileged], args[:privileged_reason])
+          w.buf
+        end
+
+        def deserialize_args(bytes)
+          r = Wire::Reader.new(bytes)
+
+          type_raw   = r.read_bytes(CERT_TYPE_SIZE)
+          subject    = r.read_bytes(PUBKEY_SIZE).unpack1('H*')
+          serial_raw = r.read_bytes(SERIAL_SIZE)
+          certifier  = r.read_bytes(PUBKEY_SIZE).unpack1('H*')
+
+          outpoint_data = r.read_outpoint
+          revocation_outpoint = "#{outpoint_data[:txid_hex]}.#{outpoint_data[:vout]}"
+
+          sig_bytes = r.read_int_bytes
+          signature = sig_bytes.empty? ? nil : sig_bytes.unpack1('H*')
+
+          field_count = r.read_varint
+          fields = {}
+          field_count.times do
+            k = r.read_int_bytes.force_encoding('UTF-8')
+            v = r.read_int_bytes.force_encoding('UTF-8')
+            fields[k] = v
+          end
+
+          fields_to_reveal_count = r.read_varint
+          fields_to_reveal = fields_to_reveal_count.times.map do
+            r.read_int_bytes.force_encoding('UTF-8')
+          end
+
+          verifier = r.read_bytes(PUBKEY_SIZE).unpack1('H*')
+          privileged, privileged_reason = Common.read_privileged_params(r)
+
+          {
+            certificate: {
+              type: Base64.strict_encode64(type_raw),
+              subject: subject,
+              serial_number: Base64.strict_encode64(serial_raw),
+              certifier: certifier,
+              revocation_outpoint: revocation_outpoint,
+              signature: signature,
+              fields: fields
+            },
+            fields_to_reveal: fields_to_reveal,
+            verifier: verifier,
+            privileged: privileged,
+            privileged_reason: privileged_reason
+          }
+        end
+
+        def serialize_result(result)
+          w = Wire::Writer.new
+          keyring = result[:keyring_for_verifier] || {}
+          w.write_varint(keyring.length)
+          keyring.keys.sort.each do |k|
+            w.write_int_bytes(k.to_s.b)
+            w.write_int_from_base64(keyring[k].to_s)
+          end
+          w.buf
+        end
+
+        def deserialize_result(bytes)
+          r = Wire::Reader.new(bytes)
+          count = r.read_varint
+          keyring = {}
+          count.times do
+            k = r.read_int_bytes.force_encoding('UTF-8')
+            keyring[k] = r.read_base64_int
+          end
+          { keyring_for_verifier: keyring }
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/relinquish_certificate.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +relinquish_certificate+ call (call byte 20).
+      #
+      # Args wire layout:
+      #   [32 bytes: type]
+      #   [32 bytes: serial_number]
+      #   [33 bytes: certifier pubkey]
+      #
+      # Result wire layout:
+      #   [empty — relinquished is implicit from the frame error byte]
+      module RelinquishCertificate
+        CERT_TYPE_SIZE = 32
+        SERIAL_SIZE    = 32
+        PUBKEY_SIZE    = 33
+
+        module_function
+
+        def serialize_args(args)
+          w = Wire::Writer.new
+          type_bytes = Base64.strict_decode64(args[:type].to_s)
+          w.write_bytes(type_bytes.ljust(CERT_TYPE_SIZE, "\x00").byteslice(0, CERT_TYPE_SIZE))
+          serial_bytes = Base64.strict_decode64(args[:serial_number].to_s)
+          w.write_bytes(serial_bytes.ljust(SERIAL_SIZE, "\x00").byteslice(0, SERIAL_SIZE))
+          w.write_bytes([args[:certifier].to_s].pack('H*'))
+          w.buf
+        end
+
+        def deserialize_args(bytes)
+          r = Wire::Reader.new(bytes)
+          type_raw   = r.read_bytes(CERT_TYPE_SIZE)
+          serial_raw = r.read_bytes(SERIAL_SIZE)
+          certifier  = r.read_bytes(PUBKEY_SIZE).unpack1('H*')
+          {
+            type: Base64.strict_encode64(type_raw),
+            serial_number: Base64.strict_encode64(serial_raw),
+            certifier: certifier
+          }
+        end
+
+        def serialize_result(_result)
+          ''.b
+        end
+
+        def deserialize_result(_bytes)
+          { relinquished: true }
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/relinquish_output.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +relinquish_output+ call (call byte 7).
+      #
+      # Args wire layout:
+      #   [varint-str: basket]
+      #   [32-byte wire txid][varint vout]
+      #
+      # Result wire layout:
+      #   [empty — relinquished is implicit from the frame error byte]
+      module RelinquishOutput
+        module_function
+
+        def serialize_args(args)
+          Wire::Validation.outpoint_string!('output', args[:output].to_s)
+          txid_hex, vout = args[:output].to_s.split('.', 2)
+          w = Wire::Writer.new
+          w.write_str_with_varint_len(args.fetch(:basket, ''))
+          w.write_outpoint(txid_hex, vout.to_i)
+          w.buf
+        end
+
+        def deserialize_args(bytes)
+          r = Wire::Reader.new(bytes)
+          basket = r.read_str_with_varint_len
+          outpoint_data = r.read_outpoint
+          output = "#{outpoint_data[:txid_hex]}.#{outpoint_data[:vout]}"
+          { basket: basket, output: output }
+        end
+
+        def serialize_result(_result)
+          ''.b
+        end
+
+        def deserialize_result(_bytes)
+          { relinquished: true }
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/reveal_counterparty_key_linkage.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +reveal_counterparty_key_linkage+ call (call byte 9).
+      #
+      # Port of go-sdk/wallet/serializer/reveal_counterparty_key_linkage.go.
+      module RevealCounterpartyKeyLinkage
+        PUBKEY_SIZE = 33
+
+        # Args wire layout:
+        #   [privileged params]
+        #   [33 bytes: counterparty compressed pubkey]
+        #   [33 bytes: verifier compressed pubkey]
+        module Args
+          module_function
+
+          def serialize(args)
+            counterparty = args[:counterparty]
+            verifier     = args[:verifier]
+            raise BSV::Wallet::InvalidParameterError.new('counterparty', 'a 33-byte binary pubkey or 66-char hex') unless counterparty
+            raise BSV::Wallet::InvalidParameterError.new('verifier', 'a 33-byte binary pubkey or 66-char hex') unless verifier
+
+            w = BSV::Wallet::Wire::Writer.new
+            Common.write_privileged_params(w, args[:privileged], args[:privileged_reason])
+            w.write_bytes(pubkey_bytes(counterparty))
+            w.write_bytes(pubkey_bytes(verifier))
+            w.buf
+          end
+
+          def deserialize(bytes)
+            r = BSV::Wallet::Wire::Reader.new(bytes)
+            privileged, reason = Common.read_privileged_params(r)
+            counterparty = r.read_bytes(PUBKEY_SIZE)
+            verifier     = r.read_bytes(PUBKEY_SIZE)
+            {
+              privileged: privileged,
+              privileged_reason: reason,
+              counterparty: counterparty,
+              verifier: verifier
+            }
+          end
+
+          def pubkey_bytes(value)
+            return value.b if value.is_a?(String) && value.bytesize == PUBKEY_SIZE
+
+            [value.to_s].pack('H*')
+          end
+          private_class_method :pubkey_bytes
+        end
+
+        # Result wire layout:
+        #   [33 bytes: prover pubkey]
+        #   [33 bytes: verifier pubkey]
+        #   [33 bytes: counterparty pubkey]
+        #   [VarInt revelation_time_len][revelation_time bytes]
+        #   [VarInt encrypted_linkage_len][encrypted_linkage bytes]
+        #   [VarInt encrypted_linkage_proof_len][encrypted_linkage_proof bytes]
+        module Result
+          module_function
+
+          def serialize(result)
+            w = BSV::Wallet::Wire::Writer.new
+            w.write_bytes(pubkey_bytes(result[:prover]))
+            w.write_bytes(pubkey_bytes(result[:verifier]))
+            w.write_bytes(pubkey_bytes(result[:counterparty]))
+            w.write_str_with_varint_len(result[:revelation_time].to_s)
+            encrypted_linkage = Common.to_binary(result[:encrypted_linkage])
+            w.write_varint(encrypted_linkage.bytesize)
+            w.write_bytes(encrypted_linkage)
+            encrypted_linkage_proof = Common.to_binary(result[:encrypted_linkage_proof])
+            w.write_varint(encrypted_linkage_proof.bytesize)
+            w.write_bytes(encrypted_linkage_proof)
+            w.buf
+          end
+
+          def deserialize(bytes)
+            r = BSV::Wallet::Wire::Reader.new(bytes)
+            prover       = r.read_bytes(PUBKEY_SIZE)
+            verifier     = r.read_bytes(PUBKEY_SIZE)
+            counterparty = r.read_bytes(PUBKEY_SIZE)
+            revelation_time = r.read_str_with_varint_len
+            el_len = r.read_varint
+            encrypted_linkage = r.read_bytes(el_len)
+            elp_len = r.read_varint
+            encrypted_linkage_proof = r.read_bytes(elp_len)
+            {
+              prover: prover,
+              verifier: verifier,
+              counterparty: counterparty,
+              revelation_time: revelation_time,
+              encrypted_linkage: encrypted_linkage,
+              encrypted_linkage_proof: encrypted_linkage_proof
+            }
+          end
+
+          def pubkey_bytes(value)
+            return value.b if value.is_a?(String) && value.bytesize == PUBKEY_SIZE
+
+            [value.to_s].pack('H*')
+          end
+          private_class_method :pubkey_bytes
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/reveal_specific_key_linkage.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 wire codec for the +reveal_specific_key_linkage+ call (call byte 10).
+      #
+      # Port of go-sdk/wallet/serializer/reveal_specific_key_linkage.go.
+      module RevealSpecificKeyLinkage
+        PUBKEY_SIZE = 33
+
+        # Args wire layout:
+        #   [key-related params: protocol + key_id + counterparty + privileged]
+        #   [33 bytes: verifier compressed pubkey]
+        module Args
+          module_function
+
+          def serialize(args)
+            verifier = args[:verifier]
+            raise BSV::Wallet::InvalidParameterError.new('verifier', 'a 33-byte binary pubkey or 66-char hex') unless verifier
+
+            w = BSV::Wallet::Wire::Writer.new
+            Common.write_key_related_params(
+              w,
+              protocol_id: args[:protocol_id],
+              key_id: args[:key_id],
+              counterparty: args[:counterparty],
+              privileged: args[:privileged],
+              privileged_reason: args[:privileged_reason]
+            )
+            w.write_bytes(pubkey_bytes(verifier))
+            w.buf
+          end
+
+          def deserialize(bytes)
+            r = BSV::Wallet::Wire::Reader.new(bytes)
+            params   = Common.read_key_related_params(r)
+            verifier = r.read_bytes(PUBKEY_SIZE)
+            params.merge(verifier: verifier)
+          end
+
+          def pubkey_bytes(value)
+            return value.b if value.is_a?(String) && value.bytesize == PUBKEY_SIZE
+
+            [value.to_s].pack('H*')
+          end
+          private_class_method :pubkey_bytes
+        end
+
+        # Result wire layout:
+        #   [33 bytes: prover pubkey]
+        #   [33 bytes: verifier pubkey]
+        #   [33 bytes: counterparty pubkey]
+        #   [1 byte: security_level][VarInt protocol_name_len][protocol_name bytes]
+        #   [VarInt key_id_len][key_id bytes]
+        #   [VarInt encrypted_linkage_len][encrypted_linkage bytes]
+        #   [VarInt encrypted_linkage_proof_len][encrypted_linkage_proof bytes]
+        #   [1 byte: proof_type]
+        module Result
+          module_function
+
+          def serialize(result)
+            w = BSV::Wallet::Wire::Writer.new
+            w.write_bytes(pubkey_bytes(result[:prover]))
+            w.write_bytes(pubkey_bytes(result[:verifier]))
+            w.write_bytes(pubkey_bytes(result[:counterparty]))
+            Common.write_protocol(w, result[:protocol_id])
+            key_id_bytes = result[:key_id].to_s.b
+            w.write_varint(key_id_bytes.bytesize)
+            w.write_bytes(key_id_bytes)
+            encrypted_linkage = Common.to_binary(result[:encrypted_linkage])
+            w.write_varint(encrypted_linkage.bytesize)
+            w.write_bytes(encrypted_linkage)
+            encrypted_linkage_proof = Common.to_binary(result[:encrypted_linkage_proof])
+            w.write_varint(encrypted_linkage_proof.bytesize)
+            w.write_bytes(encrypted_linkage_proof)
+            w.write_byte(result[:proof_type].to_i)
+            w.buf
+          end
+
+          def deserialize(bytes)
+            r = BSV::Wallet::Wire::Reader.new(bytes)
+            prover       = r.read_bytes(PUBKEY_SIZE)
+            verifier     = r.read_bytes(PUBKEY_SIZE)
+            counterparty = r.read_bytes(PUBKEY_SIZE)
+            protocol_id  = Common.read_protocol(r)
+            key_id_len   = r.read_varint
+            key_id       = r.read_bytes(key_id_len).force_encoding('UTF-8')
+            el_len = r.read_varint
+            encrypted_linkage = r.read_bytes(el_len)
+            elp_len = r.read_varint
+            encrypted_linkage_proof = r.read_bytes(elp_len)
+            proof_type = r.read_byte
+            {
+              prover: prover,
+              verifier: verifier,
+              counterparty: counterparty,
+              protocol_id: protocol_id,
+              key_id: key_id,
+              encrypted_linkage: encrypted_linkage,
+              encrypted_linkage_proof: encrypted_linkage_proof,
+              proof_type: proof_type
+            }
+          end
+
+          def pubkey_bytes(value)
+            return value.b if value.is_a?(String) && value.bytesize == PUBKEY_SIZE
+
+            [value.to_s].pack('H*')
+          end
+          private_class_method :pubkey_bytes
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/sign_action_args.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 serialiser for sign_action args (call byte 2).
+      #
+      # Wire layout (port of go-sdk/wallet/serializer/sign_action_args.go):
+      #   [varint]     spends count
+      #   For each spend (sorted by input_index):
+      #     [varint]   input_index
+      #     [int_bytes] unlocking_script
+      #     [optional_uint32] sequence_number
+      #   [int_bytes]  reference
+      #   [1 byte]     options present flag (0=absent, 1=present)
+      #   If options present:
+      #     [optional_bool] accept_delayed_broadcast
+      #     [optional_bool] return_txid_only
+      #     [optional_bool] no_send
+      #     [txid_slice]       send_with
+      module SignActionArgs
+        module_function
+
+        # @param args [Hash]
+        # @return [String] binary
+        def serialize(args)
+          w = Wire::Writer.new
+
+          spends = args[:spends] || {}
+          w.write_varint(spends.length)
+          spends.keys.sort.each do |idx|
+            spend = spends[idx]
+            w.write_varint(idx)
+            w.write_int_bytes(spend[:unlocking_script])
+            w.write_optional_uint32(spend[:sequence_number])
+          end
+
+          w.write_int_bytes(args[:reference])
+
+          opts = args[:options]
+          if opts
+            w.write_byte(1)
+            w.write_optional_bool(opts[:accept_delayed_broadcast])
+            w.write_optional_bool(opts[:return_txid_only])
+            w.write_optional_bool(opts[:no_send])
+            w.write_txid_slice(opts[:send_with])
+          else
+            w.write_byte(0)
+          end
+
+          w.buf
+        end
+
+        # @param bytes [String] binary
+        # @return [Hash]
+        def deserialize(bytes)
+          r = Wire::Reader.new(bytes)
+
+          spend_count = r.read_varint
+          spends = {}
+          spend_count.times do
+            idx    = r.read_varint
+            script = r.read_int_bytes
+            seq    = r.read_optional_uint32
+            spend  = { unlocking_script: script }
+            spend[:sequence_number] = seq unless seq.nil?
+            spends[idx] = spend
+          end
+
+          reference = r.read_int_bytes
+
+          options_present = r.read_byte
+          options = if options_present == 1
+                      opts = {}
+                      v = r.read_optional_bool
+                      opts[:accept_delayed_broadcast] = v unless v.nil?
+                      v = r.read_optional_bool
+                      opts[:return_txid_only] = v unless v.nil?
+                      v = r.read_optional_bool
+                      opts[:no_send] = v unless v.nil?
+                      sw = r.read_txid_slice
+                      opts[:send_with] = sw unless sw.nil?
+                      opts
+                    end
+
+          result = { spends: spends }
+          result[:reference] = reference unless reference.nil? || reference.empty?
+          result[:options]   = options   unless options.nil?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/sign_action_result.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 serialiser for sign_action result (call byte 2).
+      #
+      # Wire layout (port of go-sdk/wallet/serializer/sign_action_result.go):
+      #   [flag + 32 bytes] txid with flag byte: 0=absent, 1=present (wire-order)
+      #   [flag + int_bytes] tx (BEEF bytes) with flag byte: 0=absent, 1=present + varint_len
+      #   [send_with_results] varint count + txid (32 bytes) + status_byte each
+      module SignActionResult
+        module_function
+
+        # @param result [Hash]
+        # @return [String] binary
+        def serialize(result)
+          w = Wire::Writer.new
+
+          txid_bytes = result[:txid] ? [result[:txid]].pack('H*').reverse : nil
+          w.write_optional_bytes_with_flag(txid_bytes, fixed_size: 32)
+          w.write_optional_bytes_with_flag(result[:tx])
+
+          Common.write_send_with_results(w, result[:send_with_results])
+
+          w.buf
+        end
+
+        # @param bytes [String] binary
+        # @return [Hash]
+        def deserialize(bytes)
+          r = Wire::Reader.new(bytes)
+
+          txid_raw = r.read_optional_bytes_with_flag(fixed_size: 32)
+          txid_hex = txid_raw&.reverse&.unpack1('H*')
+          tx       = r.read_optional_bytes_with_flag
+
+          send_with_results = Common.read_send_with_results(r)
+
+          result = {}
+          result[:txid]              = txid_hex          unless txid_hex.nil?
+          result[:tx]                = tx                unless tx.nil?
+          result[:send_with_results] = send_with_results unless send_with_results.nil?
+          result
+        end
+      end
+    end
+  end
+end

data/lib/bsv/wallet/serializer/status.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module BSV
+  module Wallet
+    module Serializer
+      # BRC-103 serialisers for is_authenticated (call byte 23) and
+      # wait_for_authentication (call byte 24).
+      #
+      # Both calls take no args payload (originator is in the frame header).
+      #
+      # Result wire format:
+      #   is_authenticated:        [1 byte] 0x01 = true, 0x00 = false
+      #   wait_for_authentication: empty payload → always returns authenticated: true
+      #
+      # Port of go-sdk/wallet/serializer/authenticated.go.
+      module IsAuthenticated
+        module Args
+          module_function
+
+          def serialize(_args = {})
+            ''.b
+          end
+
+          def deserialize(_bytes)
+            {}
+          end
+        end
+
+        module Result
+          module_function
+
+          # @param result [Hash] { authenticated: Boolean }
+          # @return [String] 1-byte binary
+          def serialize(result)
+            [result[:authenticated] ? 1 : 0].pack('C')
+          end
+
+          # @param bytes [String] binary — must be exactly 1 byte
+          # @return [Hash] { authenticated: Boolean }
+          def deserialize(bytes)
+            data = bytes.b
+            unless data.bytesize == 1
+              raise BSV::Wallet::InvalidParameterError.new(
+                'is_authenticated result',
+                'exactly 1 byte'
+              )
+            end
+
+            { authenticated: data.getbyte(0) == 1 }
+          end
+        end
+      end
+
+      module WaitForAuthentication
+        module Args
+          module_function
+
+          def serialize(_args = {})
+            ''.b
+          end
+
+          def deserialize(_bytes)
+            {}
+          end
+        end
+
+        module Result
+          module_function
+
+          # @param _result [Hash] ignored — always serialises as empty payload
+          # @return [String] empty binary
+          def serialize(_result = {})
+            ''.b
+          end
+
+          # @param _bytes [String] ignored — always returns authenticated: true
+          # @return [Hash] { authenticated: true }
+          def deserialize(_bytes = nil)
+            { authenticated: true }
+          end
+        end
+      end
+    end
+  end
+end