add declare

.github/workflows/go.yml

@@ -25,10 +25,10 @@ jobs:
       with:
         toolchain: nightly-2023-11-13
 
-    - name: Cache cargo
-      uses: Swatinem/rust-cache@v2
-      with:
-        workspaces: "cairoVM/juno/vm/rust -> target"
+#    - name: Cache cargo
+#      uses: Swatinem/rust-cache@v2
+#      with:
+#        workspaces: "cairoVM/juno/vm/rust -> target"
 
     - name: Download juno
       run: |

cairoVM/cairo.go

@@ -80,14 +80,14 @@ func (c *Cairo) HandleDeployAccountTx(tx *core.DeployAccountTransaction) (*felt.
 	tx.TransactionSignature = sig
 
 	txs := []core.Transaction{tx}
-	_, traces, err := c.vm.Execute(txs, nil, 0, uint64(time.Now().Unix()), &felt.Zero, c.state, c.cfg.Network, nil, false, false, true, &felt.Zero, &felt.Zero, false)
+	_, traces, err := c.vm.Execute(txs, nil, 0, uint64(time.Now().Unix()), &felt.Zero, c.state, c.cfg.Network, make([]*felt.Felt, 0), false, false, true, &felt.Zero, &felt.Zero, false)
 	if err != nil {
 		return nil, err
 	}
 	return &traces[0].ConstructorInvocation.CallerAddress, nil
 }
 
