istox 0.1.86 → 0.1.87

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 54f934711b93a3532841dd514bf6acf9339719df7c029b0f040bf75002659a4d
-  data.tar.gz: f4ae4d0d97e732d911a805beacfcc2e6222b04bf0cdd35c1b720e3ac46561bc1
+  metadata.gz: b9516beb23b5b52b1a86c7a7ab8d03b7e7c377d74163b7a81400041c4501a4e0
+  data.tar.gz: fdaa33a8f434fc799eaa9416ef2287d384fd28e1610a4d68cbf637007c4d5af9
 SHA512:
-  metadata.gz: 36f9db1bfa5ca342b0f49308b5d4e18f84f1021daf58273962fcf7255be2c458edc063b951847efed3fe6bb9f2398b6fb322357d92df4495b47f1b21118c13e7
-  data.tar.gz: b8dcae36fa774e2dbe2c8fdcfa3f6d40854204b39dfe134730a4897a3c91ff4bb3a58394a77abfb7224d4139b2d1bfa427305cd6a68af329f7b836f3b2fceeed
+  metadata.gz: 957c7d9762478fa79949b747676a14361052ad9667175bd0824233fc1ac2dae72469b69e7addc8d47eb2b6ab75803edc36be3699e14cbbdbfd01daa81ffceef8
+  data.tar.gz: ab95640711cb08298c6a68e0b7a14a320d8fa38fbfebb9a44d1bf56752e1abc999459e982329addd2b48579ccd221b6565218f45afe47332571401cbd5e28928

data/.rubocop.yml

@@ -34,7 +34,7 @@ Metrics/AbcSize:
   Max: 100
 
 Metrics/BlockLength:
-  CountComments: false  # count full line comments?
+  CountComments: false # count full line comments?
   Max: 25
   Exclude:
     - config/**/*
@@ -45,7 +45,7 @@ Metrics/BlockNesting:
   Max: 4
 
 Metrics/ClassLength:
-  CountComments: false  # count full line comments?
+  CountComments: false # count full line comments?
   Max: 200
 
 # Avoid complex methods.
@@ -53,15 +53,15 @@ Metrics/CyclomaticComplexity:
   Max: 20
 
 Metrics/MethodLength:
-  CountComments: false  # count full line comments?
+  CountComments: false # count full line comments?
   Max: 100
 
 Metrics/ModuleLength:
-  CountComments: false  # count full line comments?
+  CountComments: false # count full line comments?
   Max: 200
 
 Metrics/LineLength:
-  Max: 130
+  Max: 150
   # 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
@@ -70,7 +70,7 @@ Metrics/LineLength:
     - https
 
 Metrics/ParameterLists:
-  Max: 5
+  Max: 8
   CountKeywordArgs: true
 
 Metrics/PerceivedComplexity:
@@ -91,7 +91,6 @@ RSpec/ExampleLength:
 Lint/BigDecimalNew:
   Enabled: false
 
-
 RSpec/MessageSpies:
   Enabled: false
 
@@ -99,4 +98,4 @@ RSpec/AnyInstance:
   Enabled: false
 
 RSpec/VerifiedDoubles:
-  Enabled: false
+  Enabled: false

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    istox (0.1.85.pre.test2)
+    istox (0.1.86)
       binding_of_caller
       bunny (>= 2.12.0)
       graphlient

data/lib/istox.rb

@@ -16,7 +16,8 @@ module Istox
   require 'istox/helpers/publisher'
   require 'istox/helpers/bunny_boot'
   require 'istox/helpers/vault'
-  require 'istox/helpers/order_book'
+  require 'istox/helpers/order_book_price_time'
+  require 'istox/helpers/order_book_prorate'
   require 'istox/helpers/grpc_client'
   require 'istox/helpers/graphql_client'
   require 'istox/helpers/gruf_listener_hook'

data/lib/istox/helpers/order_book_price_time.rb

