istox 0.1.81 → 0.1.82

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9b67e7deab7a2a53ab80d237842554f21ca126e3542bf75dfbbb68a46961395
-  data.tar.gz: 913e6213c402f933ac375bb77999119131d25e0a886c5cf2819c8ed56685ba88
+  metadata.gz: 143b2d10bf2308d6fa9600f98b27c2e4da90c7cc92c18f3fca1cadf4c0e1998e
+  data.tar.gz: 0cad5b15227ba33e92c097a796038a6a931c9a2754ef4ea76f32c9de9c6a0580
 SHA512:
-  metadata.gz: 6c02663da343a9b5efef558084c5a14f32c92900b055d3fc3041e71dec38a1fa828b2e8ed4aee8ef7f1c2f7eccc991bd11a24bb2e7300505b6b11e025ff4249d
-  data.tar.gz: a57ed4210294057d2ef6cbbb9dedab41b28e0a2f78f8f75e2d97d17f5afce0b3a9948f9aca7ad0a8b0d685bfd58ebbf08d0876a0236b0833ff100beed7595368
+  metadata.gz: 46dc524ec7f211533dc1ecccb7825391d78afcfc2b3fb687a418772ca257c8a0f8ee7681ed124b2bfda798bce998d62f0ed611edbeb65455784fae89d1d92494
+  data.tar.gz: 7095b75a70ab832b522b135027206529f16dd11f34fb4838d0334d55e83313a878851459825e51171fd79a669b84c02f6e0c1f8883efef12b056462cbd880c11

data/.rubocop.yml

@@ -0,0 +1,102 @@
+require: rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 2.5
+  Exclude:
+    - .gems/**/*
+    - bin/**/*
+    - config/**/*
+    - db/**/*
+    - log/**/*
+    - public/**/*
+    - tmp/**/*
+    - vendor/**/*
+    - spec/rails_helper.rb
+    - spec/spec_helper.rb
+    - config.ru
+    - Guardfile
+    - Rakefile
+
+Documentation:
+  Enabled: false
+
+Layout/SpaceBeforeFirstArg:
+  Exclude:
+    - app/views/api/**/**/*
+
+Lint/AmbiguousBlockAssociation:
+  Exclude:
+    - spec/**/*
+
+Metrics/AbcSize:
+  # The ABC size is a calculated magnitude, so this number can be an Integer or
+  # a Float.
+  Max: 100
+
+Metrics/BlockLength:
+  CountComments: false  # count full line comments?
+  Max: 25
+  Exclude:
+    - config/**/*
+    - spec/**/*
+    - app/admin/**/*
+
+Metrics/BlockNesting:
+  Max: 4
+
+Metrics/ClassLength:
+  CountComments: false  # count full line comments?
+  Max: 200
+
+# Avoid complex methods.
+Metrics/CyclomaticComplexity:
+  Max: 20
+
+Metrics/MethodLength:
+  CountComments: false  # count full line comments?
+  Max: 100
+
+Metrics/ModuleLength:
+  CountComments: false  # count full line comments?
+  Max: 200
+
+Metrics/LineLength:
+  Max: 130
+  # To make it possible to copy or click on URIs in the code, we allow lines
+  # containing a URI to be longer than Max.
+  AllowURI: true
+  URISchemes:
+    - http
+    - https
+
+Metrics/ParameterLists:
+  Max: 5
+  CountKeywordArgs: true
+
+Metrics/PerceivedComplexity:
+  Max: 12
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+RSpec/MultipleExpectations:
+  Max: 99
+
+RSpec/ExampleLength:
+  Max: 100
+
+Lint/BigDecimalNew:
+  Enabled: false
+
+
+RSpec/MessageSpies:
+  Enabled: false
+
+RSpec/AnyInstance:
+  Enabled: false
+
+RSpec/VerifiedDoubles:
+  Enabled: false

data/.solargraph.yml

@@ -0,0 +1,14 @@
+---
+include:
+- "**/*.rb"
+exclude:
+- spec/**/*
+- test/**/*
+- vendor/**/*
+- ".bundle/**/*"
+require: []
+domains: []
+reporters:
+- rubocop
+require_paths: []
+max_files: 5000

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    istox (0.1.80)
+    istox (0.1.81.pre.test9)
       binding_of_caller
       bunny (>= 2.12.0)
       graphlient

data/lib/istox.rb

@@ -1,34 +1,35 @@
 require 'active_record'
 require 'paranoia'
-require "gruf"
-require "listen"
-require "istox/version"
+require 'gruf'
+require 'listen'
+require 'istox/version'
 
 module Istox
   # Your code goes here...
   class Test
     def self.method1
-      "abc"
+      'abc'
     end
   end
 
