immudb 0.1.0 → 0.2.0

data/lib/immudb/htree.rb

@@ -95,26 +95,5 @@ module Immudb
         end
       end
     end
-
-    def self.inclusion_proof_from(iproof)
-      h = InclusionProof.new
-      h.leaf = iproof.leaf.to_i
-      h.width = iproof.width.to_i
-      h.terms = Store.digest_from(iproof.terms)
-      h
-    end
-
-    def self.dual_proof_from(dproof)
-      dp = DualProof.new
-      dp.sourceTxMetadata = Store.tx_metadata_from(dproof.sourceTxMetadata)
-      dp.targetTxMetadata = Store.tx_metadata_from(dproof.targetTxMetadata)
-      dp.inclusionProof = Store.digest_from(dproof.inclusionProof)
-      # use digests_from?
-      dp.consistencyProof = Store.digests_from(dproof.consistencyProof)
-      dp.targetBlTxAlh = Store.digest_from(dproof.targetBlTxAlh)
-      dp.lastInclusionProof = Store.digests_from(dproof.lastInclusionProof)
-      dp.linearProof = Store.linear_proof_from(dproof.linearProof)
-      dp
-    end
   end
 end

data/lib/immudb/kv_metadata.rb

@@ -0,0 +1,88 @@
+# 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
+  class KVMetadata
+    DELETED_ATTR_CODE = 0
+    EXPIRES_AT_ATTR_CODE = 1
+    NON_INDEXABLE_ATTR_CODE = 2
+
+    def initialize
+      @attributes = {}
+      @readonly = false
+    end
+
+    def as_deleted(deleted)
+      if @readonly
+        raise Error, "Read-only"
+      elsif !deleted
+        @attributes.delete(DELETED_ATTR_CODE)
+      else
+        @attributes[DELETED_ATTR_CODE] = nil
+      end
+    end
+
+    def deleted?
+      @attributes.key?(DELETED_ATTR_CODE)
+    end
+
+    def expires_at(expires_at)
+      if @readonly
+        raise Error, "Read-only"
+      end
+      @attributes[EXPIRES_AT_ATTR_CODE] = expires_at
+    end
+
+    def non_expirable
+      @attributes.delete(EXPIRES_AT_ATTR_CODE)
+    end
+
+    def expirable?
+      @attributes.key?(EXPIRES_AT_ATTR_CODE)
+    end
+
+    def expiration_time
+      if @attributes.key?(EXPIRES_AT_ATTR_CODE)
+        @attributes[EXPIRES_AT_ATTR_CODE]
+      else
+        raise Error, "Non-expirable"
+      end
+    end
+
+    def as_non_indexable(non_indexable)
+      if @readonly
+        raise Error, "Read-only"
+      elsif !non_indexable
+        @attributes.delete(NON_INDEXABLE_ATTR_CODE)
+      else
+        @attributes[NON_INDEXABLE_ATTR_CODE] = nil
+      end
+    end
+
+    def non_indexable?
+      @attributes.key?(NON_INDEXABLE_ATTR_CODE)
+    end
+
+    def bytes
+      b = "".b
+      [DELETED_ATTR_CODE, EXPIRES_AT_ATTR_CODE, NON_INDEXABLE_ATTR_CODE].each do |attr_code|
+        if @attributes.key?(attr_code)
+          b += [attr_code].pack("C")
+          if attr_code == EXPIRES_AT_ATTR_CODE
+            b += [@attributes[attr_code].to_i].pack("Q>")
+          end
+        end
+      end
+      b
+    end
+  end
+end

data/lib/immudb/linear_proof.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.
@@ -12,12 +12,6 @@
 
 module Immudb
   class LinearProof
-    attr_reader :sourceTxID, :targetTxID, :terms
-
-    def initialize(sourceTxID, targetTxID, terms)
-      @sourceTxID = sourceTxID
-      @targetTxID = targetTxID
-      @terms = terms
-    end
+    attr_accessor :sourceTxID, :targetTxID, :terms
   end
 end

data/lib/immudb/schema.rb

