Reestimate deterministic gas

integration-tests/modules/bank_test.go

@@ -812,6 +812,104 @@ func TestBankCoreSend(t *testing.T) {
 	assert.Equal(t, recipientInitialAmount.Add(amountToSend).String(), balancesRecipient.Balance.Amount.String())
 }
 
+// TestBankSendEstimation is used to estimate gas required by each additional token present in bank send message.
+// It executes transactions sending from 1 to 201 tokens in single message and reports gas estimated by each of them.
+// Then you may copy the results to a spreadsheet and calculate the gas required by each transfer.
+// Spreadsheet example might be found here: https://docs.google.com/spreadsheets/d/1qoKa8udTPYdS_-ofJ8xNbnZFDh-gqGb4n0_OgcTHUOA/edit?usp=sharing
+// Keep in mind that to estimate the gas you need to move bank send message to nondeterministic section inside deterministic gas config.
+func TestBankSendEstimation(t *testing.T) {
+	const (
+		nTokens = 201
+		step    = 10
+	)
+
+	requireT := require.New(t)
+
+	ctx, chain := integrationtests.NewCoreumTestingContext(t)
+
+	issuer := chain.GenAccount()
+	recipient1 := chain.GenAccount()
+	recipient2 := chain.GenAccount()
+
+	tokens := make([]string, 0, nTokens)
+	deterministicMsgs := make([]sdk.Msg, 0, 3*nTokens)
+	sendMsg := &banktypes.MsgSend{
+		FromAddress: issuer.String(),
+		ToAddress:   recipient1.String(),
+	}
+	initialAmount := sdkmath.NewInt(100_000_000_000)
+	for i := 0; i < nTokens; i++ {
+		subunit := fmt.Sprintf("tok%d", i)
+		denom := assetfttypes.BuildDenom(subunit, issuer)
+		deterministicMsgs = append(deterministicMsgs, &assetfttypes.MsgIssue{
+			Issuer:        issuer.String(),
+			Symbol:        fmt.Sprintf("TOK%d", i),
+			Subunit:       fmt.Sprintf("tok%d", i),
+			Precision:     1,
+			Description:   fmt.Sprintf("TOK%d", i),
+			InitialAmount: initialAmount,
+			Features: []assetfttypes.Feature{
+				assetfttypes.Feature_minting,
+				assetfttypes.Feature_burning,
+				assetfttypes.Feature_freezing,
+				assetfttypes.Feature_whitelisting,
+				assetfttypes.Feature_ibc,
+			},
+			BurnRate:           sdkmath.LegacyMustNewDecFromStr("0.01"),
+			SendCommissionRate: sdkmath.LegacyMustNewDecFromStr("0.01"),
+		}, &assetfttypes.MsgSetWhitelistedLimit{
+			Sender:  issuer.String(),
+			Account: recipient1.String(),
+			Coin:    sdk.NewInt64Coin(denom, 1_000_000_000_000),
+		}, &assetfttypes.MsgSetWhitelistedLimit{
+			Sender:  issuer.String(),
+			Account: recipient2.String(),
+			Coin:    sdk.NewInt64Coin(denom, 1_000_000_000_000),
+		})
+
+		tokens = append(tokens, assetfttypes.BuildDenom(subunit, issuer))
+		sendMsg.Amount = sendMsg.Amount.Add(sdk.NewCoin(denom, initialAmount))
+	}
+
+	chain.FundAccountWithOptions(ctx, t, issuer, integrationtests.BalancesOptions{
+		Messages: deterministicMsgs,
+		Amount:   chain.QueryAssetFTParams(ctx, t).IssueFee.Amount.MulRaw(nTokens).AddRaw(1_000_000_000),
+	})
+
+	chain.FundAccountWithOptions(ctx, t, recipient1, integrationtests.BalancesOptions{
+		Amount: sdk.NewIntFromUint64(1_000_000_000),
+	})
+
+	_, err := client.BroadcastTx(
+		ctx,
+		chain.ClientContext.WithFromAddress(issuer),
+		chain.TxFactory().WithGas(chain.GasLimitByMsgs(deterministicMsgs...)+5_000_000),
+		append(append([]sdk.Msg{}, deterministicMsgs...), sendMsg)...,
+	)
+	requireT.NoError(err)
+
+	for n := 1; n <= nTokens; n += step {
+		sendMsg := &banktypes.MsgSend{
+			FromAddress: recipient1.String(),
+			ToAddress:   recipient2.String(),
+		}
+
+		for i := 0; i < n; i++ {
+			sendMsg.Amount = sendMsg.Amount.Add(sdk.NewCoin(tokens[i], sdkmath.NewInt(1_0000_000)))
+		}
+
+		txRes, err := client.BroadcastTx(
+			ctx,
+			chain.ClientContext.WithFromAddress(recipient1),
+			chain.TxFactory().WithGas(50_000_000),
+			sendMsg,
+		)
+		requireT.NoError(err)
+
+		fmt.Printf("%d\t%d\n", n, txRes.GasUsed)
+	}
+}
+
 func assertBatchAccounts(
 	ctx context.Context,
 	chain integrationtests.CoreumChain,

x/deterministicgas/README.md

@@ -0,0 +1,14 @@
+# Gas estimation procedure
+
+After every upgrade of Cosmos SDK (or whenever we decide) we should verify that our deterministic gas estimations for messages are correct.
+
+To do it:
+1. Modify crust to deploy `explorer` and `monitoring` profiles when integration tests are started
+2. Run integration tests
+3. Go to our Grafana dashboard in `znet`
+4. Take values for deterministic gas factors reported there
+5. Recalculate the deterministic gas by multiplying it by the minimum value taken from the metric.
+
+If there is huge divergence between min and max values reported, reason should be identified.
+
+For Bank Send message we have integration test `TestBankSendEstimation` used to estimate the gas required by each additional coin present in the message.

x/deterministicgas/config.go

@@ -32,8 +32,8 @@ import (
 
 // These constants define gas for messages which have custom calculation logic.
 const (
-	BankSendPerCoinGas            = 24000
-	BankMultiSendPerOperationsGas = 11000
+	BankSendPerCoinGas            = 50000
+	BankMultiSendPerOperationsGas = 35000
 	AuthzExecOverhead             = 2000
 )
 
@@ -66,101 +66,107 @@ func DefaultConfig() Config {
 		FreeSignatures: 1,
 	}
 
-	// FIXME(v47-deterministic): re-estimate and update all values + regenerate doc
 	cfg.gasByMsg = map[MsgURL]gasByMsgFunc{
 		// asset/ft
 		MsgToMsgURL(&assetfttypes.MsgIssue{}):               constantGasFunc(70000),
-		MsgToMsgURL(&assetfttypes.MsgMint{}):                constantGasFunc(11000),
-		MsgToMsgURL(&assetfttypes.MsgBurn{}):                constantGasFunc(23000),
-		MsgToMsgURL(&assetfttypes.MsgFreeze{}):              constantGasFunc(5000),
-		MsgToMsgURL(&assetfttypes.MsgUnfreeze{}):            constantGasFunc(2500),
-		MsgToMsgURL(&assetfttypes.MsgGloballyFreeze{}):      constantGasFunc(5000),
+		MsgToMsgURL(&assetfttypes.MsgMint{}):                constantGasFunc(11000 * 2.78),
+		MsgToMsgURL(&assetfttypes.MsgBurn{}):                constantGasFunc(23000 * 1.52),
+		MsgToMsgURL(&assetfttypes.MsgFreeze{}):              constantGasFunc(5000 * 1.72),
+		MsgToMsgURL(&assetfttypes.MsgUnfreeze{}):            constantGasFunc(2500 * 1.54),
+		MsgToMsgURL(&assetfttypes.MsgGloballyFreeze{}):      constantGasFunc(5000 * 1.04),
 		MsgToMsgURL(&assetfttypes.MsgGloballyUnfreeze{}):    constantGasFunc(2500),
-		MsgToMsgURL(&assetfttypes.MsgSetWhitelistedLimit{}): constantGasFunc(5000),
-		MsgToMsgURL(&assetfttypes.MsgUpgradeTokenV1{}):      constantGasFunc(25000),
+		MsgToMsgURL(&assetfttypes.MsgSetWhitelistedLimit{}): constantGasFunc(5000 * 1.76),
+		// TODO: Reestimate when next token upgrade is prepared
+		MsgToMsgURL(&assetfttypes.MsgUpgradeTokenV1{}): constantGasFunc(25000),
 
 		// asset/nft
-		MsgToMsgURL(&assetnfttypes.MsgBurn{}):                constantGasFunc(16000),
+		MsgToMsgURL(&assetnfttypes.MsgBurn{}):                constantGasFunc(16000 * 1.64),
 		MsgToMsgURL(&assetnfttypes.MsgIssueClass{}):          constantGasFunc(16000),
 		MsgToMsgURL(&assetnfttypes.MsgMint{}):                constantGasFunc(39000),
-		MsgToMsgURL(&assetnfttypes.MsgFreeze{}):              constantGasFunc(7000),
+		MsgToMsgURL(&assetnfttypes.MsgFreeze{}):              constantGasFunc(7000 * 1.19),
 		MsgToMsgURL(&assetnfttypes.MsgUnfreeze{}):            constantGasFunc(5000),
 		MsgToMsgURL(&assetnfttypes.MsgAddToWhitelist{}):      constantGasFunc(7000),
 		MsgToMsgURL(&assetnfttypes.MsgRemoveFromWhitelist{}): constantGasFunc(3500),
 
 		// authz
+		// FIXME (v47-deterministic): We need a procedure to estimate the overhead of the authz. Proposal:
+		// 1. Estimate normal message
+		// 2. Estimate the same message executed using authz
+		// 3. Subtract one from the other
+		// We should have an integration test doing this.
 		MsgToMsgURL(&authz.MsgExec{}):   cfg.authzMsgExecGasFunc(AuthzExecOverhead),
-		MsgToMsgURL(&authz.MsgGrant{}):  constantGasFunc(7000),
-		MsgToMsgURL(&authz.MsgRevoke{}): constantGasFunc(2500),
+		MsgToMsgURL(&authz.MsgGrant{}):  constantGasFunc(7000 * 3.95),
+		MsgToMsgURL(&authz.MsgRevoke{}): constantGasFunc(2500 * 3.19),
 
 		// bank
 		MsgToMsgURL(&banktypes.MsgSend{}):      bankSendMsgGasFunc(BankSendPerCoinGas),
 		MsgToMsgURL(&banktypes.MsgMultiSend{}): bankMultiSendMsgGasFunc(BankMultiSendPerOperationsGas),
 
 		// distribution
-		MsgToMsgURL(&distributiontypes.MsgFundCommunityPool{}):           constantGasFunc(15000),
+		MsgToMsgURL(&distributiontypes.MsgFundCommunityPool{}):           constantGasFunc(15000 * 1.11),
 		MsgToMsgURL(&distributiontypes.MsgSetWithdrawAddress{}):          constantGasFunc(5000),
-		MsgToMsgURL(&distributiontypes.MsgWithdrawDelegatorReward{}):     constantGasFunc(65000),
+		MsgToMsgURL(&distributiontypes.MsgWithdrawDelegatorReward{}):     constantGasFunc(65000 * 1.21),
 		MsgToMsgURL(&distributiontypes.MsgWithdrawValidatorCommission{}): constantGasFunc(22000),
 
 		// feegrant
-		MsgToMsgURL(&feegranttypes.MsgGrantAllowance{}):  constantGasFunc(10000),
+		MsgToMsgURL(&feegranttypes.MsgGrantAllowance{}):  constantGasFunc(10000 * 1.10),
 		MsgToMsgURL(&feegranttypes.MsgRevokeAllowance{}): constantGasFunc(2500),
 
 		// gov
 		// FIXME(v47-deterministic): check that if we want to support both go types
-		MsgToMsgURL(&govtypesv1beta1.MsgVote{}):         constantGasFunc(7000),
+		MsgToMsgURL(&govtypesv1beta1.MsgVote{}):         constantGasFunc(7000 * 0.88),
 		MsgToMsgURL(&govtypesv1beta1.MsgVoteWeighted{}): constantGasFunc(9000),
-		MsgToMsgURL(&govtypesv1beta1.MsgDeposit{}):      constantGasFunc(52000),
+		MsgToMsgURL(&govtypesv1beta1.MsgDeposit{}):      constantGasFunc(52000 * 1.63),
 
-		MsgToMsgURL(&govtypesv1.MsgVote{}):         constantGasFunc(7000),
-		MsgToMsgURL(&govtypesv1.MsgVoteWeighted{}): constantGasFunc(9000),
-		MsgToMsgURL(&govtypesv1.MsgDeposit{}):      constantGasFunc(52000),
+		MsgToMsgURL(&govtypesv1.MsgVote{}):         constantGasFunc(7000 * 0.88),
+		MsgToMsgURL(&govtypesv1.MsgVoteWeighted{}): constantGasFunc(9000 * 0.72),
+		// FIXME (v47-deterministic): We must add integration test executing this message to have data to analyze
+		MsgToMsgURL(&govtypesv1.MsgDeposit{}): constantGasFunc(52000),
 
 		// nft
-		MsgToMsgURL(&nfttypes.MsgSend{}): constantGasFunc(16000),
+		MsgToMsgURL(&nfttypes.MsgSend{}): constantGasFunc(16000 * 1.55),
 
 		// slashing
+		// FIXME (v47-deterministic): We must add integration test executing this message to have data to analyze
 		MsgToMsgURL(&slashingtypes.MsgUnjail{}): constantGasFunc(25000),
 
 		// staking
-		MsgToMsgURL(&stakingtypes.MsgDelegate{}):        constantGasFunc(69000),
+		MsgToMsgURL(&stakingtypes.MsgDelegate{}):        constantGasFunc(69000 * 1.21),
 		MsgToMsgURL(&stakingtypes.MsgUndelegate{}):      constantGasFunc(112000),
-		MsgToMsgURL(&stakingtypes.MsgBeginRedelegate{}): constantGasFunc(142000),
-		MsgToMsgURL(&stakingtypes.MsgCreateValidator{}): constantGasFunc(76000),
+		MsgToMsgURL(&stakingtypes.MsgBeginRedelegate{}): constantGasFunc(142000 * 1.11),
+		MsgToMsgURL(&stakingtypes.MsgCreateValidator{}): constantGasFunc(76000 * 1.54),
 		MsgToMsgURL(&stakingtypes.MsgEditValidator{}):   constantGasFunc(13000),
 
 		// vesting
-		MsgToMsgURL(&vestingtypes.MsgCreateVestingAccount{}): constantGasFunc(25000),
+		MsgToMsgURL(&vestingtypes.MsgCreateVestingAccount{}): constantGasFunc(25000 * 1.2),
 
 		// wasm
 		MsgToMsgURL(&wasmtypes.MsgUpdateAdmin{}): constantGasFunc(8000),
 		MsgToMsgURL(&wasmtypes.MsgClearAdmin{}):  constantGasFunc(6500),
 
 		// ibc transfer
-		MsgToMsgURL(&ibctransfertypes.MsgTransfer{}): constantGasFunc(37000),
+		MsgToMsgURL(&ibctransfertypes.MsgTransfer{}): constantGasFunc(37000 * 1.47),
 	}
 
-	// FIXME(v47-deterministic): validate all new un-deterministic messages and move to deterministic if possible
 	registerNondeterministicGasFuncs(
 		&cfg,
 		[]sdk.Msg{
 			// auth
-			&authtypes.MsgUpdateParams{},
+			&authtypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// bank
-			&banktypes.MsgSetSendEnabled{},
-			&banktypes.MsgUpdateParams{},
+			&banktypes.MsgSetSendEnabled{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
+			&banktypes.MsgUpdateParams{},   // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// consensus
-			&consensustypes.MsgUpdateParams{},
+			&consensustypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// crisis
-			&crisistypes.MsgUpdateParams{},
+			&crisistypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// distribution
-			&distributiontypes.MsgUpdateParams{},
-			&distributiontypes.MsgCommunityPoolSpend{},
+			&distributiontypes.MsgUpdateParams{},       // This is non-deterministic because all the gov proposals are non-deterministic anyway
+			&distributiontypes.MsgCommunityPoolSpend{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// gov
 			// MsgSubmitProposal is defined as nondeterministic because it runs a proposal handler function
@@ -170,7 +176,7 @@ func DefaultConfig() Config {
 			// FIXME(v47-deterministic): check that if we want to support both go types
 			&govtypesv1.MsgSubmitProposal{},
 			&govtypesv1.MsgExecLegacyContent{},
-			&govtypesv1.MsgUpdateParams{},
+			&govtypesv1.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// crisis
 			// MsgVerifyInvariant is defined as nondeterministic since fee
@@ -184,22 +190,22 @@ func DefaultConfig() Config {
 			&evidencetypes.MsgSubmitEvidence{},
 
 			// mint
-			&minttypes.MsgUpdateParams{},
+			&minttypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// staking
-			&stakingtypes.MsgUpdateParams{},
+			&stakingtypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 			// FIXME(v47-deterministic): add message to deterministic (we have separate task for it)
 			&stakingtypes.MsgCancelUnbondingDelegation{},
 
 			// slashing
-			&slashingtypes.MsgUpdateParams{},
+			&slashingtypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// slashing
-			&slashingtypes.MsgUpdateParams{},
+			&slashingtypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// upgrade
-			&upgradetypes.MsgCancelUpgrade{},
-			&upgradetypes.MsgSoftwareUpgrade{},
+			&upgradetypes.MsgCancelUpgrade{},   // This is non-deterministic because all the gov proposals are non-deterministic anyway
+			&upgradetypes.MsgSoftwareUpgrade{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 
 			// vesting
 			// FIXME(v47-deterministic): add message to deterministic (we have separate task for it)
@@ -216,7 +222,7 @@ func DefaultConfig() Config {
 			&wasmtypes.MsgIBCSend{},
 			&wasmtypes.MsgIBCCloseChannel{},
 			&wasmtypes.MsgUpdateInstantiateConfig{},
-			&wasmtypes.MsgUpdateParams{},
+			&wasmtypes.MsgUpdateParams{}, // This is non-deterministic because all the gov proposals are non-deterministic anyway
 			&wasmtypes.MsgUnpinCodes{},
 			&wasmtypes.MsgPinCodes{},
 			&wasmtypes.MsgSudoContract{},