-  require "istox/interfaces/chainhub/transaction"
-  require "istox/helpers/publisher"
-  require "istox/helpers/bunny_boot"
-  require "istox/helpers/vault"
-  require "istox/helpers/order_book"
-  require "istox/helpers/grpc_client"
-  require "istox/helpers/graphql_client"
-  require "istox/helpers/gruf_listener_hook"
-  require "istox/helpers/message_service"
-  require "istox/helpers/blockchain_receipt_service"
-  require "istox/helpers/f_math"
-  require "istox/models/blockchain_receipt"
-  require "istox/models/concerns/blockchain_receipt_query"
-  require "istox/consumers/blockchain_status_handler"
-  require "istox/consumers/blockchain_hash_handler"
-  require "istox/migrations/create_blockchain_receipts"
-  require "istox/logging/hash_logging"
-  require "istox/logging/log_formatter"
+  require 'istox/interfaces/chainhub/transaction'
+  require 'istox/helpers/publisher'
+  require 'istox/helpers/bunny_boot'
+  require 'istox/helpers/vault'
+  require 'istox/helpers/order_book'
+  require 'istox/helpers/grpc_client'
+  require 'istox/helpers/graphql_client'
+  require 'istox/helpers/gruf_listener_hook'
+  require 'istox/helpers/message_service'
+  require 'istox/helpers/blockchain_service'
+  require 'istox/helpers/f_math'
+  require 'istox/helpers/my_open_struct'
+  require 'istox/helpers/common_helper'
+  require 'istox/models/blockchain_receipt'
+  require 'istox/models/concerns/blockchain_receipt_query'
+  require 'istox/consumers/blockchain_status_handler'
+  require 'istox/migrations/create_blockchain_receipts'
+  require 'istox/logging/hash_logging'
+  require 'istox/logging/log_formatter'
   require "istox/quant/bond"
 end

data/lib/istox/consumers/blockchain_status_handler.rb

@@ -1,105 +1,54 @@
 module Istox
   class BlockchainStatusHandler
     class << self
-
-      def txn_data_confirmed(transactions)
-        found_txns = transactions.map do |transaction|
-          receipt = ::Istox::BlockchainReceipt.where(txid: transaction.uuid).first
-          if !receipt.blank?
-            handling_receipt = ::Istox::BlockchainReceipt.where(txhash: transaction.id, txid: transaction.uuid).first
-            raise 'Unable to find receipt' if handling_receipt.blank?
-            transaction
-          else
-            puts 'Transaction doesnt belong here, skipping...'
-            nil
-          end
-        end.compact
-
-        found_txns.each do |transaction|
-          receipt = ::Istox::BlockchainReceipt.where(txhash: transaction.id, txid: transaction.uuid).first
-
-          receipt.update!(status: "confirmed")
-
-          resource = begin
-            class_eval("::#{receipt.resource_name}").find(receipt.resource_id)
-          rescue => e
-            puts "Class not found, skipping..."
-            next
-          end
-
-          receipt_list = get_receipt_list(resource)
-
-          next if resource_handled?(receipt_list)
-
-          next if resource.outcome == 'pending'
-
-          if resource.outcome == 'confirmed'
-            resource.handle_confirm(receipt.resource_action)
-            
-            mark_resource_handled(receipt_list)
-            publish_to_frontend(resource, true, receipt, receipt.sid, receipt_list)
-          end
-
+      # format of transaction
+      # {
+      #   type: 'CHAINHUB_RESPONSE_EVENT',
+      #   uuid:'123', //original request uuid sent from backend
+      #   success:true, //status of the whole request in true/false
+      #   message:'',  //In case of error, the message contain the error reason
+      #   txnCount:1,  //Number of blockchain transactions from the original request
+      #   txnHashes:[] //Hashes for all transactions that has been submitted and mined by the blockchain for verification purpose
+      # }
+
+      def chainhub_response_event(transaction)
+        receipt = ::Istox::BlockchainReceipt.where(txid: transaction.uuid).first
+        if receipt.blank?
+          puts 'Transaction doesn\'t belong to this backend, skipping...'
+          return
         end
-      end
-
-      def txn_status_changed(transactions, payload_target)
-        # pre check all transaction does exists
-        found_txns = transactions.map do |transaction|
-          receipt = ::Istox::BlockchainReceipt.where(txid: transaction.uuid).first
-          if !receipt.blank?
-            handling_receipt = ::Istox::BlockchainReceipt.where(txhash: transaction.id, txid: transaction.uuid).first
-            raise 'Unable to find receipt' if handling_receipt.blank?
-            transaction
-          else
-            puts 'Transaction doesnt belong here, skipping...'
-            nil
-          end
-        end.compact
 
-        found_txns.each do |transaction|
-          receipt = ::Istox::BlockchainReceipt.where(txhash: transaction.id, txid: transaction.uuid).first
+        status = transaction.success ? 'confirmed' : 'failed'
 
-          next if !(%w[failed pending].include?(transaction.status))
-          receipt.update!(status: transaction.status)
-          
-          resource = begin
-            class_eval("::#{receipt.resource_name}").find(receipt.resource_id)
-          rescue => e
-            puts "Class not found, skipping..."
-            next
-          end
+        receipt.update!(status: status, message: transaction.message,
+                        txhash: transaction.txnHashes.present? ? transaction.txnHashes.join(',') : nil)
 
-          receipt_list = get_receipt_list(resource)
-
-          next if resource_handled?(receipt_list)
+        resource = begin
+          class_eval("::#{receipt.resource_name}", __FILE__, __LINE__).find(receipt.resource_id)
+                   rescue StandardError
+                     puts 'Class not found, skipping...'
+                     return
+        end
 
-          # if transaction.status == 'confirmed'
-          #   next if resource.outcome == 'pending'
+        return if resource_handled?(receipt)
 
