2025-01-10 07:08:01 +00:00
|
|
|
package keeper_test
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"math/big"
|
|
|
|
"testing"
|
|
|
|
|
|
|
|
precisebanktypes "github.com/0glabs/0g-chain/x/precisebank/types"
|
|
|
|
"github.com/0glabs/0g-chain/x/wrapped-a0gi-base/testutil"
|
|
|
|
"github.com/0glabs/0g-chain/x/wrapped-a0gi-base/types"
|
|
|
|
sdk "github.com/cosmos/cosmos-sdk/types"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
)
|
|
|
|
|
|
|
|
type MsgServerTestSuite struct {
|
|
|
|
testutil.Suite
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *MsgServerTestSuite) TestSetWA0GI() {
|
|
|
|
govAccAddr := s.GovKeeper.GetGovernanceAccount(s.Ctx).GetAddress().String()
|
|
|
|
testCases := []struct {
|
|
|
|
name string
|
|
|
|
req *types.MsgSetWA0GI
|
|
|
|
expectErr bool
|
|
|
|
errMsg string
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "invalid signer",
|
|
|
|
req: &types.MsgSetWA0GI{
|
|
|
|
Authority: s.Addresses[0].String(),
|
|
|
|
Address: common.HexToAddress("0x0000000000000000000000000000000000000001").Bytes(),
|
|
|
|
},
|
|
|
|
expectErr: true,
|
|
|
|
errMsg: "expected gov account as only signer for proposal message",
|
|
|
|
},
|
|
|
|
{
|
|
|
|
name: "success",
|
|
|
|
req: &types.MsgSetWA0GI{
|
|
|
|
Authority: govAccAddr,
|
|
|
|
Address: common.HexToAddress("0x0000000000000000000000000000000000000001").Bytes(),
|
|
|
|
},
|
|
|
|
expectErr: false,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
|
|
s.Run(tc.name, func() {
|
|
|
|
_, err := s.Keeper.SetWA0GI(sdk.WrapSDKContext(s.Ctx), tc.req)
|
|
|
|
if tc.expectErr {
|
|
|
|
s.Require().Error(err)
|
|
|
|
s.Require().Contains(err.Error(), tc.errMsg)
|
|
|
|
} else {
|
|
|
|
s.Require().NoError(err)
|
|
|
|
response, err := s.Keeper.GetWA0GI(s.Ctx, &types.GetWA0GIRequest{})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(response.Address, tc.req.Address)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *MsgServerTestSuite) TestSetMinterCap() {
|
|
|
|
testCases := []struct {
|
|
|
|
name string
|
|
|
|
caps []struct {
|
|
|
|
account common.Address
|
|
|
|
cap *big.Int
|
|
|
|
}
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
name: "success",
|
|
|
|
caps: []struct {
|
|
|
|
account common.Address
|
|
|
|
cap *big.Int
|
|
|
|
}{
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000000"),
|
|
|
|
cap: big.NewInt(100000),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000001"),
|
|
|
|
cap: big.NewInt(200000),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000002"),
|
|
|
|
cap: big.NewInt(300000),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000003"),
|
|
|
|
cap: big.NewInt(400000),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000002"),
|
|
|
|
cap: big.NewInt(500000),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000001"),
|
|
|
|
cap: big.NewInt(600000),
|
|
|
|
},
|
|
|
|
{
|
|
|
|
account: common.HexToAddress("0x0000000000000000000000000000000000000000"),
|
|
|
|
cap: big.NewInt(700000),
|
|
|
|
},
|
|
|
|
},
|
|
|
|
},
|
|
|
|
}
|
|
|
|
s.Run("invalid authority", func() {
|
|
|
|
s.SetupTest()
|
2025-01-14 05:40:50 +00:00
|
|
|
_, err := s.Keeper.SetMinterCap(sdk.WrapSDKContext(s.Ctx), &types.MsgSetMinterCap{
|
2025-01-10 07:08:01 +00:00
|
|
|
Authority: s.Addresses[0].String(),
|
|
|
|
Minter: common.HexToAddress("0x0000000000000000000000000000000000000000").Bytes(),
|
|
|
|
Cap: big.NewInt(600000).Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().Error(err)
|
|
|
|
s.Require().Contains(err.Error(), "expected gov account as only signer for proposal message")
|
|
|
|
})
|
|
|
|
govAccAddr := s.GovKeeper.GetGovernanceAccount(s.Ctx).GetAddress().String()
|
|
|
|
for _, tc := range testCases {
|
|
|
|
s.Run(tc.name, func() {
|
|
|
|
s.SetupTest()
|
|
|
|
|
|
|
|
c := make(map[common.Address]*big.Int)
|
|
|
|
for _, cap := range tc.caps {
|
2025-01-14 05:40:50 +00:00
|
|
|
_, err := s.Keeper.SetMinterCap(sdk.WrapSDKContext(s.Ctx), &types.MsgSetMinterCap{
|
2025-01-10 07:08:01 +00:00
|
|
|
Authority: govAccAddr,
|
|
|
|
Minter: cap.account.Bytes(),
|
|
|
|
Cap: cap.cap.Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
response, err := s.Keeper.MinterSupply(s.Ctx, &types.MinterSupplyRequest{
|
|
|
|
Address: cap.account.Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(new(big.Int).SetBytes(response.Cap), cap.cap)
|
|
|
|
c[cap.account] = cap.cap
|
|
|
|
}
|
|
|
|
for account, cap := range c {
|
|
|
|
response, err := s.Keeper.MinterSupply(s.Ctx, &types.MinterSupplyRequest{
|
|
|
|
Address: account.Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(new(big.Int).SetBytes(response.Cap), cap)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
type MintBurn struct {
|
|
|
|
IsMint bool
|
|
|
|
Minter common.Address
|
|
|
|
Amount *big.Int
|
|
|
|
Success bool
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *MsgServerTestSuite) TestSetMintBurn() {
|
|
|
|
precisebankKeeper := s.App.GetPrecisebankKeeper()
|
|
|
|
accountKeeper := s.App.GetAccountKeeper()
|
|
|
|
moduleAcc := accountKeeper.GetModuleAccount(s.Ctx, types.ModuleName).GetAddress()
|
|
|
|
govAccAddr := s.GovKeeper.GetGovernanceAccount(s.Ctx).GetAddress().String()
|
|
|
|
|
|
|
|
minter1 := common.HexToAddress("0x0000000000000000000000000000000000000001")
|
|
|
|
minter2 := common.HexToAddress("0x0000000000000000000000000000000000000002")
|
|
|
|
|
|
|
|
// set mint cap of minter 1 to 8 a0gi
|
2025-01-14 05:40:50 +00:00
|
|
|
_, err := s.Keeper.SetMinterCap(sdk.WrapSDKContext(s.Ctx), &types.MsgSetMinterCap{
|
2025-01-10 07:08:01 +00:00
|
|
|
Authority: govAccAddr,
|
|
|
|
Minter: minter1.Bytes(),
|
|
|
|
Cap: big.NewInt(8e18).Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
// set mint cap of minter 2 to 5 a0gi
|
2025-01-14 05:40:50 +00:00
|
|
|
_, err = s.Keeper.SetMinterCap(sdk.WrapSDKContext(s.Ctx), &types.MsgSetMinterCap{
|
2025-01-10 07:08:01 +00:00
|
|
|
Authority: govAccAddr,
|
|
|
|
Minter: minter2.Bytes(),
|
|
|
|
Cap: big.NewInt(5e18).Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
|
|
|
|
testCases := []MintBurn{
|
|
|
|
// #0, failed burn
|
|
|
|
{
|
|
|
|
IsMint: false,
|
|
|
|
Minter: minter1,
|
|
|
|
Amount: big.NewInt(1e18),
|
|
|
|
Success: false,
|
|
|
|
},
|
|
|
|
// #1, mint 5 a0gi by minter 1
|
|
|
|
{
|
|
|
|
IsMint: true,
|
|
|
|
Minter: minter1,
|
|
|
|
Amount: big.NewInt(5e18),
|
|
|
|
Success: true,
|
|
|
|
},
|
|
|
|
// #2, burn 0.5 a0gi by minter 1
|
|
|
|
{
|
|
|
|
IsMint: false,
|
|
|
|
Minter: minter1,
|
|
|
|
Amount: big.NewInt(5e17),
|
|
|
|
Success: true,
|
|
|
|
},
|
|
|
|
// #3, mint 0.7 a0gi by minter 2
|
|
|
|
{
|
|
|
|
IsMint: true,
|
|
|
|
Minter: minter2,
|
|
|
|
Amount: big.NewInt(7e17),
|
|
|
|
Success: true,
|
|
|
|
},
|
|
|
|
// #4, mint 2 a0gi by minter 2
|
|
|
|
{
|
|
|
|
IsMint: true,
|
|
|
|
Minter: minter2,
|
|
|
|
Amount: big.NewInt(2e18),
|
|
|
|
Success: true,
|
|
|
|
},
|
|
|
|
// #5, burn 0.3 a0gi by minter 2
|
|
|
|
{
|
|
|
|
IsMint: false,
|
|
|
|
Minter: minter1,
|
|
|
|
Amount: big.NewInt(3e17),
|
|
|
|
Success: true,
|
|
|
|
},
|
|
|
|
// #6, failed to mint 4 a0gi by minter 1
|
|
|
|
{
|
|
|
|
IsMint: true,
|
|
|
|
Minter: minter1,
|
|
|
|
Amount: big.NewInt(4e18),
|
|
|
|
Success: false,
|
|
|
|
},
|
|
|
|
// #7, mint 3.5 a0gi by minter 1
|
|
|
|
{
|
|
|
|
IsMint: true,
|
|
|
|
Minter: minter1,
|
|
|
|
Amount: big.NewInt(3e18 + 5e17),
|
|
|
|
Success: true,
|
|
|
|
},
|
|
|
|
}
|
|
|
|
minted := big.NewInt(0)
|
|
|
|
supplied := make(map[common.Address]*big.Int)
|
|
|
|
for id, c := range testCases {
|
|
|
|
fmt.Println(id)
|
|
|
|
if c.IsMint {
|
|
|
|
_, err = s.Keeper.Mint(sdk.WrapSDKContext(s.Ctx), &types.MsgMint{
|
|
|
|
Minter: c.Minter.Bytes(),
|
|
|
|
Amount: c.Amount.Bytes(),
|
|
|
|
})
|
|
|
|
} else {
|
|
|
|
_, err = s.Keeper.Burn(sdk.WrapSDKContext(s.Ctx), &types.MsgBurn{
|
|
|
|
Minter: c.Minter.Bytes(),
|
|
|
|
Amount: c.Amount.Bytes(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
if c.Success {
|
|
|
|
if c.IsMint {
|
|
|
|
minted.Add(minted, c.Amount)
|
|
|
|
if amt, ok := supplied[c.Minter]; ok {
|
|
|
|
amt.Add(amt, c.Amount)
|
|
|
|
} else {
|
|
|
|
supplied[c.Minter] = new(big.Int).Set(c.Amount)
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
minted.Sub(minted, c.Amount)
|
|
|
|
if amt, ok := supplied[c.Minter]; ok {
|
|
|
|
amt.Sub(amt, c.Amount)
|
|
|
|
} else {
|
|
|
|
supplied[c.Minter] = new(big.Int).Set(c.Amount)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
s.Require().NoError(err)
|
|
|
|
response, err := s.Keeper.MinterSupply(s.Ctx, &types.MinterSupplyRequest{
|
|
|
|
Address: c.Minter.Bytes(),
|
|
|
|
})
|
|
|
|
s.Require().NoError(err)
|
|
|
|
s.Require().Equal(supplied[c.Minter].Bytes(), response.Supply)
|
|
|
|
} else {
|
|
|
|
s.Require().Error(err)
|
|
|
|
}
|
|
|
|
coins := precisebankKeeper.GetBalance(s.Ctx, moduleAcc, precisebanktypes.ExtendedCoinDenom)
|
|
|
|
s.Require().Equal(coins.Amount.BigInt(), minted)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func TestMsgServerSuite(t *testing.T) {
|
|
|
|
suite.Run(t, new(MsgServerTestSuite))
|
|
|
|
}
|