feat: add gas estimation to client (#66)

* Add gas estimation to client

* Add estimation logic

* Remove leftover code

* Resolve linter

* Remove leftover comment

* Add ratios

Author: zivkovicmilos

internal/client/client.go

@@ -5,12 +5,15 @@ import (
 
 	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	"github.com/gnolang/gno/tm2/pkg/amino"
+	abci "github.com/gnolang/gno/tm2/pkg/bft/abci/types"
 	"github.com/gnolang/gno/tm2/pkg/bft/rpc/client"
 	core_types "github.com/gnolang/gno/tm2/pkg/bft/rpc/core/types"
 	"github.com/gnolang/gno/tm2/pkg/std"
 	"github.com/gnolang/supernova/internal/common"
 )
 
+const simulatePath = ".app/simulate"
+
 type Client struct {
 	conn *client.RPCClient
 }
@@ -133,3 +136,37 @@ func (h *Client) GetBlockGasLimit(height int64) (int64, error) {
 
 	return consensusParams.ConsensusParams.Block.MaxGas, nil
 }
+
+func (h *Client) EstimateGas(tx *std.Tx) (int64, error) {
+	// Prepare the transaction.
+	// The transaction needs to be amino-binary encoded
+	// in order to be estimated
+	encodedTx, err := amino.Marshal(tx)
+	if err != nil {
+		return 0, fmt.Errorf("unable to marshal tx: %w", err)
+	}
+
+	// Perform the simulation query
+	resp, err := h.conn.ABCIQuery(simulatePath, encodedTx)
+	if err != nil {
+		return 0, fmt.Errorf("unable to perform ABCI query: %w", err)
+	}
+
+	// Extract the query response
+	if err = resp.Response.Error; err != nil {
+		return 0, fmt.Errorf("error encountered during ABCI query: %w", err)
+	}
+
+	var deliverTx abci.ResponseDeliverTx
+	if err = amino.Unmarshal(resp.Response.Value, &deliverTx); err != nil {
+		return 0, fmt.Errorf("unable to unmarshal gas estimation response: %w", err)
+	}
+
+	if err = deliverTx.Error; err != nil {
+		return 0, fmt.Errorf("error encountered during gas estimation: %w", err)
+	}
+
+	// Return the actual value returned by the node
+	// for executing the transaction
+	return deliverTx.GasUsed, nil
+}

internal/common/common.go

@@ -4,23 +4,27 @@ import "github.com/gnolang/gno/tm2/pkg/std"
 
 const Denomination = "ugnot"
 
-// TODO support estimating gas params
-// These are constants for now,
-// but should be fetched as estimations
-// from the Tendermint node once this functionality
-// is available.
-//
-// Each package call / deployment
-// costs a fixed 1 GNOT
-// https://github.com/gnolang/gno/issues/649
-var (
-	DefaultGasFee = std.Coin{
+// DefaultGasPrice represents the gno.land chain's
+// default minimum gas price ratio, which is 0.001ugnot/gas
+var DefaultGasPrice = std.GasPrice{
+	Gas: 1000,
+	Price: std.Coin{
 		Denom:  Denomination,
 		Amount: 1,
-	}
+	},
+}
 
-	InitialTxCost = std.Coin{
-		Denom:  Denomination,
-		Amount: 1000000, // 1 GNOT
+// CalculateFeeInRatio calculates the minimum gas fee that should be specified
+// in a transaction, given the gas wanted (of the tx) and the reference gas ratio
+func CalculateFeeInRatio(gasWanted int64, reference std.GasPrice) std.Fee {
+	// required amount = ceil((gas wanted * reference.Price.Amount) / reference.Gas)
+	requiredAmount := (gasWanted*reference.Price.Amount + reference.Gas - 1) / reference.Gas
+
+	return std.Fee{
+		GasWanted: gasWanted,
+		GasFee: std.Coin{
+			Denom:  reference.Price.Denom,
+			Amount: requiredAmount,
+		},
 	}
-)
+}

internal/distributor/distributor.go

@@ -19,6 +19,7 @@ var errInsufficientFunds = errors.New("insufficient distributor funds")
 type Client interface {
 	GetAccount(address string) (*gnoland.GnoAccount, error)
 	BroadcastTransaction(tx *std.Tx) error
+	EstimateGas(tx *std.Tx) (int64, error)
 }
 
 // Distributor is the process
@@ -66,13 +67,13 @@ func calculateRuntimeCosts(totalTx int64) std.Coin {
 	// NOTE: Since there is no gas estimation support yet, this value
 	// is fixed, but it will change in the future once pricing estimations
 	// are added
-	baseTxCost := common.DefaultGasFee.Add(common.InitialTxCost)
+	baseTxCost := common.CalculateFeeInRatio(1_000_000, common.DefaultGasPrice)
 
 	// Each account should have enough funds
 	// to execute the entire run
 	subAccountCost := std.Coin{
 		Denom:  common.Denomination,
-		Amount: totalTx * baseTxCost.Amount,
+		Amount: totalTx * baseTxCost.GasFee.Amount,
 	}
 
 	return subAccountCost
@@ -146,12 +147,15 @@ func (d *Distributor) fundAccounts(
 		return nil, fmt.Errorf("unable to fetch distributor account, %w", err)
 	}
 
-	distributorBalance := distributor.Coins
-	fundableIndex := 0
+	var (
+		distributorBalance = distributor.Coins
+		fundableIndex      = 0
+		defaultFee         = common.CalculateFeeInRatio(100_000, common.DefaultGasPrice)
+	)
 
 	for _, account := range shortAccounts {
-		// The transfer cost is the single run cost (missing balance) + 1ugnot fee (fixed)
-		transferCost := std.NewCoins(common.DefaultGasFee.Add(account.missingFunds))
+		// The transfer cost is the single run cost (missing balance) + approximate transfer cost
+		transferCost := std.NewCoins(defaultFee.GasFee.Add(account.missingFunds))
 
 		if distributorBalance.IsAllLT(transferCost) {
 			// Distributor does not have any more funds
@@ -176,13 +180,10 @@ func (d *Distributor) fundAccounts(
 		return nil, errInsufficientFunds
 	}
 
-	var (
-		// Locally keep track of the nonce, so
-		// there is no need to re-fetch the account again
-		// before signing a future tx
-		nonce      = distributor.Sequence
-		defaultFee = std.NewFee(100000, common.DefaultGasFee)
-	)
+	// Locally keep track of the nonce, so
+	// there is no need to re-fetch the account again
+	// before signing a future tx
+	nonce := distributor.Sequence
 
 	fmt.Printf("Funding %d accounts...\n", len(shortAccounts))
 	bar := progressbar.Default(int64(len(shortAccounts)), "funding short accounts")

internal/distributor/distributor_test.go

@@ -148,12 +148,14 @@ func TestDistributor_Distribute(t *testing.T) {
 					}
 
 					if acc.Equals(accounts[0]) {
+						sendCost := common.CalculateFeeInRatio(100_000, common.DefaultGasPrice)
+
 						return &gnoland.GnoAccount{
 							BaseAccount: *std.NewBaseAccount(
 								acc.PubKey().Address(),
 								std.NewCoins(std.Coin{
 									Denom:  common.Denomination,
-									Amount: int64(numTx) * common.DefaultGasFee.Add(singleCost).Amount,
+									Amount: int64(numTx) * sendCost.GasFee.Add(singleCost).Amount,
 								}),
 								nil,
 								0,

internal/distributor/mock_test.go

@@ -8,11 +8,13 @@ import (
 type (
 	broadcastTransactionDelegate func(*std.Tx) error
 	getAccountDelegate           func(string) (*gnoland.GnoAccount, error)
+	estimateGasDelegate          func(*std.Tx) (int64, error)
 )
 
 type mockClient struct {
 	broadcastTransactionFn broadcastTransactionDelegate
 	getAccountFn           getAccountDelegate
+	estimateGasFn          estimateGasDelegate
 }
 
 func (m *mockClient) BroadcastTransaction(tx *std.Tx) error {
@@ -30,3 +32,11 @@ func (m *mockClient) GetAccount(address string) (*gnoland.GnoAccount, error) {
 
 	return nil, nil
 }
+
+func (m *mockClient) EstimateGas(tx *std.Tx) (int64, error) {
+	if m.estimateGasFn != nil {
+		return m.estimateGasFn(tx)
+	}
+
+	return 0, nil
+}

internal/pipeline.go

@@ -110,6 +110,7 @@ func (p *Pipeline) Execute() error {
 		runAccounts,
 		p.cfg.Transactions,
 		p.cfg.ChainID,
+		p.cli.EstimateGas,
 	)
 	if err != nil {
 		return fmt.Errorf("unable to construct transactions, %w", err)
@@ -205,7 +206,12 @@ func prepareRuntime(
 	}
 
 	// Get the predeploy transactions
-	predeployTxs, err := txRuntime.Initialize(deployer, deployerKey, chainID)
+	predeployTxs, err := txRuntime.Initialize(
+		deployer,
+		deployerKey,
+		chainID,
+		cli.EstimateGas,
+	)
 	if err != nil {
 		return fmt.Errorf("unable to initialize runtime, %w", err)
 	}

internal/runtime/helper.go

@@ -5,10 +5,13 @@ import (
 
 	"github.com/gnolang/gno/tm2/pkg/crypto"
 	"github.com/gnolang/gno/tm2/pkg/std"
+	"github.com/gnolang/supernova/internal/common"
 	"github.com/gnolang/supernova/internal/signer"
 	"github.com/schollz/progressbar/v3"
 )
 
+const gasBuffer = 10_000 // 10k gas
+
 // msgFn defines the transaction message constructor
 type msgFn func(creator std.Account, index int) std.Msg
 
@@ -20,6 +23,7 @@ func constructTransactions(
 	transactions uint64,
 	chainID string,
 	getMsg msgFn,
+	estimateFn EstimateGasFn,
 ) ([]*std.Tx, error) {
 	var (
 		txs = make([]*std.Tx, transactions)
@@ -30,6 +34,53 @@ func constructTransactions(
 		nonceMap = make(map[uint64]uint64) // accountNumber -> nonce
 	)
 
+	fmt.Printf("\n⏳ Estimating Gas ⏳\n")
+
+	// Estimate the fee for the transaction batch
+	txFee := common.CalculateFeeInRatio(
+		1_000_000,
+		common.DefaultGasPrice,
+	)
+
+	// Construct the first tx
+	var (
+		creator    = accounts[0]
+		creatorKey = keys[0]
+	)
+
+	tx := &std.Tx{
+		Msgs: []std.Msg{getMsg(creator, 0)},
+		Fee:  txFee,
+	}
+
+	// Sign the transaction
+	cfg := signer.SignCfg{
+		ChainID:       chainID,
+		AccountNumber: creator.GetAccountNumber(),
+		Sequence:      creator.GetSequence(),
+	}
+
+	if err := signer.SignTx(tx, creatorKey, cfg); err != nil {
+		return nil, fmt.Errorf("unable to sign transaction, %w", err)
+	}
+
+	gasWanted, err := estimateFn(tx)
+	if err != nil {
+		return nil, fmt.Errorf("unable to estimate gas, %w", err)
+	}
+
+	// Clear the old signatures, because they need
+	// to be regenerated
+	clear(tx.Signatures)
+
+	// Use the estimated gas limit
+	txFee = common.CalculateFeeInRatio(gasWanted+gasBuffer, common.DefaultGasPrice) // 10k gas buffer
+
+	if err = signer.SignTx(tx, creatorKey, cfg); err != nil {
+		return nil, fmt.Errorf("unable to sign transaction, %w", err)
+	}
+
+	fmt.Printf("\nEstimated Gas for 1 run tx: %d \n", tx.Fee.GasWanted)
 	fmt.Printf("\n🔨 Constructing Transactions 🔨\n\n")
 
 	bar := progressbar.Default(int64(transactions), "constructing txs")
@@ -44,7 +95,7 @@ func constructTransactions(
 
 		tx := &std.Tx{
 			Msgs: []std.Msg{getMsg(creator, i)},
-			Fee:  defaultDeployTxFee,
+			Fee:  txFee,
 		}
 
 		// Fetch the next account nonce

internal/runtime/helper_test.go

@@ -6,6 +6,7 @@ import (
 	"github.com/gnolang/gno/gno.land/pkg/gnoland"
 	"github.com/gnolang/gno/gno.land/pkg/sdk/vm"
 	"github.com/gnolang/gno/tm2/pkg/std"
+	"github.com/gnolang/supernova/internal/common"
 	testutils "github.com/gnolang/supernova/internal/testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -49,15 +50,28 @@ func TestHelper_ConstructTransactions(t *testing.T) {
 		}
 	)
 
-	txs, err := constructTransactions(accountKeys, accounts, transactions, "dummy", getMsgFn)
+	txs, err := constructTransactions(
+		accountKeys,
+		accounts,
+		transactions,
+		"dummy",
+		getMsgFn,
+		func(_ *std.Tx) (int64, error) {
+			return 1_000_000, nil
+		},
+	)
 	require.NoError(t, err)
 
 	assert.Len(t, txs, int(transactions))
 
 	// Make sure the constructed transactions are valid
 	for _, tx := range txs {
 		// Make sure the fee is valid
-		assert.Equal(t, defaultDeployTxFee, tx.Fee)
+		assert.Equal(
+			t,
+			common.CalculateFeeInRatio(1_000_000+gasBuffer, common.DefaultGasPrice),
+			tx.Fee,
+		)
 
 		// Make sure the message is valid
 		if len(tx.Msgs) != 1 {

internal/runtime/package_deployment.go

@@ -20,6 +20,7 @@ func (c *packageDeployment) Initialize(
 	_ std.Account,
 	_ crypto.PrivKey,
 	_ string,
+	_ EstimateGasFn,
 ) ([]*std.Tx, error) {
 	// No extra setup needed for this runtime type
 	return nil, nil
@@ -30,6 +31,7 @@ func (c *packageDeployment) ConstructTransactions(
 	accounts []std.Account,
 	transactions uint64,
 	chainID string,
+	estimateFn EstimateGasFn,
 ) ([]*std.Tx, error) {
 	var (
 		timestamp = time.Now().Unix()
@@ -65,5 +67,6 @@ func (c *packageDeployment) ConstructTransactions(
 		transactions,
 		chainID,
 		getMsgFn,
+		estimateFn,
 	)
 }