sidetree 0.1.1 → 0.1.4

data/lib/sidetree/model/delta.rb

@@ -3,6 +3,7 @@ module Sidetree
     class Delta
       attr_reader :patches, :update_commitment
 
+      # Initializer
       # @param [Array[Hash]] patches
       # @param [String] update_commitment
       # @raise [Sidetree::Error]
@@ -11,7 +12,10 @@ module Sidetree
         @update_commitment = update_commitment
       end
 
-      def self.parse(object)
+      # Create delta object from hash object.
+      # @param [Hash] object
+      # @return [Sidetree::Model::Delta]
+      def self.from_object(object)
         Sidetree::Validator.validate_delta!(object)
         Delta.new(object[:patches], object[:updateCommitment])
       end
@@ -23,6 +27,11 @@ module Sidetree
       def to_hash
         Sidetree.to_hash(to_h)
       end
+
+      def ==(other)
+        return false unless other.is_a?(Delta)
+        to_hash == other.to_hash
+      end
     end
   end
 end

data/lib/sidetree/model/document.rb

@@ -35,6 +35,12 @@ module Sidetree
       def to_h
         { publicKeys: public_keys.map(&:to_h), services: services.map(&:to_h) }
       end
+
+      # Generate replace patch.
+      # @return [Hash]
+      def to_replace_patch
+        { action: OP::PatchAction::REPLACE, document: to_h }
+      end
     end
   end
 end

data/lib/sidetree/model/provisional_index_file.rb

@@ -0,0 +1,129 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#provisional-index-file
+    class ProvisionalIndexFile < CASFileBase
+      attr_reader :provisional_proof_file_uri
+      attr_reader :chunks
+      attr_reader :operations
+
+      # Initialize
+      # @param [String] proof_file_uri Provisional Proof File URI.
+      # @param [Array[Sidetree::Model::Chunk]] chunks
+      # @param [Array[Sidetree::OP::Update]] operations Update operations
+      # @raise [Sidetree::Error]
+      def initialize(proof_file_uri: nil, chunks: [], operations: [])
+        if !chunks.is_a?(Array) || chunks.empty?
+          raise Sidetree::Error,
+                "Provisional Index File chunk property missing or incorrect type"
+        elsif chunks.length > 1
+          raise Sidetree::Error,
+                "Provisional Index File chunks does not have exactly one element"
+        end
+        @provisional_proof_file_uri = proof_file_uri
+        @chunks = chunks
+        @operations = operations
+        did_suffixes = operations.map(&:did_suffix).compact
+        if did_suffixes.length > 0
+          unless did_suffixes.length == did_suffixes.uniq.length
+            raise Sidetree::Error,
+                  "Provisional Index File has multiple operations for same DID"
+          end
+        else
+          if proof_file_uri
+            raise Sidetree::Error,
+                  "Provisional proof file '#{proof_file_uri}' not allowed in a provisional index file with no updates"
+          end
+        end
+      end
+
+      # Parse provisional index file.
+      # @param [String] index_data provisional index file data.
+      # @param [Boolean] compressed Whether the +index_data+ is compressed or not, default: true.
+      # @return [Sidetree::Model::ProvisionalIndexFile]
+      def self.parse(index_data, compressed: true)
+        decompressed =
+          (
+            if compressed
+              decompress(
+                index_data,
+                Sidetree::Params::MAX_PROVISIONAL_INDEX_FILE_SIZE
+              )
+            else
+              index_data
+            end
+          )
+        begin
+          json = JSON.parse(decompressed, symbolize_names: true)
+          operations = []
+          chunks = []
+          json.each do |k, v|
+            case k
+            when :chunks
+              chunks =
+                v
+                  .map do |chunk|
+                    chunk.map do |c_k, c_v|
+                      case c_k
+                      when :chunkFileUri
+                        Sidetree::Model::Chunk.new(c_v)
+                      else
+                        raise Sidetree::Error,
+                              "Provisional Index File chunk has missing or unknown property"
+                      end
+                    end
+                  end
+                  .flatten
+            when :provisionalProofFileUri
+            when :operations
+              v.each do |o_k, o_v|
+                case o_k
+                when :update
+                  unless o_v.is_a?(Array)
+                    raise Sidetree::Error,
+                          "Provisional Index File update operation not array"
+                  end
+                  operations =
+                    o_v.map do |update|
+                      Sidetree::OP::Update.from_json(update.to_json_c14n)
+                    end
+                else
+                  raise Sidetree::Error,
+                        "Unexpected property '#{o_k.to_s}' in update operation"
+                end
+              end
+            else
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in provisional index file"
+            end
+          end
+          ProvisionalIndexFile.new(
+            chunks: chunks,
+            operations: operations,
+            proof_file_uri: json[:provisionalProofFileUri]
+          )
+        rescue JSON::ParserError
+          raise Sidetree::Error, "Provisional index file is not json"
+        end
+      end
+
+      # Build json string to be stored in CAS.
+      # @return [String] json string.
+      def to_json
+        params = { chunks: chunks.map(&:to_h) }
+        unless operations.empty?
+          params[:operations] = {
+            update:
+              operations.map do |update|
+                {
+                  didSuffix: update.did_suffix,
+                  revealValue: update.revealed_value
+                }
+              end
+          }
+          params[:provisionalProofFileUri] = provisional_proof_file_uri
+        end
+        params.to_json
+      end
+    end
+  end
+end