-func (c *Cairo) HandleDeclareTx(tx *core.DeclareTransaction) (*felt.Felt, error) {
+func (c *Cairo) HandleDeclareTx(tx *core.DeclareTransaction, class core.Class) (*felt.Felt, error) {
 	txnHash, err := core.TransactionHash(tx, c.cfg.Network)
 	if err != nil {
 		return nil, err
@@ -100,7 +100,8 @@ func (c *Cairo) HandleDeclareTx(tx *core.DeclareTransaction) (*felt.Felt, error)
 	tx.TransactionSignature = sig
 
 	txs := []core.Transaction{tx}
-	_, traces, err := c.vm.Execute(txs, nil, 0, uint64(time.Now().Unix()), &felt.Zero, c.state, c.cfg.Network, nil, false, false, true, &felt.Zero, &felt.Zero, false)
+	classes := []core.Class{class}
+	_, traces, err := c.vm.Execute(txs, classes, 0, uint64(time.Now().Unix()), &felt.Zero, c.state, c.cfg.Network, make([]*felt.Felt, 0), false, false, true, &felt.Zero, &felt.Zero, false)
 	if err != nil {
 		return nil, err
 	}
@@ -120,7 +121,7 @@ func (c *Cairo) HandleInvokeTx(tx *core.InvokeTransaction) (*vm.TransactionTrace
 	tx.TransactionSignature = sig
 
 	txs := []core.Transaction{tx}
-	_, traces, err := c.vm.Execute(txs, nil, 0, uint64(time.Now().Unix()), &felt.Zero, c.state, c.cfg.Network, nil, false, false, true, &felt.Zero, &felt.Zero, false)
+	_, traces, err := c.vm.Execute(txs, nil, 0, uint64(time.Now().Unix()), &felt.Zero, c.state, c.cfg.Network, make([]*felt.Felt, 0), false, false, true, &felt.Zero, &felt.Zero, false)
 	if err != nil {
 		return nil, err
 	}

cairoVM/cmd/main.go

@@ -2,10 +2,19 @@ package main
 
 import (
 	"testbot/cairoVM"
+	// "github.com/NethermindEth/juno/core"
 )
 
 func main() {
-	_, err := cairoVM.NewCairoVM(cairoVM.DefaultCfg())
+	vm, err := cairoVM.NewCairoVM(cairoVM.DefaultCfg())
+	if err != nil {
+		panic(err)
+	}
+
+	declare_tx, class := cairoVM.NewDeclare("data/cool_sierra_contract_class.json")
+	// fmt.Println(declare_tx)
+
+	_, err = vm.HandleDeclareTx(declare_tx, class)
 	if err != nil {
 		panic(err)
 	}

cairoVM/declare.go

@@ -0,0 +1,62 @@
+package cairoVM
+
+import (
+	"encoding/json"
+	"os"
+
+	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/starknet.go/contracts"
+	"github.com/NethermindEth/starknet.go/hash"
+	"github.com/NethermindEth/starknet.go/rpc"
+)
+
+type Declare struct {
+	// Fields
+	Compile   string
+	Sierra    string
+	CasmClass *contracts.CasmClass
+}
+
+func NewDeclare(sierra_file_name string) (*core.DeclareTransaction, core.Class) {
+	// ref to https://github.com/NethermindEth/starknet.go/blob/915109ab5bc1c9c5bae7a71553a96e6665c0dcb2/account/account_test.go#L1116
+
+	content, err := os.ReadFile(sierra_file_name)
+	if err != nil {
+		panic(err)
+	}
+
+	var class rpc.ContractClass
+	err = json.Unmarshal(content, &class)
+	if err != nil {
+		panic(err)
+	}
+	classHash, err := hash.ClassHash(class)
+
+	var casmClass contracts.CasmClass
+	err = json.Unmarshal(content, &casmClass)
+	if err != nil {
+		panic(err)
+	}
+
+	compClassHash := hash.CompiledClassHash(casmClass)
+
+	var nonce felt.Felt
+	nonce.SetUint64(0)
+
+	var maxFee felt.Felt
+	maxFee.SetUint64(0)
+
+	tx := core.DeclareTransaction{
+		Nonce:             &nonce,
+		MaxFee:            &maxFee,
+		Version:           new(core.TransactionVersion).SetUint64(2),
+		CompiledClassHash: compClassHash,
+		ClassHash:         classHash,
+		SenderAddress:     &felt.Zero,
+	}
+
+	coreClass, err := adaptDeclaredClass(content)
+
+	return &tx, coreClass
+}

cairoVM/utils.go

@@ -0,0 +1,68 @@
+package cairoVM
+
+import (
+	"encoding/json"
+	"errors"
+
+	"github.com/NethermindEth/juno/adapters/sn2core"
+	"github.com/NethermindEth/juno/core"
+	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/starknet"
+	"github.com/NethermindEth/juno/utils"
+)
+
+// https://github.com/starkware-libs/starknet-specs/blob/e0b76ed0d8d8eba405e182371f9edac8b2bcbc5a/api/starknet_api_openrpc.json#L268-L280
+type Class struct {
+	SierraProgram        []*felt.Felt `json:"sierra_program,omitempty"`
+	Program              string       `json:"program,omitempty"`
+	ContractClassVersion string       `json:"contract_class_version,omitempty"`
+	EntryPoints          EntryPoints  `json:"entry_points_by_type"`
+	Abi                  any          `json:"abi"`
+}
+
+type EntryPoints struct {
+	Constructor []EntryPoint `json:"CONSTRUCTOR"`
+	External    []EntryPoint `json:"EXTERNAL"`
+	L1Handler   []EntryPoint `json:"L1_HANDLER"`
+}
+
+type EntryPoint struct {
+	Index    *uint64    `json:"function_idx,omitempty"`
+	Offset   *felt.Felt `json:"offset,omitempty"`
+	Selector *felt.Felt `json:"selector"`
+}
+
+// https://github.com/starkware-libs/starknet-specs/blob/v0.3.0/api/starknet_api_openrpc.json#L2344
+type FunctionCall struct {
+	ContractAddress    felt.Felt   `json:"contract_address"`
+	EntryPointSelector felt.Felt   `json:"entry_point_selector"`
+	Calldata           []felt.Felt `json:"calldata"`
+}
+
+func adaptDeclaredClass(declaredClass json.RawMessage) (core.Class, error) {
+	var feederClass starknet.ClassDefinition
+	err := json.Unmarshal(declaredClass, &feederClass)
+	if err != nil {
+		return nil, err
+	}
+
+	switch {
+	case feederClass.V1 != nil:
+		compiledClass, cErr := starknet.Compile(feederClass.V1)
+		if cErr != nil {
+			return nil, cErr
+		}
+		return sn2core.AdaptCairo1Class(feederClass.V1, compiledClass)
+	case feederClass.V0 != nil:
+		// strip the quotes
+		base64Program := string(feederClass.V0.Program[1 : len(feederClass.V0.Program)-1])
+		feederClass.V0.Program, err = utils.Gzip64Decode(base64Program)
+		if err != nil {
+			return nil, err
+		}
+
+		return sn2core.AdaptCairo0Class(feederClass.V0)
+	default:
+		return nil, errors.New("empty class")
+	}
+}

data/cool_sierra_contract_class.json

@@ -395,35 +395,5 @@
     "L1_HANDLER": [],
     "CONSTRUCTOR": []
   },
-  "abi": [
-    {
-      "type": "function",
-      "name": "set_value",
-      "inputs": [
-        {
-          "name": "_value",
-          "type": "core::integer::u128"
-        }
-      ],
-      "outputs": [],
-      "state_mutability": "external"
-    },
-    {
-      "type": "function",
-      "name": "get_value",
-      "inputs": [],
-      "outputs": [
-        {
-          "type": "core::integer::u128"
-        }
-      ],
-      "state_mutability": "view"
-    },
-    {
-      "type": "event",
-      "name": "cool::cool::cool::Event",
-      "kind": "enum",
-      "variants": []
-    }
-  ]
+  "abi": "[{\"type\": \"function\",\"name\": \"set_value\",\"inputs\": [{\"name\": \"_value\",\"type\": \"core::integer::u128\"}],\"outputs\": [],\"state_mutability\": \"external\"},{\"type\": \"function\",\"name\": \"get_value\",\"inputs\": [],\"outputs\": [{\"type\": \"core::integer::u128\"}],\"state_mutability\": \"view\"},{\"type\": \"event\",\"name\": \"cool::cool::cool::Event\",\"kind\": \"enum\",\"variants\": []}]"
 }