1269 read only execute sc

api/swagger/server/restapi/resource/swagger.yml

@@ -71,7 +71,6 @@ paths:
               maxGas:
                 $ref: "#/definitions/Amount"
                 description: Maximum number of gas unit that a operation will be able consume.
-                default: 700000000 # DefaultGasLimit
               coins:
                 #$ref: "#/definitions/Amount"
                 description: Set the coin amount that will be transferred to the smartContract.

api/test/robot_tests/cmd/cmd.robot

@@ -107,7 +107,7 @@ POST /cmd/executeFunction with invalid address
     Should Be Equal    ${response.json()["code"]}    Execute-0001
     Should Contain
     ...    ${response.json()["message"]}
-    ...    Error: callSC failed: calling EstimateGasCost for function 
+    ...    Error: callSC failed: estimating Call SC gas cost for function
     Should Contain
     ...    ${response.json()["message"]}
     ...    receiving execute_read_only_call with

int/api/cmd/execute_function.go

@@ -40,16 +40,15 @@ func (e *executeFunction) Handle(params operations.CmdExecuteFunctionParams) mid
 		fee = parsedFee
 	}
 
-	// convert maxGas to uint64
-	maxGas := uint64(sendOperation.DefaultGasLimitCallSC)
+	maxGas := uint64(0)
 
 	if string(params.Body.MaxGas) != "" {
 		parsedMaxGas, err := strconv.ParseUint(string(params.Body.MaxGas), 10, 64)
 		if err != nil {
 			return operations.NewCmdExecuteFunctionBadRequest().WithPayload(
 				&models.Error{
 					Code:    errorInvalidMaxGas,
-					Message: "Error during amount conversion: " + err.Error(),
+					Message: "Error during max gas conversion: " + err.Error(),
 				})
 		}
 

pkg/node/sendoperation/interfaces.go

@@ -5,6 +5,7 @@
 	"fmt"
 )
 
+// ReadOnlyCallParams is the struct used to send a read only callSC to the node.
 type ReadOnlyCallParams struct {
 	MaxGas         int           `json:"max_gas"`
 	Coins          string        `json:"coins"`
@@ -15,13 +16,17 @@
 	CallerAddress  string        `json:"caller_address"`
 }
 
