[v18] Juno x/burn module (#801)

.github/workflows/interchaintest-E2E.yml

@@ -69,6 +69,7 @@ jobs:
           - "ictest-unity-gov"
           - "ictest-pob"
           - "ictest-drip"
+          - "ictest-burn"
           - "ictest-clock"
       fail-fast: false
 

Makefile

@@ -160,6 +160,9 @@ ictest-pob: rm-testcache
 ictest-drip: rm-testcache
 	cd interchaintest &&  go test -race -v -run TestJunoDrip .
 
+ictest-burn: rm-testcache
+	cd interchaintest &&  go test -race -v -run TestJunoBurnModule .
+
 ictest-clock: rm-testcache
 	cd interchaintest &&  go test -race -v -run TestJunoClock .
 

app/keepers/keepers.go

@@ -82,6 +82,7 @@ import (
 	upgradekeeper "github.com/cosmos/cosmos-sdk/x/upgrade/keeper"
 	upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
 
+	junoburn "github.com/CosmosContracts/juno/v18/x/burn"
 	clockkeeper "github.com/CosmosContracts/juno/v18/x/clock/keeper"
 	clocktypes "github.com/CosmosContracts/juno/v18/x/clock/types"
 	dripkeeper "github.com/CosmosContracts/juno/v18/x/drip/keeper"
@@ -121,10 +122,11 @@ var maccPerms = map[string][]string{
 	ibctransfertypes.ModuleName:    {authtypes.Minter, authtypes.Burner},
 	icatypes.ModuleName:            nil,
 	ibcfeetypes.ModuleName:         nil,
-	wasmtypes.ModuleName:           {authtypes.Burner},
+	wasmtypes.ModuleName:           {},
 	tokenfactorytypes.ModuleName:   {authtypes.Minter, authtypes.Burner},
 	globalfee.ModuleName:           nil,
 	buildertypes.ModuleName:        nil,
+	junoburn.ModuleName:            {authtypes.Burner},
 }
 
 type AppKeepers struct {
@@ -526,6 +528,10 @@ func NewAppKeepers(
 		})
 	wasmOpts = append(wasmOpts, querierOpts)
 
+	junoBurnerPlugin := junoburn.NewBurnerPlugin(appKeepers.BankKeeper, appKeepers.MintKeeper)
+	burnOverride := wasmkeeper.WithMessageHandler(wasmkeeper.NewBurnCoinMessageHandler(junoBurnerPlugin))
+	wasmOpts = append(wasmOpts, burnOverride)
+
 	appKeepers.WasmKeeper = wasmkeeper.NewKeeper(
 		appCodec,
 		appKeepers.keys[wasmtypes.StoreKey],

go.mod

@@ -2,7 +2,8 @@ module github.com/CosmosContracts/juno/v18
 
 go 1.21
 
-toolchain go1.21.0
+// heighliner does not like.
+// toolchain go1.21.0
 
 require (
 	cosmossdk.io/api v0.3.1

interchaintest/contracts/README.md

@@ -6,4 +6,5 @@ A list of the contracts here which are pre-compiled in other repos.
 > cw_template -> <https://github.com/CosmWasm/cw-template>
 > cw_unity_prop -> <https://github.com/CosmosContracts/cw-unity-prop> v0.3.4-alpha
 > ibchooks_counter.wasm -> <https://github.com/osmosis-labs/osmosis/blob/64393a14e18b2562d72a3892eec716197a3716c7/tests/ibc-hooks/bytecode/counter.wasm>
+> cw_testburn.wasm -> <https://github.com/Reecepbcups/cw-testburn>
 > clock_example.wasm -> <https://github.com/Reecepbcups/cw-clock-example>

interchaintest/module_burn_test.go

@@ -0,0 +1,60 @@
+package interchaintest
+
+import (
+	"fmt"
+	"strconv"
+	"testing"
+
+	"github.com/strangelove-ventures/interchaintest/v7"
+	"github.com/strangelove-ventures/interchaintest/v7/chain/cosmos"
+	"github.com/stretchr/testify/assert"
+
+	helpers "github.com/CosmosContracts/juno/tests/interchaintest/helpers"
+)
+
+// TestJunoBurnModule ensures the junoburn module register and execute sharing functions work properly on smart contracts.
+// This is required due to how x/mint handles minting tokens for the target supply.
+// It is purely for developers ::BurnTokens to function as expected.
+func TestJunoBurnModule(t *testing.T) {
+	t.Parallel()
+
+	// Base setup
+	chains := CreateThisBranchChain(t, 1, 0)
+	ic, ctx, _, _ := BuildInitialChain(t, chains)
+
+	// Chains
+	juno := chains[0].(*cosmos.CosmosChain)
+
+	nativeDenom := juno.Config().Denom
+
+	// Users
+	users := interchaintest.GetAndFundTestUsers(t, ctx, "default", int64(10_000_000), juno, juno)
+	user := users[0]
+
+	// Upload & init contract
+	_, contractAddr := helpers.SetupContract(t, ctx, juno, user.KeyName(), "contracts/cw_testburn.wasm", `{}`)
+
+	// get balance before execute
+	balance, err := juno.GetBalance(ctx, user.FormattedAddress(), nativeDenom)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// execute burn of tokens
+	burnAmt := int64(1_000_000)
+	helpers.ExecuteMsgWithAmount(t, ctx, juno, user, contractAddr, strconv.Itoa(int(burnAmt))+nativeDenom, `{"burn_token":{}}`)
+
+	// verify it is down 1_000_000 tokens since the burn
+	updatedBal, err := juno.GetBalance(ctx, user.FormattedAddress(), nativeDenom)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Verify the funds were sent, and burned.
+	fmt.Println(balance, updatedBal)
+	assert.Equal(t, burnAmt, balance-updatedBal, fmt.Sprintf("balance should be %d less than updated balance", burnAmt))
+
+	t.Cleanup(func() {
+		_ = ic.Close()
+	})
+}

x/burn/README.md

@@ -0,0 +1,7 @@
+# x/burn
+
+This is a 'module' used solely to burn tokens properly in line with our x/mint module requirements.
+
+## Burn address
+
+- juno1mj7t69y4r2adl3cnuq8y9uundkzawvx6avu7nj

x/burn/burner.go

@@ -0,0 +1,50 @@
+package burn
+
+import (
+	wasmtypes "github.com/CosmWasm/wasmd/x/wasm/types"
+
+	sdk "github.com/cosmos/cosmos-sdk/types"
+	bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+
+	mintkeeper "github.com/CosmosContracts/juno/v18/x/mint/keeper"
+)
+
+// used to override Wasmd's NewBurnCoinMessageHandler
+
+type BurnerWasmPlugin struct {
+	bk bankkeeper.Keeper
+	mk mintkeeper.Keeper
+}
+
+var _ wasmtypes.Burner = &BurnerWasmPlugin{}
+
+func NewBurnerPlugin(bk bankkeeper.Keeper, mk mintkeeper.Keeper) *BurnerWasmPlugin {
+	return &BurnerWasmPlugin{bk: bk, mk: mk}
+}
+
+func (k *BurnerWasmPlugin) BurnCoins(ctx sdk.Context, _ string, amt sdk.Coins) error {
+	// first, try to burn the coins on bank module
+	err := k.bk.BurnCoins(ctx, ModuleName, amt)
+	if err != nil {
+		return err
+	}
+
+	// get mint params
+	params := k.mk.GetParams(ctx)
+
+	// loop the burned coins
+	for _, amount := range amt {
+		// if we are burning mint denom, reduce the target staking supply
+		if amount.Denom == params.MintDenom {
+			if err := k.mk.ReduceTargetSupply(ctx, amount); err != nil {
+				return err
+			}
+		}
+	}
+
+	return nil
+}
+
+func (k *BurnerWasmPlugin) SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, _ string, amt sdk.Coins) error {
+	return k.bk.SendCoinsFromAccountToModule(ctx, senderAddr, ModuleName, amt)
+}

x/burn/constants.go

@@ -0,0 +1,5 @@
+package burn
+
+const (
+	ModuleName = "junoburn"
+)

x/mint/keeper/keeper.go

@@ -19,6 +19,7 @@ type Keeper struct {
 	cdc              codec.BinaryCodec
 	storeKey         storetypes.StoreKey
 	stakingKeeper    types.StakingKeeper
+	accountKeeper    types.AccountKeeper
 	bankKeeper       types.BankKeeper
 	feeCollectorName string
 
@@ -47,6 +48,7 @@ func NewKeeper(
 		storeKey:         key,
 		stakingKeeper:    sk,
 		bankKeeper:       bk,
+		accountKeeper:    ak,
 		feeCollectorName: feeCollectorName,
 		authority:        authority,
 	}
@@ -110,6 +112,10 @@ func (k Keeper) GetParams(ctx sdk.Context) (p types.Params) {
 	return p
 }
 
+func (k Keeper) GetAccountKeeper() types.AccountKeeper {
+	return k.accountKeeper
+}
+
 // ______________________________________________________________________
 
 // StakingTokenSupply implements an alias call to the underlying staking keeper's
@@ -124,6 +130,12 @@ func (k Keeper) TokenSupply(ctx sdk.Context, denom string) math.Int {
 	return k.bankKeeper.GetSupply(ctx, denom).Amount
 }
 
+// GetBalance implements an alias call to the underlying bank keeper's
+// GetBalance to be used in BeginBlocker.
+func (k Keeper) GetBalance(ctx sdk.Context, address sdk.AccAddress, denom string) math.Int {
+	return k.bankKeeper.GetBalance(ctx, address, denom).Amount
+}
+
 // BondedRatio implements an alias call to the underlying staking keeper's
 // BondedRatio to be used in BeginBlocker.
 func (k Keeper) BondedRatio(ctx sdk.Context) sdk.Dec {
@@ -141,6 +153,20 @@ func (k Keeper) MintCoins(ctx sdk.Context, newCoins sdk.Coins) error {
 	return k.bankKeeper.MintCoins(ctx, types.ModuleName, newCoins)
 }
 
+func (k Keeper) ReduceTargetSupply(ctx sdk.Context, burnCoin sdk.Coin) error {
+	params := k.GetParams(ctx)
+
+	if burnCoin.Denom != params.MintDenom {
+		return fmt.Errorf("tried reducing target supply with non staking token")
+	}
+
+	minter := k.GetMinter(ctx)
+	minter.TargetSupply = minter.TargetSupply.Sub(burnCoin.Amount)
+	k.SetMinter(ctx, minter)
+
+	return nil
+}
+
 // AddCollectedFees implements an alias call to the underlying supply keeper's
 // AddCollectedFees to be used in BeginBlocker.
 func (k Keeper) AddCollectedFees(ctx sdk.Context, fees sdk.Coins) error {

x/mint/types/expected_keepers.go

@@ -26,6 +26,7 @@ type AccountKeeper interface {
 // dependencies.
 type BankKeeper interface {
 	GetSupply(ctx sdk.Context, denom string) sdk.Coin
+	GetBalance(ctx sdk.Context, addr sdk.AccAddress, denom string) sdk.Coin
 	SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
 	SendCoinsFromModuleToModule(ctx sdk.Context, senderModule, recipientModule string, amt sdk.Coins) error
 	MintCoins(ctx sdk.Context, name string, amt sdk.Coins) error