@@ -0,0 +1,119 @@
+# 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 Schema
+    class << self
+      def tx_from_proto(stx)
+        header = ::Immudb::TxHeader.new
+        header.iD = stx.header.id
+        header.ts = stx.header.ts
+        header.blTxID = stx.header.blTxId
+        header.blRoot = digest_from_proto(stx.header.blRoot)
+        header.prevAlh = digest_from_proto(stx.header.prevAlh)
+
+        header.version = stx.header.version.to_i
+        header.metadata = tx_metadata_from_proto(stx.header.metadata)
+
+        header.nentries = stx.header.nentries.to_i
+        header.eh = digest_from_proto(stx.header.eH)
+
+        entries = []
+        stx.entries.each do |e|
+          entries <<
+            ::Immudb::TxEntry.new(
+              e.key,
+              kv_metadata_from_proto(e.metadata),
+              e.vLen.to_i,
+              digest_from_proto(e.hValue),
+              0
+            )
+        end
+
+        tx = Store.new_tx_with_entries(header, entries)
+
+        tx.build_hash_tree
+
+        tx
+      end
+
+      def kv_metadata_from_proto(md)
+        return nil if md.nil?
+        kvmd = ::Immudb::KVMetadata.new()
+        kvmd.as_deleted(md.deleted)
+
+        unless md.expiration.nil?
+          kvmd.expires_at(Time.at(md.expiration.expiresAt))
+        end
+
+        kvmd.as_non_indexable(md.nonIndexable)
+
+        kvmd
+      end
+
+      def inclusion_proof_from_proto(iproof)
+        ip = ::Immudb::InclusionProof.new
+        ip.leaf = iproof.leaf.to_i
+        ip.width = iproof.width.to_i
+        ip.terms = digests_from_proto(iproof.terms)
+        ip
+      end
+
+      def dual_proof_from_proto(dproof)
+        dp = ::Immudb::DualProof.new
+        dp.sourceTxHeader = tx_header_from_proto(dproof.sourceTxHeader)
+        dp.targetTxHeader = tx_header_from_proto(dproof.targetTxHeader)
+        dp.inclusionProof = digests_from_proto(dproof.inclusionProof)
+        dp.consistencyProof = digests_from_proto(dproof.consistencyProof)
+        dp.targetBlTxAlh = digest_from_proto(dproof.targetBlTxAlh)
+        dp.lastInclusionProof = digests_from_proto(dproof.lastInclusionProof)
+        dp.linearProof = linear_proof_from_proto(dproof.linearProof)
+        dp
+      end
+
+      def tx_header_from_proto(hdr)
+        txh = ::Immudb::TxHeader.new
+        txh.iD = hdr.id
+        txh.prevAlh = digest_from_proto(hdr.prevAlh)
+        txh.ts = hdr.ts
+        txh.version = hdr.version.to_i
+        txh.metadata = tx_metadata_from_proto(hdr.metadata)
+        txh.nentries = hdr.nentries.to_i
+        txh.eh = digest_from_proto(hdr.eH)
+        txh.blTxID = hdr.blTxId
+        txh.blRoot = digest_from_proto(hdr.blRoot)
+        txh
+      end
+
+      def tx_metadata_from_proto(md)
+        return nil if md.nil?
+        ::Immudb::TxMetadata.new
+      end
+
+      def linear_proof_from_proto(lproof)
+        lp = ::Immudb::LinearProof.new
+        lp.sourceTxID = lproof.sourceTxId
+        lp.targetTxID = lproof.TargetTxId
+        lp.terms = digests_from_proto(lproof.terms)
+        lp
+      end
+
+      def digest_from_proto(sliced_digest)
+        sliced_digest[0, 32]
+      end
+
+      def digests_from_proto(sliced_terms)
+        sliced_terms.map(&:dup)
+      end
+    end
+  end
+end

data/lib/immudb/store.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.
@@ -13,62 +13,14 @@
 module Immudb
   class Store
     class << self
