sidetree 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a4b7ce3f8ab94c646d21e2083664437b75877ee43264b172fdcadd8f8c9fffc
-  data.tar.gz: 3ed1dee9aaba4e13f3122d57f9b875c5279c2148a3cbf1e6818d2073e9d7759e
+  metadata.gz: 0c2645dbb06ae761fe9e966134e7b824a2d3832f9972cd0808f92d46b3f6056e
+  data.tar.gz: bce1dce70b331c7b7093ceffa8c1af4e6953914f12aae2543cf6bcc9839ba97e
 SHA512:
-  metadata.gz: 4d87cd2fae36188a3e24d37f73f99637a6a55ef8d2e300261f46595811194d2cbccc2ea9b6da3ad77564f3312ce2ee51561814a9cf02c261031b35438b2df0d5
-  data.tar.gz: f9fbb814e7536a672f3f12b2c83fbf9af4f5072a0ee210e9935ce8b627972d659d28d36df9f7425e5b3c44edd7589a8fec7b68cb1b1d34c2af711c3eedd02316
+  metadata.gz: ff5f5050ec0097e8a6f9a46d7f56c1bf43c08844d0b74a438d9daf07e508b67868537b8ab788658894a9b086673e697cab9aa9d8872c0437a61c169081986719
+  data.tar.gz: 7252b89b1c99ee2a5cc4bcb15a6f10cf08c556881665b0d5132a2aafbb414d9a51e0aafc8180b4dd3dc2e96efb40f01d9334ae5dcc493043a318002bc4b3e699

data/lib/sidetree/cas/fetch_result.rb

@@ -0,0 +1,20 @@
+module Sidetree
+  module CAS
+    class FetchResult
+      CODE_CAS_NOT_REACHABLE = "cas_not_reachable"
+      CODE_INVALID_HASH = "content_hash_invalid"
+      CODE_MAX_SIZE_EXCEEDED = "content_exceeds_maximum_allowed_size"
+      CODE_NOT_FILE = "content_not_a_file"
+      CODE_NOT_FOUND = "content_not_found"
+      CODE_SUCCESS = "success"
+
+      attr_reader :code
+      attr_reader :content
+
+      def initialize(code, content = nil)
+        @code = code
+        @content = content
+      end
+    end
+  end
+end

data/lib/sidetree/cas/ipfs.rb

@@ -0,0 +1,101 @@
+require "securerandom"
+require "uri"
+require "net/http"
+
+module Sidetree
+  module CAS
+    class IPFS
+      attr_reader :base_url
+      attr_reader :fetch_timeout
+
+      # @raise [Sidetree::Error]
+      def initialize(
+        schema: "http",
+        host: "localhost",
+        port: 5001,
+        base_path: "/api/v0",
+        fetch_timeout: nil
+      )
+        @base_url = "#{schema}://#{host}:#{port}#{base_path}"
+        @fetch_timeout = fetch_timeout
+        raise Sidetree::Error, "Failed to connect to IPFS endpoint." unless up?
+      end
+
+      # Writes the given content to CAS.
+      # @param [String] content content to be stored.
+      # @return [String] SHA256 hash in base64url encoding which represents the address of the content.
+      # @raise [Sidetree::Error] If IPFS write fails
+      def write(content)
+        multipart_boundary = SecureRandom.hex(32)
+        uri = URI("#{base_url}/add")
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        req = Net::HTTP::Post.new(uri)
+        req[
+          "Content-Type"
+        ] = "multipart/form-data; boundary=#{multipart_boundary}"
+        req["Content-Disposition"] = 'form-data; name=; filename=""'
+        req.body = build_body(multipart_boundary, content)
+        res = http.request(req)
+        if res.is_a?(Net::HTTPSuccess)
+          results = JSON.parse(res.body)
+          results["Hash"]
+        else
+          raise Sidetree::Error, "Failed writing content. #{res.body}"
+        end
+      end
+
+      # Get content from IPFS.
+      # @param [String] addr cas uri.
+      # @return [Sidetree::CAS::FetchResult] Fetch result containing the content if found.
+      # The result code is set to FetchResultCode.MaxSizeExceeded if the content exceeds the +max_bytesize+.
+      def read(addr)
+        fetch_url = "#{base_url}/cat?arg=#{addr}"
+        begin
+          res = Net::HTTP.post_form(URI(fetch_url), {})
+          if res.is_a?(Net::HTTPSuccess)
+            FetchResult.new(FetchResult::CODE_SUCCESS, res.body)
+          else
+            FetchResult.new(FetchResult::CODE_NOT_FOUND)
+          end
+        rescue Errno::ECONNREFUSED
+          FetchResult.new(FetchResult::CODE_CAS_NOT_REACHABLE)
+        rescue StandardError
+          FetchResult.new(FetchResult::CODE_NOT_FOUND)
+        end
+      end
+
+      # Get node information from IPFS endpoint.
+      # @return [String] node information.
+      def id
+        res = Net::HTTP.post_form(URI("#{base_url}/id"), {})
+        res.body if res.is_a?(Net::HTTPSuccess)
+      end
+
+      # Check IPFS endpoint are up and running.
+      # @return [Boolean]
+      def up?
+        begin
+          id
+          true
+        rescue Errno::ECONNREFUSED
+          false
+        end
+      end
+
+      private
+
+      # Fetch content from IPFS.
+      def fetch(uri, max_bytesize: nil)
+      end
+
+      def build_body(boundary, content)
+        begin_boundary = "--#{boundary}\n"
+        first_part_content_type = "Content-Disposition: form-data;\n"
+        first_part_content_type += "Content-Type: application/octet-stream\n\n"
+        end_boundary = "\n--#{boundary}--"
+        begin_boundary + first_part_content_type + content + end_boundary
+      end
+    end
+  end
+end

data/lib/sidetree/cas.rb

@@ -0,0 +1,6 @@
+module Sidetree
+  module CAS
+    autoload :FetchResult, "sidetree/cas/fetch_result"
+    autoload :IPFS, "sidetree/cas/ipfs"
+  end
+end

data/lib/sidetree/key.rb

@@ -12,7 +12,7 @@ module Sidetree
       public_key: nil,
       id: nil,
       purposes: [],
-      type: nil
+      type: Sidetree::Params::DEFAULT_PUBKEY_TYPE
     )
       if private_key
         unless Key.valid_private_key?(private_key)
@@ -56,21 +56,26 @@ module Sidetree
     end
 
     # Generate Secp256k1 key.
-    # @option [String] id Public key ID.
-    # @option [String] purpose Purpose for public key. Supported values defined by [Sidetree::PublicKeyPurpose].
+    # @param [String] id Public key ID.
+    # @param [String] purpose Purpose for public key. Supported values defined by [Sidetree::PublicKeyPurpose].
+    # @param [String] type The type of public key defined by https://w3c-ccg.github.io/ld-cryptosuite-registry/.
     # @return [Sidetree::Key]
     # @raise [Sidetree::Error]
-    def self.generate(id: nil, purposes: [])
+    def self.generate(
+      id: nil,
+      purposes: [],
+      type: Sidetree::Params::DEFAULT_PUBKEY_TYPE
+    )
       private_key =
         1 + SecureRandom.random_number(ECDSA::Group::Secp256k1.order - 1)
-      Key.new(private_key: private_key, purposes: purposes, id: id)
+      Key.new(private_key: private_key, purposes: purposes, id: id, type: type)
     end
 
     # Generate key instance from jwk Hash.
     # @param [Hash] data jwk Hash object.
     # @return [Sidetree::Key]
     # @raise [Sidetree::Error]
