sidetree 0.1.1 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5a4b7ce3f8ab94c646d21e2083664437b75877ee43264b172fdcadd8f8c9fffc
-  data.tar.gz: 3ed1dee9aaba4e13f3122d57f9b875c5279c2148a3cbf1e6818d2073e9d7759e
+  metadata.gz: 9d82e9b251c67c82450b5e76b413a69a660f8b941799c66692a731621213cd8d
+  data.tar.gz: a0a28978b8dcd21c631e6a1a2e0ff102c96ac22898485bce9e3877e9a558b13d
 SHA512:
-  metadata.gz: 4d87cd2fae36188a3e24d37f73f99637a6a55ef8d2e300261f46595811194d2cbccc2ea9b6da3ad77564f3312ce2ee51561814a9cf02c261031b35438b2df0d5
-  data.tar.gz: f9fbb814e7536a672f3f12b2c83fbf9af4f5072a0ee210e9935ce8b627972d659d28d36df9f7425e5b3c44edd7589a8fec7b68cb1b1d34c2af711c3eedd02316
+  metadata.gz: cc74695690231772786246306b93d0a674ee2da899cd953edcef91997bc778acab7d624a817e0274a0c1157ee1abe48e00d4e00626a818c485141216947b01dc
+  data.tar.gz: 678b4c0013e26cdca615f48669b373d82ff2d669be9b8190680b75704a68b1c0476f73c75d9aa3dca362b2e0f9131aa8f04fc8d6d59c45d7d084d2038be7744b

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/did.rb

@@ -48,8 +48,8 @@ module Sidetree
         raise Error, "recovery_key must be Sidetree::Key instance."
       end
 
-      patches = [{ action: OP::PatchAction::REPLACE, document: document.to_h }]
-      delta = Model::Delta.new(patches, update_key.to_commitment)
+      delta =
+        Model::Delta.new([document.to_replace_patch], update_key.to_commitment)
       suffix =
         Sidetree::Model::Suffix.new(delta.to_hash, recovery_key.to_commitment)
       DID.new(

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"]
@@ -123,10 +128,11 @@ module Sidetree
     end
 
     # Generate JSON::JWK object.
+    # @param [Boolean] include_privkey whether include private key or not.
     # @return [JSON::JWK]
-    def to_jwk
+    def to_jwk(include_privkey: false)
       jwk =
-        JSON::JWK.new(
+        Sidetree::Util::JWK.parse(
           kty: "EC",
           crv: "secp256k1",
           x:
@@ -146,18 +152,30 @@ module Sidetree
               padding: false
             )
         )
-      jwk["d"] = encoded_private_key if private_key
+      jwk["d"] = encoded_private_key if include_privkey && private_key
       jwk
     end
 
+    # Convert the private key to the format (OpenSSL::PKey::EC) in which it will be signed in JWS.
+    # @return [OpenSSL::PKey::EC]
+    def jws_sign_key
+      return nil unless private_key
+      to_jwk(include_privkey: true).to_key
+    end
+
     # Generate commitment for this key.
     # @return [String] Base64 encoded commitment.
     def to_commitment
       digest = Digest::SHA256.digest(to_jwk.normalize.to_json_c14n)
-
       Sidetree.to_hash(digest)
     end
 
+    # Generate reveal value for this key.
+    # @return [String] Base64 encoded reveal value.
+    def to_reveal_value
+      Sidetree.to_hash(to_jwk.normalize.to_json_c14n)
+    end
+
     def to_h
       h = { publicKeyJwk: to_jwk.normalize, purposes: purposes }
       h[:id] = id if id

data/lib/sidetree/model/cas_file_base.rb

@@ -0,0 +1,40 @@
+module Sidetree
+  module Model
+    class CASFileBase
+      include Sidetree::Util::Compressor
+
+      # Decompress +data+.
+      # @param [String] data compressed data.
+      # @param [Integer] max_size
+      # @return [String] decompressed data.
+      # @raise [Sidetree::Error]
+      def self.decompress(data, max_size)
+        begin
+          Sidetree::Util::Compressor.decompress(
+            data,
+            max_bytes:
+              max_size *
+                Sidetree::Util::Compressor::ESTIMATE_DECOMPRESSION_MULTIPLIER
+          )
+        rescue Zlib::GzipFile::Error
+          raise Sidetree::Error,
+                "#{self.name.split("::").last.split(/(?=[A-Z])/).join(" ")} decompression failure"
+        end
+      end
+
+      # Build json string to be stored in CAS.
+      # Child classes must implement this method.
+      # @return [String]
+      def to_json
+        raise NotImplementedError,
+              "You must implement #{self.class}##{__method__}"
+      end
+
+      # Generate compressed data via to_json to be stored in CAS.
+      # @return [String] compressed data.
+      def to_compress
+        compress(to_json)
+      end
+    end
+  end
+end

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,72 @@
+module Sidetree
+  module Model
+    # https://identity.foundation/sidetree/spec/#chunk-files
+    class ChunkFile < CASFileBase
+      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 + recover_ops + update_ops).map(&: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)
+        decompressed =
+          (
+            if compressed
+              decompress(chunk_file, Sidetree::Params::MAX_CHUNK_FILE_SIZE)
+            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
+
+      # Build json string to be stored in CAS.
+      # @return [String] json string.
+      def to_json
+        { deltas: deltas.map(&:to_h) }.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,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,105 @@
+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: recover_proofs,
+            deactivate_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