@@ -0,0 +1,167 @@
+module Istox
+  class OrderBookPriceTime
+    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]]
+        end
+
+        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
+
+        # 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.round_down(::Istox::FMath.div(item[:fiat_amount], item[:token_price]), 0)
+          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
+          {
+            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)
+        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
+
+      # rubocop:disable Metrics/BlockNesting
+      def prorate_allocation(token_price, min_investment, bid_block,
+                             invest_step, hard_cap, interests)
+        # sort by id asc
+        interests = interests.sort do |a, b|
+          a[:id] <=> b[:id]
+        end
+        total_interests = 0
+
+        max_allowed_investor = Istox::FMath.round_down(::Istox::FMath.div(
+                                                         ::Istox::FMath.div(hard_cap, bid_block), token_price
+                                                       ), 0).to_i
+
+        interests.each_with_index.map do |interest, i|
+          total_interests = ::Istox::FMath.add(total_investment, interest.fiat_amount) if i < max_allowed_investor
+        end
+
+        # only need to handle when oversubscribe
+        if total_interests.to_d > hard_cap.to_s.to_d
+
+          # prorate the interests
+          interests = interests.each_with_index.map do |interest, i|
+            {
+              id: interest.id,
+              investment: i < max_allowed_investor ? ::FMath.mul(::FMath.div(interest.fiat_amount, total_interests), hard_cap) : '0'
+            }
+          end
+
+          # do adjustments for interest if needed
+          final_interests = interests.map do |interest|
+            if interest[:investment].to_d < min_investment.to_d
+              # calculate the adjusted amount
+              lacking_amount = ::Istox::FMath.sub(min_investment, interest[:investment])
+              # if some investor has less than min_investment allocated, auto adjust to min investment
+              interest[:investment] = min_investment.to_s
+
+              # must deduct the adjust amount from later book building joiners who has more amount allocated
+              # than min-investment
+              if lacking_amount.to_d.positive?
+                interests.reverse_each do |inner_interest|
+                  # skip the same interest from deduction candidate
+                  next unless inner_interest[:id] != interest[:id]
+
+                  # when investor investment is higher than min_investment, he will become a candidate to
+                  # get investment deduction
+                  while inner_interest[:investment].to_d > min_investment.to_d && lacking_amount.to_d.positive?
+                    lacking_amount = ::Istox::FMath.sub(lacking_amount, invest_step)
+                    inner_interest[:investment] = ::Istox::FMath.sub(inner_interest[:investment], invest_step)
+
+                    # add back the difference if over deduct an investor invest amount
+                    if lacking_amount.to_d.negative?
+                      inner_interest[:investment] = ::Istox::FMath.add(inner_interest[:investment],
+                                                                       BigDecimal(lacking_amount).abs)
+                    end
+                  end
+                end
+              end
+            end
+            {
+              id: interest[:id],
+              investment: interest[:investment]
+            }
+          end
+        else
+          final_interests = interests.each_with_index.map do |interest, i|
+            {
+              id: interest.id,
+              investment: i < max_allowed_investor ? interest.fiat_amount : '0'
+            }
+          end
+        end
+
+        {
+          cutoff_price: token_price,
+          interests: final_interests
+        }
+      end
+    end
+    # rubocop:enable Metrics/BlockNesting
+  end
+end

data/lib/istox/helpers/order_book_prorate.rb

@@ -0,0 +1,80 @@
+module Istox
+  class OrderBookProrate
+    class << self
+      def allocation(token_price:, min_investment:, bid_block:,
+                     invest_step:, hard_cap:, investments:)
+
+        # sort by id asc
+        interests = investments.sort do |a, b|
+          a[:id] <=> b[:id]
+        end
+        total_interests = 0
+
+        max_allowed_investor = Istox::FMath.round_down(::Istox::FMath.div(hard_cap, bid_block), 0).to_i
+
+        interests.each_with_index.map do |interest, i|
+          total_interests = ::Istox::FMath.add(total_interests, interest[:fiat_amount]) if i < max_allowed_investor
+        end
+
+        # only need to handle when oversubscribe
+        if total_interests.to_d > hard_cap.to_s.to_d
+
+          # prorate the interests
+          interests = interests.each_with_index.map do |interest, i|
+            investment = if i < max_allowed_investor
+                           ::Istox::FMath.round_down(::Istox::FMath.mul(::Istox::FMath.div(interest[:fiat_amount], total_interests), hard_cap), 0)
+                         else
+                           ::BigDecimal.new('0').to_s
+                         end
+            investment = investment.to_d - investment.to_d.modulo(invest_step.to_s.to_d)
+
+            investment = min_investment.to_d if investment < min_investment.to_d
+
+            {
+              id: interest[:id],
+              investment: investment.to_s
+            }
+          end
+
+          new_total_interests = '0'
+          interests.each do |interest|
+            new_total_interests = ::Istox::FMath.add(new_total_interests, interest[:investment])
+          end
+
+          # need to do adjustment if summation of new rounded values still larger than
+          if new_total_interests.to_d > hard_cap.to_s.to_d
+            total_deducting = ::Istox::FMath.sub(new_total_interests, hard_cap)
+            interests.reverse_each do |interest|
+              next unless interest[:investment].to_d > min_investment.to_d
+
+              deductable = ::Istox::FMath.sub(interest[:investment], min_investment)
+
+              if deductable.to_d > total_deducting.to_d
+                interest[:investment] = ::Istox::FMath.sub(interest[:investment], total_deducting)
+                total_deducting = 0
+              else
+                interest[:investment] = ::Istox::FMath.sub(interest[:investment], deductable)
+                total_deducting = ::Istox::FMath.sub(total_deducting, deductable)
+              end
+            end
+          end
+
+          final_interests = interests
+
+        else
+          final_interests = interests.each_with_index.map do |interest, i|
+            {
+              id: interest[:id],
+              investment: i < max_allowed_investor ? ::BigDecimal.new(interest[:fiat_amount]).to_s : ::BigDecimal.new('0').to_s
+            }
+          end
+        end
+
+        {
+          cutoff_price: token_price.to_s,
+          interests: final_interests
+        }
+      end
+    end
+  end
+end

