Pps sandbox

.gitignore

@@ -8,6 +8,10 @@ courtney/
 __pycache__/
 config/
 .envrc
+juno/
+cmd/juno/pps_rpc.go
+cmd/juno/rpc_respReceipts.go
+cmd/juno/rpc_respTxns.go
 
 # pyenv
 .python-version

blockchain/blockchain.go

@@ -47,6 +47,7 @@ type Reader interface {
 	Pending() (Pending, error)
 
 	Network() *utils.Network
+	// JunoGetNodesFromRoot(key *felt.Felt) (core.StateReader /*, StateCloser*/, error)
 }
 
 var (
@@ -109,6 +110,17 @@ func (b *Blockchain) StateCommitment() (*felt.Felt, error) {
 	})
 }
 
+// func (b *Blockchain) JunoGetNodesFromRoot(key *felt.Felt) (core.StateReader /*, StateCloser*/, error) {
+// 	b.listener.OnRead("JunoGetNodesFromRoot")
+// 	var state core.StateReader
+// 	// var closer StateCloser
+// 	return state, b.database.View(func(txn db.Transaction) error {
+// 		var err error
+// 		state, _, err = core.NewState(txn).NodeFromRoot(key)
+// 		return err
+// 	})
+// }
+
 // Height returns the latest block height. If blockchain is empty nil is returned.
 func (b *Blockchain) Height() (uint64, error) {
 	b.listener.OnRead("Height")

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) NodeFromRoot() (*trie.Trie, func() error, error) {
+	return p.head.NodeFromRoot()
+}

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)
+	NodeFromRoot() (*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) NodeFromRoot() (*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) NodeFromRoot() (*trie.Trie, func() error, error) {
+	return s.state.NodeFromRoot()
+}

core/trie/trie.go

@@ -92,6 +92,10 @@ func (t *Trie) feltToKey(k *felt.Felt) Key {
 	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 @@ type storageNode struct {
 	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/block.go

@@ -361,3 +361,43 @@ func nilToZero(f *felt.Felt) *felt.Felt {
 	}
 	return f
 }
+
+func (h *Handler) JunoGetBlockWithTxsAndReceipts(id BlockID) (*BlockWithTxs, *BlockWithReceipts, *jsonrpc.Error) {
+	block, rpcErr := h.blockByID(&id)
+	if rpcErr != nil {
+		return nil, nil, rpcErr
+	}
+
+	blockStatus, rpcErr := h.blockStatus(id, block)
+	if rpcErr != nil {
+		return nil, nil, rpcErr
+	}
+
+	finalityStatus := TxnAcceptedOnL2
+	if blockStatus == BlockAcceptedL1 {
+		finalityStatus = TxnAcceptedOnL1
+	}
+
+	txs := make([]*Transaction, len(block.Transactions))
+	txsWithReceipts := make([]TransactionWithReceipt, len(block.Transactions))
+	for index, txn := range block.Transactions {
+		txs[index] = AdaptTransaction(txn)
+		r := block.Receipts[index]
+		txsWithReceipts[index] = TransactionWithReceipt{
+			Transaction: txs[index],
+			Receipt:     AdaptReceipt(r, txn, finalityStatus, nil, 0, false),
+		}
+	}
+
+	return &BlockWithTxs{
+			Status:       blockStatus,
+			BlockHeader:  adaptBlockHeader(block.Header),
+			Transactions: txs,
+		},
+		&BlockWithReceipts{
+			Status:       blockStatus,
+			BlockHeader:  adaptBlockHeader(block.Header),
+			Transactions: txsWithReceipts,
+		},
+		nil
+}

rpc/block_test.go

@@ -702,3 +702,115 @@ func TestRpcBlockAdaptation(t *testing.T) {
 		require.Equal(t, &felt.Zero, blockWithTxHashes.BlockHeader.SequencerAddress)
 	})
 }
