From 506ff804a80fc39d56f3856cdd6f20b4f6f28518 Mon Sep 17 00:00:00 2001 From: Niloy Datta Date: Tue, 11 Nov 2025 12:59:17 +0600 Subject: [PATCH 1/2] AdaptBlock method of sn2core.go is returning value type --- adapters/sn2core/sn2core.go | 8 ++++---- starknetdata/feeder/feeder.go | 8 ++++---- starknetdata/feeder/feeder_test.go | 8 ++++---- 3 files changed, 12 insertions(+), 12 deletions(-) diff --git a/adapters/sn2core/sn2core.go b/adapters/sn2core/sn2core.go index c14e0eee10..40a5a3b63e 100644 --- a/adapters/sn2core/sn2core.go +++ b/adapters/sn2core/sn2core.go @@ -13,9 +13,9 @@ import ( "github.com/ethereum/go-ethereum/common" ) -func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (*core.Block, error) { +func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (core.Block, error) { if response == nil { - return nil, errors.New("nil client block") + return core.Block{}, errors.New("nil client block") } txns := make([]core.Transaction, len(response.Transactions)) @@ -23,7 +23,7 @@ func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (*core.Block, var err error txns[i], err = AdaptTransaction(response.Transactions[i]) if err != nil { - return nil, err + return core.Block{}, err } } @@ -39,7 +39,7 @@ func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (*core.Block, sigs = append(sigs, sig.Signature) } - return &core.Block{ + return core.Block{ Header: &core.Header{ Hash: response.Hash, ParentHash: response.ParentHash, diff --git a/starknetdata/feeder/feeder.go b/starknetdata/feeder/feeder.go index 07834473f9..4f5b5b9758 100644 --- a/starknetdata/feeder/feeder.go +++ b/starknetdata/feeder/feeder.go @@ -66,8 +66,8 @@ func (f *Feeder) block(ctx context.Context, blockID string) (*core.Block, error) return nil, fmt.Errorf("get signature for block %q: %v", blockID, err) } } - - return sn2core.AdaptBlock(response, sig) + adaptedBlock, err := sn2core.AdaptBlock(response, sig) + return &adaptedBlock, err } // Transaction gets the transaction for a given transaction hash from the feeder, @@ -148,7 +148,7 @@ func (f *Feeder) stateUpdateWithBlock(ctx context.Context, blockID string) (*cor } var adaptedState *core.StateUpdate - var adaptedBlock *core.Block + var adaptedBlock core.Block if adaptedState, err = sn2core.AdaptStateUpdate(response.StateUpdate); err != nil { return nil, nil, err @@ -158,7 +158,7 @@ func (f *Feeder) stateUpdateWithBlock(ctx context.Context, blockID string) (*cor return nil, nil, err } - return adaptedState, adaptedBlock, nil + return adaptedState, &adaptedBlock, nil } // StateUpdatePendingWithBlock gets both pending state update and pending block from the feeder, diff --git a/starknetdata/feeder/feeder_test.go b/starknetdata/feeder/feeder_test.go index 95a80044e0..2c522195ee 100644 --- a/starknetdata/feeder/feeder_test.go +++ b/starknetdata/feeder/feeder_test.go @@ -32,7 +32,7 @@ func TestBlockByNumber(t *testing.T) { require.NoError(t, err) adaptedResponse, err := sn2core.AdaptBlock(response, sig) require.NoError(t, err) - assert.Equal(t, adaptedResponse, block) + assert.Equal(t, &adaptedResponse, block) }) } } @@ -50,7 +50,7 @@ func TestBlockLatest(t *testing.T) { require.NoError(t, err) adaptedResponse, err := sn2core.AdaptBlock(response, sig) require.NoError(t, err) - assert.Equal(t, adaptedResponse, block) + assert.Equal(t, &adaptedResponse, block) } func TestStateUpdate(t *testing.T) { @@ -240,7 +240,7 @@ func TestStateUpdateWithBlock(t *testing.T) { require.NoError(t, err) adaptedStateUpdate, err := sn2core.AdaptStateUpdate(response.StateUpdate) require.NoError(t, err) - assert.Equal(t, block, adaptedBlock) + assert.Equal(t, block, &adaptedBlock) assert.Equal(t, stateUpdate, adaptedStateUpdate) }) } @@ -259,7 +259,7 @@ func TestStateUpdatePendingWithBlock(t *testing.T) { require.NoError(t, err) stateUpdate, block, err := adapter.StateUpdatePendingWithBlock(ctx) require.NoError(t, err) - assert.Equal(t, block, adaptedBlock) + assert.Equal(t, block, &adaptedBlock) assert.Equal(t, stateUpdate, adaptedStateUpdate) } From 3abc38449889cda622a7487293ff03edf4ec7828 Mon Sep 17 00:00:00 2001 From: Niloy Datta Date: Tue, 11 Nov 2025 14:12:47 +0600 Subject: [PATCH 2/2] Refactored sn2core.go methods to return by value instead of reference --- adapters/p2p2core/class.go | 4 +- adapters/sn2core/sn2core.go | 85 ++++++++++++++++-------------- adapters/sn2core/sn2core_test.go | 4 +- migration/migration.go | 6 +-- migration/migration_pkg_test.go | 2 +- starknet/compiler/compiler_test.go | 4 +- starknetdata/feeder/feeder.go | 8 +-- starknetdata/feeder/feeder_test.go | 8 +-- 8 files changed, 64 insertions(+), 57 deletions(-) diff --git a/adapters/p2p2core/class.go b/adapters/p2p2core/class.go index 2212aa596e..f2e21e624a 100644 --- a/adapters/p2p2core/class.go +++ b/adapters/p2p2core/class.go @@ -119,6 +119,6 @@ func createCompiledClass(cairo1 *class.Cairo1Class) (*core.CasmClass, error) { if err != nil { return nil, err } - - return sn2core.AdaptCompiledClass(compiledClass) + coreCasmClass, err := sn2core.AdaptCasmClass(compiledClass) + return &coreCasmClass, err } diff --git a/adapters/sn2core/sn2core.go b/adapters/sn2core/sn2core.go index 40a5a3b63e..9807166128 100644 --- a/adapters/sn2core/sn2core.go +++ b/adapters/sn2core/sn2core.go @@ -30,7 +30,7 @@ func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (core.Block, receipts := make([]*core.TransactionReceipt, len(response.Receipts)) eventCount := uint64(0) for i := range response.Receipts { - receipts[i] = AdaptTransactionReceipt(response.Receipts[i]) + receipts[i] = utils.HeapPtr(AdaptTransactionReceipt(response.Receipts[i])) eventCount += uint64(len(response.Receipts[i].Events)) } @@ -63,71 +63,78 @@ func AdaptBlock(response *starknet.Block, sig *starknet.Signature) (core.Block, }, nil } -func AdaptTransactionReceipt(response *starknet.TransactionReceipt) *core.TransactionReceipt { +func AdaptTransactionReceipt(response *starknet.TransactionReceipt) core.TransactionReceipt { if response == nil { - return nil + return core.TransactionReceipt{} //nolint:exhaustruct // returning empty object + } + + events := make([]*core.Event, len(response.Events)) + for i := range response.Events { + events[i] = utils.HeapPtr(AdaptEvent(response.Events[i])) } - return &core.TransactionReceipt{ + l2ToL1Messages := make([]*core.L2ToL1Message, len(response.L2ToL1Message)) + for i := range response.L2ToL1Message { + l2ToL1Messages[i] = utils.HeapPtr(AdaptL2ToL1Message(response.L2ToL1Message[i])) + } + + return core.TransactionReceipt{ FeeUnit: 0, // todo(kirill) recheck Fee: response.ActualFee, TransactionHash: response.TransactionHash, - Events: utils.Map(utils.NonNilSlice(response.Events), AdaptEvent), - ExecutionResources: AdaptExecutionResources(response.ExecutionResources), - L1ToL2Message: AdaptL1ToL2Message(response.L1ToL2Message), - L2ToL1Message: utils.Map( - utils.NonNilSlice(response.L2ToL1Message), - AdaptL2ToL1Message, - ), - Reverted: response.ExecutionStatus == starknet.Reverted, - RevertReason: response.RevertError, + Events: events, + ExecutionResources: utils.HeapPtr(AdaptExecutionResources(response.ExecutionResources)), + L1ToL2Message: utils.HeapPtr(AdaptL1ToL2Message(response.L1ToL2Message)), + L2ToL1Message: l2ToL1Messages, + Reverted: response.ExecutionStatus == starknet.Reverted, + RevertReason: response.RevertError, } } -func adaptGasConsumed(response *starknet.GasConsumed) *core.GasConsumed { +func adaptGasConsumed(response *starknet.GasConsumed) core.GasConsumed { if response == nil { - return nil + return core.GasConsumed{} //nolint:exhaustruct // returning empty object } - return &core.GasConsumed{ + return core.GasConsumed{ L1Gas: response.L1Gas, L1DataGas: response.L1DataGas, L2Gas: response.L2Gas, } } -func AdaptEvent(response *starknet.Event) *core.Event { +func AdaptEvent(response *starknet.Event) core.Event { if response == nil { - return nil + return core.Event{} //nolint:exhaustruct // returning empty object } - return &core.Event{ + return core.Event{ Data: response.Data, From: response.From, Keys: response.Keys, } } -func AdaptExecutionResources(response *starknet.ExecutionResources) *core.ExecutionResources { +func AdaptExecutionResources(response *starknet.ExecutionResources) core.ExecutionResources { if response == nil { - return nil + return core.ExecutionResources{} //nolint:exhaustruct // returning empty object } - return &core.ExecutionResources{ + return core.ExecutionResources{ BuiltinInstanceCounter: core.BuiltinInstanceCounter(response.BuiltinInstanceCounter), MemoryHoles: response.MemoryHoles, Steps: response.Steps, DataAvailability: (*core.DataAvailability)(response.DataAvailability), - TotalGasConsumed: adaptGasConsumed(response.TotalGasConsumed), + TotalGasConsumed: utils.HeapPtr(adaptGasConsumed(response.TotalGasConsumed)), } } -func AdaptL1ToL2Message(response *starknet.L1ToL2Message) *core.L1ToL2Message { +func AdaptL1ToL2Message(response *starknet.L1ToL2Message) core.L1ToL2Message { if response == nil { - return nil + return core.L1ToL2Message{} //nolint:exhaustruct // returning empty object } - return &core.L1ToL2Message{ + return core.L1ToL2Message{ From: common.HexToAddress(response.From), Nonce: response.Nonce, Payload: response.Payload, @@ -136,12 +143,12 @@ func AdaptL1ToL2Message(response *starknet.L1ToL2Message) *core.L1ToL2Message { } } -func AdaptL2ToL1Message(response *starknet.L2ToL1Message) *core.L2ToL1Message { +func AdaptL2ToL1Message(response *starknet.L2ToL1Message) core.L2ToL1Message { if response == nil { - return nil + return core.L2ToL1Message{} //nolint:exhaustruct // returning empty object } - return &core.L2ToL1Message{ + return core.L2ToL1Message{ From: response.From, Payload: response.Payload, To: common.HexToAddress(response.To), @@ -316,7 +323,7 @@ func AdaptSierraClass( return nil, errors.New("sierra program size is too small") } - coreCompiledClass, err := AdaptCompiledClass(compiledClass) + coreCompiledClass, err := AdaptCasmClass(compiledClass) if err != nil { return nil, err } @@ -329,15 +336,15 @@ func AdaptSierraClass( Abi: response.Abi, AbiHash: crypto.StarknetKeccak([]byte(response.Abi)), - Compiled: coreCompiledClass, + Compiled: &coreCompiledClass, EntryPoints: adaptSierraEntrypoints(&response.EntryPoints), }, nil } -func AdaptCompiledClass(compiledClass *starknet.CasmClass) (*core.CasmClass, error) { +func AdaptCasmClass(compiledClass *starknet.CasmClass) (core.CasmClass, error) { if compiledClass == nil { - return nil, nil + return core.CasmClass{}, nil //nolint:exhaustruct // returning empty object } var casm core.CasmClass @@ -350,7 +357,7 @@ func AdaptCompiledClass(compiledClass *starknet.CasmClass) (*core.CasmClass, err var ok bool casm.Prime, ok = new(big.Int).SetString(compiledClass.Prime, 0) if !ok { - return nil, fmt.Errorf("couldn't convert prime value to big.Int: %d", casm.Prime) + return core.CasmClass{}, fmt.Errorf("couldn't convert prime value to big.Int: %d", casm.Prime) } entryPoints := compiledClass.EntryPoints @@ -358,7 +365,7 @@ func AdaptCompiledClass(compiledClass *starknet.CasmClass) (*core.CasmClass, err casm.L1Handler = utils.Map(entryPoints.L1Handler, adaptCompiledEntryPoint) casm.Constructor = utils.Map(entryPoints.Constructor, adaptCompiledEntryPoint) - return &casm, nil + return casm, nil } func AdaptSegmentLengths(l starknet.SegmentLengths) core.SegmentLengths { @@ -403,13 +410,13 @@ func AdaptDeprecatedCairoClass( return class, nil } -func AdaptStateUpdate(response *starknet.StateUpdate) (*core.StateUpdate, error) { +func AdaptStateUpdate(response *starknet.StateUpdate) (core.StateUpdate, error) { stateDiff, err := AdaptStateDiff(&response.StateDiff) if err != nil { - return nil, err + return core.StateUpdate{}, err } - return &core.StateUpdate{ + return core.StateUpdate{ BlockHash: response.BlockHash, NewRoot: response.NewRoot, OldRoot: response.OldRoot, @@ -525,7 +532,7 @@ func AdaptPreConfirmedBlock( return core.PreConfirmed{}, err } txStateDiffs[preIdx] = &stateDiff - receipts[preIdx] = AdaptTransactionReceipt(response.Receipts[i]) + receipts[preIdx] = utils.HeapPtr(AdaptTransactionReceipt(response.Receipts[i])) eventCount += uint64(len(response.Receipts[i].Events)) preIdx++ } else { diff --git a/adapters/sn2core/sn2core_test.go b/adapters/sn2core/sn2core_test.go index c687f06472..4408de38fa 100644 --- a/adapters/sn2core/sn2core_test.go +++ b/adapters/sn2core/sn2core_test.go @@ -627,9 +627,9 @@ func TestClassV1(t *testing.T) { } func TestAdaptCompiledClass(t *testing.T) { - result, err := sn2core.AdaptCompiledClass(nil) + result, err := sn2core.AdaptCasmClass(nil) require.NoError(t, err) - assert.Nil(t, result) + assert.Empty(t, result) } func TestAdaptPreConfirmed(t *testing.T) { diff --git a/migration/migration.go b/migration/migration.go index 9596a380c7..a208bbb3e9 100644 --- a/migration/migration.go +++ b/migration/migration.go @@ -781,7 +781,7 @@ func migrateCairo1CompiledClass2(txn db.KeyValueWriter, key, value []byte, _ *ut return err } - var casmClass *core.CasmClass + var casmClass core.CasmClass if deprecated, _ := starknet.IsDeprecatedCompiledClassDefinition(class.Class.Compiled); !deprecated { var starknetCompiledClass starknet.CasmClass err = json.Unmarshal(class.Class.Compiled, &starknetCompiledClass) @@ -789,7 +789,7 @@ func migrateCairo1CompiledClass2(txn db.KeyValueWriter, key, value []byte, _ *ut return err } - casmClass, err = sn2core.AdaptCompiledClass(&starknetCompiledClass) + casmClass, err = sn2core.AdaptCasmClass(&starknetCompiledClass) if err != nil { return err } @@ -804,7 +804,7 @@ func migrateCairo1CompiledClass2(txn db.KeyValueWriter, key, value []byte, _ *ut Program: class.Class.Program, ProgramHash: class.Class.ProgramHash, SemanticVersion: class.Class.SemanticVersion, - Compiled: casmClass, + Compiled: &casmClass, }, } diff --git a/migration/migration_pkg_test.go b/migration/migration_pkg_test.go index 355552ac8b..43f57affa2 100644 --- a/migration/migration_pkg_test.go +++ b/migration/migration_pkg_test.go @@ -345,7 +345,7 @@ func TestMigrateCairo1CompiledClass(t *testing.T) { if test.checkCompiledExists { assert.NotNil(t, actualClass.Compiled) } else { - assert.Nil(t, actualClass.Compiled) + assert.Empty(t, actualClass.Compiled) } } } diff --git a/starknet/compiler/compiler_test.go b/starknet/compiler/compiler_test.go index 93d6ec3670..4c5367b087 100644 --- a/starknet/compiler/compiler_test.go +++ b/starknet/compiler/compiler_test.go @@ -31,13 +31,13 @@ func TestCompile(t *testing.T) { compiledDef, err := cl.CasmClassDefinition(t.Context(), classHash) require.NoError(t, err) - expectedCompiled, err := sn2core.AdaptCompiledClass(compiledDef) + expectedCompiled, err := sn2core.AdaptCasmClass(compiledDef) require.NoError(t, err) res, err := compiler.Compile(classDef.Sierra) require.NoError(t, err) - gotCompiled, err := sn2core.AdaptCompiledClass(res) + gotCompiled, err := sn2core.AdaptCasmClass(res) require.NoError(t, err) assert.Equal(t, expectedCompiled.Hash(), gotCompiled.Hash()) }) diff --git a/starknetdata/feeder/feeder.go b/starknetdata/feeder/feeder.go index 4f5b5b9758..38236003fa 100644 --- a/starknetdata/feeder/feeder.go +++ b/starknetdata/feeder/feeder.go @@ -113,8 +113,8 @@ func (f *Feeder) stateUpdate(ctx context.Context, blockID string) (*core.StateUp if err != nil { return nil, err } - - return sn2core.AdaptStateUpdate(response) + coreStateUpdate, err := sn2core.AdaptStateUpdate(response) + return &coreStateUpdate, err } // StateUpdate gets the state update for a given block number from the feeder, @@ -147,7 +147,7 @@ func (f *Feeder) stateUpdateWithBlock(ctx context.Context, blockID string) (*cor } } - var adaptedState *core.StateUpdate + var adaptedState core.StateUpdate var adaptedBlock core.Block if adaptedState, err = sn2core.AdaptStateUpdate(response.StateUpdate); err != nil { @@ -158,7 +158,7 @@ func (f *Feeder) stateUpdateWithBlock(ctx context.Context, blockID string) (*cor return nil, nil, err } - return adaptedState, &adaptedBlock, nil + return &adaptedState, &adaptedBlock, nil } // StateUpdatePendingWithBlock gets both pending state update and pending block from the feeder, diff --git a/starknetdata/feeder/feeder_test.go b/starknetdata/feeder/feeder_test.go index 2c522195ee..3248661b7b 100644 --- a/starknetdata/feeder/feeder_test.go +++ b/starknetdata/feeder/feeder_test.go @@ -70,7 +70,7 @@ func TestStateUpdate(t *testing.T) { adaptedResponse, err := sn2core.AdaptStateUpdate(response) require.NoError(t, err) - assert.Equal(t, adaptedResponse, feederUpdate) + assert.Equal(t, &adaptedResponse, feederUpdate) }) } } @@ -215,7 +215,7 @@ func TestClassV1(t *testing.T) { if test.hasCompiledClass { assert.NotNil(t, adaptedResponse.Compiled) } else { - assert.Nil(t, adaptedResponse.Compiled) + assert.Empty(t, adaptedResponse.Compiled) } } } @@ -241,7 +241,7 @@ func TestStateUpdateWithBlock(t *testing.T) { adaptedStateUpdate, err := sn2core.AdaptStateUpdate(response.StateUpdate) require.NoError(t, err) assert.Equal(t, block, &adaptedBlock) - assert.Equal(t, stateUpdate, adaptedStateUpdate) + assert.Equal(t, stateUpdate, &adaptedStateUpdate) }) } } @@ -260,7 +260,7 @@ func TestStateUpdatePendingWithBlock(t *testing.T) { stateUpdate, block, err := adapter.StateUpdatePendingWithBlock(ctx) require.NoError(t, err) assert.Equal(t, block, &adaptedBlock) - assert.Equal(t, stateUpdate, adaptedStateUpdate) + assert.Equal(t, stateUpdate, &adaptedStateUpdate) } func TestPreConfirmedBlock(t *testing.T) {