Skip to content

Commit 0256fcf

Browse files
infrmtcsinfrmtcs
authored
refactor: Use types directly from proto packages instead of via aliases (#2824)
1 parent f91ebc1 commit 0256fcf

27 files changed

+342
-480
lines changed

‎adapters/core2p2p/block.go‎

Lines changed: 34 additions & 31 deletions
Original file line numberDiff line numberDiff line change
@@ -5,95 +5,98 @@ import (
55

66
"github.com/NethermindEth/juno/core"
77
"github.com/NethermindEth/juno/core/felt"
8-
"github.com/NethermindEth/juno/p2p/gen"
98
"github.com/NethermindEth/juno/utils"
9+
"github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
10+
synccommon "github.com/starknet-io/starknet-p2pspecs/p2p/proto/sync/common"
11+
"github.com/starknet-io/starknet-p2pspecs/p2p/proto/sync/event"
12+
"github.com/starknet-io/starknet-p2pspecs/p2p/proto/sync/header"
1013
)
1114

12-
func AdaptBlockID(header *core.Header) *gen.BlockID {
15+
func AdaptBlockID(header *core.Header) *common.BlockID {
1316
if header == nil {
1417
return nil
1518
}
1619

17-
return &gen.BlockID{
20+
return &common.BlockID{
1821
Number: header.Number,
1922
Header: AdaptHash(header.Hash),
2023
}
2124
}
2225

23-
func adaptSignature(sig []*felt.Felt) *gen.ConsensusSignature {
24-
return &gen.ConsensusSignature{
26+
func adaptSignature(sig []*felt.Felt) *common.ConsensusSignature {
27+
return &common.ConsensusSignature{
2528
R: AdaptFelt(sig[0]),
2629
S: AdaptFelt(sig[1]),
2730
}
2831
}
2932

30-
func AdaptHeader(header *core.Header, commitments *core.BlockCommitments,
33+
func AdaptHeader(blockHeader *core.Header, commitments *core.BlockCommitments,
3134
stateDiffCommitment *felt.Felt, stateDiffLength uint64,
32-
) *gen.SignedBlockHeader {
35+
) *header.SignedBlockHeader {
3336
var l1DataGasPriceFri, l1DataGasPriceWei, l2GasPriceFri, l2GasPriceWei *felt.Felt
34-
if l1DataGasPrice := header.L1DataGasPrice; l1DataGasPrice != nil {
37+
if l1DataGasPrice := blockHeader.L1DataGasPrice; l1DataGasPrice != nil {
3538
l1DataGasPriceFri = l1DataGasPrice.PriceInFri
3639
l1DataGasPriceWei = l1DataGasPrice.PriceInWei
3740
} else {
3841
l1DataGasPriceFri = &felt.Zero
3942
l1DataGasPriceWei = &felt.Zero
4043
}
41-
if l2GasPrice := header.L2GasPrice; l2GasPrice != nil {
44+
if l2GasPrice := blockHeader.L2GasPrice; l2GasPrice != nil {
4245
l2GasPriceFri = l2GasPrice.PriceInFri
4346
l2GasPriceWei = l2GasPrice.PriceInWei
4447
} else {
4548
l2GasPriceFri = &felt.Zero
4649
l2GasPriceWei = &felt.Zero
4750
}
48-
return &gen.SignedBlockHeader{
49-
BlockHash: AdaptHash(header.Hash),
50-
ParentHash: AdaptHash(header.ParentHash),
51-
Number: header.Number,
52-
Time: header.Timestamp,
53-
SequencerAddress: AdaptAddress(header.SequencerAddress),
54-
StateRoot: AdaptHash(header.GlobalStateRoot),
55-
Transactions: &gen.Patricia{
56-
NLeaves: header.TransactionCount,
51+
return &header.SignedBlockHeader{
52+
BlockHash: AdaptHash(blockHeader.Hash),
53+
ParentHash: AdaptHash(blockHeader.ParentHash),
54+
Number: blockHeader.Number,
55+
Time: blockHeader.Timestamp,
56+
SequencerAddress: AdaptAddress(blockHeader.SequencerAddress),
57+
StateRoot: AdaptHash(blockHeader.GlobalStateRoot),
58+
Transactions: &common.Patricia{
59+
NLeaves: blockHeader.TransactionCount,
5760
Root: AdaptHash(commitments.TransactionCommitment),
5861
},
59-
Events: &gen.Patricia{
60-
NLeaves: header.EventCount,
62+
Events: &common.Patricia{
63+
NLeaves: blockHeader.EventCount,
6164
Root: AdaptHash(commitments.EventCommitment),
6265
},
6366
Receipts: AdaptHash(commitments.ReceiptCommitment),
64-
ProtocolVersion: header.ProtocolVersion,
65-
L1GasPriceFri: AdaptUint128(header.L1GasPriceSTRK),
66-
Signatures: utils.Map(header.Signatures, adaptSignature),
67-
StateDiffCommitment: &gen.StateDiffCommitment{
67+
ProtocolVersion: blockHeader.ProtocolVersion,
68+
L1GasPriceFri: AdaptUint128(blockHeader.L1GasPriceSTRK),
69+
Signatures: utils.Map(blockHeader.Signatures, adaptSignature),
70+
StateDiffCommitment: &synccommon.StateDiffCommitment{
6871
StateDiffLength: stateDiffLength,
6972
Root: AdaptHash(stateDiffCommitment),
7073
},
71-
L1GasPriceWei: AdaptUint128(header.L1GasPriceETH),
74+
L1GasPriceWei: AdaptUint128(blockHeader.L1GasPriceETH),
7275
L1DataGasPriceFri: AdaptUint128(l1DataGasPriceFri),
7376
L1DataGasPriceWei: AdaptUint128(l1DataGasPriceWei),
74-
L1DataAvailabilityMode: adaptL1DA(header.L1DAMode),
77+
L1DataAvailabilityMode: adaptL1DA(blockHeader.L1DAMode),
7578
L2GasPriceFri: AdaptUint128(l2GasPriceFri),
7679
L2GasPriceWei: AdaptUint128(l2GasPriceWei),
7780
}
7881
}
7982

80-
func adaptL1DA(da core.L1DAMode) gen.L1DataAvailabilityMode {
83+
func adaptL1DA(da core.L1DAMode) common.L1DataAvailabilityMode {
8184
switch da {
8285
case core.Calldata:
83-
return gen.L1DataAvailabilityMode_Calldata
86+
return common.L1DataAvailabilityMode_Calldata
8487
case core.Blob:
85-
return gen.L1DataAvailabilityMode_Blob
88+
return common.L1DataAvailabilityMode_Blob
8689
default:
8790
panic(fmt.Errorf("unknown L1DAMode %v", da))
8891
}
8992
}
9093

91-
func AdaptEvent(e *core.Event, txH *felt.Felt) *gen.Event {
94+
func AdaptEvent(e *core.Event, txH *felt.Felt) *event.Event {
9295
if e == nil {
9396
return nil
9497
}
9598

96-
return &gen.Event{
99+
return &event.Event{
97100
TransactionHash: AdaptHash(txH),
98101
FromAddress: AdaptFelt(e.From),
99102
Keys: utils.Map(e.Keys, AdaptFelt),

‎adapters/core2p2p/class.go‎

Lines changed: 18 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -4,25 +4,25 @@ import (
44
"fmt"
55

66
"github.com/NethermindEth/juno/core"
7-
"github.com/NethermindEth/juno/p2p/gen"
87
"github.com/NethermindEth/juno/utils"
8+
"github.com/starknet-io/starknet-p2pspecs/p2p/proto/class"
99
)
1010

11-
func AdaptClass(class core.Class) *gen.Class {
12-
if class == nil {
11+
func AdaptClass(cls core.Class) *class.Class {
12+
if cls == nil {
1313
return nil
1414
}
1515

16-
hash, err := class.Hash()
16+
hash, err := cls.Hash()
1717
if err != nil {
18-
panic(fmt.Errorf("failed to hash %t: %w", class, err))
18+
panic(fmt.Errorf("failed to hash %t: %w", cls, err))
1919
}
2020

21-
switch v := class.(type) {
21+
switch v := cls.(type) {
2222
case *core.Cairo0Class:
23-
return &gen.Class{
24-
Class: &gen.Class_Cairo0{
25-
Cairo0: &gen.Cairo0Class{
23+
return &class.Class{
24+
Class: &class.Class_Cairo0{
25+
Cairo0: &class.Cairo0Class{
2626
Abi: string(v.Abi),
2727
Externals: utils.Map(v.Externals, adaptEntryPoint),
2828
L1Handlers: utils.Map(v.L1Handlers, adaptEntryPoint),
@@ -34,11 +34,11 @@ func AdaptClass(class core.Class) *gen.Class {
3434
ClassHash: AdaptHash(hash),
3535
}
3636
case *core.Cairo1Class:
37-
return &gen.Class{
38-
Class: &gen.Class_Cairo1{
39-
Cairo1: &gen.Cairo1Class{
37+
return &class.Class{
38+
Class: &class.Class_Cairo1{
39+
Cairo1: &class.Cairo1Class{
4040
Abi: v.Abi,
41-
EntryPoints: &gen.Cairo1EntryPoints{
41+
EntryPoints: &class.Cairo1EntryPoints{
4242
Externals: utils.Map(v.EntryPoints.External, adaptSierra),
4343
L1Handlers: utils.Map(v.EntryPoints.L1Handler, adaptSierra),
4444
Constructors: utils.Map(v.EntryPoints.Constructor, adaptSierra),
@@ -51,19 +51,19 @@ func AdaptClass(class core.Class) *gen.Class {
5151
ClassHash: AdaptHash(hash),
5252
}
5353
default:
54-
panic(fmt.Errorf("unsupported cairo class %T (version=%d)", v, class.Version()))
54+
panic(fmt.Errorf("unsupported cairo class %T (version=%d)", v, cls.Version()))
5555
}
5656
}
5757

58-
func adaptSierra(e core.SierraEntryPoint) *gen.SierraEntryPoint {
59-
return &gen.SierraEntryPoint{
58+
func adaptSierra(e core.SierraEntryPoint) *class.SierraEntryPoint {
59+
return &class.SierraEntryPoint{
6060
Index: e.Index,
6161
Selector: AdaptFelt(e.Selector),
6262
}
6363
}
6464

65-
func adaptEntryPoint(e core.EntryPoint) *gen.EntryPoint {
66-
return &gen.EntryPoint{
65+
func adaptEntryPoint(e core.EntryPoint) *class.EntryPoint {
66+
return &class.EntryPoint{
6767
Selector: AdaptFelt(e.Selector),
6868
Offset: e.Offset.Uint64(),
6969
}

‎adapters/core2p2p/felt.go‎

Lines changed: 13 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -2,55 +2,56 @@ package core2p2p
22

33
import (
44
"github.com/NethermindEth/juno/core/felt"
5-
"github.com/NethermindEth/juno/p2p/gen"
65
"github.com/NethermindEth/juno/utils"
6+
"github.com/starknet-io/starknet-p2pspecs/p2p/proto/common"
7+
"github.com/starknet-io/starknet-p2pspecs/p2p/proto/transaction"
78
)
89

9-
func AdaptHash(f *felt.Felt) *gen.Hash {
10+
func AdaptHash(f *felt.Felt) *common.Hash {
1011
if f == nil {
1112
return nil
1213
}
1314

14-
return &gen.Hash{
15+
return &common.Hash{
1516
Elements: f.Marshal(),
1617
}
1718
}
1819

19-
func AdaptAccountSignature(signature []*felt.Felt) *gen.AccountSignature {
20-
return &gen.AccountSignature{
20+
func AdaptAccountSignature(signature []*felt.Felt) *transaction.AccountSignature {
21+
return &transaction.AccountSignature{
2122
Parts: utils.Map(signature, AdaptFelt),
2223
}
2324
}
2425

25-
func AdaptFelt(f *felt.Felt) *gen.Felt252 {
26+
func AdaptFelt(f *felt.Felt) *common.Felt252 {
2627
if f == nil {
2728
return nil
2829
}
2930

30-
return &gen.Felt252{
31+
return &common.Felt252{
3132
Elements: f.Marshal(),
3233
}
3334
}
3435

35-
func AdaptFeltSlice(sl []*felt.Felt) []*gen.Felt252 {
36+
func AdaptFeltSlice(sl []*felt.Felt) []*common.Felt252 {
3637
return utils.Map(sl, AdaptFelt)
3738
}
3839

39-
func AdaptAddress(f *felt.Felt) *gen.Address {
40+
func AdaptAddress(f *felt.Felt) *common.Address {
4041
if f == nil {
4142
return nil
4243
}
4344

44-
return &gen.Address{
45+
return &common.Address{
4546
Elements: f.Marshal(),
4647
}
4748
}
4849

49-
func AdaptUint128(f *felt.Felt) *gen.Uint128 {
50+
func AdaptUint128(f *felt.Felt) *common.Uint128 {
5051
// bits represents value in little endian byte order
5152
// i.e. first is least significant byte
5253
bits := f.Bits()
53-
return &gen.Uint128{
54+
return &common.Uint128{
5455
Low: bits[0],
5556
High: bits[1],
5657
}

0 commit comments

Comments
 (0)