RecordsKeeperRubyLib 0.1.0

data/lib/RecordsKeeperRuby/block.rb

@@ -0,0 +1,89 @@
+# Library to work with RecordsKeeper blocks.
+
+#   You can retrieve complete block information by using block class.
+#   You just have to pass parameters to invoke the pre-defined functions.
+
+# Import the following libraries
+
+require 'rubygems'
+require 'httparty'
+require 'json'
+require 'binary_parser'
+require 'yaml'
+
+module RecordsKeeperRuby
+	class Block
+
+		#Entry point for accessing Block class resources.
+		#Import values from config file.
+		cfg = YAML::load(File.open('config.yaml','r'))
+		@network = cfg['testnet']								# Network variable to store the networrk that you want to access
+		if @network==cfg['testnet']
+			@url = cfg['testnet']['url']
+			@user = cfg['testnet']['rkuser']
+			@password = cfg['testnet']['passwd']
+			@chain = cfg['testnet']['chain']
+		else
+			@url = cfg['mainnet']['url']
+			@user = cfg['mainnet']['rkuser']
+			@password = cfg['mainnet']['passwd']
+			@chain = cfg['mainnet']['chain']
+		end
+
+		def self.variable
+			net = @network
+			return net
+		end
+
+		def self.blockinfo block_height
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getblock","params":[block_height],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			tx_count_number = out[0]['result']['tx']
+			tx_count = tx_count_number.length														# variable returns block's transaction count
+			miner = out[0]['result']['miner']														# variable returns block's miner
+			size = out[0]['result']['size']															# variable returns block's size
+			nonce = out[0]['result']['nonce']														# variable returns block's nonce
+			blockHash = out[0]['result']['hash']												# variable returns blockhash
+			prevblock = out[0]['result']['previousblockhash']						# variable returns prevblockhash
+			nextblock = out[0]['result']['nextblockhash']								# variable returns nextblockhash
+			merkleroot = out[0]['result']['merkleroot']									# variable returns merkleroot
+			blocktime = out[0]['result']['time']												# variable returns blocktime
+			difficulty = out[0]['result']['difficulty']									# variable returns difficulty
+			tx = []																											# list to store transaction ids
+			for i in 0...tx_count
+				tx.push(out[0]['result']['tx'][i])										# pushes transaction ids onto tx list
+			end
+			return  tx_count, tx, miner, size, nonce, blockHash, prevblock, nextblock, merkleroot, blocktime, difficulty;
+		end
+
+		def self.retrieveBlocks block_range
+			blockhash = []
+			miner = []
+			blocktime = []
+			tx_count = []
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"listblocks","params":[block_range],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			block_count_len = out[0]['result']
+			block_count = block_count_len.length
+			for i in 0...block_count
+				blockhash.push(out[0]['result'][i]['hash'])
+				miner.push(out[0]['result'][i]['miner'])
+				blocktime.push(out[0]['result'][i]['time'])
+				tx_count.push(out[0]['result'][i]['txcount'])
+			end
+			return blockhash, miner, blocktime, tx_count;
+		end
+	end
+end

data/lib/RecordsKeeperRuby/blockchain.rb

