diff --git a/app/keepers.go b/app/keepers.go
index cca81eed4c5..85664a4350a 100644
--- a/app/keepers.go
+++ b/app/keepers.go
@@ -65,6 +65,8 @@ import (
"github.com/osmosis-labs/osmosis/v7/x/superfluid"
superfluidkeeper "github.com/osmosis-labs/osmosis/v7/x/superfluid/keeper"
superfluidtypes "github.com/osmosis-labs/osmosis/v7/x/superfluid/types"
+ tokenfactorykeeper "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/keeper"
+ tokenfactorytypes "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
"github.com/osmosis-labs/osmosis/v7/x/txfees"
txfeeskeeper "github.com/osmosis-labs/osmosis/v7/x/txfees/keeper"
txfeestypes "github.com/osmosis-labs/osmosis/v7/x/txfees/types"
@@ -106,6 +108,7 @@ type appKeepers struct {
SuperfluidKeeper *superfluidkeeper.Keeper
GovKeeper *govkeeper.Keeper
WasmKeeper *wasm.Keeper
+ TokenFactoryKeeper *tokenfactorykeeper.Keeper
}
func (app *OsmosisApp) InitSpecialKeepers(
@@ -345,6 +348,14 @@ func (app *OsmosisApp) InitNormalKeepers(
)
app.TxFeesKeeper = &txFeesKeeper
+ tokenFactoryKeeper := tokenfactorykeeper.NewKeeper(
+ appCodec,
+ keys[tokenfactorytypes.StoreKey],
+ app.AccountKeeper,
+ app.BankKeeper,
+ )
+ app.TokenFactoryKeeper = &tokenFactoryKeeper
+
// The last arguments can contain custom message handlers, and custom query handlers,
// if we want to allow any custom callbacks
supportedFeatures := "iterator,staking,stargate,osmosis"
@@ -481,6 +492,7 @@ func (app *OsmosisApp) initParamsKeeper(appCodec codec.BinaryCodec, legacyAmino
paramsKeeper.Subspace(superfluidtypes.ModuleName)
paramsKeeper.Subspace(gammtypes.ModuleName)
paramsKeeper.Subspace(wasm.ModuleName)
+ paramsKeeper.Subspace(tokenfactorytypes.ModuleName)
return paramsKeeper
}
@@ -511,5 +523,6 @@ func KVStoreKeys() []string {
superfluidtypes.StoreKey,
bech32ibctypes.StoreKey,
wasm.StoreKey,
+ tokenfactorytypes.StoreKey,
}
}
diff --git a/app/modules.go b/app/modules.go
index 29a716c7bc6..cc607d1aad4 100644
--- a/app/modules.go
+++ b/app/modules.go
@@ -68,6 +68,9 @@ import (
superfluidtypes "github.com/osmosis-labs/osmosis/v7/x/superfluid/types"
"github.com/osmosis-labs/osmosis/v7/x/txfees"
txfeestypes "github.com/osmosis-labs/osmosis/v7/x/txfees/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory"
+ tokenfactorytypes "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
)
// appModuleBasics returns ModuleBasics for the module BasicManager.
@@ -112,6 +115,7 @@ var appModuleBasics = []module.AppModuleBasic{
superfluid.AppModuleBasic{},
bech32ibc.AppModuleBasic{},
wasm.AppModuleBasic{},
+ tokenfactory.AppModuleBasic{},
}
// moduleAccountPermissions defines module account permissions
@@ -132,6 +136,7 @@ var moduleAccountPermissions = map[string][]string{
superfluidtypes.ModuleName: {authtypes.Minter, authtypes.Burner},
txfeestypes.ModuleName: nil,
wasm.ModuleName: {authtypes.Burner},
+ tokenfactorytypes.ModuleName: {authtypes.Minter, authtypes.Burner},
}
// appModules return modules to initialize module manager.
@@ -184,6 +189,7 @@ func appModules(
app.EpochsKeeper,
),
bech32ibc.NewAppModule(appCodec, *app.Bech32IBCKeeper),
+ tokenfactory.NewAppModule(appCodec, *app.TokenFactoryKeeper),
}
}
@@ -217,6 +223,7 @@ func orderBeginBlockers() []string {
lockuptypes.ModuleName,
claimtypes.ModuleName,
poolincentivestypes.ModuleName,
+ tokenfactorytypes.ModuleName,
// superfluid must come after distribution and epochs
superfluidtypes.ModuleName,
bech32ibctypes.ModuleName,
@@ -254,6 +261,7 @@ var orderEndBlockers = []string{
superfluidtypes.ModuleName,
bech32ibctypes.ModuleName,
txfeestypes.ModuleName,
+ tokenfactorytypes.ModuleName,
// Note: epochs' endblock should be "real" end of epochs, we keep epochs endblock at the end
epochstypes.ModuleName,
wasm.ModuleName,
@@ -287,6 +295,7 @@ var modulesOrderInitGenesis = []string{
epochstypes.ModuleName,
lockuptypes.ModuleName,
authz.ModuleName,
+ tokenfactorytypes.ModuleName,
// wasm after ibc transfer
wasm.ModuleName,
}
@@ -330,6 +339,10 @@ func simulationModules(
app.EpochsKeeper,
),
app.transferModule,
+ tokenfactory.NewAppModule(
+ appCodec,
+ *app.TokenFactoryKeeper,
+ ),
}
}
diff --git a/docs/core/proto-docs.md b/docs/core/proto-docs.md
index 77f18a5972e..1429e8b086f 100644
--- a/docs/core/proto-docs.md
+++ b/docs/core/proto-docs.md
@@ -300,6 +300,33 @@
- [Msg](#osmosis.superfluid.Msg)
+- [osmosis/tokenfactory/v1beta1/authorityMetadata.proto](#osmosis/tokenfactory/v1beta1/authorityMetadata.proto)
+ - [DenomAuthorityMetadata](#osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata)
+
+- [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)
+
+ - [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)
+
+ - [Msg](#osmosis.tokenfactory.v1beta1.Msg)
+
- [osmosis/txfees/v1beta1/feetoken.proto](#osmosis/txfees/v1beta1/feetoken.proto)
- [FeeToken](#osmosis.txfees.v1beta1.FeeToken)
@@ -4168,6 +4195,312 @@ Execute superfluid redelegation for a lockup rpc SuperfluidRedelegate(MsgSuperfl
+
+Top
+
+## osmosis/tokenfactory/v1beta1/authorityMetadata.proto
+
+
+
+
+
+### DenomAuthorityMetadata
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `Admin` | [string](#string) | | Can be empty for no admin, or a valid osmosis address |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Top
+
+## osmosis/tokenfactory/v1beta1/genesis.proto
+
+
+
+
+
+### GenesisDenom
+
+
+
+| 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 |
+| ----- | ---- | ----- | ----------- |
+| `factory_denoms` | [GenesisDenom](#osmosis.tokenfactory.v1beta1.GenesisDenom) | repeated | |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Top
+
+## osmosis/tokenfactory/v1beta1/query.proto
+
+
+
+
+
+### QueryDenomAuthorityMetadataRequest
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `denom` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### QueryDenomAuthorityMetadataResponse
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `authority_metadata` | [DenomAuthorityMetadata](#osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata) | | |
+
+
+
+
+
+
+
+
+### QueryDenomsFromCreatorRequest
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `creator` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### QueryDenomsFromCreatorResponse
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `denoms` | [string](#string) | repeated | |
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Query
+Query defines the gRPC querier service.
+
+| Method Name | Request Type | Response Type | Description | HTTP Verb | Endpoint |
+| ----------- | ------------ | ------------- | ------------| ------- | -------- |
+| `DenomAuthorityMetadata` | [QueryDenomAuthorityMetadataRequest](#osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataRequest) | [QueryDenomAuthorityMetadataResponse](#osmosis.tokenfactory.v1beta1.QueryDenomAuthorityMetadataResponse) | | GET|/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata|
+| `DenomsFromCreator` | [QueryDenomsFromCreatorRequest](#osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorRequest) | [QueryDenomsFromCreatorResponse](#osmosis.tokenfactory.v1beta1.QueryDenomsFromCreatorResponse) | | GET|/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}|
+
+
+
+
+
+
+Top
+
+## osmosis/tokenfactory/v1beta1/tx.proto
+
+
+
+
+
+### MsgBurn
+===================== MsgBurn
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `amount` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | |
+| `burnFromAddress` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgBurnResponse
+
+
+
+
+
+
+
+
+
+### MsgChangeAdmin
+===================== MsgChangeAdmin
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `denom` | [string](#string) | | |
+| `newAdmin` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgChangeAdminResponse
+
+
+
+
+
+
+
+
+
+### MsgCreateDenom
+===================== MsgCreateDenom
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `nonce` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgCreateDenomResponse
+
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `new_token_denom` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgMint
+===================== MsgMint
+
+
+| Field | Type | Label | Description |
+| ----- | ---- | ----- | ----------- |
+| `sender` | [string](#string) | | |
+| `amount` | [cosmos.base.v1beta1.Coin](#cosmos.base.v1beta1.Coin) | | |
+| `mintToAddress` | [string](#string) | | |
+
+
+
+
+
+
+
+
+### MsgMintResponse
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Msg
+Msg defines the Msg 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) | ForceTransfer is deactivated for now because we need to think through edge cases rpc ForceTransfer(MsgForceTransfer) returns (MsgForceTransferResponse); | |
+
+
+
+
+
Top
diff --git a/proto/osmosis/tokenfactory/v1beta1/authorityMetadata.proto b/proto/osmosis/tokenfactory/v1beta1/authorityMetadata.proto
new file mode 100644
index 00000000000..172acba2fbb
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/authorityMetadata.proto
@@ -0,0 +1,14 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos/base/v1beta1/coin.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types";
+
+message DenomAuthorityMetadata {
+ option (gogoproto.equal) = true;
+
+ // Can be empty for no admin, or a valid osmosis address
+ string Admin = 1 [ (gogoproto.moretags) = "yaml:\"admin\"" ];
+}
\ No newline at end of file
diff --git a/proto/osmosis/tokenfactory/v1beta1/genesis.proto b/proto/osmosis/tokenfactory/v1beta1/genesis.proto
new file mode 100644
index 00000000000..16338e58bf3
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/genesis.proto
@@ -0,0 +1,27 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "osmosis/tokenfactory/v1beta1/authorityMetadata.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types";
+
+// GenesisState defines the tokenfactory module's genesis state.
+message GenesisState {
+ option (gogoproto.equal) = true;
+
+ repeated GenesisDenom factory_denoms = 1 [
+ (gogoproto.moretags) = "yaml:\"factory_denoms\"",
+ (gogoproto.nullable) = false
+ ];
+}
+
+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
+ ];
+}
diff --git a/proto/osmosis/tokenfactory/v1beta1/query.proto b/proto/osmosis/tokenfactory/v1beta1/query.proto
new file mode 100644
index 00000000000..48ebf6c6677
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/query.proto
@@ -0,0 +1,41 @@
+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/authorityMetadata.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types";
+
+// Query defines the gRPC querier service.
+service Query {
+ rpc DenomAuthorityMetadata(QueryDenomAuthorityMetadataRequest)
+ returns (QueryDenomAuthorityMetadataResponse) {
+ option (google.api.http).get =
+ "/osmosis/tokenfactory/v1beta1/denoms/{denom}/authority_metadata";
+ }
+
+ rpc DenomsFromCreator(QueryDenomsFromCreatorRequest)
+ returns (QueryDenomsFromCreatorResponse) {
+ option (google.api.http).get =
+ "/osmosis/tokenfactory/v1beta1/denoms_from_creator/{creator}";
+ }
+}
+
+message QueryDenomAuthorityMetadataRequest {
+ string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ];
+}
+message QueryDenomAuthorityMetadataResponse {
+ DenomAuthorityMetadata authority_metadata = 1 [
+ (gogoproto.moretags) = "yaml:\"authority_metadata\"",
+ (gogoproto.nullable) = false
+ ];
+}
+
+message QueryDenomsFromCreatorRequest {
+ string creator = 1 [ (gogoproto.moretags) = "yaml:\"denoms\"" ];
+}
+message QueryDenomsFromCreatorResponse {
+ repeated string denoms = 1 [ (gogoproto.moretags) = "yaml:\"denoms\"" ];
+}
\ 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 00000000000..8c312ec7120
--- /dev/null
+++ b/proto/osmosis/tokenfactory/v1beta1/tx.proto
@@ -0,0 +1,79 @@
+syntax = "proto3";
+package osmosis.tokenfactory.v1beta1;
+
+import "gogoproto/gogo.proto";
+import "cosmos/base/v1beta1/coin.proto";
+
+option go_package = "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types";
+
+// Msg defines the Msg service.
+service Msg {
+ rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse);
+ rpc Mint(MsgMint) returns (MsgMintResponse);
+ rpc Burn(MsgBurn) returns (MsgBurnResponse);
+ // ForceTransfer is deactivated for now because we need to think through edge
+ // cases rpc ForceTransfer(MsgForceTransfer) returns
+ // (MsgForceTransferResponse);
+ rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse);
+}
+
+// ===================== MsgCreateDenom
+message MsgCreateDenom {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ string nonce = 2 [ (gogoproto.moretags) = "yaml:\"nonce\"" ];
+}
+
+message MsgCreateDenomResponse {
+ string new_token_denom = 1
+ [ (gogoproto.moretags) = "yaml:\"new_token_denom\"" ];
+}
+
+// ===================== MsgMint
+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
+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 {}
+
+// // ===================== MsgForceTransfer
+// message MsgForceTransfer {
+// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+// cosmos.base.v1beta1.Coin amount = 2 [
+// (gogoproto.moretags) = "yaml:\"amount\"",
+// (gogoproto.nullable) = false
+// ];
+// string transferFromAddress = 3
+// [ (gogoproto.moretags) = "yaml:\"transfer_from_address\"" ];
+// string transferToAddress = 4
+// [ (gogoproto.moretags) = "yaml:\"transfer_to_address\"" ];
+// }
+
+// message MsgForceTransferResponse {}
+
+// ===================== MsgChangeAdmin
+message MsgChangeAdmin {
+ string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ];
+ string denom = 2 [ (gogoproto.moretags) = "yaml:\"denom\"" ];
+ string newAdmin = 3 [ (gogoproto.moretags) = "yaml:\"new_admin\"" ];
+}
+
+message MsgChangeAdminResponse {}
\ No newline at end of file
diff --git a/x/tokenfactory/README.md b/x/tokenfactory/README.md
new file mode 100644
index 00000000000..b376cdacdce
--- /dev/null
+++ b/x/tokenfactory/README.md
@@ -0,0 +1,38 @@
+# Token Factory
+
+The tokenfactory module allows any account to create a new token with the name `factory/{creator address}/{nonce}
+
+Because tokens are namespaced by creator address, this allows token minting to be permissionless, due to not needing to resolve name collisions.
+A single account can create multiple denoms, by providing a unique nonce for each created denom.
+
+Once a denom is created, the original creator is given "admin" privleges over the asset. This allows them to:
+- Mint their denom to any account
+- Burn their denom from any account
+- Create a transfer of their denom between any two accounts
+- Change the admin
+
+In the future, more admin capabilities may be added. Admins can choose to share admin privledges with other accounts using the authz module. The `ChangeAdmin` functionality, allows changing the master admin account, or even setting it to `""`, meaning no account has admin privledges of the asset.
+
+## State Changes
+
+TODO: Describe
+
+## New SDK messages
+
+TODO: Describe
+
+## CLI commands
+
+TODO: Describe
+
+## Queries
+
+TODO: Describe
+
+## Code structure
+
+TODO: Describe
+
+## Future directions
+
+TODO: Describe
\ 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 00000000000..9da1cdc8c9b
--- /dev/null
+++ b/x/tokenfactory/client/cli/query.go
@@ -0,0 +1,94 @@
+package cli
+
+import (
+ "fmt"
+
+ // "strings"
+
+ "github.com/spf13/cobra"
+
+ "github.com/cosmos/cosmos-sdk/client"
+ "github.com/cosmos/cosmos-sdk/client/flags"
+
+ // "github.com/cosmos/cosmos-sdk/client/flags"
+ // sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+// GetQueryCmd returns the cli query commands for this module
+func GetQueryCmd(queryRoute string) *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(),
+ GetCmdDenomsFromCreator(),
+ )
+
+ 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
+}
+
+// GetCmdDenomAuthorityMetadata returns the authority metadata for a queried denom
+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
+}
diff --git a/x/tokenfactory/client/cli/tx.go b/x/tokenfactory/client/cli/tx.go
new file mode 100644
index 00000000000..e2f8ce6b1c6
--- /dev/null
+++ b/x/tokenfactory/client/cli/tx.go
@@ -0,0 +1,191 @@
+package cli
+
+import (
+ "fmt"
+
+ "github.com/spf13/cobra"
+
+ "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/cosmos/cosmos-sdk/client/flags"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+// 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(),
+ NewMintCmd(),
+ NewBurnCmd(),
+ // NewForceTransferCmd(),
+ NewChangeAdminCmd(),
+ )
+
+ return cmd
+}
+
+// NewCreateDenomCmd broadcast MsgCreateDenom
+func NewCreateDenomCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "create-denom [nonce] [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] [mint-to-address] [flags]",
+ Short: "Mint a denom to an address. 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)
+
+ amount, err := sdk.ParseCoinNormalized(args[0])
+ if err != nil {
+ return err
+ }
+
+ msg := types.NewMsgMint(
+ clientCtx.GetFromAddress().String(),
+ amount,
+ args[1],
+ )
+
+ return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+ },
+ }
+
+ flags.AddTxFlagsToCmd(cmd)
+ return cmd
+}
+
+// NewBurnCmd broadcast MsgBurn
+func NewBurnCmd() *cobra.Command {
+ cmd := &cobra.Command{
+ Use: "burn [amount] [burn-from-address] [flags]",
+ Short: "Burn tokens from an address. 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)
+
+ amount, err := sdk.ParseCoinNormalized(args[0])
+ if err != nil {
+ return err
+ }
+
+ msg := types.NewMsgBurn(
+ clientCtx.GetFromAddress().String(),
+ amount,
+ args[1],
+ )
+
+ return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+ },
+ }
+
+ flags.AddTxFlagsToCmd(cmd)
+ return cmd
+}
+
+// // NewForceTransferCmd broadcast MsgForceTransfer
+// func NewForceTransferCmd() *cobra.Command {
+// cmd := &cobra.Command{
+// Use: "force-transfer [amount] [transfer-from-address] [transfer-to-address] [flags]",
+// Short: "Force transfer tokens from one address to another address. Must have admin authority to do so.",
+// Args: cobra.ExactArgs(3),
+// 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.NewMsgForceTransfer(
+// clientCtx.GetFromAddress().String(),
+// amount,
+// args[1],
+// args[2],
+// )
+
+// return tx.GenerateOrBroadcastTxWithFactory(clientCtx, txf, msg)
+// },
+// }
+
+// flags.AddTxFlagsToCmd(cmd)
+// return cmd
+// }
+
+// NewForceTransferCmd broadcast MsgForceTransfer
+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/genesis.go b/x/tokenfactory/genesis.go
new file mode 100644
index 00000000000..35c3b02c835
--- /dev/null
+++ b/x/tokenfactory/genesis.go
@@ -0,0 +1,53 @@
+package tokenfactory
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/keeper"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+// InitGenesis initializes the capability module's state from a provided genesis
+// state.
+func InitGenesis(ctx sdk.Context, k keeper.Keeper, genState types.GenesisState) {
+ k.CreateModuleAccount(ctx)
+
+ for _, genDenom := range genState.GetFactoryDenoms() {
+ creator, nonce, err := types.DeconstructDenom(genDenom.GetDenom())
+ if err != nil {
+ panic(err.Error())
+ }
+ _, err = k.CreateDenom(ctx, creator, nonce)
+ if err != nil {
+ panic(err.Error())
+ }
+ err = k.SetAuthorityMetadata(ctx, genDenom.GetDenom(), genDenom.GetAuthorityMetadata())
+ if err != nil {
+ panic(err.Error())
+ }
+ }
+}
+
+// ExportGenesis returns the capability module's exported genesis.
+func ExportGenesis(ctx sdk.Context, k keeper.Keeper) *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.Error())
+ }
+
+ genDenoms = append(genDenoms, types.GenesisDenom{
+ Denom: denom,
+ AuthorityMetadata: authorityMetadata,
+ })
+ }
+
+ return &types.GenesisState{
+ FactoryDenoms: genDenoms,
+ }
+}
diff --git a/x/tokenfactory/genesis_test.go b/x/tokenfactory/genesis_test.go
new file mode 100644
index 00000000000..3749c043ccd
--- /dev/null
+++ b/x/tokenfactory/genesis_test.go
@@ -0,0 +1,42 @@
+package tokenfactory_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+ simapp "github.com/osmosis-labs/osmosis/v7/app"
+ appparams "github.com/osmosis-labs/osmosis/v7/app/params"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+func TestGenesis(t *testing.T) {
+ appparams.SetAddressPrefixes()
+
+ genesisState := types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44",
+ },
+ },
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/litecoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44",
+ },
+ },
+ },
+ }
+ app := simapp.Setup(false)
+ ctx := app.BaseApp.NewContext(false, tmproto.Header{})
+
+ tokenfactory.InitGenesis(ctx, *app.TokenFactoryKeeper, genesisState)
+ exportedGenesis := tokenfactory.ExportGenesis(ctx, *app.TokenFactoryKeeper)
+ require.NotNil(t, exportedGenesis)
+ require.Equal(t, genesisState, *exportedGenesis)
+}
diff --git a/x/tokenfactory/keeper/admins.go b/x/tokenfactory/keeper/admins.go
new file mode 100644
index 00000000000..590490e840d
--- /dev/null
+++ b/x/tokenfactory/keeper/admins.go
@@ -0,0 +1,50 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/gogo/protobuf/proto"
+
+ "github.com/osmosis-labs/osmosis/v7/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
+}
+
+func (k Keeper) SetAuthorityMetadata(ctx sdk.Context, denom string, metadata types.DenomAuthorityMetadata) error {
+ if metadata.Admin != "" {
+ _, err := sdk.AccAddressFromBech32(metadata.Admin)
+ 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 00000000000..85f7c4e37ee
--- /dev/null
+++ b/x/tokenfactory/keeper/admins_test.go
@@ -0,0 +1,86 @@
+package keeper_test
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/keeper"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+func (suite *KeeperTestSuite) TestAdminMsgs() {
+ suite.SetupTest()
+
+ addr1 := sdk.AccAddress([]byte("addr1---------------"))
+ addr2 := sdk.AccAddress([]byte("addr2---------------"))
+ addr1bal := int64(0)
+ addr2bal := int64(0)
+
+ msgServer := keeper.NewMsgServerImpl(*suite.app.TokenFactoryKeeper)
+
+ // Create a denom
+ res, err := msgServer.CreateDenom(sdk.WrapSDKContext(suite.ctx), types.NewMsgCreateDenom(addr1.String(), "bitcoin"))
+ suite.Require().NoError(err)
+ denom := 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(addr1.String(), queryRes.AuthorityMetadata.Admin)
+
+ // Test minting to admins own account
+ _, err = msgServer.Mint(sdk.WrapSDKContext(suite.ctx), types.NewMsgMint(addr1.String(), sdk.NewInt64Coin(denom, 10), addr1.String()))
+ addr1bal += 10
+ suite.Require().NoError(err)
+ suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr1, denom).Amount.Int64() == addr1bal, suite.app.BankKeeper.GetBalance(suite.ctx, addr1, denom))
+
+ // Test minting to a separate account. Should not work.
+ _, err = msgServer.Mint(sdk.WrapSDKContext(suite.ctx), types.NewMsgMint(addr1.String(), sdk.NewInt64Coin(denom, 10), addr2.String()))
+ suite.Require().Error(err)
+ suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr2, denom).Amount.Int64() == addr2bal)
+
+ // // Test force transferring
+ // _, err = msgServer.ForceTransfer(sdk.WrapSDKContext(suite.ctx), types.NewMsgForceTransfer(addr1.String(), sdk.NewInt64Coin(denom, 5), addr2.String(), addr1.String()))
+ // suite.Require().NoError(err)
+ // suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr1, denom).IsEqual(sdk.NewInt64Coin(denom, 15)))
+ // suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr2, denom).IsEqual(sdk.NewInt64Coin(denom, 5)))
+
+ // Test burning from own account
+ _, err = msgServer.Burn(sdk.WrapSDKContext(suite.ctx), types.NewMsgBurn(addr1.String(), sdk.NewInt64Coin(denom, 5), addr1.String()))
+ addr1bal -= 5
+ suite.Require().NoError(err)
+ suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr2, denom).Amount.Int64() == addr2bal)
+
+ // Test burning from a separate account. Should not work.
+ _, err = msgServer.Burn(sdk.WrapSDKContext(suite.ctx), types.NewMsgBurn(addr1.String(), sdk.NewInt64Coin(denom, 5), addr2.String()))
+ suite.Require().Error(err)
+ suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr2, denom).Amount.Int64() == addr2bal)
+
+ // Test Change Admin
+ _, err = msgServer.ChangeAdmin(sdk.WrapSDKContext(suite.ctx), types.NewMsgChangeAdmin(addr1.String(), denom, addr2.String()))
+ queryRes, err = suite.queryClient.DenomAuthorityMetadata(suite.ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: res.GetNewTokenDenom(),
+ })
+ suite.Require().NoError(err)
+ suite.Require().Equal(addr2.String(), queryRes.AuthorityMetadata.Admin)
+
+ // Make sure old admin can no longer do actions
+ _, err = msgServer.Burn(sdk.WrapSDKContext(suite.ctx), types.NewMsgBurn(addr1.String(), sdk.NewInt64Coin(denom, 5), addr1.String()))
+ suite.Require().Error(err)
+
+ // Make sure the new admin works
+ _, err = msgServer.Mint(sdk.WrapSDKContext(suite.ctx), types.NewMsgMint(addr2.String(), sdk.NewInt64Coin(denom, 5), addr2.String()))
+ addr2bal += 5
+ suite.Require().NoError(err)
+ suite.Require().True(suite.app.BankKeeper.GetBalance(suite.ctx, addr2, denom).Amount.Int64() == addr2bal)
+
+ // Try setting admin to empty
+ _, err = msgServer.ChangeAdmin(sdk.WrapSDKContext(suite.ctx), types.NewMsgChangeAdmin(addr2.String(), denom, ""))
+ suite.Require().NoError(err)
+ queryRes, err = suite.queryClient.DenomAuthorityMetadata(suite.ctx.Context(), &types.QueryDenomAuthorityMetadataRequest{
+ Denom: res.GetNewTokenDenom(),
+ })
+ suite.Require().NoError(err)
+ suite.Require().Equal("", queryRes.AuthorityMetadata.Admin)
+}
diff --git a/x/tokenfactory/keeper/bankactions.go b/x/tokenfactory/keeper/bankactions.go
new file mode 100644
index 00000000000..25bde730064
--- /dev/null
+++ b/x/tokenfactory/keeper/bankactions.go
@@ -0,0 +1,54 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+func (k Keeper) mintTo(ctx sdk.Context, amount sdk.Coin, mintTo string) error {
+ 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 {
+ 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))
+}
+
+func (k Keeper) forceTransfer(ctx sdk.Context, amount sdk.Coin, fromAddr string, toAddr string) error {
+ fromSdkAddr, err := sdk.AccAddressFromBech32(fromAddr)
+ if err != nil {
+ return err
+ }
+
+ toSdkAddr, err := sdk.AccAddressFromBech32(toAddr)
+ if err != nil {
+ return err
+ }
+
+ return k.bankKeeper.SendCoins(ctx, fromSdkAddr, toSdkAddr, sdk.NewCoins(amount))
+}
diff --git a/x/tokenfactory/keeper/createdenom.go b/x/tokenfactory/keeper/createdenom.go
new file mode 100644
index 00000000000..a07d3898776
--- /dev/null
+++ b/x/tokenfactory/keeper/createdenom.go
@@ -0,0 +1,44 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ banktypes "github.com/cosmos/cosmos-sdk/x/bank/types"
+
+ "github.com/osmosis-labs/osmosis/v7/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, denomnonce string) (newTokenDenom string, err error) {
+ denom, err := types.GetTokenDenom(creatorAddr, denomnonce)
+ if err != nil {
+ return "", err
+ }
+
+ _, found := k.bankKeeper.GetDenomMetaData(ctx, denom)
+ if found {
+ return "", types.ErrDenomExists
+ }
+
+ baseDenomUnit := banktypes.DenomUnit{
+ Denom: denom,
+ Exponent: 0,
+ }
+
+ denomMetaData := banktypes.Metadata{
+ DenomUnits: []*banktypes.DenomUnit{&baseDenomUnit},
+ 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 denom, nil
+}
diff --git a/x/tokenfactory/keeper/createdenom_test.go b/x/tokenfactory/keeper/createdenom_test.go
new file mode 100644
index 00000000000..a74b8066954
--- /dev/null
+++ b/x/tokenfactory/keeper/createdenom_test.go
@@ -0,0 +1,54 @@
+package keeper_test
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/keeper"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+func (suite *KeeperTestSuite) TestMsgCreateDenom() {
+ suite.SetupTest()
+
+ addr1 := sdk.AccAddress([]byte("addr1---------------"))
+
+ msgServer := keeper.NewMsgServerImpl(*suite.app.TokenFactoryKeeper)
+
+ // Creating a denom should work
+ res, err := msgServer.CreateDenom(sdk.WrapSDKContext(suite.ctx), types.NewMsgCreateDenom(addr1.String(), "bitcoin"))
+ 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(addr1.String(), queryRes.AuthorityMetadata.Admin)
+
+ // Make sure that a second version of the same denom can't be recreated
+ res, err = msgServer.CreateDenom(sdk.WrapSDKContext(suite.ctx), types.NewMsgCreateDenom(addr1.String(), "bitcoin"))
+ suite.Require().Error(err)
+
+ // Creating a second denom should work
+ res, err = msgServer.CreateDenom(sdk.WrapSDKContext(suite.ctx), types.NewMsgCreateDenom(addr1.String(), "litecoin"))
+ suite.Require().NoError(err)
+ suite.Require().NotEmpty(res.GetNewTokenDenom())
+
+ // Try querying all the denoms created by addr1
+ queryRes2, err := suite.queryClient.DenomsFromCreator(suite.ctx.Context(), &types.QueryDenomsFromCreatorRequest{
+ Creator: addr1.String(),
+ })
+ suite.Require().NoError(err)
+ suite.Require().Len(queryRes2.Denoms, 2)
+
+ // Make sure that a second account can create a denom with the same nonce
+ addr2 := sdk.AccAddress([]byte("addr2---------------"))
+ res, err = msgServer.CreateDenom(sdk.WrapSDKContext(suite.ctx), types.NewMsgCreateDenom(addr2.String(), "bitcoin"))
+ suite.Require().NoError(err)
+ suite.Require().NotEmpty(res.GetNewTokenDenom())
+
+ // Make sure that an address with a "/" in it can't create denoms
+ res, err = msgServer.CreateDenom(sdk.WrapSDKContext(suite.ctx), types.NewMsgCreateDenom("osmosis.eth/creator", "bitcoin"))
+ suite.Require().Error(err)
+}
diff --git a/x/tokenfactory/keeper/creators.go b/x/tokenfactory/keeper/creators.go
new file mode 100644
index 00000000000..6ce10469a03
--- /dev/null
+++ b/x/tokenfactory/keeper/creators.go
@@ -0,0 +1,27 @@
+package keeper
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+)
+
+// GetAuthorityMetadata returns the authority metadata for a specific denom
+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/grpc_query.go b/x/tokenfactory/keeper/grpc_query.go
new file mode 100644
index 00000000000..23b2278c8bf
--- /dev/null
+++ b/x/tokenfactory/keeper/grpc_query.go
@@ -0,0 +1,28 @@
+package keeper
+
+import (
+ "context"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+var _ types.QueryServer = Keeper{}
+
+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 00000000000..50b956df5e4
--- /dev/null
+++ b/x/tokenfactory/keeper/keeper.go
@@ -0,0 +1,73 @@
+package keeper
+
+import (
+ "fmt"
+
+ "github.com/tendermint/tendermint/libs/log"
+
+ "github.com/cosmos/cosmos-sdk/codec"
+ "github.com/cosmos/cosmos-sdk/store/prefix"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+
+ authtypes "github.com/cosmos/cosmos-sdk/x/auth/types"
+)
+
+type (
+ Keeper struct {
+ cdc codec.Codec
+ storeKey sdk.StoreKey
+
+ accountKeeper types.AccountKeeper
+ bankKeeper types.BankKeeper
+ }
+)
+
+func NewKeeper(
+ cdc codec.Codec,
+ storeKey sdk.StoreKey,
+ accountKeeper types.AccountKeeper,
+ bankKeeper types.BankKeeper,
+) Keeper {
+ return Keeper{
+ cdc: cdc,
+ storeKey: storeKey,
+
+ accountKeeper: accountKeeper,
+ bankKeeper: bankKeeper,
+ }
+}
+
+func (k Keeper) Logger(ctx sdk.Context) log.Logger {
+ return ctx.Logger().With("module", fmt.Sprintf("x/%s", types.ModuleName))
+}
+
+func (k Keeper) GetDenomPrefixStore(ctx sdk.Context, denom string) sdk.KVStore {
+ store := ctx.KVStore(k.storeKey)
+ return prefix.NewStore(store, types.GetDenomPrefixStore(denom))
+}
+
+func (k Keeper) GetCreatorPrefixStore(ctx sdk.Context, creator string) sdk.KVStore {
+ store := ctx.KVStore(k.storeKey)
+ return prefix.NewStore(store, types.GetCreatorPrefix(creator))
+}
+
+func (k Keeper) GetCreatorsPrefixStore(ctx sdk.Context) sdk.KVStore {
+ store := ctx.KVStore(k.storeKey)
+ return prefix.NewStore(store, types.GetCreatorsPrefix())
+}
+
+// func (k Keeper) GetAdminPrefixStore(ctx sdk.Context, admin string) sdk.KVStore {
+// store := ctx.KVStore(k.storeKey)
+// return prefix.NewStore(store, types.GetAdminPrefix(admin))
+// }
+
+// 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 00000000000..fbafb50943d
--- /dev/null
+++ b/x/tokenfactory/keeper/keeper_test.go
@@ -0,0 +1,48 @@
+package keeper_test
+
+import (
+ "testing"
+ "time"
+
+ "github.com/cosmos/cosmos-sdk/baseapp"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ "github.com/stretchr/testify/suite"
+ tmproto "github.com/tendermint/tendermint/proto/tendermint/types"
+
+ "github.com/osmosis-labs/osmosis/v7/app"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+type KeeperTestSuite struct {
+ suite.Suite
+
+ ctx sdk.Context
+ querier sdk.Querier
+ app *app.OsmosisApp
+ queryClient types.QueryClient
+ cleanup func()
+}
+
+func (suite *KeeperTestSuite) SetupTest() {
+ suite.app = app.Setup(false)
+ suite.ctx = suite.app.BaseApp.NewContext(false, tmproto.Header{Height: 1, ChainID: "osmosis-1", Time: time.Now().UTC()})
+
+ suite.app.TokenFactoryKeeper.CreateModuleAccount(suite.ctx)
+
+ queryHelper := baseapp.NewQueryServerTestHelper(suite.ctx, suite.app.InterfaceRegistry())
+ types.RegisterQueryServer(queryHelper, suite.app.TokenFactoryKeeper)
+ suite.queryClient = types.NewQueryClient(queryHelper)
+}
+
+func (suite *KeeperTestSuite) SetupTestWithLevelDb() {
+ suite.app, suite.cleanup = app.SetupTestingAppWithLevelDb(false)
+ suite.ctx = suite.app.BaseApp.NewContext(false, tmproto.Header{Height: 1, ChainID: "osmosis-1", Time: time.Now().UTC()})
+}
+
+func (suite *KeeperTestSuite) Cleanup() {
+ suite.cleanup()
+}
+
+func TestKeeperTestSuite(t *testing.T) {
+ suite.Run(t, new(KeeperTestSuite))
+}
diff --git a/x/tokenfactory/keeper/msg_server.go b/x/tokenfactory/keeper/msg_server.go
new file mode 100644
index 00000000000..1e765953558
--- /dev/null
+++ b/x/tokenfactory/keeper/msg_server.go
@@ -0,0 +1,171 @@
+package keeper
+
+import (
+ "context"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+
+ "github.com/osmosis-labs/osmosis/v7/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.Nonce)
+ 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)
+
+ authorityMetadata, err := server.Keeper.GetAuthorityMetadata(ctx, msg.Amount.GetDenom())
+ if err != nil {
+ return nil, err
+ }
+
+ if msg.Sender != authorityMetadata.GetAdmin() {
+ return nil, types.ErrUnauthorized
+ }
+
+ // Temporary additional check that only allows sender to mint coins into their own account.
+ // This check will be removed in the future once edge cases can be worked out
+ if msg.Sender != msg.MintToAddress {
+ return nil, sdkerrors.Wrap(types.ErrUnauthorized, "MintToAddress must be the same as Sender address")
+ }
+
+ err = server.Keeper.mintTo(ctx, msg.Amount, msg.MintToAddress)
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgMint,
+ sdk.NewAttribute(types.AttributeMintToAddress, msg.MintToAddress),
+ 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
+ }
+
+ // Temporary additional check that only allows sender to burn coins from their own account.
+ // This check will be removed in the future once edge cases can be worked out
+ if msg.Sender != msg.BurnFromAddress {
+ return nil, sdkerrors.Wrap(types.ErrUnauthorized, "BurnFromAddress must be the same as Sender address")
+ }
+
+ err = server.Keeper.burnFrom(ctx, msg.Amount, msg.GetBurnFromAddress())
+ if err != nil {
+ return nil, err
+ }
+
+ ctx.EventManager().EmitEvents(sdk.Events{
+ sdk.NewEvent(
+ types.TypeMsgBurn,
+ sdk.NewAttribute(types.AttributeBurnFromAddress, msg.BurnFromAddress),
+ sdk.NewAttribute(types.AttributeAmount, msg.Amount.String()),
+ ),
+ })
+
+ return &types.MsgBurnResponse{}, nil
+}
+
+// func (server msgServer) ForceTransfer(goCtx context.Context, msg *types.MsgForceTransfer) (*types.MsgForceTransferResponse, 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.forceTransfer(ctx, msg.Amount, msg.TransferFromAddress, msg.TransferToAddress)
+// if err != nil {
+// return nil, err
+// }
+
+// ctx.EventManager().EmitEvents(sdk.Events{
+// sdk.NewEvent(
+// types.TypeMsgForceTransfer,
+// sdk.NewAttribute(types.AttributeTransferFromAddress, msg.TransferFromAddress),
+// sdk.NewAttribute(types.AttributeTransferToAddress, msg.TransferToAddress),
+// sdk.NewAttribute(types.AttributeAmount, msg.Amount.String()),
+// ),
+// })
+
+// return &types.MsgForceTransferResponse{}, 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
+ }
+
+ // TODO: events
+ 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
+}
+
+var _ types.MsgServer = msgServer{}
diff --git a/x/tokenfactory/module.go b/x/tokenfactory/module.go
new file mode 100644
index 00000000000..5984f0817ae
--- /dev/null
+++ b/x/tokenfactory/module.go
@@ -0,0 +1,202 @@
+package tokenfactory
+
+import (
+ "context"
+ "encoding/json"
+ "fmt"
+ "math/rand"
+
+ // this line is used by starport scaffolding # 1
+
+ "github.com/gorilla/mux"
+ "github.com/grpc-ecosystem/grpc-gateway/runtime"
+ "github.com/spf13/cobra"
+
+ abci "github.com/tendermint/tendermint/abci/types"
+
+ "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"
+ simtypes "github.com/cosmos/cosmos-sdk/types/simulation"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/client/cli"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/keeper"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+var (
+ _ module.AppModule = AppModule{}
+ _ module.AppModuleBasic = AppModuleBasic{}
+)
+
+// ----------------------------------------------------------------------------
+// AppModuleBasic
+// ----------------------------------------------------------------------------
+
+// AppModuleBasic implements the AppModuleBasic interface for the capability module.
+type AppModuleBasic struct {
+ cdc codec.Codec
+}
+
+func NewAppModuleBasic(cdc codec.Codec) AppModuleBasic {
+ return AppModuleBasic{cdc: cdc}
+}
+
+// Name returns the capability module's name.
+func (AppModuleBasic) Name() string {
+ return types.ModuleName
+}
+
+func (AppModuleBasic) RegisterCodec(cdc *codec.LegacyAmino) {
+ types.RegisterCodec(cdc)
+}
+
+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 capability 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 capability module.
+func (AppModuleBasic) ValidateGenesis(cdc codec.JSONCodec, config 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(clientCtx client.Context, rtr *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 capability module's root tx command.
+func (a AppModuleBasic) GetTxCmd() *cobra.Command {
+ return cli.GetTxCmd()
+}
+
+// GetQueryCmd returns the capability module's root query command.
+func (AppModuleBasic) GetQueryCmd() *cobra.Command {
+ return cli.GetQueryCmd(types.StoreKey)
+}
+
+// ----------------------------------------------------------------------------
+// AppModule
+// ----------------------------------------------------------------------------
+
+// AppModule implements the AppModule interface for the capability module.
+type AppModule struct {
+ AppModuleBasic
+
+ keeper keeper.Keeper
+}
+
+func NewAppModule(cdc codec.Codec, keeper keeper.Keeper) AppModule {
+ return AppModule{
+ AppModuleBasic: NewAppModuleBasic(cdc),
+ keeper: keeper,
+ }
+}
+
+// Name returns the capability module's name.
+func (am AppModule) Name() string {
+ return am.AppModuleBasic.Name()
+}
+
+// Route returns the capability module's message routing key.
+func (am AppModule) Route() sdk.Route {
+ return sdk.Route{}
+}
+
+// QuerierRoute returns the capability module's query routing key.
+func (AppModule) QuerierRoute() string { return types.QuerierRoute }
+
+// LegacyQuerierHandler returns the capability module's Querier.
+func (am AppModule) LegacyQuerierHandler(legacyQuerierCdc *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 capability module's invariants.
+func (am AppModule) RegisterInvariants(_ sdk.InvariantRegistry) {}
+
+// InitGenesis performs the capability 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
+ // Initialize global index to index in genesis state
+ cdc.MustUnmarshalJSON(gs, &genState)
+
+ InitGenesis(ctx, am.keeper, genState)
+
+ return []abci.ValidatorUpdate{}
+}
+
+// ExportGenesis returns the capability module's exported genesis state as raw JSON bytes.
+func (am AppModule) ExportGenesis(ctx sdk.Context, cdc codec.JSONCodec) json.RawMessage {
+ genState := ExportGenesis(ctx, am.keeper)
+ return cdc.MustMarshalJSON(genState)
+}
+
+// ConsensusVersion implements ConsensusVersion.
+func (AppModule) ConsensusVersion() uint64 { return 1 }
+
+// BeginBlock executes all ABCI BeginBlock logic respective to the capability module.
+func (am AppModule) BeginBlock(_ sdk.Context, _ abci.RequestBeginBlock) {}
+
+// EndBlock executes all ABCI EndBlock logic respective to the capability module. It
+// returns no validator updates.
+func (am AppModule) EndBlock(_ sdk.Context, _ abci.RequestEndBlock) []abci.ValidatorUpdate {
+ return []abci.ValidatorUpdate{}
+}
+
+// ___________________________________________________________________________
+
+// AppModuleSimulation functions
+
+// GenerateGenesisState creates a randomized GenState of the pool-incentives module.
+func (am AppModule) GenerateGenesisState(simState *module.SimulationState) {
+ // gen := types.DefaultGenesis()
+ // gen.Basedenom = sdk.DefaultBondDenom
+ simState.GenState[types.ModuleName] = simState.Cdc.MustMarshalJSON(types.DefaultGenesis())
+}
+
+// ProposalContents doesn't return any content functions for governance proposals.
+func (am AppModule) ProposalContents(simState module.SimulationState) []simtypes.WeightedProposalContent {
+ return nil
+}
+
+// RandomizedParams creates randomized txfees param changes for the simulator.
+func (am AppModule) RandomizedParams(r *rand.Rand) []simtypes.ParamChange {
+ return nil
+}
+
+// RegisterStoreDecoder registers a decoder for supply module's types
+func (am AppModule) RegisterStoreDecoder(sdr sdk.StoreDecoderRegistry) {
+}
+
+// WeightedOperations returns simulator module operations with their respective weights.
+func (am AppModule) WeightedOperations(simState module.SimulationState) []simtypes.WeightedOperation {
+ return nil // TODO
+}
diff --git a/x/tokenfactory/types/authorityMetadata.pb.go b/x/tokenfactory/types/authorityMetadata.pb.go
new file mode 100644
index 00000000000..6f45d94a9c3
--- /dev/null
+++ b/x/tokenfactory/types/authorityMetadata.pb.go
@@ -0,0 +1,348 @@
+// Code generated by protoc-gen-gogo. DO NOT EDIT.
+// source: osmosis/tokenfactory/v1beta1/authorityMetadata.proto
+
+package types
+
+import (
+ fmt "fmt"
+ _ "github.com/cosmos/cosmos-sdk/types"
+ _ "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
+
+type DenomAuthorityMetadata struct {
+ // Can be empty for no admin, or a valid osmosis 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_99435de88ae175f7, []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 ""
+}
+
+func init() {
+ proto.RegisterType((*DenomAuthorityMetadata)(nil), "osmosis.tokenfactory.v1beta1.DenomAuthorityMetadata")
+}
+
+func init() {
+ proto.RegisterFile("osmosis/tokenfactory/v1beta1/authorityMetadata.proto", fileDescriptor_99435de88ae175f7)
+}
+
+var fileDescriptor_99435de88ae175f7 = []byte{
+ // 239 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0xc9, 0x2f, 0xce, 0xcd,
+ 0x2f, 0xce, 0x2c, 0xd6, 0x2f, 0xc9, 0xcf, 0x4e, 0xcd, 0x4b, 0x4b, 0x4c, 0x2e, 0xc9, 0x2f, 0xaa,
+ 0xd4, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x2c, 0x2d, 0xc9, 0xc8, 0x2f, 0xca,
+ 0x2c, 0xa9, 0xf4, 0x4d, 0x2d, 0x49, 0x4c, 0x49, 0x2c, 0x49, 0xd4, 0x2b, 0x28, 0xca, 0x2f, 0xc9,
+ 0x17, 0x92, 0x81, 0xea, 0xd2, 0x43, 0xd6, 0xa5, 0x07, 0xd5, 0x25, 0x25, 0x92, 0x9e, 0x9f, 0x9e,
+ 0x0f, 0x56, 0xa8, 0x0f, 0x62, 0x41, 0xf4, 0x48, 0xc9, 0x25, 0x83, 0x35, 0xe9, 0x27, 0x25, 0x16,
+ 0xa7, 0xc2, 0x2d, 0x48, 0xce, 0xcf, 0xcc, 0x83, 0xc8, 0x2b, 0xb9, 0x71, 0x89, 0xb9, 0xa4, 0xe6,
+ 0xe5, 0xe7, 0x3a, 0xa2, 0xdb, 0x29, 0xa4, 0xc6, 0xc5, 0xea, 0x98, 0x92, 0x9b, 0x99, 0x27, 0xc1,
+ 0xa8, 0xc0, 0xa8, 0xc1, 0xe9, 0x24, 0xf0, 0xe9, 0x9e, 0x3c, 0x4f, 0x65, 0x62, 0x6e, 0x8e, 0x95,
+ 0x52, 0x22, 0x48, 0x58, 0x29, 0x08, 0x22, 0x6d, 0xc5, 0xf2, 0x62, 0x81, 0x3c, 0xa3, 0x53, 0xe0,
+ 0x89, 0x47, 0x72, 0x8c, 0x17, 0x1e, 0xc9, 0x31, 0x3e, 0x78, 0x24, 0xc7, 0x38, 0xe1, 0xb1, 0x1c,
+ 0xc3, 0x85, 0xc7, 0x72, 0x0c, 0x37, 0x1e, 0xcb, 0x31, 0x44, 0x99, 0xa7, 0x67, 0x96, 0x64, 0x94,
+ 0x26, 0xe9, 0x25, 0xe7, 0xe7, 0xea, 0x43, 0x3d, 0xa0, 0x9b, 0x93, 0x98, 0x54, 0x0c, 0xe3, 0xe8,
+ 0x97, 0x99, 0xeb, 0x57, 0xa0, 0x06, 0x44, 0x49, 0x65, 0x41, 0x6a, 0x71, 0x12, 0x1b, 0xd8, 0x85,
+ 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x06, 0xef, 0xbb, 0x91, 0x2d, 0x01, 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 = encodeVarintAuthorityMetadata(dAtA, i, uint64(len(m.Admin)))
+ i--
+ dAtA[i] = 0xa
+ }
+ return len(dAtA) - i, nil
+}
+
+func encodeVarintAuthorityMetadata(dAtA []byte, offset int, v uint64) int {
+ offset -= sovAuthorityMetadata(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 + sovAuthorityMetadata(uint64(l))
+ }
+ return n
+}
+
+func sovAuthorityMetadata(x uint64) (n int) {
+ return (math_bits.Len64(x|1) + 6) / 7
+}
+func sozAuthorityMetadata(x uint64) (n int) {
+ return sovAuthorityMetadata(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 ErrIntOverflowAuthorityMetadata
+ }
+ 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 ErrIntOverflowAuthorityMetadata
+ }
+ 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 ErrInvalidLengthAuthorityMetadata
+ }
+ postIndex := iNdEx + intStringLen
+ if postIndex < 0 {
+ return ErrInvalidLengthAuthorityMetadata
+ }
+ if postIndex > l {
+ return io.ErrUnexpectedEOF
+ }
+ m.Admin = string(dAtA[iNdEx:postIndex])
+ iNdEx = postIndex
+ default:
+ iNdEx = preIndex
+ skippy, err := skipAuthorityMetadata(dAtA[iNdEx:])
+ if err != nil {
+ return err
+ }
+ if (skippy < 0) || (iNdEx+skippy) < 0 {
+ return ErrInvalidLengthAuthorityMetadata
+ }
+ if (iNdEx + skippy) > l {
+ return io.ErrUnexpectedEOF
+ }
+ iNdEx += skippy
+ }
+ }
+
+ if iNdEx > l {
+ return io.ErrUnexpectedEOF
+ }
+ return nil
+}
+func skipAuthorityMetadata(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, ErrIntOverflowAuthorityMetadata
+ }
+ 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, ErrIntOverflowAuthorityMetadata
+ }
+ 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, ErrIntOverflowAuthorityMetadata
+ }
+ 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, ErrInvalidLengthAuthorityMetadata
+ }
+ iNdEx += length
+ case 3:
+ depth++
+ case 4:
+ if depth == 0 {
+ return 0, ErrUnexpectedEndOfGroupAuthorityMetadata
+ }
+ depth--
+ case 5:
+ iNdEx += 4
+ default:
+ return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+ }
+ if iNdEx < 0 {
+ return 0, ErrInvalidLengthAuthorityMetadata
+ }
+ if depth == 0 {
+ return iNdEx, nil
+ }
+ }
+ return 0, io.ErrUnexpectedEOF
+}
+
+var (
+ ErrInvalidLengthAuthorityMetadata = fmt.Errorf("proto: negative length found during unmarshaling")
+ ErrIntOverflowAuthorityMetadata = fmt.Errorf("proto: integer overflow")
+ ErrUnexpectedEndOfGroupAuthorityMetadata = fmt.Errorf("proto: unexpected end of group")
+)
diff --git a/x/tokenfactory/types/codec.go b/x/tokenfactory/types/codec.go
new file mode 100644
index 00000000000..6308a36fe5b
--- /dev/null
+++ b/x/tokenfactory/types/codec.go
@@ -0,0 +1,35 @@
+package types
+
+import (
+ "github.com/cosmos/cosmos-sdk/codec"
+ cdctypes "github.com/cosmos/cosmos-sdk/codec/types"
+ sdk "github.com/cosmos/cosmos-sdk/types"
+
+ // this line is used by starport scaffolding # 1
+ "github.com/cosmos/cosmos-sdk/types/msgservice"
+)
+
+func RegisterCodec(cdc *codec.LegacyAmino) {
+ cdc.RegisterConcrete(&MsgCreateDenom{}, "osmosis/tokenfactory/create-denom", nil)
+ cdc.RegisterConcrete(&MsgMint{}, "osmosis/tokenfactory/mint", nil)
+ cdc.RegisterConcrete(&MsgBurn{}, "osmosis/tokenfactory/burn", nil)
+ // cdc.RegisterConcrete(&MsgForceTransfer{}, "osmosis/tokenfactory/force-transfer", nil)
+ cdc.RegisterConcrete(&MsgChangeAdmin{}, "osmosis/tokenfactory/change-admin", nil)
+}
+
+func RegisterInterfaces(registry cdctypes.InterfaceRegistry) {
+ registry.RegisterImplementations(
+ (*sdk.Msg)(nil),
+ &MsgCreateDenom{},
+ &MsgMint{},
+ &MsgBurn{},
+ // &MsgForceTransfer{},
+ &MsgChangeAdmin{},
+ )
+ msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc)
+}
+
+var (
+ amino = codec.NewLegacyAmino()
+ ModuleCdc = codec.NewProtoCodec(cdctypes.NewInterfaceRegistry())
+)
diff --git a/x/tokenfactory/types/denoms.go b/x/tokenfactory/types/denoms.go
new file mode 100644
index 00000000000..892122606ae
--- /dev/null
+++ b/x/tokenfactory/types/denoms.go
@@ -0,0 +1,49 @@
+package types
+
+import (
+ "strings"
+
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+const (
+ ModuleDenomPrefix = "factory"
+)
+
+func GetTokenDenom(creator, nonce string) (string, error) {
+ if strings.Contains(creator, "/") {
+ return "", ErrInvalidCreator
+ }
+ denom := strings.Join([]string{ModuleDenomPrefix, creator, nonce}, "/")
+ return denom, sdk.ValidateDenom(denom)
+}
+
+func DeconstructDenom(denom string) (creator string, nonce 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]
+ _, err = sdk.AccAddressFromBech32(creator)
+ if err != nil {
+ return "", "", sdkerrors.Wrapf(ErrInvalidDenom, "Invalid creator address (%s)", err)
+ }
+
+ // This is to for if there is a denom with a slash in its nonce. For example,
+ // when we did the split, we'd turn factory/sunnyaddr/atomderivative/sikka into ["factory", "sunnyaddr", "atomderivative", "sikka"]
+ // So we have to join [2:] with a "/" as the delimiter to get back the correct nonce which should be "atomderivative/sikka"
+ nonce = strings.Join(strParts[2:], "/")
+
+ return creator, nonce, nil
+}
diff --git a/x/tokenfactory/types/denoms_test.go b/x/tokenfactory/types/denoms_test.go
new file mode 100644
index 00000000000..b7f0fc01067
--- /dev/null
+++ b/x/tokenfactory/types/denoms_test.go
@@ -0,0 +1,64 @@
+package types_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ appparams "github.com/osmosis-labs/osmosis/v7/app/params"
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+func TestDecomposeDenoms(t *testing.T) {
+ appparams.SetAddressPrefixes()
+ for _, tc := range []struct {
+ desc string
+ denom string
+ valid bool
+ }{
+ {
+ desc: "empty is invalid",
+ denom: "",
+ valid: false,
+ },
+ {
+ desc: "normal",
+ denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ valid: true,
+ },
+ {
+ desc: "multiple slashes in nonce",
+ denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin/1",
+ valid: true,
+ },
+ {
+ desc: "no nonce",
+ denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/",
+ valid: true,
+ },
+ {
+ desc: "incorrect prefix",
+ denom: "ibc/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ valid: false,
+ },
+ {
+ desc: "nonce of only slashes",
+ denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/////",
+ valid: true,
+ },
+ {
+ desc: "too long name",
+ denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/adsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsfadsf",
+ valid: false,
+ },
+ } {
+ t.Run(tc.desc, func(t *testing.T) {
+ _, _, err := types.DeconstructDenom(tc.denom)
+ 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 00000000000..cb6e7c23d41
--- /dev/null
+++ b/x/tokenfactory/types/errors.go
@@ -0,0 +1,17 @@
+package types
+
+// DONTCOVER
+
+import (
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// x/tokenfactory module sentinel errors
+var (
+ ErrDenomExists = sdkerrors.Register(ModuleName, 1, "denom already exists")
+ ErrUnauthorized = sdkerrors.Register(ModuleName, 2, "unauthorized account")
+ ErrInvalidDenom = sdkerrors.Register(ModuleName, 3, "invalid denom")
+ ErrInvalidCreator = sdkerrors.Register(ModuleName, 4, "invalid creator")
+ ErrInvalidAuthorityMetadata = sdkerrors.Register(ModuleName, 5, "invalid authority metadata")
+ ErrInvalidGenesis = sdkerrors.Register(ModuleName, 6, "invalid genesis")
+)
diff --git a/x/tokenfactory/types/events.go b/x/tokenfactory/types/events.go
new file mode 100644
index 00000000000..24742983950
--- /dev/null
+++ b/x/tokenfactory/types/events.go
@@ -0,0 +1,15 @@
+package types
+
+// event types
+const (
+ AttributeAmount = "amount"
+ AttributeCreator = "creator"
+ AttributeNonce = "nonce"
+ AttributeNewTokenDenom = "new_token_denom"
+ AttributeMintToAddress = "mint_to_address"
+ AttributeBurnFromAddress = "burn_from_address"
+ AttributeTransferFromAddress = "transfer_from_address"
+ AttributeTransferToAddress = "transfer_to_address"
+ AttributeDenom = "denom"
+ AttributeNewAdmin = "new_admin"
+)
diff --git a/x/tokenfactory/types/expected_keepers.go b/x/tokenfactory/types/expected_keepers.go
new file mode 100644
index 00000000000..9ef176f0c73
--- /dev/null
+++ b/x/tokenfactory/types/expected_keepers.go
@@ -0,0 +1,30 @@
+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 {
+ // Methods imported from bank should be defined here
+ GetDenomMetaData(ctx sdk.Context, denom string) (banktypes.Metadata, bool)
+ SetDenomMetaData(ctx sdk.Context, denomMetaData banktypes.Metadata)
+
+ SendCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, amt sdk.Coins) error
+ SendCoinsFromModuleToModule(ctx sdk.Context, senderModule, recipientModule string, amt sdk.Coins) error
+ SendCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+ DelegateCoinsFromAccountToModule(ctx sdk.Context, senderAddr sdk.AccAddress, recipientModule string, amt sdk.Coins) error
+ UndelegateCoinsFromModuleToAccount(ctx sdk.Context, senderModule string, recipientAddr sdk.AccAddress, 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
+}
+
+// AccountKeeper defines the expected account keeper used for simulations (noalias)
+type AccountKeeper interface {
+ GetModuleAddress(name string) sdk.AccAddress
+ SetModuleAccount(ctx sdk.Context, macc authtypes.ModuleAccountI)
+ GetAccount(sdk.Context, sdk.AccAddress) authtypes.AccountI
+}
diff --git a/x/tokenfactory/types/genesis.go b/x/tokenfactory/types/genesis.go
new file mode 100644
index 00000000000..7c274555415
--- /dev/null
+++ b/x/tokenfactory/types/genesis.go
@@ -0,0 +1,45 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// this line is used by starport scaffolding # genesis/types/import
+
+// DefaultIndex is the default capability global index
+const DefaultIndex uint64 = 1
+
+// DefaultGenesis returns the default Capability genesis state
+func DefaultGenesis() *GenesisState {
+ return &GenesisState{
+ FactoryDenoms: []GenesisDenom{},
+ }
+}
+
+// Validate performs basic genesis state validation returning an error upon any
+// failure.
+func (gs GenesisState) Validate() error {
+ 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 00000000000..7f7f10e2d1d
--- /dev/null
+++ b/x/tokenfactory/types/genesis.pb.go
@@ -0,0 +1,619 @@
+// 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 {
+ FactoryDenoms []GenesisDenom `protobuf:"bytes,1,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) GetFactoryDenoms() []GenesisDenom {
+ if m != nil {
+ return m.FactoryDenoms
+ }
+ return nil
+}
+
+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{
+ // 336 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0xd2, 0xca, 0x2f, 0xce, 0xcd,
+ 0x2f, 0xce, 0x2c, 0xd6, 0x2f, 0xc9, 0xcf, 0x4e, 0xcd, 0x4b, 0x4b, 0x4c, 0x2e, 0xc9, 0x2f, 0xaa,
+ 0xd4, 0x2f, 0x33, 0x4c, 0x4a, 0x2d, 0x49, 0x34, 0xd4, 0x4f, 0x4f, 0xcd, 0x4b, 0x2d, 0xce, 0x2c,
+ 0xd6, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17, 0x92, 0x81, 0xaa, 0xd5, 0x43, 0x56, 0xab, 0x07, 0x55,
+ 0x2b, 0x25, 0x92, 0x9e, 0x9f, 0x9e, 0x0f, 0x56, 0xa8, 0x0f, 0x62, 0x41, 0xf4, 0x48, 0x99, 0xe0,
+ 0x35, 0x3f, 0xb1, 0xb4, 0x24, 0x23, 0xbf, 0x28, 0xb3, 0xa4, 0xd2, 0x37, 0xb5, 0x24, 0x31, 0x25,
+ 0xb1, 0x24, 0x11, 0xa2, 0x4b, 0xa9, 0x8d, 0x91, 0x8b, 0xc7, 0x1d, 0x62, 0x77, 0x70, 0x49, 0x62,
+ 0x49, 0xaa, 0x50, 0x01, 0x17, 0x1f, 0x54, 0x6f, 0x7c, 0x4a, 0x6a, 0x5e, 0x7e, 0x6e, 0xb1, 0x04,
+ 0xa3, 0x02, 0xb3, 0x06, 0xb7, 0x91, 0x96, 0x1e, 0x3e, 0x37, 0xe9, 0x41, 0xcd, 0x70, 0x01, 0x69,
+ 0x71, 0x92, 0x3d, 0x71, 0x4f, 0x9e, 0xe1, 0xd3, 0x3d, 0x79, 0xd1, 0xca, 0xc4, 0xdc, 0x1c, 0x2b,
+ 0x25, 0x54, 0xf3, 0x94, 0x82, 0x78, 0xa1, 0x02, 0x60, 0xc5, 0xc5, 0x56, 0x2c, 0x2f, 0x16, 0xc8,
+ 0x33, 0x2a, 0x1d, 0x45, 0x38, 0x04, 0x2c, 0x2e, 0xa4, 0xc6, 0xc5, 0x0a, 0xd6, 0x20, 0xc1, 0xa8,
+ 0xc0, 0xa8, 0xc1, 0xe9, 0x24, 0xf0, 0xe9, 0x9e, 0x3c, 0x0f, 0xc4, 0x3c, 0xb0, 0xb0, 0x52, 0x10,
+ 0x44, 0x5a, 0xa8, 0x8d, 0x91, 0x4b, 0x08, 0xee, 0xbb, 0xf8, 0x5c, 0xa8, 0xf7, 0x24, 0x98, 0x14,
+ 0x18, 0x35, 0xb8, 0x8d, 0x4c, 0xf0, 0xbb, 0x1a, 0x6c, 0x93, 0x23, 0x7a, 0xd0, 0x38, 0x29, 0x42,
+ 0xdd, 0x2f, 0x09, 0xb1, 0x0f, 0xd3, 0x74, 0xa5, 0x20, 0x41, 0x8c, 0x00, 0x85, 0xf8, 0xc3, 0x29,
+ 0xf0, 0xc4, 0x23, 0x39, 0xc6, 0x0b, 0x8f, 0xe4, 0x18, 0x1f, 0x3c, 0x92, 0x63, 0x9c, 0xf0, 0x58,
+ 0x8e, 0xe1, 0xc2, 0x63, 0x39, 0x86, 0x1b, 0x8f, 0xe5, 0x18, 0xa2, 0xcc, 0xd3, 0x33, 0x4b, 0x32,
+ 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, 0xa1, 0xae, 0xd2, 0xcd, 0x49, 0x4c, 0x2a, 0x86, 0x71,
+ 0xf4, 0xcb, 0xcc, 0xf5, 0x2b, 0x50, 0x63, 0xaf, 0xa4, 0xb2, 0x20, 0xb5, 0x38, 0x89, 0x0d, 0x1c,
+ 0x55, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0xec, 0xfa, 0xc9, 0x97, 0x42, 0x02, 0x00, 0x00,
+}
+
+func (this *GenesisState) Equal(that interface{}) bool {
+ if that == nil {
+ return this == nil
+ }
+
+ that1, ok := that.(*GenesisState)
+ if !ok {
+ that2, ok := that.(GenesisState)
+ if ok {
+ that1 = &that2
+ } else {
+ return false
+ }
+ }
+ if that1 == nil {
+ return this == nil
+ } else if this == nil {
+ return false
+ }
+ if len(this.FactoryDenoms) != len(that1.FactoryDenoms) {
+ return false
+ }
+ for i := range this.FactoryDenoms {
+ if !this.FactoryDenoms[i].Equal(&that1.FactoryDenoms[i]) {
+ return false
+ }
+ }
+ return true
+}
+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] = 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
+ 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 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 00000000000..6b6e3bf86f3
--- /dev/null
+++ b/x/tokenfactory/types/genesis_test.go
@@ -0,0 +1,139 @@
+package types_test
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/osmosis-labs/osmosis/v7/x/tokenfactory/types"
+)
+
+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/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "different admin from creator",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "osmo1ft6e5esdtdegnvcr3djd3ftk4kwpcr6jrx5fj9",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "empty admin",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "no admin",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "invalid admin",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "moose",
+ },
+ },
+ },
+ },
+ valid: false,
+ },
+ {
+ desc: "multiple denoms",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/litecoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ },
+ },
+ valid: true,
+ },
+ {
+ desc: "duplicate denoms",
+ genState: &types.GenesisState{
+ FactoryDenoms: []types.GenesisDenom{
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ AuthorityMetadata: types.DenomAuthorityMetadata{
+ Admin: "",
+ },
+ },
+ {
+ Denom: "factory/osmo1t7egva48prqmzl59x5ngv4zx0dtrwewc9m7z44/bitcoin",
+ 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 00000000000..d4b48670369
--- /dev/null
+++ b/x/tokenfactory/types/keys.go
@@ -0,0 +1,48 @@
+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"
+)
+
+func GetDenomPrefixStore(denom string) []byte {
+ return []byte(strings.Join([]string{DenomsPrefixKey, denom, ""}, KeySeparator))
+}
+
+func GetCreatorPrefix(creator string) []byte {
+ return []byte(strings.Join([]string{CreatorPrefixKey, creator, ""}, KeySeparator))
+}
+
+func GetCreatorsPrefix() []byte {
+ return []byte(strings.Join([]string{CreatorPrefixKey, ""}, KeySeparator))
+}
+
+// func GetAdminPrefix(admin string) []byte {
+// return []byte(strings.Join([]string{admin, "admin", ""}, KeySeparator))
+// }
diff --git a/x/tokenfactory/types/msgs.go b/x/tokenfactory/types/msgs.go
new file mode 100644
index 00000000000..753325e8579
--- /dev/null
+++ b/x/tokenfactory/types/msgs.go
@@ -0,0 +1,216 @@
+package types
+
+import (
+ sdk "github.com/cosmos/cosmos-sdk/types"
+ sdkerrors "github.com/cosmos/cosmos-sdk/types/errors"
+)
+
+// constants
+const (
+ TypeMsgCreateDenom = "create_denom"
+ TypeMsgMint = "mint"
+ TypeMsgBurn = "burn"
+ TypeMsgForceTransfer = "force_transfer"
+ TypeMsgChangeAdmin = "change_admin"
+)
+
+var _ sdk.Msg = &MsgCreateDenom{}
+
+// NewMsgCreateDenom creates a msg to create a new denom
+func NewMsgCreateDenom(sender, nonce string) *MsgCreateDenom {
+ return &MsgCreateDenom{
+ Sender: sender,
+ Nonce: nonce,
+ }
+}
+
+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.Nonce)
+ 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, mintTo string) *MsgMint {
+ return &MsgMint{
+ Sender: sender,
+ Amount: amount,
+ MintToAddress: mintTo,
+ }
+}
+
+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)
+ }
+
+ _, err = sdk.AccAddressFromBech32(m.MintToAddress)
+ if err != nil {
+ return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "Invalid recipient address (%s)", err)
+ }
+
+ if !m.Amount.IsValid() {
+ 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, burnFrom string) *MsgBurn {
+ return &MsgBurn{
+ Sender: sender,
+ Amount: amount,
+ BurnFromAddress: burnFrom,
+ }
+}
+
+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)
+ }
+
+ _, err = sdk.AccAddressFromBech32(m.BurnFromAddress)
+ 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 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}
+}
diff --git a/x/tokenfactory/types/query.pb.go b/x/tokenfactory/types/query.pb.go
new file mode 100644
index 00000000000..30a0311d4eb
--- /dev/null
+++ b/x/tokenfactory/types/query.pb.go
@@ -0,0 +1,977 @@
+// 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
+
+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{0}
+}
+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 ""
+}
+
+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{1}
+}
+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{}
+}
+
+type QueryDenomsFromCreatorRequest struct {
+ Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty" yaml:"denoms"`
+}
+
+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{2}
+}
+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 ""
+}
+
+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{3}
+}
+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((*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{
+ // 492 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x93, 0x41, 0x6b, 0x13, 0x41,
+ 0x14, 0xc7, 0x33, 0x96, 0x56, 0x1c, 0x15, 0xcc, 0x20, 0x52, 0x43, 0xdd, 0xd4, 0x11, 0xa4, 0x2a,
+ 0xee, 0xd0, 0x5a, 0x28, 0x58, 0x45, 0x93, 0x8a, 0x1e, 0xac, 0x87, 0xe6, 0xe8, 0x25, 0xcc, 0xa6,
+ 0xd3, 0xed, 0x62, 0x76, 0xdf, 0x76, 0x66, 0x52, 0x5c, 0x4a, 0x2f, 0x1e, 0x3c, 0x0b, 0x7e, 0x0f,
+ 0x3f, 0x86, 0xf4, 0x58, 0xe8, 0xc5, 0x53, 0x90, 0x44, 0xfc, 0x00, 0xf9, 0x04, 0x92, 0x99, 0x49,
+ 0xac, 0xee, 0xba, 0x16, 0x3d, 0xed, 0x30, 0xef, 0xff, 0xfe, 0xef, 0xfd, 0xde, 0x9b, 0xc5, 0x4b,
+ 0xa0, 0x62, 0x50, 0x91, 0x62, 0x1a, 0xde, 0x88, 0x64, 0x87, 0x77, 0x34, 0xc8, 0x8c, 0xed, 0x2f,
+ 0x07, 0x42, 0xf3, 0x65, 0xb6, 0xd7, 0x13, 0x32, 0xf3, 0x53, 0x09, 0x1a, 0xc8, 0x82, 0x53, 0xfa,
+ 0xa7, 0x95, 0xbe, 0x53, 0xd6, 0xae, 0x86, 0x10, 0x82, 0x11, 0xb2, 0xf1, 0xc9, 0xe6, 0xd4, 0x16,
+ 0x42, 0x80, 0xb0, 0x2b, 0x18, 0x4f, 0x23, 0xc6, 0x93, 0x04, 0x34, 0xd7, 0x11, 0x24, 0xca, 0x45,
+ 0xef, 0x76, 0x8c, 0x25, 0x0b, 0xb8, 0x12, 0xb6, 0xd4, 0xb4, 0x70, 0xca, 0xc3, 0x28, 0x31, 0x62,
+ 0xa7, 0x5d, 0x2d, 0xed, 0x93, 0xf7, 0xf4, 0x2e, 0xc8, 0x48, 0x67, 0xaf, 0x84, 0xe6, 0xdb, 0x5c,
+ 0x73, 0x9b, 0x45, 0x37, 0x31, 0xdd, 0x1a, 0xfb, 0x3e, 0x13, 0x09, 0xc4, 0x8d, 0xdf, 0x45, 0x2d,
+ 0xb1, 0xd7, 0x13, 0x4a, 0x93, 0xdb, 0x78, 0x76, 0x7b, 0x2c, 0x98, 0x47, 0x8b, 0x68, 0xe9, 0x42,
+ 0xf3, 0xca, 0xa8, 0x5f, 0xbf, 0x94, 0xf1, 0xb8, 0xfb, 0x90, 0x9a, 0x6b, 0xda, 0xb2, 0x61, 0xfa,
+ 0x09, 0xe1, 0x5b, 0xa5, 0x76, 0x2a, 0x85, 0x44, 0x09, 0xf2, 0x1e, 0x61, 0x32, 0xed, 0xa8, 0x1d,
+ 0xbb, 0xb0, 0x71, 0xbf, 0xb8, 0xb2, 0xea, 0x97, 0xcd, 0xd1, 0x2f, 0xb6, 0x6e, 0xde, 0x3c, 0xea,
+ 0xd7, 0x2b, 0xa3, 0x7e, 0xfd, 0xba, 0xed, 0x2b, 0xef, 0x4e, 0x5b, 0xd5, 0xdc, 0x10, 0xe8, 0x26,
+ 0xbe, 0xf1, 0xb3, 0x5f, 0xf5, 0x5c, 0x42, 0xbc, 0x21, 0x05, 0xd7, 0x20, 0x27, 0xe4, 0xf7, 0xf0,
+ 0xf9, 0x8e, 0xbd, 0x71, 0xec, 0xd5, 0x51, 0xbf, 0x7e, 0xf9, 0x14, 0xbb, 0xa2, 0xad, 0x89, 0x82,
+ 0xbe, 0xc4, 0xde, 0x9f, 0xdc, 0x1c, 0xf8, 0x1d, 0x3c, 0x67, 0xb3, 0xe6, 0xd1, 0xe2, 0x4c, 0xb1,
+ 0x9b, 0x13, 0xac, 0x7c, 0x9e, 0xc1, 0xb3, 0xc6, 0x8d, 0x7c, 0x47, 0xf8, 0x5a, 0x31, 0x35, 0x79,
+ 0x5a, 0x3e, 0xab, 0xbf, 0xaf, 0xb6, 0xd6, 0xf8, 0x0f, 0x07, 0x0b, 0x45, 0x5f, 0xbc, 0x3b, 0xf9,
+ 0xf6, 0xf1, 0x5c, 0x83, 0x3c, 0x61, 0xa5, 0x4f, 0xd0, 0x72, 0xb1, 0x03, 0xf3, 0x3d, 0x64, 0xf9,
+ 0x0d, 0x91, 0x13, 0x84, 0xab, 0xb9, 0xd9, 0x91, 0xf5, 0xb3, 0x76, 0x58, 0xb0, 0xbf, 0xda, 0xa3,
+ 0x7f, 0x4b, 0x76, 0x64, 0x1b, 0x86, 0xec, 0x31, 0x59, 0x3f, 0x0b, 0x59, 0x7b, 0x47, 0x42, 0xdc,
+ 0x76, 0x6f, 0x81, 0x1d, 0xb8, 0xc3, 0x61, 0x73, 0xeb, 0x68, 0xe0, 0xa1, 0xe3, 0x81, 0x87, 0xbe,
+ 0x0e, 0x3c, 0xf4, 0x61, 0xe8, 0x55, 0x8e, 0x87, 0x5e, 0xe5, 0xcb, 0xd0, 0xab, 0xbc, 0x5e, 0x0b,
+ 0x23, 0xbd, 0xdb, 0x0b, 0xfc, 0x0e, 0xc4, 0x93, 0x02, 0xf7, 0xbb, 0x3c, 0x50, 0xd3, 0x6a, 0xfb,
+ 0x6b, 0xec, 0xed, 0xaf, 0x25, 0x75, 0x96, 0x0a, 0x15, 0xcc, 0x99, 0x9f, 0xf7, 0xc1, 0x8f, 0x00,
+ 0x00, 0x00, 0xff, 0xff, 0xd1, 0x0c, 0x41, 0xe9, 0x9c, 0x04, 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 {
+ DenomAuthorityMetadata(ctx context.Context, in *QueryDenomAuthorityMetadataRequest, opts ...grpc.CallOption) (*QueryDenomAuthorityMetadataResponse, error)
+ 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) 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 {
+ DenomAuthorityMetadata(context.Context, *QueryDenomAuthorityMetadataRequest) (*QueryDenomAuthorityMetadataResponse, error)
+ DenomsFromCreator(context.Context, *QueryDenomsFromCreatorRequest) (*QueryDenomsFromCreatorResponse, error)
+}
+
+// UnimplementedQueryServer can be embedded to have forward compatible implementations.
+type UnimplementedQueryServer struct {
+}
+
+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_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: "DenomAuthorityMetadata",
+ Handler: _Query_DenomAuthorityMetadata_Handler,
+ },
+ {
+ MethodName: "DenomsFromCreator",
+ Handler: _Query_DenomsFromCreator_Handler,
+ },
+ },
+ Streams: []grpc.StreamDesc{},
+ Metadata: "osmosis/tokenfactory/v1beta1/query.proto",
+}
+
+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 *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 *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 00000000000..f3b609e8a15
--- /dev/null
+++ b/x/tokenfactory/types/query.pb.gw.go
@@ -0,0 +1,282 @@
+// 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_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_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_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_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{"osmosis", "tokenfactory", "v1beta1", "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{"osmosis", "tokenfactory", "v1beta1", "denoms_from_creator", "creator"}, "", runtime.AssumeColonVerbOpt(true)))
+)
+
+var (
+ forward_Query_DenomAuthorityMetadata_0 = runtime.ForwardResponseMessage
+
+ forward_Query_DenomsFromCreator_0 = runtime.ForwardResponseMessage
+)
diff --git a/x/tokenfactory/types/tx.pb.go b/x/tokenfactory/types/tx.pb.go
new file mode 100644
index 00000000000..5180fd9b254
--- /dev/null
+++ b/x/tokenfactory/types/tx.pb.go
@@ -0,0 +1,1945 @@
+// 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"
+ _ "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
+type MsgCreateDenom struct {
+ Sender string `protobuf:"bytes,1,opt,name=sender,proto3" json:"sender,omitempty" yaml:"sender"`
+ Nonce string `protobuf:"bytes,2,opt,name=nonce,proto3" json:"nonce,omitempty" yaml:"nonce"`
+}
+
+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) GetNonce() string {
+ if m != nil {
+ return m.Nonce
+ }
+ return ""
+}
+
+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
+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
+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
+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=newAdmin,proto3" json:"newAdmin,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 ""
+}
+
+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
+
+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")
+}
+
+func init() {
+ proto.RegisterFile("osmosis/tokenfactory/v1beta1/tx.proto", fileDescriptor_283b6c9a90a846b4)
+}
+
+var fileDescriptor_283b6c9a90a846b4 = []byte{
+ // 563 bytes of a gzipped FileDescriptorProto
+ 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xc4, 0x54, 0xcf, 0x6e, 0xd3, 0x30,
+ 0x1c, 0x6e, 0x28, 0x14, 0xf0, 0x28, 0xdd, 0xa2, 0x31, 0x95, 0x6a, 0x4a, 0x90, 0xa5, 0x21, 0x90,
+ 0x58, 0xc2, 0x06, 0xd2, 0x24, 0x4e, 0xac, 0x43, 0x13, 0x97, 0x1e, 0x88, 0x76, 0x42, 0x93, 0x2a,
+ 0x27, 0xf1, 0xb2, 0x88, 0xc5, 0x2e, 0xb1, 0xbb, 0xae, 0x6f, 0xc1, 0x85, 0x67, 0xe0, 0x35, 0x38,
+ 0xa1, 0x1d, 0x77, 0xe4, 0x14, 0xa1, 0xf6, 0x0d, 0xf2, 0x04, 0xc8, 0x7f, 0xda, 0x24, 0x9b, 0xc4,
+ 0xda, 0x13, 0xb7, 0xc4, 0xbf, 0xef, 0xfb, 0xfc, 0xfb, 0x7e, 0xfe, 0x6c, 0xb0, 0x45, 0x59, 0x42,
+ 0x59, 0xcc, 0x5c, 0x4e, 0xbf, 0x60, 0x72, 0x82, 0x02, 0x4e, 0xd3, 0xb1, 0x7b, 0xbe, 0xe3, 0x63,
+ 0x8e, 0x76, 0x5c, 0x7e, 0xe1, 0x0c, 0x52, 0xca, 0xa9, 0xb9, 0xa9, 0x61, 0x4e, 0x19, 0xe6, 0x68,
+ 0x58, 0x67, 0x3d, 0xa2, 0x11, 0x95, 0x40, 0x57, 0x7c, 0x29, 0x4e, 0xc7, 0x0a, 0x24, 0xc9, 0xf5,
+ 0x11, 0xc3, 0x73, 0xc5, 0x80, 0xc6, 0x44, 0xd5, 0x61, 0x00, 0x1e, 0xf7, 0x58, 0x74, 0x90, 0x62,
+ 0xc4, 0xf1, 0x07, 0x4c, 0x68, 0x62, 0xbe, 0x04, 0x0d, 0x86, 0x49, 0x88, 0xd3, 0xb6, 0xf1, 0xcc,
+ 0x78, 0xf1, 0xb0, 0xbb, 0x96, 0x67, 0x76, 0x73, 0x8c, 0x92, 0xb3, 0x77, 0x50, 0xad, 0x43, 0x4f,
+ 0x03, 0xcc, 0xe7, 0xe0, 0x1e, 0xa1, 0x24, 0xc0, 0xed, 0x3b, 0x12, 0xb9, 0x9a, 0x67, 0xf6, 0x23,
+ 0x85, 0x94, 0xcb, 0xd0, 0x53, 0x65, 0x78, 0x0c, 0x36, 0xaa, 0x9b, 0x78, 0x98, 0x0d, 0x28, 0x61,
+ 0xd8, 0xec, 0x82, 0x16, 0xc1, 0xa3, 0xbe, 0x34, 0xd4, 0x0f, 0x45, 0x49, 0xef, 0xda, 0xc9, 0x33,
+ 0x7b, 0x43, 0x6b, 0x55, 0x01, 0xd0, 0x6b, 0x12, 0x3c, 0x3a, 0x12, 0x0b, 0x52, 0x0b, 0xfe, 0x34,
+ 0xc0, 0xfd, 0x1e, 0x8b, 0x7a, 0x31, 0xe1, 0xcb, 0x34, 0xff, 0x11, 0x34, 0x50, 0x42, 0x87, 0x84,
+ 0xcb, 0xee, 0x57, 0x76, 0x9f, 0x3a, 0x6a, 0x54, 0x8e, 0x18, 0xd5, 0x6c, 0xaa, 0xce, 0x01, 0x8d,
+ 0x49, 0xf7, 0xc9, 0x65, 0x66, 0xd7, 0x0a, 0x25, 0x45, 0x83, 0x9e, 0xe6, 0x9b, 0xef, 0x41, 0x33,
+ 0x89, 0x09, 0x3f, 0xa2, 0xfb, 0x61, 0x98, 0x62, 0xc6, 0xda, 0xf5, 0xeb, 0x16, 0x44, 0xb9, 0xcf,
+ 0x69, 0x1f, 0x29, 0x00, 0xf4, 0xaa, 0x04, 0xb8, 0x06, 0x5a, 0xda, 0xc1, 0x6c, 0x32, 0xf0, 0x97,
+ 0x72, 0xd5, 0x1d, 0xa6, 0xe4, 0xff, 0xb8, 0x3a, 0x04, 0x2d, 0x7f, 0x98, 0x92, 0xc3, 0x94, 0x26,
+ 0x55, 0x5f, 0x9b, 0x79, 0x66, 0xb7, 0x15, 0x47, 0x00, 0xfa, 0x27, 0x29, 0x4d, 0x0a, 0x67, 0xd7,
+ 0x49, 0xda, 0x9b, 0xf0, 0x31, 0xf7, 0xf6, 0xdd, 0x50, 0xa9, 0x3b, 0x45, 0x24, 0xc2, 0xfb, 0x61,
+ 0x12, 0x93, 0x25, 0x53, 0xa7, 0x92, 0x72, 0x23, 0x75, 0x3a, 0x1f, 0xaa, 0x6c, 0xbe, 0x06, 0x0f,
+ 0x08, 0x1e, 0x49, 0x79, 0xdd, 0xf9, 0x7a, 0x9e, 0xd9, 0xab, 0x45, 0xa8, 0x90, 0x28, 0x41, 0x6f,
+ 0x8e, 0x82, 0x6d, 0x95, 0xd3, 0xa2, 0xad, 0x59, 0xc7, 0xbb, 0x3f, 0xea, 0xa0, 0xde, 0x63, 0x91,
+ 0xf9, 0x15, 0xac, 0x94, 0xef, 0xca, 0x2b, 0xe7, 0x5f, 0x57, 0xd2, 0xa9, 0x86, 0xbe, 0xf3, 0x76,
+ 0x19, 0xf4, 0xfc, 0x8a, 0x1c, 0x83, 0xbb, 0x32, 0xda, 0x5b, 0xb7, 0xb2, 0x05, 0xac, 0xb3, 0xbd,
+ 0x10, 0xac, 0xac, 0x2e, 0x23, 0x76, 0xbb, 0xba, 0x80, 0x2d, 0xa0, 0x5e, 0x3e, 0x68, 0x39, 0xae,
+ 0xd2, 0x21, 0x2f, 0x30, 0xae, 0x02, 0xbd, 0xc8, 0xb8, 0x6e, 0x9e, 0x54, 0xf7, 0xd3, 0xe5, 0xc4,
+ 0x32, 0xae, 0x26, 0x96, 0xf1, 0x67, 0x62, 0x19, 0xdf, 0xa6, 0x56, 0xed, 0x6a, 0x6a, 0xd5, 0x7e,
+ 0x4f, 0xad, 0xda, 0xe7, 0xbd, 0x28, 0xe6, 0xa7, 0x43, 0xdf, 0x09, 0x68, 0xe2, 0x6a, 0xe5, 0xed,
+ 0x33, 0xe4, 0xb3, 0xd9, 0x8f, 0x7b, 0xbe, 0xe7, 0x5e, 0x54, 0x9f, 0x60, 0x3e, 0x1e, 0x60, 0xe6,
+ 0x37, 0xe4, 0x53, 0xf9, 0xe6, 0x6f, 0x00, 0x00, 0x00, 0xff, 0xff, 0x6b, 0x4a, 0x5e, 0xb4, 0xa7,
+ 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
+
+// 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)
+ // ForceTransfer is deactivated for now because we need to think through edge
+ // cases rpc ForceTransfer(MsgForceTransfer) returns
+ // (MsgForceTransferResponse);
+ ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, 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
+}
+
+// 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)
+ // ForceTransfer is deactivated for now because we need to think through edge
+ // cases rpc ForceTransfer(MsgForceTransfer) returns
+ // (MsgForceTransferResponse);
+ ChangeAdmin(context.Context, *MsgChangeAdmin) (*MsgChangeAdminResponse, 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 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)
+}
+
+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,
+ },
+ },
+ 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.Nonce) > 0 {
+ i -= len(m.Nonce)
+ copy(dAtA[i:], m.Nonce)
+ i = encodeVarintTx(dAtA, i, uint64(len(m.Nonce)))
+ 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 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.Nonce)
+ 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 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 Nonce", 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.Nonce = 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 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")
+)