feat: 0.14.0 preconfirmed block (#2954)

* starknet preconfirmed block type

* core preconfirmed

* test feeder gw supports get_preconfirmed_block

* feeder endpoints and preconfirmed block adapter with tests

* extract statediff into its own type

* fix message

* remove blocknumber assignment since it is already done in adapter

* remove unnecessary functions

* []*Transaction to []Transaction

* move preconfirmed block status check to adapter

* return PreConfirmed as value

* address requested changes

* bump SupportedStarknetVersion

* extract feeder test client into its own file

* update starknet-js version

* ci: upgrade starknet.js tests

---------

Co-authored-by: wojo <wojciech.zieba@gmail.com>

Author: EgeCaner

.github/workflows/deploy-and-test.yaml

@@ -105,7 +105,7 @@ jobs:
     with:
       test_mode: ${{ inputs.test_mode }}
     secrets:
-      TEST_RPC_URL: ${{ secrets.RPC_URL }}/v0_7?apikey=${{ secrets.AUTH_TOKEN }}
+      TEST_RPC_URL: ${{ secrets.RPC_URL }}/v0_8?apikey=${{ secrets.AUTH_TOKEN }}
       TEST_ACCOUNT_ADDRESS: ${{ secrets.TEST_ACCOUNT_ADDRESS }}
       TEST_ACCOUNT_PRIVATE_KEY: ${{ secrets.TEST_ACCOUNT_PRIVATE_KEY }}
 

.github/workflows/starknet-js-tests.yml

@@ -23,7 +23,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           repository: starknet-io/starknet.js
-          ref: v6.14.1
+          ref: v7.6.2
 
       - name: Setup Node.js
         uses: actions/setup-node@v4
@@ -48,3 +48,4 @@ jobs:
           TEST_RPC_URL: ${{ secrets.TEST_RPC_URL }}
           TEST_ACCOUNT_ADDRESS: ${{ secrets.TEST_ACCOUNT_ADDRESS }}
           TEST_ACCOUNT_PRIVATE_KEY: ${{ secrets.TEST_ACCOUNT_PRIVATE_KEY }}
+          TX_VERSION: v3

adapters/sn2core/sn2core.go

@@ -357,35 +357,49 @@ func AdaptCairo0Class(response *starknet.Cairo0Definition) (core.Class, error) {
 }
 
 func AdaptStateUpdate(response *starknet.StateUpdate) (*core.StateUpdate, error) {
+	stateDiff, err := AdaptStateDiff(&response.StateDiff)
+	if err != nil {
+		return nil, err
+	}
+
+	return &core.StateUpdate{
+		BlockHash: response.BlockHash,
+		NewRoot:   response.NewRoot,
+		OldRoot:   response.OldRoot,
+		StateDiff: stateDiff,
+	}, nil
+}
+
+func AdaptStateDiff(response *starknet.StateDiff) (*core.StateDiff, error) {
 	stateDiff := new(core.StateDiff)
-	stateDiff.DeclaredV0Classes = response.StateDiff.OldDeclaredContracts
+	stateDiff.DeclaredV0Classes = response.OldDeclaredContracts
 
-	stateDiff.DeclaredV1Classes = make(map[felt.Felt]*felt.Felt, len(response.StateDiff.DeclaredClasses))
-	for _, declaredV1Class := range response.StateDiff.DeclaredClasses {
+	stateDiff.DeclaredV1Classes = make(map[felt.Felt]*felt.Felt, len(response.DeclaredClasses))
+	for _, declaredV1Class := range response.DeclaredClasses {
 		stateDiff.DeclaredV1Classes[*declaredV1Class.ClassHash] = declaredV1Class.CompiledClassHash
 	}
 
-	stateDiff.ReplacedClasses = make(map[felt.Felt]*felt.Felt, len(response.StateDiff.ReplacedClasses))
-	for _, replacedClass := range response.StateDiff.ReplacedClasses {
+	stateDiff.ReplacedClasses = make(map[felt.Felt]*felt.Felt, len(response.ReplacedClasses))
+	for _, replacedClass := range response.ReplacedClasses {
 		stateDiff.ReplacedClasses[*replacedClass.Address] = replacedClass.ClassHash
 	}
 
-	stateDiff.DeployedContracts = make(map[felt.Felt]*felt.Felt, len(response.StateDiff.DeployedContracts))
-	for _, deployedContract := range response.StateDiff.DeployedContracts {
+	stateDiff.DeployedContracts = make(map[felt.Felt]*felt.Felt, len(response.DeployedContracts))
+	for _, deployedContract := range response.DeployedContracts {
 		stateDiff.DeployedContracts[*deployedContract.Address] = deployedContract.ClassHash
 	}
 
-	stateDiff.Nonces = make(map[felt.Felt]*felt.Felt, len(response.StateDiff.Nonces))
-	for addrStr, nonce := range response.StateDiff.Nonces {
+	stateDiff.Nonces = make(map[felt.Felt]*felt.Felt, len(response.Nonces))
+	for addrStr, nonce := range response.Nonces {
 		addr, err := new(felt.Felt).SetString(addrStr)
 		if err != nil {
 			return nil, err
 		}
 		stateDiff.Nonces[*addr] = nonce
 	}
 
-	stateDiff.StorageDiffs = make(map[felt.Felt]map[felt.Felt]*felt.Felt, len(response.StateDiff.StorageDiffs))
-	for addrStr, diffs := range response.StateDiff.StorageDiffs {
+	stateDiff.StorageDiffs = make(map[felt.Felt]map[felt.Felt]*felt.Felt, len(response.StorageDiffs))
+	for addrStr, diffs := range response.StorageDiffs {
 		addr, err := new(felt.Felt).SetString(addrStr)
 		if err != nil {
 			return nil, err
@@ -397,12 +411,102 @@ func AdaptStateUpdate(response *starknet.StateUpdate) (*core.StateUpdate, error)
 		}
 	}
 
-	return &core.StateUpdate{
-		BlockHash: response.BlockHash,
-		NewRoot:   response.NewRoot,
-		OldRoot:   response.OldRoot,
-		StateDiff: stateDiff,
-	}, nil
+	return stateDiff, nil
+}
+
+func AdaptPreConfirmedBlock(response *starknet.PreConfirmedBlock, number uint64) (core.PreConfirmed, error) {
+	if response == nil {
+		return core.PreConfirmed{}, errors.New("nil preconfirmed block")
+	}
+
+	if response.Status != "PRE_CONFIRMED" {
+		return core.PreConfirmed{}, errors.New("invalid status for pre_confirmed block")
+	}
+
+	var adaptedStateDiff *core.StateDiff
+	var err error
+
+	txStateDiffs := make([]*core.StateDiff, 0, len(response.TransactionStateDiffs))
+	for _, stateDiff := range response.TransactionStateDiffs {
+		if stateDiff == nil {
+			break
+		}
+
+		if adaptedStateDiff, err = AdaptStateDiff(stateDiff); err != nil {
+			return core.PreConfirmed{}, err
+		}
+		txStateDiffs = append(txStateDiffs, adaptedStateDiff)
+	}
+
+	preConfirmedTxCount := len(txStateDiffs)
+
+	txns := make([]core.Transaction, preConfirmedTxCount)
+	for i := range preConfirmedTxCount {
+		txns[i], err = AdaptTransaction(&response.Transactions[i])
+		if err != nil {
+			return core.PreConfirmed{}, err
+		}
+	}
+
+	rawTxCount := len(response.Transactions)
+	candidateTxs := make([]core.Transaction, rawTxCount-preConfirmedTxCount)
+
+	for i := range rawTxCount - preConfirmedTxCount {
+		candidateTxs[i], err = AdaptTransaction(&response.Transactions[preConfirmedTxCount+i])
+		if err != nil {
+			return core.PreConfirmed{}, err
+		}
+	}
+
+	receipts := make([]*core.TransactionReceipt, preConfirmedTxCount)
+	eventCount := uint64(0)
+	for i, receipt := range response.Receipts[:preConfirmedTxCount] {
+		receipts[i] = AdaptTransactionReceipt(receipt)
+		eventCount += uint64(len(receipt.Events))
+	}
+
+	// Squash per-tx state updates
+	stateDiff := core.EmptyStateDiff()
+	for _, txStateDiff := range txStateDiffs {
+		stateDiff.Merge(txStateDiff)
+	}
+
+	stateUpdate := core.StateUpdate{
+		BlockHash: nil,
+		NewRoot:   nil,
+		// Must be set to previous global state root, when have access to latest header
+		OldRoot:   nil,
+		StateDiff: &stateDiff,
+	}
+
+	adaptedBlock := &core.Block{
+		// https://github.com/starkware-libs/starknet-specs/blob/9377851884da5c81f757b6ae0ed47e84f9e7c058/api/starknet_api_openrpc.json#L1636
+		Header: &core.Header{
+			Number:           number,
+			SequencerAddress: response.SequencerAddress,
+			// Not required in spec but useful
+			TransactionCount: uint64(len(txns)),
+			// Not required in spec but useful
+			EventCount:      eventCount,
+			Timestamp:       response.Timestamp,
+			ProtocolVersion: response.Version,
+			// Not required in spec but useful
+			EventsBloom:    core.EventsBloom(receipts),
+			L1GasPriceETH:  response.L1GasPrice.PriceInWei,
+			L1GasPriceSTRK: response.L1GasPrice.PriceInFri,
+			L1DAMode:       core.L1DAMode(response.L1DAMode),
+			L1DataGasPrice: (*core.GasPrice)(response.L1DataGasPrice),
+			L2GasPrice:     (*core.GasPrice)(response.L2GasPrice),
+			// Following fields are nil for pre_confirmed block
+			Hash:            nil,
+			ParentHash:      nil,
+			GlobalStateRoot: nil,
+			Signatures:      nil,
+		},
+		Transactions: txns,
+		Receipts:     receipts,
+	}
+	return core.NewPreConfirmed(adaptedBlock, &stateUpdate, txStateDiffs, candidateTxs), nil
 }
 
 func safeFeltToUint64(f *felt.Felt) uint64 {

adapters/sn2core/sn2core_test.go

@@ -623,3 +623,139 @@ func TestAdaptCompiledClass(t *testing.T) {
 	require.NoError(t, err)
 	assert.Nil(t, result)
 }
+
+func TestAdaptPreConfirmed(t *testing.T) {
+	n := &utils.SepoliaIntegration
+	client := feeder.NewTestClient(t, n)
+	emptyPreConfirmedBlock := uint64(1201960)
+	blockWithCandidates := uint64(1204672)
+	blockWithNoCandidates := uint64(1204673)
+	blockFullOfCandidates := uint64(1204674)
+
+	type preConfirmedTest struct {
+		description string
+		blockNumber uint64
+	}
+
+	tests := []preConfirmedTest{
+		{
+			description: "PreConfirmedBlock when there is no candidates",
+			blockNumber: blockWithNoCandidates,
+		},
+		{
+			description: "PreConfirmedBlock with candidates",
+			blockNumber: blockWithCandidates,
+		},
+		{
+			description: "PreConfirmedBlock when full of candidates",
+			blockNumber: blockFullOfCandidates,
+		},
+		{
+			description: "PreConfirmedBlock when empty",
+			blockNumber: emptyPreConfirmedBlock,
+		},
+	}
+
+	for _, test := range tests {
+		response, err := client.PreConfirmedBlock(t.Context(), strconv.FormatUint(test.blockNumber, 10))
+		require.NoError(t, err)
+
+		expectedEventCount, expectedPreConfirmedTxCount := countEventsAndTxs(response.Receipts)
+		expectedCandidateCount := len(response.Transactions) - expectedPreConfirmedTxCount
+
+		adapted, err := sn2core.AdaptPreConfirmedBlock(response, test.blockNumber)
+		require.NoError(t, err)
+
+		assertPreConfirmedBlockBasics(t, &adapted, test.blockNumber, response, expectedPreConfirmedTxCount, expectedCandidateCount, expectedEventCount)
+		assertPreConfirmedBlockReceipts(t, response.Receipts, adapted.Block.Receipts, expectedPreConfirmedTxCount)
+		assertPreConfirmedBlockGasPrices(t, response, adapted.Block)
+		assertCandidateTxs(t, response.Transactions, adapted.CandidateTxs, expectedPreConfirmedTxCount)
+		assert.Equal(t, len(adapted.TransactionStateDiffs), expectedPreConfirmedTxCount)
+	}
+}
+
+func assertPreConfirmedBlockBasics(
+	t *testing.T,
+	preConfirmed *core.PreConfirmed,
+	blockNum uint64,
+	response *starknet.PreConfirmedBlock,
+	expectedTxCount int,
+	expectedCandidateCount int,
+	expectedEventCount uint64,
+) {
+	assert.Equal(t, blockNum, preConfirmed.Block.Number)
+	assert.NotNil(t, preConfirmed.Block.EventsBloom)
+	assert.Empty(t, preConfirmed.Block.Hash)
+	assert.Empty(t, preConfirmed.Block.ParentHash)
+	assert.Empty(t, preConfirmed.Block.GlobalStateRoot)
+	assert.Empty(t, preConfirmed.Block.Signatures)
+	assert.Empty(t, preConfirmed.StateUpdate.NewRoot)
+	assert.Empty(t, preConfirmed.StateUpdate.BlockHash)
+	assert.Equal(t, response.Timestamp, preConfirmed.Block.Timestamp)
+	assert.Equal(t, expectedTxCount, len(preConfirmed.Block.Transactions))
+	assert.Equal(t, expectedCandidateCount, len(preConfirmed.CandidateTxs))
+	assert.Equal(t, uint64(expectedTxCount), preConfirmed.Block.TransactionCount)
+	assert.Equal(t, expectedEventCount, preConfirmed.Block.EventCount)
+	assert.Equal(t, response.Version, preConfirmed.Block.ProtocolVersion)
+	assert.Equal(t, response.L1GasPrice.PriceInFri, preConfirmed.Block.L1GasPriceSTRK)
+	assert.Equal(t, response.L1GasPrice.PriceInWei, preConfirmed.Block.L1GasPriceETH)
+}
+
+func assertCandidateTxs(
+	t *testing.T,
+	transactions []starknet.Transaction,
+	candidateTxs []core.Transaction,
+	offset int,
+) {
+	t.Helper()
+
+	for i, txn := range candidateTxs {
+		adaptedTx, err := sn2core.AdaptTransaction(&transactions[offset+i])
+		require.NoError(t, err)
+		assert.Equal(t, adaptedTx, txn)
+	}
+}
+
+func assertPreConfirmedBlockGasPrices(t *testing.T, response *starknet.PreConfirmedBlock, block *core.Block) {
+	t.Helper()
+	assert.Equal(t, response.L1DataGasPrice.PriceInFri, block.L1DataGasPrice.PriceInFri)
+	assert.Equal(t, response.L1DataGasPrice.PriceInWei, block.L1DataGasPrice.PriceInWei)
+	assert.Equal(t, response.L2GasPrice.PriceInFri, block.L2GasPrice.PriceInFri)
+	assert.Equal(t, response.L2GasPrice.PriceInWei, block.L2GasPrice.PriceInWei)
+}
+
+func countEventsAndTxs(receipts []*starknet.TransactionReceipt) (uint64, int) {
+	var evCount uint64
+	txCount := 0
+	for _, r := range receipts {
+		if r == nil {
+			break
+		}
+		evCount += uint64(len(r.Events))
+		txCount++
+	}
+	return evCount, txCount
+}
+
+func assertPreConfirmedBlockReceipts(
+	t *testing.T,
+	expectedReceipts []*starknet.TransactionReceipt,
+	blockReceipts []*core.TransactionReceipt,
+	expectedPreConfirmedTxCount int,
+) {
+	t.Helper()
+	if assert.Equal(t, expectedPreConfirmedTxCount, len(blockReceipts)) {
+		for i, actual := range blockReceipts {
+			expected := expectedReceipts[i]
+			assert.Equal(t, expected.ExecutionStatus == starknet.Reverted, actual.Reverted)
+			assert.Equal(t, expected.RevertError, actual.RevertReason)
+			if expected.ExecutionResources != nil {
+				assert.Equal(
+					t,
+					(*core.DataAvailability)(expected.ExecutionResources.DataAvailability),
+					actual.ExecutionResources.DataAvailability,
+				)
+			}
+		}
+	}
+}

blockchain/blockchain.go

@@ -52,7 +52,7 @@ type Reader interface {
 
 var (
 	ErrParentDoesNotMatchHead = errors.New("block's parent hash does not match head block hash")
-	SupportedStarknetVersion  = semver.MustParse("0.13.3")
+	SupportedStarknetVersion  = semver.MustParse("0.14.0")
 )
 
 func CheckBlockVersion(protocolVersion string) error {