sidetree 0.1.0

data/lib/sidetree/model/service.rb

@@ -0,0 +1,50 @@
+module Sidetree
+  module Model
+    class Service
+      MAX_TYPE_LENGTH = 30
+
+      attr_reader :id # String
+      attr_reader :type # String
+      attr_reader :endpoint # URI string or JSON object
+
+      # @raise [Sidetree::Error]
+      def initialize(id, type, endpoint)
+        Sidetree::Validator.validate_id!(id)
+        raise Error, 'type should be String.' unless type.is_a?(String)
+        if type.length > MAX_TYPE_LENGTH
+          raise Error,
+                "Service endpoint type length #{type.length} exceeds max allowed length of #{MAX_TYPE_LENGTH}."
+        end
+        if endpoint.is_a?(Array)
+          raise Error, 'Service endpoint value cannot be an array.'
+        end
+
+        Sidetree::Validator.validate_uri!(endpoint) if endpoint.is_a?(String)
+        @id = id
+        @type = type
+        @endpoint = endpoint
+      end
+
+      # Generate service from json object.
+      # @param [Hash] data Hash params.
+      # @option data [String] :id id
+      # @option data [String] :type type
+      # @option data [String || Object] :endpoint endpoint url
+      # @raise [Sidetree::Error]
+      # @return [Sidetree::Model::Service]
+      def self.from_hash(data)
+        Service.new(data['id'], data['type'], data['serviceEndpoint'])
+      end
+
+      # Convert data to Hash object.
+      # @return [Hash]
+      def to_h
+        hash = {}
+        hash['id'] = id if id
+        hash['type'] = type if type
+        hash['serviceEndpoint'] = endpoint if endpoint
+        hash
+      end
+    end
+  end
+end

data/lib/sidetree/model/suffix.rb

@@ -0,0 +1,34 @@
+module Sidetree
+  module Model
+    class Suffix
+      attr_reader :delta_hash, :recovery_commitment
+
+      # @param [String] delta_hash Base64 encoded delta hash.
+      # @param [String] recovery_commitment Base64 encoded recovery commitment.
+      def initialize(delta_hash, recovery_commitment)
+        @delta_hash = delta_hash
+        @recovery_commitment = recovery_commitment
+      end
+
+      # Generate Suffix object from Hash object.
+      # @return [Sidetree::Model::Suffix]
+      # @raise [Sidetree::Error]
+      def self.parse(object)
+        Sidetree::Validator.validate_suffix_data!(object)
+        Suffix.new(object[:deltaHash], object[:recoveryCommitment])
+      end
+
+      # Convert data to Hash object.
+      # @return [Hash]
+      def to_h
+        { deltaHash: delta_hash, recoveryCommitment: recovery_commitment }
+      end
+
+      # Calculate unique suffix
+      # @return [String] unique suffix
+      def unique_suffix
+        Sidetree.to_hash(to_h)
+      end
+    end
+  end
+end

data/lib/sidetree/model.rb

@@ -0,0 +1,8 @@
+module Sidetree
+  module Model
+    autoload :Suffix, 'sidetree/model/suffix'
+    autoload :Delta, 'sidetree/model/delta'
+    autoload :Document, 'sidetree/model/document'
+    autoload :Service, 'sidetree/model/service'
+  end
+end

data/lib/sidetree/op/base.rb

@@ -0,0 +1,11 @@
+module Sidetree
+  module OP
+    class Base
+      # Return operation type.
+      # @return [String] see Sidetree::OP::Type
+      def type
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/sidetree/op/create.rb

@@ -0,0 +1,69 @@
+module Sidetree
+  module OP
+    # Create operation class.
+    class Create < Base
+      attr_reader :suffix, :delta
+
+      # @param [Sidetree::Model::Suffix] suffix
+      # @param [Sidetree::Model::Delta] delta
+      def initialize(suffix, delta)
+        @delta = delta
+        @suffix = suffix
+      end
+
+      def type
+        Sidetree::OP::Type::CREATE
+      end
+
+      # Check whether suffix's delta_hash equal to hash of delta.
+      # @return [Boolean] result
+      def match_delta_hash?
+        suffix.delta_hash == delta.to_hash
+      end
+
+      # @return [Sidetree::OP::Create] create operation.
+      def self.from_base64(base64_str)
+        jcs = Base64.urlsafe_decode64(base64_str)
+        begin
+          json = JSON.parse(jcs, symbolize_names: true)
+
+          # validate jcs
+          expected_base64 =
+            Base64.urlsafe_encode64(json.to_json_c14n, padding: false)
+          unless expected_base64 == base64_str
+            raise Error, 'Initial state object and JCS string mismatch.'
+          end
+
+          Create.new(
+            Sidetree::Model::Suffix.parse(json[:suffixData]),
+            Sidetree::Model::Delta.parse(json[:delta])
+          )
+        rescue JSON::ParserError
+          raise Error, 'Long form initial state should be encoded jcs.'
+        end
+      end
+
+      def to_h
+        { suffixData: suffix.to_h, delta: delta.to_h }
+      end
+
+      # Generate long_suffix for DID.
+      # @return [String] Base64 encoded long_suffix.
+      def long_suffix
+        Base64.urlsafe_encode64(to_h.to_json_c14n, padding: false)
+      end
+
+      # Generate DID
+      # @param [String] method DID method.
+      # @param [Boolean] include_long
+      # @return [String] DID
+      def did(method: Sidetree::Params::DEFAULT_METHOD, include_long: false)
+        did = "did:#{method}"
+        did += ":#{Sidetree::Params.network}" if Sidetree::Params.testnet?
+        did += ":#{suffix.unique_suffix}"
+        did += ":#{long_suffix}" if include_long
+        did
+      end
+    end
+  end
+end