-          #   if resource.outcome == 'confirmed'
-          #     resource.handle_confirm(receipt.resource_action)
-              
-          #     mark_resource_handled(receipt_list)
-          #     publish_to_frontend(resource, true, receipt, receipt.sid, receipt_list)
-          #   end
-          # end
+        if status == 'confirmed'
+          resource.handle_confirm(receipt)
 
-          if transaction.status == 'failed'
-            resource.handle_fail(receipt.resource_action)
+          mark_resource_handled(receipt)
+          publish_to_frontend(resource, true, receipt, receipt.sid)
 
-            mark_resource_handled(receipt_list)
-            publish_to_frontend(resource, false, receipt, receipt.sid, receipt_list)
-          end
+        elsif status == 'failed'
+          resource.handle_fail(receipt)
 
+          mark_resource_handled(receipt)
+          publish_to_frontend(resource, false, receipt, receipt.sid)
         end
       end
 
       private
 
-      def publish_to_frontend(model, success, receipt, sid, receipt_list)
-        yield if block_given?
-
+      def publish_to_frontend(model, success, receipt, sid)
         ::Istox::Publisher.publish(
           'amq.topic',
           model.class.name.gsub('::', '').underscore.to_s,
@@ -115,34 +64,26 @@ module Istox
           data: {
             success: success,
             purpose: receipt.activity,
-            txids: get_receipts_tx_hashes(receipt_list)
+            message: receipt.message
           }
         )
+      rescue StandardError => e
+        Rails.logger.error "Unable to publish to frontend for receipt #{receipt.inspect},
+        but will silently ignore the error"
+        Rails.logger.error e
       end
 
-      def get_receipts_tx_hashes(receipt_list)
-        tx_hashes = receipt_list.map(&:txhash).compact
-
-        tx_hashes.join(', ')
+      def mark_resource_handled(receipt)
+        receipt.update(resource_handled: true)
+      rescue StandardError => e
+        Rails.logger.error "Unable to update resource_handled for receipt #{receipt.inspect},
+        but will silently ignore the error"
+        Rails.logger.error e
       end
 
-      def mark_resource_handled(receipt_list)
-        receipt_list.each do |receipt|
-          receipt.update(resource_handled: true)
-        end
+      def resource_handled?(receipt)
+        receipt.resource_handled == true
       end
-
-      def resource_handled?(receipt_list)
-        receipt_list.map(&:resource_handled).none? { |item| item.nil? || item == false }
-      end
-
-      def get_receipt_list(resource)
-        ::Istox::BlockchainReceipt.where(
-          resource_name: resource.class.name,
-          resource_id: resource.id
-        )
-      end
-
     end
   end
 end

data/lib/istox/helpers/blockchain_service.rb

@@ -0,0 +1,64 @@
+module Istox
+  class BlockchainService
+    def self.init(blockchain_receipt_klass)
+      @@blockchain_receipt_klass = blockchain_receipt_klass
+    end
+
+    def self.get_blockchain_receipt_klass
+      @@blockchain_receipt_klass
+    end
+
+    def self.request(sid:, action:, before:, execute:)
+      start(sid: sid, action: action, before: before, execute: execute, is_request: true)
+    end
+
+    def self.run(sid:, action:, before:, execute:)
+      start(sid: sid, action: action, before: before, execute: execute)
+    end
+    class << self
+      private
+
+      # before is the proc that will be executed before, must return the main model blockchain receipt will bind to
+      def start(sid:, action:, before:, execute:, is_request: false)
+        # create blockchain receipt first
+        klass = blockchain_receipt_class
+        uuid = ::SecureRandom.uuid
+        @receipt = klass.create!(
+          txid: uuid,
+          sid: sid,
+          is_request: is_request,
+          resource_action: action
+        )
+
+        ::ActiveRecord::Base.transaction do
+          # execute before proc, and get the model that blockchain receipt should bind to
+          model = before.call(uuid)
+
+          # delete the previous existing blockchain receipts
+          klass.where(resource_name: model.class.name, resource_id: model.id).destroy_all
+
+          # then update receipt
+          @receipt.update!(resource_id: model.id, resource_name: model.class.name)
+
+          # execute the actual call to chainhub
+          execute.call(uuid)
+        end
+      rescue StandardError => e
+        @receipt&.destroy
+        raise e
+      end
+
+      def blockchain_receipt_class
+        raise 'Have you forgetten to init blockchain receipt service?' if get_blockchain_receipt_klass.nil?
+
+        blockchain_receipt_klass = get_blockchain_receipt_klass
+        klass = class_eval("::#{blockchain_receipt_klass.name}", __FILE__, __LINE__)
+        unless klass <= ::Istox::BlockchainReceipt
+          raise "#{blockchain_receipt_klass.name} does not inherit istox blockchain receipt"
+        end
+
+        klass
+      end
+    end
+  end
+end

data/lib/istox/helpers/common_helper.rb

