sidetree 0.1.0 → 0.1.3

data/lib/sidetree/model/core_index_file.rb

@@ -0,0 +1,197 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#core-index-file
+    class CoreIndexFile < CASFileBase
+      attr_reader :core_proof_file_uri
+      attr_reader :provisional_index_file_uri
+      attr_reader :writer_lock_id
+      attr_reader :create_ops
+      attr_reader :recover_ops
+      attr_reader :deactivate_ops
+
+      # @param [Array[Sidetree::OP::Create]] create_ops
+      # @param [Array[Sidetree::OP::Recover]] recover_ops
+      # @param [Array[Sidetree::OP::Deactivate]] deactivate_ops
+      # @param [String] provisional_index_file_uri
+      # @param [String] core_proof_file_uri
+      # @raise [Sidetree::Error]
+      def initialize(
+        create_ops: [],
+        recover_ops: [],
+        deactivate_ops: [],
+        provisional_index_file_uri: nil,
+        core_proof_file_uri: nil,
+        writer_lock_id: nil
+      )
+        (create_ops + recover_ops + deactivate_ops).each do |operation|
+          unless operation.is_a?(Sidetree::OP::Base)
+            raise Sidetree::Error, "Invalid operation class specified."
+          end
+        end
+        @create_ops = create_ops
+        @recover_ops = recover_ops
+        @deactivate_ops = deactivate_ops
+        @provisional_index_file_uri = provisional_index_file_uri
+        @core_proof_file_uri = core_proof_file_uri
+        @writer_lock_id = writer_lock_id
+        unless did_suffixes.length == did_suffixes.uniq.length
+          raise Sidetree::Error,
+                "Core index file multiple operations for the same DID"
+        end
+        if writer_lock_id &&
+             writer_lock_id.bytesize > Sidetree::Params::MAX_WRITER_LOCK_ID_SIZE
+          raise Sidetree::Error,
+                "Writer lock ID of #{writer_lock_id.bytesize} bytes exceeded the maximum size of #{Sidetree::Params::MAX_WRITER_LOCK_ID_SIZE} bytes"
+        end
+        if provisional_index_file_uri
+          Validator.validate_cas_file_uri!(
+            provisional_index_file_uri,
+            "provisional index file URI"
+          )
+        else
+          if (create_ops.length + recover_ops.length) > 0
+            raise Sidetree::Error, "Provisional index file uri missing"
+          end
+        end
+        if recover_ops.length > 0 || deactivate_ops.length > 0
+          Validator.validate_cas_file_uri!(
+            core_proof_file_uri,
+            "core proof file URI"
+          )
+        else
+          if core_proof_file_uri
+            raise Sidetree::Error,
+                  "Core proof file is specified but there is no recover and no deactivate operation"
+          end
+        end
+      end
+
+      # Parse core index file.
+      # @param [String] index_data core 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_CORE_INDEX_FILE_SIZE)
+            else
+              index_data
+            end
+          )
+        begin
+          json = JSON.parse(decompressed, symbolize_names: true)
+          create_ops, recover_ops, deactivate_ops = [], [], []
+          core_proof_uri, provisional_index_uri = nil, nil
+          json.each do |k, v|
+            case k
+            when :provisionalIndexFileUri
+              provisional_index_uri = v
+            when :coreProofFileUri
+              core_proof_uri = v
+            when :operations
+              create_ops, recover_ops, deactivate_ops = parse_operations(v)
+            when :writerLockId
+              unless v.is_a?(String)
+                raise Sidetree::Error, "Core index file writerLockId not string"
+              end
+            else
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in core index file"
+            end
+          end
+          CoreIndexFile.new(
+            create_ops: create_ops,
+            recover_ops: recover_ops,
+            deactivate_ops: deactivate_ops,
+            provisional_index_file_uri: provisional_index_uri,
+            core_proof_file_uri: core_proof_uri,
+            writer_lock_id: json[:writerLockId]
+          )
+        rescue JSON::ParserError
+          raise Sidetree::Error, "Core index file is not json"
+        end
+      end
+
+      def self.parse_operations(operations)
+        create_ops, recover_ops, deactivate_ops = [], [], []
+        operations.each do |o_k, o_v|
+          case o_k
+          when :create
+            unless o_v.is_a?(Array)
+              raise Sidetree::Error, "Core index file create property not array"
+            end
+            create_ops =
+              o_v.map do |create|
+                Sidetree::OP::Create.from_json(create.to_json_c14n)
+              end
+          when :recover
+            unless o_v.is_a?(Array)
+              raise Sidetree::Error,
+                    "Core index file recover property not array"
+            end
+            recover_ops =
+              o_v.map do |recover|
+                Sidetree::OP::Recover.from_json(recover.to_json_c14n)
+              end
+          when :deactivate
+            unless o_v.is_a?(Array)
+              raise Sidetree::Error,
+                    "Core index file deactivate property not array"
+            end
+            deactivate_ops =
+              o_v.map do |deactivate|
+                Sidetree::OP::Deactivate.from_json(deactivate.to_json_c14n)
+              end
+          else
+            raise Sidetree::Error,
+                  "Unexpected property #{o_k.to_s} in operations property in core index file"
+          end
+        end
+        [create_ops, recover_ops, deactivate_ops]
+      end
+
+      private_class_method :parse_operations
+
+      def did_suffixes
+        create_ops.map { |o| o.suffix.unique_suffix } +
+          (recover_ops + deactivate_ops).map { |o| o.did_suffix }
+      end
+
+      # Build json string to be stored in CAS.
+      # @return [String] json string.
+      def to_json
+        params = {}
+        params[
+          :provisionalIndexFileUri
+        ] = provisional_index_file_uri if provisional_index_file_uri
+        operations = {}
+        unless create_ops.empty?
+          operations[:create] = create_ops.map do |create|
+            { suffixData: create.suffix.to_h }
+          end
+        end
+        unless recover_ops.empty?
+          operations[:recover] = recover_ops.map do |recover|
+            {
+              didSuffix: recover.did_suffix,
+              revealValue: recover.revealed_value
+            }
+          end
+        end
+        unless deactivate_ops.empty?
+          operations[:deactivate] = deactivate_ops.map do |deactivate|
+            {
+              didSuffix: deactivate.did_suffix,
+              revealValue: deactivate.revealed_value
+            }
+          end
+        end
+        params[:operations] = operations
+        params[:coreProofFileUri] = core_proof_file_uri if core_proof_file_uri
+        params[:writerLockId] = writer_lock_id if writer_lock_id
+        params.to_json
+      end
+    end
+  end
+end

