Juno @task-5

.gitignore

@@ -8,6 +8,7 @@ courtney/
 __pycache__/
 config/
 .envrc
+juno/
 
 # pyenv
 .python-version

blockchain/pending.go

@@ -3,6 +3,7 @@ package blockchain
 import (
 	"github.com/NethermindEth/juno/core"
 	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/core/trie"
 )
 
 type Pending struct {
@@ -65,3 +66,7 @@ func (p *PendingState) Class(classHash *felt.Felt) (*core.DeclaredClass, error)
 
 	return p.head.Class(classHash)
 }
+
+func (p *PendingState) GetGlobalTrie() (*trie.Trie, func() error, error) {
+	return p.head.GetGlobalTrie()
+}

core/state.go

@@ -40,6 +40,7 @@ type StateReader interface {
 	ContractNonce(addr *felt.Felt) (*felt.Felt, error)
 	ContractStorage(addr, key *felt.Felt) (*felt.Felt, error)
 	Class(classHash *felt.Felt) (*DeclaredClass, error)
+	GetGlobalTrie() (*trie.Trie, func() error, error)
 }
 
 type State struct {
@@ -122,6 +123,10 @@ func (s *State) Root() (*felt.Felt, error) {
 	return crypto.PoseidonArray(stateVersion, storageRoot, classesRoot), nil
 }
 
+func (s *State) GetGlobalTrie() (*trie.Trie, func() error, error) {
+	return s.globalTrie(db.StateTrie, trie.NewTriePedersen)
+}
+
 // storage returns a [core.Trie] that represents the Starknet global state in the given Txn context.
 func (s *State) storage() (*trie.Trie, func() error, error) {
 	return s.globalTrie(db.StateTrie, trie.NewTriePedersen)

core/state_snapshot.go

@@ -4,6 +4,7 @@ import (
 	"errors"
 
 	"github.com/NethermindEth/juno/core/felt"
+	"github.com/NethermindEth/juno/core/trie"
 	"github.com/NethermindEth/juno/db"
 )
 
@@ -87,3 +88,7 @@ func (s *stateSnapshot) Class(classHash *felt.Felt) (*DeclaredClass, error) {
 	}
 	return declaredClass, nil
 }
+
+func (s *stateSnapshot) GetGlobalTrie() (*trie.Trie, func() error, error) {
+	return s.state.GetGlobalTrie()
+}

core/trie/trie.go

@@ -92,6 +92,10 @@
 	return NewKey(t.height, kBytes[:])
 }
 
+func (t *Trie) FeltToKeyConverter(key *felt.Felt) Key {
+	return t.feltToKey(key)
+}
+
 // findCommonKey finds the set of common MSB bits in two key bitsets.
 func findCommonKey(longerKey, shorterKey *Key) (Key, bool) {
 	divergentBit := findDivergentBit(longerKey, shorterKey)
@@ -135,6 +139,27 @@
 	node *Node
 }
 
+type ParsedNodes struct {
+	k string
+	v string
+}
+
+func (t *Trie) NodeParser(nodes []storageNode) []ParsedNodes {
+	var parsedNodes []ParsedNodes
+	for _, node := range nodes {
+		parsableNode := ParsedNodes{
+			k: fmt.Sprintf("%v", node.key), // Assuming node.key can be stringified
+			v: fmt.Sprintf("%v", node.node),
+		}
+		parsedNodes = append(parsedNodes, parsableNode)
+	}
+	return parsedNodes
+}
+
+func (t *Trie) GetNodesFromRoot(key *Key) ([]storageNode, error) {
+	return t.nodesFromRoot(key)
+}
+
 // nodesFromRoot enumerates the set of [Node] objects that need to be traversed from the root
 // of the Trie to the node which is given by the key.
 // The [storageNode]s are returned in descending order beginning with the root.

rpc/handlers.go

@@ -56,6 +56,7 @@
 	ErrUnsupportedTxVersion            = &jsonrpc.Error{Code: 61, Message: "the transaction version is not supported"}
 	ErrUnsupportedContractClassVersion = &jsonrpc.Error{Code: 62, Message: "the contract class version is not supported"}
 	ErrUnexpectedError                 = &jsonrpc.Error{Code: 63, Message: "An unexpected error occurred"}