@@ -0,0 +1,45 @@
+module Istox
+  module CommonHelper
+    def self.to_open_struct(model)
+      return nil if model.blank?
+
+      if model.is_a?(Array)
+        model.map do |item|
+          hash = deep_to_h(item).deep_transform_keys { |key| key.to_s.underscore.to_sym }
+          to_recursive_ostruct(hash)
+        end
+      else
+        hash = deep_to_h(model).deep_transform_keys { |key| key.to_s.underscore.to_sym }
+        to_recursive_ostruct(hash)
+      end
+    end
+
+    def self.to_recursive_ostruct(obj)
+      if obj.is_a?(Hash)
+        ::Istox::MyOpenStruct.new(obj.map { |key, val| [key, to_recursive_ostruct(val)] }.to_h)
+      elsif obj.is_a?(Array)
+        obj.map { |o| to_recursive_ostruct(o) }
+      elsif obj.is_a?(OpenStruct)
+        ::Istox::MyOpenStruct.new(obj)
+      else # Assumed to be a primitive value
+        obj
+      end
+    end
+
+    def self.deep_to_h(obj)
+      if obj.is_a?(Array)
+        obj.map { |r| deep_to_h(r) }
+      elsif obj.is_a?(OpenStruct) || obj.is_a?(Hash) || (obj.methods.include?(:to_h) && obj.present?)
+        obj.to_h.transform_values do |v|
+          if v.is_a?(OpenStruct) || v.is_a?(Array)
+            deep_to_h(v)
+          else
+            v
+          end
+        end
+      else
+        obj
+      end
+    end
+  end
+end

data/lib/istox/helpers/f_math.rb

@@ -1,7 +1,7 @@
+# rubocop:disable Naming/UncommunicativeMethodParamName
 module Istox
   class FMath
     class << self
-
       def add(x, y)
         BigDecimal.mode(BigDecimal::ROUND_MODE, :down)
 
@@ -11,7 +11,7 @@ module Istox
         x = ::BigDecimal.new(x.to_s)
         y = ::BigDecimal.new(y.to_s)
 
-        return x.add(y, 100).truncate(18).to_s
+        x.add(y, 100).truncate(18).to_s
       end
 
       def sub(x, y)
@@ -23,7 +23,7 @@ module Istox
         x = ::BigDecimal.new(x.to_s)
         y = ::BigDecimal.new(y.to_s)
 
-        return x.sub(y, 100).truncate(18).to_s
+        x.sub(y, 100).truncate(18).to_s
       end
 
       def mul(x, y)
@@ -35,7 +35,7 @@ module Istox
         x = ::BigDecimal.new(x.to_s)
         y = ::BigDecimal.new(y.to_s)
 
-        return x.mult(y, 100).truncate(18).to_s
+        x.mult(y, 100).truncate(18).to_s
       end
 
       def div(x, y)
@@ -47,19 +47,17 @@ module Istox
         x = to_fixed(x)
         y = to_fixed(y)
 
-        return ::BigDecimal.new("1").to_s if x == y
+        return ::BigDecimal.new('1').to_s if x == y
+
+        fixed1 = ::BigDecimal.new('1e18')
 
-        fixed_1 = ::BigDecimal.new("1e18")
-        
-        if (((x.div(y, 100)).modulo(BigDecimal.new(10)) == 0) && (x.modulo(y) == 0)) 
-          return from_fixed((x.div(y, 100).mult(fixed_1, 100)))
-        end
+        return from_fixed(x.div(y, 100).mult(fixed1, 100)).to_s if x.div(y, 100).modulo(BigDecimal.new(10)).zero? && x.modulo(y).zero?
 
-        r_y = fixed_1.mult(fixed_1, 100).truncate(0).div(y, 100).truncate(0)
+        r_y = fixed1.mult(fixed1, 100).truncate(0).div(y, 100).truncate(0)
 
-        result = from_fixed(x.mult(r_y, 100).truncate(0).div(fixed_1, 100).truncate(0))
+        result = from_fixed(x.mult(r_y, 100).truncate(0).div(fixed1, 100).truncate(0))
 
-        return result.truncate(18).to_s
+        result.truncate(18).to_s
       end
 
       def round_up(x, digits)
@@ -67,24 +65,23 @@ module Istox
         x = 0 if x.blank?
         ::BigDecimal.new(x.to_s).round(digits).to_s
       end
-      
+
       def round_down(x, digits)
         BigDecimal.mode(BigDecimal::ROUND_MODE, :down)
         x = 0 if x.blank?
         ::BigDecimal.new(x.to_s).round(digits).to_s
       end
 
-      private 
+      private
 
       def to_fixed(x)
-        return ::BigDecimal.new(x.to_s).mult(::BigDecimal.new('1e18'), 100).truncate(18)
+        ::BigDecimal.new(x.to_s).mult(::BigDecimal.new('1e18'), 100).truncate(18)
       end
 
       def from_fixed(x)
-        return ::BigDecimal.new(x.to_s).div(::BigDecimal.new('1e18'), 100).truncate(18)
+        ::BigDecimal.new(x.to_s).div(::BigDecimal.new('1e18'), 100).truncate(18)
       end
-
-
     end
   end
 end
+# rubocop:enable Naming/UncommunicativeMethodParamName

data/lib/istox/helpers/graphql_client.rb

@@ -1,35 +1,35 @@
-require "graphlient"
+require 'graphlient'
 
 module Istox
   class GraphqlClient