data/lib/istox/quant/bond.rb

@@ -1,4 +1,5 @@
 require 'date'
+require 'rails'
 
 # https://en.wikipedia.org/wiki/Day_count_convention#30/360_Bond_Basis
 # For 360 basis: 30/360 Bond Basis
@@ -15,25 +16,25 @@ module Istox
       def initialize(coupon: nil, maturity_date: nil, years: nil, coupon_frequency: nil, coupon_payment_dates: nil, face_value: 100, days_of_year: 365)
         raise "Invalid coupon #{coupon}" if (coupon.nil? || !is_number?(coupon))
         raise "Invalid maturity_date #{maturity_date}" if (maturity_date.nil? || maturity_date.methods.include?("strftime"))
-        raise "Invalid years #{years}" if (years.nil? || !years.is_a?(Integer))
+        raise "Invalid years #{years}" if (years.nil? || !is_number?(years))
         raise "Invalid coupon_frequency #{days_of_year}" if (coupon_frequency.nil? || !is_number?(coupon))
         raise "Invalid coupon_payment_dates #{coupon_payment_dates}" if (coupon_payment_dates.nil? || coupon_payment_dates.count == 0 || coupon_payment_dates.any? { |date| date > maturity_date })
         raise "Invalid days_of_year #{days_of_year}" if (days_of_year != 365 && days_of_year != 360)
 
-        @coupon               = coupon
+        @coupon               = coupon.to_d
         @maturity_date        = maturity_date
         @years                = years
-        @coupon_frequency     = coupon_frequency
-        @days_of_year         = days_of_year
+        @coupon_frequency     = coupon_frequency.to_d
+        @days_of_year         = days_of_year.to_d
         @face_value           = face_value
         @coupon_payment_dates = coupon_payment_dates.sort
-        @start_date           = (@maturity_date-@years.years)
+        @start_date           = (@maturity_date-(years*12).to_i.months)
       end
 
       def price(ytm, date, ex_coupon_date: nil, fees: 0)
         # price_for_irr(irr_from_ytm(ytm), date, fees: fees)
         price = price_for_irr(ytm/@coupon_frequency, date, ex_coupon_date: ex_coupon_date, fees: fees)
-        price.round(2)
+        price
       end
 
       # def interest_payments(from_date)
@@ -67,7 +68,7 @@ module Istox
       private
 
       def is_365?
-        @days_of_year == 365
+        @days_of_year == 365.to_d
       end
 
       def add_month(mydate, n)
@@ -129,9 +130,9 @@ module Istox
         if payment_dates.count == 0
           # no more coupon payments, we do only 1 discount of accrued interest and face value to the current date
           if is_365?
-            discount_factor = 1/(1+irr*(@maturity_date-date)/accrued_interest_discount_days)
+            discount_factor = 1.0/(1+irr*(@maturity_date-date)/accrued_interest_discount_days)
           else
-            discount_factor = 1/(1+irr*@coupon_frequency*day_count_factor(date, @maturity_date, nil))
+            discount_factor = 1.0/(1+irr*@coupon_frequency*day_count_factor(date, @maturity_date, nil))
           end
           discounted_accrued_interest = @coupon*@face_value*accrued_interest_factor*discount_factor
           discounted_face_value = @face_value*discount_factor
@@ -139,14 +140,15 @@ module Istox
         else
           # we discount face value and coupons and accrued interest (coupon) at maturity (if any)
           # to the first coupon payment left, and then discount the total to current date
-          value_at_first_coupon = 0
+          value_at_first_coupon = 0.to_d
           if payment_dates.include?(@maturity)
             # last coupon payment is at maturity
