0g-chain/migrate/v0_15/migrate_test.go
Kevin Davis dd03ba5671
Add supply migration for kava-8 (#1008)
* fix: update supply migration to add swp token supply

* add full migration test with app initialization

* fix: use correct chain-id in test app initialization

* address review comments
2021-08-24 16:33:10 -05:00

731 lines
28 KiB
Go

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 TestMigrateFull(t *testing.T) {
t.Skip() // skip to avoid having to commit a large genesis file to the repo
oldGenDoc, err := tmtypes.GenesisDocFromFile(filepath.Join("testdata", "genesis.json"))
require.NoError(t, err)
// 2) migrate
newGenDoc := Migrate(*oldGenDoc)
tApp := app.NewTestApp()
cdc := app.MakeCodec()
var newAppState genutil.AppMap
require.NoError(t,
cdc.UnmarshalJSON(newGenDoc.AppState, &newAppState),
)
err = app.ModuleBasics.ValidateGenesis(newAppState)
if err != nil {
require.NoError(t, err)
}
require.NotPanics(t, func() {
// this runs both InitGenesis for all modules (which panic on errors) and runs all invariants
tApp.InitializeFromGenesisStatesWithTimeAndChainID(newGenDoc.GenesisTime, newGenDoc.ChainID, app.GenesisState(newAppState))
})
}
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)
}