-    def self.from_hash(data)
+    def self.from_jwk(data)
       key_data = data["publicKeyJwk"] ? data["publicKeyJwk"] : data
       key_type = key_data["kty"]
       curve = key_data["crv"]

data/lib/sidetree/model/chunk.rb

@@ -0,0 +1,21 @@
+module Sidetree
+  module Model
+    class Chunk
+      attr_reader :chunk_file_uri
+
+      # Initializer
+      # @param [String] chunk_file_uri chunk file uri.
+      # @raise [Sidetree::Error]
+      def initialize(chunk_file_uri)
+        unless chunk_file_uri.is_a?(String)
+          raise Sidetree::Error, "chunk_file_uri must be String"
+        end
+        @chunk_file_uri = chunk_file_uri
+      end
+
+      def to_h
+        { chunkFileUri: chunk_file_uri }
+      end
+    end
+  end
+end

data/lib/sidetree/model/chunk_file.rb

@@ -0,0 +1,80 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#chunk-files
+    class ChunkFile
+      attr_reader :deltas # Array of Sidetree::Model::Delta
+
+      def initialize(deltas = [])
+        deltas.each do |delta|
+          unless delta.is_a?(Sidetree::Model::Delta)
+            raise Sidetree::Error,
+                  "deltas contains data that is not Sidetree::Model::Delta object."
+          end
+        end
+        @deltas = deltas
+      end
+
+      # Generate chunk file from operations.
+      # @param [Array[Sidetree::OP::Create]] create_ops
+      # @param [Array[Sidetree::OP::Recover]] recover_ops
+      # @param [Array[Sidetree::OP::Update]] update_ops
+      def self.create_from_ops(create_ops: [], recover_ops: [], update_ops: [])
+        deltas = create_ops.map(&:delta)
+        # TODO add update and recover operation delta
+        ChunkFile.new(deltas)
+      end
+
+      # Parse chunk file from compressed data.
+      # @param [String] chunk_file compressed chunk file data.
+      # @param [Boolean] compressed Whether the chunk_file is compressed or not, default: true.
+      # @return [Sidetree::Model::ChunkFile]
+      # @raise [Sidetree::Error]
+      def self.parse(chunk_file, compressed: true)
+        max_bytes =
+          Sidetree::Params::MAX_CHUNK_FILE_SIZE *
+            Sidetree::Util::Compressor::ESTIMATE_DECOMPRESSION_MULTIPLIER
+        decompressed =
+          (
+            if compressed
+              Sidetree::Util::Compressor.decompress(
+                chunk_file,
+                max_bytes: max_bytes
+              )
+            else
+              chunk_file
+            end
+          )
+        json = JSON.parse(decompressed, symbolize_names: true)
+        json.keys.each do |k|
+          unless k == :deltas
+            raise Sidetree::Error,
+                  "Unexpected property #{k.to_s} in chunk file."
+          end
+        end
+        unless json[:deltas].is_a?(Array)
+          raise Sidetree::Error,
+                "Invalid chunk file, deltas property is not an array."
+        end
+        ChunkFile.new(
+          json[:deltas].map do |delta|
+            Sidetree::Model::Delta.from_object(delta)
+          end
+        )
+      end
+
+      # Compress this chunk file
+      # @return [String] compressed data.
+      def to_compress
+        params = { deltas: deltas.map(&:to_h) }
+        Sidetree::Util::Compressor.compress(params.to_json)
+      end
+
+      # Check if the +other+ object have the same chunk data.
+      # @return [Boolean]
+      def ==(other)
+        return false unless other.is_a?(ChunkFile)
+        deltas == other.deltas
+      end
+    end
+  end
+end

data/lib/sidetree/model/core_index_file.rb

