dbchain_client 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 210b81d91f0d16ba4c191890158681b2f0e70f10c9ef1ffeafd59c4507100292
-  data.tar.gz: 31c9e6e230074fbfb61fd86f2119063a752fc84cee87bb1a3e706aed6a986706
+  metadata.gz: f300331aa2995762eb461fee85ea02a12e736319679a0ceea696be1917dfb71d
+  data.tar.gz: f78d01c152f1ad80c72f35cf7d1454fcc3b6b0808d4d300b13d77c978547daee
 SHA512:
-  metadata.gz: fa30c27609db0223a7879b3edb82344fea4deea5692a97c0616afb4be7c8e119be2572cdb82a3be9ef585b69303d5899840f43c58e1085f2d261f99237761ef7
-  data.tar.gz: e72dee491bb0c0b8d764960c2c7e531ecd46c1cad3df94a6d02d83797e58ab2e9220360d5d4359b45c829cc20052e8fabbcffd7be130d342a3f467b244ff2346
+  metadata.gz: d40306d4be159d83f9aee1d49899232523235b0d9b396d4350e1f5c8d7243255f0990659f6487e41742466fcafc12886a8dbe3eaa329aae5ad08ab2bc00ea388
+  data.tar.gz: 3a1507e51851413873b544624569b0d665159986d487bfbf59db531f7e6f890dd93f48f1cea2ebd3887792b0c8c790de90fdf4436d9060aa686817aad638bc18

data/lib/dbchain_client/aes.rb

@@ -0,0 +1,49 @@
+require 'base64'
+require 'digest'
+require 'openssl'
+
+module DbchainClient 
+  class AESCrypt
+    def initialize
+      @cipher = OpenSSL::Cipher.new('AES-256-CBC')
+    end
+      
+    def encrypt(password, clear_data)
+      iv  = generate_iv
+
+      @cipher.encrypt
+      @cipher.key = Digest::SHA256.digest(password)
+      @cipher.iv  = iv
+
+      encrypted = @cipher.update(clear_data) + @cipher.final
+      encrypted_with_iv = prefix_iv(iv, encrypted) 
+      Base64.strict_encode64(encrypted_with_iv)
+    end
+
+    def decrypt(password, secret_data_with_iv)
+      iv_encrypted = Base64::decode64(secret_data_with_iv)
+      iv, encrypted = extract_iv_and_encrypted(iv_encrypted)
+
+      @cipher.decrypt
+      @cipher.key = Digest::SHA256.digest(password)
+      @cipher.iv = iv
+      @cipher.update(encrypted) + @cipher.final
+    end
+
+    private
+
+    def prefix_iv(iv, encrypted)
+      iv + encrypted
+    end
+
+    def generate_iv
+      OpenSSL::Random.random_bytes(16)
+    end
+ 
+    def extract_iv_and_encrypted(iv_encrypted)
+      iv = iv_encrypted[0..15]
+      encrypted = iv_encrypted[16..-1]
+      [iv, encrypted]
+    end
+  end
+end

data/lib/dbchain_client/key.rb

@@ -0,0 +1,54 @@
+#require "bitcoin"
+require "secp256k1"
+
+module DbchainClient
+  class PublicKey
+    def initialize(pub_key) # hex or raw public key
+      if pub_key.instance_of?(Secp256k1::PublicKey)
+        @public_key = pub_key
+      else
+        raw_pub_key = Secp256k1::Utils.decode_hex(pub_key)
+        @public_key = Secp256k1::PublicKey.new(pubkey: raw_pub_key, raw: true)
+      end
+    end
+
+    def public_key_hex
+      @public_key.serialize.unpack('H*')[0]
+    end
+
+    def to_raw
+      @public_key.serialize
+    end
+
+    def to_s
+      public_key_hex
+    end
+
+    def address
+      @address ||= Mnemonics.public_key_to_address(public_key_hex)
+    end
+
+    def verify(message, signature)
+      compact_sig = Secp256k1::Utils.decode_hex(signature)
+      raw_sig = @public_key.ecdsa_deserialize_compact(compact_sig)
+      @public_key.ecdsa_verify(message, raw_sig)
+    end
+  end
+
+  class PrivateKey
+    def initialize(private_key_hex)
+      raw_key = Secp256k1::Utils.decode_hex(private_key_hex)
+      @private_key = Secp256k1::PrivateKey.new(privkey: raw_key)
+    end
+
+    def public_key
+      @public_key ||= PublicKey.new(@private_key.pubkey)
+    end
+
+    def sign(message)
+      raw_sig = @private_key.ecdsa_sign(message)
+      compact_sig = @private_key.ecdsa_serialize_compact(raw_sig)
+      Secp256k1::Utils.encode_hex(compact_sig)
+    end
+  end
+end

