vchain_client 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5331089e365d13a224dc8b586d015a5b38de6929
+  data.tar.gz: a6883aff699c11c312a38f66cdf4a7142f606853
+SHA512:
+  metadata.gz: d393052fc49844ce44434dfda1a277cf516fca9a6455c907acd73f5c4982069d5f1582f71422b4f66b06637d40f4fb639ce368f8d2212cb3dc23d0d0e95687d9
+  data.tar.gz: 0d1dafe6329b2a54c9622ce358b1578488e7b5a11820200a2ccc4a1ef0456df65f98a13f9e910645717c54f7addf0de79940b421f6a8679bd75be6cf7aafb7b9

data/lib/vchain_client/bitcoind_blockchain_adapter.rb

@@ -0,0 +1,135 @@
+module VChainClient
+
+  class BitcoindBlockchainAdapter < VChainClient::BlockchainAdapter
+
+    @server = nil
+    @port = nil
+    @rpc_username = nil
+    @rpc_password = nil
+
+    def initialize(server, port, rpc_username, rpc_password)
+      @server = server
+      @port = port
+      @rpc_username = rpc_username
+      @rpc_password = rpc_password
+    end 
+
+    def getTx(txid)
+      raw_tx = self.getRawTx(txid)
+
+      if raw_tx != nil
+        if raw_tx.key?("confirmations")
+          if raw_tx["confirmations"] > 5
+            if raw_tx.key?("blockhash")
+              if raw_tx.key?("blocktime")
+
+                op_return = self.getOpReturn(raw_tx)
+
+                if op_return != nil
+                  prefix = op_return[0..2]
+                  if prefix == "VCH"
+                    op_return = op_return[3..op_return.length]
+
+                    return {
+                      "size"            => raw_tx["size"],
+                      "block_hash"      => raw_tx["blockhash"],
+                      "block_timestamp" => raw_tx["blocktime"],
+                      "op_return"       => op_return
+                    }
+                  end
+                end
+
+              end
+            end
+          end
+        end
+      end
+
+      return nil
+    end
+
+    def getRawTx(txid)
+      request = {
+        "id"     => Random.rand(0...999999),
+        "method" => "getrawtransaction",
+        "params" => [txid, 1]
+      }
+
+      url = "http://"+ @rpc_username +":"+ @rpc_password +"@"+ @server +":"+ @port +"/"
+
+      begin
+
+        req = RestClient.post(url, request.to_json)
+
+        if req.code != 200
+          return nil
+        end
+
+        raw_tx = JSON.parse req.body
+
+        return raw_tx["result"]
+
+      rescue => e
+        raise e
+      end
+
+      return nil
+    end
+
+    def getOpReturn(raw_tx)
+      if raw_tx != nil
+        tx_unpacked = {}
+        tx_unpacked["vout"] = []
+
+        if raw_tx.key?("vout")
+          if raw_tx["vout"].length > 0
+            raw_tx["vout"].each_with_index { |vout,index|
+              vout_t = {}
+
+              vout_t["value"] = 0
+              
+              if vout.key?("value") 
+                vout_t["value"] = vout["value"]
+              end
+
+              vout_t["scriptPubKey"] = ""
+              if vout.key?("scriptPubKey")
+                if vout["scriptPubKey"].key?("hex")
+                  vout_t["scriptPubKey"] = vout["scriptPubKey"]["hex"]
+                end
+              end
+
+              tx_unpacked["vout"][index] = vout_t;
+            }
+
+            tx_unpacked["vout"].each { |output|
+              
+              scriptPubKeyArr = output["scriptPubKey"].split()
+              scriptPubKeyBinary = scriptPubKeyArr.pack("H*")
+
+              if scriptPubKeyBinary[0] == "\x6a"
+                first_ord = scriptPubKeyBinary[1].ord()
+
+                if first_ord <= 75
+                  return scriptPubKeyBinary[2..first_ord+1]
+
+                elsif first_ord == 0x4c
+                  return scriptPubKeyBinary[3..scriptPubKeyBinary[2].ord()+1]
+
+                elsif first_ord == 0x4d
+                  return scriptPubKeyBinary[4..scriptPubKeyBinary[2].ord()+1+256*scriptPubKeyBinary[3].ord()+1]
+                end
+              end
+
+            }
+
+          end
+        end
+      end
+
+      return nil
+    end
+
+  end
+
+end

