istox 0.1.81.pre.test10 → 0.1.81

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 137bc00193a848330fba21e01f23d89d9c06ff55604bf75e5d6368ea14bf0192
-  data.tar.gz: 6cf96f0726fd3dc5680a9b332536613fc8da2679a2a965791b51c30bac66d580
+  metadata.gz: b9b67e7deab7a2a53ab80d237842554f21ca126e3542bf75dfbbb68a46961395
+  data.tar.gz: 913e6213c402f933ac375bb77999119131d25e0a886c5cf2819c8ed56685ba88
 SHA512:
-  metadata.gz: 9b1071eb5a4d22a8763ae6d7255a3211f16f8fdff943226632229279b24f00941bf4efc83ee332960cc7b8bc189d2d45727ca303c1b231bd549cdd1e7598343e
-  data.tar.gz: 3b72c52f64f0104c6f0d18a6875cd93cde6e249ac200dc6372551498bb6890c8370aa620d7bced6af1a94f7f9f6abb76b7d4547ca1cb3702ece300bef9e58913
+  metadata.gz: 6c02663da343a9b5efef558084c5a14f32c92900b055d3fc3041e71dec38a1fa828b2e8ed4aee8ef7f1c2f7eccc991bd11a24bb2e7300505b6b11e025ff4249d
+  data.tar.gz: a57ed4210294057d2ef6cbbb9dedab41b28e0a2f78f8f75e2d97d17f5afce0b3a9948f9aca7ad0a8b0d685bfd58ebbf08d0876a0236b0833ff100beed7595368

data/Gemfile.lock

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

data/lib/istox.rb

@@ -1,35 +1,34 @@
 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_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/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/quant/bond"
 end

data/lib/istox/consumers/blockchain_hash_handler.rb

@@ -0,0 +1,19 @@
+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/consumers/blockchain_status_handler.rb

@@ -1,54 +1,105 @@
 module Istox
   class BlockchainStatusHandler
     class << self
-      # 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
 
-        status = transaction.success ? 'confirmed' : 'failed'
+      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)
 
-        receipt.update!(status: status, message: transaction.message,
-                        txhash: transaction.txnHashes.present? ? transaction.txnHashes.join(',') : nil)
+          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
 
-        resource = begin
-          class_eval("::#{receipt.resource_name}", __FILE__, __LINE__).find(receipt.resource_id)
-                   rescue StandardError
-                     puts 'Class not found, 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
+
+          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
 
-        return if resource_handled?(receipt)
+          receipt_list = get_receipt_list(resource)
 
-        if status == 'confirmed'
-          resource.handle_confirm(receipt)
+          next if resource_handled?(receipt_list)
 
-          mark_resource_handled(receipt)
-          publish_to_frontend(resource, true, receipt, receipt.sid)
+          # if transaction.status == 'confirmed'
+          #   next if resource.outcome == 'pending'
 
-        elsif status == 'failed'
-          resource.handle_fail(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 transaction.status == 'failed'
+            resource.handle_fail(receipt.resource_action)
+
+            mark_resource_handled(receipt_list)
+            publish_to_frontend(resource, false, receipt, receipt.sid, receipt_list)
+          end
 
-          mark_resource_handled(receipt)
-          publish_to_frontend(resource, false, receipt, receipt.sid)
         end
       end
 
       private
 
-      def publish_to_frontend(model, success, receipt, sid)
+      def publish_to_frontend(model, success, receipt, sid, receipt_list)
+        yield if block_given?
+
         ::Istox::Publisher.publish(
           'amq.topic',
           model.class.name.gsub('::', '').underscore.to_s,
@@ -64,26 +115,34 @@ module Istox
           data: {
             success: success,
             purpose: receipt.activity,
-            message: receipt.message
+            txids: get_receipts_tx_hashes(receipt_list)
           }
         )
-      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 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
+      def get_receipts_tx_hashes(receipt_list)
+        tx_hashes = receipt_list.map(&:txhash).compact
+
+        tx_hashes.join(', ')
       end
 
-      def resource_handled?(receipt)
-        receipt.resource_handled == true
+      def mark_resource_handled(receipt_list)
+        receipt_list.each do |receipt|
+          receipt.update(resource_handled: true)
+        end
       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_receipt_service.rb

@@ -0,0 +1,71 @@
+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

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)
 
