Merge branch 'main' into rpcv05-estimateFee-params

account/account.go

@@ -604,17 +604,16 @@ func (account *Account) Events(ctx context.Context, input rpc.EventsInput) (*rpc
 	return account.provider.Events(ctx, input)
 }
 
-// Nonce returns the nonce for the specified account and contract address.
+// Nonce retrieves the nonce for a given block ID and contract address.
 //
 // Parameters:
-// - ctx: The context.Context object for the function
-// - blockID: the rpc.BlockID object for the function
-// - contractAddress: the felt.Felt (address of the contract) whose nonce we're seeking
-//
+// - ctx: is the context.Context for the function call
+// - blockID: is the ID of the block
+// - contractAddress: is the address of the contract
 // Returns:
-// - *string: a string pointer
-// - error: an error
-func (account *Account) Nonce(ctx context.Context, blockID rpc.BlockID, contractAddress *felt.Felt) (*string, error) {
+// - *felt.Felt: the contract's nonce at the requested state
+// - error: an error if any
+func (account *Account) Nonce(ctx context.Context, blockID rpc.BlockID, contractAddress *felt.Felt) (*felt.Felt, error) {
 	return account.provider.Nonce(ctx, blockID, contractAddress)
 }
 

account/account_test.go

@@ -932,7 +932,7 @@ func TestAddDeclareTxn(t *testing.T) {
 	require.NoError(t, err)
 
 	tx := rpc.DeclareTxnV2{
-		Nonce:             utils.TestHexToFelt(t, *nonce),
+		Nonce:             nonce,
 		MaxFee:            utils.TestHexToFelt(t, "0x50c8f3053db"),
 		Type:              rpc.TransactionType_Declare,
 		Version:           rpc.TransactionV2,

examples/simpleInvoke/main.go

@@ -66,9 +66,8 @@ func main() {
 		panic(err.Error())
 	}
 
-	//Getting the nonce from the account, and then converting it into felt
-	nonce_string, _ := accnt.Nonce(context.Background(), rpc.BlockID{Tag: "latest"}, accnt.AccountAddress)
-	nonce, err := utils.HexToFelt(*nonce_string)
+	//Getting the nonce from the account
+	nonce, err := accnt.Nonce(context.Background(), rpc.BlockID{Tag: "latest"}, accnt.AccountAddress)
 	if err != nil {
 		panic(err.Error())
 	}

rpc/contract.go

@@ -123,15 +123,15 @@ func (provider *Provider) StorageAt(ctx context.Context, contractAddress *felt.F
 // - blockID: is the ID of the block
 // - contractAddress: is the address of the contract
 // Returns:
-// - *string: the nonce
+// - *felt.Felt: the contract's nonce at the requested state
 // - error: an error if any
-func (provider *Provider) Nonce(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*string, error) {
-	nonce := ""
+func (provider *Provider) Nonce(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*felt.Felt, error) {
+	var nonce *felt.Felt
 	if err := do(ctx, provider.c, "starknet_getNonce", &nonce, blockID, contractAddress); err != nil {
 
 		return nil, tryUnwrapToRPCErr(err, ErrContractNotFound, ErrBlockNotFound)
 	}
-	return &nonce, nil
+	return nonce, nil
 }
 
 // EstimateFee estimates the fee for executing a set of requests on the StarkNet blockchain.

rpc/contract_test.go

@@ -323,16 +323,19 @@ func TestNonce(t *testing.T) {
 
 	type testSetType struct {
 		ContractAddress *felt.Felt
+		ExpectedNonce   *felt.Felt
 	}
 	testSet := map[string][]testSetType{
 		"mock": {
 			{
 				ContractAddress: utils.TestHexToFelt(t, "0x0207acc15dc241e7d167e67e30e769719a727d3e0fa47f9e187707289885dfde"),
+				ExpectedNonce:   utils.TestHexToFelt(t, "0x0"),
 			},
 		},
 		"testnet": {
 			{
 				ContractAddress: utils.TestHexToFelt(t, "0x0207acc15dc241e7d167e67e30e769719a727d3e0fa47f9e187707289885dfde"),
+				ExpectedNonce:   utils.TestHexToFelt(t, "0x0"),
 			},
 		},
 		"mainnet": {},
@@ -341,21 +344,23 @@ func TestNonce(t *testing.T) {
 	for _, test := range testSet {
 		spy := NewSpy(testConfig.provider.c)
 		testConfig.provider.c = spy
-		value, err := testConfig.provider.Nonce(context.Background(), WithBlockTag("latest"), test.ContractAddress)
+		nonce, err := testConfig.provider.Nonce(context.Background(), WithBlockTag("latest"), test.ContractAddress)
 		if err != nil {
 			t.Fatal(err)
 		}
-		diff, err := spy.Compare(value, false)
+		diff, err := spy.Compare(nonce, false)
 		if err != nil {
 			t.Fatal("expecting to match", err)
 		}
 		if diff != "FullMatch" {
-			spy.Compare(value, true)
+			spy.Compare(nonce, true)
 			t.Fatal("structure expecting to be FullMatch, instead", diff)
 		}
-		if *value != "0x0" {
-			t.Fatalf("expecting value %s, got %s", "0x0", *value)
+
+		if nonce == nil {
+			t.Fatalf("should return a nonce, instead %v", nonce)
 		}
+		require.Equal(t, test.ExpectedNonce, nonce)
 	}
 }
 

rpc/mock_test.go

@@ -810,9 +810,12 @@ func mock_starknet_getNonce(result interface{}, method string, args ...interface
 		fmt.Printf("args[0] should be *felt.Felt, got %T\n", args[1])
 		return errWrongArgs
 	}
-	output := "0x0"
+	output, err := utils.HexToFelt("0x0")
+	if err != nil {
+		return err
+	}
 	outputContent, _ := json.Marshal(output)
-	json.Unmarshal(outputContent, &r)
+	json.Unmarshal(outputContent, r)
 	return nil
 }
 

rpc/provider.go

@@ -45,7 +45,7 @@ type RpcProvider interface {
 	EstimateMessageFee(ctx context.Context, msg MsgFromL1, blockID BlockID) (*FeeEstimate, error)
 	Events(ctx context.Context, input EventsInput) (*EventChunk, error)
 	GetTransactionStatus(ctx context.Context, transactionHash *felt.Felt) (*TxnStatusResp, error)
-	Nonce(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*string, error)
+	Nonce(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*felt.Felt, error)
 	SimulateTransactions(ctx context.Context, blockID BlockID, txns []Transaction, simulationFlags []SimulationFlag) ([]SimulatedTransaction, error)
 	StateUpdate(ctx context.Context, blockID BlockID) (*StateUpdateOutput, error)
 	StorageAt(ctx context.Context, contractAddress *felt.Felt, key string, blockID BlockID) (string, error)