bsv-sdk 0.4.0 → 0.5.0

data/lib/bsv/identity/identity_parser.rb

@@ -0,0 +1,247 @@
+# frozen_string_literal: true
+
+module BSV
+  module Identity
+    # Parses an {IdentityCertificate} into a {DisplayableIdentity} suitable for
+    # presentation in a user interface.
+    #
+    # Handles all 9 well-known certificate types (xCert, discordCert, phoneCert,
+    # emailCert, identiCert, registrant, coolCert, anyone, self) with type-specific
+    # field extraction that matches the TS SDK implementation exactly. Unknown
+    # certificate types fall through to a generic field-name heuristic.
+    module IdentityParser
+      # Well-known avatar opaque strings used by specific certificate types.
+      EMAIL_AVATAR  = 'XUTZxep7BBghAJbSBwTjNfmcsDdRFs5EaGEgkESGSgjJVYgMEizu'
+      PHONE_AVATAR  = 'XUTLxtX3ELNUwRhLwL7kWNGbdnFM8WG2eSLv84J7654oH8HaJWrU'
+      ANYONE_AVATAR = 'XUT4bpQ6cpBaXi1oMzZsXfpkWGbtp2JTUYAoN7PzhStFJ6wLfoeR'
+      SELF_AVATAR   = 'XUT9jHGk2qace148jeCX5rDsMftkSGYKmigLwU2PLLBc7Hm63VYR'
+      BADGE_ICON    = 'XUUV39HVPkpmMzYNTx7rpKzJvXfeiVyQWg2vfSpjBAuhunTCA9uG'
+
+      # Parses an {IdentityCertificate} and returns a {DisplayableIdentity}.
+      #
+      # @param identity_certificate [IdentityCertificate]
+      # @return [DisplayableIdentity]
+      def self.parse(identity_certificate)
+        fields       = identity_certificate.decrypted_fields
+        certifier    = identity_certificate.certifier_info
+        type_b64     = identity_certificate.certificate[:type]
+
+        name, avatar_url, badge_label, badge_icon_url, badge_click_url =
+          extract_fields(type_b64, fields, certifier)
+
+        subject       = identity_certificate.certificate[:subject].to_s
+        identity_key  = subject
+        abbreviated   = abbreviated_key(subject)
+
+        DisplayableIdentity.new(
+          name: name,
+          avatar_url: avatar_url,
+          abbreviated_key: abbreviated,
+          identity_key: identity_key,
+          badge_icon_url: badge_icon_url,
+          badge_label: badge_label,
+          badge_click_url: badge_click_url
+        )
+      end
+
+      # -----------------------------------------------------------------------
+      # Private helpers
+      # -----------------------------------------------------------------------
+
+      # Returns true when +val+ is a non-nil, non-empty string.
+      def self.present?(val)
+        val.is_a?(String) && !val.empty?
+      end
+      private_class_method :present?
+
+      # Returns the first 10 characters of the subject followed by '...',
+      # or the subject itself when it is shorter than 10 characters.
+      def self.abbreviated_key(subject)
+        return '' unless present?(subject)
+        return subject if subject.length < 10
+
+        "#{subject[0, 10]}..."
+      end
+      private_class_method :abbreviated_key
+
+      # Dispatches to per-type extraction logic and returns a 5-element array:
+      # [name, avatar_url, badge_label, badge_icon_url, badge_click_url]
+      def self.extract_fields(type_b64, fields, certifier)
+        types = Constants::KNOWN_IDENTITY_TYPES
+
+        case type_b64
+        when types[:x_cert]       then parse_x_cert(fields, certifier)
+        when types[:discord_cert] then parse_discord_cert(fields, certifier)
+        when types[:email_cert]   then parse_email_cert(fields, certifier)
+        when types[:phone_cert]   then parse_phone_cert(fields, certifier)
+        when types[:identi_cert]  then parse_identi_cert(fields, certifier)
+        when types[:registrant]   then parse_registrant(fields, certifier)
+        when types[:cool_cert]    then parse_cool_cert(fields)
+        when types[:anyone]       then parse_anyone
+        when types[:self]         then parse_self
+        else                           parse_generic(type_b64, fields, certifier)
+        end
+      end
+      private_class_method :extract_fields
+
+      # -- Known-type parsers --------------------------------------------------
+
+      def self.parse_x_cert(fields, certifier)
+        name          = fields['userName']
+        avatar_url    = fields['profilePhoto']
+        badge_label   = "X account certified by #{certifier&.name}"
+        badge_icon    = certifier&.icon_url
+        badge_click   = 'https://socialcert.net'
+        [name, avatar_url, badge_label, badge_icon, badge_click]
+      end
+      private_class_method :parse_x_cert
+
+      def self.parse_discord_cert(fields, certifier)
+        name          = fields['userName']
+        avatar_url    = fields['profilePhoto']
+        badge_label   = "Discord account certified by #{certifier&.name}"
+        badge_icon    = certifier&.icon_url
+        badge_click   = 'https://socialcert.net'
+        [name, avatar_url, badge_label, badge_icon, badge_click]
+      end
+      private_class_method :parse_discord_cert
+
+      def self.parse_email_cert(fields, certifier)
+        name        = fields['email']
+        avatar_url  = EMAIL_AVATAR
+        badge_label = "Email certified by #{certifier&.name}"
+        badge_icon  = certifier&.icon_url
+        badge_click = 'https://socialcert.net'
+        [name, avatar_url, badge_label, badge_icon, badge_click]
+      end
+      private_class_method :parse_email_cert
+
+      def self.parse_phone_cert(fields, certifier)
+        name        = fields['phoneNumber']
+        avatar_url  = PHONE_AVATAR
+        badge_label = "Phone certified by #{certifier&.name}"
+        badge_icon  = certifier&.icon_url
+        badge_click = 'https://socialcert.net'
+        [name, avatar_url, badge_label, badge_icon, badge_click]
+      end
+      private_class_method :parse_phone_cert
+
+      def self.parse_identi_cert(fields, certifier)
+        first = fields['firstName']
+        last  = fields['lastName']
+        name  = if present?(first) && present?(last)
+                  "#{first} #{last}"
+                elsif present?(first)
+                  first
+                elsif present?(last)
+                  last
+                end
+        avatar_url  = fields['profilePhoto']
+        badge_label = "Government ID certified by #{certifier&.name}"
+        badge_icon  = certifier&.icon_url
+        badge_click = 'https://identicert.me'
+        [name, avatar_url, badge_label, badge_icon, badge_click]
+      end
+      private_class_method :parse_identi_cert
+
+      def self.parse_registrant(fields, certifier)
+        name        = fields['name']
+        avatar_url  = fields['icon']
+        badge_label = "Entity certified by #{certifier&.name}"
+        badge_icon  = certifier&.icon_url
+        badge_click = 'https://projectbabbage.com/docs/registrant'
+        [name, avatar_url, badge_label, badge_icon, badge_click]
+      end
+      private_class_method :parse_registrant
+
+      def self.parse_cool_cert(fields)
+        name = fields['cool'] == 'true' ? 'Cool Person!' : 'Not cool!'
+        [name, nil, nil, nil, nil]
+      end
+      private_class_method :parse_cool_cert
+
+      def self.parse_anyone
+        [
+          'Anyone',
+          ANYONE_AVATAR,
+          'Represents the ability for anyone to access this information.',
+          BADGE_ICON,
+          'https://projectbabbage.com/docs/anyone-identity'
+        ]
+      end
+      private_class_method :parse_anyone
+
+      def self.parse_self
+        [
+          'You',
+          SELF_AVATAR,
+          'Represents your ability to access this information.',
+          BADGE_ICON,
+          'https://projectbabbage.com/docs/self-identity'
+        ]
+      end
+      private_class_method :parse_self
+
+      # -- Generic fallback ---------------------------------------------------
+
+      # Attempts to extract identity fields from an unknown certificate type by
+      # checking commonly used field names in order of preference.
+      def self.parse_generic(type_b64, fields, certifier)
+        default = Constants::DEFAULT_IDENTITY
+
+        name      = resolve_generic_name(fields, default)
+        avatar    = resolve_generic_avatar(fields, default)
+        b_label   = resolve_generic_badge_label(type_b64, certifier, default)
+        b_icon    = present?(certifier&.icon_url) ? certifier.icon_url : default.badge_icon_url
+        b_click   = default.badge_click_url
+
+        [name, avatar, b_label, b_icon, b_click]
+      end
+      private_class_method :parse_generic
+
+      def self.resolve_generic_name(fields, default)
+        return fields['name']     if present?(fields['name'])
+        return fields['userName'] if present?(fields['userName'])
+
+        full_name = compose_full_name(fields)
+        return full_name if present?(full_name)
+
+        return fields['email'] if present?(fields['email'])
+
+        default.name
+      end
+      private_class_method :resolve_generic_name
+
+      def self.compose_full_name(fields)
+        first = fields['firstName']
+        last  = fields['lastName']
+
+        if present?(first) && present?(last)
+          "#{first} #{last}"
+        elsif present?(first)
+          first
+        elsif present?(last)
+          last
+        end
+      end
+      private_class_method :compose_full_name
+
+      def self.resolve_generic_avatar(fields, default)
+        return fields['profilePhoto'] if present?(fields['profilePhoto'])
+        return fields['avatar']       if present?(fields['avatar'])
+        return fields['icon']         if present?(fields['icon'])
+        return fields['photo']        if present?(fields['photo'])
+
+        default.avatar_url
+      end
+      private_class_method :resolve_generic_avatar
+
+      def self.resolve_generic_badge_label(type_b64, certifier, default)
+        return "#{type_b64} certified by #{certifier.name}" if present?(certifier&.name)
+
+        default.badge_label
+      end
+      private_class_method :resolve_generic_badge_label
+    end
+  end
+end

