smeb_y/0g-chain
1
0
Fork 0
mirror of https://github.com/0glabs/0g-chain.git synced 2024-12-24 23:35:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Implement infrastructure proposal (#1306)

Browse Source 
* update params

* stub out methods

* delete legacy migration test

* feat: add infrastructure inflation and payouts

* fix: load same module account blocked addrs in kavadist as app

* fix: testing edge case where period starts and ends same block

* fix: add store key for infra params, update newparams function

* fix: testing edge case where period starts and ends in same block

* add test for basic infra minting

* add test for stand-alone core, partner rewards

* fix: set time elapsed in each case

* add e2e test for infra rewards

* fix: use standard method for naming infra params key
This commit is contained in:
Kevin Davis 2022-09-29 13:27:40 -06:00 committed by GitHub
parent ef874f9913
commit b0932f7062
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
13 changed files with 1396 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
app/app.go
View File

@ -518,7 +518,7 @@ func NewApp(
app.bankKeeper, app.bankKeeper,
app.accountKeeper, app.accountKeeper,
app.distrKeeper, app.distrKeeper,
app.ModuleAccountAddrs(), app.loadBlockedMaccAddrs(),
) )
app.transferKeeper = ibctransferkeeper.NewKeeper( app.transferKeeper = ibctransferkeeper.NewKeeper(

53
docs/core/proto-docs.md
View File

@ -375,7 +375,10 @@
- [Msg](#kava.issuance.v1beta1.Msg) - [Msg](#kava.issuance.v1beta1.Msg)
- [kava/kavadist/v1beta1/params.proto](#kava/kavadist/v1beta1/params.proto) - [kava/kavadist/v1beta1/params.proto](#kava/kavadist/v1beta1/params.proto)
- [CoreReward](#kava.kavadist.v1beta1.CoreReward)
- [InfrastructureParams](#kava.kavadist.v1beta1.InfrastructureParams)
- [Params](#kava.kavadist.v1beta1.Params) - [Params](#kava.kavadist.v1beta1.Params)
- [PartnerReward](#kava.kavadist.v1beta1.PartnerReward)
- [Period](#kava.kavadist.v1beta1.Period) - [Period](#kava.kavadist.v1beta1.Period)
- [kava/kavadist/v1beta1/genesis.proto](#kava/kavadist/v1beta1/genesis.proto) - [kava/kavadist/v1beta1/genesis.proto](#kava/kavadist/v1beta1/genesis.proto)
@ -5325,6 +5328,39 @@ Msg defines the issuance Msg service.
<a name="kava.kavadist.v1beta1.CoreReward"></a>
### CoreReward
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| `address` | [bytes](#bytes) | | |
| `weight` | [string](#string) | | |
<a name="kava.kavadist.v1beta1.InfrastructureParams"></a>
### InfrastructureParams
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| `infrastructure_periods` | [Period](#kava.kavadist.v1beta1.Period) | repeated | |
| `core_rewards` | [CoreReward](#kava.kavadist.v1beta1.CoreReward) | repeated | |
| `partner_rewards` | [PartnerReward](#kava.kavadist.v1beta1.PartnerReward) | repeated | |
<a name="kava.kavadist.v1beta1.Params"></a> <a name="kava.kavadist.v1beta1.Params"></a>
### Params ### Params
@ -5335,6 +5371,23 @@ Params governance parameters for kavadist module
| ----- | ---- | ----- | ----------- | | ----- | ---- | ----- | ----------- |
| `active` | [bool](#bool) | | | | `active` | [bool](#bool) | | |
| `periods` | [Period](#kava.kavadist.v1beta1.Period) | repeated | | | `periods` | [Period](#kava.kavadist.v1beta1.Period) | repeated | |
| `infrastructure_params` | [InfrastructureParams](#kava.kavadist.v1beta1.InfrastructureParams) | | |
<a name="kava.kavadist.v1beta1.PartnerReward"></a>
### PartnerReward
| Field | Type | Label | Description |
| ----- | ---- | ----- | ----------- |
| `address` | [bytes](#bytes) | | |
| `rewards_per_second` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | |

33
proto/kava/kavadist/v1beta1/params.proto
View File

@ -2,6 +2,8 @@ syntax = "proto3";
package kava.kavadist.v1beta1; package kava.kavadist.v1beta1;
import "gogoproto/gogo.proto"; import "gogoproto/gogo.proto";
import "cosmos/base/v1beta1/coin.proto";
import "cosmos_proto/cosmos.proto";
import "google/protobuf/timestamp.proto"; import "google/protobuf/timestamp.proto";
option go_package = "github.com/kava-labs/kava/x/kavadist/types"; option go_package = "github.com/kava-labs/kava/x/kavadist/types";
@ -13,6 +15,36 @@ option (gogoproto.goproto_getters_all) = false;
message Params { message Params {
bool active = 1 [(gogoproto.moretags) = "yaml:\"active\""]; bool active = 1 [(gogoproto.moretags) = "yaml:\"active\""];
repeated Period periods = 3 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"periods\""]; repeated Period periods = 3 [(gogoproto.nullable) = false, (gogoproto.moretags) = "yaml:\"periods\""];
InfrastructureParams infrastructure_params = 4 [(gogoproto.nullable) = false];
}
message InfrastructureParams {
repeated Period infrastructure_periods = 1 [(gogoproto.castrepeated) = "Periods", (gogoproto.nullable) = false];
repeated CoreReward core_rewards = 2 [(gogoproto.castrepeated) = "CoreRewards", (gogoproto.nullable) = false];
repeated PartnerReward partner_rewards = 3 [(gogoproto.castrepeated) = "PartnerRewards", (gogoproto.nullable) = false];
option (gogoproto.goproto_stringer) = true;
}
message CoreReward {
bytes address = 1 [
(cosmos_proto.scalar) = "cosmos.AddressBytes",
(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"
];
string weight = 2 [
(cosmos_proto.scalar) = "cosmos.Dec",
(gogoproto.customtype) = "github.com/cosmos/cosmos-sdk/types.Dec",
(gogoproto.nullable) = false
];
option (gogoproto.goproto_stringer) = true;
}
message PartnerReward {
bytes address = 1 [
(cosmos_proto.scalar) = "cosmos.AddressBytes",
(gogoproto.casttype) = "github.com/cosmos/cosmos-sdk/types.AccAddress"
];
cosmos.base.v1beta1.Coin rewards_per_second = 2[(gogoproto.nullable) = false];
option (gogoproto.goproto_stringer) = true;
} }
// Period stores the specified start and end dates, and the inflation, expressed as a decimal // Period stores the specified start and end dates, and the inflation, expressed as a decimal
@ -35,3 +67,4 @@ message Period {
(gogoproto.moretags) = "yaml:\"inflation\"" (gogoproto.moretags) = "yaml:\"inflation\""
]; ];
} }

100
x/kavadist/keeper/infrastructure.go Normal file
View File

@ -0,0 +1,100 @@
package keeper
import (
"fmt"
"time"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/kava-labs/kava/x/kavadist/types"
)
func (k Keeper) mintInfrastructurePeriods(ctx sdk.Context, periods types.Periods, previousBlockTime time.Time) (sdk.Coin, sdk.Int, error) {
var err error
coinsMinted := sdk.NewCoin(types.GovDenom, sdk.ZeroInt())
timeElapsed := sdk.ZeroInt()
for _, period := range periods {
switch {
// Case 1 - period is fully expired
case period.End.Before(previousBlockTime):
continue
// Case 2 - period has ended since the previous block time
case period.End.After(previousBlockTime) && (period.End.Before(ctx.BlockTime()) || period.End.Equal(ctx.BlockTime())):
// calculate time elapsed relative to the periods end time
timeElapsed = sdk.NewInt(period.End.Unix() - previousBlockTime.Unix())
coins, errI := k.mintInflationaryCoins(ctx, period.Inflation, timeElapsed, types.GovDenom)
err = errI
if !coins.IsZero() {
coinsMinted = coinsMinted.Add(coins)
}
// update the value of previousBlockTime so that the next period starts from the end of the last
// period and not the original value of previousBlockTime
previousBlockTime = period.End
// Case 3 - period is ongoing
case (period.Start.Before(previousBlockTime) || period.Start.Equal(previousBlockTime)) && period.End.After(ctx.BlockTime()):
// calculate time elapsed relative to the current block time
timeElapsed = sdk.NewInt(ctx.BlockTime().Unix() - previousBlockTime.Unix())
coins, errI := k.mintInflationaryCoins(ctx, period.Inflation, timeElapsed, types.GovDenom)
if !coins.IsZero() {
coinsMinted = coinsMinted.Add(coins)
}
err = errI
// Case 4 - period hasn't started
case period.Start.After(ctx.BlockTime()) || period.Start.Equal(ctx.BlockTime()):
timeElapsed = sdk.NewInt(ctx.BlockTime().Unix() - previousBlockTime.Unix())
continue
}
if err != nil {
return sdk.Coin{}, sdk.Int{}, err
}
}
return coinsMinted, timeElapsed, nil
}
func (k Keeper) distributeInfrastructureCoins(ctx sdk.Context, partnerRewards types.PartnerRewards, coreRewards types.CoreRewards, timeElapsed sdk.Int, coinsToDistribute sdk.Coin) error {
if timeElapsed.IsZero() {
return nil
}
if coinsToDistribute.IsZero() {
return nil
}
for _, pr := range partnerRewards {
coinsToSend := sdk.NewCoin(types.GovDenom, pr.RewardsPerSecond.Amount.Mul(timeElapsed))
// TODO check balance, log if insufficient and return rather than error
err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, pr.Address, sdk.NewCoins(coinsToSend))
if err != nil {
return err
}
neg, updatedCoins := safeSub(coinsToDistribute, coinsToSend)
if neg {
return fmt.Errorf("negative coins")
}
coinsToDistribute = updatedCoins
}
for _, cr := range coreRewards {
coinsToSend := sdk.NewCoin(types.GovDenom, coinsToDistribute.Amount.ToDec().Mul(cr.Weight).RoundInt())
// TODO check balance, log if insufficient and return rather than error
err := k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName, cr.Address, sdk.NewCoins(coinsToSend))
if err != nil {
return err
}
neg, updatedCoins := safeSub(coinsToDistribute, coinsToSend)
if neg {
return fmt.Errorf("negative coins")
}
coinsToDistribute = updatedCoins
}
return nil
}
func safeSub(a, b sdk.Coin) (bool, sdk.Coin) {
isNeg := a.IsLT(b)
if isNeg {
return true, sdk.Coin{}
}
return false, a.Sub(b)
}

37
x/kavadist/keeper/mint.go
View File

@ -1,6 +1,8 @@
package keeper package keeper
import ( import (
"time"
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/kava-labs/kava/x/kavadist/types" "github.com/kava-labs/kava/x/kavadist/types"
@ -25,19 +27,37 @@ func (k Keeper) MintPeriodInflation(ctx sdk.Context) error {
k.SetPreviousBlockTime(ctx, previousBlockTime) k.SetPreviousBlockTime(ctx, previousBlockTime)
return nil return nil
} }
err := k.mintIncentivePeriods(ctx, params.Periods, previousBlockTime)
if err != nil {
return err
}
coinsToDistribute, timeElapsed, err := k.mintInfrastructurePeriods(ctx, params.InfrastructureParams.InfrastructurePeriods, previousBlockTime)
if err != nil {
return err
}
err = k.distributeInfrastructureCoins(ctx, params.InfrastructureParams.PartnerRewards, params.InfrastructureParams.CoreRewards, timeElapsed, coinsToDistribute)
if err != nil {
return err
}
k.SetPreviousBlockTime(ctx, ctx.BlockTime())
return nil
}
func (k Keeper) mintIncentivePeriods(ctx sdk.Context, periods types.Periods, previousBlockTime time.Time) error {
var err error var err error
for _, period := range params.Periods { for _, period := range periods {
switch { switch {
// Case 1 - period is fully expired // Case 1 - period is fully expired
case period.End.Before(previousBlockTime): case period.End.Before(previousBlockTime):
continue continue
// Case 2 - period has ended since the previous block time // Case 2 - period has ended since the previous block time
case period.End.After(previousBlockTime) && period.End.Before(ctx.BlockTime()): case period.End.After(previousBlockTime) && (period.End.Before(ctx.BlockTime()) || period.End.Equal(ctx.BlockTime())):
// calculate time elapsed relative to the periods end time // calculate time elapsed relative to the periods end time
timeElapsed := sdk.NewInt(period.End.Unix() - previousBlockTime.Unix()) timeElapsed := sdk.NewInt(period.End.Unix() - previousBlockTime.Unix())
err = k.mintInflationaryCoins(ctx, period.Inflation, timeElapsed, types.GovDenom) _, err = k.mintInflationaryCoins(ctx, period.Inflation, timeElapsed, types.GovDenom)
// update the value of previousBlockTime so that the next period starts from the end of the last // update the value of previousBlockTime so that the next period starts from the end of the last
// period and not the original value of previousBlockTime // period and not the original value of previousBlockTime
previousBlockTime = period.End previousBlockTime = period.End
@ -46,7 +66,7 @@ func (k Keeper) MintPeriodInflation(ctx sdk.Context) error {
case (period.Start.Before(previousBlockTime) || period.Start.Equal(previousBlockTime)) && period.End.After(ctx.BlockTime()): case (period.Start.Before(previousBlockTime) || period.Start.Equal(previousBlockTime)) && period.End.After(ctx.BlockTime()):
// calculate time elapsed relative to the current block time // calculate time elapsed relative to the current block time
timeElapsed := sdk.NewInt(ctx.BlockTime().Unix() - previousBlockTime.Unix()) timeElapsed := sdk.NewInt(ctx.BlockTime().Unix() - previousBlockTime.Unix())
err = k.mintInflationaryCoins(ctx, period.Inflation, timeElapsed, types.GovDenom) _, err = k.mintInflationaryCoins(ctx, period.Inflation, timeElapsed, types.GovDenom)
// Case 4 - period hasn't started // Case 4 - period hasn't started
case period.Start.After(ctx.BlockTime()) || period.Start.Equal(ctx.BlockTime()): case period.Start.After(ctx.BlockTime()) || period.Start.Equal(ctx.BlockTime()):
@ -57,11 +77,10 @@ func (k Keeper) MintPeriodInflation(ctx sdk.Context) error {
return err return err
} }
} }
k.SetPreviousBlockTime(ctx, ctx.BlockTime())
return nil return nil
} }
func (k Keeper) mintInflationaryCoins(ctx sdk.Context, inflationRate sdk.Dec, timePeriods sdk.Int, denom string) error { func (k Keeper) mintInflationaryCoins(ctx sdk.Context, inflationRate sdk.Dec, timePeriods sdk.Int, denom string) (sdk.Coin, error) {
totalSupply := k.bankKeeper.GetSupply(ctx, denom) totalSupply := k.bankKeeper.GetSupply(ctx, denom)
// used to scale accumulator calculations by 10^18 // used to scale accumulator calculations by 10^18
scalar := sdk.NewInt(1000000000000000000) scalar := sdk.NewInt(1000000000000000000)
@ -75,11 +94,11 @@ func (k Keeper) mintInflationaryCoins(ctx sdk.Context, inflationRate sdk.Dec, ti
// calculate the number of coins to mint // calculate the number of coins to mint
amountToMint := (sdk.NewDecFromInt(totalSupply.Amount).Mul(accumulator)).Sub(sdk.NewDecFromInt(totalSupply.Amount)).TruncateInt() amountToMint := (sdk.NewDecFromInt(totalSupply.Amount).Mul(accumulator)).Sub(sdk.NewDecFromInt(totalSupply.Amount)).TruncateInt()
if amountToMint.IsZero() { if amountToMint.IsZero() {
return nil return sdk.Coin{}, nil
} }
err := k.bankKeeper.MintCoins(ctx, types.KavaDistMacc, sdk.NewCoins(sdk.NewCoin(denom, amountToMint))) err := k.bankKeeper.MintCoins(ctx, types.KavaDistMacc, sdk.NewCoins(sdk.NewCoin(denom, amountToMint)))
if err != nil { if err != nil {
return err return sdk.Coin{}, err
} }
ctx.EventManager().EmitEvent( ctx.EventManager().EmitEvent(
@ -89,5 +108,5 @@ func (k Keeper) mintInflationaryCoins(ctx sdk.Context, inflationRate sdk.Dec, ti
), ),
) )
return nil return sdk.NewCoin(denom, amountToMint), nil
} }

288
x/kavadist/keeper/mint_test.go
View File

@ -5,6 +5,7 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types" sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/kava-labs/kava/app"
"github.com/kava-labs/kava/x/kavadist/types" "github.com/kava-labs/kava/x/kavadist/types"
) )
@ -88,3 +89,290 @@ func (suite *keeperTestSuite) TestMintNotActive() {
finalSupply := suite.BankKeeper.GetSupply(suite.Ctx, types.GovDenom) finalSupply := suite.BankKeeper.GetSupply(suite.Ctx, types.GovDenom)
suite.Require().Equal(initialSupply, finalSupply) suite.Require().Equal(initialSupply, finalSupply)
} }
func (suite *keeperTestSuite) TestInfraMinting() {
type args struct {
startTime time.Time
endTime time.Time
infraPeriods types.Periods
expectedFinalSupply sdk.Coin
marginOfError sdk.Dec
}
type errArgs struct {
expectPass bool
contains string
}
type test struct {
name string
args args
errArgs errArgs
}
testCases := []test{
{
"5% apy one year",
args{
startTime: time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC),
endTime: time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC),
infraPeriods: types.Periods{types.NewPeriod(time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC), time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC), sdk.MustNewDecFromStr("1.000000001547125958"))},
expectedFinalSupply: sdk.NewCoin(types.GovDenom, sdk.NewInt(1050000000000)),
marginOfError: sdk.MustNewDecFromStr("0.0001"),
},
errArgs{
expectPass: true,
contains: "",
},
},
{
"5% apy 10 seconds",
args{
startTime: time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC),
endTime: time.Date(2022, time.October, 1, 1, 0, 10, 0, time.UTC),
infraPeriods: types.Periods{types.NewPeriod(time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC), time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC), sdk.MustNewDecFromStr("1.000000001547125958"))},
expectedFinalSupply: sdk.NewCoin(types.GovDenom, sdk.NewInt(1000000015471)),
marginOfError: sdk.MustNewDecFromStr("0.0001"),
},
errArgs{
expectPass: true,
contains: "",
},
},
}
for _, tc := range testCases {
suite.SetupTest()
params := types.NewParams(true, types.DefaultPeriods, types.NewInfraParams(tc.args.infraPeriods, types.DefaultInfraParams.PartnerRewards, types.DefaultInfraParams.CoreRewards))
ctx := suite.Ctx.WithBlockTime(tc.args.startTime)
suite.Keeper.SetParams(ctx, params)
suite.Require().NotPanics(func() {
suite.Keeper.SetPreviousBlockTime(ctx, tc.args.startTime)
})
ctx = suite.Ctx.WithBlockTime(tc.args.endTime)
err := suite.Keeper.MintPeriodInflation(ctx)
suite.Require().NoError(err)
finalSupply := suite.BankKeeper.GetSupply(ctx, types.GovDenom)
marginHigh := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Add(tc.args.marginOfError))
marginLow := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Sub(tc.args.marginOfError))
suite.Require().True(finalSupply.Amount.ToDec().LTE(marginHigh))
suite.Require().True(finalSupply.Amount.ToDec().GTE(marginLow))
}
}
func (suite *keeperTestSuite) TestInfraPayoutCore() {
type args struct {
startTime time.Time
endTime time.Time
infraPeriods types.Periods
expectedFinalSupply sdk.Coin
expectedBalanceIncrease sdk.Coin
marginOfError sdk.Dec
}
type errArgs struct {
expectPass bool
contains string
}
type test struct {
name string
args args
errArgs errArgs
}
testCases := []test{
{
"5% apy one year",
args{
startTime: time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC),
endTime: time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC),
infraPeriods: types.Periods{types.NewPeriod(time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC), time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC), sdk.MustNewDecFromStr("1.000000001547125958"))},
expectedFinalSupply: sdk.NewCoin(types.GovDenom, sdk.NewInt(1050000000000)),
expectedBalanceIncrease: sdk.NewCoin(types.GovDenom, sdk.NewInt(50000000000)),
marginOfError: sdk.MustNewDecFromStr("0.0001"),
},
errArgs{
expectPass: true,
contains: "",
},
},
}
for _, tc := range testCases {
suite.SetupTest()
coreReward := types.NewCoreReward(suite.Addrs[0], sdk.OneDec())
params := types.NewParams(true, types.DefaultPeriods, types.NewInfraParams(tc.args.infraPeriods, types.DefaultInfraParams.PartnerRewards, types.CoreRewards{coreReward}))
ctx := suite.Ctx.WithBlockTime(tc.args.startTime)
suite.Keeper.SetParams(ctx, params)
suite.Require().NotPanics(func() {
suite.Keeper.SetPreviousBlockTime(ctx, tc.args.startTime)
})
initialBalance := suite.BankKeeper.GetBalance(ctx, suite.Addrs[0], types.GovDenom)
ctx = suite.Ctx.WithBlockTime(tc.args.endTime)
err := suite.Keeper.MintPeriodInflation(ctx)
suite.Require().NoError(err)
finalSupply := suite.BankKeeper.GetSupply(ctx, types.GovDenom)
marginHigh := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Add(tc.args.marginOfError))
marginLow := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Sub(tc.args.marginOfError))
suite.Require().True(finalSupply.Amount.ToDec().LTE(marginHigh))
suite.Require().True(finalSupply.Amount.ToDec().GTE(marginLow))
finalBalance := suite.BankKeeper.GetBalance(ctx, suite.Addrs[0], types.GovDenom)
suite.Require().Equal(tc.args.expectedBalanceIncrease, finalBalance.Sub(initialBalance))
}
}
func (suite *keeperTestSuite) TestInfraPayoutPartner() {
type args struct {
startTime time.Time
endTime time.Time
infraPeriods types.Periods
expectedFinalSupply sdk.Coin
expectedBalanceIncrease sdk.Coin
marginOfError sdk.Dec
}
type errArgs struct {
expectPass bool
contains string
}
type test struct {
name string
args args
errArgs errArgs
}
testCases := []test{
{
"5% apy one year",
args{
startTime: time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC),
endTime: time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC),
infraPeriods: types.Periods{types.NewPeriod(time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC), time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC), sdk.MustNewDecFromStr("1.000000001547125958"))},
expectedFinalSupply: sdk.NewCoin(types.GovDenom, sdk.NewInt(1050000000000)),
expectedBalanceIncrease: sdk.NewCoin(types.GovDenom, sdk.NewInt(63072000)),
marginOfError: sdk.MustNewDecFromStr("0.0001"),
},
errArgs{
expectPass: true,
contains: "",
},
},
}
for _, tc := range testCases {
suite.SetupTest()
partnerReward := types.NewPartnerReward(suite.Addrs[0], sdk.NewCoin(types.GovDenom, sdk.NewInt(2)))
params := types.NewParams(true, types.DefaultPeriods, types.NewInfraParams(tc.args.infraPeriods, types.PartnerRewards{partnerReward}, types.DefaultInfraParams.CoreRewards))
ctx := suite.Ctx.WithBlockTime(tc.args.startTime)
suite.Keeper.SetParams(ctx, params)
suite.Require().NotPanics(func() {
suite.Keeper.SetPreviousBlockTime(ctx, tc.args.startTime)
})
initialBalance := suite.BankKeeper.GetBalance(ctx, suite.Addrs[0], types.GovDenom)
ctx = suite.Ctx.WithBlockTime(tc.args.endTime)
err := suite.Keeper.MintPeriodInflation(ctx)
suite.Require().NoError(err)
finalSupply := suite.BankKeeper.GetSupply(ctx, types.GovDenom)
marginHigh := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Add(tc.args.marginOfError))
marginLow := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Sub(tc.args.marginOfError))
suite.Require().True(finalSupply.Amount.ToDec().LTE(marginHigh))
suite.Require().True(finalSupply.Amount.ToDec().GTE(marginLow))
finalBalance := suite.BankKeeper.GetBalance(ctx, suite.Addrs[0], types.GovDenom)
suite.Require().Equal(tc.args.expectedBalanceIncrease, finalBalance.Sub(initialBalance))
}
}
func (suite *keeperTestSuite) TestInfraPayoutE2E() {
type balance struct {
address sdk.AccAddress
amount sdk.Coins
}
type balances []balance
type args struct {
periods types.Periods
startTime time.Time
endTime time.Time
infraPeriods types.Periods
coreRewards types.CoreRewards
partnerRewards types.PartnerRewards
expectedFinalSupply sdk.Coin
expectedBalances balances
marginOfError sdk.Dec
}
type errArgs struct {
expectPass bool
contains string
}
type test struct {
name string
args args
errArgs errArgs
}
_, addrs := app.GeneratePrivKeyAddressPairs(3)
testCases := []test{
{
"5% apy one year",
args{
periods: types.Periods{types.NewPeriod(time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC), time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC), sdk.MustNewDecFromStr("1.000000001547125958"))},
startTime: time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC),
endTime: time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC),
infraPeriods: types.Periods{types.NewPeriod(time.Date(2022, time.October, 1, 1, 0, 0, 0, time.UTC), time.Date(2023, time.October, 1, 1, 0, 0, 0, time.UTC), sdk.MustNewDecFromStr("1.000000001547125958"))},
coreRewards: types.CoreRewards{types.NewCoreReward(addrs[1], sdk.OneDec())},
partnerRewards: types.PartnerRewards{types.NewPartnerReward(addrs[2], sdk.NewCoin("ukava", sdk.NewInt(2)))},
expectedFinalSupply: sdk.NewCoin(types.GovDenom, sdk.NewInt(1102500000000)),
expectedBalances: balances{
balance{addrs[1], sdk.NewCoins(sdk.NewCoin("ukava", sdk.NewInt(52436928000)))},
balance{addrs[2], sdk.NewCoins(sdk.NewCoin("ukava", sdk.NewInt(63072000)))},
},
marginOfError: sdk.MustNewDecFromStr("0.0001"),
},
errArgs{
expectPass: true,
contains: "",
},
},
}
for _, tc := range testCases {
suite.SetupTest()
params := types.NewParams(true, tc.args.periods, types.NewInfraParams(tc.args.infraPeriods, tc.args.partnerRewards, tc.args.coreRewards))
ctx := suite.Ctx.WithBlockTime(tc.args.startTime)
suite.Keeper.SetParams(ctx, params)
suite.Require().NotPanics(func() {
suite.Keeper.SetPreviousBlockTime(ctx, tc.args.startTime)
})
ctx = suite.Ctx.WithBlockTime(tc.args.endTime)
err := suite.Keeper.MintPeriodInflation(ctx)
suite.Require().NoError(err)
finalSupply := suite.BankKeeper.GetSupply(ctx, types.GovDenom)
marginHigh := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Add(tc.args.marginOfError))
marginLow := tc.args.expectedFinalSupply.Amount.ToDec().Mul(sdk.OneDec().Sub(tc.args.marginOfError))
suite.Require().True(finalSupply.Amount.ToDec().LTE(marginHigh))
suite.Require().True(finalSupply.Amount.ToDec().GTE(marginLow))
for _, bal := range tc.args.expectedBalances {
finalBalance := suite.BankKeeper.GetAllBalances(ctx, bal.address)
suite.Require().Equal(bal.amount, finalBalance)
}
}
}

151
x/kavadist/legacy/v0_16/migrate_test.go
View File

@ -1,151 +0,0 @@
package v0_16
import (
"testing"
"time"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/stretchr/testify/suite"
tmtime "github.com/tendermint/tendermint/types/time"
app "github.com/kava-labs/kava/app"
v015kavadist "github.com/kava-labs/kava/x/kavadist/legacy/v0_15"
v016kavadist "github.com/kava-labs/kava/x/kavadist/types"
)
type migrateTestSuite struct {
suite.Suite
addresses []sdk.AccAddress
v15genstate v015kavadist.GenesisState
cdc codec.Codec
legacyCdc *codec.LegacyAmino
}
func (s *migrateTestSuite) SetupTest() {
app.SetSDKConfig()
s.v15genstate = v015kavadist.GenesisState{
Params: v015kavadist.Params{},
PreviousBlockTime: tmtime.Canonical(time.Unix(1, 0)),
}
config := app.MakeEncodingConfig()
s.cdc = config.Marshaler
legacyCodec := codec.NewLegacyAmino()
s.legacyCdc = legacyCodec
_, accAddresses := app.GeneratePrivKeyAddressPairs(10)
s.addresses = accAddresses
}
func (s *migrateTestSuite) TestMigrate_JSON() {
// Migrate v15 kavadist to v16
data := `{
"params": {
"active": true,
"periods": [
{
"end": "2021-06-01T14:00:00Z",
"inflation": "1.000000000000000000",
"start": "2020-06-01T14:00:00Z"
},
{
"end": "2022-06-01T14:00:00Z",
"inflation": "1.000000002293273137",
"start": "2021-06-01T14:00:00Z"
},
{
"end": "2023-06-01T14:00:00Z",
"inflation": "1.000000001167363430",
"start": "2022-06-01T14:00:00Z"
},
{
"end": "2024-06-01T14:00:00Z",
"inflation": "1.000000000782997609",
"start": "2023-06-01T14:00:00Z"
}
]
},
"previous_block_time": "2021-11-05T21:13:12.85608847Z"
}`
err := s.legacyCdc.UnmarshalJSON([]byte(data), &s.v15genstate)
s.Require().NoError(err)
genstate := Migrate(s.v15genstate)
// Compare expect v16 kavadist json with migrated json
actual := s.cdc.MustMarshalJSON(genstate)
expected := `{
"params": {
"active": true,
"periods": [
{
"start": "2020-06-01T14:00:00Z",
"end": "2021-06-01T14:00:00Z",
"inflation": "1.000000000000000000"
},
{
"start": "2021-06-01T14:00:00Z",
"end": "2022-06-01T14:00:00Z",
"inflation": "1.000000002293273137"
},
{
"start": "2022-06-01T14:00:00Z",
"end": "2023-06-01T14:00:00Z",
"inflation": "1.000000001167363430"
},
{
"start": "2023-06-01T14:00:00Z",
"end": "2024-06-01T14:00:00Z",
"inflation": "1.000000000782997609"
}
]
},
"previous_block_time": "2021-11-05T21:13:12.856088470Z"
}`
s.Require().NoError(err)
s.Require().JSONEq(string(expected), string(actual))
}
func (s *migrateTestSuite) TestMigrate_Params() {
params := v015kavadist.Params{
Active: true,
Periods: v015kavadist.Periods{
{
Start: time.Date(2020, time.March, 1, 1, 0, 0, 0, time.UTC),
End: time.Date(2021, time.March, 1, 1, 0, 0, 0, time.UTC),
Inflation: sdk.MustNewDecFromStr("0.1"),
},
{
Start: time.Date(2010, time.March, 1, 1, 0, 0, 0, time.UTC),
End: time.Date(2011, time.March, 2, 1, 0, 0, 0, time.UTC),
Inflation: sdk.MustNewDecFromStr("0.01"),
},
},
}
expected := v016kavadist.Params{
Active: true,
Periods: []v016kavadist.Period{
{
Start: time.Date(2020, time.March, 1, 1, 0, 0, 0, time.UTC),
End: time.Date(2021, time.March, 1, 1, 0, 0, 0, time.UTC),
Inflation: sdk.MustNewDecFromStr("0.1"),
},
{
Start: time.Date(2010, time.March, 1, 1, 0, 0, 0, time.UTC),
End: time.Date(2011, time.March, 2, 1, 0, 0, 0, time.UTC),
Inflation: sdk.MustNewDecFromStr("0.01"),
},
},
}
s.v15genstate.Params = params
genState := Migrate(s.v15genstate)
s.Require().Equal(expected, genState.Params)
}
func TestMigrateTestSuite(t *testing.T) {
suite.Run(t, new(migrateTestSuite))
}