data/lib/dbchain_client/key_escrow.rb

@@ -0,0 +1,97 @@
+require 'singleton'
+require 'securerandom'
+require 'digest'
+
+module DbchainClient
+  class KeyEscrow 
+    include Singleton
+
+    SUFFIX_SECRET = "secret"
+    SUFFIX_PRIVATE = "private"
+
+    def create_and_save_private_key_with_password(username, password, key_store_obj)
+      private_key = DbchainClient::Mnemonics.generate_private_key
+      save_private_key(username, password, private_key, key_store_obj) 
+    end 
+  
+    def load_private_key_with_password(username, password, key_store_obj)
+      load_private_key(username, password, key_store_obj)
+    end
+  
+    def save_private_key_with_recovery_phrase(username, recovery_phrase, private_key, key_store_obj)
+      save_private_key(username, recovery_phrase, private_key, key_store_obj)
+    end
+  
+    def load_private_key_by_recovery_phrase(username, recovery_phrase, key_store_obj)
+      load_private_key(username, recovery_phrase, key_store_obj) 
+    end
+  
+    def reset_password_from_recovery_phrase(username, recovery_phrase, new_password, key_store_obj)
+      private_key = load_private_key(username, recovery_phrase, key_store_obj) or raise "Failed to retrieve private key"
+      save_private_key(username, new_password, private_key, key_store_obj)
+    end
+  
+    def reset_password_from_old(username, old_password, new_password, key_store_obj)
+      private_key = load_private_key(username, old_password, key_store_obj) or raise "Failed to retrive private key"
+      save_private_key(username, new_password, private_key, key_store_obj)
+    end
+  
+    private
+  
+    def save_private_key(username, password_or_recovery_phrase, private_key, key_store_obj)
+      seed = random_seed()
+      aes = DbchainClient::AESCrypt.new
+      encrypted_private_key = aes.encrypt(f1(seed, password_or_recovery_phrase), private_key)
+      secret = aes.encrypt(f2(username, password_or_recovery_phrase), seed)
+      key_of_secret = hash1(username, password_or_recovery_phrase)
+      key_of_private = hash2(username, password_or_recovery_phrase)
+      key_store_obj.save(key_of_private, encrypted_private_key) && key_store_obj.save(key_of_secret, secret)
+    end
+  
+    def load_private_key(username, password_or_recovery_phrase, key_store_obj)
+      key_of_secret = hash1(username, password_or_recovery_phrase)
+      key_of_private = hash2(username, password_or_recovery_phrase)
+      secret = key_store_obj.load(key_of_secret)
+      encrypted_private_key = key_store_obj.load(key_of_private)
+
+      aes = DbchainClient::AESCrypt.new
+      seed = aes.decrypt(f2(username, password_or_recovery_phrase), secret)
+      aes.decrypt(f1(seed, password_or_recovery_phrase), encrypted_private_key)
+    end
+  
+    def f1(str1, str2)
+      Digest::SHA256.digest(str1 + str2)
+    end
+  
+    def f2(str1, str2)
+      f1(str1, str2)
+    end
+  
+    def hash1(str1, str2)
+      Digest::SHA256.digest(str1 + str2 + SUFFIX_SECRET)
+    end
+  
+    def hash2(str1, str2)
+      Digest::SHA256.digest(str1 + str2 + SUFFIX_PRIVATE)
+    end
+  
+    def random_seed()
+      SecureRandom.random_bytes(32)
+    end
+  end
+  
+  # This key store is for test purpose. Developers are supposed to implement their own key store for production.
+  class KeyStore
+    def initialize
+      @h = {}
+    end
+  
+    def save(key, value)
+      @h[key] = value
+    end
+  
+    def load(key)
+      @h[key]
+    end
+  end
+end

data/lib/dbchain_client/message_generator.rb

@@ -0,0 +1,19 @@
+module DbchainClient
+  class MessageGenerator 
+    def initialize(from_address)
+      @from_address = from_address
+    end
+
+    def run(message_name, message_hash)
+      if message_name == 'MsgSend'
+        type = 'cosmos-sdk/MsgSend'
+        message_hash[:from_address] = @from_address
+      else
+        type = "dbchain/#{message_name}"
+        message_hash[:owner] = @from_address
+      end
+    
+      return { type: type, value: message_hash }
+    end
+  end
+end

data/lib/dbchain_client/mnemonics.rb

