feat: state diff migrated compiled class (#3226)

* feat: add migrated class for a bunch of state diffs impl

* new field vm state diff: migrated compiled classes

* chore: add a bunch of todo and random refactors

* update vm2core stateDiff adapter

* chore: remove unnecessary dependencies from go.mod & go.sum

* feat: update blockifier to rpc v0.16.0-rc.1 (go dependencies)

* remove prints in test

* Initialize state diff with empty migrated classes

---------

Co-authored-by: Rodrigo <rodrodpino@gmail.com>

Author: EgeCaner

adapters/p2p2core/state.go

@@ -87,6 +87,7 @@ func AdaptStateDiff(
 		DeclaredV0Classes: declaredV0Classes,
 		DeclaredV1Classes: declaredV1Classes,
 		ReplacedClasses:   utils.ToMap(replacedClasses, adaptAddrToClassHash),
+		MigratedClasses:   nil, // todo(rdr): unsure of p2p relationship
 	}, nil
 }
 

adapters/sn2core/sn2core.go

@@ -393,6 +393,7 @@ func AdaptStateUpdate(response *starknet.StateUpdate) (*core.StateUpdate, error)
 	}, nil
 }
 
+// todo(rdr): return `core.StateDiff` by value
 func AdaptStateDiff(response *starknet.StateDiff) (*core.StateDiff, error) {
 	stateDiff := new(core.StateDiff)
 	stateDiff.DeclaredV0Classes = response.OldDeclaredContracts
@@ -402,6 +403,13 @@ func AdaptStateDiff(response *starknet.StateDiff) (*core.StateDiff, error) {
 		stateDiff.DeclaredV1Classes[*declaredV1Class.ClassHash] = declaredV1Class.CompiledClassHash
 	}
 
+	stateDiff.MigratedClasses = make(
+		map[felt.SierraClassHash]felt.CasmClassHash, len(response.MigratedClasses),
+	)
+	for _, migratedClass := range response.MigratedClasses {
+		stateDiff.MigratedClasses[migratedClass.ClassHash] = migratedClass.CompiledClassHash
+	}
+
 	stateDiff.ReplacedClasses = make(map[felt.Felt]*felt.Felt, len(response.ReplacedClasses))
 	for _, replacedClass := range response.ReplacedClasses {
 		stateDiff.ReplacedClasses[*replacedClass.Address] = replacedClass.ClassHash

adapters/vm2core/vm2core.go

@@ -19,11 +19,17 @@ func AdaptOrderedEvent(event vm.OrderedEvent) *core.Event {
 	}
 }
 
+// todo(rdr): this is function definition is twice wrong:
+//   - the parameters should be received by reference
+//   - the output param should be return by value
 func AdaptOrderedMessageToL1(message vm.OrderedL2toL1Message) *core.L2ToL1Message {
 	return &core.L2ToL1Message{
 		From:    message.From,
 		Payload: message.Payload,
-		To:      common.HexToAddress(message.To),
+		// todo(rdr): this is not correct because it implies the L1 is always Ethereum
+		// 			  and from Starknet 0.14.1 that is no longer a strong assumption.
+		//            we should have a `felt.L1Address` (or similar)
+		To: common.HexToAddress(message.To.String()),
 	}
 }
 
@@ -49,12 +55,18 @@ func AdaptStateDiff(fromStateDiff *vm.StateDiff) core.StateDiff {
 
 	// Preallocate all maps with known sizes from fromStateDiff
 	toStateDiff = core.StateDiff{
-		StorageDiffs:      make(map[felt.Felt]map[felt.Felt]*felt.Felt, len(fromStateDiff.StorageDiffs)),
+		StorageDiffs: make(
+			map[felt.Felt]map[felt.Felt]*felt.Felt, len(fromStateDiff.StorageDiffs),
+		),
 		Nonces:            make(map[felt.Felt]*felt.Felt, len(fromStateDiff.Nonces)),
 		DeployedContracts: make(map[felt.Felt]*felt.Felt, len(fromStateDiff.DeployedContracts)),
 		DeclaredV0Classes: make([]*felt.Felt, len(fromStateDiff.DeprecatedDeclaredClasses)),
 		DeclaredV1Classes: make(map[felt.Felt]*felt.Felt, len(fromStateDiff.DeclaredClasses)),
-		ReplacedClasses:   make(map[felt.Felt]*felt.Felt, len(fromStateDiff.ReplacedClasses)),
+		MigratedClasses: make(
+			map[felt.SierraClassHash]felt.CasmClassHash,
+			len(fromStateDiff.MigratedCompiledClasses),
+		),
+		ReplacedClasses: make(map[felt.Felt]*felt.Felt, len(fromStateDiff.ReplacedClasses)),
 	}
 
 	for _, sd := range fromStateDiff.StorageDiffs {
@@ -85,6 +97,11 @@ func AdaptStateDiff(fromStateDiff *vm.StateDiff) core.StateDiff {
 		ch := rc.ClassHash
 		toStateDiff.ReplacedClasses[rc.ContractAddress] = &ch
 	}
+
+	for _, mc := range fromStateDiff.MigratedCompiledClasses {
+		toStateDiff.MigratedClasses[mc.ClassHash] = mc.CompiledClassHash
+	}
+
 	return toStateDiff
 }
 

adapters/vm2core/vm2core_test.go

@@ -42,13 +42,13 @@ func TestAdaptOrderedEvents(t *testing.T) {
 
 func TestAdaptOrderedMessageToL1(t *testing.T) {
 	require.Equal(t, &core.L2ToL1Message{
-		From:    new(felt.Felt).SetUint64(2),
+		From:    felt.NewFromUint64[felt.Felt](2),
 		To:      common.HexToAddress("0x3"),
 		Payload: []*felt.Felt{new(felt.Felt).SetUint64(4)},
 	}, vm2core.AdaptOrderedMessageToL1(vm.OrderedL2toL1Message{
 		Order:   1,
-		From:    new(felt.Felt).SetUint64(2),
-		To:      "0x3",
+		From:    felt.NewFromUint64[felt.Felt](2),
+		To:      felt.NewFromUint64[felt.Address](0x3),
 		Payload: []*felt.Felt{new(felt.Felt).SetUint64(4)},
 	}))
 }

blockchain/blockchain.go

@@ -409,6 +409,7 @@ func (b *Blockchain) RevertHead() error {
 	return b.database.Update(b.revertHead)
 }
 
+// todo(rdr): return `core.StateDiff` by value
 func (b *Blockchain) GetReverseStateDiff() (*core.StateDiff, error) {
 	var reverseStateDiff *core.StateDiff
 

core/felt/hash.go

@@ -16,6 +16,18 @@ func (h *ClassHash) String() string {
 	return (*Hash)(h).String()
 }
 
+type SierraClassHash ClassHash
+
+func (h *SierraClassHash) String() string {
+	return (*ClassHash)(h).String()
+}
+
+type CasmClassHash ClassHash
+
+func (h *CasmClassHash) String() string {
+	return (*ClassHash)(h).String()
+}
+
 type TransactionHash Hash
 
 func (h *TransactionHash) String() string {

core/state.go

@@ -645,11 +645,15 @@ func (s *State) purgesystemContracts() error {
 	return nil
 }
 
-func (s *State) removeDeclaredClasses(blockNumber uint64, v0Classes []*felt.Felt, v1Classes map[felt.Felt]*felt.Felt) error {
-	totalCapacity := len(v0Classes) + len(v1Classes)
+func (s *State) removeDeclaredClasses(
+	blockNumber uint64,
+	deprecatedClasses []*felt.Felt,
+	sierraClasses map[felt.Felt]*felt.Felt,
+) error {
+	totalCapacity := len(deprecatedClasses) + len(sierraClasses)
 	classHashes := make([]*felt.Felt, 0, totalCapacity)
-	classHashes = append(classHashes, v0Classes...)
-	for classHash := range v1Classes {
+	classHashes = append(classHashes, deprecatedClasses...)
+	for classHash := range sierraClasses {
 		classHashes = append(classHashes, classHash.Clone())
 	}
 
@@ -705,10 +709,10 @@ func (s *State) purgeContract(addr *felt.Felt) error {
 	return storageCloser()
 }
 
+// todo(rdr): return `StateDiff` by value
 func (s *State) GetReverseStateDiff(blockNumber uint64, diff *StateDiff) (*StateDiff, error) {
 	reversed := *diff
 
-	// storage diffs
 	reversed.StorageDiffs = make(map[felt.Felt]map[felt.Felt]*felt.Felt, len(diff.StorageDiffs))
 	for addr, storageDiffs := range diff.StorageDiffs {
 		reversedDiffs := make(map[felt.Felt]*felt.Felt, len(storageDiffs))
@@ -726,7 +730,6 @@ func (s *State) GetReverseStateDiff(blockNumber uint64, diff *StateDiff) (*State
 		reversed.StorageDiffs[addr] = reversedDiffs
 	}
 
-	// nonces
 	reversed.Nonces = make(map[felt.Felt]*felt.Felt, len(diff.Nonces))
 	for addr := range diff.Nonces {
 		oldNonce := felt.Zero
@@ -740,7 +743,6 @@ func (s *State) GetReverseStateDiff(blockNumber uint64, diff *StateDiff) (*State
 		reversed.Nonces[addr] = &oldNonce
 	}
 
-	// replaced
 	reversed.ReplacedClasses = make(map[felt.Felt]*felt.Felt, len(diff.ReplacedClasses))
 	for addr := range diff.ReplacedClasses {
 		classHash := felt.Zero

core/state_update.go

@@ -16,12 +16,24 @@ type StateUpdate struct {
 }
 
 type StateDiff struct {
-	StorageDiffs      map[felt.Felt]map[felt.Felt]*felt.Felt // addr -> {key -> value, ...}
-	Nonces            map[felt.Felt]*felt.Felt               // addr -> nonce
-	DeployedContracts map[felt.Felt]*felt.Felt               // addr -> class hash
-	DeclaredV0Classes []*felt.Felt                           // class hashes
-	DeclaredV1Classes map[felt.Felt]*felt.Felt               // class hash -> compiled class hash
-	ReplacedClasses   map[felt.Felt]*felt.Felt               // addr -> class hash
+	// todo(rdr): replace felt.Felt for the right types (felt.Address to felt.What? to felt.What?)
+	//            felt.What? means I'm not sure which type, but if it doesn't exist, create it.
+	StorageDiffs map[felt.Felt]map[felt.Felt]*felt.Felt // addr -> {key -> value, ...}
+	// todo(rdr): felt.Address to felt.Nonce (`Nonce` is a new type that should be created?)
+	Nonces map[felt.Felt]*felt.Felt
+	// todo(rdr): felt.Addr to felt.ClassHash (do we know if it will be `SierraClassHash or
+	//            `CasmClassHash`)
+	DeployedContracts map[felt.Felt]*felt.Felt
+	// todo(rdr): an array of felt.ClassHash, or perhaps, felt.DeprecatedCairoClassHash
+	//            Also, change the name from `DeclaredV0Classes` to `DeprecatedDeclaredClasses`
+	DeclaredV0Classes []*felt.Felt
+	// todo(rdr): felt.SierraClassHash to felt.CasmClassHash
+	DeclaredV1Classes map[felt.Felt]*felt.Felt // class hash -> compiled class hash
+	// todo(rdr): felt.Address to (felt.SierraClassHash or felt.CasmClassHash, I'm unsure)
+	ReplacedClasses map[felt.Felt]*felt.Felt // addr -> class hash
+	// Sierra Class definitions which had their compiled class hash definition (CASM)
+	// migrated from poseidon hash to blake2s hash (Starknet 0.14.1)
+	MigratedClasses map[felt.SierraClassHash]felt.CasmClassHash
 }
 
 func (d *StateDiff) Length() uint64 {
@@ -35,50 +47,61 @@ func (d *StateDiff) Length() uint64 {
 	length += len(d.DeclaredV0Classes)
 	length += len(d.DeclaredV1Classes)
 	length += len(d.ReplacedClasses)
+	length += len(d.MigratedClasses)
 
 	return uint64(length)
 }
 
 func (d *StateDiff) Merge(incoming *StateDiff) {
-	mergeStorageDiffs := func(oldMap, newMap map[felt.Felt]map[felt.Felt]*felt.Felt) {
-		for addr, newAddrStorage := range newMap {
-			if oldAddrStorage, exists := oldMap[addr]; exists {
-				maps.Copy(oldAddrStorage, newAddrStorage)
-			} else {
-				oldMap[addr] = maps.Clone(newAddrStorage)
-			}
+	// Merge storage diffs
+	for addr, newAddrStorage := range incoming.StorageDiffs {
+		if oldAddrStorage, exists := d.StorageDiffs[addr]; exists {
+			maps.Copy(oldAddrStorage, newAddrStorage)
+		} else {
+			d.StorageDiffs[addr] = maps.Clone(newAddrStorage)
 		}
 	}
+
+	// Merge everything else
 	maps.Copy(d.Nonces, incoming.Nonces)
 	maps.Copy(d.DeployedContracts, incoming.DeployedContracts)
 	maps.Copy(d.DeclaredV1Classes, incoming.DeclaredV1Classes)
 	maps.Copy(d.ReplacedClasses, incoming.ReplacedClasses)
-	mergeStorageDiffs(d.StorageDiffs, incoming.StorageDiffs)
+	maps.Copy(d.MigratedClasses, incoming.MigratedClasses)
 	d.DeclaredV0Classes = append(d.DeclaredV0Classes, incoming.DeclaredV0Classes...)
 }
 
-var starknetStateDiff0 = new(felt.Felt).SetBytes([]byte("STARKNET_STATE_DIFF0"))
+// todo(rdr): Is this global variable justified?
+var starknetStateDiff0 = felt.FromBytes[felt.Felt]([]byte("STARKNET_STATE_DIFF0"))
 
 func (d *StateDiff) Hash() *felt.Felt {
 	digest := new(crypto.PoseidonDigest)
 
-	digest.Update(starknetStateDiff0)
+	digest.Update(&starknetStateDiff0)
 
 	// updated_contracts = deployedContracts + replacedClasses
 	// Digest: [number_of_updated_contracts, address_0, class_hash_0, address_1, class_hash_1, ...].
 	updatedContractsDigest(d.DeployedContracts, d.ReplacedClasses, digest)
 
 	// declared classes
-	// Digest: [number_of_declared_classes, class_hash_0, compiled_class_hash_0, class_hash_1, compiled_class_hash_1,
-	// ...].
-	declaredClassesDigest(d.DeclaredV1Classes, digest)
+	// Digest: [
+	//    number_of_declared_classes,
+	//    class_hash_0, compiled_class_hash_0,
+	//    class_hash_1, compiled_class_hash_1,
+	//   ...
+	// ]  + [
+	//    migrated_class_hash_0, migrated_compiled_class_hash_0,
+	//    migrated_class_hash_1, migrated_compiled_class_hash_1,
+	//   ...
+	// ]
+	declaredClassesDigest(d.DeclaredV1Classes, d.MigratedClasses, digest)
 
 	// deprecated_declared_classes
 	// Digest: [number_of_old_declared_classes, class_hash_0, class_hash_1, ...].
 	deprecatedDeclaredClassesDigest(d.DeclaredV0Classes, digest)
 
 	// Placeholder values
-	digest.Update(new(felt.Felt).SetUint64(1), new(felt.Felt).SetUint64(0))
+	digest.Update(&felt.One, &felt.Zero)
 
 	// storage_diffs
 	// Digest: [
@@ -89,12 +112,23 @@ func (d *StateDiff) Hash() *felt.Felt {
 	storageDiffDigest(d.StorageDiffs, digest)
 
 	// nonces
-	// Digest: [number_of_updated_contracts nonces, contract_address_0, nonce_0, contract_address_1, nonce_1, ...]
+	// Digest: [
+	//   number_of_updated_contracts nonces,
+	//   contract_address_0, nonce_0,
+	//   contract_address_1, nonce_1,
+	//   ...,
+	// ]
 	noncesDigest(d.Nonces, digest)
 
 	/*Poseidon(
-	    "STARKNET_STATE_DIFF0", deployed_contracts_and_replaced_classes, declared_classes, deprecated_declared_classes,
-	    1, 0, storage_diffs, nonces
+	    "STARKNET_STATE_DIFF0",
+		deployed_contracts_and_replaced_classes,
+		declared_classes,
+		deprecated_declared_classes,
+	    1,
+		0,
+		storage_diffs,
+		nonces
 	)*/
 	return digest.Finish()
 }
@@ -114,8 +148,9 @@ func (d *StateDiff) Commitment() *felt.Felt {
 		hash_of_declared_classes = hash([number_of_declared_classes, class_hash_1, compiled_class_hash_1,
 			class_hash_2, compiled_class_hash_2, ...])
 	*/
+	// todo(rdr): check if commitment is like this too
 	hashOfDeclaredClasses := new(crypto.PoseidonDigest)
-	declaredClassesDigest(d.DeclaredV1Classes, hashOfDeclaredClasses)
+	declaredClassesDigest(d.DeclaredV1Classes, d.MigratedClasses, hashOfDeclaredClasses)
 
 	/*
 		hash_of_old_declared_classes = hash([number_of_old_declared_classes, class_hash_1, class_hash_2, ...])
@@ -173,13 +208,36 @@ func updatedContractsDigest(deployedContracts, replacedClasses map[felt.Felt]*fe
 	}
 }
 
-func declaredClassesDigest(declaredV1Classes map[felt.Felt]*felt.Felt, digest *crypto.PoseidonDigest) {
-	numOfDeclaredClasses := uint64(len(declaredV1Classes))
-	digest.Update(new(felt.Felt).SetUint64(numOfDeclaredClasses))
+func declaredClassesDigest(
+	declaredClasses map[felt.Felt]*felt.Felt,
+	migratedClasses map[felt.SierraClassHash]felt.CasmClassHash,
+	digest *crypto.PoseidonDigest,
+) {
+	mapsLen := len(declaredClasses) + len(migratedClasses)
+	numOfDeclaredClasses := felt.FromUint64[felt.Felt](uint64(mapsLen))
+	digest.Update(&numOfDeclaredClasses)
+
+	// Sorting the two keys without actually modifying `declaredClasses` or `migratedClasses`
+	// to avoid the memory overhead of creating a new map since we **mustn't** mutate them
+	keys := make([]felt.Felt, mapsLen)
+	index := 0
+	for key := range declaredClasses {
+		keys[index] = key
+		index += 1
+	}
+	for key := range migratedClasses {
+		// todo(rdr): we shouldn't need to convert the key to a felt here but the right fix
+		// includes a bigger refactor
+		keys[index] = felt.Felt(key)
+		index += 1
+	}
+	slices.SortFunc(keys, func(a felt.Felt, b felt.Felt) int { return a.Cmp(&b) })
 
-	sortedDeclaredV1ClassHashes := sortedFeltKeys(declaredV1Classes)
+	// todo(rdr): Is it more performant to do multiple calls to `diget.Update`, or
+	// pre-store all the values and make a single call to `digest.Update`?
+	sortedDeclaredV1ClassHashes := sortedFeltKeys(declaredClasses)
 	for _, classHash := range sortedDeclaredV1ClassHashes {
-		digest.Update(&classHash, declaredV1Classes[classHash])
+		digest.Update(&classHash, declaredClasses[classHash])
 	}
 }
 
@@ -191,7 +249,10 @@ func deprecatedDeclaredClassesDigest(declaredV0Classes []*felt.Felt, digest *cry
 	digest.Update(declaredV0Classes...)
 }
 
-func storageDiffDigest(storageDiffs map[felt.Felt]map[felt.Felt]*felt.Felt, digest *crypto.PoseidonDigest) {
+func storageDiffDigest(
+	storageDiffs map[felt.Felt]map[felt.Felt]*felt.Felt,
+	digest *crypto.PoseidonDigest,
+) {
 	numOfStorageDiffs := uint64(len(storageDiffs))
 	digest.Update(new(felt.Felt).SetUint64(numOfStorageDiffs))
 
@@ -226,5 +287,6 @@ func EmptyStateDiff() StateDiff {
 		DeclaredV0Classes: []*felt.Felt{},
 		DeclaredV1Classes: make(map[felt.Felt]*felt.Felt),
 		ReplacedClasses:   make(map[felt.Felt]*felt.Felt),
+		MigratedClasses:   make(map[felt.SierraClassHash]felt.CasmClassHash),
 	}
 }

core/transaction.go

@@ -85,6 +85,8 @@ type Event struct {
 }
 
 type L1ToL2Message struct {
+	// todo(rdr): Starknet from 0.14.1 has dropped the assumption that we use an EthAddress
+	//            here. We should change this to felt.Address
 	From     common.Address
 	Nonce    *felt.Felt
 	Payload  []*felt.Felt
@@ -95,7 +97,9 @@ type L1ToL2Message struct {
 type L2ToL1Message struct {
 	From    *felt.Felt
 	Payload []*felt.Felt
-	To      common.Address
+	// todo(rdr): Starknet from 0.14.1 has dropped the assumption that we use an EthAddress
+	//            here. We should change this to felt.Address
+	To common.Address
 }
 
 type ExecutionResources struct {