diff --git a/docs/static/openapi.yml b/docs/static/openapi.yml index 617e7a46..3488d787 100644 --- a/docs/static/openapi.yml +++ b/docs/static/openapi.yml @@ -32344,6 +32344,8 @@ definitions: title: 'Can be empty for no admin, or a valid osmosis address' bze.tokenfactory.v1.MsgBurnResponse: type: object + bze.tokenfactory.v1.MsgChangeAdminResponse: + type: object bze.tokenfactory.v1.MsgCreateDenomResponse: type: object properties: @@ -32351,6 +32353,8 @@ definitions: type: string bze.tokenfactory.v1.MsgMintResponse: type: object + bze.tokenfactory.v1.MsgSetDenomMetadataResponse: + type: object bze.tokenfactory.v1.Params: type: object properties: @@ -32376,6 +32380,100 @@ definitions: createDenomFee: type: string description: QueryParamsResponse is response type for the Query/Params RPC method. + cosmos.bank.v1beta1.DenomUnit: + type: object + properties: + denom: + type: string + description: denom represents the string name of the given denom unit (e.g uatom). + exponent: + type: integer + format: int64 + description: >- + exponent represents power of 10 exponent that one must + + raise the base_denom to in order to equal the given DenomUnit's denom + + 1 denom = 1^exponent base_denom + + (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' + with + + exponent = 6, thus: 1 atom = 10^6 uatom). + aliases: + type: array + items: + type: string + title: aliases is a list of string aliases for the given denom + description: |- + DenomUnit represents a struct that describes a given + denomination unit of the basic token. + cosmos.bank.v1beta1.Metadata: + type: object + properties: + description: + type: string + denom_units: + type: array + items: + type: object + properties: + denom: + type: string + description: >- + denom represents the string name of the given denom unit (e.g + uatom). + exponent: + type: integer + format: int64 + description: >- + exponent represents power of 10 exponent that one must + + raise the base_denom to in order to equal the given DenomUnit's + denom + + 1 denom = 1^exponent base_denom + + (e.g. with a base_denom of uatom, one can create a DenomUnit of + 'atom' with + + exponent = 6, thus: 1 atom = 10^6 uatom). + aliases: + type: array + items: + type: string + title: aliases is a list of string aliases for the given denom + description: |- + DenomUnit represents a struct that describes a given + denomination unit of the basic token. + title: denom_units represents the list of DenomUnit's for a given coin + base: + type: string + description: >- + base represents the base denom (should be the DenomUnit with exponent + = 0). + display: + type: string + description: |- + display indicates the suggested denom that should be + displayed in clients. + name: + type: string + description: 'Since: cosmos-sdk 0.43' + title: 'name defines the name of the token (eg: Cosmos Atom)' + symbol: + type: string + description: >- + symbol is the token symbol usually shown on exchanges (eg: ATOM). This + can + + be the same as the display. + + + Since: cosmos-sdk 0.43 + description: |- + Metadata represents a struct that describes + a basic token. cosmos.auth.v1beta1.Params: type: object properties: @@ -33811,34 +33909,6 @@ definitions: description: >- QueryGrantsResponse is the response type for the Query/Authorizations RPC method. - cosmos.bank.v1beta1.DenomUnit: - type: object - properties: - denom: - type: string - description: denom represents the string name of the given denom unit (e.g uatom). - exponent: - type: integer - format: int64 - description: >- - exponent represents power of 10 exponent that one must - - raise the base_denom to in order to equal the given DenomUnit's denom - - 1 denom = 1^exponent base_denom - - (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' - with - - exponent = 6, thus: 1 atom = 10^6 uatom). - aliases: - type: array - items: - type: string - title: aliases is a list of string aliases for the given denom - description: |- - DenomUnit represents a struct that describes a given - denomination unit of the basic token. cosmos.bank.v1beta1.Input: type: object properties: @@ -33859,72 +33929,6 @@ definitions: NOTE: The amount field is an Int which implements the custom method signatures required by gogoproto. description: Input models transaction input. - cosmos.bank.v1beta1.Metadata: - type: object - properties: - description: - type: string - denom_units: - type: array - items: - type: object - properties: - denom: - type: string - description: >- - denom represents the string name of the given denom unit (e.g - uatom). - exponent: - type: integer - format: int64 - description: >- - exponent represents power of 10 exponent that one must - - raise the base_denom to in order to equal the given DenomUnit's - denom - - 1 denom = 1^exponent base_denom - - (e.g. with a base_denom of uatom, one can create a DenomUnit of - 'atom' with - - exponent = 6, thus: 1 atom = 10^6 uatom). - aliases: - type: array - items: - type: string - title: aliases is a list of string aliases for the given denom - description: |- - DenomUnit represents a struct that describes a given - denomination unit of the basic token. - title: denom_units represents the list of DenomUnit's for a given coin - base: - type: string - description: >- - base represents the base denom (should be the DenomUnit with exponent - = 0). - display: - type: string - description: |- - display indicates the suggested denom that should be - displayed in clients. - name: - type: string - description: 'Since: cosmos-sdk 0.43' - title: 'name defines the name of the token (eg: Cosmos Atom)' - symbol: - type: string - description: >- - symbol is the token symbol usually shown on exchanges (eg: ATOM). This - can - - be the same as the display. - - - Since: cosmos-sdk 0.43 - description: |- - Metadata represents a struct that describes - a basic token. cosmos.bank.v1beta1.MsgMultiSendResponse: type: object description: MsgMultiSendResponse defines the Msg/MultiSend response type. diff --git a/proto/tokenfactory/tx.proto b/proto/tokenfactory/tx.proto index ae75ee76..d386752b 100644 --- a/proto/tokenfactory/tx.proto +++ b/proto/tokenfactory/tx.proto @@ -1,6 +1,9 @@ syntax = "proto3"; package bze.tokenfactory.v1; +import "gogoproto/gogo.proto"; +import "cosmos/bank/v1beta1/bank.proto"; + // this line is used by starport scaffolding # proto/tx/import option go_package = "github.com/bze-alphateam/bze/x/tokenfactory/types"; @@ -10,6 +13,8 @@ service Msg { rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse); rpc Mint(MsgMint) returns (MsgMintResponse); rpc Burn(MsgBurn) returns (MsgBurnResponse); + rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse); + rpc SetDenomMetadata(MsgSetDenomMetadata) returns (MsgSetDenomMetadataResponse); // this line is used by starport scaffolding # proto/tx/rpc } @@ -38,4 +43,24 @@ message MsgBurn { message MsgBurnResponse { } +message MsgChangeAdmin { + string creator = 1; + string denom = 2; + string newAdmin = 3; +} + +message MsgChangeAdminResponse { +} + +message MsgSetDenomMetadata { + string creator = 1; + cosmos.bank.v1beta1.Metadata metadata = 2 [ + (gogoproto.moretags) = "yaml:\"metadata\"", + (gogoproto.nullable) = false + ]; +} + +message MsgSetDenomMetadataResponse { +} + // this line is used by starport scaffolding # proto/tx/message diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/index.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/index.ts index f727366d..4abfa08a 100755 --- a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/index.ts +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/index.ts @@ -168,6 +168,36 @@ export default { }, + async sendMsgCreateDenom({ rootGetters }, { value, fee = [], memo = '' }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgCreateDenom(value) + const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, + gas: "200000" }, memo}) + return result + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgCreateDenom:Init Could not initialize signing client. Wallet is required.') + }else{ + throw new Error('TxClient:MsgCreateDenom:Send Could not broadcast Tx: '+ e.message) + } + } + }, + async sendMsgMint({ rootGetters }, { value, fee = [], memo = '' }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgMint(value) + const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, + gas: "200000" }, memo}) + return result + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgMint:Init Could not initialize signing client. Wallet is required.') + }else{ + throw new Error('TxClient:MsgMint:Send Could not broadcast Tx: '+ e.message) + } + } + }, async sendMsgBurn({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) @@ -183,37 +213,63 @@ export default { } } }, - async sendMsgCreateDenom({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgSetDenomMetadata({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreateDenom(value) + const msg = await txClient.msgSetDenomMetadata(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreateDenom:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgSetDenomMetadata:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgCreateDenom:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgSetDenomMetadata:Send Could not broadcast Tx: '+ e.message) } } }, - async sendMsgMint({ rootGetters }, { value, fee = [], memo = '' }) { + async sendMsgChangeAdmin({ rootGetters }, { value, fee = [], memo = '' }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgMint(value) + const msg = await txClient.msgChangeAdmin(value) const result = await txClient.signAndBroadcast([msg], {fee: { amount: fee, gas: "200000" }, memo}) return result } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgMint:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgChangeAdmin:Init Could not initialize signing client. Wallet is required.') }else{ - throw new Error('TxClient:MsgMint:Send Could not broadcast Tx: '+ e.message) + throw new Error('TxClient:MsgChangeAdmin:Send Could not broadcast Tx: '+ e.message) } } }, + async MsgCreateDenom({ rootGetters }, { value }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgCreateDenom(value) + return msg + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgCreateDenom:Init Could not initialize signing client. Wallet is required.') + } else{ + throw new Error('TxClient:MsgCreateDenom:Create Could not create message: ' + e.message) + } + } + }, + async MsgMint({ rootGetters }, { value }) { + try { + const txClient=await initTxClient(rootGetters) + const msg = await txClient.msgMint(value) + return msg + } catch (e) { + if (e == MissingWalletError) { + throw new Error('TxClient:MsgMint:Init Could not initialize signing client. Wallet is required.') + } else{ + throw new Error('TxClient:MsgMint:Create Could not create message: ' + e.message) + } + } + }, async MsgBurn({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) @@ -227,29 +283,29 @@ export default { } } }, - async MsgCreateDenom({ rootGetters }, { value }) { + async MsgSetDenomMetadata({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgCreateDenom(value) + const msg = await txClient.msgSetDenomMetadata(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgCreateDenom:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgSetDenomMetadata:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgCreateDenom:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgSetDenomMetadata:Create Could not create message: ' + e.message) } } }, - async MsgMint({ rootGetters }, { value }) { + async MsgChangeAdmin({ rootGetters }, { value }) { try { const txClient=await initTxClient(rootGetters) - const msg = await txClient.msgMint(value) + const msg = await txClient.msgChangeAdmin(value) return msg } catch (e) { if (e == MissingWalletError) { - throw new Error('TxClient:MsgMint:Init Could not initialize signing client. Wallet is required.') + throw new Error('TxClient:MsgChangeAdmin:Init Could not initialize signing client. Wallet is required.') } else{ - throw new Error('TxClient:MsgMint:Create Could not create message: ' + e.message) + throw new Error('TxClient:MsgChangeAdmin:Create Could not create message: ' + e.message) } } }, diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/index.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/index.ts index 1ec89d83..607cdc12 100755 --- a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/index.ts +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/index.ts @@ -4,15 +4,19 @@ import { StdFee } from "@cosmjs/launchpad"; import { SigningStargateClient } from "@cosmjs/stargate"; import { Registry, OfflineSigner, EncodeObject, DirectSecp256k1HdWallet } from "@cosmjs/proto-signing"; import { Api } from "./rest"; -import { MsgBurn } from "./types/tokenfactory/tx"; import { MsgCreateDenom } from "./types/tokenfactory/tx"; import { MsgMint } from "./types/tokenfactory/tx"; +import { MsgBurn } from "./types/tokenfactory/tx"; +import { MsgSetDenomMetadata } from "./types/tokenfactory/tx"; +import { MsgChangeAdmin } from "./types/tokenfactory/tx"; const types = [ - ["/bze.tokenfactory.v1.MsgBurn", MsgBurn], ["/bze.tokenfactory.v1.MsgCreateDenom", MsgCreateDenom], ["/bze.tokenfactory.v1.MsgMint", MsgMint], + ["/bze.tokenfactory.v1.MsgBurn", MsgBurn], + ["/bze.tokenfactory.v1.MsgSetDenomMetadata", MsgSetDenomMetadata], + ["/bze.tokenfactory.v1.MsgChangeAdmin", MsgChangeAdmin], ]; export const MissingWalletError = new Error("wallet is required"); @@ -45,9 +49,11 @@ const txClient = async (wallet: OfflineSigner, { addr: addr }: TxClientOptions = return { signAndBroadcast: (msgs: EncodeObject[], { fee, memo }: SignAndBroadcastOptions = {fee: defaultFee, memo: ""}) => client.signAndBroadcast(address, msgs, fee,memo), - msgBurn: (data: MsgBurn): EncodeObject => ({ typeUrl: "/bze.tokenfactory.v1.MsgBurn", value: MsgBurn.fromPartial( data ) }), msgCreateDenom: (data: MsgCreateDenom): EncodeObject => ({ typeUrl: "/bze.tokenfactory.v1.MsgCreateDenom", value: MsgCreateDenom.fromPartial( data ) }), msgMint: (data: MsgMint): EncodeObject => ({ typeUrl: "/bze.tokenfactory.v1.MsgMint", value: MsgMint.fromPartial( data ) }), + msgBurn: (data: MsgBurn): EncodeObject => ({ typeUrl: "/bze.tokenfactory.v1.MsgBurn", value: MsgBurn.fromPartial( data ) }), + msgSetDenomMetadata: (data: MsgSetDenomMetadata): EncodeObject => ({ typeUrl: "/bze.tokenfactory.v1.MsgSetDenomMetadata", value: MsgSetDenomMetadata.fromPartial( data ) }), + msgChangeAdmin: (data: MsgChangeAdmin): EncodeObject => ({ typeUrl: "/bze.tokenfactory.v1.MsgChangeAdmin", value: MsgChangeAdmin.fromPartial( data ) }), }; }; diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/rest.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/rest.ts index 88843eb9..9ec73818 100644 --- a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/rest.ts +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/rest.ts @@ -33,12 +33,16 @@ export interface Tokenfactoryv1Params { export type V1MsgBurnResponse = object; +export type V1MsgChangeAdminResponse = object; + export interface V1MsgCreateDenomResponse { new_denom?: string; } export type V1MsgMintResponse = object; +export type V1MsgSetDenomMetadataResponse = object; + export interface V1QueryDenomAuthorityResponse { denomAuthority?: Tokenfactoryv1DenomAuthority; } @@ -51,6 +55,55 @@ export interface V1QueryParamsResponse { params?: Tokenfactoryv1Params; } +/** +* DenomUnit represents a struct that describes a given +denomination unit of the basic token. +*/ +export interface V1Beta1DenomUnit { + /** denom represents the string name of the given denom unit (e.g uatom). */ + denom?: string; + + /** + * exponent represents power of 10 exponent that one must + * raise the base_denom to in order to equal the given DenomUnit's denom + * 1 denom = 1^exponent base_denom + * (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with + * exponent = 6, thus: 1 atom = 10^6 uatom). + * @format int64 + */ + exponent?: number; + aliases?: string[]; +} + +/** +* Metadata represents a struct that describes +a basic token. +*/ +export interface V1Beta1Metadata { + description?: string; + denom_units?: V1Beta1DenomUnit[]; + + /** base represents the base denom (should be the DenomUnit with exponent = 0). */ + base?: string; + + /** + * display indicates the suggested denom that should be + * displayed in clients. + */ + display?: string; + + /** Since: cosmos-sdk 0.43 */ + name?: string; + + /** + * symbol is the token symbol usually shown on exchanges (eg: ATOM). This can + * be the same as the display. + * + * Since: cosmos-sdk 0.43 + */ + symbol?: string; +} + export type QueryParamsType = Record; export type ResponseFormat = keyof Omit; diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos/bank/v1beta1/bank.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos/bank/v1beta1/bank.ts new file mode 100644 index 00000000..87339324 --- /dev/null +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos/bank/v1beta1/bank.ts @@ -0,0 +1,737 @@ +/* eslint-disable */ +import { Coin } from "../../../cosmos/base/v1beta1/coin"; +import { Writer, Reader } from "protobufjs/minimal"; + +export const protobufPackage = "cosmos.bank.v1beta1"; + +/** Params defines the parameters for the bank module. */ +export interface Params { + send_enabled: SendEnabled[]; + default_send_enabled: boolean; +} + +/** + * SendEnabled maps coin denom to a send_enabled status (whether a denom is + * sendable). + */ +export interface SendEnabled { + denom: string; + enabled: boolean; +} + +/** Input models transaction input. */ +export interface Input { + address: string; + coins: Coin[]; +} + +/** Output models transaction outputs. */ +export interface Output { + address: string; + coins: Coin[]; +} + +/** + * Supply represents a struct that passively keeps track of the total supply + * amounts in the network. + * This message is deprecated now that supply is indexed by denom. + * + * @deprecated + */ +export interface Supply { + total: Coin[]; +} + +/** + * DenomUnit represents a struct that describes a given + * denomination unit of the basic token. + */ +export interface DenomUnit { + /** denom represents the string name of the given denom unit (e.g uatom). */ + denom: string; + /** + * exponent represents power of 10 exponent that one must + * raise the base_denom to in order to equal the given DenomUnit's denom + * 1 denom = 1^exponent base_denom + * (e.g. with a base_denom of uatom, one can create a DenomUnit of 'atom' with + * exponent = 6, thus: 1 atom = 10^6 uatom). + */ + exponent: number; + /** aliases is a list of string aliases for the given denom */ + aliases: string[]; +} + +/** + * Metadata represents a struct that describes + * a basic token. + */ +export interface Metadata { + description: string; + /** denom_units represents the list of DenomUnit's for a given coin */ + denom_units: DenomUnit[]; + /** base represents the base denom (should be the DenomUnit with exponent = 0). */ + base: string; + /** + * display indicates the suggested denom that should be + * displayed in clients. + */ + display: string; + /** + * name defines the name of the token (eg: Cosmos Atom) + * + * Since: cosmos-sdk 0.43 + */ + name: string; + /** + * symbol is the token symbol usually shown on exchanges (eg: ATOM). This can + * be the same as the display. + * + * Since: cosmos-sdk 0.43 + */ + symbol: string; +} + +const baseParams: object = { default_send_enabled: false }; + +export const Params = { + encode(message: Params, writer: Writer = Writer.create()): Writer { + for (const v of message.send_enabled) { + SendEnabled.encode(v!, writer.uint32(10).fork()).ldelim(); + } + if (message.default_send_enabled === true) { + writer.uint32(16).bool(message.default_send_enabled); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Params { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseParams } as Params; + message.send_enabled = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.send_enabled.push( + SendEnabled.decode(reader, reader.uint32()) + ); + break; + case 2: + message.default_send_enabled = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Params { + const message = { ...baseParams } as Params; + message.send_enabled = []; + if (object.send_enabled !== undefined && object.send_enabled !== null) { + for (const e of object.send_enabled) { + message.send_enabled.push(SendEnabled.fromJSON(e)); + } + } + if ( + object.default_send_enabled !== undefined && + object.default_send_enabled !== null + ) { + message.default_send_enabled = Boolean(object.default_send_enabled); + } else { + message.default_send_enabled = false; + } + return message; + }, + + toJSON(message: Params): unknown { + const obj: any = {}; + if (message.send_enabled) { + obj.send_enabled = message.send_enabled.map((e) => + e ? SendEnabled.toJSON(e) : undefined + ); + } else { + obj.send_enabled = []; + } + message.default_send_enabled !== undefined && + (obj.default_send_enabled = message.default_send_enabled); + return obj; + }, + + fromPartial(object: DeepPartial): Params { + const message = { ...baseParams } as Params; + message.send_enabled = []; + if (object.send_enabled !== undefined && object.send_enabled !== null) { + for (const e of object.send_enabled) { + message.send_enabled.push(SendEnabled.fromPartial(e)); + } + } + if ( + object.default_send_enabled !== undefined && + object.default_send_enabled !== null + ) { + message.default_send_enabled = object.default_send_enabled; + } else { + message.default_send_enabled = false; + } + return message; + }, +}; + +const baseSendEnabled: object = { denom: "", enabled: false }; + +export const SendEnabled = { + encode(message: SendEnabled, writer: Writer = Writer.create()): Writer { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.enabled === true) { + writer.uint32(16).bool(message.enabled); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): SendEnabled { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseSendEnabled } as SendEnabled; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.enabled = reader.bool(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): SendEnabled { + const message = { ...baseSendEnabled } as SendEnabled; + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + if (object.enabled !== undefined && object.enabled !== null) { + message.enabled = Boolean(object.enabled); + } else { + message.enabled = false; + } + return message; + }, + + toJSON(message: SendEnabled): unknown { + const obj: any = {}; + message.denom !== undefined && (obj.denom = message.denom); + message.enabled !== undefined && (obj.enabled = message.enabled); + return obj; + }, + + fromPartial(object: DeepPartial): SendEnabled { + const message = { ...baseSendEnabled } as SendEnabled; + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + if (object.enabled !== undefined && object.enabled !== null) { + message.enabled = object.enabled; + } else { + message.enabled = false; + } + return message; + }, +}; + +const baseInput: object = { address: "" }; + +export const Input = { + encode(message: Input, writer: Writer = Writer.create()): Writer { + if (message.address !== "") { + writer.uint32(10).string(message.address); + } + for (const v of message.coins) { + Coin.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Input { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseInput } as Input; + message.coins = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.address = reader.string(); + break; + case 2: + message.coins.push(Coin.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Input { + const message = { ...baseInput } as Input; + message.coins = []; + if (object.address !== undefined && object.address !== null) { + message.address = String(object.address); + } else { + message.address = ""; + } + if (object.coins !== undefined && object.coins !== null) { + for (const e of object.coins) { + message.coins.push(Coin.fromJSON(e)); + } + } + return message; + }, + + toJSON(message: Input): unknown { + const obj: any = {}; + message.address !== undefined && (obj.address = message.address); + if (message.coins) { + obj.coins = message.coins.map((e) => (e ? Coin.toJSON(e) : undefined)); + } else { + obj.coins = []; + } + return obj; + }, + + fromPartial(object: DeepPartial): Input { + const message = { ...baseInput } as Input; + message.coins = []; + if (object.address !== undefined && object.address !== null) { + message.address = object.address; + } else { + message.address = ""; + } + if (object.coins !== undefined && object.coins !== null) { + for (const e of object.coins) { + message.coins.push(Coin.fromPartial(e)); + } + } + return message; + }, +}; + +const baseOutput: object = { address: "" }; + +export const Output = { + encode(message: Output, writer: Writer = Writer.create()): Writer { + if (message.address !== "") { + writer.uint32(10).string(message.address); + } + for (const v of message.coins) { + Coin.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Output { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseOutput } as Output; + message.coins = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.address = reader.string(); + break; + case 2: + message.coins.push(Coin.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Output { + const message = { ...baseOutput } as Output; + message.coins = []; + if (object.address !== undefined && object.address !== null) { + message.address = String(object.address); + } else { + message.address = ""; + } + if (object.coins !== undefined && object.coins !== null) { + for (const e of object.coins) { + message.coins.push(Coin.fromJSON(e)); + } + } + return message; + }, + + toJSON(message: Output): unknown { + const obj: any = {}; + message.address !== undefined && (obj.address = message.address); + if (message.coins) { + obj.coins = message.coins.map((e) => (e ? Coin.toJSON(e) : undefined)); + } else { + obj.coins = []; + } + return obj; + }, + + fromPartial(object: DeepPartial): Output { + const message = { ...baseOutput } as Output; + message.coins = []; + if (object.address !== undefined && object.address !== null) { + message.address = object.address; + } else { + message.address = ""; + } + if (object.coins !== undefined && object.coins !== null) { + for (const e of object.coins) { + message.coins.push(Coin.fromPartial(e)); + } + } + return message; + }, +}; + +const baseSupply: object = {}; + +export const Supply = { + encode(message: Supply, writer: Writer = Writer.create()): Writer { + for (const v of message.total) { + Coin.encode(v!, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Supply { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseSupply } as Supply; + message.total = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.total.push(Coin.decode(reader, reader.uint32())); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Supply { + const message = { ...baseSupply } as Supply; + message.total = []; + if (object.total !== undefined && object.total !== null) { + for (const e of object.total) { + message.total.push(Coin.fromJSON(e)); + } + } + return message; + }, + + toJSON(message: Supply): unknown { + const obj: any = {}; + if (message.total) { + obj.total = message.total.map((e) => (e ? Coin.toJSON(e) : undefined)); + } else { + obj.total = []; + } + return obj; + }, + + fromPartial(object: DeepPartial): Supply { + const message = { ...baseSupply } as Supply; + message.total = []; + if (object.total !== undefined && object.total !== null) { + for (const e of object.total) { + message.total.push(Coin.fromPartial(e)); + } + } + return message; + }, +}; + +const baseDenomUnit: object = { denom: "", exponent: 0, aliases: "" }; + +export const DenomUnit = { + encode(message: DenomUnit, writer: Writer = Writer.create()): Writer { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.exponent !== 0) { + writer.uint32(16).uint32(message.exponent); + } + for (const v of message.aliases) { + writer.uint32(26).string(v!); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): DenomUnit { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseDenomUnit } as DenomUnit; + message.aliases = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.exponent = reader.uint32(); + break; + case 3: + message.aliases.push(reader.string()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): DenomUnit { + const message = { ...baseDenomUnit } as DenomUnit; + message.aliases = []; + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + if (object.exponent !== undefined && object.exponent !== null) { + message.exponent = Number(object.exponent); + } else { + message.exponent = 0; + } + if (object.aliases !== undefined && object.aliases !== null) { + for (const e of object.aliases) { + message.aliases.push(String(e)); + } + } + return message; + }, + + toJSON(message: DenomUnit): unknown { + const obj: any = {}; + message.denom !== undefined && (obj.denom = message.denom); + message.exponent !== undefined && (obj.exponent = message.exponent); + if (message.aliases) { + obj.aliases = message.aliases.map((e) => e); + } else { + obj.aliases = []; + } + return obj; + }, + + fromPartial(object: DeepPartial): DenomUnit { + const message = { ...baseDenomUnit } as DenomUnit; + message.aliases = []; + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + if (object.exponent !== undefined && object.exponent !== null) { + message.exponent = object.exponent; + } else { + message.exponent = 0; + } + if (object.aliases !== undefined && object.aliases !== null) { + for (const e of object.aliases) { + message.aliases.push(e); + } + } + return message; + }, +}; + +const baseMetadata: object = { + description: "", + base: "", + display: "", + name: "", + symbol: "", +}; + +export const Metadata = { + encode(message: Metadata, writer: Writer = Writer.create()): Writer { + if (message.description !== "") { + writer.uint32(10).string(message.description); + } + for (const v of message.denom_units) { + DenomUnit.encode(v!, writer.uint32(18).fork()).ldelim(); + } + if (message.base !== "") { + writer.uint32(26).string(message.base); + } + if (message.display !== "") { + writer.uint32(34).string(message.display); + } + if (message.name !== "") { + writer.uint32(42).string(message.name); + } + if (message.symbol !== "") { + writer.uint32(50).string(message.symbol); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Metadata { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMetadata } as Metadata; + message.denom_units = []; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.description = reader.string(); + break; + case 2: + message.denom_units.push(DenomUnit.decode(reader, reader.uint32())); + break; + case 3: + message.base = reader.string(); + break; + case 4: + message.display = reader.string(); + break; + case 5: + message.name = reader.string(); + break; + case 6: + message.symbol = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Metadata { + const message = { ...baseMetadata } as Metadata; + message.denom_units = []; + if (object.description !== undefined && object.description !== null) { + message.description = String(object.description); + } else { + message.description = ""; + } + if (object.denom_units !== undefined && object.denom_units !== null) { + for (const e of object.denom_units) { + message.denom_units.push(DenomUnit.fromJSON(e)); + } + } + if (object.base !== undefined && object.base !== null) { + message.base = String(object.base); + } else { + message.base = ""; + } + if (object.display !== undefined && object.display !== null) { + message.display = String(object.display); + } else { + message.display = ""; + } + if (object.name !== undefined && object.name !== null) { + message.name = String(object.name); + } else { + message.name = ""; + } + if (object.symbol !== undefined && object.symbol !== null) { + message.symbol = String(object.symbol); + } else { + message.symbol = ""; + } + return message; + }, + + toJSON(message: Metadata): unknown { + const obj: any = {}; + message.description !== undefined && + (obj.description = message.description); + if (message.denom_units) { + obj.denom_units = message.denom_units.map((e) => + e ? DenomUnit.toJSON(e) : undefined + ); + } else { + obj.denom_units = []; + } + message.base !== undefined && (obj.base = message.base); + message.display !== undefined && (obj.display = message.display); + message.name !== undefined && (obj.name = message.name); + message.symbol !== undefined && (obj.symbol = message.symbol); + return obj; + }, + + fromPartial(object: DeepPartial): Metadata { + const message = { ...baseMetadata } as Metadata; + message.denom_units = []; + if (object.description !== undefined && object.description !== null) { + message.description = object.description; + } else { + message.description = ""; + } + if (object.denom_units !== undefined && object.denom_units !== null) { + for (const e of object.denom_units) { + message.denom_units.push(DenomUnit.fromPartial(e)); + } + } + if (object.base !== undefined && object.base !== null) { + message.base = object.base; + } else { + message.base = ""; + } + if (object.display !== undefined && object.display !== null) { + message.display = object.display; + } else { + message.display = ""; + } + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } else { + message.name = ""; + } + if (object.symbol !== undefined && object.symbol !== null) { + message.symbol = object.symbol; + } else { + message.symbol = ""; + } + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos/base/v1beta1/coin.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos/base/v1beta1/coin.ts new file mode 100644 index 00000000..ce2ac984 --- /dev/null +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos/base/v1beta1/coin.ts @@ -0,0 +1,301 @@ +/* eslint-disable */ +import { Writer, Reader } from "protobufjs/minimal"; + +export const protobufPackage = "cosmos.base.v1beta1"; + +/** + * Coin defines a token with a denomination and an amount. + * + * NOTE: The amount field is an Int which implements the custom method + * signatures required by gogoproto. + */ +export interface Coin { + denom: string; + amount: string; +} + +/** + * DecCoin defines a token with a denomination and a decimal amount. + * + * NOTE: The amount field is an Dec which implements the custom method + * signatures required by gogoproto. + */ +export interface DecCoin { + denom: string; + amount: string; +} + +/** IntProto defines a Protobuf wrapper around an Int object. */ +export interface IntProto { + int: string; +} + +/** DecProto defines a Protobuf wrapper around a Dec object. */ +export interface DecProto { + dec: string; +} + +const baseCoin: object = { denom: "", amount: "" }; + +export const Coin = { + encode(message: Coin, writer: Writer = Writer.create()): Writer { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.amount !== "") { + writer.uint32(18).string(message.amount); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): Coin { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseCoin } as Coin; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.amount = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): Coin { + const message = { ...baseCoin } as Coin; + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + if (object.amount !== undefined && object.amount !== null) { + message.amount = String(object.amount); + } else { + message.amount = ""; + } + return message; + }, + + toJSON(message: Coin): unknown { + const obj: any = {}; + message.denom !== undefined && (obj.denom = message.denom); + message.amount !== undefined && (obj.amount = message.amount); + return obj; + }, + + fromPartial(object: DeepPartial): Coin { + const message = { ...baseCoin } as Coin; + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + if (object.amount !== undefined && object.amount !== null) { + message.amount = object.amount; + } else { + message.amount = ""; + } + return message; + }, +}; + +const baseDecCoin: object = { denom: "", amount: "" }; + +export const DecCoin = { + encode(message: DecCoin, writer: Writer = Writer.create()): Writer { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.amount !== "") { + writer.uint32(18).string(message.amount); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): DecCoin { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseDecCoin } as DecCoin; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.amount = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): DecCoin { + const message = { ...baseDecCoin } as DecCoin; + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + if (object.amount !== undefined && object.amount !== null) { + message.amount = String(object.amount); + } else { + message.amount = ""; + } + return message; + }, + + toJSON(message: DecCoin): unknown { + const obj: any = {}; + message.denom !== undefined && (obj.denom = message.denom); + message.amount !== undefined && (obj.amount = message.amount); + return obj; + }, + + fromPartial(object: DeepPartial): DecCoin { + const message = { ...baseDecCoin } as DecCoin; + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + if (object.amount !== undefined && object.amount !== null) { + message.amount = object.amount; + } else { + message.amount = ""; + } + return message; + }, +}; + +const baseIntProto: object = { int: "" }; + +export const IntProto = { + encode(message: IntProto, writer: Writer = Writer.create()): Writer { + if (message.int !== "") { + writer.uint32(10).string(message.int); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): IntProto { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseIntProto } as IntProto; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.int = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): IntProto { + const message = { ...baseIntProto } as IntProto; + if (object.int !== undefined && object.int !== null) { + message.int = String(object.int); + } else { + message.int = ""; + } + return message; + }, + + toJSON(message: IntProto): unknown { + const obj: any = {}; + message.int !== undefined && (obj.int = message.int); + return obj; + }, + + fromPartial(object: DeepPartial): IntProto { + const message = { ...baseIntProto } as IntProto; + if (object.int !== undefined && object.int !== null) { + message.int = object.int; + } else { + message.int = ""; + } + return message; + }, +}; + +const baseDecProto: object = { dec: "" }; + +export const DecProto = { + encode(message: DecProto, writer: Writer = Writer.create()): Writer { + if (message.dec !== "") { + writer.uint32(10).string(message.dec); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): DecProto { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseDecProto } as DecProto; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.dec = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): DecProto { + const message = { ...baseDecProto } as DecProto; + if (object.dec !== undefined && object.dec !== null) { + message.dec = String(object.dec); + } else { + message.dec = ""; + } + return message; + }, + + toJSON(message: DecProto): unknown { + const obj: any = {}; + message.dec !== undefined && (obj.dec = message.dec); + return obj; + }, + + fromPartial(object: DeepPartial): DecProto { + const message = { ...baseDecProto } as DecProto; + if (object.dec !== undefined && object.dec !== null) { + message.dec = object.dec; + } else { + message.dec = ""; + } + return message; + }, +}; + +type Builtin = Date | Function | Uint8Array | string | number | undefined; +export type DeepPartial = T extends Builtin + ? T + : T extends Array + ? Array> + : T extends ReadonlyArray + ? ReadonlyArray> + : T extends {} + ? { [K in keyof T]?: DeepPartial } + : Partial; diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos_proto/cosmos.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos_proto/cosmos.ts new file mode 100644 index 00000000..9ec67a12 --- /dev/null +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/cosmos_proto/cosmos.ts @@ -0,0 +1,2 @@ +/* eslint-disable */ +export const protobufPackage = "cosmos_proto"; diff --git a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/tokenfactory/tx.ts b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/tokenfactory/tx.ts index 7994def0..5bd32c35 100644 --- a/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/tokenfactory/tx.ts +++ b/vue/src/store/generated/bze-alphateam/bze/bze.tokenfactory.v1/module/types/tokenfactory/tx.ts @@ -1,5 +1,6 @@ /* eslint-disable */ import { Reader, Writer } from "protobufjs/minimal"; +import { Metadata } from "../cosmos/bank/v1beta1/bank"; export const protobufPackage = "bze.tokenfactory.v1"; @@ -26,6 +27,21 @@ export interface MsgBurn { export interface MsgBurnResponse {} +export interface MsgChangeAdmin { + creator: string; + denom: string; + newAdmin: string; +} + +export interface MsgChangeAdminResponse {} + +export interface MsgSetDenomMetadata { + creator: string; + metadata: Metadata | undefined; +} + +export interface MsgSetDenomMetadataResponse {} + const baseMsgCreateDenom: object = { creator: "", subdenom: "" }; export const MsgCreateDenom = { @@ -378,12 +394,273 @@ export const MsgBurnResponse = { }, }; +const baseMsgChangeAdmin: object = { creator: "", denom: "", newAdmin: "" }; + +export const MsgChangeAdmin = { + encode(message: MsgChangeAdmin, writer: Writer = Writer.create()): Writer { + if (message.creator !== "") { + writer.uint32(10).string(message.creator); + } + if (message.denom !== "") { + writer.uint32(18).string(message.denom); + } + if (message.newAdmin !== "") { + writer.uint32(26).string(message.newAdmin); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgChangeAdmin { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgChangeAdmin } as MsgChangeAdmin; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.creator = reader.string(); + break; + case 2: + message.denom = reader.string(); + break; + case 3: + message.newAdmin = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgChangeAdmin { + const message = { ...baseMsgChangeAdmin } as MsgChangeAdmin; + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + if (object.denom !== undefined && object.denom !== null) { + message.denom = String(object.denom); + } else { + message.denom = ""; + } + if (object.newAdmin !== undefined && object.newAdmin !== null) { + message.newAdmin = String(object.newAdmin); + } else { + message.newAdmin = ""; + } + return message; + }, + + toJSON(message: MsgChangeAdmin): unknown { + const obj: any = {}; + message.creator !== undefined && (obj.creator = message.creator); + message.denom !== undefined && (obj.denom = message.denom); + message.newAdmin !== undefined && (obj.newAdmin = message.newAdmin); + return obj; + }, + + fromPartial(object: DeepPartial): MsgChangeAdmin { + const message = { ...baseMsgChangeAdmin } as MsgChangeAdmin; + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } else { + message.denom = ""; + } + if (object.newAdmin !== undefined && object.newAdmin !== null) { + message.newAdmin = object.newAdmin; + } else { + message.newAdmin = ""; + } + return message; + }, +}; + +const baseMsgChangeAdminResponse: object = {}; + +export const MsgChangeAdminResponse = { + encode(_: MsgChangeAdminResponse, writer: Writer = Writer.create()): Writer { + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgChangeAdminResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgChangeAdminResponse } as MsgChangeAdminResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): MsgChangeAdminResponse { + const message = { ...baseMsgChangeAdminResponse } as MsgChangeAdminResponse; + return message; + }, + + toJSON(_: MsgChangeAdminResponse): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial(_: DeepPartial): MsgChangeAdminResponse { + const message = { ...baseMsgChangeAdminResponse } as MsgChangeAdminResponse; + return message; + }, +}; + +const baseMsgSetDenomMetadata: object = { creator: "" }; + +export const MsgSetDenomMetadata = { + encode( + message: MsgSetDenomMetadata, + writer: Writer = Writer.create() + ): Writer { + if (message.creator !== "") { + writer.uint32(10).string(message.creator); + } + if (message.metadata !== undefined) { + Metadata.encode(message.metadata, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + + decode(input: Reader | Uint8Array, length?: number): MsgSetDenomMetadata { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { ...baseMsgSetDenomMetadata } as MsgSetDenomMetadata; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.creator = reader.string(); + break; + case 2: + message.metadata = Metadata.decode(reader, reader.uint32()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(object: any): MsgSetDenomMetadata { + const message = { ...baseMsgSetDenomMetadata } as MsgSetDenomMetadata; + if (object.creator !== undefined && object.creator !== null) { + message.creator = String(object.creator); + } else { + message.creator = ""; + } + if (object.metadata !== undefined && object.metadata !== null) { + message.metadata = Metadata.fromJSON(object.metadata); + } else { + message.metadata = undefined; + } + return message; + }, + + toJSON(message: MsgSetDenomMetadata): unknown { + const obj: any = {}; + message.creator !== undefined && (obj.creator = message.creator); + message.metadata !== undefined && + (obj.metadata = message.metadata + ? Metadata.toJSON(message.metadata) + : undefined); + return obj; + }, + + fromPartial(object: DeepPartial): MsgSetDenomMetadata { + const message = { ...baseMsgSetDenomMetadata } as MsgSetDenomMetadata; + if (object.creator !== undefined && object.creator !== null) { + message.creator = object.creator; + } else { + message.creator = ""; + } + if (object.metadata !== undefined && object.metadata !== null) { + message.metadata = Metadata.fromPartial(object.metadata); + } else { + message.metadata = undefined; + } + return message; + }, +}; + +const baseMsgSetDenomMetadataResponse: object = {}; + +export const MsgSetDenomMetadataResponse = { + encode( + _: MsgSetDenomMetadataResponse, + writer: Writer = Writer.create() + ): Writer { + return writer; + }, + + decode( + input: Reader | Uint8Array, + length?: number + ): MsgSetDenomMetadataResponse { + const reader = input instanceof Uint8Array ? new Reader(input) : input; + let end = length === undefined ? reader.len : reader.pos + length; + const message = { + ...baseMsgSetDenomMetadataResponse, + } as MsgSetDenomMetadataResponse; + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + + fromJSON(_: any): MsgSetDenomMetadataResponse { + const message = { + ...baseMsgSetDenomMetadataResponse, + } as MsgSetDenomMetadataResponse; + return message; + }, + + toJSON(_: MsgSetDenomMetadataResponse): unknown { + const obj: any = {}; + return obj; + }, + + fromPartial( + _: DeepPartial + ): MsgSetDenomMetadataResponse { + const message = { + ...baseMsgSetDenomMetadataResponse, + } as MsgSetDenomMetadataResponse; + return message; + }, +}; + /** Msg defines the Msg service. */ export interface Msg { CreateDenom(request: MsgCreateDenom): Promise; Mint(request: MsgMint): Promise; - /** this line is used by starport scaffolding # proto/tx/rpc */ Burn(request: MsgBurn): Promise; + ChangeAdmin(request: MsgChangeAdmin): Promise; + /** this line is used by starport scaffolding # proto/tx/rpc */ + SetDenomMetadata( + request: MsgSetDenomMetadata + ): Promise; } export class MsgClientImpl implements Msg { @@ -414,6 +691,32 @@ export class MsgClientImpl implements Msg { const promise = this.rpc.request("bze.tokenfactory.v1.Msg", "Burn", data); return promise.then((data) => MsgBurnResponse.decode(new Reader(data))); } + + ChangeAdmin(request: MsgChangeAdmin): Promise { + const data = MsgChangeAdmin.encode(request).finish(); + const promise = this.rpc.request( + "bze.tokenfactory.v1.Msg", + "ChangeAdmin", + data + ); + return promise.then((data) => + MsgChangeAdminResponse.decode(new Reader(data)) + ); + } + + SetDenomMetadata( + request: MsgSetDenomMetadata + ): Promise { + const data = MsgSetDenomMetadata.encode(request).finish(); + const promise = this.rpc.request( + "bze.tokenfactory.v1.Msg", + "SetDenomMetadata", + data + ); + return promise.then((data) => + MsgSetDenomMetadataResponse.decode(new Reader(data)) + ); + } } interface Rpc { diff --git a/x/tokenfactory/client/cli/tx.go b/x/tokenfactory/client/cli/tx.go index 76c629cd..bd54a074 100644 --- a/x/tokenfactory/client/cli/tx.go +++ b/x/tokenfactory/client/cli/tx.go @@ -33,6 +33,8 @@ func GetTxCmd() *cobra.Command { cmd.AddCommand(CmdCreateDenom()) cmd.AddCommand(CmdMint()) cmd.AddCommand(CmdBurn()) + cmd.AddCommand(CmdChangeAdmin()) + cmd.AddCommand(CmdSetDenomMetadata()) // this line is used by starport scaffolding # 1 return cmd diff --git a/x/tokenfactory/client/cli/tx_change_admin.go b/x/tokenfactory/client/cli/tx_change_admin.go new file mode 100644 index 00000000..94d8ac14 --- /dev/null +++ b/x/tokenfactory/client/cli/tx_change_admin.go @@ -0,0 +1,44 @@ +package cli + +import ( + "strconv" + + "github.com/bze-alphateam/bze/x/tokenfactory/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/spf13/cobra" +) + +var _ = strconv.Itoa(0) + +func CmdChangeAdmin() *cobra.Command { + cmd := &cobra.Command{ + Use: "change-admin [denom] [new-admin]", + Short: "Broadcast message ChangeAdmin", + Args: cobra.ExactArgs(2), + RunE: func(cmd *cobra.Command, args []string) (err error) { + argDenom := args[0] + argNewAdmin := args[1] + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgChangeAdmin( + clientCtx.GetFromAddress().String(), + argDenom, + argNewAdmin, + ) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/tokenfactory/client/cli/tx_set_denom_metadata.go b/x/tokenfactory/client/cli/tx_set_denom_metadata.go new file mode 100644 index 00000000..27a8a99b --- /dev/null +++ b/x/tokenfactory/client/cli/tx_set_denom_metadata.go @@ -0,0 +1,68 @@ +package cli + +import ( + "strconv" + + "github.com/bze-alphateam/bze/x/tokenfactory/types" + "github.com/cosmos/cosmos-sdk/client" + "github.com/cosmos/cosmos-sdk/client/flags" + "github.com/cosmos/cosmos-sdk/client/tx" + "github.com/spf13/cobra" +) + +var _ = strconv.Itoa(0) + +// string description = 1; +// // denom_units represents the list of DenomUnit's for a given coin +// repeated DenomUnit denom_units = 2; +// // base represents the base denom (should be the DenomUnit with exponent = 0). +// string base = 3; +// // display indicates the suggested denom that should be +// // displayed in clients. +// string display = 4; +// // name defines the name of the token (eg: Cosmos Atom) +// // +// // Since: cosmos-sdk 0.43 +// string name = 5; +// // symbol is the token symbol usually shown on exchanges (eg: ATOM). This can +// // be the same as the display. +// // +// // Since: cosmos-sdk 0.43 +// string symbol = 6; +// // URI to a document (on or off-chain) that contains additional information. Optional. +// // +// // Since: cosmos-sdk 0.46 +// string uri = 7 [(gogoproto.customname) = "URI"]; +// // URIHash is a sha256 hash of a document pointed by URI. It's used to verify that +// // the document didn't change. Optional. +// // +// // Since: cosmos-sdk 0.46 +// string uri_hash = 8 [(gogoproto.customname) = "URIHash"]; +func CmdSetDenomMetadata() *cobra.Command { + cmd := &cobra.Command{ + Use: "set-denom-metadata [metadata_json]", + Short: "Broadcast message SetDenomMetadata", + Args: cobra.ExactArgs(1), + RunE: func(cmd *cobra.Command, args []string) (err error) { + argMetadataJsonString := args[0] + + clientCtx, err := client.GetClientTxContext(cmd) + if err != nil { + return err + } + + msg := types.NewMsgSetDenomMetadata( + clientCtx.GetFromAddress().String(), + argMetadataJsonString, + ) + if err := msg.ValidateBasic(); err != nil { + return err + } + return tx.GenerateOrBroadcastTxCLI(clientCtx, cmd.Flags(), msg) + }, + } + + flags.AddTxFlagsToCmd(cmd) + + return cmd +} diff --git a/x/tokenfactory/handler.go b/x/tokenfactory/handler.go index 0dc81af5..d53273a1 100644 --- a/x/tokenfactory/handler.go +++ b/x/tokenfactory/handler.go @@ -26,6 +26,12 @@ func NewHandler(k keeper.Keeper) sdk.Handler { case *types.MsgBurn: res, err := msgServer.Burn(sdk.WrapSDKContext(ctx), msg) return sdk.WrapServiceResult(ctx, res, err) + case *types.MsgChangeAdmin: + res, err := msgServer.ChangeAdmin(sdk.WrapSDKContext(ctx), msg) + return sdk.WrapServiceResult(ctx, res, err) + case *types.MsgSetDenomMetadata: + res, err := msgServer.SetDenomMetadata(sdk.WrapSDKContext(ctx), msg) + return sdk.WrapServiceResult(ctx, res, err) // this line is used by starport scaffolding # 1 default: errMsg := fmt.Sprintf("unrecognized %s message type: %T", types.ModuleName, msg) diff --git a/x/tokenfactory/keeper/msg_server_change_admin.go b/x/tokenfactory/keeper/msg_server_change_admin.go new file mode 100644 index 00000000..69afbfd0 --- /dev/null +++ b/x/tokenfactory/keeper/msg_server_change_admin.go @@ -0,0 +1,45 @@ +package keeper + +import ( + "context" + + "github.com/bze-alphateam/bze/x/tokenfactory/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (k msgServer) ChangeAdmin(goCtx context.Context, msg *types.MsgChangeAdmin) (*types.MsgChangeAdminResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + + dAuth, err := k.Keeper.GetDenomAuthority(ctx, msg.Denom) + if err != nil { + return nil, err + } + + if msg.NewAdmin != "" { + //validate new admin address only if one was provided + _, err = sdk.AccAddressFromBech32(msg.NewAdmin) + if err != nil { + return nil, err + } + } + + if msg.Creator != dAuth.GetAdmin() { + return nil, types.ErrUnauthorized + } + + dAuth.Admin = msg.NewAdmin + err = k.Keeper.SetDenomAuthority(ctx, msg.Denom, dAuth) + if err != nil { + return nil, err + } + + ctx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgChangeAdmin, + sdk.NewAttribute(types.AttributeDenom, msg.GetDenom()), + sdk.NewAttribute(types.AttributeNewAdmin, msg.NewAdmin), + ), + }) + + return &types.MsgChangeAdminResponse{}, nil +} diff --git a/x/tokenfactory/keeper/msg_server_set_denom_metadata.go b/x/tokenfactory/keeper/msg_server_set_denom_metadata.go new file mode 100644 index 00000000..b86a8c45 --- /dev/null +++ b/x/tokenfactory/keeper/msg_server_set_denom_metadata.go @@ -0,0 +1,38 @@ +package keeper + +import ( + "context" + + "github.com/bze-alphateam/bze/x/tokenfactory/types" + sdk "github.com/cosmos/cosmos-sdk/types" +) + +func (k msgServer) SetDenomMetadata(goCtx context.Context, msg *types.MsgSetDenomMetadata) (*types.MsgSetDenomMetadataResponse, error) { + ctx := sdk.UnwrapSDKContext(goCtx) + // Defense in depth validation of metadata + err := msg.Metadata.Validate() + if err != nil { + return nil, err + } + + dAuth, err := k.Keeper.GetDenomAuthority(ctx, msg.Metadata.Base) + if err != nil { + return nil, err + } + + if msg.Creator != dAuth.GetAdmin() { + return nil, types.ErrUnauthorized + } + + k.Keeper.bankKeeper.SetDenomMetaData(ctx, msg.Metadata) + + ctx.EventManager().EmitEvents(sdk.Events{ + sdk.NewEvent( + types.TypeMsgSetDenomMetadata, + sdk.NewAttribute(types.AttributeDenom, msg.Metadata.Base), + sdk.NewAttribute(types.AttributeDenomMetadata, msg.Metadata.String()), + ), + }) + + return &types.MsgSetDenomMetadataResponse{}, nil +} diff --git a/x/tokenfactory/module_simulation.go b/x/tokenfactory/module_simulation.go index f86ac005..2dc4f3a9 100644 --- a/x/tokenfactory/module_simulation.go +++ b/x/tokenfactory/module_simulation.go @@ -36,6 +36,14 @@ const ( // TODO: Determine the simulation weight value defaultWeightMsgBurn int = 100 + opWeightMsgChangeAdmin = "op_weight_msg_change_admin" + // TODO: Determine the simulation weight value + defaultWeightMsgChangeAdmin int = 100 + + opWeightMsgSetDenomMetadata = "op_weight_msg_set_denom_metadata" + // TODO: Determine the simulation weight value + defaultWeightMsgSetDenomMetadata int = 100 + // this line is used by starport scaffolding # simapp/module/const ) @@ -107,6 +115,28 @@ func (am AppModule) WeightedOperations(simState module.SimulationState) []simtyp tokenfactorysimulation.SimulateMsgBurn(am.accountKeeper, am.bankKeeper, am.keeper), )) + var weightMsgChangeAdmin int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgChangeAdmin, &weightMsgChangeAdmin, nil, + func(_ *rand.Rand) { + weightMsgChangeAdmin = defaultWeightMsgChangeAdmin + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgChangeAdmin, + tokenfactorysimulation.SimulateMsgChangeAdmin(am.accountKeeper, am.bankKeeper, am.keeper), + )) + + var weightMsgSetDenomMetadata int + simState.AppParams.GetOrGenerate(simState.Cdc, opWeightMsgSetDenomMetadata, &weightMsgSetDenomMetadata, nil, + func(_ *rand.Rand) { + weightMsgSetDenomMetadata = defaultWeightMsgSetDenomMetadata + }, + ) + operations = append(operations, simulation.NewWeightedOperation( + weightMsgSetDenomMetadata, + tokenfactorysimulation.SimulateMsgSetDenomMetadata(am.accountKeeper, am.bankKeeper, am.keeper), + )) + // this line is used by starport scaffolding # simapp/module/operation return operations diff --git a/x/tokenfactory/simulation/change_admin.go b/x/tokenfactory/simulation/change_admin.go new file mode 100644 index 00000000..5f3a189d --- /dev/null +++ b/x/tokenfactory/simulation/change_admin.go @@ -0,0 +1,29 @@ +package simulation + +import ( + "math/rand" + + "github.com/bze-alphateam/bze/x/tokenfactory/keeper" + "github.com/bze-alphateam/bze/x/tokenfactory/types" + "github.com/cosmos/cosmos-sdk/baseapp" + sdk "github.com/cosmos/cosmos-sdk/types" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" +) + +func SimulateMsgChangeAdmin( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + simAccount, _ := simtypes.RandomAcc(r, accs) + msg := &types.MsgChangeAdmin{ + Creator: simAccount.Address.String(), + } + + // TODO: Handling the ChangeAdmin simulation + + return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "ChangeAdmin simulation not implemented"), nil, nil + } +} diff --git a/x/tokenfactory/simulation/set_denom_metadata.go b/x/tokenfactory/simulation/set_denom_metadata.go new file mode 100644 index 00000000..bd14d38f --- /dev/null +++ b/x/tokenfactory/simulation/set_denom_metadata.go @@ -0,0 +1,29 @@ +package simulation + +import ( + "math/rand" + + "github.com/bze-alphateam/bze/x/tokenfactory/keeper" + "github.com/bze-alphateam/bze/x/tokenfactory/types" + "github.com/cosmos/cosmos-sdk/baseapp" + sdk "github.com/cosmos/cosmos-sdk/types" + simtypes "github.com/cosmos/cosmos-sdk/types/simulation" +) + +func SimulateMsgSetDenomMetadata( + ak types.AccountKeeper, + bk types.BankKeeper, + k keeper.Keeper, +) simtypes.Operation { + return func(r *rand.Rand, app *baseapp.BaseApp, ctx sdk.Context, accs []simtypes.Account, chainID string, + ) (simtypes.OperationMsg, []simtypes.FutureOperation, error) { + simAccount, _ := simtypes.RandomAcc(r, accs) + msg := &types.MsgSetDenomMetadata{ + Creator: simAccount.Address.String(), + } + + // TODO: Handling the SetDenomMetadata simulation + + return simtypes.NoOpMsg(types.ModuleName, msg.Type(), "SetDenomMetadata simulation not implemented"), nil, nil + } +} diff --git a/x/tokenfactory/types/codec.go b/x/tokenfactory/types/codec.go index a1302b92..3cb8c76a 100644 --- a/x/tokenfactory/types/codec.go +++ b/x/tokenfactory/types/codec.go @@ -11,6 +11,8 @@ func RegisterCodec(cdc *codec.LegacyAmino) { cdc.RegisterConcrete(&MsgCreateDenom{}, "tokenfactory/CreateDenom", nil) cdc.RegisterConcrete(&MsgMint{}, "tokenfactory/Mint", nil) cdc.RegisterConcrete(&MsgBurn{}, "tokenfactory/Burn", nil) + cdc.RegisterConcrete(&MsgChangeAdmin{}, "tokenfactory/ChangeAdmin", nil) + cdc.RegisterConcrete(&MsgSetDenomMetadata{}, "tokenfactory/SetDenomMetadata", nil) // this line is used by starport scaffolding # 2 } @@ -24,6 +26,12 @@ func RegisterInterfaces(registry cdctypes.InterfaceRegistry) { registry.RegisterImplementations((*sdk.Msg)(nil), &MsgBurn{}, ) + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgChangeAdmin{}, + ) + registry.RegisterImplementations((*sdk.Msg)(nil), + &MsgSetDenomMetadata{}, + ) // this line is used by starport scaffolding # 3 msgservice.RegisterMsgServiceDesc(registry, &_Msg_serviceDesc) diff --git a/x/tokenfactory/types/message_change_admin.go b/x/tokenfactory/types/message_change_admin.go new file mode 100644 index 00000000..d09a42d5 --- /dev/null +++ b/x/tokenfactory/types/message_change_admin.go @@ -0,0 +1,56 @@ +package types + +import ( + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" +) + +const TypeMsgChangeAdmin = "change_admin" + +var _ sdk.Msg = &MsgChangeAdmin{} + +func NewMsgChangeAdmin(creator string, denom string, newAdmin string) *MsgChangeAdmin { + return &MsgChangeAdmin{ + Creator: creator, + Denom: denom, + NewAdmin: newAdmin, + } +} + +func (msg *MsgChangeAdmin) Route() string { + return RouterKey +} + +func (msg *MsgChangeAdmin) Type() string { + return TypeMsgChangeAdmin +} + +func (msg *MsgChangeAdmin) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgChangeAdmin) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgChangeAdmin) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + + if msg.NewAdmin != "" { + // try to validate only if one was provided + _, err = sdk.AccAddressFromBech32(msg.NewAdmin) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid new admin address (%s)", err) + } + } + + return nil +} diff --git a/x/tokenfactory/types/message_change_admin_test.go b/x/tokenfactory/types/message_change_admin_test.go new file mode 100644 index 00000000..bf5ab918 --- /dev/null +++ b/x/tokenfactory/types/message_change_admin_test.go @@ -0,0 +1,40 @@ +package types + +import ( + "testing" + + "github.com/bze-alphateam/bze/testutil/sample" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" +) + +func TestMsgChangeAdmin_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgChangeAdmin + err error + }{ + { + name: "invalid address", + msg: MsgChangeAdmin{ + Creator: "invalid_address", + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgChangeAdmin{ + Creator: sample.AccAddress(), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/tokenfactory/types/message_set_denom_metadata.go b/x/tokenfactory/types/message_set_denom_metadata.go new file mode 100644 index 00000000..0f5007f7 --- /dev/null +++ b/x/tokenfactory/types/message_set_denom_metadata.go @@ -0,0 +1,55 @@ +package types + +import ( + "encoding/json" + sdk "github.com/cosmos/cosmos-sdk/types" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/cosmos/cosmos-sdk/x/bank/types" +) + +const TypeMsgSetDenomMetadata = "set_denom_metadata" + +var _ sdk.Msg = &MsgSetDenomMetadata{} + +func NewMsgSetDenomMetadata(creator string, metadata string) *MsgSetDenomMetadata { + mdByte := []byte(metadata) + mdStruct := types.Metadata{} + err := json.Unmarshal(mdByte, &mdStruct) + if err != nil { + return nil + } + + return &MsgSetDenomMetadata{ + Creator: creator, + Metadata: mdStruct, + } +} + +func (msg *MsgSetDenomMetadata) Route() string { + return RouterKey +} + +func (msg *MsgSetDenomMetadata) Type() string { + return TypeMsgSetDenomMetadata +} + +func (msg *MsgSetDenomMetadata) GetSigners() []sdk.AccAddress { + creator, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + panic(err) + } + return []sdk.AccAddress{creator} +} + +func (msg *MsgSetDenomMetadata) GetSignBytes() []byte { + bz := ModuleCdc.MustMarshalJSON(msg) + return sdk.MustSortJSON(bz) +} + +func (msg *MsgSetDenomMetadata) ValidateBasic() error { + _, err := sdk.AccAddressFromBech32(msg.Creator) + if err != nil { + return sdkerrors.Wrapf(sdkerrors.ErrInvalidAddress, "invalid creator address (%s)", err) + } + return nil +} diff --git a/x/tokenfactory/types/message_set_denom_metadata_test.go b/x/tokenfactory/types/message_set_denom_metadata_test.go new file mode 100644 index 00000000..87769e9f --- /dev/null +++ b/x/tokenfactory/types/message_set_denom_metadata_test.go @@ -0,0 +1,40 @@ +package types + +import ( + "testing" + + "github.com/bze-alphateam/bze/testutil/sample" + sdkerrors "github.com/cosmos/cosmos-sdk/types/errors" + "github.com/stretchr/testify/require" +) + +func TestMsgSetDenomMetadata_ValidateBasic(t *testing.T) { + tests := []struct { + name string + msg MsgSetDenomMetadata + err error + }{ + { + name: "invalid address", + msg: MsgSetDenomMetadata{ + Creator: "invalid_address", + }, + err: sdkerrors.ErrInvalidAddress, + }, { + name: "valid address", + msg: MsgSetDenomMetadata{ + Creator: sample.AccAddress(), + }, + }, + } + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + err := tt.msg.ValidateBasic() + if tt.err != nil { + require.ErrorIs(t, err, tt.err) + return + } + require.NoError(t, err) + }) + } +} diff --git a/x/tokenfactory/types/tx.pb.go b/x/tokenfactory/types/tx.pb.go index 12825dae..838022f9 100644 --- a/x/tokenfactory/types/tx.pb.go +++ b/x/tokenfactory/types/tx.pb.go @@ -6,6 +6,8 @@ package types import ( context "context" fmt "fmt" + types "github.com/cosmos/cosmos-sdk/x/bank/types" + _ "github.com/gogo/protobuf/gogoproto" grpc1 "github.com/gogo/protobuf/grpc" proto "github.com/gogo/protobuf/proto" grpc "google.golang.org/grpc" @@ -299,6 +301,190 @@ func (m *MsgBurnResponse) XXX_DiscardUnknown() { var xxx_messageInfo_MsgBurnResponse proto.InternalMessageInfo +type MsgChangeAdmin struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + Denom string `protobuf:"bytes,2,opt,name=denom,proto3" json:"denom,omitempty"` + NewAdmin string `protobuf:"bytes,3,opt,name=newAdmin,proto3" json:"newAdmin,omitempty"` +} + +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_51ab120c97d57038, []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) GetCreator() string { + if m != nil { + return m.Creator + } + 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_51ab120c97d57038, []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 + +type MsgSetDenomMetadata struct { + Creator string `protobuf:"bytes,1,opt,name=creator,proto3" json:"creator,omitempty"` + Metadata types.Metadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata" yaml:"metadata"` +} + +func (m *MsgSetDenomMetadata) Reset() { *m = MsgSetDenomMetadata{} } +func (m *MsgSetDenomMetadata) String() string { return proto.CompactTextString(m) } +func (*MsgSetDenomMetadata) ProtoMessage() {} +func (*MsgSetDenomMetadata) Descriptor() ([]byte, []int) { + return fileDescriptor_51ab120c97d57038, []int{8} +} +func (m *MsgSetDenomMetadata) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSetDenomMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetDenomMetadata.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgSetDenomMetadata) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetDenomMetadata.Merge(m, src) +} +func (m *MsgSetDenomMetadata) XXX_Size() int { + return m.Size() +} +func (m *MsgSetDenomMetadata) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetDenomMetadata.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetDenomMetadata proto.InternalMessageInfo + +func (m *MsgSetDenomMetadata) GetCreator() string { + if m != nil { + return m.Creator + } + return "" +} + +func (m *MsgSetDenomMetadata) GetMetadata() types.Metadata { + if m != nil { + return m.Metadata + } + return types.Metadata{} +} + +type MsgSetDenomMetadataResponse struct { +} + +func (m *MsgSetDenomMetadataResponse) Reset() { *m = MsgSetDenomMetadataResponse{} } +func (m *MsgSetDenomMetadataResponse) String() string { return proto.CompactTextString(m) } +func (*MsgSetDenomMetadataResponse) ProtoMessage() {} +func (*MsgSetDenomMetadataResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_51ab120c97d57038, []int{9} +} +func (m *MsgSetDenomMetadataResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *MsgSetDenomMetadataResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_MsgSetDenomMetadataResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *MsgSetDenomMetadataResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_MsgSetDenomMetadataResponse.Merge(m, src) +} +func (m *MsgSetDenomMetadataResponse) XXX_Size() int { + return m.Size() +} +func (m *MsgSetDenomMetadataResponse) XXX_DiscardUnknown() { + xxx_messageInfo_MsgSetDenomMetadataResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_MsgSetDenomMetadataResponse proto.InternalMessageInfo + func init() { proto.RegisterType((*MsgCreateDenom)(nil), "bze.tokenfactory.v1.MsgCreateDenom") proto.RegisterType((*MsgCreateDenomResponse)(nil), "bze.tokenfactory.v1.MsgCreateDenomResponse") @@ -306,32 +492,47 @@ func init() { proto.RegisterType((*MsgMintResponse)(nil), "bze.tokenfactory.v1.MsgMintResponse") proto.RegisterType((*MsgBurn)(nil), "bze.tokenfactory.v1.MsgBurn") proto.RegisterType((*MsgBurnResponse)(nil), "bze.tokenfactory.v1.MsgBurnResponse") + proto.RegisterType((*MsgChangeAdmin)(nil), "bze.tokenfactory.v1.MsgChangeAdmin") + proto.RegisterType((*MsgChangeAdminResponse)(nil), "bze.tokenfactory.v1.MsgChangeAdminResponse") + proto.RegisterType((*MsgSetDenomMetadata)(nil), "bze.tokenfactory.v1.MsgSetDenomMetadata") + proto.RegisterType((*MsgSetDenomMetadataResponse)(nil), "bze.tokenfactory.v1.MsgSetDenomMetadataResponse") } func init() { proto.RegisterFile("tokenfactory/tx.proto", fileDescriptor_51ab120c97d57038) } var fileDescriptor_51ab120c97d57038 = []byte{ - // 315 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x2d, 0xc9, 0xcf, 0x4e, - 0xcd, 0x4b, 0x4b, 0x4c, 0x2e, 0xc9, 0x2f, 0xaa, 0xd4, 0x2f, 0xa9, 0xd0, 0x2b, 0x28, 0xca, 0x2f, - 0xc9, 0x17, 0x12, 0x4e, 0xaa, 0x4a, 0xd5, 0x43, 0x96, 0xd2, 0x2b, 0x33, 0x54, 0x72, 0xe3, 0xe2, - 0xf3, 0x2d, 0x4e, 0x77, 0x2e, 0x4a, 0x4d, 0x2c, 0x49, 0x75, 0x49, 0xcd, 0xcb, 0xcf, 0x15, 0x92, - 0xe0, 0x62, 0x4f, 0x06, 0x71, 0xf3, 0x8b, 0x24, 0x18, 0x15, 0x18, 0x35, 0x38, 0x83, 0x60, 0x5c, - 0x21, 0x29, 0x2e, 0x8e, 0xe2, 0xd2, 0xa4, 0x14, 0x90, 0x2a, 0x09, 0x26, 0xb0, 0x14, 0x9c, 0xaf, - 0x64, 0xca, 0x25, 0x86, 0x6a, 0x4e, 0x50, 0x6a, 0x71, 0x41, 0x7e, 0x5e, 0x71, 0xaa, 0x90, 0x34, - 0x17, 0x67, 0x5e, 0x6a, 0x79, 0x3c, 0x44, 0x1b, 0xc4, 0x44, 0x8e, 0xbc, 0xd4, 0x72, 0xb0, 0x22, - 0x25, 0x4b, 0x2e, 0x76, 0xdf, 0xe2, 0x74, 0xdf, 0xcc, 0xbc, 0x12, 0x3c, 0xf6, 0x8a, 0x70, 0xb1, - 0x26, 0xe7, 0x67, 0xe6, 0x15, 0x43, 0x2d, 0x85, 0x70, 0x94, 0x04, 0xb9, 0xf8, 0xa1, 0x5a, 0x61, - 0x56, 0x41, 0x4d, 0x73, 0x2a, 0x2d, 0xca, 0x23, 0xd3, 0x34, 0x90, 0x56, 0x98, 0x69, 0x46, 0xff, - 0x18, 0xb9, 0x98, 0x7d, 0x8b, 0xd3, 0x85, 0xe2, 0xb9, 0xb8, 0x91, 0xc3, 0x47, 0x59, 0x0f, 0x4b, - 0x38, 0xea, 0xa1, 0x7a, 0x5e, 0x4a, 0x9b, 0x08, 0x45, 0xf0, 0x10, 0xf2, 0xe2, 0x62, 0x01, 0x87, - 0x80, 0x0c, 0x2e, 0x4d, 0x20, 0x59, 0x29, 0x15, 0x7c, 0xb2, 0xc8, 0x66, 0x81, 0xfd, 0x8f, 0xd3, - 0x2c, 0x90, 0x2c, 0x6e, 0xb3, 0x90, 0x03, 0xc0, 0xc9, 0xfb, 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, 0x0c, 0xd3, 0x33, 0x4b, 0x32, 0x4a, 0x93, 0xf4, 0x92, 0xf3, 0x73, 0xf5, - 0x93, 0xaa, 0x52, 0x75, 0x13, 0x73, 0x0a, 0x32, 0x12, 0x4b, 0x52, 0x13, 0xc1, 0x3c, 0xfd, 0x0a, - 0x7d, 0xd4, 0x04, 0x58, 0x59, 0x90, 0x5a, 0x9c, 0xc4, 0x06, 0x4e, 0x84, 0xc6, 0x80, 0x00, 0x00, - 0x00, 0xff, 0xff, 0x18, 0xf6, 0x9c, 0xa0, 0x9d, 0x02, 0x00, 0x00, + // 491 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x9c, 0x54, 0xc1, 0x6e, 0xd3, 0x40, + 0x10, 0x8d, 0x09, 0xd0, 0x74, 0x2a, 0x51, 0x70, 0x0b, 0x58, 0x2e, 0x75, 0x91, 0xe1, 0x50, 0x09, + 0xb1, 0x26, 0x45, 0x1c, 0xe0, 0x46, 0x40, 0x1c, 0x40, 0xbe, 0x84, 0x1b, 0x42, 0xaa, 0xd6, 0xce, + 0xb0, 0x89, 0x5a, 0xef, 0x46, 0xde, 0x4d, 0xd3, 0xf4, 0xca, 0x0f, 0xf0, 0x59, 0xbd, 0xd1, 0x23, + 0xa7, 0x0a, 0x25, 0x7f, 0xc0, 0x17, 0x20, 0xef, 0xda, 0xae, 0x43, 0xeb, 0x10, 0xf5, 0xe6, 0xa7, + 0xf7, 0xe6, 0xcd, 0xce, 0xcc, 0x93, 0xe1, 0xbe, 0x12, 0x07, 0xc8, 0xbf, 0xd1, 0x58, 0x89, 0x74, + 0x12, 0xa8, 0x63, 0x32, 0x4c, 0x85, 0x12, 0xf6, 0x46, 0x74, 0x82, 0xa4, 0x4a, 0x91, 0xa3, 0xb6, + 0xbb, 0xc9, 0x04, 0x13, 0x9a, 0x0f, 0xb2, 0x2f, 0x23, 0x75, 0xbd, 0x58, 0xc8, 0x44, 0xc8, 0x20, + 0xa2, 0xfc, 0x20, 0x38, 0x6a, 0x47, 0xa8, 0x68, 0x5b, 0x03, 0xc3, 0xfb, 0x1f, 0xe0, 0x4e, 0x28, + 0xd9, 0xbb, 0x14, 0xa9, 0xc2, 0xf7, 0xc8, 0x45, 0x62, 0x3b, 0xb0, 0x12, 0x67, 0x50, 0xa4, 0x8e, + 0xf5, 0xd8, 0xda, 0x5d, 0xed, 0x16, 0xd0, 0x76, 0xa1, 0x25, 0x47, 0x51, 0x2f, 0x53, 0x39, 0x37, + 0x34, 0x55, 0x62, 0xff, 0x15, 0x3c, 0x98, 0xf7, 0xe9, 0xa2, 0x1c, 0x0a, 0x2e, 0xd1, 0xde, 0x82, + 0x55, 0x8e, 0xe3, 0x7d, 0x53, 0x66, 0x1c, 0x5b, 0x1c, 0xc7, 0x5a, 0xe4, 0xbf, 0x86, 0x95, 0x50, + 0xb2, 0x70, 0xc0, 0xd5, 0x82, 0xbe, 0x9b, 0x70, 0x2b, 0x16, 0x03, 0x2e, 0xf3, 0xa6, 0x06, 0xf8, + 0xf7, 0x60, 0x3d, 0x2f, 0x2d, 0x5a, 0xe5, 0x6e, 0x9d, 0x51, 0xca, 0xaf, 0xe9, 0x96, 0x95, 0x96, + 0x6e, 0x5f, 0xcd, 0x6a, 0xfa, 0x94, 0x33, 0x7c, 0xdb, 0x4b, 0x06, 0xff, 0x31, 0xad, 0xee, 0xc5, + 0x80, 0x6c, 0x61, 0x1c, 0xc7, 0xba, 0xd6, 0x69, 0x96, 0x93, 0x6b, 0xec, 0x3b, 0x66, 0x61, 0x17, + 0xee, 0x65, 0xdf, 0xef, 0x16, 0x6c, 0x84, 0x92, 0x7d, 0x46, 0xa5, 0x77, 0x14, 0xa2, 0xa2, 0x3d, + 0xaa, 0xe8, 0x82, 0xee, 0x5d, 0x68, 0x25, 0xb9, 0x4a, 0x3f, 0x60, 0x6d, 0x6f, 0x9b, 0x98, 0xbb, + 0x13, 0x7d, 0xea, 0xfc, 0xee, 0xa4, 0xb0, 0xea, 0x3c, 0x3c, 0x3d, 0xdf, 0x69, 0xfc, 0x39, 0xdf, + 0x59, 0x9f, 0xd0, 0xe4, 0xf0, 0x8d, 0x5f, 0x14, 0xfb, 0xdd, 0xd2, 0xc7, 0xdf, 0x86, 0xad, 0x2b, + 0x1e, 0x51, 0x3c, 0x72, 0xef, 0x67, 0x13, 0x9a, 0xa1, 0x64, 0xf6, 0x3e, 0xac, 0x55, 0xc3, 0xf3, + 0x84, 0x5c, 0x11, 0x4d, 0x32, 0x9f, 0x0c, 0xf7, 0xd9, 0x12, 0xa2, 0x32, 0x3e, 0x1f, 0xe1, 0xa6, + 0x8e, 0xc7, 0xa3, 0xba, 0xa2, 0x8c, 0x75, 0x9f, 0x2e, 0x62, 0xab, 0x5e, 0x3a, 0x1c, 0xb5, 0x5e, + 0x19, 0x5b, 0xef, 0x55, 0x4d, 0x87, 0x1e, 0xbc, 0x12, 0x8d, 0xfa, 0xc1, 0x2f, 0x44, 0x0b, 0x06, + 0xbf, 0x1c, 0x03, 0x9b, 0xc3, 0xdd, 0x4b, 0x11, 0xd8, 0xad, 0x33, 0xf8, 0x57, 0xe9, 0xbe, 0x58, + 0x56, 0x59, 0xf4, 0xeb, 0x7c, 0x3a, 0x9d, 0x7a, 0xd6, 0xd9, 0xd4, 0xb3, 0x7e, 0x4f, 0x3d, 0xeb, + 0xc7, 0xcc, 0x6b, 0x9c, 0xcd, 0xbc, 0xc6, 0xaf, 0x99, 0xd7, 0xf8, 0xd2, 0x66, 0x03, 0xd5, 0x1f, + 0x45, 0x24, 0x16, 0x49, 0x10, 0x9d, 0xe0, 0x73, 0x7a, 0x38, 0xec, 0x53, 0x85, 0x54, 0xa3, 0xe0, + 0x38, 0x98, 0xff, 0x49, 0x4d, 0x86, 0x28, 0xa3, 0xdb, 0xfa, 0xef, 0xf2, 0xf2, 0x6f, 0x00, 0x00, + 0x00, 0xff, 0xff, 0xbb, 0xbb, 0x9c, 0x5d, 0xc1, 0x04, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -349,6 +550,8 @@ type MsgClient interface { CreateDenom(ctx context.Context, in *MsgCreateDenom, opts ...grpc.CallOption) (*MsgCreateDenomResponse, error) Mint(ctx context.Context, in *MsgMint, opts ...grpc.CallOption) (*MsgMintResponse, error) Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOption) (*MsgBurnResponse, error) + ChangeAdmin(ctx context.Context, in *MsgChangeAdmin, opts ...grpc.CallOption) (*MsgChangeAdminResponse, error) + SetDenomMetadata(ctx context.Context, in *MsgSetDenomMetadata, opts ...grpc.CallOption) (*MsgSetDenomMetadataResponse, error) } type msgClient struct { @@ -386,11 +589,31 @@ func (c *msgClient) Burn(ctx context.Context, in *MsgBurn, opts ...grpc.CallOpti 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, "/bze.tokenfactory.v1.Msg/ChangeAdmin", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *msgClient) SetDenomMetadata(ctx context.Context, in *MsgSetDenomMetadata, opts ...grpc.CallOption) (*MsgSetDenomMetadataResponse, error) { + out := new(MsgSetDenomMetadataResponse) + err := c.cc.Invoke(ctx, "/bze.tokenfactory.v1.Msg/SetDenomMetadata", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // MsgServer is the server API for Msg service. type MsgServer interface { CreateDenom(context.Context, *MsgCreateDenom) (*MsgCreateDenomResponse, error) Mint(context.Context, *MsgMint) (*MsgMintResponse, error) Burn(context.Context, *MsgBurn) (*MsgBurnResponse, error) + ChangeAdmin(context.Context, *MsgChangeAdmin) (*MsgChangeAdminResponse, error) + SetDenomMetadata(context.Context, *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error) } // UnimplementedMsgServer can be embedded to have forward compatible implementations. @@ -406,6 +629,12 @@ func (*UnimplementedMsgServer) Mint(ctx context.Context, req *MsgMint) (*MsgMint func (*UnimplementedMsgServer) Burn(ctx context.Context, req *MsgBurn) (*MsgBurnResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Burn not implemented") } +func (*UnimplementedMsgServer) ChangeAdmin(ctx context.Context, req *MsgChangeAdmin) (*MsgChangeAdminResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method ChangeAdmin not implemented") +} +func (*UnimplementedMsgServer) SetDenomMetadata(ctx context.Context, req *MsgSetDenomMetadata) (*MsgSetDenomMetadataResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method SetDenomMetadata not implemented") +} func RegisterMsgServer(s grpc1.Server, srv MsgServer) { s.RegisterService(&_Msg_serviceDesc, srv) @@ -465,6 +694,42 @@ func _Msg_Burn_Handler(srv interface{}, ctx context.Context, dec func(interface{ 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: "/bze.tokenfactory.v1.Msg/ChangeAdmin", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).ChangeAdmin(ctx, req.(*MsgChangeAdmin)) + } + return interceptor(ctx, in, info, handler) +} + +func _Msg_SetDenomMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(MsgSetDenomMetadata) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(MsgServer).SetDenomMetadata(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/bze.tokenfactory.v1.Msg/SetDenomMetadata", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(MsgServer).SetDenomMetadata(ctx, req.(*MsgSetDenomMetadata)) + } + return interceptor(ctx, in, info, handler) +} + var _Msg_serviceDesc = grpc.ServiceDesc{ ServiceName: "bze.tokenfactory.v1.Msg", HandlerType: (*MsgServer)(nil), @@ -481,6 +746,14 @@ var _Msg_serviceDesc = grpc.ServiceDesc{ MethodName: "Burn", Handler: _Msg_Burn_Handler, }, + { + MethodName: "ChangeAdmin", + Handler: _Msg_ChangeAdmin_Handler, + }, + { + MethodName: "SetDenomMetadata", + Handler: _Msg_SetDenomMetadata_Handler, + }, }, Streams: []grpc.StreamDesc{}, Metadata: "tokenfactory/tx.proto", @@ -673,6 +946,136 @@ func (m *MsgBurnResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { 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.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgChangeAdminResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgChangeAdminResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgChangeAdminResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *MsgSetDenomMetadata) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSetDenomMetadata) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetDenomMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + { + size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintTx(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + if len(m.Creator) > 0 { + i -= len(m.Creator) + copy(dAtA[i:], m.Creator) + i = encodeVarintTx(dAtA, i, uint64(len(m.Creator))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *MsgSetDenomMetadataResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *MsgSetDenomMetadataResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *MsgSetDenomMetadataResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + func encodeVarintTx(dAtA []byte, offset int, v uint64) int { offset -= sovTx(v) base := offset @@ -754,25 +1157,275 @@ func (m *MsgBurn) Size() (n int) { if l > 0 { n += 1 + l + sovTx(uint64(l)) } - return n -} + 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.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.Denom) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = len(m.NewAdmin) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + return n +} + +func (m *MsgChangeAdminResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *MsgSetDenomMetadata) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Creator) + if l > 0 { + n += 1 + l + sovTx(uint64(l)) + } + l = m.Metadata.Size() + n += 1 + l + sovTx(uint64(l)) + return n +} + +func (m *MsgSetDenomMetadataResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func sovTx(x uint64) (n int) { + return (math_bits.Len64(x|1) + 6) / 7 +} +func sozTx(x uint64) (n int) { + return sovTx(uint64((x << 1) ^ uint64((int64(x) >> 63)))) +} +func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCreateDenom: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateDenom: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Creator", 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.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Subdenom", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthTx + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthTx + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Subdenom = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipTx(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthTx + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowTx + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: MsgCreateDenomResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: MsgCreateDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field NewDenom", 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.NewDenom = 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 + } + } -func (m *MsgBurnResponse) Size() (n int) { - if m == nil { - return 0 + if iNdEx > l { + return io.ErrUnexpectedEOF } - 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)))) + return nil } -func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { +func (m *MsgMint) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -795,10 +1448,10 @@ func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateDenom: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMint: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateDenom: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgMint: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -835,7 +1488,7 @@ func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Subdenom", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Coins", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -863,7 +1516,7 @@ func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Subdenom = string(dAtA[iNdEx:postIndex]) + m.Coins = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -886,7 +1539,7 @@ func (m *MsgCreateDenom) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { +func (m *MsgMintResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -909,15 +1562,65 @@ func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgCreateDenomResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgMintResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgCreateDenomResponse: illegal tag %d (wire type %d)", fieldNum, wire) + 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 NewDenom", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Creator", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -945,7 +1648,39 @@ func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.NewDenom = string(dAtA[iNdEx:postIndex]) + m.Creator = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Coins", 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.Coins = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -968,7 +1703,7 @@ func (m *MsgCreateDenomResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMint) Unmarshal(dAtA []byte) error { +func (m *MsgBurnResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -991,10 +1726,60 @@ func (m *MsgMint) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMint: wiretype end group for non-group") + return fmt.Errorf("proto: MsgBurnResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMint: illegal tag %d (wire type %d)", fieldNum, wire) + 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: @@ -1031,7 +1816,7 @@ func (m *MsgMint) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Coins", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Denom", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -1059,7 +1844,39 @@ func (m *MsgMint) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Coins = string(dAtA[iNdEx:postIndex]) + 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 @@ -1082,7 +1899,7 @@ func (m *MsgMint) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgMintResponse) Unmarshal(dAtA []byte) error { +func (m *MsgChangeAdminResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1105,10 +1922,10 @@ func (m *MsgMintResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgMintResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgChangeAdminResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgMintResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgChangeAdminResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -1132,7 +1949,7 @@ func (m *MsgMintResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgBurn) Unmarshal(dAtA []byte) error { +func (m *MsgSetDenomMetadata) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1155,10 +1972,10 @@ func (m *MsgBurn) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgBurn: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSetDenomMetadata: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgBurn: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSetDenomMetadata: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: @@ -1195,9 +2012,9 @@ func (m *MsgBurn) Unmarshal(dAtA []byte) error { iNdEx = postIndex case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Coins", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowTx @@ -1207,23 +2024,24 @@ func (m *MsgBurn) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthTx } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthTx } if postIndex > l { return io.ErrUnexpectedEOF } - m.Coins = string(dAtA[iNdEx:postIndex]) + if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -1246,7 +2064,7 @@ func (m *MsgBurn) Unmarshal(dAtA []byte) error { } return nil } -func (m *MsgBurnResponse) Unmarshal(dAtA []byte) error { +func (m *MsgSetDenomMetadataResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -1269,10 +2087,10 @@ func (m *MsgBurnResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: MsgBurnResponse: wiretype end group for non-group") + return fmt.Errorf("proto: MsgSetDenomMetadataResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: MsgBurnResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: MsgSetDenomMetadataResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: