package v0_15 import ( "fmt" "io/ioutil" "os" "path/filepath" "testing" "time" "github.com/cosmos/cosmos-sdk/codec" sdk "github.com/cosmos/cosmos-sdk/types" "github.com/cosmos/cosmos-sdk/x/auth" "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/stretchr/testify/assert" "github.com/stretchr/testify/require" tmtypes "github.com/tendermint/tendermint/types" "github.com/kava-labs/kava/app" 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/swap" ) func TestMain(m *testing.M) { config := sdk.GetConfig() app.SetBech32AddressPrefixes(config) app.SetBip44CoinType(config) os.Exit(m.Run()) } func TestCommittee(t *testing.T) { bz, err := ioutil.ReadFile(filepath.Join("testdata", "kava-7-committee-state.json")) require.NoError(t, err) var oldGenState v0_14committee.GenesisState cdc := codec.New() sdk.RegisterCodec(cdc) v0_14committee.RegisterCodec(cdc) require.NotPanics(t, func() { cdc.MustUnmarshalJSON(bz, &oldGenState) }) newGenState := Committee(oldGenState) err = newGenState.Validate() require.NoError(t, err) require.Equal(t, len(oldGenState.Committees)+2, len(newGenState.Committees)) // New gen state has 2 additional committees for i := 0; i < len(oldGenState.Committees); i++ { require.Equal(t, len(oldGenState.Committees[i].Permissions), len(newGenState.Committees[i].GetPermissions())) } oldSPCP := oldGenState.Committees[0].Permissions[0].(v0_14committee.SubParamChangePermission) newSPCP := newGenState.Committees[0].GetPermissions()[0].(v0_15committee.SubParamChangePermission) require.Equal(t, len(oldSPCP.AllowedParams), len(newSPCP.AllowedParams)) require.Equal(t, len(oldSPCP.AllowedAssetParams), len(newSPCP.AllowedAssetParams)) require.Equal(t, len(oldSPCP.AllowedCollateralParams), len(newSPCP.AllowedCollateralParams)) require.Equal(t, len(oldSPCP.AllowedMarkets), len(newSPCP.AllowedMarkets)) require.Equal(t, len(oldSPCP.AllowedMoneyMarkets), len(newSPCP.AllowedMoneyMarkets)) } func TestIncentive_Full(t *testing.T) { t.Skip() // skip to avoid having to commit a large genesis file to the repo genDoc, err := tmtypes.GenesisDocFromFile(filepath.Join("testdata", "genesis.json")) require.NoError(t, err) cdc := makeV014Codec() var oldState genutil.AppMap cdc.MustUnmarshalJSON(genDoc.AppState, &oldState) var oldIncentiveGenState v0_14incentive.GenesisState cdc.MustUnmarshalJSON(oldState[v0_14incentive.ModuleName], &oldIncentiveGenState) var oldHardGenState v0_15hard.GenesisState cdc.MustUnmarshalJSON(oldState[v0_15hard.ModuleName], &oldHardGenState) var oldStakingGenState v0_15staking.GenesisState cdc.MustUnmarshalJSON(oldState[v0_15staking.ModuleName], &oldStakingGenState) var oldCDPGenState v0_15cdp.GenesisState cdc.MustUnmarshalJSON(oldState[v0_15cdp.ModuleName], &oldCDPGenState) newGenState := Incentive(app.MakeCodec(), oldIncentiveGenState, oldCDPGenState.CDPs, oldHardGenState, oldStakingGenState.Delegations) require.NoError(t, newGenState.Validate()) // TODO check params, indexes, and accumulation times // ensure every hard deposit has a claim with correct indexes for _, deposit := range oldHardGenState.Deposits { foundClaim := false for _, claim := range newGenState.HardLiquidityProviderClaims { if claim.Owner.Equals(deposit.Depositor) { foundClaim = true // check indexes are valid err := collateralTypesMatch(deposit.Amount, claim.SupplyRewardIndexes) require.NoErrorf(t, err, "invalid claim %s, %s", claim, deposit) break } } require.True(t, foundClaim, "missing claim for hard deposit") // also ensure hard deposit indexes are valid for _, i := range deposit.Index { require.Truef(t, i.Value.GTE(sdk.OneDec()), "found invalid hard deposit index %s", deposit) } } // ensure every hard borrow has a claim with correct indexes for _, borrow := range oldHardGenState.Borrows { foundClaim := false for _, claim := range newGenState.HardLiquidityProviderClaims { if claim.Owner.Equals(borrow.Borrower) { foundClaim = true // check indexes are valid err := collateralTypesMatch(borrow.Amount, claim.BorrowRewardIndexes) require.NoErrorf(t, err, "invalid claim %s, %s", claim, borrow) break } } require.True(t, foundClaim, "missing claim for hard borrow") // also ensure hard borrow indexes are valid for _, i := range borrow.Index { require.Truef(t, i.Value.GTE(sdk.OneDec()), "found invalid hard borrow index %s", borrow) } } // ensure all claim indexes are ≤ global values for _, claim := range newGenState.HardLiquidityProviderClaims { for _, ri := range claim.BorrowRewardIndexes { global, found := newGenState.HardBorrowRewardState.MultiRewardIndexes.Get(ri.CollateralType) if !found { global = v0_15incentive.RewardIndexes{} } require.Truef(t, indexesAllLessThanOrEqual(ri.RewardIndexes, global), "invalid claim supply indexes %s %s", ri.RewardIndexes, global) } for _, ri := range claim.SupplyRewardIndexes { global, found := newGenState.HardSupplyRewardState.MultiRewardIndexes.Get(ri.CollateralType) if !found { global = v0_15incentive.RewardIndexes{} } require.Truef(t, indexesAllLessThanOrEqual(ri.RewardIndexes, global), "invalid claim borrow indexes %s %s", ri.RewardIndexes, global) } } // ensure (synced) reward amounts are unchanged for _, claim := range newGenState.HardLiquidityProviderClaims { for _, oldClaim := range oldIncentiveGenState.HardLiquidityProviderClaims { if oldClaim.Owner.Equals(claim.Owner) { require.Equal(t, claim.Reward, oldClaim.Reward) } } } // Ensure the usdx claim indexes match global globalIndexes := newGenState.USDXRewardState.MultiRewardIndexes for _, claim := range newGenState.USDXMintingClaims { for _, globalIndex := range globalIndexes { expectedFactor, found := globalIndex.RewardIndexes.Get(v0_15incentive.USDXMintingRewardDenom) require.True(t, found) factor, found := claim.RewardIndexes.Get(globalIndex.CollateralType) require.True(t, found) require.Equal(t, expectedFactor, factor) } } // Ensure there is a usdx claim for every cdp for _, cdp := range oldCDPGenState.CDPs { numClaims := 0 for _, claim := range newGenState.USDXMintingClaims { if cdp.Owner.Equals(claim.Owner) { numClaims++ } } require.Equal(t, 1, numClaims, "cdp '%s' has invalid number of claims '%d'", cdp.Owner, numClaims) // also check cdp indexes are valid require.True(t, cdp.InterestFactor.GTE(sdk.OneDec()), "found cdp with interest factor < 1") } // Check reward amounts for _, claim := range newGenState.USDXMintingClaims { // check a few high value accounts switch claim.Owner.String() { // check reward is: additional reward + existing unclaimed reward // note, non zero unclaimed rewards could change if the user submits a claim tx before launch case "kava1k8lymw58tduy9gm6jkt04ddkjd83nf7sm8xthl": require.Equal(t, sdk.NewInt(370982556999+0), claim.Reward.Amount) case "kava1p3ucd3ptpw902fluyjzhq3ffgq4ntddaysyq8h": require.Equal(t, sdk.NewInt(77550672285+16960713469), claim.Reward.Amount) case "kava1qe6ahdnhnfugle29054d8uqg7fa44ryx934yc6": require.Equal(t, sdk.NewInt(40874651319+0), claim.Reward.Amount) case "kava12h6pq2xqzgtxttrzg7q2rplsyxtv2dc5gwh8rl": require.Equal(t, sdk.NewInt(30867752254+0), claim.Reward.Amount) case "kava10hczxv0p3eadcwgt5u79yhahsyuw98u26qan50": require.Equal(t, sdk.NewInt(22429344254+0), claim.Reward.Amount) case "kava15wyjwhj6zh79m7adm69pwl3nsq9z8gs9ezs4k7": require.Equal(t, sdk.NewInt(10252596901+0), claim.Reward.Amount) case "kava1yg4840l77dfs5zqflldhut27en2mhvvc8vj93x": require.Equal(t, sdk.NewInt(9898765520+0), claim.Reward.Amount) case "kava1x242qk6jf2rv23ruvk6fmxp97gg2y75a9r2caq": require.Equal(t, sdk.NewInt(7761701231+0), claim.Reward.Amount) case "kava1tstf3u4cw7u4xyu7wxdrnmrpvvmfamq3twcj7f": require.Equal(t, sdk.NewInt(2466900572+0), claim.Reward.Amount) } // check no rewards have been reduced for _, oldClaim := range oldIncentiveGenState.USDXMintingClaims { if oldClaim.Owner.Equals(claim.Owner) { require.Truef(t, claim.Reward.IsGTE(oldClaim.Reward), "found claim with reduced rewards, old %s, new %s", oldClaim, claim) } } } // Ensure every delegation has a claim for _, delegation := range oldStakingGenState.Delegations { numClaims := 0 for _, claim := range newGenState.DelegatorClaims { if delegation.DelegatorAddress.Equals(claim.Owner) { numClaims++ } } require.Equal(t, 1, numClaims, "delegation '%s' has invalid number of claims '%d'", delegation.DelegatorAddress, numClaims) } // Ensure all delegation indexes are ≤ global values for _, claim := range newGenState.DelegatorClaims { for _, ri := range claim.RewardIndexes { require.Equal(t, v0_15incentive.BondDenom, ri.CollateralType) global, found := newGenState.DelegatorRewardState.MultiRewardIndexes.Get(ri.CollateralType) if !found { global = v0_15incentive.RewardIndexes{} } require.Truef(t, indexesAllLessThanOrEqual(ri.RewardIndexes, global), "invalid delegator claim indexes %s %s", ri.RewardIndexes, global) } } // Ensure delegator rewards are all initialized at 0 for _, claim := range newGenState.DelegatorClaims { require.Equal(t, sdk.NewCoins(), claim.Reward) } } // collateralTypesMatch checks if the set of coin denoms is equal to the set of CollateralTypes in the indexes. func collateralTypesMatch(coins sdk.Coins, indexes v0_15incentive.MultiRewardIndexes) error { for _, index := range indexes { if coins.AmountOf(index.CollateralType).Equal(sdk.ZeroInt()) { return fmt.Errorf("index contains denom not found in coins") } } for _, coin := range coins { _, found := indexes.Get(coin.Denom) if !found { return fmt.Errorf("coins contain denom not found in indexes") } } return nil } // indexesAllLessThanOrEqual computes if all factors in A are ≤ factors in B. // Missing indexes are taken to be zero. func indexesAllLessThanOrEqual(indexesA, indexesB v0_15incentive.RewardIndexes) bool { allLT := true for _, ri := range indexesA { factor, found := indexesB.Get(ri.CollateralType) if !found { // value not found is same as it being zero factor = sdk.ZeroDec() } allLT = allLT && ri.RewardFactor.LTE(factor) } return allLT } func TestIncentive_Full_TotalRewards(t *testing.T) { t.Skip() // skip to avoid having to commit a large genesis file to the repo genDoc, err := tmtypes.GenesisDocFromFile(filepath.Join("testdata", "genesis.json")) require.NoError(t, err) cdc := makeV014Codec() var oldState genutil.AppMap cdc.MustUnmarshalJSON(genDoc.AppState, &oldState) var oldIncentiveGenState v0_14incentive.GenesisState cdc.MustUnmarshalJSON(oldState[v0_14incentive.ModuleName], &oldIncentiveGenState) var oldHardGenState v0_15hard.GenesisState cdc.MustUnmarshalJSON(oldState[v0_15hard.ModuleName], &oldHardGenState) var oldStakingGenState v0_15staking.GenesisState cdc.MustUnmarshalJSON(oldState[v0_15staking.ModuleName], &oldStakingGenState) var oldCDPGenState v0_15cdp.GenesisState cdc.MustUnmarshalJSON(oldState[v0_15cdp.ModuleName], &oldCDPGenState) newGenState := Incentive(app.MakeCodec(), oldIncentiveGenState, oldCDPGenState.CDPs, oldHardGenState, oldStakingGenState.Delegations) // total previous rewards oldTotalRewards := sdk.NewCoins() // total synced unclaimed rewards for _, claim := range oldIncentiveGenState.HardLiquidityProviderClaims { oldTotalRewards = oldTotalRewards.Add(claim.Reward...) } for _, claim := range oldIncentiveGenState.USDXMintingClaims { oldTotalRewards = oldTotalRewards.Add(claim.Reward) } // total new rewards newTotalRewards := sdk.NewCoins() // total synced unclaimed rewards for _, claim := range newGenState.USDXMintingClaims { newTotalRewards = newTotalRewards.Add(claim.Reward) } for _, claim := range newGenState.HardLiquidityProviderClaims { newTotalRewards = newTotalRewards.Add(claim.Reward...) } // rewards added in migration additionalRewards := sdk.NewCoins() var missedRewards map[string]sdk.Coin cdc.MustUnmarshalJSON([]byte(missedUSDXMintingRewards), &missedRewards) for _, c := range missedRewards { additionalRewards = additionalRewards.Add(c) } require.Equal(t, oldTotalRewards.Add(additionalRewards...), newTotalRewards) } func TestIncentive_SwpLPRewards(t *testing.T) { expectedAnnualRewards := sdk.NewCoin("swp", sdk.NewInt(24000000e6)) expectedAnnualRewardsMap := map[string]sdk.Coin{ "ukava:usdx": sdk.NewCoin("swp", sdk.NewInt(7000000e6)), "swp:usdx": sdk.NewCoin("swp", sdk.NewInt(6000000e6)), "busd:usdx": sdk.NewCoin("swp", sdk.NewInt(5000000e6)), "bnb:usdx": sdk.NewCoin("swp", sdk.NewInt(1500000e6)), "btcb:usdx": sdk.NewCoin("swp", sdk.NewInt(1500000e6)), "hard:usdx": sdk.NewCoin("swp", sdk.NewInt(1500000e6)), "usdx:xrpb": sdk.NewCoin("swp", sdk.NewInt(1500000e6)), } bz, err := ioutil.ReadFile(filepath.Join("testdata", "kava-7-test-incentive-state.json")) require.NoError(t, err) var oldIncentiveGenState v0_14incentive.GenesisState cdc := app.MakeCodec() require.NotPanics(t, func() { cdc.MustUnmarshalJSON(bz, &oldIncentiveGenState) }) secondsPerYear := sdk.NewInt(31536000) newGenState := v0_15incentive.GenesisState{} require.NotPanics(t, func() { newGenState = Incentive(app.MakeCodec(), oldIncentiveGenState, v0_15cdp.CDPs{}, v0_15hard.DefaultGenesisState(), v0_15staking.Delegations{}) }) err = newGenState.Validate() require.NoError(t, err) actualAnnualRewards := sdk.NewCoin("swp", sdk.ZeroInt()) for _, rp := range newGenState.Params.SwapRewardPeriods { expected, found := expectedAnnualRewardsMap[rp.CollateralType] require.True(t, found) require.True(t, len(rp.RewardsPerSecond) == 1) require.True(t, rp.RewardsPerSecond[0].Denom == "swp") annualRewardsAmount := rp.RewardsPerSecond[0].Amount.ToDec().Mul(secondsPerYear.ToDec()).RoundInt() annualRewardsCoin := sdk.NewCoin("swp", annualRewardsAmount) actualAnnualRewards = actualAnnualRewards.Add(annualRewardsCoin) // allow for +- 0.1% deviation for targeted annual rewards inRange := assertRewardsWithinRange(expected, annualRewardsCoin, sdk.MustNewDecFromStr("0.001")) require.True(t, inRange, fmt.Sprintf("expected annual rewards: %s, actual %s", expected, annualRewardsCoin)) } inRange := assertRewardsWithinRange(expectedAnnualRewards, actualAnnualRewards, sdk.MustNewDecFromStr("0.001")) require.True(t, inRange, fmt.Sprintf("expected annual rewards: %s, actual %s", expectedAnnualRewards, actualAnnualRewards)) } func TestIncentive_SwpDelegatorRewards(t *testing.T) { expectedAnnualRewards := sdk.NewCoin("swp", sdk.NewInt(6250000e6)) bz, err := ioutil.ReadFile(filepath.Join("testdata", "kava-7-test-incentive-state.json")) require.NoError(t, err) var oldIncentiveGenState v0_14incentive.GenesisState cdc := app.MakeCodec() require.NotPanics(t, func() { cdc.MustUnmarshalJSON(bz, &oldIncentiveGenState) }) secondsPerYear := sdk.NewInt(31536000) newGenState := v0_15incentive.GenesisState{} require.NotPanics(t, func() { newGenState = Incentive(app.MakeCodec(), oldIncentiveGenState, v0_15cdp.CDPs{}, v0_15hard.DefaultGenesisState(), v0_15staking.Delegations{}) }) for _, rp := range newGenState.Params.DelegatorRewardPeriods { swpRewardsPerSecondDelegators := sdk.NewCoin("swp", rp.RewardsPerSecond.AmountOf("swp")) annualRewardsAmount := swpRewardsPerSecondDelegators.Amount.ToDec().Mul(secondsPerYear.ToDec()).RoundInt() annualRewardsCoin := sdk.NewCoin("swp", annualRewardsAmount) inRange := assertRewardsWithinRange(expectedAnnualRewards, annualRewardsCoin, sdk.MustNewDecFromStr("0.001")) require.True(t, inRange, fmt.Sprintf("expected annual rewards: %s, actual %s", expectedAnnualRewards, annualRewardsCoin)) } } func TestIncentive_SwpPoolsValid(t *testing.T) { bz, err := ioutil.ReadFile(filepath.Join("testdata", "kava-7-test-incentive-state.json")) require.NoError(t, err) appState := genutil.AppMap{ v0_14incentive.ModuleName: bz, v0_15cdp.ModuleName: app.MakeCodec().MustMarshalJSON(v0_15cdp.DefaultGenesisState()), v0_15hard.ModuleName: app.MakeCodec().MustMarshalJSON(v0_15hard.DefaultGenesisState()), v0_15staking.ModuleName: app.MakeCodec().MustMarshalJSON(v0_15staking.DefaultGenesisState()), } MigrateAppState(appState) cdc := app.MakeCodec() var swapGS swap.GenesisState cdc.MustUnmarshalJSON(appState[swap.ModuleName], &swapGS) var incentiveGS v0_15incentive.GenesisState cdc.MustUnmarshalJSON(appState[v0_15incentive.ModuleName], &incentiveGS) for _, rp := range incentiveGS.Params.SwapRewardPeriods { found := false for _, pool := range swapGS.Params.AllowedPools { if pool.Name() == rp.CollateralType { found = true } } require.True(t, found, fmt.Sprintf("incentivized pool %s not found in swap genesis state", rp.CollateralType)) } } func assertRewardsWithinRange(expected, actual sdk.Coin, tolerance sdk.Dec) bool { upper := expected.Amount.ToDec().Mul(sdk.OneDec().Add(tolerance)) lower := expected.Amount.ToDec().Mul(sdk.OneDec().Sub(tolerance)) if actual.Amount.ToDec().GTE(lower) && actual.Amount.ToDec().LTE(upper) { return true } return false } func TestSwap(t *testing.T) { swapGS := Swap() err := swapGS.Validate() require.NoError(t, err) require.Equal(t, 7, len(swapGS.Params.AllowedPools)) require.Equal(t, 0, len(swapGS.PoolRecords)) require.Equal(t, 0, len(swapGS.ShareRecords)) } func TestAuth_ParametersEqual(t *testing.T) { bz, err := ioutil.ReadFile(filepath.Join("testdata", "kava-7-test-auth-state.json")) require.NoError(t, err) var genesisState auth.GenesisState cdc := app.MakeCodec() cdc.MustUnmarshalJSON(bz, &genesisState) migratedGenesisState := Auth(cdc, genesisState, GenesisTime) assert.Equal(t, genesisState.Params, migratedGenesisState.Params, "expected auth parameters to not change") } func TestAuth_AccountConversion(t *testing.T) { bz, err := ioutil.ReadFile(filepath.Join("testdata", "kava-7-test-auth-state.json")) require.NoError(t, err) cdc := app.MakeCodec() var genesisState auth.GenesisState cdc.MustUnmarshalJSON(bz, &genesisState) migratedGenesisState := MigrateAccounts(genesisState, GenesisTime) var originalGenesisState auth.GenesisState cdc.MustUnmarshalJSON(bz, &originalGenesisState) require.Equal(t, len(genesisState.Accounts), len(migratedGenesisState.Accounts), "expected the number of accounts after migration to be equal") err = auth.ValidateGenesis(migratedGenesisState) require.NoError(t, err, "expected migrated genesis to be valid") for i, acc := range migratedGenesisState.Accounts { oldAcc := originalGenesisState.Accounts[i] // total owned coins does not change require.Equal(t, oldAcc.GetCoins(), acc.GetCoins(), "expected base coins to not change") // ensure spenable coins at genesis time is equal require.Equal(t, oldAcc.SpendableCoins(GenesisTime), acc.SpendableCoins(GenesisTime), "expected spendable coins to not change") // check 30 days futureDate := GenesisTime.Add(30 * 24 * time.Hour) require.Equal(t, oldAcc.SpendableCoins(futureDate), acc.SpendableCoins(futureDate), "expected spendable coins to not change") // check 90 days futureDate = GenesisTime.Add(90 * 24 * time.Hour) require.Equal(t, oldAcc.SpendableCoins(futureDate), acc.SpendableCoins(futureDate), "expected spendable coins to not change") // check 180 days futureDate = GenesisTime.Add(180 * 24 * time.Hour) require.Equal(t, oldAcc.SpendableCoins(futureDate), acc.SpendableCoins(futureDate), "expected spendable coins to not change") // check 365 days futureDate = GenesisTime.Add(365 * 24 * time.Hour) require.Equal(t, oldAcc.SpendableCoins(futureDate), acc.SpendableCoins(futureDate), "expected spendable coins to not change") // check 2 years futureDate = GenesisTime.Add(2 * 365 * 24 * time.Hour) require.Equal(t, oldAcc.SpendableCoins(futureDate), acc.SpendableCoins(futureDate), "expected spendable coins to not change") if vacc, ok := acc.(*vesting.PeriodicVestingAccount); ok { // old account must be a periodic vesting account oldVacc, ok := oldAcc.(*vesting.PeriodicVestingAccount) require.True(t, ok) // total delegated coins must match oldTotalDelegated := oldVacc.DelegatedFree.Add(oldVacc.DelegatedVesting...) newTotalDelegated := vacc.DelegatedFree.Add(vacc.DelegatedVesting...) require.Equal(t, oldTotalDelegated, newTotalDelegated, "expected total amount of tracked delegations to not change") // delegated vesting must be less or equal to original vesting require.True(t, vacc.DelegatedVesting.IsAllLTE(vacc.OriginalVesting), "expected delegated vesting to be less or equal to original vesting") // vested coins must be nil for the new account require.Equal(t, sdk.Coins(nil), vacc.GetVestedCoins(GenesisTime), "expected no vested coins at genesis time") // vesting coins must not be nil require.NotEqual(t, sdk.Coins(nil), vacc.GetVestingCoins(GenesisTime), "expected vesting coins to be greater than 0") // new account as less than or equal require.LessOrEqual(t, len(vacc.VestingPeriods), len(oldVacc.VestingPeriods), "expected vesting periods of new account to be less than or equal to old") // end time should not change require.Equal(t, oldVacc.EndTime, vacc.EndTime, "expected end time to not change") } } } func TestAuth_Regression_BalancesEqual(t *testing.T) { bz, err := ioutil.ReadFile(filepath.Join("testdata", "block-1543671-auth-state.json")) require.NoError(t, err) cdc := app.MakeCodec() var originalGenesisState auth.GenesisState cdc.MustUnmarshalJSON(bz, &originalGenesisState) var genesisState auth.GenesisState cdc.MustUnmarshalJSON(bz, &genesisState) genesisState = Auth(cdc, genesisState, GenesisTime) for i, oldAcc := range originalGenesisState.Accounts { acc := genesisState.Accounts[i] // total owned coins does not change, despite additional swp tokens swpBalance := sdk.NewCoins(sdk.NewCoin("swp", acc.GetCoins().AmountOf("swp"))) require.Equal(t, oldAcc.GetCoins(), acc.GetCoins().Sub(swpBalance), "expected base coins to not change") // ensure spendable coins at genesis time is equal, despite additional swp tokens swpBalance = sdk.NewCoins(sdk.NewCoin("swp", acc.SpendableCoins(GenesisTime).AmountOf("swp"))) require.Equal(t, oldAcc.SpendableCoins(GenesisTime), acc.SpendableCoins(GenesisTime).Sub(swpBalance), "expected spendable coins to not change") } } func TestAuth_MakeAirdropMap(t *testing.T) { cdc := app.MakeCodec() aidropTokenAmount := sdk.NewInt(1000000000000) totalSwpTokens := sdk.ZeroInt() var loadedAirdropMap map[string]sdk.Coin cdc.MustUnmarshalJSON([]byte(swpAirdropMap), &loadedAirdropMap) for _, coin := range loadedAirdropMap { totalSwpTokens = totalSwpTokens.Add(coin.Amount) } require.Equal(t, aidropTokenAmount, totalSwpTokens) } func TestAuth_TestAllDepositorsIncluded(t *testing.T) { var deposits v0_15hard.Deposits cdc := app.MakeCodec() bz, err := ioutil.ReadFile("./data/hard-deposits-block-1543671.json") if err != nil { panic(fmt.Sprintf("Couldn't open hard deposit snapshot file: %v", err)) } cdc.MustUnmarshalJSON(bz, &deposits) depositorsInSnapShot := 0 for _, dep := range deposits { if dep.Amount.AmountOf("usdx").IsPositive() { depositorsInSnapShot++ } } var loadedAirdropMap map[string]sdk.Coin cdc.MustUnmarshalJSON([]byte(swpAirdropMap), &loadedAirdropMap) keys := make([]string, 0, len(loadedAirdropMap)) for k := range loadedAirdropMap { keys = append(keys, k) } require.Equal(t, depositorsInSnapShot, len(keys)) } func TestAuth_SwpSupply_AfterAirdrop(t *testing.T) { swpSupply := sdk.NewCoin("swp", sdk.ZeroInt()) expectedSwpSupply := sdk.NewCoin("swp", sdk.NewInt(1000000000000)) bz, err := ioutil.ReadFile(filepath.Join("testdata", "block-1543671-auth-state.json")) require.NoError(t, err) var genesisState auth.GenesisState cdc := app.MakeCodec() cdc.MustUnmarshalJSON(bz, &genesisState) migratedGenesisState := ApplySwpAirdrop(cdc, genesisState) for _, acc := range migratedGenesisState.Accounts { swpAmount := acc.GetCoins().AmountOf("swp") if swpAmount.IsPositive() { swpCoin := sdk.NewCoin("swp", swpAmount) swpSupply = swpSupply.Add(swpCoin) } } require.Equal(t, expectedSwpSupply, swpSupply) } func TestAuth_SwpSupply_TotalSupply(t *testing.T) { swpSupply := sdk.NewCoin("swp", sdk.ZeroInt()) expectedSwpSupply := sdk.NewCoin("swp", sdk.NewInt(250000000e6)) bz, err := ioutil.ReadFile(filepath.Join("testdata", "block-1543671-auth-state.json")) require.NoError(t, err) var genesisState auth.GenesisState cdc := app.MakeCodec() cdc.MustUnmarshalJSON(bz, &genesisState) migratedGenesisState := Auth(cdc, genesisState, GenesisTime) for _, acc := range migratedGenesisState.Accounts { swpAmount := acc.GetCoins().AmountOf("swp") if swpAmount.IsPositive() { swpCoin := sdk.NewCoin("swp", swpAmount) swpSupply = swpSupply.Add(swpCoin) } } require.Equal(t, expectedSwpSupply, swpSupply) } func TestAuth_SwpSupply_SpendableCoins(t *testing.T) { bz, err := ioutil.ReadFile(filepath.Join("testdata", "block-1543671-auth-state.json")) require.NoError(t, err) var genesisState auth.GenesisState cdc := app.MakeCodec() cdc.MustUnmarshalJSON(bz, &genesisState) swpTreasuryExpectedSpendableCoins := sdk.NewCoins(SwpTreasuryCoins.Sub(SwpTreasuryOriginalVesting)) foundTreasury := false swpTeamExpectedSpendableCoins := sdk.Coins(nil) foundTeam := false kavaDistExpectedSpendableCoins := KavaDistCoins foundKavadist := false swpEcosystemExpectedSpendableCoins := sdk.NewCoins(EcoSystemCoins) foundEcosystem := false migratedGenesisState := Auth(cdc, genesisState, GenesisTime) for _, acc := range migratedGenesisState.Accounts { if acc.GetAddress().Equals(SwpTreasuryAddr) { foundTreasury = true pva, ok := acc.(*vesting.PeriodicVestingAccount) require.True(t, ok) spendableCoins := pva.SpendableCoins(GenesisTime) require.Equal(t, swpTreasuryExpectedSpendableCoins, spendableCoins) } if acc.GetAddress().Equals(SwpTeamAddr) { foundTeam = true pva, ok := acc.(*vesting.PeriodicVestingAccount) require.True(t, ok) spendableCoins := pva.SpendableCoins(GenesisTime) require.Equal(t, swpTeamExpectedSpendableCoins, spendableCoins) } if acc.GetAddress().Equals(KavaDistAddr) { foundKavadist = true spendableCoins := acc.SpendableCoins(GenesisTime) spendableSwp := sdk.NewCoin("swp", spendableCoins.AmountOf("swp")) require.Equal(t, kavaDistExpectedSpendableCoins, spendableSwp) } if acc.GetAddress().Equals(SwpEcoSystemAddr) { foundEcosystem = true spendableCoins := acc.SpendableCoins(GenesisTime) require.Equal(t, swpEcosystemExpectedSpendableCoins, spendableCoins) } } require.True(t, foundTreasury) require.True(t, foundTeam) require.True(t, foundKavadist) require.True(t, foundEcosystem) }