data/lib/sidetree/op.rb

@@ -0,0 +1,37 @@
+module Sidetree
+  module OP
+    module Type
+      CREATE = 'create'
+      UPDATE = 'update'
+      RECOVER = 'recover'
+      DEACTIVATE = 'deactivate'
+    end
+
+    # Sidetree patch actions. These are the valid values in the action property of a patch.
+    module PatchAction
+      REPLACE = 'replace'
+      ADD_PUBLIC_KEYS = 'add-public-keys'
+      REMOVE_PUBLIC_KEYS = 'remove-public-keys'
+      ADD_SERVICES = 'add-services'
+      REMOVE_SERVICES = 'remove-services'
+    end
+
+    # DID Document public key purpose.
+    module PublicKeyPurpose
+      AUTHENTICATION = 'authentication'
+      ASSERTION_METHOD = 'assertionMethod'
+      CAPABILITY_INVOCATION = 'capabilityInvocation'
+      CAPABILITY_DELEGATION = 'capabilityDelegation'
+      KEY_AGREEMENT = 'keyAgreement'
+
+      module_function
+
+      def values
+        PublicKeyPurpose.constants.map { |c| PublicKeyPurpose.const_get(c) }
+      end
+    end
+
+    autoload :Base, 'sidetree/op/base'
+    autoload :Create, 'sidetree/op/create'
+  end
+end

data/lib/sidetree/validator.rb