@@ -0,0 +1,204 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#core-index-file
+    class CoreIndexFile
+      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
+              begin
+                Sidetree::Util::Compressor.decompress(
+                  index_data,
+                  max_bytes: Sidetree::Params::MAX_CORE_INDEX_FILE_SIZE
+                )
+              rescue Zlib::GzipFile::Error
+                raise Sidetree::Error, "Core index file decompression failure"
+              end
+            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
+
+      # Compress this core index file
+      # @return [String] compressed data.
+      def to_compress
+        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
+        Sidetree::Util::Compressor.compress(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/provisional_index_file.rb

@@ -0,0 +1,134 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#provisional-index-file
+    class ProvisionalIndexFile
+      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
+              begin
+                Sidetree::Util::Compressor.decompress(
+                  index_data,
+                  max_bytes: Sidetree::Params::MAX_PROVISIONAL_INDEX_FILE_SIZE
+                )
+              rescue Zlib::GzipFile::Error
+                raise Sidetree::Error,
+                      "Provisional Index File decompression failure"
+              end
+            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
+
+      # Compress this provisional index file
+      # @return [String] compressed data.
+      def to_compress
+        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
+        Sidetree::Util::Compressor.compress(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,9 @@ module Sidetree
     autoload :Delta, "sidetree/model/delta"
     autoload :Document, "sidetree/model/document"
     autoload :Service, "sidetree/model/service"
+    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"
   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,76 @@
 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 = JSON::JWS.decode_compact_serialized(v, :skip_verification)
+              unless jws.keys.length == 2
+                raise Sidetree::Error,
+                      "Deactivate operation signed data missing or unknown property"
+              end
+            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,84 @@
+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
+      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"
+        )
+        @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 = JSON::JWS.decode_compact_serialized(v, :skip_verification)
+              unless jws.keys.length ==
+                       (type == Sidetree::OP::Type::RECOVER ? 3 : 2)
+                raise Sidetree::Error,
+                      "#{type.capitalize} operation signed data missing or unknown property"
+              end
+            when :delta
+              delta = Sidetree::Model::Delta.from_object(v)
+            else
+              raise Sidetree::Error,
+                    "Unexpected property #{k.to_s} in #{type} operation"
+            end
+          end
+          if jws
+            key =
+              type == Sidetree::OP::Type::UPDATE ? "updateKey" : "recoveryKey"
+            Validator.validate_canonicalize_object_hash!(
+              jws[key],
+              revealed_value,
+              "#{type.capitalize} key"
+            )
+          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
+    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

data/lib/sidetree/util.rb

@@ -0,0 +1,6 @@
+module Sidetree
+  module Util
+    autoload :Compressor, "sidetree/util/compressor"
+    autoload :AnchoredDataSerializer, "sidetree/util/anchored_data_serializer"
+  end
+end

data/lib/sidetree/validator.rb

@@ -215,6 +215,18 @@ module Sidetree
       end
     end
 
+    # Verify that the Multihash of +content+ matches that of +multihash+.
+    # @param [String] content content to be hashed
+    # @param [String] multihash Hash value to be checked
+    # @param [String] target Name of the target object to include in the error message
+    # @raise [Sidetree::Error]
+    def validate_canonicalize_object_hash!(content, multihash, target)
+      unless Sidetree.to_hash(content) == multihash
+        raise Sidetree::Error,
+              "Canonicalized #{target} object hash does not match expected hash '#{multihash}'"
+      end
+    end
+
     def validate_did_type!(type)
       return unless type
       raise Error, "DID type must be a string." unless type.instance_of?(String)
@@ -245,5 +257,16 @@ module Sidetree
       validate_encoded_multi_hash!(suffix[:deltaHash], "delta hash")
       validate_did_type!(suffix[:type])
     end
+
+    def validate_cas_file_uri!(uri, target)
+      unless uri.is_a?(String)
+        raise Sidetree::Error,
+              "Input #{target} CAS file URI '#{uri}' needs to be of string type"
+      end
+      if uri.bytesize > Sidetree::Params::MAX_CAS_URI_LENGTH
+        raise Sidetree::Error,
+              "Input #{target} CAS file URI byte size cannot exceed #{Sidetree::Params::MAX_CAS_URI_LENGTH}"
+      end
+    end
   end
 end

data/lib/sidetree/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Sidetree
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

data/lib/sidetree.rb

@@ -13,11 +13,13 @@ module Sidetree
   class Error < StandardError
   end
 
+  autoload :Util, "sidetree/util"
   autoload :Key, "sidetree/key"
   autoload :DID, "sidetree/did"
   autoload :Model, "sidetree/model"
   autoload :OP, "sidetree/op"
   autoload :Validator, "sidetree/validator"
+  autoload :CAS, "sidetree/cas"
 
   module Params
     # Algorithm for generating hashes of protocol-related values. 0x12 = sha2-256
@@ -26,7 +28,20 @@ module Sidetree
 
     # Maximum canonicalized operation delta buffer size.
     MAX_DELTA_SIZE = 1000
-
+    # Maximum compressed chunk file size. 10MB.
+    MAX_CHUNK_FILE_SIZE = 10_000_000
+    # Maximum compressed Provisional Index File size. 1 MB (zipped)
+    MAX_PROVISIONAL_INDEX_FILE_SIZE = 1_000_000
+    # Maximum compressed Core Index File size. 1 MB (zipped)
+    MAX_CORE_INDEX_FILE_SIZE = 1_000_000
+    # Maximum writer lock ID size
+    MAX_WRITER_LOCK_ID_SIZE = 200
+    # Maximum length of CAS URIs. 100 bytes
+    MAX_CAS_URI_LENGTH = 100
+    # Maximum number of operations per batch. 10000 ops.
+    MAX_OPERATION_COUNT = 10_000
+    # Default public key type
+    DEFAULT_PUBKEY_TYPE = "EcdsaSecp256k1VerificationKey2019"
     # Default DID method
     DEFAULT_METHOD = "sidetree"
 

data/sidetree.gemspec

@@ -39,5 +39,6 @@ Gem::Specification.new do |spec|
   # 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', '~> 3.1.2'
+  spec.add_development_dependency 'prettier', '~> 3.2.0'
+  spec.add_development_dependency 'webmock', '~> 3.14.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sidetree
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - azuchi
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-06-29 00:00:00.000000000 Z
+date: 2022-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ecdsa
@@ -86,14 +86,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.2
+        version: 3.2.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.1.2
+        version: 3.2.0
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.14.0
 description: Ruby implementation for Sidetree protocol.
 email:
 - azuchi@chaintope.com
@@ -116,11 +130,18 @@ files:
 - bin/console
 - bin/setup
 - lib/sidetree.rb
+- lib/sidetree/cas.rb
+- lib/sidetree/cas/fetch_result.rb
+- lib/sidetree/cas/ipfs.rb
 - lib/sidetree/did.rb
 - lib/sidetree/key.rb
 - lib/sidetree/model.rb
+- lib/sidetree/model/chunk.rb
+- lib/sidetree/model/chunk_file.rb
+- lib/sidetree/model/core_index_file.rb
 - lib/sidetree/model/delta.rb
 - lib/sidetree/model/document.rb
+- lib/sidetree/model/provisional_index_file.rb
 - lib/sidetree/model/service.rb
 - lib/sidetree/model/suffix.rb
 - lib/sidetree/op.rb
@@ -128,6 +149,11 @@ files:
 - lib/sidetree/op/create.rb
 - lib/sidetree/op/deactivate.rb
 - lib/sidetree/op/recover.rb
+- lib/sidetree/op/updatable.rb
+- lib/sidetree/op/update.rb
+- lib/sidetree/util.rb
+- lib/sidetree/util/anchored_data_serializer.rb
+- lib/sidetree/util/compressor.rb
 - lib/sidetree/validator.rb
 - lib/sidetree/version.rb
 - sidetree.gemspec