immudb 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e530750b846b9cbb85420fd917f44d965047526d4f3c2dd04105827d5e58b56
-  data.tar.gz: e64b188ed24cecad8641bcb700911308c33c4ace0c5fcb48b4419f0d57ed7fcf
+  metadata.gz: 0200e6229a8e67d2592feb14e0375910e5c62bf358ee826357fc4b0b03b17751
+  data.tar.gz: dcb8aab1b18fd45882517b7a4aaa76801ec0fdd8881676084df490e57af354b6
 SHA512:
-  metadata.gz: 3ccee301794025162563a425a08f758728b9971c88a35011dd4f6a11d9b7cf1cc98f5fdfedad0f5e978eb28089ec25334a64349d2366a8be6b486f8ad7b5be68
-  data.tar.gz: 520659b836111fd48fc56143bac7b59ebb4360d070d307c6ba331e1fe169fe5f9ecaaba0b1578d8eacc41502ec6409b751c0bb9436c79551a2137df717283dcb
+  metadata.gz: a0b20a298d7deb3783b988486c414d7486e242709cbb7b13fbab8579159cdb757ff68f870233a38da5a0aa0813c6c98415967a07bf4f808fc4a48764bec4204b
+  data.tar.gz: 5d2f796fea4da4e067f197a47469ae6bb95ccb4a24b4e81982948e113c79c7244827be5e33e8010431268975854f6d5802b6610a1f65ccafe71b4b25a356e87e

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.2.0 (2023-05-11)
+
+- Dropped support for Ruby < 3
+
+## 0.1.1 (2022-06-12)
+
+- Added support for verified methods with immudb 1.2.1+
+
 ## 0.1.0 (2021-12-31)
 
 - First release

data/lib/immudb/client.rb

@@ -1,4 +1,4 @@
-# Copyright 2021 CodeNotary, Inc. All rights reserved.
+# Copyright 2022 CodeNotary, Inc. All rights reserved.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -76,51 +76,61 @@ module Immudb
       nil
     end
 
-    def verified_set(key, value)
+    def verified_set(key, value, metadata: nil)
+      schema_metadata = metadata_to_proto(metadata)
       state = @rs.get
-      kv = Schema::KeyValue.new(key: key, value: value)
+      kv = Schema::KeyValue.new(key: key, value: value, metadata: schema_metadata)
 
       raw_request = Schema::VerifiableSetRequest.new(
         setRequest: Schema::SetRequest.new(KVs: [kv]),
         proveSinceTx: state.txId
       )
       verifiable_tx = grpc.verifiable_set(raw_request)
-      tx = Store.tx_from(verifiable_tx.tx)
-      inclusion_proof = tx.proof(SET_KEY_PREFIX + key)
-      ekv = Store.encode_kv(key, value)
-      verifies = Store.verify_inclusion(inclusion_proof, ekv.digest, tx.eh)
-      unless verifies
+      if verifiable_tx.tx.header.nentries != 1 || verifiable_tx.tx.entries.length != 1
         raise VerificationError
       end
-      if tx.eh != Store.digest_from(verifiable_tx.dualProof.targetTxMetadata.eH)
+      tx = Schema.tx_from_proto(verifiable_tx.tx)
+      entry_spec_digest = Store.entry_spec_digest_for(tx.header.version)
+      inclusion_proof = tx.proof(Database.encode_key(key))
+      md = tx.entries[0].metadata
+
+      if !md.nil? && md.deleted?
         raise VerificationError
       end
-      if state.txId == 0
-        source_id = tx.ID
-        source_alh = tx.Alh
-      else
-        source_id = state.txId
-        source_alh = Store.digest_from(state.txHash)
+
+      e = Database.encode_entry_spec(key, md, value)
+
+      verifies = Store.verify_inclusion(inclusion_proof, entry_spec_digest.call(e), tx.header.eh)
+      unless verifies
+        raise VerificationError
       end
-      target_id = tx.ID
-      target_alh = tx.Alh
-
-      verifies = Store.verify_dual_proof(
-        HTree.dual_proof_from(verifiable_tx.dualProof),
-        source_id,
-        target_id,
-        source_alh,
-        target_alh
-      )
-      if !verifies
+      if tx.header.eh != Schema.digest_from_proto(verifiable_tx.dualProof.targetTxHeader.eH)
         raise VerificationError
       end
+      source_id = state.txId
+      source_alh = Schema.digest_from_proto(state.txHash)
+      target_id = tx.header.iD
+      target_alh = tx.header.alh
+
+      if state.txId > 0
+        verifies = Store.verify_dual_proof(
+          Schema.dual_proof_from_proto(verifiable_tx.dualProof),
+          source_id,
+          target_id,
+          source_alh,
+          target_alh
+        )
+        unless verifies
+          raise VerificationError
+        end
+      end
+
       newstate = State.new(
         db: state.db,
         txId: target_id,
         txHash: target_alh,
         publicKey: verifiable_tx.signature&.publicKey,
-        signature: verifiable_tx.signature&.signature,
+        signature: verifiable_tx.signature&.signature
       )
       if !verifying_key.nil?
         newstate.verify(verifying_key)
@@ -142,43 +152,50 @@ module Immudb
       )
       ventry = grpc.verifiable_get(req)
 
