[wildcat] track rate by multiple amountIn (#1244)

* track rate by multiple amountIn

* .

* bin search

Author: tien7668

pkg/liquidity-source/wildcat/constant.go

@@ -5,6 +5,7 @@ import "errors"
 const (
 	DexType    = "wildcat"
 	defaultGas = 10000
+	sampleSize = 15
 )
 
 var (

pkg/liquidity-source/wildcat/pool_list_updater.go

@@ -100,9 +100,9 @@ func (u *PoolsListUpdater) GetNewPools(ctx context.Context, metadataBytes []byte
 		p.Extra = string(extraBytes)
 		return p
 	})
-	if _, err := TrackPools(ctx, pools, u.ethrpcClient, u.config); err != nil {
-		return nil, metadataBytes, err
-	}
+	// if _, err := TrackPools(ctx, pools, u.ethrpcClient, u.config); err != nil {
+	// 	return nil, metadataBytes, err
+	// }
 
 	newMetadataBytes, err := u.newMetadata(offset + len(pairs))
 	if err != nil {

pkg/liquidity-source/wildcat/pool_simulator.go

@@ -4,6 +4,7 @@ import (
 	"encoding/json"
 	"math/big"
 	"slices"
+	"sort"
 
 	"github.com/samber/lo"
 
@@ -51,11 +52,17 @@ func (s *PoolSimulator) CalcAmountOut(params pool.CalcAmountOutParams) (*pool.Ca
 		return nil, ErrInvalidToken
 	}
 
-	amountOut := big.NewInt(0)
-	if s.Rates[indexIn].Sign() >= 0 {
-		bignumber.MulDivDown(amountOut, tokenAmountIn.Amount, s.Info.Reserves[indexOut], s.Rates[indexIn])
+	if len(s.Samples[indexIn]) == 0 {
+		return nil, ErrInsufficientLiquidity
 	}
 
+	samples := s.Samples[indexIn]
+	idx := sort.Search(len(samples), func(i int) bool {
+		return samples[i][0].Cmp(tokenAmountIn.Amount) > 0
+	})
+	sampleIndex := max(idx-1, 0)
+	amountOut := bignumber.MulDivDown(big.NewInt(0), tokenAmountIn.Amount, samples[sampleIndex][1], samples[sampleIndex][0])
+
 	if amountOut.Cmp(s.Info.Reserves[indexOut]) >= 0 {
 		return nil, ErrInsufficientLiquidity
 	}

pkg/liquidity-source/wildcat/pool_simulator_test.go

@@ -12,7 +12,7 @@ import (
 
 var (
 	entityPool entity.Pool
-	_          = json.Unmarshal([]byte(`{"address":"0x4ec0cb2ef6c438f1c1634212377abdc9f2b0b20d","exchange":"wildcat","type":"wildcat","timestamp":1765885780,"reserves":["118004000000000000000","999930756215080"],"tokens":[{"address":"0x6a5e34ea281b25a860517077a7a942e95ec31154","symbol":"ETH","decimals":18,"swappable":true},{"address":"0xb2b18b723f6d0df5be06e245f6eebf8a43d85151","symbol":"USDC","decimals":6,"swappable":true}],"extra":"{\"rates\":[332665881250712632291671,355429528951],\"isNative\":[false,false]}"}`),
+	_          = json.Unmarshal([]byte(`{"address":"0xcc8e05f2d5e28b70214d3d384bada2bd0ae99cda","exchange":"wildcat","type":"wildcat","timestamp":1767595770,"reserves":["30699993136664026623","31490510717"],"tokens":[{"address":"0x4200000000000000000000000000000000000006","symbol":"WETH","decimals":18,"swappable":true},{"address":"0x833589fcd6edb6e08f4c7c32d4f71b54bda02913","symbol":"USDC","decimals":6,"swappable":true}],"extra":"{\"rates\":[18332721688954665668,70366686069],\"isNative\":[true,false],\"samples\":[[[1000000000000000,3154701],[10000000000000000,31547016],[100000000000000000,315470163],[1000000000000000000,3154701633],[10000000000000000000,0],[100000000000000000000,0],[1000000000000000000000,0]],[[1000,0],[10000,0],[100000,31698338375796],[1000000,316983383757966],[10000000,3169833837579669],[100000000,31698338375796699],[1000000000,316983383757966994]]]}"}`),
 		&entityPool)
 	poolSim = lo.Must(NewPoolSimulator(entityPool))
 )
@@ -22,12 +22,12 @@ func TestPoolSimulator_CalcAmountOut(t *testing.T) {
 	testutil.TestCalcAmountOut(t, poolSim, map[int]map[int]map[string]string{
 		1: {
 			0: {
-				"3005810": "997940729029576",
+				"3005810": "952791824733531",
 			},
 		},
 		0: {
 			1: {
-				"1000000000000000": "3005810",
+				"1000000000000000": "3154701",
 			},
 		},
 	})

pkg/liquidity-source/wildcat/pool_tracker.go

@@ -9,10 +9,12 @@ import (
 	"github.com/KyberNetwork/ethrpc"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/ethclient/gethclient"
+	"github.com/samber/lo"
 
 	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/entity"
 	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/source/pool"
 	pooltrack "github.com/KyberNetwork/kyberswap-dex-lib/pkg/source/pool/tracker"
+	"github.com/KyberNetwork/kyberswap-dex-lib/pkg/util/bignumber"
 )
 
 type PoolTracker struct {
@@ -63,7 +65,6 @@ func (t *PoolTracker) getNewPoolState(
 
 func TrackPools(ctx context.Context, pools []entity.Pool, rpcClient *ethrpc.Client, cfg *Config) ([]entity.Pool, error) {
 	req := rpcClient.NewRequest().SetContext(ctx)
-	rates := make([][]*big.Int, len(pools))
 	reserves := make([][]*big.Int, len(pools))
 	extras := make([]Extra, len(pools))
 	for i, pool := range pools {
@@ -96,29 +97,40 @@ func TrackPools(ctx context.Context, pools []entity.Pool, rpcClient *ethrpc.Clie
 	}
 
 	req = rpcClient.NewRequest().SetContext(ctx)
+	samples := make([][][][2]*big.Int, len(pools))
 	for i, pool := range pools {
-		rates[i] = make([]*big.Int, 2)
+		samples[i] = make([][][2]*big.Int, len(pool.Tokens))
 		for j := range pool.Tokens {
-			if reserves[i][(j+1)%2].Sign() == 0 {
-				rates[i][j] = big.NewInt(0)
-				continue
+			samples[i][j] = make([][2]*big.Int, sampleSize)
+			start := lo.Ternary(pool.Tokens[j].Decimals < sampleSize/2, 0, pool.Tokens[j].Decimals-sampleSize/2)
+			end := pool.Tokens[j].Decimals + sampleSize/2
+			index := 0
+			for k := start; k <= end; k++ {
+				samples[i][j][index] = [2]*big.Int{bignumber.TenPowInt(k), big.NewInt(0)}
+				req.AddCall(&ethrpc.Call{
+					ABI:    pairABI,
+					Target: pool.Address,
+					Method: "getAmountOut",
+					Params: []any{j == 0, samples[i][j][index][0]}, // true = 0->1 (getAmountIn(zero_for_one, amount_out))
+				}, []any{&samples[i][j][index][1]})
+				index++
 			}
-			req.AddCall(&ethrpc.Call{
-				ABI:    pairABI,
-				Target: pool.Address,
-				Method: "getAmountIn",
-				Params: []any{j == 0, reserves[i][(j+1)%2]}, // true = 0->1 (getAmountIn(zero_for_one, amount_out))
-			}, []any{&rates[i][j]})
 		}
 	}
-	_, err = req.Aggregate()
+	_, err = req.TryAggregate()
 	if err != nil {
 		return nil, err
 	}
-
+	for i := range samples {
+		for j := range samples[i] {
+			samples[i][j] = lo.Filter(samples[i][j], func(sample [2]*big.Int, _ int) bool {
+				return sample[0] != nil && sample[1] != nil
+			})
+		}
+	}
 	for i := range pools {
 		pools[i].Reserves = []string{reserves[i][0].String(), reserves[i][1].String()}
-		extras[i].Rates = rates[i]
+		extras[i].Samples = samples[i]
 		extraBytes, err := json.Marshal(extras[i])
 		if err != nil {
 			return nil, err

pkg/liquidity-source/wildcat/types.go

@@ -3,8 +3,9 @@ package wildcat
 import "math/big"
 
 type Extra struct {
-	Rates    []*big.Int `json:"rates"`
-	IsNative []bool     `json:"isNative"`
+	Rates    []*big.Int      `json:"rates"`
+	IsNative []bool          `json:"isNative"`
+	Samples  [][][2]*big.Int `json:"samples"` // [2]*big.Int = [amountIn, amountOut]
 }
 
 type PoolExtra struct {