feat : Integrate balancer-v3

pkg/liquidity-source/balancer-v3/hooks/base_hook.go

@@ -0,0 +1,28 @@
+package hooks
+
+import (
+	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/liquidity-source/balancer-v3/math"
+	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/liquidity-source/balancer-v3/shared"
+	"github.com/holiman/uint256"
+)
+
+type BaseHook struct{}
+
+var _ IHook = (*BaseHook)(nil)
+
+func NewBaseHook() *BaseHook {
+	return &BaseHook{}
+}
+
+func (h *BaseHook) OnBeforeSwap(shared.PoolSwapParams) (bool, error) {
+	return false, nil
+}
+
+func (h *BaseHook) OnAfterSwap(shared.AfterSwapParams) (bool, *uint256.Int, error) {
+	return false, math.ZERO, nil
+
+}
+
+func (h *BaseHook) OnComputeDynamicSwapFeePercentage(shared.PoolSwapParams) (bool, *uint256.Int, error) {
+	return false, math.ZERO, nil
+}

pkg/liquidity-source/balancer-v3/hooks/directional_fee.go

@@ -0,0 +1,64 @@
+package hooks
+
+import (
+	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/liquidity-source/balancer-v3/math"
+	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/liquidity-source/balancer-v3/shared"
+	"github.com/holiman/uint256"
+)
+
+const DirectionalFeeHookType = "DirectionalFeeHook"
+
+type directionalFeeHook struct {
+	BaseHook
+
+	staticSwapFeePercentage *uint256.Int
+}
+
+func NewDirectionalFeeHook(staticSwapFeePercentage *uint256.Int) *directionalFeeHook {
+	return &directionalFeeHook{
+		staticSwapFeePercentage: staticSwapFeePercentage,
+	}
+}
+
+func (h *directionalFeeHook) OnComputeDynamicSwapFeePercentage(param shared.PoolSwapParams) (bool, *uint256.Int, error) {
+	calculatedSwapFeePercentage, err := h.calculatedExpectedSwapFeePercentage(param.BalancesLiveScaled18[param.IndexIn],
+		param.BalancesLiveScaled18[param.IndexOut], param.AmountGivenScaled18)
+	if err != nil {
+		return false, nil, err
+	}
+
+	if calculatedSwapFeePercentage.Gt(h.staticSwapFeePercentage) {
+		return true, calculatedSwapFeePercentage, nil
+	}
+
+	return false, new(uint256.Int).Set(h.staticSwapFeePercentage), nil
+}
+
+func (h *directionalFeeHook) calculatedExpectedSwapFeePercentage(balanceIn, balanceOut, swapAmount *uint256.Int) (*uint256.Int, error) {
+	finalBalanceTokenIn, err := math.FixPoint.Add(balanceIn, swapAmount)
+	if err != nil {
+		return nil, err
+	}
+
+	finalBalanceTokenOut, err := math.FixPoint.Sub(balanceOut, swapAmount)
+	if err != nil {
+		return nil, err
+	}
+
+	if finalBalanceTokenIn.Gt(finalBalanceTokenOut) {
+		diff, err := math.FixPoint.Sub(finalBalanceTokenIn, finalBalanceTokenOut)
+		if err != nil {
+			return nil, err
+		}
+
+		totalLiquidity, err := math.FixPoint.Add(finalBalanceTokenIn, finalBalanceTokenOut)
+		if err != nil {
+			return nil, err
+		}
+
+		diff, err = math.FixPoint.DivDown(diff, totalLiquidity)
+		return diff, err
+	}
+
+	return math.ZERO, nil
+}

pkg/liquidity-source/balancer-v3/hooks/fee_taking.go

@@ -0,0 +1,3 @@
+package hooks
+
+const FeeTakingHookType = "FeeTakingHook"

pkg/liquidity-source/balancer-v3/hooks/ihook.go

@@ -0,0 +1,25 @@
+package hooks
+
+import (
+	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/liquidity-source/balancer-v3/shared"
+	"github.com/holiman/uint256"
+)
+
+type IHook interface {
+	OnBeforeSwap(param shared.PoolSwapParams) (bool, error)
+	OnAfterSwap(param shared.AfterSwapParams) (bool, *uint256.Int, error)
+	OnComputeDynamicSwapFeePercentage(param shared.PoolSwapParams) (bool, *uint256.Int, error)
+}
+
+// Define a map of supported hooks
+var hooksMap = map[string]bool{
+	"DirectionalFee":   true,
+	"FeeTaking":        true,
+	"StableSurge":      true,
+	"VeBALFeeDiscount": true,
+}
+
+func IsHookSupported(hook string) bool {
+	_, exists := hooksMap[hook]
+	return exists
+}

pkg/liquidity-source/balancer-v3/hooks/stable_surge.go

@@ -0,0 +1,11 @@
+package hooks
+
+const StableSurgeHookType = "StableSurgeHook"
+
+type StableSurgeHook struct {
+	BaseHook
+}
+
+func NewStableSurgeHook() *StableSurgeHook {
+	return &StableSurgeHook{}
+}

pkg/liquidity-source/balancer-v3/hooks/ve_BAL_fee_discount.go

@@ -0,0 +1,11 @@
+package hooks
+
+const VeBALFeeDiscountHookType = "VeBALFeeDiscountHook"
+
+type VeBALFeeDiscountHook struct {
+	BaseHook
+}
+
+func NewVeBALFeeDiscountHook() *VeBALFeeDiscountHook {
+	return &VeBALFeeDiscountHook{}
+}

