blzrb 0.1.0

data/lib/bluzelle/swarm/cosmos.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+require 'json'
+require 'bluzelle/utils'
+require 'bluzelle/constants'
+
+module Bluzelle
+  module Swarm
+    class Cosmos
+      include Bluzelle::Constants
+      include Bluzelle::Utils
+
+      attr_reader :mnemonic, :endpoint, :address, :chain_id
+      attr_accessor :account_info
+
+      def initialize(options = {})
+        @mnemonic = options[:mnemonic]
+        @chain_id = options[:chain_id]
+        @endpoint = options[:endpoint]
+        @account_info = {}
+
+        @private_key = get_ec_private_key(@mnemonic)
+        @address = address_from_mnemonic
+
+        account
+      end
+
+      def query(endpoint)
+        Request.execute(method: 'get', url: "#{@endpoint}/#{endpoint}")
+      end
+
+      def send_transaction(method, endpoint, data, gas_info)
+        txn = Transaction.new(method, endpoint, data)
+        txn.set_gas(gas_info)
+
+        # fetch skeleton
+        skeleton = fetch_txn_skeleton(txn)
+        # set gas
+        skeleton = update_gas(txn, skeleton)
+        # sort
+        skeleton = sort_hash(skeleton)
+
+        broadcast_transaction(Transaction.new('post', TX_COMMAND, skeleton))
+      end
+
+      private
+
+      # Account query
+      def account
+        url = "#{@endpoint}/auth/accounts/#{@address}"
+        res = Request.execute(method: 'get', url: url)
+
+        set_account_details(res.dig('result', 'value'))
+      end
+
+      # Broadcasts a transaction
+      #
+      # @param [Bluzelle::Swarm::Transaction] txn
+      def broadcast_transaction(txn)
+        txn.data['memo'] = make_random_string
+
+        txn.data['signatures'] = [{
+          'account_number' => @account_info['account_number'].to_s,
+          'pub_key' => {
+            'type' => 'tendermint/PubKeySecp256k1',
+            'value' => to_base64(
+              [compressed_pub_key(open_key(@private_key))].pack('H*')
+            )
+          },
+          'sequence' => @account_info['sequence'].to_s,
+          'signature' => sign_transaction(txn.data)
+        }]
+
+        url = "#{@endpoint}/#{txn.endpoint}"
+        payload = { 'mode' => 'block', 'tx' => txn.data }
+
+        res = Request.execute(method: txn.method, url: url, payload: payload)
+
+        if res.dig('code').nil?
+          update_sequence
+          decode_json(hex_to_bin(res.dig('data'))) if res.key?('data')
+        else
+          handle_broadcast_error(res.dig('raw_log'), txn)
+        end
+      end
+
+      # Updates account sequence and retries broadcast
+      #
+      # @param [Bluzelle::Swarm::Transaction] txn
+      def update_account_sequence(txn)
+        if txn.retries_left != 0
+          account
+          retry_broadcast(txn)
+        else
+          raise Error::ApiError, 'Invalid chain id'
+        end
+      end
+
+      # Fetch transaction skeleton
+      def fetch_txn_skeleton(txn)
+        url = "#{@endpoint}/#{txn.endpoint}"
+
+        data = Request.execute(
+          method: txn.method,
+          url: url,
+          payload: txn.data,
+          headers: { 'Content-Type': 'application/x-www-form-urlencoded' }
+        )
+
+        data['value']
+      end
+
+      # Check if address and mnemonic are valid
+      def address_from_mnemonic
+        pub_key = get_ec_public_key_from_priv(@private_key)
+        get_address(pub_key)
+      end
+
+      # Updates account details
+      #
+      # @param [Hash] data
+      def set_account_details(data)
+        account_number = data.dig('account_number')
+        sequence = data.dig('sequence')
+
+        @account_info['account_number'] = account_number
+
+        if @account_info['sequence'] != sequence
+          @account_info['sequence'] = sequence
+          return true
+        end
+
+        false
+      end
+
+      # Retry broadcast after failure
+      #
+      # @param [Bluzelle::Swarm::Transaction]
+      def retry_broadcast(txn)
+        txn.retries_left -= 1
+
+        sleep BROADCAST_RETRY_SECONDS
+
+        broadcast_transaction(txn)
+      end
+
+      # Handle broadcast error
+      #
+      # @param [String] raw_log
+      # @param [Bluzelle::Swarm::Transaction] txn
+      def handle_broadcast_error(raw_log, txn)
+        if raw_log.include?('signature verification failed')
+          update_account_sequence(txn)
+        else
+          raise Error::ApiError, extract_error_message(raw_log)
+        end
+      end
+
+      # Update account sequence
+      def update_sequence
+        @account_info['sequence'] = @account_info['sequence'].to_i + 1
+      end
+
+      # Signs a transaction
+      #
+      # @param txn
+      def sign_transaction(txn)
+        payload = {
+          'account_number' => @account_info['account_number'].to_s,
+          'chain_id' => @chain_id,
+          'fee' => txn['fee'],
+          'memo' => txn['memo'],
+          'msgs' => txn['msg'],
+          'sequence' => @account_info['sequence'].to_s
+        }
+
+        to_base64(ecdsa_sign(encode_json(payload), @private_key))
+      end
+
+      def update_gas(txn, data)
+        res = data.clone
+
+        if res.dig('fee', 'gas').to_i > txn.max_gas && txn.max_gas != 0
+          res['fee']['gas'] = txn.max_gas.to_s
+        end
+
+        if !txn.max_fee.nil?
+          res['fee']['amount'] = [{
+            'denom': TOKEN_NAME,
+            'amount': txn.max_fee.to_s
+          }]
+        elsif !txn.gas_price.nil?
+          res['fee']['amount'] = [{
+            'denom': TOKEN_NAME,
+            'amount': (res['fee']['gas'] * txn.gas_price).to_s
+          }]
+        end
+
+        res
+      end
+
+      def update_memo(txn)
+        txn['memo'] = make_random_string
+        txn
+      end
+    end
+  end
+end