data/lib/sidetree/model/provisional_proof_file.rb

@@ -0,0 +1,80 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#provisional-proof-file
+    class ProvisionalProofFile < CASFileBase
+      attr_reader :update_proofs
+
+      # Initialize
+      # @param [Array[JSON::JWS]] update_proofs Array of update proof.
+      def initialize(update_proofs)
+        @update_proofs = update_proofs
+      end
+
+      # Parse provisional proof file from compressed data.
+      # @param [String] proof_file compressed provisional proof file.
+      # @param [Boolean] compressed Whether the proof_file is compressed or not, default: true.
+      # @return [Sidetree::Model::ProvisionalProofFile]
+      # @raise [Sidetree::Error]
+      def self.parse(proof_file, compressed: true)
+        decompressed =
+          (
+            if compressed
+              decompress(proof_file, Sidetree::Params::MAX_PROOF_FILE_SIZE)
+            else
+              proof_file
+            end
+          )
+        begin
+          json = JSON.parse(decompressed, symbolize_names: true)
+          json.keys.each do |k|
+            unless k == :operations
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in provisional proof file"
+            end
+          end
+          unless json[:operations]
+            raise Sidetree::Error,
+                  "Provisional proof file does not have any operation proofs"
+          end
+          json[:operations].keys.each do |k|
+            unless k == :update
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in provisional proof file"
+            end
+          end
+          unless json[:operations][:update].is_a?(Array)
+            raise Sidetree::Error,
+                  "Provisional proof file update property not array"
+          end
+          update_proofs =
+            json[:operations][:update].each.map do |update|
+              update.keys.each do |k|
+                unless k == :signedData
+                  raise Sidetree::Error,
+                        "Unexpected property #{k.to_s} in provisional proof file"
+                end
+              end
+              Sidetree::Util::JWS.parse(update[:signedData])
+            end
+          if update_proofs.empty?
+            raise Sidetree::Error, "Provisional proof file has no proof"
+          end
+          ProvisionalProofFile.new(update_proofs)
+        rescue JSON::ParserError
+          raise Sidetree::Error, "Provisional proof file is not json"
+        end
+      end
+
+      # Build json string to be stored in CAS.
+      # @return [String] json string.
+      def to_json
+        params = {
+          operations: {
+            update: update_proofs.map { |u| { signedData: u.to_s } }
+          }
+        }
+        params.to_json
+      end
+    end
+  end
+end

data/lib/sidetree/model/suffix.rb

@@ -10,10 +10,10 @@ module Sidetree
         @recovery_commitment = recovery_commitment
       end
 
-      # Generate Suffix object from Hash object.
+      # Create Suffix object from hash object.
       # @return [Sidetree::Model::Suffix]
       # @raise [Sidetree::Error]
-      def self.parse(object)
+      def self.from_object(object)
         Sidetree::Validator.validate_suffix_data!(object)
         Suffix.new(object[:deltaHash], object[:recoveryCommitment])
       end

data/lib/sidetree/model.rb

@@ -4,5 +4,12 @@ module Sidetree
     autoload :Delta, "sidetree/model/delta"
     autoload :Document, "sidetree/model/document"
     autoload :Service, "sidetree/model/service"
