feat: PRT-change-slices-to-lavaslices

ecosystem/cache/handlers.go

@@ -16,7 +16,7 @@ import (
 	"github.com/lavanet/lava/protocol/lavaprotocol"
 	"github.com/lavanet/lava/protocol/parser"
 	"github.com/lavanet/lava/utils"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
 	spectypes "github.com/lavanet/lava/x/spec/types"
 	emptypb "google.golang.org/protobuf/types/known/emptypb"
@@ -128,7 +128,7 @@ func (s *RelayerCacheServer) GetRelay(ctx context.Context, relayCacheGet *pairin
 		waitGroup.Wait()
 		if err == nil { // in case we got a hit validate seen block of the reply.
 			// validate that the response seen block is larger or equal to our expectations.
-			if cacheReply.SeenBlock < slices.Min([]int64{relayCacheGet.SeenBlock, relayCacheGet.RequestedBlock}) { // TODO unitest this.
+			if cacheReply.SeenBlock < lavaslices.Min([]int64{relayCacheGet.SeenBlock, relayCacheGet.RequestedBlock}) { // TODO unitest this.
 				// Error, our reply seen block is not larger than our expectations, meaning we got an old response
 				// this can happen only in the case relayCacheGet.SeenBlock < relayCacheGet.RequestedBlock
 				// by setting the err variable we will get a cache miss, and the relay will continue to the node.

ecosystem/cache/server.go

@@ -9,7 +9,7 @@ import (
 	"os/signal"
 	"time"
 
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 
 	"github.com/dgraph-io/ristretto"
 	"github.com/improbable-eng/grpc-web/go/grpcweb"
@@ -115,7 +115,7 @@ func (cs *CacheServer) Serve(ctx context.Context,
 
 func (cs *CacheServer) ExpirationForChain(averageBlockTimeForChain time.Duration) time.Duration {
 	eighthBlock := averageBlockTimeForChain / 8
-	return slices.Max([]time.Duration{eighthBlock, cs.ExpirationNonFinalized}) // return the maximum TTL between an eighth block and expiration
+	return lavaslices.Max([]time.Duration{eighthBlock, cs.ExpirationNonFinalized}) // return the maximum TTL between an eighth block and expiration
 }
 
 func Server(

protocol/chaintracker/chain_tracker.go

@@ -21,7 +21,7 @@ import (
 	"github.com/lavanet/lava/protocol/lavasession"
 	"github.com/lavanet/lava/protocol/metrics"
 	"github.com/lavanet/lava/utils"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"golang.org/x/net/http2"
 	"golang.org/x/net/http2/h2c"
 	grpc "google.golang.org/grpc"
@@ -467,8 +467,8 @@ func (ct *ChainTracker) updatePollingTimeBasedOnBlockGap(pollingTime time.Durati
 	if blockGapsLen > PollingUpdateLength { // check we have enough samples
 		// smaller times give more resolution to indentify changes, and also make block arrival predictions more optimistic
 		// so we take a 0.33 percentile because we want to be on the safe side by have a smaller time than expected
-		percentileTime := slices.Percentile(ct.blockEventsGap, 0.33)
-		stability := slices.Stability(ct.blockEventsGap, percentileTime)
+		percentileTime := lavaslices.Percentile(ct.blockEventsGap, 0.33)
+		stability := lavaslices.Stability(ct.blockEventsGap, percentileTime)
 		if debug {
 			utils.LavaFormatDebug("block gaps", utils.Attribute{Key: "block gaps", Value: ct.blockEventsGap}, utils.Attribute{Key: "specID", Value: ct.endpoint.ChainID})
 		}

protocol/lavaprotocol/finalization_consensus.go

@@ -9,7 +9,7 @@ import (
 
 	"github.com/lavanet/lava/protocol/chainlib"
 	"github.com/lavanet/lava/utils"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 	conflicttypes "github.com/lavanet/lava/x/conflict/types"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
 )
@@ -251,7 +251,7 @@ func (fc *FinalizationConsensus) ExpectedBlockHeight(chainParser chainlib.ChainP
 			data[i] = latestBlock
 			i++
 		}
-		return slices.Median(data)
+		return lavaslices.Median(data)
 	}
 	medianOfExpectedBlocks := median(mapExpectedBlockHeights)
 	providersMedianOfLatestBlock := medianOfExpectedBlocks + int64(blockDistanceForFinalizedData)

protocol/lavaprotocol/response_builder.go

@@ -8,8 +8,8 @@ import (
 	btcSecp256k1 "github.com/btcsuite/btcd/btcec"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/lavanet/lava/utils"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/utils/sigs"
-	"github.com/lavanet/lava/utils/slices"
 	conflicttypes "github.com/lavanet/lava/x/conflict/types"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
 	spectypes "github.com/lavanet/lava/x/spec/types"
@@ -87,7 +87,7 @@ func VerifyFinalizationData(reply *pairingtypes.RelayReply, relayRequest *pairin
 	providerLatestBlock := reply.LatestBlock
 	seenBlock := relayRequest.RelayData.SeenBlock
 	requestBlock := relayRequest.RelayData.RequestBlock
-	if providerLatestBlock < slices.Min([]int64{seenBlock, requestBlock}) {
+	if providerLatestBlock < lavaslices.Min([]int64{seenBlock, requestBlock}) {
 		return nil, nil, utils.LavaFormatError("provider response does not meet consistency requirements", ProviderFinzalizationDataError, utils.LogAttr("ProviderAddress", relayRequest.RelaySession.Provider), utils.LogAttr("providerLatestBlock", providerLatestBlock), utils.LogAttr("seenBlock", seenBlock), utils.LogAttr("requestBlock", requestBlock), utils.Attribute{Key: "provider address", Value: providerAddr})
 	}
 	return finalizedBlocks, finalizationConflict, errRet

protocol/lavasession/provider_session_manager.go

@@ -6,7 +6,7 @@ import (
 	"sync/atomic"
 
 	"github.com/lavanet/lava/utils"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
 )
 
@@ -109,7 +109,7 @@ func getBadgeEpochDataFromProviderSessionWithConsumer(badgeUser string, provider
 func registerBadgeEpochDataToProviderSessionWithConsumer(badgeUser string, badgeCuAllocation uint64, providerSessionsWithConsumer *ProviderSessionsWithConsumerProject) *ProviderSessionsEpochData {
 	providerSessionsWithConsumer.Lock.Lock()
 	defer providerSessionsWithConsumer.Lock.Unlock()
-	providerSessionsWithConsumer.badgeEpochData[badgeUser] = &ProviderSessionsEpochData{MaxComputeUnits: slices.Min([]uint64{providerSessionsWithConsumer.epochData.MaxComputeUnits, badgeCuAllocation})}
+	providerSessionsWithConsumer.badgeEpochData[badgeUser] = &ProviderSessionsEpochData{MaxComputeUnits: lavaslices.Min([]uint64{providerSessionsWithConsumer.epochData.MaxComputeUnits, badgeCuAllocation})}
 	return providerSessionsWithConsumer.badgeEpochData[badgeUser]
 }
 

protocol/monitoring/health_results.go

@@ -5,7 +5,7 @@ import (
 	"time"
 
 	"github.com/lavanet/lava/protocol/common"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 	spectypes "github.com/lavanet/lava/x/spec/types"
 )
 
@@ -88,7 +88,7 @@ func (healthResults *HealthResults) updateLatestBlock(specId string, latestBlock
 	if !ok {
 		healthResults.LatestBlocks[specId] = latestBlock
 	} else {
-		healthResults.LatestBlocks[specId] = slices.Max([]int64{existing, latestBlock})
+		healthResults.LatestBlocks[specId] = lavaslices.Max([]int64{existing, latestBlock})
 	}
 }
 
@@ -150,9 +150,9 @@ func (healthResults *HealthResults) SetProviderData(providerKey LavaEntity, late
 		if existing.Block == 0 {
 			existing.Block = latestData.Block
 		} else {
-			latestData.Block = slices.Min([]int64{existing.Block, latestData.Block})
+			latestData.Block = lavaslices.Min([]int64{existing.Block, latestData.Block})
 		}
-		latestData.Latency = slices.Max([]time.Duration{existing.Latency, latestData.Latency})
+		latestData.Latency = lavaslices.Max([]time.Duration{existing.Latency, latestData.Latency})
 	}
 	healthResults.ProviderData[providerKey] = latestData
 }

protocol/provideroptimizer/provider_optimizer.go

@@ -10,9 +10,9 @@ import (
 	"github.com/dgraph-io/ristretto"
 	"github.com/lavanet/lava/protocol/common"
 	"github.com/lavanet/lava/utils"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/utils/rand"
 	"github.com/lavanet/lava/utils/score"
-	"github.com/lavanet/lava/utils/slices"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
 	"gonum.org/v1/gonum/mathext"
 )
@@ -188,7 +188,7 @@ func (po *ProviderOptimizer) calculateSyncLag(latestSync uint64, timeSync time.T
 	}
 	// lag on first block
 	timeLag := sampleTime.Sub(timeSync) // received the latest block at time X, this provider provided the entry at time Y, which is X-Y time after
-	firstBlockLag := slices.Min([]time.Duration{po.averageBlockTime, timeLag})
+	firstBlockLag := lavaslices.Min([]time.Duration{po.averageBlockTime, timeLag})
 	blocksGap := latestSync - providerBlock - 1                     // latestSync > providerBlock
 	blocksGapTime := time.Duration(blocksGap) * po.averageBlockTime // the provider is behind by X blocks, so is expected to catch up in averageBlockTime * X
 	timeLag = firstBlockLag + blocksGapTime

protocol/rpcprovider/rpcprovider_server.go

@@ -25,9 +25,9 @@ import (
 	"github.com/lavanet/lava/protocol/provideroptimizer"
 	"github.com/lavanet/lava/protocol/upgrade"
 	"github.com/lavanet/lava/utils"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/utils/protocopy"
 	"github.com/lavanet/lava/utils/sigs"
-	"github.com/lavanet/lava/utils/slices"
 	pairingtypes "github.com/lavanet/lava/x/pairing/types"
 	spectypes "github.com/lavanet/lava/x/spec/types"
 	grpc "google.golang.org/grpc"
@@ -824,7 +824,7 @@ func (rpcps *RPCProviderServer) TryRelay(ctx context.Context, request *pairingty
 		} // else: we updated the chain message to request the specific latestBlock we fetched earlier, so use the previously fetched latest block and hashes
 		if proofBlock < modifiedReqBlock && proofBlock < request.RelayData.SeenBlock {
 			// we requested with a newer block, but don't necessarily have the finaliziation proof, chaintracker might be behind
-			proofBlock = slices.Min([]int64{modifiedReqBlock, request.RelayData.SeenBlock})
+			proofBlock = lavaslices.Min([]int64{modifiedReqBlock, request.RelayData.SeenBlock})
 
 			proofBlock, requestedHashes, err = rpcps.GetBlockDataForOptimisticFetch(ctx, relayTimeout, proofBlock, blockDistanceToFinalization, blocksInFinalizationData, averageBlockTime)
 			if err != nil {
@@ -864,7 +864,7 @@ func (rpcps *RPCProviderServer) GetBlockDataForOptimisticFetch(ctx context.Conte
 	}
 	timeSlept := 0 * time.Millisecond
 	refreshTime := (averageBlockTime / chaintracker.MostFrequentPollingMultiplier) / 2
-	sleepTime := slices.Min([]time.Duration{10 * refreshTime, timeCanWait, relayBaseTimeout / 2})
+	sleepTime := lavaslices.Min([]time.Duration{10 * refreshTime, timeCanWait, relayBaseTimeout / 2})
 	sleepContext, cancel := context.WithTimeout(context.Background(), sleepTime)
 	fetchedWithoutError := func() bool {
 		timeSlept += refreshTime
@@ -976,7 +976,7 @@ func (rpcps *RPCProviderServer) SleepUntilTimeOrConditionReached(ctx context.Con
 				var sleeping time.Duration
 				deadline, ok := ctx.Deadline()
 				if ok {
-					sleeping = slices.Min([]time.Duration{queryTime, time.Until(deadline) / 4})
+					sleeping = lavaslices.Min([]time.Duration{queryTime, time.Until(deadline) / 4})
 				} else {
 					sleeping = queryTime
 				}

testutil/common/tester.go

@@ -15,8 +15,8 @@ import (
 	stakingtypes "github.com/cosmos/cosmos-sdk/x/staking/types"
 	testkeeper "github.com/lavanet/lava/testutil/keeper"
 	"github.com/lavanet/lava/utils"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/utils/sigs"
-	"github.com/lavanet/lava/utils/slices"
 	dualstakingante "github.com/lavanet/lava/x/dualstaking/ante"
 	dualstakingtypes "github.com/lavanet/lava/x/dualstaking/types"
 	epochstoragetypes "github.com/lavanet/lava/x/epochstorage/types"
@@ -297,7 +297,7 @@ func NewCoin(tokenDenom string, amount int64) sdk.Coin {
 }
 
 func NewCoins(tokenDenom string, amount ...int64) []sdk.Coin {
-	return slices.Map(amount, func(a int64) sdk.Coin { return NewCoin(tokenDenom, a) })
+	return lavaslices.Map(amount, func(a int64) sdk.Coin { return NewCoin(tokenDenom, a) })
 }
 
 // keeper helpers
@@ -648,7 +648,7 @@ func (ts *Tester) TxPairingRelayPayment(addr string, rs ...*pairingtypes.RelaySe
 func (ts *Tester) TxPairingFreezeProvider(addr, chainID string) (*pairingtypes.MsgFreezeProviderResponse, error) {
 	msg := &pairingtypes.MsgFreezeProvider{
 		Creator:  addr,
-		ChainIds: slices.Slice(chainID),
+		ChainIds: lavaslices.Slice(chainID),
 		Reason:   "test",
 	}
 	return ts.Servers.PairingServer.FreezeProvider(ts.GoCtx, msg)
@@ -658,7 +658,7 @@ func (ts *Tester) TxPairingFreezeProvider(addr, chainID string) (*pairingtypes.M
 func (ts *Tester) TxPairingUnfreezeProvider(addr, chainID string) (*pairingtypes.MsgUnfreezeProviderResponse, error) {
 	msg := &pairingtypes.MsgUnfreezeProvider{
 		Creator:  addr,
-		ChainIds: slices.Slice(chainID),
+		ChainIds: lavaslices.Slice(chainID),
 	}
 	return ts.Servers.PairingServer.UnfreezeProvider(ts.GoCtx, msg)
 }

utils/slices/slices.go → utils/lavaslices/slices.go

@@ -1,4 +1,4 @@
-package slices
+package lavaslices
 
 import (
 	"golang.org/x/exp/constraints"

utils/slices/slices_test.go → utils/lavaslices/slices_test.go

@@ -1,4 +1,4 @@
-package slices
+package lavaslices
 
 import (
 	"math"

x/conflict/keeper/msg_server_detection_test.go

@@ -7,8 +7,8 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/lavanet/lava/testutil/common"
 	"github.com/lavanet/lava/utils"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/utils/sigs"
-	"github.com/lavanet/lava/utils/slices"
 	conflicttypes "github.com/lavanet/lava/x/conflict/types"
 	conflictconstruct "github.com/lavanet/lava/x/conflict/types/construct"
 	"github.com/lavanet/lava/x/pairing/types"
@@ -182,5 +182,5 @@ func TestFrozenProviderDetection(t *testing.T) {
 	require.NotEqual(t, 0, len(votersList))
 
 	// the frozen provider should not be part of the voters list
-	require.False(t, slices.Contains(votersList, frozenProvider))
+	require.False(t, lavaslices.Contains(votersList, frozenProvider))
 }

x/dualstaking/keeper/delegate.go

@@ -24,7 +24,7 @@ import (
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
 	"github.com/lavanet/lava/utils"
-	lavaslices "github.com/lavanet/lava/utils/slices"
+	lavaslices "github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/x/dualstaking/types"
 	epochstoragetypes "github.com/lavanet/lava/x/epochstorage/types"
 	"golang.org/x/exp/slices"

x/dualstaking/keeper/delegator_reward.go

@@ -7,7 +7,7 @@ import (
 	"github.com/cosmos/cosmos-sdk/store/prefix"
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/lavanet/lava/utils"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 	"github.com/lavanet/lava/x/dualstaking/types"
 	epochstoragetypes "github.com/lavanet/lava/x/epochstorage/types"
 	spectypes "github.com/lavanet/lava/x/spec/types"
@@ -207,7 +207,7 @@ func (k Keeper) RewardProvidersAndDelegators(ctx sdk.Context, providerAddr sdk.A
 		}
 	}
 
-	relevantDelegations := slices.Filter(delegations,
+	relevantDelegations := lavaslices.Filter(delegations,
 		func(d types.Delegation) bool {
 			return d.ChainID == chainID && d.IsFirstMonthPassed(ctx.BlockTime().UTC().Unix()) && d.Delegator != d.Provider
 		})

x/dualstaking/types/delegate.go

@@ -5,7 +5,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	"github.com/lavanet/lava/utils"
-	"github.com/lavanet/lava/utils/slices"
+	"github.com/lavanet/lava/utils/lavaslices"
 )
 
 func NewDelegation(delegator, provider, chainID string, blockTime time.Time, tokenDenom string) Delegation {
@@ -51,14 +51,14 @@ func NewDelegator(delegator, provider string) Delegator {
 }
 
 func (delegator *Delegator) AddProvider(provider string) {
-	if !slices.Contains(delegator.Providers, provider) {
+	if !lavaslices.Contains(delegator.Providers, provider) {
 		delegator.Providers = append(delegator.Providers, provider)
 	}
 }
 
 func (delegator *Delegator) DelProvider(provider string) {
-	if slices.Contains(delegator.Providers, provider) {
-		delegator.Providers, _ = slices.Remove(delegator.Providers, provider)
+	if lavaslices.Contains(delegator.Providers, provider) {
+		delegator.Providers, _ = lavaslices.Remove(delegator.Providers, provider)
 	}
 }