rpcv03 starknet_getClass (#293)

* rpcv03 starknet_getClass

* Fix some typos

* fix comments

---------

Co-authored-by: Carmen Cabrera <kr1000a@gmail.com>

account.go

@@ -31,7 +31,7 @@ type account interface {
 	Nonce(ctx context.Context) (*big.Int, error)
 	EstimateFee(ctx context.Context, calls []types.FunctionCall, details types.ExecuteDetails) (*types.FeeEstimate, error)
 	Execute(ctx context.Context, calls []types.FunctionCall, details types.ExecuteDetails) (*types.AddInvokeTransactionOutput, error)
-	Declare(ctx context.Context, classHash string, contract rpc.ContractClass, details types.ExecuteDetails) (types.AddDeclareResponse, error)
+	Declare(ctx context.Context, classHash string, contract rpc.DeprecatedContractClass, details types.ExecuteDetails) (types.AddDeclareResponse, error)
 	Deploy(ctx context.Context, classHash string, details types.ExecuteDetails) (*types.AddDeployResponse, error)
 }
 
@@ -530,7 +530,7 @@ func (account *Account) Execute(ctx context.Context, calls []types.FunctionCall,
 	return nil, ErrUnsupportedAccount
 }
 
-func (account *Account) Declare(ctx context.Context, classHash string, contract rpc.ContractClass, details types.ExecuteDetails) (types.AddDeclareResponse, error) {
+func (account *Account) Declare(ctx context.Context, classHash string, contract rpc.DeprecatedContractClass, details types.ExecuteDetails) (types.AddDeclareResponse, error) {
 	switch account.provider {
 	case ProviderRPC:
 		panic("unsupported")

contracts/contracts.go

@@ -29,7 +29,7 @@ type GatewayProvider gateway.GatewayProvider
 
 func (p *GatewayProvider) declareAndWaitWithWallet(ctx context.Context, compiledClass []byte) (*DeclareOutput, error) {
 	provider := gateway.GatewayProvider(*p)
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(compiledClass, &class); err != nil {
 		return nil, err
 	}
@@ -54,7 +54,7 @@ func (p *GatewayProvider) declareAndWaitWithWallet(ctx context.Context, compiled
 // TODO: remove compiledClass from the interface
 func (p *GatewayProvider) deployAccountAndWaitNoWallet(ctx context.Context, classHash *felt.Felt, compiledClass []byte, salt string, inputs []string) (*DeployOutput, error) {
 	provider := gateway.GatewayProvider(*p)
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 
 	if err := json.Unmarshal(compiledClass, &class); err != nil {
 		return nil, err
@@ -99,7 +99,7 @@ func (p *GatewayProvider) deployAccountAndWaitNoWallet(ctx context.Context, clas
 // DEPLOY_ACCOUNT for an account.
 func (p *GatewayProvider) deployAndWaitNoWallet(ctx context.Context, compiledClass []byte, salt string, inputs []string) (*DeployOutput, error) {
 	provider := gateway.GatewayProvider(*p)
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(compiledClass, &class); err != nil {
 		return nil, err
 	}

contracts/contractsv02.go

@@ -19,7 +19,7 @@ type RPCProvider rpc.Provider
 
 func (p *RPCProvider) declareAndWaitWithWallet(ctx context.Context, compiledClass []byte) (*DeclareOutput, error) {
 	provider := rpc.Provider(*p)
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(compiledClass, &class); err != nil {
 		return nil, err
 	}
@@ -60,7 +60,7 @@ func (p *RPCProvider) declareAndWaitWithWallet(ctx context.Context, compiledClas
 
 func (p *RPCProvider) deployAccountAndWaitNoWallet(ctx context.Context, classHash *felt.Felt, compiledClass []byte, salt string, inputs []string) (*DeployOutput, error) {
 	provider := rpc.Provider(*p)
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(compiledClass, &class); err != nil {
 		return nil, err
 	}
@@ -109,7 +109,7 @@ func (p *RPCProvider) deployAccountAndWaitNoWallet(ctx context.Context, classHas
 
 func (p *RPCProvider) deployAndWaitWithWallet(ctx context.Context, compiledClass []byte, salt string, inputs []string) (*DeployOutput, error) {
 	provider := rpc.Provider(*p)
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(compiledClass, &class); err != nil {
 		return nil, err
 	}
@@ -131,7 +131,7 @@ func (p *RPCProvider) deployAndWaitWithWallet(ctx context.Context, compiledClass
 			ContractAddressSalt: saltFelt,
 			ConstructorCalldata: inputsFelt,
 		},
-		ContractClass: class,
+		DeprecatedContractClass: class,
 	})
 	fmt.Println("b")
 	if err != nil {

gateway/class.go

@@ -10,7 +10,7 @@ import (
 )
 
 // TODO: returns DeprecatedContractClass | SierraContractClass
-func (sg *Gateway) ClassByHash(ctx context.Context, hash string) (*rpc.ContractClass, error) {
+func (sg *Gateway) ClassByHash(ctx context.Context, hash string) (*rpc.DeprecatedContractClass, error) {
 	req, err := sg.newRequest(ctx, http.MethodGet, "/get_class_by_hash", nil)
 	if err != nil {
 		return nil, err
@@ -20,7 +20,7 @@ func (sg *Gateway) ClassByHash(ctx context.Context, hash string) (*rpc.ContractC
 		"classHash": []string{hash},
 	})
 
-	var resp rpc.ContractClass
+	var resp rpc.DeprecatedContractClass
 	return &resp, sg.do(req, &resp)
 }
 
@@ -41,10 +41,10 @@ func (sg *Gateway) ClassHashAt(ctx context.Context, address string) (*felt.Felt,
 	return resp, nil
 }
 
-func (sg *Gateway) Class(context.Context, string) (*rpc.ContractClass, error) {
+func (sg *Gateway) Class(context.Context, string) (*rpc.DeprecatedContractClass, error) {
 	panic("not implemented")
 }
 
-func (sg *Gateway) ClassAt(context.Context, string) (*rpc.ContractClass, error) {
+func (sg *Gateway) ClassAt(context.Context, string) (*rpc.DeprecatedContractClass, error) {
 	panic("not implemented")
 }

gateway/code.go

@@ -14,7 +14,7 @@ import (
 type Bytecode []string
 
 type Code struct {
-	Bytecode Bytecode    `json:"bytecode"`
+	Bytecode Bytecode `json:"bytecode"`
 	Abi      *rpc.ABI `json:"abi"`
 }
 
@@ -100,14 +100,14 @@ func (sg *Gateway) CodeAt(ctx context.Context, contract string, blockNumber *big
 	return &resp, sg.do(req, &resp)
 }
 
-func (sg *Gateway) FullContract(ctx context.Context, contract string) (*rpc.ContractClass, error) {
+func (sg *Gateway) FullContract(ctx context.Context, contract string) (*rpc.DeprecatedContractClass, error) {
 	req, err := sg.newRequest(ctx, http.MethodGet, "/get_full_contract", nil)
 	if err != nil {
 		return nil, err
 	}
 
 	appendQueryValues(req, url.Values{"contractAddress": []string{contract}})
 
-	var resp rpc.ContractClass
+	var resp rpc.DeprecatedContractClass
 	return &resp, sg.do(req, &resp)
 }

gateway/gateway_test.go

@@ -55,7 +55,7 @@ func setupDevnet(ctx context.Context) error {
 		return fmt.Errorf("could not connect to devnet: %v", err)
 	}
 
-	contract := rpc.ContractClass{}
+	contract := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(counterCompiled, &contract); err != nil {
 		return err
 	}

gateway/provider.go

@@ -46,14 +46,14 @@ func (p *GatewayProvider) TransactionByHash(ctx context.Context, hash string) (*
 	return &t.Transaction, nil
 }
 
-func (p *GatewayProvider) Class(ctx context.Context, classHash string) (*rpc.ContractClass, error) {
+func (p *GatewayProvider) Class(ctx context.Context, classHash string) (*rpc.DeprecatedContractClass, error) {
 	panic("not implemented")
 }
 
 func (p *GatewayProvider) ClassHashAt(ctx context.Context, contractAddress string) (*felt.Felt, error) {
 	panic("not implemented")
 }
 
-func (p *GatewayProvider) ClassAt(ctx context.Context, contractAddress string) (*rpc.ContractClass, error) {
+func (p *GatewayProvider) ClassAt(ctx context.Context, contractAddress string) (*rpc.DeprecatedContractClass, error) {
 	panic("not implemented")
 }

gateway/starknet.go

@@ -142,7 +142,7 @@ func (sg *Gateway) Invoke(ctx context.Context, invoke types.FunctionInvoke) (*ty
 /*
 'add_transaction' wrapper for compressing and deploying a compiled StarkNet contract
 */
-func (sg *Gateway) Deploy(ctx context.Context, contract rpc.ContractClass, deployRequest rpc.DeployAccountTxn) (resp types.AddDeployResponse, err error) {
+func (sg *Gateway) Deploy(ctx context.Context, contract rpc.DepcreatedContractClass, deployRequest rpc.DeployAccountTxn) (resp types.AddDeployResponse, err error) {
 	panic("deploy transaction has been removed, use account.Deploy() instead")
 }
 
@@ -197,7 +197,7 @@ func (sg *Gateway) DeployAccount(ctx context.Context, deployAccountRequest types
 /*
 'add_transaction' wrapper for compressing and declaring a contract class
 */
-func (sg *Gateway) Declare(ctx context.Context, contract rpc.ContractClass, declareRequest DeclareRequest) (resp types.AddDeclareResponse, err error) {
+func (sg *Gateway) Declare(ctx context.Context, contract rpc.DepcreatedContractClass, declareRequest DeclareRequest) (resp types.AddDeclareResponse, err error) {
 	declareRequest.Type = DECLARE
 
 	req, err := sg.newRequest(ctx, http.MethodPost, "/add_transaction", declareRequest)
@@ -220,13 +220,13 @@ func (sg *Gateway) Declare(ctx context.Context, contract rpc.ContractClass, decl
 // }
 
 type DeclareRequest struct {
-	Type          string            `json:"type"`
-	SenderAddress *felt.Felt        `json:"sender_address"`
-	Version       string            `json:"version"`
-	MaxFee        string            `json:"max_fee"`
-	Nonce         string            `json:"nonce"`
-	Signature     []string          `json:"signature"`
-	ContractClass rpc.ContractClass `json:"contract_class"`
+	Type          string                      `json:"type"`
+	SenderAddress *felt.Felt                  `json:"sender_address"`
+	Version       string                      `json:"version"`
+	MaxFee        string                      `json:"max_fee"`
+	Nonce         string                      `json:"nonce"`
+	Signature     []string                    `json:"signature"`
+	ContractClass rpc.DepcreatedContractClass `json:"contract_class"`
 }
 
 func (sg *Gateway) StateUpdate(ctx context.Context, opts *BlockOptions) (*StateUpdate, error) {

gateway/starknet_test.go

@@ -36,7 +36,7 @@ func TestDeclare(t *testing.T) {
 
 	for _, env := range testSet {
 		gw := testConfig.client
-		accountClass := rpc.ContractClass{}
+		accountClass := rpc.DeprecatedContractClass{}
 		err := json.Unmarshal(accountCompiled, &accountClass)
 		if err != nil {
 			t.Fatalf("could not parse contract: %v\n", err)
@@ -73,7 +73,7 @@ func TestDeployCounterContract(t *testing.T) {
 
 		gw := testConfig.client
 
-		counterClass := rpc.ContractClass{}
+		counterClass := rpc.DeprecatedContractClass{}
 		err := json.Unmarshal(counterCompiled, &counterClass)
 		if err != nil {
 			t.Fatalf("could not parse contract: %v\n", err)
@@ -148,7 +148,7 @@ func TestDeployAccountContract(t *testing.T) {
 	for _, test := range testSet {
 		gw := testConfig.client
 		// Step 1: deploy the a class
-		accountClass := rpc.ContractClass{}
+		accountClass := rpc.DeprecatedContractClass{}
 		err := json.Unmarshal(accountCompiled, &accountClass)
 		if err != nil {
 			t.Fatalf("could not parse account: %v\n", err)

plugins/xsessions/accounts_test.go

@@ -49,7 +49,7 @@ var counterCompiled = artifacts.CounterCompiled
 func TestCounter_DeployContract(t *testing.T) {
 	provider := beforeEachRPC(t)
 
-	counterClass := rpc.ContractClass{}
+	counterClass := rpc.DeprecatedContractClass{}
 	inputs := []string{}
 
 	if err := json.Unmarshal(counterCompiled, &counterClass); err != nil {

plugins/xsessions/plugin_test.go

@@ -25,7 +25,7 @@ import (
 func RegisterClass(t *testing.T, pluginCompiled []byte) string {
 	provider := beforeEachRPC(t)
 
-	yeasayerClass := rpc.ContractClass{}
+	yeasayerClass := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(pluginCompiled, &yeasayerClass); err != nil {
 		t.Fatal(err)
 	}
@@ -61,7 +61,7 @@ func RegisterClass(t *testing.T, pluginCompiled []byte) string {
 // DeployContract
 func DeployContract(t *testing.T, contractCompiled []byte, inputs []string) string {
 	provider := beforeEachRPC(t)
-	contractClass := rpc.ContractClass{}
+	contractClass := rpc.DeprecatedContractClass{}
 
 	if err := json.Unmarshal(contractCompiled, &contractClass); err != nil {
 		t.Fatal(err)

providers_test.go

@@ -89,7 +89,7 @@ var (
 )
 
 func InstallCounterContract(provider *gateway.GatewayProvider) (string, error) {
-	class := rpc.ContractClass{}
+	class := rpc.DeprecatedContractClass{}
 	if err := json.Unmarshal(artifacts.CounterCompiled, &class); err != nil {
 		return "", err
 	}

rpc/contract.go

@@ -2,6 +2,7 @@ package rpc
 
 import (
 	"context"
+	"encoding/json"
 	"errors"
 	"fmt"
 
@@ -10,8 +11,8 @@ import (
 )
 
 // Class gets the contract class definition associated with the given hash.
-func (provider *Provider) Class(ctx context.Context, blockID BlockID, classHash string) (*ContractClass, error) {
-	var rawClass ContractClass
+func (provider *Provider) Class(ctx context.Context, blockID BlockID, classHash string) (ClassOutput, error) {
+	var rawClass map[string]any
 	if err := do(ctx, provider.c, "starknet_getClass", &rawClass, blockID, classHash); err != nil {
 		switch {
 		case errors.Is(err, ErrClassHashNotFound):
@@ -21,12 +22,14 @@ func (provider *Provider) Class(ctx context.Context, blockID BlockID, classHash
 		}
 		return nil, err
 	}
-	return &rawClass, nil
+
+	return typecastClassOutput(&rawClass)
+
 }
 
 // ClassAt get the contract class definition at the given address.
-func (provider *Provider) ClassAt(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (*ContractClass, error) {
-	var rawClass ContractClass
+func (provider *Provider) ClassAt(ctx context.Context, blockID BlockID, contractAddress *felt.Felt) (ClassOutput, error) {
+	var rawClass map[string]any
 	if err := do(ctx, provider.c, "starknet_getClassAt", &rawClass, blockID, contractAddress); err != nil {
 		switch {
 		case errors.Is(err, ErrContractNotFound):
@@ -36,7 +39,30 @@ func (provider *Provider) ClassAt(ctx context.Context, blockID BlockID, contract
 		}
 		return nil, err
 	}
-	return &rawClass, nil
+	return typecastClassOutput(&rawClass)
+}
+
+func typecastClassOutput(rawClass *map[string]any) (ClassOutput, error) {
+	rawClassByte, err := json.Marshal(rawClass)
+	if err != nil {
+		return nil, err
+	}
+
+	// if contract_class_version exists, then it's a ContractClass type
+	if _, exists := (*rawClass)["contract_class_version"]; exists {
+		var contractClass ContractClass
+		err = json.Unmarshal(rawClassByte, &contractClass)
+		if err != nil {
+			return nil, err
+		}
+		return &contractClass, nil
+	}
+	var depContractClass DeprecatedContractClass
+	err = json.Unmarshal(rawClassByte, &depContractClass)
+	if err != nil {
+		return nil, err
+	}
+	return &depContractClass, nil
 }
 
 // ClassHashAt gets the contract class hash for the contract deployed at the given address.