-        x.add(y, 100).truncate(18).to_s
+        return 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)
 
-        x.sub(y, 100).truncate(18).to_s
+        return 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)
 
-        x.mult(y, 100).truncate(18).to_s
+        return x.mult(y, 100).truncate(18).to_s
       end
 
       def div(x, y)
@@ -47,17 +47,19 @@ module Istox
         x = to_fixed(x)
         y = to_fixed(y)
 
-        return ::BigDecimal.new('1').to_s if x == y
-
-        fixed1 = ::BigDecimal.new('1e18')
+        return ::BigDecimal.new("1").to_s if x == y
 
-        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?
+        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
 
-        r_y = fixed1.mult(fixed1, 100).truncate(0).div(y, 100).truncate(0)
+        r_y = fixed_1.mult(fixed_1, 100).truncate(0).div(y, 100).truncate(0)
 
-        result = from_fixed(x.mult(r_y, 100).truncate(0).div(fixed1, 100).truncate(0))
+        result = from_fixed(x.mult(r_y, 100).truncate(0).div(fixed_1, 100).truncate(0))
 
-        result.truncate(18).to_s
+        return result.truncate(18).to_s
       end
 
       def round_up(x, digits)
@@ -65,23 +67,24 @@ 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)
-        ::BigDecimal.new(x.to_s).mult(::BigDecimal.new('1e18'), 100).truncate(18)
+        return ::BigDecimal.new(x.to_s).mult(::BigDecimal.new('1e18'), 100).truncate(18)
       end
 
       def from_fixed(x)
-        ::BigDecimal.new(x.to_s).div(::BigDecimal.new('1e18'), 100).truncate(18)
+        return ::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)
-        @@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)
+      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
 
-        @@hosts[host_type] = client
       end
-    end
   end
-end
+end

data/lib/istox/helpers/grpc_client.rb

@@ -1,63 +1,66 @@
 module Istox
-  class GrpcClient
-    class << self
-      def add_host(host_type, url)
-        @@hosts = {} unless defined?(@@hosts)
+    class GrpcClient
+        class << self
+            def add_host(host_type, url)
+                unless defined?(@@hosts)
+                   @@hosts = {}
+                end
 
-        @@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
+            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
 
-      private
+            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
 
-      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
+            def get_host(host_type, service)
+                unless defined?(@@services)
+                   @@services = {}
+                end
 
-        result = get_host(host_type, service).call(method, keyword_args)
-        Rails.logger.info "Time taken for grpc execution: #{Time.now - t1} seconds"
+                grpc_client = @@services[get_key(host_type, service)]
 
-        return_values = ::Istox::CommonHelper.to_open_struct(result.message)
-        Rails.logger.info "Result: #{return_values}"
+                if grpc_client
+                    return grpc_client
+                else
+                    reinitiate_service(host_type, service)
+                    return @@services[get_key(host_type, service)]
+                end
+            end
 
-        return_values
-      end
+            def reinitiate_service(host_type, service)
+                unless defined?(@@services)
+                   @@services = {}
+                end
 
-      def get_host(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?' 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
 
-        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)]
+            def get_key(host_type, service)
+                host_type.to_s + service.to_s
+            end
         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/order_book.rb

@@ -2,6 +2,7 @@ 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]]
@@ -10,79 +11,50 @@ module Istox
         total_supply = ::BigDecimal.new(total_supply.to_s)
 
         interests = investments
-        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
+        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
 
-        # 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
+          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)
             end
