diff --git a/.drone.yml b/.drone.yml
index 787f8f7fb..ca3c451f0 100644
--- a/.drone.yml
+++ b/.drone.yml
@@ -77,12 +77,12 @@ steps:
password:
from_secret: docker_password
tags:
- - v10.0.1.alpha-1
+ - v11.0.0-alpha.1
when:
event:
- push
branch:
- - jhernandezb/update-libwasmvm
+ - spoorthi/token-factory
- name: docker_release
image: plugins/docker
settings:
@@ -313,7 +313,7 @@ steps:
environment:
GOPROXY: http://goproxy
- name: stargaze
- image: publicawesome/stargaze:9.0.0
+ image: publicawesome/stargaze:10.0.1
commands:
- ./scripts/ci/upgrade/setup-preinstalled-stargaze.sh
environment:
@@ -350,7 +350,7 @@ steps:
- ./scripts/ci/upgrade/proposal.sh
- name: stargaze-upgraded
pull: always
- image: publicawesome/stargaze:v10.0.1.alpha-1
+ image: publicawesome/stargaze:v11.0.0-alpha.1
commands:
- ./scripts/ci/upgrade/run-upgrade.sh
environment:
@@ -369,7 +369,7 @@ steps:
- http://icad:26657
- name: check-params
pull: always
- image: publicawesome/stargaze:v10.0.1.alpha-1
+ image: publicawesome/stargaze:v11.0.0-alpha.1
commands:
- starsd q globalfee params --node http://stargaze-upgraded:26657
environment:
@@ -411,6 +411,6 @@ volumes:
---
kind: signature
-hmac: b2d583e9b1cde6ac36be1e9c239762e3af7717daf94cf73dd401b9e026866dff
+hmac: 71444d9f3946dc2f7b52f73c6063e53bd69cdcce971772a09d2fc405e7916137
...
diff --git a/app/app.go b/app/app.go
index a086e4097..bc98296ee 100644
--- a/app/app.go
+++ b/app/app.go
@@ -80,6 +80,9 @@ import (
"github.com/public-awesome/stargaze/v11/x/mint"
mintkeeper "github.com/public-awesome/stargaze/v11/x/mint/keeper"
minttypes "github.com/public-awesome/stargaze/v11/x/mint/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory"
+ tokenfactorykeeper "github.com/public-awesome/stargaze/v11/x/tokenfactory/keeper"
+ tokenfactorytypes "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
"github.com/spf13/cast"
abci "github.com/tendermint/tendermint/abci/types"
tmjson "github.com/tendermint/tendermint/libs/json"
@@ -214,6 +217,7 @@ var (
allocmodule.AppModuleBasic{},
cronmodule.AppModuleBasic{},
globalfeemodule.AppModuleBasic{},
+ tokenfactory.AppModuleBasic{},
wasm.AppModuleBasic{},
ica.AppModuleBasic{},
)
@@ -234,6 +238,7 @@ var (
icatypes.ModuleName: nil,
cronmoduletypes.ModuleName: nil,
globalfeemoduletypes.ModuleName: nil,
+ tokenfactorytypes.ModuleName: {authtypes.Minter, authtypes.Burner},
// this line is used by starport scaffolding # stargate/app/maccPerms
}
)
@@ -299,10 +304,11 @@ type App struct {
ScopedWasmKeeper capabilitykeeper.ScopedKeeper
// stargaze modules
- ClaimKeeper claimmodulekeeper.Keeper
- AllocKeeper allocmodulekeeper.Keeper
- CronKeeper cronmodulekeeper.Keeper
- GlobalFeeKeeper globalfeemodulekeeper.Keeper
+ AllocKeeper allocmodulekeeper.Keeper
+ ClaimKeeper claimmodulekeeper.Keeper
+ CronKeeper cronmodulekeeper.Keeper
+ GlobalFeeKeeper globalfeemodulekeeper.Keeper
+ TokenFactoryKeeper tokenfactorykeeper.Keeper
// this line is used by starport scaffolding # stargate/app/keeperDeclaration
// the module manager
@@ -343,6 +349,7 @@ func NewStargazeApp(
authzkeeper.StoreKey,
wasm.StoreKey,
cronmoduletypes.StoreKey,
+ tokenfactorytypes.StoreKey,
icahosttypes.StoreKey,
globalfeemoduletypes.StoreKey,
// this line is used by starport scaffolding # stargate/app/storeKey
@@ -515,12 +522,21 @@ func NewStargazeApp(
// The last arguments can contain custom message handlers, and custom query handlers,
// if we want to allow any custom callbacks
- availableCapabilities := "iterator,staking,stargate,stargaze,cosmwasm_1_1,cosmwasm_1_2"
+ availableCapabilities := "iterator,staking,stargate,stargaze,cosmwasm_1_1,cosmwasm_1_2,token_factory"
+
+ // Wasm accepted Stargate Queries
+ acceptStargateQueriesList := wasmkeeper.AcceptedStargateQueries{
+ "/stargaze.tokenfactory.v1.Query/Params": &tokenfactorytypes.QueryParamsResponse{},
+ "/stargaze.tokenfactory.v1.Query/DenomAuthorityMetadata": &tokenfactorytypes.QueryDenomAuthorityMetadataResponse{},
+ "/stargaze.tokenfactory.v1.Query/DenomsFromCreator": &tokenfactorytypes.QueryDenomsFromCreatorResponse{},
+ }
wasmOpts = append(
wasmOpts,
wasmkeeper.WithMessageEncoders(sgwasm.MessageEncoders(registry)),
- wasmkeeper.WithQueryPlugins(nil),
+ wasmkeeper.WithQueryPlugins(&wasmkeeper.QueryPlugins{
+ Stargate: wasmkeeper.AcceptListStargateQuerier(acceptStargateQueriesList, app.GRPCQueryRouter(), appCodec),
+ }),
)
app.WasmKeeper = wasm.NewKeeper(
appCodec,
@@ -582,6 +598,12 @@ func NewStargazeApp(
)
allocModule := allocmodule.NewAppModule(appCodec, app.AllocKeeper)
+ tokenfactoryKeeper := tokenfactorykeeper.NewKeeper(keys[tokenfactorytypes.StoreKey], app.GetSubspace(tokenfactorytypes.ModuleName),
+ app.AccountKeeper, app.BankKeeper, app.DistrKeeper)
+ app.TokenFactoryKeeper = tokenfactoryKeeper
+
+ // this line is used by starport scaffolding # stargate/app/keeperDefinition
+
/**** Module Options ****/
// NOTE: we may consider parsing `appOpts` inside module constructors. For the moment
@@ -619,6 +641,7 @@ func NewStargazeApp(
wasm.NewAppModule(appCodec, &app.WasmKeeper, app.StakingKeeper, app.AccountKeeper, app.BankKeeper),
cronModule,
globalfeeModule,
+ tokenfactory.NewAppModule(app.TokenFactoryKeeper, app.AccountKeeper, app.BankKeeper),
// this line is used by starport scaffolding # stargate/app/appModule
)
@@ -639,6 +662,7 @@ func NewStargazeApp(
wasm.ModuleName,
cronmoduletypes.ModuleName,
globalfeemoduletypes.ModuleName,
+ tokenfactorytypes.ModuleName,
)
app.mm.SetOrderEndBlockers(
@@ -654,6 +678,7 @@ func NewStargazeApp(
wasm.ModuleName,
cronmoduletypes.ModuleName,
globalfeemoduletypes.ModuleName,
+ tokenfactorytypes.ModuleName,
)
// NOTE: The genutils module must occur after staking so that pools are
@@ -681,6 +706,7 @@ func NewStargazeApp(
paramstypes.ModuleName, upgradetypes.ModuleName, vestingtypes.ModuleName,
claimmoduletypes.ModuleName,
allocmoduletypes.ModuleName,
+ tokenfactorytypes.ModuleName,
// wasm after ibc transfer
wasm.ModuleName,
cronmoduletypes.ModuleName,
@@ -906,6 +932,7 @@ func initParamsKeeper(
paramsKeeper.Subspace(ibchost.ModuleName)
paramsKeeper.Subspace(claimmoduletypes.ModuleName)
paramsKeeper.Subspace(allocmoduletypes.ModuleName)
+ paramsKeeper.Subspace(tokenfactorytypes.ModuleName)
paramsKeeper.Subspace(wasm.ModuleName)
paramsKeeper.Subspace(cronmoduletypes.ModuleName)
paramsKeeper.Subspace(icahosttypes.SubModuleName)
diff --git a/app/upgrades.go b/app/upgrades.go
index 3e7fa7e75..ca70969d6 100644
--- a/app/upgrades.go
+++ b/app/upgrades.go
@@ -7,6 +7,8 @@ import (
sdk "github.com/cosmos/cosmos-sdk/types"
"github.com/cosmos/cosmos-sdk/types/module"
upgradetypes "github.com/cosmos/cosmos-sdk/x/upgrade/types"
+
+ tokenfactorytypes "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
)
// next upgrade name
@@ -20,6 +22,10 @@ func (app *App) RegisterUpgradeHandlers(cfg module.Configurator) {
if err != nil {
return nil, err
}
+ params := app.TokenFactoryKeeper.GetParams(ctx)
+ params.DenomCreationFee = nil
+ params.DenomCreationGasConsume = 50_000_000 // 50STARS at 1ustars
+ app.TokenFactoryKeeper.SetParams(ctx, params)
return migrations, nil
})
@@ -29,7 +35,9 @@ func (app *App) RegisterUpgradeHandlers(cfg module.Configurator) {
}
if upgradeInfo.Name == upgradeName && !app.UpgradeKeeper.IsSkipHeight(upgradeInfo.Height) {
- storeUpgrades := store.StoreUpgrades{}
+ storeUpgrades := store.StoreUpgrades{
+ Added: []string{tokenfactorytypes.ModuleName},
+ }
// configure store loader that checks if version == upgradeHeight and applies store upgrades
app.SetStoreLoader(upgradetypes.UpgradeStoreLoader(upgradeInfo.Height, &storeUpgrades))
}
diff --git a/docs/proto/proto-docs.md b/docs/proto/proto-docs.md
index 28dcd2994..738fa043e 100644
--- a/docs/proto/proto-docs.md
+++ b/docs/proto/proto-docs.md
@@ -4,6 +4,38 @@
## Table of Contents
+- [osmosis/tokenfactory/v1beta1/tokenfactory.proto](#osmosis/tokenfactory/v1beta1/tokenfactory.proto)
+ - [DenomAuthorityMetadata](#osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata)
+ - [Params](#osmosis.tokenfactory.v1beta1.Params)
+
+- [osmosis/tokenfactory/v1beta1/genesis.proto](#osmosis/tokenfactory/v1beta1/genesis.proto)
+ - [GenesisDenom](#osmosis.tokenfactory.v1beta1.GenesisDenom)
+ - [GenesisState](#osmosis.tokenfactory.v1beta1.GenesisState)
+
+- [osmosis/tokenfactory/v1beta1/query.proto](#osmosis/tokenfactory/v1beta1/query.proto)
+ - [QueryDenomAuthorityMetadataRequest](#osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataRequest)
+ - [QueryDenomAuthorityMetadataResponse](#osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataResponse)
+ - [QueryDenomsFromCreatorRequest](#osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorRequest)
+ - [QueryDenomsFromCreatorResponse](#osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorResponse)
+ - [QueryParamsRequest](#osmosis.tokenfactory.v1beta1.QueryParamsRequest)
+ - [QueryParamsResponse](#osmosis.tokenfactory.v1beta1.QueryParamsResponse)
+
+ - [Query](#osmosis.tokenfactory.v1beta1.Query)
+
+- [osmosis/tokenfactory/v1beta1/tx.proto](#osmosis/tokenfactory/v1beta1/tx.proto)
+ - [MsgBurn](#osmosis.tokenfactory.v1beta1.MsgBurn)
+ - [MsgBurnResponse](#osmosis.tokenfactory.v1beta1.MsgBurnResponse)
+ - [MsgChangeAdmin](#osmosis.tokenfactory.v1beta1.MsgChangeAdmin)
+ - [MsgChangeAdminResponse](#osmosis.tokenfactory.v1beta1.MsgChangeAdminResponse)
+ - [MsgCreateDenom](#osmosis.tokenfactory.v1beta1.MsgCreateDenom)
+ - [MsgCreateDenomResponse](#osmosis.tokenfactory.v1beta1.MsgCreateDenomResponse)
+ - [MsgMint](#osmosis.tokenfactory.v1beta1.MsgMint)
+ - [MsgMintResponse](#osmosis.tokenfactory.v1beta1.MsgMintResponse)
+ - [MsgSetDenomMetadata](#osmosis.tokenfactory.v1beta1.MsgSetDenomMetadata)
+ - [MsgSetDenomMetadataResponse](#osmosis.tokenfactory.v1beta1.MsgSetDenomMetadataResponse)
+
+ - [Msg](#osmosis.tokenfactory.v1beta1.Msg)
+
- [stargaze/alloc/v1beta1/params.proto](#stargaze/alloc/v1beta1/params.proto)
- [DistributionProportions](#publicawesome.stargaze.alloc.v1beta1.DistributionProportions)
- [Params](#publicawesome.stargaze.alloc.v1beta1.Params)
@@ -130,6 +162,407 @@
+
+Top
+
+## osmosis/tokenfactory/v1beta1/tokenfactory.proto
+
+
+
+
+
+### DenomAuthorityMetadata
+DenomAuthorityMetadata specifies metadata for addresses that have specific
+capabilities over a token factory denom. Right now there is only one Admin
+permission, but is planned to be extended to the future.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `admin` | [string](#string) | | Can be empty for no admin, or a valid stargaze address |
+
+
+
+
+
+
+
+
+### Params
+Params defines the parameters for the tokenfactory module.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `denom_creation_fee` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | repeated | DenomCreationFee defines the fee to be charged on the creation of a new denom. The fee is drawn from the MsgCreateDenom's sender account, and transferred to the community pool. |
+| `denom_creation_gas_consume` | [uint64](#uint64) | | DenomCreationGasConsume defines the gas cost for creating a new denom. This is intended as a spam deterrence mechanism.
+
+See: https://github.com/CosmWasm/token-factory/issues/11 |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Top
+
+## osmosis/tokenfactory/v1beta1/genesis.proto
+
+
+
+
+
+### GenesisDenom
+GenesisDenom defines a tokenfactory denom that is defined within genesis
+state. The structure contains DenomAuthorityMetadata which defines the
+denom's admin.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `denom` | [string](#string) | | |
+| `authority_metadata` | [DenomAuthorityMetadata](#osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata) | | |
+
+
+
+
+
+
+
+
+### GenesisState
+GenesisState defines the tokenfactory module's genesis state.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `params` | [Params](#osmosis.tokenfactory.v1beta1.Params) | | params defines the paramaters of the module. |
+| `factory_denoms` | [GenesisDenom](#osmosis.tokenfactory.v1beta1.GenesisDenom) | repeated | |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Top
+
+## osmosis/tokenfactory/v1beta1/query.proto
+
+
+
+
+
+### QueryDenomAuthorityMetadataRequest
+QueryDenomAuthorityMetadataRequest defines the request structure for the
+DenomAuthorityMetadata gRPC query.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `denom` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### QueryDenomAuthorityMetadataResponse
+QueryDenomAuthorityMetadataResponse defines the response structure for the
+DenomAuthorityMetadata gRPC query.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `authority_metadata` | [DenomAuthorityMetadata](#osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata) | | |
+
+
+
+
+
+
+
+
+### QueryDenomsFromCreatorRequest
+QueryDenomsFromCreatorRequest defines the request structure for the
+DenomsFromCreator gRPC query.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `creator` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### QueryDenomsFromCreatorResponse
+QueryDenomsFromCreatorRequest defines the response structure for the
+DenomsFromCreator gRPC query.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `denoms` | [string](#string) | repeated | |
+
+
+
+
+
+
+
+
+### QueryParamsRequest
+QueryParamsRequest is the request type for the Query/Params RPC method.
+
+
+
+
+
+
+
+
+### QueryParamsResponse
+QueryParamsResponse is the response type for the Query/Params RPC method.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `params` | [Params](#osmosis.tokenfactory.v1beta1.Params) | | params defines the parameters of the module. |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Query
+Query defines the gRPC querier service.
+
+| Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
+| ----------- | ------------ | ------------- | ------------| ------- | -------- |
+| `Params` | [QueryParamsRequest](#osmosis.tokenfactory.v1beta1.QueryParamsRequest) | [QueryParamsResponse](#osmosis.tokenfactory.v1beta1.QueryParamsResponse) | Params defines a gRPC query method that returns the tokenfactory module's parameters. | GET|/stargaze/tokenfactory/v1/params|
+| `DenomAuthorityMetadata` | [QueryDenomAuthorityMetadataRequest](#osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataRequest) | [QueryDenomAuthorityMetadataResponse](#osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataResponse) | DenomAuthorityMetadata defines a gRPC query method for fetching DenomAuthorityMetadata for a particular denom. | GET|/stargaze/tokenfactory/v1/denoms/{denom}/authority_metadata|
+| `DenomsFromCreator` | [QueryDenomsFromCreatorRequest](#osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorRequest) | [QueryDenomsFromCreatorResponse](#osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorResponse) | DenomsFromCreator defines a gRPC query method for fetching all denominations created by a specific admin/creator. | GET|/stargaze/tokenfactory/v1/denoms_from_creator/{creator}|
+
+
+
+
+
+
+Top
+
+## osmosis/tokenfactory/v1beta1/tx.proto
+
+
+
+
+
+### MsgBurn
+MsgBurn is the sdk.Msg type for allowing an admin account to burn
+a token. For now, we only support burning from the sender account.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `amount` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | |
+| `burnFromAddress` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgBurnResponse
+
+
+
+
+
+
+
+
+
+### MsgChangeAdmin
+MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign
+adminship of a denom to a new account
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `denom` | [string](#string) | | |
+| `new_admin` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgChangeAdminResponse
+MsgChangeAdminResponse defines the response structure for an executed
+MsgChangeAdmin message.
+
+
+
+
+
+
+
+
+### MsgCreateDenom
+MsgCreateDenom defines the message structure for the CreateDenom gRPC service
+method. It allows an account to create a new denom. It requires a sender
+address and a sub denomination. The (sender_address, sub_denomination) tuple
+must be unique and cannot be re-used.
+
+The resulting denom created is defined as
+. The resulting denom's admin is
+originally set to be the creator, but this can be changed later. The token
+denom does not indicate the current admin.
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `subdenom` | [string](#string) | | subdenom can be up to 44 "alphanumeric" characters long. |
+
+
+
+
+
+
+
+
+### MsgCreateDenomResponse
+MsgCreateDenomResponse is the return value of MsgCreateDenom
+It returns the full string of the newly created denom
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `new_token_denom` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgMint
+MsgMint is the sdk.Msg type for allowing an admin account to mint
+more of a token. For now, we only support minting to the sender account
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `amount` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | |
+| `mintToAddress` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgMintResponse
+
+
+
+
+
+
+
+
+
+### MsgSetDenomMetadata
+MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set
+the denom's bank metadata
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `metadata` | [cosmos.bank.v1beta1.Metadata](#cosmos.bank.v1beta1.Metadata) | | |
+
+
+
+
+
+
+
+
+### MsgSetDenomMetadataResponse
+MsgSetDenomMetadataResponse defines the response structure for an executed
+MsgSetDenomMetadata message.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Msg
+Msg defines the tokefactory module's gRPC message service.
+
+| Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
+| ----------- | ------------ | ------------- | ------------| ------- | -------- |
+| `CreateDenom` | [MsgCreateDenom](#osmosis.tokenfactory.v1beta1.MsgCreateDenom) | [MsgCreateDenomResponse](#osmosis.tokenfactory.v1beta1.MsgCreateDenomResponse) | | |
+| `Mint` | [MsgMint](#osmosis.tokenfactory.v1beta1.MsgMint) | [MsgMintResponse](#osmosis.tokenfactory.v1beta1.MsgMintResponse) | | |
+| `Burn` | [MsgBurn](#osmosis.tokenfactory.v1beta1.MsgBurn) | [MsgBurnResponse](#osmosis.tokenfactory.v1beta1.MsgBurnResponse) | | |
+| `ChangeAdmin` | [MsgChangeAdmin](#osmosis.tokenfactory.v1beta1.MsgChangeAdmin) | [MsgChangeAdminResponse](#osmosis.tokenfactory.v1beta1.MsgChangeAdminResponse) | | |
+| `SetDenomMetadata` | [MsgSetDenomMetadata](#osmosis.tokenfactory.v1beta1.MsgSetDenomMetadata) | [MsgSetDenomMetadataResponse](#osmosis.tokenfactory.v1beta1.MsgSetDenomMetadataResponse) | | |
+
+
+
+
+
Top
diff --git a/go.mod b/go.mod
index cf437bb00..e7a6b2f75 100644
--- a/go.mod
+++ b/go.mod
@@ -6,6 +6,7 @@ require (
github.com/CosmWasm/wasmd v0.31.0
github.com/CosmWasm/wasmvm v1.2.4
github.com/armon/go-metrics v0.4.1
+ github.com/cometbft/cometbft v0.37.1
github.com/cosmos/cosmos-proto v1.0.0-beta.2
github.com/cosmos/cosmos-sdk v0.45.16
github.com/cosmos/go-bip39 v1.0.0
@@ -98,7 +99,7 @@ require (
github.com/klauspost/compress v1.15.11 // indirect
github.com/kr/pretty v0.3.1 // indirect
github.com/kr/text v0.2.0 // indirect
- github.com/lib/pq v1.10.6 // indirect
+ github.com/lib/pq v1.10.7 // indirect
github.com/libp2p/go-buffer-pool v0.1.0 // indirect
github.com/linxGnu/grocksdb v1.7.10 // indirect
github.com/magiconair/properties v1.8.6 // indirect
diff --git a/go.sum b/go.sum
index 5a6774c2a..598a4c5d6 100644
--- a/go.sum
+++ b/go.sum
@@ -207,6 +207,8 @@ github.com/coinbase/rosetta-sdk-go v0.7.9 h1:lqllBjMnazTjIqYrOGv8h8jxjg9+hJazIGZ
github.com/coinbase/rosetta-sdk-go v0.7.9/go.mod h1:0/knutI7XGVqXmmH4OQD8OckFrbQ8yMsUZTG7FXCR2M=
github.com/cometbft/cometbft v0.34.27 h1:ri6BvmwjWR0gurYjywcBqRe4bbwc3QVs9KRcCzgh/J0=
github.com/cometbft/cometbft v0.34.27/go.mod h1:BcCbhKv7ieM0KEddnYXvQZR+pZykTKReJJYf7YC7qhw=
+github.com/cometbft/cometbft v0.37.1 h1:KLxkQTK2hICXYq21U2hn1W5hOVYUdQgDQ1uB+90xPIg=
+github.com/cometbft/cometbft v0.37.1/go.mod h1:Y2MMMN//O5K4YKd8ze4r9jmk4Y7h0ajqILXbH5JQFVs=
github.com/cometbft/cometbft-db v0.7.0 h1:uBjbrBx4QzU0zOEnU8KxoDl18dMNgDh+zZRUE0ucsbo=
github.com/cometbft/cometbft-db v0.7.0/go.mod h1:yiKJIm2WKrt6x8Cyxtq9YTEcIMPcEe4XPxhgX59Fzf0=
github.com/confio/ics23/go v0.9.0 h1:cWs+wdbS2KRPZezoaaj+qBleXgUk5WOQFMP3CQFGTr4=
@@ -668,8 +670,8 @@ github.com/leanovate/gopter v0.2.9/go.mod h1:U2L/78B+KVFIx2VmW6onHJQzXtFb+p5y3y2
github.com/leodido/go-urn v1.2.1 h1:BqpAaACuzVSgi/VLzGZIobT2z4v53pjosyNd9Yv6n/w=
github.com/leodido/go-urn v1.2.1/go.mod h1:zt4jvISO2HfUBqxjfIshjdMTYS56ZS/qv49ictyFfxY=
github.com/lib/pq v1.0.0/go.mod h1:5WUZQaWbwv1U+lTReE5YruASi9Al49XbQIvNi/34Woo=
-github.com/lib/pq v1.10.6 h1:jbk+ZieJ0D7EVGJYpL9QTz7/YW6UHbmdnZWYyK5cdBs=
-github.com/lib/pq v1.10.6/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
+github.com/lib/pq v1.10.7 h1:p7ZhMD+KsSRozJr34udlUrhboJwWAgCg34+/ZZNvZZw=
+github.com/lib/pq v1.10.7/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/libp2p/go-buffer-pool v0.1.0 h1:oK4mSFcQz7cTQIfqbe4MIj9gLW+mnanjyFtc6cdF0Y8=
github.com/libp2p/go-buffer-pool v0.1.0/go.mod h1:N+vh8gMqimBzdKkSMVuydVDq+UV5QTWy5HSiZacSbPg=
github.com/lightstep/lightstep-tracer-common/golang/gogo v0.0.0-20190605223551-bc2310a04743/go.mod h1:qklhhLq1aX+mtWk9cPHPzaBjWImj5ULL6C7HFJtXQMM=
@@ -773,8 +775,8 @@ github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W
github.com/onsi/ginkgo v1.10.3/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
github.com/onsi/ginkgo v1.13.0/go.mod h1:+REjRxOmWfHCjfv9TTWB1jD1Frx4XydAD3zm1lskyM0=
-github.com/onsi/ginkgo v1.14.0 h1:2mOpI4JVVPBN+WQRa0WKH2eXR+Ey+uK4n7Zj0aYpIQA=
github.com/onsi/ginkgo v1.14.0/go.mod h1:iSB4RoI2tjJc9BBv4NKIKWKya62Rps+oPG/Lv9klQyY=
+github.com/onsi/ginkgo v1.16.4 h1:29JGrr5oVBm5ulCWet69zQkzWipVXIol6ygQUe/EzNc=
github.com/onsi/gomega v1.4.1/go.mod h1:C1qb7wdrVGGVU+Z6iS04AVkA3Q65CEZX59MT0QO5uiA=
github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
diff --git a/proto/osmosis/tokenfactory/v1beta1/genesis.proto b/proto/osmosis/tokenfactory/v1beta1/genesis.proto
new file mode 100644
index 000000000..b3b270077
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/genesis.proto
@@ -0,0 +1,31 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "osmosis/tokenfactory/v1beta1/tokenfactory.proto";
+
+option go_package = "github.com/public-awesome/stargaze/v10/x/tokenfactory/types";
+
+// GenesisState defines the tokenfactory module's genesis state.
+message GenesisState {
+ // params defines the paramaters of the module.
+ Params params = 1 [ (gogoproto.nullable) = false ];
+
+ repeated GenesisDenom factory_denoms = 2 [
+ (gogoproto.moretags) = "yaml:\"factory_denoms\"",
+ (gogoproto.nullable) = false
+ ];
+}
+
+// GenesisDenom defines a tokenfactory denom that is defined within genesis
+// state. The structure contains DenomAuthorityMetadata which defines the
+// denom's admin.
+message GenesisDenom {
+ option (gogoproto.equal) = true;
+
+ string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ];
+ DenomAuthorityMetadata authority_metadata = 2 [
+ (gogoproto.moretags) = "yaml:\"authority_metadata\"",
+ (gogoproto.nullable) = false
+ ];
+}
\ No newline at end of file
diff --git a/proto/osmosis/tokenfactory/v1beta1/query.proto b/proto/osmosis/tokenfactory/v1beta1/query.proto
new file mode 100644
index 000000000..94e2f4860
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/query.proto
@@ -0,0 +1,70 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "google/api/annotations.proto";
+import "cosmos/base/query/v1beta1/pagination.proto";
+import "osmosis/tokenfactory/v1beta1/tokenfactory.proto";
+
+option go_package = "github.com/public-awesome/stargaze/v10/x/tokenfactory/types";
+
+// Query defines the gRPC querier service.
+service Query {
+ // Params defines a gRPC query method that returns the tokenfactory module's
+ // parameters.
+ rpc Params(QueryParamsRequest) returns (QueryParamsResponse) {
+ option (google.api.http).get = "/stargaze/tokenfactory/v1/params";
+ }
+
+ // DenomAuthorityMetadata defines a gRPC query method for fetching
+ // DenomAuthorityMetadata for a particular denom.
+ rpc DenomAuthorityMetadata(QueryDenomAuthorityMetadataRequest)
+ returns (QueryDenomAuthorityMetadataResponse) {
+ option (google.api.http).get =
+ "/stargaze/tokenfactory/v1/denoms/{denom}/authority_metadata";
+ }
+
+ // DenomsFromCreator defines a gRPC query method for fetching all
+ // denominations created by a specific admin/creator.
+ rpc DenomsFromCreator(QueryDenomsFromCreatorRequest)
+ returns (QueryDenomsFromCreatorResponse) {
+ option (google.api.http).get =
+ "/stargaze/tokenfactory/v1/denoms_from_creator/{creator}";
+ }
+}
+
+// QueryParamsRequest is the request type for the Query/Params RPC method.
+message QueryParamsRequest {}
+
+// QueryParamsResponse is the response type for the Query/Params RPC method.
+message QueryParamsResponse {
+ // params defines the parameters of the module.
+ Params params = 1 [ (gogoproto.nullable) = false ];
+}
+
+// QueryDenomAuthorityMetadataRequest defines the request structure for the
+// DenomAuthorityMetadata gRPC query.
+message QueryDenomAuthorityMetadataRequest {
+ string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ];
+}
+
+// QueryDenomAuthorityMetadataResponse defines the response structure for the
+// DenomAuthorityMetadata gRPC query.
+message QueryDenomAuthorityMetadataResponse {
+ DenomAuthorityMetadata authority_metadata = 1 [
+ (gogoproto.moretags) = "yaml:\"authority_metadata\"",
+ (gogoproto.nullable) = false
+ ];
+}
+
+// QueryDenomsFromCreatorRequest defines the request structure for the
+// DenomsFromCreator gRPC query.
+message QueryDenomsFromCreatorRequest {
+ string creator = 1 [ (gogoproto.moretags) = "yaml:\"creator\"" ];
+}
+
+// QueryDenomsFromCreatorRequest defines the response structure for the
+// DenomsFromCreator gRPC query.
+message QueryDenomsFromCreatorResponse {
+ repeated string denoms = 1 [ (gogoproto.moretags) = "yaml:\"denoms\"" ];
+}
\ No newline at end of file
diff --git a/proto/osmosis/tokenfactory/v1beta1/tokenfactory.proto b/proto/osmosis/tokenfactory/v1beta1/tokenfactory.proto
new file mode 100644
index 000000000..d2b187942
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/tokenfactory.proto
@@ -0,0 +1,39 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos_proto/cosmos.proto";
+import "cosmos/base/v1beta1/coin.proto";
+
+option go_package = "github.com/public-awesome/stargaze/v10/x/tokenfactory/types";
+
+// DenomAuthorityMetadata specifies metadata for addresses that have specific
+// capabilities over a token factory denom. Right now there is only one Admin
+// permission, but is planned to be extended to the future.
+message DenomAuthorityMetadata {
+ option (gogoproto.equal) = true;
+
+ // Can be empty for no admin, or a valid stargaze address
+ string admin = 1 [ (gogoproto.moretags) = "yaml:\"admin\"" ];
+}
+
+// Params defines the parameters for the tokenfactory module.
+message Params {
+ // DenomCreationFee defines the fee to be charged on the creation of a new
+ // denom. The fee is drawn from the MsgCreateDenom's sender account, and
+ // transferred to the community pool.
+ repeated cosmos.base.v1beta1.Coin denom_creation_fee = 1 [
+ (gogoproto.castrepeated) = "github.com/cosmos/cosmos-sdk/types.Coins",
+ (gogoproto.moretags) = "yaml:\"denom_creation_fee\"",
+ (gogoproto.nullable) = false
+ ];
+
+ // DenomCreationGasConsume defines the gas cost for creating a new denom.
+ // This is intended as a spam deterrence mechanism.
+ //
+ // See: https://github.com/CosmWasm/token-factory/issues/11
+ uint64 denom_creation_gas_consume = 2 [
+ (gogoproto.moretags) = "yaml:\"denom_creation_gas_consume\"",
+ (gogoproto.nullable) = true
+ ];
+}
\ No newline at end of file
diff --git a/proto/osmosis/tokenfactory/v1beta1/tx.proto b/proto/osmosis/tokenfactory/v1beta1/tx.proto
new file mode 100644
index 000000000..1a71d9d88
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/tx.proto
@@ -0,0 +1,94 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos/base/v1beta1/coin.proto";
+import "cosmos/bank/v1beta1/bank.proto";
+
+option go_package = "github.com/public-awesome/stargaze/v10/x/tokenfactory/types";
+
+// Msg defines the tokefactory module's gRPC message service.
+service Msg {
+ rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse);
+ rpc Mint(MsgMint) returns (MsgMintResponse);
+ rpc Burn(MsgBurn) returns (MsgBurnResponse);
+ rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse);
+ rpc SetDenomMetadata(MsgSetDenomMetadata)
+ returns (MsgSetDenomMetadataResponse);
+}
+
+// MsgCreateDenom defines the message structure for the CreateDenom gRPC service
+// method. It allows an account to create a new denom. It requires a sender
+// address and a sub denomination. The (sender_address, sub_denomination) tuple
+// must be unique and cannot be re-used.
+//
+// The resulting denom created is defined as
+// . The resulting denom's admin is
+// originally set to be the creator, but this can be changed later. The token
+// denom does not indicate the current admin.
+message MsgCreateDenom {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ // subdenom can be up to 44 "alphanumeric" characters long.
+ string subdenom = 2 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ];
+}
+
+// MsgCreateDenomResponse is the return value of MsgCreateDenom
+// It returns the full string of the newly created denom
+message MsgCreateDenomResponse {
+ string new_token_denom = 1
+ [ (gogoproto.moretags) = "yaml:\"new_token_denom\"" ];
+}
+
+// MsgMint is the sdk.Msg type for allowing an admin account to mint
+// more of a token. For now, we only support minting to the sender account
+message MsgMint {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ cosmos.base.v1beta1.Coin amount = 2 [
+ (gogoproto.moretags) = "yaml:\"amount\"",
+ (gogoproto.nullable) = false
+ ];
+ string mintToAddress = 3
+ [ (gogoproto.moretags) = "yaml:\"mint_to_address\"" ];
+}
+
+message MsgMintResponse {}
+
+// MsgBurn is the sdk.Msg type for allowing an admin account to burn
+// a token. For now, we only support burning from the sender account.
+message MsgBurn {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ cosmos.base.v1beta1.Coin amount = 2 [
+ (gogoproto.moretags) = "yaml:\"amount\"",
+ (gogoproto.nullable) = false
+ ];
+ string burnFromAddress = 3
+ [ (gogoproto.moretags) = "yaml:\"burn_from_address\"" ];
+}
+
+message MsgBurnResponse {}
+
+// MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign
+// adminship of a denom to a new account
+message MsgChangeAdmin {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ string denom = 2 [ (gogoproto.moretags) = "yaml:\"denom\"" ];
+ string new_admin = 3 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ];
+}
+
+// MsgChangeAdminResponse defines the response structure for an executed
+// MsgChangeAdmin message.
+message MsgChangeAdminResponse {}
+
+// MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set
+// the denom's bank metadata
+message MsgSetDenomMetadata {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ cosmos.bank.v1beta1.Metadata metadata = 2 [
+ (gogoproto.moretags) = "yaml:\"metadata\"",
+ (gogoproto.nullable) = false
+ ];
+}
+
+// MsgSetDenomMetadataResponse defines the response structure for an executed
+// MsgSetDenomMetadata message.
+message MsgSetDenomMetadataResponse {}
diff --git a/scripts/ci/upgrade/proposal.sh b/scripts/ci/upgrade/proposal.sh
index c862abac1..a5b6e3dbd 100755
--- a/scripts/ci/upgrade/proposal.sh
+++ b/scripts/ci/upgrade/proposal.sh
@@ -13,10 +13,10 @@ HEIGHT=$(starsd status --node http://stargaze:26657 --home $STARGAZE_HOME | jq .
echo "current height $HEIGHT"
HEIGHT=$(expr $HEIGHT + 20)
echo "submit with height $HEIGHT"
-starsd tx gov submit-proposal software-upgrade v10 --upgrade-height $HEIGHT \
+starsd tx gov submit-proposal software-upgrade v11 --upgrade-height $HEIGHT \
--deposit 1000000000ustars \
---description "v10 Upgrade" \
---title "v10 Upgrade" \
+--description "v11 Upgrade" \
+--title "v11 Upgrade" \
--gas-prices 1ustars --gas auto --gas-adjustment 1.5 --from validator \
--chain-id stargaze -b block --yes --node http://stargaze:26657 --home $STARGAZE_HOME --keyring-backend test
diff --git a/x/tokenfactory/README.md b/x/tokenfactory/README.md
new file mode 100644
index 000000000..25a7963bd
--- /dev/null
+++ b/x/tokenfactory/README.md
@@ -0,0 +1,14 @@
+# Token Factory
+
+The code of x/tokenfactory is taken from Osmosis [v15.1.0](https://github.com/osmosis-labs/osmosis/releases/tag/v15.1.0)
+
+The module additionally includes the changes by [larry0x](https://github.com/larry0x) which allows the denom creation to consume gas if denom creation fee is set to zero. https://github.com/osmosis-labs/osmosis/pull/4983
+
+The module implementation details can be found [here](https://github.com/osmosis-labs/osmosis/blob/v15.1.0/x/tokenfactory/README.md)
+
+
+## Attribution
+Thanks to [Osmosis-labs](https://github.com/osmosis-labs) for the tokenfactory module implementation, which was largely extracted as-is to be included in Stargaze.
+
+
+Original source of token factory module: [x/tokenfactory](https://github.com/osmosis-labs/osmosis/blob/v15.1.0/x/tokenfactory/README.md)
\ No newline at end of file
diff --git a/x/tokenfactory/client/cli/query.go b/x/tokenfactory/client/cli/query.go
new file mode 100644
index 000000000..0fc05d143
--- /dev/null
+++ b/x/tokenfactory/client/cli/query.go
@@ -0,0 +1,111 @@
+package cli
+
+import (
+ "fmt"
+
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/spf13/cobra"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/client/flags"
+)
+
+// GetQueryCmd returns the cli query commands for this module
+func GetQueryCmd() *cobra.Command {
+ // Group tokenfactory queries under a subcommand
+ cmd := &cobra.Command{
+ Use: types.ModuleName,
+ Short: fmt.Sprintf("Querying commands for the %s module", types.ModuleName),
+ DisableFlagParsing: true,
+ SuggestionsMinimumDistance: 2,
+ RunE: client.ValidateCmd,
+ }
+
+ cmd.AddCommand(GetCmdDenomAuthorityMetadata())
+ cmd.AddCommand(GetCmdDenomsFromCreator())
+ cmd.AddCommand(GetParams())
+
+ return cmd
+}
+
+// GetCmdDenomAuthorityMetadata returns the authority metadata for a queried denom
+func GetCmdDenomAuthorityMetadata() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "denom-authority-metadata [denom] [flags]",
+ Short: "Get the authority metadata for a specific denom",
+ Args: cobra.ExactArgs(1),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientQueryContext(cmd)
+ if err != nil {
+ return err
+ }
+ queryClient := types.NewQueryClient(clientCtx)
+
+ res, err := queryClient.DenomAuthorityMetadata(cmd.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: args[0],
+ })
+ if err != nil {
+ return err
+ }
+
+ return clientCtx.PrintProto(res)
+ },
+ }
+
+ flags.AddQueryFlagsToCmd(cmd)
+
+ return cmd
+}
+
+// GetCmdDenomsFromCreator a command to get a list of all tokens created by a specific creator address
+func GetCmdDenomsFromCreator() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "denoms-from-creator [creator address] [flags]",
+ Short: "Returns a list of all tokens created by a specific creator address",
+ Args: cobra.ExactArgs(1),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientQueryContext(cmd)
+ if err != nil {
+ return err
+ }
+ queryClient := types.NewQueryClient(clientCtx)
+
+ res, err := queryClient.DenomsFromCreator(cmd.Context(), &types.QueryDenomsFromCreatorRequest{
+ Creator: args[0],
+ })
+ if err != nil {
+ return err
+ }
+
+ return clientCtx.PrintProto(res)
+ },
+ }
+
+ flags.AddQueryFlagsToCmd(cmd)
+ return cmd
+}
+
+// GetParams returns the params for the module
+func GetParams() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "params [flags]",
+ Short: "Get the params for the x/tokenfactory module",
+ Args: cobra.ExactArgs(0),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientQueryContext(cmd)
+ if err != nil {
+ return err
+ }
+ queryClient := types.NewQueryClient(clientCtx)
+
+ res, err := queryClient.Params(cmd.Context(), &types.QueryParamsRequest{})
+ if err != nil {
+ return err
+ }
+ return clientCtx.PrintProto(res)
+ },
+ }
+
+ flags.AddQueryFlagsToCmd(cmd)
+ return cmd
+}
diff --git a/x/tokenfactory/client/cli/tx.go b/x/tokenfactory/client/cli/tx.go
new file mode 100644
index 000000000..84a1523d9
--- /dev/null
+++ b/x/tokenfactory/client/cli/tx.go
@@ -0,0 +1,149 @@
+package cli
+
+import (
+ "fmt"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/client/flags"
+ "github.com/cosmos/cosmos-sdk/client/tx"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/spf13/cobra"
+)
+
+// GetTxCmd returns the transaction commands for this module
+func GetTxCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: types.ModuleName,
+ Short: fmt.Sprintf("%s transactions subcommands", types.ModuleName),
+ DisableFlagParsing: true,
+ SuggestionsMinimumDistance: 2,
+ RunE: client.ValidateCmd,
+ }
+
+ cmd.AddCommand(NewCreateDenomCmd())
+ cmd.AddCommand(NewMintCmd())
+ cmd.AddCommand(NewBurnCmd())
+ cmd.AddCommand(NewChangeAdminCmd())
+
+ return cmd
+}
+
+// NewCreateDenomCmd broadcast MsgCreateDenom
+func NewCreateDenomCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "create-denom [subdenom] [flags]",
+ Short: "create a new denom from an account",
+ Args: cobra.ExactArgs(1),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientTxContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ txf := tx.NewFactoryCLI(clientCtx, cmd.Flags()).WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever)
+
+ msg := types.NewMsgCreateDenom(
+ clientCtx.GetFromAddress().String(),
+ args[0],
+ )
+
+ return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+ },
+ }
+
+ flags.AddTxFlagsToCmd(cmd)
+ return cmd
+}
+
+// NewMintCmd broadcast MsgMint
+func NewMintCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "mint [amount] [flags]",
+ Short: "Mint a denom to an address. Must have admin authority to do so.",
+ Args: cobra.ExactArgs(1),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientTxContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ txf := tx.NewFactoryCLI(clientCtx, cmd.Flags()).WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever)
+
+ amount, err := sdk.ParseCoinNormalized(args[0])
+ if err != nil {
+ return err
+ }
+
+ msg := types.NewMsgMint(
+ clientCtx.GetFromAddress().String(),
+ amount,
+ )
+
+ return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+ },
+ }
+
+ flags.AddTxFlagsToCmd(cmd)
+ return cmd
+}
+
+// NewBurnCmd broadcast MsgBurn
+func NewBurnCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "burn [amount] [flags]",
+ Short: "Burn tokens from an address. Must have admin authority to do so.",
+ Args: cobra.ExactArgs(1),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientTxContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ txf := tx.NewFactoryCLI(clientCtx, cmd.Flags()).WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever)
+
+ amount, err := sdk.ParseCoinNormalized(args[0])
+ if err != nil {
+ return err
+ }
+
+ msg := types.NewMsgBurn(
+ clientCtx.GetFromAddress().String(),
+ amount,
+ )
+
+ return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+ },
+ }
+
+ flags.AddTxFlagsToCmd(cmd)
+ return cmd
+}
+
+// NewChangeAdminCmd broadcast MsgChangeAdmin
+func NewChangeAdminCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "change-admin [denom] [new-admin-address] [flags]",
+ Short: "Changes the admin address for a factory-created denom. Must have admin authority to do so.",
+ Args: cobra.ExactArgs(2),
+ RunE: func(cmd *cobra.Command, args []string) error {
+ clientCtx, err := client.GetClientTxContext(cmd)
+ if err != nil {
+ return err
+ }
+
+ txf := tx.NewFactoryCLI(clientCtx, cmd.Flags()).WithTxConfig(clientCtx.TxConfig).WithAccountRetriever(clientCtx.AccountRetriever)
+
+ msg := types.NewMsgChangeAdmin(
+ clientCtx.GetFromAddress().String(),
+ args[0],
+ args[1],
+ )
+
+ return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+ },
+ }
+
+ flags.AddTxFlagsToCmd(cmd)
+ return cmd
+}
diff --git a/x/tokenfactory/keeper/admins.go b/x/tokenfactory/keeper/admins.go
new file mode 100644
index 000000000..aeeb9d1da
--- /dev/null
+++ b/x/tokenfactory/keeper/admins.go
@@ -0,0 +1,48 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/gogo/protobuf/proto"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+// GetAuthorityMetadata returns the authority metadata for a specific denom
+func (k Keeper) GetAuthorityMetadata(ctx sdk.Context, denom string) (types.DenomAuthorityMetadata, error) {
+ bz := k.GetDenomPrefixStore(ctx, denom).Get([]byte(types.DenomAuthorityMetadataKey))
+
+ metadata := types.DenomAuthorityMetadata{}
+ err := proto.Unmarshal(bz, &metadata)
+ if err != nil {
+ return types.DenomAuthorityMetadata{}, err
+ }
+ return metadata, nil
+}
+
+// setAuthorityMetadata stores authority metadata for a specific denom
+func (k Keeper) setAuthorityMetadata(ctx sdk.Context, denom string, metadata types.DenomAuthorityMetadata) error {
+ err := metadata.Validate()
+ if err != nil {
+ return err
+ }
+
+ store := k.GetDenomPrefixStore(ctx, denom)
+
+ bz, err := proto.Marshal(&metadata)
+ if err != nil {
+ return err
+ }
+
+ store.Set([]byte(types.DenomAuthorityMetadataKey), bz)
+ return nil
+}
+
+func (k Keeper) setAdmin(ctx sdk.Context, denom string, admin string) error {
+ metadata, err := k.GetAuthorityMetadata(ctx, denom)
+ if err != nil {
+ return err
+ }
+
+ metadata.Admin = admin
+
+ return k.setAuthorityMetadata(ctx, denom, metadata)
+}
diff --git a/x/tokenfactory/keeper/admins_test.go b/x/tokenfactory/keeper/admins_test.go
new file mode 100644
index 000000000..680a362e8
--- /dev/null
+++ b/x/tokenfactory/keeper/admins_test.go
@@ -0,0 +1,396 @@
+package keeper_test
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+func (suite *KeeperTestSuite) TestAdminMsgs() {
+ addr0bal := int64(0)
+ addr1bal := int64(0)
+
+ bankKeeper := suite.App.BankKeeper
+
+ suite.CreateDefaultDenom()
+ // Make sure that the admin is set correctly
+ queryRes, err := suite.queryClient.DenomAuthorityMetadata(suite.Ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: suite.defaultDenom,
+ })
+ suite.Require().NoError(err)
+ suite.Require().Equal(suite.TestAccs[0].String(), queryRes.AuthorityMetadata.Admin)
+
+ // Test minting to admins own account
+ _, err = suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), types.NewMsgMint(suite.TestAccs[0].String(), sdk.NewInt64Coin(suite.defaultDenom, 10)))
+ addr0bal += 10
+ suite.Require().NoError(err)
+ suite.Require().True(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom).Amount.Int64() == addr0bal, bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom))
+
+ // Test burning from own account
+ _, err = suite.msgServer.Burn(sdk.WrapSDKContext(suite.Ctx), types.NewMsgBurn(suite.TestAccs[0].String(), sdk.NewInt64Coin(suite.defaultDenom, 5)))
+ addr0bal -= 5
+ suite.Require().NoError(err)
+ suite.Require().True(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[1], suite.defaultDenom).Amount.Int64() == addr1bal)
+
+ // Test Change Admin
+ _, err = suite.msgServer.ChangeAdmin(sdk.WrapSDKContext(suite.Ctx), types.NewMsgChangeAdmin(suite.TestAccs[0].String(), suite.defaultDenom, suite.TestAccs[1].String()))
+ queryRes, err = suite.queryClient.DenomAuthorityMetadata(suite.Ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: suite.defaultDenom,
+ })
+ suite.Require().NoError(err)
+ suite.Require().Equal(suite.TestAccs[1].String(), queryRes.AuthorityMetadata.Admin)
+
+ // Make sure old admin can no longer do actions
+ _, err = suite.msgServer.Burn(sdk.WrapSDKContext(suite.Ctx), types.NewMsgBurn(suite.TestAccs[0].String(), sdk.NewInt64Coin(suite.defaultDenom, 5)))
+ suite.Require().Error(err)
+
+ // Make sure the new admin works
+ _, err = suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), types.NewMsgMint(suite.TestAccs[1].String(), sdk.NewInt64Coin(suite.defaultDenom, 5)))
+ addr1bal += 5
+ suite.Require().NoError(err)
+ suite.Require().True(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[1], suite.defaultDenom).Amount.Int64() == addr1bal)
+
+ // Try setting admin to empty
+ _, err = suite.msgServer.ChangeAdmin(sdk.WrapSDKContext(suite.Ctx), types.NewMsgChangeAdmin(suite.TestAccs[1].String(), suite.defaultDenom, ""))
+ suite.Require().NoError(err)
+ queryRes, err = suite.queryClient.DenomAuthorityMetadata(suite.Ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: suite.defaultDenom,
+ })
+ suite.Require().NoError(err)
+ suite.Require().Equal("", queryRes.AuthorityMetadata.Admin)
+}
+
+// TestMintDenom ensures the following properties of the MintMessage:
+// * Noone can mint tokens for a denom that doesn't exist
+// * Only the admin of a denom can mint tokens for it
+// * The admin of a denom can mint tokens for it
+func (suite *KeeperTestSuite) TestMintDenom() {
+ var addr0bal int64
+
+ // Create a denom
+ suite.CreateDefaultDenom()
+
+ for _, tc := range []struct {
+ desc string
+ amount int64
+ mintDenom string
+ admin string
+ valid bool
+ }{
+ {
+ desc: "denom does not exist",
+ amount: 10,
+ mintDenom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/evmos",
+ admin: suite.TestAccs[0].String(),
+ valid: false,
+ },
+ {
+ desc: "mint is not by the admin",
+ amount: 10,
+ mintDenom: suite.defaultDenom,
+ admin: suite.TestAccs[1].String(),
+ valid: false,
+ },
+ {
+ desc: "success case",
+ amount: 10,
+ mintDenom: suite.defaultDenom,
+ admin: suite.TestAccs[0].String(),
+ valid: true,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ // Test minting to admins own account
+ bankKeeper := suite.App.BankKeeper
+ _, err := suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), types.NewMsgMint(tc.admin, sdk.NewInt64Coin(tc.mintDenom, 10)))
+ if tc.valid {
+ addr0bal += 10
+ suite.Require().NoError(err)
+ suite.Require().Equal(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom).Amount.Int64(), addr0bal, bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom))
+ } else {
+ suite.Require().Error(err)
+ }
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestBurnDenom() {
+ var addr0bal int64
+
+ // Create a denom.
+ suite.CreateDefaultDenom()
+
+ // mint 10 default token for testAcc[0]
+ suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), types.NewMsgMint(suite.TestAccs[0].String(), sdk.NewInt64Coin(suite.defaultDenom, 10)))
+ addr0bal += 10
+
+ for _, tc := range []struct {
+ desc string
+ amount int64
+ burnDenom string
+ admin string
+ valid bool
+ }{
+ {
+ desc: "denom does not exist",
+ amount: 10,
+ burnDenom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/evmos",
+ admin: suite.TestAccs[0].String(),
+ valid: false,
+ },
+ {
+ desc: "burn is not by the admin",
+ amount: 10,
+ burnDenom: suite.defaultDenom,
+ admin: suite.TestAccs[1].String(),
+ valid: false,
+ },
+ {
+ desc: "burn amount is bigger than minted amount",
+ amount: 1000,
+ burnDenom: suite.defaultDenom,
+ admin: suite.TestAccs[1].String(),
+ valid: false,
+ },
+ {
+ desc: "success case",
+ amount: 10,
+ burnDenom: suite.defaultDenom,
+ admin: suite.TestAccs[0].String(),
+ valid: true,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ // Test minting to admins own account
+ bankKeeper := suite.App.BankKeeper
+ _, err := suite.msgServer.Burn(sdk.WrapSDKContext(suite.Ctx), types.NewMsgBurn(tc.admin, sdk.NewInt64Coin(tc.burnDenom, 10)))
+ if tc.valid {
+ addr0bal -= 10
+ suite.Require().NoError(err)
+ suite.Require().True(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom).Amount.Int64() == addr0bal, bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom))
+ } else {
+ suite.Require().Error(err)
+ suite.Require().True(bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom).Amount.Int64() == addr0bal, bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], suite.defaultDenom))
+ }
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestChangeAdminDenom() {
+ for _, tc := range []struct {
+ desc string
+ msgChangeAdmin func(denom string) *types.MsgChangeAdmin
+ expectedChangeAdminPass bool
+ expectedAdminIndex int
+ msgMint func(denom string) *types.MsgMint
+ expectedMintPass bool
+ }{
+ {
+ desc: "creator admin can't mint after setting to '' ",
+ msgChangeAdmin: func(denom string) *types.MsgChangeAdmin {
+ return types.NewMsgChangeAdmin(suite.TestAccs[0].String(), denom, "")
+ },
+ expectedChangeAdminPass: true,
+ expectedAdminIndex: -1,
+ msgMint: func(denom string) *types.MsgMint {
+ return types.NewMsgMint(suite.TestAccs[0].String(), sdk.NewInt64Coin(denom, 5))
+ },
+ expectedMintPass: false,
+ },
+ {
+ desc: "non-admins can't change the existing admin",
+ msgChangeAdmin: func(denom string) *types.MsgChangeAdmin {
+ return types.NewMsgChangeAdmin(suite.TestAccs[1].String(), denom, suite.TestAccs[2].String())
+ },
+ expectedChangeAdminPass: false,
+ expectedAdminIndex: 0,
+ },
+ {
+ desc: "success change admin",
+ msgChangeAdmin: func(denom string) *types.MsgChangeAdmin {
+ return types.NewMsgChangeAdmin(suite.TestAccs[0].String(), denom, suite.TestAccs[1].String())
+ },
+ expectedAdminIndex: 1,
+ expectedChangeAdminPass: true,
+ msgMint: func(denom string) *types.MsgMint {
+ return types.NewMsgMint(suite.TestAccs[1].String(), sdk.NewInt64Coin(denom, 5))
+ },
+ expectedMintPass: true,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ // setup test
+ suite.SetupTest()
+
+ // Create a denom and mint
+ res, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "bitcoin"))
+ suite.Require().NoError(err)
+
+ testDenom := res.GetNewTokenDenom()
+
+ _, err = suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), types.NewMsgMint(suite.TestAccs[0].String(), sdk.NewInt64Coin(testDenom, 10)))
+ suite.Require().NoError(err)
+
+ _, err = suite.msgServer.ChangeAdmin(sdk.WrapSDKContext(suite.Ctx), tc.msgChangeAdmin(testDenom))
+ if tc.expectedChangeAdminPass {
+ suite.Require().NoError(err)
+ } else {
+ suite.Require().Error(err)
+ }
+
+ queryRes, err := suite.queryClient.DenomAuthorityMetadata(suite.Ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: testDenom,
+ })
+ suite.Require().NoError(err)
+
+ // expectedAdminIndex with negative value is assumed as admin with value of ""
+ const emptyStringAdminIndexFlag = -1
+ if tc.expectedAdminIndex == emptyStringAdminIndexFlag {
+ suite.Require().Equal("", queryRes.AuthorityMetadata.Admin)
+ } else {
+ suite.Require().Equal(suite.TestAccs[tc.expectedAdminIndex].String(), queryRes.AuthorityMetadata.Admin)
+ }
+
+ // we test mint to test if admin authority is performed properly after admin change.
+ if tc.msgMint != nil {
+ _, err := suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), tc.msgMint(testDenom))
+ if tc.expectedMintPass {
+ suite.Require().NoError(err)
+ } else {
+ suite.Require().Error(err)
+ }
+ }
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestSetDenomMetaData() {
+ // setup test
+ suite.SetupTest()
+ suite.CreateDefaultDenom()
+
+ for _, tc := range []struct {
+ desc string
+ msgSetDenomMetadata types.MsgSetDenomMetadata
+ expectedPass bool
+ }{
+ {
+ desc: "successful set denom metadata",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[0].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: suite.defaultDenom,
+ Exponent: 0,
+ },
+ {
+ Denom: "utest",
+ Exponent: 6,
+ },
+ },
+ Base: suite.defaultDenom,
+ Display: "utest",
+ Name: "TEST",
+ Symbol: "TEST",
+ }),
+ expectedPass: true,
+ },
+ {
+ desc: "non existent factory denom name",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[0].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: fmt.Sprintf("factory/%s/litecoin", suite.TestAccs[0].String()),
+ Exponent: 0,
+ },
+ {
+ Denom: "utest",
+ Exponent: 6,
+ },
+ },
+ Base: fmt.Sprintf("factory/%s/litecoin", suite.TestAccs[0].String()),
+ Display: "utest",
+ Name: "TEST",
+ Symbol: "TEST",
+ }),
+ expectedPass: false,
+ },
+ {
+ desc: "non-factory denom",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[0].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: "utest",
+ Exponent: 0,
+ },
+ {
+ Denom: "ufest",
+ Exponent: 6,
+ },
+ },
+ Base: "utest",
+ Display: "ufest",
+ Name: "TEST",
+ Symbol: "TEST",
+ }),
+ expectedPass: false,
+ },
+ {
+ desc: "wrong admin",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[1].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: suite.defaultDenom,
+ Exponent: 0,
+ },
+ {
+ Denom: "utest",
+ Exponent: 6,
+ },
+ },
+ Base: suite.defaultDenom,
+ Display: "utest",
+ Name: "TEST",
+ Symbol: "TEST",
+ }),
+ expectedPass: false,
+ },
+ {
+ desc: "invalid metadata (missing display denom unit)",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[0].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: suite.defaultDenom,
+ Exponent: 0,
+ },
+ },
+ Base: suite.defaultDenom,
+ Display: "utest",
+ Name: "TEST",
+ Symbol: "TEST",
+ }),
+ expectedPass: false,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ bankKeeper := suite.App.BankKeeper
+ res, err := suite.msgServer.SetDenomMetadata(sdk.WrapSDKContext(suite.Ctx), &tc.msgSetDenomMetadata)
+ if tc.expectedPass {
+ suite.Require().NoError(err)
+ suite.Require().NotNil(res)
+
+ md, found := bankKeeper.GetDenomMetaData(suite.Ctx, suite.defaultDenom)
+ suite.Require().True(found)
+ suite.Require().Equal(tc.msgSetDenomMetadata.Metadata.Name, md.Name)
+ } else {
+ suite.Require().Error(err)
+ }
+ })
+ }
+}
diff --git a/x/tokenfactory/keeper/bank_actions.go b/x/tokenfactory/keeper/bank_actions.go
new file mode 100644
index 000000000..b7f919660
--- /dev/null
+++ b/x/tokenfactory/keeper/bank_actions.go
@@ -0,0 +1,51 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+func (k Keeper) mintTo(ctx sdk.Context, amount sdk.Coin, mintTo string) error {
+ // verify that denom is an x/tokenfactory denom
+ _, _, err := types.DeconstructDenom(amount.Denom)
+ if err != nil {
+ return err
+ }
+
+ err = k.bankKeeper.MintCoins(ctx, types.ModuleName, sdk.NewCoins(amount))
+ if err != nil {
+ return err
+ }
+
+ addr, err := sdk.AccAddressFromBech32(mintTo)
+ if err != nil {
+ return err
+ }
+
+ return k.bankKeeper.SendCoinsFromModuleToAccount(ctx, types.ModuleName,
+ addr,
+ sdk.NewCoins(amount))
+}
+
+func (k Keeper) burnFrom(ctx sdk.Context, amount sdk.Coin, burnFrom string) error {
+ // verify that denom is an x/tokenfactory denom
+ _, _, err := types.DeconstructDenom(amount.Denom)
+ if err != nil {
+ return err
+ }
+
+ addr, err := sdk.AccAddressFromBech32(burnFrom)
+ if err != nil {
+ return err
+ }
+
+ err = k.bankKeeper.SendCoinsFromAccountToModule(ctx,
+ addr,
+ types.ModuleName,
+ sdk.NewCoins(amount))
+ if err != nil {
+ return err
+ }
+
+ return k.bankKeeper.BurnCoins(ctx, types.ModuleName, sdk.NewCoins(amount))
+}
diff --git a/x/tokenfactory/keeper/create_denom.go b/x/tokenfactory/keeper/create_denom.go
new file mode 100644
index 000000000..1d3fba947
--- /dev/null
+++ b/x/tokenfactory/keeper/create_denom.go
@@ -0,0 +1,94 @@
+package keeper
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+// ConvertToBaseToken converts a fee amount in a whitelisted fee token to the base fee token amount
+func (k Keeper) CreateDenom(ctx sdk.Context, creatorAddr string, subdenom string) (newTokenDenom string, err error) {
+ denom, err := k.validateCreateDenom(ctx, creatorAddr, subdenom)
+ if err != nil {
+ return "", err
+ }
+
+ err = k.chargeForCreateDenom(ctx, creatorAddr, subdenom)
+ if err != nil {
+ return "", err
+ }
+
+ err = k.createDenomAfterValidation(ctx, creatorAddr, denom)
+ return denom, err
+}
+
+// Runs CreateDenom logic after the charge and all denom validation has been handled.
+// Made into a second function for genesis initialization.
+func (k Keeper) createDenomAfterValidation(ctx sdk.Context, creatorAddr string, denom string) (err error) {
+ denomMetaData := banktypes.Metadata{
+ DenomUnits: []*banktypes.DenomUnit{{
+ Denom: denom,
+ Exponent: 0,
+ }},
+ Base: denom,
+ }
+
+ k.bankKeeper.SetDenomMetaData(ctx, denomMetaData)
+
+ authorityMetadata := types.DenomAuthorityMetadata{
+ Admin: creatorAddr,
+ }
+ err = k.setAuthorityMetadata(ctx, denom, authorityMetadata)
+ if err != nil {
+ return err
+ }
+
+ k.addDenomFromCreator(ctx, creatorAddr, denom)
+ return nil
+}
+
+func (k Keeper) validateCreateDenom(ctx sdk.Context, creatorAddr string, subdenom string) (newTokenDenom string, err error) {
+ // Temporary check until IBC bug is sorted out
+ if k.bankKeeper.HasSupply(ctx, subdenom) {
+ return "", fmt.Errorf("temporary error until IBC bug is sorted out, " +
+ "can't create subdenoms that are the same as a native denom")
+ }
+
+ denom, err := types.GetTokenDenom(creatorAddr, subdenom)
+ if err != nil {
+ return "", err
+ }
+
+ _, found := k.bankKeeper.GetDenomMetaData(ctx, denom)
+ if found {
+ return "", types.ErrDenomExists
+ }
+
+ return denom, nil
+}
+
+func (k Keeper) chargeForCreateDenom(ctx sdk.Context, creatorAddr string, _ string) (err error) {
+ params := k.GetParams(ctx)
+
+ // if DenomCreationFee is non-zero, transfer the tokens from the creator
+ // account to community pool
+ if params.DenomCreationFee != nil {
+ accAddr, err := sdk.AccAddressFromBech32(creatorAddr)
+ if err != nil {
+ return err
+ }
+
+ if err := k.communityPoolKeeper.FundCommunityPool(ctx, params.DenomCreationFee, accAddr); err != nil {
+ return err
+ }
+ }
+
+ // if DenomCreationGasConsume is non-zero, consume the gas
+ if params.DenomCreationGasConsume != 0 {
+ ctx.GasMeter().ConsumeGas(params.DenomCreationGasConsume, "consume denom creation gas")
+ }
+
+ return nil
+}
diff --git a/x/tokenfactory/keeper/create_denom_test.go b/x/tokenfactory/keeper/create_denom_test.go
new file mode 100644
index 000000000..0c2995266
--- /dev/null
+++ b/x/tokenfactory/keeper/create_denom_test.go
@@ -0,0 +1,225 @@
+package keeper_test
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+func (suite *KeeperTestSuite) TestMsgCreateDenom() {
+ var (
+ tokenFactoryKeeper = suite.App.TokenFactoryKeeper
+ bankKeeper = suite.App.BankKeeper
+ denomCreationFee = tokenFactoryKeeper.GetParams(suite.Ctx).DenomCreationFee
+ )
+
+ // Get balance of acc 0 before creating a denom
+ preCreateBalance := bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], denomCreationFee[0].Denom)
+
+ // Creating a denom should work
+ res, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "testy"))
+ suite.Require().NoError(err)
+ suite.Require().NotEmpty(res.GetNewTokenDenom())
+
+ // Make sure that the admin is set correctly
+ queryRes, err := suite.queryClient.DenomAuthorityMetadata(suite.Ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: res.GetNewTokenDenom(),
+ })
+ suite.Require().NoError(err)
+ suite.Require().Equal(suite.TestAccs[0].String(), queryRes.AuthorityMetadata.Admin)
+
+ // Make sure that creation fee was deducted
+ postCreateBalance := bankKeeper.GetBalance(suite.Ctx, suite.TestAccs[0], tokenFactoryKeeper.GetParams(suite.Ctx).DenomCreationFee[0].Denom)
+ suite.Require().True(preCreateBalance.Sub(postCreateBalance).IsEqual(denomCreationFee[0]))
+
+ // Make sure that a second version of the same denom can't be recreated
+ res, err = suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "testy"))
+ suite.Require().Error(err)
+
+ // Creating a second denom should work
+ res, err = suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "minty"))
+ suite.Require().NoError(err)
+ suite.Require().NotEmpty(res.GetNewTokenDenom())
+
+ // Try querying all the denoms created by suite.TestAccs[0]
+ queryRes2, err := suite.queryClient.DenomsFromCreator(suite.Ctx.Context(), &types.QueryDenomsFromCreatorRequest{
+ Creator: suite.TestAccs[0].String(),
+ })
+ suite.Require().NoError(err)
+ suite.Require().Len(queryRes2.Denoms, 2)
+
+ // Make sure that a second account can create a denom with the same subdenom
+ res, err = suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[1].String(), "testy"))
+ suite.Require().NoError(err)
+ suite.Require().NotEmpty(res.GetNewTokenDenom())
+
+ // Make sure that an address with a "/" in it can't create denoms
+ res, err = suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom("stargaze.stars/creator", "testy"))
+ suite.Require().Error(err)
+}
+
+func (suite *KeeperTestSuite) TestCreateDenom() {
+ var (
+ primaryDenom = types.DefaultParams().DenomCreationFee[0].Denom
+ defaultDenomCreationFee = types.Params{DenomCreationFee: sdk.NewCoins(sdk.NewCoin(primaryDenom, sdk.NewInt(50000000)))}
+ twoDenomCreationFee = types.Params{DenomCreationFee: sdk.NewCoins(sdk.NewCoin(primaryDenom, sdk.NewInt(50000000)), sdk.NewCoin("utest", sdk.NewInt(50000000)))}
+ nilCreationFee = types.Params{DenomCreationFee: nil}
+ largeCreationFee = types.Params{DenomCreationFee: sdk.NewCoins(sdk.NewCoin(primaryDenom, sdk.NewInt(5000000000)))}
+ )
+
+ for _, tc := range []struct {
+ desc string
+ denomCreationFee types.Params
+ setup func()
+ subdenom string
+ valid bool
+ }{
+ {
+ desc: "subdenom too long",
+ denomCreationFee: defaultDenomCreationFee,
+ subdenom: "assadsadsadasdasdsadsadsadsadsadsadsklkadaskkkdasdasedskhanhassyeunganassfnlksdflksafjlkasd",
+ valid: false,
+ },
+ {
+ desc: "subdenom and creator pair already exists",
+ denomCreationFee: defaultDenomCreationFee,
+ setup: func() {
+ _, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "testy"))
+ suite.Require().NoError(err)
+ },
+ subdenom: "testy",
+ valid: false,
+ },
+ {
+ desc: "success case: defaultDenomCreationFee",
+ denomCreationFee: defaultDenomCreationFee,
+ subdenom: "evmos",
+ valid: true,
+ },
+ {
+ desc: "success case: twoDenomCreationFee",
+ denomCreationFee: twoDenomCreationFee,
+ subdenom: "catcoin",
+ valid: true,
+ },
+ {
+ desc: "success case: nilCreationFee",
+ denomCreationFee: nilCreationFee,
+ subdenom: "bzzzcoin",
+ valid: true,
+ },
+ {
+ desc: "account doesn't have enough to pay for denom creation fee",
+ denomCreationFee: largeCreationFee,
+ subdenom: "tooexpensive",
+ valid: false,
+ },
+ {
+ desc: "subdenom having invalid characters",
+ denomCreationFee: defaultDenomCreationFee,
+ subdenom: "bit/***///&&&/coin",
+ valid: false,
+ },
+ } {
+ suite.SetupTest()
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ if tc.setup != nil {
+ tc.setup()
+ }
+ tokenFactoryKeeper := suite.App.TokenFactoryKeeper
+ bankKeeper := suite.App.BankKeeper
+ // Set denom creation fee in params
+ tokenFactoryKeeper.SetParams(suite.Ctx, tc.denomCreationFee)
+ denomCreationFee := tokenFactoryKeeper.GetParams(suite.Ctx).DenomCreationFee
+ suite.Require().Equal(tc.denomCreationFee.DenomCreationFee, denomCreationFee)
+
+ // note balance, create a tokenfactory denom, then note balance again
+ preCreateBalance := bankKeeper.GetAllBalances(suite.Ctx, suite.TestAccs[0])
+ res, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), tc.subdenom))
+ postCreateBalance := bankKeeper.GetAllBalances(suite.Ctx, suite.TestAccs[0])
+ if tc.valid {
+ suite.Require().NoError(err)
+ suite.Require().True(preCreateBalance.Sub(postCreateBalance).IsEqual(denomCreationFee))
+
+ // Make sure that the admin is set correctly
+ queryRes, err := suite.queryClient.DenomAuthorityMetadata(suite.Ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: res.GetNewTokenDenom(),
+ })
+
+ suite.Require().NoError(err)
+ suite.Require().Equal(suite.TestAccs[0].String(), queryRes.AuthorityMetadata.Admin)
+
+ } else {
+ suite.Require().Error(err)
+ // Ensure we don't charge if we expect an error
+ suite.Require().True(preCreateBalance.IsEqual(postCreateBalance))
+ }
+ })
+ }
+}
+
+func (suite *KeeperTestSuite) TestGasConsume() {
+ // It's hard to estimate exactly how much gas will be consumed when creating a
+ // denom, because besides consuming the gas specified by the params, the keeper
+ // also does a bunch of other things that consume gas.
+ //
+ // Rather, we test whether the gas consumed is within a range. Specifically,
+ // the range [gasConsume, gasConsume + offset]. If the actual gas consumption
+ // falls within the range for all test cases, we consider the test passed.
+ //
+ // In experience, the total amount of gas consumed should consume be ~30k more
+ // than the set amount.
+ const offset = 50000
+
+ for _, tc := range []struct {
+ desc string
+ gasConsume uint64
+ }{
+ {
+ desc: "gas consume zero",
+ gasConsume: 0,
+ },
+ {
+ desc: "gas consume 1,000,000",
+ gasConsume: 1_000_000,
+ },
+ {
+ desc: "gas consume 10,000,000",
+ gasConsume: 10_000_000,
+ },
+ {
+ desc: "gas consume 25,000,000",
+ gasConsume: 25_000_000,
+ },
+ {
+ desc: "gas consume 50,000,000",
+ gasConsume: 50_000_000,
+ },
+ {
+ desc: "gas consume 200,000,000",
+ gasConsume: 200_000_000,
+ },
+ } {
+ suite.SetupTest()
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ // set params with the gas consume amount
+ suite.App.TokenFactoryKeeper.SetParams(suite.Ctx, types.NewParams(nil, tc.gasConsume))
+
+ // amount of gas consumed prior to the denom creation
+ gasConsumedBefore := suite.Ctx.GasMeter().GasConsumed()
+
+ // create a denom
+ _, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "larry"))
+ suite.Require().NoError(err)
+
+ // amount of gas consumed after the denom creation
+ gasConsumedAfter := suite.Ctx.GasMeter().GasConsumed()
+
+ // the amount of gas consumed must be within the range
+ gasConsumed := gasConsumedAfter - gasConsumedBefore
+ suite.Require().Greater(gasConsumed, tc.gasConsume)
+ suite.Require().Less(gasConsumed, tc.gasConsume+offset)
+ })
+ }
+}
diff --git a/x/tokenfactory/keeper/creators.go b/x/tokenfactory/keeper/creators.go
new file mode 100644
index 000000000..c3145474e
--- /dev/null
+++ b/x/tokenfactory/keeper/creators.go
@@ -0,0 +1,27 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (k Keeper) addDenomFromCreator(ctx sdk.Context, creator, denom string) {
+ store := k.GetCreatorPrefixStore(ctx, creator)
+ store.Set([]byte(denom), []byte(denom))
+}
+
+func (k Keeper) getDenomsFromCreator(ctx sdk.Context, creator string) []string {
+ store := k.GetCreatorPrefixStore(ctx, creator)
+
+ iterator := store.Iterator(nil, nil)
+ defer iterator.Close()
+
+ denoms := []string{}
+ for ; iterator.Valid(); iterator.Next() {
+ denoms = append(denoms, string(iterator.Key()))
+ }
+ return denoms
+}
+
+func (k Keeper) GetAllDenomsIterator(ctx sdk.Context) sdk.Iterator {
+ return k.GetCreatorsPrefixStore(ctx).Iterator(nil, nil)
+}
diff --git a/x/tokenfactory/keeper/genesis.go b/x/tokenfactory/keeper/genesis.go
new file mode 100644
index 000000000..d3903aaf8
--- /dev/null
+++ b/x/tokenfactory/keeper/genesis.go
@@ -0,0 +1,57 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+// InitGenesis initializes the tokenfactory module's state from a provided genesis
+// state.
+func (k Keeper) InitGenesis(ctx sdk.Context, genState types.GenesisState) {
+ k.CreateModuleAccount(ctx)
+
+ if genState.Params.DenomCreationFee == nil {
+ genState.Params.DenomCreationFee = sdk.NewCoins()
+ }
+ k.SetParams(ctx, genState.Params)
+
+ for _, genDenom := range genState.GetFactoryDenoms() {
+ creator, _, err := types.DeconstructDenom(genDenom.GetDenom())
+ if err != nil {
+ panic(err)
+ }
+ err = k.createDenomAfterValidation(ctx, creator, genDenom.GetDenom())
+ if err != nil {
+ panic(err)
+ }
+ err = k.setAuthorityMetadata(ctx, genDenom.GetDenom(), genDenom.GetAuthorityMetadata())
+ if err != nil {
+ panic(err)
+ }
+ }
+}
+
+// ExportGenesis returns the tokenfactory module's exported genesis.
+func (k Keeper) ExportGenesis(ctx sdk.Context) *types.GenesisState {
+ genDenoms := []types.GenesisDenom{}
+ iterator := k.GetAllDenomsIterator(ctx)
+ defer iterator.Close()
+ for ; iterator.Valid(); iterator.Next() {
+ denom := string(iterator.Value())
+
+ authorityMetadata, err := k.GetAuthorityMetadata(ctx, denom)
+ if err != nil {
+ panic(err)
+ }
+
+ genDenoms = append(genDenoms, types.GenesisDenom{
+ Denom: denom,
+ AuthorityMetadata: authorityMetadata,
+ })
+ }
+
+ return &types.GenesisState{
+ FactoryDenoms: genDenoms,
+ Params: k.GetParams(ctx),
+ }
+}
diff --git a/x/tokenfactory/keeper/genesis_test.go b/x/tokenfactory/keeper/genesis_test.go
new file mode 100644
index 000000000..d21919e84
--- /dev/null
+++ b/x/tokenfactory/keeper/genesis_test.go
@@ -0,0 +1,58 @@
+package keeper_test
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+func (suite *KeeperTestSuite) TestGenesis() {
+ genesisState := types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ },
+ },
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/diff-admin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "cosmos15czt5nhlnvayqq37xun9s9yus0d6y26dx74r5p",
+ },
+ },
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/litecoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ },
+ },
+ },
+ }
+
+ suite.SetupTestForInitGenesis()
+ app := suite.App
+
+ // Test both with bank denom metadata set, and not set.
+ for i, denom := range genesisState.FactoryDenoms {
+ // hacky, sets bank metadata to exist if i != 0, to cover both cases.
+ if i != 0 {
+ app.BankKeeper.SetDenomMetaData(suite.Ctx, banktypes.Metadata{Base: denom.GetDenom()})
+ }
+ }
+
+ // check before initGenesis that the module account is nil
+ tokenfactoryModuleAccount := app.AccountKeeper.GetAccount(suite.Ctx, app.AccountKeeper.GetModuleAddress(types.ModuleName))
+ suite.Require().Nil(tokenfactoryModuleAccount)
+
+ app.TokenFactoryKeeper.SetParams(suite.Ctx, types.Params{DenomCreationFee: sdk.Coins{sdk.NewInt64Coin("utest", 100)}})
+ app.TokenFactoryKeeper.InitGenesis(suite.Ctx, genesisState)
+
+ // check that the module account is now initialized
+ tokenfactoryModuleAccount = app.AccountKeeper.GetAccount(suite.Ctx, app.AccountKeeper.GetModuleAddress(types.ModuleName))
+ suite.Require().NotNil(tokenfactoryModuleAccount)
+
+ exportedGenesis := app.TokenFactoryKeeper.ExportGenesis(suite.Ctx)
+ suite.Require().NotNil(exportedGenesis)
+ suite.Require().Equal(genesisState, *exportedGenesis)
+}
diff --git a/x/tokenfactory/keeper/grpc_query.go b/x/tokenfactory/keeper/grpc_query.go
new file mode 100644
index 000000000..3dddce168
--- /dev/null
+++ b/x/tokenfactory/keeper/grpc_query.go
@@ -0,0 +1,34 @@
+package keeper
+
+import (
+ "context"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+var _ types.QueryServer = Keeper{}
+
+func (k Keeper) Params(ctx context.Context, _ *types.QueryParamsRequest) (*types.QueryParamsResponse, error) {
+ sdkCtx := sdk.UnwrapSDKContext(ctx)
+ params := k.GetParams(sdkCtx)
+
+ return &types.QueryParamsResponse{Params: params}, nil
+}
+
+func (k Keeper) DenomAuthorityMetadata(ctx context.Context, req *types.QueryDenomAuthorityMetadataRequest) (*types.QueryDenomAuthorityMetadataResponse, error) {
+ sdkCtx := sdk.UnwrapSDKContext(ctx)
+
+ authorityMetadata, err := k.GetAuthorityMetadata(sdkCtx, req.GetDenom())
+ if err != nil {
+ return nil, err
+ }
+
+ return &types.QueryDenomAuthorityMetadataResponse{AuthorityMetadata: authorityMetadata}, nil
+}
+
+func (k Keeper) DenomsFromCreator(ctx context.Context, req *types.QueryDenomsFromCreatorRequest) (*types.QueryDenomsFromCreatorResponse, error) {
+ sdkCtx := sdk.UnwrapSDKContext(ctx)
+ denoms := k.getDenomsFromCreator(sdkCtx, req.GetCreator())
+ return &types.QueryDenomsFromCreatorResponse{Denoms: denoms}, nil
+}
diff --git a/x/tokenfactory/keeper/keeper.go b/x/tokenfactory/keeper/keeper.go
new file mode 100644
index 000000000..ac282c069
--- /dev/null
+++ b/x/tokenfactory/keeper/keeper.go
@@ -0,0 +1,80 @@
+package keeper
+
+import (
+ "fmt"
+
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/tendermint/tendermint/libs/log"
+
+ "github.com/cosmos/cosmos-sdk/store/prefix"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+)
+
+type (
+ Keeper struct {
+ storeKey sdk.StoreKey
+
+ paramSpace paramtypes.Subspace
+
+ accountKeeper types.AccountKeeper
+ bankKeeper types.BankKeeper
+ communityPoolKeeper types.CommunityPoolKeeper
+ }
+)
+
+// NewKeeper returns a new instance of the x/tokenfactory keeper
+func NewKeeper(
+ storeKey sdk.StoreKey,
+ paramSpace paramtypes.Subspace,
+ accountKeeper types.AccountKeeper,
+ bankKeeper types.BankKeeper,
+ communityPoolKeeper types.CommunityPoolKeeper,
+) Keeper {
+ if !paramSpace.HasKeyTable() {
+ paramSpace = paramSpace.WithKeyTable(types.ParamKeyTable())
+ }
+
+ return Keeper{
+ storeKey: storeKey,
+ paramSpace: paramSpace,
+
+ accountKeeper: accountKeeper,
+ bankKeeper: bankKeeper,
+ communityPoolKeeper: communityPoolKeeper,
+ }
+}
+
+// Logger returns a logger for the x/tokenfactory module
+func (k Keeper) Logger(ctx sdk.Context) log.Logger {
+ return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
+}
+
+// GetDenomPrefixStore returns the substore for a specific denom
+func (k Keeper) GetDenomPrefixStore(ctx sdk.Context, denom string) sdk.KVStore {
+ store := ctx.KVStore(k.storeKey)
+ return prefix.NewStore(store, types.GetDenomPrefixStore(denom))
+}
+
+// GetCreatorPrefixStore returns the substore for a specific creator address
+func (k Keeper) GetCreatorPrefixStore(ctx sdk.Context, creator string) sdk.KVStore {
+ store := ctx.KVStore(k.storeKey)
+ return prefix.NewStore(store, types.GetCreatorPrefix(creator))
+}
+
+// GetCreatorsPrefixStore returns the substore that contains a list of creators
+func (k Keeper) GetCreatorsPrefixStore(ctx sdk.Context) sdk.KVStore {
+ store := ctx.KVStore(k.storeKey)
+ return prefix.NewStore(store, types.GetCreatorsPrefix())
+}
+
+// CreateModuleAccount creates a module account with minting and burning capabilities
+// This account isn't intended to store any coins,
+// it purely mints and burns them on behalf of the admin of respective denoms,
+// and sends to the relevant address.
+func (k Keeper) CreateModuleAccount(ctx sdk.Context) {
+ moduleAcc := authtypes.NewEmptyModuleAccount(types.ModuleName, authtypes.Minter, authtypes.Burner)
+ k.accountKeeper.SetModuleAccount(ctx, moduleAcc)
+}
diff --git a/x/tokenfactory/keeper/keeper_test.go b/x/tokenfactory/keeper/keeper_test.go
new file mode 100644
index 000000000..67abde9dd
--- /dev/null
+++ b/x/tokenfactory/keeper/keeper_test.go
@@ -0,0 +1,132 @@
+package keeper_test
+
+import (
+ "testing"
+
+ "github.com/cometbft/cometbft/crypto/ed25519"
+ "github.com/cosmos/cosmos-sdk/baseapp"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+ minttypes "github.com/cosmos/cosmos-sdk/x/mint/types"
+ stargazeapp "github.com/public-awesome/stargaze/v11/app"
+ "github.com/public-awesome/stargaze/v11/testutil/simapp"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/keeper"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/stretchr/testify/suite"
+ tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+)
+
+type KeeperTestSuite struct {
+ suite.Suite
+
+ App *stargazeapp.App
+ Ctx sdk.Context
+ QueryHelper *baseapp.QueryServiceTestHelper
+ TestAccs []sdk.AccAddress
+
+ queryClient types.QueryClient
+ msgServer types.MsgServer
+ // defaultDenom is on the suite, as it depends on the creator test address.
+ defaultDenom string
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+ suite.Run(t, new(KeeperTestSuite))
+}
+
+func (suite *KeeperTestSuite) TestCreateModuleAccount() {
+ app := suite.App
+
+ // remove module account
+ tokenfactoryModuleAccount := app.AccountKeeper.GetAccount(suite.Ctx, app.AccountKeeper.GetModuleAddress(types.ModuleName))
+ app.AccountKeeper.RemoveAccount(suite.Ctx, tokenfactoryModuleAccount)
+
+ // ensure module account was removed
+ suite.Ctx = app.BaseApp.NewContext(false, tmproto.Header{})
+ tokenfactoryModuleAccount = app.AccountKeeper.GetAccount(suite.Ctx, app.AccountKeeper.GetModuleAddress(types.ModuleName))
+ suite.Require().Nil(tokenfactoryModuleAccount)
+
+ // create module account
+ app.TokenFactoryKeeper.CreateModuleAccount(suite.Ctx)
+
+ // check that the module account is now initialized
+ tokenfactoryModuleAccount = app.AccountKeeper.GetAccount(suite.Ctx, app.AccountKeeper.GetModuleAddress(types.ModuleName))
+ suite.Require().NotNil(tokenfactoryModuleAccount)
+}
+
+func (suite *KeeperTestSuite) SetupTest() {
+ suite.Setup()
+ // Fund every TestAcc with two denoms, one of which is the denom creation fee
+ fundAccsAmount := sdk.NewCoins(
+ sdk.NewCoin(types.DefaultParams().DenomCreationFee[0].Denom, types.DefaultParams().DenomCreationFee[0].Amount.MulRaw(100)),
+ sdk.NewCoin("utest", sdk.NewInt(5000000000)),
+ )
+ for _, acc := range suite.TestAccs {
+ suite.FundAcc(acc, fundAccsAmount)
+ }
+
+ suite.queryClient = types.NewQueryClient(suite.QueryHelper)
+ suite.msgServer = keeper.NewMsgServerImpl(suite.App.TokenFactoryKeeper)
+}
+
+func (suite *KeeperTestSuite) CreateDefaultDenom() {
+ res, _ := suite.msgServer.CreateDenom(sdk.WrapSDKContext(suite.Ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "bitcoin"))
+ suite.defaultDenom = res.GetNewTokenDenom()
+}
+
+func (suite *KeeperTestSuite) Setup() {
+ suite.App = simapp.New(suite.T().TempDir())
+ suite.Ctx = suite.App.BaseApp.NewContext(false, tmproto.Header{})
+ suite.QueryHelper = &baseapp.QueryServiceTestHelper{
+ GRPCQueryRouter: suite.App.GRPCQueryRouter(),
+ Ctx: suite.Ctx,
+ }
+ suite.TestAccs = createRandomAccounts(3)
+}
+
+func (suite *KeeperTestSuite) SetupTestForInitGenesis() {
+ // Setting to True, leads to init genesis not running
+ suite.App = simapp.New(suite.T().TempDir())
+ suite.Ctx = suite.App.BaseApp.NewContext(true, tmproto.Header{})
+}
+
+// AssertEventEmitted asserts that ctx's event manager has emitted the given number of events
+// of the given type.
+func (suite *KeeperTestSuite) AssertEventEmitted(ctx sdk.Context, eventTypeExpected string, numEventsExpected int) {
+ allEvents := ctx.EventManager().Events()
+ // filter out other events
+ actualEvents := make([]sdk.Event, 0)
+ for _, event := range allEvents {
+ if event.Type == eventTypeExpected {
+ actualEvents = append(actualEvents, event)
+ }
+ }
+ suite.Equal(numEventsExpected, len(actualEvents))
+}
+
+// FundAcc funds target address with specified amount.
+func (s *KeeperTestSuite) FundAcc(acc sdk.AccAddress, amounts sdk.Coins) {
+ err := FundAccount(s.App.BankKeeper, s.Ctx, acc, amounts)
+ s.Require().NoError(err)
+}
+
+// FundAccount is a utility function that funds an account by minting and
+// sending the coins to the address. This should be used for testing purposes
+// only!
+func FundAccount(bankKeeper bankkeeper.Keeper, ctx sdk.Context, addr sdk.AccAddress, amounts sdk.Coins) error {
+ if err := bankKeeper.MintCoins(ctx, minttypes.ModuleName, amounts); err != nil {
+ return err
+ }
+
+ return bankKeeper.SendCoinsFromModuleToAccount(ctx, minttypes.ModuleName, addr, amounts)
+}
+
+// createRandomAccounts is a function return a list of randomly generated AccAddresses
+func createRandomAccounts(numAccts int) []sdk.AccAddress {
+ testAddrs := make([]sdk.AccAddress, numAccts)
+ for i := 0; i < numAccts; i++ {
+ pk := ed25519.GenPrivKey().PubKey()
+ testAddrs[i] = sdk.AccAddress(pk.Address())
+ }
+ return testAddrs
+}
diff --git a/x/tokenfactory/keeper/msg_server.go b/x/tokenfactory/keeper/msg_server.go
new file mode 100644
index 000000000..19aca1db2
--- /dev/null
+++ b/x/tokenfactory/keeper/msg_server.go
@@ -0,0 +1,161 @@
+package keeper
+
+import (
+ "context"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+type msgServer struct {
+ Keeper
+}
+
+// NewMsgServerImpl returns an implementation of the MsgServer interface
+// for the provided Keeper.
+func NewMsgServerImpl(keeper Keeper) types.MsgServer {
+ return &msgServer{Keeper: keeper}
+}
+
+var _ types.MsgServer = msgServer{}
+
+func (server msgServer) CreateDenom(goCtx context.Context, msg *types.MsgCreateDenom) (*types.MsgCreateDenomResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ denom, err := server.Keeper.CreateDenom(ctx, msg.Sender, msg.Subdenom)
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgCreateDenom,
+ sdk.NewAttribute(types.AttributeCreator, msg.Sender),
+ sdk.NewAttribute(types.AttributeNewTokenDenom, denom),
+ ),
+ })
+
+ return &types.MsgCreateDenomResponse{
+ NewTokenDenom: denom,
+ }, nil
+}
+
+func (server msgServer) Mint(goCtx context.Context, msg *types.MsgMint) (*types.MsgMintResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ // pay some extra gas cost to give a better error here.
+ _, denomExists := server.bankKeeper.GetDenomMetaData(ctx, msg.Amount.Denom)
+ if !denomExists {
+ return nil, types.ErrDenomDoesNotExist.Wrapf("denom: %s", msg.Amount.Denom)
+ }
+
+ authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Amount.GetDenom())
+ if err != nil {
+ return nil, err
+ }
+
+ if msg.Sender != authorityMetadata.GetAdmin() {
+ return nil, types.ErrUnauthorized
+ }
+
+ err = server.Keeper.mintTo(ctx, msg.Amount, msg.Sender)
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgMint,
+ sdk.NewAttribute(types.AttributeMintToAddress, msg.Sender),
+ sdk.NewAttribute(types.AttributeAmount, msg.Amount.String()),
+ ),
+ })
+
+ return &types.MsgMintResponse{}, nil
+}
+
+func (server msgServer) Burn(goCtx context.Context, msg *types.MsgBurn) (*types.MsgBurnResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Amount.GetDenom())
+ if err != nil {
+ return nil, err
+ }
+
+ if msg.Sender != authorityMetadata.GetAdmin() {
+ return nil, types.ErrUnauthorized
+ }
+
+ err = server.Keeper.burnFrom(ctx, msg.Amount, msg.Sender)
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgBurn,
+ sdk.NewAttribute(types.AttributeBurnFromAddress, msg.Sender),
+ sdk.NewAttribute(types.AttributeAmount, msg.Amount.String()),
+ ),
+ })
+
+ return &types.MsgBurnResponse{}, nil
+}
+
+func (server msgServer) ChangeAdmin(goCtx context.Context, msg *types.MsgChangeAdmin) (*types.MsgChangeAdminResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Denom)
+ if err != nil {
+ return nil, err
+ }
+
+ if msg.Sender != authorityMetadata.GetAdmin() {
+ return nil, types.ErrUnauthorized
+ }
+
+ err = server.Keeper.setAdmin(ctx, msg.Denom, msg.NewAdmin)
+ if err != nil {
+ return nil, err
+ }
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgChangeAdmin,
+ sdk.NewAttribute(types.AttributeDenom, msg.GetDenom()),
+ sdk.NewAttribute(types.AttributeNewAdmin, msg.NewAdmin),
+ ),
+ })
+
+ return &types.MsgChangeAdminResponse{}, nil
+}
+
+func (server msgServer) SetDenomMetadata(goCtx context.Context, msg *types.MsgSetDenomMetadata) (*types.MsgSetDenomMetadataResponse, error) {
+ ctx := sdk.UnwrapSDKContext(goCtx)
+
+ // Defense in depth validation of metadata
+ err := msg.Metadata.Validate()
+ if err != nil {
+ return nil, err
+ }
+
+ authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Metadata.Base)
+ if err != nil {
+ return nil, err
+ }
+
+ if msg.Sender != authorityMetadata.GetAdmin() {
+ return nil, types.ErrUnauthorized
+ }
+
+ server.Keeper.bankKeeper.SetDenomMetaData(ctx, msg.Metadata)
+
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgSetDenomMetadata,
+ sdk.NewAttribute(types.AttributeDenom, msg.Metadata.Base),
+ sdk.NewAttribute(types.AttributeDenomMetadata, msg.Metadata.String()),
+ ),
+ })
+
+ return &types.MsgSetDenomMetadataResponse{}, nil
+}
diff --git a/x/tokenfactory/keeper/msg_server_test.go b/x/tokenfactory/keeper/msg_server_test.go
new file mode 100644
index 000000000..48ef6324f
--- /dev/null
+++ b/x/tokenfactory/keeper/msg_server_test.go
@@ -0,0 +1,246 @@
+package keeper_test
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+// TestMintDenomMsg tests TypeMsgMint message is emitted on a successful mint
+func (suite *KeeperTestSuite) TestMintDenomMsg() {
+ // Create a denom
+ suite.CreateDefaultDenom()
+
+ for _, tc := range []struct {
+ desc string
+ amount int64
+ mintDenom string
+ admin string
+ valid bool
+ expectedMessageEvents int
+ }{
+ {
+ desc: "denom does not exist",
+ amount: 10,
+ mintDenom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/evmos",
+ admin: suite.TestAccs[0].String(),
+ valid: false,
+ },
+ {
+ desc: "success case",
+ amount: 10,
+ mintDenom: suite.defaultDenom,
+ admin: suite.TestAccs[0].String(),
+ valid: true,
+ expectedMessageEvents: 1,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ ctx := suite.Ctx.WithEventManager(sdk.NewEventManager())
+ suite.Require().Equal(0, len(ctx.EventManager().Events()))
+ // Test mint message
+ suite.msgServer.Mint(sdk.WrapSDKContext(ctx), types.NewMsgMint(tc.admin, sdk.NewInt64Coin(tc.mintDenom, 10)))
+ // Ensure current number and type of event is emitted
+ suite.AssertEventEmitted(ctx, types.TypeMsgMint, tc.expectedMessageEvents)
+ })
+ }
+}
+
+// TestBurnDenomMsg tests TypeMsgBurn message is emitted on a successful burn
+func (suite *KeeperTestSuite) TestBurnDenomMsg() {
+ // Create a denom.
+ suite.CreateDefaultDenom()
+ // mint 10 default token for testAcc[0]
+ suite.msgServer.Mint(sdk.WrapSDKContext(suite.Ctx), types.NewMsgMint(suite.TestAccs[0].String(), sdk.NewInt64Coin(suite.defaultDenom, 10)))
+
+ for _, tc := range []struct {
+ desc string
+ amount int64
+ burnDenom string
+ admin string
+ valid bool
+ expectedMessageEvents int
+ }{
+ {
+ desc: "denom does not exist",
+ burnDenom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/evmos",
+ admin: suite.TestAccs[0].String(),
+ valid: false,
+ },
+ {
+ desc: "success case",
+ burnDenom: suite.defaultDenom,
+ admin: suite.TestAccs[0].String(),
+ valid: true,
+ expectedMessageEvents: 1,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ ctx := suite.Ctx.WithEventManager(sdk.NewEventManager())
+ suite.Require().Equal(0, len(ctx.EventManager().Events()))
+ // Test burn message
+ suite.msgServer.Burn(sdk.WrapSDKContext(ctx), types.NewMsgBurn(tc.admin, sdk.NewInt64Coin(tc.burnDenom, 10)))
+ // Ensure current number and type of event is emitted
+ suite.AssertEventEmitted(ctx, types.TypeMsgBurn, tc.expectedMessageEvents)
+ })
+ }
+}
+
+// TestCreateDenomMsg tests TypeMsgCreateDenom message is emitted on a successful denom creation
+func (suite *KeeperTestSuite) TestCreateDenomMsg() {
+ defaultDenomCreationFee := types.Params{DenomCreationFee: sdk.NewCoins(sdk.NewCoin(sdk.DefaultBondDenom, sdk.NewInt(50000000)))}
+ for _, tc := range []struct {
+ desc string
+ denomCreationFee types.Params
+ subdenom string
+ valid bool
+ expectedMessageEvents int
+ }{
+ {
+ desc: "subdenom too long",
+ denomCreationFee: defaultDenomCreationFee,
+ subdenom: "assadsadsadasdasdsadsadsadsadsadsadsklkadaskkkdasdasedskhanhassyeunganassfnlksdflksafjlkasd",
+ valid: false,
+ },
+ {
+ desc: "success case: defaultDenomCreationFee",
+ denomCreationFee: defaultDenomCreationFee,
+ subdenom: "evmos",
+ valid: true,
+ expectedMessageEvents: 1,
+ },
+ } {
+ suite.SetupTest()
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ tokenFactoryKeeper := suite.App.TokenFactoryKeeper
+ ctx := suite.Ctx.WithEventManager(sdk.NewEventManager())
+ suite.Require().Equal(0, len(ctx.EventManager().Events()))
+ // Set denom creation fee in params
+ tokenFactoryKeeper.SetParams(suite.Ctx, tc.denomCreationFee)
+ // Test create denom message
+ suite.msgServer.CreateDenom(sdk.WrapSDKContext(ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), tc.subdenom))
+ // Ensure current number and type of event is emitted
+ suite.AssertEventEmitted(ctx, types.TypeMsgCreateDenom, tc.expectedMessageEvents)
+ })
+ }
+}
+
+// TestChangeAdminDenomMsg tests TypeMsgChangeAdmin message is emitted on a successful admin change
+func (suite *KeeperTestSuite) TestChangeAdminDenomMsg() {
+ for _, tc := range []struct {
+ desc string
+ msgChangeAdmin func(denom string) *types.MsgChangeAdmin
+ expectedChangeAdminPass bool
+ expectedAdminIndex int
+ msgMint func(denom string) *types.MsgMint
+ expectedMintPass bool
+ expectedMessageEvents int
+ }{
+ {
+ desc: "non-admins can't change the existing admin",
+ msgChangeAdmin: func(denom string) *types.MsgChangeAdmin {
+ return types.NewMsgChangeAdmin(suite.TestAccs[1].String(), denom, suite.TestAccs[2].String())
+ },
+ expectedChangeAdminPass: false,
+ expectedAdminIndex: 0,
+ },
+ {
+ desc: "success change admin",
+ msgChangeAdmin: func(denom string) *types.MsgChangeAdmin {
+ return types.NewMsgChangeAdmin(suite.TestAccs[0].String(), denom, suite.TestAccs[1].String())
+ },
+ expectedAdminIndex: 1,
+ expectedChangeAdminPass: true,
+ expectedMessageEvents: 1,
+ msgMint: func(denom string) *types.MsgMint {
+ return types.NewMsgMint(suite.TestAccs[1].String(), sdk.NewInt64Coin(denom, 5))
+ },
+ expectedMintPass: true,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ // setup test
+ suite.SetupTest()
+ ctx := suite.Ctx.WithEventManager(sdk.NewEventManager())
+ suite.Require().Equal(0, len(ctx.EventManager().Events()))
+ // Create a denom and mint
+ res, err := suite.msgServer.CreateDenom(sdk.WrapSDKContext(ctx), types.NewMsgCreateDenom(suite.TestAccs[0].String(), "bitcoin"))
+ suite.Require().NoError(err)
+ testDenom := res.GetNewTokenDenom()
+ suite.msgServer.Mint(sdk.WrapSDKContext(ctx), types.NewMsgMint(suite.TestAccs[0].String(), sdk.NewInt64Coin(testDenom, 10)))
+ // Test change admin message
+ suite.msgServer.ChangeAdmin(sdk.WrapSDKContext(ctx), tc.msgChangeAdmin(testDenom))
+ // Ensure current number and type of event is emitted
+ suite.AssertEventEmitted(ctx, types.TypeMsgChangeAdmin, tc.expectedMessageEvents)
+ })
+ }
+}
+
+// TestSetDenomMetaDataMsg tests TypeMsgSetDenomMetadata message is emitted on a successful denom metadata change
+func (suite *KeeperTestSuite) TestSetDenomMetaDataMsg() {
+ // setup test
+ suite.SetupTest()
+ suite.CreateDefaultDenom()
+
+ for _, tc := range []struct {
+ desc string
+ msgSetDenomMetadata types.MsgSetDenomMetadata
+ expectedPass bool
+ expectedMessageEvents int
+ }{
+ {
+ desc: "successful set denom metadata",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[0].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: suite.defaultDenom,
+ Exponent: 0,
+ },
+ {
+ Denom: "uosmo",
+ Exponent: 6,
+ },
+ },
+ Base: suite.defaultDenom,
+ Display: "uosmo",
+ Name: "OSMO",
+ Symbol: "OSMO",
+ }),
+ expectedPass: true,
+ expectedMessageEvents: 1,
+ },
+ {
+ desc: "non existent factory denom name",
+ msgSetDenomMetadata: *types.NewMsgSetDenomMetadata(suite.TestAccs[0].String(), banktypes.Metadata{
+ Description: "yeehaw",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: fmt.Sprintf("factory/%s/litecoin", suite.TestAccs[0].String()),
+ Exponent: 0,
+ },
+ {
+ Denom: "uosmo",
+ Exponent: 6,
+ },
+ },
+ Base: fmt.Sprintf("factory/%s/litecoin", suite.TestAccs[0].String()),
+ Display: "uosmo",
+ Name: "OSMO",
+ Symbol: "OSMO",
+ }),
+ expectedPass: false,
+ },
+ } {
+ suite.Run(fmt.Sprintf("Case %s", tc.desc), func() {
+ ctx := suite.Ctx.WithEventManager(sdk.NewEventManager())
+ suite.Require().Equal(0, len(ctx.EventManager().Events()))
+ // Test set denom metadata message
+ suite.msgServer.SetDenomMetadata(sdk.WrapSDKContext(ctx), &tc.msgSetDenomMetadata)
+ // Ensure current number and type of event is emitted
+ suite.AssertEventEmitted(ctx, types.TypeMsgSetDenomMetadata, tc.expectedMessageEvents)
+ })
+ }
+}
diff --git a/x/tokenfactory/keeper/params.go b/x/tokenfactory/keeper/params.go
new file mode 100644
index 000000000..acc5a5dd3
--- /dev/null
+++ b/x/tokenfactory/keeper/params.go
@@ -0,0 +1,17 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+)
+
+// GetParams returns the total set params.
+func (k Keeper) GetParams(ctx sdk.Context) (params types.Params) {
+ k.paramSpace.GetParamSet(ctx, ¶ms)
+ return params
+}
+
+// SetParams sets the total set of params.
+func (k Keeper) SetParams(ctx sdk.Context, params types.Params) {
+ k.paramSpace.SetParamSet(ctx, ¶ms)
+}
diff --git a/x/tokenfactory/module.go b/x/tokenfactory/module.go
new file mode 100644
index 000000000..90e121c5e
--- /dev/null
+++ b/x/tokenfactory/module.go
@@ -0,0 +1,175 @@
+/*
+The tokenfactory module allows any account to create a new token with
+the name `factory/{creator address}/{subdenom}`.
+
+- Mint and burn user denom to and form any account
+- Create a transfer of their denom between any two accounts
+- Change the admin. In the future, more admin capabilities may be added.
+*/
+package tokenfactory
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/codec"
+ cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/types/module"
+ "github.com/gorilla/mux"
+ "github.com/grpc-ecosystem/grpc-gateway/runtime"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/client/cli"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/keeper"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/spf13/cobra"
+ abci "github.com/tendermint/tendermint/abci/types"
+)
+
+var (
+ _ module.AppModule = AppModule{}
+ _ module.AppModuleBasic = AppModuleBasic{}
+)
+
+// ----------------------------------------------------------------------------
+// AppModuleBasic
+// ----------------------------------------------------------------------------
+
+// AppModuleBasic implements the AppModuleBasic interface for the capability module.
+type AppModuleBasic struct{}
+
+func NewAppModuleBasic() AppModuleBasic {
+ return AppModuleBasic{}
+}
+
+// Name returns the x/tokenfactory module's name.
+func (AppModuleBasic) Name() string {
+ return types.ModuleName
+}
+
+func (AppModuleBasic) RegisterLegacyAminoCodec(cdc *codec.LegacyAmino) {
+ types.RegisterCodec(cdc)
+}
+
+// RegisterInterfaces registers the module's interface types
+func (a AppModuleBasic) RegisterInterfaces(reg cdctypes.InterfaceRegistry) {
+ types.RegisterInterfaces(reg)
+}
+
+// DefaultGenesis returns the x/tokenfactory module's default genesis state.
+func (AppModuleBasic) DefaultGenesis(cdc codec.JSONCodec) json.RawMessage {
+ return cdc.MustMarshalJSON(types.DefaultGenesis())
+}
+
+// ValidateGenesis performs genesis state validation for the x/tokenfactory module.
+func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, _ client.TxEncodingConfig, bz json.RawMessage) error {
+ var genState types.GenesisState
+ if err := cdc.UnmarshalJSON(bz, &genState); err != nil {
+ return fmt.Errorf("failed to unmarshal %s genesis state: %w", types.ModuleName, err)
+ }
+
+ return genState.Validate()
+}
+
+// RegisterRESTRoutes registers the capability module's REST service handlers.
+func (AppModuleBasic) RegisterRESTRoutes(_ client.Context, _ *mux.Router) {}
+
+// RegisterGRPCGatewayRoutes registers the gRPC Gateway routes for the module.
+func (AppModuleBasic) RegisterGRPCGatewayRoutes(clientCtx client.Context, mux *runtime.ServeMux) {
+ types.RegisterQueryHandlerClient(context.Background(), mux, types.NewQueryClient(clientCtx)) //nolint:errcheck
+}
+
+// GetTxCmd returns the x/tokenfactory module's root tx command.
+func (a AppModuleBasic) GetTxCmd() *cobra.Command {
+ return cli.GetTxCmd()
+}
+
+// GetQueryCmd returns the x/tokenfactory module's root query command.
+func (AppModuleBasic) GetQueryCmd() *cobra.Command {
+ return cli.GetQueryCmd()
+}
+
+// ----------------------------------------------------------------------------
+// AppModule
+// ----------------------------------------------------------------------------
+
+// AppModule implements the AppModule interface for the capability module.
+type AppModule struct {
+ AppModuleBasic
+
+ keeper keeper.Keeper
+ accountKeeper types.AccountKeeper
+ bankKeeper types.BankKeeper
+}
+
+func NewAppModule(
+ keeper keeper.Keeper,
+ accountKeeper types.AccountKeeper,
+ bankKeeper types.BankKeeper,
+) AppModule {
+ return AppModule{
+ AppModuleBasic: NewAppModuleBasic(),
+ keeper: keeper,
+ accountKeeper: accountKeeper,
+ bankKeeper: bankKeeper,
+ }
+}
+
+// Name returns the x/tokenfactory module's name.
+func (am AppModule) Name() string {
+ return am.AppModuleBasic.Name()
+}
+
+// Route returns the x/tokenfactory module's message routing key.
+func (am AppModule) Route() sdk.Route {
+ return sdk.Route{}
+}
+
+// QuerierRoute returns the x/tokenfactory module's query routing key.
+func (AppModule) QuerierRoute() string { return types.QuerierRoute }
+
+// LegacyQuerierHandler returns the x/tokenfactory module's Querier.
+func (am AppModule) LegacyQuerierHandler(_ *codec.LegacyAmino) sdk.Querier {
+ return nil
+}
+
+// RegisterServices registers a GRPC query service to respond to the
+// module-specific GRPC queries.
+func (am AppModule) RegisterServices(cfg module.Configurator) {
+ types.RegisterMsgServer(cfg.MsgServer(), keeper.NewMsgServerImpl(am.keeper))
+ types.RegisterQueryServer(cfg.QueryServer(), am.keeper)
+}
+
+// RegisterInvariants registers the x/tokenfactory module's invariants.
+func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {}
+
+// InitGenesis performs the x/tokenfactory module's genesis initialization. It
+// returns no validator updates.
+func (am AppModule) InitGenesis(ctx sdk.Context, cdc codec.JSONCodec, gs json.RawMessage) []abci.ValidatorUpdate {
+ var genState types.GenesisState
+ cdc.MustUnmarshalJSON(gs, &genState)
+
+ am.keeper.InitGenesis(ctx, genState)
+
+ return []abci.ValidatorUpdate{}
+}
+
+// ExportGenesis returns the x/tokenfactory module's exported genesis state as raw
+// JSON bytes.
+func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
+ genState := am.keeper.ExportGenesis(ctx)
+ return cdc.MustMarshalJSON(genState)
+}
+
+// ConsensusVersion implements ConsensusVersion.
+func (AppModule) ConsensusVersion() uint64 { return 1 }
+
+// BeginBlock executes all ABCI BeginBlock logic respective to the tokenfactory module.
+func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+
+// EndBlock executes all ABCI EndBlock logic respective to the tokenfactory module. It
+// returns no validator updates.
+func (am AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
+ return []abci.ValidatorUpdate{}
+}
diff --git a/x/tokenfactory/types/codec.go b/x/tokenfactory/types/codec.go
new file mode 100644
index 000000000..2ead3330c
--- /dev/null
+++ b/x/tokenfactory/types/codec.go
@@ -0,0 +1,37 @@
+package types
+
+import (
+ "github.com/cosmos/cosmos-sdk/codec"
+ cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/cosmos/cosmos-sdk/types/msgservice"
+)
+
+func RegisterCodec(cdc *codec.LegacyAmino) {
+ cdc.RegisterConcrete(&MsgCreateDenom{}, "tokenfactory/create-denom", nil)
+ cdc.RegisterConcrete(&MsgMint{}, "tokenfactory/mint", nil)
+ cdc.RegisterConcrete(&MsgBurn{}, "tokenfactory/burn", nil)
+ cdc.RegisterConcrete(&MsgChangeAdmin{}, "tokenfactory/change-admin", nil)
+}
+
+func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
+ registry.RegisterImplementations(
+ (*sdk.Msg)(nil),
+ &MsgCreateDenom{},
+ &MsgMint{},
+ &MsgBurn{},
+ &MsgChangeAdmin{},
+ )
+ msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+}
+
+var (
+ amino = codec.NewLegacyAmino()
+ ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry())
+)
+
+func init() {
+ RegisterCodec(amino)
+ sdk.RegisterLegacyAminoCodec(amino)
+ amino.Seal()
+}
diff --git a/x/tokenfactory/types/denoms.go b/x/tokenfactory/types/denoms.go
new file mode 100644
index 000000000..02ee13804
--- /dev/null
+++ b/x/tokenfactory/types/denoms.go
@@ -0,0 +1,84 @@
+package types
+
+import (
+ fmt "fmt"
+ "strings"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ bankkeeper "github.com/cosmos/cosmos-sdk/x/bank/keeper"
+)
+
+const (
+ ModuleDenomPrefix = "factory"
+ // See the TokenFactory readme for a derivation of these.
+ // TL;DR, MaxSubdenomLength + MaxHrpLength = 60 comes from SDK max denom length = 128
+ // and the structure of tokenfactory denoms.
+ MaxSubdenomLength = 44
+ MaxHrpLength = 16
+ // MaxCreatorLength = 59 + MaxHrpLength
+ MaxCreatorLength = 59 + MaxHrpLength
+)
+
+// GetTokenDenom constructs a denom string for tokens created by tokenfactory
+// based on an input creator address and a subdenom
+// The denom constructed is factory/{creator}/{subdenom}
+func GetTokenDenom(creator, subdenom string) (string, error) {
+ if len(subdenom) > MaxSubdenomLength {
+ return "", ErrSubdenomTooLong
+ }
+ if len(creator) > MaxCreatorLength {
+ return "", ErrCreatorTooLong
+ }
+ if strings.Contains(creator, "/") {
+ return "", ErrInvalidCreator
+ }
+ denom := strings.Join([]string{ModuleDenomPrefix, creator, subdenom}, "/")
+ return denom, sdk.ValidateDenom(denom)
+}
+
+// DeconstructDenom takes a token denom string and verifies that it is a valid
+// denom of the tokenfactory module, and is of the form `factory/{creator}/{subdenom}`
+// If valid, it returns the creator address and subdenom
+func DeconstructDenom(denom string) (creator string, subdenom string, err error) {
+ err = sdk.ValidateDenom(denom)
+ if err != nil {
+ return "", "", err
+ }
+
+ strParts := strings.Split(denom, "/")
+ if len(strParts) < 3 {
+ return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "not enough parts of denom %s", denom)
+ }
+
+ if strParts[0] != ModuleDenomPrefix {
+ return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "denom prefix is incorrect. Is: %s. Should be: %s", strParts[0], ModuleDenomPrefix)
+ }
+
+ creator = strParts[1]
+ creatorAddr, err := sdk.AccAddressFromBech32(creator)
+ if err != nil {
+ return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "Invalid creator address (%s)", err)
+ }
+
+ // Handle the case where a denom has a slash in its subdenom. For example,
+ // when we did the split, we'd turn factory/accaddr/atomderivative/testy into ["factory", "accaddr", "atomderivative", "testy"]
+ // So we have to join [2:] with a "/" as the delimiter to get back the correct subdenom which should be "atomderivative/testy"
+ subdenom = strings.Join(strParts[2:], "/")
+
+ return creatorAddr.String(), subdenom, nil
+}
+
+// NewTokenFactoryDenomMintCoinsRestriction creates and returns a MintingRestrictionFn that only allows minting of
+// valid tokenfactory denoms
+func NewTokenFactoryDenomMintCoinsRestriction() bankkeeper.MintingRestrictionFn {
+ return func(ctx sdk.Context, coinsToMint sdk.Coins) error {
+ for _, coin := range coinsToMint {
+ _, _, err := DeconstructDenom(coin.Denom)
+ if err != nil {
+ return fmt.Errorf("does not have permission to mint %s", coin.Denom)
+ }
+ }
+ return nil
+ }
+}
diff --git a/x/tokenfactory/types/denoms_test.go b/x/tokenfactory/types/denoms_test.go
new file mode 100644
index 000000000..7ec0fb910
--- /dev/null
+++ b/x/tokenfactory/types/denoms_test.go
@@ -0,0 +1,126 @@
+package types_test
+
+import (
+ "testing"
+
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/stretchr/testify/require"
+)
+
+func TestDeconstructDenom(t *testing.T) {
+ for _, tc := range []struct {
+ desc string
+ denom string
+ expectedSubdenom string
+ err error
+ }{
+ {
+ desc: "empty is invalid",
+ denom: "",
+ err: types.ErrInvalidDenom,
+ },
+ {
+ desc: "normal",
+ denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ expectedSubdenom: "testy",
+ },
+ {
+ desc: "multiple slashes in subdenom",
+ denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy/1",
+ expectedSubdenom: "testy/1",
+ },
+ {
+ desc: "no subdenom",
+ denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/",
+ expectedSubdenom: "",
+ },
+ {
+ desc: "incorrect prefix",
+ denom: "ibc/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ err: types.ErrInvalidDenom,
+ },
+ {
+ desc: "subdenom of only slashes",
+ denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/////",
+ expectedSubdenom: "////",
+ },
+ {
+ desc: "too long name",
+ denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/adsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsf",
+ err: types.ErrInvalidDenom,
+ },
+ } {
+ t.Run(tc.desc, func(t *testing.T) {
+ expectedCreator := "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f"
+ creator, subdenom, err := types.DeconstructDenom(tc.denom)
+ if tc.err != nil {
+ require.ErrorContains(t, err, tc.err.Error())
+ } else {
+ require.NoError(t, err)
+ require.Equal(t, expectedCreator, creator)
+ require.Equal(t, tc.expectedSubdenom, subdenom)
+ }
+ })
+ }
+}
+
+func TestGetTokenDenom(t *testing.T) {
+ for _, tc := range []struct {
+ desc string
+ creator string
+ subdenom string
+ valid bool
+ }{
+ {
+ desc: "normal",
+ creator: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ subdenom: "testy",
+ valid: true,
+ },
+ {
+ desc: "multiple slashes in subdenom",
+ creator: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ subdenom: "testy/1",
+ valid: true,
+ },
+ {
+ desc: "no subdenom",
+ creator: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ subdenom: "",
+ valid: true,
+ },
+ {
+ desc: "subdenom of only slashes",
+ creator: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ subdenom: "/////",
+ valid: true,
+ },
+ {
+ desc: "too long name",
+ creator: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ subdenom: "adsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsf",
+ valid: false,
+ },
+ {
+ desc: "subdenom is exactly max length",
+ creator: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ subdenom: "testyfsadfsdfeadfsafwefsefsefsdfsdafasefsf",
+ valid: true,
+ },
+ {
+ desc: "creator is exactly max length",
+ creator: "cosmos1t7egva48prqmzl59x5ngv4zx0dtrwewcdqdjr8jhgjhgkhjklhkjhkhgjhgjgjgheugt",
+ subdenom: "testy",
+ valid: true,
+ },
+ } {
+ t.Run(tc.desc, func(t *testing.T) {
+ _, err := types.GetTokenDenom(tc.creator, tc.subdenom)
+ if tc.valid {
+ require.NoError(t, err)
+ } else {
+ require.Error(t, err)
+ }
+ })
+ }
+}
diff --git a/x/tokenfactory/types/errors.go b/x/tokenfactory/types/errors.go
new file mode 100644
index 000000000..06991f19b
--- /dev/null
+++ b/x/tokenfactory/types/errors.go
@@ -0,0 +1,22 @@
+package types
+
+// DONTCOVER
+
+import (
+ fmt "fmt"
+
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// x/tokenfactory module sentinel errors
+var (
+ ErrDenomExists = sdkerrors.Register(ModuleName, 2, "attempting to create a denom that already exists (has bank metadata)")
+ ErrUnauthorized = sdkerrors.Register(ModuleName, 3, "unauthorized account")
+ ErrInvalidDenom = sdkerrors.Register(ModuleName, 4, "invalid denom")
+ ErrInvalidCreator = sdkerrors.Register(ModuleName, 5, "invalid creator")
+ ErrInvalidAuthorityMetadata = sdkerrors.Register(ModuleName, 6, "invalid authority metadata")
+ ErrInvalidGenesis = sdkerrors.Register(ModuleName, 7, "invalid genesis")
+ ErrSubdenomTooLong = sdkerrors.Register(ModuleName, 8, fmt.Sprintf("subdenom too long, max length is %d bytes", MaxSubdenomLength))
+ ErrCreatorTooLong = sdkerrors.Register(ModuleName, 9, fmt.Sprintf("creator too long, max length is %d bytes", MaxCreatorLength))
+ ErrDenomDoesNotExist = sdkerrors.Register(ModuleName, 10, "denom does not exist")
+)
diff --git a/x/tokenfactory/types/events.go b/x/tokenfactory/types/events.go
new file mode 100644
index 000000000..3e2938061
--- /dev/null
+++ b/x/tokenfactory/types/events.go
@@ -0,0 +1,16 @@
+package types
+
+// event types
+const (
+ AttributeAmount = "amount"
+ AttributeCreator = "creator"
+ AttributeSubdenom = "subdenom"
+ AttributeNewTokenDenom = "new_token_denom" // #nosec G101
+ AttributeMintToAddress = "mint_to_address"
+ AttributeBurnFromAddress = "burn_from_address"
+ AttributeTransferFromAddress = "transfer_from_address"
+ AttributeTransferToAddress = "transfer_to_address"
+ AttributeDenom = "denom"
+ AttributeNewAdmin = "new_admin"
+ AttributeDenomMetadata = "denom_metadata"
+)
diff --git a/x/tokenfactory/types/expected_keepers.go b/x/tokenfactory/types/expected_keepers.go
new file mode 100644
index 000000000..9ab066d07
--- /dev/null
+++ b/x/tokenfactory/types/expected_keepers.go
@@ -0,0 +1,27 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+)
+
+type BankKeeper interface {
+ GetDenomMetaData(ctx sdk.Context, denom string) (banktypes.Metadata, bool)
+ SetDenomMetaData(ctx sdk.Context, denomMetaData banktypes.Metadata)
+ HasSupply(ctx sdk.Context, denom string) bool
+ SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
+ SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+ MintCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
+ BurnCoins(ctx sdk.Context, moduleName string, amt sdk.Coins) error
+ SendCoins(ctx sdk.Context, fromAddr sdk.AccAddress, toAddr sdk.AccAddress, amt sdk.Coins) error
+ HasBalance(ctx sdk.Context, addr sdk.AccAddress, amt sdk.Coin) bool
+}
+
+type AccountKeeper interface {
+ SetModuleAccount(ctx sdk.Context, macc authtypes.ModuleAccountI)
+}
+
+type CommunityPoolKeeper interface {
+ FundCommunityPool(ctx sdk.Context, amount sdk.Coins, sender sdk.AccAddress) error
+}
diff --git a/x/tokenfactory/types/genesis.go b/x/tokenfactory/types/genesis.go
new file mode 100644
index 000000000..5478251af
--- /dev/null
+++ b/x/tokenfactory/types/genesis.go
@@ -0,0 +1,49 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// DefaultIndex is the default capability global index
+const DefaultIndex uint64 = 1
+
+// DefaultGenesis returns the default Capability genesis state
+func DefaultGenesis() *GenesisState {
+ return &GenesisState{
+ Params: DefaultParams(),
+ FactoryDenoms: []GenesisDenom{},
+ }
+}
+
+// Validate performs basic genesis state validation returning an error upon any
+// failure.
+func (gs GenesisState) Validate() error {
+ err := gs.Params.Validate()
+ if err != nil {
+ return err
+ }
+
+ seenDenoms := map[string]bool{}
+
+ for _, denom := range gs.GetFactoryDenoms() {
+ if seenDenoms[denom.GetDenom()] {
+ return sdkerrors.Wrapf(ErrInvalidGenesis, "duplicate denom: %s", denom.GetDenom())
+ }
+ seenDenoms[denom.GetDenom()] = true
+
+ _, _, err := DeconstructDenom(denom.GetDenom())
+ if err != nil {
+ return err
+ }
+
+ if denom.AuthorityMetadata.Admin != "" {
+ _, err = sdk.AccAddressFromBech32(denom.AuthorityMetadata.Admin)
+ if err != nil {
+ return sdkerrors.Wrapf(ErrInvalidAuthorityMetadata, "Invalid admin address (%s)", err)
+ }
+ }
+ }
+
+ return nil
+}
diff --git a/x/tokenfactory/types/genesis.pb.go b/x/tokenfactory/types/genesis.pb.go
new file mode 100644
index 000000000..18d79bb97
--- /dev/null
+++ b/x/tokenfactory/types/genesis.pb.go
@@ -0,0 +1,650 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: osmosis/tokenfactory/v1beta1/genesis.proto
+
+package types
+
+import (
+ fmt "fmt"
+ _ "github.com/gogo/protobuf/gogoproto"
+ proto "github.com/gogo/protobuf/proto"
+ io "io"
+ math "math"
+ math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// GenesisState defines the tokenfactory module's genesis state.
+type GenesisState struct {
+ // params defines the paramaters of the module.
+ Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+ FactoryDenoms []GenesisDenom `protobuf:"bytes,2,rep,name=factory_denoms,json=factoryDenoms,proto3" json:"factory_denoms" yaml:"factory_denoms"`
+}
+
+func (m *GenesisState) Reset() { *m = GenesisState{} }
+func (m *GenesisState) String() string { return proto.CompactTextString(m) }
+func (*GenesisState) ProtoMessage() {}
+func (*GenesisState) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5749c3f71850298b, []int{0}
+}
+func (m *GenesisState) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *GenesisState) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_GenesisState.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *GenesisState) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GenesisState.Merge(m, src)
+}
+func (m *GenesisState) XXX_Size() int {
+ return m.Size()
+}
+func (m *GenesisState) XXX_DiscardUnknown() {
+ xxx_messageInfo_GenesisState.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenesisState proto.InternalMessageInfo
+
+func (m *GenesisState) GetParams() Params {
+ if m != nil {
+ return m.Params
+ }
+ return Params{}
+}
+
+func (m *GenesisState) GetFactoryDenoms() []GenesisDenom {
+ if m != nil {
+ return m.FactoryDenoms
+ }
+ return nil
+}
+
+// GenesisDenom defines a tokenfactory denom that is defined within genesis
+// state. The structure contains DenomAuthorityMetadata which defines the
+// denom's admin.
+type GenesisDenom struct {
+ Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
+ AuthorityMetadata DenomAuthorityMetadata `protobuf:"bytes,2,opt,name=authority_metadata,json=authorityMetadata,proto3" json:"authority_metadata" yaml:"authority_metadata"`
+}
+
+func (m *GenesisDenom) Reset() { *m = GenesisDenom{} }
+func (m *GenesisDenom) String() string { return proto.CompactTextString(m) }
+func (*GenesisDenom) ProtoMessage() {}
+func (*GenesisDenom) Descriptor() ([]byte, []int) {
+ return fileDescriptor_5749c3f71850298b, []int{1}
+}
+func (m *GenesisDenom) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *GenesisDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_GenesisDenom.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *GenesisDenom) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_GenesisDenom.Merge(m, src)
+}
+func (m *GenesisDenom) XXX_Size() int {
+ return m.Size()
+}
+func (m *GenesisDenom) XXX_DiscardUnknown() {
+ xxx_messageInfo_GenesisDenom.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_GenesisDenom proto.InternalMessageInfo
+
+func (m *GenesisDenom) GetDenom() string {
+ if m != nil {
+ return m.Denom
+ }
+ return ""
+}
+
+func (m *GenesisDenom) GetAuthorityMetadata() DenomAuthorityMetadata {
+ if m != nil {
+ return m.AuthorityMetadata
+ }
+ return DenomAuthorityMetadata{}
+}
+
+func init() {
+ proto.RegisterType((*GenesisState)(nil), "osmosis.tokenfactory.v1beta1.GenesisState")
+ proto.RegisterType((*GenesisDenom)(nil), "osmosis.tokenfactory.v1beta1.GenesisDenom")
+}
+
+func init() {
+ proto.RegisterFile("osmosis/tokenfactory/v1beta1/genesis.proto", fileDescriptor_5749c3f71850298b)
+}
+
+var fileDescriptor_5749c3f71850298b = []byte{
+ // 372 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x91, 0xc1, 0x4a, 0xeb, 0x40,
+ 0x14, 0x86, 0x33, 0xbd, 0xbd, 0x85, 0x9b, 0xf6, 0x8a, 0x06, 0x85, 0x5a, 0x34, 0xa9, 0x41, 0xa4,
+ 0x14, 0xcc, 0xd8, 0xea, 0xaa, 0xae, 0x0c, 0x05, 0x57, 0x82, 0x44, 0xdc, 0xb8, 0x29, 0x27, 0xed,
+ 0x98, 0x06, 0x9b, 0x4e, 0xc8, 0x4c, 0xab, 0xf1, 0x01, 0x5c, 0xfb, 0x08, 0x3e, 0x8c, 0x42, 0x97,
+ 0x5d, 0xba, 0x2a, 0xd2, 0x6e, 0x5c, 0xf7, 0x09, 0xa4, 0x93, 0x11, 0xad, 0x42, 0x76, 0xc9, 0x99,
+ 0xff, 0xfb, 0xce, 0x39, 0x1c, 0xb5, 0x4a, 0x59, 0x40, 0x99, 0xcf, 0x30, 0xa7, 0x37, 0xa4, 0x7f,
+ 0x0d, 0x6d, 0x4e, 0xa3, 0x18, 0x0f, 0x6b, 0x2e, 0xe1, 0x50, 0xc3, 0x1e, 0xe9, 0x13, 0xe6, 0x33,
+ 0x2b, 0x8c, 0x28, 0xa7, 0xda, 0x96, 0xcc, 0x5a, 0xdf, 0xb3, 0x96, 0xcc, 0x96, 0xd6, 0x3d, 0xea,
+ 0x51, 0x11, 0xc4, 0x8b, 0xaf, 0x84, 0x29, 0xe1, 0x54, 0xff, 0x92, 0x48, 0x00, 0xe6, 0x33, 0x52,
+ 0x0b, 0xa7, 0x49, 0xdb, 0x0b, 0x0e, 0x9c, 0x68, 0xb6, 0x9a, 0x0b, 0x21, 0x82, 0x80, 0x15, 0x51,
+ 0x19, 0x55, 0xf2, 0xf5, 0x5d, 0x2b, 0x6d, 0x0c, 0xeb, 0x5c, 0x64, 0xed, 0xec, 0x68, 0x62, 0x28,
+ 0x8e, 0x24, 0xb5, 0x50, 0x5d, 0x91, 0xb9, 0x56, 0x87, 0xf4, 0x69, 0xc0, 0x8a, 0x99, 0xf2, 0x9f,
+ 0x4a, 0xbe, 0x5e, 0x4d, 0x77, 0xc9, 0x39, 0x9a, 0x0b, 0xc4, 0xde, 0x5e, 0x18, 0xe7, 0x13, 0x63,
+ 0x23, 0x86, 0xa0, 0xd7, 0x30, 0x97, 0x7d, 0xa6, 0xf3, 0x5f, 0x16, 0x9a, 0xc9, 0xff, 0xcb, 0xd7,
+ 0x1a, 0xa2, 0xa2, 0xed, 0xa9, 0x7f, 0x45, 0x54, 0x6c, 0xf1, 0xcf, 0x5e, 0x9d, 0x4f, 0x8c, 0x42,
+ 0x62, 0x12, 0x65, 0xd3, 0x49, 0x9e, 0xb5, 0x07, 0xa4, 0x6a, 0x30, 0xe0, 0x5d, 0x1a, 0xf9, 0x3c,
+ 0x6e, 0x05, 0x84, 0x43, 0x07, 0x38, 0x14, 0x33, 0x62, 0xf7, 0xa3, 0xf4, 0x79, 0x45, 0xa7, 0x93,
+ 0x4f, 0xf8, 0x4c, 0xb2, 0xf6, 0x8e, 0x9c, 0x7c, 0x33, 0xe9, 0xf7, 0xdb, 0x6e, 0x3a, 0x6b, 0xf0,
+ 0x93, 0x6a, 0x64, 0xdf, 0x9f, 0x0c, 0x64, 0x5f, 0x8e, 0xa6, 0x3a, 0x1a, 0x4f, 0x75, 0xf4, 0x36,
+ 0xd5, 0xd1, 0xe3, 0x4c, 0x57, 0xc6, 0x33, 0x5d, 0x79, 0x9d, 0xe9, 0xca, 0xd5, 0xb1, 0xe7, 0xf3,
+ 0xee, 0xc0, 0xb5, 0xda, 0x34, 0xc0, 0xe1, 0xc0, 0xed, 0xf9, 0xed, 0x7d, 0xb8, 0x25, 0x8c, 0x06,
+ 0x04, 0x33, 0x0e, 0x91, 0x07, 0xf7, 0x04, 0x0f, 0x6b, 0x07, 0xf8, 0x6e, 0xf9, 0xf4, 0x3c, 0x0e,
+ 0x09, 0x73, 0x73, 0xe2, 0xd8, 0x87, 0x1f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x6b, 0x14, 0xec, 0x7d,
+ 0x7f, 0x02, 0x00, 0x00,
+}
+
+func (this *GenesisDenom) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*GenesisDenom)
+ if !ok {
+ that2, ok := that.(GenesisDenom)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Denom != that1.Denom {
+ return false
+ }
+ if !this.AuthorityMetadata.Equal(&that1.AuthorityMetadata) {
+ return false
+ }
+ return true
+}
+func (m *GenesisState) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *GenesisState) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisState) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.FactoryDenoms) > 0 {
+ for iNdEx := len(m.FactoryDenoms) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.FactoryDenoms[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintGenesis(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ }
+ }
+ {
+ size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintGenesis(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
+}
+
+func (m *GenesisDenom) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *GenesisDenom) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *GenesisDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.AuthorityMetadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintGenesis(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ if len(m.Denom) > 0 {
+ i -= len(m.Denom)
+ copy(dAtA[i:], m.Denom)
+ i = encodeVarintGenesis(dAtA, i, uint64(len(m.Denom)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintGenesis(dAtA []byte, offset int, v uint64) int {
+ offset -= sovGenesis(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *GenesisState) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = m.Params.Size()
+ n += 1 + l + sovGenesis(uint64(l))
+ if len(m.FactoryDenoms) > 0 {
+ for _, e := range m.FactoryDenoms {
+ l = e.Size()
+ n += 1 + l + sovGenesis(uint64(l))
+ }
+ }
+ return n
+}
+
+func (m *GenesisDenom) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Denom)
+ if l > 0 {
+ n += 1 + l + sovGenesis(uint64(l))
+ }
+ l = m.AuthorityMetadata.Size()
+ n += 1 + l + sovGenesis(uint64(l))
+ return n
+}
+
+func sovGenesis(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozGenesis(x uint64) (n int) {
+ return sovGenesis(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *GenesisState) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GenesisState: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GenesisState: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field FactoryDenoms", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.FactoryDenoms = append(m.FactoryDenoms, GenesisDenom{})
+ if err := m.FactoryDenoms[len(m.FactoryDenoms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenesis(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *GenesisDenom) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: GenesisDenom: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: GenesisDenom: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Denom = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AuthorityMetadata", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.AuthorityMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipGenesis(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthGenesis
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipGenesis(dAtA []byte) (n int, err error) {
+ l := len(dAtA)
+ iNdEx := 0
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if dAtA[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ case 1:
+ iNdEx += 8
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowGenesis
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if length < 0 {
+ return 0, ErrInvalidLengthGenesis
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupGenesis
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthGenesis
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthGenesis = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowGenesis = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupGenesis = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/tokenfactory/types/genesis_test.go b/x/tokenfactory/types/genesis_test.go
new file mode 100644
index 000000000..a51d827c2
--- /dev/null
+++ b/x/tokenfactory/types/genesis_test.go
@@ -0,0 +1,138 @@
+package types_test
+
+import (
+ "testing"
+
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/stretchr/testify/require"
+)
+
+func TestGenesisState_Validate(t *testing.T) {
+ for _, tc := range []struct {
+ desc string
+ genState *types.GenesisState
+ valid bool
+ }{
+ {
+ desc: "default is valid",
+ genState: types.DefaultGenesis(),
+ valid: true,
+ },
+ {
+ desc: "valid genesis state",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1t7egva48prqmzl59x5ngv4zx0dtrwewcdqdjr8/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "cosmos1t7egva48prqmzl59x5ngv4zx0dtrwewcdqdjr8",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "different admin from creator",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1t7egva48prqmzl59x5ngv4zx0dtrwewcdqdjr8/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "empty admin",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "no admin",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "invalid admin",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "👻",
+ },
+ },
+ },
+ },
+ valid: false,
+ },
+ {
+ desc: "multiple denoms",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/beepboop",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "duplicate denoms",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ {
+ Denom: "factory/cosmos1rf3renzcj8m2pav74758lj7wm8z98yky20x64f/testy",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ },
+ },
+ valid: false,
+ },
+ } {
+ t.Run(tc.desc, func(t *testing.T) {
+ err := tc.genState.Validate()
+ if tc.valid {
+ require.NoError(t, err)
+ } else {
+ require.Error(t, err)
+ }
+ })
+ }
+}
diff --git a/x/tokenfactory/types/keys.go b/x/tokenfactory/types/keys.go
new file mode 100644
index 000000000..fac4a6e39
--- /dev/null
+++ b/x/tokenfactory/types/keys.go
@@ -0,0 +1,49 @@
+package types
+
+import (
+ "strings"
+)
+
+const (
+ // ModuleName defines the module name
+ ModuleName = "tokenfactory"
+
+ // StoreKey defines the primary module store key
+ StoreKey = ModuleName
+
+ // RouterKey is the message route for slashing
+ RouterKey = ModuleName
+
+ // QuerierRoute defines the module's query routing key
+ QuerierRoute = ModuleName
+
+ // MemStoreKey defines the in-memory store key
+ MemStoreKey = "mem_tokenfactory"
+)
+
+// KeySeparator is used to combine parts of the keys in the store
+const KeySeparator = "|"
+
+var (
+ DenomAuthorityMetadataKey = "authoritymetadata"
+ DenomsPrefixKey = "denoms"
+ CreatorPrefixKey = "creator"
+ AdminPrefixKey = "admin"
+)
+
+// GetDenomPrefixStore returns the store prefix where all the data associated with a specific denom
+// is stored
+func GetDenomPrefixStore(denom string) []byte {
+ return []byte(strings.Join([]string{DenomsPrefixKey, denom, ""}, KeySeparator))
+}
+
+// GetCreatorsPrefix returns the store prefix where the list of the denoms created by a specific
+// creator are stored
+func GetCreatorPrefix(creator string) []byte {
+ return []byte(strings.Join([]string{CreatorPrefixKey, creator, ""}, KeySeparator))
+}
+
+// GetCreatorsPrefix returns the store prefix where a list of all creator addresses are stored
+func GetCreatorsPrefix() []byte {
+ return []byte(strings.Join([]string{CreatorPrefixKey, ""}, KeySeparator))
+}
diff --git a/x/tokenfactory/types/msgs.go b/x/tokenfactory/types/msgs.go
new file mode 100644
index 000000000..9c78328e1
--- /dev/null
+++ b/x/tokenfactory/types/msgs.go
@@ -0,0 +1,246 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+)
+
+// constants
+const (
+ TypeMsgCreateDenom = "create_denom"
+ TypeMsgMint = "tf_mint"
+ TypeMsgBurn = "tf_burn"
+ TypeMsgForceTransfer = "force_transfer"
+ TypeMsgChangeAdmin = "change_admin"
+ TypeMsgSetDenomMetadata = "set_denom_metadata"
+)
+
+var _ sdk.Msg = &MsgCreateDenom{}
+
+// NewMsgCreateDenom creates a msg to create a new denom
+func NewMsgCreateDenom(sender, subdenom string) *MsgCreateDenom {
+ return &MsgCreateDenom{
+ Sender: sender,
+ Subdenom: subdenom,
+ }
+}
+
+func (m MsgCreateDenom) Route() string { return RouterKey }
+func (m MsgCreateDenom) Type() string { return TypeMsgCreateDenom }
+func (m MsgCreateDenom) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(m.Sender)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err)
+ }
+
+ _, err = GetTokenDenom(m.Sender, m.Subdenom)
+ if err != nil {
+ return sdkerrors.Wrap(ErrInvalidDenom, err.Error())
+ }
+
+ return nil
+}
+
+func (m MsgCreateDenom) GetSignBytes() []byte {
+ return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m))
+}
+
+func (m MsgCreateDenom) GetSigners() []sdk.AccAddress {
+ sender, _ := sdk.AccAddressFromBech32(m.Sender)
+ return []sdk.AccAddress{sender}
+}
+
+var _ sdk.Msg = &MsgMint{}
+
+// NewMsgMint creates a message to mint tokens
+func NewMsgMint(sender string, amount sdk.Coin) *MsgMint {
+ return &MsgMint{
+ Sender: sender,
+ Amount: amount,
+ }
+}
+
+func (m MsgMint) Route() string { return RouterKey }
+func (m MsgMint) Type() string { return TypeMsgMint }
+func (m MsgMint) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(m.Sender)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err)
+ }
+
+ if !m.Amount.IsValid() || m.Amount.Amount.Equal(sdk.ZeroInt()) {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, m.Amount.String())
+ }
+
+ return nil
+}
+
+func (m MsgMint) GetSignBytes() []byte {
+ return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m))
+}
+
+func (m MsgMint) GetSigners() []sdk.AccAddress {
+ sender, _ := sdk.AccAddressFromBech32(m.Sender)
+ return []sdk.AccAddress{sender}
+}
+
+var _ sdk.Msg = &MsgBurn{}
+
+// NewMsgBurn creates a message to burn tokens
+func NewMsgBurn(sender string, amount sdk.Coin) *MsgBurn {
+ return &MsgBurn{
+ Sender: sender,
+ Amount: amount,
+ }
+}
+
+func (m MsgBurn) Route() string { return RouterKey }
+func (m MsgBurn) Type() string { return TypeMsgBurn }
+func (m MsgBurn) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(m.Sender)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err)
+ }
+
+ if !m.Amount.IsValid() || m.Amount.Amount.Equal(sdk.ZeroInt()) {
+ return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, m.Amount.String())
+ }
+
+ return nil
+}
+
+func (m MsgBurn) GetSignBytes() []byte {
+ return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m))
+}
+
+func (m MsgBurn) GetSigners() []sdk.AccAddress {
+ sender, _ := sdk.AccAddressFromBech32(m.Sender)
+ return []sdk.AccAddress{sender}
+}
+
+// var _ sdk.Msg = &MsgForceTransfer{}
+
+// // NewMsgForceTransfer creates a transfer funds from one account to another
+// func NewMsgForceTransfer(sender string, amount sdk.Coin, fromAddr, toAddr string) *MsgForceTransfer {
+// return &MsgForceTransfer{
+// Sender: sender,
+// Amount: amount,
+// TransferFromAddress: fromAddr,
+// TransferToAddress: toAddr,
+// }
+// }
+
+// func (m MsgForceTransfer) Route() string { return RouterKey }
+// func (m MsgForceTransfer) Type() string { return TypeMsgForceTransfer }
+// func (m MsgForceTransfer) ValidateBasic() error {
+// _, err := sdk.AccAddressFromBech32(m.Sender)
+// if err != nil {
+// return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err)
+// }
+
+// _, err = sdk.AccAddressFromBech32(m.TransferFromAddress)
+// if err != nil {
+// return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid address (%s)", err)
+// }
+// _, err = sdk.AccAddressFromBech32(m.TransferToAddress)
+// if err != nil {
+// return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid address (%s)", err)
+// }
+
+// if !m.Amount.IsValid() {
+// return sdkerrors.Wrap(sdkerrors.ErrInvalidCoins, m.Amount.String())
+// }
+
+// return nil
+// }
+
+// func (m MsgForceTransfer) GetSignBytes() []byte {
+// return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m))
+// }
+
+// func (m MsgForceTransfer) GetSigners() []sdk.AccAddress {
+// sender, _ := sdk.AccAddressFromBech32(m.Sender)
+// return []sdk.AccAddress{sender}
+// }
+
+var _ sdk.Msg = &MsgChangeAdmin{}
+
+// NewMsgChangeAdmin creates a message to burn tokens
+func NewMsgChangeAdmin(sender, denom, newAdmin string) *MsgChangeAdmin {
+ return &MsgChangeAdmin{
+ Sender: sender,
+ Denom: denom,
+ NewAdmin: newAdmin,
+ }
+}
+
+func (m MsgChangeAdmin) Route() string { return RouterKey }
+func (m MsgChangeAdmin) Type() string { return TypeMsgChangeAdmin }
+func (m MsgChangeAdmin) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(m.Sender)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err)
+ }
+
+ _, err = sdk.AccAddressFromBech32(m.NewAdmin)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid address (%s)", err)
+ }
+
+ _, _, err = DeconstructDenom(m.Denom)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (m MsgChangeAdmin) GetSignBytes() []byte {
+ return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m))
+}
+
+func (m MsgChangeAdmin) GetSigners() []sdk.AccAddress {
+ sender, _ := sdk.AccAddressFromBech32(m.Sender)
+ return []sdk.AccAddress{sender}
+}
+
+var _ sdk.Msg = &MsgSetDenomMetadata{}
+
+// NewMsgChangeAdmin creates a message to burn tokens
+func NewMsgSetDenomMetadata(sender string, metadata banktypes.Metadata) *MsgSetDenomMetadata {
+ return &MsgSetDenomMetadata{
+ Sender: sender,
+ Metadata: metadata,
+ }
+}
+
+func (m MsgSetDenomMetadata) Route() string { return RouterKey }
+func (m MsgSetDenomMetadata) Type() string { return TypeMsgSetDenomMetadata }
+func (m MsgSetDenomMetadata) ValidateBasic() error {
+ _, err := sdk.AccAddressFromBech32(m.Sender)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid sender address (%s)", err)
+ }
+
+ err = m.Metadata.Validate()
+ if err != nil {
+ return err
+ }
+
+ _, _, err = DeconstructDenom(m.Metadata.Base)
+ if err != nil {
+ return err
+ }
+
+ return nil
+}
+
+func (m MsgSetDenomMetadata) GetSignBytes() []byte {
+ return sdk.MustSortJSON(ModuleCdc.MustMarshalJSON(&m))
+}
+
+func (m MsgSetDenomMetadata) GetSigners() []sdk.AccAddress {
+ sender, _ := sdk.AccAddressFromBech32(m.Sender)
+ return []sdk.AccAddress{sender}
+}
diff --git a/x/tokenfactory/types/msgs_test.go b/x/tokenfactory/types/msgs_test.go
new file mode 100644
index 000000000..2559a1fd7
--- /dev/null
+++ b/x/tokenfactory/types/msgs_test.go
@@ -0,0 +1,401 @@
+package types_test
+
+import (
+ fmt "fmt"
+ "testing"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/public-awesome/stargaze/v11/x/tokenfactory/types"
+ "github.com/stretchr/testify/require"
+
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+ "github.com/tendermint/tendermint/crypto/ed25519"
+)
+
+// TestMsgCreateDenom tests if valid/invalid create denom messages are properly validated/invalidated
+func TestMsgCreateDenom(t *testing.T) {
+ // generate a private/public key pair and get the respective address
+ pk1 := ed25519.GenPrivKey().PubKey()
+ addr1 := sdk.AccAddress(pk1.Address())
+
+ // make a proper createDenom message
+ createMsg := func(after func(msg types.MsgCreateDenom) types.MsgCreateDenom) types.MsgCreateDenom {
+ properMsg := *types.NewMsgCreateDenom(
+ addr1.String(),
+ "bitcoin",
+ )
+
+ return after(properMsg)
+ }
+
+ // validate createDenom message was created as intended
+ msg := createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom {
+ return msg
+ })
+ require.Equal(t, msg.Route(), types.RouterKey)
+ require.Equal(t, msg.Type(), "create_denom")
+ signers := msg.GetSigners()
+ require.Equal(t, len(signers), 1)
+ require.Equal(t, signers[0].String(), addr1.String())
+
+ tests := []struct {
+ name string
+ msg types.MsgCreateDenom
+ expectPass bool
+ }{
+ {
+ name: "proper msg",
+ msg: createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom {
+ return msg
+ }),
+ expectPass: true,
+ },
+ {
+ name: "empty sender",
+ msg: createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom {
+ msg.Sender = ""
+ return msg
+ }),
+ expectPass: false,
+ },
+ {
+ name: "invalid subdenom",
+ msg: createMsg(func(msg types.MsgCreateDenom) types.MsgCreateDenom {
+ msg.Subdenom = "thissubdenomismuchtoolongasdkfjaasdfdsafsdlkfnmlksadmflksmdlfmlsakmfdsafasdfasdf"
+ return msg
+ }),
+ expectPass: false,
+ },
+ }
+
+ for _, test := range tests {
+ if test.expectPass {
+ require.NoError(t, test.msg.ValidateBasic(), "test: %v", test.name)
+ } else {
+ require.Error(t, test.msg.ValidateBasic(), "test: %v", test.name)
+ }
+ }
+}
+
+// TestMsgMint tests if valid/invalid create denom messages are properly validated/invalidated
+func TestMsgMint(t *testing.T) {
+ // generate a private/public key pair and get the respective address
+ pk1 := ed25519.GenPrivKey().PubKey()
+ addr1 := sdk.AccAddress(pk1.Address())
+
+ // make a proper mint message
+ createMsg := func(after func(msg types.MsgMint) types.MsgMint) types.MsgMint {
+ properMsg := *types.NewMsgMint(
+ addr1.String(),
+ sdk.NewCoin("bitcoin", sdk.NewInt(500000000)),
+ )
+
+ return after(properMsg)
+ }
+
+ // validate mint message was created as intended
+ msg := createMsg(func(msg types.MsgMint) types.MsgMint {
+ return msg
+ })
+ require.Equal(t, msg.Route(), types.RouterKey)
+ require.Equal(t, msg.Type(), "tf_mint")
+ signers := msg.GetSigners()
+ require.Equal(t, len(signers), 1)
+ require.Equal(t, signers[0].String(), addr1.String())
+
+ tests := []struct {
+ name string
+ msg types.MsgMint
+ expectPass bool
+ }{
+ {
+ name: "proper msg",
+ msg: createMsg(func(msg types.MsgMint) types.MsgMint {
+ return msg
+ }),
+ expectPass: true,
+ },
+ {
+ name: "empty sender",
+ msg: createMsg(func(msg types.MsgMint) types.MsgMint {
+ msg.Sender = ""
+ return msg
+ }),
+ expectPass: false,
+ },
+ {
+ name: "zero amount",
+ msg: createMsg(func(msg types.MsgMint) types.MsgMint {
+ msg.Amount = sdk.NewCoin("bitcoin", sdk.ZeroInt())
+ return msg
+ }),
+ expectPass: false,
+ },
+ {
+ name: "negative amount",
+ msg: createMsg(func(msg types.MsgMint) types.MsgMint {
+ msg.Amount.Amount = sdk.NewInt(-10000000)
+ return msg
+ }),
+ expectPass: false,
+ },
+ }
+
+ for _, test := range tests {
+ if test.expectPass {
+ require.NoError(t, test.msg.ValidateBasic(), "test: %v", test.name)
+ } else {
+ require.Error(t, test.msg.ValidateBasic(), "test: %v", test.name)
+ }
+ }
+}
+
+// TestMsgBurn tests if valid/invalid create denom messages are properly validated/invalidated
+func TestMsgBurn(t *testing.T) {
+ // generate a private/public key pair and get the respective address
+ pk1 := ed25519.GenPrivKey().PubKey()
+ addr1 := sdk.AccAddress(pk1.Address())
+
+ // make a proper burn message
+ baseMsg := types.NewMsgBurn(
+ addr1.String(),
+ sdk.NewCoin("bitcoin", sdk.NewInt(500000000)),
+ )
+
+ // validate burn message was created as intended
+ require.Equal(t, baseMsg.Route(), types.RouterKey)
+ require.Equal(t, baseMsg.Type(), "tf_burn")
+ signers := baseMsg.GetSigners()
+ require.Equal(t, len(signers), 1)
+ require.Equal(t, signers[0].String(), addr1.String())
+
+ tests := []struct {
+ name string
+ msg func() *types.MsgBurn
+ expectPass bool
+ }{
+ {
+ name: "proper msg",
+ msg: func() *types.MsgBurn {
+ msg := baseMsg
+ return msg
+ },
+ expectPass: true,
+ },
+ {
+ name: "empty sender",
+ msg: func() *types.MsgBurn {
+ msg := baseMsg
+ msg.Sender = ""
+ return msg
+ },
+ expectPass: false,
+ },
+ {
+ name: "zero amount",
+ msg: func() *types.MsgBurn {
+ msg := baseMsg
+ msg.Amount.Amount = sdk.ZeroInt()
+ return msg
+ },
+ expectPass: false,
+ },
+ {
+ name: "negative amount",
+ msg: func() *types.MsgBurn {
+ msg := baseMsg
+ msg.Amount.Amount = sdk.NewInt(-10000000)
+ return msg
+ },
+ expectPass: false,
+ },
+ }
+
+ for _, test := range tests {
+ if test.expectPass {
+ require.NoError(t, test.msg().ValidateBasic(), "test: %v", test.name)
+ } else {
+ require.Error(t, test.msg().ValidateBasic(), "test: %v", test.name)
+ }
+ }
+}
+
+// TestMsgChangeAdmin tests if valid/invalid create denom messages are properly validated/invalidated
+func TestMsgChangeAdmin(t *testing.T) {
+ // generate a private/public key pair and get the respective address
+ pk1 := ed25519.GenPrivKey().PubKey()
+ addr1 := sdk.AccAddress(pk1.Address())
+ pk2 := ed25519.GenPrivKey().PubKey()
+ addr2 := sdk.AccAddress(pk2.Address())
+ tokenFactoryDenom := fmt.Sprintf("factory/%s/bitcoin", addr1.String())
+
+ // make a proper changeAdmin message
+ baseMsg := types.NewMsgChangeAdmin(
+ addr1.String(),
+ tokenFactoryDenom,
+ addr2.String(),
+ )
+
+ // validate changeAdmin message was created as intended
+ require.Equal(t, baseMsg.Route(), types.RouterKey)
+ require.Equal(t, baseMsg.Type(), "change_admin")
+ signers := baseMsg.GetSigners()
+ require.Equal(t, len(signers), 1)
+ require.Equal(t, signers[0].String(), addr1.String())
+
+ tests := []struct {
+ name string
+ msg func() *types.MsgChangeAdmin
+ expectPass bool
+ }{
+ {
+ name: "proper msg",
+ msg: func() *types.MsgChangeAdmin {
+ msg := baseMsg
+ return msg
+ },
+ expectPass: true,
+ },
+ {
+ name: "empty sender",
+ msg: func() *types.MsgChangeAdmin {
+ msg := baseMsg
+ msg.Sender = ""
+ return msg
+ },
+ expectPass: false,
+ },
+ {
+ name: "empty newAdmin",
+ msg: func() *types.MsgChangeAdmin {
+ msg := baseMsg
+ msg.NewAdmin = ""
+ return msg
+ },
+ expectPass: false,
+ },
+ {
+ name: "invalid denom",
+ msg: func() *types.MsgChangeAdmin {
+ msg := baseMsg
+ msg.Denom = "bitcoin"
+ return msg
+ },
+ expectPass: false,
+ },
+ }
+
+ for _, test := range tests {
+ if test.expectPass {
+ require.NoError(t, test.msg().ValidateBasic(), "test: %v", test.name)
+ } else {
+ require.Error(t, test.msg().ValidateBasic(), "test: %v", test.name)
+ }
+ }
+}
+
+// TestMsgSetDenomMetadata tests if valid/invalid create denom messages are properly validated/invalidated
+func TestMsgSetDenomMetadata(t *testing.T) {
+ // generate a private/public key pair and get the respective address
+ pk1 := ed25519.GenPrivKey().PubKey()
+ addr1 := sdk.AccAddress(pk1.Address())
+ tokenFactoryDenom := fmt.Sprintf("factory/%s/bitcoin", addr1.String())
+ denomMetadata := banktypes.Metadata{
+ Description: "nakamoto",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: tokenFactoryDenom,
+ Exponent: 0,
+ },
+ {
+ Denom: "sats",
+ Exponent: 6,
+ },
+ },
+ Display: "sats",
+ Base: tokenFactoryDenom,
+ Name: "bitcoin",
+ Symbol: "BTC",
+ }
+ invalidDenomMetadata := banktypes.Metadata{
+ Description: "nakamoto",
+ DenomUnits: []*banktypes.DenomUnit{
+ {
+ Denom: "bitcoin",
+ Exponent: 0,
+ },
+ {
+ Denom: "sats",
+ Exponent: 6,
+ },
+ },
+ Display: "sats",
+ Base: "bitcoin",
+ Name: "bitcoin",
+ Symbol: "BTC",
+ }
+
+ // make a proper setDenomMetadata message
+ baseMsg := types.NewMsgSetDenomMetadata(
+ addr1.String(),
+ denomMetadata,
+ )
+
+ // validate setDenomMetadata message was created as intended
+ require.Equal(t, baseMsg.Route(), types.RouterKey)
+ require.Equal(t, baseMsg.Type(), "set_denom_metadata")
+ signers := baseMsg.GetSigners()
+ require.Equal(t, len(signers), 1)
+ require.Equal(t, signers[0].String(), addr1.String())
+
+ tests := []struct {
+ name string
+ msg func() *types.MsgSetDenomMetadata
+ expectPass bool
+ }{
+ {
+ name: "proper msg",
+ msg: func() *types.MsgSetDenomMetadata {
+ msg := baseMsg
+ return msg
+ },
+ expectPass: true,
+ },
+ {
+ name: "empty sender",
+ msg: func() *types.MsgSetDenomMetadata {
+ msg := baseMsg
+ msg.Sender = ""
+ return msg
+ },
+ expectPass: false,
+ },
+ {
+ name: "invalid metadata",
+ msg: func() *types.MsgSetDenomMetadata {
+ msg := baseMsg
+ msg.Metadata.Name = ""
+ return msg
+ },
+
+ expectPass: false,
+ },
+ {
+ name: "invalid base",
+ msg: func() *types.MsgSetDenomMetadata {
+ msg := baseMsg
+ msg.Metadata = invalidDenomMetadata
+ return msg
+ },
+ expectPass: false,
+ },
+ }
+
+ for _, test := range tests {
+ if test.expectPass {
+ require.NoError(t, test.msg().ValidateBasic(), "test: %v", test.name)
+ } else {
+ require.Error(t, test.msg().ValidateBasic(), "test: %v", test.name)
+ }
+ }
+}
diff --git a/x/tokenfactory/types/params.go b/x/tokenfactory/types/params.go
new file mode 100644
index 000000000..a1fa44ca1
--- /dev/null
+++ b/x/tokenfactory/types/params.go
@@ -0,0 +1,69 @@
+package types
+
+import (
+ "fmt"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ paramtypes "github.com/cosmos/cosmos-sdk/x/params/types"
+)
+
+// Parameter store keys.
+var (
+ KeyDenomCreationFee = []byte("DenomCreationFee")
+ KeyDenomCreationGasConsume = []byte("DenomCreationGasConsume")
+)
+
+// ParamTable for gamm module.
+func ParamKeyTable() paramtypes.KeyTable {
+ return paramtypes.NewKeyTable().RegisterParamSet(&Params{})
+}
+
+func NewParams(denomCreationFee sdk.Coins, denomCreationGasConsume uint64) Params {
+ return Params{
+ DenomCreationFee: denomCreationFee,
+ DenomCreationGasConsume: denomCreationGasConsume,
+ }
+}
+
+// default gamm module parameters.
+func DefaultParams() Params {
+ return Params{
+ DenomCreationFee: sdk.NewCoins(sdk.NewInt64Coin(sdk.DefaultBondDenom, 10_000_000)), // 10 STAKE
+ DenomCreationGasConsume: 0,
+ }
+}
+
+// validate params.
+func (p Params) Validate() error {
+ return validateDenomCreationFee(p.DenomCreationFee)
+}
+
+// Implements params.ParamSet.
+func (p *Params) ParamSetPairs() paramtypes.ParamSetPairs {
+ return paramtypes.ParamSetPairs{
+ paramtypes.NewParamSetPair(KeyDenomCreationFee, &p.DenomCreationFee, validateDenomCreationFee),
+ paramtypes.NewParamSetPair(KeyDenomCreationGasConsume, &p.DenomCreationGasConsume, validateDenomCreationGasConsume),
+ }
+}
+
+func validateDenomCreationFee(i interface{}) error {
+ v, ok := i.(sdk.Coins)
+ if !ok {
+ return fmt.Errorf("invalid parameter type: %T", i)
+ }
+
+ if v.Validate() != nil {
+ return fmt.Errorf("invalid denom creation fee: %+v", i)
+ }
+
+ return nil
+}
+
+func validateDenomCreationGasConsume(i interface{}) error {
+ _, ok := i.(uint64)
+ if !ok {
+ return fmt.Errorf("invalid parameter type: %T", i)
+ }
+
+ return nil
+}
diff --git a/x/tokenfactory/types/query.pb.go b/x/tokenfactory/types/query.pb.go
new file mode 100644
index 000000000..2579a7d17
--- /dev/null
+++ b/x/tokenfactory/types/query.pb.go
@@ -0,0 +1,1333 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: osmosis/tokenfactory/v1beta1/query.proto
+
+package types
+
+import (
+ context "context"
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-sdk/types/query"
+ _ "github.com/gogo/protobuf/gogoproto"
+ grpc1 "github.com/gogo/protobuf/grpc"
+ proto "github.com/gogo/protobuf/proto"
+ _ "google.golang.org/genproto/googleapis/api/annotations"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+ io "io"
+ math "math"
+ math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// QueryParamsRequest is the request type for the Query/Params RPC method.
+type QueryParamsRequest struct {
+}
+
+func (m *QueryParamsRequest) Reset() { *m = QueryParamsRequest{} }
+func (m *QueryParamsRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryParamsRequest) ProtoMessage() {}
+func (*QueryParamsRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_6f22013ad0f72e3f, []int{0}
+}
+func (m *QueryParamsRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *QueryParamsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_QueryParamsRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *QueryParamsRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_QueryParamsRequest.Merge(m, src)
+}
+func (m *QueryParamsRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *QueryParamsRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_QueryParamsRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryParamsRequest proto.InternalMessageInfo
+
+// QueryParamsResponse is the response type for the Query/Params RPC method.
+type QueryParamsResponse struct {
+ // params defines the parameters of the module.
+ Params Params `protobuf:"bytes,1,opt,name=params,proto3" json:"params"`
+}
+
+func (m *QueryParamsResponse) Reset() { *m = QueryParamsResponse{} }
+func (m *QueryParamsResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryParamsResponse) ProtoMessage() {}
+func (*QueryParamsResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_6f22013ad0f72e3f, []int{1}
+}
+func (m *QueryParamsResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *QueryParamsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_QueryParamsResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *QueryParamsResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_QueryParamsResponse.Merge(m, src)
+}
+func (m *QueryParamsResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *QueryParamsResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_QueryParamsResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryParamsResponse proto.InternalMessageInfo
+
+func (m *QueryParamsResponse) GetParams() Params {
+ if m != nil {
+ return m.Params
+ }
+ return Params{}
+}
+
+// QueryDenomAuthorityMetadataRequest defines the request structure for the
+// DenomAuthorityMetadata gRPC query.
+type QueryDenomAuthorityMetadataRequest struct {
+ Denom string `protobuf:"bytes,1,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
+}
+
+func (m *QueryDenomAuthorityMetadataRequest) Reset() { *m = QueryDenomAuthorityMetadataRequest{} }
+func (m *QueryDenomAuthorityMetadataRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryDenomAuthorityMetadataRequest) ProtoMessage() {}
+func (*QueryDenomAuthorityMetadataRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_6f22013ad0f72e3f, []int{2}
+}
+func (m *QueryDenomAuthorityMetadataRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *QueryDenomAuthorityMetadataRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_QueryDenomAuthorityMetadataRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *QueryDenomAuthorityMetadataRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_QueryDenomAuthorityMetadataRequest.Merge(m, src)
+}
+func (m *QueryDenomAuthorityMetadataRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *QueryDenomAuthorityMetadataRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_QueryDenomAuthorityMetadataRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryDenomAuthorityMetadataRequest proto.InternalMessageInfo
+
+func (m *QueryDenomAuthorityMetadataRequest) GetDenom() string {
+ if m != nil {
+ return m.Denom
+ }
+ return ""
+}
+
+// QueryDenomAuthorityMetadataResponse defines the response structure for the
+// DenomAuthorityMetadata gRPC query.
+type QueryDenomAuthorityMetadataResponse struct {
+ AuthorityMetadata DenomAuthorityMetadata `protobuf:"bytes,1,opt,name=authority_metadata,json=authorityMetadata,proto3" json:"authority_metadata" yaml:"authority_metadata"`
+}
+
+func (m *QueryDenomAuthorityMetadataResponse) Reset() { *m = QueryDenomAuthorityMetadataResponse{} }
+func (m *QueryDenomAuthorityMetadataResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryDenomAuthorityMetadataResponse) ProtoMessage() {}
+func (*QueryDenomAuthorityMetadataResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_6f22013ad0f72e3f, []int{3}
+}
+func (m *QueryDenomAuthorityMetadataResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *QueryDenomAuthorityMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_QueryDenomAuthorityMetadataResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *QueryDenomAuthorityMetadataResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_QueryDenomAuthorityMetadataResponse.Merge(m, src)
+}
+func (m *QueryDenomAuthorityMetadataResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *QueryDenomAuthorityMetadataResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_QueryDenomAuthorityMetadataResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryDenomAuthorityMetadataResponse proto.InternalMessageInfo
+
+func (m *QueryDenomAuthorityMetadataResponse) GetAuthorityMetadata() DenomAuthorityMetadata {
+ if m != nil {
+ return m.AuthorityMetadata
+ }
+ return DenomAuthorityMetadata{}
+}
+
+// QueryDenomsFromCreatorRequest defines the request structure for the
+// DenomsFromCreator gRPC query.
+type QueryDenomsFromCreatorRequest struct {
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty" yaml:"creator"`
+}
+
+func (m *QueryDenomsFromCreatorRequest) Reset() { *m = QueryDenomsFromCreatorRequest{} }
+func (m *QueryDenomsFromCreatorRequest) String() string { return proto.CompactTextString(m) }
+func (*QueryDenomsFromCreatorRequest) ProtoMessage() {}
+func (*QueryDenomsFromCreatorRequest) Descriptor() ([]byte, []int) {
+ return fileDescriptor_6f22013ad0f72e3f, []int{4}
+}
+func (m *QueryDenomsFromCreatorRequest) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *QueryDenomsFromCreatorRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_QueryDenomsFromCreatorRequest.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *QueryDenomsFromCreatorRequest) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_QueryDenomsFromCreatorRequest.Merge(m, src)
+}
+func (m *QueryDenomsFromCreatorRequest) XXX_Size() int {
+ return m.Size()
+}
+func (m *QueryDenomsFromCreatorRequest) XXX_DiscardUnknown() {
+ xxx_messageInfo_QueryDenomsFromCreatorRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryDenomsFromCreatorRequest proto.InternalMessageInfo
+
+func (m *QueryDenomsFromCreatorRequest) GetCreator() string {
+ if m != nil {
+ return m.Creator
+ }
+ return ""
+}
+
+// QueryDenomsFromCreatorRequest defines the response structure for the
+// DenomsFromCreator gRPC query.
+type QueryDenomsFromCreatorResponse struct {
+ Denoms []string `protobuf:"bytes,1,rep,name=denoms,proto3" json:"denoms,omitempty" yaml:"denoms"`
+}
+
+func (m *QueryDenomsFromCreatorResponse) Reset() { *m = QueryDenomsFromCreatorResponse{} }
+func (m *QueryDenomsFromCreatorResponse) String() string { return proto.CompactTextString(m) }
+func (*QueryDenomsFromCreatorResponse) ProtoMessage() {}
+func (*QueryDenomsFromCreatorResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_6f22013ad0f72e3f, []int{5}
+}
+func (m *QueryDenomsFromCreatorResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *QueryDenomsFromCreatorResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_QueryDenomsFromCreatorResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *QueryDenomsFromCreatorResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_QueryDenomsFromCreatorResponse.Merge(m, src)
+}
+func (m *QueryDenomsFromCreatorResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *QueryDenomsFromCreatorResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_QueryDenomsFromCreatorResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_QueryDenomsFromCreatorResponse proto.InternalMessageInfo
+
+func (m *QueryDenomsFromCreatorResponse) GetDenoms() []string {
+ if m != nil {
+ return m.Denoms
+ }
+ return nil
+}
+
+func init() {
+ proto.RegisterType((*QueryParamsRequest)(nil), "osmosis.tokenfactory.v1beta1.QueryParamsRequest")
+ proto.RegisterType((*QueryParamsResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryParamsResponse")
+ proto.RegisterType((*QueryDenomAuthorityMetadataRequest)(nil), "osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataRequest")
+ proto.RegisterType((*QueryDenomAuthorityMetadataResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataResponse")
+ proto.RegisterType((*QueryDenomsFromCreatorRequest)(nil), "osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorRequest")
+ proto.RegisterType((*QueryDenomsFromCreatorResponse)(nil), "osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorResponse")
+}
+
+func init() {
+ proto.RegisterFile("osmosis/tokenfactory/v1beta1/query.proto", fileDescriptor_6f22013ad0f72e3f)
+}
+
+var fileDescriptor_6f22013ad0f72e3f = []byte{
+ // 581 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x54, 0xcd, 0x6e, 0xd3, 0x40,
+ 0x10, 0x8e, 0xa1, 0x0d, 0xea, 0xf2, 0x23, 0xb2, 0x54, 0x08, 0xa2, 0xe2, 0x94, 0x05, 0xa1, 0x80,
+ 0xc0, 0xdb, 0x14, 0x24, 0x04, 0x01, 0x41, 0x5d, 0xc4, 0x05, 0x2a, 0x81, 0x25, 0x0e, 0x70, 0x89,
+ 0x36, 0xe9, 0xd6, 0xb5, 0x88, 0x3d, 0xae, 0x77, 0x53, 0x08, 0x55, 0x2f, 0x1c, 0x38, 0x23, 0x71,
+ 0xe0, 0x2d, 0x78, 0x8e, 0xde, 0xa8, 0xc4, 0xa5, 0xa7, 0x08, 0x25, 0x3c, 0x41, 0x9e, 0x00, 0x79,
+ 0x77, 0x43, 0x9b, 0x26, 0x35, 0x85, 0x9e, 0xbc, 0x9a, 0xf9, 0xe6, 0x9b, 0xef, 0x9b, 0x19, 0x19,
+ 0x95, 0x41, 0x84, 0x20, 0x02, 0x41, 0x25, 0xbc, 0xe5, 0xd1, 0x0a, 0x6b, 0x48, 0x48, 0xda, 0x74,
+ 0xbd, 0x52, 0xe7, 0x92, 0x55, 0xe8, 0x5a, 0x8b, 0x27, 0x6d, 0x27, 0x4e, 0x40, 0x02, 0x9e, 0x31,
+ 0x48, 0x67, 0x2f, 0xd2, 0x31, 0xc8, 0xe2, 0xb4, 0x0f, 0x3e, 0x28, 0x20, 0x4d, 0x5f, 0xba, 0xa6,
+ 0x38, 0xe3, 0x03, 0xf8, 0x4d, 0x4e, 0x59, 0x1c, 0x50, 0x16, 0x45, 0x20, 0x99, 0x0c, 0x20, 0x12,
+ 0x26, 0x7b, 0xa3, 0xa1, 0x28, 0x69, 0x9d, 0x09, 0xae, 0x5b, 0xfd, 0x69, 0x1c, 0x33, 0x3f, 0x88,
+ 0x14, 0xd8, 0x60, 0x69, 0xa6, 0xce, 0x21, 0x49, 0xaa, 0x80, 0x4c, 0x23, 0xfc, 0x32, 0xa5, 0x7c,
+ 0xc1, 0x12, 0x16, 0x0a, 0x8f, 0xaf, 0xb5, 0xb8, 0x90, 0xe4, 0x35, 0x3a, 0x37, 0x14, 0x15, 0x31,
+ 0x44, 0x82, 0x63, 0x17, 0xe5, 0x63, 0x15, 0xb9, 0x60, 0xcd, 0x5a, 0xe5, 0x93, 0xf3, 0x57, 0x9d,
+ 0x2c, 0xb3, 0x8e, 0xae, 0x76, 0x27, 0xb6, 0x3a, 0xa5, 0x9c, 0x67, 0x2a, 0xc9, 0x73, 0x44, 0x14,
+ 0xf5, 0x13, 0x1e, 0x41, 0xb8, 0xd0, 0x92, 0xab, 0x90, 0x04, 0xb2, 0xbd, 0xc4, 0x25, 0x5b, 0x66,
+ 0x92, 0x19, 0x01, 0xf8, 0x1a, 0x9a, 0x5c, 0x4e, 0x01, 0xaa, 0xd1, 0x94, 0x7b, 0xb6, 0xdf, 0x29,
+ 0x9d, 0x6a, 0xb3, 0xb0, 0x79, 0x9f, 0xa8, 0x30, 0xf1, 0x74, 0x9a, 0x7c, 0xb3, 0xd0, 0x95, 0x4c,
+ 0x3a, 0xa3, 0xfc, 0x93, 0x85, 0x30, 0x1b, 0x64, 0x6b, 0xa1, 0x49, 0x1b, 0x1b, 0x77, 0xb2, 0x6d,
+ 0x8c, 0xa7, 0x76, 0x2f, 0xa7, 0xb6, 0xfa, 0x9d, 0xd2, 0x45, 0xad, 0x6b, 0x94, 0x9d, 0x78, 0x05,
+ 0xb6, 0xbf, 0x8a, 0x2c, 0xa1, 0x4b, 0xbb, 0x7a, 0xc5, 0xd3, 0x04, 0xc2, 0xc5, 0x84, 0x33, 0x09,
+ 0xc9, 0xc0, 0xf9, 0x4d, 0x74, 0xa2, 0xa1, 0x23, 0xc6, 0x3b, 0xee, 0x77, 0x4a, 0x67, 0x74, 0x0f,
+ 0x93, 0x20, 0xde, 0x00, 0x42, 0x9e, 0x21, 0xfb, 0x20, 0x3a, 0xe3, 0xfc, 0x3a, 0xca, 0xab, 0x51,
+ 0xa5, 0x3b, 0x3b, 0x5e, 0x9e, 0x72, 0x0b, 0xfd, 0x4e, 0xe9, 0xf4, 0x9e, 0x51, 0x0a, 0xe2, 0x19,
+ 0xc0, 0xfc, 0xce, 0x04, 0x9a, 0x54, 0x6c, 0xf8, 0xab, 0x85, 0xf2, 0x7a, 0x7b, 0x78, 0x2e, 0x7b,
+ 0x38, 0xa3, 0xc7, 0x53, 0xac, 0xfc, 0x43, 0x85, 0x16, 0x49, 0xca, 0x1f, 0x7f, 0xfc, 0xfa, 0x72,
+ 0x8c, 0xe0, 0x59, 0x2a, 0x24, 0x4b, 0x7c, 0xf6, 0x81, 0xef, 0x3f, 0x60, 0xaa, 0xcf, 0x07, 0x77,
+ 0x2d, 0x74, 0x7e, 0xfc, 0x42, 0xf0, 0xe3, 0x43, 0xf4, 0xcd, 0xbc, 0xba, 0xe2, 0xc2, 0x11, 0x18,
+ 0x8c, 0x93, 0x45, 0xe5, 0xe4, 0x21, 0xae, 0x1e, 0xec, 0x44, 0x4f, 0x9b, 0x6e, 0xa8, 0xef, 0x26,
+ 0x1d, 0x3d, 0x1c, 0xfc, 0xdd, 0x42, 0x85, 0x91, 0x8d, 0xe2, 0xea, 0x61, 0xd5, 0x8d, 0x39, 0xab,
+ 0xe2, 0x83, 0xff, 0x2b, 0x36, 0xae, 0x1e, 0x29, 0x57, 0xf7, 0xf0, 0xdd, 0xbf, 0xb9, 0xaa, 0xad,
+ 0x24, 0x10, 0xd6, 0xcc, 0x75, 0xd2, 0x0d, 0xf3, 0xd8, 0x74, 0x5f, 0x6d, 0x75, 0x6d, 0x6b, 0xbb,
+ 0x6b, 0x5b, 0x3f, 0xbb, 0xb6, 0xf5, 0xb9, 0x67, 0xe7, 0xb6, 0x7b, 0x76, 0x6e, 0xa7, 0x67, 0xe7,
+ 0xde, 0x54, 0xfd, 0x40, 0xae, 0xb6, 0xea, 0x4e, 0x03, 0x42, 0x1a, 0xb7, 0xea, 0xcd, 0xa0, 0x71,
+ 0x8b, 0xbd, 0xe3, 0x02, 0x42, 0xbe, 0xdb, 0x6b, 0xbd, 0x32, 0x47, 0xdf, 0x0f, 0x77, 0x94, 0xed,
+ 0x98, 0x8b, 0x7a, 0x5e, 0xfd, 0xc4, 0x6e, 0xff, 0x0e, 0x00, 0x00, 0xff, 0xff, 0xa9, 0x49, 0x60,
+ 0xb8, 0x9f, 0x05, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// QueryClient is the client API for Query service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type QueryClient interface {
+ // Params defines a gRPC query method that returns the tokenfactory module's
+ // parameters.
+ Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error)
+ // DenomAuthorityMetadata defines a gRPC query method for fetching
+ // DenomAuthorityMetadata for a particular denom.
+ DenomAuthorityMetadata(ctx context.Context, in *QueryDenomAuthorityMetadataRequest, opts ...grpc.CallOption) (*QueryDenomAuthorityMetadataResponse, error)
+ // DenomsFromCreator defines a gRPC query method for fetching all
+ // denominations created by a specific admin/creator.
+ DenomsFromCreator(ctx context.Context, in *QueryDenomsFromCreatorRequest, opts ...grpc.CallOption) (*QueryDenomsFromCreatorResponse, error)
+}
+
+type queryClient struct {
+ cc grpc1.ClientConn
+}
+
+func NewQueryClient(cc grpc1.ClientConn) QueryClient {
+ return &queryClient{cc}
+}
+
+func (c *queryClient) Params(ctx context.Context, in *QueryParamsRequest, opts ...grpc.CallOption) (*QueryParamsResponse, error) {
+ out := new(QueryParamsResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Query/Params", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) DenomAuthorityMetadata(ctx context.Context, in *QueryDenomAuthorityMetadataRequest, opts ...grpc.CallOption) (*QueryDenomAuthorityMetadataResponse, error) {
+ out := new(QueryDenomAuthorityMetadataResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Query/DenomAuthorityMetadata", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *queryClient) DenomsFromCreator(ctx context.Context, in *QueryDenomsFromCreatorRequest, opts ...grpc.CallOption) (*QueryDenomsFromCreatorResponse, error) {
+ out := new(QueryDenomsFromCreatorResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Query/DenomsFromCreator", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// QueryServer is the server API for Query service.
+type QueryServer interface {
+ // Params defines a gRPC query method that returns the tokenfactory module's
+ // parameters.
+ Params(context.Context, *QueryParamsRequest) (*QueryParamsResponse, error)
+ // DenomAuthorityMetadata defines a gRPC query method for fetching
+ // DenomAuthorityMetadata for a particular denom.
+ DenomAuthorityMetadata(context.Context, *QueryDenomAuthorityMetadataRequest) (*QueryDenomAuthorityMetadataResponse, error)
+ // DenomsFromCreator defines a gRPC query method for fetching all
+ // denominations created by a specific admin/creator.
+ DenomsFromCreator(context.Context, *QueryDenomsFromCreatorRequest) (*QueryDenomsFromCreatorResponse, error)
+}
+
+// UnimplementedQueryServer can be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+func (*UnimplementedQueryServer) Params(ctx context.Context, req *QueryParamsRequest) (*QueryParamsResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Params not implemented")
+}
+func (*UnimplementedQueryServer) DenomAuthorityMetadata(ctx context.Context, req *QueryDenomAuthorityMetadataRequest) (*QueryDenomAuthorityMetadataResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method DenomAuthorityMetadata not implemented")
+}
+func (*UnimplementedQueryServer) DenomsFromCreator(ctx context.Context, req *QueryDenomsFromCreatorRequest) (*QueryDenomsFromCreatorResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method DenomsFromCreator not implemented")
+}
+
+func RegisterQueryServer(s grpc1.Server, srv QueryServer) {
+ s.RegisterService(&_Query_serviceDesc, srv)
+}
+
+func _Query_Params_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryParamsRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).Params(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Query/Params",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).Params(ctx, req.(*QueryParamsRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_DenomAuthorityMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryDenomAuthorityMetadataRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).DenomAuthorityMetadata(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Query/DenomAuthorityMetadata",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).DenomAuthorityMetadata(ctx, req.(*QueryDenomAuthorityMetadataRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Query_DenomsFromCreator_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(QueryDenomsFromCreatorRequest)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(QueryServer).DenomsFromCreator(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Query/DenomsFromCreator",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(QueryServer).DenomsFromCreator(ctx, req.(*QueryDenomsFromCreatorRequest))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _Query_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "osmosis.tokenfactory.v1beta1.Query",
+ HandlerType: (*QueryServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "Params",
+ Handler: _Query_Params_Handler,
+ },
+ {
+ MethodName: "DenomAuthorityMetadata",
+ Handler: _Query_DenomAuthorityMetadata_Handler,
+ },
+ {
+ MethodName: "DenomsFromCreator",
+ Handler: _Query_DenomsFromCreator_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "osmosis/tokenfactory/v1beta1/query.proto",
+}
+
+func (m *QueryParamsRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *QueryParamsRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryParamsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+func (m *QueryParamsResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *QueryParamsResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryParamsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.Params.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintQuery(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
+}
+
+func (m *QueryDenomAuthorityMetadataRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *QueryDenomAuthorityMetadataRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryDenomAuthorityMetadataRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Denom) > 0 {
+ i -= len(m.Denom)
+ copy(dAtA[i:], m.Denom)
+ i = encodeVarintQuery(dAtA, i, uint64(len(m.Denom)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *QueryDenomAuthorityMetadataResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *QueryDenomAuthorityMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryDenomAuthorityMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.AuthorityMetadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintQuery(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ return len(dAtA) - i, nil
+}
+
+func (m *QueryDenomsFromCreatorRequest) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *QueryDenomsFromCreatorRequest) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryDenomsFromCreatorRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Creator) > 0 {
+ i -= len(m.Creator)
+ copy(dAtA[i:], m.Creator)
+ i = encodeVarintQuery(dAtA, i, uint64(len(m.Creator)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *QueryDenomsFromCreatorResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *QueryDenomsFromCreatorResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *QueryDenomsFromCreatorResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Denoms) > 0 {
+ for iNdEx := len(m.Denoms) - 1; iNdEx >= 0; iNdEx-- {
+ i -= len(m.Denoms[iNdEx])
+ copy(dAtA[i:], m.Denoms[iNdEx])
+ i = encodeVarintQuery(dAtA, i, uint64(len(m.Denoms[iNdEx])))
+ i--
+ dAtA[i] = 0xa
+ }
+ }
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintQuery(dAtA []byte, offset int, v uint64) int {
+ offset -= sovQuery(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *QueryParamsRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func (m *QueryParamsResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = m.Params.Size()
+ n += 1 + l + sovQuery(uint64(l))
+ return n
+}
+
+func (m *QueryDenomAuthorityMetadataRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Denom)
+ if l > 0 {
+ n += 1 + l + sovQuery(uint64(l))
+ }
+ return n
+}
+
+func (m *QueryDenomAuthorityMetadataResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = m.AuthorityMetadata.Size()
+ n += 1 + l + sovQuery(uint64(l))
+ return n
+}
+
+func (m *QueryDenomsFromCreatorRequest) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Creator)
+ if l > 0 {
+ n += 1 + l + sovQuery(uint64(l))
+ }
+ return n
+}
+
+func (m *QueryDenomsFromCreatorResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if len(m.Denoms) > 0 {
+ for _, s := range m.Denoms {
+ l = len(s)
+ n += 1 + l + sovQuery(uint64(l))
+ }
+ }
+ return n
+}
+
+func sovQuery(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozQuery(x uint64) (n int) {
+ return sovQuery(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *QueryParamsRequest) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: QueryParamsRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: QueryParamsRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipQuery(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *QueryParamsResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: QueryParamsResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: QueryParamsResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Params", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthQuery
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Params.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipQuery(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *QueryDenomAuthorityMetadataRequest) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: QueryDenomAuthorityMetadataRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: QueryDenomAuthorityMetadataRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthQuery
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Denom = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipQuery(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *QueryDenomAuthorityMetadataResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: QueryDenomAuthorityMetadataResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: QueryDenomAuthorityMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field AuthorityMetadata", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthQuery
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.AuthorityMetadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipQuery(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *QueryDenomsFromCreatorRequest) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: QueryDenomsFromCreatorRequest: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: QueryDenomsFromCreatorRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthQuery
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Creator = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipQuery(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *QueryDenomsFromCreatorResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: QueryDenomsFromCreatorResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: QueryDenomsFromCreatorResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Denoms", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthQuery
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Denoms = append(m.Denoms, string(dAtA[iNdEx:postIndex]))
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipQuery(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthQuery
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipQuery(dAtA []byte) (n int, err error) {
+ l := len(dAtA)
+ iNdEx := 0
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if dAtA[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ case 1:
+ iNdEx += 8
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowQuery
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if length < 0 {
+ return 0, ErrInvalidLengthQuery
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupQuery
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthQuery
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthQuery = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowQuery = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupQuery = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/tokenfactory/types/query.pb.gw.go b/x/tokenfactory/types/query.pb.gw.go
new file mode 100644
index 000000000..bfda62112
--- /dev/null
+++ b/x/tokenfactory/types/query.pb.gw.go
@@ -0,0 +1,344 @@
+// Code generated by protoc-gen-grpc-gateway. DO NOT EDIT.
+// source: osmosis/tokenfactory/v1beta1/query.proto
+
+/*
+Package types is a reverse proxy.
+
+It translates gRPC into RESTful JSON APIs.
+*/
+package types
+
+import (
+ "context"
+ "io"
+ "net/http"
+
+ "github.com/golang/protobuf/descriptor"
+ "github.com/golang/protobuf/proto"
+ "github.com/grpc-ecosystem/grpc-gateway/runtime"
+ "github.com/grpc-ecosystem/grpc-gateway/utilities"
+ "google.golang.org/grpc"
+ "google.golang.org/grpc/codes"
+ "google.golang.org/grpc/grpclog"
+ "google.golang.org/grpc/status"
+)
+
+// Suppress "imported and not used" errors
+var _ codes.Code
+var _ io.Reader
+var _ status.Status
+var _ = runtime.String
+var _ = utilities.NewDoubleArray
+var _ = descriptor.ForMessage
+
+func request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq QueryParamsRequest
+ var metadata runtime.ServerMetadata
+
+ msg, err := client.Params(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_Query_Params_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq QueryParamsRequest
+ var metadata runtime.ServerMetadata
+
+ msg, err := server.Params(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+func request_Query_DenomAuthorityMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq QueryDenomAuthorityMetadataRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["denom"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
+ }
+
+ protoReq.Denom, err = runtime.String(val)
+
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
+ }
+
+ msg, err := client.DenomAuthorityMetadata(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_Query_DenomAuthorityMetadata_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq QueryDenomAuthorityMetadataRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["denom"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "denom")
+ }
+
+ protoReq.Denom, err = runtime.String(val)
+
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "denom", err)
+ }
+
+ msg, err := server.DenomAuthorityMetadata(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+func request_Query_DenomsFromCreator_0(ctx context.Context, marshaler runtime.Marshaler, client QueryClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq QueryDenomsFromCreatorRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["creator"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "creator")
+ }
+
+ protoReq.Creator, err = runtime.String(val)
+
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator", err)
+ }
+
+ msg, err := client.DenomsFromCreator(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))
+ return msg, metadata, err
+
+}
+
+func local_request_Query_DenomsFromCreator_0(ctx context.Context, marshaler runtime.Marshaler, server QueryServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {
+ var protoReq QueryDenomsFromCreatorRequest
+ var metadata runtime.ServerMetadata
+
+ var (
+ val string
+ ok bool
+ err error
+ _ = err
+ )
+
+ val, ok = pathParams["creator"]
+ if !ok {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "missing parameter %s", "creator")
+ }
+
+ protoReq.Creator, err = runtime.String(val)
+
+ if err != nil {
+ return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "creator", err)
+ }
+
+ msg, err := server.DenomsFromCreator(ctx, &protoReq)
+ return msg, metadata, err
+
+}
+
+// RegisterQueryHandlerServer registers the http handlers for service Query to "mux".
+// UnaryRPC :call QueryServer directly.
+// StreamingRPC :currently unsupported pending https://github.com/grpc/grpc-go/issues/906.
+// Note that using this registration option will cause many gRPC library features (such as grpc.SendHeader, etc) to stop working. Consider using RegisterQueryHandlerFromEndpoint instead.
+func RegisterQueryHandlerServer(ctx context.Context, mux *runtime.ServeMux, server QueryServer) error {
+
+ mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_Query_Params_0(rctx, inboundMarshaler, server, req, pathParams)
+ ctx = runtime.NewServerMetadataContext(ctx, md)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("GET", pattern_Query_DenomAuthorityMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_Query_DenomAuthorityMetadata_0(rctx, inboundMarshaler, server, req, pathParams)
+ ctx = runtime.NewServerMetadataContext(ctx, md)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_Query_DenomAuthorityMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("GET", pattern_Query_DenomsFromCreator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ rctx, err := runtime.AnnotateIncomingContext(ctx, mux, req)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := local_request_Query_DenomsFromCreator_0(rctx, inboundMarshaler, server, req, pathParams)
+ ctx = runtime.NewServerMetadataContext(ctx, md)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_Query_DenomsFromCreator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ return nil
+}
+
+// RegisterQueryHandlerFromEndpoint is same as RegisterQueryHandler but
+// automatically dials to "endpoint" and closes the connection when "ctx" gets done.
+func RegisterQueryHandlerFromEndpoint(ctx context.Context, mux *runtime.ServeMux, endpoint string, opts []grpc.DialOption) (err error) {
+ conn, err := grpc.Dial(endpoint, opts...)
+ if err != nil {
+ return err
+ }
+ defer func() {
+ if err != nil {
+ if cerr := conn.Close(); cerr != nil {
+ grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+ }
+ return
+ }
+ go func() {
+ <-ctx.Done()
+ if cerr := conn.Close(); cerr != nil {
+ grpclog.Infof("Failed to close conn to %s: %v", endpoint, cerr)
+ }
+ }()
+ }()
+
+ return RegisterQueryHandler(ctx, mux, conn)
+}
+
+// RegisterQueryHandler registers the http handlers for service Query to "mux".
+// The handlers forward requests to the grpc endpoint over "conn".
+func RegisterQueryHandler(ctx context.Context, mux *runtime.ServeMux, conn *grpc.ClientConn) error {
+ return RegisterQueryHandlerClient(ctx, mux, NewQueryClient(conn))
+}
+
+// RegisterQueryHandlerClient registers the http handlers for service Query
+// to "mux". The handlers forward requests to the grpc endpoint over the given implementation of "QueryClient".
+// Note: the gRPC framework executes interceptors within the gRPC handler. If the passed in "QueryClient"
+// doesn't go through the normal gRPC flow (creating a gRPC client etc.) then it will be up to the passed in
+// "QueryClient" to call the correct interceptors.
+func RegisterQueryHandlerClient(ctx context.Context, mux *runtime.ServeMux, client QueryClient) error {
+
+ mux.Handle("GET", pattern_Query_Params_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ rctx, err := runtime.AnnotateContext(ctx, mux, req)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_Query_Params_0(rctx, inboundMarshaler, client, req, pathParams)
+ ctx = runtime.NewServerMetadataContext(ctx, md)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_Query_Params_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("GET", pattern_Query_DenomAuthorityMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ rctx, err := runtime.AnnotateContext(ctx, mux, req)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_Query_DenomAuthorityMetadata_0(rctx, inboundMarshaler, client, req, pathParams)
+ ctx = runtime.NewServerMetadataContext(ctx, md)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_Query_DenomAuthorityMetadata_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ mux.Handle("GET", pattern_Query_DenomsFromCreator_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {
+ ctx, cancel := context.WithCancel(req.Context())
+ defer cancel()
+ inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)
+ rctx, err := runtime.AnnotateContext(ctx, mux, req)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+ resp, md, err := request_Query_DenomsFromCreator_0(rctx, inboundMarshaler, client, req, pathParams)
+ ctx = runtime.NewServerMetadataContext(ctx, md)
+ if err != nil {
+ runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)
+ return
+ }
+
+ forward_Query_DenomsFromCreator_0(ctx, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)
+
+ })
+
+ return nil
+}
+
+var (
+ pattern_Query_Params_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3}, []string{"stargaze", "tokenfactory", "v1", "params"}, "", runtime.AssumeColonVerbOpt(true)))
+
+ pattern_Query_DenomAuthorityMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4, 2, 5}, []string{"stargaze", "tokenfactory", "v1", "denoms", "denom", "authority_metadata"}, "", runtime.AssumeColonVerbOpt(true)))
+
+ pattern_Query_DenomsFromCreator_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2, 2, 3, 1, 0, 4, 1, 5, 4}, []string{"stargaze", "tokenfactory", "v1", "denoms_from_creator", "creator"}, "", runtime.AssumeColonVerbOpt(true)))
+)
+
+var (
+ forward_Query_Params_0 = runtime.ForwardResponseMessage
+
+ forward_Query_DenomAuthorityMetadata_0 = runtime.ForwardResponseMessage
+
+ forward_Query_DenomsFromCreator_0 = runtime.ForwardResponseMessage
+)
diff --git a/x/tokenfactory/types/tokenfactory.go b/x/tokenfactory/types/tokenfactory.go
new file mode 100644
index 000000000..b45bffcab
--- /dev/null
+++ b/x/tokenfactory/types/tokenfactory.go
@@ -0,0 +1,15 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+func (metadata DenomAuthorityMetadata) Validate() error {
+ if metadata.Admin != "" {
+ _, err := sdk.AccAddressFromBech32(metadata.Admin)
+ if err != nil {
+ return err
+ }
+ }
+ return nil
+}
diff --git a/x/tokenfactory/types/tokenfactory.pb.go b/x/tokenfactory/types/tokenfactory.pb.go
new file mode 100644
index 000000000..25629f3df
--- /dev/null
+++ b/x/tokenfactory/types/tokenfactory.pb.go
@@ -0,0 +1,587 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: osmosis/tokenfactory/v1beta1/tokenfactory.proto
+
+package types
+
+import (
+ fmt "fmt"
+ github_com_cosmos_cosmos_sdk_types "github.com/cosmos/cosmos-sdk/types"
+ types "github.com/cosmos/cosmos-sdk/types"
+ _ "github.com/gogo/protobuf/gogoproto"
+ proto "github.com/gogo/protobuf/proto"
+ _ "github.com/regen-network/cosmos-proto"
+ io "io"
+ math "math"
+ math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// DenomAuthorityMetadata specifies metadata for addresses that have specific
+// capabilities over a token factory denom. Right now there is only one Admin
+// permission, but is planned to be extended to the future.
+type DenomAuthorityMetadata struct {
+ // Can be empty for no admin, or a valid stargaze address
+ Admin string `protobuf:"bytes,1,opt,name=admin,proto3" json:"admin,omitempty" yaml:"admin"`
+}
+
+func (m *DenomAuthorityMetadata) Reset() { *m = DenomAuthorityMetadata{} }
+func (m *DenomAuthorityMetadata) String() string { return proto.CompactTextString(m) }
+func (*DenomAuthorityMetadata) ProtoMessage() {}
+func (*DenomAuthorityMetadata) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ce345928cf8ce182, []int{0}
+}
+func (m *DenomAuthorityMetadata) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *DenomAuthorityMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_DenomAuthorityMetadata.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *DenomAuthorityMetadata) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_DenomAuthorityMetadata.Merge(m, src)
+}
+func (m *DenomAuthorityMetadata) XXX_Size() int {
+ return m.Size()
+}
+func (m *DenomAuthorityMetadata) XXX_DiscardUnknown() {
+ xxx_messageInfo_DenomAuthorityMetadata.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_DenomAuthorityMetadata proto.InternalMessageInfo
+
+func (m *DenomAuthorityMetadata) GetAdmin() string {
+ if m != nil {
+ return m.Admin
+ }
+ return ""
+}
+
+// Params defines the parameters for the tokenfactory module.
+type Params struct {
+ // DenomCreationFee defines the fee to be charged on the creation of a new
+ // denom. The fee is drawn from the MsgCreateDenom's sender account, and
+ // transferred to the community pool.
+ DenomCreationFee github_com_cosmos_cosmos_sdk_types.Coins `protobuf:"bytes,1,rep,name=denom_creation_fee,json=denomCreationFee,proto3,castrepeated=github.com/cosmos/cosmos-sdk/types.Coins" json:"denom_creation_fee" yaml:"denom_creation_fee"`
+ // DenomCreationGasConsume defines the gas cost for creating a new denom.
+ // This is intended as a spam deterrence mechanism.
+ //
+ // See: https://github.com/CosmWasm/token-factory/issues/11
+ DenomCreationGasConsume uint64 `protobuf:"varint,2,opt,name=denom_creation_gas_consume,json=denomCreationGasConsume,proto3" json:"denom_creation_gas_consume,omitempty" yaml:"denom_creation_gas_consume"`
+}
+
+func (m *Params) Reset() { *m = Params{} }
+func (m *Params) String() string { return proto.CompactTextString(m) }
+func (*Params) ProtoMessage() {}
+func (*Params) Descriptor() ([]byte, []int) {
+ return fileDescriptor_ce345928cf8ce182, []int{1}
+}
+func (m *Params) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *Params) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_Params.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *Params) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_Params.Merge(m, src)
+}
+func (m *Params) XXX_Size() int {
+ return m.Size()
+}
+func (m *Params) XXX_DiscardUnknown() {
+ xxx_messageInfo_Params.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_Params proto.InternalMessageInfo
+
+func (m *Params) GetDenomCreationFee() github_com_cosmos_cosmos_sdk_types.Coins {
+ if m != nil {
+ return m.DenomCreationFee
+ }
+ return nil
+}
+
+func (m *Params) GetDenomCreationGasConsume() uint64 {
+ if m != nil {
+ return m.DenomCreationGasConsume
+ }
+ return 0
+}
+
+func init() {
+ proto.RegisterType((*DenomAuthorityMetadata)(nil), "osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata")
+ proto.RegisterType((*Params)(nil), "osmosis.tokenfactory.v1beta1.Params")
+}
+
+func init() {
+ proto.RegisterFile("osmosis/tokenfactory/v1beta1/tokenfactory.proto", fileDescriptor_ce345928cf8ce182)
+}
+
+var fileDescriptor_ce345928cf8ce182 = []byte{
+ // 396 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x52, 0xb1, 0x8e, 0xd3, 0x40,
+ 0x10, 0xf5, 0x1e, 0xc7, 0x49, 0x18, 0x8a, 0x93, 0x85, 0x20, 0x89, 0x90, 0x1d, 0x5c, 0x20, 0x53,
+ 0x9c, 0x97, 0x40, 0x17, 0x2a, 0x1c, 0x14, 0xaa, 0x48, 0x28, 0x12, 0x0d, 0x8d, 0x35, 0xb6, 0x37,
+ 0xce, 0x2a, 0x59, 0x4f, 0xe4, 0x5d, 0x03, 0xe6, 0x0f, 0xe8, 0xa8, 0xa8, 0xa9, 0xf9, 0x92, 0x94,
+ 0x29, 0xa9, 0x0c, 0x4a, 0x1a, 0xea, 0x7c, 0x01, 0xb2, 0xd7, 0xa0, 0x18, 0xae, 0xb2, 0x67, 0xde,
+ 0xbc, 0x37, 0xef, 0x69, 0xd6, 0xa4, 0x28, 0x05, 0x4a, 0x2e, 0xa9, 0xc2, 0x15, 0xcb, 0x16, 0x10,
+ 0x2b, 0xcc, 0x4b, 0xfa, 0x6e, 0x14, 0x31, 0x05, 0xa3, 0x4e, 0xd3, 0xdf, 0xe4, 0xa8, 0xd0, 0x7a,
+ 0xd0, 0x12, 0xfc, 0x0e, 0xd6, 0x12, 0x06, 0x77, 0x53, 0x4c, 0xb1, 0x19, 0xa4, 0xf5, 0x9f, 0xe6,
+ 0x0c, 0xfa, 0x71, 0x43, 0x0a, 0x35, 0xa0, 0x8b, 0x16, 0xb2, 0x75, 0x45, 0x23, 0x90, 0xec, 0xef,
+ 0xda, 0x18, 0x79, 0xa6, 0x71, 0x77, 0x6a, 0xde, 0x7b, 0xc9, 0x32, 0x14, 0x2f, 0x0a, 0xb5, 0xc4,
+ 0x9c, 0xab, 0x72, 0xc6, 0x14, 0x24, 0xa0, 0xc0, 0x7a, 0x64, 0xde, 0x84, 0x44, 0xf0, 0xac, 0x47,
+ 0x86, 0xc4, 0xbb, 0x15, 0x5c, 0x1e, 0x2b, 0xe7, 0x4e, 0x09, 0x62, 0x3d, 0x76, 0x9b, 0xb6, 0x3b,
+ 0xd7, 0xf0, 0xf8, 0xfc, 0xd7, 0x57, 0x87, 0xb8, 0x9f, 0xce, 0xcc, 0x8b, 0xd7, 0x90, 0x83, 0x90,
+ 0xd6, 0x17, 0x62, 0x5a, 0x49, 0xad, 0x19, 0xc6, 0x39, 0x03, 0xc5, 0x31, 0x0b, 0x17, 0x8c, 0xf5,
+ 0xc8, 0xf0, 0x86, 0x77, 0xfb, 0x69, 0xdf, 0x6f, 0xed, 0xd5, 0x86, 0xfe, 0xc4, 0xf2, 0x27, 0xc8,
+ 0xb3, 0x60, 0xb6, 0xad, 0x1c, 0xe3, 0x58, 0x39, 0x7d, 0xbd, 0xe5, 0x7f, 0x09, 0xf7, 0xdb, 0x0f,
+ 0xc7, 0x4b, 0xb9, 0x5a, 0x16, 0x91, 0x1f, 0xa3, 0x68, 0x83, 0xb6, 0x9f, 0x2b, 0x99, 0xac, 0xa8,
+ 0x2a, 0x37, 0x4c, 0x36, 0x6a, 0x72, 0x7e, 0xd9, 0x08, 0x4c, 0x5a, 0xfe, 0x94, 0x31, 0x6b, 0x61,
+ 0x0e, 0xfe, 0x11, 0x4d, 0x41, 0x86, 0x31, 0x66, 0xb2, 0x10, 0xac, 0x77, 0x36, 0x24, 0xde, 0x79,
+ 0xf0, 0x78, 0x5b, 0x39, 0xe4, 0x58, 0x39, 0x0f, 0xaf, 0x35, 0x71, 0x32, 0xef, 0xce, 0xef, 0x77,
+ 0x16, 0xbc, 0x02, 0x39, 0xd1, 0x48, 0xf0, 0x66, 0xbb, 0xb7, 0xc9, 0x6e, 0x6f, 0x93, 0x9f, 0x7b,
+ 0x9b, 0x7c, 0x3e, 0xd8, 0xc6, 0xee, 0x60, 0x1b, 0xdf, 0x0f, 0xb6, 0xf1, 0xf6, 0xf9, 0x89, 0xfb,
+ 0x4d, 0x11, 0xad, 0x79, 0x7c, 0x05, 0xef, 0x99, 0x44, 0xc1, 0xa8, 0x54, 0x90, 0xa7, 0xf0, 0xb1,
+ 0x3e, 0xd2, 0x13, 0xfa, 0xa1, 0xfb, 0x5c, 0x9a, 0x58, 0xd1, 0x45, 0x73, 0xb1, 0x67, 0xbf, 0x03,
+ 0x00, 0x00, 0xff, 0xff, 0x3a, 0xaa, 0x5e, 0xd8, 0x53, 0x02, 0x00, 0x00,
+}
+
+func (this *DenomAuthorityMetadata) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*DenomAuthorityMetadata)
+ if !ok {
+ that2, ok := that.(DenomAuthorityMetadata)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if this.Admin != that1.Admin {
+ return false
+ }
+ return true
+}
+func (m *DenomAuthorityMetadata) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *DenomAuthorityMetadata) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *DenomAuthorityMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Admin) > 0 {
+ i -= len(m.Admin)
+ copy(dAtA[i:], m.Admin)
+ i = encodeVarintTokenfactory(dAtA, i, uint64(len(m.Admin)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *Params) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *Params) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *Params) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if m.DenomCreationGasConsume != 0 {
+ i = encodeVarintTokenfactory(dAtA, i, uint64(m.DenomCreationGasConsume))
+ i--
+ dAtA[i] = 0x10
+ }
+ if len(m.DenomCreationFee) > 0 {
+ for iNdEx := len(m.DenomCreationFee) - 1; iNdEx >= 0; iNdEx-- {
+ {
+ size, err := m.DenomCreationFee[iNdEx].MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTokenfactory(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0xa
+ }
+ }
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintTokenfactory(dAtA []byte, offset int, v uint64) int {
+ offset -= sovTokenfactory(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *DenomAuthorityMetadata) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Admin)
+ if l > 0 {
+ n += 1 + l + sovTokenfactory(uint64(l))
+ }
+ return n
+}
+
+func (m *Params) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ if len(m.DenomCreationFee) > 0 {
+ for _, e := range m.DenomCreationFee {
+ l = e.Size()
+ n += 1 + l + sovTokenfactory(uint64(l))
+ }
+ }
+ if m.DenomCreationGasConsume != 0 {
+ n += 1 + sovTokenfactory(uint64(m.DenomCreationGasConsume))
+ }
+ return n
+}
+
+func sovTokenfactory(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTokenfactory(x uint64) (n int) {
+ return sovTokenfactory(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *DenomAuthorityMetadata) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: DenomAuthorityMetadata: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: DenomAuthorityMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Admin", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTokenfactory
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTokenfactory
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Admin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTokenfactory(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTokenfactory
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *Params) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: Params: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: Params: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DenomCreationFee", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthTokenfactory
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthTokenfactory
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.DenomCreationFee = append(m.DenomCreationFee, types.Coin{})
+ if err := m.DenomCreationFee[len(m.DenomCreationFee)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 2:
+ if wireType != 0 {
+ return fmt.Errorf("proto: wrong wireType = %d for field DenomCreationGasConsume", wireType)
+ }
+ m.DenomCreationGasConsume = 0
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ m.DenomCreationGasConsume |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTokenfactory(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTokenfactory
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipTokenfactory(dAtA []byte) (n int, err error) {
+ l := len(dAtA)
+ iNdEx := 0
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if dAtA[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ case 1:
+ iNdEx += 8
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTokenfactory
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if length < 0 {
+ return 0, ErrInvalidLengthTokenfactory
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupTokenfactory
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthTokenfactory
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthTokenfactory = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowTokenfactory = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupTokenfactory = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/tokenfactory/types/tx.pb.go b/x/tokenfactory/types/tx.pb.go
new file mode 100644
index 000000000..b847beb7e
--- /dev/null
+++ b/x/tokenfactory/types/tx.pb.go
@@ -0,0 +1,2344 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: osmosis/tokenfactory/v1beta1/tx.proto
+
+package types
+
+import (
+ context "context"
+ fmt "fmt"
+ types "github.com/cosmos/cosmos-sdk/types"
+ types1 "github.com/cosmos/cosmos-sdk/x/bank/types"
+ _ "github.com/gogo/protobuf/gogoproto"
+ grpc1 "github.com/gogo/protobuf/grpc"
+ proto "github.com/gogo/protobuf/proto"
+ grpc "google.golang.org/grpc"
+ codes "google.golang.org/grpc/codes"
+ status "google.golang.org/grpc/status"
+ io "io"
+ math "math"
+ math_bits "math/bits"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
+
+// MsgCreateDenom defines the message structure for the CreateDenom gRPC service
+// method. It allows an account to create a new denom. It requires a sender
+// address and a sub denomination. The (sender_address, sub_denomination) tuple
+// must be unique and cannot be re-used.
+//
+// The resulting denom created is defined as
+// . The resulting denom's admin is
+// originally set to be the creator, but this can be changed later. The token
+// denom does not indicate the current admin.
+type MsgCreateDenom struct {
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+ // subdenom can be up to 44 "alphanumeric" characters long.
+ Subdenom string `protobuf:"bytes,2,opt,name=subdenom,proto3" json:"subdenom,omitempty" yaml:"subdenom"`
+}
+
+func (m *MsgCreateDenom) Reset() { *m = MsgCreateDenom{} }
+func (m *MsgCreateDenom) String() string { return proto.CompactTextString(m) }
+func (*MsgCreateDenom) ProtoMessage() {}
+func (*MsgCreateDenom) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{0}
+}
+func (m *MsgCreateDenom) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgCreateDenom) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgCreateDenom.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgCreateDenom) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgCreateDenom.Merge(m, src)
+}
+func (m *MsgCreateDenom) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgCreateDenom) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgCreateDenom.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgCreateDenom proto.InternalMessageInfo
+
+func (m *MsgCreateDenom) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgCreateDenom) GetSubdenom() string {
+ if m != nil {
+ return m.Subdenom
+ }
+ return ""
+}
+
+// MsgCreateDenomResponse is the return value of MsgCreateDenom
+// It returns the full string of the newly created denom
+type MsgCreateDenomResponse struct {
+ NewTokenDenom string `protobuf:"bytes,1,opt,name=new_token_denom,json=newTokenDenom,proto3" json:"new_token_denom,omitempty" yaml:"new_token_denom"`
+}
+
+func (m *MsgCreateDenomResponse) Reset() { *m = MsgCreateDenomResponse{} }
+func (m *MsgCreateDenomResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgCreateDenomResponse) ProtoMessage() {}
+func (*MsgCreateDenomResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{1}
+}
+func (m *MsgCreateDenomResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgCreateDenomResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgCreateDenomResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgCreateDenomResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgCreateDenomResponse.Merge(m, src)
+}
+func (m *MsgCreateDenomResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgCreateDenomResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgCreateDenomResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgCreateDenomResponse proto.InternalMessageInfo
+
+func (m *MsgCreateDenomResponse) GetNewTokenDenom() string {
+ if m != nil {
+ return m.NewTokenDenom
+ }
+ return ""
+}
+
+// MsgMint is the sdk.Msg type for allowing an admin account to mint
+// more of a token. For now, we only support minting to the sender account
+type MsgMint struct {
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+ Amount types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount" yaml:"amount"`
+ MintToAddress string `protobuf:"bytes,3,opt,name=mintToAddress,proto3" json:"mintToAddress,omitempty" yaml:"mint_to_address"`
+}
+
+func (m *MsgMint) Reset() { *m = MsgMint{} }
+func (m *MsgMint) String() string { return proto.CompactTextString(m) }
+func (*MsgMint) ProtoMessage() {}
+func (*MsgMint) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{2}
+}
+func (m *MsgMint) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgMint) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgMint.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgMint) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgMint.Merge(m, src)
+}
+func (m *MsgMint) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgMint) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgMint.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgMint proto.InternalMessageInfo
+
+func (m *MsgMint) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgMint) GetAmount() types.Coin {
+ if m != nil {
+ return m.Amount
+ }
+ return types.Coin{}
+}
+
+func (m *MsgMint) GetMintToAddress() string {
+ if m != nil {
+ return m.MintToAddress
+ }
+ return ""
+}
+
+type MsgMintResponse struct {
+}
+
+func (m *MsgMintResponse) Reset() { *m = MsgMintResponse{} }
+func (m *MsgMintResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgMintResponse) ProtoMessage() {}
+func (*MsgMintResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{3}
+}
+func (m *MsgMintResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgMintResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgMintResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgMintResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgMintResponse.Merge(m, src)
+}
+func (m *MsgMintResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgMintResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgMintResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgMintResponse proto.InternalMessageInfo
+
+// MsgBurn is the sdk.Msg type for allowing an admin account to burn
+// a token. For now, we only support burning from the sender account.
+type MsgBurn struct {
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+ Amount types.Coin `protobuf:"bytes,2,opt,name=amount,proto3" json:"amount" yaml:"amount"`
+ BurnFromAddress string `protobuf:"bytes,3,opt,name=burnFromAddress,proto3" json:"burnFromAddress,omitempty" yaml:"burn_from_address"`
+}
+
+func (m *MsgBurn) Reset() { *m = MsgBurn{} }
+func (m *MsgBurn) String() string { return proto.CompactTextString(m) }
+func (*MsgBurn) ProtoMessage() {}
+func (*MsgBurn) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{4}
+}
+func (m *MsgBurn) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgBurn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgBurn.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgBurn) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgBurn.Merge(m, src)
+}
+func (m *MsgBurn) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgBurn) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgBurn.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgBurn proto.InternalMessageInfo
+
+func (m *MsgBurn) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgBurn) GetAmount() types.Coin {
+ if m != nil {
+ return m.Amount
+ }
+ return types.Coin{}
+}
+
+func (m *MsgBurn) GetBurnFromAddress() string {
+ if m != nil {
+ return m.BurnFromAddress
+ }
+ return ""
+}
+
+type MsgBurnResponse struct {
+}
+
+func (m *MsgBurnResponse) Reset() { *m = MsgBurnResponse{} }
+func (m *MsgBurnResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgBurnResponse) ProtoMessage() {}
+func (*MsgBurnResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{5}
+}
+func (m *MsgBurnResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgBurnResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgBurnResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgBurnResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgBurnResponse.Merge(m, src)
+}
+func (m *MsgBurnResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgBurnResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgBurnResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgBurnResponse proto.InternalMessageInfo
+
+// MsgChangeAdmin is the sdk.Msg type for allowing an admin account to reassign
+// adminship of a denom to a new account
+type MsgChangeAdmin struct {
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+ Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty" yaml:"denom"`
+ NewAdmin string `protobuf:"bytes,3,opt,name=new_admin,json=newAdmin,proto3" json:"new_admin,omitempty" yaml:"new_admin"`
+}
+
+func (m *MsgChangeAdmin) Reset() { *m = MsgChangeAdmin{} }
+func (m *MsgChangeAdmin) String() string { return proto.CompactTextString(m) }
+func (*MsgChangeAdmin) ProtoMessage() {}
+func (*MsgChangeAdmin) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{6}
+}
+func (m *MsgChangeAdmin) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgChangeAdmin) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgChangeAdmin.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgChangeAdmin) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgChangeAdmin.Merge(m, src)
+}
+func (m *MsgChangeAdmin) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgChangeAdmin) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgChangeAdmin.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgChangeAdmin proto.InternalMessageInfo
+
+func (m *MsgChangeAdmin) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgChangeAdmin) GetDenom() string {
+ if m != nil {
+ return m.Denom
+ }
+ return ""
+}
+
+func (m *MsgChangeAdmin) GetNewAdmin() string {
+ if m != nil {
+ return m.NewAdmin
+ }
+ return ""
+}
+
+// MsgChangeAdminResponse defines the response structure for an executed
+// MsgChangeAdmin message.
+type MsgChangeAdminResponse struct {
+}
+
+func (m *MsgChangeAdminResponse) Reset() { *m = MsgChangeAdminResponse{} }
+func (m *MsgChangeAdminResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgChangeAdminResponse) ProtoMessage() {}
+func (*MsgChangeAdminResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{7}
+}
+func (m *MsgChangeAdminResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgChangeAdminResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgChangeAdminResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgChangeAdminResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgChangeAdminResponse.Merge(m, src)
+}
+func (m *MsgChangeAdminResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgChangeAdminResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgChangeAdminResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgChangeAdminResponse proto.InternalMessageInfo
+
+// MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set
+// the denom's bank metadata
+type MsgSetDenomMetadata struct {
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+ Metadata types1.Metadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"`
+}
+
+func (m *MsgSetDenomMetadata) Reset() { *m = MsgSetDenomMetadata{} }
+func (m *MsgSetDenomMetadata) String() string { return proto.CompactTextString(m) }
+func (*MsgSetDenomMetadata) ProtoMessage() {}
+func (*MsgSetDenomMetadata) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{8}
+}
+func (m *MsgSetDenomMetadata) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgSetDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgSetDenomMetadata.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgSetDenomMetadata) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgSetDenomMetadata.Merge(m, src)
+}
+func (m *MsgSetDenomMetadata) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgSetDenomMetadata) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgSetDenomMetadata.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgSetDenomMetadata proto.InternalMessageInfo
+
+func (m *MsgSetDenomMetadata) GetSender() string {
+ if m != nil {
+ return m.Sender
+ }
+ return ""
+}
+
+func (m *MsgSetDenomMetadata) GetMetadata() types1.Metadata {
+ if m != nil {
+ return m.Metadata
+ }
+ return types1.Metadata{}
+}
+
+// MsgSetDenomMetadataResponse defines the response structure for an executed
+// MsgSetDenomMetadata message.
+type MsgSetDenomMetadataResponse struct {
+}
+
+func (m *MsgSetDenomMetadataResponse) Reset() { *m = MsgSetDenomMetadataResponse{} }
+func (m *MsgSetDenomMetadataResponse) String() string { return proto.CompactTextString(m) }
+func (*MsgSetDenomMetadataResponse) ProtoMessage() {}
+func (*MsgSetDenomMetadataResponse) Descriptor() ([]byte, []int) {
+ return fileDescriptor_283b6c9a90a846b4, []int{9}
+}
+func (m *MsgSetDenomMetadataResponse) XXX_Unmarshal(b []byte) error {
+ return m.Unmarshal(b)
+}
+func (m *MsgSetDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+ if deterministic {
+ return xxx_messageInfo_MsgSetDenomMetadataResponse.Marshal(b, m, deterministic)
+ } else {
+ b = b[:cap(b)]
+ n, err := m.MarshalToSizedBuffer(b)
+ if err != nil {
+ return nil, err
+ }
+ return b[:n], nil
+ }
+}
+func (m *MsgSetDenomMetadataResponse) XXX_Merge(src proto.Message) {
+ xxx_messageInfo_MsgSetDenomMetadataResponse.Merge(m, src)
+}
+func (m *MsgSetDenomMetadataResponse) XXX_Size() int {
+ return m.Size()
+}
+func (m *MsgSetDenomMetadataResponse) XXX_DiscardUnknown() {
+ xxx_messageInfo_MsgSetDenomMetadataResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_MsgSetDenomMetadataResponse proto.InternalMessageInfo
+
+func init() {
+ proto.RegisterType((*MsgCreateDenom)(nil), "osmosis.tokenfactory.v1beta1.MsgCreateDenom")
+ proto.RegisterType((*MsgCreateDenomResponse)(nil), "osmosis.tokenfactory.v1beta1.MsgCreateDenomResponse")
+ proto.RegisterType((*MsgMint)(nil), "osmosis.tokenfactory.v1beta1.MsgMint")
+ proto.RegisterType((*MsgMintResponse)(nil), "osmosis.tokenfactory.v1beta1.MsgMintResponse")
+ proto.RegisterType((*MsgBurn)(nil), "osmosis.tokenfactory.v1beta1.MsgBurn")
+ proto.RegisterType((*MsgBurnResponse)(nil), "osmosis.tokenfactory.v1beta1.MsgBurnResponse")
+ proto.RegisterType((*MsgChangeAdmin)(nil), "osmosis.tokenfactory.v1beta1.MsgChangeAdmin")
+ proto.RegisterType((*MsgChangeAdminResponse)(nil), "osmosis.tokenfactory.v1beta1.MsgChangeAdminResponse")
+ proto.RegisterType((*MsgSetDenomMetadata)(nil), "osmosis.tokenfactory.v1beta1.MsgSetDenomMetadata")
+ proto.RegisterType((*MsgSetDenomMetadataResponse)(nil), "osmosis.tokenfactory.v1beta1.MsgSetDenomMetadataResponse")
+}
+
+func init() {
+ proto.RegisterFile("osmosis/tokenfactory/v1beta1/tx.proto", fileDescriptor_283b6c9a90a846b4)
+}
+
+var fileDescriptor_283b6c9a90a846b4 = []byte{
+ // 664 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x55, 0x4d, 0x4f, 0x13, 0x41,
+ 0x18, 0xee, 0x0a, 0x22, 0x0c, 0x62, 0x61, 0x41, 0xac, 0x15, 0x76, 0xcd, 0x24, 0x18, 0x4d, 0x64,
+ 0xd7, 0xa2, 0x17, 0xf5, 0x22, 0xc5, 0x10, 0x2f, 0xbd, 0xac, 0x78, 0x31, 0x24, 0xcd, 0x6c, 0x3b,
+ 0x2c, 0x1b, 0xd8, 0x99, 0xba, 0x33, 0xb5, 0xe0, 0xc9, 0x9f, 0xe0, 0xc1, 0xf8, 0x23, 0xfc, 0x15,
+ 0x9e, 0x0c, 0x47, 0x8e, 0x9e, 0x36, 0x06, 0xfe, 0x41, 0x7f, 0x81, 0x99, 0x8f, 0xfd, 0x68, 0x31,
+ 0xb6, 0x3d, 0x79, 0x6b, 0xf7, 0x7d, 0x9e, 0x67, 0xdf, 0xe7, 0x9d, 0xe7, 0xdd, 0x01, 0x1b, 0x94,
+ 0x45, 0x94, 0x85, 0xcc, 0xe5, 0xf4, 0x08, 0x93, 0x03, 0xd4, 0xe2, 0x34, 0x3e, 0x75, 0x3f, 0xd6,
+ 0x7c, 0xcc, 0x51, 0xcd, 0xe5, 0x27, 0x4e, 0x27, 0xa6, 0x9c, 0x9a, 0x6b, 0x1a, 0xe6, 0x14, 0x61,
+ 0x8e, 0x86, 0x55, 0x57, 0x02, 0x1a, 0x50, 0x09, 0x74, 0xc5, 0x2f, 0xc5, 0xa9, 0x5a, 0x2d, 0x49,
+ 0x72, 0x7d, 0xc4, 0x70, 0xa6, 0xd8, 0xa2, 0x21, 0xb9, 0x52, 0x27, 0x47, 0x59, 0x5d, 0xfc, 0x51,
+ 0x75, 0x78, 0x0c, 0x6e, 0x35, 0x58, 0xb0, 0x13, 0x63, 0xc4, 0xf1, 0x6b, 0x4c, 0x68, 0x64, 0x3e,
+ 0x02, 0x33, 0x0c, 0x93, 0x36, 0x8e, 0x2b, 0xc6, 0x7d, 0xe3, 0xe1, 0x5c, 0x7d, 0xa9, 0x9f, 0xd8,
+ 0x0b, 0xa7, 0x28, 0x3a, 0x7e, 0x01, 0xd5, 0x73, 0xe8, 0x69, 0x80, 0xe9, 0x82, 0x59, 0xd6, 0xf5,
+ 0xdb, 0x82, 0x56, 0xb9, 0x26, 0xc1, 0xcb, 0xfd, 0xc4, 0x2e, 0x6b, 0xb0, 0xae, 0x40, 0x2f, 0x03,
+ 0xc1, 0x7d, 0xb0, 0x3a, 0xf8, 0x36, 0x0f, 0xb3, 0x0e, 0x25, 0x0c, 0x9b, 0x75, 0x50, 0x26, 0xb8,
+ 0xd7, 0x94, 0xce, 0x9b, 0x4a, 0x51, 0xbd, 0xbe, 0xda, 0x4f, 0xec, 0x55, 0xa5, 0x38, 0x04, 0x80,
+ 0xde, 0x02, 0xc1, 0xbd, 0x3d, 0xf1, 0x40, 0x6a, 0xc1, 0x1f, 0x06, 0xb8, 0xd1, 0x60, 0x41, 0x23,
+ 0x24, 0x7c, 0x12, 0x17, 0x6f, 0xc0, 0x0c, 0x8a, 0x68, 0x97, 0x70, 0xe9, 0x61, 0x7e, 0xeb, 0xae,
+ 0xa3, 0x66, 0xe6, 0x88, 0x99, 0xa6, 0xe3, 0x77, 0x76, 0x68, 0x48, 0xea, 0xb7, 0xcf, 0x12, 0xbb,
+ 0x94, 0x2b, 0x29, 0x1a, 0xf4, 0x34, 0xdf, 0x7c, 0x05, 0x16, 0xa2, 0x90, 0xf0, 0x3d, 0xba, 0xdd,
+ 0x6e, 0xc7, 0x98, 0xb1, 0xca, 0xd4, 0xb0, 0x05, 0x51, 0x6e, 0x72, 0xda, 0x44, 0x0a, 0x00, 0xbd,
+ 0x41, 0x02, 0x5c, 0x02, 0x65, 0xed, 0x20, 0x9d, 0x0c, 0xfc, 0xa9, 0x5c, 0xd5, 0xbb, 0x31, 0xf9,
+ 0x3f, 0xae, 0x76, 0x41, 0xd9, 0xef, 0xc6, 0x64, 0x37, 0xa6, 0xd1, 0xa0, 0xaf, 0xb5, 0x7e, 0x62,
+ 0x57, 0x14, 0x47, 0x00, 0x9a, 0x07, 0x31, 0x8d, 0x72, 0x67, 0xc3, 0x24, 0xed, 0x4d, 0xf8, 0xc8,
+ 0xbc, 0x7d, 0x33, 0x54, 0xfc, 0x0e, 0x11, 0x09, 0xf0, 0x76, 0x3b, 0x0a, 0x27, 0xb2, 0xf8, 0x00,
+ 0x5c, 0x2f, 0x66, 0x6f, 0xb1, 0x9f, 0xd8, 0x37, 0x15, 0x52, 0xe7, 0x43, 0x95, 0xcd, 0x1a, 0x98,
+ 0x13, 0xd1, 0x41, 0x42, 0x5f, 0xb7, 0xbe, 0xd2, 0x4f, 0xec, 0xc5, 0x3c, 0x55, 0xb2, 0x04, 0xbd,
+ 0x59, 0x82, 0x7b, 0xb2, 0x0b, 0x58, 0x51, 0x41, 0xcd, 0xfb, 0xca, 0x5a, 0xfe, 0x6a, 0x80, 0xe5,
+ 0x06, 0x0b, 0xde, 0x62, 0x2e, 0x43, 0xd7, 0xc0, 0x1c, 0xb5, 0x11, 0x47, 0x93, 0xf4, 0xed, 0x81,
+ 0xd9, 0x48, 0xd3, 0xf4, 0xe1, 0xac, 0xe7, 0x87, 0x43, 0x8e, 0xb2, 0xc3, 0x49, 0xb5, 0xeb, 0x77,
+ 0xf4, 0x01, 0xe9, 0xcd, 0x4a, 0xc9, 0xd0, 0xcb, 0x74, 0xe0, 0x3a, 0xb8, 0xf7, 0x97, 0xae, 0xd2,
+ 0xae, 0xb7, 0xbe, 0x4f, 0x83, 0xa9, 0x06, 0x0b, 0xcc, 0x0f, 0x60, 0xbe, 0xb8, 0xeb, 0x8f, 0x9d,
+ 0x7f, 0x7d, 0x72, 0x9c, 0xc1, 0x5d, 0xad, 0x3e, 0x9b, 0x04, 0x9d, 0x6d, 0xf6, 0x3e, 0x98, 0x96,
+ 0x1b, 0xb9, 0x31, 0x92, 0x2d, 0x60, 0xd5, 0xcd, 0xb1, 0x60, 0x45, 0x75, 0xb9, 0x19, 0xa3, 0xd5,
+ 0x05, 0x6c, 0x0c, 0xf5, 0x62, 0x3e, 0xe5, 0xb8, 0x0a, 0xd9, 0x1c, 0x63, 0x5c, 0x39, 0x7a, 0x9c,
+ 0x71, 0x5d, 0xcd, 0x97, 0xf9, 0xd9, 0x00, 0x8b, 0x57, 0xc2, 0x55, 0x1b, 0x29, 0x35, 0x4c, 0xa9,
+ 0x3e, 0x9f, 0x98, 0x92, 0xb6, 0x50, 0x7f, 0x77, 0x76, 0x61, 0x19, 0xe7, 0x17, 0x96, 0xf1, 0xfb,
+ 0xc2, 0x32, 0xbe, 0x5c, 0x5a, 0xa5, 0xf3, 0x4b, 0xab, 0xf4, 0xeb, 0xd2, 0x2a, 0xbd, 0x7f, 0x19,
+ 0x84, 0xfc, 0xb0, 0xeb, 0x3b, 0x2d, 0x1a, 0xb9, 0x9d, 0xae, 0x7f, 0x1c, 0xb6, 0x36, 0x51, 0x0f,
+ 0x33, 0x1a, 0x61, 0x97, 0x71, 0x14, 0x07, 0xe8, 0x93, 0xb8, 0x84, 0x9e, 0xb8, 0x27, 0x83, 0x37,
+ 0x1d, 0x3f, 0xed, 0x60, 0xe6, 0xcf, 0xc8, 0x1b, 0xe7, 0xe9, 0x9f, 0x00, 0x00, 0x00, 0xff, 0xff,
+ 0x6b, 0xb5, 0xca, 0x58, 0x0e, 0x07, 0x00, 0x00,
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// MsgClient is the client API for Msg service.
+//
+// For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream.
+type MsgClient interface {
+ CreateDenom(ctx context.Context, in *MsgCreateDenom, opts ...grpc.CallOption) (*MsgCreateDenomResponse, error)
+ Mint(ctx context.Context, in *MsgMint, opts ...grpc.CallOption) (*MsgMintResponse, error)
+ Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOption) (*MsgBurnResponse, error)
+ ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, error)
+ SetDenomMetadata(ctx context.Context, in *MsgSetDenomMetadata, opts ...grpc.CallOption) (*MsgSetDenomMetadataResponse, error)
+}
+
+type msgClient struct {
+ cc grpc1.ClientConn
+}
+
+func NewMsgClient(cc grpc1.ClientConn) MsgClient {
+ return &msgClient{cc}
+}
+
+func (c *msgClient) CreateDenom(ctx context.Context, in *MsgCreateDenom, opts ...grpc.CallOption) (*MsgCreateDenomResponse, error) {
+ out := new(MsgCreateDenomResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Msg/CreateDenom", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) Mint(ctx context.Context, in *MsgMint, opts ...grpc.CallOption) (*MsgMintResponse, error) {
+ out := new(MsgMintResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Msg/Mint", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOption) (*MsgBurnResponse, error) {
+ out := new(MsgBurnResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Msg/Burn", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, error) {
+ out := new(MsgChangeAdminResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Msg/ChangeAdmin", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+func (c *msgClient) SetDenomMetadata(ctx context.Context, in *MsgSetDenomMetadata, opts ...grpc.CallOption) (*MsgSetDenomMetadataResponse, error) {
+ out := new(MsgSetDenomMetadataResponse)
+ err := c.cc.Invoke(ctx, "/osmosis.tokenfactory.v1beta1.Msg/SetDenomMetadata", in, out, opts...)
+ if err != nil {
+ return nil, err
+ }
+ return out, nil
+}
+
+// MsgServer is the server API for Msg service.
+type MsgServer interface {
+ CreateDenom(context.Context, *MsgCreateDenom) (*MsgCreateDenomResponse, error)
+ Mint(context.Context, *MsgMint) (*MsgMintResponse, error)
+ Burn(context.Context, *MsgBurn) (*MsgBurnResponse, error)
+ ChangeAdmin(context.Context, *MsgChangeAdmin) (*MsgChangeAdminResponse, error)
+ SetDenomMetadata(context.Context, *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error)
+}
+
+// UnimplementedMsgServer can be embedded to have forward compatible implementations.
+type UnimplementedMsgServer struct {
+}
+
+func (*UnimplementedMsgServer) CreateDenom(ctx context.Context, req *MsgCreateDenom) (*MsgCreateDenomResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method CreateDenom not implemented")
+}
+func (*UnimplementedMsgServer) Mint(ctx context.Context, req *MsgMint) (*MsgMintResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Mint not implemented")
+}
+func (*UnimplementedMsgServer) Burn(ctx context.Context, req *MsgBurn) (*MsgBurnResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method Burn not implemented")
+}
+func (*UnimplementedMsgServer) ChangeAdmin(ctx context.Context, req *MsgChangeAdmin) (*MsgChangeAdminResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method ChangeAdmin not implemented")
+}
+func (*UnimplementedMsgServer) SetDenomMetadata(ctx context.Context, req *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error) {
+ return nil, status.Errorf(codes.Unimplemented, "method SetDenomMetadata not implemented")
+}
+
+func RegisterMsgServer(s grpc1.Server, srv MsgServer) {
+ s.RegisterService(&_Msg_serviceDesc, srv)
+}
+
+func _Msg_CreateDenom_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgCreateDenom)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).CreateDenom(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Msg/CreateDenom",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).CreateDenom(ctx, req.(*MsgCreateDenom))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_Mint_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgMint)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).Mint(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Msg/Mint",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).Mint(ctx, req.(*MsgMint))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_Burn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgBurn)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).Burn(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Msg/Burn",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).Burn(ctx, req.(*MsgBurn))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_ChangeAdmin_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgChangeAdmin)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).ChangeAdmin(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Msg/ChangeAdmin",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).ChangeAdmin(ctx, req.(*MsgChangeAdmin))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+func _Msg_SetDenomMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+ in := new(MsgSetDenomMetadata)
+ if err := dec(in); err != nil {
+ return nil, err
+ }
+ if interceptor == nil {
+ return srv.(MsgServer).SetDenomMetadata(ctx, in)
+ }
+ info := &grpc.UnaryServerInfo{
+ Server: srv,
+ FullMethod: "/osmosis.tokenfactory.v1beta1.Msg/SetDenomMetadata",
+ }
+ handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+ return srv.(MsgServer).SetDenomMetadata(ctx, req.(*MsgSetDenomMetadata))
+ }
+ return interceptor(ctx, in, info, handler)
+}
+
+var _Msg_serviceDesc = grpc.ServiceDesc{
+ ServiceName: "osmosis.tokenfactory.v1beta1.Msg",
+ HandlerType: (*MsgServer)(nil),
+ Methods: []grpc.MethodDesc{
+ {
+ MethodName: "CreateDenom",
+ Handler: _Msg_CreateDenom_Handler,
+ },
+ {
+ MethodName: "Mint",
+ Handler: _Msg_Mint_Handler,
+ },
+ {
+ MethodName: "Burn",
+ Handler: _Msg_Burn_Handler,
+ },
+ {
+ MethodName: "ChangeAdmin",
+ Handler: _Msg_ChangeAdmin_Handler,
+ },
+ {
+ MethodName: "SetDenomMetadata",
+ Handler: _Msg_SetDenomMetadata_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "osmosis/tokenfactory/v1beta1/tx.proto",
+}
+
+func (m *MsgCreateDenom) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgCreateDenom) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgCreateDenom) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.Subdenom) > 0 {
+ i -= len(m.Subdenom)
+ copy(dAtA[i:], m.Subdenom)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Subdenom)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgCreateDenomResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgCreateDenomResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgCreateDenomResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.NewTokenDenom) > 0 {
+ i -= len(m.NewTokenDenom)
+ copy(dAtA[i:], m.NewTokenDenom)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.NewTokenDenom)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgMint) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgMint) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgMint) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.MintToAddress) > 0 {
+ i -= len(m.MintToAddress)
+ copy(dAtA[i:], m.MintToAddress)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.MintToAddress)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ {
+ size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTx(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgMintResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgMintResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgMintResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgBurn) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgBurn) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgBurn) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.BurnFromAddress) > 0 {
+ i -= len(m.BurnFromAddress)
+ copy(dAtA[i:], m.BurnFromAddress)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.BurnFromAddress)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ {
+ size, err := m.Amount.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTx(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgBurnResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgBurnResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgBurnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgChangeAdmin) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgChangeAdmin) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgChangeAdmin) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ if len(m.NewAdmin) > 0 {
+ i -= len(m.NewAdmin)
+ copy(dAtA[i:], m.NewAdmin)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.NewAdmin)))
+ i--
+ dAtA[i] = 0x1a
+ }
+ if len(m.Denom) > 0 {
+ i -= len(m.Denom)
+ copy(dAtA[i:], m.Denom)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Denom)))
+ i--
+ dAtA[i] = 0x12
+ }
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgChangeAdminResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgChangeAdminResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgChangeAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgSetDenomMetadata) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgSetDenomMetadata) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgSetDenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ {
+ size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i])
+ if err != nil {
+ return 0, err
+ }
+ i -= size
+ i = encodeVarintTx(dAtA, i, uint64(size))
+ }
+ i--
+ dAtA[i] = 0x12
+ if len(m.Sender) > 0 {
+ i -= len(m.Sender)
+ copy(dAtA[i:], m.Sender)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Sender)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func (m *MsgSetDenomMetadataResponse) Marshal() (dAtA []byte, err error) {
+ size := m.Size()
+ dAtA = make([]byte, size)
+ n, err := m.MarshalToSizedBuffer(dAtA[:size])
+ if err != nil {
+ return nil, err
+ }
+ return dAtA[:n], nil
+}
+
+func (m *MsgSetDenomMetadataResponse) MarshalTo(dAtA []byte) (int, error) {
+ size := m.Size()
+ return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *MsgSetDenomMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+ i := len(dAtA)
+ _ = i
+ var l int
+ _ = l
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintTx(dAtA []byte, offset int, v uint64) int {
+ offset -= sovTx(v)
+ base := offset
+ for v >= 1<<7 {
+ dAtA[offset] = uint8(v&0x7f | 0x80)
+ v >>= 7
+ offset++
+ }
+ dAtA[offset] = uint8(v)
+ return base
+}
+func (m *MsgCreateDenom) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = len(m.Subdenom)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ return n
+}
+
+func (m *MsgCreateDenomResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.NewTokenDenom)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ return n
+}
+
+func (m *MsgMint) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = m.Amount.Size()
+ n += 1 + l + sovTx(uint64(l))
+ l = len(m.MintToAddress)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ return n
+}
+
+func (m *MsgMintResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func (m *MsgBurn) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = m.Amount.Size()
+ n += 1 + l + sovTx(uint64(l))
+ l = len(m.BurnFromAddress)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ return n
+}
+
+func (m *MsgBurnResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func (m *MsgChangeAdmin) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = len(m.Denom)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = len(m.NewAdmin)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ return n
+}
+
+func (m *MsgChangeAdminResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func (m *MsgSetDenomMetadata) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ l = len(m.Sender)
+ if l > 0 {
+ n += 1 + l + sovTx(uint64(l))
+ }
+ l = m.Metadata.Size()
+ n += 1 + l + sovTx(uint64(l))
+ return n
+}
+
+func (m *MsgSetDenomMetadataResponse) Size() (n int) {
+ if m == nil {
+ return 0
+ }
+ var l int
+ _ = l
+ return n
+}
+
+func sovTx(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozTx(x uint64) (n int) {
+ return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgCreateDenom: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgCreateDenom: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Subdenom", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Subdenom = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgCreateDenomResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgCreateDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewTokenDenom", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NewTokenDenom = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgMint) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgMint: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgMint: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field MintToAddress", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.MintToAddress = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgMintResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgMintResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgMintResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgBurn) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgBurn: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgBurn: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Amount", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Amount.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field BurnFromAddress", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.BurnFromAddress = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgBurnResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgBurnResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgBurnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgChangeAdmin) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgChangeAdmin: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgChangeAdmin: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Denom = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 3:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field NewAdmin", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.NewAdmin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgChangeAdminResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgChangeAdminResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgChangeAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgSetDenomMetadata) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgSetDenomMetadata: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgSetDenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ case 1:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Sender", wireType)
+ }
+ var stringLen uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ stringLen |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ intStringLen := int(stringLen)
+ if intStringLen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Sender = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ case 2:
+ if wireType != 2 {
+ return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
+ }
+ var msglen int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ msglen |= int(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if msglen < 0 {
+ return ErrInvalidLengthTx
+ }
+ postIndex := iNdEx + msglen
+ if postIndex < 0 {
+ return ErrInvalidLengthTx
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+ return err
+ }
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func (m *MsgSetDenomMetadataResponse) Unmarshal(dAtA []byte) error {
+ l := len(dAtA)
+ iNdEx := 0
+ for iNdEx < l {
+ preIndex := iNdEx
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= uint64(b&0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ fieldNum := int32(wire >> 3)
+ wireType := int(wire & 0x7)
+ if wireType == 4 {
+ return fmt.Errorf("proto: MsgSetDenomMetadataResponse: wiretype end group for non-group")
+ }
+ if fieldNum <= 0 {
+ return fmt.Errorf("proto: MsgSetDenomMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+ }
+ switch fieldNum {
+ default:
+ iNdEx = preIndex
+ skippy, err := skipTx(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthTx
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipTx(dAtA []byte) (n int, err error) {
+ l := len(dAtA)
+ iNdEx := 0
+ depth := 0
+ for iNdEx < l {
+ var wire uint64
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ wire |= (uint64(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ wireType := int(wire & 0x7)
+ switch wireType {
+ case 0:
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ iNdEx++
+ if dAtA[iNdEx-1] < 0x80 {
+ break
+ }
+ }
+ case 1:
+ iNdEx += 8
+ case 2:
+ var length int
+ for shift := uint(0); ; shift += 7 {
+ if shift >= 64 {
+ return 0, ErrIntOverflowTx
+ }
+ if iNdEx >= l {
+ return 0, io.ErrUnexpectedEOF
+ }
+ b := dAtA[iNdEx]
+ iNdEx++
+ length |= (int(b) & 0x7F) << shift
+ if b < 0x80 {
+ break
+ }
+ }
+ if length < 0 {
+ return 0, ErrInvalidLengthTx
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupTx
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthTx
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthTx = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowTx = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupTx = fmt.Errorf("proto: unexpected end of group")
+)