From 81d44ffada5fefb2620f4f8c504900caf43ab011 Mon Sep 17 00:00:00 2001 From: milad Date: Mon, 11 Dec 2023 13:47:26 +0330 Subject: [PATCH] fix line length linter errors (#62) # Description This PR fixes the linter errors after enabling lll linter. # Reviewers checklist: - [ ] Try to write more meaningful comments with clear actions to be taken. - [ ] Nit-picking should be unblocking. Focus on core issues. # Authors checklist - [x] Provide a concise and meaningful description - [x] Review the code yourself first, before making the PR. - [x] Annotate your PR in places that require explanation. - [x] Think and try to split the PR to smaller PR if it is big. --- integration-tests/contract.go | 6 +- integration-tests/conv.go | 3 +- integration-tests/coreum.go | 9 +- .../coreum/contract_client_test.go | 518 ++++++++++++++---- integration-tests/init.go | 1 + integration-tests/processes/env_test.go | 17 +- integration-tests/processes/send_test.go | 395 +++++++++++-- .../processes/ticket_allocation_test.go | 21 +- integration-tests/xrpl.go | 30 +- integration-tests/xrpl/rpc_test.go | 84 ++- integration-tests/xrpl/scanner_test.go | 8 +- relayer/cmd/cli/cli.go | 12 +- relayer/coreum/contract.go | 125 ++++- relayer/fee/rounding_test.go | 18 +- relayer/processes/amount.go | 53 +- relayer/processes/model.go | 31 +- relayer/processes/xrpl_tx_observer.go | 24 +- relayer/processes/xrpl_tx_submitter.go | 48 +- .../xrpl_tx_submitter_operation_tx.go | 29 +- relayer/processes/xrpl_tx_submitter_test.go | 182 ++++-- relayer/runner/runner.go | 22 +- relayer/xrpl/memo.go | 3 +- relayer/xrpl/rpc.go | 7 +- relayer/xrpl/scanner.go | 25 +- relayer/xrpl/scanner_test.go | 21 +- relayer/xrpl/signer_test.go | 7 +- 26 files changed, 1368 insertions(+), 331 deletions(-) diff --git a/integration-tests/contract.go b/integration-tests/contract.go index a9f6cb4e..ca8c4ad7 100644 --- a/integration-tests/contract.go +++ b/integration-tests/contract.go @@ -37,7 +37,11 @@ func DeployAndInstantiateContract( Amount: issueFee.Amount.AddRaw(1_000_000), }) - contractClient := coreum.NewContractClient(coreum.DefaultContractClientConfig(sdk.AccAddress(nil)), chains.Log, chains.Coreum.ClientContext) + contractClient := coreum.NewContractClient( + coreum.DefaultContractClientConfig(sdk.AccAddress(nil)), + chains.Log, + chains.Coreum.ClientContext, + ) instantiationCfg := coreum.InstantiationConfig{ Owner: owner, Admin: owner, diff --git a/integration-tests/conv.go b/integration-tests/conv.go index 65f7e2d1..ecad307a 100644 --- a/integration-tests/conv.go +++ b/integration-tests/conv.go @@ -8,7 +8,8 @@ import ( "github.com/stretchr/testify/require" ) -// ConvertStringWithDecimalsToSDKInt accepts the float string and returns the value equal to `value * 1e(tokenDecimals)` truncate to int. +// ConvertStringWithDecimalsToSDKInt accepts the float string and returns the value equal to +// `value * 1e(tokenDecimals)` truncate to int. func ConvertStringWithDecimalsToSDKInt(t *testing.T, stringValue string, tokenDecimals int64) sdkmath.Int { tenPowerDec := big.NewInt(0).Exp(big.NewInt(10), big.NewInt(tokenDecimals), nil) valueRat, ok := big.NewRat(0, 1).SetString(stringValue) diff --git a/integration-tests/coreum.go b/integration-tests/coreum.go index eec15432..3a4de0f4 100644 --- a/integration-tests/coreum.go +++ b/integration-tests/coreum.go @@ -28,7 +28,10 @@ type CoreumChain struct { // NewCoreumChain returns new instance of the coreum chain. func NewCoreumChain(cfg CoreumChainConfig) (CoreumChain, error) { - queryCtx, queryCtxCancel := context.WithTimeout(context.Background(), getTestContextConfig().TimeoutConfig.RequestTimeout) + queryCtx, queryCtxCancel := context.WithTimeout( + context.Background(), + getTestContextConfig().TimeoutConfig.RequestTimeout, + ) defer queryCtxCancel() coreumGRPCClient := integration.DialGRPCClient(cfg.GRPCAddress) @@ -37,7 +40,9 @@ func NewCoreumChain(cfg CoreumChainConfig) (CoreumChain, error) { coreumClientCtx := client.NewContext(getTestContextConfig(), app.ModuleBasics). WithGRPCClient(coreumGRPCClient) - coreumFeemodelParamsRes, err := feemodeltypes.NewQueryClient(coreumClientCtx).Params(queryCtx, &feemodeltypes.QueryParamsRequest{}) + coreumFeemodelParamsRes, err := feemodeltypes. + NewQueryClient(coreumClientCtx). + Params(queryCtx, &feemodeltypes.QueryParamsRequest{}) if err != nil { return CoreumChain{}, errors.WithStack(err) } diff --git a/integration-tests/coreum/contract_client_test.go b/integration-tests/coreum/contract_client_test.go index 65f95c7b..a18ef2c8 100644 --- a/integration-tests/coreum/contract_client_test.go +++ b/integration-tests/coreum/contract_client_test.go @@ -95,14 +95,18 @@ func TestDeployAndInstantiateContract(t *testing.T) { coreumDenom := fmt.Sprintf("%s-%s", drop, contractAddress.String()) require.Equal(t, assetfttypes.Token{ - Denom: coreumDenom, - Issuer: contractAddress.String(), - Symbol: xrp, - Subunit: drop, - Precision: 6, - Description: "", - GloballyFrozen: false, - Features: []assetfttypes.Feature{assetfttypes.Feature_minting, assetfttypes.Feature_burning, assetfttypes.Feature_ibc}, + Denom: coreumDenom, + Issuer: contractAddress.String(), + Symbol: xrp, + Subunit: drop, + Precision: 6, + Description: "", + GloballyFrozen: false, + Features: []assetfttypes.Feature{ + assetfttypes.Feature_minting, + assetfttypes.Feature_burning, + assetfttypes.Feature_ibc, + }, BurnRate: sdk.ZeroDec(), SendCommissionRate: sdk.ZeroDec(), Version: assetfttypes.CurrentTokenVersion, @@ -362,14 +366,18 @@ func TestRegisterXRPLToken(t *testing.T) { require.NoError(t, err) require.Equal(t, assetfttypes.Token{ - Denom: registeredInactiveToken.CoreumDenom, - Issuer: contractAddress.String(), - Symbol: strings.ToUpper(prefix), - Subunit: prefix, - Precision: xrplPrecision, - Description: "", - GloballyFrozen: false, - Features: []assetfttypes.Feature{assetfttypes.Feature_minting, assetfttypes.Feature_burning, assetfttypes.Feature_ibc}, + Denom: registeredInactiveToken.CoreumDenom, + Issuer: contractAddress.String(), + Symbol: strings.ToUpper(prefix), + Subunit: prefix, + Precision: xrplPrecision, + Description: "", + GloballyFrozen: false, + Features: []assetfttypes.Feature{ + assetfttypes.Feature_minting, + assetfttypes.Feature_burning, + assetfttypes.Feature_ibc, + }, BurnRate: sdk.ZeroDec(), SendCommissionRate: sdk.ZeroDec(), Version: assetfttypes.CurrentTokenVersion, @@ -396,25 +404,43 @@ func TestRegisterXRPLToken(t *testing.T) { // try to register not existing operation invalidEvidenceTrustSetWithInvalidTicket := rejectedTxEvidenceTrustSet invalidEvidenceTrustSetWithInvalidTicket.TicketSequence = lo.ToPtr(uint32(99)) - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidEvidenceTrustSetWithInvalidTicket) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[0].CoreumAddress, + invalidEvidenceTrustSetWithInvalidTicket, + ) require.True(t, coreum.IsPendingOperationNotFoundError(err), err) // try to register with not existing currency invalidEvidenceNotExistingIssuer := rejectedTxEvidenceTrustSet invalidEvidenceNotExistingIssuer.Issuer = xrpl.GenPrivKeyTxSigner().Account().String() - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidEvidenceNotExistingIssuer) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[0].CoreumAddress, + invalidEvidenceNotExistingIssuer, + ) require.True(t, coreum.IsTokenNotRegisteredError(err), err) // send valid rejected evidence from first relayer - txResTrustSet, err := contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[0].CoreumAddress, rejectedTxEvidenceTrustSet) + txResTrustSet, err := contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[0].CoreumAddress, + rejectedTxEvidenceTrustSet, + ) require.NoError(t, err) - thresholdReachedTrustSet, err := event.FindStringEventAttribute(txResTrustSet.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReachedTrustSet, err := event.FindStringEventAttribute( + txResTrustSet.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(false), thresholdReachedTrustSet) // send valid rejected evidence from second relayer - txResTrustSet, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[1].CoreumAddress, rejectedTxEvidenceTrustSet) + txResTrustSet, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, relayers[1].CoreumAddress, rejectedTxEvidenceTrustSet, + ) require.NoError(t, err) - thresholdReachedTrustSet, err = event.FindStringEventAttribute(txResTrustSet.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReachedTrustSet, err = event.FindStringEventAttribute( + txResTrustSet.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReachedTrustSet) @@ -431,7 +457,11 @@ func TestRegisterXRPLToken(t *testing.T) { }, registeredInactiveToken) // try to send evidence one more time - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[1].CoreumAddress, rejectedTxEvidenceTrustSet) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[1].CoreumAddress, + rejectedTxEvidenceTrustSet, + ) require.True(t, coreum.IsOperationAlreadyExecutedError(err), err) // try to register the sending from the XRPL to coreum evidence with inactive token @@ -442,7 +472,11 @@ func TestRegisterXRPLToken(t *testing.T) { Amount: sdkmath.NewInt(10), Recipient: coreumRecipient, } - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[1].CoreumAddress, xrplToCoreumInactiveTokenTransferEvidence) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, + relayers[1].CoreumAddress, + xrplToCoreumInactiveTokenTransferEvidence, + ) require.True(t, coreum.IsXRPLTokenNotEnabledError(err), err) // register one more token and activate it @@ -551,11 +585,19 @@ func TestSendFromXRPLToCoreumXRPLOriginatedToken(t *testing.T) { // try use not registered token wrongXRPLToCoreumTransferEvidence := xrplToCoreumTransferEvidence wrongXRPLToCoreumTransferEvidence.Currency = "NEZ" - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, wrongXRPLToCoreumTransferEvidence) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, + relayers[0].CoreumAddress, + wrongXRPLToCoreumTransferEvidence, + ) require.True(t, coreum.IsTokenNotRegisteredError(err), err) // call from first relayer - txRes, err := contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err := contractClient.SendXRPLToCoreumTransferEvidence( + ctx, + relayers[0].CoreumAddress, + xrplToCoreumTransferEvidence, + ) require.NoError(t, err) recipientBalanceRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ Address: coreumRecipient.String(), @@ -563,23 +605,35 @@ func TestSendFromXRPLToCoreumXRPLOriginatedToken(t *testing.T) { }) require.NoError(t, err) require.True(t, recipientBalanceRes.Balance.IsZero()) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, + wasmtypes.ModuleName, + eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(false), thresholdReached) // call from first relayer one more time - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, + relayers[0].CoreumAddress, + xrplToCoreumTransferEvidence, + ) require.True(t, coreum.IsEvidenceAlreadyProvidedError(err), err) // call from second relayer - txRes, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence, + ) require.NoError(t, err) recipientBalanceRes, err = bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ Address: coreumRecipient.String(), Denom: registeredToken.CoreumDenom, }) require.NoError(t, err) - thresholdReached, err = event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err = event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReached) @@ -588,7 +642,9 @@ func TestSendFromXRPLToCoreumXRPLOriginatedToken(t *testing.T) { require.Equal(t, xrplToCoreumTransferEvidence.Amount.String(), recipientBalanceRes.Balance.Amount.String()) // try to push the same evidence - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence, + ) require.True(t, coreum.IsOperationAlreadyExecutedError(err), err) } @@ -695,10 +751,12 @@ func TestSendFromXRPLToCoreumXRPLOriginatedTokenWithDifferentSendingPrecision(t wantIsAmountSentIsZeroAfterTruncationError: true, }, { - name: "reached_max_holding_amount", - sendingPrecision: 2, - maxHoldingAmount: integrationtests.ConvertStringWithDecimalsToSDKInt(t, "9999", tokenDecimals), - sendingAmount: integrationtests.ConvertStringWithDecimalsToSDKInt(t, "9999.01", tokenDecimals), + name: "reached_max_holding_amount", + sendingPrecision: 2, + maxHoldingAmount: integrationtests.ConvertStringWithDecimalsToSDKInt(t, "9999", tokenDecimals), + sendingAmount: integrationtests.ConvertStringWithDecimalsToSDKInt( + t, "9999.01", tokenDecimals, + ), wantIsMaximumBridgedAmountReachedError: true, }, } @@ -781,7 +839,11 @@ func TestSendFromXRPLToCoreumXRPToken(t *testing.T) { defaultTrustSetLimitAmount, xrpl.GenPrivKeyTxSigner().Account().String(), ) - registeredXRPToken, err := contractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrpl.XRPTokenIssuer.String(), xrpl.XRPTokenCurrency.String()) + registeredXRPToken, err := contractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, + xrpl.XRPTokenIssuer.String(), + xrpl.XRPTokenCurrency.String(), + ) require.NoError(t, err) require.Equal(t, coreum.XRPLToken{ @@ -807,7 +869,11 @@ func TestSendFromXRPLToCoreumXRPToken(t *testing.T) { require.True(t, coreum.IsUnauthorizedSenderError(err), err) // call from first relayer - txRes, err := contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err := contractClient.SendXRPLToCoreumTransferEvidence( + ctx, + relayers[0].CoreumAddress, + xrplToCoreumTransferEvidence, + ) require.NoError(t, err) recipientBalanceRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ Address: coreumRecipient.String(), @@ -815,23 +881,33 @@ func TestSendFromXRPLToCoreumXRPToken(t *testing.T) { }) require.NoError(t, err) require.True(t, recipientBalanceRes.Balance.IsZero()) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, + wasmtypes.ModuleName, + eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(false), thresholdReached) // call from first relayer one more time - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence, + ) require.True(t, coreum.IsEvidenceAlreadyProvidedError(err), err) // call from second relayer - txRes, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence, + ) require.NoError(t, err) recipientBalanceRes, err = bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ Address: coreumRecipient.String(), Denom: registeredXRPToken.CoreumDenom, }) require.NoError(t, err) - thresholdReached, err = event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err = event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReached) @@ -927,7 +1003,9 @@ func TestSendFromXRPLToCoreumCoreumOriginatedToken(t *testing.T) { xrplToCoreumTransferEvidenceForNotRegisteredToken := xrplToCoreumTransferEvidence xrplToCoreumTransferEvidenceForNotRegisteredToken.Currency = "XZA" - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidenceForNotRegisteredToken) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidenceForNotRegisteredToken, + ) require.True(t, coreum.IsTokenNotRegisteredError(err), err) // call from first relayer @@ -935,9 +1013,13 @@ func TestSendFromXRPLToCoreumCoreumOriginatedToken(t *testing.T) { require.NoError(t, err) // call from second relayer - txRes, err := contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err := contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence, + ) require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReached) @@ -1127,11 +1209,15 @@ func TestSendFromXRPLToCoreumCoreumOriginatedTokenWithFreezingAndWhitelisting(t } // call from first relayer - _, err = contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence) + _, err = contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[0].CoreumAddress, xrplToCoreumTransferEvidence, + ) require.NoError(t, err) // call from second relayer - txRes, err := contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err := contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayers[1].CoreumAddress, xrplToCoreumTransferEvidence, + ) if tt.checkAssetFTError != nil { require.True(t, coreum.IsAssetFTStateError(err), err) tt.checkAssetFTError(t, err) @@ -1139,7 +1225,9 @@ func TestSendFromXRPLToCoreumCoreumOriginatedTokenWithFreezingAndWhitelisting(t } require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReached) @@ -1149,7 +1237,11 @@ func TestSendFromXRPLToCoreumCoreumOriginatedTokenWithFreezingAndWhitelisting(t Denom: registeredCoreumToken.Denom, }) require.NoError(t, err) - require.Equal(t, xrplToCoreumTransferEvidence.Amount.String(), recipientBalanceRes.Balance.Amount.String()) + require.Equal( + t, + xrplToCoreumTransferEvidence.Amount.String(), + recipientBalanceRes.Balance.Amount.String(), + ) // check contract balance contractBalanceRes, err = bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ @@ -1157,7 +1249,11 @@ func TestSendFromXRPLToCoreumCoreumOriginatedTokenWithFreezingAndWhitelisting(t Denom: denom, }) require.NoError(t, err) - require.Equal(t, coinToSend.Amount.Sub(xrplToCoreumTransferEvidence.Amount).String(), contractBalanceRes.Balance.Amount.String()) + require.Equal( + t, + coinToSend.Amount.Sub(xrplToCoreumTransferEvidence.Amount).String(), + contractBalanceRes.Balance.Amount.String(), + ) }) } } @@ -1316,7 +1412,9 @@ func TestSendFromXRPLToCoreumCoreumOriginatedTokenWithDifferentSendingPrecision( // if we expect an error the amount is invalid so it won't be accepted from the coreum to XRPL if !tt.wantIsAmountSentIsZeroAfterTruncationError { coinToSend := sdk.NewCoin(denom, tt.sendingAmount) - sendFromCoreumToXRPL(ctx, t, contractClient, relayers, coreumSenderAddress, coinToSend, xrpl.GenPrivKeyTxSigner().Account()) + sendFromCoreumToXRPL( + ctx, t, contractClient, relayers, coreumSenderAddress, coinToSend, xrpl.GenPrivKeyTxSigner().Account(), + ) } // create an evidence @@ -1374,7 +1472,9 @@ func TestRecoverTickets(t *testing.T) { bridgeXRPLAccountFirstSeqNumber := uint32(1) // try to call from not owner - _, err := contractClient.RecoverTickets(ctx, relayers[0].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, &numberOfTicketsToInit) + _, err := contractClient.RecoverTickets( + ctx, relayers[0].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, &numberOfTicketsToInit, + ) require.True(t, coreum.IsNotOwnerError(err), err) // try to use more than max allowed tickets @@ -1428,15 +1528,21 @@ func TestRecoverTickets(t *testing.T) { require.True(t, coreum.IsUnauthorizedSenderError(err), err) // try to send with incorrect operation ID - _, err = contractClient.SaveSignature(ctx, relayers[0].CoreumAddress, uint32(999), signerItem1.TxnSignature.String()) + _, err = contractClient.SaveSignature( + ctx, relayers[0].CoreumAddress, uint32(999), signerItem1.TxnSignature.String(), + ) require.True(t, coreum.IsPendingOperationNotFoundError(err), err) // send from first relayer - _, err = contractClient.SaveSignature(ctx, relayers[0].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, signerItem1.TxnSignature.String()) + _, err = contractClient.SaveSignature( + ctx, relayers[0].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, signerItem1.TxnSignature.String(), + ) require.NoError(t, err) // try to send from the same relayer one more time - _, err = contractClient.SaveSignature(ctx, relayers[0].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, signerItem1.TxnSignature.String()) + _, err = contractClient.SaveSignature( + ctx, relayers[0].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, signerItem1.TxnSignature.String(), + ) require.True(t, coreum.IsSignatureAlreadyProvidedError(err), err) // send from second relayer @@ -1449,7 +1555,9 @@ func TestRecoverTickets(t *testing.T) { relayer2XRPLAcc, err := rippledata.NewAccountFromAddress(relayers[0].XRPLAddress) require.NoError(t, err) signerItem2 := chains.XRPL.Multisign(t, &createTicketsTx, *relayer2XRPLAcc).Signer - _, err = contractClient.SaveSignature(ctx, relayers[1].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, signerItem2.TxnSignature.String()) + _, err = contractClient.SaveSignature( + ctx, relayers[1].CoreumAddress, bridgeXRPLAccountFirstSeqNumber, signerItem2.TxnSignature.String(), + ) require.NoError(t, err) pendingOperations, err = contractClient.GetPendingOperations(ctx) @@ -1491,14 +1599,18 @@ func TestRecoverTickets(t *testing.T) { // try to send with not existing sequence invalidRejectedTxEvidence := rejectedTxEvidence invalidRejectedTxEvidence.AccountSequence = lo.ToPtr(uint32(999)) - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidRejectedTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, invalidRejectedTxEvidence, + ) require.True(t, coreum.IsPendingOperationNotFoundError(err), err) // try to send with not existing ticket invalidRejectedTxEvidence = rejectedTxEvidence invalidRejectedTxEvidence.AccountSequence = nil invalidRejectedTxEvidence.TicketSequence = lo.ToPtr(uint32(999)) - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidRejectedTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, invalidRejectedTxEvidence, + ) require.True(t, coreum.IsPendingOperationNotFoundError(err), err) // try to send from not relayer @@ -1506,25 +1618,37 @@ func TestRecoverTickets(t *testing.T) { require.True(t, coreum.IsUnauthorizedSenderError(err), err) // send evidence from first relayer - txRes, err := contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, rejectedTxEvidence) + txRes, err := contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, rejectedTxEvidence, + ) require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(false), thresholdReached) // try to send evidence from second relayer one more time - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, rejectedTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, rejectedTxEvidence, + ) require.True(t, coreum.IsEvidenceAlreadyProvidedError(err), err) // send evidence from second relayer - txRes, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[1].CoreumAddress, rejectedTxEvidence) + txRes, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[1].CoreumAddress, rejectedTxEvidence, + ) require.NoError(t, err) - thresholdReached, err = event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err = event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReached) // try to send the evidence one more time - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, rejectedTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, rejectedTxEvidence, + ) require.True(t, coreum.IsOperationAlreadyExecutedError(err), err) pendingOperations, err = contractClient.GetPendingOperations(ctx) @@ -1549,9 +1673,13 @@ func TestRecoverTickets(t *testing.T) { }, Tickets: nil, } - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, invalidTxEvidence, + ) require.NoError(t, err) - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[1].CoreumAddress, invalidTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[1].CoreumAddress, invalidTxEvidence, + ) require.NoError(t, err) pendingOperations, err = contractClient.GetPendingOperations(ctx) @@ -1567,9 +1695,13 @@ func TestRecoverTickets(t *testing.T) { require.NoError(t, err) // reject one more time - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, invalidTxEvidence, + ) require.NoError(t, err) - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[1].CoreumAddress, invalidTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[1].CoreumAddress, invalidTxEvidence, + ) require.NoError(t, err) pendingOperations, err = contractClient.GetPendingOperations(ctx) @@ -1598,20 +1730,30 @@ func TestRecoverTickets(t *testing.T) { // try to send with already used txHash invalidAcceptedTxEvidence := acceptedTxEvidence invalidAcceptedTxEvidence.TxHash = rejectedTxHash - _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, invalidAcceptedTxEvidence) + _, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, invalidAcceptedTxEvidence, + ) require.True(t, coreum.IsOperationAlreadyExecutedError(err), err) // send evidence from first relayer - txRes, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[0].CoreumAddress, acceptedTxEvidence) + txRes, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) - thresholdReached, err = event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err = event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(false), thresholdReached) // send evidence from second relayer - txRes, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayers[1].CoreumAddress, acceptedTxEvidence) + txRes, err = contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayers[1].CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) - thresholdReached, err = event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err = event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) require.Equal(t, strconv.FormatBool(true), thresholdReached) @@ -1677,7 +1819,9 @@ func TestSendFromCoreumToXRPLXRPLOriginatedToken(t *testing.T) { activateXRPLToken(ctx, t, contractClient, relayers, issuer, currency) amountToSendFromXRPLToCoreum := sdkmath.NewInt(1_000_100) - sendFromXRPLToCoreum(ctx, t, contractClient, relayers, issuer, currency, amountToSendFromXRPLToCoreum, coreumSenderAddress) + sendFromXRPLToCoreum( + ctx, t, contractClient, relayers, issuer, currency, amountToSendFromXRPLToCoreum, coreumSenderAddress, + ) // validate that the amount is received balanceRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ Address: coreumSenderAddress.String(), @@ -1689,15 +1833,30 @@ func TestSendFromCoreumToXRPLXRPLOriginatedToken(t *testing.T) { amountToSend := sdkmath.NewInt(1_000_000) // try to send more than account has - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, amountToSendFromXRPLToCoreum.AddRaw(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, amountToSendFromXRPLToCoreum.AddRaw(1)), + ) require.ErrorContains(t, err, cosmoserrors.ErrInsufficientFunds.Error()) // try to send with invalid recipient - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, "invalid", sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, amountToSend)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + "invalid", + sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, amountToSend), + ) require.True(t, coreum.IsInvalidXRPLAddressError(err), err) // try to send with not registered token - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(chains.Coreum.ChainSettings.Denom, sdk.NewIntFromUint64(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(chains.Coreum.ChainSettings.Denom, sdk.NewIntFromUint64(1)), + ) require.True(t, coreum.IsTokenNotRegisteredError(err), err) // send valid amount and validate the state @@ -1706,7 +1865,12 @@ func TestSendFromCoreumToXRPLXRPLOriginatedToken(t *testing.T) { Denom: registeredXRPLOriginatedToken.CoreumDenom, }) require.NoError(t, err) - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, amountToSend)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) // check the remaining balance coreumSenderBalanceAfterRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ @@ -1714,7 +1878,11 @@ func TestSendFromCoreumToXRPLXRPLOriginatedToken(t *testing.T) { Denom: registeredXRPLOriginatedToken.CoreumDenom, }) require.NoError(t, err) - require.Equal(t, coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSend).String(), coreumSenderBalanceAfterRes.Balance.Amount.String()) + require.Equal( + t, + coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSend).String(), + coreumSenderBalanceAfterRes.Balance.Amount.String(), + ) pendingOperations, err := contractClient.GetPendingOperations(ctx) require.NoError(t, err) @@ -1736,11 +1904,19 @@ func TestSendFromCoreumToXRPLXRPLOriginatedToken(t *testing.T) { } // send from first relayer - _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayers[0].CoreumAddress, acceptedTxEvidence) + _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, + relayers[0].CoreumAddress, + acceptedTxEvidence, + ) require.NoError(t, err) // send from second relayer - _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayers[1].CoreumAddress, acceptedTxEvidence) + _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, + relayers[1].CoreumAddress, + acceptedTxEvidence, + ) require.NoError(t, err) // check pending operations @@ -1752,12 +1928,22 @@ func TestSendFromCoreumToXRPLXRPLOriginatedToken(t *testing.T) { tickets, err := contractClient.GetAvailableTickets(ctx) require.NoError(t, err) for i := 0; i < len(tickets)-1; i++ { - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, sdk.NewIntFromUint64(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, sdk.NewIntFromUint64(1)), + ) require.NoError(t, err) } // try to use last (protected) ticket - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, sdk.NewIntFromUint64(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLOriginatedToken.CoreumDenom, sdk.NewIntFromUint64(1)), + ) require.True(t, coreum.IsLastTicketReservedError(err)) } @@ -1896,7 +2082,12 @@ func TestSendFromCoreumToXRPLXRPLOriginatedTokenWithDifferentSendingPrecision(t require.NoError(t, err) require.Equal(t, tt.maxHoldingAmount.String(), coreumSenderBalanceRes.Balance.Amount.String()) - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipient.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, tt.sendingAmount)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipient.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, tt.sendingAmount), + ) if tt.wantIsAmountSentIsZeroAfterTruncationError { require.True(t, coreum.IsAmountSentIsZeroAfterTruncationError(err), err) return @@ -1943,14 +2134,25 @@ func TestSendFromCoreumToXRPLXRPToken(t *testing.T) { defaultTrustSetLimitAmount, xrpl.GenPrivKeyTxSigner().Account().String(), ) - registeredXRPToken, err := contractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrpl.XRPTokenIssuer.String(), xrpl.XRPTokenCurrency.String()) + registeredXRPToken, err := contractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, xrpl.XRPTokenIssuer.String(), xrpl.XRPTokenCurrency.String(), + ) require.NoError(t, err) // recover tickets to be able to create operations from coreum to XRPL recoverTickets(ctx, t, contractClient, owner, relayers, 5) amountToSendFromXRPLToCoreum := sdkmath.NewInt(1_000_100) - sendFromXRPLToCoreum(ctx, t, contractClient, relayers, registeredXRPToken.Issuer, registeredXRPToken.Currency, amountToSendFromXRPLToCoreum, coreumSenderAddress) + sendFromXRPLToCoreum( + ctx, + t, + contractClient, + relayers, + registeredXRPToken.Issuer, + registeredXRPToken.Currency, + amountToSendFromXRPLToCoreum, + coreumSenderAddress, + ) // validate that the amount is received balanceRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ Address: coreumSenderAddress.String(), @@ -1967,7 +2169,12 @@ func TestSendFromCoreumToXRPLXRPToken(t *testing.T) { Denom: registeredXRPToken.CoreumDenom, }) require.NoError(t, err) - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPToken.CoreumDenom, amountToSend)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) // check the remaining balance coreumSenderBalanceAfterRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ @@ -1975,7 +2182,11 @@ func TestSendFromCoreumToXRPLXRPToken(t *testing.T) { Denom: registeredXRPToken.CoreumDenom, }) require.NoError(t, err) - require.Equal(t, coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSend).String(), coreumSenderBalanceAfterRes.Balance.Amount.String()) + require.Equal( + t, + coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSend).String(), + coreumSenderBalanceAfterRes.Balance.Amount.String(), + ) pendingOperations, err := contractClient.GetPendingOperations(ctx) require.NoError(t, err) @@ -1997,11 +2208,15 @@ func TestSendFromCoreumToXRPLXRPToken(t *testing.T) { } // send from first relayer - _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayers[0].CoreumAddress, acceptedTxEvidence) + _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, relayers[0].CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) // send from second relayer - _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayers[1].CoreumAddress, acceptedTxEvidence) + _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, relayers[1].CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) // check pending operations @@ -2092,7 +2307,12 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { notRegisteredTokenDenom := assetfttypes.BuildDenom(issueMsg.Subunit, coreumSenderAddress) // try to send with not registered token - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(notRegisteredTokenDenom, sdk.NewIntFromUint64(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(notRegisteredTokenDenom, sdk.NewIntFromUint64(1)), + ) require.True(t, coreum.IsTokenNotRegisteredError(err), err) // ********** test token1 (assetft) ********** @@ -2105,7 +2325,12 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { Denom: registeredCoreumOriginatedToken1.Denom, }) require.NoError(t, err) - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken1.Denom, amountToSendOfToken1)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken1.Denom, amountToSendOfToken1), + ) require.NoError(t, err) // check the remaining balance coreumSenderBalanceAfterRes, err := bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ @@ -2113,7 +2338,11 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { Denom: registeredCoreumOriginatedToken1.Denom, }) require.NoError(t, err) - require.Equal(t, coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSendOfToken1).String(), coreumSenderBalanceAfterRes.Balance.Amount.String()) + require.Equal( + t, + coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSendOfToken1).String(), + coreumSenderBalanceAfterRes.Balance.Amount.String(), + ) pendingOperations, err := contractClient.GetPendingOperations(ctx) require.NoError(t, err) @@ -2136,7 +2365,9 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { } // send from all relayers for _, relayer := range relayers { - _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayer.CoreumAddress, acceptedTxEvidence) + _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, relayer.CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) } @@ -2155,7 +2386,12 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { Denom: registeredCoreumOriginatedToken2.Denom, }) require.NoError(t, err) - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken2.Denom, amountToSendOfToken2)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken2.Denom, amountToSendOfToken2), + ) require.NoError(t, err) // check the remaining balance coreumSenderBalanceAfterRes, err = bankClient.Balance(ctx, &banktypes.QueryBalanceRequest{ @@ -2163,7 +2399,10 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { Denom: registeredCoreumOriginatedToken2.Denom, }) require.NoError(t, err) - require.True(t, coreumSenderBalanceBeforeRes.Balance.Amount.Sub(amountToSendOfToken2).GT(coreumSenderBalanceAfterRes.Balance.Amount)) + require.True(t, coreumSenderBalanceBeforeRes.Balance.Amount. + Sub(amountToSendOfToken2). + GT(coreumSenderBalanceAfterRes.Balance.Amount), + ) pendingOperations, err = contractClient.GetPendingOperations(ctx) require.NoError(t, err) @@ -2187,7 +2426,9 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { // send from all relayers for _, relayer := range relayers { - _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayer.CoreumAddress, acceptedTxEvidence) + _, err = contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, relayer.CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) } @@ -2201,12 +2442,22 @@ func TestSendFromCoreumToXRPLCoreumOriginatedToken(t *testing.T) { tickets, err := contractClient.GetAvailableTickets(ctx) require.NoError(t, err) for i := 0; i < len(tickets)-1; i++ { - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken1.Denom, sdk.NewIntFromUint64(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken1.Denom, sdk.NewIntFromUint64(1)), + ) require.NoError(t, err) } // try to use last (protected) ticket - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken1.Denom, sdk.NewIntFromUint64(1))) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken1.Denom, sdk.NewIntFromUint64(1)), + ) require.True(t, coreum.IsLastTicketReservedError(err)) } @@ -2357,7 +2608,12 @@ func TestSendFromCoreumToXRPLCoreumOriginatedTokenWithDifferentSendingPrecisionA registeredCoreumToken, err := contractClient.GetCoreumTokenByDenom(ctx, denom) require.NoError(t, err) - _, err = contractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipient.String(), sdk.NewCoin(registeredCoreumToken.Denom, tt.sendingAmount)) + _, err = contractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipient.String(), + sdk.NewCoin(registeredCoreumToken.Denom, tt.sendingAmount), + ) if tt.wantIsAmountSentIsZeroAfterTruncationError { require.True(t, coreum.IsAmountSentIsZeroAfterTruncationError(err), err) return @@ -2373,7 +2629,9 @@ func TestSendFromCoreumToXRPLCoreumOriginatedTokenWithDifferentSendingPrecisionA found := false for _, operation := range pendingOperations { operationType := operation.OperationType.CoreumToXRPLTransfer - if operationType != nil && operationType.Issuer == bridgeXRPLAddress && operationType.Currency == registeredCoreumToken.XRPLCurrency { + if operationType != nil && + operationType.Issuer == bridgeXRPLAddress && + operationType.Currency == registeredCoreumToken.XRPLCurrency { found = true require.Equal(t, tt.wantReceivedAmount.String(), operationType.Amount.String()) } @@ -2464,10 +2722,18 @@ func TestRecoverXRPLTokeRegistration(t *testing.T) { } // send from first relayer - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[0].CoreumAddress, rejectedTxEvidenceTrustSet) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[0].CoreumAddress, + rejectedTxEvidenceTrustSet, + ) require.NoError(t, err) // send from second relayer - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[1].CoreumAddress, rejectedTxEvidenceTrustSet) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[1].CoreumAddress, + rejectedTxEvidenceTrustSet, + ) require.NoError(t, err) // check that we don't have pending operations anymore @@ -2517,10 +2783,18 @@ func TestRecoverXRPLTokeRegistration(t *testing.T) { } // send from first relayer - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[0].CoreumAddress, acceptedTxEvidenceTrustSet) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[0].CoreumAddress, + acceptedTxEvidenceTrustSet, + ) require.NoError(t, err) // send from second relayer - _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayers[1].CoreumAddress, acceptedTxEvidenceTrustSet) + _, err = contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, + relayers[1].CoreumAddress, + acceptedTxEvidenceTrustSet, + ) require.NoError(t, err) pendingOperations, err = contractClient.GetPendingOperations(ctx) @@ -2557,9 +2831,13 @@ func recoverTickets( } for _, relayer := range relayers { - txRes, err := contractClient.SendXRPLTicketsAllocationTransactionResultEvidence(ctx, relayer.CoreumAddress, acceptedTxEvidence) + txRes, err := contractClient.SendXRPLTicketsAllocationTransactionResultEvidence( + ctx, relayer.CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) if thresholdReached == strconv.FormatBool(true) { break @@ -2606,9 +2884,13 @@ func activateXRPLToken( // send evidences from relayers for _, relayer := range relayers { - txRes, err := contractClient.SendXRPLTrustSetTransactionResultEvidence(ctx, relayer.CoreumAddress, acceptedTxEvidenceTrustSet) + txRes, err := contractClient.SendXRPLTrustSetTransactionResultEvidence( + ctx, relayer.CoreumAddress, acceptedTxEvidenceTrustSet, + ) require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) if thresholdReached == strconv.FormatBool(true) { break @@ -2642,9 +2924,13 @@ func sendFromXRPLToCoreum( // send evidences from relayers for _, relayer := range relayers { - txRes, err := contractClient.SendXRPLToCoreumTransferEvidence(ctx, relayer.CoreumAddress, xrplToCoreumTransferEvidence) + txRes, err := contractClient.SendXRPLToCoreumTransferEvidence( + ctx, relayer.CoreumAddress, xrplToCoreumTransferEvidence, + ) require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) if thresholdReached == strconv.FormatBool(true) { break @@ -2681,9 +2967,13 @@ func sendFromCoreumToXRPL( // send evidences from relayers for _, relayer := range relayers { - txRes, err := contractClient.SendCoreumToXRPLTransferTransactionResultEvidence(ctx, relayer.CoreumAddress, acceptedTxEvidence) + txRes, err := contractClient.SendCoreumToXRPLTransferTransactionResultEvidence( + ctx, relayer.CoreumAddress, acceptedTxEvidence, + ) require.NoError(t, err) - thresholdReached, err := event.FindStringEventAttribute(txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached) + thresholdReached, err := event.FindStringEventAttribute( + txRes.Events, wasmtypes.ModuleName, eventAttributeThresholdReached, + ) require.NoError(t, err) if thresholdReached == strconv.FormatBool(true) { break @@ -2691,7 +2981,9 @@ func sendFromCoreumToXRPL( } } -func genRelayers(ctx context.Context, t *testing.T, chains integrationtests.Chains, relayersCount int) []coreum.Relayer { +func genRelayers( + ctx context.Context, t *testing.T, chains integrationtests.Chains, relayersCount int, +) []coreum.Relayer { relayers := make([]coreum.Relayer, 0) for i := 0; i < relayersCount; i++ { diff --git a/integration-tests/init.go b/integration-tests/init.go index 6fbbd42a..0bd32e4f 100644 --- a/integration-tests/init.go +++ b/integration-tests/init.go @@ -31,6 +31,7 @@ type Chains struct { Log logger.Logger } +//nolint:lll // breaking down cli flags will make it less readable. func init() { flag.StringVar(&coreumCfg.GRPCAddress, "coreum-grpc-address", "localhost:9090", "GRPC address of cored node started by coreum") flag.StringVar(&coreumCfg.FundingMnemonic, "coreum-funding-mnemonic", "sad hobby filter tray ordinary gap half web cat hard call mystery describe member round trend friend beyond such clap frozen segment fan mistake", "Funding coreum account mnemonic required by tests") diff --git a/integration-tests/processes/env_test.go b/integration-tests/processes/env_test.go index 4eae4260..26f92b11 100644 --- a/integration-tests/processes/env_test.go +++ b/integration-tests/processes/env_test.go @@ -241,7 +241,9 @@ func (r *RunnerEnv) AllocateTickets( require.NoError(t, err) r.Chains.XRPL.FundAccountForTicketAllocation(ctx, t, r.bridgeXRPLAddress, numberOfTicketsToAllocate) - _, err = r.ContractClient.RecoverTickets(ctx, r.ContractOwner, *bridgeXRPLAccountInfo.AccountData.Sequence, &numberOfTicketsToAllocate) + _, err = r.ContractClient.RecoverTickets( + ctx, r.ContractOwner, *bridgeXRPLAccountInfo.AccountData.Sequence, &numberOfTicketsToAllocate, + ) require.NoError(t, err) require.NoError(t, err) @@ -263,11 +265,20 @@ func (r *RunnerEnv) RegisterXRPLOriginatedToken( r.Chains.Coreum.FundAccountWithOptions(ctx, t, r.ContractOwner, coreumintegration.BalancesOptions{ Amount: r.Chains.Coreum.QueryAssetFTParams(ctx, t).IssueFee.Amount, }) - _, err := r.ContractClient.RegisterXRPLToken(ctx, r.ContractOwner, issuer.String(), xrpl.ConvertCurrencyToString(currency), sendingPrecision, maxHoldingAmount) + _, err := r.ContractClient.RegisterXRPLToken( + ctx, + r.ContractOwner, + issuer.String(), + xrpl.ConvertCurrencyToString(currency), + sendingPrecision, + maxHoldingAmount, + ) require.NoError(t, err) // await for the trust set r.AwaitNoPendingOperations(ctx, t) - registeredXRPLToken, err := r.ContractClient.GetXRPLTokenByIssuerAndCurrency(ctx, issuer.String(), xrpl.ConvertCurrencyToString(currency)) + registeredXRPLToken, err := r.ContractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, issuer.String(), xrpl.ConvertCurrencyToString(currency), + ) require.NoError(t, err) require.Equal(t, coreum.TokenStateEnabled, registeredXRPLToken.State) diff --git a/integration-tests/processes/send_test.go b/integration-tests/processes/send_test.go index 35522674..a67cc366 100644 --- a/integration-tests/processes/send_test.go +++ b/integration-tests/processes/send_test.go @@ -48,7 +48,14 @@ func TestSendXRPLOriginatedTokensFromXRPLToCoreumAndBack(t *testing.T) { xrplIssuerAddress := chains.XRPL.GenAccount(ctx, t, 1) // enable to be able to send to any address runnerEnv.EnableXRPLAccountRippling(ctx, t, xrplIssuerAddress) - registeredXRPLToken := runnerEnv.RegisterXRPLOriginatedToken(ctx, t, xrplIssuerAddress, registeredXRPLCurrency, int32(6), integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30)) + registeredXRPLToken := runnerEnv.RegisterXRPLOriginatedToken( + ctx, + t, + xrplIssuerAddress, + registeredXRPLCurrency, + int32(6), + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30), + ) valueToSendFromXRPLtoCoreum, err := rippledata.NewValue("1e10", false) require.NoError(t, err) @@ -61,29 +68,66 @@ func TestSendXRPLOriginatedTokensFromXRPLToCoreumAndBack(t *testing.T) { require.NoError(t, err) runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, amountToSendFromXRPLtoCoreum, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumSender, sdk.NewCoin(registeredXRPLToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumSender, + sdk.NewCoin( + registeredXRPLToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt( + t, + valueToSendFromXRPLtoCoreum.String(), + xrpl.XRPLIssuedTokenDecimals, + ), + ), + ) // send the full amount in 4 transactions to XRPL - amountToSend := integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals).QuoRaw(4) + amountToSend := integrationtests.ConvertStringWithDecimalsToSDKInt( + t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals, + ).QuoRaw(4) // send 2 transactions without the trust set to be reverted // TODO(dzmitryhil) update assertion once we add the final tx revert/recovery - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) // send TrustSet to be able to receive coins runnerEnv.SendXRPLMaxTrustSetTx(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) - balance := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) + balance := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency, + ) require.Equal(t, "5000000000", balance.Value.String()) } @@ -108,7 +152,9 @@ func TestSendXRPTokenFromXRPLToCoreumAndBack(t *testing.T) { xrplSenderAddress := chains.XRPL.GenAccount(ctx, t, 2.2) t.Logf("XRPL sender: %s", xrplSenderAddress.String()) - registeredXRPToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrpl.XRPTokenIssuer.String(), xrpl.XRPTokenCurrency.String()) + registeredXRPToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, xrpl.XRPTokenIssuer.String(), xrpl.XRPTokenCurrency.String(), + ) require.NoError(t, err) valueToSendFromXRPLtoCoreum, err := rippledata.NewValue("2.111111", true) @@ -122,9 +168,23 @@ func TestSendXRPTokenFromXRPLToCoreumAndBack(t *testing.T) { require.NoError(t, err) runnerEnv.SendXRPLPaymentTx(ctx, t, xrplSenderAddress, runnerEnv.bridgeXRPLAddress, amountToSendFromXRPLtoCoreum, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumSender, sdk.NewCoin(registeredXRPToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPCurrencyDecimals))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumSender, + sdk.NewCoin( + registeredXRPToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt( + t, + valueToSendFromXRPLtoCoreum.String(), + xrpl.XRPCurrencyDecimals, + )), + ) - xrplRecipientBalanceBefore := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, xrpl.XRPTokenIssuer, xrpl.XRPTokenCurrency) + xrplRecipientBalanceBefore := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, xrpl.XRPTokenIssuer, xrpl.XRPTokenCurrency, + ) for _, v := range []string{"1.1", "0.5", "0.51111", "0.000001"} { _, err = runnerEnv.ContractClient.SendToXRPL( @@ -144,7 +204,9 @@ func TestSendXRPTokenFromXRPLToCoreumAndBack(t *testing.T) { runnerEnv.AwaitNoPendingOperations(ctx, t) - xrplRecipientBalanceAfter := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, xrpl.XRPTokenIssuer, xrpl.XRPTokenCurrency) + xrplRecipientBalanceAfter := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, xrpl.XRPTokenIssuer, xrpl.XRPTokenCurrency, + ) received, err := xrplRecipientBalanceAfter.Value.Subtract(*xrplRecipientBalanceBefore.Value) require.NoError(t, err) require.Equal(t, valueToSendFromXRPLtoCoreum.String(), received.String()) @@ -176,7 +238,14 @@ func TestSendXRPLOriginatedTokenFromXRPLToCoreumWithMaliciousRelayer(t *testing. xrplIssuerAddress := chains.XRPL.GenAccount(ctx, t, 1) // enable to be able to send to any address runnerEnv.EnableXRPLAccountRippling(ctx, t, xrplIssuerAddress) - registeredXRPLToken := runnerEnv.RegisterXRPLOriginatedToken(ctx, t, xrplIssuerAddress, registeredXRPLCurrency, int32(6), integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30)) + registeredXRPLToken := runnerEnv.RegisterXRPLOriginatedToken( + ctx, + t, + xrplIssuerAddress, + registeredXRPLCurrency, + int32(6), + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30), + ) valueToSendFromXRPLtoCoreum, err := rippledata.NewValue("1e10", false) require.NoError(t, err) @@ -189,17 +258,39 @@ func TestSendXRPLOriginatedTokenFromXRPLToCoreumWithMaliciousRelayer(t *testing. require.NoError(t, err) runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, amountToSendFromXRPLtoCoreum, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumSender, sdk.NewCoin(registeredXRPLToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumSender, + sdk.NewCoin( + registeredXRPLToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt( + t, + valueToSendFromXRPLtoCoreum.String(), + xrpl.XRPLIssuedTokenDecimals, + ), + ), + ) // send TrustSet to be able to receive coins runnerEnv.SendXRPLMaxTrustSetTx(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) - amountToSend := integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals).QuoRaw(4) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend)) + amountToSend := integrationtests.ConvertStringWithDecimalsToSDKInt( + t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals, + ).QuoRaw(4) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) - balance := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) + balance := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency, + ) require.Equal(t, "2500000000", balance.Value.String()) } @@ -230,7 +321,14 @@ func TestSendXRPLOriginatedTokenFromXRPLToCoreumWithTicketsReallocation(t *testi xrplIssuerAddress := chains.XRPL.GenAccount(ctx, t, 1) // enable to be able to send to any address runnerEnv.EnableXRPLAccountRippling(ctx, t, xrplIssuerAddress) - registeredXRPLToken := runnerEnv.RegisterXRPLOriginatedToken(ctx, t, xrplIssuerAddress, registeredXRPLCurrency, int32(6), integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30)) + registeredXRPLToken := runnerEnv.RegisterXRPLOriginatedToken( + ctx, + t, + xrplIssuerAddress, + registeredXRPLCurrency, + int32(6), + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30), + ) valueToSendFromXRPLtoCoreum, err := rippledata.NewValue("1e10", false) require.NoError(t, err) @@ -243,7 +341,20 @@ func TestSendXRPLOriginatedTokenFromXRPLToCoreumWithTicketsReallocation(t *testi require.NoError(t, err) runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, amountToSendFromXRPLtoCoreum, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumSender, sdk.NewCoin(registeredXRPLToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumSender, + sdk.NewCoin( + registeredXRPLToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt( + t, + valueToSendFromXRPLtoCoreum.String(), + xrpl.XRPLIssuedTokenDecimals, + ), + ), + ) // send TrustSet to be able to receive coins runnerEnv.SendXRPLMaxTrustSetTx(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) @@ -253,7 +364,12 @@ func TestSendXRPLOriginatedTokenFromXRPLToCoreumWithTicketsReallocation(t *testi for i := 0; i < sendingCount; i++ { retryCtx, retryCtxCancel := context.WithTimeout(ctx, 15*time.Second) require.NoError(t, retry.Do(retryCtx, 500*time.Millisecond, func() error { - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredXRPLToken.CoreumDenom, amountToSend), + ) if err == nil { return nil } @@ -269,8 +385,18 @@ func TestSendXRPLOriginatedTokenFromXRPLToCoreumWithTicketsReallocation(t *testi } runnerEnv.AwaitNoPendingOperations(ctx, t) - balance := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) - require.Equal(t, totalSent.Quo(sdkmath.NewIntWithDecimal(1, xrpl.XRPLIssuedTokenDecimals)).String(), balance.Value.String()) + balance := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, + t, + xrplRecipientAddress, + xrplIssuerAddress, + registeredXRPLCurrency, + ) + require.Equal( + t, + totalSent.Quo(sdkmath.NewIntWithDecimal(1, xrpl.XRPLIssuedTokenDecimals)).String(), + balance.Value.String(), + ) } func TestSendXRPLOriginatedTokensFromXRPLToCoreumWithDifferentAmountAndPartialAmount(t *testing.T) { @@ -309,21 +435,39 @@ func TestSendXRPLOriginatedTokensFromXRPLToCoreumWithDifferentAmountAndPartialAm runnerEnv.AllocateTickets(ctx, t, 200) // register XRPL originated token with 3 chars - _, err = runnerEnv.ContractClient.RegisterXRPLToken(ctx, runnerEnv.ContractOwner, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency), sendingPrecision, maxHoldingAmount) + _, err = runnerEnv.ContractClient.RegisterXRPLToken( + ctx, + runnerEnv.ContractOwner, + xrplIssuerAddress.String(), + xrpl.ConvertCurrencyToString(registeredXRPLCurrency), + sendingPrecision, + maxHoldingAmount, + ) require.NoError(t, err) // register XRPL originated token with 20 chars - _, err = runnerEnv.ContractClient.RegisterXRPLToken(ctx, runnerEnv.ContractOwner, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLHexCurrency), sendingPrecision, maxHoldingAmount) + _, err = runnerEnv.ContractClient.RegisterXRPLToken( + ctx, + runnerEnv.ContractOwner, + xrplIssuerAddress.String(), + xrpl.ConvertCurrencyToString(registeredXRPLHexCurrency), + sendingPrecision, + maxHoldingAmount, + ) require.NoError(t, err) // await for the trust set runnerEnv.AwaitNoPendingOperations(ctx, t) - registeredXRPLToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency)) + registeredXRPLToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency), + ) require.NoError(t, err) require.Equal(t, coreum.TokenStateEnabled, registeredXRPLToken.State) - registeredXRPLHexCurrencyToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLHexCurrency)) + registeredXRPLHexCurrencyToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLHexCurrency), + ) require.NoError(t, err) require.Equal(t, coreum.TokenStateEnabled, registeredXRPLHexCurrencyToken.State) @@ -355,19 +499,59 @@ func TestSendXRPLOriginatedTokensFromXRPLToCoreumWithDifferentAmountAndPartialAm require.NoError(t, err) // incorrect memo - runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, maxDecimalsRegisterCurrencyAmount, rippledata.Memo{}) + runnerEnv.SendXRPLPaymentTx( + ctx, + t, + xrplIssuerAddress, + runnerEnv.bridgeXRPLAddress, + maxDecimalsRegisterCurrencyAmount, + rippledata.Memo{}, + ) // send tx with partial payment - runnerEnv.SendXRPLPartialPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, highValueRegisteredCurrencyAmount, maxDecimalsRegisterCurrencyAmount, memo) + runnerEnv.SendXRPLPartialPaymentTx( + ctx, + t, + xrplIssuerAddress, + runnerEnv.bridgeXRPLAddress, + highValueRegisteredCurrencyAmount, + maxDecimalsRegisterCurrencyAmount, + memo, + ) // send tx with high amount - runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, highValueRegisteredCurrencyAmount, memo) + runnerEnv.SendXRPLPaymentTx( + ctx, + t, + xrplIssuerAddress, + runnerEnv.bridgeXRPLAddress, + highValueRegisteredCurrencyAmount, + memo, + ) // send tx with hex currency runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, registeredHexCurrencyAmount, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumRecipient, sdk.NewCoin(registeredXRPLToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, "100001.000001", xrpl.XRPLIssuedTokenDecimals))) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumRecipient, sdk.NewCoin(registeredXRPLHexCurrencyToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, "9.9", xrpl.XRPLIssuedTokenDecimals))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumRecipient, + sdk.NewCoin( + registeredXRPLToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "100001.000001", xrpl.XRPLIssuedTokenDecimals), + ), + ) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumRecipient, + sdk.NewCoin( + registeredXRPLHexCurrencyToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "9.9", xrpl.XRPLIssuedTokenDecimals), + ), + ) } func TestRecoverXRPLOriginatedTokenRegistrationAndSendFromXRPLToCoreumAndBack(t *testing.T) { @@ -399,21 +583,34 @@ func TestRecoverXRPLOriginatedTokenRegistrationAndSendFromXRPLToCoreumAndBack(t // gen account but don't fund it to let the tx to fail since the account won't exist on the XRPL side xrplIssuerAddress := chains.XRPL.GenEmptyAccount(t) - _, err = runnerEnv.ContractClient.RegisterXRPLToken(ctx, runnerEnv.ContractOwner, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency), int32(6), integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30)) + _, err = runnerEnv.ContractClient.RegisterXRPLToken( + ctx, + runnerEnv.ContractOwner, + xrplIssuerAddress.String(), + xrpl.ConvertCurrencyToString(registeredXRPLCurrency), + int32(6), + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) - registeredXRPLToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency)) + registeredXRPLToken, err := runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency), + ) require.NoError(t, err) require.Equal(t, coreum.TokenStateInactive, registeredXRPLToken.State) // create the account on the XRPL and send some XRP on top to cover fees runnerEnv.Chains.XRPL.CreateAccount(ctx, t, xrplIssuerAddress, 1) // recover from owner - _, err = runnerEnv.ContractClient.RecoverXRPLTokenRegistration(ctx, runnerEnv.ContractOwner, xrplIssuerAddress.String(), registeredXRPLCurrency.String()) + _, err = runnerEnv.ContractClient.RecoverXRPLTokenRegistration( + ctx, runnerEnv.ContractOwner, xrplIssuerAddress.String(), registeredXRPLCurrency.String(), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) // now the token is enabled - registeredXRPLToken, err = runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency(ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency)) + registeredXRPLToken, err = runnerEnv.ContractClient.GetXRPLTokenByIssuerAndCurrency( + ctx, xrplIssuerAddress.String(), xrpl.ConvertCurrencyToString(registeredXRPLCurrency), + ) require.NoError(t, err) require.Equal(t, coreum.TokenStateEnabled, registeredXRPLToken.State) @@ -431,16 +628,46 @@ func TestRecoverXRPLOriginatedTokenRegistrationAndSendFromXRPLToCoreumAndBack(t require.NoError(t, err) runnerEnv.SendXRPLPaymentTx(ctx, t, xrplIssuerAddress, runnerEnv.bridgeXRPLAddress, amountToSendFromXRPLtoCoreum, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumSender, sdk.NewCoin(registeredXRPLToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumSender, + sdk.NewCoin( + registeredXRPLToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt( + t, + valueToSendFromXRPLtoCoreum.String(), + xrpl.XRPLIssuedTokenDecimals, + ), + ), + ) // send TrustSet to be able to receive coins runnerEnv.SendXRPLMaxTrustSetTx(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSender, xrplRecipientAddress.String(), sdk.NewCoin(registeredXRPLToken.CoreumDenom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, valueToSendFromXRPLtoCoreum.String(), xrpl.XRPLIssuedTokenDecimals))) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSender, + xrplRecipientAddress.String(), + sdk.NewCoin( + registeredXRPLToken.CoreumDenom, + integrationtests.ConvertStringWithDecimalsToSDKInt( + t, + valueToSendFromXRPLtoCoreum.String(), + xrpl.XRPLIssuedTokenDecimals), + ), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) - balance := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, xrplIssuerAddress, registeredXRPLCurrency) + balance := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, + t, + xrplRecipientAddress, + xrplIssuerAddress, + registeredXRPLCurrency, + ) require.Equal(t, valueToSendFromXRPLtoCoreum.String(), balance.Value.String()) } @@ -492,7 +719,9 @@ func TestSendCoreumOriginatedTokenFromCoreumToXRPLAndBackWithDifferentAmountsAnd // register Coreum originated token require.NoError(t, err) denom := assetfttypes.BuildDenom(issueMsg.Subunit, coreumSenderAddress) - _, err = runnerEnv.ContractClient.RegisterCoreumToken(ctx, runnerEnv.ContractOwner, denom, tokenDecimals, sendingPrecision, maxHoldingAmount) + _, err = runnerEnv.ContractClient.RegisterCoreumToken( + ctx, runnerEnv.ContractOwner, denom, tokenDecimals, sendingPrecision, maxHoldingAmount, + ) require.NoError(t, err) registeredCoreumOriginatedToken, err := runnerEnv.ContractClient.GetCoreumTokenByDenom(ctx, denom) require.NoError(t, err) @@ -505,24 +734,38 @@ func TestSendCoreumOriginatedTokenFromCoreumToXRPLAndBackWithDifferentAmountsAnd // equal to 11.1111 on XRPL, but with the sending prec 2 we expect 11.11 to be received amountToSendToXRPL1 := sdkmath.NewInt(111111) // TODO(dzmitryhil) update assertion once we add the final tx revert/recovery - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken.Denom, amountToSendToXRPL1)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken.Denom, amountToSendToXRPL1), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) // check the XRPL recipient balance - balance := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency) + balance := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency, + ) require.Equal(t, "11.11", balance.Value.String()) amountToSendToXRPL2 := maxHoldingAmount.QuoRaw(2) require.NoError(t, err) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken.Denom, amountToSendToXRPL2)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken.Denom, amountToSendToXRPL2), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) // check the XRPL recipient balance - balance = runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency) + balance = runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency, + ) require.Equal(t, "50000000001111e-2", balance.Value.String()) // now start sending from XRPL to coreum, coreum originated token @@ -556,15 +799,46 @@ func TestSendCoreumOriginatedTokenFromCoreumToXRPLAndBackWithDifferentAmountsAnd require.NoError(t, err) // send tx with partial payment - runnerEnv.SendXRPLPartialPaymentTx(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, highValueRegisteredCurrencyAmount, currencyAmountWithTruncation, memo) + runnerEnv.SendXRPLPartialPaymentTx( + ctx, + t, + xrplRecipientAddress, + runnerEnv.bridgeXRPLAddress, + highValueRegisteredCurrencyAmount, + currencyAmountWithTruncation, + memo, + ) // send tx with high amount - runnerEnv.SendXRPLPaymentTx(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, highValueRegisteredCurrencyAmount, memo) + runnerEnv.SendXRPLPaymentTx( + ctx, + t, + xrplRecipientAddress, + runnerEnv.bridgeXRPLAddress, + highValueRegisteredCurrencyAmount, + memo, + ) // send tx with hex currency - runnerEnv.SendXRPLPaymentTx(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, registeredHexCurrencyAmount, memo) + runnerEnv.SendXRPLPaymentTx( + ctx, + t, + xrplRecipientAddress, + runnerEnv.bridgeXRPLAddress, + registeredHexCurrencyAmount, + memo, + ) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumRecipientAddress, sdk.NewCoin(registeredCoreumOriginatedToken.Denom, integrationtests.ConvertStringWithDecimalsToSDKInt(t, "100011.01", int64(tokenDecimals)))) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumRecipientAddress, + sdk.NewCoin( + registeredCoreumOriginatedToken.Denom, + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "100011.01", int64(tokenDecimals)), + ), + ) } func TestSendCoreumOriginatedTokenFromCoreumToXRPLAndBackWithMaliciousRelayer(t *testing.T) { @@ -616,7 +890,9 @@ func TestSendCoreumOriginatedTokenFromCoreumToXRPLAndBackWithMaliciousRelayer(t // register Coreum originated token require.NoError(t, err) denom := assetfttypes.BuildDenom(issueMsg.Subunit, coreumSenderAddress) - _, err = runnerEnv.ContractClient.RegisterCoreumToken(ctx, runnerEnv.ContractOwner, denom, tokenDecimals, sendingPrecision, maxHoldingAmount) + _, err = runnerEnv.ContractClient.RegisterCoreumToken( + ctx, runnerEnv.ContractOwner, denom, tokenDecimals, sendingPrecision, maxHoldingAmount, + ) require.NoError(t, err) registeredCoreumOriginatedToken, err := runnerEnv.ContractClient.GetCoreumTokenByDenom(ctx, denom) require.NoError(t, err) @@ -627,18 +903,33 @@ func TestSendCoreumOriginatedTokenFromCoreumToXRPLAndBackWithMaliciousRelayer(t runnerEnv.SendXRPLMaxTrustSetTx(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency) amountToSendToXRPL := sdkmath.NewInt(9999999) - _, err = runnerEnv.ContractClient.SendToXRPL(ctx, coreumSenderAddress, xrplRecipientAddress.String(), sdk.NewCoin(registeredCoreumOriginatedToken.Denom, amountToSendToXRPL)) + _, err = runnerEnv.ContractClient.SendToXRPL( + ctx, + coreumSenderAddress, + xrplRecipientAddress.String(), + sdk.NewCoin(registeredCoreumOriginatedToken.Denom, amountToSendToXRPL), + ) require.NoError(t, err) runnerEnv.AwaitNoPendingOperations(ctx, t) // check the XRPL recipient balance - balance := runnerEnv.Chains.XRPL.GetAccountBalance(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency) + balance := runnerEnv.Chains.XRPL.GetAccountBalance( + ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, xrplCurrency, + ) require.Equal(t, "0.0009", balance.Value.String()) // send the full amount back memo, err := xrpl.EncodeCoreumRecipientToMemo(coreumRecipientAddress) require.NoError(t, err) - runnerEnv.SendXRPLPaymentTx(ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, balance, memo) - runnerEnv.AwaitCoreumBalance(ctx, t, chains.Coreum, coreumRecipientAddress, sdk.NewCoin(registeredCoreumOriginatedToken.Denom, sdk.NewInt(9000000))) + runnerEnv.SendXRPLPaymentTx( + ctx, t, xrplRecipientAddress, runnerEnv.bridgeXRPLAddress, balance, memo, + ) + runnerEnv.AwaitCoreumBalance( + ctx, + t, + chains.Coreum, + coreumRecipientAddress, + sdk.NewCoin(registeredCoreumOriginatedToken.Denom, sdk.NewInt(9000000)), + ) } diff --git a/integration-tests/processes/ticket_allocation_test.go b/integration-tests/processes/ticket_allocation_test.go index 3168cb8c..76eb6595 100644 --- a/integration-tests/processes/ticket_allocation_test.go +++ b/integration-tests/processes/ticket_allocation_test.go @@ -199,13 +199,21 @@ func TestTicketsReAllocationByTheXRPLTokenRegistration(t *testing.T) { numberOfXRPLTokensToRegister := envCfg.UsedTicketSequenceThreshold + 1 // fund owner to cover asset FT issuance fees chains.Coreum.FundAccountWithOptions(ctx, t, runnerEnv.ContractOwner, coreumintegration.BalancesOptions{ - Amount: chains.Coreum.QueryAssetFTParams(ctx, t).IssueFee.Amount.MulRaw(int64(numberOfXRPLTokensToRegister)).MulRaw(2), + Amount: chains.Coreum.QueryAssetFTParams(ctx, t).IssueFee.Amount. + MulRaw(int64(numberOfXRPLTokensToRegister)).MulRaw(2), }) for i := 0; i < numberOfXRPLTokensToRegister; i++ { registeredXRPLCurrency, err := rippledata.NewCurrency(fmt.Sprintf("CR%d", i)) require.NoError(t, err) - runnerEnv.RegisterXRPLOriginatedToken(ctx, t, xrplCurrencyIssuerAcc, registeredXRPLCurrency, int32(6), integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30)) + runnerEnv.RegisterXRPLOriginatedToken( + ctx, + t, + xrplCurrencyIssuerAcc, + registeredXRPLCurrency, + int32(6), + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30), + ) } runnerEnv.AwaitNoPendingOperations(ctx, t) @@ -219,7 +227,14 @@ func TestTicketsReAllocationByTheXRPLTokenRegistration(t *testing.T) { for i := 0; i < numberOfXRPLTokensToRegister; i++ { registeredXRPLCurrency, err := rippledata.NewCurrency(fmt.Sprintf("DR%d", i)) require.NoError(t, err) - runnerEnv.RegisterXRPLOriginatedToken(ctx, t, xrplCurrencyIssuerAcc, registeredXRPLCurrency, int32(6), integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30)) + runnerEnv.RegisterXRPLOriginatedToken( + ctx, + t, + xrplCurrencyIssuerAcc, + registeredXRPLCurrency, + int32(6), + integrationtests.ConvertStringWithDecimalsToSDKInt(t, "1", 30), + ) } runnerEnv.AwaitNoPendingOperations(ctx, t) availableTicketsAfterSecondReallocation, err := runnerEnv.ContractClient.GetAvailableTickets(ctx) diff --git a/integration-tests/xrpl.go b/integration-tests/xrpl.go index 2be50068..2a74cee8 100644 --- a/integration-tests/xrpl.go +++ b/integration-tests/xrpl.go @@ -158,12 +158,16 @@ func (c XRPLChain) ActivateAccount(ctx context.Context, t *testing.T, acc ripple } // FundAccountForTicketAllocation funds the provided account with the amount required for the ticket allocation. -func (c XRPLChain) FundAccountForTicketAllocation(ctx context.Context, t *testing.T, acc rippledata.Account, ticketsNumber uint32) { +func (c XRPLChain) FundAccountForTicketAllocation( + ctx context.Context, t *testing.T, acc rippledata.Account, ticketsNumber uint32, +) { c.FundAccount(ctx, t, acc, xrplReservePerTicket*float64(ticketsNumber)) } // FundAccountForSignerListSet funds the provided account with the amount required for the multi-signing set. -func (c XRPLChain) FundAccountForSignerListSet(ctx context.Context, t *testing.T, acc rippledata.Account, singersCount int) { +func (c XRPLChain) FundAccountForSignerListSet( + ctx context.Context, t *testing.T, acc rippledata.Account, singersCount int, +) { c.FundAccount(ctx, t, acc, xrplReservePerSigner*float64(singersCount)) } @@ -195,7 +199,9 @@ func (c XRPLChain) FundAccount(ctx context.Context, t *testing.T, acc rippledata } // AutoFillSignAndSubmitTx autofills the transaction and submits it. -func (c XRPLChain) AutoFillSignAndSubmitTx(ctx context.Context, t *testing.T, tx rippledata.Transaction, acc rippledata.Account) error { +func (c XRPLChain) AutoFillSignAndSubmitTx( + ctx context.Context, t *testing.T, tx rippledata.Transaction, acc rippledata.Account, +) error { t.Helper() c.AutoFillTx(ctx, t, tx, acc) @@ -212,7 +218,9 @@ func (c XRPLChain) Multisign(t *testing.T, tx rippledata.MultiSignable, acc ripp } // SignAndSubmitTx signs the transaction from the signer and submits it. -func (c XRPLChain) SignAndSubmitTx(ctx context.Context, t *testing.T, tx rippledata.Transaction, acc rippledata.Account) error { +func (c XRPLChain) SignAndSubmitTx( + ctx context.Context, t *testing.T, tx rippledata.Transaction, acc rippledata.Account, +) error { t.Helper() require.NoError(t, c.signer.Sign(tx, acc.String())) @@ -268,7 +276,9 @@ func (c XRPLChain) SubmitTx(ctx context.Context, t *testing.T, tx rippledata.Tra } // GetAccountBalance returns account balance for the provided issuer and currency. -func (c XRPLChain) GetAccountBalance(ctx context.Context, t *testing.T, account, issuer rippledata.Account, currency rippledata.Currency) rippledata.Amount { +func (c XRPLChain) GetAccountBalance( + ctx context.Context, t *testing.T, account, issuer rippledata.Account, currency rippledata.Currency, +) rippledata.Amount { balance, ok := c.GetAccountBalances(ctx, t, account)[fmt.Sprintf("%s/%s", currency.String(), issuer.String())] if !ok { // equal to zero @@ -282,7 +292,9 @@ func (c XRPLChain) GetAccountBalance(ctx context.Context, t *testing.T, account, } // GetAccountBalances returns account balances. -func (c XRPLChain) GetAccountBalances(ctx context.Context, t *testing.T, acc rippledata.Account) map[string]rippledata.Amount { +func (c XRPLChain) GetAccountBalances( + ctx context.Context, t *testing.T, acc rippledata.Account, +) map[string]rippledata.Amount { t.Helper() amounts := make(map[string]rippledata.Amount, 0) @@ -324,7 +336,11 @@ func (c XRPLChain) AwaitLedger(ctx context.Context, t *testing.T, ledgerIndex in } if res.LedgerCurrentIndex < ledgerIndex { - return retry.Retryable(errors.Errorf("ledger has not passed, current:%d, expected:%d", res.LedgerCurrentIndex, ledgerIndex)) + return retry.Retryable(errors.Errorf( + "ledger has not passed, current:%d, expected:%d", + res.LedgerCurrentIndex, + ledgerIndex, + )) } return nil diff --git a/integration-tests/xrpl/rpc_test.go b/integration-tests/xrpl/rpc_test.go index 6bf9ec0a..686a61d0 100644 --- a/integration-tests/xrpl/rpc_test.go +++ b/integration-tests/xrpl/rpc_test.go @@ -148,12 +148,22 @@ func TestMultisigPayment(t *testing.T) { t.Logf("TwoSignersHash/ThreeSignersHash: %s/%s", xrpPaymentTxTwoSigners.Hash, xrpPaymentTxThreeSigners.Hash) require.NotEqual(t, xrpPaymentTxTwoSigners.Hash.String(), xrpPaymentTxThreeSigners.Hash.String()) - t.Logf("Recipinet account balance before: %s", chains.XRPL.GetAccountBalances(ctx, t, xrpPaymentTxTwoSigners.Destination)) + t.Logf( + "Recipinet account balance before: %s", + chains.XRPL.GetAccountBalances(ctx, t, xrpPaymentTxTwoSigners.Destination), + ) require.NoError(t, chains.XRPL.SubmitTx(ctx, t, &xrpPaymentTxTwoSigners)) - t.Logf("Recipinet account balance after: %s", chains.XRPL.GetAccountBalances(ctx, t, xrpPaymentTxTwoSigners.Destination)) + t.Logf( + "Recipinet account balance after: %s", + chains.XRPL.GetAccountBalances(ctx, t, xrpPaymentTxTwoSigners.Destination), + ) // try to submit with three signers (the transaction won't be accepted) - require.ErrorContains(t, chains.XRPL.SubmitTx(ctx, t, &xrpPaymentTxThreeSigners), "This sequence number has already passed") + require.ErrorContains( + t, + chains.XRPL.SubmitTx(ctx, t, &xrpPaymentTxThreeSigners), + "This sequence number has already passed", + ) } func TestCreateAndUseTicketForPaymentAndTicketsCreation(t *testing.T) { @@ -244,7 +254,11 @@ func TestCreateAndUseTicketForPaymentAndTicketsCreation(t *testing.T) { fooPaymentTx.TxBase.Sequence = 0 fooPaymentTx.TicketSequence = ticketForFailingTx // there is no trust set so the tx should fail and use the ticket - require.ErrorContains(t, chains.XRPL.SignAndSubmitTx(ctx, t, &fooPaymentTx, senderAcc), "Path could not send partial amount") + require.ErrorContains( + t, + chains.XRPL.SignAndSubmitTx(ctx, t, &fooPaymentTx, senderAcc), + "Path could not send partial amount", + ) // try to reuse the ticket for the success tx xrpPaymentTx = rippledata.Payment{ @@ -305,10 +319,14 @@ func TestCreateAndUseTicketForTicketsCreationWithMultisigning(t *testing.T) { createdTickets := integrationtests.ExtractTicketsFromMeta(txRes) require.Len(t, createdTickets, int(ticketsToCreate)) - createTicketsTx = buildCreateTicketsTxForMultiSigning(ctx, t, chains.XRPL, ticketsToCreate, 0, createdTickets[0].TicketSequence, multisigAcc) + createTicketsTx = buildCreateTicketsTxForMultiSigning( + ctx, t, chains.XRPL, ticketsToCreate, 0, createdTickets[0].TicketSequence, multisigAcc, + ) signer1 = chains.XRPL.Multisign(t, &createTicketsTx, signer1Acc) - createTicketsTx = buildCreateTicketsTxForMultiSigning(ctx, t, chains.XRPL, ticketsToCreate, 0, createdTickets[0].TicketSequence, multisigAcc) + createTicketsTx = buildCreateTicketsTxForMultiSigning( + ctx, t, chains.XRPL, ticketsToCreate, 0, createdTickets[0].TicketSequence, multisigAcc, + ) require.NoError(t, rippledata.SetSigners(&createTicketsTx, signer1)) require.NoError(t, chains.XRPL.SubmitTx(ctx, t, &createTicketsTx)) @@ -365,26 +383,42 @@ func TestCreateAndUseTicketForMultisigningKeysRotation(t *testing.T) { createdTickets := integrationtests.ExtractTicketsFromMeta(txRes) require.Len(t, createdTickets, int(ticketsToCreate)) - updateSignerListSetTx := buildUpdateSignerListSetTxForMultiSigning(ctx, t, chains.XRPL, signer2Acc, createdTickets[0].TicketSequence, multisigAcc) + updateSignerListSetTx := buildUpdateSignerListSetTxForMultiSigning( + ctx, t, chains.XRPL, signer2Acc, createdTickets[0].TicketSequence, multisigAcc, + ) signer1 = chains.XRPL.Multisign(t, &updateSignerListSetTx, signer1Acc) - updateSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning(ctx, t, chains.XRPL, signer2Acc, createdTickets[0].TicketSequence, multisigAcc) + updateSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning( + ctx, t, chains.XRPL, signer2Acc, createdTickets[0].TicketSequence, multisigAcc, + ) require.NoError(t, rippledata.SetSigners(&updateSignerListSetTx, signer1)) require.NoError(t, chains.XRPL.SubmitTx(ctx, t, &updateSignerListSetTx)) // try to sign and send with previous signer - restoreSignerListSetTx := buildUpdateSignerListSetTxForMultiSigning(ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc) + restoreSignerListSetTx := buildUpdateSignerListSetTxForMultiSigning( + ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc, + ) signer1 = chains.XRPL.Multisign(t, &restoreSignerListSetTx, signer1Acc) - restoreSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning(ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc) + restoreSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning( + ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc, + ) require.NoError(t, rippledata.SetSigners(&restoreSignerListSetTx, signer1)) - require.ErrorContains(t, chains.XRPL.SubmitTx(ctx, t, &restoreSignerListSetTx), "A signature is provided for a non-signer") + require.ErrorContains( + t, + chains.XRPL.SubmitTx(ctx, t, &restoreSignerListSetTx), + "A signature is provided for a non-signer", + ) // build and send with correct signer - restoreSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning(ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc) + restoreSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning( + ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc, + ) signer2 := chains.XRPL.Multisign(t, &restoreSignerListSetTx, signer2Acc) - restoreSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning(ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc) + restoreSignerListSetTx = buildUpdateSignerListSetTxForMultiSigning( + ctx, t, chains.XRPL, signer1Acc, createdTickets[1].TicketSequence, multisigAcc, + ) require.NoError(t, rippledata.SetSigners(&restoreSignerListSetTx, signer2)) require.NoError(t, chains.XRPL.SubmitTx(ctx, t, &restoreSignerListSetTx)) } @@ -438,7 +472,11 @@ func TestMultisigWithMasterKeyRemoval(t *testing.T) { t.Logf("The master key is disabled") // try to update signers one more time - require.ErrorContains(t, chains.XRPL.AutoFillSignAndSubmitTx(ctx, t, &signerListSetTx, multisigAccToDisable), "Master key is disabled") + require.ErrorContains( + t, + chains.XRPL.AutoFillSignAndSubmitTx(ctx, t, &signerListSetTx, multisigAccToDisable), + "Master key is disabled", + ) // now use multi-signing for the account xrpPaymentTx := buildXrpPaymentTxForMultiSigning(ctx, t, chains.XRPL, multisigAccToDisable, signer1Acc) @@ -532,9 +570,13 @@ func TestCreateAndUseUsedTicketAndSequencesWithMultisigning(t *testing.T) { // use ticket number as sequence number ticketSequence := createdTickets[0].TicketSequence - createTicketsTx = buildCreateTicketsTxForMultiSigning(ctx, t, chains.XRPL, ticketsToCreate, *ticketSequence, nil, multisigAcc) + createTicketsTx = buildCreateTicketsTxForMultiSigning( + ctx, t, chains.XRPL, ticketsToCreate, *ticketSequence, nil, multisigAcc, + ) signer1 = chains.XRPL.Multisign(t, &createTicketsTx, signer1Acc) - createTicketsTx = buildCreateTicketsTxForMultiSigning(ctx, t, chains.XRPL, ticketsToCreate, *ticketSequence, nil, multisigAcc) + createTicketsTx = buildCreateTicketsTxForMultiSigning( + ctx, t, chains.XRPL, ticketsToCreate, *ticketSequence, nil, multisigAcc, + ) require.NoError(t, rippledata.SetSigners(&createTicketsTx, signer1)) res, err = chains.XRPL.RPCClient().Submit(ctx, &createTicketsTx) require.NoError(t, err) @@ -546,9 +588,13 @@ func TestCreateAndUseUsedTicketAndSequencesWithMultisigning(t *testing.T) { multisigAccInfo, err = chains.XRPL.RPCClient().AccountInfo(ctx, multisigAcc) require.NoError(t, err) futureSeqNo := *multisigAccInfo.AccountData.Sequence + 10000 - createTicketsTx = buildCreateTicketsTxForMultiSigning(ctx, t, chains.XRPL, ticketsToCreate, futureSeqNo, nil, multisigAcc) + createTicketsTx = buildCreateTicketsTxForMultiSigning( + ctx, t, chains.XRPL, ticketsToCreate, futureSeqNo, nil, multisigAcc, + ) signer1 = chains.XRPL.Multisign(t, &createTicketsTx, signer1Acc) - createTicketsTx = buildCreateTicketsTxForMultiSigning(ctx, t, chains.XRPL, ticketsToCreate, futureSeqNo, nil, multisigAcc) + createTicketsTx = buildCreateTicketsTxForMultiSigning( + ctx, t, chains.XRPL, ticketsToCreate, futureSeqNo, nil, multisigAcc, + ) require.NoError(t, rippledata.SetSigners(&createTicketsTx, signer1)) res, err = chains.XRPL.RPCClient().Submit(ctx, &createTicketsTx) require.NoError(t, err) @@ -601,6 +647,7 @@ func TestXRPLHighLowAmountsPayments(t *testing.T) { ctx, chains := integrationtests.NewTestingContext(t) + //nolint:lll // breaking down test case string will make it less readable. tests := []struct { name string senderBalanceBefore string @@ -796,6 +843,7 @@ func TestXRPLHighLowAmountsPayments(t *testing.T) { senderBalanceAfter := getBalanceAccount(ctx, t, chains.XRPL, senderAcc, issuerAcc, currency) recipientBalanceAfter := getBalanceAccount(ctx, t, chains.XRPL, recipientAcc, issuerAcc, currency) + //nolint:lll // breaking down the log line will make it less redable. t.Logf( "Sender before: %s | Recipient before: %s | Sending amounts: %+v | Sender after: %s | Recipient after: %s | Delivered amount: %v", senderBalanceBefore, recipientBalanceBefore, tt.sendingAmounts, senderBalanceAfter, recipientBalanceAfter, deliveredAmounts, diff --git a/integration-tests/xrpl/scanner_test.go b/integration-tests/xrpl/scanner_test.go index a627e43d..844e18d0 100644 --- a/integration-tests/xrpl/scanner_test.go +++ b/integration-tests/xrpl/scanner_test.go @@ -144,7 +144,9 @@ func sendMultipleTxs( return writtenTxHashes } -func validateTxsHashesInChannel(ctx context.Context, t *testing.T, writtenTxHashes map[string]struct{}, txsCh chan rippledata.TransactionWithMetaData) { +func validateTxsHashesInChannel( + ctx context.Context, t *testing.T, writtenTxHashes map[string]struct{}, txsCh chan rippledata.TransactionWithMetaData, +) { scanCtx, scanCtxCancel := context.WithTimeout(ctx, time.Minute) defer scanCtxCancel() // copy the original map @@ -169,7 +171,9 @@ func validateTxsHashesInChannel(ctx context.Context, t *testing.T, writtenTxHash } } -func getTxHashesFromChannel(ctx context.Context, t *testing.T, txsCh chan rippledata.TransactionWithMetaData, count int) map[string]struct{} { +func getTxHashesFromChannel( + ctx context.Context, t *testing.T, txsCh chan rippledata.TransactionWithMetaData, count int, +) map[string]struct{} { scanCtx, scanCtxCancel := context.WithTimeout(ctx, time.Minute) defer scanCtxCancel() txHashes := make(map[string]struct{}, count) diff --git a/relayer/cmd/cli/cli.go b/relayer/cmd/cli/cli.go index f5312a9e..003068e3 100644 --- a/relayer/cmd/cli/cli.go +++ b/relayer/cmd/cli/cli.go @@ -137,8 +137,16 @@ func addHomeFlag(cmd *cobra.Command) { } func addKeyringFlags(cmd *cobra.Command) { - cmd.PersistentFlags().String(flags.FlagKeyringBackend, flags.DefaultKeyringBackend, "Select keyring's backend (os|file|kwallet|pass|test)") - cmd.PersistentFlags().String(flags.FlagKeyringDir, path.Join(DefaultHomeDir, "keys"), "The client Keyring directory; if omitted, the default 'home' directory will be used") + cmd.PersistentFlags().String( + flags.FlagKeyringBackend, + flags.DefaultKeyringBackend, + "Select keyring's backend (os|file|kwallet|pass|test)", + ) + cmd.PersistentFlags().String( + flags.FlagKeyringDir, + path.Join(DefaultHomeDir, "keys"), + "The client Keyring directory; if omitted, the default 'home' directory will be used", + ) } // returns the console logger initialised with the default logger config but with set `console` format. diff --git a/relayer/coreum/contract.go b/relayer/coreum/contract.go index 7a0bcab5..e4b04c6c 100644 --- a/relayer/coreum/contract.go +++ b/relayer/coreum/contract.go @@ -279,6 +279,7 @@ type xrplTransactionEvidenceTrustSetOperationResult struct { type xrplTransactionEvidenceCoreumToXRPLTransferOperationResult struct{} +//nolint:lll // breaking this down will make it less readable. type xrplTransactionEvidenceOperationResult struct { TicketsAllocation *xrplTransactionEvidenceTicketsAllocationOperationResult `json:"tickets_allocation,omitempty"` TrustSet *xrplTransactionEvidenceTrustSetOperationResult `json:"trust_set,omitempty"` @@ -370,7 +371,12 @@ func NewContractClient(cfg ContractClientConfig, log logger.Logger, clientCtx cl } // DeployAndInstantiate instantiates the contract. -func (c *ContractClient) DeployAndInstantiate(ctx context.Context, sender sdk.AccAddress, byteCode []byte, config InstantiationConfig) (sdk.AccAddress, error) { +func (c *ContractClient) DeployAndInstantiate( + ctx context.Context, + sender sdk.AccAddress, + byteCode []byte, + config InstantiationConfig, +) (sdk.AccAddress, error) { msgStoreCode := &wasmtypes.MsgStoreCode{ Sender: sender.String(), WASMByteCode: byteCode, @@ -420,7 +426,9 @@ func (c *ContractClient) DeployAndInstantiate(ctx context.Context, sender sdk.Ac return nil, errors.Wrap(err, "failed to deploy bytecode") } - contractAddr, err := event.FindStringEventAttribute(res.Events, wasmtypes.EventTypeInstantiate, wasmtypes.AttributeKeyContractAddr) + contractAddr, err := event.FindStringEventAttribute( + res.Events, wasmtypes.EventTypeInstantiate, wasmtypes.AttributeKeyContractAddr, + ) if err != nil { return nil, errors.Wrap(err, "failed to find contract address in the tx result") } @@ -458,7 +466,9 @@ func (c *ContractClient) IsInitialized() bool { // ******************** Execute ******************** // TransferOwnership executes `update_ownership` method with transfer action. -func (c *ContractClient) TransferOwnership(ctx context.Context, sender, newOwner sdk.AccAddress) (*sdk.TxResponse, error) { +func (c *ContractClient) TransferOwnership( + ctx context.Context, sender, newOwner sdk.AccAddress, +) (*sdk.TxResponse, error) { req := transferOwnershipRequest{} req.TransferOwnership.NewOwner = newOwner @@ -489,7 +499,14 @@ func (c *ContractClient) AcceptOwnership(ctx context.Context, sender sdk.AccAddr } // RegisterCoreumToken executes `register_coreum_token` method. -func (c *ContractClient) RegisterCoreumToken(ctx context.Context, sender sdk.AccAddress, denom string, decimals uint32, sendingPrecision int32, maxHoldingAmount sdkmath.Int) (*sdk.TxResponse, error) { +func (c *ContractClient) RegisterCoreumToken( + ctx context.Context, + sender sdk.AccAddress, + denom string, + decimals uint32, + sendingPrecision int32, + maxHoldingAmount sdkmath.Int, +) (*sdk.TxResponse, error) { txRes, err := c.execute(ctx, sender, execRequest{ Body: map[ExecMethod]registerCoreumTokenRequest{ ExecMethodRegisterCoreumToken: { @@ -508,7 +525,13 @@ func (c *ContractClient) RegisterCoreumToken(ctx context.Context, sender sdk.Acc } // RegisterXRPLToken executes `register_xrpl_token` method. -func (c *ContractClient) RegisterXRPLToken(ctx context.Context, sender sdk.AccAddress, issuer, currency string, sendingPrecision int32, maxHoldingAmount sdkmath.Int) (*sdk.TxResponse, error) { +func (c *ContractClient) RegisterXRPLToken( + ctx context.Context, + sender sdk.AccAddress, + issuer, currency string, + sendingPrecision int32, + maxHoldingAmount sdkmath.Int, +) (*sdk.TxResponse, error) { fee, err := c.queryAssetFTIssueFee(ctx) if err != nil { return nil, err @@ -533,7 +556,11 @@ func (c *ContractClient) RegisterXRPLToken(ctx context.Context, sender sdk.AccAd } // SendXRPLToCoreumTransferEvidence sends an Evidence of an accepted XRPL to coreum transfer transaction. -func (c *ContractClient) SendXRPLToCoreumTransferEvidence(ctx context.Context, sender sdk.AccAddress, evd XRPLToCoreumTransferEvidence) (*sdk.TxResponse, error) { +func (c *ContractClient) SendXRPLToCoreumTransferEvidence( + ctx context.Context, + sender sdk.AccAddress, + evd XRPLToCoreumTransferEvidence, +) (*sdk.TxResponse, error) { req := saveEvidenceRequest{ Evidence: evidence{ XRPLToCoreumTransfer: &evd, @@ -551,8 +578,13 @@ func (c *ContractClient) SendXRPLToCoreumTransferEvidence(ctx context.Context, s return txRes, nil } -// SendXRPLTicketsAllocationTransactionResultEvidence sends an Evidence of an accepted or rejected ticket allocation transaction. -func (c *ContractClient) SendXRPLTicketsAllocationTransactionResultEvidence(ctx context.Context, sender sdk.AccAddress, evd XRPLTransactionResultTicketsAllocationEvidence) (*sdk.TxResponse, error) { +// SendXRPLTicketsAllocationTransactionResultEvidence sends an Evidence of an accepted +// or rejected ticket allocation transaction. +func (c *ContractClient) SendXRPLTicketsAllocationTransactionResultEvidence( + ctx context.Context, + sender sdk.AccAddress, + evd XRPLTransactionResultTicketsAllocationEvidence, +) (*sdk.TxResponse, error) { req := saveEvidenceRequest{ Evidence: evidence{ XRPLTransactionResult: &xrplTransactionResultEvidence{ @@ -578,7 +610,11 @@ func (c *ContractClient) SendXRPLTicketsAllocationTransactionResultEvidence(ctx } // SendXRPLTrustSetTransactionResultEvidence sends an Evidence of an accepted or rejected trust set transaction. -func (c *ContractClient) SendXRPLTrustSetTransactionResultEvidence(ctx context.Context, sender sdk.AccAddress, evd XRPLTransactionResultTrustSetEvidence) (*sdk.TxResponse, error) { +func (c *ContractClient) SendXRPLTrustSetTransactionResultEvidence( + ctx context.Context, + sender sdk.AccAddress, + evd XRPLTransactionResultTrustSetEvidence, +) (*sdk.TxResponse, error) { req := saveEvidenceRequest{ Evidence: evidence{ XRPLTransactionResult: &xrplTransactionResultEvidence{ @@ -604,8 +640,13 @@ func (c *ContractClient) SendXRPLTrustSetTransactionResultEvidence(ctx context.C return txRes, nil } -// SendCoreumToXRPLTransferTransactionResultEvidence sends an Evidence of an accepted or rejected coreum to XRPL transfer transaction. -func (c *ContractClient) SendCoreumToXRPLTransferTransactionResultEvidence(ctx context.Context, sender sdk.AccAddress, evd XRPLTransactionResultCoreumToXRPLTransferEvidence) (*sdk.TxResponse, error) { +// SendCoreumToXRPLTransferTransactionResultEvidence sends an Evidence of an accepted or +// rejected coreum to XRPL transfer transaction. +func (c *ContractClient) SendCoreumToXRPLTransferTransactionResultEvidence( + ctx context.Context, + sender sdk.AccAddress, + evd XRPLTransactionResultCoreumToXRPLTransferEvidence, +) (*sdk.TxResponse, error) { req := saveEvidenceRequest{ Evidence: evidence{ XRPLTransactionResult: &xrplTransactionResultEvidence{ @@ -629,7 +670,12 @@ func (c *ContractClient) SendCoreumToXRPLTransferTransactionResultEvidence(ctx c } // RecoverTickets executes `recover_tickets` method. -func (c *ContractClient) RecoverTickets(ctx context.Context, sender sdk.AccAddress, accountSequence uint32, numberOfTickets *uint32) (*sdk.TxResponse, error) { +func (c *ContractClient) RecoverTickets( + ctx context.Context, + sender sdk.AccAddress, + accountSequence uint32, + numberOfTickets *uint32, +) (*sdk.TxResponse, error) { txRes, err := c.execute(ctx, sender, execRequest{ Body: map[ExecMethod]recoverTicketsRequest{ ExecMethodRecoverTickets: { @@ -646,7 +692,12 @@ func (c *ContractClient) RecoverTickets(ctx context.Context, sender sdk.AccAddre } // SaveSignature executes `save_signature` method. -func (c *ContractClient) SaveSignature(ctx context.Context, sender sdk.AccAddress, operationID uint32, signature string) (*sdk.TxResponse, error) { +func (c *ContractClient) SaveSignature( + ctx context.Context, + sender sdk.AccAddress, + operationID uint32, + signature string, +) (*sdk.TxResponse, error) { txRes, err := c.execute(ctx, sender, execRequest{ Body: map[ExecMethod]saveSignatureRequest{ ExecMethodSaveSignature: { @@ -663,7 +714,12 @@ func (c *ContractClient) SaveSignature(ctx context.Context, sender sdk.AccAddres } // SendToXRPL executes `send_to_xrpl` method. -func (c *ContractClient) SendToXRPL(ctx context.Context, sender sdk.AccAddress, recipient string, amount sdk.Coin) (*sdk.TxResponse, error) { +func (c *ContractClient) SendToXRPL( + ctx context.Context, + sender sdk.AccAddress, + recipient string, + amount sdk.Coin, +) (*sdk.TxResponse, error) { txRes, err := c.execute(ctx, sender, execRequest{ Body: map[ExecMethod]sendToXRPLRequest{ ExecSendToXRPL: { @@ -680,7 +736,11 @@ func (c *ContractClient) SendToXRPL(ctx context.Context, sender sdk.AccAddress, } // RecoverXRPLTokenRegistration executes `recover_xrpl_token_registration` method. -func (c *ContractClient) RecoverXRPLTokenRegistration(ctx context.Context, sender sdk.AccAddress, issuer, currency string) (*sdk.TxResponse, error) { +func (c *ContractClient) RecoverXRPLTokenRegistration( + ctx context.Context, + sender sdk.AccAddress, + issuer, currency string, +) (*sdk.TxResponse, error) { txRes, err := c.execute(ctx, sender, execRequest{ Body: map[ExecMethod]recoverXRPLTokenRegistrationRequest{ ExecRecoveryXRPLTokenRegistration: { @@ -725,7 +785,10 @@ func (c *ContractClient) GetContractOwnership(ctx context.Context) (ContractOwne } // GetXRPLTokenByIssuerAndCurrency returns a XRPL registered token by issuer and currency or error. -func (c *ContractClient) GetXRPLTokenByIssuerAndCurrency(ctx context.Context, issuer, currency string) (XRPLToken, error) { +func (c *ContractClient) GetXRPLTokenByIssuerAndCurrency( + ctx context.Context, + issuer, currency string, +) (XRPLToken, error) { tokens, err := c.GetXRPLTokens(ctx) if err != nil { return XRPLToken{}, err @@ -736,7 +799,10 @@ func (c *ContractClient) GetXRPLTokenByIssuerAndCurrency(ctx context.Context, is } } - return XRPLToken{}, errors.Errorf("token not found in the registered tokens list, issuer:%s, currency:%s", issuer, currency) + return XRPLToken{}, errors.Errorf( + "token not found in the registered tokens list, issuer:%s, currency:%s", + issuer, currency, + ) } // GetXRPLTokens returns a list of all XRPL tokens. @@ -818,7 +884,11 @@ func (c *ContractClient) GetAvailableTickets(ctx context.Context) ([]uint32, err return response.Tickets, nil } -func (c *ContractClient) getPaginatedXRPLTokens(ctx context.Context, offset *uint64, limit *uint32) ([]XRPLToken, error) { +func (c *ContractClient) getPaginatedXRPLTokens( + ctx context.Context, + offset *uint64, + limit *uint32, +) ([]XRPLToken, error) { var response xrplTokensResponse err := c.query(ctx, map[QueryMethod]pagingRequest{ QueryMethodXRPLTokens: { @@ -833,7 +903,11 @@ func (c *ContractClient) getPaginatedXRPLTokens(ctx context.Context, offset *uin return response.Tokens, nil } -func (c *ContractClient) getPaginatedCoreumTokens(ctx context.Context, offset *uint64, limit *uint32) ([]CoreumToken, error) { +func (c *ContractClient) getPaginatedCoreumTokens( + ctx context.Context, + offset *uint64, + limit *uint32, +) ([]CoreumToken, error) { var response coreumTokensResponse err := c.query(ctx, map[QueryMethod]pagingRequest{ QueryMethodCoreumTokens: { @@ -857,7 +931,11 @@ func (c *ContractClient) queryAssetFTIssueFee(ctx context.Context) (sdk.Coin, er return assetFtParamsRes.Params.IssueFee, nil } -func (c *ContractClient) execute(ctx context.Context, sender sdk.AccAddress, requests ...execRequest) (*sdk.TxResponse, error) { +func (c *ContractClient) execute( + ctx context.Context, + sender sdk.AccAddress, + requests ...execRequest, +) (*sdk.TxResponse, error) { if c.cfg.ContractAddress == nil { return nil, errors.New("failed to execute with empty contract address") } @@ -909,7 +987,12 @@ func (c *ContractClient) query(ctx context.Context, request, response any) error c.log.Debug(ctx, "Query is succeeded", logger.StringField("data", string(resp.Data))) if err := json.Unmarshal(resp.Data, response); err != nil { - return errors.Wrapf(err, "failed to unmarshal wasm contract response, request:%s, response:%s", string(payload), string(resp.Data)) + return errors.Wrapf( + err, + "failed to unmarshal wasm contract response, request:%s, response:%s", + string(payload), + string(resp.Data), + ) } return nil diff --git a/relayer/fee/rounding_test.go b/relayer/fee/rounding_test.go index 469917ff..20ee8b4f 100644 --- a/relayer/fee/rounding_test.go +++ b/relayer/fee/rounding_test.go @@ -222,7 +222,11 @@ func TestReceivedCoreumToXRPLAmount(t *testing.T) { require.Equal(t, tt.wantReceivedValue.String(), receivedValue.String()) if tt.wantAllocatedOnTheAccountToPayTransferFee != nil { - require.Equal(t, tt.wantAllocatedOnTheAccountToPayTransferFee.String(), allocatedOnTheAccountToPayTransferFee.String()) + require.Equal( + t, + tt.wantAllocatedOnTheAccountToPayTransferFee.String(), + allocatedOnTheAccountToPayTransferFee.String(), + ) } }) } @@ -255,7 +259,9 @@ func computeReceivedTransferAmountsWithFeesFromCoreumToXRPL( valueRat := big.NewRat(0, 1).SetFrac(value, tenPowerDec) transferFeeRate := big.NewRat(0, 1).SetFrac(big.NewInt(transferRate), big.NewInt(TransferRateDenominator)) // value - ((value * transfer fee rate) - val) - allocatedOnTheAccountToPayTransferFeeRat := big.NewRat(0, 1).Sub(big.NewRat(0, 1).Mul(valueRat, transferFeeRate), valueRat) + allocatedOnTheAccountToPayTransferFeeRat := big. + NewRat(0, 1). + Sub(big.NewRat(0, 1).Mul(valueRat, transferFeeRate), valueRat) ratValueWithoutTransferFee := big.NewRat(0, 1).Sub(valueRat, allocatedOnTheAccountToPayTransferFeeRat) bridgingFeeRat := big.NewRat(0, 1).SetFrac(bridgingFee, tenPowerDec) @@ -271,7 +277,10 @@ func computeReceivedTransferAmountsWithFeesFromCoreumToXRPL( } receivedAmount, err := rippledata.NewValue((&big.Float{}).SetRat(receivedAmountRat).Text('f', prec), false) require.NoError(t, err) - allocatedOnTheAccountToPayTransferFee, err := rippledata.NewValue((&big.Float{}).SetRat(allocatedOnTheAccountToPayTransferFeeRat).Text('f', prec), false) + allocatedOnTheAccountToPayTransferFee, err := rippledata.NewValue( + (&big.Float{}).SetRat(allocatedOnTheAccountToPayTransferFeeRat).Text('f', prec), + false, + ) require.NoError(t, err) return receivedAmount, allocatedOnTheAccountToPayTransferFee @@ -285,7 +294,8 @@ func truncateRatBySendingPrecision(ratValue *big.Rat, sendingPrecision int) *big switch { case sendingPrecision > 0: tenPowerDec := big.NewInt(0).Exp(big.NewInt(10), big.NewInt(int64(sendingPrecision)), nil) - // (nominator / (denominator / 1e(sendingPrecision)) * (denominator / 1e(sendingPrecision)) with denominator equal original + // (nominator / (denominator / 1e(sendingPrecision)) * (denominator / 1e(sendingPrecision)) + // with denominator equal original subDenominator := big.NewInt(0).Quo(denominator, tenPowerDec) if subDenominator.Cmp(big.NewInt(0)) == 1 { updatedNominator := big.NewInt(0).Mul( diff --git a/relayer/processes/amount.go b/relayer/processes/amount.go index 9ddd0106..73c6fc1c 100644 --- a/relayer/processes/amount.go +++ b/relayer/processes/amount.go @@ -31,23 +31,35 @@ func ConvertXRPLAmountToCoreumAmount(xrplAmount rippledata.Amount) (sdkmath.Int, return convertXRPLAmountToCoreumAmountWithDecimals(xrplAmount, xrpl.XRPLIssuedTokenDecimals) } -// ConvertXRPLOriginatedTokenCoreumAmountToXRPLAmount converts the XRPL originated token amount from coreum to XRPL amount -// based on the currency type. -func ConvertXRPLOriginatedTokenCoreumAmountToXRPLAmount(coreumAmount sdkmath.Int, issuerString, currencyString string) (rippledata.Amount, error) { +// ConvertXRPLOriginatedTokenCoreumAmountToXRPLAmount converts the XRPL originated token amount from +// coreum to XRPL amount based on the currency type. +func ConvertXRPLOriginatedTokenCoreumAmountToXRPLAmount( + coreumAmount sdkmath.Int, + issuerString, + currencyString string, +) (rippledata.Amount, error) { if isXRPToken(issuerString, currencyString) { // format with exponent amountString := big.NewFloat(0).SetInt(coreumAmount.BigInt()).Text('g', XRPLAmountPrec) // we don't use the decimals for the XRP values since the `NewValue` function will do it automatically xrplValue, err := rippledata.NewValue(amountString, true) if err != nil { - return rippledata.Amount{}, errors.Wrapf(err, "failed to convert amount string to ripple.Value, amount stirng: %s", amountString) + return rippledata.Amount{}, errors.Wrapf( + err, + "failed to convert amount string to ripple.Value, amount stirng: %s", + amountString, + ) } return rippledata.Amount{ Value: xrplValue, }, nil } - return convertCoreumAmountToXRPLAmountWithDecimals(coreumAmount, xrpl.XRPLIssuedTokenDecimals, issuerString, currencyString) + return convertCoreumAmountToXRPLAmountWithDecimals( + coreumAmount, + xrpl.XRPLIssuedTokenDecimals, + issuerString, currencyString, + ) } func convertXRPLAmountToCoreumAmountWithDecimals(xrplAmount rippledata.Amount, decimals uint32) (sdkmath.Int, error) { @@ -62,22 +74,43 @@ func convertXRPLAmountToCoreumAmountWithDecimals(xrplAmount rippledata.Amount, d return sdkmath.NewIntFromBigInt(binIntAmount), nil } -func convertCoreumAmountToXRPLAmountWithDecimals(coreumAmount sdkmath.Int, decimals uint32, issuerString, currencyString string) (rippledata.Amount, error) { +func convertCoreumAmountToXRPLAmountWithDecimals( + coreumAmount sdkmath.Int, + decimals uint32, + issuerString, currencyString string, +) (rippledata.Amount, error) { tenPowerDec := big.NewInt(0).Exp(big.NewInt(10), big.NewInt(int64(decimals)), nil) floatAmount := big.NewFloat(0).SetRat(big.NewRat(0, 1).SetFrac(coreumAmount.BigInt(), tenPowerDec)) // format with exponent - amountString := fmt.Sprintf("%s/%s/%s", floatAmount.Text('g', XRPLAmountPrec), currencyString, issuerString) + amountString := fmt.Sprintf( + "%s/%s/%s", + floatAmount.Text('g', XRPLAmountPrec), + currencyString, + issuerString, + ) xrplValue, err := rippledata.NewValue(amountString, false) if err != nil { - return rippledata.Amount{}, errors.Wrapf(err, "failed to convert amount string to ripple.Value, amount stirng: %s", amountString) + return rippledata.Amount{}, errors.Wrapf( + err, + "failed to convert amount string to ripple.Value, amount stirng: %s", + amountString, + ) } currency, err := rippledata.NewCurrency(currencyString) if err != nil { - return rippledata.Amount{}, errors.Wrapf(err, "failed to convert currency to ripple.Currency, currency: %s", currencyString) + return rippledata.Amount{}, errors.Wrapf( + err, + "failed to convert currency to ripple.Currency, currency: %s", + currencyString, + ) } issuer, err := rippledata.NewAccountFromAddress(issuerString) if err != nil { - return rippledata.Amount{}, errors.Wrapf(err, "failed to convert issuer to ripple.Account, issuer: %s", issuerString) + return rippledata.Amount{}, errors.Wrapf( + err, + "failed to convert issuer to ripple.Account, issuer: %s", + issuerString, + ) } return rippledata.Amount{ diff --git a/relayer/processes/model.go b/relayer/processes/model.go index 15442768..54c1dec7 100644 --- a/relayer/processes/model.go +++ b/relayer/processes/model.go @@ -15,11 +15,32 @@ import ( // ContractClient is the interface for the contract client. type ContractClient interface { IsInitialized() bool - SendXRPLToCoreumTransferEvidence(ctx context.Context, sender sdk.AccAddress, evidence coreum.XRPLToCoreumTransferEvidence) (*sdk.TxResponse, error) - SendXRPLTicketsAllocationTransactionResultEvidence(ctx context.Context, sender sdk.AccAddress, evidence coreum.XRPLTransactionResultTicketsAllocationEvidence) (*sdk.TxResponse, error) - SendXRPLTrustSetTransactionResultEvidence(ctx context.Context, sender sdk.AccAddress, evd coreum.XRPLTransactionResultTrustSetEvidence) (*sdk.TxResponse, error) - SendCoreumToXRPLTransferTransactionResultEvidence(ctx context.Context, sender sdk.AccAddress, evd coreum.XRPLTransactionResultCoreumToXRPLTransferEvidence) (*sdk.TxResponse, error) - SaveSignature(ctx context.Context, sender sdk.AccAddress, operationID uint32, signature string) (*sdk.TxResponse, error) + SendXRPLToCoreumTransferEvidence( + ctx context.Context, + sender sdk.AccAddress, + evidence coreum.XRPLToCoreumTransferEvidence, + ) (*sdk.TxResponse, error) + SendXRPLTicketsAllocationTransactionResultEvidence( + ctx context.Context, + sender sdk.AccAddress, + evidence coreum.XRPLTransactionResultTicketsAllocationEvidence, + ) (*sdk.TxResponse, error) + SendXRPLTrustSetTransactionResultEvidence( + ctx context.Context, + sender sdk.AccAddress, + evd coreum.XRPLTransactionResultTrustSetEvidence, + ) (*sdk.TxResponse, error) + SendCoreumToXRPLTransferTransactionResultEvidence( + ctx context.Context, + sender sdk.AccAddress, + evd coreum.XRPLTransactionResultCoreumToXRPLTransferEvidence, + ) (*sdk.TxResponse, error) + SaveSignature( + ctx context.Context, + sender sdk.AccAddress, + operationID uint32, + signature string, + ) (*sdk.TxResponse, error) GetPendingOperations(ctx context.Context) ([]coreum.Operation, error) GetContractConfig(ctx context.Context) (coreum.ContractConfig, error) } diff --git a/relayer/processes/xrpl_tx_observer.go b/relayer/processes/xrpl_tx_observer.go index 47ed3cab..006e4e13 100644 --- a/relayer/processes/xrpl_tx_observer.go +++ b/relayer/processes/xrpl_tx_observer.go @@ -160,7 +160,11 @@ func (o *XRPLTxObserver) processIncomingTx(ctx context.Context, tx rippledata.Tr } if coreum.IsAssetFTWhitelistedLimitExceededError(err) { - o.log.Info(ctx, "The evidence saving is failed because of the asset FT rules, the evidence is skipped", logger.AnyField("evidence", evidence)) + o.log.Info( + ctx, + "The evidence saving is failed because of the asset FT rules, the evidence is skipped", + logger.AnyField("evidence", evidence), + ) return nil } @@ -187,7 +191,10 @@ func (o *XRPLTxObserver) processOutgoingTx(ctx context.Context, tx rippledata.Tr } } -func (o *XRPLTxObserver) sendXRPLTicketsAllocationTransactionResultEvidence(ctx context.Context, tx rippledata.TransactionWithMetaData) error { +func (o *XRPLTxObserver) sendXRPLTicketsAllocationTransactionResultEvidence( + ctx context.Context, + tx rippledata.TransactionWithMetaData, +) error { tickets := extractTicketSequencesFromMetaData(tx.MetaData) txResult := getTransactionResult(tx) if txResult == coreum.TransactionResultRejected { @@ -219,7 +226,10 @@ func (o *XRPLTxObserver) sendXRPLTicketsAllocationTransactionResultEvidence(ctx return o.handleEvidenceSubmissionError(ctx, err, tx, evidence.XRPLTransactionResultEvidence) } -func (o *XRPLTxObserver) sendXRPLTrustSetTransactionResultEvidence(ctx context.Context, tx rippledata.TransactionWithMetaData) error { +func (o *XRPLTxObserver) sendXRPLTrustSetTransactionResultEvidence( + ctx context.Context, + tx rippledata.TransactionWithMetaData, +) error { trustSetTx, ok := tx.Transaction.(*rippledata.TrustSet) if !ok { return errors.Errorf("failed to cast tx to TrustSet, data:%+v", tx) @@ -243,7 +253,10 @@ func (o *XRPLTxObserver) sendXRPLTrustSetTransactionResultEvidence(ctx context.C return o.handleEvidenceSubmissionError(ctx, err, tx, evidence.XRPLTransactionResultEvidence) } -func (o *XRPLTxObserver) sendCoreumToXRPLTransferTransactionResultEvidence(ctx context.Context, tx rippledata.TransactionWithMetaData) error { +func (o *XRPLTxObserver) sendCoreumToXRPLTransferTransactionResultEvidence( + ctx context.Context, + tx rippledata.TransactionWithMetaData, +) error { paymentTx, ok := tx.Transaction.(*rippledata.Payment) if !ok { return errors.Errorf("failed to cast tx to Payment, data:%+v", tx) @@ -290,7 +303,8 @@ func (o *XRPLTxObserver) handleEvidenceSubmissionError( // Any tec code Final when included in a validated ledger. // Any tem code Final unless the protocol changes to make the transaction valid. // tefPAST_SEQ Final when another transaction with the same sequence number is included in a validated ledger. -// tefMAX_LEDGER Final when a validated ledger has a ledger index higher than the transaction's LastLedgerSequence field, and no validated ledger includes the transaction. +// tefMAX_LEDGER Final when a validated ledger has a ledger index higher than the transaction's LastLedgerSequence +// field, and no validated ledger includes the transaction. func txIsFinal(tx rippledata.TransactionWithMetaData) bool { txResult := tx.MetaData.TransactionResult return tx.MetaData.TransactionResult.Success() || diff --git a/relayer/processes/xrpl_tx_submitter.go b/relayer/processes/xrpl_tx_submitter.go index 9d565a2b..c86a6e2e 100644 --- a/relayer/processes/xrpl_tx_submitter.go +++ b/relayer/processes/xrpl_tx_submitter.go @@ -38,7 +38,10 @@ type XRPLTxSubmitterConfig struct { } // DefaultXRPLTxSubmitterConfig returns the default XRPLTxSubmitter. -func DefaultXRPLTxSubmitterConfig(bridgeXRPLAddress rippledata.Account, relayerAddress sdk.AccAddress) XRPLTxSubmitterConfig { +func DefaultXRPLTxSubmitterConfig( + bridgeXRPLAddress rippledata.Account, + relayerAddress sdk.AccAddress, +) XRPLTxSubmitterConfig { return XRPLTxSubmitterConfig{ BridgeXRPLAddress: bridgeXRPLAddress, RelayerCoreumAddress: relayerAddress, @@ -152,11 +155,20 @@ func (s *XRPLTxSubmitter) getBridgeSigners(ctx context.Context) (BridgeSigners, for _, relayer := range contractConfig.Relayers { xrplAcc, err := rippledata.NewAccountFromAddress(relayer.XRPLAddress) if err != nil { - return BridgeSigners{}, errors.Wrapf(err, "failed to covert XRPL relayer address to Account type, address:%s", relayer.XRPLAddress) + return BridgeSigners{}, errors.Wrapf( + err, + "failed to covert XRPL relayer address to Account type, address:%s", + relayer.XRPLAddress, + ) } var accPubKey rippledata.PublicKey if err := accPubKey.UnmarshalText([]byte(relayer.XRPLPubKey)); err != nil { - return BridgeSigners{}, errors.Wrapf(err, "failed to unmarshal XRPL relayer pubkey, address:%s, pubKey:%s", relayer.XRPLAddress, relayer.XRPLPubKey) + return BridgeSigners{}, errors.Wrapf( + err, + "failed to unmarshal XRPL relayer pubkey, address:%s, pubKey:%s", + relayer.XRPLAddress, + relayer.XRPLPubKey, + ) } xrplPubKeys[*xrplAcc] = accPubKey @@ -171,7 +183,9 @@ func (s *XRPLTxSubmitter) getBridgeSigners(ctx context.Context) (BridgeSigners, }, nil } -func (s *XRPLTxSubmitter) getBridgeXRPLSignerAccountsWithWeights(ctx context.Context) (map[rippledata.Account]uint16, uint32, error) { +func (s *XRPLTxSubmitter) getBridgeXRPLSignerAccountsWithWeights( + ctx context.Context, +) (map[rippledata.Account]uint16, uint32, error) { accountInfo, err := s.xrplRPCClient.AccountInfo(ctx, s.cfg.BridgeXRPLAddress) if err != nil { return nil, 0, err @@ -190,7 +204,11 @@ func (s *XRPLTxSubmitter) getBridgeXRPLSignerAccountsWithWeights(ctx context.Con return accountWights, weightsQuorum, nil } -func (s *XRPLTxSubmitter) signOrSubmitOperation(ctx context.Context, operation coreum.Operation, bridgeSigners BridgeSigners) error { +func (s *XRPLTxSubmitter) signOrSubmitOperation( + ctx context.Context, + operation coreum.Operation, + bridgeSigners BridgeSigners, +) error { valid, err := s.preValidateOperation(ctx, operation) if err != nil { return err @@ -222,6 +240,7 @@ func (s *XRPLTxSubmitter) signOrSubmitOperation(ctx context.Context, operation c s.log.Debug(ctx, "Transaction has been already submitted", logger.StringField("txHash", tx.GetHash().String())) return nil case xrpl.TecPathDryTxResult: + //nolint:lll // breaking down the log line will make it less readable. s.log.Info( ctx, "The transaction has been sent, but will be reverted since the provided path does not have enough liquidity or the receipt doesn't link by trust lines.", @@ -235,7 +254,11 @@ func (s *XRPLTxSubmitter) signOrSubmitOperation(ctx context.Context, operation c return nil case xrpl.TecInsufficientReserveTxResult: // for that case the tx will be accepted by the node and its rejection will be handled in the observer - s.log.Error(ctx, "Insufficient reserve to complete the operation", logger.StringField("txHash", tx.GetHash().String())) + s.log.Error( + ctx, + "Insufficient reserve to complete the operation", + logger.StringField("txHash", tx.GetHash().String()), + ) return nil default: // TODO(dzmitryhil) handle the case when the keys are rotated but the bridgeSigners are from the previous state @@ -259,7 +282,11 @@ func (s *XRPLTxSubmitter) buildSubmittableTransaction( } xrplPubKey, ok := bridgeSigners.XRPLPubKeys[xrplAcc] if !ok { - s.log.Warn(ctx, "Found XRPL signer address without pub key in the contract", logger.StringField("xrplAddress", xrplAcc.String())) + s.log.Warn( + ctx, + "Found XRPL signer address without pub key in the contract", + logger.StringField("xrplAddress", xrplAcc.String()), + ) continue } xrplAccWeight, ok := bridgeSigners.XRPLWeights[xrplAcc] @@ -294,7 +321,12 @@ func (s *XRPLTxSubmitter) buildSubmittableTransaction( } isValid, _, err := rippledata.CheckMultiSignature(tx) if err != nil { - s.log.Warn(ctx, "failed to check transaction signature, err:%s, signer:%+v", logger.Error(err), logger.AnyField("signer", txSigner)) + s.log.Warn( + ctx, + "failed to check transaction signature, err:%s, signer:%+v", + logger.Error(err), + logger.AnyField("signer", txSigner), + ) continue } if !isValid { diff --git a/relayer/processes/xrpl_tx_submitter_operation_tx.go b/relayer/processes/xrpl_tx_submitter_operation_tx.go index 521eca95..0e27032e 100644 --- a/relayer/processes/xrpl_tx_submitter_operation_tx.go +++ b/relayer/processes/xrpl_tx_submitter_operation_tx.go @@ -1,8 +1,6 @@ package processes import ( - "fmt" - "github.com/pkg/errors" rippledata "github.com/rubblelabs/ripple/data" @@ -10,7 +8,10 @@ import ( ) // BuildTicketCreateTxForMultiSigning builds TicketCreate transaction operation from the contract operation. -func BuildTicketCreateTxForMultiSigning(bridgeXRPLAddress rippledata.Account, operation coreum.Operation) (*rippledata.TicketCreate, error) { +func BuildTicketCreateTxForMultiSigning( + bridgeXRPLAddress rippledata.Account, + operation coreum.Operation, +) (*rippledata.TicketCreate, error) { tx := rippledata.TicketCreate{ TxBase: rippledata.TxBase{ Account: bridgeXRPLAddress, @@ -36,7 +37,10 @@ func BuildTicketCreateTxForMultiSigning(bridgeXRPLAddress rippledata.Account, op } // BuildTrustSetTxForMultiSigning builds TrustSet transaction operation from the contract operation. -func BuildTrustSetTxForMultiSigning(bridgeXRPLAddress rippledata.Account, operation coreum.Operation) (*rippledata.TrustSet, error) { +func BuildTrustSetTxForMultiSigning( + bridgeXRPLAddress rippledata.Account, + operation coreum.Operation, +) (*rippledata.TrustSet, error) { trustSetType := operation.OperationType.TrustSet value, err := ConvertXRPLOriginatedTokenCoreumAmountToXRPLAmount( trustSetType.TrustSetLimitAmount, @@ -66,8 +70,12 @@ func BuildTrustSetTxForMultiSigning(bridgeXRPLAddress rippledata.Account, operat return &tx, nil } -// BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning builds Payment transaction for XRPL originated token from the contract operation. -func BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning(bridgeXRPLAddress rippledata.Account, operation coreum.Operation) (*rippledata.Payment, error) { +// BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning builds Payment transaction for +// XRPL originated token from the contract operation. +func BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning( + bridgeXRPLAddress rippledata.Account, + operation coreum.Operation, +) (*rippledata.Payment, error) { coreumToXRPLTransferOperationType := operation.OperationType.CoreumToXRPLTransfer value, err := ConvertXRPLOriginatedTokenCoreumAmountToXRPLAmount( coreumToXRPLTransferOperationType.Amount, @@ -86,7 +94,8 @@ func BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning(bridge return &tx, nil } -// BuildCoreumToXRPLCoreumOriginatedTokenTransferPaymentTxForMultiSigning builds Payment transaction for coreum originated token from the contract operation. +// BuildCoreumToXRPLCoreumOriginatedTokenTransferPaymentTxForMultiSigning builds Payment transaction for coreum +// originated token from the contract operation. func BuildCoreumToXRPLCoreumOriginatedTokenTransferPaymentTxForMultiSigning( bridgeXRPLAddress rippledata.Account, operation coreum.Operation, @@ -116,7 +125,11 @@ func buildPaymentTx( ) (rippledata.Payment, error) { recipient, err := rippledata.NewAccountFromAddress(operation.OperationType.CoreumToXRPLTransfer.Recipient) if err != nil { - return rippledata.Payment{}, errors.Wrap(err, fmt.Sprintf("failed to convert XRPL recipient to rippledata.Account, recipient:%s", operation.OperationType.CoreumToXRPLTransfer.Recipient)) + return rippledata.Payment{}, errors.Wrapf( + err, + "failed to convert XRPL recipient to rippledata.Account, recipient:%s", + operation.OperationType.CoreumToXRPLTransfer.Recipient, + ) } tx := rippledata.Payment{ Destination: *recipient, diff --git a/relayer/processes/xrpl_tx_submitter_test.go b/relayer/processes/xrpl_tx_submitter_test.go index 9bdfd123..4898718b 100644 --- a/relayer/processes/xrpl_tx_submitter_test.go +++ b/relayer/processes/xrpl_tx_submitter_test.go @@ -30,7 +30,9 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { allocateTicketsOperation, allocateTicketOperationWithUnexpectedSeqNumber, allocateTicketOperationWithSignatures, - allocateTicketOperationValidSigners := buildAllocateTicketsTestData(t, xrplTxSigners, bridgeXRPLAddress, contractRelayers) + allocateTicketOperationValidSigners := buildAllocateTicketsTestData( + t, xrplTxSigners, bridgeXRPLAddress, contractRelayers, + ) // ********** TrustSet ********** @@ -42,7 +44,9 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { coreumToXRPLTokenTransferOperation, coreumToXRPLTokenTransferOperationWithSignatures, - coreumToXRPLTokenTransferOperationValidSigners := buildCoreumToXRPLTokenTransferTestData(t, xrplTxSigners, bridgeXRPLAddress, contractRelayers) + coreumToXRPLTokenTransferOperationValidSigners := buildCoreumToXRPLTokenTransferTestData( + t, xrplTxSigners, bridgeXRPLAddress, contractRelayers, + ) tests := []struct { name string @@ -62,17 +66,28 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { name: "register_signature_for_create_ticket_tx", contractClientBuilder: func(ctrl *gomock.Controller) processes.ContractClient { contractClientMock := NewMockContractClient(ctrl) - contractClientMock.EXPECT().GetPendingOperations(gomock.Any()).Return([]coreum.Operation{allocateTicketsOperation}, nil) + contractClientMock.EXPECT(). + GetPendingOperations(gomock.Any()). + Return([]coreum.Operation{allocateTicketsOperation}, nil) contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) - contractClientMock.EXPECT().SaveSignature(gomock.Any(), contractRelayers[0].CoreumAddress, allocateTicketsOperation.AccountSequence, allocateTicketOperationValidSigners[0].Signer.TxnSignature.String()) + contractClientMock.EXPECT().SaveSignature( + gomock.Any(), + contractRelayers[0].CoreumAddress, + allocateTicketsOperation.AccountSequence, + allocateTicketOperationValidSigners[0].Signer.TxnSignature.String(), + ) return contractClientMock }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) // 2 times one for the signatures and one more for the seq number - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil).Times(2) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil). + Times(2) return xrplRPCClientMock }, xrplTxSignerBuilder: func(ctrl *gomock.Controller) processes.XRPLTxSigner { @@ -88,7 +103,10 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { name: "submit_create_ticket_tx_with_filtered_signature", contractClientBuilder: func(ctrl *gomock.Controller) processes.ContractClient { contractClientMock := NewMockContractClient(ctrl) - contractClientMock.EXPECT().GetPendingOperations(gomock.Any()).Return([]coreum.Operation{allocateTicketOperationWithSignatures}, nil) + contractClientMock. + EXPECT(). + GetPendingOperations(gomock.Any()). + Return([]coreum.Operation{allocateTicketOperationWithSignatures}, nil) contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) @@ -96,18 +114,26 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil) - expectedTx, err := processes.BuildTicketCreateTxForMultiSigning(bridgeXRPLAddress, allocateTicketOperationWithSignatures) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil) + expectedTx, err := processes.BuildTicketCreateTxForMultiSigning( + bridgeXRPLAddress, allocateTicketOperationWithSignatures, + ) require.NoError(t, err) require.NoError(t, rippledata.SetSigners(expectedTx, allocateTicketOperationValidSigners...)) - xrplRPCClientMock.EXPECT().Submit(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, tx rippledata.Transaction) (xrpl.SubmitResult, error) { - _, expectedTxRaw, err := rippledata.Raw(expectedTx) - require.NoError(t, err) - _, txRaw, err := rippledata.Raw(tx) - require.NoError(t, err) - require.Equal(t, expectedTxRaw, txRaw) - return xrpl.SubmitResult{}, nil - }) + xrplRPCClientMock. + EXPECT(). + Submit(gomock.Any(), gomock.Any()). + Do(func(ctx context.Context, tx rippledata.Transaction) (xrpl.SubmitResult, error) { + _, expectedTxRaw, err := rippledata.Raw(expectedTx) + require.NoError(t, err) + _, txRaw, err := rippledata.Raw(tx) + require.NoError(t, err) + require.Equal(t, expectedTxRaw, txRaw) + return xrpl.SubmitResult{}, nil + }) return xrplRPCClientMock }, @@ -116,22 +142,32 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { name: "register_invalid_create_ticket_tx", contractClientBuilder: func(ctrl *gomock.Controller) processes.ContractClient { contractClientMock := NewMockContractClient(ctrl) - contractClientMock.EXPECT().GetPendingOperations(gomock.Any()).Return([]coreum.Operation{allocateTicketOperationWithUnexpectedSeqNumber}, nil) + contractClientMock. + EXPECT(). + GetPendingOperations(gomock.Any()). + Return([]coreum.Operation{allocateTicketOperationWithUnexpectedSeqNumber}, nil) contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) - contractClientMock.EXPECT().SendXRPLTicketsAllocationTransactionResultEvidence(gomock.Any(), contractRelayers[0].CoreumAddress, coreum.XRPLTransactionResultTicketsAllocationEvidence{ - XRPLTransactionResultEvidence: coreum.XRPLTransactionResultEvidence{ - AccountSequence: &allocateTicketOperationWithUnexpectedSeqNumber.AccountSequence, - TransactionResult: coreum.TransactionResultInvalid, - }, - }) + contractClientMock.EXPECT().SendXRPLTicketsAllocationTransactionResultEvidence( + gomock.Any(), + contractRelayers[0].CoreumAddress, + coreum.XRPLTransactionResultTicketsAllocationEvidence{ + XRPLTransactionResultEvidence: coreum.XRPLTransactionResultEvidence{ + AccountSequence: &allocateTicketOperationWithUnexpectedSeqNumber.AccountSequence, + TransactionResult: coreum.TransactionResultInvalid, + }, + }) return contractClientMock }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) // 2 times one for the signatures and one more for the seq number - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil).Times(2) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil). + Times(2) return xrplRPCClientMock }, }, @@ -143,12 +179,20 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) - contractClientMock.EXPECT().SaveSignature(gomock.Any(), contractRelayers[0].CoreumAddress, trustSetOperation.TicketSequence, trustSetOperationValidSigners[0].Signer.TxnSignature.String()) + contractClientMock.EXPECT().SaveSignature( + gomock.Any(), + contractRelayers[0].CoreumAddress, + trustSetOperation.TicketSequence, + trustSetOperationValidSigners[0].Signer.TxnSignature.String(), + ) return contractClientMock }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil) return xrplRPCClientMock }, xrplTxSignerBuilder: func(ctrl *gomock.Controller) processes.XRPLTxSigner { @@ -164,7 +208,10 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { name: "submit_trust_set_tx_with_filtered_signature", contractClientBuilder: func(ctrl *gomock.Controller) processes.ContractClient { contractClientMock := NewMockContractClient(ctrl) - contractClientMock.EXPECT().GetPendingOperations(gomock.Any()).Return([]coreum.Operation{trustSetOperationWithSignatures}, nil) + contractClientMock. + EXPECT(). + GetPendingOperations(gomock.Any()). + Return([]coreum.Operation{trustSetOperationWithSignatures}, nil) contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) @@ -172,18 +219,24 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil) expectedTx, err := processes.BuildTrustSetTxForMultiSigning(bridgeXRPLAddress, trustSetOperationWithSignatures) require.NoError(t, err) require.NoError(t, rippledata.SetSigners(expectedTx, trustSetOperationValidSigners...)) - xrplRPCClientMock.EXPECT().Submit(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, tx rippledata.Transaction) (xrpl.SubmitResult, error) { - _, expectedTxRaw, err := rippledata.Raw(expectedTx) - require.NoError(t, err) - _, txRaw, err := rippledata.Raw(tx) - require.NoError(t, err) - require.Equal(t, expectedTxRaw, txRaw) - return xrpl.SubmitResult{}, nil - }) + xrplRPCClientMock. + EXPECT(). + Submit(gomock.Any(), gomock.Any()). + Do(func(ctx context.Context, tx rippledata.Transaction) (xrpl.SubmitResult, error) { + _, expectedTxRaw, err := rippledata.Raw(expectedTx) + require.NoError(t, err) + _, txRaw, err := rippledata.Raw(tx) + require.NoError(t, err) + require.Equal(t, expectedTxRaw, txRaw) + return xrpl.SubmitResult{}, nil + }) return xrplRPCClientMock }, @@ -192,23 +245,39 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { name: "register_signature_for_coreum_to_XRPL_token_transfer_payment_tx", contractClientBuilder: func(ctrl *gomock.Controller) processes.ContractClient { contractClientMock := NewMockContractClient(ctrl) - contractClientMock.EXPECT().GetPendingOperations(gomock.Any()).Return([]coreum.Operation{coreumToXRPLTokenTransferOperation}, nil) + contractClientMock. + EXPECT(). + GetPendingOperations(gomock.Any()). + Return([]coreum.Operation{coreumToXRPLTokenTransferOperation}, nil) contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) - contractClientMock.EXPECT().SaveSignature(gomock.Any(), contractRelayers[0].CoreumAddress, coreumToXRPLTokenTransferOperation.TicketSequence, coreumToXRPLTokenTransferOperationValidSigners[0].Signer.TxnSignature.String()) + contractClientMock.EXPECT().SaveSignature( + gomock.Any(), + contractRelayers[0].CoreumAddress, + coreumToXRPLTokenTransferOperation.TicketSequence, + coreumToXRPLTokenTransferOperationValidSigners[0].Signer.TxnSignature.String(), + ) return contractClientMock }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil) return xrplRPCClientMock }, xrplTxSignerBuilder: func(ctrl *gomock.Controller) processes.XRPLTxSigner { xrplTxSignerMock := NewMockXRPLTxSigner(ctrl) - tx, err := processes.BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning(bridgeXRPLAddress, coreumToXRPLTokenTransferOperation) + tx, err := processes.BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning( + bridgeXRPLAddress, coreumToXRPLTokenTransferOperation, + ) require.NoError(t, err) - xrplTxSignerMock.EXPECT().MultiSign(tx, xrplTxSignerKeyName).Return(coreumToXRPLTokenTransferOperationValidSigners[0], nil) + xrplTxSignerMock. + EXPECT(). + MultiSign(tx, xrplTxSignerKeyName). + Return(coreumToXRPLTokenTransferOperationValidSigners[0], nil) return xrplTxSignerMock }, @@ -217,7 +286,10 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { name: "submit_coreum_to_XRPL_token_transfer_payment_tx_with_filtered_signature", contractClientBuilder: func(ctrl *gomock.Controller) processes.ContractClient { contractClientMock := NewMockContractClient(ctrl) - contractClientMock.EXPECT().GetPendingOperations(gomock.Any()).Return([]coreum.Operation{coreumToXRPLTokenTransferOperationWithSignatures}, nil) + contractClientMock. + EXPECT(). + GetPendingOperations(gomock.Any()). + Return([]coreum.Operation{coreumToXRPLTokenTransferOperationWithSignatures}, nil) contractClientMock.EXPECT().GetContractConfig(gomock.Any()).Return(coreum.ContractConfig{ Relayers: contractRelayers, }, nil) @@ -225,18 +297,24 @@ func TestXRPLTxSubmitter_Start(t *testing.T) { }, xrplRPCClientBuilder: func(ctrl *gomock.Controller) processes.XRPLRPCClient { xrplRPCClientMock := NewMockXRPLRPCClient(ctrl) - xrplRPCClientMock.EXPECT().AccountInfo(gomock.Any(), bridgeXRPLAddress).Return(bridgeXRPLSignerAccountWithSigners, nil) - expectedTx, err := processes.BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning(bridgeXRPLAddress, coreumToXRPLTokenTransferOperationWithSignatures) + xrplRPCClientMock. + EXPECT(). + AccountInfo(gomock.Any(), bridgeXRPLAddress). + Return(bridgeXRPLSignerAccountWithSigners, nil) + expectedTx, err := processes.BuildCoreumToXRPLXRPLOriginatedTokenTransferPaymentTxForMultiSigning( + bridgeXRPLAddress, coreumToXRPLTokenTransferOperationWithSignatures, + ) require.NoError(t, err) require.NoError(t, rippledata.SetSigners(expectedTx, coreumToXRPLTokenTransferOperationValidSigners...)) - xrplRPCClientMock.EXPECT().Submit(gomock.Any(), gomock.Any()).Do(func(ctx context.Context, tx rippledata.Transaction) (xrpl.SubmitResult, error) { - _, expectedTxRaw, err := rippledata.Raw(expectedTx) - require.NoError(t, err) - _, txRaw, err := rippledata.Raw(tx) - require.NoError(t, err) - require.Equal(t, expectedTxRaw, txRaw) - return xrpl.SubmitResult{}, nil - }) + xrplRPCClientMock.EXPECT().Submit(gomock.Any(), gomock.Any()).Do( + func(ctx context.Context, tx rippledata.Transaction) (xrpl.SubmitResult, error) { + _, expectedTxRaw, err := rippledata.Raw(expectedTx) + require.NoError(t, err) + _, txRaw, err := rippledata.Raw(tx) + require.NoError(t, err) + require.Equal(t, expectedTxRaw, txRaw) + return xrpl.SubmitResult{}, nil + }) return xrplRPCClientMock }, diff --git a/relayer/runner/runner.go b/relayer/runner/runner.go index 28281a52..b80ecc84 100644 --- a/relayer/runner/runner.go +++ b/relayer/runner/runner.go @@ -227,7 +227,11 @@ func NewRunner(ctx context.Context, cfg Config, kr keyring.Keyring) (*Runner, er if cfg.Coreum.Contract.ContractAddress != "" { contractAddress, err = sdk.AccAddressFromBech32(cfg.Coreum.Contract.ContractAddress) if err != nil { - return nil, errors.Wrapf(err, "failed to decode contract address to sdk.AccAddress, address:%s", cfg.Coreum.Contract.ContractAddress) + return nil, errors.Wrapf( + err, + "failed to decode contract address to sdk.AccAddress, address:%s", + cfg.Coreum.Contract.ContractAddress, + ) } } contractClientCfg := coreum.ContractClientConfig{ @@ -256,9 +260,15 @@ func NewRunner(ctx context.Context, cfg Config, kr keyring.Keyring) (*Runner, er var coreumChainNetworkConfig coreumchainconfig.NetworkConfig if cfg.Coreum.Network.ChainID != "" { - coreumChainNetworkConfig, err = coreumchainconfig.NetworkConfigByChainID(coreumchainconstant.ChainID(cfg.Coreum.Network.ChainID)) + coreumChainNetworkConfig, err = coreumchainconfig.NetworkConfigByChainID( + coreumchainconstant.ChainID(cfg.Coreum.Network.ChainID), + ) if err != nil { - return nil, errors.Wrapf(err, "failed to set get correum network config for the chainID, chainID:%s", cfg.Coreum.Network.ChainID) + return nil, errors.Wrapf( + err, + "failed to set get correum network config for the chainID, chainID:%s", + cfg.Coreum.Network.ChainID, + ) } clientContext = clientContext.WithChainID(cfg.Coreum.Network.ChainID) } @@ -271,7 +281,11 @@ func NewRunner(ctx context.Context, cfg Config, kr keyring.Keyring) (*Runner, er } relayerAddress, err = keyRecord.GetAddress() if err != nil { - return nil, errors.Wrapf(err, "failed to get address from keyring key recodr, key name:%s", cfg.Coreum.RelayerKeyName) + return nil, errors.Wrapf( + err, + "failed to get address from keyring key recodr, key name:%s", + cfg.Coreum.RelayerKeyName, + ) } } contractClient := coreum.NewContractClient(contractClientCfg, zapLogger, clientContext) diff --git a/relayer/xrpl/memo.go b/relayer/xrpl/memo.go index 3d2890f4..95869f42 100644 --- a/relayer/xrpl/memo.go +++ b/relayer/xrpl/memo.go @@ -21,7 +21,8 @@ type BridgeMemo struct { CoreumRecipient string `json:"coreum_recipient"` } -// DecodeCoreumRecipientFromMemo decodes the coreum recipient from memo or returns nil in case the memo is not as expected. +// DecodeCoreumRecipientFromMemo decodes the coreum recipient from memo or returns nil in case the memo +// is not as expected. func DecodeCoreumRecipientFromMemo(memos rippledata.Memos) sdk.AccAddress { var bridgeMemo BridgeMemo for _, memo := range memos { diff --git a/relayer/xrpl/rpc.go b/relayer/xrpl/rpc.go index 12f19d7e..4843dae5 100644 --- a/relayer/xrpl/rpc.go +++ b/relayer/xrpl/rpc.go @@ -259,7 +259,12 @@ func (c *RPCClient) LedgerCurrent(ctx context.Context) (LedgerCurrentResult, err // AccountTx returns paginated account transactions. // Use minLedger -1 for the earliest ledger available. // Use maxLedger -1 for the most recent validated ledger. -func (c *RPCClient) AccountTx(ctx context.Context, account rippledata.Account, minLedger, maxLedger int64, marker map[string]any) (AccountTxResult, error) { +func (c *RPCClient) AccountTx( + ctx context.Context, + account rippledata.Account, + minLedger, maxLedger int64, + marker map[string]any, +) (AccountTxResult, error) { params := AccountTxRequest{ Account: account, MinLedger: minLedger, diff --git a/relayer/xrpl/scanner.go b/relayer/xrpl/scanner.go index 97ee40b4..e23be613 100644 --- a/relayer/xrpl/scanner.go +++ b/relayer/xrpl/scanner.go @@ -16,7 +16,12 @@ import ( // RPCTxProvider is RPC transactions provider. type RPCTxProvider interface { LedgerCurrent(ctx context.Context) (LedgerCurrentResult, error) - AccountTx(ctx context.Context, account rippledata.Account, minLedger, maxLedger int64, marker map[string]any) (AccountTxResult, error) + AccountTx( + ctx context.Context, + account rippledata.Account, + minLedger, maxLedger int64, + marker map[string]any, + ) (AccountTxResult, error) } // AccountScannerConfig is the AccountScanner config. @@ -87,7 +92,11 @@ func (s *AccountScanner) ScanTxs(ctx context.Context, ch chan<- rippledata.Trans return nil } -func (s *AccountScanner) scanRecentHistory(ctx context.Context, currentLedger int64, ch chan<- rippledata.TransactionWithMetaData) { +func (s *AccountScanner) scanRecentHistory( + ctx context.Context, + currentLedger int64, + ch chan<- rippledata.TransactionWithMetaData, +) { // in case we don't have enough ledges for the window we start from the initla minLedger := int64(0) if currentLedger > s.cfg.RecentScanWindow { @@ -112,7 +121,11 @@ func (s *AccountScanner) scanFullHistory(ctx context.Context, ch chan<- rippleda }) } -func (s *AccountScanner) scanTransactions(ctx context.Context, minLedger int64, ch chan<- rippledata.TransactionWithMetaData) int64 { +func (s *AccountScanner) scanTransactions( + ctx context.Context, + minLedger int64, + ch chan<- rippledata.TransactionWithMetaData, +) int64 { if minLedger <= 0 { minLedger = -1 } @@ -139,7 +152,11 @@ func (s *AccountScanner) scanTransactions(ctx context.Context, minLedger int64, return lastLedger } // this panic is unexpected - panic(errors.Wrapf(err, "unexpected error received for the get account transactions with retry, err:%s", err.Error())) + panic(errors.Wrapf( + err, + "unexpected error received for the get account transactions with retry, err:%s", + err.Error(), + )) } // we accept the transaction from the validated ledger only if accountTxResult.Validated { diff --git a/relayer/xrpl/scanner_test.go b/relayer/xrpl/scanner_test.go index 829c3cd0..9f7c915d 100644 --- a/relayer/xrpl/scanner_test.go +++ b/relayer/xrpl/scanner_test.go @@ -46,7 +46,12 @@ func TestAccountScanner_ScanTxs(t *testing.T) { mockedProvider := NewMockRPCTxProvider(ctrl) callNumber := 0 mockedProvider.EXPECT().AccountTx(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn( - func(ctx context.Context, account rippledata.Account, minLedger, maxLedger int64, marker map[string]any) (xrpl.AccountTxResult, error) { + func( + ctx context.Context, + account rippledata.Account, + minLedger, maxLedger int64, + marker map[string]any, + ) (xrpl.AccountTxResult, error) { callNumber++ switch callNumber { case 1: @@ -99,7 +104,12 @@ func TestAccountScanner_ScanTxs(t *testing.T) { callNumber := 0 mockedProvider.EXPECT().AccountTx(gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any(), gomock.Any()).DoAndReturn( - func(ctx context.Context, account rippledata.Account, minLedger, maxLedger int64, marker map[string]any) (xrpl.AccountTxResult, error) { + func( + ctx context.Context, + account rippledata.Account, + minLedger, maxLedger int64, + marker map[string]any, + ) (xrpl.AccountTxResult, error) { callNumber++ switch callNumber { case 1: @@ -185,7 +195,12 @@ func TestAccountScanner_ScanTxs(t *testing.T) { } } -func readTxHashesFromChannels(ctx context.Context, t *testing.T, txsCh chan rippledata.TransactionWithMetaData, count int) map[string]struct{} { +func readTxHashesFromChannels( + ctx context.Context, + t *testing.T, + txsCh chan rippledata.TransactionWithMetaData, + count int, +) map[string]struct{} { gotTxHashes := make(map[string]struct{}) for { select { diff --git a/relayer/xrpl/signer_test.go b/relayer/xrpl/signer_test.go index f1f9260a..ff11cc7c 100644 --- a/relayer/xrpl/signer_test.go +++ b/relayer/xrpl/signer_test.go @@ -14,6 +14,7 @@ import ( "github.com/CoreumFoundation/coreumbridge-xrpl/relayer/xrpl" ) +//nolint:lll // test contains mnemonics and long hashes. func TestKeyringTxSigner_MultiSignWithSignatureVerification(t *testing.T) { t.Parallel() @@ -92,7 +93,11 @@ func TestPrivKeyTxSigner_MultiSignWithSignatureVerification(t *testing.T) { require.True(t, valid) } -func buildPaymentTx(recipientAccount *rippledata.Account, xrpAmount *rippledata.Amount, signerAcc rippledata.Account) rippledata.Payment { +func buildPaymentTx( + recipientAccount *rippledata.Account, + xrpAmount *rippledata.Amount, + signerAcc rippledata.Account, +) rippledata.Payment { return rippledata.Payment{ Destination: *recipientAccount, Amount: *xrpAmount,