0g-chain/migrate/v0_14/migrate.go
Denali Marsh bc33b94822
Update delegator rewards to multi-reward index (#945)
* update claim attribute type to MultiRewardIndexes

* update param attribute type to MultiRewardPeriods

* keeper: update params to match types

* keeper: update delegator core keeper methods

* keeper: update InitializeHardDelegatorReward

* keeper: update SynchronizeHardDelegatorRewards

* remove reward factor in favor of reward indexes

* update querier

* fix test: delegator init test

* fix test: delegator sync test

* implement delegator reward accumulation

* fix test: delegator general tests

* add legact types, update v0_11 -> v0_14 migration

* remove duplicate import form v0_15 migration

* implement v0_15incentive migration

* test data and migration test

* add multiple reward denoms to init/sync tests

* update delegator test with multiple reward coins

* clean up simulation sync
2021-07-06 00:01:25 +02:00

698 lines
29 KiB
Go

package v0_14
import (
"fmt"
"sort"
"time"
"github.com/cosmos/cosmos-sdk/codec"
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/x/auth"
authexported "github.com/cosmos/cosmos-sdk/x/auth/exported"
"github.com/cosmos/cosmos-sdk/x/genutil"
"github.com/cosmos/cosmos-sdk/x/supply"
cryptoAmino "github.com/tendermint/tendermint/crypto/encoding/amino"
tmtypes "github.com/tendermint/tendermint/types"
"github.com/kava-labs/kava/app"
"github.com/kava-labs/kava/x/bep3"
v0_14cdp "github.com/kava-labs/kava/x/cdp"
v0_11cdp "github.com/kava-labs/kava/x/cdp/legacy/v0_11"
v0_11committee "github.com/kava-labs/kava/x/committee/legacy/v0_11"
v0_14committee "github.com/kava-labs/kava/x/committee/legacy/v0_14"
v0_14hard "github.com/kava-labs/kava/x/hard"
v0_11hard "github.com/kava-labs/kava/x/hard/legacy/v0_11"
v0_11incentive "github.com/kava-labs/kava/x/incentive/legacy/v0_11"
v0_14incentive "github.com/kava-labs/kava/x/incentive/legacy/v0_14"
"github.com/kava-labs/kava/x/kavadist"
v0_11pricefeed "github.com/kava-labs/kava/x/pricefeed"
v0_14pricefeed "github.com/kava-labs/kava/x/pricefeed"
validatorvesting "github.com/kava-labs/kava/x/validator-vesting"
)
var (
GenesisTime = time.Date(2021, 4, 8, 15, 0, 0, 0, time.UTC)
RewardEndTime = time.Date(2022, 4, 8, 14, 0, 0, 0, time.UTC)
ClaimEndTime = time.Date(2026, 4, 8, 14, 0, 0, 0, time.UTC)
)
// Migrate translates a genesis file from kava v0.11 (or v0.12) format to kava v0.13.x format.
func Migrate(genDoc tmtypes.GenesisDoc) tmtypes.GenesisDoc {
// migrate app state
var appStateMap genutil.AppMap
cdc := codec.New()
cryptoAmino.RegisterAmino(cdc)
tmtypes.RegisterEvidences(cdc)
if err := cdc.UnmarshalJSON(genDoc.AppState, &appStateMap); err != nil {
panic(err)
}
newAppState := MigrateAppState(appStateMap)
v0_14Codec := app.MakeCodec()
marshaledNewAppState, err := v0_14Codec.MarshalJSON(newAppState)
if err != nil {
panic(err)
}
genDoc.AppState = marshaledNewAppState
genDoc.GenesisTime = GenesisTime
genDoc.ChainID = "kava-7"
genDoc.ConsensusParams.Block.MaxGas = 20000000
return genDoc
}
// MigrateAppState migrates application state from v0.11 (or v0.12) format to a kava v0.13.x format
func MigrateAppState(v0_11AppState genutil.AppMap) genutil.AppMap {
v0_14AppState := v0_11AppState
cdc := app.MakeCodec()
var hardGenState v0_11hard.GenesisState
if v0_11AppState[v0_14hard.ModuleName] == nil {
cdc.MustUnmarshalJSON(v0_11AppState[v0_11hard.ModuleName], &hardGenState)
delete(v0_11AppState, v0_11hard.ModuleName)
v0_14AppState[v0_14hard.ModuleName] = cdc.MustMarshalJSON(
Hard(hardGenState))
}
delete(v0_14AppState, v0_11hard.ModuleName)
if v0_11AppState[v0_11cdp.ModuleName] != nil {
var cdpGenState v0_11cdp.GenesisState
cdc.MustUnmarshalJSON(v0_11AppState[v0_11cdp.ModuleName], &cdpGenState)
delete(v0_11AppState, v0_11cdp.ModuleName)
v0_14AppState[v0_14cdp.ModuleName] = cdc.MustMarshalJSON(
CDP(cdpGenState))
}
if v0_11AppState[v0_11incentive.ModuleName] != nil {
var incentiveGenState v0_11incentive.GenesisState
cdc.MustUnmarshalJSON(v0_11AppState[v0_14incentive.ModuleName], &incentiveGenState)
delete(v0_11AppState, v0_11incentive.ModuleName)
v0_14AppState[v0_14incentive.ModuleName] = cdc.MustMarshalJSON(Incentive(hardGenState, incentiveGenState))
}
if v0_11AppState[v0_11pricefeed.ModuleName] != nil {
var pricefeedGS v0_11pricefeed.GenesisState
cdc.MustUnmarshalJSON(v0_11AppState[v0_14pricefeed.ModuleName], &pricefeedGS)
delete(v0_11AppState, v0_11pricefeed.ModuleName)
v0_14AppState[v0_14pricefeed.ModuleName] = cdc.MustMarshalJSON(Pricefeed(pricefeedGS))
}
if v0_11AppState[bep3.ModuleName] != nil {
var bep3GS bep3.GenesisState
cdc.MustUnmarshalJSON(v0_11AppState[bep3.ModuleName], &bep3GS)
delete(v0_11AppState, bep3.ModuleName)
v0_14AppState[bep3.ModuleName] = cdc.MustMarshalJSON(Bep3(bep3GS))
}
if v0_11AppState[v0_11committee.ModuleName] != nil {
var committeeGS v0_11committee.GenesisState
cdc := codec.New()
sdk.RegisterCodec(cdc)
v0_11committee.RegisterCodec(cdc)
cdc.MustUnmarshalJSON(v0_11AppState[v0_11committee.ModuleName], &committeeGS)
delete(v0_11AppState, v0_11committee.ModuleName)
cdc = app.MakeCodec()
v0_14AppState[v0_14committee.ModuleName] = cdc.MustMarshalJSON(Committee(committeeGS))
}
if v0_11AppState[auth.ModuleName] != nil {
var authGS auth.GenesisState
cdc.MustUnmarshalJSON(v0_11AppState[auth.ModuleName], &authGS)
delete(v0_11AppState, auth.ModuleName)
v0_14AppState[auth.ModuleName] = cdc.MustMarshalJSON(Auth(authGS))
}
return v0_14AppState
}
// CDP migrates from a v0.11 cdp genesis state to a v0.13 cdp genesis state
func CDP(oldGenState v0_11cdp.GenesisState) v0_14cdp.GenesisState {
var newCDPs v0_14cdp.CDPs
var newDeposits v0_14cdp.Deposits
var newCollateralParams v0_14cdp.CollateralParams
var newGenesisAccumulationTimes v0_14cdp.GenesisAccumulationTimes
var previousAccumulationTime time.Time
var totalPrincipals v0_14cdp.GenesisTotalPrincipals
newStartingID := oldGenState.StartingCdpID
totalPrincipalMap := make(map[string]sdk.Int)
for _, cdp := range oldGenState.CDPs {
newCDP := v0_14cdp.NewCDPWithFees(cdp.ID, cdp.Owner, cdp.Collateral, cdp.Type, cdp.Principal, cdp.AccumulatedFees, cdp.FeesUpdated, sdk.OneDec())
if previousAccumulationTime.Before(cdp.FeesUpdated) {
previousAccumulationTime = cdp.FeesUpdated
}
_, found := totalPrincipalMap[cdp.Type]
if !found {
totalPrincipalMap[cdp.Type] = sdk.ZeroInt()
}
totalPrincipalMap[cdp.Type] = totalPrincipalMap[cdp.Type].Add(newCDP.GetTotalPrincipal().Amount)
newCDPs = append(newCDPs, newCDP)
}
for _, cp := range oldGenState.Params.CollateralParams {
newCollateralParam := v0_14cdp.NewCollateralParam(cp.Denom, cp.Type, cp.LiquidationRatio, cp.DebtLimit, cp.StabilityFee, cp.AuctionSize, cp.LiquidationPenalty, cp.Prefix, cp.SpotMarketID, cp.LiquidationMarketID, sdk.MustNewDecFromStr("0.01"), sdk.NewInt(10), cp.ConversionFactor)
newCollateralParams = append(newCollateralParams, newCollateralParam)
newGenesisAccumulationTime := v0_14cdp.NewGenesisAccumulationTime(cp.Type, previousAccumulationTime, sdk.OneDec())
newGenesisAccumulationTimes = append(newGenesisAccumulationTimes, newGenesisAccumulationTime)
}
for _, dep := range oldGenState.Deposits {
newDep := v0_14cdp.NewDeposit(dep.CdpID, dep.Depositor, dep.Amount)
newDeposits = append(newDeposits, newDep)
}
for ctype, tp := range totalPrincipalMap {
totalPrincipal := v0_14cdp.NewGenesisTotalPrincipal(ctype, tp)
totalPrincipals = append(totalPrincipals, totalPrincipal)
}
sort.Slice(totalPrincipals, func(i, j int) bool { return totalPrincipals[i].CollateralType < totalPrincipals[j].CollateralType })
oldDebtParam := oldGenState.Params.DebtParam
newDebtParam := v0_14cdp.NewDebtParam(oldDebtParam.Denom, oldDebtParam.ReferenceAsset, oldDebtParam.ConversionFactor, oldDebtParam.DebtFloor)
newGlobalDebtLimit := oldGenState.Params.GlobalDebtLimit
newParams := v0_14cdp.NewParams(newGlobalDebtLimit, newCollateralParams, newDebtParam, oldGenState.Params.SurplusAuctionThreshold, oldGenState.Params.SurplusAuctionLot, oldGenState.Params.DebtAuctionThreshold, oldGenState.Params.DebtAuctionLot, false)
return v0_14cdp.NewGenesisState(
newParams,
newCDPs,
newDeposits,
newStartingID,
oldGenState.DebtDenom,
oldGenState.GovDenom,
newGenesisAccumulationTimes,
totalPrincipals,
)
}
// Hard migrates from a v0.11 hard (harvest) genesis state to a v0.13 hard genesis state
func Hard(genesisState v0_11hard.GenesisState) v0_14hard.GenesisState {
v13Deposits := v0_14hard.Deposits{}
v13DepositorMap := make(map[string]v0_14hard.Deposit)
v13GenesisAccumulationTimes := v0_14hard.GenesisAccumulationTimes{}
v13TotalSupplied := sdk.NewCoins()
for _, dep := range genesisState.Deposits {
v13Deposit, ok := v13DepositorMap[dep.Depositor.String()]
if !ok {
v13Deposit := v0_14hard.NewDeposit(dep.Depositor, sdk.NewCoins(dep.Amount), v0_14hard.SupplyInterestFactors{v0_14hard.NewSupplyInterestFactor(dep.Amount.Denom, sdk.OneDec())})
v13DepositorMap[dep.Depositor.String()] = v13Deposit
} else {
v13Deposit.Amount = v13Deposit.Amount.Add(dep.Amount)
v13Deposit.Index = append(v13Deposit.Index, v0_14hard.NewSupplyInterestFactor(dep.Amount.Denom, sdk.OneDec()))
v13DepositorMap[dep.Depositor.String()] = v13Deposit
}
}
defaultInterestModel := v0_14hard.NewInterestRateModel(sdk.ZeroDec(), sdk.MustNewDecFromStr("0.05"), sdk.MustNewDecFromStr("0.8"), sdk.MustNewDecFromStr("1.0"))
newParams := v0_14hard.NewParams(
v0_14hard.MoneyMarkets{
v0_14hard.NewMoneyMarket("btcb", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "btc:usd", sdk.NewInt(100000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
// bnb
v0_14hard.NewMoneyMarket("bnb", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "bnb:usd", sdk.NewInt(100000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
// xrpb
v0_14hard.NewMoneyMarket("xrpb", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "xrp:usd", sdk.NewInt(100000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
// busd
v0_14hard.NewMoneyMarket("busd", v0_14hard.NewBorrowLimit(true, sdk.MustNewDecFromStr("100000000000000"), sdk.MustNewDecFromStr("0.5")), "busd:usd", sdk.NewInt(100000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
// usdx
v0_14hard.NewMoneyMarket("usdx", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.ZeroDec()), "usdx:usd", sdk.NewInt(1000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
// ukava
v0_14hard.NewMoneyMarket("ukava", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "kava:usd", sdk.NewInt(1000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
// hard
v0_14hard.NewMoneyMarket("hard", v0_14hard.NewBorrowLimit(true, sdk.ZeroDec(), sdk.MustNewDecFromStr("0.5")), "hard:usd", sdk.NewInt(1000000),
defaultInterestModel,
sdk.MustNewDecFromStr("0.025"), sdk.MustNewDecFromStr("0.02"),
),
},
sdk.MustNewDecFromStr("10.0"),
)
for _, newDep := range v13DepositorMap {
v13Deposits = append(v13Deposits, newDep)
v13TotalSupplied = v13TotalSupplied.Add(newDep.Amount...)
}
sort.Slice(v13Deposits, func(i, j int) bool {
return v13Deposits[i].Depositor.String() > v13Deposits[j].Depositor.String()
})
for _, mm := range newParams.MoneyMarkets {
genAccumulationTime := v0_14hard.NewGenesisAccumulationTime(mm.Denom, GenesisTime, sdk.OneDec(), sdk.OneDec())
v13GenesisAccumulationTimes = append(v13GenesisAccumulationTimes, genAccumulationTime)
}
return v0_14hard.NewGenesisState(newParams, v13GenesisAccumulationTimes, v13Deposits, v0_14hard.DefaultBorrows, v13TotalSupplied, v0_14hard.DefaultTotalBorrowed, v0_14hard.DefaultTotalReserves)
}
// Incentive migrates from a v0.11 incentive genesis state to a v0.13 incentive genesis state
func Incentive(hardGS v0_11hard.GenesisState, incentiveGS v0_11incentive.GenesisState) v0_14incentive.GenesisState {
usdxMintingRewardPeriods := v0_14incentive.RewardPeriods{}
usdxRewardsPerSecondMap := make(map[string]sdk.Coin)
usdxRewardsPerSecondMap["bnb-a"] = sdk.NewCoin("ukava", sdk.NewInt(122354))
usdxRewardsPerSecondMap["btcb-a"] = sdk.NewCoin("ukava", sdk.NewInt(110780))
usdxRewardsPerSecondMap["busd-a"] = sdk.NewCoin("ukava", sdk.NewInt(30588))
usdxRewardsPerSecondMap["hard-a"] = sdk.NewCoin("ukava", sdk.NewInt(23809))
usdxRewardsPerSecondMap["ukava-a"] = sdk.NewCoin("ukava", sdk.NewInt(31746))
usdxRewardsPerSecondMap["xrpb-a"] = sdk.NewCoin("ukava", sdk.NewInt(31746))
usdxRewardsPerSecondMap["hbtc-a"] = sdk.NewCoin("ukava", sdk.NewInt(79365))
for _, rp := range incentiveGS.RewardPeriods {
rewardsPerSecond, ok := usdxRewardsPerSecondMap[rp.CollateralType]
if !ok {
panic(fmt.Sprintf("No rewards per second for collateral type: %s\n", rp.CollateralType))
}
newRP := v0_14incentive.NewRewardPeriod(true, rp.CollateralType, GenesisTime, RewardEndTime, rewardsPerSecond)
usdxMintingRewardPeriods = append(usdxMintingRewardPeriods, newRP)
}
hardSupplyRewardPeriods := v0_14incentive.MultiRewardPeriods{}
for _, rp := range hardGS.Params.LiquidityProviderSchedules {
newRP := v0_14incentive.NewMultiRewardPeriod(true, rp.DepositDenom, rp.Start, rp.End, sdk.NewCoins(rp.RewardsPerSecond))
hardSupplyRewardPeriods = append(hardSupplyRewardPeriods, newRP)
}
hardBorrowRewardPeriods := v0_14incentive.MultiRewardPeriods{}
hardDelegatorRewardPeriods := v0_14incentive.RewardPeriods{}
for _, rp := range hardGS.Params.DelegatorDistributionSchedules {
newRP := v0_14incentive.NewRewardPeriod(rp.DistributionSchedule.Active, rp.DistributionSchedule.DepositDenom, rp.DistributionSchedule.Start, rp.DistributionSchedule.End, rp.DistributionSchedule.RewardsPerSecond)
hardDelegatorRewardPeriods = append(hardDelegatorRewardPeriods, newRP)
}
params := v0_14incentive.NewParams(usdxMintingRewardPeriods, hardSupplyRewardPeriods, hardBorrowRewardPeriods, hardDelegatorRewardPeriods, v0_14incentive.Multipliers{v0_14incentive.NewMultiplier(v0_14incentive.Small, 1, sdk.MustNewDecFromStr("0.2")), v0_14incentive.NewMultiplier(v0_14incentive.Large, 12, sdk.MustNewDecFromStr("1.0"))}, ClaimEndTime)
usdxGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}
for _, rp := range params.USDXMintingRewardPeriods {
gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
usdxGenAccumulationTimes = append(usdxGenAccumulationTimes, gat)
}
hardSupplyGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}
for _, rp := range params.HardSupplyRewardPeriods {
gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
hardSupplyGenAccumulationTimes = append(hardSupplyGenAccumulationTimes, gat)
}
hardBorrowGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}
for _, rp := range params.HardBorrowRewardPeriods {
gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
hardBorrowGenAccumulationTimes = append(hardBorrowGenAccumulationTimes, gat)
}
hardDelegatorGenAccumulationTimes := v0_14incentive.GenesisAccumulationTimes{}
for _, rp := range params.HardDelegatorRewardPeriods {
gat := v0_14incentive.NewGenesisAccumulationTime(rp.CollateralType, GenesisTime)
hardDelegatorGenAccumulationTimes = append(hardDelegatorGenAccumulationTimes, gat)
}
usdxClaims := v0_14incentive.USDXMintingClaims{}
usdxClaimMap := make(map[string]v0_14incentive.USDXMintingClaim)
claimEndMap := make(map[uint64]time.Time)
for _, cp := range incentiveGS.ClaimPeriods {
claimEndMap[cp.ID] = cp.End
}
for _, claim := range incentiveGS.Claims {
if claimEndMap[claim.ClaimPeriodID].Before(GenesisTime) {
continue
}
newClaim, ok := usdxClaimMap[claim.Owner.String()]
if !ok {
newClaim = v0_14incentive.NewUSDXMintingClaim(claim.Owner, claim.Reward, v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex(claim.CollateralType, sdk.ZeroDec())})
} else {
newClaim.Reward = newClaim.Reward.Add(claim.Reward)
_, found := newClaim.RewardIndexes.GetRewardIndex(claim.CollateralType)
if !found {
newClaim.RewardIndexes = append(newClaim.RewardIndexes, v0_14incentive.NewRewardIndex(claim.CollateralType, sdk.ZeroDec()))
}
}
usdxClaimMap[newClaim.Owner.String()] = newClaim
}
for _, claim := range usdxClaimMap {
usdxClaims = append(usdxClaims, claim)
}
hardClaims := v0_14incentive.HardLiquidityProviderClaims{}
hardClaimMap := make(map[string]v0_14incentive.HardLiquidityProviderClaim)
for _, claim := range hardGS.Claims {
newClaim, ok := hardClaimMap[claim.Owner.String()]
if !ok {
// if claim.Type == "lp" -- hard supply
// if claim.Type == "stake" -- hard delegator
// hard barrow always empty
delegatorIndexes := v0_14incentive.RewardIndexes{}
supplyIndexes := v0_14incentive.MultiRewardIndexes{}
borrowIndexes := v0_14incentive.MultiRewardIndexes{}
if claim.Type == v0_11hard.Stake {
delegatorIndexes = v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex(claim.DepositDenom, sdk.ZeroDec())}
}
if claim.Type == v0_11hard.LP {
supplyIndexes = v0_14incentive.MultiRewardIndexes{v0_14incentive.NewMultiRewardIndex(claim.DepositDenom, v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex("hard", sdk.ZeroDec())})}
}
newClaim = v0_14incentive.NewHardLiquidityProviderClaim(claim.Owner, sdk.NewCoins(claim.Amount), supplyIndexes, borrowIndexes, delegatorIndexes)
} else {
newClaim.Reward = newClaim.Reward.Add(claim.Amount)
if claim.Type == v0_11hard.Stake {
newClaim.DelegatorRewardIndexes = v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex(claim.DepositDenom, sdk.ZeroDec())}
}
if claim.Type == v0_11hard.LP {
_, found := newClaim.SupplyRewardIndexes.GetRewardIndex(claim.DepositDenom)
if !found {
newClaim.SupplyRewardIndexes = append(newClaim.SupplyRewardIndexes, v0_14incentive.NewMultiRewardIndex(claim.DepositDenom, v0_14incentive.RewardIndexes{v0_14incentive.NewRewardIndex("hard", sdk.ZeroDec())}))
}
}
}
hardClaimMap[claim.Owner.String()] = newClaim
}
for _, claim := range hardClaimMap {
hardClaims = append(hardClaims, claim)
}
sort.Slice(hardClaims, func(i, j int) bool { return hardClaims[i].Owner.String() < hardClaims[j].Owner.String() })
sort.Slice(usdxClaims, func(i, j int) bool { return usdxClaims[i].Owner.String() < usdxClaims[j].Owner.String() })
return v0_14incentive.NewGenesisState(
params,
usdxGenAccumulationTimes,
hardSupplyGenAccumulationTimes,
hardBorrowGenAccumulationTimes,
hardDelegatorGenAccumulationTimes,
usdxClaims,
hardClaims,
)
}
// Auth migrates from a v0.11 auth genesis state to a v0.13
func Auth(genesisState auth.GenesisState) auth.GenesisState {
validatorVestingChangeAddress, err := sdk.AccAddressFromBech32("kava1a3qmze57knfj29a5knqs5ptewh76v4fg23xsvn")
if err != nil {
panic(err)
}
validatorVestingUpdatedValAddress, err := sdk.ConsAddressFromBech32("kavavalcons1ucxhn6zh7y2zun49m36psjffrhmux7ukqxdcte")
if err != nil {
panic(err)
}
savingsRateMaccCoins := sdk.NewCoins()
savingsMaccAddr := supply.NewModuleAddress(v0_11cdp.SavingsRateMacc)
savingsRateMaccIndex := 0
liquidatorMaccIndex := 0
// moves hard distributions from hard module account to kavadist module account
hardDelegatorAddr := supply.NewModuleAddress(v0_11hard.DelegatorAccount)
hardDelegatorIdx := 0
hardDelegatorCoins := sdk.NewCoins()
hardLPAddr := supply.NewModuleAddress(v0_11hard.LPAccount)
hardLPIdx := 0
hardLPCoins := sdk.NewCoins()
harvestAddr := supply.NewModuleAddress(v0_11hard.ModuleAccountName)
harvestIdx := 0
kavaDistAddr := supply.NewModuleAddress(kavadist.KavaDistMacc)
kavaDistIdx := 0
for idx, acc := range genesisState.Accounts {
// reset validator vesting missed blocks to zero (due to ongoing network issues in kava-4)
vvacc, ok := acc.(*validatorvesting.ValidatorVestingAccount)
if ok {
vvacc.CurrentPeriodProgress.MissedBlocks = 0
if vvacc.GetAddress().Equals(validatorVestingChangeAddress) {
// update validator vesting validator address for shiprekt
vvacc.ValidatorAddress = validatorVestingUpdatedValAddress
}
}
if acc.GetAddress().Equals(savingsMaccAddr) {
savingsRateMaccCoins = acc.GetCoins()
savingsRateMaccIndex = idx
err := acc.SetCoins(acc.GetCoins().Sub(acc.GetCoins()))
if err != nil {
panic(err)
}
}
if acc.GetAddress().Equals(supply.NewModuleAddress(v0_14cdp.LiquidatorMacc)) {
liquidatorMaccIndex = idx
}
if acc.GetAddress().Equals(hardDelegatorAddr) {
hardDelegatorIdx = idx
hardDelegatorCoins = acc.GetCoins()
}
if acc.GetAddress().Equals(hardLPAddr) {
hardLPIdx = idx
hardLPCoins = acc.GetCoins()
}
if acc.GetAddress().Equals(kavaDistAddr) {
kavaDistIdx = idx
}
if acc.GetAddress().Equals(harvestAddr) {
harvestIdx = idx
}
}
// move remaining cdp savings to liquidator account
liquidatorAcc := genesisState.Accounts[liquidatorMaccIndex]
err = liquidatorAcc.SetCoins(liquidatorAcc.GetCoins().Add(savingsRateMaccCoins...))
if err != nil {
panic(err)
}
genesisState.Accounts[liquidatorMaccIndex] = liquidatorAcc
// migrate harvest account to new hard name
harvestAcc := genesisState.Accounts[harvestIdx].(*supply.ModuleAccount)
harvestAcc.Address = supply.NewModuleAddress(v0_14hard.ModuleAccountName)
harvestAcc.Name = v0_14hard.ModuleAccountName
harvestAcc.Permissions = []string{supply.Minter}
genesisState.Accounts[harvestIdx] = harvestAcc
// add hard module accounts to kavadist
kavaDistAcc := genesisState.Accounts[kavaDistIdx]
err = kavaDistAcc.SetCoins(kavaDistAcc.GetCoins().Add(hardDelegatorCoins...).Add(hardLPCoins...))
if err != nil {
panic(err)
}
genesisState.Accounts[kavaDistIdx] = kavaDistAcc
// reverse sort indexes of accounts to remove so that re-numbering is irrelevant
indexesToRemove := []int{savingsRateMaccIndex, hardDelegatorIdx, hardLPIdx}
sort.Slice(indexesToRemove, func(i, j int) bool { return indexesToRemove[i] > indexesToRemove[j] })
// delete hard delegator, hard lp, and savings rate module accounts
for _, idx := range indexesToRemove {
genesisState.Accounts = removeIndex(genesisState.Accounts, idx)
}
return genesisState
}
// Bep3 migrates a v0.11 bep3 genesis state to a v0.13 genesis state
func Bep3(genesisState bep3.GenesisState) bep3.GenesisState {
var newSupplies bep3.AssetSupplies
for _, supply := range genesisState.Supplies {
if supply.GetDenom() == "bnb" {
supply.CurrentSupply = supply.CurrentSupply.Sub(sdk.NewCoin("bnb", sdk.NewInt(1000000000000)))
}
newSupplies = append(newSupplies, supply)
}
var newSwaps bep3.AtomicSwaps
for _, swap := range genesisState.AtomicSwaps {
if swap.Status == bep3.Completed {
swap.ClosedBlock = 1 // reset closed block to one so completed swaps are removed from long term storage properly
}
if swap.Status == bep3.Open || swap.Status == bep3.Expired {
swap.Status = bep3.Expired // set open swaps to expired so they can be refunded after chain start
swap.ExpireHeight = 1 // set expire on first block as well to be safe
}
newSwaps = append(newSwaps, swap)
}
var newAssetParams bep3.AssetParams
for _, ap := range genesisState.Params.AssetParams {
ap.MinBlockLock = uint64(24686)
ap.MaxBlockLock = uint64(86400)
newAssetParams = append(newAssetParams, ap)
}
newParams := bep3.NewParams(newAssetParams)
return bep3.NewGenesisState(newParams, newSwaps, newSupplies, genesisState.PreviousBlockTime)
}
// Committee migrates from a v0.11 (or v0.12) committee genesis state to a v0.13 committee genesis state
func Committee(genesisState v0_11committee.GenesisState) v0_14committee.GenesisState {
committees := []v0_14committee.Committee{}
votes := []v0_14committee.Vote{}
proposals := []v0_14committee.Proposal{}
var newStabilityCommittee v0_14committee.Committee
var newSafetyCommittee v0_14committee.Committee
for _, com := range genesisState.Committees {
if com.ID == 1 {
newStabilityCommittee.Description = com.Description
newStabilityCommittee.ID = com.ID
newStabilityCommittee.Members = com.Members
newStabilityCommittee.VoteThreshold = com.VoteThreshold
newStabilityCommittee.ProposalDuration = com.ProposalDuration
var newStabilityCommitteePermissions []v0_14committee.Permission
var newStabilitySubParamPermissions v0_14committee.SubParamChangePermission
for _, perm := range com.Permissions {
subPerm, ok := perm.(v0_11committee.SubParamChangePermission)
if ok {
// update AllowedParams
var newAllowedParams v0_14committee.AllowedParams
for _, ap := range subPerm.AllowedParams {
if ap.Subspace == "harvest" {
continue
}
newAP := v0_14committee.AllowedParam(ap)
newAllowedParams = append(newAllowedParams, newAP)
}
hrdaMMAp := v0_14committee.AllowedParam{Subspace: "hard", Key: "MoneyMarkets"}
hardLimitAp := v0_14committee.AllowedParam{Subspace: "hard", Key: "MinimumBorrowUSDValue"}
newAllowedParams = append(newAllowedParams, hrdaMMAp)
newAllowedParams = append(newAllowedParams, hardLimitAp)
newStabilitySubParamPermissions.AllowedParams = newAllowedParams
// update AllowedCollateralParams
var newCollateralParams v0_14committee.AllowedCollateralParams
collateralTypes := []string{"bnb-a", "busd-a", "busd-b", "btcb-a", "xrpb-a", "ukava-a", "hard-a", "hbtc-a"}
for _, cp := range subPerm.AllowedCollateralParams {
newCP := v0_14committee.NewAllowedCollateralParam(
cp.Type,
cp.Denom,
cp.LiquidationRatio,
cp.DebtLimit,
cp.StabilityFee,
cp.AuctionSize,
cp.LiquidationPenalty,
cp.Prefix,
cp.SpotMarketID,
cp.LiquidationMarketID,
cp.ConversionFactor,
true,
true,
)
newCollateralParams = append(newCollateralParams, newCP)
}
for _, cType := range collateralTypes {
var foundCtype bool
for _, cp := range newCollateralParams {
if cType == cp.Type {
foundCtype = true
}
}
if !foundCtype {
newCP := v0_14committee.NewAllowedCollateralParam(cType, false, false, true, true, true, false, false, false, false, false, true, true)
newCollateralParams = append(newCollateralParams, newCP)
}
}
newStabilitySubParamPermissions.AllowedCollateralParams = newCollateralParams
// update AllowedDebtParam
newDP := v0_14committee.AllowedDebtParam{
Denom: subPerm.AllowedDebtParam.Denom,
ReferenceAsset: subPerm.AllowedDebtParam.ReferenceAsset,
ConversionFactor: subPerm.AllowedDebtParam.ConversionFactor,
DebtFloor: subPerm.AllowedDebtParam.DebtFloor,
}
newStabilitySubParamPermissions.AllowedDebtParam = newDP
// update AllowedAssetParams
var newAssetParams v0_14committee.AllowedAssetParams
for _, ap := range subPerm.AllowedAssetParams {
newAP := v0_14committee.AllowedAssetParam(ap)
newAssetParams = append(newAssetParams, newAP)
}
newStabilitySubParamPermissions.AllowedAssetParams = newAssetParams
// Update Allowed Markets
var newMarketParams v0_14committee.AllowedMarkets
for _, mp := range subPerm.AllowedMarkets {
newMP := v0_14committee.AllowedMarket(mp)
newMarketParams = append(newMarketParams, newMP)
}
newStabilitySubParamPermissions.AllowedMarkets = newMarketParams
// Add hard money market committee permissions
var newMoneyMarketParams v0_14committee.AllowedMoneyMarkets
hardMMDenoms := []string{"bnb", "busd", "btcb", "xrpb", "usdx", "ukava", "hard"}
for _, mmDenom := range hardMMDenoms {
newMoneyMarketParam := v0_14committee.NewAllowedMoneyMarket(mmDenom, true, false, false, true, true, true)
newMoneyMarketParams = append(newMoneyMarketParams, newMoneyMarketParam)
}
newStabilitySubParamPermissions.AllowedMoneyMarkets = newMoneyMarketParams
newStabilityCommitteePermissions = append(newStabilityCommitteePermissions, newStabilitySubParamPermissions)
}
}
newStabilityCommitteePermissions = append(newStabilityCommitteePermissions, v0_14committee.TextPermission{})
newStabilityCommittee.Permissions = newStabilityCommitteePermissions
committees = append(committees, newStabilityCommittee)
} else {
newSafetyCommittee.ID = com.ID
newSafetyCommittee.Description = com.Description
newSafetyCommittee.Members = com.Members
newSafetyCommittee.Permissions = []v0_14committee.Permission{v0_14committee.SoftwareUpgradePermission{}}
newSafetyCommittee.VoteThreshold = com.VoteThreshold
newSafetyCommittee.ProposalDuration = com.ProposalDuration
committees = append(committees, newSafetyCommittee)
}
}
for _, v := range genesisState.Votes {
votes = append(votes, v0_14committee.Vote(v))
}
for _, p := range genesisState.Proposals {
newPubProp := v0_14committee.PubProposal(p.PubProposal)
newProp := v0_14committee.NewProposal(newPubProp, p.ID, p.CommitteeID, p.Deadline)
proposals = append(proposals, newProp)
}
return v0_14committee.NewGenesisState(
genesisState.NextProposalID, committees, proposals, votes)
}
// Pricefeed migrates from a v0.11 (or v0.12) pricefeed genesis state to a v0.13 pricefeed genesis state
func Pricefeed(genesisState v0_11pricefeed.GenesisState) v0_14pricefeed.GenesisState {
newMarkets := v0_14pricefeed.Markets{}
oracles := genesisState.Params.Markets[0].Oracles
for _, m := range genesisState.Params.Markets {
newMarkets = append(newMarkets, m)
}
usdx := v0_11pricefeed.NewMarket("usdx:usd", "usdx", "usd", oracles, true)
newMarkets = append(newMarkets, usdx)
newPrices := v0_14pricefeed.PostedPrices{}
for _, p := range genesisState.PostedPrices {
if p.Expiry.After(GenesisTime) {
newPrices = append(newPrices, p)
}
}
return v0_14pricefeed.NewGenesisState(v0_14pricefeed.NewParams(newMarkets), newPrices)
}
func removeIndex(accs authexported.GenesisAccounts, index int) authexported.GenesisAccounts {
ret := make(authexported.GenesisAccounts, 0)
ret = append(ret, accs[:index]...)
newAccounts := append(ret, accs[index+1:]...)
return newAccounts
}