@@ -0,0 +1,135 @@
+# 	Library to work with RecordsKeeper Blockchain.
+
+#   You can retrieve blockchain information, node's information, node's balance, node's permissions, pending transaction details
+# 		by using Blockchain class.
+#   You just have to pass parameters to invoke the pre-defined functions."""
+
+require 'rubygems'
+require 'httparty'
+require 'json'
+require 'binary_parser'
+require 'yaml'
+
+module RecordsKeeperRuby
+	class Blockchain
+
+		cfg = YAML::load(File.open('config.yaml','r'))
+		@network = cfg['testnet']
+		if @network==cfg['testnet']
+			@url = cfg['testnet']['url']
+			@user = cfg['testnet']['rkuser']
+			@password = cfg['testnet']['passwd']
+			@chain = cfg['testnet']['chain']
+		else
+			@url = cfg['mainnet']['url']
+			@user = cfg['mainnet']['rkuser']
+			@password = cfg['mainnet']['passwd']
+			@chain = cfg['mainnet']['chain']
+		end
+
+		def self.variable
+			net = @network
+			return net
+		end
+
+		# Function to retrieve RecordsKeeper Blockchain parameters
+		def self.getChainInfo
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getblockchainparams","params":[],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			result = out[0]['result']
+			chain_protocol = result['chain-protocol']
+			chain_description = result['chain-description']
+			root_stream = result['root-stream-name']
+			max_blocksize = result['maximum-block-size']
+			default_networkport = result['default-network-port']
+			default_rpcport = result['default-rpc-port']
+			mining_diversity = result['mining-diversity']
+			chain_name = result['chain-name']
+			return chain_protocol, chain_description, root_stream, max_blocksize, default_networkport, default_rpcport, mining_diversity, chain_name;										#returns chain parameters
+		end
+
+		# Function to retrieve node's information on RecordsKeeper Blockchain
+		def self.getNodeInfo
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getinfo","params":[],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			node_balance = out[0]['result']['balance']
+			synced_blocks = out[0]['result']['blocks']
+			node_address = out[0]['result']['nodeaddress']
+			difficulty = out[0]['result']['difficulty']
+			return node_balance, synced_blocks, node_address, difficulty;						# Returns node's details
+		end
+
+		# Function to retrieve node's permissions on RecordsKeeper Blockchain
+		def self.permissions
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"listpermissions","params":[],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			pms_count_len = out[0]['result']
+			pms_count = pms_count_len.length
+			permissions = []
+			for i in 0...pms_count
+				permissions.push(out[0]['result'][i]['type'])
+			end
+			return permissions;																# Returns list of permissions
+		end
+
+		# Function to retrieve pending transactions information on RecordsKeeper Blockchain
+		def self.getpendingTransactions
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getmempoolinfo","params":[],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			tx_count = out[0]['result']['size']											# Stores pending tx count
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getrawmempool","params":[],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response2 = HTTParty.get(@url, options)
+			out2 = response2.parsed_response
+			tx = []
+			x = 0
+			begin
+				tx.push(out2[0]['result'])
+			end until x <tx_count
+			return tx_count, tx;														# Returns pending tx and tx count
+		end
+
+		# Function to check node's total balance
+		def self.checkNodeBalance
+			auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getmultibalances","params":[],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			balance = out[0]['result']['total'][0]['qty']
+			return balance;														# Returns balance of  node
+		end
+	end
+
+end

data/lib/RecordsKeeperRuby/permissions.rb

