dbchain_client 0.0.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 173ee91c28a540f7ff7b59d983f343f0d8cefc6a72e75f781dc520105bbe7ec0
-  data.tar.gz: b3421de0f7cf1165c838636954fcd81ce29411bd40576dcec00f60812b098005
+  metadata.gz: 8bbc767c04668e2a61263dca178a4b957c754859e4319dec14048d230d639c26
+  data.tar.gz: 5f5eb7aed816a764524b3c50f0ae74fa54626595eefdfcf6f228bceb238c196e
 SHA512:
-  metadata.gz: f0c5d9e16423d59ce77d2e3831527d0bf6ec80a19f89a95eb418f6d39b80c1e62d48b35de74a47976ac949f326624686606176d7ac50791b337ec7f78737c198
-  data.tar.gz: c2cdae17fea8f1dfa6fde586aa0a2e58a7901de4c32bc6abb6fa45d826365c0ee34f325c29fbc2d3dbfba937d8e536e71da784a67a496913a614aba1b34add7d
+  metadata.gz: eadc63b8c3a2a771bcb1845103bf86a35ae9a2af2273f89a1a680f779d95ca2732752957314874be431072c7c10dd0e7ed4f548334091c4b86fb50fd1b270ef2
+  data.tar.gz: 5996ecbe45d93d40a9b9beee5fdb1c3f621af2585d70dde2b9fb9bdde8b2748685f2b2b36ac4e0ffc9d20231def53cf656fef982db6543f54f4f3815acd01600

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,72 @@
+#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)
+      raw_sig = signature.raw
+      @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)
+      Signature.new(raw_sig)
+    end
+  end
+
+  class Signature
+    include Secp256k1::ECDSA
+
+    def initialize(raw_sig)
+      @raw_sig = raw_sig
+    end
+
+    def raw
+      @raw_sig
+    end
+
+    def compact
+      ecdsa_serialize_compact(@raw_sig)
+    end
+
+    def to_hex
+      compact.unpack("H*")
+    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,44 @@
+require 'json'
+require 'base58'
+
+module DbchainClient
+  class Reader
+    QueryRoot = '/dbchain'
+
+    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 get_row(app_code, table_name, id)
+      uri = uri_builder("find", app_code, table_name, id)
+      response = @rest_lib.rest_get(uri)
+      h = JSON.parse(response.body)
+      return h['result']
+    end
+
+    def generate_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.compact, :bitcoin)
+      "#{encoded_public_key}:#{time}:#{encoded_signature}"
+    end
+
+    def uri_builder(*args)
+      raise "At least one parameter is needed!" if args.size < 1
+      access_token = generate_access_code
+      args.insert(1, access_token)
+      args.unshift(QueryRoot)
+      args.join('/')
+    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.compact),
+        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(messages)
+    end
+  end
+end

data/lib/dbchain_client.rb

@@ -1,26 +1,13 @@
-require "bitcoin"
-
-module DbchainRubyClient
-  class Key
-    def self.generate_mnemonic(strength_bits = 128)
-      Bitcoin::Trezor::Mnemonic.generate(strength_bits)
-    end
-
-    def self.mnemonic_to_master_key(mnemonic)
-      seed = Bitcoin::Trezor::Mnemonic.to_seed(mnemonic)
-      Bitcoin::ExtKey.generate_master(seed.htb)
-    end
-
-    def self.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 self.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
+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,23 +1,34 @@
 --- !ruby/object:Gem::Specification
 name: dbchain_client
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Ethan Zhang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-12-01 00:00:00.000000000 Z
+date: 2021-12-16 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
-homepage: https://rubygems.org/gems/dbchain_client
+- 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://github.com/dbchaincloud/ruby-client
 licenses:
 - MIT
 metadata: {}
@@ -36,7 +47,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3.1
+rubygems_version: 3.2.22
 signing_key: 
 specification_version: 4
 summary: ruby client of dbchain.