Resolve linter

Author: zivkovicmilos

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/runtime/helper.go

@@ -9,6 +9,8 @@ import (
 	"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
 
@@ -31,7 +33,7 @@ func constructTransactions(
 		nonceMap = make(map[uint64]uint64) // accountNumber -> nonce
 	)
 
-	fmt.Printf("\n🔨 Estimating Gas 🔨\n\n")
+	fmt.Printf("\n⏳ Estimating Gas ⏳\n")
 
 	// Estimate the fee for the transaction batch
 	txFee := defaultDeployTxFee
@@ -69,12 +71,13 @@ func constructTransactions(
 	clear(tx.Signatures)
 
 	// Use the estimated gas limit
-	txFee.GasWanted = gasWanted + 10_000 // 10k gas buffer
+	txFee.GasWanted = gasWanted + gasBuffer // 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")

internal/runtime/helper_test.go

@@ -49,15 +49,31 @@ 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 defaultDeployTxFee.GasWanted, 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,
+			std.NewFee(
+				defaultDeployTxFee.GasWanted+gasBuffer,
+				defaultDeployTxFee.GasFee,
+			),
+			tx.Fee,
+		)
 
 		// Make sure the message is valid
 		if len(tx.Msgs) != 1 {

internal/runtime/realm_call.go

@@ -79,7 +79,7 @@ func (r *realmCall) Initialize(
 	clear(tx.Signatures)
 
 	tx.Fee = std.NewFee(
-		gasWanted+10_000, // buffer with 10k gas
+		gasWanted+gasBuffer, // buffer with 10k gas
 		common.DefaultGasFee,
 	)
 

internal/runtime/runtime_test.go

@@ -31,7 +31,14 @@ func verifyDeployTxCommon(t *testing.T, tx *std.Tx, expectedPrefix string) {
 	assert.Nil(t, vmMsg.Deposit)
 
 	// Make sure the fee is valid
-	assert.Equal(t, tx.Fee, defaultDeployTxFee)
+	assert.Equal(
+		t,
+		std.NewFee(
+			defaultDeployTxFee.GasWanted+gasBuffer,
+			defaultDeployTxFee.GasFee,
+		),
+		tx.Fee,
+	)
 }
 
 func TestRuntime_CommonDeployment(t *testing.T) {
@@ -68,13 +75,28 @@ func TestRuntime_CommonDeployment(t *testing.T) {
 			r := GetRuntime(testCase.mode)
 
 			// Make sure there is no initialization logic
-			initialTxs, err := r.Initialize(accounts[0], accountKeys[0], "dummy")
+			initialTxs, err := r.Initialize(
+				accounts[0],
+				accountKeys[0],
+				"dummy",
+				func(_ *std.Tx) (int64, error) {
+					return defaultDeployTxFee.GasWanted, nil
+				},
+			)
 
 			assert.Nil(t, initialTxs)
 			assert.Nil(t, err)
 
 			// Construct the transactions
-			txs, err := r.ConstructTransactions(accountKeys, accounts, transactions, "dummy")
+			txs, err := r.ConstructTransactions(
+				accountKeys,
+				accounts,
+				transactions,
+				"dummy",
+				func(_ *std.Tx) (int64, error) {
+					return defaultDeployTxFee.GasWanted, nil
+				},
+			)
 			if err != nil {
 				t.Fatalf("unable to construct transactions, %v", err)
 			}
@@ -104,7 +126,14 @@ func TestRuntime_RealmCall(t *testing.T) {
 	r := GetRuntime(RealmCall)
 
 	// Make sure the initialization logic is present
-	initialTxs, err := r.Initialize(accounts[0], accountKeys[0], "dummy")
+	initialTxs, err := r.Initialize(
+		accounts[0],
+		accountKeys[0],
+		"dummy",
+		func(_ *std.Tx) (int64, error) {
+			return defaultDeployTxFee.GasWanted, nil
+		},
+	)
 	if err != nil {
 		t.Fatalf("unable to generate init transactions, %v", err)
 	}
@@ -118,7 +147,15 @@ func TestRuntime_RealmCall(t *testing.T) {
 	}
 
 	// Construct the transactions
-	txs, err := r.ConstructTransactions(accountKeys[1:], accounts[1:], transactions, "dummy")
+	txs, err := r.ConstructTransactions(
+		accountKeys[1:],
+		accounts[1:],
+		transactions,
+		"dummy",
+		func(_ *std.Tx) (int64, error) {
+			return defaultDeployTxFee.GasWanted, nil
+		},
+	)
 	if err != nil {
 		t.Fatalf("unable to construct transactions, %v", err)
 	}
@@ -152,6 +189,13 @@ func TestRuntime_RealmCall(t *testing.T) {
 		assert.Contains(t, vmMsg.Args[0], "Account")
 
 		// Make sure the fee is valid
-		assert.Equal(t, tx.Fee, defaultDeployTxFee)
+		assert.Equal(
+			t,
+			std.NewFee(
+				defaultDeployTxFee.GasWanted+gasBuffer,
+				defaultDeployTxFee.GasFee,
+			),
+			tx.Fee,
+		)
 	}
 }