package v0_15 import ( "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/auth/vesting" "github.com/cosmos/cosmos-sdk/x/genutil" v0_15staking "github.com/cosmos/cosmos-sdk/x/staking/types" "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" v0_15bep3 "github.com/kava-labs/kava/x/bep3/types" v0_15cdp "github.com/kava-labs/kava/x/cdp/types" v0_14committee "github.com/kava-labs/kava/x/committee/legacy/v0_14" v0_15committee "github.com/kava-labs/kava/x/committee/types" v0_15hard "github.com/kava-labs/kava/x/hard/types" v0_14incentive "github.com/kava-labs/kava/x/incentive/legacy/v0_14" v0_15incentive "github.com/kava-labs/kava/x/incentive/types" "github.com/kava-labs/kava/x/kavadist" v0_15swap "github.com/kava-labs/kava/x/swap/types" v0_14validator_vesting "github.com/kava-labs/kava/x/validator-vesting" ) var ( GenesisTime = time.Date(2021, 8, 30, 15, 0, 0, 0, time.UTC) ChainID = "kava-8" SwpDelegatorRewardsPerSecond = sdk.NewCoin("swp", sdk.NewInt(198186)) SwpTotalSupply = sdk.NewCoin("swp", sdk.NewInt(250000000e6)) ) // Migrate translates a genesis file from kava v0.14 format to kava v0.15 format func Migrate(genDoc tmtypes.GenesisDoc) tmtypes.GenesisDoc { // migrate app state var appStateMap genutil.AppMap cdc := codec.New() cryptoAmino.RegisterAmino(cdc) tmtypes.RegisterEvidences(cdc) // Old codec does not need all old modules registered on it to correctly decode at this stage // as it only decodes the app state into a map of module names to json encoded bytes. if err := cdc.UnmarshalJSON(genDoc.AppState, &appStateMap); err != nil { panic(err) } MigrateAppState(appStateMap) v0_15Codec := app.MakeCodec() marshaledNewAppState, err := v0_15Codec.MarshalJSON(appStateMap) if err != nil { panic(err) } genDoc.AppState = marshaledNewAppState genDoc.GenesisTime = GenesisTime genDoc.ChainID = ChainID return genDoc } // MigrateAppState migrates application state from v0.14 format to a kava v0.15 format // It modifies the provided genesis state in place. func MigrateAppState(v0_14AppState genutil.AppMap) { v0_14Codec := makeV014Codec() v0_15Codec := app.MakeCodec() // Migrate auth app state if v0_14AppState[auth.ModuleName] != nil { var authGenState auth.GenesisState v0_14Codec.MustUnmarshalJSON(v0_14AppState[auth.ModuleName], &authGenState) delete(v0_14AppState, auth.ModuleName) v0_14AppState[auth.ModuleName] = v0_15Codec.MustMarshalJSON(Auth(v0_15Codec, authGenState, GenesisTime)) } // Migrate supply app state if v0_14AppState[supply.ModuleName] != nil { var supplyGenState supply.GenesisState v0_14Codec.MustUnmarshalJSON(v0_14AppState[supply.ModuleName], &supplyGenState) delete(v0_14AppState, supply.ModuleName) v0_14AppState[supply.ModuleName] = v0_15Codec.MustMarshalJSON(Supply(supplyGenState, SwpTotalSupply)) } // Migrate incentive app state if v0_14AppState[v0_14incentive.ModuleName] != nil { var incentiveGenState v0_14incentive.GenesisState v0_14Codec.MustUnmarshalJSON(v0_14AppState[v0_14incentive.ModuleName], &incentiveGenState) delete(v0_14AppState, v0_14incentive.ModuleName) var stakingGenState v0_15staking.GenesisState // staking unchanged between v0_14 and v0_15 v0_14Codec.MustUnmarshalJSON(v0_14AppState[v0_15staking.ModuleName], &stakingGenState) var hardGenState v0_15hard.GenesisState // v0_14 hard genesis state is the same as v0_15 v0_15Codec.MustUnmarshalJSON(v0_14AppState[v0_15hard.ModuleName], &hardGenState) // unmarshal all cdps using v0_15 types as there has been no changes since v0_14 var cdpGenState v0_15cdp.GenesisState v0_15Codec.MustUnmarshalJSON(v0_14AppState[v0_15cdp.ModuleName], &cdpGenState) v0_14AppState[v0_15incentive.ModuleName] = v0_15Codec.MustMarshalJSON( Incentive(v0_15Codec, incentiveGenState, cdpGenState.CDPs, hardGenState, stakingGenState.Delegations), ) } // Migrate commmittee app state if v0_14AppState[v0_14committee.ModuleName] != nil { // Unmarshal v14 committee genesis state and delete it var committeeGS v0_14committee.GenesisState v0_14Codec.MustUnmarshalJSON(v0_14AppState[v0_14committee.ModuleName], &committeeGS) delete(v0_14AppState, v0_14committee.ModuleName) // Marshal v15 committee genesis state v0_14AppState[v0_15committee.ModuleName] = v0_15Codec.MustMarshalJSON(Committee(committeeGS)) } // Migrate bep3 app state if v0_14AppState[v0_15bep3.ModuleName] != nil { // Unmarshal genesis state and delete it. The genesis format was not changed between v0.14 and v0.15. var bep3GenState v0_15bep3.GenesisState v0_14Codec.MustUnmarshalJSON(v0_14AppState[v0_15bep3.ModuleName], &bep3GenState) delete(v0_14AppState, v0_15bep3.ModuleName) v0_14AppState[v0_15bep3.ModuleName] = v0_15Codec.MustMarshalJSON(Bep3(bep3GenState)) } v0_14AppState[v0_15swap.ModuleName] = v0_15Codec.MustMarshalJSON(Swap()) } func makeV014Codec() *codec.Codec { cdc := codec.New() sdk.RegisterCodec(cdc) cryptoAmino.RegisterAmino(cdc) auth.RegisterCodec(cdc) supply.RegisterCodec(cdc) vesting.RegisterCodec(cdc) v0_14validator_vesting.RegisterCodec(cdc) v0_14committee.RegisterCodec(cdc) v0_14incentive.RegisterCodec(cdc) // TODO bep3? return cdc } // Auth migrates the auth genesis state to a new state with pruned vesting periods func Auth(cdc *codec.Codec, genesisState auth.GenesisState, genesisTime time.Time) auth.GenesisState { genesisStateWithAccountsMigrated := MigrateAccounts(genesisState, genesisTime) genesisStateWithSwpAirdrop := ApplySwpAirdrop(cdc, genesisStateWithAccountsMigrated) genesisStateWithSwpDistribution := DistributeSwpTokens(genesisStateWithSwpAirdrop) return genesisStateWithSwpDistribution } // ApplySwpAirdrop airdrops 1,000,000 SWP tokens to USDX depositors to HARD at block 1543671 func ApplySwpAirdrop(cdc *codec.Codec, genesisState auth.GenesisState) auth.GenesisState { accounts := make([]authexported.GenesisAccount, len(genesisState.Accounts)) migratedGenesisState := auth.NewGenesisState(genesisState.Params, accounts) var swpAirdrop map[string]sdk.Coin cdc.MustUnmarshalJSON([]byte(swpAirdropMap), &swpAirdrop) for i, acc := range genesisState.Accounts { if swpReward, ok := swpAirdrop[acc.GetAddress().String()]; ok { err := acc.SetCoins(acc.GetCoins().Add(swpReward)) if err != nil { panic(err) } } accounts[i] = authexported.GenesisAccount(acc) } return migratedGenesisState } // MigrateAccounts removes expired vesting periods from account state func MigrateAccounts(genesisState auth.GenesisState, genesisTime time.Time) auth.GenesisState { accounts := make([]authexported.GenesisAccount, len(genesisState.Accounts)) migratedGenesisState := auth.NewGenesisState(genesisState.Params, accounts) for i, acc := range genesisState.Accounts { migratedAcc := MigrateAccount(acc, genesisTime) accounts[i] = authexported.GenesisAccount(migratedAcc) } return migratedGenesisState } // global variables for swp distribution var ( SwpEcoSystemAddr = mustAccAddressFromBech32("kava174crgzk006lj39s258gjxkh0p9tmmq8ugdcg0n") SwpTreasuryAddr = mustAccAddressFromBech32("kava1w56wrusdnrv4tvn86eyam65wwhqatmsqg9fxjm") SwpTeamAddr = mustAccAddressFromBech32("kava129eqnykzkc5ceyq9sv7ltxev22y8qwm94kr0ew") KavaDistAddr = supply.NewModuleAddress(kavadist.KavaDistMacc) SwpTreasuryCoins = sdk.NewCoin("swp", sdk.NewInt(62500000000000)) SwpTreasuryOriginalVesting = sdk.NewCoin("swp", sdk.NewInt(46875000000000)) KavaDistCoins = sdk.NewCoin("swp", sdk.NewInt(137500000e6)) EcoSystemCoins = sdk.NewCoin("swp", sdk.NewInt(11500000000000)) SwpTeamCoins = sdk.NewCoin("swp", sdk.NewInt(37500000000000)) ) // DistributeSwpTokens sets the initial distribution of swp tokens according to the proposed token supply schedule in prop 59 func DistributeSwpTokens(genesisState auth.GenesisState) auth.GenesisState { // add SWP incentives (LP, Kava stakers) to kavadist module account accounts := make([]authexported.GenesisAccount, len(genesisState.Accounts)) for i, acc := range genesisState.Accounts { if acc.GetAddress().Equals(KavaDistAddr) { err := acc.SetCoins(acc.GetCoins().Add(KavaDistCoins)) if err != nil { panic(err) } } accounts[i] = authexported.GenesisAccount(acc) } // Add ecosystem account swpEcosystemBacc := auth.NewBaseAccountWithAddress(SwpEcoSystemAddr) // 11.5M because 1M has already been airdropped err := swpEcosystemBacc.SetCoins(sdk.NewCoins(EcoSystemCoins)) if err != nil { panic(err) } // Add team vesting account swpTeamBacc := auth.NewBaseAccountWithAddress(SwpTeamAddr) err = swpTeamBacc.SetCoins(sdk.NewCoins(SwpTeamCoins)) if err != nil { panic(err) } swpTeamBva, err := vesting.NewBaseVestingAccount(&swpTeamBacc, sdk.NewCoins(SwpTeamCoins), 1693407600) if err != nil { panic(err) } swpTeamTokenSchedule := []sdk.Coin{ sdk.NewCoin("swp", sdk.NewInt(18750000000000)), sdk.NewCoin("swp", sdk.NewInt(4687500000000)), sdk.NewCoin("swp", sdk.NewInt(4687500000000)), sdk.NewCoin("swp", sdk.NewInt(4687500000000)), sdk.NewCoin("swp", sdk.NewInt(4687500000000)), } swpTeamVestingLengths := []int64{31536000, 7948800, 7776000, 7948800, 7862400} swpTeamVestingPeriods := vesting.Periods{} for i, vestingCoin := range swpTeamTokenSchedule { period := vesting.Period{Length: swpTeamVestingLengths[i], Amount: sdk.NewCoins(vestingCoin)} swpTeamVestingPeriods = append(swpTeamVestingPeriods, period) } swpTeamVestingAccount := vesting.NewPeriodicVestingAccountRaw(swpTeamBva, GenesisTime.Unix(), swpTeamVestingPeriods) // Add treasury vesting account swpTreasuryBacc := auth.NewBaseAccountWithAddress(SwpTreasuryAddr) err = swpTreasuryBacc.SetCoins(sdk.NewCoins(SwpTreasuryCoins)) if err != nil { panic(err) } swpTreasuryBva, err := vesting.NewBaseVestingAccount(&swpTreasuryBacc, sdk.NewCoins(SwpTreasuryOriginalVesting), 1693407600) if err != nil { panic(err) } swpTreasuryTokenSchedule := []sdk.Coin{ sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), sdk.NewCoin("swp", sdk.NewInt(5859375e6)), } swpTreasuryVestingLengths := []int64{7948800, 7776000, 7948800, 7862400, 7948800, 7776000, 7948800, 7862400} swpTreasuryVestingPeriods := vesting.Periods{} for i, vestingCoin := range swpTreasuryTokenSchedule { period := vesting.Period{Length: swpTreasuryVestingLengths[i], Amount: sdk.NewCoins(vestingCoin)} swpTreasuryVestingPeriods = append(swpTreasuryVestingPeriods, period) } swpTreasuryVestingAccount := vesting.NewPeriodicVestingAccountRaw(swpTreasuryBva, GenesisTime.Unix(), swpTreasuryVestingPeriods) accounts = append(accounts, &swpEcosystemBacc, swpTeamVestingAccount, swpTreasuryVestingAccount) return auth.NewGenesisState(genesisState.Params, accounts) } // Supply adds SWP token to total supply func Supply(supplyGenesisState supply.GenesisState, swpBalance sdk.Coin) supply.GenesisState { supplyGenesisState.Supply = supplyGenesisState.Supply.Add(swpBalance) return supplyGenesisState } // Committee migrates from a v0.14 committee genesis state to a v0.15 committee genesis state func Committee(genesisState v0_14committee.GenesisState) v0_15committee.GenesisState { committees := []v0_15committee.Committee{} votes := []v0_15committee.Vote{} proposals := []v0_15committee.Proposal{} for _, com := range genesisState.Committees { switch com.ID { case 1: // Initialize member committee without permissions stabilityCom := v0_15committee.NewMemberCommittee(com.ID, com.Description, com.Members, []v0_15committee.Permission{}, com.VoteThreshold, com.ProposalDuration, v0_15committee.FirstPastThePost) // Build stability committee permissions var newStabilityCommitteePermissions []v0_15committee.Permission var newStabilitySubParamPermissions v0_15committee.SubParamChangePermission for _, perm := range com.Permissions { subPerm, ok := perm.(v0_14committee.SubParamChangePermission) if ok { // update AllowedParams var newAllowedParams v0_15committee.AllowedParams for _, ap := range subPerm.AllowedParams { newAP := v0_15committee.AllowedParam(ap) newAllowedParams = append(newAllowedParams, newAP) } newStabilitySubParamPermissions.AllowedParams = newAllowedParams // update AllowedCollateralParams var newCollateralParams v0_15committee.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_15committee.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_15committee.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_15committee.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_15committee.AllowedAssetParams for _, ap := range subPerm.AllowedAssetParams { newAP := v0_15committee.AllowedAssetParam(ap) newAssetParams = append(newAssetParams, newAP) } newStabilitySubParamPermissions.AllowedAssetParams = newAssetParams // Update Allowed Markets var newMarketParams v0_15committee.AllowedMarkets for _, mp := range subPerm.AllowedMarkets { newMP := v0_15committee.AllowedMarket(mp) newMarketParams = append(newMarketParams, newMP) } newStabilitySubParamPermissions.AllowedMarkets = newMarketParams // Add hard money market committee permissions var newMoneyMarketParams v0_15committee.AllowedMoneyMarkets hardMMDenoms := []string{"bnb", "busd", "btcb", "xrpb", "usdx", "ukava", "hard"} for _, mmDenom := range hardMMDenoms { newMoneyMarketParam := v0_15committee.NewAllowedMoneyMarket(mmDenom, true, false, false, true, true, true) newMoneyMarketParams = append(newMoneyMarketParams, newMoneyMarketParam) } newStabilitySubParamPermissions.AllowedMoneyMarkets = newMoneyMarketParams newStabilityCommitteePermissions = append(newStabilityCommitteePermissions, newStabilitySubParamPermissions) } } newStabilityCommitteePermissions = append(newStabilityCommitteePermissions, v0_15committee.TextPermission{}) // Set stability committee permissions newStabilityCom := stabilityCom.SetPermissions(newStabilityCommitteePermissions) committees = append(committees, newStabilityCom) case 2: safetyCom := v0_15committee.NewMemberCommittee(com.ID, com.Description, com.Members, []v0_15committee.Permission{v0_15committee.SoftwareUpgradePermission{}}, com.VoteThreshold, com.ProposalDuration, v0_15committee.FirstPastThePost) committees = append(committees, safetyCom) } } stabilityComMembers, err := loadStabilityComMembers() if err != nil { panic(err) } // ---------------------------- Initialize hard governance committee ---------------------------- hardGovDuration := time.Duration(time.Hour * 24 * 7) hardGovThreshold := sdk.MustNewDecFromStr("0.5") // 50% hardGovQuorum := sdk.MustNewDecFromStr("0.1") // 10% hardGovCom := v0_15committee.NewTokenCommittee(3, "Hard Governance Committee", stabilityComMembers, []v0_15committee.Permission{}, hardGovThreshold, hardGovDuration, v0_15committee.Deadline, hardGovQuorum, "hard") // Add hard money market committee permissions var newHardCommitteePermissions []v0_15committee.Permission var newHardSubParamPermissions v0_15committee.SubParamChangePermission // Allowed params permissions hardComAllowedParams := v0_15committee.AllowedParams{ v0_15committee.AllowedParam{Subspace: "hard", Key: "MoneyMarkets"}, v0_15committee.AllowedParam{Subspace: "hard", Key: "MinimumBorrowUSDValue"}, v0_15committee.AllowedParam{Subspace: "incentive", Key: "HardSupplyRewardPeriods"}, v0_15committee.AllowedParam{Subspace: "incentive", Key: "HardBorrowRewardPeriods"}, v0_15committee.AllowedParam{Subspace: "incentive", Key: "DelegatorRewardPeriods"}, } newHardSubParamPermissions.AllowedParams = hardComAllowedParams // Money market permissions var newMoneyMarketParams v0_15committee.AllowedMoneyMarkets hardMMDenoms := []string{"bnb", "busd", "btcb", "xrpb", "usdx", "ukava", "hard"} for _, mmDenom := range hardMMDenoms { newMoneyMarketParam := v0_15committee.NewAllowedMoneyMarket(mmDenom, true, true, false, true, true, true) newMoneyMarketParams = append(newMoneyMarketParams, newMoneyMarketParam) } newHardSubParamPermissions.AllowedMoneyMarkets = newMoneyMarketParams newHardCommitteePermissions = append(newHardCommitteePermissions, newHardSubParamPermissions) // Text permissions newHardCommitteePermissions = append(newHardCommitteePermissions, v0_15committee.TextPermission{}) // Set hard governance committee permissions permissionedHardGovCom := hardGovCom.SetPermissions(newHardCommitteePermissions) committees = append(committees, permissionedHardGovCom) // ---------------------------- Initialize swp governance committee ---------------------------- swpGovDuration := time.Duration(time.Hour * 24 * 7) swpGovThreshold := sdk.MustNewDecFromStr("0.5") // 50% swpGovQuorum := sdk.MustNewDecFromStr("0.1") // 10% swpGovCom := v0_15committee.NewTokenCommittee(4, "Swp Governance Committee", stabilityComMembers, []v0_15committee.Permission{}, swpGovThreshold, swpGovDuration, v0_15committee.Deadline, swpGovQuorum, "swp") // Add swap committee permissions var newSwapCommitteePermissions []v0_15committee.Permission var newSwapSubParamPermissions v0_15committee.SubParamChangePermission // Allowed params permissions swpAllowedParams := v0_15committee.AllowedParams{ v0_15committee.AllowedParam{Subspace: "swap", Key: "AllowedPools"}, v0_15committee.AllowedParam{Subspace: "swap", Key: "SwapFee"}, v0_15committee.AllowedParam{Subspace: "incentive", Key: "DelegatorRewardPeriods"}, v0_15committee.AllowedParam{Subspace: "incentive", Key: "SwapRewardPeriods"}, } newSwapSubParamPermissions.AllowedParams = swpAllowedParams newSwpCommitteePermissions := append(newSwapCommitteePermissions, newSwapSubParamPermissions) // Text permissions newSwpCommitteePermissions = append(newSwpCommitteePermissions, v0_15committee.TextPermission{}) // Set swap governance committee permissions permissionedSwapGovCom := swpGovCom.SetPermissions(newSwpCommitteePermissions) committees = append(committees, permissionedSwapGovCom) for _, v := range genesisState.Votes { newVote := v0_15committee.NewVote(v.ProposalID, v.Voter, v0_15committee.Yes) votes = append(votes, v0_15committee.Vote(newVote)) } for _, p := range genesisState.Proposals { newPubProp := v0_15committee.PubProposal(p.PubProposal) newProp := v0_15committee.NewProposal(newPubProp, p.ID, p.CommitteeID, p.Deadline) proposals = append(proposals, newProp) } return v0_15committee.NewGenesisState( genesisState.NextProposalID, committees, proposals, votes) } func loadStabilityComMembers() ([]sdk.AccAddress, error) { strAddrs := []string{ "kava1gru35up50ql2wxhegr880qy6ynl63ujlv8gum2", "kava1sc3mh3pkas5e7xd269am4xm5mp6zweyzmhjagj", "kava1c9ye54e3pzwm3e0zpdlel6pnavrj9qqv6e8r4h", "kava1m7p6sjqrz6mylz776ct48wj6lpnpcd0z82209d", "kava1a9pmkzk570egv3sflu3uwdf3gejl7qfy9hghzl", } var addrs []sdk.AccAddress for _, strAddr := range strAddrs { addr, err := sdk.AccAddressFromBech32(strAddr) if err != nil { return addrs, err } addrs = append(addrs, addr) } return addrs, nil } // Swap introduces new v0.15 swap genesis state func Swap() v0_15swap.GenesisState { pools := v0_15swap.AllowedPools{ v0_15swap.NewAllowedPool("bnb", "usdx"), v0_15swap.NewAllowedPool("btcb", "usdx"), v0_15swap.NewAllowedPool("busd", "usdx"), v0_15swap.NewAllowedPool("hard", "usdx"), v0_15swap.NewAllowedPool("swp", "usdx"), v0_15swap.NewAllowedPool("ukava", "usdx"), v0_15swap.NewAllowedPool("usdx", "xrpb"), } fee := sdk.MustNewDecFromStr("0.0015") params := v0_15swap.NewParams(pools, fee) return v0_15swap.NewGenesisState(params, v0_15swap.DefaultPoolRecords, v0_15swap.DefaultShareRecords) } func mustAccAddressFromBech32(bech32Addr string) sdk.AccAddress { app.SetBech32AddressPrefixes(sdk.GetConfig()) addr, err := sdk.AccAddressFromBech32(bech32Addr) if err != nil { panic(err) } return addr }