-            total_allocated = ::Istox::FMath.add(total_allocated, allocated)
-            total_unallocated = ::Istox::FMath.add(total_unallocated, unallocated)
+            { id: item[:id], fiat_amount: item[:fiat_amount], bid_price: item[:token_price], bid_token: bid_token, 
+              allocated: allocated, 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)
-
-          # each user maximum total investment amount in fiat
-          item.merge!(investment: investment)
+          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'
         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,8 +13,9 @@ module Istox
         include ActiveSupport::TaggedLogging::Formatter
 
         def call(severity, timestamp, progname, msg)
-          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 }
+          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 }
                            else msg
                            end
 

data/lib/istox/logging/log_formatter.rb

@@ -1,9 +1,8 @@
 # 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 = {
@@ -11,9 +10,11 @@ module Istox
           message: processed_message(msg)
         }
 
-        hash[:app] = progname if progname.present?
+        if progname.present?
+          hash[:app] = progname
+        end
 
-        hash.to_json + "\n"
+        return 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,26 +1,27 @@
 module Istox
-  class CreateBlockchainReceipts < ActiveRecord::Migration[5.0]
-    def initialize(_, _, table_name = nil)
-      @table_name = table_name
-      @table_name ||= :blockchain_receipts
-    end
+    class CreateBlockchainReceipts < ActiveRecord::Migration[5.0]
+        def initialize(_, _, table_name = nil)
+            @table_name = table_name
+            unless @table_name
+                @table_name = :blockchain_receipts
+            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
+        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
     end
-  end
-end
+end

data/lib/istox/models/blockchain_receipt.rb

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

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

@@ -1,31 +1,45 @@
 module Istox
   module BlockchainReceiptQuery
     extend ActiveSupport::Concern
-
-    # overrideable, when blockchain transaction has confirmed
-    def handle_confirm(_receipt)
+  
+    #overrideable, when blockchain transaction has confirmed
+    def handle_confirm(resource_action)
       self
     end
 
-    # overrideable, when blockchain transaction has failed
-    def handle_fail(_receipt)
+    #overrideable, when blockchain transaction has failed
+    def handle_fail(resource_action)
       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_receipt = ::Istox::BlockchainReceipt.where(resource_id: id, resource_name: self.class.name).first
+      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' }
 
-      return 'confirmed' unless blockchain_receipt.present?
+      # return pending state if there is any pending hashes
+      return "pending" if blockchain_receipts.any?{ |r| r.status == 'pending' }
 
-      return 'confirmed' if blockchain_receipt.status.blank?
+      # return confirmed otherwise
+      return "confirmed" 
+    end
+
+    def get_blockchain_receipts
+      ::Istox::BlockchainReceipt.where(resource_id: self.id, resource_name: self.class.name).all
+    end
 
-      blockchain_receipt.status
+    def last_receipt
+      ::Istox::BlockchainReceipt.where(resource_id: self.id, resource_name: self.class.name).last
     end
+  
   end
 end

data/lib/istox/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: istox
 version: !ruby/object:Gem::Version
-  version: 0.1.81.pre.test10
+  version: 0.1.81
 platform: ruby
 authors:
 - Siong Leng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-15 00:00:00.000000000 Z
+date: 2019-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -278,8 +278,6 @@ files:
 - ".idea/modules.xml"
 - ".idea/vcs.xml"
 - ".idea/workspace.xml"
-- ".rubocop.yml"
-- ".solargraph.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
 - Gemfile.lock
@@ -289,16 +287,15 @@ 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_service.rb
+- lib/istox/helpers/blockchain_receipt_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
@@ -324,9 +321,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">"
+  - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.1
+      version: '0'
 requirements: []
 rubygems_version: 3.0.6
 signing_key: 

data/.rubocop.yml

@@ -1,102 +0,0 @@
-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

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

data/lib/istox/helpers/blockchain_service.rb

@@ -1,64 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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/my_open_struct.rb

@@ -1,13 +0,0 @@
-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