From 0c29f859d3f1d9622c1a6a6ca622e86c4414f65f Mon Sep 17 00:00:00 2001 From: _dssei_ Date: Fri, 13 Sep 2024 10:22:52 -0700 Subject: [PATCH 1/4] Token factory allow list proto changes --- packages/proto/proto/tokenfactory/query.proto | 34 +++- packages/proto/proto/tokenfactory/tx.proto | 32 ++-- .../src/codegen/tokenfactory/query.lcd.ts | 16 +- .../codegen/tokenfactory/query.rpc.Query.ts | 15 +- .../proto/src/codegen/tokenfactory/query.ts | 158 +++++++++++++++++ .../src/codegen/tokenfactory/tx.amino.ts | 7 +- .../src/codegen/tokenfactory/tx.registry.ts | 21 ++- .../src/codegen/tokenfactory/tx.rpc.msg.ts | 9 + packages/proto/src/codegen/tokenfactory/tx.ts | 164 ++++++++++++++++++ 9 files changed, 426 insertions(+), 30 deletions(-) diff --git a/packages/proto/proto/tokenfactory/query.proto b/packages/proto/proto/tokenfactory/query.proto index 7a3d1d55..8fdd8621 100644 --- a/packages/proto/proto/tokenfactory/query.proto +++ b/packages/proto/proto/tokenfactory/query.proto @@ -21,9 +21,9 @@ service Query { // DenomAuthorityMetadata defines a gRPC query method for fetching // DenomAuthorityMetadata for a particular denom. rpc DenomAuthorityMetadata(QueryDenomAuthorityMetadataRequest) - returns (QueryDenomAuthorityMetadataResponse) { + returns (QueryDenomAuthorityMetadataResponse) { option (google.api.http).get = - "/sei-protocol/seichain/tokenfactory/denoms/{denom}/authority_metadata"; + "/sei-protocol/seichain/tokenfactory/denoms/{denom}/authority_metadata"; } // DenomsMetadata defines a gRPC query method for fetching @@ -35,9 +35,14 @@ service Query { // DenomsFromCreator defines a gRPC query method for fetching all // denominations created by a specific admin/creator. rpc DenomsFromCreator(QueryDenomsFromCreatorRequest) - returns (QueryDenomsFromCreatorResponse) { + returns (QueryDenomsFromCreatorResponse) { option (google.api.http).get = - "/sei-protocol/seichain/tokenfactory/denoms_from_creator/{creator}"; + "/sei-protocol/seichain/tokenfactory/denoms_from_creator/{creator}"; + } + + // DenomAllowList defines a gRPC query method for fetching the denom allow list + rpc DenomAllowList(QueryDenomAllowListRequest) returns (QueryDenomAllowListResponse) { + option (google.api.http).get = "/sei-protocol/seichain/tokenfactory/denoms/allow_list"; } } @@ -48,13 +53,13 @@ message QueryParamsRequest {} // QueryParamsResponse is the response type for the Query/Params RPC method. message QueryParamsResponse { // params defines the parameters of the module. - Params params = 1 [ (gogoproto.nullable) = false ]; + Params params = 1 [(gogoproto.nullable) = false]; } // QueryDenomAuthorityMetadataRequest defines the request structure for the // DenomAuthorityMetadata gRPC query. message QueryDenomAuthorityMetadataRequest { - string denom = 1 [ (gogoproto.moretags) = "yaml:\"denom\"" ]; + string denom = 1 [(gogoproto.moretags) = "yaml:\"denom\""]; } // QueryDenomAuthorityMetadataResponse defines the response structure for the @@ -69,13 +74,13 @@ message QueryDenomAuthorityMetadataResponse { // QueryDenomsFromCreatorRequest defines the request structure for the // DenomsFromCreator gRPC query. message QueryDenomsFromCreatorRequest { - string creator = 1 [ (gogoproto.moretags) = "yaml:\"creator\"" ]; + string creator = 1 [(gogoproto.moretags) = "yaml:\"creator\""]; } // QueryDenomsFromCreatorRequest defines the response structure for the // DenomsFromCreator gRPC query. message QueryDenomsFromCreatorResponse { - repeated string denoms = 1 [ (gogoproto.moretags) = "yaml:\"denoms\"" ]; + repeated string denoms = 1 [(gogoproto.moretags) = "yaml:\"denoms\""]; } // QueryDenomMetadataRequest is the request type for the DenomMetadata gRPC method. @@ -90,3 +95,16 @@ message QueryDenomMetadataResponse { // metadata describes and provides all the client information for the requested token. cosmos.bank.v1beta1.Metadata metadata = 1 [(gogoproto.nullable) = false]; } + +// QueryDenomAllowListRequest is the request type for the DenomAllowList gRPC method +message QueryDenomAllowListRequest { + // denom is the coin denom to query the allowlist for. + string denom = 1; +} + +// QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC +// method. +message QueryDenomAllowListResponse { + // allow_list provides addresses allowed for the requested token. + cosmos.bank.v1beta1.AllowList allow_list = 1 [(gogoproto.nullable) = false]; +} diff --git a/packages/proto/proto/tokenfactory/tx.proto b/packages/proto/proto/tokenfactory/tx.proto index 7610c2e9..7c0402b9 100644 --- a/packages/proto/proto/tokenfactory/tx.proto +++ b/packages/proto/proto/tokenfactory/tx.proto @@ -10,15 +10,12 @@ option go_package = "github.com/sei-protocol/sei-chain/x/tokenfactory/types"; // Msg defines the tokefactory module's gRPC message service. service Msg { rpc CreateDenom(MsgCreateDenom) returns (MsgCreateDenomResponse); + rpc UpdateDenom(MsgUpdateDenom) returns (MsgUpdateDenomResponse); rpc Mint(MsgMint) returns (MsgMintResponse); rpc Burn(MsgBurn) returns (MsgBurnResponse); rpc ChangeAdmin(MsgChangeAdmin) returns (MsgChangeAdminResponse); rpc SetDenomMetadata(MsgSetDenomMetadata) returns (MsgSetDenomMetadataResponse); - - // ForceTransfer is deactivated for now because we need to think through edge - // cases rpc ForceTransfer(MsgForceTransfer) returns - // (MsgForceTransferResponse); } // MsgCreateDenom defines the message structure for the CreateDenom gRPC service @@ -34,6 +31,7 @@ message MsgCreateDenom { string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; // subdenom can be up to 44 "alphanumeric" characters long. string subdenom = 2 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ]; + cosmos.bank.v1beta1.AllowList allow_list = 3 [ (gogoproto.moretags) = "yaml:\"allow_list\"", (gogoproto.nullable) = true ]; } // MsgCreateDenomResponse is the return value of MsgCreateDenom @@ -79,20 +77,6 @@ message MsgChangeAdmin { // MsgChangeAdmin message. message MsgChangeAdminResponse {} -// message MsgForceTransfer { -// string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; -// cosmos.base.v1beta1.Coin amount = 2 [ -// (gogoproto.moretags) = "yaml:\"amount\"", -// (gogoproto.nullable) = false -// ]; -// string transferFromAddress = 3 -// [ (gogoproto.moretags) = "yaml:\"transfer_from_address\"" ]; -// string transferToAddress = 4 -// [ (gogoproto.moretags) = "yaml:\"transfer_to_address\"" ]; -// } - -// message MsgForceTransferResponse {} - // MsgSetDenomMetadata is the sdk.Msg type for allowing an admin account to set // the denom's bank metadata message MsgSetDenomMetadata { @@ -103,3 +87,15 @@ message MsgSetDenomMetadata { // MsgSetDenomMetadataResponse defines the response structure for an executed // MsgSetDenomMetadata message. message MsgSetDenomMetadataResponse {} + +// MsgUpdateDenom is the sdk.Msg allowing an admin to update the denom +message MsgUpdateDenom { + string sender = 1 [ (gogoproto.moretags) = "yaml:\"sender\"" ]; + // subdenom can be up to 44 "alphanumeric" characters long. + string subdenom = 2 [ (gogoproto.moretags) = "yaml:\"subdenom\"" ]; + cosmos.bank.v1beta1.AllowList allow_list = 3 [ (gogoproto.moretags) = "yaml:\"allow_list\"", (gogoproto.nullable) = true ]; +} + + +// MsgUpdateDenomResponse defines the response structure for an executed MsgUpdateDenom message. +message MsgUpdateDenomResponse {} diff --git a/packages/proto/src/codegen/tokenfactory/query.lcd.ts b/packages/proto/src/codegen/tokenfactory/query.lcd.ts index 7bc81550..3b476bac 100644 --- a/packages/proto/src/codegen/tokenfactory/query.lcd.ts +++ b/packages/proto/src/codegen/tokenfactory/query.lcd.ts @@ -7,7 +7,9 @@ import { QueryDenomMetadataRequest, QueryDenomMetadataResponseSDKType, QueryDenomsFromCreatorRequest, - QueryDenomsFromCreatorResponseSDKType + QueryDenomsFromCreatorResponseSDKType, + QueryDenomAllowListRequest, + QueryDenomAllowListResponseSDKType } from './query'; export class LCDQueryClient { req: LCDClient; @@ -17,6 +19,7 @@ export class LCDQueryClient { this.denomAuthorityMetadata = this.denomAuthorityMetadata.bind(this); this.denomMetadata = this.denomMetadata.bind(this); this.denomsFromCreator = this.denomsFromCreator.bind(this); + this.denomAllowList = this.denomAllowList.bind(this); } /* Params defines a gRPC query method that returns the tokenfactory module's parameters. */ @@ -48,4 +51,15 @@ export class LCDQueryClient { const endpoint = `sei-protocol/seichain/tokenfactory/denoms_from_creator/${params.creator}`; return await this.req.get(endpoint); } + /* DenomAllowList defines a gRPC query method for fetching the denom allow list */ + async denomAllowList(params: QueryDenomAllowListRequest): Promise { + const options: any = { + params: {} + }; + if (typeof params?.denom !== 'undefined') { + options.params.denom = params.denom; + } + const endpoint = `sei-protocol/seichain/tokenfactory/denoms/allow_list`; + return await this.req.get(endpoint, options); + } } diff --git a/packages/proto/src/codegen/tokenfactory/query.rpc.Query.ts b/packages/proto/src/codegen/tokenfactory/query.rpc.Query.ts index d071bbbb..6ddfddd3 100644 --- a/packages/proto/src/codegen/tokenfactory/query.rpc.Query.ts +++ b/packages/proto/src/codegen/tokenfactory/query.rpc.Query.ts @@ -9,7 +9,9 @@ import { QueryDenomMetadataRequest, QueryDenomMetadataResponse, QueryDenomsFromCreatorRequest, - QueryDenomsFromCreatorResponse + QueryDenomsFromCreatorResponse, + QueryDenomAllowListRequest, + QueryDenomAllowListResponse } from './query'; /** Query defines the gRPC querier service. */ export interface Query { @@ -33,6 +35,8 @@ export interface Query { * denominations created by a specific admin/creator. */ denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise; + /** DenomAllowList defines a gRPC query method for fetching the denom allow list */ + denomAllowList(request: QueryDenomAllowListRequest): Promise; } export class QueryClientImpl implements Query { private readonly rpc: TxRpc; @@ -42,6 +46,7 @@ export class QueryClientImpl implements Query { this.denomAuthorityMetadata = this.denomAuthorityMetadata.bind(this); this.denomMetadata = this.denomMetadata.bind(this); this.denomsFromCreator = this.denomsFromCreator.bind(this); + this.denomAllowList = this.denomAllowList.bind(this); } params(request: QueryParamsRequest = {}): Promise { const data = QueryParamsRequest.encode(request).finish(); @@ -63,6 +68,11 @@ export class QueryClientImpl implements Query { const promise = this.rpc.request('seiprotocol.seichain.tokenfactory.Query', 'DenomsFromCreator', data); return promise.then((data) => QueryDenomsFromCreatorResponse.decode(new BinaryReader(data))); } + denomAllowList(request: QueryDenomAllowListRequest): Promise { + const data = QueryDenomAllowListRequest.encode(request).finish(); + const promise = this.rpc.request('seiprotocol.seichain.tokenfactory.Query', 'DenomAllowList', data); + return promise.then((data) => QueryDenomAllowListResponse.decode(new BinaryReader(data))); + } } export const createRpcQueryExtension = (base: QueryClient) => { const rpc = createProtobufRpcClient(base); @@ -79,6 +89,9 @@ export const createRpcQueryExtension = (base: QueryClient) => { }, denomsFromCreator(request: QueryDenomsFromCreatorRequest): Promise { return queryService.denomsFromCreator(request); + }, + denomAllowList(request: QueryDenomAllowListRequest): Promise { + return queryService.denomAllowList(request); } }; }; diff --git a/packages/proto/src/codegen/tokenfactory/query.ts b/packages/proto/src/codegen/tokenfactory/query.ts index 069c6aac..49a70e00 100644 --- a/packages/proto/src/codegen/tokenfactory/query.ts +++ b/packages/proto/src/codegen/tokenfactory/query.ts @@ -206,6 +206,51 @@ export interface QueryDenomMetadataResponseAminoMsg { export interface QueryDenomMetadataResponseSDKType { metadata: MetadataSDKType | undefined; } +/** QueryDenomAllowListRequest is the request type for the DenomAllowList gRPC method */ +export interface QueryDenomAllowListRequest { + /** denom is the coin denom to query the allowlist for. */ + denom: string; +} +export interface QueryDenomAllowListRequestProtoMsg { + typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListRequest'; + value: Uint8Array; +} +/** QueryDenomAllowListRequest is the request type for the DenomAllowList gRPC method */ +export interface QueryDenomAllowListRequestAmino { + /** denom is the coin denom to query the allowlist for. */ + denom?: string; +} +export interface QueryDenomAllowListRequestAminoMsg { + type: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListRequest'; + value: QueryDenomAllowListRequestAmino; +} +/** QueryDenomAllowListRequest is the request type for the DenomAllowList gRPC method */ +export interface QueryDenomAllowListRequestSDKType { + denom: string; +} +/** + * QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC + * method. + */ +export interface QueryDenomAllowListResponse {} +export interface QueryDenomAllowListResponseProtoMsg { + typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse'; + value: Uint8Array; +} +/** + * QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC + * method. + */ +export interface QueryDenomAllowListResponseAmino {} +export interface QueryDenomAllowListResponseAminoMsg { + type: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse'; + value: QueryDenomAllowListResponseAmino; +} +/** + * QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC + * method. + */ +export interface QueryDenomAllowListResponseSDKType {} function createBaseQueryParamsRequest(): QueryParamsRequest { return {}; } @@ -700,3 +745,116 @@ export const QueryDenomMetadataResponse = { }; } }; +function createBaseQueryDenomAllowListRequest(): QueryDenomAllowListRequest { + return { + denom: '' + }; +} +export const QueryDenomAllowListRequest = { + typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListRequest', + encode(message: QueryDenomAllowListRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== '') { + writer.uint32(10).string(message.denom); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): QueryDenomAllowListRequest { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryDenomAllowListRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): QueryDenomAllowListRequest { + const message = createBaseQueryDenomAllowListRequest(); + message.denom = object.denom ?? ''; + return message; + }, + fromAmino(object: QueryDenomAllowListRequestAmino): QueryDenomAllowListRequest { + const message = createBaseQueryDenomAllowListRequest(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + return message; + }, + toAmino(message: QueryDenomAllowListRequest): QueryDenomAllowListRequestAmino { + const obj: any = {}; + obj.denom = message.denom === '' ? undefined : message.denom; + return obj; + }, + fromAminoMsg(object: QueryDenomAllowListRequestAminoMsg): QueryDenomAllowListRequest { + return QueryDenomAllowListRequest.fromAmino(object.value); + }, + fromProtoMsg(message: QueryDenomAllowListRequestProtoMsg): QueryDenomAllowListRequest { + return QueryDenomAllowListRequest.decode(message.value); + }, + toProto(message: QueryDenomAllowListRequest): Uint8Array { + return QueryDenomAllowListRequest.encode(message).finish(); + }, + toProtoMsg(message: QueryDenomAllowListRequest): QueryDenomAllowListRequestProtoMsg { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListRequest', + value: QueryDenomAllowListRequest.encode(message).finish() + }; + } +}; +function createBaseQueryDenomAllowListResponse(): QueryDenomAllowListResponse { + return {}; +} +export const QueryDenomAllowListResponse = { + typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse', + encode(_: QueryDenomAllowListResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): QueryDenomAllowListResponse { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryDenomAllowListResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(_: Partial): QueryDenomAllowListResponse { + const message = createBaseQueryDenomAllowListResponse(); + return message; + }, + fromAmino(_: QueryDenomAllowListResponseAmino): QueryDenomAllowListResponse { + const message = createBaseQueryDenomAllowListResponse(); + return message; + }, + toAmino(_: QueryDenomAllowListResponse): QueryDenomAllowListResponseAmino { + const obj: any = {}; + return obj; + }, + fromAminoMsg(object: QueryDenomAllowListResponseAminoMsg): QueryDenomAllowListResponse { + return QueryDenomAllowListResponse.fromAmino(object.value); + }, + fromProtoMsg(message: QueryDenomAllowListResponseProtoMsg): QueryDenomAllowListResponse { + return QueryDenomAllowListResponse.decode(message.value); + }, + toProto(message: QueryDenomAllowListResponse): Uint8Array { + return QueryDenomAllowListResponse.encode(message).finish(); + }, + toProtoMsg(message: QueryDenomAllowListResponse): QueryDenomAllowListResponseProtoMsg { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse', + value: QueryDenomAllowListResponse.encode(message).finish() + }; + } +}; diff --git a/packages/proto/src/codegen/tokenfactory/tx.amino.ts b/packages/proto/src/codegen/tokenfactory/tx.amino.ts index 7e819439..1bc70833 100644 --- a/packages/proto/src/codegen/tokenfactory/tx.amino.ts +++ b/packages/proto/src/codegen/tokenfactory/tx.amino.ts @@ -1,10 +1,15 @@ -import { MsgCreateDenom, MsgMint, MsgBurn, MsgChangeAdmin, MsgSetDenomMetadata } from './tx'; +import { MsgCreateDenom, MsgUpdateDenom, MsgMint, MsgBurn, MsgChangeAdmin, MsgSetDenomMetadata } from './tx'; export const AminoConverter = { '/seiprotocol.seichain.tokenfactory.MsgCreateDenom': { aminoType: '/seiprotocol.seichain.tokenfactory.MsgCreateDenom', toAmino: MsgCreateDenom.toAmino, fromAmino: MsgCreateDenom.fromAmino }, + '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom': { + aminoType: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', + toAmino: MsgUpdateDenom.toAmino, + fromAmino: MsgUpdateDenom.fromAmino + }, '/seiprotocol.seichain.tokenfactory.MsgMint': { aminoType: '/seiprotocol.seichain.tokenfactory.MsgMint', toAmino: MsgMint.toAmino, diff --git a/packages/proto/src/codegen/tokenfactory/tx.registry.ts b/packages/proto/src/codegen/tokenfactory/tx.registry.ts index a0f469c7..49a5e0ac 100644 --- a/packages/proto/src/codegen/tokenfactory/tx.registry.ts +++ b/packages/proto/src/codegen/tokenfactory/tx.registry.ts @@ -1,8 +1,9 @@ import { TelescopeGeneratedType } from '../types'; import { Registry } from '@cosmjs/proto-signing'; -import { MsgCreateDenom, MsgMint, MsgBurn, MsgChangeAdmin, MsgSetDenomMetadata } from './tx'; +import { MsgCreateDenom, MsgUpdateDenom, MsgMint, MsgBurn, MsgChangeAdmin, MsgSetDenomMetadata } from './tx'; export const registry: ReadonlyArray<[string, TelescopeGeneratedType]> = [ ['/seiprotocol.seichain.tokenfactory.MsgCreateDenom', MsgCreateDenom], + ['/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', MsgUpdateDenom], ['/seiprotocol.seichain.tokenfactory.MsgMint', MsgMint], ['/seiprotocol.seichain.tokenfactory.MsgBurn', MsgBurn], ['/seiprotocol.seichain.tokenfactory.MsgChangeAdmin', MsgChangeAdmin], @@ -21,6 +22,12 @@ export const MessageComposer = { value: MsgCreateDenom.encode(value).finish() }; }, + updateDenom(value: MsgUpdateDenom) { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', + value: MsgUpdateDenom.encode(value).finish() + }; + }, mint(value: MsgMint) { return { typeUrl: '/seiprotocol.seichain.tokenfactory.MsgMint', @@ -53,6 +60,12 @@ export const MessageComposer = { value }; }, + updateDenom(value: MsgUpdateDenom) { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', + value + }; + }, mint(value: MsgMint) { return { typeUrl: '/seiprotocol.seichain.tokenfactory.MsgMint', @@ -85,6 +98,12 @@ export const MessageComposer = { value: MsgCreateDenom.fromPartial(value) }; }, + updateDenom(value: MsgUpdateDenom) { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', + value: MsgUpdateDenom.fromPartial(value) + }; + }, mint(value: MsgMint) { return { typeUrl: '/seiprotocol.seichain.tokenfactory.MsgMint', diff --git a/packages/proto/src/codegen/tokenfactory/tx.rpc.msg.ts b/packages/proto/src/codegen/tokenfactory/tx.rpc.msg.ts index 34522b34..64dac8b1 100644 --- a/packages/proto/src/codegen/tokenfactory/tx.rpc.msg.ts +++ b/packages/proto/src/codegen/tokenfactory/tx.rpc.msg.ts @@ -3,6 +3,8 @@ import { BinaryReader } from '../binary'; import { MsgCreateDenom, MsgCreateDenomResponse, + MsgUpdateDenom, + MsgUpdateDenomResponse, MsgMint, MsgMintResponse, MsgBurn, @@ -15,6 +17,7 @@ import { /** Msg defines the tokefactory module's gRPC message service. */ export interface Msg { createDenom(request: MsgCreateDenom): Promise; + updateDenom(request: MsgUpdateDenom): Promise; mint(request: MsgMint): Promise; burn(request: MsgBurn): Promise; changeAdmin(request: MsgChangeAdmin): Promise; @@ -25,6 +28,7 @@ export class MsgClientImpl implements Msg { constructor(rpc: TxRpc) { this.rpc = rpc; this.createDenom = this.createDenom.bind(this); + this.updateDenom = this.updateDenom.bind(this); this.mint = this.mint.bind(this); this.burn = this.burn.bind(this); this.changeAdmin = this.changeAdmin.bind(this); @@ -35,6 +39,11 @@ export class MsgClientImpl implements Msg { const promise = this.rpc.request('seiprotocol.seichain.tokenfactory.Msg', 'CreateDenom', data); return promise.then((data) => MsgCreateDenomResponse.decode(new BinaryReader(data))); } + updateDenom(request: MsgUpdateDenom): Promise { + const data = MsgUpdateDenom.encode(request).finish(); + const promise = this.rpc.request('seiprotocol.seichain.tokenfactory.Msg', 'UpdateDenom', data); + return promise.then((data) => MsgUpdateDenomResponse.decode(new BinaryReader(data))); + } mint(request: MsgMint): Promise { const data = MsgMint.encode(request).finish(); const promise = this.rpc.request('seiprotocol.seichain.tokenfactory.Msg', 'Mint', data); diff --git a/packages/proto/src/codegen/tokenfactory/tx.ts b/packages/proto/src/codegen/tokenfactory/tx.ts index ab1ce481..b6c42254 100644 --- a/packages/proto/src/codegen/tokenfactory/tx.ts +++ b/packages/proto/src/codegen/tokenfactory/tx.ts @@ -284,6 +284,45 @@ export interface MsgSetDenomMetadataResponseAminoMsg { * MsgSetDenomMetadata message. */ export interface MsgSetDenomMetadataResponseSDKType {} +/** MsgUpdateDenom is the sdk.Msg allowing an admin to update the denom */ +export interface MsgUpdateDenom { + sender: string; + /** subdenom can be up to 44 "alphanumeric" characters long. */ + subdenom: string; +} +export interface MsgUpdateDenomProtoMsg { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom'; + value: Uint8Array; +} +/** MsgUpdateDenom is the sdk.Msg allowing an admin to update the denom */ +export interface MsgUpdateDenomAmino { + sender?: string; + /** subdenom can be up to 44 "alphanumeric" characters long. */ + subdenom?: string; +} +export interface MsgUpdateDenomAminoMsg { + type: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom'; + value: MsgUpdateDenomAmino; +} +/** MsgUpdateDenom is the sdk.Msg allowing an admin to update the denom */ +export interface MsgUpdateDenomSDKType { + sender: string; + subdenom: string; +} +/** MsgUpdateDenomResponse defines the response structure for an executed MsgUpdateDenom message. */ +export interface MsgUpdateDenomResponse {} +export interface MsgUpdateDenomResponseProtoMsg { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenomResponse'; + value: Uint8Array; +} +/** MsgUpdateDenomResponse defines the response structure for an executed MsgUpdateDenom message. */ +export interface MsgUpdateDenomResponseAmino {} +export interface MsgUpdateDenomResponseAminoMsg { + type: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenomResponse'; + value: MsgUpdateDenomResponseAmino; +} +/** MsgUpdateDenomResponse defines the response structure for an executed MsgUpdateDenom message. */ +export interface MsgUpdateDenomResponseSDKType {} function createBaseMsgCreateDenom(): MsgCreateDenom { return { sender: '', @@ -934,3 +973,128 @@ export const MsgSetDenomMetadataResponse = { }; } }; +function createBaseMsgUpdateDenom(): MsgUpdateDenom { + return { + sender: '', + subdenom: '' + }; +} +export const MsgUpdateDenom = { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', + encode(message: MsgUpdateDenom, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.sender !== '') { + writer.uint32(10).string(message.sender); + } + if (message.subdenom !== '') { + writer.uint32(18).string(message.subdenom); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateDenom { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMsgUpdateDenom(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.sender = reader.string(); + break; + case 2: + message.subdenom = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): MsgUpdateDenom { + const message = createBaseMsgUpdateDenom(); + message.sender = object.sender ?? ''; + message.subdenom = object.subdenom ?? ''; + return message; + }, + fromAmino(object: MsgUpdateDenomAmino): MsgUpdateDenom { + const message = createBaseMsgUpdateDenom(); + if (object.sender !== undefined && object.sender !== null) { + message.sender = object.sender; + } + if (object.subdenom !== undefined && object.subdenom !== null) { + message.subdenom = object.subdenom; + } + return message; + }, + toAmino(message: MsgUpdateDenom): MsgUpdateDenomAmino { + const obj: any = {}; + obj.sender = message.sender === '' ? undefined : message.sender; + obj.subdenom = message.subdenom === '' ? undefined : message.subdenom; + return obj; + }, + fromAminoMsg(object: MsgUpdateDenomAminoMsg): MsgUpdateDenom { + return MsgUpdateDenom.fromAmino(object.value); + }, + fromProtoMsg(message: MsgUpdateDenomProtoMsg): MsgUpdateDenom { + return MsgUpdateDenom.decode(message.value); + }, + toProto(message: MsgUpdateDenom): Uint8Array { + return MsgUpdateDenom.encode(message).finish(); + }, + toProtoMsg(message: MsgUpdateDenom): MsgUpdateDenomProtoMsg { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom', + value: MsgUpdateDenom.encode(message).finish() + }; + } +}; +function createBaseMsgUpdateDenomResponse(): MsgUpdateDenomResponse { + return {}; +} +export const MsgUpdateDenomResponse = { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenomResponse', + encode(_: MsgUpdateDenomResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateDenomResponse { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMsgUpdateDenomResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(_: Partial): MsgUpdateDenomResponse { + const message = createBaseMsgUpdateDenomResponse(); + return message; + }, + fromAmino(_: MsgUpdateDenomResponseAmino): MsgUpdateDenomResponse { + const message = createBaseMsgUpdateDenomResponse(); + return message; + }, + toAmino(_: MsgUpdateDenomResponse): MsgUpdateDenomResponseAmino { + const obj: any = {}; + return obj; + }, + fromAminoMsg(object: MsgUpdateDenomResponseAminoMsg): MsgUpdateDenomResponse { + return MsgUpdateDenomResponse.fromAmino(object.value); + }, + fromProtoMsg(message: MsgUpdateDenomResponseProtoMsg): MsgUpdateDenomResponse { + return MsgUpdateDenomResponse.decode(message.value); + }, + toProto(message: MsgUpdateDenomResponse): Uint8Array { + return MsgUpdateDenomResponse.encode(message).finish(); + }, + toProtoMsg(message: MsgUpdateDenomResponse): MsgUpdateDenomResponseProtoMsg { + return { + typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenomResponse', + value: MsgUpdateDenomResponse.encode(message).finish() + }; + } +}; From 74fdc13f6a5ec2b2820b81d9004c61acd4c040df Mon Sep 17 00:00:00 2001 From: _dssei_ Date: Fri, 13 Sep 2024 10:24:49 -0700 Subject: [PATCH 2/4] change set --- .changeset/bright-trains-rule.md | 5 +++++ 1 file changed, 5 insertions(+) create mode 100644 .changeset/bright-trains-rule.md diff --git a/.changeset/bright-trains-rule.md b/.changeset/bright-trains-rule.md new file mode 100644 index 00000000..9ebfea31 --- /dev/null +++ b/.changeset/bright-trains-rule.md @@ -0,0 +1,5 @@ +--- +'@sei-js/proto': minor +--- + +New gRPC methods to fetch token allow list From 31314df3c75aaf2fe9d29cdf01bb334de4d92b35 Mon Sep 17 00:00:00 2001 From: _dssei_ Date: Fri, 13 Sep 2024 11:54:30 -0700 Subject: [PATCH 3/4] include bank proto changes --- .../proto/cosmos/bank/v1beta1/bank.proto | 6 ++ .../src/codegen/cosmos/bank/v1beta1/bank.ts | 88 +++++++++++++++++++ .../proto/src/codegen/tokenfactory/query.ts | 49 +++++++++-- packages/proto/src/codegen/tokenfactory/tx.ts | 36 +++++++- 4 files changed, 167 insertions(+), 12 deletions(-) diff --git a/packages/proto/proto/cosmos/bank/v1beta1/bank.proto b/packages/proto/proto/cosmos/bank/v1beta1/bank.proto index df91008d..7fd01314 100644 --- a/packages/proto/proto/cosmos/bank/v1beta1/bank.proto +++ b/packages/proto/proto/cosmos/bank/v1beta1/bank.proto @@ -94,3 +94,9 @@ message Metadata { // Since: cosmos-sdk 0.43 string symbol = 6; } + +message AllowList { + option (gogoproto.equal) = true; + + repeated string addresses = 1 [ (gogoproto.moretags) = "yaml:\"addresses\"" ]; +} diff --git a/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts b/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts index eb09e9b0..5d63a181 100644 --- a/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts +++ b/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts @@ -269,6 +269,23 @@ export interface MetadataSDKType { name: string; symbol: string; } +export interface AllowList { + addresses: string[]; +} +export interface AllowListProtoMsg { + typeUrl: "/cosmos.bank.v1beta1.AllowList"; + value: Uint8Array; +} +export interface AllowListAmino { + addresses?: string[]; +} +export interface AllowListAminoMsg { + type: "cosmos-sdk/AllowList"; + value: AllowListAmino; +} +export interface AllowListSDKType { + addresses: string[]; +} function createBaseParams(): Params { return { sendEnabled: [], @@ -896,4 +913,75 @@ export const Metadata = { value: Metadata.encode(message).finish() }; } +}; +function createBaseAllowList(): AllowList { + return { + addresses: [] + }; +} +export const AllowList = { + typeUrl: "/cosmos.bank.v1beta1.AllowList", + encode(message: AllowList, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + for (const v of message.addresses) { + writer.uint32(10).string(v!); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number): AllowList { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseAllowList(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.addresses.push(reader.string()); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): AllowList { + const message = createBaseAllowList(); + message.addresses = object.addresses?.map(e => e) || []; + return message; + }, + fromAmino(object: AllowListAmino): AllowList { + const message = createBaseAllowList(); + message.addresses = object.addresses?.map(e => e) || []; + return message; + }, + toAmino(message: AllowList): AllowListAmino { + const obj: any = {}; + if (message.addresses) { + obj.addresses = message.addresses.map(e => e); + } else { + obj.addresses = message.addresses; + } + return obj; + }, + fromAminoMsg(object: AllowListAminoMsg): AllowList { + return AllowList.fromAmino(object.value); + }, + toAminoMsg(message: AllowList): AllowListAminoMsg { + return { + type: "cosmos-sdk/AllowList", + value: AllowList.toAmino(message) + }; + }, + fromProtoMsg(message: AllowListProtoMsg): AllowList { + return AllowList.decode(message.value); + }, + toProto(message: AllowList): Uint8Array { + return AllowList.encode(message).finish(); + }, + toProtoMsg(message: AllowList): AllowListProtoMsg { + return { + typeUrl: "/cosmos.bank.v1beta1.AllowList", + value: AllowList.encode(message).finish() + }; + } }; \ No newline at end of file diff --git a/packages/proto/src/codegen/tokenfactory/query.ts b/packages/proto/src/codegen/tokenfactory/query.ts index 49a70e00..2823e6cf 100644 --- a/packages/proto/src/codegen/tokenfactory/query.ts +++ b/packages/proto/src/codegen/tokenfactory/query.ts @@ -1,4 +1,14 @@ -import { Params, ParamsAmino, ParamsSDKType, Metadata, MetadataAmino, MetadataSDKType } from '../cosmos/bank/v1beta1/bank'; +import { + Params, + ParamsAmino, + ParamsSDKType, + Metadata, + MetadataAmino, + MetadataSDKType, + AllowList, + AllowListAmino, + AllowListSDKType +} from '../cosmos/bank/v1beta1/bank'; import { DenomAuthorityMetadata, DenomAuthorityMetadataAmino, DenomAuthorityMetadataSDKType } from './authorityMetadata'; import { BinaryReader, BinaryWriter } from '../binary'; /** QueryParamsRequest is the request type for the Query/Params RPC method. */ @@ -232,7 +242,10 @@ export interface QueryDenomAllowListRequestSDKType { * QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC * method. */ -export interface QueryDenomAllowListResponse {} +export interface QueryDenomAllowListResponse { + /** allow_list provides addresses allowed for the requested token. */ + allowList: AllowList | undefined; +} export interface QueryDenomAllowListResponseProtoMsg { typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse'; value: Uint8Array; @@ -241,7 +254,10 @@ export interface QueryDenomAllowListResponseProtoMsg { * QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC * method. */ -export interface QueryDenomAllowListResponseAmino {} +export interface QueryDenomAllowListResponseAmino { + /** allow_list provides addresses allowed for the requested token. */ + allow_list?: AllowListAmino | undefined; +} export interface QueryDenomAllowListResponseAminoMsg { type: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse'; value: QueryDenomAllowListResponseAmino; @@ -250,7 +266,9 @@ export interface QueryDenomAllowListResponseAminoMsg { * QueryDenomAllowListResponse is the response type for the DenomAllowList gRPC * method. */ -export interface QueryDenomAllowListResponseSDKType {} +export interface QueryDenomAllowListResponseSDKType { + allow_list: AllowListSDKType | undefined; +} function createBaseQueryParamsRequest(): QueryParamsRequest { return {}; } @@ -809,11 +827,16 @@ export const QueryDenomAllowListRequest = { } }; function createBaseQueryDenomAllowListResponse(): QueryDenomAllowListResponse { - return {}; + return { + allowList: AllowList.fromPartial({}) + }; } export const QueryDenomAllowListResponse = { typeUrl: '/seiprotocol.seichain.tokenfactory.QueryDenomAllowListResponse', - encode(_: QueryDenomAllowListResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + encode(message: QueryDenomAllowListResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.allowList !== undefined) { + AllowList.encode(message.allowList, writer.uint32(10).fork()).ldelim(); + } return writer; }, decode(input: BinaryReader | Uint8Array, length?: number): QueryDenomAllowListResponse { @@ -823,6 +846,9 @@ export const QueryDenomAllowListResponse = { while (reader.pos < end) { const tag = reader.uint32(); switch (tag >>> 3) { + case 1: + message.allowList = AllowList.decode(reader, reader.uint32()); + break; default: reader.skipType(tag & 7); break; @@ -830,16 +856,21 @@ export const QueryDenomAllowListResponse = { } return message; }, - fromPartial(_: Partial): QueryDenomAllowListResponse { + fromPartial(object: Partial): QueryDenomAllowListResponse { const message = createBaseQueryDenomAllowListResponse(); + message.allowList = object.allowList !== undefined && object.allowList !== null ? AllowList.fromPartial(object.allowList) : undefined; return message; }, - fromAmino(_: QueryDenomAllowListResponseAmino): QueryDenomAllowListResponse { + fromAmino(object: QueryDenomAllowListResponseAmino): QueryDenomAllowListResponse { const message = createBaseQueryDenomAllowListResponse(); + if (object.allow_list !== undefined && object.allow_list !== null) { + message.allowList = AllowList.fromAmino(object.allow_list); + } return message; }, - toAmino(_: QueryDenomAllowListResponse): QueryDenomAllowListResponseAmino { + toAmino(message: QueryDenomAllowListResponse): QueryDenomAllowListResponseAmino { const obj: any = {}; + obj.allow_list = message.allowList ? AllowList.toAmino(message.allowList) : undefined; return obj; }, fromAminoMsg(object: QueryDenomAllowListResponseAminoMsg): QueryDenomAllowListResponse { diff --git a/packages/proto/src/codegen/tokenfactory/tx.ts b/packages/proto/src/codegen/tokenfactory/tx.ts index b6c42254..21c4712a 100644 --- a/packages/proto/src/codegen/tokenfactory/tx.ts +++ b/packages/proto/src/codegen/tokenfactory/tx.ts @@ -1,5 +1,5 @@ +import { AllowList, AllowListAmino, AllowListSDKType, Metadata, MetadataAmino, MetadataSDKType } from '../cosmos/bank/v1beta1/bank'; import { Coin, CoinAmino, CoinSDKType } from '../cosmos/base/v1beta1/coin'; -import { Metadata, MetadataAmino, MetadataSDKType } from '../cosmos/bank/v1beta1/bank'; import { BinaryReader, BinaryWriter } from '../binary'; /** * MsgCreateDenom defines the message structure for the CreateDenom gRPC service @@ -16,6 +16,7 @@ export interface MsgCreateDenom { sender: string; /** subdenom can be up to 44 "alphanumeric" characters long. */ subdenom: string; + allowList?: AllowList | undefined; } export interface MsgCreateDenomProtoMsg { typeUrl: '/seiprotocol.seichain.tokenfactory.MsgCreateDenom'; @@ -36,6 +37,7 @@ export interface MsgCreateDenomAmino { sender?: string; /** subdenom can be up to 44 "alphanumeric" characters long. */ subdenom?: string; + allow_list?: AllowListAmino | undefined; } export interface MsgCreateDenomAminoMsg { type: '/seiprotocol.seichain.tokenfactory.MsgCreateDenom'; @@ -55,6 +57,7 @@ export interface MsgCreateDenomAminoMsg { export interface MsgCreateDenomSDKType { sender: string; subdenom: string; + allow_list?: AllowListSDKType | undefined; } /** * MsgCreateDenomResponse is the return value of MsgCreateDenom @@ -289,6 +292,7 @@ export interface MsgUpdateDenom { sender: string; /** subdenom can be up to 44 "alphanumeric" characters long. */ subdenom: string; + allowList?: AllowList | undefined; } export interface MsgUpdateDenomProtoMsg { typeUrl: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom'; @@ -299,6 +303,7 @@ export interface MsgUpdateDenomAmino { sender?: string; /** subdenom can be up to 44 "alphanumeric" characters long. */ subdenom?: string; + allow_list?: AllowListAmino | undefined; } export interface MsgUpdateDenomAminoMsg { type: '/seiprotocol.seichain.tokenfactory.MsgUpdateDenom'; @@ -308,6 +313,7 @@ export interface MsgUpdateDenomAminoMsg { export interface MsgUpdateDenomSDKType { sender: string; subdenom: string; + allow_list?: AllowListSDKType | undefined; } /** MsgUpdateDenomResponse defines the response structure for an executed MsgUpdateDenom message. */ export interface MsgUpdateDenomResponse {} @@ -326,7 +332,8 @@ export interface MsgUpdateDenomResponseSDKType {} function createBaseMsgCreateDenom(): MsgCreateDenom { return { sender: '', - subdenom: '' + subdenom: '', + allowList: undefined }; } export const MsgCreateDenom = { @@ -338,6 +345,9 @@ export const MsgCreateDenom = { if (message.subdenom !== '') { writer.uint32(18).string(message.subdenom); } + if (message.allowList !== undefined) { + AllowList.encode(message.allowList, writer.uint32(26).fork()).ldelim(); + } return writer; }, decode(input: BinaryReader | Uint8Array, length?: number): MsgCreateDenom { @@ -353,6 +363,9 @@ export const MsgCreateDenom = { case 2: message.subdenom = reader.string(); break; + case 3: + message.allowList = AllowList.decode(reader, reader.uint32()); + break; default: reader.skipType(tag & 7); break; @@ -364,6 +377,7 @@ export const MsgCreateDenom = { const message = createBaseMsgCreateDenom(); message.sender = object.sender ?? ''; message.subdenom = object.subdenom ?? ''; + message.allowList = object.allowList !== undefined && object.allowList !== null ? AllowList.fromPartial(object.allowList) : undefined; return message; }, fromAmino(object: MsgCreateDenomAmino): MsgCreateDenom { @@ -374,12 +388,16 @@ export const MsgCreateDenom = { if (object.subdenom !== undefined && object.subdenom !== null) { message.subdenom = object.subdenom; } + if (object.allow_list !== undefined && object.allow_list !== null) { + message.allowList = AllowList.fromAmino(object.allow_list); + } return message; }, toAmino(message: MsgCreateDenom): MsgCreateDenomAmino { const obj: any = {}; obj.sender = message.sender === '' ? undefined : message.sender; obj.subdenom = message.subdenom === '' ? undefined : message.subdenom; + obj.allow_list = message.allowList ? AllowList.toAmino(message.allowList) : undefined; return obj; }, fromAminoMsg(object: MsgCreateDenomAminoMsg): MsgCreateDenom { @@ -976,7 +994,8 @@ export const MsgSetDenomMetadataResponse = { function createBaseMsgUpdateDenom(): MsgUpdateDenom { return { sender: '', - subdenom: '' + subdenom: '', + allowList: undefined }; } export const MsgUpdateDenom = { @@ -988,6 +1007,9 @@ export const MsgUpdateDenom = { if (message.subdenom !== '') { writer.uint32(18).string(message.subdenom); } + if (message.allowList !== undefined) { + AllowList.encode(message.allowList, writer.uint32(26).fork()).ldelim(); + } return writer; }, decode(input: BinaryReader | Uint8Array, length?: number): MsgUpdateDenom { @@ -1003,6 +1025,9 @@ export const MsgUpdateDenom = { case 2: message.subdenom = reader.string(); break; + case 3: + message.allowList = AllowList.decode(reader, reader.uint32()); + break; default: reader.skipType(tag & 7); break; @@ -1014,6 +1039,7 @@ export const MsgUpdateDenom = { const message = createBaseMsgUpdateDenom(); message.sender = object.sender ?? ''; message.subdenom = object.subdenom ?? ''; + message.allowList = object.allowList !== undefined && object.allowList !== null ? AllowList.fromPartial(object.allowList) : undefined; return message; }, fromAmino(object: MsgUpdateDenomAmino): MsgUpdateDenom { @@ -1024,12 +1050,16 @@ export const MsgUpdateDenom = { if (object.subdenom !== undefined && object.subdenom !== null) { message.subdenom = object.subdenom; } + if (object.allow_list !== undefined && object.allow_list !== null) { + message.allowList = AllowList.fromAmino(object.allow_list); + } return message; }, toAmino(message: MsgUpdateDenom): MsgUpdateDenomAmino { const obj: any = {}; obj.sender = message.sender === '' ? undefined : message.sender; obj.subdenom = message.subdenom === '' ? undefined : message.subdenom; + obj.allow_list = message.allowList ? AllowList.toAmino(message.allowList) : undefined; return obj; }, fromAminoMsg(object: MsgUpdateDenomAminoMsg): MsgUpdateDenom { From 703463c35bc9ee3dc9722073605fed7003c34543 Mon Sep 17 00:00:00 2001 From: _dssei_ Date: Fri, 13 Sep 2024 12:00:27 -0700 Subject: [PATCH 4/4] add comment to proto --- packages/proto/proto/cosmos/bank/v1beta1/bank.proto | 1 + packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts | 3 +++ 2 files changed, 4 insertions(+) diff --git a/packages/proto/proto/cosmos/bank/v1beta1/bank.proto b/packages/proto/proto/cosmos/bank/v1beta1/bank.proto index 7fd01314..c28e7d42 100644 --- a/packages/proto/proto/cosmos/bank/v1beta1/bank.proto +++ b/packages/proto/proto/cosmos/bank/v1beta1/bank.proto @@ -95,6 +95,7 @@ message Metadata { string symbol = 6; } +// AllowList represents a list of allowed addresses to transact the denom. message AllowList { option (gogoproto.equal) = true; diff --git a/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts b/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts index 5d63a181..aae73196 100644 --- a/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts +++ b/packages/proto/src/codegen/cosmos/bank/v1beta1/bank.ts @@ -269,6 +269,7 @@ export interface MetadataSDKType { name: string; symbol: string; } +/** AllowList represents a list of allowed addresses to transact the denom. */ export interface AllowList { addresses: string[]; } @@ -276,6 +277,7 @@ export interface AllowListProtoMsg { typeUrl: "/cosmos.bank.v1beta1.AllowList"; value: Uint8Array; } +/** AllowList represents a list of allowed addresses to transact the denom. */ export interface AllowListAmino { addresses?: string[]; } @@ -283,6 +285,7 @@ export interface AllowListAminoMsg { type: "cosmos-sdk/AllowList"; value: AllowListAmino; } +/** AllowList represents a list of allowed addresses to transact the denom. */ export interface AllowListSDKType { addresses: string[]; }