+    autoload :CASFileBase, "sidetree/model/cas_file_base"
+    autoload :CoreIndexFile, "sidetree/model/core_index_file"
+    autoload :ChunkFile, "sidetree/model/chunk_file"
+    autoload :Chunk, "sidetree/model/chunk"
+    autoload :ProvisionalIndexFile, "sidetree/model/provisional_index_file"
+    autoload :ProvisionalProofFile, "sidetree/model/provisional_proof_file"
+    autoload :CoreProofFile, "sidetree/model/core_proof_file"
   end
 end

data/lib/sidetree/op/create.rb

@@ -29,6 +29,39 @@ module Sidetree
         did.create_op
       end
 
+      # Parse create operation data from json string
+      # @param [String] create_data create operation data(json string).
+      # @return [Sidetree::OP::Create]
+      # @raise [Sidetree::Error]
+      def self.from_json(create_data)
+        begin
+          json = JSON.parse(create_data, symbolize_names: true)
+          json.each do |k, v|
+            case k
+            when :type, :suffixData, :delta
+            else
+              raise Sidetree::Error,
+                    "Create operation missing or unknown property"
+            end
+          end
+          if json[:type] && json[:type] != Sidetree::OP::Type::CREATE
+            raise Sidetree::Error, "Create operation type incorrect"
+          end
+          suffix = Sidetree::Model::Suffix.from_object(json[:suffixData])
+          delta = nil
+          begin
+            # For compatibility with data pruning
+            delta = Sidetree::Model::Delta.from_object(json[:delta]) if json[
+              :delta
+            ]
+          rescue Sidetree::Error
+          end
+          Create.new(suffix, delta)
+        rescue JSON::ParserError
+          raise Sidetree::Error, "create_data not json"
+        end
+      end
+
       def type
         Sidetree::OP::Type::CREATE
       end
@@ -53,8 +86,8 @@ module Sidetree
           end
 
           Create.new(
-            Sidetree::Model::Suffix.parse(json[:suffixData]),
-            Sidetree::Model::Delta.parse(json[:delta])
+            Sidetree::Model::Suffix.from_object(json[:suffixData]),
+            Sidetree::Model::Delta.from_object(json[:delta])
           )
         rescue JSON::ParserError
           raise Error, "Long form initial state should be encoded jcs."
@@ -62,7 +95,7 @@ module Sidetree
       end
 
       def to_h
-        { suffixData: suffix.to_h, delta: delta.to_h }
+        { suffixData: suffix.to_h, delta: delta&.to_h }
       end
 
       # Generate long_suffix for DID.

data/lib/sidetree/op/deactivate.rb

@@ -1,7 +1,79 @@
 module Sidetree
   module OP
-    # Deactivate operation class TODO implementation
+    # Deactivate operation class
+    # https://identity.foundation/sidetree/spec/#deactivate
     class Deactivate < Base
+      attr_reader :did_suffix
+      attr_reader :signed_data
+      attr_reader :revealed_value
+
+      # Initialize
+      # @param [String] did_suffix
+      # @param [JSON::JWS] signed_data
+      # @param [String] revealed_value
+      def initialize(did_suffix, signed_data, revealed_value)
+        Sidetree::Validator.validate_encoded_multi_hash!(
+          did_suffix,
+          "#{type} didSuffix"
+        )
+        Sidetree::Validator.validate_encoded_multi_hash!(
+          revealed_value,
+          "#{type} revealValue"
+        )
+        @did_suffix = did_suffix
+        @signed_data = signed_data
+        @revealed_value = revealed_value
+      end
+
+      # Parse Deactivate operation data from json string
+      # @param [String] deactivate_data deactivate operation data(json string).
+      # @return [Sidetree::OP::Deactivate]
+      # @raise [Sidetree::Error]
+      def self.from_json(deactivate_data)
+        begin
+          json = JSON.parse(deactivate_data, symbolize_names: true)
+          jws, revealed_value, did_suffix = nil, nil, nil
+          json.each do |k, v|
+            case k
+            when :type
+              unless v == Sidetree::OP::Type::DEACTIVATE
+                raise Sidetree::Error, "Deactivate operation type incorrect"
+              end
+            when :didSuffix
+              did_suffix = v
+            when :revealValue
+              revealed_value = v
+            when :signedData
+              jws = Sidetree::Util::JWS.parse(v)
+              unless jws.keys.length == 2
+                raise Sidetree::Error,
+                      "Deactivate operation signed data missing or unknown property"
+              end
+              Sidetree::Util::JWK.validate!(
+                Sidetree::Util::JWK.parse(jws["recoveryKey"])
+              )
+            else
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in deactivate operation"
+            end
+          end
+          if jws
+            Validator.validate_canonicalize_object_hash!(
+              jws["recoveryKey"],
+              revealed_value,
+              "Deactivate key"
+            )
+          end
+          unless did_suffix
+            raise Sidetree::Error, "The deactivate didSuffix must be a string"
+          end
+          Deactivate.new(did_suffix, jws, revealed_value)
+        rescue JSON::ParserError
+          raise Sidetree::Error, "deactivate_data not json"
+        rescue JSON::JWS::InvalidFormat
+          raise Sidetree::Error, "Invalid signedData"
+        end
+      end
       def type
         Sidetree::OP::Type::DEACTIVATE
       end