data/lib/sidetree/model/core_proof_file.rb

@@ -0,0 +1,102 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#core-proof-file
+    class CoreProofFile < CASFileBase
+      attr_reader :recover_proofs
+      attr_reader :deactivate_proofs
+
+      def initialize(recover_proofs, deactivate_proofs)
+        @recover_proofs = recover_proofs
+        @deactivate_proofs = deactivate_proofs
+      end
+
+      # Parse core proof file from compressed data.
+      # @param [String] proof_file compressed core proof file.
+      # @param [Boolean] compressed Whether the proof_file is compressed or not, default: true.
+      # @return [Sidetree::Model::CoreProofFile]
+      # @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)
+          recover_proofs, deactivate_proofs = [], []
+          json.keys.each do |k|
+            unless k == :operations
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in core proof file"
+            end
+          end
+          unless json[:operations]
+            raise Sidetree::Error,
+                  "Core proof file does not have any operation proofs"
+          end
+          json[:operations].keys.each do |k|
+            unless k == :recover || k == :deactivate
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in core proof file"
+            end
+          end
+          if json[:operations][:recover]
+            unless json[:operations][:recover].is_a?(Array)
+              raise Sidetree::Error,
+                    "Core proof file recover property not array"
+            end
+            recover_proofs =
+              json[:operations][:recover].each.map do |update|
+                update.keys.each do |k|
+                  unless k == :signedData
+                    raise Sidetree::Error,
+                          "Unexpected property #{k.to_s} in core proof file"
+                  end
+                end
+                Sidetree::Util::JWS.parse(update[:signedData])
+              end
+          end
+          if json[:operations][:deactivate]
+            unless json[:operations][:deactivate].is_a?(Array)
+              raise Sidetree::Error,
+                    "Core proof file deactivate property not array"
+            end
+            deactivate_proofs =
+              json[:operations][:deactivate].each.map do |update|
+                update.keys.each do |k|
+                  unless k == :signedData
+                    raise Sidetree::Error,
+                          "Unexpected property #{k.to_s} in core proof file"
+                  end
+                end
+                Sidetree::Util::JWS.parse(update[:signedData])
+              end
+          end
+          if recover_proofs.length + deactivate_proofs.length == 0
+            raise Sidetree::Error, "Core proof file has no proof"
+          end
+          CoreProofFile.new(recover_proofs, deactivate_proofs)
+        rescue JSON::ParserError
+          raise Sidetree::Error, "Core proof file is not json"
+        end
+      end
+
+      # Build json string to be stored in CAS.
+      # @return [String] json string.
+      def to_json
+        operations = {}
+        operations[:recover] = recover_proofs.map do |u|
+          { signedData: u.to_s }
+        end unless recover_proofs.empty?
+        operations[:deactivate] = deactivate_proofs.map do |u|
+          { signedData: u.to_s }
+        end unless deactivate_proofs.empty?
+        params = { operations: operations }
+        params.to_json
+      end
+    end
+  end
+end

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