data/lib/bluzelle/swarm/request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'rest-client'
+
+module Bluzelle
+  module Swarm
+    class Request
+      class << self
+        def execute(options = {})
+          resp = RestClient::Request.execute(parse_options(options))
+        rescue RestClient::ExceptionWithResponse => e
+          case e.http_code
+          when 404, 500
+            raise Error::ApiError, e.response.body
+          else
+            error(e)
+          end
+        else
+          success(resp)
+        end
+
+        private
+
+        def parse_options(options = {})
+          {
+            method: options[:method],
+            url: options[:url],
+            payload: JSON.generate(options[:payload]),
+            headers: options[:headers]
+          }
+        end
+
+        def error(err)
+          body = JSON.parse(err.response.body)
+          error_message = body.dig('error', 'message')
+
+          if error_message.is_a?(String)
+            raise Error::ApiError, error_message
+          else
+            raise Error::ApiError, 'error occurred'
+          end
+        end
+
+        def success(resp)
+          JSON.parse(resp.body)
+        end
+      end
+    end
+  end
+end

data/lib/bluzelle/swarm/transaction.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Bluzelle
+  module Swarm
+    class Transaction
+      attr_reader :method, :endpoint, :data
+      attr_accessor :gas_price, :max_gas, :max_fee, :memo, :retries_left
+
+      def initialize(method, endpoint, data)
+        @method = method
+        @endpoint = endpoint
+        @data = data
+        @gas_price = 0
+        @max_gas = 0
+        @max_fee = 0
+        @retries_left = 10
+      end
+
+      def set_gas(gas_info)
+        return if gas_info.nil? || !gas_info.is_a?(Hash)
+
+        gas_info = Utils.stringify_keys(gas_info)
+
+        @gas_price = gas_info['gas_price'].to_i if gas_info.key?('gas_price')
+
+        @max_gas = gas_info['max_gas'].to_i if gas_info.key?('max_gas')
+
+        @max_fee = gas_info['max_fee'].to_i if gas_info.key?('max_fee')
+      end
+    end
+  end
+end

data/lib/bluzelle/utils.rb