+	ErrParsingError                    = &jsonrpc.Error{Code: 64, Message: "Failed to parse"}
 
 	// These errors can be only be returned by Juno-specific methods.
 	ErrSubscriptionNotFound = &jsonrpc.Error{Code: 100, Message: "Subscription not found"}
@@ -330,6 +331,11 @@
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
 			Handler: h.BlockWithReceipts,
 		},
+		{
+			Name:    "juno_getNodesFromRoot",
+			Params:  []jsonrpc.Parameter{{Name: "key"}},
+			Handler: h.JunoGetNodesFromRoot,
+		},
 	}, "/v0_7"
 }
 
@@ -483,5 +489,52 @@
 			Params:  []jsonrpc.Parameter{{Name: "id"}},
 			Handler: h.Unsubscribe,
 		},
+		{
+			Name:    "juno_getNodesFromRoot",
+			Params:  []jsonrpc.Parameter{{Name: "key"}},
+			Handler: h.JunoGetNodesFromRoot,
+		},
 	}, "/v0_6"
 }
+
+func (h *Handler) JunoGetNodesFromRoot(key felt.Felt) (string, *jsonrpc.Error) {
+	stateReader, _, error := h.bcReader.HeadState()
+	if error != nil {
+		return "", &jsonrpc.Error{
+			Code:    11111,
+			Message: "Failed to retrieve head state",
+			Data:    error.Error(),
+		}
+	}
+
+	try, _, errTry := stateReader.GetGlobalTrie()
+	if errTry != nil {
+		return "", &jsonrpc.Error{
+			Code:    22222,
+			Message: "Failed to get global trie",
+			Data:    errTry.Error(),
+		}
+	}
+
+	k := try.FeltToKeyConverter(&key)
+	storageNodes, err := try.GetNodesFromRoot(&k)
+	if err != nil {
+		return "", &jsonrpc.Error{
+			Code:    33333,
+			Message: "Failed to get nodes from root",
+			Data:    err.Error(),
+		}
+	}
+
+	parsedNodes := try.NodeParser(storageNodes)
+
+	jsonBytes, err := json.Marshal(parsedNodes)
+	if err != nil {
+		return "", &jsonrpc.Error{
+			Code:    44444,
+			Message: "Failed to parse nodes",
+			Data:    err.Error(),
+		}
+	}
+	return string(jsonBytes), nil
+}

rpc/handlers_test.go

@@ -10,6 +10,7 @@ import (
 	"github.com/NethermindEth/juno/node"
 	"github.com/NethermindEth/juno/rpc"
 	"github.com/NethermindEth/juno/utils"
+	fp1 "github.com/consensys/gnark-crypto/ecc/stark-curve/fp"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.uber.org/mock/gomock"
@@ -99,3 +100,30 @@ func TestThrottledVMError(t *testing.T) {
 		assert.Equal(t, throttledErr, rpcErr.Data)
 	})
 }
+
+func TestJunoGetNodesFromRoot(t *testing.T) {
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+	mockReader := mocks.NewMockReader(mockCtrl)
+	mockReader.EXPECT().Network().Return(&utils.Mainnet).AnyTimes()
+
+	log := utils.NewNopZapLogger()
+	mockState := mocks.NewMockStateHistoryReader(mockCtrl)
+
+	handler := rpc.New(mockReader, nil, nil, "", utils.Ptr(utils.Mainnet), log)
+
+	t.Run("Key DNE", func(t *testing.T) {
+		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
+		nodeStorage, err := handler.JunoGetNodesFromRoot(felt.Zero)
+		require.Nil(t, nodeStorage)
+		require.NotEqual(t, err, nil)
+	})
+
+	t.Run("Key Exist", func(t *testing.T) {
+		element := fp1.NewElement(1)
+		mockReader.EXPECT().HeadState().Return(mockState, nopCloser, nil)
+		nodeStorage, err := handler.JunoGetNodesFromRoot(*felt.NewFelt(&element))
+		require.Nil(t, err)
+		assert.NotEqual(t, nodeStorage, nil)
+	})
+}