-      inclusion_proof = HTree.inclusion_proof_from(ventry.inclusionProof)
-      dual_proof = HTree.dual_proof_from(ventry.verifiableTx.dualProof)
+      entry_spec_digest = Store.entry_spec_digest_for(ventry.verifiableTx.tx.header.version.to_i)
+      inclusion_proof = Schema.inclusion_proof_from_proto(ventry.inclusionProof)
+      dual_proof = Schema.dual_proof_from_proto(ventry.verifiableTx.dualProof)
 
       if ventry.entry.referencedBy.nil? || ventry.entry.referencedBy.key == ""
         vTx = ventry.entry.tx
-        kv = Store.encode_kv(key, ventry.entry.value)
+        e = Database.encode_entry_spec(key, Schema.kv_metadata_from_proto(ventry.entry.metadata), ventry.entry.value)
       else
-        vTx = ventry.entry.referencedBy.tx
-        kv = store.encode_reference(ventry.entry.referencedBy.key, ventry.entry.key, ventry.entry.referencedBy.atTx)
+        ref = ventry.entry.referencedBy
+        vTx = ref.tx
+        e = Database.encode_reference(ref.key, Schema.kv_metadata_from_proto(ref.metadata), ventry.entry.key, ref.atTx)
       end
 
       if state.txId <= vTx
-        eh = Store.digest_from(ventry.verifiableTx.dualProof.targetTxMetadata.eH)
+        eh = Schema.digest_from_proto(ventry.verifiableTx.dualProof.targetTxHeader.eH)
         source_id = state.txId
-        source_alh = Store.digest_from(state.txHash)
+        source_alh = Schema.digest_from_proto(state.txHash)
         target_id = vTx
-        target_alh = dual_proof.targetTxMetadata.alh
+        target_alh = dual_proof.targetTxHeader.alh
       else
-        eh = Store.digest_from(ventry.verifiableTx.dualProof.sourceTxMetadata.eH)
+        eh = Schema.digest_from_proto(ventry.verifiableTx.dualProof.sourceTxHeader.eH)
         source_id = vTx
-        source_alh = dual_proof.sourceTxMetadata.alh
+        source_alh = dual_proof.sourceTxHeader.alh
         target_id = state.txId
-        target_alh = store.digest_from(state.txHash)
+        target_alh = Schema.digest_from_proto(state.txHash)
       end
 
-      verifies = Store.verify_inclusion(inclusion_proof, kv.digest, eh)
+      verifies = Store.verify_inclusion(inclusion_proof, entry_spec_digest.call(e), eh)
       if !verifies
         raise VerificationError
       end
-      verifies = Store.verify_dual_proof(
-          dual_proof,
-          source_id,
-          target_id,
-          source_alh,
-          target_alh)
-      if !verifies
-        raise VerificationError
+
+      if state.txId > 0
+        verifies =
+          Store.verify_dual_proof(
+            dual_proof,
+            source_id,
+            target_id,
+            source_alh,
+            target_alh
+          )
+        if !verifies
+          raise VerificationError
+        end
       end
       newstate = State.new(
         db: state.db,
@@ -362,5 +379,22 @@ module Immudb
         name
       end
     end
+
+    def metadata_to_proto(metadata)
+      schema_metadata = nil
+      if metadata
+        schema_metadata = Schema::KVMetadata.new
+        if metadata.deleted?
+          schema_metadata.deleted = true
+        end
+        if metadata.expirable?
+          schema_metadata.expiration = Schema::Expiration.new(expiresAt: metadata.expiration_time.to_i)
+        end
+        if metadata.non_indexable?
+          schema_metadata.nonIndexable = true
+        end
+      end
+      schema_metadata
+    end
   end
 end

data/lib/immudb/database.rb

@@ -0,0 +1,33 @@
+# Copyright 2022 CodeNotary, Inc. All rights reserved.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#       http://www.apache.org/licenses/LICENSE-2.0
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Immudb
+  module Database
+    class << self
+      def wrap_with_prefix(b, prefix)
+        prefix + b
+      end
+
+      def encode_key(key)
+        wrap_with_prefix(key, SET_KEY_PREFIX)
+      end
+
+      def encode_entry_spec(key, md, value)
+        EntrySpec.new(
+          key: wrap_with_prefix(key, SET_KEY_PREFIX),
+          md: md,
+          value: wrap_with_prefix(value, PLAIN_VALUE_PREFIX)
+        )
+      end
+    end
+  end
+end

data/lib/immudb/dual_proof.rb

@@ -12,6 +12,6 @@
 
 module Immudb
   class DualProof
-    attr_accessor :sourceTxMetadata, :targetTxMetadata, :inclusionProof, :consistencyProof, :targetBlTxAlh, :lastInclusionProof, :linearProof
+    attr_accessor :sourceTxHeader, :targetTxHeader, :inclusionProof, :consistencyProof, :targetBlTxAlh, :lastInclusionProof, :linearProof
   end
 end

data/lib/immudb/{txe.rb → entry_spec.rb}

@@ -1,4 +1,4 @@
-# Copyright 2021 CodeNotary, Inc. All rights reserved.
+# Copyright 2022 CodeNotary, Inc. All rights reserved.
 
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -11,17 +11,13 @@
 # limitations under the License.
 
 module Immudb
-  class TXe
-    attr_accessor :key_len, :key, :value_len, :h_value, :v_off
+  class EntrySpec
+    attr_reader :key, :metadata, :value
 
-    def set_key(key)
-      @key = key.dup
-      @key_len = key.length
-    end
-
-    def digest
-      b = @key + @h_value
-      Digest::SHA256.digest(b)
+    def initialize(key:, md:, value:)
+      @key = key
+      @metadata = md
+      @value = value
     end
   end
 end