/
keeper.go
181 lines (147 loc) · 4.5 KB
/
keeper.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
package keeper
import (
"fmt"
"github.com/cometbft/cometbft/libs/log"
"github.com/cosmos/cosmos-sdk/codec"
storetypes "github.com/cosmos/cosmos-sdk/store/types"
sdk "github.com/cosmos/cosmos-sdk/types"
rewards "github.com/skip-mev/pob/x/builder/rewards"
"github.com/skip-mev/pob/x/builder/types"
)
type Keeper struct {
cdc codec.BinaryCodec
storeKey storetypes.StoreKey
bankKeeper types.BankKeeper
rewardsAddressProvider types.RewardsAddressProvider
// The address that is capable of executing a MsgUpdateParams message.
// Typically this will be the governance module's address.
authority string
}
// NewKeeper is a wrapper around NewKeeperWithRewardsAddressProvider for backwards compatibility.
func NewKeeper(
cdc codec.BinaryCodec,
storeKey storetypes.StoreKey,
accountKeeper types.AccountKeeper,
bankKeeper types.BankKeeper,
distrKeeper types.DistributionKeeper,
stakingKeeper types.StakingKeeper,
authority string,
) Keeper {
// Build a rewards address provider
rewardsAddressProvider := rewards.NewProposerRewardsAddressProvider(
distrKeeper,
stakingKeeper,
)
return NewKeeperWithRewardsAddressProvider(
cdc,
storeKey,
accountKeeper,
bankKeeper,
rewardsAddressProvider,
authority,
)
}
func NewKeeperWithRewardsAddressProvider(
cdc codec.BinaryCodec,
storeKey storetypes.StoreKey,
accountKeeper types.AccountKeeper,
bankKeeper types.BankKeeper,
rewardsAddressProvider types.RewardsAddressProvider,
authority string,
) Keeper {
// Ensure that the authority address is valid.
if _, err := sdk.AccAddressFromBech32(authority); err != nil {
panic(err)
}
// Ensure that the builder module account exists.
if accountKeeper.GetModuleAddress(types.ModuleName) == nil {
panic("builder module account has not been set")
}
return Keeper{
cdc: cdc,
storeKey: storeKey,
bankKeeper: bankKeeper,
rewardsAddressProvider: rewardsAddressProvider,
authority: authority,
}
}
// Logger returns a builder module-specific logger.
func (k Keeper) Logger(ctx sdk.Context) log.Logger {
return ctx.Logger().With("module", "x/"+types.ModuleName)
}
// GetAuthority returns the address that is capable of executing a MsgUpdateParams message.
func (k Keeper) GetAuthority() string {
return k.authority
}
// GetParams returns the builder module's parameters.
func (k Keeper) GetParams(ctx sdk.Context) (types.Params, error) {
store := ctx.KVStore(k.storeKey)
key := types.KeyParams
bz := store.Get(key)
if len(bz) == 0 {
return types.Params{}, fmt.Errorf("no params found for the builder module")
}
params := types.Params{}
if err := params.Unmarshal(bz); err != nil {
return types.Params{}, err
}
return params, nil
}
// SetParams sets the builder module's parameters.
func (k Keeper) SetParams(ctx sdk.Context, params types.Params) error {
store := ctx.KVStore(k.storeKey)
bz, err := params.Marshal()
if err != nil {
return err
}
store.Set(types.KeyParams, bz)
return nil
}
// GetMaxBundleSize returns the maximum number of transactions that can be included in a bundle.
func (k Keeper) GetMaxBundleSize(ctx sdk.Context) (uint32, error) {
params, err := k.GetParams(ctx)
if err != nil {
return 0, err
}
return params.MaxBundleSize, nil
}
// GetEscrowAccount returns the builder module's escrow account.
func (k Keeper) GetEscrowAccount(ctx sdk.Context) (sdk.AccAddress, error) {
params, err := k.GetParams(ctx)
if err != nil {
return nil, err
}
return params.EscrowAccountAddress, nil
}
// GetReserveFee returns the reserve fee of the builder module.
func (k Keeper) GetReserveFee(ctx sdk.Context) (sdk.Coin, error) {
params, err := k.GetParams(ctx)
if err != nil {
return sdk.Coin{}, err
}
return params.ReserveFee, nil
}
// GetMinBidIncrement returns the minimum bid increment for the builder.
func (k Keeper) GetMinBidIncrement(ctx sdk.Context) (sdk.Coin, error) {
params, err := k.GetParams(ctx)
if err != nil {
return sdk.Coin{}, err
}
return params.MinBidIncrement, nil
}
// GetProposerFee returns the proposer fee for the builder module.
func (k Keeper) GetProposerFee(ctx sdk.Context) (sdk.Dec, error) {
params, err := k.GetParams(ctx)
if err != nil {
return sdk.ZeroDec(), err
}
return params.ProposerFee, nil
}
// FrontRunningProtectionEnabled returns true if front-running protection is enabled.
func (k Keeper) FrontRunningProtectionEnabled(ctx sdk.Context) (bool, error) {
params, err := k.GetParams(ctx)
if err != nil {
return false, err
}
return params.FrontRunningProtection, nil
}