-// Read only call response (chatgpt4 generated).
-type ReadOnlyCallResponse struct {
-	JSONRPC string               `json:"jsonrpc"`
-	Result  []ReadOnlyCallResult `json:"result"`
+// ReadOnlyExecuteParams is the struct used to send a read only executeSC to the node.
+type ReadOnlyExecuteParams struct {
+	MaxGas             int           `json:"max_gas"`
+	Coins              string        `json:"coins"`
+	Fee                string        `json:"fee"`
+	Address            string        `json:"address"`
+	Bytecode           JSONableSlice `json:"bytecode"`
+	OperationDatastore JSONableSlice `json:"operation_datastore"`
 }
 
-type ReadOnlyCallResult struct {
+type ReadOnlyResult struct {
 	ExecutedAt   Timestamp   `json:"executed_at"`
 	Result       Result      `json:"result"`
 	OutputEvents []Event     `json:"output_events"`
@@ -66,7 +71,7 @@
 		return nil
 	}
 
-	return nil // Or return an error if neither key is present
+	return nil
 }
 
 type Timestamp struct {

pkg/node/sendoperation/readonlycall.go

@@ -63,7 +63,7 @@
 	fee string,
 	callerAddr string,
 	client *node.Client,
-) (*ReadOnlyCallResult, error) {
+) (*ReadOnlyResult, error) {
 	readOnlyCallParams := [][]ReadOnlyCallParams{
 		{
 			ReadOnlyCallParams{
@@ -95,7 +95,7 @@
 		)
 	}
 
-	var resp []ReadOnlyCallResult
+	var resp []ReadOnlyResult
 
 	err = rawResponse.GetObject(&resp)
 	if err != nil {
@@ -109,3 +109,94 @@
 
 	return &resp[0], nil
 }
+
+func EstimateGasCostExecuteSC(
+	nickname string,
+	contract []byte,
+	datastore []byte,
+	maxCoins uint64,
+	fee uint64,
+	client *node.Client,
+) (uint64, error) {
+	acc, err := wallet.Fetch(nickname)
+	if err != nil {
+		return 0, fmt.Errorf("loading wallet '%s': %w", nickname, err)
+	}
+
+	coinsString, err := NanoToMas(maxCoins)
+	if err != nil {
+		return 0, fmt.Errorf("converting maxCoins to mas: %w", err)
+	}
+
+	feeString, err := NanoToMas(fee)
+	if err != nil {
+		return 0, fmt.Errorf("converting fee to mas: %w", err)
+	}
+
+	result, err := ReadOnlyExecuteSC(contract, datastore, coinsString, feeString, acc.Address, client)
+	if err != nil {
+		return 0, fmt.Errorf("ReadOnlyExecuteSC error: %w, caller address is %s", err, acc.Address)
+	}
+
+	estimatedGasCost := uint64(result.GasCost)
+
+	return addXPercentage(estimatedGasCost, PercentageGasLimit), nil
+}
+
+// ReadOnlyExecuteSC calls execute_read_only_bytecode jsonrpc method.
+// coins and fee must be in MAS.
+func ReadOnlyExecuteSC(
+	contract []byte,
+	datastore []byte,
+	coins string,
+	fee string,
+	callerAddr string,
+	client *node.Client,
+) (*ReadOnlyResult, error) {
+	if datastore == nil {
+		datastore = []byte{0}
+	}
+
+	readOnlyExecuteParams := [][]ReadOnlyExecuteParams{
+		{
+			ReadOnlyExecuteParams{
+				Coins:              coins,
+				MaxGas:             MaxGasAllowedExecuteSC,
+				Fee:                fee,
+				Address:            callerAddr,
+				Bytecode:           contract,
+				OperationDatastore: datastore,
+			},
+		},
+	}
+
+	rawResponse, err := client.RPCClient.Call(
+		context.Background(),
+		"execute_read_only_bytecode",
+		readOnlyExecuteParams,
+	)
+	if err != nil {
+		return nil, fmt.Errorf("calling execute_read_only_bytecode jsonrpc: %w", err)
+	}
+
+	if rawResponse.Error != nil {
+		return nil, fmt.Errorf(
+			"receiving execute_read_only_bytecode  response: %w, %v",
+			rawResponse.Error,
+			fmt.Sprint(rawResponse.Error.Data),
+		)
+	}
+
+	var resp []ReadOnlyResult
+
+	err = rawResponse.GetObject(&resp)
+	if err != nil {
+		return nil, fmt.Errorf("parsing execute_read_only_bytecode jsonrpc response '%+v': %w", rawResponse, err)
+	}
+
+	if resp[0].Result.Error != "" {
+		return nil, fmt.Errorf("ReadOnlyExecuteSC error: %s, caller address is %s", resp[0].Result.Error, callerAddr)
+	}
+
+	return &resp[0], nil
+}

pkg/node/sendoperation/sendoperation.go

@@ -14,9 +14,8 @@ import (
 )
 
 const (
-	DefaultGasLimitExecuteSC   = 1_000_000_000
+	MaxGasAllowedExecuteSC     = 3_980_167_295
 	MaxGasAllowedCallSC        = 4_294_167_295
-	DefaultGasLimitCallSC      = 700_000_000
 	DefaultExpiryInSlot        = 3
 	DefaultFee                 = 0
 	accountCreationStorageCost = 1_000_000

pkg/onchain/dns/dns.go

@@ -56,7 +56,7 @@ func SetRecord(
 		"dns1_setResolver",
 		rec,
 		sendoperation.DefaultFee,
-		sendoperation.DefaultGasLimitCallSC,
+		0,
 		sendoperation.OneMassa,
 		sendoperation.DefaultExpiryInSlot,
 		false,

pkg/onchain/sc.go

@@ -5,7 +5,6 @@ import (
 	"regexp"
 	"strings"
 
-	"github.com/massalabs/station/pkg/logger"
 	"github.com/massalabs/station/pkg/node"
 	sendOperation "github.com/massalabs/station/pkg/node/sendoperation"
 	"github.com/massalabs/station/pkg/node/sendoperation/callsc"
@@ -37,14 +36,12 @@ func CallFunction(
 	description string,
 ) (*OperationWithEventResponse, error) {
 	// Calibrate max_gas
-	if maxGas == sendOperation.DefaultGasLimitCallSC || maxGas == 0 {
+	if maxGas == 0 {
 		estimatedGasCost, err := sendOperation.EstimateGasCostCallSC(nickname, addr, function, parameter, coins, fee, client)
 		if err != nil {
-			return nil, fmt.Errorf("calling EstimateGasCost for function '%s' at '%s': %w", function, addr, err)
+			return nil, fmt.Errorf("estimating Call SC gas cost for function '%s' at '%s': %w", function, addr, err)
 		}
 
-		logger.Debugf("Estimated gas cost for %s at %s: %d", function, addr, estimatedGasCost)
-
 		maxGas = estimatedGasCost
 	}
 
@@ -109,7 +106,7 @@ func CallFunctionSuccess(
 // The smart contract is deployed with the given account nickname.
 func DeploySC(client *node.Client,
 	nickname string,
-	gasLimit uint64,
+	maxGas uint64,
 	maxCoins uint64,
 	fee uint64,
 	expiry uint64,
@@ -119,9 +116,19 @@ func DeploySC(client *node.Client,
 	signer signer.Signer,
 	description string,
 ) (*sendOperation.OperationResponse, []node.Event, error) {
+	// Calibrate max_gas
+	if maxGas == 0 {
+		estimatedGasCost, err := sendOperation.EstimateGasCostExecuteSC(nickname, contract, datastore, maxCoins, fee, client)
+		if err != nil {
+			return nil, nil, fmt.Errorf("estimating Execute SC gas cost: %w", err)
+		}
+
+		maxGas = estimatedGasCost
+	}
+
 	exeSC := executesc.New(
 		contract,
-		gasLimit,
+		maxGas,
 		maxCoins,
 		datastore)
 

pkg/onchain/website/uploader.go

@@ -82,7 +82,7 @@ func PrepareForUpload(
 	operationResponse, events, err := onchain.DeploySC(
 		client,
 		nickname,
-		sendOperation.DefaultGasLimitExecuteSC,
+		0,
 		uint64(totalStorageCost),
 		sendOperation.DefaultFee,
 		sendOperation.DefaultExpiryInSlot,
@@ -189,7 +189,7 @@ func upload(
 			"appendBytesToWebsite",
 			params,
 			sendOperation.DefaultFee,
-			sendOperation.DefaultGasLimitCallSC,
+			0,
 			uint64(uploadCost),
 			sendOperation.DefaultExpiryInSlot,
 			false,
@@ -287,7 +287,7 @@ func uploadMissedChunks(
 			"appendBytesToWebsite",
 			params,
 			sendOperation.DefaultFee,
-			sendOperation.DefaultGasLimitCallSC,
+			0,
 			uint64(uploadCost),
 			sendOperation.DefaultExpiryInSlot,
 			false,