-            discount_factor = 1/(1+irr)**(payment_dates.count-1)
+            discount_factor = 1.0/(1+irr)**(payment_dates.count-1)
             value_at_first_coupon = @face_value*discount_factor
           else
+            period = @coupon_payment_dates.include?(date) ? payment_dates.count : payment_dates.count-1
             # last coupon is not at maturity, need to add accrued interest (coupon)
-            discount_factor = 1/((1+irr)**(payment_dates.count-1))/(1+irr*@coupon_frequency*accrued_interest_factor)
+            discount_factor = 1.0/((1+irr)**period)/(1+irr*@coupon_frequency*accrued_interest_factor)
             discounted_accrued_interest = @coupon*@face_value*accrued_interest_factor*discount_factor
             discounted_face_value = @face_value*discount_factor
             value_at_first_coupon = discounted_accrued_interest + discounted_face_value
@@ -154,26 +156,42 @@ module Istox
 
           # first coupon can be pro-rata
           value_at_first_coupon += first_coupon(date, ex_coupon_date)
-          if payment_dates.count > 1
-            for n in 1..payment_dates.count-1 do
-              value_at_first_coupon += @coupon*@face_value/@coupon_frequency/(1+irr)**n   
+          if payment_dates.count >= 1
+            if @coupon_payment_dates.include?(date)
+              # today is on one of the coupon payment date, the coupon will not be payed today
+              # discount all coupon payments to first coupon date
+              for n in 1..payment_dates.count do
+                value_at_first_coupon += @coupon*@face_value/@coupon_frequency/(1+irr)**n    
+              end
+            else
+              # discount all coupon payments excluding first one to first coupon date
+              for n in 1..payment_dates.count-1 do
+                value_at_first_coupon += @coupon*@face_value/@coupon_frequency/(1+irr)**n    
+              end
             end
           end
 
-          # discount value at first coupon date to present value
-          if is_365?
-            price = value_at_first_coupon/(1+irr*(payment_dates.first-date)/first_coupon_discount_days(date))/(1+fees)
+          if @coupon_payment_dates.include?(date)
+            # today is one of the coupon payment, no need to discount
+            price = value_at_first_coupon
           else
-            price = value_at_first_coupon/(1+irr*@coupon_frequency*day_count_factor(date, payment_dates.first, nil))/(1+fees)
-          end   
+            # discount value at first coupon date to present value
+            if is_365?
+              price = value_at_first_coupon/(1+irr*(payment_dates.first-date)/first_coupon_discount_days(date))/(1+fees)
+            else
+              price = value_at_first_coupon/(1+irr*@coupon_frequency*day_count_factor(date, payment_dates.first, nil))/(1+fees)
+            end   
+          end
         end
 
       end
 
       def first_coupon(date, ex_coupon_date)
-        if !ex_coupon_date.nil? && date > ex_coupon_date
+        if @coupon_payment_dates.include?(date) || (!ex_coupon_date.nil? && date > ex_coupon_date)
+          # if today is on coupon payment date, we won't include the coupon 
+          # as by default it's passing ex_coupon_date in our calculation
           # after ex coupon date, buyer won't receive next coupon
-          return 0
+          return 0.to_d
         end
         
         coupon = @coupon*@face_value/@coupon_frequency
@@ -223,7 +241,7 @@ module Istox
           if d1 == 30 
             d2 = [d2, 30].min
           end
-          (360*(date2.year - date1.year) + 30*(date2.month - date1.month) + d2 - d1)/360.to_d
+          (360*(date2.year - date1.year) + 30*(date2.month - date1.month) + d2 - d1)/@days_of_year
         end
       end
 

data/lib/istox/version.rb

@@ -1,3 +1,3 @@
 module Istox
-  VERSION = '0.1.86'.freeze
+  VERSION = '0.1.87'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: istox
 version: !ruby/object:Gem::Version
-  version: 0.1.86
+  version: 0.1.87
 platform: ruby
 authors:
 - Siong Leng
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-09-17 00:00:00.000000000 Z
+date: 2019-09-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bunny
@@ -299,7 +299,8 @@ files:
 - 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/order_book_price_time.rb
+- lib/istox/helpers/order_book_prorate.rb
 - lib/istox/helpers/publisher.rb
 - lib/istox/helpers/vault.rb
 - lib/istox/interfaces/chainhub/transaction.rb

data/lib/istox/helpers/order_book.rb

@@ -1,88 +0,0 @@
-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]]
-        end
-
-        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
-
-        # 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.round_down(::Istox::FMath.div(item[:fiat_amount], item[:token_price]), 0)
-          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
-          {
-            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)
-        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