-      def tx_from(stx)
-        entries = []
-        stx.entries.each do |e|
-          i = TXe.new
-          i.h_value = digest_from(e.hValue)
-          i.v_off = e.vOff
-          i.value_len = e.vLen.to_i
-          i.set_key(e.key)
-          entries << i
-        end
-        tx = new_tx_with_entries(entries)
-        tx.ID = stx.metadata.id
-        tx.PrevAlh = digest_from(stx.metadata.prevAlh)
-        tx.Ts = stx.metadata.ts
-        tx.BlTxID = stx.metadata.blTxId
-        tx.BlRoot = digest_from(stx.metadata.blRoot)
-        tx.build_hash_tree
-        tx.calc_alh
-        tx
-      end
-
-      def tx_metadata_from(txmFrom)
-        txm = TxMetadata.new
-        txm.iD = txmFrom.id
-        txm.prevAlh = digest_from(txmFrom.prevAlh)
-        txm.ts = txmFrom.ts
-        txm.nEntries = txmFrom.nentries.to_i
-        txm.eh = digest_from(txmFrom.eH)
-        txm.blTxID = txmFrom.blTxId
-        txm.blRoot = digest_from(txmFrom.blRoot)
-        txm
-      end
-
-      def encode_key(key)
-        SET_KEY_PREFIX + key
-      end
-
-      def encode_kv(key, value)
-        KV.new(SET_KEY_PREFIX + key, PLAIN_VALUE_PREFIX + value)
-      end
-
-      def encode_reference(key, referencedKey, atTx)
-        refVal = REFERENCE_VALUE_PREFIX + [atTx].pack("Q>") + SET_KEY_PREFIX + referencedKey
-        KV.new(SET_KEY_PREFIX + key, refVal)
-      end
-
-      def linear_proof_from(lp)
-        LinearProof.new(lp.sourceTxId, lp.TargetTxId, lp.terms)
-      end
+      def new_tx_with_entries(header, entries)
+        htree = HTree.new(entries.length)
 
-      def digest_from(sliced_digest)
-        sliced_digest[0, 32]
-      end
-
-      def digests_from(sliced_terms)
-        sliced_terms.map(&:dup)
+        tx = Tx.new
+        tx.header = header
+        tx.entries = entries
+        tx.htree = htree
+        tx
       end
 
       def verify_inclusion(proof, digest, root)
@@ -92,43 +44,75 @@ module Immudb
       end
 
       def verify_dual_proof(proof, sourceTxID, targetTxID, sourceAlh, targetAlh)
-        if proof.nil? || proof.sourceTxMetadata.nil? || proof.targetTxMetadata.nil? || proof.sourceTxMetadata.iD != sourceTxID || proof.targetTxMetadata.iD != targetTxID
+        if proof.nil? || proof.sourceTxHeader.nil? || proof.targetTxHeader.nil? || proof.sourceTxHeader.iD != sourceTxID || proof.targetTxHeader.iD != targetTxID
           return false
         end
-        if proof.sourceTxMetadata.iD == 0 || proof.sourceTxMetadata.iD > proof.targetTxMetadata.iD
+        if proof.sourceTxHeader.iD == 0 || proof.sourceTxHeader.iD > proof.targetTxHeader.iD
           return false
         end
-        if sourceAlh != proof.sourceTxMetadata.alh
+        if sourceAlh != proof.sourceTxHeader.alh
           return false
         end
-        if targetAlh != proof.targetTxMetadata.alh
+        if targetAlh != proof.targetTxHeader.alh
           return false
         end
-        if sourceTxID < proof.targetTxMetadata.blTxID && !verify_inclusion_aht(proof.inclusionProof, sourceTxID, proof.targetTxMetadata.blTxID, leaf_for(sourceAlh), proof.targetTxMetadata.blRoot)
+        if sourceTxID < proof.targetTxHeader.blTxID && !verify_inclusion_aht(proof.inclusionProof, sourceTxID, proof.targetTxHeader.blTxID, leaf_for(sourceAlh), proof.targetTxHeader.blRoot)
           return false
         end
-        if proof.sourceTxMetadata.blTxID > 0 && !verify_consistency(proof.consistencyProof, proof.sourceTxMetadata.blTxID, proof.targetTxMetadata.blTxID, proof.sourceTxMetadata.blRoot, proof.targetTxMetadata.blRoot)
+        if proof.sourceTxHeader.blTxID > 0 && !verify_consistency(proof.consistencyProof, proof.sourceTxHeader.blTxID, proof.targetTxHeader.blTxID, proof.sourceTxHeader.blRoot, proof.targetTxHeader.blRoot)
           return false
         end