@@ -0,0 +1,250 @@
+module Sidetree
+  module Validator
+    module_function
+
+    # @param [Hash] delta delta object.
+    # @return [Sidetree::Error]
+    def validate_delta!(delta)
+      raise Error, 'Delta does not defined.' unless delta
+      delta_size = delta.to_json_c14n.bytesize
+      if delta_size > Sidetree::Params::MAX_DELTA_SIZE
+        raise Error,
+              "#{delta_size} bytes of 'delta' exceeded limit of #{Sidetree::Params::MAX_DELTA_SIZE} bytes."
+      end
+
+      if delta.instance_of?(Array)
+        raise Error, 'Delta object cannot be an array.'
+      end
+      delta.keys.each do |k|
+        unless %w[patches updateCommitment].include?(k.to_s)
+          raise Error, "Property '#{k}' is not allowed in delta object."
+        end
+      end
+
+      unless delta[:patches].instance_of?(Array)
+        raise Error, 'Patches object in delta must be an array.'
+      end
+      delta[:patches].each { |p| validate_patch!(p) }
+
+      validate_encoded_multi_hash!(delta[:updateCommitment], 'updateCommitment')
+    end
+
+    # @param [Hash] patch patch object.
+    # @raise [Sidetree::Error]
+    def validate_patch!(patch)
+      case patch[:action]
+      when OP::PatchAction::REPLACE
+        validate_document!(patch[:document])
+      when OP::PatchAction::ADD_PUBLIC_KEYS
+        validate_add_public_keys_patch!(patch)
+      when OP::PatchAction::REMOVE_PUBLIC_KEYS
+        validate_remove_public_keys_patch!(patch)
+      when OP::PatchAction::ADD_SERVICES
+        validate_add_services_patch!(patch)
+      when OP::PatchAction::REMOVE_SERVICES
+        validate_remove_services_patch!(patch)
+      else
+        raise Error, "#{patch[:action]} is unknown patch action."
+      end
+    end
+
+    def validate_document!(document)
+      raise Error, 'Document object missing in patch object' unless document
+      document.keys.each do |k|
+        unless %w[publicKeys services].include?(k.to_s)
+          raise Error, "Property '#{k}' is not allowed in document object."
+        end
+      end
+      validate_public_keys!(document[:publicKeys]) if document[:publicKeys]
+      validate_services!(document[:services]) if document[:services]
+    end
+
+    def validate_add_public_keys_patch!(patch)
+      unless patch.keys.length == 2
+        raise Error, 'Patch missing or unknown property.'
+      end
+      validate_public_keys!(patch[:publicKeys])
+    end
+
+    def validate_remove_public_keys_patch!(patch)
+      patch.keys.each do |k|
+        unless %w[action ids].include?(k.to_s)
+          raise Error, "Unexpected property '#{k}' in remove-public-keys patch."
+        end
+      end
+      unless patch[:ids].instance_of?(Array)
+        raise Error, 'Patch public key ids not an array.'
+      end
+
+      patch[:ids].each { |id| validate_id!(id) }
+    end
+
+    def validate_add_services_patch!(patch)
+      unless patch.keys.length == 2
+        raise Error, 'Patch missing or unknown property.'
+      end
+      unless patch[:services].instance_of?(Array)
+        raise Error, 'Patch services not an array.'
+      end
+      validate_services!(patch[:services])
+    end
+
+    def validate_remove_services_patch!(patch)
+      patch.keys.each do |k|
+        unless %w[action ids].include?(k.to_s)
+          raise Error, "Unexpected property '#{k}' in remove-services patch."
+        end
+      end
+      unless patch[:ids].instance_of?(Array)
+        raise Error, 'Patch service ids not an array.'
+      end
+
+      patch[:ids].each { |id| validate_id!(id) }
+    end
+
+    def validate_public_keys!(public_keys)
+      unless public_keys.instance_of?(Array)
+        raise Error, 'publicKeys must be an array.'
+      end
+      pubkey_ids = []
+      public_keys.each do |public_key|
+        public_key.keys.each do |k|
+          unless %w[id type purposes publicKeyJwk].include?(k.to_s)
+            raise Error, "Property '#{k}' is not allowed in publicKeys object."
+          end
+        end
+        if public_key[:publicKeyJwk].instance_of?(Array)
+          raise Error, 'publicKeyJwk object cannot be an array.'
+        end
+        if public_key[:type] && !public_key[:type].is_a?(String)
+          raise Error, "Public key type #{public_key[:type]} is incorrect."
+        end
+
+        validate_id!(public_key[:id])
+
+        if pubkey_ids.include?(public_key[:id])
+          raise Error, 'Public key id is duplicated.'
+        end
+        pubkey_ids << public_key[:id]
+
+        if public_key[:purposes]
+          unless public_key[:purposes].instance_of?(Array)
+            raise Error, 'purposes must be an array.'
+          end
+          unless public_key[:purposes].count == public_key[:purposes].uniq.count
+            raise Error, 'purpose is duplicated.'
+          end
+          public_key[:purposes].each do |purpose|
+            unless OP::PublicKeyPurpose.values.include?(purpose)
+              raise Error, "purpose #{} is invalid."
+            end
+          end
+        end
+      end
+    end
+
+    def validate_services!(services)
+      unless services.instance_of?(Array)
+        raise Error, 'services must be an array.'
+      end
+
+      service_ids = []
+      services.each do |service|
+        unless service.keys.length == 3
+          raise Error, 'Service has missing or unknown property.'
+        end
+
+        validate_id!(service[:id])
+
+        if service_ids.include?(service[:id])
+          raise Error, 'Service id has to be unique.'
+        end
+        service_ids << service[:id]
+
+        unless service[:type].is_a?(String)
+          raise Error, "Service type #{service[:type]} is incorrect."
+        end
+        raise Error, 'Service type too long.' if service[:type].length > 30
+
+        endpoint = service[:serviceEndpoint]
+        if endpoint.instance_of?(String)
+          validate_uri!(endpoint)
+        elsif endpoint.instance_of?(Hash)
+
+        else
+          raise Error, 'ServiceEndpoint must be string or object.'
+        end
+      end
+    end
+
+    def valid_base64_encoding?(base64)
+      /^[A-Za-z0-9_-]+$/.match?(base64)
+    end
+
+    # Validate uri
+    # @param [String] uri uri
+    # @return [Sidetree::Error] Occurs if it is an incorrect URI
+    def validate_uri!(uri)
+      begin
+        URI.parse(uri)
+        unless uri =~ /\A#{URI.regexp(%w[http https])}\z/
+          raise Error, "URI string '#{uri}' is not a valid URI."
+        end
+      rescue StandardError
+        raise Error, "URI string '#{uri}' is not a valid URI."
+      end
+    end
+
+    def validate_id!(id)
+      raise Error, 'id does not string.' unless id.instance_of?(String)
+      raise Error, 'id is too long.' if id.length > 50
+      unless valid_base64_encoding?(id)
+        raise Error, 'id does not use base64url character set.'
+      end
+    end
+
+    def validate_encoded_multi_hash!(multi_hash, target)
+      begin
+        decoded = Multihashes.decode(Base64.urlsafe_decode64(multi_hash))
+        unless Params::HASH_ALGORITHM.include?(decoded[:code])
+          raise Error,
+                "Given #{target} uses unsupported multihash algorithm with code #{decoded[:code]}."
+        end
+      rescue StandardError
+        raise Error,
+              "Given #{target} string '#{multi_hash}' is not a multihash."
+      end
+    end
+
+    def validate_did_type!(type)
+      return unless type
+      raise Error, 'DID type must be a string.' unless type.instance_of?(String)
+      if type.length > 4
+        raise Error,
+              "DID type string '#{type}' cannot be longer than 4 characters."
+      end
+      unless valid_base64_encoding?(type)
+        raise Error,
+              "DID type string '#{type}' contains a non-Base64URL character."
+      end
+    end
+
+    def validate_suffix_data!(suffix)
+      if suffix.instance_of?(Array)
+        raise Error, 'Suffix data can not be an array.'
+      end
+      suffix.keys.each do |k|
+        unless %w[deltaHash recoveryCommitment type].include?(k.to_s)
+          raise Error, "Property '#{k}' is not allowed in publicKeys object."
+        end
+      end
+      validate_encoded_multi_hash!(suffix[:deltaHash], 'delta hash')
+      validate_encoded_multi_hash!(
+        suffix[:recoveryCommitment],
+        'recovery commitment'
+      )
+      validate_encoded_multi_hash!(suffix[:deltaHash], 'delta hash')
+      validate_did_type!(suffix[:type])
+    end
+  end
+end

