sidetree 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 55fc6b6c312458a0e0d627daeb1f1f5cd84e87a6f1b74c0a9a9d584848e31a8a
-  data.tar.gz: 34a4aa6ee3457c84b0d1148108d19f5e7afea5f32d1210299ca530bdd00d6a59
+  metadata.gz: b65f50d961dcfc15f1440ae26225fad38a7b42f43874764005b9d01cc624bb3a
+  data.tar.gz: dbe04b5d7072da5b1cbec36b90089d29cb69e6077cc60a501045d0eddff38d92
 SHA512:
-  metadata.gz: 47cfc0743c8da5ccf12bae7fa2114474607a0f68814fccf0738390f87bc52855e96b2eaedc70b68328a8b7b0b7dbc892f6eba199a0ba87b842b369e71603d472
-  data.tar.gz: 0032c7d6faedaf3873fdc1594f19eb3ceb431129cb5fd2dd436e322dfb9b5a155e5901c87c0530e9b42bb6d3ca01562e393c83bbc62f51ec61d4f4c4c37a8c25
+  metadata.gz: e7aa774c61569b33aa98de41aa6ab265c58107346704aaebf673e45bc464f250f1073ea70994ae1a884cbd92964dc7e84b1841e2cbfc917601157a2eea1a7854
+  data.tar.gz: a68ccd2615046db978b08dcffa585611f2ed44ee59a765e0c53614074892ad83e5f733df493bc8f06a15a4b264c777c52867f486562e13918b5cf4fff236c758

data/.github/workflows/main.yml

@@ -7,7 +7,7 @@ jobs:
     strategy:
       fail-fast: true
       matrix:
-        ruby: [2.6, 2.7, 3.0, 3.1]
+        ruby: [2.7, 3.0, 3.1]
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2

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

@@ -6,21 +6,21 @@ module Sidetree
 
     # @raise [Sidetree::Error]
     def initialize(did)
-      if !did.start_with?('did:ion:') && !did.start_with?('did:sidetree:')
-        raise Error, 'Expected DID method not given in DID.'
+      if !did.start_with?("did:ion:") && !did.start_with?("did:sidetree:")
+        raise Error, "Expected DID method not given in DID."
       end
-      if did.count(':') > (Sidetree::Params.testnet? ? 4 : 3)
-        raise Error, 'Unsupported DID format.'
+      if did.count(":") > (Sidetree::Params.testnet? ? 4 : 3)
+        raise Error, "Unsupported DID format."
       end
       if Sidetree::Params.testnet?
-        _, @method, _, @suffix, @long_suffix = did.split(':')
+        _, @method, _, @suffix, @long_suffix = did.split(":")
       else
-        _, @method, @suffix, @long_suffix = did.split(':')
+        _, @method, @suffix, @long_suffix = did.split(":")
       end
 
       if @long_suffix
         unless suffix == create_op.suffix.unique_suffix
-          raise Error, 'DID document mismatches short-form DID.'
+          raise Error, "DID document mismatches short-form DID."
         end
       end
     end
@@ -39,19 +39,17 @@ module Sidetree
       method: Sidetree::Params::DEFAULT_METHOD
     )
       unless document.is_a?(Sidetree::Model::Document)
-        raise Error, 'document must be Sidetree::Model::Document instance.'
+        raise Error, "document must be Sidetree::Model::Document instance."
       end
       unless update_key.is_a?(Sidetree::Key)
-        raise Error, 'update_key must be Sidetree::Key instance.'
+        raise Error, "update_key must be Sidetree::Key instance."
       end
       unless recovery_key.is_a?(Sidetree::Key)
-        raise Error, 'recovery_key must be Sidetree::Key instance.'
+        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,18 +12,18 @@ 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)
-          raise Error, 'private key is invalid range.'
+          raise Error, "private key is invalid range."
         end
 
         @private_key = private_key
         pub = ECDSA::Group::Secp256k1.generator.multiply_by_scalar(private_key)
         if public_key
           unless pub == public_key