@@ -0,0 +1,185 @@
+require 'bip_mnemonic'
+require 'bitcoin'
+require 'money-tree'
+require 'digest'
+require 'openssl'
+require 'base64'
+require 'secp256k1'
+
+module Bluzelle
+  module Utils
+    module_function
+
+    def get_ec_private_key(mnemonic)
+      seed = bip39_mnemonic_to_seed(mnemonic)
+      node = bip32_from_seed(seed)
+      child = node.node_for_path(Constants::PATH)
+      ec_pair = create_ec_pair(child.private_key.to_hex)
+      ec_pair.priv
+    end
+
+    def get_ec_public_key_from_priv(priv)
+      key = open_key(priv)
+      compressed_pub_key(key)
+    end
+
+    def validate_address(address, mnemonic)
+      priv_key = get_ec_private_key(mnemonic)
+      pub_key = get_ec_public_key_from_priv(priv_key)
+
+      if get_address(pub_key) != address
+        raise ArgumentError, 'Bad credentials - verify your address and mnemonic'
+      end
+    end
+
+    def get_address(pub_key)
+      hash = rmd_160_digest(sha_256_digest([pub_key].pack('H*')))
+      word = bech32_convert_bits(to_bytes(hash))
+      bech32_encode(Constants::PREFIX, word)
+    end
+
+    def to_bytes(obj)
+      obj.bytes
+    end
+
+    def rmd_160_digest(hex)
+      Digest::RMD160.digest hex
+    end
+
+    def sha_256_digest(hex)
+      Digest::SHA256.digest hex
+    end
+
+    def bech32_encode(prefix, word)
+      Bitcoin::Bech32.encode(prefix, word)
+    end
+
+    def bech32_convert_bits(bytes, from_bits: 8, to_bits: 5, pad: false)
+      Bitcoin::Bech32.convert_bits(bytes, from_bits: from_bits, to_bits: to_bits, pad: pad)
+    end
+
+    def bip39_mnemonic_to_seed(mnemonic)
+      BipMnemonic.to_seed(mnemonic: mnemonic)
+    end
+
+    def open_key(priv)
+      group = OpenSSL::PKey::EC::Group.new('secp256k1')
+      key = OpenSSL::PKey::EC.new(group)
+
+      key.private_key = OpenSSL::BN.new(priv, 16)
+      key.public_key = group.generator.mul(key.private_key)
+
+      key
+    end
+
+    def compressed_pub_key(key)
+      public_key = key.public_key
+      public_key.group.point_conversion_form = :compressed
+      public_key.to_hex.rjust(66, '0')
+    end
+
+    def bip32_from_seed(seed)
+      MoneyTree::Master.new(seed_hex: seed)
+    end
+
+    def create_ec_pair(private_key)
+      Bitcoin::Key.new(private_key, nil, { compressed: false })
+    end
+
+    def make_random_string(length = 32)
+      random_string = ''
+      chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'.chars
+
+      1.upto(length) { random_string << chars.sample }
+
+      random_string
+    end
+
+    def to_base64(str)
+      Base64.strict_encode64(str)
+    end
+
+    def convert_lease(lease)
+      return '0' if lease.nil?
+
+      seconds = 0
+
+      seconds += lease.dig(:days).nil? ? 0 : (lease.dig(:days).to_i * 24 * 60 * 60)
+      seconds += lease.dig(:hours).nil? ? 0 : (lease.dig(:hours).to_i * 60 * 60)
+      seconds += lease.dig(:minutes).nil? ? 0 : (lease.dig(:minutes).to_i * 60)
+      seconds += lease.dig(:seconds).nil? ? 0 : lease.dig(:seconds).to_i
+
+      (seconds / Constants::BLOCK_TIME_IN_SECONDS).to_s
+    end
+
+    def sort_hash(hash)
+      hash_clone = hash.clone
+
+      hash_clone.each do |key, value|
+        hash_clone[key] = sort_hash(value) if value.is_a?(Hash)
+
+        next unless value.is_a?(Array)
+
+        arr = []
+
+        hash_clone[key].each do |el|
+          arr << sort_hash(el)
+        end
+
+        hash_clone[key] = arr
+      end
+
+      hash_clone.sort.to_h
+    end
+
+    def stringify_keys(hash)
+      res = {}
+
+      hash.each do |key, value|
+        if value.is_a?(Hash)
+          res[key.to_s] = stringify_keys(value)
+          next
+        end
+        res[key.to_s] = value
+      end
+
+      res
+    end
+
+    def ecdsa_sign(payload, private_key)
+      pk = Secp256k1::PrivateKey.new(privkey: hex_to_bin(private_key), raw: true)
+      rs = pk.ecdsa_sign(payload)
+      r = rs.slice(0, 32).read_string.reverse
+      s = rs.slice(32, 32).read_string.reverse
+      "#{r}#{s}"
+    end
+
+    def encode_json(obj)
+      JSON.generate(obj)
+    end
+
+    def decode_json(str)
+      JSON.parse(str)
+    end
+
+    def hex_to_bin(hex_str)
+      [hex_str].pack('H*')
+    end
+
+    def extract_error_message(str)
+      offset1 = str.index(': ')
+
+      return str if offset1.nil?
+
+      prefix = str.slice(0, offset1)
+
+      case prefix
+      when 'insufficient fee'
+        return str.slice(offset1 + 2, str.length)
+      end
+
+      offset2 = str.index(': ', offset1 + 1)
+      str[(offset1 + 2)..(offset2 - 1)]
+    end
+  end
+end