@@ -0,0 +1,34 @@
+require "bitcoin"
+
+module DbchainClient
+  class Mnemonics
+    class << self
+      def generate_mnemonic(strength_bits = 128)
+        Bitcoin::Trezor::Mnemonic.generate(strength_bits)
+      end
+
+      def mnemonic_to_master_key(mnemonic)
+        seed = Bitcoin::Trezor::Mnemonic.to_seed(mnemonic)
+        Bitcoin::ExtKey.generate_master(seed.htb)
+      end
+
+      def master_key_to_cosmos_key_pair(master_key)
+        # m/44'/118'/0'/0/0"
+        key = master_key.derive(2**31 + 44).derive(2**31 + 118).derive(2**31).derive(0 ).derive(0)
+        [key.priv, key.pub]
+      end
+
+      def generate_private_key
+        mnemonic = generate_mnemonic
+        master_key = mnemonic_to_master_key(mnemonic)
+        master_key_to_cosmos_key_pair(master_key)[0]
+      end
+
+      def public_key_to_address(pub_key)
+        hash160 = Bitcoin.hash160(pub_key)
+        words = Bitcoin::Bech32.convert_bits(hash160.htb.unpack("C*"), from_bits: 8, to_bits: 5, pad: true)
+        Bitcoin::Bech32.encode("cosmos", words)
+      end
+    end
+  end
+end

data/lib/dbchain_client/reader.rb

@@ -0,0 +1,27 @@
+require 'json'
+require 'base58'
+
+module DbchainClient
+  class Reader
+    def initialize(base_url, private_key, address=nil)
+      @rest_lib = DbchainClient::RestLib.new(base_url)
+
+      if private_key.instance_of? String
+        @private_key = PrivateKey.new(private_key)
+      else
+        @private_key = private_key
+      end
+
+      @public_key = @private_key.public_key
+      @from_address = address || @public_key.address
+    end
+
+    def access_code(time=nil)
+      encoded_public_key = Base58.binary_to_base58(@public_key.to_raw, :bitcoin)
+      time ||= (Time.now.to_f * 1000).to_i.to_s
+      signature = @private_key.sign(time)
+      encoded_signature = Base58.binary_to_base58([signature].pack("H*"), :bitcoin)
+      "#{encoded_public_key}:#{time}:#{encoded_signature}"
+    end
+  end
+end

data/lib/dbchain_client/rest_lib.rb

@@ -0,0 +1,27 @@
+require 'json'
+require 'base64'
+require 'net/http'
+require_relative 'message_generator'
+
+module DbchainClient
+  class RestLib
+    def initialize(base_url)
+      @base_url = base_url
+    end
+
+    def rest_get(url)
+      uri = URI(@base_url + url)
+      res = Net::HTTP.get_response(uri)
+      res
+    end
+
+    def rest_post(url, data)
+      uri = URI(@base_url + url)
+      req = Net::HTTP::Post.new(uri.path, 'Content-Type' => 'application/json')
+      req.body = data
+      http = Net::HTTP.new(uri.host, uri.port)
+      res = http.request(req)
+      res.body
+    end
+  end
+end

data/lib/dbchain_client/transaction.rb

@@ -0,0 +1,87 @@
+require 'json'
+require 'base64'
+require 'net/http'
+require_relative 'message_generator'
+
+module DbchainClient
+  class Transaction
+    def initialize(base_url, chain_id, private_key_hex)
+      @rest_lib = DbchainClient::RestLib.new(base_url)
+      @chain_id = chain_id
+      @private_key = PrivateKey.new(private_key_hex)
+      @from_address = @private_key.public_key.address
+    end
+ 
+    def sign_and_broadcast(messages, gas: '99999999', memo: '')
+      tx = {
+        fee: {
+          amount: [],
+          gas:    gas
+        },
+        memo: memo,
+        msg: messages
+      }
+
+      sign_message = make_sign_message(tx, messages)
+      signature = @private_key.sign(sign_message)
+      signed_tx = {
+        signature: Base64.strict_encode64([signature].pack("H*")),
+        pub_key:   {
+            type:  'tendermint/PubKeySecp256k1',
+            value: Base64.strict_encode64([@private_key.public_key.public_key_hex].pack("H*"))
+        }
+      }
+
+      tx[:signatures] = [signed_tx]
+      broadcastBody = {
+        tx: tx,
+        mode: 'async'
+      }.to_json
+
+      response = rest_post("/txs", broadcastBody)
+      response#.data.txhash
+    end
+
+    private
+
+    def make_sign_message(tx, messages)
+      account = get_account
+      sign_obj = {
+        account_number: account["account_number"],
+        chain_id:       @chain_id,
+        fee:            tx[:fee],
+        memo:           tx[:memo],
+        msgs:           tx[:msg],
+        sequence:       account["sequence"]
+      }
+      to_deep_sorted_json(sign_obj)
+    end
+
+    def get_account
+      response = rest_get("/auth/accounts/#{@from_address}")
+      account = JSON.parse(response.body)
+      return account['result']['value']
+    end
+
+    def rest_get(url)
+      @rest_lib.rest_get(url)
+    end
+
+    def rest_post(url, data)
+      @rest_lib.rest_post(url, data)
+    end
+
+    def to_deep_sorted_json(obj)
+      if obj.instance_of?(Array)
+        return '[' + obj.map{|o|to_deep_sorted_json(o)}.join(',') + ']'
+      end
+
+      if obj.instance_of?(Hash)
+        keys = obj.keys.sort
+        return '{' + keys.map{|k| JSON.generate(k) + ':' + to_deep_sorted_json(obj[k])}.join(',') + '}'
+      end
+
+      JSON.generate(obj)
+    end
+  end
+end