-      class << self
-          def add_host(host_type, url)
-              unless defined?(@@hosts)
-                 @@hosts = {}
-              end
-              init_host(host_type, url)
-          end
-
-          def query(host_type, query, variables = {})
-            client = @@hosts[host_type]
-
-            raise "Please make sure you have initialised graphql cient for host #{host_type}" if !client
-
-            Rails.logger.info "Querying Graphql host: #{host_type}, query: #{query}, variables: #{variables.inspect}"
-            result = client.query(query, variables)
-            Rails.logger.info "Graphql result: #{result.inspect}"
-
-            return result
-          end
-
-          private
-          
-          def init_host(host_type, url)
-            client = Graphlient::Client.new(url, http: Graphlient::Adapters::HTTP::HTTPAdapter)
-        
-            @@hosts[host_type] = client
-          end
+    class << self
+      def add_host(host_type, url)
+        @@hosts = {} unless defined?(@@hosts)
+        init_host(host_type, url)
+      end
+
+      def query(host_type, query, variables = {})
+        client = @@hosts[host_type]
+
+        raise "Please make sure you have initialised graphql cient for host #{host_type}" unless client
+
+        Rails.logger.info "Querying Graphql host: #{host_type}, query: #{query}, variables: #{variables.inspect}"
+        result = client.query(query, variables)
+
+        return_values = ::Istox::CommonHelper.to_open_struct(result&.data)
+
+        Rails.logger.info "Graphql result: #{return_values.inspect}"
+
+        return_values
+      end
+
+      private
+
+      def init_host(host_type, url)
+        client = Graphlient::Client.new(url, http: Graphlient::Adapters::HTTP::HTTPAdapter)
 
+        @@hosts[host_type] = client
       end
+    end
   end
-end
+end

data/lib/istox/helpers/grpc_client.rb

@@ -1,66 +1,63 @@
 module Istox
-    class GrpcClient
-        class << self
-            def add_host(host_type, url)
-                unless defined?(@@hosts)
-                   @@hosts = {}
-                end
+  class GrpcClient
+    class << self
+      def add_host(host_type, url)
+        @@hosts = {} unless defined?(@@hosts)
 
-                @@hosts[host_type] = url
-            end
+        @@hosts[host_type] = url
+      end
 
-            def call(host_type, service, method, **keyword_args)
-                execute(host_type, service, method, **keyword_args)
-            # rescue => e
-                # reinitiate service and try again, second chance
-                # reinitiate_service(host_type, service)
-                # execute(host_type, service, method, **keyword_args)
-            end
-        
-            private
+      def call(host_type, service, method, **keyword_args)
+        execute(host_type, service, method, **keyword_args)
+        # rescue => e
+        # reinitiate service and try again, second chance
+        # reinitiate_service(host_type, service)
+        # execute(host_type, service, method, **keyword_args)
+      end
 
-            def execute(host_type, service, method, **keyword_args)
-                Rails.logger.info "Calling method in grpc method: #{method.inspect}, params: #{keyword_args.inspect}"
-                t1 = Time.now
-                
-                result = get_host(host_type, service).call(method, keyword_args)
-                Rails.logger.info "Time taken for grpc execution: #{Time.now - t1} seconds"
-                Rails.logger.info "Result: #{result.message.inspect}"
-                result
-            end
+      private
 
-            def get_host(host_type, service)
-                unless defined?(@@services)
-                   @@services = {}
-                end
+      def execute(host_type, service, method, **keyword_args)
+        Rails.logger.info "Calling method in grpc method: #{method.inspect}, params: #{keyword_args.inspect}"
+        t1 = Time.now
 
-                grpc_client = @@services[get_key(host_type, service)]
+        result = get_host(host_type, service).call(method, keyword_args)
+        Rails.logger.info "Time taken for grpc execution: #{Time.now - t1} seconds"
 
-                if grpc_client
-                    return grpc_client
-                else
-                    reinitiate_service(host_type, service)
-                    return @@services[get_key(host_type, service)]
-                end
-            end
+        return_values = ::Istox::CommonHelper.to_open_struct(result.message)
+        Rails.logger.info "Result: #{return_values}"
 
-            def reinitiate_service(host_type, service)
-                unless defined?(@@services)
-                   @@services = {}
-                end
+        return_values
+      end
 
-                host_url = @@hosts[host_type]
-                raise StandardError, 'Unable to find host, have you forgotten to add host to grpc client?' if !host_url
-                
-                Rails.logger.info 'Reinitiating to grpc host at ' + host_url
-                t1 = Time.now
-                @@services[get_key(host_type, service)] = ::Gruf::Client.new(service: service, options: { hostname: host_url })
-                Rails.logger.info "Time taken for reinitiating grpc host: #{Time.now - t1} seconds"
-            end
+      def get_host(host_type, service)
+        @@services = {} unless defined?(@@services)
 
-            def get_key(host_type, service)
-                host_type.to_s + service.to_s
-            end
+        grpc_client = @@services[get_key(host_type, service)]
+
+        if grpc_client
+          return grpc_client
+        else
+          reinitiate_service(host_type, service)
+          return @@services[get_key(host_type, service)]
         end
+      end
+
+      def reinitiate_service(host_type, service)
+        @@services = {} unless defined?(@@services)
+
+        host_url = @@hosts[host_type]
+        raise StandardError, 'Unable to find host, have you forgotten to add host to grpc client?' unless host_url
+
+        Rails.logger.info 'Reinitiating to grpc host at ' + host_url
+        t1 = Time.now
+        @@services[get_key(host_type, service)] = ::Gruf::Client.new(service: service, options: { hostname: host_url })
+        Rails.logger.info "Time taken for reinitiating grpc host: #{Time.now - t1} seconds"
+      end
+
+      def get_key(host_type, service)
+        host_type.to_s + service.to_s
+      end
     end