data/lib/vchain_client/blockchain_adapter.rb

@@ -0,0 +1,11 @@
+module VChainClient
+  
+  class BlockchainAdapter
+
+  	def getTx(txid)
+  		return nil
+  	end
+
+  end
+
+end

data/lib/vchain_client/blockchain_adapter_factory.rb

@@ -0,0 +1,18 @@
+module VChainClient
+
+  class BlockchainAdapterFactory
+
+  	def self.getAdapter(type, config)
+  		if type == "bitcoind"
+  			return VChainClient::BitcoindBlockchainAdapter.new(config["server"], config["port"], config["rpc_username"], config["rpc_password"])
+
+  		elsif type == "blockcypher"
+  			return VChainClient::BlockcypherBlockchainAdapter.new(config["api_token"])
+  		end
+
+  		return nil
+  	end
+
+  end
+
+end

data/lib/vchain_client/blockchain_connection.rb

@@ -0,0 +1,85 @@
+module VChainClient
+
+  class BlockchainConnection
+
+    @config = nil
+
+    def initialize(config)
+      @config = config
+    end 
+
+  	def getTx(txid)
+
+  		adapters = []
+
+  		config_adapters = @config["blockchain_adapters"]
+
+  		config_adapters.each { |adapter_config|
+  			adapter = VChainClient::BlockchainAdapterFactory.getAdapter(adapter_config["type"], adapter_config)
+
+  			if adapter != nil
+  				adapters.push(adapter)
+  			end
+  		}
+
+  		if adapters.length > 0
+
+        prev_size = nil
+        prev_block_hash = nil
+        prev_block_timestamp = nil
+        prev_op_return = nil
+
+        adapters.each { |adapter|
+
+  				tx = adapter.getTx(txid)
+
+  				if tx == nil
+  					return nil
+  				end
+  				if !tx.key?("block_hash")
+  					return nil
+  				end
+  				if !tx.key?("block_timestamp")
+  					return nil
+  				end
+  				if tx["block_hash"] == nil || tx["block_hash"] == ""
+  					return nil
+  				end
+
+				  size = tx["size"]
+				  block_hash = tx["block_hash"]
+				  block_timestamp = tx["block_timestamp"]
+				  op_return = tx["op_return"]
+
+				  if prev_size != nil && prev_size != size
+            return nil
+				  end
+          if prev_block_hash != nil && prev_block_hash != block_hash
+            return nil
+          end
+          if prev_block_timestamp != nil && prev_block_timestamp != block_timestamp
+            return nil
+          end
+          if prev_op_return != nil && prev_op_return != op_return
+            return nil
+          end
+
+          prev_size = size
+          prev_block_hash = block_hash
+          prev_block_timestamp = block_timestamp
+          prev_op_return = op_return
+  			}
+
+        return {
+          "block_hash"      => prev_block_hash,
+          "block_timestamp" => prev_block_timestamp,
+          "op_return"       => prev_op_return
+				}
+  		end
+
+  		return nil
+  	end
+
+  end
+
+end

data/lib/vchain_client/blockcypher_blockchain_adapter.rb