@@ -0,0 +1,77 @@
+#   Library to work with RecordsKeeper Blockchain permissions.
+
+#   You can grant and revoke permissions to any node on Recordskeeper Blockchain by using permissions class.
+#   You just have to pass parameters to invoke the pre-defined functions.
+
+require 'rubygems'
+require 'httparty'
+require 'json'
+require 'binary_parser'
+require 'yaml'
+require 'hex_string'
+
+module RecordsKeeperRuby
+
+	class Permissions
+
+		# Entry point for accessing Block class resources.
+		# Import values from config file.
+		cfg = YAML::load(File.open('config.yaml','r'))
+		@network = cfg['testnet']								# Network variable to store the networrk that you want to access
+		if @network==cfg['testnet']
+			@url = cfg['testnet']['url']
+			@user = cfg['testnet']['rkuser']
+			@password = cfg['testnet']['passwd']
+			@chain = cfg['testnet']['chain']
+		else
+			@url = cfg['mainnet']['url']
+			@user = cfg['mainnet']['rkuser']
+			@password = cfg['mainnet']['passwd']
+			@chain = cfg['mainnet']['chain']
+		end
+
+		def self.variable
+			net = @network
+			return net
+		end
+
+	  # Function to grant permissions on RecordsKeeper Blockchain
+	  def self.grantPermission address, permissions
+	    auth = {:username => @user, :password => @password}
+	    options = {
+	      :headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+	      :basic_auth => auth,
+	      :body => [ {"method":"grant","params":[address, permissions],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+	    }
+	    response = HTTParty.get(@url, options)
+	    out = response.parsed_response
+	    result = out[0]['result']
+	    if result.nil?
+	      res = out[0]['error']['message']
+	    else
+	      res = out[0]['result']
+	    end
+	    return res;									#returns permissions tx id
+	  end
+
+	  # Function to revoke permissions on RecordsKeeper Blockchain
+	  def self.revokePermission address, permissions
+	    auth = {:username => @user, :password => @password}
+	    options = {
+	      :headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+	      :basic_auth => auth,
+	      :body => [ {"method":"revoke","params":[address, permissions],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+	    }
+	    response = HTTParty.get(@url, options)
+	    out = response.parsed_response
+	    result = out[0]['result']
+	    if result.nil?
+	      res = out[0]['error']['message']
+	    else
+	      res = out[0]['result']
+	    end
+	    return res;									#returns revoke permissions tx id
+	  end
+	end
+
+end

data/lib/RecordsKeeperRuby/sample_config.yaml

@@ -0,0 +1,60 @@
+# config.yaml
+testnet:
+    url: testurl
+    rkuser: rkuser
+    passwd: rkpwd
+    chain: test-chain
+    port: testport
+    stream: streamname
+    testdata: test_data
+    amount: test_amount
+    dumptxid: test_txid
+    privatekey: test_privkey
+    validaddress: valid_address
+    invalidaddress: invalid_address
+    miningaddress: mining_address
+    nonminingaddress: nonmining_address
+    multisigaddress: multisig_address
+    wrongimportaddress: wrongimport_address
+    mainaddress: main_address
+    permissionaddress: permission_address
+    dumptxhex: dump_txhex
+    dumpsignedtxhex: dump_signedtxhex
+    samplegetmultisigaddress: sample_multisigaddress
+    samplemerkleroot: sample_merkleroot
+    sampleblockhash: sample_blockhash
+    sampledata: sample_data
+    sampletransac: sample_transaction_id
+    transactionid: transaction_id
+    sampletxid: sample_txid
+
+
+
+mainnet:
+    url: mainurl
+    rkuser: rkuser
+    passwd: rkpwd
+    chain: main-chain
+    port: mainport
+    stream: streamname
+    testdata: main_data
+    amount: main_amount
+    dumptxid: main_txid
+    privatekey: main_privkey
+    validaddress: valid_address
+    invalidaddress: invalid_address
+    miningaddress: mining_address
+    nonminingaddress: nonmining_address
+    multisigaddress: multisig_address
+    wrongimportaddress: wrongimport_address
+    mainaddress: main_address
+    permissionaddress: permission_address
+    dumptxhex: dump_txhex
+    dumpsignedtxhex: dump_signedtxhex
+    samplegetmultisigaddress: sample_multisigaddress
+    samplemerkleroot: sample_merkleroot
+    sampleblockhash: sample_blockhash
+    sampledata: sample_data
+    sampletransac: sample_transaction_id
+    transactionid: transaction_id
+    sampletxid: sample_txid

data/lib/RecordsKeeperRuby/stream.rb

@@ -0,0 +1,169 @@
+# 	Library to work with RecordsKeeper streams.
+
+#   You can publish, retrieve and verify stream data by using stream class.
+# 	   You just have to pass parameters to invoke the pre-defined functions.
+
+require 'rubygems'
+require 'httparty'
+require 'json'
+require 'binary_parser'
+require 'yaml'
+require 'hex_string'
+
+module RecordsKeeperRuby
+
+	class Stream
+
+		# Entry point for accessing Block class resources.
+		# Import values from config file.
+		cfg = YAML::load(File.open('config.yaml','r'))
+		@network = cfg['testnet']								# Network variable to store the networrk that you want to access
+		if @network==cfg['testnet']
+			@url = cfg['testnet']['url']
+			@user = cfg['testnet']['rkuser']
+			@password = cfg['testnet']['passwd']
+			@chain = cfg['testnet']['chain']
+		else
+			@url = cfg['mainnet']['url']
+			@user = cfg['mainnet']['rkuser']
+			@password = cfg['mainnet']['passwd']
+			@chain = cfg['mainnet']['chain']
+		end
+
+		def self.variable
+			net = @network
+			return net
+		end
+
+	  # Function to publish data into the stream
+		def self.publish address, stream, key, data
+	    datahex1 = data.to_hex_string
+	    datahex = datahex1.delete(' ')
+	    auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"publishfrom","params":[address, stream, key, datahex],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			txid = out[0]['result']
+			return txid;
+	  end
+
+	  # Function to retrieve data against transaction id from the stream
+		def self.retrieve stream, txid
+	    auth = {:username => @user, :password => @password}
+			options = {
+				:headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+				:basic_auth => auth,
+				:body => [ {"method":"getstreamitem","params":[stream, txid],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+			}
+			response = HTTParty.get(@url, options)
+			out = response.parsed_response
+			data = out[0]['result']['data']
+	    raw_data = data.to_byte_string
+			return raw_data;
+	  end
+
+	  # Function to retrieve data against a particular publisher address
+		def self.retrieveWithAddress stream, address, count
+	    auth = {:username => @user, :password => @password}
+	    options = {
+	      :headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+	      :basic_auth => auth,
+	      :body => [ {"method":"liststreampublisheritems","params":[stream, address, false, count],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+	    }
+	    response = HTTParty.get(@url, options)
+	    out = response.parsed_response
+			key = []
+	    raw_data = []
+	    txid = []
+			i = 0
+			begin
+				key.push(out[0]['result'][i]['key'])           	  #returns key value of the published data
+	      data = out[0]['result'][i]['data']                #returns hex data
+	      raw_data.push(data.to_byte_string)    						#returns raw data
+	      txid.push(out[0]['result'][i]['txid'])            #returns tx id
+			end until i <count
+	    return key, raw_data, txid;
+	  end
+
+	  # Function to retrieve data against a particular key value
+		def self.retrieveWithKey stream, key, count
+	    auth = {:username => @user, :password => @password}
+	    options = {
+	      :headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+	      :basic_auth => auth,
+	      :body => [ {"method":"liststreamkeyitems","params":[stream, key, false, count],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+	    }
+	    response = HTTParty.get(@url, options)
+	    out = response.parsed_response
+			publisher = []
+	    raw_data = []
+	    txid = []
+			i = 0
+			begin
+				publisher.push(out[0]['result'][i]['publishers'][0])    	#returns publisher's address of published data
+	      data = out[0]['result'][i]['data']                        #returns published hex data
+	      raw_data.push(data.to_byte_string)           						  #returns data published
+	      txid.push(out[0]['result'][i]['txid'])                    #returns transaction id of published data
+			end until i <count
+	    return publisher, raw_data, txid;
+	  end
+
+	  # Function to verify data on RecordsKeeper Blockchain
+		def self.verifyData stream, data, count
+	    auth = {:username => @user, :password => @password}
+	    options = {
+	      :headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+	      :basic_auth => auth,
+	      :body => [ {"method":"liststreamitems","params":[stream,false ,count],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+	    }
+	    response = HTTParty.get(@url, options)
+	    out = response.parsed_response
+			raw_data = []
+			i = 0
+			begin
+				result_data = out[0]['result'][i]['data']						       # returns hex data
+			end until i <count
+	    if result_data.unicode_normalized?
+				raw_data.push(result_data.to_byte_string)	                 # returns raw data
+			else
+	      raw_data.push("No data found")
+	    end
+	    if raw_data.include?data
+			  result = "Data is successfully verified."
+			else
+				result = "Data not found."
+	    end
+			return result;
+	  end
+
+		# Function to list stream items on RecordsKeeper Blockchain
+		def self.retrieveItems stream, count
+	    auth = {:username => @user, :password => @password}
+	    options = {
+	      :headers => headers= {"Content-Type"=> "application/json","Cache-Control" => "no-cache"},
+	      :basic_auth => auth,
+	      :body => [ {"method":"liststreamitems","params":[stream, false ,count],"jsonrpc":2.0,"id":"curltext","chain_name":@chain}].to_json
+	    }
+	    response = HTTParty.get(@url, options)
+	    out = response.parsed_response
+	    address =[]
+			key_value = []
+			raw_data = []
+			txid = []
+			i = 0
+			begin
+				address.push(out[0]['result'][i]['publishers'])		        # returns publisher address
+				key_value.push(out[0]['result'][i]['key'])			          # returns key value of data
+				data = out[0]['result'][i]['data']					              # returns hex data
+	      raw_data.push(data.to_byte_string)                     	  # returns raw data
+				txid.push(out[0]['result'][i]['txid'])				            # returns tx id
+			end until i <count
+			return address, key_value, raw_data, txid;
+	  end
+	end
+
+end