-            raise Error, 'Public and private keys do not match.'
+            raise Error, "Public and private keys do not match."
           end
         else
           public_key = pub
@@ -31,13 +31,13 @@ module Sidetree
       end
 
       unless public_key
-        raise Error, 'Specify either the private key or the public key'
+        raise Error, "Specify either the private key or the public key"
       end
       unless public_key.is_a?(ECDSA::Point)
-        raise Error, 'public key must be an ECDSA::Point instance.'
+        raise Error, "public key must be an ECDSA::Point instance."
       end
       unless ECDSA::Group::Secp256k1.valid_public_key?(public_key)
-        raise Error, 'public key is invalid.'
+        raise Error, "public key is invalid."
       end
 
       @public_key = public_key
@@ -56,62 +56,67 @@ 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)
-      key_data = data['publicKeyJwk'] ? data['publicKeyJwk'] : data
-      key_type = key_data['kty']
-      curve = key_data['crv']
-      if key_type.nil? || key_type != 'EC'
+    def self.from_jwk(data)
+      key_data = data["publicKeyJwk"] ? data["publicKeyJwk"] : data
+      key_type = key_data["kty"]
+      curve = key_data["crv"]
+      if key_type.nil? || key_type != "EC"
         raise Error, "Unsupported key type '#{key_type}' specified."
       end
-      if curve.nil? || curve != 'secp256k1'
+      if curve.nil? || curve != "secp256k1"
         raise Error, "Unsupported curve '#{curve}' specified."
       end
-      raise Error, 'x property required.' unless key_data['x']
-      raise Error, 'y property required.' unless key_data['y']
+      raise Error, "x property required." unless key_data["x"]
+      raise Error, "y property required." unless key_data["y"]
 
       # `x` and `y` need 43 Base64URL encoded bytes to contain 256 bits.
-      unless key_data['x'].length == 43
+      unless key_data["x"].length == 43
         raise Error, "Secp256k1 JWK 'x' property must be 43 bytes."
       end
-      unless key_data['y'].length == 43
+      unless key_data["y"].length == 43
         raise Error, "Secp256k1 JWK 'y' property must be 43 bytes."
       end
 
-      x = Base64.urlsafe_decode64(key_data['x'])
-      y = Base64.urlsafe_decode64(key_data['y'])
+      x = Base64.urlsafe_decode64(key_data["x"])
+      y = Base64.urlsafe_decode64(key_data["y"])
       point =
         ECDSA::Format::PointOctetString.decode(
-          ['04'].pack('H*') + x + y,
+          ["04"].pack("H*") + x + y,
           ECDSA::Group::Secp256k1
         )
       private_key =
-        if key_data['d']
-          Base64.urlsafe_decode64(key_data['d']).unpack1('H*').to_i(16)
+        if key_data["d"]
+          Base64.urlsafe_decode64(key_data["d"]).unpack1("H*").to_i(16)
         else
           nil
         end
 
-      purposes = data['purposes'] ? data['purposes'] : []
+      purposes = data["purposes"] ? data["purposes"] : []
       Key.new(
         public_key: point,
         private_key: private_key,
         purposes: purposes,
-        id: data['id'],
-        type: data['type']
+        id: data["id"],
+        type: data["type"]
       )
     end
 
@@ -123,12 +128,13 @@ 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(
-          kty: 'EC',
-          crv: 'secp256k1',
+        Sidetree::Util::JWK.parse(
+          kty: "EC",
+          crv: "secp256k1",
           x:
             Base64.urlsafe_encode64(
               ECDSA::Format::FieldElementOctetString.encode(
@@ -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
@@ -170,7 +188,7 @@ module Sidetree
     def encoded_private_key
       if private_key
         Base64.urlsafe_encode64(
-          [private_key.to_s(16).rjust(32 * 2, '0')].pack('H*'),
+          [private_key.to_s(16).rjust(32 * 2, "0")].pack("H*"),
           padding: false
         )
       else

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