Move from LegacyDec to osmomath BigDec for internal calculations (#1231)

* replacing price by osmosmath BigDec

* further fixes

* amm: move from LegacyDec to osmomath BigDec

* commitment: move from LegacyDec to osmomath BigDec

* estaking: move from LegacyDec to osmomath BigDec

* leveragelp: move LegacyDec to osmoBigDec

* masterchef: move LegacyDec to osmoBigDec

* perpetual: move LegacyDec to osmoBigDec

* stablestake: move LegacyDec to osmoBigDec

* tier: move LegacyDec to osmoBigDec

* tradeshield: move LegacyDec to osmoBigDec

* more changes

* fix interest rate hour usd calculation

* test fix

* fixes

* refactoring

* optimizing pow 10 function

* optimizing power functions

* fix test case

* optimizing further GetDenomPrice

* refactor

* add comment for using MaxBigdec

* adding constants

* reordering multiplication

* reordering multiplication

* removing redundant function

* simplify addition

---------

Co-authored-by: avkr003 <abhinav@elys.network>

Author: 99adarsh

go.mod

@@ -7,7 +7,7 @@ toolchain go1.23.1
 require (
 	cosmossdk.io/api v0.7.6
 	cosmossdk.io/client/v2 v2.0.0-beta.7
-	cosmossdk.io/core v0.11.1
+	cosmossdk.io/core v0.12.0
 	cosmossdk.io/errors v1.0.1
 	cosmossdk.io/log v1.5.0
 	cosmossdk.io/math v1.4.0
@@ -29,6 +29,7 @@ require (
 	github.com/cosmos/ibc-go/v8 v8.7.0
 	github.com/cosmos/interchain-security/v6 v6.3.0
 	github.com/gorilla/mux v1.8.1
+	github.com/osmosis-labs/osmosis/osmomath v0.0.17
 	github.com/prometheus/client_golang v1.20.5 // indirect
 	github.com/spf13/cast v1.7.1
 	github.com/spf13/cobra v1.8.1
@@ -143,13 +144,13 @@ require (
 	github.com/gofrs/uuid/v5 v5.1.0 // indirect
 	github.com/gogo/googleapis v1.4.1 // indirect
 	github.com/gogo/protobuf v1.3.3 // indirect
-	github.com/golang/glog v1.2.3 // indirect
+	github.com/golang/glog v1.2.4 // indirect
 	github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da // indirect
 	github.com/golang/mock v1.6.0 // indirect
 	github.com/golang/snappy v0.0.5-0.20220116011046-fa5810519dcb // indirect
 	github.com/google/btree v1.1.3 // indirect
 	github.com/google/cel-go v0.20.1 // indirect
-	github.com/google/flatbuffers v2.0.8+incompatible // indirect
+	github.com/google/flatbuffers v23.5.26+incompatible // indirect
 	github.com/google/go-cmp v0.6.0 // indirect
 	github.com/google/go-containerregistry v0.19.1 // indirect
 	github.com/google/gofuzz v1.2.0 // indirect
@@ -183,7 +184,7 @@ require (
 	github.com/jmespath/go-jmespath v0.4.0 // indirect
 	github.com/jmhodges/levigo v1.0.0 // indirect
 	github.com/klauspost/compress v1.17.9 // indirect
-	github.com/klauspost/cpuid/v2 v2.0.9 // indirect
+	github.com/klauspost/cpuid/v2 v2.2.5 // indirect
 	github.com/klauspost/pgzip v1.2.6 // indirect
 	github.com/kr/pretty v0.3.1 // indirect
 	github.com/kr/text v0.2.0 // indirect
@@ -271,6 +272,7 @@ require (
 )
 
 replace (
+	cosmossdk.io/core => cosmossdk.io/core v0.11.1
 	github.com/99designs/keyring => github.com/cosmos/keyring v1.2.0
 	github.com/bandprotocol/bandchain-packet => github.com/elys-network/bandchain-packet v0.0.3-sdk47
 

go.sum

@@ -0,0 +1,7 @@
+package utils
+
+import "github.com/osmosis-labs/osmosis/osmomath"
+
+var (
+	HoursInYear = osmomath.NewBigDec(365 * 24)
+)

utils/constants.go

@@ -0,0 +1,59 @@
+package utils
+
+import (
+	sdkmath "cosmossdk.io/math"
+	"github.com/osmosis-labs/osmosis/osmomath"
+)
+
+var pow10Int64Cache = [...]int64{
+	1,
+	10,
+	100,
+	1000,
+	10000,
+	100000,
+	1000000,
+	10000000,
+	100000000,
+	1000000000,
+	10000000000,
+	100000000000,
+	1000000000000,
+	10000000000000,
+	100000000000000,
+	1000000000000000,
+	10000000000000000,
+	100000000000000000,
+	1000000000000000000,
+}
+
+func Pow10(decimal uint64) osmomath.BigDec {
+	if decimal <= 18 {
+		return osmomath.NewBigDec(pow10Int64Cache[decimal])
+	}
+
+	// This case less likely to happen
+	value := osmomath.NewBigDec(1)
+	for i := 0; i < int(decimal); i++ {
+		value = value.MulInt64(10)
+	}
+	return value
+}
+
+func Pow10Int64(decimal uint64) int64 {
+	if decimal <= 18 {
+		return pow10Int64Cache[decimal]
+	} else {
+		panic("cannot do more than 10^18 for int64")
+	}
+}
+
+// AbsDifferenceWithSign returns | a - b |, (a - b).sign()
+// a is mutated and returned.
+func AbsDifferenceWithSign(a, b sdkmath.LegacyDec) (sdkmath.LegacyDec, bool) {
+	if a.GTE(b) {
+		return a.SubMut(b), false
+	} else {
+		return a.NegMut().AddMut(b), true
+	}
+}

utils/math.go

@@ -0,0 +1,27 @@
+package utils
+
+import (
+	"testing"
+
+	sdkmath "cosmossdk.io/math"
+)
+
+func TestAbsDifferenceWithSign(t *testing.T) {
+	tests := []struct {
+		a        sdkmath.LegacyDec
+		b        sdkmath.LegacyDec
+		expected sdkmath.LegacyDec
+		sign     bool
+	}{
+		{sdkmath.LegacyNewDec(5), sdkmath.LegacyNewDec(3), sdkmath.LegacyNewDec(2), false},
+		{sdkmath.LegacyNewDec(3), sdkmath.LegacyNewDec(5), sdkmath.LegacyNewDec(2), true},
+		{sdkmath.LegacyNewDec(0), sdkmath.LegacyNewDec(0), sdkmath.LegacyNewDec(0), false},
+	}
+
+	for _, tt := range tests {
+		result, sign := AbsDifferenceWithSign(tt.a, tt.b)
+		if !result.Equal(tt.expected) || sign != tt.sign {
+			t.Errorf("AbsDifferenceWithSign(%s, %s) = (%s, %v); want (%s, %v)", tt.a, tt.b, result, sign, tt.expected, tt.sign)
+		}
+	}
+}

utils/math_test.go

@@ -1,15 +1,30 @@
-package types
+package utils
 
 import (
 	sdkmath "cosmossdk.io/math"
 	"fmt"
+
+	"github.com/osmosis-labs/osmosis/osmomath"
+)
+
+var (
+	oneHalf           = sdkmath.LegacyMustNewDecFromStr("0.5")
+	twoDec            = sdkmath.LegacyMustNewDecFromStr("2")
+	ln2               = sdkmath.LegacyMustNewDecFromStr("0.693147180559945309")
+	inverseLn2        = sdkmath.LegacyMustNewDecFromStr("1.442695040888963407")
+	euler             = sdkmath.LegacyMustNewDecFromStr("2.718281828459045235")
+	powIterationLimit = int64(150_000)
+
+	// PowPrecision Don't EVER change after initializing
+	// TODO: Analyze choice here.
+	powPrecision = sdkmath.LegacyMustNewDecFromStr("0.00000001")
 )
 
 // Pow computes base^(exp)
 // However since the exponent is not an integer, we must do an approximation algorithm.
 // TODO: In the future, lets add some optimized routines for common exponents, e.g. for common wIn / wOut ratios
 // Many simple exponents like 2:1 pools.
-func Pow(base sdkmath.LegacyDec, exp sdkmath.LegacyDec) sdkmath.LegacyDec {
+func Pow(base osmomath.BigDec, exp osmomath.BigDec) osmomath.BigDec {
 	// Exponentiation of a negative base with an arbitrary real exponent is not closed within the reals.
 	// You can see this by recalling that `i = (-1)^(.5)`. We have to go to complex numbers to define this.
 	// (And would have to implement complex logarithms)
@@ -24,16 +39,16 @@ func Pow(base sdkmath.LegacyDec, exp sdkmath.LegacyDec) sdkmath.LegacyDec {
 	integer := exp.TruncateDec()
 	fractional := exp.Sub(integer)
 
-	integerPow := base.Power(uint64(integer.TruncateInt64()))
+	integerPow := base.PowerInteger(uint64(integer.TruncateInt64()))
 
 	if fractional.IsZero() {
 		return integerPow
 	}
 
-	fractionalPow, err := powerApproximation(base, fractional)
+	fractionalPow, err := powerApproximation(base.Dec(), fractional.Dec())
 	if err != nil {
 		panic(err)
 	}
 
-	return integerPow.Mul(fractionalPow)
+	return integerPow.Mul(osmomath.BigDecFromDec(fractionalPow))
 }

x/amm/types/pow.go utils/pow.gox/amm/types/pow.go renamed to utils/pow.go

@@ -1,11 +1,13 @@
-package types
+package utils
 
 import (
-	sdkmath "cosmossdk.io/math"
 	"errors"
 	"fmt"
+	"github.com/osmosis-labs/osmosis/osmomath"
 	"math"
 	"strconv"
+
+	sdkmath "cosmossdk.io/math"
 )
 
 func computeExp(x sdkmath.LegacyDec) (sdkmath.LegacyDec, error) {
@@ -16,13 +18,13 @@ func computeExp(x sdkmath.LegacyDec) (sdkmath.LegacyDec, error) {
 		return euler, nil
 	}
 	// exp(-42) is approx 5.7 x 10^-19, smallest dec possible is 10^-18
-	if x.LTE(sdkmath.LegacyNewDecFromInt(sdkmath.NewInt(-42))) {
+	if x.LTE(sdkmath.LegacyNewDec(-42)) {
 		return sdkmath.LegacyZeroDec(), nil
 	}
 
 	// Range reduction: x = k * ln(2) + y
 	k := x.Mul(inverseLn2).TruncateInt64()
-	y := x.Sub(sdkmath.LegacyNewDecFromInt(sdkmath.NewInt(k)).Mul(ln2))
+	y := x.Sub(sdkmath.LegacyNewDec(k).Mul(ln2))
 
 	expY := sdkmath.LegacyOneDec()
 	term := sdkmath.LegacyOneDec()
@@ -104,6 +106,7 @@ func computeLn(x sdkmath.LegacyDec) (result sdkmath.LegacyDec, err error) {
 }
 
 // powerApproximation Check exponentialLogarithmicMethod and maclaurinSeriesApproximation to understand the limits of this function
+// Power calculation is currently being used to calculate fees, having precision more than 18 decimal places is not that useful as it's as good as 0
 func powerApproximation(base sdkmath.LegacyDec, exp sdkmath.LegacyDec) (sdkmath.LegacyDec, error) {
 	if !base.IsPositive() {
 		return sdkmath.LegacyDec{}, errors.New("base must be greater than 0")
@@ -133,7 +136,8 @@ func powerApproximation(base sdkmath.LegacyDec, exp sdkmath.LegacyDec) (sdkmath.
 	}
 
 	if exp.GT(sdkmath.LegacyOneDec()) {
-		return Pow(base, exp), nil
+		result := Pow(osmomath.BigDecFromDec(base), osmomath.BigDecFromDec(exp))
+		return result.Dec(), nil
 	}
 
 	if base.GTE(oneHalf) && base.LT(twoDec) {

x/amm/types/pow_approx.go utils/pow_approx.gox/amm/types/pow_approx.go renamed to utils/pow_approx.go

@@ -1,10 +1,11 @@
-package types
+package utils
 
 import (
 	sdkmath "cosmossdk.io/math"
 	"fmt"
-	"github.com/stretchr/testify/require"
 	"testing"
+
+	"github.com/stretchr/testify/require"
 )
 
 func ConditionalPanic(t *testing.T, expectPanic bool, sut func()) {

x/amm/types/pow_approx_test.go utils/pow_approx_test.gox/amm/types/pow_approx_test.go renamed to utils/pow_approx_test.go

@@ -0,0 +1,16 @@
+package utils_test
+
+import (
+	"github.com/elys-network/elys/utils"
+	"testing"
+
+	"github.com/osmosis-labs/osmosis/osmomath"
+	"github.com/stretchr/testify/require"
+)
+
+func TestPow(t *testing.T) {
+	pow := utils.Pow(osmomath.NewBigDec(2), osmomath.NewBigDecWithPrec(25, 1)) // 2^2.5
+	require.Equal(t, pow.String(), "5.656854249492380196000000000000000000")
+	pow = utils.Pow(osmomath.NewBigDec(10), osmomath.NewBigDecWithPrec(25, 1)) // 10^2.5
+	require.Equal(t, pow.String(), "316.227766016837933200000000000000000000")
+}

utils/pow_test.go

@@ -5,17 +5,17 @@ import (
 	"strings"
 	"time"
 
-	sdkmath "cosmossdk.io/math"
 	"github.com/cosmos/cosmos-sdk/telemetry"
 	sdk "github.com/cosmos/cosmos-sdk/types"
+	"github.com/osmosis-labs/osmosis/osmomath"
 
 	"github.com/elys-network/elys/x/amm/types"
 )
 
-func (k Keeper) GetStackedSlippage(ctx sdk.Context, poolId uint64) sdkmath.LegacyDec {
+func (k Keeper) GetStackedSlippage(ctx sdk.Context, poolId uint64) osmomath.BigDec {
 	pool, found := k.GetPool(ctx, poolId)
 	if !found {
-		return sdkmath.LegacyZeroDec()
+		return osmomath.ZeroBigDec()
 	}
 	snapshot := k.GetAccountedPoolSnapshotOrSet(ctx, pool)
 	return pool.StackedRatioFromSnapshot(ctx, k.oracleKeeper, &snapshot)