-end
+  end
+end

data/lib/istox/helpers/my_open_struct.rb

@@ -0,0 +1,13 @@
+module Istox
+  class MyOpenStruct < OpenStruct
+    def to_json(*_args)
+      hash = ::Istox::CommonHelper.deep_to_h(self)
+
+      hash.to_json
+    end
+
+    def to_hash
+      ::Istox::CommonHelper.deep_to_h(self)
+    end
+  end
+end

data/lib/istox/helpers/order_book.rb

@@ -2,7 +2,6 @@ module Istox
   class OrderBook
     class << self
       def allocation(soft_cap, total_supply, investments)
-        
         # sort by token price desc, and id asc
         investments = investments.sort do |a, b|
           [b[:token_price], a[:id]] <=> [a[:token_price], b[:id]]
@@ -11,50 +10,79 @@ module Istox
         total_supply = ::BigDecimal.new(total_supply.to_s)
 
         interests = investments
-        if interests.count > 0
-          cutoff_price = 0.0
-          total_bid_token = 0.0
-          total_allocated = 0.0
-          total_unallocated = 0.0
-          total_investment = 0.0
-          cutoff_price = ::Istox::FMath.round_down(::Istox::FMath.div(soft_cap, total_supply), 2)
-          is_cutoff = false
+        cutoff_price = 0.0
+        total_bid_token = 0.0
+        total_allocated = 0.0
+        total_unallocated = 0.0
+        total_investment = 0.0
+        cutoff_price = ::Istox::FMath.round_up(::Istox::FMath.div(soft_cap, total_supply), 2)
+        is_cutoff = false
 
-          interests = interests.map do |item|
-            bid_token = ::Istox::FMath.div(item[:fiat_amount], item[:token_price])
-            total_bid_token = ::Istox::FMath.add(total_bid_token, bid_token)
-            allocated = 0.0
-            unallocated = bid_token
-            unless is_cutoff
-              allocated = bid_token
-              unallocated = 0.0
-              if ::BigDecimal.new(::Istox::FMath.add(total_allocated, bid_token)) >= total_supply
-                unallocated = ::Istox::FMath.sub(::Istox::FMath.add(total_allocated, bid_token), total_supply)
-                allocated = ::Istox::FMath.sub(bid_token, unallocated)
-                cutoff_price = item[:token_price]
-                is_cutoff = true
-              end
-              total_allocated = ::Istox::FMath.add(total_allocated, allocated)
-              total_unallocated = ::Istox::FMath.add(total_unallocated, unallocated)
+        # return result immediately if no interest
+        unless interests.count.positive?
+          return { total_supply: total_supply.to_s, total_investment: '0',
+                   cutoff_price: cutoff_price, total_bid_token: '0',
+                   total_allocated: '0', total_unallocated: total_supply.to_s,
+                   interests: [] }
+        end
+
+        interests = interests.map do |item|
+          bid_token = ::Istox::FMath.div(item[:fiat_amount], item[:token_price])
+          total_bid_token = ::Istox::FMath.add(total_bid_token, bid_token)
+          allocated = 0.0
+          unallocated = bid_token
+          unless is_cutoff
+            allocated = bid_token
+            unallocated = 0.0
+            if ::BigDecimal.new(::Istox::FMath.add(total_allocated, bid_token)) >= total_supply
+              unallocated = ::Istox::FMath.sub(::Istox::FMath.add(total_allocated, bid_token), total_supply)
+              allocated = ::Istox::FMath.sub(bid_token, unallocated)
+              cutoff_price = item[:token_price]
+              is_cutoff = true
             end
-            { id: item[:id], fiat_amount: item[:fiat_amount], bid_price: item[:token_price], bid_token: bid_token, 
-              allocated: allocated, unallocated: unallocated }
+            total_allocated = ::Istox::FMath.add(total_allocated, allocated)
+            total_unallocated = ::Istox::FMath.add(total_unallocated, unallocated)
           end
+          {
+            id: item[:id],
+            # user bidding total fiat amount
+            fiat_amount: item[:fiat_amount],
+            # user bidding price
+            bid_price: item[:token_price],
+            # total user bidding token derived from fiat_amount / token_price
+            bid_token: bid_token,
+            # round down allocated token to whole number
+            allocated: ::Istox::FMath.round_down(allocated, 0),
+            # round up unallocated token to whole number
+            unallocated: ::Istox::FMath.round_up(unallocated, 0)
+          }
+        end
 
-          interests = interests.map do |item|
-            investment = ::Istox::FMath.mul(item[:allocated], cutoff_price)
-            total_investment = ::Istox::FMath.add(total_investment, investment)
-            item.merge!(investment: investment)
-          end
-          
-          return { total_supply: total_supply, total_investment: total_investment, 
-              cutoff_price: cutoff_price, total_bid_token: total_bid_token, 
-              total_allocated: total_allocated, total_unallocated: total_unallocated, 
-              interests: interests }
-        else
-          raise 'Registration interest is empty'
+        interests = interests.map do |item|
+          investment = ::Istox::FMath.mul(item[:allocated], cutoff_price)
+          total_investment = ::Istox::FMath.add(total_investment, investment)
+
+          # each user maximum total investment amount in fiat
+          item.merge!(investment: investment)
         end