data/lib/bsv/identity/types.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module BSV
+  module Identity
+    # Formatted identity information for display in user interfaces.
+    class DisplayableIdentity
+      # @return [String] human-readable display name
+      attr_reader :name
+
+      # @return [String] URL or opaque string for the identity avatar image
+      attr_reader :avatar_url
+
+      # @return [String] shortened version of the identity key for compact display
+      attr_reader :abbreviated_key
+
+      # @return [String] full identity public key
+      attr_reader :identity_key
+
+      # @return [String, nil] URL or opaque string for a trust badge icon
+      attr_reader :badge_icon_url
+
+      # @return [String, nil] human-readable badge label (e.g. certifier name)
+      attr_reader :badge_label
+
+      # @return [String, nil] URL to open when the badge is clicked
+      attr_reader :badge_click_url
+
+      # @param name [String]
+      # @param avatar_url [String]
+      # @param abbreviated_key [String]
+      # @param identity_key [String]
+      # @param badge_icon_url [String, nil]
+      # @param badge_label [String, nil]
+      # @param badge_click_url [String, nil]
+      def initialize(name:, avatar_url:, abbreviated_key:, identity_key:,
+                     badge_icon_url: nil, badge_label: nil, badge_click_url: nil)
+        @name            = name
+        @avatar_url      = avatar_url
+        @abbreviated_key = abbreviated_key
+        @identity_key    = identity_key
+        @badge_icon_url  = badge_icon_url
+        @badge_label     = badge_label
+        @badge_click_url = badge_click_url
+      end
+    end
+
+    # Certifier metadata attached to a certificate for display purposes.
+    class CertifierInfo
+      # @return [String] certifier's display name
+      attr_reader :name
+
+      # @return [String, nil] URL or opaque string for the certifier's icon
+      attr_reader :icon_url
+
+      # @param name [String]
+      # @param icon_url [String, nil]
+      def initialize(name:, icon_url: nil)
+        @name     = name
+        @icon_url = icon_url
+      end
+    end
+
+    # A certificate together with its decrypted field values and optional certifier info.
+    class IdentityCertificate
+      # @return [Hash] raw certificate data (type, subject, fields, etc.)
+      attr_reader :certificate
+
+      # @return [Hash] certificate field values after decryption
+      attr_reader :decrypted_fields
+
+      # @return [CertifierInfo, nil] display information about the certifier
+      attr_reader :certifier_info
+
+      # @param certificate [Hash]
+      # @param decrypted_fields [Hash]
+      # @param certifier_info [CertifierInfo, nil]
+      def initialize(certificate:, decrypted_fields:, certifier_info: nil)
+        @certificate      = certificate
+        @decrypted_fields = decrypted_fields
+        @certifier_info   = certifier_info
+      end
+    end
+
+    # Configuration options for an IdentityClient instance.
+    class ClientOptions
+      # @return [Array] BRC-42/43 wallet protocol identifier, e.g. [1, 'identity']
+      attr_reader :protocol_id
+
+      # @return [String] key identifier within the protocol
+      attr_reader :key_id
+
+      # @return [Integer] token amount in satoshis for identity operations
+      attr_reader :token_amount
+
+      # @return [Integer] output index within the token transaction
+      attr_reader :output_index
+
+      # @param protocol_id [Array]
+      # @param key_id [String]
+      # @param token_amount [Integer]
+      # @param output_index [Integer]
+      def initialize(protocol_id:, key_id:, token_amount:, output_index:)
+        @protocol_id  = protocol_id
+        @key_id       = key_id
+        @token_amount = token_amount
+        @output_index = output_index
+      end
+
+      # Default options matching the TS SDK DEFAULT_IDENTITY_CLIENT_OPTIONS constant.
+      DEFAULT = new(
+        protocol_id: [1, 'identity'].freeze,
+        key_id: '1',
+        token_amount: 1,
+        output_index: 0
+      ).freeze
+    end
+  end
+end