data/lib/sidetree/op/recover.rb

@@ -1,7 +1,16 @@
 module Sidetree
   module OP
-    # Recover operation class. TODO implementation
-    class Recover < Base
+    # Recover operation class.
+    # https://identity.foundation/sidetree/spec/#recover
+    class Recover < Updatable
+      # Parse Recover operation data from json string
+      # @param [String] recover_data recover operation data(json string).
+      # @return [Sidetree::OP::Recover]
+      # @raise [Sidetree::Error]
+      def self.from_json(recover_data)
+        parse_json(recover_data, Sidetree::OP::Type::RECOVER)
+      end
+
       def type
         Sidetree::OP::Type::RECOVER
       end

data/lib/sidetree/op/updatable.rb

@@ -0,0 +1,98 @@
+module Sidetree
+  module OP
+    class Updatable < Base
+      attr_reader :did_suffix
+      attr_reader :delta
+      attr_reader :signed_data
+      attr_reader :revealed_value
+
+      # Initialize
+      # @param [String] did_suffix
+      # @param [Sidetree::Model::Delta] delta
+      # @param [JSON::JWS] signed_data
+      # @param [String] revealed_value
+      # @raise [Sidetree::Error]
+      def initialize(did_suffix, delta, signed_data, revealed_value)
+        Sidetree::Validator.validate_encoded_multi_hash!(
+          did_suffix,
+          "#{type} didSuffix"
+        )
+        Sidetree::Validator.validate_encoded_multi_hash!(
+          revealed_value,
+          "#{type} revealValue"
+        )
+        if signed_data
+          Validator.validate_canonicalize_object_hash!(
+            signed_data[key_name],
+            revealed_value,
+            type
+          )
+        end
+        @did_suffix = did_suffix
+        @delta = delta
+        @signed_data = signed_data
+        @revealed_value = revealed_value
+      end
+
+      def self.parse_json(data, type)
+        begin
+          json = JSON.parse(data, symbolize_names: true)
+          delta, jws, revealed_value, did_suffix = nil, nil, nil, nil
+          json.each do |k, v|
+            case k
+            when :type
+              unless v == type
+                raise Sidetree::Error,
+                      "#{type.capitalize} operation type incorrect"
+              end
+            when :didSuffix
+              did_suffix = v
+            when :revealValue
+              revealed_value = v
+            when :signedData
+              jws = Sidetree::Util::JWS.parse(v)
+              unless jws.keys.length ==
+                       (type == Sidetree::OP::Type::RECOVER ? 3 : 2)
+                raise Sidetree::Error,
+                      "#{type.capitalize} operation signed data missing or unknown property"
+              end
+              key_name =
+                (
+                  if type == Sidetree::OP::Type::RECOVER
+                    "recoveryKey"
+                  else
+                    "updateKey"
+                  end
+                )
+              Sidetree::Util::JWK.validate!(
+                Sidetree::Util::JWK.parse(jws[key_name])
+              )
+            when :delta
+              delta = Sidetree::Model::Delta.from_object(v)
+            else
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in #{type} operation"
+            end
+          end
+          unless did_suffix
+            raise Sidetree::Error, "The #{type} didSuffix must be a string"
+          end
+          Module.const_get("Sidetree::OP::#{type.capitalize}").new(
+            did_suffix,
+            delta,
+            jws,
+            revealed_value
+          )
+        rescue JSON::ParserError
+          raise Sidetree::Error, "data dose not json"
+        rescue JSON::JWS::InvalidFormat
+          raise Sidetree::Error, "Invalid signedData"
+        end
+      end
+
+      def key_name
+        type == Sidetree::OP::Type::UPDATE ? "updateKey" : "recoveryKey"
+      end
+    end
+  end
+end