@@ -0,0 +1,79 @@
+module VChainClient
+
+  class BlockcypherBlockchainAdapter < VChainClient::BlockchainAdapter
+
+    @api_token = nil
+
+    def initialize(api_token)
+    	@api_token = api_token
+    end 
+
+  	def getTx(txid)
+      url = "https://api.blockcypher.com/v1/btc/main/txs/"
+  		url += txid
+  		url += "?token="+ @api_token
+  		url += "&rand="+ Random.rand(0...999999).to_s
+
+      req = RestClient.get(url)
+
+      if req.code != 200
+        return nil
+      end
+
+      res = JSON.parse req.body
+
+      if res != nil
+        if res.key?("confirmations")
+        	if res["confirmations"] > 5
+        		if res.key?("block_hash")
+        			if res.key?("confirmed")
+        				block_timestamp = DateTime.parse(res["confirmed"]).to_i
+
+        				op_return = self.getOpReturn(res)
+
+        				if op_return != nil
+        					prefix = op_return[0..2]
+
+        					if prefix == "VCH"
+        						op_return = op_return[3..op_return.length]
+
+        						return {
+  										"size"            => res["size"],
+  										"block_hash"      => res["block_hash"],
+  										"block_timestamp" => block_timestamp,
+  										"op_return"       => op_return
+        						}
+        					end
+        				end
+        			end
+        		end
+        	end
+        end
+      end
+
+      return nil
+    end
+
+  	def getOpReturn(raw_tx)
+  		if raw_tx != nil
+  			if raw_tx.key?("outputs")
+  				if raw_tx["outputs"].length > 0
+  					raw_tx["outputs"].each { |vout|
+  						if vout.key?("script_type")
+  							if vout["script_type"] == "null-data"
+  								if vout.key?("data_string")
+  									return vout["data_string"]
+  								end
+  							end
+  						end
+  					}
+  				end
+  			end
+  		end
+
+  		return nil
+  	end
+
+  end
+
+end

data/lib/vchain_client/blockstack_client.rb

@@ -0,0 +1,155 @@
+module VChainClient
+
+	class BlockstackClient
+
+		MASTER_PUBLIC_KEY = "MFYwEAYHKoZIzj0CAQYFK4EEAAoDQgAEXGOuvJT5hb/bR5y/JADHxJEEaQzuJUzw
+	Xet0UYuBrILjHB9HcxFc+WwuCflIRWtRDsNfaY6Ra7j/cRYLeiocYA=="
+
+		@config = nil
+
+	  	@@recs_cache = {}
+	  	@@keys_cache = {}
+
+	    def initialize(config)
+	    	@config = config
+	    end 
+
+	  	def checkFederativeServer(federative_server_id)
+	  		return self.checkBlockstackRecord(federative_server_id, 'federative_server')
+	  	end
+
+	  	def checkVerificator(verificator_id)
+	  		return self.checkBlockstackRecord(verificator_id, 'verificator')
+	  	end
+
+	  	def checkValidator(validator_id)
+	  		return self.checkBlockstackRecord(validator_id, 'validator')
+	  	end
+
+	  	def checkBlockstackRecord(blockstack_id, type)
+
+	  		record = self.getBlockstackRecord(blockstack_id)
+
+	  		signaturesHelper = VChainClient::Signatures.new(@config)
+
+	  		if record != nil
+	  			if record.key?("pubkey")
+	  				if record.key?("vchain_role")
+	  					
+	  					if record["vchain_role"] != type
+	  						return nil
+	  					end
+
+	  					validator_blockstack_id = record["validator_blockstack_id"]
+	  					if validator_blockstack_id != nil
+
+	  						if record["vchain_role"] != 'validator'
+	  							if !self.checkValidator(validator_blockstack_id)
+	  								return nil
+	  							end
+	  						end
+
+	  						validator_pub_key = nil
+	  						if record["vchain_role"] != 'validator'
+	  							validator_pub_key = self.getPublicKey(validator_blockstack_id)
+	  						else
+	  							validator_pub_key = MASTER_PUBLIC_KEY;
+	  						end
+
+							# check client's sig
+
+							client_sig_to_check = record["vchain_id"] + record["vchain_role"] + blockstack_id + record["pubkey"] + record["sig_version"];
+
+							if signaturesHelper.verifySignature(client_sig_to_check, record["client_sig"], record["pubkey"])
+								# check validator's sig
+								validator_sig_to_check = record["vchain_id"] + record["vchain_role"] + blockstack_id + record["pubkey"] + record["sig_version"] + record["validator_vchain_id"] + validator_blockstack_id
+								
+								if signaturesHelper.verifySignature(validator_sig_to_check, record["validator_sig"], validator_pub_key)
+									return true;
+
+								else
+									return nil
+								end
+
+							else
+								return nil
+							end
+	  					end
+	  				end
+	  			end
+	  		end
+
+	  		return nil
+	  	end
+
+	  	def getPublicKey(blockstack_id)
+	  		if @@keys_cache.key?(blockstack_id)
+	  			return @@keys_cache[blockstack_id]
+	  		end
+
+	  		record = self.getBlockstackRecord(blockstack_id);
+	  		if record != nil
+	  			if record.key?("pubkey")
+
+	  				@@keys_cache[blockstack_id] = record["pubkey"]
+
+	  				return record["pubkey"]
+	  			end
+	  		end
+
+	  		return nil
+	  	end
+
+	  	def getBlockstackRecord(blockstack_id)
+	  		if @@recs_cache.key?(blockstack_id)
+	  			return @@recs_cache[blockstack_id]
+	  		end
+
+	  		blockstack_path = @config["blockstack"]["path"]
+
+	  		cmd = blockstack_path +" get_name_zonefile "+ blockstack_id
+
+	  		ret = `#{cmd}`
+	  		if ret == nil || ret == "Name has no user record hash defined"
+	  			return nil
+	  		end
+	  		ret = JSON.parse ret
+
+	  		fz = {}
+	  		if ret != nil
+	  			if ret.key?("txt")
+	  				ret["txt"].each { |rec|
+	  					if rec.key?("name") && rec.key?("txt")
+	  						fz[rec["name"]] = rec["txt"]
+	  					end
+	  				}
+	  			end
+	  		end
+
+	  		if fz.key?("A1")
+	  			pubkey_aligned = fz["A1"]
+	  			pubkey = pubkey_aligned[0..63] +"\n"+ pubkey_aligned[64..pubkey_aligned.length]
+
+	  			output = {
+					"pubkey"                  => pubkey,
+					"vchain_id"               => fz["A2"],
+					"validator_sig"           => Base64.decode64(fz["A3"]),
+					"validator_vchain_id"     => fz["A4"],
+					"validator_blockstack_id" => fz["A5"],
+					"vchain_role"             => fz["A6"],
+					"sig_version"             => fz["A7"],
+					"client_sig"              => Base64.decode64(fz["A8"])
+	  			}
+
+	  			@@recs_cache[blockstack_id] = output
+	  			@@keys_cache[blockstack_id] = pubkey
+
+	  			return output
+	  		end
+
+	  		return nil
+	  	end
+
+	end
+
+end