2
x/kavadist/simulation/genesis.go
View File

@ -42,7 +42,7 @@ func RandomizedGenState(simState *module.SimulationState) {
func genRandomParams(simState *module.SimulationState) types.Params { func genRandomParams(simState *module.SimulationState) types.Params {
periods := genRandomPeriods(simState.Rand, simState.GenTimestamp) periods := genRandomPeriods(simState.Rand, simState.GenTimestamp)
params := types.NewParams(true, periods) params := types.NewParams(true, periods, types.DefaultInfraParams)
return params return params
} }

2
x/kavadist/simulation/params.go
View File

@ -16,7 +16,7 @@ func ParamChanges(r *rand.Rand) []simtypes.ParamChange {
// Hacky way to validate periods since validation is wrapped in params // Hacky way to validate periods since validation is wrapped in params
active := genRandomActive(r) active := genRandomActive(r)
periods := genRandomPeriods(r, simtypes.RandTimestamp(r)) periods := genRandomPeriods(r, simtypes.RandTimestamp(r))
if err := types.NewParams(active, periods).Validate(); err != nil { if err := types.NewParams(active, periods, types.DefaultInfraParams).Validate(); err != nil {
panic(err) panic(err)
} }

2
x/kavadist/testutil/suite.go
View File

@ -52,7 +52,7 @@ func (suite *Suite) SetupTest() {
Inflation: sdk.MustNewDecFromStr("1.000000003022265980"), Inflation: sdk.MustNewDecFromStr("1.000000003022265980"),
}, },
} }
params := types.NewParams(true, testPeriods) params := types.NewParams(true, testPeriods, types.DefaultInfraParams)
moduleGs := types.ModuleCdc.MustMarshalJSON(types.NewGenesisState(params, types.DefaultPreviousBlockTime)) moduleGs := types.ModuleCdc.MustMarshalJSON(types.NewGenesisState(params, types.DefaultPreviousBlockTime))
gs := app.GenesisState{types.ModuleName: moduleGs} gs := app.GenesisState{types.ModuleName: moduleGs}
tApp.InitializeFromGenesisStates(authGS, gs) tApp.InitializeFromGenesisStates(authGS, gs)