+
+func TestJunoGetBlockWithTxsAndReceipts(t *testing.T) {
+	blockId := map[string]rpc.BlockID{
+		"latest":  {Latest: true},
+		"pending": {Pending: true},
+		"hash":    {Hash: new(felt.Felt).SetUint64(1)},
+		"number":  {Number: 1},
+	}
+
+	log := utils.NewNopZapLogger()
+	n := utils.Ptr(utils.Mainnet)
+	chain := blockchain.New(pebble.NewMemTest(t), n)
+	handler := rpc.New(chain, nil, nil, "", n, log)
+	for desc, id := range blockId {
+		t.Run(desc, func(t *testing.T) {
+			block, blockReceipt, rpcErr := handler.JunoGetBlockWithTxsAndReceipts(id)
+			assert.Nil(t, block)
+			assert.Nil(t, blockReceipt)
+			assert.Equal(t, rpc.ErrBlockNotFound, rpcErr)
+		})
+	}
+
+	mockCtrl := gomock.NewController(t)
+	t.Cleanup(mockCtrl.Finish)
+	mockReader := mocks.NewMockReader(mockCtrl)
+
+	t.Run("transaction DNE", func(t *testing.T) {
+		blockID := rpc.BlockID{Number: 420}
+
+		mockReader.EXPECT().BlockByNumber(blockID.Number).Return(nil, db.ErrKeyNotFound) // Expecting BlockID DNE
+
+		respTxn, respRecp, rpcErr := handler.JunoGetBlockWithTxsAndReceipts(blockID)
+		assert.Nil(t, respTxn)
+		assert.Nil(t, respRecp)
+		assert.Equal(t, rpc.ErrBlockNotFound, rpcErr)
+	})
+
+	t.Run("l1head failure", func(t *testing.T) {
+		blockID := rpc.BlockID{Number: 420}
+		block := &core.Block{
+			Header: &core.Header{},
+		}
+
+		err := errors.New("l1 failure")
+		mockReader.EXPECT().BlockByNumber(blockID.Number).Return(block, nil) // Expecting BlockID to be valid
+		mockReader.EXPECT().L1Head().Return(nil, err)                        // Expecting L1head to fail
+
+		respTxn, respRecp, rpcErr := handler.JunoGetBlockWithTxsAndReceipts(blockID)
+		assert.Nil(t, respTxn)
+		assert.Nil(t, respRecp)
+		assert.Equal(t, rpc.ErrInternal.CloneWithData(err.Error()), rpcErr)
+	})
+
+	client := feeder.NewTestClient(t, n)
+	mainnetGw := adaptfeeder.New(client)
+
+	t.Run("pending block", func(t *testing.T) {
+		t.Skip()
+		block0, err := mainnetGw.BlockByNumber(context.Background(), 0)
+		require.NoError(t, err)
+
+		blockID := rpc.BlockID{Pending: true}
+
+		mockReader.EXPECT().Pending().Return(blockchain.Pending{Block: block0}, nil)
+		mockReader.EXPECT().L1Head().Return(&core.L1Head{}, nil)
+
+		respTxn, respRecp, rpcErr := handler.JunoGetBlockWithTxsAndReceipts(blockID)
+		header := respRecp.BlockHeader
+
+		var txsWithReceipt []rpc.TransactionWithReceipt
+		var txns []*rpc.Transaction
+		for i, tx := range block0.Transactions {
+			receipt := block0.Receipts[i]
+			adaptedTx := rpc.AdaptTransaction(tx)
+			txns = append(txns, adaptedTx)
+			txsWithReceipt = append(txsWithReceipt, rpc.TransactionWithReceipt{
+				Transaction: adaptedTx,
+				Receipt:     rpc.AdaptReceipt(receipt, tx, rpc.TxnAcceptedOnL2, nil, 0, true),
+			})
+		}
+
+		assert.Nil(t, rpcErr)
+		assert.Equal(t, &rpc.BlockWithTxs{
+			Status: rpc.BlockPending,
+			BlockHeader: rpc.BlockHeader{
+				Hash:             header.Hash,
+				ParentHash:       header.ParentHash,
+				Number:           header.Number,
+				NewRoot:          header.NewRoot,
+				Timestamp:        header.Timestamp,
+				SequencerAddress: header.SequencerAddress,
+				L1GasPrice:       header.L1GasPrice,
+				StarknetVersion:  header.StarknetVersion,
+			},
+			Transactions: txns,
+		}, respTxn)
+		assert.Equal(t, &rpc.BlockWithReceipts{
+			Status: rpc.BlockPending,
+			BlockHeader: rpc.BlockHeader{
+				Hash:             header.Hash,
+				ParentHash:       header.ParentHash,
+				Number:           header.Number,
+				NewRoot:          header.NewRoot,
+				Timestamp:        header.Timestamp,
+				SequencerAddress: header.SequencerAddress,
+				L1GasPrice:       header.L1GasPrice,
+				StarknetVersion:  header.StarknetVersion,
+			},
+			Transactions: txsWithReceipt,
+		}, respRecp)
+	})
+}

rpc/handlers.go

@@ -56,6 +56,7 @@ var (
 	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 @@ func (h *Handler) Methods() ([]jsonrpc.Method, string) { //nolint: funlen
 			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
 			Handler: h.BlockWithReceipts,
 		},
+		{
+			Name:    "juno_getBlockWithTxsAndReceipts",
+			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
+			Handler: h.JunoGetBlockWithTxsAndReceipts,
+		},
 	}, "/v0_7"
 }
 
@@ -483,5 +489,35 @@ func (h *Handler) MethodsV0_6() ([]jsonrpc.Method, string) { //nolint: funlen
 			Params:  []jsonrpc.Parameter{{Name: "id"}},
 			Handler: h.Unsubscribe,
 		},
+		{
+			Name:    "juno_getBlockWithTxsAndReceipts",
+			Params:  []jsonrpc.Parameter{{Name: "block_id"}},
+			Handler: h.JunoGetBlockWithTxsAndReceipts,
+		},
 	}, "/v0_6"
 }
+
+func (h *Handler) JunoGetNodesFromRoot(key felt.Felt) (string, *jsonrpc.Error) {
+	stateReader, _, error := h.bcReader.HeadState()
+	if error != nil {
+		return "", ErrBlockNotFound
+	}
+	try, _, errTry := stateReader.NodeFromRoot()
+	if errTry != nil {
+		return "", ErrBlockNotFound
+	}
+
+	k := try.FeltToKeyConverter(&key)
+	storageNodes, err := try.GetNodesFromRoot(&k)
+	if err != nil {
+		return "", ErrBlockNotFound
+	}
+
+	parsedNodes := try.NodeParser(storageNodes)
+
+	jsonBytes, err := json.Marshal(parsedNodes)
+	if err != nil {
+		return "", ErrParsingError
+	}
+	return string(jsonBytes), nil
+}

rpc/handlers_test.go

@@ -99,3 +99,21 @@ func TestThrottledVMError(t *testing.T) {
 		assert.Equal(t, throttledErr, rpcErr.Data)
 	})
 }
+
+func TestJunoGetBlockFromRoot(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, _ := handler.JunoGetNodesFromRoot(felt.Zero)
+		require.Nil(t, nodeStorage)
+		// assert.Equal(t, rpc.ErrBlockNotFound, err)
+	})
+}