data/lib/vchain_client/signatures.rb

@@ -0,0 +1,103 @@
+module VChainClient
+
+	class Signatures
+
+		@config = nil
+
+	    def initialize(config)
+	    	@config = config
+	    end 
+
+		def signRequest(document, timestamp)
+			priv_key_path = @config["private_key_location"]
+
+			priv_key = File.read(priv_key_path)
+
+			whole_sign = document.to_json + timestamp.to_s
+
+			ec = OpenSSL::PKey::EC.new(priv_key)
+
+			digest = OpenSSL::Digest::SHA256.new
+
+			whole_signature = ec.sign(digest, whole_sign)
+
+			return Base64.encode64(whole_signature).gsub(/\n/, "") 
+		end
+
+	  	def verifySignature(what_to_check, signature, public_key)
+	  		pub_key = "-----BEGIN PUBLIC KEY-----\n"
+	  		pub_key += public_key
+			pub_key += "\n-----END PUBLIC KEY-----"
+
+			ec = OpenSSL::PKey::EC.new(pub_key)
+
+			digest = OpenSSL::Digest::SHA256.new
+
+			return ec.verify(digest, signature, what_to_check)
+	  	end
+
+	  	def signVerification(verification_type, data, timestamp)
+
+	  		this_client_id = @config["blockstack"]["client_id"]
+	  		priv_key_path = @config["private_key_location"]
+
+	  		priv_key = File.read(priv_key_path)
+
+	  		output = {}
+
+	  		data.each{ |rec|
+	  			field = rec[0]
+	  			value = rec[1]
+
+	  			if field != 'type' && field != 'client_id'
+
+	  				field_hash = Digest::SHA512.hexdigest(field)
+
+	  				value_hash = Digest::SHA512.hexdigest(value)
+
+	  				what_to_sign = field_hash
+	  				what_to_sign += value_hash
+	  				what_to_sign += verification_type
+	  				what_to_sign += timestamp.to_s
+	  				what_to_sign += this_client_id
+
+	  				ec = OpenSSL::PKey::EC.new(priv_key)
+
+	  				digest = OpenSSL::Digest::SHA256.new
+
+	  				signature = ec.sign(digest, what_to_sign)
+
+	  				output[field] = Base64.encode64(signature).gsub(/\n/, "")
+
+	  			end
+	  		}
+
+	  		return output
+	  	end
+
+	    def checkTreeSignature(tree_root_hash, blockchain_txid, blockchain_block_hash, blockchain_timestamp, blockstack_client_id, sig_version, signature, pubkey)
+
+		    what_to_check = tree_root_hash
+		    what_to_check += blockchain_txid
+		    what_to_check += blockchain_block_hash
+		    what_to_check += blockchain_timestamp.to_s
+		    what_to_check += blockstack_client_id
+		    what_to_check += sig_version
+
+		    return self.verifySignature(what_to_check, signature, pubkey)
+	    end
+
+	    def checkVerificationSignature(field_hash, data_hash, verification_type, timestamp, blockstack_client_id, pubkey, signature)
+
+			what_to_check = field_hash
+			what_to_check += data_hash
+			what_to_check += verification_type
+			what_to_check += timestamp.to_s
+			what_to_check += blockstack_client_id
+
+			return self.verifySignature(what_to_check, signature, pubkey)
+	    end
+
+	end
+
+end

