chore: update mocks with decimal conversion

Author: RomuloSiebra

integrationTests/mock/KcMock.go

@@ -161,6 +161,16 @@ func (mock *KleverBlockchainMock) AddTokensPair(erc20 common.Address, ticker str
 	mock.addTokensPair(erc20, ticker, isNativeToken, isMintBurnToken, totalBalance, mintBalances, burnBalances)
 }
 
+// SetDecimalConversion sets the decimal conversion configuration for a token
+// The conversion is calculated as: convertedAmount = (amount * multiplier) / divisor
+// For example, ETH 18 decimals to KDA 6 decimals: multiplier=1, divisor=10^12
+func (mock *KleverBlockchainMock) SetDecimalConversion(ticker string, multiplier, divisor *big.Int) {
+	mock.mutState.Lock()
+	defer mock.mutState.Unlock()
+
+	mock.setDecimalConversion(ticker, multiplier, divisor)
+}
+
 // SetLastExecutedEthBatchID -
 func (mock *KleverBlockchainMock) SetLastExecutedEthBatchID(lastExecutedEthBatchId uint64) {
 	mock.mutState.Lock()

integrationTests/mock/KleverContractStateMock.go

@@ -28,12 +28,13 @@ type kleverBlockchainProposedTransfer struct {
 
 // Transfer -
 type Transfer struct {
-	From   []byte
-	To     []byte
-	Token  string
-	Amount *big.Int
-	Nonce  *big.Int
-	Data   []byte
+	From            []byte
+	To              []byte
+	Token           string
+	Amount          *big.Int
+	ConvertedAmount *big.Int
+	Nonce           *big.Int
+	Data            []byte
 }
 
 // KleverBlockchainPendingBatch -
@@ -44,11 +45,12 @@ type KleverBlockchainPendingBatch struct {
 
 // KleverBlockchainDeposit -
 type KleverBlockchainDeposit struct {
-	From         address.Address
-	To           common.Address
-	Ticker       string
-	Amount       *big.Int
-	DepositNonce uint64
+	From            address.Address
+	To              common.Address
+	Ticker          string
+	Amount          *big.Int
+	ConvertedAmount *big.Int
+	DepositNonce    uint64
 }
 
 // kleverBlockchainContractStateMock is not concurrent safe
@@ -193,26 +195,32 @@ func (mock *kleverBlockchainContractStateMock) createProposedTransfer(dataSplit
 			panic(errDecode)
 		}
 
-		nonceBytes, errDecode := hex.DecodeString(dataSplit[currentIndex+4])
+		convertedAmountBytes, errDecode := hex.DecodeString(dataSplit[currentIndex+4])
 		if errDecode != nil {
 			panic(errDecode)
 		}
 
-		dataBytes, errDecode := hex.DecodeString(dataSplit[currentIndex+5])
+		nonceBytes, errDecode := hex.DecodeString(dataSplit[currentIndex+5])
+		if errDecode != nil {
+			panic(errDecode)
+		}
+
+		dataBytes, errDecode := hex.DecodeString(dataSplit[currentIndex+6])
 		if errDecode != nil {
 			panic(errDecode)
 		}
 
 		t := Transfer{
-			From:   from,
-			To:     to,
-			Token:  dataSplit[currentIndex+2],
-			Amount: big.NewInt(0).SetBytes(amountBytes),
-			Nonce:  big.NewInt(0).SetBytes(nonceBytes),
-			Data:   dataBytes,
+			From:            from,
+			To:              to,
+			Token:           dataSplit[currentIndex+2],
+			Amount:          big.NewInt(0).SetBytes(amountBytes),
+			ConvertedAmount: big.NewInt(0).SetBytes(convertedAmountBytes),
+			Nonce:           big.NewInt(0).SetBytes(nonceBytes),
+			Data:            dataBytes,
 		}
 
-		indexIncrementValue := 6
+		indexIncrementValue := 7
 		transfer.Transfers = append(transfer.Transfers, t)
 		currentIndex += indexIncrementValue
 	}
@@ -283,6 +291,8 @@ func (mock *kleverBlockchainContractStateMock) processVmRequests(vmRequest *mode
 		return mock.vmRequestGetBurnBalances(vmRequest), nil
 	case "getLastBatchId":
 		return mock.vmRequestGetLastBatchId(vmRequest), nil
+	case "convertEthToKdaAmount":
+		return mock.vmRequestConvertEthToKdaAmount(vmRequest), nil
 	}
 
 	return nil, fmt.Errorf("unimplemented function: %s", vmRequest.FuncName)
@@ -464,6 +474,11 @@ func (mock *kleverBlockchainContractStateMock) responseWithPendingBatch() *model
 		args = append(args, deposit.To.Bytes())
 		args = append(args, []byte(deposit.Ticker))
 		args = append(args, deposit.Amount.Bytes())
+		convertedAmount := deposit.ConvertedAmount
+		if convertedAmount == nil {
+			convertedAmount = deposit.Amount // default to same as Amount if not set
+		}
+		args = append(args, convertedAmount.Bytes())
 	}
 	return createOkVmResponse(args)
 }
@@ -553,6 +568,23 @@ func (mock *kleverBlockchainContractStateMock) vmRequestGetLastBatchId(_ *models
 	return createOkVmResponse([][]byte{mock.pendingBatch.Nonce.Bytes()})
 }
 