+
+        {
+          # total token supply
+          total_supply: total_supply.to_s,
+          # total investment in fiat
+          total_investment: total_investment,
+          # cut off price
+          cutoff_price: cutoff_price.to_s,
+          # total bid tokens, more than total supply for oversubscribe case
+          total_bid_token: total_bid_token,
+          # total allocated tokens
+          total_allocated: total_allocated,
+          # total unallocated tokens
+          total_unallocated: total_unallocated,
+          # all investor interest results
+          interests: interests
+        }
       end
     end
   end
-end
+end

data/lib/istox/logging/hash_logging.rb

@@ -13,9 +13,8 @@ module Istox
         include ActiveSupport::TaggedLogging::Formatter
 
         def call(severity, timestamp, progname, msg)
-          tagged_message = case
-                           when msg.is_a?(Hash) then tags_text.present? ? msg.merge(tags: tags_text) : msg
-                           when tags_text.present? then { message: msg, tag: tags_text }
+          tagged_message = if msg.is_a?(Hash) then tags_text.present? ? msg.merge(tags: tags_text) : msg
+                           elsif tags_text.present? then { message: msg, tag: tags_text }
                            else msg
                            end
 

data/lib/istox/logging/log_formatter.rb

@@ -1,8 +1,9 @@
 # frozen_string_literal: true
+
 module Istox
   module Logging
     class LogFormatter
-      def call(severity, time, progname, msg='')
+      def call(severity, _time, progname, msg = '')
         return '' if msg.blank?
 
         hash = {
@@ -10,11 +11,9 @@ module Istox
           message: processed_message(msg)
         }
 
-        if progname.present?
-          hash[:app] = progname
-        end
+        hash[:app] = progname if progname.present?
 
-        return hash.to_json + "\n"
+        hash.to_json + "\n"
 
         # return "timestamp='#{time}' level=#{severity} progname='#{progname}' #{processed_message(msg)}\n" if progname.present?
         # "timestamp='#{time}' level=#{severity} #{processed_message(msg)}\n"

data/lib/istox/migrations/create_blockchain_receipts.rb

@@ -1,27 +1,26 @@
 module Istox
-    class CreateBlockchainReceipts < ActiveRecord::Migration[5.0]
-        def initialize(_, _, table_name = nil)
-            @table_name = table_name
-            unless @table_name
-                @table_name = :blockchain_receipts
-            end
-        end
+  class CreateBlockchainReceipts < ActiveRecord::Migration[5.0]
+    def initialize(_, _, table_name = nil)
+      @table_name = table_name
+      @table_name ||= :blockchain_receipts
+    end
 
-        def change
-            create_table @table_name do |t|
-                t.string :txid
-                t.string :txhash
-                t.integer :resource_id
-                t.string :resource_action
-                t.string :resource_name
-                t.boolean :resource_handled
-                t.datetime :deleted_at, index: true
-                t.timestamps
-                t.string :sid
-                t.string :status, :default => "pending"
-                t.boolean :is_request, :default => false
-                t.integer :lock_version
-            end
-        end
+    def change
+      create_table @table_name do |t|
+        t.string :txid
+        t.string :txhash
+        t.integer :resource_id
+        t.string :resource_action
+        t.string :resource_name
+        t.boolean :resource_handled
+        t.datetime :deleted_at, index: true
+        t.timestamps
+        t.string :sid
+        t.string :status, default: 'pending'
+        t.text :message
+        t.boolean :is_request, default: false
+        t.integer :lock_version
+      end
     end
-end
+  end
+end

data/lib/istox/models/blockchain_receipt.rb

@@ -2,11 +2,8 @@ module Istox
   class BlockchainReceipt < ActiveRecord::Base
     acts_as_paranoid
 
-
     def activity
-      if resource_name.present? && resource_action.present?
-        I18n.t("#{resource_name}.#{resource_action}")
-      end
+      I18n.t("#{resource_name}.#{resource_action}") if resource_name.present? && resource_action.present?
     end
   end
-end
+end

data/lib/istox/models/concerns/blockchain_receipt_query.rb

@@ -1,45 +1,31 @@
 module Istox
   module BlockchainReceiptQuery
     extend ActiveSupport::Concern
-  
-    #overrideable, when blockchain transaction has confirmed
-    def handle_confirm(resource_action)
+
+    # overrideable, when blockchain transaction has confirmed
+    def handle_confirm(_receipt)
       self
     end
 
-    #overrideable, when blockchain transaction has failed
-    def handle_fail(resource_action)
+    # overrideable, when blockchain transaction has failed
+    def handle_fail(_receipt)
       self
     end
 
-    #overrideable, extra data that will be published back to frontend
+    # overrideable, extra data that will be published back to frontend
     def handle_extra
       nil
     end
 
     # outcome of the blockchain transaction, can be "pending" / "confirmed" / "failed"
     def outcome
-      blockchain_receipts = get_blockchain_receipts
-
-      return "confirmed" if blockchain_receipts.empty?
-  
-      # return failed state if there is any failed hashes
-      return "failed" if blockchain_receipts.any?{ |r| r.status == 'failed' }
+      blockchain_receipt = ::Istox::BlockchainReceipt.where(resource_id: id, resource_name: self.class.name).first
 