data/lib/sidetree/version.rb

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

data/lib/sidetree.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'sidetree/version'
+require 'ecdsa'
+require 'json/jwt'
+require 'base64'
+require 'json'
+require 'json/canonicalization'
+require 'uri'
+require 'multihashes'
+
+module Sidetree
+  class Error < StandardError
+  end
+
+  autoload :Key, 'sidetree/key'
+  autoload :DID, 'sidetree/did'
+  autoload :Model, 'sidetree/model'
+  autoload :OP, 'sidetree/op'
+  autoload :Validator, 'sidetree/validator'
+
+  module Params
+    # Algorithm for generating hashes of protocol-related values. 0x12 = sha2-256
+    HASH_ALGORITHM = [0x12]
+    HASH_ALGORITH_STRING = 'sha2-256'
+
+    # Maximum canonicalized operation delta buffer size.
+    MAX_DELTA_SIZE = 1000
+
+    # Default DID method
+    DEFAULT_METHOD = 'sidetree'
+
+    # Supported did methods.
+    METHODS = { default: DEFAULT_METHOD, ion: 'ion' }
+
+    @network = nil
+
+    def self.network=(network)
+      @network = network
+    end
+
+    def self.network
+      @network
+    end
+
+    def self.testnet?
+      @network == Network::TESTNET
+    end
+
+    module Network
+      MAINNET = 'mainnet'
+      TESTNET = 'test'
+    end
+  end
+
+  module_function
+
+  # Calculate Base64 encoded hash of hash object.
+  # @param [Hash] data
+  # @return [String] Base64 encoded hash value
+  def to_hash(data)
+    digest = Digest::SHA256.digest(data.is_a?(Hash) ? data.to_json_c14n : data)
+    hash = Multihashes.encode(digest, Params::HASH_ALGORITH_STRING)
+
+    # TODO Need to decide on what hash algorithm to use when hashing suffix data
+    # - https://github.com/decentralized-identity/sidetree/issues/965
+    Base64.urlsafe_encode64(hash, padding: false)
+  end
+end

data/sidetree.gemspec

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'lib/sidetree/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'sidetree'
+  spec.version = Sidetree::VERSION
+  spec.authors = ['azuchi']
+  spec.email = ['azuchi@chaintope.com']
+
+  spec.summary = 'Ruby implementation for Sidetree protocol.'
+  spec.description = 'Ruby implementation for Sidetree protocol.'
+  spec.homepage = 'https://github.com/azuchi/sidetreerb'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = spec.homepage
+  spec.metadata['changelog_uri'] = spec.homepage
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject do |f|
+        f.match(%r{\A(?:test|spec|features)/})
+      end
+    end
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  # Uncomment to register a new dependency of your gem
+  spec.add_dependency 'ecdsa', '~> 1.2.0'
+  spec.add_dependency 'json-jwt', '~> 1.13.0'
+  spec.add_dependency 'json-canonicalization', '~> 0.3.0'
+  spec.add_dependency 'multihashes', '~> 0.2.0'
+  spec.add_runtime_dependency 'thor'
+
+  # For more information and examples about making a new gem, checkout our
+  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'prettier'
+end