add market parameter TobinTaxList to speicify a more strict tobin tax…

… for the denom with high volatility

types/alias.go

@@ -19,6 +19,7 @@ const (
 	MicroJPYDenom        = assets.MicroJPYDenom
 	MicroEURDenom        = assets.MicroEURDenom
 	MicroGBPDenom        = assets.MicroGBPDenom
+	MicroMNTDenom        = assets.MicroMNTDenom
 	MicroUnit            = assets.MicroUnit
 	BlocksPerMinute      = util.BlocksPerMinute
 	BlocksPerHour        = util.BlocksPerHour

types/assets/assets.go

@@ -10,6 +10,7 @@ const (
 	MicroJPYDenom  = "ujpy"
 	MicroEURDenom  = "ueur"
 	MicroGBPDenom  = "ugbp"
+	MicroMNTDenom  = "umnt"
 
 	MicroUnit = int64(1e6)
 )

x/market/internal/keeper/params.go

@@ -29,12 +29,19 @@ func (k Keeper) PoolRecoveryPeriod(ctx sdk.Context) (res int64) {
 	return
 }
 
-// TobinTax is a tax on all spot conversions of one Terra into another Terra
+// TobinTax is a tax rates on all spot conversions of one Terra into another Terra
 func (k Keeper) TobinTax(ctx sdk.Context) (res sdk.Dec) {
 	k.paramSpace.Get(ctx, types.ParmamStoreKeyTobinTax, &res)
 	return
 }
 
+// TobinTaxList is a tax rates on all spot conversions of the specific Terra into another Terra
+// TobinTax will be used for the denoms which are not in the list
+func (k Keeper) TobinTaxList(ctx sdk.Context) (res types.TobinTaxList) {
+	k.paramSpace.Get(ctx, types.ParmamStoreKeyTobinTaxList, &res)
+	return
+}
+
 // GetParams returns the total set of market parameters.
 func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
 	k.paramSpace.GetParamSet(ctx, &params)

x/market/internal/keeper/swap.go

@@ -70,6 +70,18 @@ func (k Keeper) ComputeSwap(ctx sdk.Context, offerCoin sdk.Coin, askDenom string
 	// Apply only tobin tax without constant product spread
 	if offerCoin.Denom != core.MicroLunaDenom && askDenom != core.MicroLunaDenom {
 		spread = k.TobinTax(ctx)
+		tobinTaxList := k.TobinTaxList(ctx)
+
+		// Apply highest tobin tax for the denoms in the swap operation
+		for _, tobinTax := range tobinTaxList {
+			if tobinTax.Denom == offerCoin.Denom ||
+				tobinTax.Denom == askDenom {
+				if tobinTax.TaxRate.GT(spread) {
+					spread = tobinTax.TaxRate
+				}
+			}
+		}
+
 		return
 	}
 

x/market/internal/keeper/swap_test.go

@@ -8,6 +8,7 @@ import (
 
 	sdk "github.com/cosmos/cosmos-sdk/types"
 	core "github.com/terra-project/core/types"
+	"github.com/terra-project/core/x/market/internal/types"
 )
 
 func TestApplySwapToPool(t *testing.T) {
@@ -82,3 +83,45 @@ func TestComputeInternalSwap(t *testing.T) {
 	_, err := input.MarketKeeper.ComputeInternalSwap(input.Ctx, offerCoin, core.MicroLunaDenom)
 	require.Error(t, err)
 }
+
+func TestTobinTaxListParams(t *testing.T) {
+	input := CreateTestInput(t)
+
+	// Set Oracle Price
+	lunaPriceInSDR := sdk.NewDecWithPrec(17, 1)
+	lunaPriceInMNT := sdk.NewDecWithPrec(7652, 1)
+	input.OracleKeeper.SetLunaExchangeRate(input.Ctx, core.MicroSDRDenom, lunaPriceInSDR)
+	input.OracleKeeper.SetLunaExchangeRate(input.Ctx, core.MicroMNTDenom, lunaPriceInMNT)
+
+	// Case 1: tobin tax 2% due to umnt denom
+	params := input.MarketKeeper.GetParams(input.Ctx)
+	params.TobinTax = sdk.NewDecWithPrec(25, 4)
+	params.TobinTaxList = types.TobinTaxList{
+		types.TobinTax{
+			Denom:   core.MicroSDRDenom,
+			TaxRate: sdk.NewDecWithPrec(25, 4),
+		},
+		types.TobinTax{
+			Denom:   core.MicroMNTDenom,
+			TaxRate: sdk.NewDecWithPrec(2, 2),
+		},
+	}
+	input.MarketKeeper.SetParams(input.Ctx, params)
+
+	swapAmountInSDR := lunaPriceInSDR.MulInt64(rand.Int63()%10000 + 2).TruncateInt()
+	offerCoin := sdk.NewCoin(core.MicroSDRDenom, swapAmountInSDR)
+	_, spread, err := input.MarketKeeper.ComputeSwap(input.Ctx, offerCoin, core.MicroMNTDenom)
+	require.NoError(t, err)
+	require.Equal(t, sdk.NewDecWithPrec(2, 2), spread)
+
+	// Case 2: tobin tax 5% due to default
+	params.TobinTax = sdk.NewDecWithPrec(5, 2)
+	input.MarketKeeper.SetParams(input.Ctx, params)
+
+	swapAmountInSDR = lunaPriceInSDR.MulInt64(rand.Int63()%10000 + 2).TruncateInt()
+	offerCoin = sdk.NewCoin(core.MicroSDRDenom, swapAmountInSDR)
+	_, spread, err = input.MarketKeeper.ComputeSwap(input.Ctx, offerCoin, core.MicroMNTDenom)
+	require.NoError(t, err)
+	require.Equal(t, sdk.NewDecWithPrec(5, 2), spread)
+
+}

x/market/internal/types/genesis_test.go

@@ -20,6 +20,8 @@ func TestGenesisValidation(t *testing.T) {
 
 	genState.Params.MinSpread = sdk.NewDec(-1)
 	require.Error(t, ValidateGenesis(genState))
+
+	require.True(t, len(genState.Params.String()) != 0)
 }
 
 func TestGenesisEqual(t *testing.T) {

x/market/internal/types/params.go

@@ -22,6 +22,8 @@ var (
 	ParamStoreKeyMinSpread = []byte("minspread")
 	// Tobin tax
 	ParmamStoreKeyTobinTax = []byte("tobintax")
+	// Tobin tax list
+	ParmamStoreKeyTobinTaxList = []byte("tobintaxlist")
 )
 
 // Default parameter values
@@ -30,16 +32,23 @@ var (
 	DefaultPoolRecoveryPeriod = core.BlocksPerDay                   // 14,400
 	DefaultMinSpread          = sdk.NewDecWithPrec(2, 2)            // 2%
 	DefaultTobinTax           = sdk.NewDecWithPrec(25, 4)           // 0.25%
+	DefaultTobinTaxList       = TobinTaxList{
+		{
+			Denom:   core.MicroMNTDenom,
+			TaxRate: sdk.NewDecWithPrec(2, 2), // 2%
+		},
+	}
 )
 
 var _ subspace.ParamSet = &Params{}
 
 // Params market parameters
 type Params struct {
-	PoolRecoveryPeriod int64   `json:"pool_recovery_period" yaml:"pool_recovery_period"`
-	BasePool           sdk.Dec `json:"base_pool" yaml:"base_pool"`
-	MinSpread          sdk.Dec `json:"min_spread" yaml:"min_spread"`
-	TobinTax           sdk.Dec `json:"tobin_tax" yaml:"tobin_tax"`
+	PoolRecoveryPeriod int64        `json:"pool_recovery_period" yaml:"pool_recovery_period"`
+	BasePool           sdk.Dec      `json:"base_pool" yaml:"base_pool"`
+	MinSpread          sdk.Dec      `json:"min_spread" yaml:"min_spread"`
+	TobinTax           sdk.Dec      `json:"tobin_tax" yaml:"tobin_tax"`
+	TobinTaxList       TobinTaxList `json:"tobin_tax_list" yaml:"tobin_tax_list"`
 }
 
 // DefaultParams creates default market module parameters
@@ -49,6 +58,7 @@ func DefaultParams() Params {
 		PoolRecoveryPeriod: DefaultPoolRecoveryPeriod,
 		MinSpread:          DefaultMinSpread,
 		TobinTax:           DefaultTobinTax,
+		TobinTaxList:       DefaultTobinTaxList,
 	}
 }
 
@@ -66,6 +76,11 @@ func (params Params) Validate() error {
 	if params.TobinTax.IsNegative() || params.TobinTax.GT(sdk.OneDec()) {
 		return fmt.Errorf("tobin tax should be a value between [0,1], is %s", params.TobinTax)
 	}
+	for _, val := range params.TobinTaxList {
+		if val.TaxRate.IsNegative() || val.TaxRate.GT(sdk.OneDec()) {
+			return fmt.Errorf("tobin tax should be a value between [0,1], is %s", val)
+		}
+	}
 
 	return nil
 }
@@ -79,6 +94,7 @@ func (params *Params) ParamSetPairs() subspace.ParamSetPairs {
 		{Key: ParamStoreKeyPoolRecoveryPeriod, Value: &params.PoolRecoveryPeriod},
 		{Key: ParamStoreKeyMinSpread, Value: &params.MinSpread},
 		{Key: ParmamStoreKeyTobinTax, Value: &params.TobinTax},
+		{Key: ParmamStoreKeyTobinTaxList, Value: &params.TobinTaxList},
 	}
 }
 
@@ -89,5 +105,6 @@ func (params Params) String() string {
 	PoolRecoveryPeriod:         %d
 	MinSpread:                  %s
 	TobinTax:                   %s
-	`, params.BasePool, params.PoolRecoveryPeriod, params.MinSpread, params.TobinTax)
+	TobinTaxList:                   %s
+	`, params.BasePool, params.PoolRecoveryPeriod, params.MinSpread, params.TobinTax, params.TobinTaxList)
 }

x/market/internal/types/tobin_tax.go

@@ -0,0 +1,34 @@
+package types
+
+import (
+	"fmt"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// TobinTax - struct to store tobin tax for the specific denom with high volatility
+type TobinTax struct {
+	Denom   string  `json:"denom" yaml:"denom"`
+	TaxRate sdk.Dec `json:"tax_rate" yaml:"tax_rate"`
+}
+
+// String implements fmt.Stringer interface
+func (tt TobinTax) String() string {
+	return fmt.Sprintf(`TobinTax
+	Denom:      %s, 
+	TaxRate:    %s`,
+		tt.Denom, tt.TaxRate)
+}
+
+// TobinTaxList is convience wrapper to handle TobinTax array
+type TobinTaxList []TobinTax
+
+// String implements fmt.Stringer interface
+func (ttl TobinTaxList) String() (out string) {
+	out = ""
+	for _, tt := range ttl {
+		out += tt.String() + "\n"
+	}
+
+	return
+}

x/oracle/internal/types/denom.go

@@ -8,7 +8,6 @@ import (
 type DenomList []string
 
 // String implements fmt.Stringer interface
-func (dl DenomList) String() (out string) {
-	strings.Join(dl, "\n")
-	return
+func (dl DenomList) String() string {
+	return strings.Join(dl, "\n")
 }

x/oracle/internal/types/vote.go

@@ -83,8 +83,8 @@ func (pv ExchangeRateVote) getPower(ctx sdk.Context, powerMap map[string]int64)
 // String implements fmt.Stringer interface
 func (pv ExchangeRateVote) String() string {
 	return fmt.Sprintf(`ExchangeRateVote
-	Denom:    %s, 
-	Voter:    %s, 
+	Denom:           %s, 
+	Voter:           %s, 
 	ExchangeRate:    %s`,
 		pv.Denom, pv.Voter, pv.ExchangeRate)
 }