data/lib/vchain_client.rb

@@ -0,0 +1,302 @@
+module VChainClient
+
+  class Client
+
+  	require 'rest-client'
+  	require 'base64'
+    gem "openssl"
+  	require 'openssl'
+
+    require 'vchain_client/blockchain_adapter'
+    require 'vchain_client/bitcoind_blockchain_adapter'
+    require 'vchain_client/blockcypher_blockchain_adapter'
+    require 'vchain_client/blockchain_adapter_factory'
+    require 'vchain_client/blockchain_connection'
+    require 'vchain_client/signatures'
+    require 'vchain_client/blockstack_client'
+
+    FIELD_TYPE_HASHED = "fbb6889f44061c2a91e17a411cf168f9457981257a5e0a31fb706cd5cd1e64c263780a42a1fd858ee69429869ab2e2c53b9d94c4a26946f2b0c12f8ce2812d6b"
+
+    @config = nil
+
+    def initialize(config)
+      @config = config
+    end 
+
+  	def hash(arr)
+      arr.each { |k, v| 
+      	arr[k] = Digest::SHA512.hexdigest(v.downcase)
+      }
+  	end
+
+  	def get_credentials_hash(document)
+  		if document["type"] == FIELD_TYPE_HASHED
+  			what_to_hash = document["type"] + document["citizenship"] + document["number"] + document["first_name"] + document["last_name"] + document["birthdate"]
+
+  			return Digest::SHA512.hexdigest(what_to_hash)
+  		end
+
+  		return nil
+  	end
+
+  	def build_merkle_tree(tree, timestamp)
+  		previous_parent = nil
+
+  		tree.each { |tree_level|
+  			if previous_parent != nil
+  				if previous_parent != tree_level["left"] && previous_parent != tree_level["right"]
+  					return nil
+  				end
+  			end
+
+  			what_to_hash = tree_level["left"]
+  			if tree_level["right"] != nil
+  				what_to_hash += tree_level["right"]
+  			else
+  				what_to_hash += tree_level["left"]
+  			end
+  			what_to_hash += timestamp.to_s
+
+  			level_hash = Digest::SHA256.hexdigest(what_to_hash);
+
+  			if level_hash != tree_level["parent"]
+  				return nil
+  			end
+
+  			previous_parent = level_hash
+  		}
+
+  		return previous_parent
+  	end
+
+  	def do_use(input, ignore_possible_matches = false)
+
+      client_id = @config["client_id"]
+      api_url = @config["api"]["url"] + "v0.1/use/";
+
+      document = input
+      document = self.hash(document)
+
+      document["client_id"] = client_id
+      document["ignore_possible_matches"] = ignore_possible_matches
+
+      req = RestClient.post(api_url, 
+      					            document.to_json, 
+      					            {'Content-Type' => 'application/json'})
+
+      if req.code != 200
+      	return false
+      end
+
+      return true
+  	end
+
+  	def do_verify(verification_type, input)
+
+    	client_id = @config["client_id"]
+    	api_url = @config["api"]["url"] + "v0.1/verify/";
+
+	  	time = Time.now.getutc
+	  	timestamp = time.to_i
+
+	    document = input
+	    document = self.hash(document)
+
+      signaturesHelper = VChainClient::Signatures.new(@config)
+
+	    verifications_data = signaturesHelper.signVerification(verification_type, document, timestamp)
+
+	    document = Hash[document.sort]
+
+      whole_signature = signaturesHelper.signRequest(document, timestamp)
+
+		  send_data = {}
+		  send_data["client_id"] = client_id
+		  send_data["data"] = document
+		  send_data["timestamp"] = timestamp.to_s
+		  send_data["verification_type"] = verification_type;
+		  send_data["verifications_signatures"] = verifications_data
+		  send_data["signature"] = whole_signature
+
+    	req = RestClient.post(api_url, 
+      					            send_data.to_json, 
+      					            {'Content-Type' => 'application/json'})
+
+    	if req.code != 200
+    		return false
+    	end
+
+    	return true
+  	end
+
+    def do_check(input, is_already_hashed=false)
+
+      client_id = @config["client_id"]
+      api_url = @config["api"]["url"] + "v0.1/check/";
+
+      document = input
+      
+      if (!is_already_hashed)
+      	document = self.hash(document)
+      end
+
+      document["client_id"] = client_id
+
+      req = RestClient.post(api_url, 
+      					            document.to_json, 
+      					            {'Content-Type' => 'application/json'})
+
+      if req.code != 200
+      	return false
+      end
+
+      res = JSON.parse req.body
+
+      if res["status"] == "ERROR" || res["status"] == "error"
+
+      	raise res["error_reason_code"] 
+
+      else
+      	res_document = res["document"]
+
+		    validated_verifications = {}
+
+		    credentials_hash = self.get_credentials_hash(document)
+
+        blockchainConnection = VChainClient::BlockchainConnection.new(@config)
+
+        blockstackClient = VChainClient::BlockstackClient.new(@config)
+
+        signaturesHelper = VChainClient::Signatures.new(@config)
+
+    		res_document.each { |field, v|
+    			if v["verifications"].length > 0 && field != "type"
+    				v["verifications"].each { |verification|
+
+    					next if !verification.key?("blockchain_reciepts")
+
+    					next if verification["blockchain_reciepts"].length <= 0
+
+    					# 1a. check credentials_hash
+    					next if credentials_hash != verification["credentials_hash"]
+
+    					# 1b. check field_hash
+    					field_hash = Digest::SHA512.hexdigest(field)
+    					next if field_hash != verification["field_hash"]
+
+    					# 1c. check data_hash
+    					data_hash = Digest::SHA512.hexdigest(document[field])
+    					next if data_hash != verification["data_hash"]
+
+    					# 1d. check checksum
+    					checksum_to_hash = credentials_hash + field_hash + data_hash
+    					checksum = Digest::SHA512.hexdigest(checksum_to_hash)
+    					next if checksum != verification["checksum"]
+
+    					verification_hash = verification["verification_hash"]
+
+    					# 2. check verification_hash to be in target_proof's
+    					# first element
+    					reciepts_validated = 0
+    					verification["blockchain_reciepts"].each { |reciept|
+
+    						break if !reciept.key?("target_proof")
+
+    						break if reciept["target_proof"].length <= 0
+
+    						break if reciept["target_proof"][0]["left"] != verification_hash && reciept["target_proof"][0]["right"] != verification_hash
+
+    						# verification_hash is in tree
+    						# and in right position
+    						# now,
+
+    						# 3. check tree convergence to root hash
+    						# and compare this computed root hash
+    						# with merkle_tree_root_hash from response
+    						computed_tree_root_hash = self.build_merkle_tree(reciept["target_proof"], reciept["timestamp"])
+
+    						break if computed_tree_root_hash == nil
+    						break if computed_tree_root_hash != reciept["merkle_tree_root_hash"]
+
+    						last_proof_index = reciept["target_proof"].length - 1
+    						reciept_stored_last_parent = reciept["target_proof"][last_proof_index]["parent"]
+    						break if reciept_stored_last_parent != computed_tree_root_hash
+
+    						# 4. check OP_RETURN in Bitcoin's tx,
+    						# compare it to computed root hash of a tree
+    						# retrieve some info from tx to verify signature
+    						tx = blockchainConnection.getTx(reciept["blockchain_txid"])
+
+    						break if tx == nil
+    						break if tx["block_hash"] != reciept["blockchain_block_hash"]
+    						break if tx["block_timestamp"] != reciept["blockchain_timestamp"]
+    						break if tx["op_return"] != computed_tree_root_hash
+
+    						blockchain_txid = reciept["blockchain_txid"];
+    						blockchain_block_hash = tx["block_hash"];
+    						blockchain_timestamp = tx["block_timestamp"];
+
+    						# 5. check tree signature:
+    						# a) federative server record in Blockstack (recursive)
+    						# b) tree_signature
+
+    						# a) federative server record in Blockstack (recursive)
+    						break if !blockstackClient.checkFederativeServer(reciept["federative_server_id"])
+
+    						# b) check tree signature
+    						federative_server_pubkey = blockstackClient.getPublicKey(reciept["federative_server_id"])
+
+    						break if !signaturesHelper.checkTreeSignature(computed_tree_root_hash, blockchain_txid, blockchain_block_hash, blockchain_timestamp, reciept["federative_server_id"], reciept["federative_server_version"], Base64.decode64(reciept["tree_signature"]), federative_server_pubkey)
+
+    						reciepts_validated += 1
+    					}
+    					next if reciepts_validated != verification["blockchain_reciepts"].length
+
+    					# 6. check verification signatures:
+    					# a) check verificator record in Blockstack (recursive)
+    					# b) check validator record in Blockstack (recursive)
+    					# c) verificator_sig
+    					# d) validtor_sig
+    					
+    					# a) check verificator record in Blockstack (recursive)
+    					next if !blockstackClient.checkVerificator(verification["verificator_id"])
+
+    					# b) check validator record in Blockstack (recursive)
+    					next if !blockstackClient.checkValidator(verification["validator_id"])
+
+    					# c) check verificator's signature
+    					verificator_pubkey = blockstackClient.getPublicKey(verification["verificator_id"])
+
+    					next if !signaturesHelper.checkVerificationSignature(field_hash, data_hash, verification["type"], verification["timestamp"], verification["verificator_id"], verificator_pubkey, Base64.decode64(verification["verificator_sig"]))
+
+    					# d) check validator's signature
+    					validator_pubkey = blockstackClient.getPublicKey(verification["validator_id"])
+
+    					next if !signaturesHelper.checkVerificationSignature(field_hash, data_hash, verification["type"], verification["timestamp"], verification["validator_id"], validator_pubkey, Base64.decode64(verification["validator_sig"]))
+
+    					# 7. timestamps checking
+    					# TODO
+    					if !validated_verifications.key?(field)
+    						validated_verifications[field] = 0
+    					end
+    					validated_verifications[field] = validated_verifications[field] + 1
+    				}
+    			end 
+    		}
+
+    		# check input fields
+    		input.each_with_index { |field,index|
+    			if field[0] != 'type' && field[0] != 'client_id'
+    				if !validated_verifications.key?(field[0])
+    					validated_verifications[field[0]] = 0
+    				end
+    			end
+    		}
+
+    		return validated_verifications
+      end
+    end
+
+  end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: vchain_client
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aleksandr Gorelik
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-09-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.8.3
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Fully functional client for VChain Platform written on Ruby
+email: alexander@vchain.tech
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/vchain_client.rb
+- lib/vchain_client/bitcoind_blockchain_adapter.rb
+- lib/vchain_client/blockchain_adapter.rb
+- lib/vchain_client/blockchain_adapter_factory.rb
+- lib/vchain_client/blockchain_connection.rb
+- lib/vchain_client/blockcypher_blockchain_adapter.rb
+- lib/vchain_client/blockstack_client.rb
+- lib/vchain_client/signatures.rb
+homepage: http://rubygems.org/gems/vchain_client
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.6
+signing_key: 
+specification_version: 4
+summary: VChain Platform client written on Ruby
+test_files: []