pkg/liquidity-source/balancer-v3/math/const.go

@@ -0,0 +1,9 @@
+package math
+
+import "github.com/holiman/uint256"
+
+var (
+	ZERO = uint256.NewInt(0)
+	ONE  = uint256.NewInt(1)
+	TWO  = uint256.NewInt(2)
+)

pkg/liquidity-source/balancer-v3/math/fixed_point_math.go

@@ -0,0 +1,154 @@
+package math
+
+import (
+	"errors"
+
+	v3Utils "github.com/KyberNetwork/uniswapv3-sdk-uint256/utils"
+	"github.com/holiman/uint256"
+)
+
+var (
+	ErrAddOverflow  = errors.New("ADD_OVERFLOW")
+	ErrSubOverflow  = errors.New("SUB_OVERFLOW")
+	ErrMulOverflow  = errors.New("MUL_OVERFLOW")
+	ErrZeroDivision = errors.New("ZERO_DIVISION")
+
+	ONE_E18                = uint256.NewInt(1e18) // 18 decimal places
+	TWO_E18                = new(uint256.Int).Mul(ONE_E18, TWO)
+	FOUR_E18               = new(uint256.Int).Mul(TWO_E18, TWO)
+	MAX_POW_RELATIVE_ERROR = uint256.NewInt(10000) // 10^(-14)
+)
+
+var FixPoint *fixPoint
+
+type fixPoint struct{}
+
+func init() {
+	FixPoint = &fixPoint{}
+}
+
+func (f *fixPoint) MulDivUp(a, b, c *uint256.Int) (*uint256.Int, error) {
+	return v3Utils.MulDivRoundingUp(a, b, c)
+}
+
+func (f *fixPoint) MulUp(a, b *uint256.Int) (*uint256.Int, error) {
+	return v3Utils.MulDivRoundingUp(a, b, ONE_E18)
+}
+
+func (f *fixPoint) MulDown(a, b *uint256.Int) (*uint256.Int, error) {
+	res, overflow := new(uint256.Int).MulDivOverflow(a, b, ONE_E18)
+	if overflow {
+		return nil, ErrMulOverflow
+	}
+
+	return res, nil
+}
+
+func (f *fixPoint) DivUp(a, b *uint256.Int) (*uint256.Int, error) {
+	if b.IsZero() {
+		return nil, ErrZeroDivision
+	}
+
+	return v3Utils.MulDivRoundingUp(a, ONE_E18, b)
+}
+
+func (f *fixPoint) DivDown(a, b *uint256.Int) (*uint256.Int, error) {
+	if b.IsZero() {
+		return nil, ErrZeroDivision
+	}
+
+	res, overflow := new(uint256.Int).MulDivOverflow(a, ONE_E18, b)
+	if overflow {
+		return nil, ErrMulOverflow
+	}
+
+	return res, nil
+}
+
+func (f *fixPoint) DivRawUp(a, b *uint256.Int) (*uint256.Int, error) {
+	if b.IsZero() {
+		return nil, ErrZeroDivision
+	}
+
+	// result = a == 0 ? 0 : 1 + (a - 1) / b
+	if a.IsZero() {
+		return ZERO, nil
+	}
+
+	delta := new(uint256.Int).Sub(a, ONE)
+	delta.Div(delta, b)
+	delta.Add(ONE, delta)
+
+	return delta, nil
+}
+
+func (f *fixPoint) PowUp(x, y *uint256.Int) (*uint256.Int, error) {
+	if y.Eq(ONE_E18) {
+		return x, nil
+	}
+
+	if y.Eq(TWO_E18) {
+		return f.MulUp(x, x)
+	}
+
+	if y.Eq(FOUR_E18) {
+		square, err := f.MulUp(x, x)
+		if err != nil {
+			return nil, err
+		}
+
+		return f.MulUp(square, square)
+	}
+
+	raw, err := Pow(x, y)
+	if err != nil {
+		return nil, err
+	}
+
+	var maxError *uint256.Int
+	maxError, err = f.MulUp(raw, MAX_POW_RELATIVE_ERROR)
+	if err != nil {
+		return nil, err
+	}
+
+	maxError, err = f.Add(maxError, ONE)
+	if err != nil {
+		return nil, err
+	}
+
+	return f.Add(raw, maxError)
+}
+
+func (f *fixPoint) Complement(x *uint256.Int) *uint256.Int {
+	// result = (x < ONE) ? (ONE - x) : 0
+	result := new(uint256.Int).Set(ZERO)
+	if x.Lt(ONE_E18) {
+		result.Sub(ONE_E18, x)
+	}
+
+	return result
+}
+
+func (f *fixPoint) Add(a *uint256.Int, b *uint256.Int) (*uint256.Int, error) {
+	c, overflow := new(uint256.Int).AddOverflow(a, b)
+	if overflow {
+		return nil, ErrAddOverflow
+	}
+	return c, nil
+}
+
+func (f *fixPoint) Sub(a *uint256.Int, b *uint256.Int) (*uint256.Int, error) {
+	c, overflow := new(uint256.Int).SubOverflow(a, b)
+	if overflow {
+		return nil, ErrSubOverflow
+	}
+	return c, nil
+}
+
+func (f *fixPoint) Mul(a *uint256.Int, b *uint256.Int) (*uint256.Int, error) {
+	c, overflow := new(uint256.Int).MulOverflow(a, b)
+	if overflow {
+		return nil, ErrMulOverflow
+	}
+	return c, nil
+}