data/lib/dbchain_client/writer.rb

@@ -0,0 +1,42 @@
+require 'json'
+require 'base64'
+require 'net/http'
+require_relative 'message_generator'
+
+module DbchainClient
+  class Writer 
+    def initialize(base_url, chain_id, private_key_hex, address=nil)
+      @transaction = DbchainClient::Transaction.new(base_url, chain_id, private_key_hex)
+      from_address = address || PrivateKey.new(private_key_hex).public_key.address
+      @message_generator = DbchainClient::MessageGenerator.new(from_address)
+    end
+  
+    def send_token(to_address, amount)
+      message = generate_message('MsgSend',
+        to_address: to_address,
+        amount: [{denom: 'dbctoken', amount: amount.to_string}]
+      )
+      sign_and_broadcast([message])
+    end
+
+    def insert_row(app_code, table_name, fields)
+      fields_str = Base64.strict_encode64(fields.to_json)
+      message = generate_message('InsertRow',
+        app_code: app_code,
+        table_name: table_name,
+        fields: fields_str
+      )
+      sign_and_broadcast([message])
+    end
+
+    private
+
+    def generate_message(message_type, message_data)
+      @message_generator.run(message_type, message_data)
+    end
+
+    def sign_and_broadcast(messages)
+      @transaction.sign_and_broadcast([message])
+    end
+  end
+end

data/lib/dbchain_client.rb

@@ -1,3 +1,13 @@
-require_relative "dbchain_client/mnemonics"
-require_relative "dbchain_client/key"
-require_relative "dbchain_client/transaction"
+module DbchainClient
+  autoload :Mnemonics,        "dbchain_client/mnemonics"
+  autoload :PrivateKey,       "dbchain_client/key"
+  autoload :PublicKey,        "dbchain_client/key"
+  autoload :KeyStore,         "dbchain_client/key_escrow"
+  autoload :MessageGenerator, "dbchain_client/message_generator"
+  autoload :RestLib,          "dbchain_client/rest_lib"
+  autoload :Transaction,      "dbchain_client/transaction"
+  autoload :Writer,           "dbchain_client/writer"
+  autoload :Reader,           "dbchain_client/reader"
+  autoload :KeyEscrow,        "dbchain_client/key_escrow"
+  autoload :AESCrypt,         "dbchain_client/aes"
+end

metadata

@@ -1,22 +1,33 @@
 --- !ruby/object:Gem::Specification
 name: dbchain_client
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Ethan Zhang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-14 00:00:00.000000000 Z
+date: 2021-12-15 00:00:00.000000000 Z
 dependencies: []
-description: This is the ruby client of dbchain.
+description: This is the ruby client of DBChain. DBChain is a blockchain based relational
+  database. Developers can use traditional ways to quickly develop blockchain applications
+  with DBChain.
 email: yzhang.wa@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
 - lib/dbchain_client.rb
+- lib/dbchain_client/aes.rb
+- lib/dbchain_client/key.rb
+- lib/dbchain_client/key_escrow.rb
+- lib/dbchain_client/message_generator.rb
+- lib/dbchain_client/mnemonics.rb
+- lib/dbchain_client/reader.rb
+- lib/dbchain_client/rest_lib.rb
+- lib/dbchain_client/transaction.rb
+- lib/dbchain_client/writer.rb
 homepage: https://rubygems.org/gems/dbchain_client
 licenses:
 - MIT