1
x/kavadist/types/expected_keepers.go
View File

@ -22,4 +22,5 @@ type BankKeeper interface {
GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins GetAllBalances(ctx sdk.Context, addr sdk.AccAddress) sdk.Coins
MintCoins(ctx sdk.Context, moduleName string, amounts sdk.Coins) error MintCoins(ctx sdk.Context, moduleName string, amounts sdk.Coins) error
GetSupply(ctx sdk.Context, denom string) sdk.Coin GetSupply(ctx sdk.Context, denom string) sdk.Coin
SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
} }

93
x/kavadist/types/params.go
View File

@ -15,38 +15,24 @@ import (
var ( var (
KeyActive = []byte("Active") KeyActive = []byte("Active")
KeyPeriods = []byte("Periods") KeyPeriods = []byte("Periods")
KeyInfra = []byte("InfrastructureParams")
DefaultActive = false DefaultActive = false
DefaultPeriods = []Period{} DefaultPeriods = []Period{}
DefaultInfraParams = InfrastructureParams{}
DefaultPreviousBlockTime = tmtime.Canonical(time.Unix(1, 0)) DefaultPreviousBlockTime = tmtime.Canonical(time.Unix(1, 0))
GovDenom = "ukava" // TODO: replace with cdptypes.DefaultGovDenom GovDenom = "ukava" // TODO: replace with cdptypes.DefaultGovDenom
) )
// NewPeriod returns a new instance of Period func NewParams(active bool, periods []Period, infraParams InfrastructureParams) Params {
func NewPeriod(start time.Time, end time.Time, inflation sdk.Dec) Period {
return Period{
Start: start,
End: end,
Inflation: inflation,
}
}
// String implements fmt.Stringer
func (pr Period) String() string {
return fmt.Sprintf(`Period:
Start: %s
End: %s
Inflation: %s`, pr.Start, pr.End, pr.Inflation)
}
func NewParams(active bool, periods []Period) Params {
return Params{ return Params{
Active: active, Active: active,
Periods: periods, Periods: periods,
InfrastructureParams: infraParams,
} }
} }
func DefaultParams() Params { func DefaultParams() Params {
return NewParams(DefaultActive, DefaultPeriods) return NewParams(DefaultActive, DefaultPeriods, DefaultInfraParams)
} }
func (p Params) String() string { func (p Params) String() string {
@ -87,6 +73,7 @@ func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
return paramtypes.ParamSetPairs{ return paramtypes.ParamSetPairs{
paramtypes.NewParamSetPair(KeyActive, &p.Active, validateActiveParam), paramtypes.NewParamSetPair(KeyActive, &p.Active, validateActiveParam),
paramtypes.NewParamSetPair(KeyPeriods, &p.Periods, validatePeriodsParams), paramtypes.NewParamSetPair(KeyPeriods, &p.Periods, validatePeriodsParams),
paramtypes.NewParamSetPair(KeyInfra, &p.InfrastructureParams, validateInfraParams),
} }
} }
@ -99,6 +86,47 @@ func (p Params) Validate() error {
return validatePeriodsParams(p.Periods) return validatePeriodsParams(p.Periods)
} }
// NewPeriod returns a new instance of Period
func NewPeriod(start time.Time, end time.Time, inflation sdk.Dec) Period {
return Period{
Start: start,
End: end,
Inflation: inflation,
}
}
type Periods []Period
// String implements fmt.Stringer
func (pr Period) String() string {
return fmt.Sprintf(`Period:
Start: %s
End: %s
Inflation: %s`, pr.Start, pr.End, pr.Inflation)
}
func NewInfraParams(p Periods, pr PartnerRewards, cr CoreRewards) InfrastructureParams {
return InfrastructureParams{
InfrastructurePeriods: p,
PartnerRewards: pr,
CoreRewards: cr,
}
}
func NewPartnerReward(addr sdk.AccAddress, rps sdk.Coin) PartnerReward {
return PartnerReward{
Address: addr,
RewardsPerSecond: rps,
}
}
func NewCoreReward(addr sdk.AccAddress, w sdk.Dec) CoreReward {
return CoreReward{
Address: addr,
Weight: w,
}
}
func validateActiveParam(i interface{}) error { func validateActiveParam(i interface{}) error {
_, ok := i.(bool) _, ok := i.(bool)
if !ok { if !ok {
@ -134,3 +162,30 @@ func validatePeriodsParams(i interface{}) error {
return nil return nil
} }
func validateInfraParams(i interface{}) error {
infraParams, ok := i.(InfrastructureParams)
if !ok {
return fmt.Errorf("invalid parameter type: %T", i)
}
for _, pr := range infraParams.InfrastructurePeriods {
if pr.End.Before(pr.Start) {
return fmt.Errorf("end time for period is before start time: %s", pr)
}
prevEnd := tmtime.Canonical(time.Unix(0, 0))
if pr.Start.Before(prevEnd) {
return fmt.Errorf("periods must be in chronological order: %s", infraParams.InfrastructurePeriods)
}
prevEnd = pr.End
if pr.Start.Unix() <= 0 || pr.End.Unix() <= 0 {
return fmt.Errorf("start or end time cannot be zero: %s", pr)
}
// TODO: validate period Inflation?
}
return nil
}
type CoreRewards []CoreReward
type PartnerRewards []PartnerReward

848
x/kavadist/types/params.pb.go
View File

@ -5,7 +5,9 @@ package types
import ( import (
fmt "fmt" fmt "fmt"
_ "github.com/cosmos/cosmos-proto"
github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types" github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
types "github.com/cosmos/cosmos-sdk/types"
_ "github.com/gogo/protobuf/gogoproto" _ "github.com/gogo/protobuf/gogoproto"
proto "github.com/gogo/protobuf/proto" proto "github.com/gogo/protobuf/proto"
github_com_gogo_protobuf_types "github.com/gogo/protobuf/types" github_com_gogo_protobuf_types "github.com/gogo/protobuf/types"
@ -32,6 +34,7 @@ const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
type Params struct { type Params struct {
Active bool `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty" yaml:"active"` Active bool `protobuf:"varint,1,opt,name=active,proto3" json:"active,omitempty" yaml:"active"`
Periods []Period `protobuf:"bytes,3,rep,name=periods,proto3" json:"periods" yaml:"periods"` Periods []Period `protobuf:"bytes,3,rep,name=periods,proto3" json:"periods" yaml:"periods"`
InfrastructureParams InfrastructureParams `protobuf:"bytes,4,opt,name=infrastructure_params,json=infrastructureParams,proto3" json:"infrastructure_params"`
} }
func (m *Params) Reset() { *m = Params{} } func (m *Params) Reset() { *m = Params{} }
@ -66,6 +69,121 @@ func (m *Params) XXX_DiscardUnknown() {
var xxx_messageInfo_Params proto.InternalMessageInfo var xxx_messageInfo_Params proto.InternalMessageInfo
type InfrastructureParams struct {
InfrastructurePeriods Periods `protobuf:"bytes,1,rep,name=infrastructure_periods,json=infrastructurePeriods,proto3,castrepeated=Periods" json:"infrastructure_periods"`
CoreRewards CoreRewards `protobuf:"bytes,2,rep,name=core_rewards,json=coreRewards,proto3,castrepeated=CoreRewards" json:"core_rewards"`
PartnerRewards PartnerRewards `protobuf:"bytes,3,rep,name=partner_rewards,json=partnerRewards,proto3,castrepeated=PartnerRewards" json:"partner_rewards"`
}
func (m *InfrastructureParams) Reset() { *m = InfrastructureParams{} }
func (m *InfrastructureParams) String() string { return proto.CompactTextString(m) }
func (*InfrastructureParams) ProtoMessage() {}
func (*InfrastructureParams) Descriptor() ([]byte, []int) {
return fileDescriptor_2c7a7a4b0c884a4e, []int{1}
}
func (m *InfrastructureParams) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *InfrastructureParams) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_InfrastructureParams.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *InfrastructureParams) XXX_Merge(src proto.Message) {
xxx_messageInfo_InfrastructureParams.Merge(m, src)
}
func (m *InfrastructureParams) XXX_Size() int {
return m.Size()
}
func (m *InfrastructureParams) XXX_DiscardUnknown() {
xxx_messageInfo_InfrastructureParams.DiscardUnknown(m)
}
var xxx_messageInfo_InfrastructureParams proto.InternalMessageInfo
type CoreReward struct {
Address github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=address,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"address,omitempty"`
Weight github_com_cosmos_cosmos_sdk_types.Dec `protobuf:"bytes,2,opt,name=weight,proto3,customtype=github.com/cosmos/cosmos-sdk/types.Dec" json:"weight"`
}
func (m *CoreReward) Reset() { *m = CoreReward{} }
func (m *CoreReward) String() string { return proto.CompactTextString(m) }
func (*CoreReward) ProtoMessage() {}
func (*CoreReward) Descriptor() ([]byte, []int) {
return fileDescriptor_2c7a7a4b0c884a4e, []int{2}
}
func (m *CoreReward) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *CoreReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_CoreReward.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *CoreReward) XXX_Merge(src proto.Message) {
xxx_messageInfo_CoreReward.Merge(m, src)
}
func (m *CoreReward) XXX_Size() int {
return m.Size()
}
func (m *CoreReward) XXX_DiscardUnknown() {
xxx_messageInfo_CoreReward.DiscardUnknown(m)
}
var xxx_messageInfo_CoreReward proto.InternalMessageInfo
type PartnerReward struct {
Address github_com_cosmos_cosmos_sdk_types.AccAddress `protobuf:"bytes,1,opt,name=address,proto3,casttype=github.com/cosmos/cosmos-sdk/types.AccAddress" json:"address,omitempty"`
RewardsPerSecond types.Coin `protobuf:"bytes,2,opt,name=rewards_per_second,json=rewardsPerSecond,proto3" json:"rewards_per_second"`
}
func (m *PartnerReward) Reset() { *m = PartnerReward{} }
func (m *PartnerReward) String() string { return proto.CompactTextString(m) }
func (*PartnerReward) ProtoMessage() {}
func (*PartnerReward) Descriptor() ([]byte, []int) {
return fileDescriptor_2c7a7a4b0c884a4e, []int{3}
}
func (m *PartnerReward) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *PartnerReward) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_PartnerReward.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalToSizedBuffer(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *PartnerReward) XXX_Merge(src proto.Message) {
xxx_messageInfo_PartnerReward.Merge(m, src)
}
func (m *PartnerReward) XXX_Size() int {
return m.Size()
}
func (m *PartnerReward) XXX_DiscardUnknown() {
xxx_messageInfo_PartnerReward.DiscardUnknown(m)
}
var xxx_messageInfo_PartnerReward proto.InternalMessageInfo
// Period stores the specified start and end dates, and the inflation, expressed as a decimal // Period stores the specified start and end dates, and the inflation, expressed as a decimal
// representing the yearly APR of KAVA tokens that will be minted during that period // representing the yearly APR of KAVA tokens that will be minted during that period
type Period struct { type Period struct {
@ -80,7 +198,7 @@ type Period struct {
func (m *Period) Reset() { *m = Period{} } func (m *Period) Reset() { *m = Period{} }
func (*Period) ProtoMessage() {} func (*Period) ProtoMessage() {}
func (*Period) Descriptor() ([]byte, []int) { func (*Period) Descriptor() ([]byte, []int) {
return fileDescriptor_2c7a7a4b0c884a4e, []int{1} return fileDescriptor_2c7a7a4b0c884a4e, []int{4}
} }
func (m *Period) XXX_Unmarshal(b []byte) error { func (m *Period) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b) return m.Unmarshal(b)
@ -111,6 +229,9 @@ var xxx_messageInfo_Period proto.InternalMessageInfo
func init() { func init() {
proto.RegisterType((*Params)(nil), "kava.kavadist.v1beta1.Params") proto.RegisterType((*Params)(nil), "kava.kavadist.v1beta1.Params")
proto.RegisterType((*InfrastructureParams)(nil), "kava.kavadist.v1beta1.InfrastructureParams")
proto.RegisterType((*CoreReward)(nil), "kava.kavadist.v1beta1.CoreReward")
proto.RegisterType((*PartnerReward)(nil), "kava.kavadist.v1beta1.PartnerReward")
proto.RegisterType((*Period)(nil), "kava.kavadist.v1beta1.Period") proto.RegisterType((*Period)(nil), "kava.kavadist.v1beta1.Period")
} }
@ -119,32 +240,51 @@ func init() {
} }
var fileDescriptor_2c7a7a4b0c884a4e = []byte{ var fileDescriptor_2c7a7a4b0c884a4e = []byte{
// 399 bytes of a gzipped FileDescriptorProto // 696 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x84, 0x92, 0xb1, 0x8e, 0xd3, 0x30, 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x54, 0xbd, 0x6f, 0xd3, 0x40,
0x18, 0xc7, 0xe3, 0x0b, 0x04, 0xf0, 0x1d, 0x08, 0x22, 0x40, 0x51, 0x25, 0xec, 0xca, 0x03, 0x2a, 0x14, 0xcf, 0x25, 0x21, 0xa5, 0x97, 0x7e, 0xe1, 0x7e, 0xc8, 0xad, 0x84, 0x1d, 0x2c, 0x84, 0x02,
0x48, 0x67, 0xeb, 0x8e, 0xed, 0xc6, 0xe8, 0x26, 0x84, 0xc4, 0x29, 0x62, 0x62, 0xc2, 0x49, 0x7c, 0x28, 0xb6, 0x1a, 0xb6, 0x8a, 0xa5, 0xa6, 0x03, 0x20, 0x10, 0x95, 0xe9, 0x02, 0x4b, 0x38, 0xdb,
0x21, 0xba, 0x24, 0x8e, 0x62, 0xb7, 0xa2, 0x2b, 0xe2, 0x01, 0xfa, 0x08, 0x3c, 0x4e, 0xc7, 0x8e, 0x97, 0xd4, 0x6a, 0xe2, 0xb3, 0xee, 0x2e, 0x2d, 0x5d, 0xf9, 0x0b, 0x3a, 0x32, 0x76, 0x66, 0xee,
0x15, 0x43, 0xa0, 0xed, 0xc2, 0xdc, 0x27, 0x40, 0xb1, 0x13, 0xca, 0x80, 0x74, 0x4b, 0xf2, 0x25, 0xbf, 0x80, 0x94, 0x81, 0xa1, 0xea, 0x54, 0x31, 0xa4, 0xb4, 0x5d, 0x18, 0x98, 0x3a, 0x32, 0x21,
0xf9, 0x7d, 0xbf, 0xef, 0xfb, 0x47, 0x86, 0xe4, 0x86, 0xcf, 0x38, 0xeb, 0x2e, 0x69, 0xae, 0x34, 0xdf, 0x5d, 0x92, 0xa6, 0x6a, 0x50, 0x59, 0x58, 0x12, 0xbf, 0x8f, 0xdf, 0xef, 0xbd, 0xdf, 0xdd,
0x9b, 0x9d, 0xc5, 0x42, 0xf3, 0x33, 0x56, 0xf3, 0x86, 0x97, 0x8a, 0xd6, 0x8d, 0xd4, 0xd2, 0x7f, 0x7b, 0x07, 0xad, 0x2d, 0xb4, 0x8d, 0x9c, 0xf4, 0x27, 0x8c, 0x18, 0x77, 0xb6, 0x97, 0x7d, 0xcc,
0xd6, 0x7d, 0xa6, 0x03, 0x43, 0x7b, 0x66, 0xf4, 0x34, 0x93, 0x99, 0x34, 0x04, 0xeb, 0x2a, 0x0b, 0xd1, 0xb2, 0x93, 0x20, 0x8a, 0x5a, 0xcc, 0x4e, 0x28, 0xe1, 0x44, 0x9b, 0x4f, 0xc3, 0x76, 0x2f,
0x8f, 0x70, 0x26, 0x65, 0x56, 0x08, 0x66, 0x9e, 0xe2, 0xe9, 0x35, 0xd3, 0x79, 0x29, 0x94, 0xe6, 0xc7, 0x56, 0x39, 0x4b, 0x73, 0x0d, 0xd2, 0x20, 0x22, 0xc3, 0x49, 0xbf, 0x64, 0xf2, 0x92, 0x11,
0x65, 0x6d, 0x01, 0xf2, 0x0d, 0x40, 0xef, 0xca, 0xe8, 0xfd, 0x57, 0xd0, 0xe3, 0x89, 0xce, 0x67, 0x10, 0xd6, 0x22, 0xcc, 0xf1, 0x11, 0xc3, 0x7d, 0xba, 0x80, 0x44, 0xb1, 0x8a, 0x2f, 0xca, 0x78,
0x22, 0x00, 0x63, 0x30, 0xb9, 0x1f, 0x3e, 0xd9, 0xb7, 0xf8, 0xe1, 0x9c, 0x97, 0xc5, 0x05, 0xb1, 0x4d, 0x02, 0xa5, 0xa1, 0x42, 0x66, 0x83, 0x90, 0x46, 0x13, 0x3b, 0xc2, 0xf2, 0xdb, 0x75, 0x87,
0xef, 0x49, 0xd4, 0x03, 0xfe, 0x7b, 0x78, 0xaf, 0x16, 0x4d, 0x2e, 0x53, 0x15, 0xb8, 0x63, 0x77, 0x47, 0x2d, 0xcc, 0x38, 0x6a, 0x25, 0x32, 0xc1, 0xfa, 0x05, 0x60, 0x61, 0x5d, 0x74, 0xa6, 0x3d,
0x72, 0x7c, 0xfe, 0x82, 0xfe, 0x77, 0x2b, 0x7a, 0x65, 0xa8, 0xf0, 0xf9, 0xb2, 0xc5, 0xce, 0xbe, 0x84, 0x05, 0x14, 0xf0, 0x68, 0x1b, 0xeb, 0xa0, 0x04, 0xca, 0xb7, 0xdd, 0x3b, 0x17, 0x5d, 0x73,
0xc5, 0x8f, 0xac, 0xae, 0xef, 0x25, 0xd1, 0x60, 0x21, 0x5f, 0x8f, 0xa0, 0x67, 0x59, 0xff, 0x2d, 0x72, 0x17, 0xb5, 0x9a, 0x2b, 0x96, 0xf4, 0x5b, 0x9e, 0x4a, 0xd0, 0xde, 0xc0, 0xb1, 0x04, 0xd3,
0xbc, 0xab, 0x34, 0x6f, 0xb4, 0xd9, 0xe2, 0xf8, 0x7c, 0x44, 0x6d, 0x04, 0x3a, 0x44, 0xa0, 0x1f, 0x88, 0x84, 0x4c, 0xcf, 0x95, 0x72, 0xe5, 0x62, 0xf5, 0xae, 0x7d, 0xad, 0x20, 0x7b, 0x5d, 0x64,
0x86, 0x08, 0x61, 0xd0, 0x6b, 0x4f, 0xac, 0xd6, 0xb4, 0x91, 0xc5, 0x4f, 0x0c, 0x22, 0xab, 0xf0, 0xb9, 0x0b, 0x9d, 0xae, 0x99, 0xb9, 0xe8, 0x9a, 0x53, 0x92, 0x4e, 0x61, 0x2d, 0xaf, 0xc7, 0xa2,
0x2f, 0xa1, 0x2b, 0xaa, 0x34, 0x38, 0xba, 0xd5, 0x34, 0x2c, 0x08, 0xad, 0x49, 0x54, 0xa9, 0xf5, 0xd5, 0xe1, 0x7c, 0x14, 0xd7, 0x29, 0x62, 0x9c, 0xb6, 0x03, 0xde, 0xa6, 0xb8, 0x26, 0x8f, 0x4b,
0x74, 0xed, 0xfe, 0x27, 0xf8, 0x20, 0xaf, 0xae, 0x0b, 0xae, 0x73, 0x59, 0x05, 0xee, 0x18, 0x4c, 0xcf, 0x97, 0x40, 0xb9, 0x58, 0x7d, 0x3c, 0x82, 0xfe, 0xc5, 0x10, 0x46, 0xea, 0x70, 0xf3, 0x69,
0x4e, 0xc2, 0xb0, 0xe3, 0x7f, 0xb4, 0xf8, 0x65, 0x96, 0xeb, 0xcf, 0xd3, 0x98, 0x26, 0xb2, 0x64, 0x31, 0x6f, 0x2e, 0xba, 0x26, 0x66, 0x7d, 0xcd, 0xc2, 0xb9, 0xeb, 0x40, 0x1a, 0x86, 0x0b, 0x57,
0x89, 0x54, 0xa5, 0x54, 0xfd, 0xed, 0x54, 0xa5, 0x37, 0x4c, 0xcf, 0x6b, 0xa1, 0xe8, 0xa5, 0x48, 0x1b, 0x50, 0x02, 0xc1, 0x4d, 0x04, 0x4e, 0xa7, 0x35, 0xbf, 0x9c, 0x98, 0x63, 0xd2, 0x66, 0xde,
0xf6, 0x2d, 0x7e, 0x6c, 0xcd, 0x7f, 0x45, 0x24, 0x3a, 0x48, 0x2f, 0xee, 0xfc, 0xfe, 0x8e, 0x41, 0x15, 0x39, 0xca, 0xad, 0xbd, 0x83, 0x13, 0x01, 0xa1, 0xb8, 0x46, 0xf1, 0x0e, 0xa2, 0x21, 0xd3,
0xf8, 0x6e, 0xb9, 0x41, 0xce, 0x7a, 0x83, 0x9c, 0xe5, 0x16, 0x81, 0xd5, 0x16, 0x81, 0x5f, 0x5b, 0xb3, 0x82, 0xfc, 0xde, 0x08, 0xf2, 0x67, 0x84, 0x62, 0x4f, 0x64, 0xba, 0xb3, 0xaa, 0x40, 0x71,
0x04, 0x16, 0x3b, 0xe4, 0xac, 0x76, 0xc8, 0x59, 0xef, 0x90, 0xf3, 0xf1, 0xf5, 0x3f, 0xe3, 0xba, 0xe0, 0x63, 0x5e, 0x31, 0x18, 0x18, 0x1a, 0x86, 0xd3, 0x09, 0xa2, 0x3c, 0xc6, 0xb4, 0xcf, 0x2e,
0x7f, 0x7d, 0x5a, 0xf0, 0x58, 0x99, 0x8a, 0x7d, 0x39, 0x1c, 0x1b, 0x33, 0x36, 0xf6, 0x4c, 0xcc, 0xef, 0xe6, 0xfe, 0xa8, 0xd6, 0x65, 0xb6, 0x2a, 0xb0, 0xa0, 0x0a, 0x4c, 0x0d, 0xb9, 0x99, 0x37,
0x37, 0x7f, 0x02, 0x00, 0x00, 0xff, 0xff, 0xd6, 0x3b, 0xc2, 0x43, 0x54, 0x02, 0x00, 0x00, 0x95, 0x0c, 0xd9, 0x2b, 0xf9, 0xcf, 0xfb, 0x26, 0xb0, 0xbe, 0x01, 0x08, 0x07, 0x9d, 0x68, 0x3e,
0x1c, 0x43, 0x61, 0x48, 0x31, 0x63, 0x62, 0x76, 0x26, 0xdc, 0xe7, 0xbf, 0xbb, 0x66, 0xa5, 0x11,
0xf1, 0xcd, 0xb6, 0x6f, 0x07, 0xa4, 0xa5, 0x86, 0x52, 0xfd, 0x55, 0x58, 0xb8, 0xe5, 0xf0, 0xdd,
0x04, 0x33, 0x7b, 0x35, 0x08, 0x56, 0x25, 0xf0, 0xe8, 0xa0, 0x32, 0xab, 0x46, 0x57, 0x79, 0xdc,
0x5d, 0x8e, 0x99, 0xd7, 0x23, 0xd6, 0x36, 0x60, 0x61, 0x07, 0x47, 0x8d, 0x4d, 0xae, 0x67, 0x4b,
0xa0, 0x3c, 0xee, 0x3e, 0x4d, 0x1b, 0xfe, 0xde, 0x35, 0x1f, 0xdc, 0xa0, 0xcc, 0x1a, 0x0e, 0x8e,
0x0e, 0x2a, 0x50, 0xf1, 0xaf, 0xe1, 0xc0, 0x53, 0x5c, 0x4a, 0x4e, 0x07, 0xc0, 0xc9, 0x21, 0xdd,
0xff, 0x45, 0xd1, 0x6b, 0xa8, 0xa9, 0x9b, 0x4a, 0x87, 0xad, 0xc6, 0x70, 0x40, 0xe2, 0x50, 0xa8,
0x2b, 0x56, 0x17, 0x6d, 0x05, 0x4d, 0x97, 0xfe, 0xd2, 0x40, 0x44, 0xb1, 0x9a, 0xef, 0x19, 0x05,
0x5d, 0xc7, 0xf4, 0xad, 0x00, 0x2a, 0x29, 0x9f, 0xb2, 0xb0, 0x20, 0xa7, 0x4d, 0x7b, 0x09, 0x6f,
0x31, 0x8e, 0x28, 0x17, 0x0a, 0x8a, 0xd5, 0x25, 0x5b, 0x3e, 0x06, 0x76, 0xef, 0x31, 0xb0, 0x37,
0x7a, 0x8f, 0x81, 0xab, 0xab, 0x05, 0x9d, 0x90, 0x0b, 0x2a, 0x60, 0xd6, 0xde, 0x89, 0x09, 0x3c,
0x49, 0xa1, 0xad, 0xc1, 0x1c, 0xee, 0x37, 0xf7, 0x37, 0xa6, 0xde, 0xaa, 0x43, 0xc9, 0x84, 0xe3,
0x50, 0xf2, 0xa4, 0x70, 0xed, 0x03, 0x1c, 0x8f, 0xe2, 0x7a, 0x13, 0xf1, 0x88, 0xc4, 0x7a, 0x4e,
0x9c, 0xab, 0xfb, 0x6f, 0xd7, 0x78, 0xd1, 0x35, 0x67, 0x24, 0x73, 0x9f, 0xc8, 0xf2, 0x06, 0xa4,
0x2b, 0xf9, 0x9f, 0xfb, 0x26, 0x70, 0x5f, 0x75, 0x4e, 0x8d, 0xcc, 0xf1, 0xa9, 0x91, 0xe9, 0x9c,
0x19, 0xe0, 0xf0, 0xcc, 0x00, 0x3f, 0xce, 0x0c, 0xb0, 0x77, 0x6e, 0x64, 0x0e, 0xcf, 0x8d, 0xcc,
0xf1, 0xb9, 0x91, 0x79, 0xff, 0xe8, 0x52, 0xb9, 0x74, 0x33, 0x2a, 0x4d, 0xe4, 0x33, 0xf1, 0xe5,
0x7c, 0x1c, 0xbc, 0xdd, 0xa2, 0xac, 0x5f, 0x10, 0x32, 0x9f, 0xfc, 0x09, 0x00, 0x00, 0xff, 0xff,
0xb2, 0xbd, 0x98, 0xf3, 0xd9, 0x05, 0x00, 0x00,
} }
func (this *Period) Equal(that interface{}) bool { func (this *Period) Equal(that interface{}) bool {
@ -197,6 +337,16 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
_ = i _ = i
var l int var l int
_ = l _ = l
{
size, err := m.InfrastructureParams.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x22
if len(m.Periods) > 0 { if len(m.Periods) > 0 {
for iNdEx := len(m.Periods) - 1; iNdEx >= 0; iNdEx-- { for iNdEx := len(m.Periods) - 1; iNdEx >= 0; iNdEx-- {
{ {
@ -224,6 +374,151 @@ func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
return len(dAtA) - i, nil return len(dAtA) - i, nil
} }
func (m *InfrastructureParams) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *InfrastructureParams) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *InfrastructureParams) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
if len(m.PartnerRewards) > 0 {
for iNdEx := len(m.PartnerRewards) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.PartnerRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x1a
}
}
if len(m.CoreRewards) > 0 {
for iNdEx := len(m.CoreRewards) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.CoreRewards[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
}
}
if len(m.InfrastructurePeriods) > 0 {
for iNdEx := len(m.InfrastructurePeriods) - 1; iNdEx >= 0; iNdEx-- {
{
size, err := m.InfrastructurePeriods[iNdEx].MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0xa
}
}
return len(dAtA) - i, nil
}
func (m *CoreReward) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *CoreReward) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *CoreReward) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size := m.Weight.Size()
i -= size
if _, err := m.Weight.MarshalTo(dAtA[i:]); err != nil {
return 0, err
}
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintParams(dAtA, i, uint64(len(m.Address)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *PartnerReward) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalToSizedBuffer(dAtA[:size])
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *PartnerReward) MarshalTo(dAtA []byte) (int, error) {
size := m.Size()
return m.MarshalToSizedBuffer(dAtA[:size])
}
func (m *PartnerReward) MarshalToSizedBuffer(dAtA []byte) (int, error) {
i := len(dAtA)
_ = i
var l int
_ = l
{
size, err := m.RewardsPerSecond.MarshalToSizedBuffer(dAtA[:i])
if err != nil {
return 0, err
}
i -= size
i = encodeVarintParams(dAtA, i, uint64(size))
}
i--
dAtA[i] = 0x12
if len(m.Address) > 0 {
i -= len(m.Address)
copy(dAtA[i:], m.Address)
i = encodeVarintParams(dAtA, i, uint64(len(m.Address)))
i--
dAtA[i] = 0xa
}
return len(dAtA) - i, nil
}
func (m *Period) Marshal() (dAtA []byte, err error) { func (m *Period) Marshal() (dAtA []byte, err error) {
size := m.Size() size := m.Size()
dAtA = make([]byte, size) dAtA = make([]byte, size)
@ -254,20 +549,20 @@ func (m *Period) MarshalToSizedBuffer(dAtA []byte) (int, error) {
} }
i-- i--
dAtA[i] = 0x1a dAtA[i] = 0x1a
n1, err1 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):]) n3, err3 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.End, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.End):])
if err1 != nil { if err3 != nil {
return 0, err1 return 0, err3
} }
i -= n1 i -= n3
i = encodeVarintParams(dAtA, i, uint64(n1)) i = encodeVarintParams(dAtA, i, uint64(n3))
i-- i--
dAtA[i] = 0x12 dAtA[i] = 0x12
n2, err2 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):]) n4, err4 := github_com_gogo_protobuf_types.StdTimeMarshalTo(m.Start, dAtA[i-github_com_gogo_protobuf_types.SizeOfStdTime(m.Start):])
if err2 != nil { if err4 != nil {
return 0, err2 return 0, err4
} }
i -= n2 i -= n4
i = encodeVarintParams(dAtA, i, uint64(n2)) i = encodeVarintParams(dAtA, i, uint64(n4))
i-- i--
dAtA[i] = 0xa dAtA[i] = 0xa
return len(dAtA) - i, nil return len(dAtA) - i, nil
@ -299,6 +594,65 @@ func (m *Params) Size() (n int) {
n += 1 + l + sovParams(uint64(l)) n += 1 + l + sovParams(uint64(l))
} }
} }
l = m.InfrastructureParams.Size()
n += 1 + l + sovParams(uint64(l))
return n
}
func (m *InfrastructureParams) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
if len(m.InfrastructurePeriods) > 0 {
for _, e := range m.InfrastructurePeriods {
l = e.Size()
n += 1 + l + sovParams(uint64(l))
}
}
if len(m.CoreRewards) > 0 {
for _, e := range m.CoreRewards {
l = e.Size()
n += 1 + l + sovParams(uint64(l))
}
}
if len(m.PartnerRewards) > 0 {
for _, e := range m.PartnerRewards {
l = e.Size()
n += 1 + l + sovParams(uint64(l))
}
}
return n
}
func (m *CoreReward) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Address)
if l > 0 {
n += 1 + l + sovParams(uint64(l))
}
l = m.Weight.Size()
n += 1 + l + sovParams(uint64(l))
return n
}
func (m *PartnerReward) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = len(m.Address)
if l > 0 {
n += 1 + l + sovParams(uint64(l))
}
l = m.RewardsPerSecond.Size()
n += 1 + l + sovParams(uint64(l))
return n return n
} }
@ -406,6 +760,426 @@ func (m *Params) Unmarshal(dAtA []byte) error {
return err return err
} }
iNdEx = postIndex iNdEx = postIndex
case 4:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field InfrastructureParams", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.InfrastructureParams.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthParams
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *InfrastructureParams) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: InfrastructureParams: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: InfrastructureParams: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field InfrastructurePeriods", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.InfrastructurePeriods = append(m.InfrastructurePeriods, Period{})
if err := m.InfrastructurePeriods[len(m.InfrastructurePeriods)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field CoreRewards", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.CoreRewards = append(m.CoreRewards, CoreReward{})
if err := m.CoreRewards[len(m.CoreRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 3:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field PartnerRewards", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.PartnerRewards = append(m.PartnerRewards, PartnerReward{})
if err := m.PartnerRewards[len(m.PartnerRewards)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthParams
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *CoreReward) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: CoreReward: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: CoreReward: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
if m.Address == nil {
m.Address = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Weight", wireType)
}
var stringLen uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
stringLen |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
intStringLen := int(stringLen)
if intStringLen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + intStringLen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.Weight.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:])
if err != nil {
return err
}
if (skippy < 0) || (iNdEx+skippy) < 0 {
return ErrInvalidLengthParams
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func (m *PartnerReward) Unmarshal(dAtA []byte) error {
l := len(dAtA)
iNdEx := 0
for iNdEx < l {
preIndex := iNdEx
var wire uint64
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
wire |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
fieldNum := int32(wire >> 3)
wireType := int(wire & 0x7)
if wireType == 4 {
return fmt.Errorf("proto: PartnerReward: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: PartnerReward: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field Address", wireType)
}
var byteLen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
byteLen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if byteLen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + byteLen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
m.Address = append(m.Address[:0], dAtA[iNdEx:postIndex]...)
if m.Address == nil {
m.Address = []byte{}
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field RewardsPerSecond", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowParams
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthParams
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthParams
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.RewardsPerSecond.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default: default:
iNdEx = preIndex iNdEx = preIndex
skippy, err := skipParams(dAtA[iNdEx:]) skippy, err := skipParams(dAtA[iNdEx:])