data/lib/bsv/identity.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module BSV
+  # Identity module for BSV blockchain.
+  #
+  # Provides data structures and constants for resolving and displaying
+  # identity information associated with BSV public keys, backed by
+  # verifiable certificates managed through the BSV overlay network.
+  module Identity
+    autoload :DisplayableIdentity,  'bsv/identity/types'
+    autoload :CertifierInfo,        'bsv/identity/types'
+    autoload :IdentityCertificate,  'bsv/identity/types'
+    autoload :ClientOptions,        'bsv/identity/types'
+    autoload :Constants,            'bsv/identity/constants'
+    autoload :IdentityParser,       'bsv/identity/identity_parser'
+    autoload :Client,               'bsv/identity/client'
+  end
+end

data/lib/bsv/overlay/admin_token_template.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+module BSV
+  module Overlay
+    # Script template for creating, unlocking, and decoding SHIP and SLAP advertisements.
+    #
+    # SHIP (Service Host Interconnect) and SLAP (Service Lookup Availability)
+    # tokens are PushDrop scripts containing four data fields:
+    #
+    #   Field 0: protocol string — 'SHIP' or 'SLAP'
+    #   Field 1: identity key — 33-byte compressed public key (binary)
+    #   Field 2: domain — UTF-8 string
+    #   Field 3: topic or service name — UTF-8 string
+    #
+    # The locking script includes a fifth field containing a wallet signature
+    # over the concatenation of fields 0–3, which authenticates the token at
+    # creation time. The lock is secured with a P2PK condition derived from the
+    # wallet using BRC-42/43 key derivation at security level 2.
+    #
+    # Script layout (lock-after PushDrop format):
+    #
+    #   <protocol> <identity_key> <domain> <topic> <wallet_sig>
+    #   OP_2DROP OP_2DROP OP_DROP
+    #   <derived_pubkey> OP_CHECKSIG
+    #
+    # @example Lock a SHIP advertisement
+    #   wallet = BSV::Wallet::ProtoWallet.new(private_key)
+    #   template = BSV::Overlay::AdminTokenTemplate.new(wallet)
+    #   locking_script = template.lock('SHIP', 'myhost.example.com', 'tm_payments')
+    #   decoded = BSV::Overlay::AdminTokenTemplate.decode(locking_script)
+    #   decoded.identity_key  # => hex public key of the wallet
+    class AdminTokenTemplate
+      # Decoded representation of a SHIP or SLAP advertisement.
+      class Advertisement
+        # @return [String] protocol identifier — 'SHIP' or 'SLAP'
+        attr_reader :protocol
+
+        # @return [String] hex-encoded compressed public key (33 bytes)
+        attr_reader :identity_key
+
+        # @return [String] domain where the topic or service is available
+        attr_reader :domain
+
+        # @return [String] topic or service name being advertised
+        attr_reader :topic_or_service
+
+        # @param protocol [String]
+        # @param identity_key [String]
+        # @param domain [String]
+        # @param topic_or_service [String]
+        def initialize(protocol:, identity_key:, domain:, topic_or_service:)
+          @protocol = protocol
+          @identity_key = identity_key
+          @domain = domain
+          @topic_or_service = topic_or_service
+        end
+      end
+
+      # Unlocker returned by {#unlock}.
+      #
+      # Satisfies the P2PK condition in a PushDrop locking script by signing
+      # the BIP-143 sighash of the spending transaction using the wallet's
+      # derived key for the appropriate protocol.
+      class Unlocker
+        # Estimated length of a P2PK unlocking script: 1 push opcode + up to
+        # 72 DER-encoded signature bytes + 1 sighash byte = 73 bytes total.
+        ESTIMATED_LENGTH = 73
+
+        # @param wallet [#create_signature] BRC-100 wallet interface
+        # @param protocol_id [Array] two-element array [security_level, protocol_name]
+        # @param originator [String, nil] optional originator domain
+        def initialize(wallet, protocol_id, originator)
+          @wallet = wallet
+          @protocol_id = protocol_id
+          @originator = originator
+        end
+
+        # Generate the unlocking script for the given input.
+        #
+        # Computes the BIP-143 sighash (SIGHASH_ALL|FORK_ID) and signs it
+        # using the wallet's derived key for the protocol.
+        #
+        # @param tx [BSV::Transaction::Transaction] the spending transaction
+        # @param input_index [Integer] which input to sign
+        # @return [BSV::Script::Script] the unlocking script
+        def sign(tx, input_index)
+          sighash_type = BSV::Transaction::Sighash::ALL_FORK_ID
+          hash = tx.sighash(input_index, sighash_type)
+          hash_bytes = hash.unpack('C*')
+
+          sig_args = { hash_to_directly_sign: hash_bytes, protocol_id: @protocol_id, key_id: '1', counterparty: 'self' }
+          sig_args[:originator] = @originator if @originator
+          result = @wallet.create_signature(sig_args)
+
+          sig_bytes = result[:signature].pack('C*')
+          sig_with_hashtype = sig_bytes + [sighash_type].pack('C')
+          BSV::Script::Script.pushdrop_unlock(
+            BSV::Script::Script.p2pk_unlock(sig_with_hashtype)
+          )
+        end
+
+        # Estimated byte length of the unlocking script.
+        #
+        # @param _tx [BSV::Transaction::Transaction] unused
+        # @param _input_index [Integer] unused
+        # @return [Integer]
+        def estimated_length(_tx, _input_index)
+          ESTIMATED_LENGTH
+        end
+      end
+
+      VALID_PROTOCOLS = [Constants::PROTOCOL_SHIP, Constants::PROTOCOL_SLAP].freeze
+      private_constant :VALID_PROTOCOLS
+
+      # Decode a SHIP or SLAP advertisement from a PushDrop locking script.
+      #
+      # @param script [BSV::Script::Script, nil] the locking script to decode
+      # @return [Advertisement, nil] the decoded advertisement, or +nil+ if the
+      #   script is nil, empty, or not a PushDrop script
+      # @raise [BSV::Overlay::OverlayError] if the script is PushDrop but has
+      #   fewer than 4 fields, or if the protocol field is not 'SHIP' or 'SLAP'
+      def self.decode(script)
+        return nil if script.nil? || script.bytes.empty?
+        return nil unless script.pushdrop?
+
+        fields = script.pushdrop_fields
+        raise OverlayError, 'Invalid SHIP/SLAP advertisement: expected at least 4 fields' if fields.length < 4
+
+        protocol = fields[0].force_encoding('UTF-8')
+        raise OverlayError, "Invalid SHIP/SLAP protocol: #{protocol.inspect}" unless VALID_PROTOCOLS.include?(protocol)
+
+        identity_key = fields[1].unpack1('H*')
+        domain = normalise_field(fields[2])
+        topic_or_service = normalise_field(fields[3])
+
+        Advertisement.new(
+          protocol: protocol,
+          identity_key: identity_key,
+          domain: domain,
+          topic_or_service: topic_or_service
+        )
+      end
+
+      # Construct a new AdminTokenTemplate instance.
+      #
+      # @param wallet [#get_public_key, #create_signature] any object implementing
+      #   the BRC-100 wallet interface (e.g. {BSV::Wallet::ProtoWallet})
+      # @param originator [String, nil] optional FQDN of the originating application
+      def initialize(wallet, originator: nil)
+        @wallet = wallet
+        @originator = originator
+      end
+
+      # Create a SHIP or SLAP advertisement locking script.
+      #
+      # Derives the wallet's identity key, builds the four advertisement fields,
+      # signs them with the protocol-derived key, and constructs a PushDrop
+      # locking script with a P2PK spending condition.
+      #
+      # @param protocol [String] 'SHIP' or 'SLAP'
+      # @param domain [String] domain where the service or topic is available
+      # @param topic_or_service [String] topic or service name to advertise
+      # @return [BSV::Script::Script] the locking script
+      # @raise [BSV::Overlay::OverlayError] if protocol is not 'SHIP' or 'SLAP'
+      def lock(protocol, domain, topic_or_service)
+        raise OverlayError, "Invalid protocol: #{protocol.inspect}. Must be 'SHIP' or 'SLAP'" \
+          unless VALID_PROTOCOLS.include?(protocol)
+
+        protocol_id = protocol_id_for(protocol)
+
+        # Fetch the wallet's identity key (compressed public key hex)
+        id_args = { identity_key: true }
+        id_args[:originator] = @originator if @originator
+        identity_result = @wallet.get_public_key(id_args)
+        identity_key_hex = identity_result[:public_key]
+        identity_key_bytes = [identity_key_hex].pack('H*')
+
+        # Derive the locking public key for this protocol
+        lock_args = { protocol_id: protocol_id, key_id: '1', counterparty: 'self' }
+        lock_args[:originator] = @originator if @originator
+        locking_result = @wallet.get_public_key(lock_args)
+        locking_pubkey_hex = locking_result[:public_key]
+        locking_pubkey_bytes = [locking_pubkey_hex].pack('H*')
+
+        # Build the four advertisement fields
+        field_protocol = protocol.b
+        field_identity = identity_key_bytes
+        field_domain = domain.encode('binary')
+        field_topic = topic_or_service.encode('binary')
+
+        # Sign the concatenation of all four fields as authentication
+        data_to_sign = (field_protocol + field_identity + field_domain + field_topic).unpack('C*')
+        sig_args = { data: data_to_sign, protocol_id: protocol_id, key_id: '1', counterparty: 'self' }
+        sig_args[:originator] = @originator if @originator
+        sig_result = @wallet.create_signature(sig_args)
+        field_sig = sig_result[:signature].pack('C*')
+
+        fields = [field_protocol, field_identity, field_domain, field_topic, field_sig]
+        lock_script = BSV::Script::Script.p2pk_lock(locking_pubkey_bytes)
+        BSV::Script::Script.pushdrop_lock(fields, lock_script)
+      end
+
+      # Return an unlocker for spending an advertisement token.
+      #
+      # The returned object follows the {BSV::Transaction::UnlockingScriptTemplate}
+      # interface and can be assigned to an input's +unlocking_script_template+.
+      #
+      # @param protocol [String] 'SHIP' or 'SLAP' — must match the locked token
+      # @return [Unlocker] an object with +#sign+ and +#estimated_length+
+      # @raise [BSV::Overlay::OverlayError] if protocol is not 'SHIP' or 'SLAP'
+      def unlock(protocol)
+        raise OverlayError, "Invalid protocol: #{protocol.inspect}. Must be 'SHIP' or 'SLAP'" \
+          unless VALID_PROTOCOLS.include?(protocol)
+
+        Unlocker.new(@wallet, protocol_id_for(protocol), @originator)
+      end
+
+      class << self
+        private
+
+        # Normalise a field value: decode as UTF-8 and treat a single null byte
+        # as an empty string. This matches the encoding used when an empty string
+        # is represented as a raw +\x00+ byte push rather than OP_0.
+        def normalise_field(raw)
+          return '' if raw.bytesize == 1 && raw.getbyte(0).zero?
+
+          raw.force_encoding('UTF-8')
+        end
+      end
+
+      private
+
+      # Map a protocol string to its BRC-42/43 protocol ID array for key derivation.
+      #
+      # Uses the lowercase derivation names required by the wallet key-derivation
+      # validator, matching the Go SDK convention (not the titlecase TS SDK variant).
+      #
+      # @param protocol [String] 'SHIP' or 'SLAP'
+      # @return [Array] [security_level, protocol_name]
+      def protocol_id_for(protocol)
+        if protocol == Constants::PROTOCOL_SHIP
+          [2, Constants::DERIVE_PROTOCOL_SHIP]
+        else
+          [2, Constants::DERIVE_PROTOCOL_SLAP]
+        end
+      end
+    end
+  end
+end