-        if proof.targetTxMetadata.blTxID > 0 && !verify_last_inclusion(proof.lastInclusionProof, proof.targetTxMetadata.blTxID, leaf_for(proof.targetBlTxAlh), proof.targetTxMetadata.blRoot)
+        if proof.targetTxHeader.blTxID > 0 && !verify_last_inclusion(proof.lastInclusionProof, proof.targetTxHeader.blTxID, leaf_for(proof.targetBlTxAlh), proof.targetTxHeader.blRoot)
           return false
         end
-        if sourceTxID < proof.targetTxMetadata.blTxID
-          verify_linear_proof(proof.linearProof, proof.targetTxMetadata.blTxID, targetTxID, proof.targetBlTxAlh, targetAlh)
+        if sourceTxID < proof.targetTxHeader.blTxID
+          verify_linear_proof(proof.linearProof, proof.targetTxHeader.blTxID, targetTxID, proof.targetBlTxAlh, targetAlh)
         else
           verify_linear_proof(proof.linearProof, sourceTxID, targetTxID, sourceAlh, targetAlh)
         end
       end
 
+      def entry_spec_digest_for(version)
+        if version == 0
+          method(:entry_spec_digest_v0)
+        elsif version == 1
+          method(:entry_spec_digest_v1)
+        else
+          # TODO raise ErrUnsupportedTxVersion
+          raise VerificationError
+        end
+      end
+
       private
 
-      def new_tx_with_entries(entries)
-        tx = Tx.new
-        tx.ID = 0
-        tx.entries = entries
-        tx.nentries = entries.length
-        tx.htree = HTree.new(entries.length)
-        tx
+      def entry_spec_digest_v0(kv)
+        md = Digest::SHA256.new
+        md.update(kv.key)
+        valmd = Digest::SHA256.new
+        valmd.update(kv.value)
+        md.update(valmd.digest)
+        md.digest
+      end
+
+      def entry_spec_digest_v1(kv)
+        mdbs = "".b
+        if !kv.metadata.nil?
+          mdbs = kv.metadata.bytes
+        end
+        mdLen = mdbs.length
+        kLen = kv.key.length
+        b = "".b
+        b = b + [mdLen].pack("n")
+        b = b + mdbs
+        b = b + [kLen].pack("n")
+        b = b + kv.key
+
+        md = Digest::SHA256.new
+        md.update(b)
+        valmd = Digest::SHA256.new
+        valmd.update(kv.value)
+        md.update(valmd.digest)
+        md.digest
       end
 
       def leaf_for(d)

data/lib/immudb/tx.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.
@@ -12,35 +12,37 @@
 
 module Immudb
   class Tx
-    attr_accessor :ID, :Ts, :BlTxID, :BlRoot, :PrevAlh, :nentries, :entries, :htree, :Alh
+    attr_accessor :header, :entries, :htree
+
+    def initialize
+      @header = nil
+      @entries = nil
+      @htree = nil
+    end
+
+    def tx_entry_digest
+      if @header.version == 0
+        method(:tx_entry_digest_v1_1)
+      elsif @header.version == 1
+        method(:tx_entry_digest_v1_2)
+      else
+        raise VerificationError
+      end
+    end
 
     def build_hash_tree
       digests = []
+      tx_entry_digest = self.tx_entry_digest
       @entries.each do |e|
-        digests << e.digest
+        digests << tx_entry_digest.call(e)
       end
       @htree.build_with(digests)
+      root = @htree.root
+      @header.eh = root
     end
 
-    def calc_alh
-      calc_innerhash
-      bi = [@ID].pack("Q>") + @PrevAlh + @InnerHash
-      @Alh = Digest::SHA256.digest(bi)
-    end
-
-    def calc_innerhash
-      bj = [@Ts, @nentries].pack("Q>L>") + eh
-      bj += [@BlTxID].pack("Q>") + @BlRoot
-      @InnerHash = Digest::SHA256.digest(bj)
-    end
-
-    def eh
-      @htree.root
-    end
-
-    def proof(key)
+    def index_of(key)
       kindex = nil
-      # find index of element holding given key
       @entries.each_with_index do |v, k|
         if v.key == key
           kindex = k