@@ -10,22 +10,22 @@ module Sidetree
       def initialize(public_keys: [], services: [])
         public_keys.each do |public_key|
           unless public_key.is_a?(Sidetree::Key)
-            raise Error, 'public_keys should be array of Sidetree::Key objects.'
+            raise Error, "public_keys should be array of Sidetree::Key objects."
           end
         end
         id_set = public_keys.map(&:id)
         if (id_set.count - id_set.uniq.count) > 0
-          raise Error 'Public key id has to be unique.'
+          raise Error "Public key id has to be unique."
         end
         services.each do |service|
           unless service.is_a?(Sidetree::Model::Service)
             raise Error,
-                  'services should be array of Sidetree::Model::Service objects.'
+                  "services should be array of Sidetree::Model::Service objects."
           end
         end
         id_set = services.map(&:id)
         if (id_set.count - id_set.uniq.count) > 0
-          raise Error 'Service id has to be unique.'
+          raise Error "Service id has to be unique."
         end
 
         @public_keys = public_keys
@@ -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/service.rb

@@ -10,13 +10,13 @@ module Sidetree
       # @raise [Sidetree::Error]
       def initialize(id, type, endpoint)
         Sidetree::Validator.validate_id!(id)
-        raise Error, 'type should be String.' unless type.is_a?(String)
+        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.'
+          raise Error, "Service endpoint value cannot be an array."
         end
 
         Sidetree::Validator.validate_uri!(endpoint) if endpoint.is_a?(String)
@@ -33,16 +33,16 @@ module Sidetree
       # @raise [Sidetree::Error]
       # @return [Sidetree::Model::Service]
       def self.from_hash(data)
-        Service.new(data['id'], data['type'], data['serviceEndpoint'])
+        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["id"] = id if id
+        hash["type"] = type if type
+        hash["serviceEndpoint"] = endpoint if endpoint
         hash
       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

@@ -1,8 +1,15 @@
 module Sidetree
   module Model
-    autoload :Suffix, 'sidetree/model/suffix'
-    autoload :Delta, 'sidetree/model/delta'
-    autoload :Document, 'sidetree/model/document'
-    autoload :Service, 'sidetree/model/service'
+    autoload :Suffix, "sidetree/model/suffix"
+    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