+func (mock *kleverBlockchainContractStateMock) vmRequestConvertEthToKdaAmount(vmRequest *models.VmValueRequest) *models.VmValuesResponseData {
+	// Parse the token from the first argument
+	hexedToken := vmRequest.Args[0]
+
+	// Parse the amount from the second argument
+	amountBytes, err := hex.DecodeString(vmRequest.Args[1])
+	if err != nil {
+		return createNokVmResponse(err)
+	}
+	amount := big.NewInt(0).SetBytes(amountBytes)
+
+	// Use the decimal conversion configuration from the token registry
+	convertedAmount := mock.tokensRegistryMock.getConvertedAmount(hexedToken, amount)
+
+	return createOkVmResponse([][]byte{convertedAmount.Bytes()})
+}
+
 func getBigIntFromString(data string) *big.Int {
 	buff, err := hex.DecodeString(data)
 	if err != nil {

integrationTests/mock/tokensRegistryMock.go

@@ -8,15 +8,22 @@ import (
 	"github.com/klever-io/klv-bridge-eth-go/integrationTests"
 )
 
+// DecimalConversionConfig holds the multiplier and divisor for decimal conversion
+type DecimalConversionConfig struct {
+	Multiplier *big.Int
+	Divisor    *big.Int
+}
+
 // tokensRegistryMock is not concurrent safe
 type tokensRegistryMock struct {
-	ethToKC        map[common.Address]string
-	kcToEth        map[string]common.Address
-	mintBurnTokens map[string]bool
-	nativeTokens   map[string]bool
-	totalBalances  map[string]*big.Int
-	mintBalances   map[string]*big.Int
-	burnBalances   map[string]*big.Int
+	ethToKC           map[common.Address]string
+	kcToEth           map[string]common.Address
+	mintBurnTokens    map[string]bool
+	nativeTokens      map[string]bool
+	totalBalances     map[string]*big.Int
+	mintBalances      map[string]*big.Int
+	burnBalances      map[string]*big.Int
+	decimalConversion map[string]*DecimalConversionConfig // key is hex-encoded ticker
 }
 
 func (mock *tokensRegistryMock) addTokensPair(erc20Address common.Address, ticker string, isNativeToken, isMintBurnToken bool, totalBalance, mintBalances, burnBalances *big.Int) {
@@ -41,6 +48,30 @@ func (mock *tokensRegistryMock) addTokensPair(erc20Address common.Address, ticke
 	}
 }
 
+// setDecimalConversion sets the decimal conversion configuration for a token
+// The conversion is calculated as: convertedAmount = (amount * multiplier) / divisor
+// For example, ETH 18 decimals to KDA 6 decimals: multiplier=1, divisor=10^12
+func (mock *tokensRegistryMock) setDecimalConversion(ticker string, multiplier, divisor *big.Int) {
+	hexedTicker := hex.EncodeToString([]byte(ticker))
+	mock.decimalConversion[hexedTicker] = &DecimalConversionConfig{
+		Multiplier: multiplier,
+		Divisor:    divisor,
+	}
+}
+
+// getConvertedAmount converts an amount using the decimal conversion config for the token
+// If no conversion is configured, returns the same amount
+func (mock *tokensRegistryMock) getConvertedAmount(hexedTicker string, amount *big.Int) *big.Int {
+	config, exists := mock.decimalConversion[hexedTicker]
+	if !exists || config == nil {
+		return amount
+	}
+	// convertedAmount = (amount * multiplier) / divisor
+	result := new(big.Int).Mul(amount, config.Multiplier)
+	result.Div(result, config.Divisor)
+	return result
+}
+
 func (mock *tokensRegistryMock) clearTokens() {
 	mock.ethToKC = make(map[common.Address]string)
 	mock.kcToEth = make(map[string]common.Address)
@@ -49,6 +80,7 @@ func (mock *tokensRegistryMock) clearTokens() {
 	mock.totalBalances = make(map[string]*big.Int)
 	mock.mintBalances = make(map[string]*big.Int)
 	mock.burnBalances = make(map[string]*big.Int)
+	mock.decimalConversion = make(map[string]*DecimalConversionConfig)
 }
 
 func (mock *tokensRegistryMock) getTicker(erc20Address common.Address) string {

integrationTests/relayers/kcToEth_test.go

@@ -248,12 +248,14 @@ func createTransactions(n int) ([]mock.KleverBlockchainDeposit, []common.Address
 
 func createTransaction(index int) (mock.KleverBlockchainDeposit, common.Address) {
 	tokenAddress := testsCommon.CreateRandomEthereumAddress()
+	amount := big.NewInt(int64(index*1000) + 500) // 0 as amount is not relevant
 
 	return mock.KleverBlockchainDeposit{
-		From:   testsCommon.CreateRandomKCAddress(),
-		To:     testsCommon.CreateRandomEthereumAddress(),
-		Ticker: fmt.Sprintf("tck-00000%d", index+1),
-		Amount: big.NewInt(int64(index*1000) + 500), // 0 as amount is not relevant
+		From:            testsCommon.CreateRandomKCAddress(),
+		To:              testsCommon.CreateRandomEthereumAddress(),
+		Ticker:          fmt.Sprintf("tck-00000%d", index+1),
+		Amount:          amount,
+		ConvertedAmount: amount, // default to same as Amount for now
 	}, tokenAddress
 }