@@ -48,9 +50,44 @@ module Immudb
         end
       end
       if kindex.nil?
-        raise KeyError
+        raise VerificationError
+      end
+      kindex
+    end
+
+    def proof(key)
+      kindex = index_of(key)
+      htree.inclusion_proof(kindex)
+    end
+
+    private
+
+    def tx_entry_digest_v1_1(e)
+      unless e.md.nil?
+        # TODO raise ErrMetadataUnsupported
+        raise Error, "Metadata not supported"
+      end
+      md = Digest::SHA256.new
+      md.update(e.k)
+      md.update(e.hVal)
+      md.digest
+    end
+
+    def tx_entry_digest_v1_2(e)
+      mdbs = "".b
+      if !e.md.nil?
+        mdbs = e.md.bytes
       end
-      @htree.inclusion_proof(kindex)
+      mdLen = mdbs.length
+      b = "".b
+      b = b + [mdLen].pack("n")
+      b = b + mdbs
+      b = b + [e.kLen].pack("n")
+      b = b + e.k
+      md = Digest::SHA256.new
+      md.update(b)
+      md.update(e.hVal)
+      md.digest
     end
   end
 end

data/lib/immudb/tx_entry.rb

@@ -0,0 +1,34 @@
+# 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
+  class TxEntry
+    attr_reader :k, :kLen, :md, :vLen, :hVal, :vOff
+
+    def initialize(key, md, vLen, hVal, vOff)
+      @k = key
+      @kLen = key.length
+      @md = md
+      @vLen = vLen
+      @hVal = hVal
+      @vOff = vOff
+    end
+
+    def key
+      @k
+    end
+
+    def metadata
+      @md
+    end
+  end
+end

data/lib/immudb/tx_header.rb

@@ -0,0 +1,62 @@
+# 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
+  class TxHeader
+    attr_accessor :iD, :ts, :blTxID, :blRoot, :prevAlh, :version, :metadata, :nentries, :eh
+
+    def initialize
+      @iD = nil
+      @ts = nil
+      @blTxID = nil
+      @blRoot = nil
+      @prevAlh = nil
+
+      @version = nil
+      @metadata = TxMetadata.new
+
+      @nentries = nil
+      @eh = nil
+    end
+
+    def inner_hash
+      md = Digest::SHA256.new
+      md.update([@ts].pack("Q>"))
+      md.update([@version].pack("n"))
+      if @version == 0
+        md.update([@nentries].pack("n"))
+      elsif @version == 1
+        mdbs = "".b
+        if !@metadata.nil?
+          mdbs = @metadata.bytes
+        end
+        md.update([mdbs.length].pack("n"))
+        md.update(mdbs)
+        md.update([@nentries].pack("N"))
+      else
+        raise VerificationError, "missing tx hash calculation method for version #{@version}"
+      end
+      md.update(@eh)
+      md.update([@blTxID].pack("Q>"))
+      md.update(@blRoot)
+      md.digest
+    end
+
+    def alh
+      md = Digest::SHA256.new
+      md.update([@iD].pack("Q>"))
+      md.update(@prevAlh)
+      md.update(inner_hash)
+      md.digest
+    end
+  end
+end

data/lib/immudb/version.rb

@@ -1,3 +1,3 @@
 module Immudb
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/immudb.rb

@@ -4,25 +4,29 @@ require "openssl"
 require "time"
 
 # grpc
-require "immudb/grpc/schema_pb"
 require "immudb/grpc/schema_services_pb"
 
 # modules
 require "immudb/client"
 require "immudb/constants"
+require "immudb/database"
 require "immudb/dual_proof"
+require "immudb/entry_spec"
 require "immudb/htree"
 require "immudb/inclusion_proof"
 require "immudb/interceptor"
 require "immudb/kv"
+require "immudb/kv_metadata"
 require "immudb/linear_proof"
 require "immudb/root_service"
+require "immudb/schema"
 require "immudb/sql_result"
 require "immudb/state"
 require "immudb/store"
 require "immudb/tx"
+require "immudb/tx_entry"
+require "immudb/tx_header"
 require "immudb/tx_metadata"
-require "immudb/txe"
 require "immudb/version"
 
 module Immudb