data/lib/sidetree/op/update.rb

@@ -0,0 +1,19 @@
+module Sidetree
+  module OP
+    # Update operation class.
+    # https://identity.foundation/sidetree/spec/#update
+    class Update < Updatable
+      # Parse update operation data from json string
+      # @param [String] update_data update operation data(json string).
+      # @return [Sidetree::OP::Update]
+      # @raise [Sidetree::Error]
+      def self.from_json(update_data)
+        parse_json(update_data, Sidetree::OP::Type::UPDATE)
+      end
+
+      def type
+        Sidetree::OP::Type::UPDATE
+      end
+    end
+  end
+end

data/lib/sidetree/op.rb

@@ -32,8 +32,10 @@ module Sidetree
     end
 
     autoload :Base, "sidetree/op/base"
+    autoload :Updatable, "sidetree/op/updatable"
     autoload :Create, "sidetree/op/create"
     autoload :Recover, "sidetree/op/recover"
+    autoload :Update, "sidetree/op/update"
     autoload :Deactivate, "sidetree/op/deactivate"
   end
 end

data/lib/sidetree/util/anchored_data_serializer.rb

@@ -0,0 +1,41 @@
+module Sidetree
+  module Util
+    module AnchoredDataSerializer
+      DELIMITER = "."
+
+      module_function
+
+      # Serialize given data as Anchor String.
+      # @param [Integer] op_count Number of operations
+      # @param [String] uri Core Index File uri.
+      # @return [String] Anchor String
+      # @raise [Sidetree::Error]
+      def serialize(op_count, uri)
+        if op_count > Sidetree::Params::MAX_OPERATION_COUNT
+          raise Sidetree::Error, "Number of operations greater than max"
+        end
+        "#{op_count}#{DELIMITER}#{uri}"
+      end
+
+      # Deserializes the given string that is read from the blockchain into data.
+      # @param [String] anchor_str Anchor String
+      # @return [Array[Integer, String]]
+      # @raise [Sidetree::Error]
+      def deserialize(anchor_str)
+        data = anchor_str.split(DELIMITER)
+        raise Sidetree::Error, "Invalid anchor string" unless data.length == 2
+        unless data[0] =~ /^[1-9]\d*$/
+          raise Sidetree::Error,
+                "Number of operations in anchor string is not positive number"
+        end
+
+        count = data[0].to_i
+        if count > Sidetree::Params::MAX_OPERATION_COUNT
+          raise Sidetree::Error,
+                "Number of operations in anchor string greater than max"
+        end
+        [count, data[1]]
+      end
+    end
+  end
+end

data/lib/sidetree/util/compressor.rb

@@ -0,0 +1,38 @@
+require "zlib"
+
+module Sidetree
+  module Util
+    module Compressor
+      # The estimated ratio/multiplier of decompressed Sidetree CAS file size compared against the compressed file size.
+      ESTIMATE_DECOMPRESSION_MULTIPLIER = 3
+
+      module_function
+
+      # Compresses teh data in gzip and return it as buffer.
+      # @param [String] data Data to be compressed.
+      # @return [String] compressed data.
+      def compress(data)
+        io = StringIO.new("w")
+        Zlib::GzipWriter.wrap(io) do |w|
+          w.mtime = 0
+          w.write data
+        end
+        io.string.force_encoding("binary")
+      end
+
+      # Decompresses +compressed+.
+      # @param [String] compressed compressed data.
+      # @return [String] decompressed data.
+      # @raise [Sidetree::Error] raise if data exceeds max_bytes size.
+      def decompress(compressed, max_bytes: nil)
+        if max_bytes && compressed.bytesize > max_bytes
+          raise Sidetree::Error, "Exceed maximum compressed chunk file size."
+        end
+        io = StringIO.new(compressed)
+        result = StringIO.new
+        Zlib::GzipReader.wrap(io) { |gz| result << gz.read }
+        result.string
+      end
+    end
+  end
+end