-      # return pending state if there is any pending hashes
-      return "pending" if blockchain_receipts.any?{ |r| r.status == 'pending' }
+      return 'confirmed' unless blockchain_receipt.present?
 
-      # return confirmed otherwise
-      return "confirmed" 
-    end
-
-    def get_blockchain_receipts
-      ::Istox::BlockchainReceipt.where(resource_id: self.id, resource_name: self.class.name).all
-    end
+      return 'confirmed' if blockchain_receipt.status.blank?
 
-    def last_receipt
-      ::Istox::BlockchainReceipt.where(resource_id: self.id, resource_name: self.class.name).last
+      blockchain_receipt.status
     end
-  
   end
 end

data/lib/istox/version.rb

@@ -1,3 +1,3 @@
 module Istox
-  VERSION = "0.1.81"
+  VERSION = '0.1.82'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: istox
 version: !ruby/object:Gem::Version
-  version: 0.1.81
+  version: 0.1.82
 platform: ruby
 authors:
 - Siong Leng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-05 00:00:00.000000000 Z
+date: 2019-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -278,6 +278,8 @@ files:
 - ".idea/modules.xml"
 - ".idea/vcs.xml"
 - ".idea/workspace.xml"
+- ".rubocop.yml"
+- ".solargraph.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -287,15 +289,16 @@ files:
 - bin/setup
 - istox.gemspec
 - lib/istox.rb
-- lib/istox/consumers/blockchain_hash_handler.rb
 - lib/istox/consumers/blockchain_status_handler.rb
-- lib/istox/helpers/blockchain_receipt_service.rb
+- lib/istox/helpers/blockchain_service.rb
 - lib/istox/helpers/bunny_boot.rb
+- lib/istox/helpers/common_helper.rb
 - lib/istox/helpers/f_math.rb
 - lib/istox/helpers/graphql_client.rb
 - lib/istox/helpers/grpc_client.rb
 - lib/istox/helpers/gruf_listener_hook.rb
 - lib/istox/helpers/message_service.rb
+- lib/istox/helpers/my_open_struct.rb
 - lib/istox/helpers/order_book.rb
 - lib/istox/helpers/publisher.rb
 - lib/istox/helpers/vault.rb

data/lib/istox/consumers/blockchain_hash_handler.rb

@@ -1,19 +0,0 @@
-module Istox
-  class BlockchainHashHandler
-    class << self
-      def hash_generated(data, payload_target)
-        receipt = ::Istox::BlockchainReceipt.where(txid: data.uuid).first
-        if receipt.nil? 
-          puts 'Transaction doesnt belong here, skipping...'
-          return
-        end 
-
-        # sid cannot be nil
-        update_receipt = ::Istox::BlockchainReceipt.where(txid: data.uuid, txhash: nil).where.not(sid: nil).first
-        raise "Unable to find receipt to update" if update_receipt.blank?
-
-        update_receipt.update!(txhash: data.txnHash)
-      end
-    end
-  end
-end

data/lib/istox/helpers/blockchain_receipt_service.rb

@@ -1,71 +0,0 @@
-module Istox
-    class BlockchainReceiptService
-    
-        def self.init(blockchain_receipt_klass)
-            @@blockchain_receipt_klass = blockchain_receipt_klass
-        end
-
-        def self.get_blockchain_receipt_klass
-            @@blockchain_receipt_klass
-        end
-
-        def self.generate_uuid
-            klass = ::Istox::BlockchainReceiptService.blockchain_receipt_class
-            uuid = SecureRandom.uuid
-
-            klass.create!({
-                txid: uuid
-            })
-
-            uuid
-        end
-
-        def create!(tx_message, model, sid, action, is_request: false)
-            klass = ::Istox::BlockchainReceiptService.blockchain_receipt_class
-
-            # delete the previous existing blockchain receipts
-            klass.where(resource_name: model.class.name,
-                                    resource_id: model.id).destroy_all
-
-            (0...tx_message.txnCount).each do |i|
-                if i == 0
-                    blockchain_receipt = klass.find_by_txid(tx_message.uuid)
-
-                    raise "Unable to find blockchain receipt with uuid #{tx_message.uuid}, have you forgetten to generate uuid?" if blockchain_receipt.blank?
-
-                    blockchain_receipt.update!({
-                        sid: sid,
-                        txid: tx_message.uuid,
-                        resource_name: model.class.name,
-                        resource_id: model.id,
-                        resource_action: action,
-                        is_request: is_request
-                    })
-                else
-                    blockchain_receipt = klass.new(
-                        sid: sid,
-                        txid: tx_message.uuid,
-                        resource_name: model.class.name,
-                        resource_id: model.id,
-                        resource_action: action,
-                        is_request: is_request
-                    )
-                    blockchain_receipt.save!
-                end
-            end
-        end
-
-        def self.blockchain_receipt_class
-            raise "Have you forgetten to init blockchain receipt service?" if ::Istox::BlockchainReceiptService.get_blockchain_receipt_klass == nil
-
-            blockchain_receipt_klass = ::Istox::BlockchainReceiptService.get_blockchain_receipt_klass
-            klass = class_eval("::#{blockchain_receipt_klass.name}")
-            unless klass <= ::Istox::BlockchainReceipt
-                raise RuntimeError, "#{blockchain_receipt_klass.name} does not inherit istox blockchain receipt"
-            end
-
-            return klass
-        end
-
-    end
-end