Add a new script that checks if payer has balance to pay for tx

lib/go/templates/service_templates.go

@@ -41,6 +41,8 @@ const (
 	getExecutionMemoryLimit   = "FlowServiceAccount/scripts/get_execution_memory_limit.cdc"
 	setExecutionMemoryLimit   = "FlowServiceAccount/set_execution_memory_limit.cdc"
 
+	verifyPayerBalanceForTxExecution = "FlowServiceAccount/scripts/verify_payer_balance_for_tx_execution.cdc"
+
 	// Account templates
 	createAccountFilename = "accounts/create_new_account.cdc"
 	addKeyFilename        = "accounts/add_key.cdc"
@@ -243,3 +245,9 @@ func GenerateGetExecutionMemoryLimit(env Environment) []byte {
 
 	return []byte(ReplaceAddresses(code, env))
 }
+
+func GenerateVerifyPayerBalanceForTxExecution(env Environment) []byte {
+	code := assets.MustAssetString(verifyPayerBalanceForTxExecution)
+
+	return []byte(ReplaceAddresses(code, env))
+}

lib/go/test/service_test.go

@@ -401,6 +401,76 @@ func TestContracts(t *testing.T) {
 
 	})
 
+	t.Run("Should check if payer has sufficient balance to execute tx", func(t *testing.T) {
+		//TODO: it doesn't work, does it?
+		tx := createTxWithTemplateAndAuthorizer(b,
+			templates.GenerateChangeStorageFeeParametersScript(env),
+			storageFeesAddress)
+
+		err = tx.AddArgument(CadenceUFix64("1.0"))
+		require.NoError(t, err)
+		err = tx.AddArgument(CadenceUFix64("4.0"))
+		require.NoError(t, err)
+
+		signAndSubmit(
+			t, b, tx,
+			[]flow.Address{storageFeesAddress},
+			[]crypto.Signer{storageFeesSigner},
+			false,
+		)
+
+		assert.NoError(t, err)
+		_, err = b.CommitBlock()
+		assert.NoError(t, err)
+
+		// create SmallBalanceContract contract
+		code := []byte(`
+			access(all) contract SmallBalanceContract {
+    			access(all) let value: Int32
+
+    			init() {
+        			self.value = 42
+    			}
+			}
+    	`)
+		keys := test.AccountKeyGenerator()
+		key, _ := keys.NewWithSigner()
+		address, err := adapter.CreateAccount(context.Background(), []*flow.AccountKey{key}, []sdktemplates.Contract{
+			{
+				Name:   "SmallBalanceContract",
+				Source: string(code),
+			},
+		})
+
+		assert.NoError(t, err)
+		_, err = b.CommitBlock()
+		assert.NoError(t, err)
+
+		// mint some flows to the account
+		mintTokensForAccount(t, b, env, address, "15.0")
+
+		//TODO: remove this. this is for debug only
+		acc, err := adapter.GetAccount(context.Background(), address)
+		require.NotNil(t, acc)
+		require.NoError(t, err)
+
+		// set up args
+		cadenceAddress := cadence.NewAddress(address)
+		inclusionEffort := cadence.UFix64(500)
+		gasLimit := cadence.UFix64(1)
+
+		args := [][]byte{jsoncdc.MustEncode(cadenceAddress), jsoncdc.MustEncode(inclusionEffort), jsoncdc.MustEncode(gasLimit)}
+
+		result = executeScriptAndCheck(t, b, templates.GenerateVerifyPayerBalanceForTxExecution(env), args)
+		require.NotNil(t, result)
+
+		// parse VerifyPayerBalanceResult.canExecuteTransaction
+		resultStruct := result.(cadence.Struct)
+		fields := cadence.FieldsMappedByName(resultStruct)
+		canExecuteTransaction := bool(fields["canExecuteTransaction"].(cadence.Bool))
+		require.True(t, canExecuteTransaction)
+	})
+
 	// deploy the ServiceAccount contract
 	serviceAccountCode := contracts.FlowServiceAccount(
 		env,

transactions/FlowServiceAccount/scripts/verify_payer_balance_for_tx_execution.cdc

@@ -0,0 +1,7 @@
+import FlowFees from "FlowFees"
+
+access(all) fun main(payerAcct: Address, inclusionEffort: UFix64, maxExecutionEffort: UFix64): FlowFees.VerifyPayerBalanceResult {
+    let authAcct = getAuthAccount<auth(BorrowValue) &Account>(payerAcct)
+    return FlowFees.verifyPayersBalanceForTransactionExecution(authAcct, inclusionEffort: inclusionEffort,
+        maxExecutionEffort: maxExecutionEffort)
+}