diff --git a/packages/dispatch/package.json b/packages/dispatch/package.json index fab6884b40..8957a53a96 100644 --- a/packages/dispatch/package.json +++ b/packages/dispatch/package.json @@ -23,6 +23,7 @@ "prettier": "@dao-dao/config/prettier", "dependencies": { "@cosmjs/cosmwasm-stargate": "^0.32.3", + "@cosmjs/crypto": "^0.32.3", "@cosmjs/proto-signing": "^0.32.3" } } diff --git a/packages/dispatch/scripts/deploy.ts b/packages/dispatch/scripts/deploy.ts index 7fda28fb16..ccefcc2db3 100644 --- a/packages/dispatch/scripts/deploy.ts +++ b/packages/dispatch/scripts/deploy.ts @@ -2,6 +2,7 @@ import fs from 'fs' import path from 'path' import { SigningCosmWasmClient } from '@cosmjs/cosmwasm-stargate' +import { stringToPath as stringToHdPath } from '@cosmjs/crypto' import { DirectSecp256k1HdWallet, EncodeObject } from '@cosmjs/proto-signing' import chalk from 'chalk' import { Command } from 'commander' @@ -11,9 +12,12 @@ import { chainQueries, makeGetSignerOptions, makeReactQueryClient, - skipQueries, } from '@dao-dao/state' -import { SupportedChainConfig, cwMsgToEncodeObject } from '@dao-dao/types' +import { + ContractVersion, + SupportedChainConfig, + cwMsgToEncodeObject, +} from '@dao-dao/types' import { MsgExec } from '@dao-dao/types/protobuf/codegen/cosmos/authz/v1beta1/tx' import { MsgStoreCode } from '@dao-dao/types/protobuf/codegen/cosmwasm/wasm/v1/tx' import { AccessType } from '@dao-dao/types/protobuf/codegen/cosmwasm/wasm/v1/types' @@ -21,30 +25,42 @@ import { CHAIN_GAS_MULTIPLIER, encodeJsonToBase64, findEventsAttributeValue, + getChainForChainId, getRpcForChainId, gzipCompress, - maybeGetChainForChainId, } from '@dao-dao/utils' +const { log } = console + const { parsed: { MNEMONIC, DAO_CONTRACTS_DIR, POLYTONE_CONTRACTS_DIR } = {} } = dotenv.config() if (!MNEMONIC) { - console.error('MNEMONIC not set') + log(chalk.red('MNEMONIC not set')) process.exit(1) } if (!DAO_CONTRACTS_DIR) { - console.error('DAO_CONTRACTS_DIR not set') + log(chalk.red('DAO_CONTRACTS_DIR not set')) process.exit(1) } if (!POLYTONE_CONTRACTS_DIR) { - console.error('POLYTONE_CONTRACTS_DIR not set') + log(chalk.red('POLYTONE_CONTRACTS_DIR not set')) process.exit(1) } +enum Mode { + Dao = 'dao', + Polytone = 'polytone', + Factory = 'factory', +} + const program = new Command() program.requiredOption('-c, --chain ', 'chain ID') -program.option('-p, --polytone', 'only deploy polytone contracts') +program.option( + '-m, --mode ', + 'deploy mode (dao = deploy DAO contracts and instantiate admin factory, polytone = deploy Polytone contracts, factory = instantiate admin factory)', + 'dao' +) program.option( '-a, --authz ', 'upload contracts via authz exec as this granter' @@ -55,25 +71,28 @@ program.option( ) program.parse(process.argv) -const { chain: chainId, polytone, authz, exclude: _exclude } = program.opts() +const { chain: chainId, mode, authz, exclude: _exclude } = program.opts() const exclude: string[] | undefined = _exclude?.split(',') -const { log } = console +if (!Object.values(Mode).includes(mode)) { + log( + chalk.red('Invalid mode. Must be one of: ' + Object.values(Mode).join(', ')) + ) + process.exit(1) +} + +const codeIdMap: Record = {} const main = async () => { const queryClient = await makeReactQueryClient() - const chain = - maybeGetChainForChainId(chainId) || - // Fetch from Skip API if doesn't exist locally. - (await queryClient.fetchQuery( - skipQueries.chain(queryClient, { - chainId, - }) - )) - const chainName = chain.chain_name - const bech32Prefix = chain.bech32_prefix + const { + chain_name: chainName, + bech32_prefix: bech32Prefix, + network_type: networkType, + slip44, + } = getChainForChainId(chainId) await queryClient.prefetchQuery( chainQueries.dynamicGasPrice({ chainId: chainId }) @@ -81,6 +100,7 @@ const main = async () => { const signer = await DirectSecp256k1HdWallet.fromMnemonic(MNEMONIC, { prefix: bech32Prefix, + hdPaths: [stringToHdPath(`m/44'/${slip44}'/0'/0/0`)], }) const sender = (await signer.getAccounts())[0].address @@ -230,33 +250,39 @@ const main = async () => { label: string prefixLength: number }) => { - const { events, transactionHash } = await client.signAndBroadcast( - sender, - [ - cwMsgToEncodeObject( - chainId, - { - wasm: { - instantiate: { - code_id: codeId, - msg: encodeJsonToBase64(msg), - funds: [], - label, - admin: undefined, + let transactionHash + try { + transactionHash = await client.signAndBroadcastSync( + sender, + [ + cwMsgToEncodeObject( + chainId, + { + wasm: { + instantiate: { + code_id: codeId, + msg: encodeJsonToBase64(msg), + funds: [], + label, + admin: undefined, + }, }, }, - }, - sender - ), - ], - CHAIN_GAS_MULTIPLIER - ) - - const contractAddress = findEventsAttributeValue( - events, - 'instantiate', - '_contract_address' - ) + sender + ), + ], + CHAIN_GAS_MULTIPLIER + ) + } catch (err) { + log( + chalk.red( + `[${id}.CONTRACT]${' '.repeat( + prefixLength - id.length - 11 + )}instantiate failed` + ) + ) + throw err + } log( chalk.greenBright( @@ -266,6 +292,38 @@ const main = async () => { ) ) + // Poll for TX. + let events + let tries = 15 + while (tries > 0) { + try { + events = (await client.getTx(transactionHash))?.events + if (events) { + break + } + } catch {} + + tries-- + await new Promise((resolve) => setTimeout(resolve, 1000)) + } + + if (!events) { + log( + chalk.red( + `[${id}.CONTRACT]${' '.repeat( + prefixLength - id.length - 11 + )}TX not found` + ) + ) + process.exit(1) + } + + const contractAddress = findEventsAttributeValue( + events, + 'instantiate', + '_contract_address' + ) + if (!contractAddress) { log( chalk.red( @@ -291,7 +349,7 @@ const main = async () => { log() // Upload polytone contracts only. - if (polytone) { + if (mode === Mode.Polytone) { const contracts = [ 'polytone_listener', 'polytone_note', @@ -313,44 +371,59 @@ const main = async () => { process.exit(0) } + let consolePrefixLength = 32 + // Upload DAO contracts. + if (mode === Mode.Dao) { + // List files in the contracts directory. + const contracts = fs + .readdirSync(DAO_CONTRACTS_DIR) + .filter((file) => file.endsWith('.wasm')) + .sort() - // List files in the contracts directory. - const contracts = fs - .readdirSync(DAO_CONTRACTS_DIR) - .filter((file) => file.endsWith('.wasm')) - .sort() + // Set console prefix length to the max file length plus space for brackets + // and longest ID suffix (CONTRACT). + consolePrefixLength = Math.max(...contracts.map((file) => file.length)) + 10 - // Set console prefix length to the max file length plus space for brackets - // and longest ID suffix (CONTRACT). - const consolePrefixLength = - Math.max(...contracts.map((file) => file.length)) + 10 + for (const contract of contracts) { + const id = contract.slice(0, -5) + if (exclude?.some((substring) => id.includes(substring))) { + continue + } - const codeIdMap: Record = {} + const file = path.join(DAO_CONTRACTS_DIR, contract) - for (const contract of contracts) { - const id = contract.slice(0, -5) - if (exclude?.some((substring) => id.includes(substring))) { - continue + if (!(id in codeIdMap)) { + codeIdMap[id] = await uploadContract({ + id, + file, + prefixLength: consolePrefixLength, + }) + } else { + log( + chalk.green( + `[${id}.CODE_ID]${' '.repeat( + consolePrefixLength - id.length - 10 + )}${codeIdMap[id]}` + ) + ) + } } + } - const file = path.join(DAO_CONTRACTS_DIR, contract) - - if (!(id in codeIdMap)) { - codeIdMap[id] = await uploadContract({ - id, - file, - prefixLength: consolePrefixLength, - }) - } else { - log( - chalk.green( - `[${id}.CODE_ID]${' '.repeat(consolePrefixLength - id.length - 10)}${ - codeIdMap[id] - }` - ) - ) + // Upload just admin factory if needed. + else if (mode === Mode.Factory && !codeIdMap['cw_admin_factory']) { + const file = path.join(DAO_CONTRACTS_DIR, 'cw_admin_factory.wasm') + if (!fs.existsSync(file)) { + log(chalk.red('cw_admin_factory.wasm not found')) + process.exit(1) } + + codeIdMap['cw_admin_factory'] = await uploadContract({ + id: 'cw_admin_factory', + file, + prefixLength: consolePrefixLength, + }) } // Instantiate admin factory. @@ -374,10 +447,7 @@ const main = async () => { const config: SupportedChainConfig = { chainId, name: chainName, - mainnet: - 'is_testnet' in chain - ? !chain.is_testnet - : chain.network_type === 'mainnet', + mainnet: networkType === 'mainnet', accentColor: 'ACCENT_COLOR', factoryContractAddress: adminFactoryAddress, explorerUrlTemplates: { @@ -386,6 +456,7 @@ const main = async () => { govProp: `https://ping.pub/${chainName}/gov/REPLACE`, wallet: `https://ping.pub/${chainName}/account/REPLACE`, }, + codeIdsVersion: ContractVersion.Unknown, codeIds: { Cw1Whitelist: codeIdMap['cw1_whitelist'] ?? -1, Cw4Group: codeIdMap['cw4_group'] ?? -1, diff --git a/packages/state/recoil/selectors/chain.ts b/packages/state/recoil/selectors/chain.ts index b14083685d..31b19e1bcf 100644 --- a/packages/state/recoil/selectors/chain.ts +++ b/packages/state/recoil/selectors/chain.ts @@ -50,6 +50,7 @@ import { Params as NobleTariffParams } from '@dao-dao/types/protobuf/codegen/tar import { MAINNET, SecretCosmWasmClient, + bitsongProtoRpcClientRouter, cosmosProtoRpcClientRouter, cosmosSdkVersionIs46OrHigher, cosmosSdkVersionIs47OrHigher, @@ -394,6 +395,15 @@ export const tokenFactoryDenomCreationFeeSelector = selectorFamily< return params?.creationFee } + if ( + chainId === ChainId.BitsongMainnet || + chainId === ChainId.BitsongTestnet + ) { + const bitsongClient = await bitsongProtoRpcClientRouter.connect(chainId) + const { params } = await bitsongClient.fantoken.v1beta1.params() + return params?.issueFee && [params.issueFee] + } + const osmosisClient = get(osmosisRpcClientForChainSelector(chainId)) try { return (await osmosisClient.tokenfactory.v1beta1.params()).params diff --git a/packages/stateful/clients/voting-module/TokenStakedVotingModule.ts b/packages/stateful/clients/voting-module/TokenStakedVotingModule.ts index 4641e1b771..c1f76b89e4 100644 --- a/packages/stateful/clients/voting-module/TokenStakedVotingModule.ts +++ b/packages/stateful/clients/voting-module/TokenStakedVotingModule.ts @@ -110,14 +110,12 @@ export class TokenStakedVotingModule extends VotingModuleBase { } : { factory: encodeJsonToBase64({ - wasm: { - execute: { - contract_addr: config.token.factory.address, - funds: config.token.factory.funds || [], - msg: encodeJsonToBase64(config.token.factory.message), - }, - } as WasmMsg, - }), + execute: { + contract_addr: config.token.factory.address, + funds: config.token.factory.funds || [], + msg: encodeJsonToBase64(config.token.factory.message), + }, + } as WasmMsg), }, unstaking_duration: config.unstakingDuration, } as InstantiateMsg), diff --git a/packages/stateful/creators/TokenBased/getInstantiateInfo.ts b/packages/stateful/creators/TokenBased/getInstantiateInfo.ts index add38945ab..2a26dd0a99 100644 --- a/packages/stateful/creators/TokenBased/getInstantiateInfo.ts +++ b/packages/stateful/creators/TokenBased/getInstantiateInfo.ts @@ -1,4 +1,5 @@ -import { DaoCreatorGetInstantiateInfo } from '@dao-dao/types' +import { ChainId, DaoCreatorGetInstantiateInfo } from '@dao-dao/types' +import { ExecuteMsg as BtsgFtFactoryExecuteMsg } from '@dao-dao/types/contracts/BtsgFtFactory' import { InitialBalance } from '@dao-dao/types/contracts/DaoVotingTokenStaked' import { NEW_DAO_TOKEN_DECIMALS, @@ -15,7 +16,7 @@ import { SecretTokenStakedVotingModule } from '../../clients/voting-module/Token import { CreatorData, GovernanceTokenType } from './types' export const getInstantiateInfo: DaoCreatorGetInstantiateInfo = ({ - chainConfig: { createWithCw20 }, + chainConfig: { createWithCw20, tokenCreationFactoryAddress }, newDao: { chainId, name: daoName }, data: { tiers, @@ -89,8 +90,52 @@ export const getInstantiateInfo: DaoCreatorGetInstantiateInfo = ({ ) } - return isNative - ? TokenStakedVotingModule.generateModuleInstantiateInfo( + if (isNative) { + // New BitSong Fantoken + if ( + chainId === ChainId.BitsongMainnet || + chainId === ChainId.BitsongTestnet + ) { + if (!tokenCreationFactoryAddress) { + throw new Error('tokenCreationFactoryAddress not set') + } + + const fantokenExecute: BtsgFtFactoryExecuteMsg = { + issue: { + symbol, + name, + // TODO(bitsong-fantoken-factory) + max_supply: ( + microInitialBalances.reduce( + (acc, { amount }) => acc + BigInt(amount), + 0n + ) + BigInt(microInitialTreasuryBalance) + ).toString(), + // TODO(bitsong-fantoken-factory) + uri: '', + initial_balances: microInitialBalances, + initial_dao_balance: microInitialTreasuryBalance, + }, + } + + return TokenStakedVotingModule.generateModuleInstantiateInfo( + chainId, + daoName, + { + ...commonConfig, + unstakingDuration, + token: { + factory: { + address: tokenCreationFactoryAddress, + message: fantokenExecute, + funds: tokenFactoryDenomCreationFee, + }, + }, + } + ) + } else { + // New tokenfactory token + return TokenStakedVotingModule.generateModuleInstantiateInfo( chainId, daoName, { @@ -108,23 +153,26 @@ export const getInstantiateInfo: DaoCreatorGetInstantiateInfo = ({ }, } ) - : (isSecret - ? SecretSnip20StakedVotingModule - : Cw20StakedVotingModule - ).generateModuleInstantiateInfo(chainId, daoName, { - ...commonConfig, - token: { - new: { - symbol, - decimals: NEW_DAO_TOKEN_DECIMALS, - name: symbol, - initialBalances: microInitialBalances, - initialDaoBalance: microInitialTreasuryBalance, - marketingInfo: imageUrl ? { logo: { url: imageUrl } } : null, - unstakingDuration, - }, + } + } else { + // New CW20 / SNIP20 + return ( + isSecret ? SecretSnip20StakedVotingModule : Cw20StakedVotingModule + ).generateModuleInstantiateInfo(chainId, daoName, { + ...commonConfig, + token: { + new: { + symbol, + decimals: NEW_DAO_TOKEN_DECIMALS, + name: symbol, + initialBalances: microInitialBalances, + initialDaoBalance: microInitialTreasuryBalance, + marketingInfo: imageUrl ? { logo: { url: imageUrl } } : null, + unstakingDuration, }, - }) + }, + }) + } } else { if (!existingTokenDenomOrAddress) { throw new Error(t('error.missingGovernanceTokenDenom')) diff --git a/packages/stateless/components/dao/create/pages/CreateDaoReview.tsx b/packages/stateless/components/dao/create/pages/CreateDaoReview.tsx index 31e26b99db..caf805ffc5 100644 --- a/packages/stateless/components/dao/create/pages/CreateDaoReview.tsx +++ b/packages/stateless/components/dao/create/pages/CreateDaoReview.tsx @@ -43,10 +43,10 @@ export const CreateDaoReview = ({ throw new Error(t('error.daoCreationIncomplete')) } - const msg = cloneDeep(instantiateMsg) + const msg: any = cloneDeep(instantiateMsg) // Convert encoded module instantiation messages back to readable JSON. if (decodeModuleMessages) { - msg.proposal_modules_instantiate_info.forEach((info) => { + msg.proposal_modules_instantiate_info.forEach((info: any) => { const msg = decodeJsonFromBase64(info.msg) // Convert encoded pre_propose_info message back to readable JSON. @@ -69,9 +69,29 @@ export const CreateDaoReview = ({ info.msg = msg }) + msg.voting_module_instantiate_info.msg = decodeJsonFromBase64( msg.voting_module_instantiate_info.msg ) + // Convert encoded token_info.factory message back to readable JSON. + if ( + objectMatchesStructure(msg.voting_module_instantiate_info.msg, { + token_info: { + factory: {}, + }, + }) + ) { + msg.voting_module_instantiate_info.msg.token_info.factory = + decodeJsonFromBase64( + msg.voting_module_instantiate_info.msg.token_info.factory + ) + + msg.voting_module_instantiate_info.msg.token_info.factory.execute.msg = + decodeJsonFromBase64( + msg.voting_module_instantiate_info.msg.token_info.factory.execute + .msg + ) + } } // Pretty print output. previewJson = JSON.stringify(msg, undefined, 2) diff --git a/packages/types/chain.ts b/packages/types/chain.ts index 19f0047f4b..0566465aec 100644 --- a/packages/types/chain.ts +++ b/packages/types/chain.ts @@ -174,6 +174,10 @@ export type SupportedChainConfig = BaseChainConfig & { * to false. */ nftDaosUnderDevelopment?: boolean + /** + * Token creation factory address to use during DAO creation. + */ + tokenCreationFactoryAddress?: string /** * Whether or not to create a DAO through chain governance. */ diff --git a/packages/types/contracts/BtsgFtFactory.ts b/packages/types/contracts/BtsgFtFactory.ts new file mode 100644 index 0000000000..a20a505bf8 --- /dev/null +++ b/packages/types/contracts/BtsgFtFactory.ts @@ -0,0 +1,25 @@ +/** + * This file was automatically generated by @cosmwasm/ts-codegen@1.10.0. + * DO NOT MODIFY IT BY HAND. Instead, modify the source JSONSchema file, + * and run the @cosmwasm/ts-codegen generate command to regenerate this file. + */ + +export interface InstantiateMsg {} +export type ExecuteMsg = { + issue: NewFanToken +} +export type Uint128 = string +export interface NewFanToken { + initial_balances: InitialBalance[] + initial_dao_balance?: Uint128 | null + max_supply: Uint128 + name: string + symbol: string + uri: string +} +export interface InitialBalance { + address: string + amount: Uint128 +} +export type QueryMsg = string +export interface MigrateMsg {} diff --git a/packages/types/protobuf/codegen/alliance/bundle.ts b/packages/types/protobuf/codegen/alliance/bundle.ts index b65aac5b72..7ec9d42d7b 100644 --- a/packages/types/protobuf/codegen/alliance/bundle.ts +++ b/packages/types/protobuf/codegen/alliance/bundle.ts @@ -12,8 +12,8 @@ import * as _369 from "./alliance/tx.amino"; import * as _370 from "./alliance/tx.registry"; import * as _371 from "./alliance/query.rpc.Query"; import * as _372 from "./alliance/tx.rpc.msg"; -import * as _624 from "./rpc.query"; -import * as _625 from "./rpc.tx"; +import * as _625 from "./rpc.query"; +import * as _626 from "./rpc.tx"; export namespace alliance { export const alliance = { ..._0, @@ -32,7 +32,7 @@ export namespace alliance { ..._372 }; export const ClientFactory = { - ..._624, - ..._625 + ..._625, + ..._626 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/bundle.ts b/packages/types/protobuf/codegen/bitsong/bundle.ts index 580f4a0bfa..57c7abc40d 100644 --- a/packages/types/protobuf/codegen/bitsong/bundle.ts +++ b/packages/types/protobuf/codegen/bitsong/bundle.ts @@ -1,16 +1,22 @@ import * as _11 from "./fantoken/v1beta1/tx"; import * as _373 from "./fantoken/v1beta1/tx.amino"; import * as _374 from "./fantoken/v1beta1/tx.registry"; -import * as _375 from "./fantoken/v1beta1/tx.rpc.msg"; -import * as _626 from "./rpc.tx"; +import * as _375 from "./fantoken/v1beta1/query.rpc.Query"; +import * as _376 from "./fantoken/v1beta1/tx.rpc.msg"; +import * as _627 from "./rpc.query"; +import * as _628 from "./rpc.tx"; export namespace bitsong { export const fantoken = { ..._11, ..._373, ..._374, - ..._375 + ..._376, + v1beta1: { + ..._375 + } }; export const ClientFactory = { - ..._626 + ..._627, + ..._628 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/events.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/events.ts new file mode 100644 index 0000000000..ad4b09d527 --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/events.ts @@ -0,0 +1,651 @@ +import { BinaryReader, BinaryWriter } from "../../../binary"; +export interface EventIssue { + denom: string; +} +export interface EventIssueProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventIssue"; + value: Uint8Array; +} +export interface EventIssueAmino { + denom?: string; +} +export interface EventIssueAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventIssue"; + value: EventIssueAmino; +} +export interface EventIssueSDKType { + denom: string; +} +export interface EventDisableMint { + denom: string; +} +export interface EventDisableMintProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventDisableMint"; + value: Uint8Array; +} +export interface EventDisableMintAmino { + denom?: string; +} +export interface EventDisableMintAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventDisableMint"; + value: EventDisableMintAmino; +} +export interface EventDisableMintSDKType { + denom: string; +} +export interface EventMint { + recipient: string; + coin: string; +} +export interface EventMintProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventMint"; + value: Uint8Array; +} +export interface EventMintAmino { + recipient?: string; + coin?: string; +} +export interface EventMintAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventMint"; + value: EventMintAmino; +} +export interface EventMintSDKType { + recipient: string; + coin: string; +} +export interface EventBurn { + sender: string; + coin: string; +} +export interface EventBurnProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventBurn"; + value: Uint8Array; +} +export interface EventBurnAmino { + sender?: string; + coin?: string; +} +export interface EventBurnAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventBurn"; + value: EventBurnAmino; +} +export interface EventBurnSDKType { + sender: string; + coin: string; +} +export interface EventSetAuthority { + denom: string; + oldAuthority: string; + newAuthority: string; +} +export interface EventSetAuthorityProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetAuthority"; + value: Uint8Array; +} +export interface EventSetAuthorityAmino { + denom?: string; + old_authority?: string; + new_authority?: string; +} +export interface EventSetAuthorityAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventSetAuthority"; + value: EventSetAuthorityAmino; +} +export interface EventSetAuthoritySDKType { + denom: string; + old_authority: string; + new_authority: string; +} +export interface EventSetMinter { + denom: string; + oldMinter: string; + newMinter: string; +} +export interface EventSetMinterProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetMinter"; + value: Uint8Array; +} +export interface EventSetMinterAmino { + denom?: string; + old_minter?: string; + new_minter?: string; +} +export interface EventSetMinterAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventSetMinter"; + value: EventSetMinterAmino; +} +export interface EventSetMinterSDKType { + denom: string; + old_minter: string; + new_minter: string; +} +export interface EventSetUri { + denom: string; +} +export interface EventSetUriProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetUri"; + value: Uint8Array; +} +export interface EventSetUriAmino { + denom?: string; +} +export interface EventSetUriAminoMsg { + type: "/bitsong.fantoken.v1beta1.EventSetUri"; + value: EventSetUriAmino; +} +export interface EventSetUriSDKType { + denom: string; +} +function createBaseEventIssue(): EventIssue { + return { + denom: "" + }; +} +export const EventIssue = { + typeUrl: "/bitsong.fantoken.v1beta1.EventIssue", + encode(message: EventIssue, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventIssue { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventIssue(); + 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): EventIssue { + const message = createBaseEventIssue(); + message.denom = object.denom ?? ""; + return message; + }, + fromAmino(object: EventIssueAmino): EventIssue { + const message = createBaseEventIssue(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + return message; + }, + toAmino(message: EventIssue, useInterfaces: boolean = false): EventIssueAmino { + const obj: any = {}; + obj.denom = message.denom; + return obj; + }, + fromAminoMsg(object: EventIssueAminoMsg): EventIssue { + return EventIssue.fromAmino(object.value); + }, + fromProtoMsg(message: EventIssueProtoMsg, useInterfaces: boolean = false): EventIssue { + return EventIssue.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventIssue): Uint8Array { + return EventIssue.encode(message).finish(); + }, + toProtoMsg(message: EventIssue): EventIssueProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventIssue", + value: EventIssue.encode(message).finish() + }; + } +}; +function createBaseEventDisableMint(): EventDisableMint { + return { + denom: "" + }; +} +export const EventDisableMint = { + typeUrl: "/bitsong.fantoken.v1beta1.EventDisableMint", + encode(message: EventDisableMint, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventDisableMint { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventDisableMint(); + 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): EventDisableMint { + const message = createBaseEventDisableMint(); + message.denom = object.denom ?? ""; + return message; + }, + fromAmino(object: EventDisableMintAmino): EventDisableMint { + const message = createBaseEventDisableMint(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + return message; + }, + toAmino(message: EventDisableMint, useInterfaces: boolean = false): EventDisableMintAmino { + const obj: any = {}; + obj.denom = message.denom; + return obj; + }, + fromAminoMsg(object: EventDisableMintAminoMsg): EventDisableMint { + return EventDisableMint.fromAmino(object.value); + }, + fromProtoMsg(message: EventDisableMintProtoMsg, useInterfaces: boolean = false): EventDisableMint { + return EventDisableMint.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventDisableMint): Uint8Array { + return EventDisableMint.encode(message).finish(); + }, + toProtoMsg(message: EventDisableMint): EventDisableMintProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventDisableMint", + value: EventDisableMint.encode(message).finish() + }; + } +}; +function createBaseEventMint(): EventMint { + return { + recipient: "", + coin: "" + }; +} +export const EventMint = { + typeUrl: "/bitsong.fantoken.v1beta1.EventMint", + encode(message: EventMint, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.recipient !== "") { + writer.uint32(10).string(message.recipient); + } + if (message.coin !== "") { + writer.uint32(18).string(message.coin); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventMint { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventMint(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.recipient = reader.string(); + break; + case 2: + message.coin = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): EventMint { + const message = createBaseEventMint(); + message.recipient = object.recipient ?? ""; + message.coin = object.coin ?? ""; + return message; + }, + fromAmino(object: EventMintAmino): EventMint { + const message = createBaseEventMint(); + if (object.recipient !== undefined && object.recipient !== null) { + message.recipient = object.recipient; + } + if (object.coin !== undefined && object.coin !== null) { + message.coin = object.coin; + } + return message; + }, + toAmino(message: EventMint, useInterfaces: boolean = false): EventMintAmino { + const obj: any = {}; + obj.recipient = message.recipient; + obj.coin = message.coin; + return obj; + }, + fromAminoMsg(object: EventMintAminoMsg): EventMint { + return EventMint.fromAmino(object.value); + }, + fromProtoMsg(message: EventMintProtoMsg, useInterfaces: boolean = false): EventMint { + return EventMint.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventMint): Uint8Array { + return EventMint.encode(message).finish(); + }, + toProtoMsg(message: EventMint): EventMintProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventMint", + value: EventMint.encode(message).finish() + }; + } +}; +function createBaseEventBurn(): EventBurn { + return { + sender: "", + coin: "" + }; +} +export const EventBurn = { + typeUrl: "/bitsong.fantoken.v1beta1.EventBurn", + encode(message: EventBurn, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.sender !== "") { + writer.uint32(10).string(message.sender); + } + if (message.coin !== "") { + writer.uint32(18).string(message.coin); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventBurn { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventBurn(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.sender = reader.string(); + break; + case 2: + message.coin = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): EventBurn { + const message = createBaseEventBurn(); + message.sender = object.sender ?? ""; + message.coin = object.coin ?? ""; + return message; + }, + fromAmino(object: EventBurnAmino): EventBurn { + const message = createBaseEventBurn(); + if (object.sender !== undefined && object.sender !== null) { + message.sender = object.sender; + } + if (object.coin !== undefined && object.coin !== null) { + message.coin = object.coin; + } + return message; + }, + toAmino(message: EventBurn, useInterfaces: boolean = false): EventBurnAmino { + const obj: any = {}; + obj.sender = message.sender; + obj.coin = message.coin; + return obj; + }, + fromAminoMsg(object: EventBurnAminoMsg): EventBurn { + return EventBurn.fromAmino(object.value); + }, + fromProtoMsg(message: EventBurnProtoMsg, useInterfaces: boolean = false): EventBurn { + return EventBurn.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventBurn): Uint8Array { + return EventBurn.encode(message).finish(); + }, + toProtoMsg(message: EventBurn): EventBurnProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventBurn", + value: EventBurn.encode(message).finish() + }; + } +}; +function createBaseEventSetAuthority(): EventSetAuthority { + return { + denom: "", + oldAuthority: "", + newAuthority: "" + }; +} +export const EventSetAuthority = { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetAuthority", + encode(message: EventSetAuthority, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.oldAuthority !== "") { + writer.uint32(18).string(message.oldAuthority); + } + if (message.newAuthority !== "") { + writer.uint32(26).string(message.newAuthority); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventSetAuthority { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventSetAuthority(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.oldAuthority = reader.string(); + break; + case 3: + message.newAuthority = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): EventSetAuthority { + const message = createBaseEventSetAuthority(); + message.denom = object.denom ?? ""; + message.oldAuthority = object.oldAuthority ?? ""; + message.newAuthority = object.newAuthority ?? ""; + return message; + }, + fromAmino(object: EventSetAuthorityAmino): EventSetAuthority { + const message = createBaseEventSetAuthority(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + if (object.old_authority !== undefined && object.old_authority !== null) { + message.oldAuthority = object.old_authority; + } + if (object.new_authority !== undefined && object.new_authority !== null) { + message.newAuthority = object.new_authority; + } + return message; + }, + toAmino(message: EventSetAuthority, useInterfaces: boolean = false): EventSetAuthorityAmino { + const obj: any = {}; + obj.denom = message.denom; + obj.old_authority = message.oldAuthority; + obj.new_authority = message.newAuthority; + return obj; + }, + fromAminoMsg(object: EventSetAuthorityAminoMsg): EventSetAuthority { + return EventSetAuthority.fromAmino(object.value); + }, + fromProtoMsg(message: EventSetAuthorityProtoMsg, useInterfaces: boolean = false): EventSetAuthority { + return EventSetAuthority.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventSetAuthority): Uint8Array { + return EventSetAuthority.encode(message).finish(); + }, + toProtoMsg(message: EventSetAuthority): EventSetAuthorityProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetAuthority", + value: EventSetAuthority.encode(message).finish() + }; + } +}; +function createBaseEventSetMinter(): EventSetMinter { + return { + denom: "", + oldMinter: "", + newMinter: "" + }; +} +export const EventSetMinter = { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetMinter", + encode(message: EventSetMinter, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.oldMinter !== "") { + writer.uint32(18).string(message.oldMinter); + } + if (message.newMinter !== "") { + writer.uint32(26).string(message.newMinter); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventSetMinter { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventSetMinter(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.oldMinter = reader.string(); + break; + case 3: + message.newMinter = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): EventSetMinter { + const message = createBaseEventSetMinter(); + message.denom = object.denom ?? ""; + message.oldMinter = object.oldMinter ?? ""; + message.newMinter = object.newMinter ?? ""; + return message; + }, + fromAmino(object: EventSetMinterAmino): EventSetMinter { + const message = createBaseEventSetMinter(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + if (object.old_minter !== undefined && object.old_minter !== null) { + message.oldMinter = object.old_minter; + } + if (object.new_minter !== undefined && object.new_minter !== null) { + message.newMinter = object.new_minter; + } + return message; + }, + toAmino(message: EventSetMinter, useInterfaces: boolean = false): EventSetMinterAmino { + const obj: any = {}; + obj.denom = message.denom; + obj.old_minter = message.oldMinter; + obj.new_minter = message.newMinter; + return obj; + }, + fromAminoMsg(object: EventSetMinterAminoMsg): EventSetMinter { + return EventSetMinter.fromAmino(object.value); + }, + fromProtoMsg(message: EventSetMinterProtoMsg, useInterfaces: boolean = false): EventSetMinter { + return EventSetMinter.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventSetMinter): Uint8Array { + return EventSetMinter.encode(message).finish(); + }, + toProtoMsg(message: EventSetMinter): EventSetMinterProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetMinter", + value: EventSetMinter.encode(message).finish() + }; + } +}; +function createBaseEventSetUri(): EventSetUri { + return { + denom: "" + }; +} +export const EventSetUri = { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetUri", + encode(message: EventSetUri, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): EventSetUri { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseEventSetUri(); + 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): EventSetUri { + const message = createBaseEventSetUri(); + message.denom = object.denom ?? ""; + return message; + }, + fromAmino(object: EventSetUriAmino): EventSetUri { + const message = createBaseEventSetUri(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + return message; + }, + toAmino(message: EventSetUri, useInterfaces: boolean = false): EventSetUriAmino { + const obj: any = {}; + obj.denom = message.denom; + return obj; + }, + fromAminoMsg(object: EventSetUriAminoMsg): EventSetUri { + return EventSetUri.fromAmino(object.value); + }, + fromProtoMsg(message: EventSetUriProtoMsg, useInterfaces: boolean = false): EventSetUri { + return EventSetUri.decode(message.value, undefined, useInterfaces); + }, + toProto(message: EventSetUri): Uint8Array { + return EventSetUri.encode(message).finish(); + }, + toProtoMsg(message: EventSetUri): EventSetUriProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.EventSetUri", + value: EventSetUri.encode(message).finish() + }; + } +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/fantoken.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/fantoken.ts new file mode 100644 index 0000000000..1993fbdc46 --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/fantoken.ts @@ -0,0 +1,272 @@ +import { BinaryReader, BinaryWriter } from "../../../binary"; +export interface Metadata { + /** name defines the name of the fantoken (eg: Kitty Punk) */ + name: string; + /** symbol is the token symbol usually shown on exchanges (eg: KITTY) */ + symbol: string; + /** + * URI to a document (on or off-chain) that contains additional + * information.Optional. + */ + uri: string; + /** sdk.AccAddress allowed to set a new uri */ + authority: string; +} +export interface MetadataProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.Metadata"; + value: Uint8Array; +} +export interface MetadataAmino { + /** name defines the name of the fantoken (eg: Kitty Punk) */ + name?: string; + /** symbol is the token symbol usually shown on exchanges (eg: KITTY) */ + symbol?: string; + /** + * URI to a document (on or off-chain) that contains additional + * information.Optional. + */ + uri?: string; + /** sdk.AccAddress allowed to set a new uri */ + authority?: string; +} +export interface MetadataAminoMsg { + type: "/bitsong.fantoken.v1beta1.Metadata"; + value: MetadataAmino; +} +export interface MetadataSDKType { + name: string; + symbol: string; + uri: string; + authority: string; +} +/** FanToken defines a standard for the fungible token */ +export interface FanToken { + /** denom represents the string name of the given denom unit (e.g ft). */ + denom: string; + maxSupply: string; + /** sdk.AccAddress allowed to mint new fantoken */ + minter: string; + metaData: Metadata | undefined; +} +export interface FanTokenProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.FanToken"; + value: Uint8Array; +} +/** FanToken defines a standard for the fungible token */ +export interface FanTokenAmino { + /** denom represents the string name of the given denom unit (e.g ft). */ + denom?: string; + max_supply?: string; + /** sdk.AccAddress allowed to mint new fantoken */ + minter?: string; + meta_data?: MetadataAmino | undefined; +} +export interface FanTokenAminoMsg { + type: "/bitsong.fantoken.v1beta1.FanToken"; + value: FanTokenAmino; +} +/** FanToken defines a standard for the fungible token */ +export interface FanTokenSDKType { + denom: string; + max_supply: string; + minter: string; + meta_data: MetadataSDKType | undefined; +} +function createBaseMetadata(): Metadata { + return { + name: "", + symbol: "", + uri: "", + authority: "" + }; +} +export const Metadata = { + typeUrl: "/bitsong.fantoken.v1beta1.Metadata", + encode(message: Metadata, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.name !== "") { + writer.uint32(10).string(message.name); + } + if (message.symbol !== "") { + writer.uint32(18).string(message.symbol); + } + if (message.uri !== "") { + writer.uint32(26).string(message.uri); + } + if (message.authority !== "") { + writer.uint32(34).string(message.authority); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): Metadata { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseMetadata(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.name = reader.string(); + break; + case 2: + message.symbol = reader.string(); + break; + case 3: + message.uri = reader.string(); + break; + case 4: + message.authority = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): Metadata { + const message = createBaseMetadata(); + message.name = object.name ?? ""; + message.symbol = object.symbol ?? ""; + message.uri = object.uri ?? ""; + message.authority = object.authority ?? ""; + return message; + }, + fromAmino(object: MetadataAmino): Metadata { + const message = createBaseMetadata(); + if (object.name !== undefined && object.name !== null) { + message.name = object.name; + } + if (object.symbol !== undefined && object.symbol !== null) { + message.symbol = object.symbol; + } + if (object.uri !== undefined && object.uri !== null) { + message.uri = object.uri; + } + if (object.authority !== undefined && object.authority !== null) { + message.authority = object.authority; + } + return message; + }, + toAmino(message: Metadata, useInterfaces: boolean = false): MetadataAmino { + const obj: any = {}; + obj.name = message.name; + obj.symbol = message.symbol; + obj.uri = message.uri; + obj.authority = message.authority; + return obj; + }, + fromAminoMsg(object: MetadataAminoMsg): Metadata { + return Metadata.fromAmino(object.value); + }, + fromProtoMsg(message: MetadataProtoMsg, useInterfaces: boolean = false): Metadata { + return Metadata.decode(message.value, undefined, useInterfaces); + }, + toProto(message: Metadata): Uint8Array { + return Metadata.encode(message).finish(); + }, + toProtoMsg(message: Metadata): MetadataProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.Metadata", + value: Metadata.encode(message).finish() + }; + } +}; +function createBaseFanToken(): FanToken { + return { + denom: "", + maxSupply: "", + minter: "", + metaData: Metadata.fromPartial({}) + }; +} +export const FanToken = { + typeUrl: "/bitsong.fantoken.v1beta1.FanToken", + encode(message: FanToken, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + if (message.maxSupply !== "") { + writer.uint32(18).string(message.maxSupply); + } + if (message.minter !== "") { + writer.uint32(26).string(message.minter); + } + if (message.metaData !== undefined) { + Metadata.encode(message.metaData, writer.uint32(34).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): FanToken { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseFanToken(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.denom = reader.string(); + break; + case 2: + message.maxSupply = reader.string(); + break; + case 3: + message.minter = reader.string(); + break; + case 4: + message.metaData = Metadata.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): FanToken { + const message = createBaseFanToken(); + message.denom = object.denom ?? ""; + message.maxSupply = object.maxSupply ?? ""; + message.minter = object.minter ?? ""; + message.metaData = object.metaData !== undefined && object.metaData !== null ? Metadata.fromPartial(object.metaData) : undefined; + return message; + }, + fromAmino(object: FanTokenAmino): FanToken { + const message = createBaseFanToken(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + if (object.max_supply !== undefined && object.max_supply !== null) { + message.maxSupply = object.max_supply; + } + if (object.minter !== undefined && object.minter !== null) { + message.minter = object.minter; + } + if (object.meta_data !== undefined && object.meta_data !== null) { + message.metaData = Metadata.fromAmino(object.meta_data); + } + return message; + }, + toAmino(message: FanToken, useInterfaces: boolean = false): FanTokenAmino { + const obj: any = {}; + obj.denom = message.denom; + obj.max_supply = message.maxSupply; + obj.minter = message.minter; + obj.meta_data = message.metaData ? Metadata.toAmino(message.metaData, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: FanTokenAminoMsg): FanToken { + return FanToken.fromAmino(object.value); + }, + fromProtoMsg(message: FanTokenProtoMsg, useInterfaces: boolean = false): FanToken { + return FanToken.decode(message.value, undefined, useInterfaces); + }, + toProto(message: FanToken): Uint8Array { + return FanToken.encode(message).finish(); + }, + toProtoMsg(message: FanToken): FanTokenProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.FanToken", + value: FanToken.encode(message).finish() + }; + } +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/genesis.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/genesis.ts new file mode 100644 index 0000000000..666d29e608 --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/genesis.ts @@ -0,0 +1,104 @@ +//@ts-nocheck +import { Params, ParamsAmino, ParamsSDKType } from "./params"; +import { FanToken, FanTokenAmino, FanTokenSDKType } from "./fantoken"; +import { BinaryReader, BinaryWriter } from "../../../binary"; +/** GenesisState defines the fantoken module's genesis state */ +export interface GenesisState { + params: Params | undefined; + fanTokens: FanToken[]; +} +export interface GenesisStateProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.GenesisState"; + value: Uint8Array; +} +/** GenesisState defines the fantoken module's genesis state */ +export interface GenesisStateAmino { + params?: ParamsAmino | undefined; + fan_tokens?: FanTokenAmino[]; +} +export interface GenesisStateAminoMsg { + type: "/bitsong.fantoken.v1beta1.GenesisState"; + value: GenesisStateAmino; +} +/** GenesisState defines the fantoken module's genesis state */ +export interface GenesisStateSDKType { + params: ParamsSDKType | undefined; + fan_tokens: FanTokenSDKType[]; +} +function createBaseGenesisState(): GenesisState { + return { + params: Params.fromPartial({}), + fanTokens: [] + }; +} +export const GenesisState = { + typeUrl: "/bitsong.fantoken.v1beta1.GenesisState", + encode(message: GenesisState, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.params !== undefined) { + Params.encode(message.params, writer.uint32(10).fork()).ldelim(); + } + for (const v of message.fanTokens) { + FanToken.encode(v!, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): GenesisState { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseGenesisState(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.params = Params.decode(reader, reader.uint32(), useInterfaces); + break; + case 2: + message.fanTokens.push(FanToken.decode(reader, reader.uint32(), useInterfaces)); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): GenesisState { + const message = createBaseGenesisState(); + message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined; + message.fanTokens = object.fanTokens?.map(e => FanToken.fromPartial(e)) || []; + return message; + }, + fromAmino(object: GenesisStateAmino): GenesisState { + const message = createBaseGenesisState(); + if (object.params !== undefined && object.params !== null) { + message.params = Params.fromAmino(object.params); + } + message.fanTokens = object.fan_tokens?.map(e => FanToken.fromAmino(e)) || []; + return message; + }, + toAmino(message: GenesisState, useInterfaces: boolean = false): GenesisStateAmino { + const obj: any = {}; + obj.params = message.params ? Params.toAmino(message.params, useInterfaces) : undefined; + if (message.fanTokens) { + obj.fan_tokens = message.fanTokens.map(e => e ? FanToken.toAmino(e, useInterfaces) : undefined); + } else { + obj.fan_tokens = []; + } + return obj; + }, + fromAminoMsg(object: GenesisStateAminoMsg): GenesisState { + return GenesisState.fromAmino(object.value); + }, + fromProtoMsg(message: GenesisStateProtoMsg, useInterfaces: boolean = false): GenesisState { + return GenesisState.decode(message.value, undefined, useInterfaces); + }, + toProto(message: GenesisState): Uint8Array { + return GenesisState.encode(message).finish(); + }, + toProtoMsg(message: GenesisState): GenesisStateProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.GenesisState", + value: GenesisState.encode(message).finish() + }; + } +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/gov.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/gov.ts new file mode 100644 index 0000000000..15fedf0140 --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/gov.ts @@ -0,0 +1,298 @@ +//@ts-nocheck +import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin"; +import { BinaryReader, BinaryWriter } from "../../../binary"; +export interface UpdateFeesProposal { + title: string; + description: string; + issueFee: Coin | undefined; + mintFee: Coin | undefined; + burnFee: Coin | undefined; +} +export interface UpdateFeesProposalProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.UpdateFeesProposal"; + value: Uint8Array; +} +export interface UpdateFeesProposalAmino { + title?: string; + description?: string; + issue_fee?: CoinAmino | undefined; + mint_fee?: CoinAmino | undefined; + burn_fee?: CoinAmino | undefined; +} +export interface UpdateFeesProposalAminoMsg { + type: "/bitsong.fantoken.v1beta1.UpdateFeesProposal"; + value: UpdateFeesProposalAmino; +} +export interface UpdateFeesProposalSDKType { + title: string; + description: string; + issue_fee: CoinSDKType | undefined; + mint_fee: CoinSDKType | undefined; + burn_fee: CoinSDKType | undefined; +} +export interface UpdateFeesProposalWithDeposit { + title: string; + description: string; + issueFee: string; + mintFee: string; + burnFee: string; + deposit: string; +} +export interface UpdateFeesProposalWithDepositProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.UpdateFeesProposalWithDeposit"; + value: Uint8Array; +} +export interface UpdateFeesProposalWithDepositAmino { + title?: string; + description?: string; + issue_fee?: string; + mint_fee?: string; + burn_fee?: string; + deposit?: string; +} +export interface UpdateFeesProposalWithDepositAminoMsg { + type: "/bitsong.fantoken.v1beta1.UpdateFeesProposalWithDeposit"; + value: UpdateFeesProposalWithDepositAmino; +} +export interface UpdateFeesProposalWithDepositSDKType { + title: string; + description: string; + issue_fee: string; + mint_fee: string; + burn_fee: string; + deposit: string; +} +function createBaseUpdateFeesProposal(): UpdateFeesProposal { + return { + title: "", + description: "", + issueFee: Coin.fromPartial({}), + mintFee: Coin.fromPartial({}), + burnFee: Coin.fromPartial({}) + }; +} +export const UpdateFeesProposal = { + typeUrl: "/bitsong.fantoken.v1beta1.UpdateFeesProposal", + encode(message: UpdateFeesProposal, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.title !== "") { + writer.uint32(10).string(message.title); + } + if (message.description !== "") { + writer.uint32(18).string(message.description); + } + if (message.issueFee !== undefined) { + Coin.encode(message.issueFee, writer.uint32(26).fork()).ldelim(); + } + if (message.mintFee !== undefined) { + Coin.encode(message.mintFee, writer.uint32(34).fork()).ldelim(); + } + if (message.burnFee !== undefined) { + Coin.encode(message.burnFee, writer.uint32(42).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): UpdateFeesProposal { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateFeesProposal(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.title = reader.string(); + break; + case 2: + message.description = reader.string(); + break; + case 3: + message.issueFee = Coin.decode(reader, reader.uint32(), useInterfaces); + break; + case 4: + message.mintFee = Coin.decode(reader, reader.uint32(), useInterfaces); + break; + case 5: + message.burnFee = Coin.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): UpdateFeesProposal { + const message = createBaseUpdateFeesProposal(); + message.title = object.title ?? ""; + message.description = object.description ?? ""; + message.issueFee = object.issueFee !== undefined && object.issueFee !== null ? Coin.fromPartial(object.issueFee) : undefined; + message.mintFee = object.mintFee !== undefined && object.mintFee !== null ? Coin.fromPartial(object.mintFee) : undefined; + message.burnFee = object.burnFee !== undefined && object.burnFee !== null ? Coin.fromPartial(object.burnFee) : undefined; + return message; + }, + fromAmino(object: UpdateFeesProposalAmino): UpdateFeesProposal { + const message = createBaseUpdateFeesProposal(); + if (object.title !== undefined && object.title !== null) { + message.title = object.title; + } + if (object.description !== undefined && object.description !== null) { + message.description = object.description; + } + if (object.issue_fee !== undefined && object.issue_fee !== null) { + message.issueFee = Coin.fromAmino(object.issue_fee); + } + if (object.mint_fee !== undefined && object.mint_fee !== null) { + message.mintFee = Coin.fromAmino(object.mint_fee); + } + if (object.burn_fee !== undefined && object.burn_fee !== null) { + message.burnFee = Coin.fromAmino(object.burn_fee); + } + return message; + }, + toAmino(message: UpdateFeesProposal, useInterfaces: boolean = false): UpdateFeesProposalAmino { + const obj: any = {}; + obj.title = message.title; + obj.description = message.description; + obj.issue_fee = message.issueFee ? Coin.toAmino(message.issueFee, useInterfaces) : undefined; + obj.mint_fee = message.mintFee ? Coin.toAmino(message.mintFee, useInterfaces) : undefined; + obj.burn_fee = message.burnFee ? Coin.toAmino(message.burnFee, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: UpdateFeesProposalAminoMsg): UpdateFeesProposal { + return UpdateFeesProposal.fromAmino(object.value); + }, + fromProtoMsg(message: UpdateFeesProposalProtoMsg, useInterfaces: boolean = false): UpdateFeesProposal { + return UpdateFeesProposal.decode(message.value, undefined, useInterfaces); + }, + toProto(message: UpdateFeesProposal): Uint8Array { + return UpdateFeesProposal.encode(message).finish(); + }, + toProtoMsg(message: UpdateFeesProposal): UpdateFeesProposalProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.UpdateFeesProposal", + value: UpdateFeesProposal.encode(message).finish() + }; + } +}; +function createBaseUpdateFeesProposalWithDeposit(): UpdateFeesProposalWithDeposit { + return { + title: "", + description: "", + issueFee: "", + mintFee: "", + burnFee: "", + deposit: "" + }; +} +export const UpdateFeesProposalWithDeposit = { + typeUrl: "/bitsong.fantoken.v1beta1.UpdateFeesProposalWithDeposit", + encode(message: UpdateFeesProposalWithDeposit, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.title !== "") { + writer.uint32(10).string(message.title); + } + if (message.description !== "") { + writer.uint32(18).string(message.description); + } + if (message.issueFee !== "") { + writer.uint32(26).string(message.issueFee); + } + if (message.mintFee !== "") { + writer.uint32(34).string(message.mintFee); + } + if (message.burnFee !== "") { + writer.uint32(42).string(message.burnFee); + } + if (message.deposit !== "") { + writer.uint32(58).string(message.deposit); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): UpdateFeesProposalWithDeposit { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseUpdateFeesProposalWithDeposit(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.title = reader.string(); + break; + case 2: + message.description = reader.string(); + break; + case 3: + message.issueFee = reader.string(); + break; + case 4: + message.mintFee = reader.string(); + break; + case 5: + message.burnFee = reader.string(); + break; + case 7: + message.deposit = reader.string(); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): UpdateFeesProposalWithDeposit { + const message = createBaseUpdateFeesProposalWithDeposit(); + message.title = object.title ?? ""; + message.description = object.description ?? ""; + message.issueFee = object.issueFee ?? ""; + message.mintFee = object.mintFee ?? ""; + message.burnFee = object.burnFee ?? ""; + message.deposit = object.deposit ?? ""; + return message; + }, + fromAmino(object: UpdateFeesProposalWithDepositAmino): UpdateFeesProposalWithDeposit { + const message = createBaseUpdateFeesProposalWithDeposit(); + if (object.title !== undefined && object.title !== null) { + message.title = object.title; + } + if (object.description !== undefined && object.description !== null) { + message.description = object.description; + } + if (object.issue_fee !== undefined && object.issue_fee !== null) { + message.issueFee = object.issue_fee; + } + if (object.mint_fee !== undefined && object.mint_fee !== null) { + message.mintFee = object.mint_fee; + } + if (object.burn_fee !== undefined && object.burn_fee !== null) { + message.burnFee = object.burn_fee; + } + if (object.deposit !== undefined && object.deposit !== null) { + message.deposit = object.deposit; + } + return message; + }, + toAmino(message: UpdateFeesProposalWithDeposit, useInterfaces: boolean = false): UpdateFeesProposalWithDepositAmino { + const obj: any = {}; + obj.title = message.title; + obj.description = message.description; + obj.issue_fee = message.issueFee; + obj.mint_fee = message.mintFee; + obj.burn_fee = message.burnFee; + obj.deposit = message.deposit; + return obj; + }, + fromAminoMsg(object: UpdateFeesProposalWithDepositAminoMsg): UpdateFeesProposalWithDeposit { + return UpdateFeesProposalWithDeposit.fromAmino(object.value); + }, + fromProtoMsg(message: UpdateFeesProposalWithDepositProtoMsg, useInterfaces: boolean = false): UpdateFeesProposalWithDeposit { + return UpdateFeesProposalWithDeposit.decode(message.value, undefined, useInterfaces); + }, + toProto(message: UpdateFeesProposalWithDeposit): Uint8Array { + return UpdateFeesProposalWithDeposit.encode(message).finish(); + }, + toProtoMsg(message: UpdateFeesProposalWithDeposit): UpdateFeesProposalWithDepositProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.UpdateFeesProposalWithDeposit", + value: UpdateFeesProposalWithDeposit.encode(message).finish() + }; + } +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/params.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/params.ts new file mode 100644 index 0000000000..cb6ffd7de0 --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/params.ts @@ -0,0 +1,115 @@ +import { Coin, CoinAmino, CoinSDKType } from "../../../cosmos/base/v1beta1/coin"; +import { BinaryReader, BinaryWriter } from "../../../binary"; +/** Params defines fantoken module's parameters */ +export interface Params { + issueFee: Coin | undefined; + mintFee: Coin | undefined; + burnFee: Coin | undefined; +} +export interface ParamsProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.Params"; + value: Uint8Array; +} +/** Params defines fantoken module's parameters */ +export interface ParamsAmino { + issue_fee?: CoinAmino | undefined; + mint_fee?: CoinAmino | undefined; + burn_fee?: CoinAmino | undefined; +} +export interface ParamsAminoMsg { + type: "/bitsong.fantoken.v1beta1.Params"; + value: ParamsAmino; +} +/** Params defines fantoken module's parameters */ +export interface ParamsSDKType { + issue_fee: CoinSDKType | undefined; + mint_fee: CoinSDKType | undefined; + burn_fee: CoinSDKType | undefined; +} +function createBaseParams(): Params { + return { + issueFee: Coin.fromPartial({}), + mintFee: Coin.fromPartial({}), + burnFee: Coin.fromPartial({}) + }; +} +export const Params = { + typeUrl: "/bitsong.fantoken.v1beta1.Params", + encode(message: Params, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.issueFee !== undefined) { + Coin.encode(message.issueFee, writer.uint32(10).fork()).ldelim(); + } + if (message.mintFee !== undefined) { + Coin.encode(message.mintFee, writer.uint32(18).fork()).ldelim(); + } + if (message.burnFee !== undefined) { + Coin.encode(message.burnFee, writer.uint32(26).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): Params { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseParams(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.issueFee = Coin.decode(reader, reader.uint32(), useInterfaces); + break; + case 2: + message.mintFee = Coin.decode(reader, reader.uint32(), useInterfaces); + break; + case 3: + message.burnFee = Coin.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): Params { + const message = createBaseParams(); + message.issueFee = object.issueFee !== undefined && object.issueFee !== null ? Coin.fromPartial(object.issueFee) : undefined; + message.mintFee = object.mintFee !== undefined && object.mintFee !== null ? Coin.fromPartial(object.mintFee) : undefined; + message.burnFee = object.burnFee !== undefined && object.burnFee !== null ? Coin.fromPartial(object.burnFee) : undefined; + return message; + }, + fromAmino(object: ParamsAmino): Params { + const message = createBaseParams(); + if (object.issue_fee !== undefined && object.issue_fee !== null) { + message.issueFee = Coin.fromAmino(object.issue_fee); + } + if (object.mint_fee !== undefined && object.mint_fee !== null) { + message.mintFee = Coin.fromAmino(object.mint_fee); + } + if (object.burn_fee !== undefined && object.burn_fee !== null) { + message.burnFee = Coin.fromAmino(object.burn_fee); + } + return message; + }, + toAmino(message: Params, useInterfaces: boolean = false): ParamsAmino { + const obj: any = {}; + obj.issue_fee = message.issueFee ? Coin.toAmino(message.issueFee, useInterfaces) : undefined; + obj.mint_fee = message.mintFee ? Coin.toAmino(message.mintFee, useInterfaces) : undefined; + obj.burn_fee = message.burnFee ? Coin.toAmino(message.burnFee, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: ParamsAminoMsg): Params { + return Params.fromAmino(object.value); + }, + fromProtoMsg(message: ParamsProtoMsg, useInterfaces: boolean = false): Params { + return Params.decode(message.value, undefined, useInterfaces); + }, + toProto(message: Params): Uint8Array { + return Params.encode(message).finish(); + }, + toProtoMsg(message: Params): ParamsProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.Params", + value: Params.encode(message).finish() + }; + } +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/query.rpc.Query.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/query.rpc.Query.ts new file mode 100644 index 0000000000..60059028df --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/query.rpc.Query.ts @@ -0,0 +1,52 @@ +import { Rpc } from "../../../helpers"; +import { BinaryReader } from "../../../binary"; +import { QueryClient, createProtobufRpcClient } from "@cosmjs/stargate"; +import { QueryFanTokenRequest, QueryFanTokenResponse, QueryFanTokensRequest, QueryFanTokensResponse, QueryParamsRequest, QueryParamsResponse } from "./query"; +/** Query creates service with fantoken as RPC */ +export interface Query { + /** FanToken returns fantoken with fantoken name */ + fanToken(request: QueryFanTokenRequest): Promise; + /** FanTokens returns the fantoken list */ + fanTokens(request: QueryFanTokensRequest): Promise; + /** Params queries the fantoken parameters */ + params(request?: QueryParamsRequest): Promise; +} +export class QueryClientImpl implements Query { + private readonly rpc: Rpc; + constructor(rpc: Rpc) { + this.rpc = rpc; + this.fanToken = this.fanToken.bind(this); + this.fanTokens = this.fanTokens.bind(this); + this.params = this.params.bind(this); + } + fanToken(request: QueryFanTokenRequest, useInterfaces: boolean = true): Promise { + const data = QueryFanTokenRequest.encode(request).finish(); + const promise = this.rpc.request("bitsong.fantoken.v1beta1.Query", "FanToken", data); + return promise.then(data => QueryFanTokenResponse.decode(new BinaryReader(data), undefined, useInterfaces)); + } + fanTokens(request: QueryFanTokensRequest, useInterfaces: boolean = true): Promise { + const data = QueryFanTokensRequest.encode(request).finish(); + const promise = this.rpc.request("bitsong.fantoken.v1beta1.Query", "FanTokens", data); + return promise.then(data => QueryFanTokensResponse.decode(new BinaryReader(data), undefined, useInterfaces)); + } + params(request: QueryParamsRequest = {}, useInterfaces: boolean = true): Promise { + const data = QueryParamsRequest.encode(request).finish(); + const promise = this.rpc.request("bitsong.fantoken.v1beta1.Query", "Params", data); + return promise.then(data => QueryParamsResponse.decode(new BinaryReader(data), undefined, useInterfaces)); + } +} +export const createRpcQueryExtension = (base: QueryClient) => { + const rpc = createProtobufRpcClient(base); + const queryService = new QueryClientImpl(rpc); + return { + fanToken(request: QueryFanTokenRequest, useInterfaces: boolean = true): Promise { + return queryService.fanToken(request, useInterfaces); + }, + fanTokens(request: QueryFanTokensRequest, useInterfaces: boolean = true): Promise { + return queryService.fanTokens(request, useInterfaces); + }, + params(request?: QueryParamsRequest, useInterfaces: boolean = true): Promise { + return queryService.params(request, useInterfaces); + } + }; +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/query.ts b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/query.ts new file mode 100644 index 0000000000..fd821a1451 --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/fantoken/v1beta1/query.ts @@ -0,0 +1,522 @@ +//@ts-nocheck +import { PageRequest, PageRequestAmino, PageRequestSDKType, PageResponse, PageResponseAmino, PageResponseSDKType } from "../../../cosmos/base/query/v1beta1/pagination"; +import { FanToken, FanTokenAmino, FanTokenSDKType } from "./fantoken"; +import { Params, ParamsAmino, ParamsSDKType } from "./params"; +import { BinaryReader, BinaryWriter } from "../../../binary"; +/** QueryFanTokenRequest is request type for the Query/FanToken RPC method */ +export interface QueryFanTokenRequest { + /** QueryFanTokenRequest is request type for the Query/FanToken RPC method */ + denom: string; +} +export interface QueryFanTokenRequestProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokenRequest"; + value: Uint8Array; +} +/** QueryFanTokenRequest is request type for the Query/FanToken RPC method */ +export interface QueryFanTokenRequestAmino { + /** QueryFanTokenRequest is request type for the Query/FanToken RPC method */ + denom?: string; +} +export interface QueryFanTokenRequestAminoMsg { + type: "/bitsong.fantoken.v1beta1.QueryFanTokenRequest"; + value: QueryFanTokenRequestAmino; +} +/** QueryFanTokenRequest is request type for the Query/FanToken RPC method */ +export interface QueryFanTokenRequestSDKType { + denom: string; +} +/** QueryFanTokenResponse is response type for the Query/FanToken RPC method */ +export interface QueryFanTokenResponse { + /** QueryFanTokenResponse is response type for the Query/FanToken RPC method */ + fantoken?: FanToken | undefined; +} +export interface QueryFanTokenResponseProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokenResponse"; + value: Uint8Array; +} +/** QueryFanTokenResponse is response type for the Query/FanToken RPC method */ +export interface QueryFanTokenResponseAmino { + /** QueryFanTokenResponse is response type for the Query/FanToken RPC method */ + fantoken?: FanTokenAmino | undefined; +} +export interface QueryFanTokenResponseAminoMsg { + type: "/bitsong.fantoken.v1beta1.QueryFanTokenResponse"; + value: QueryFanTokenResponseAmino; +} +/** QueryFanTokenResponse is response type for the Query/FanToken RPC method */ +export interface QueryFanTokenResponseSDKType { + fantoken?: FanTokenSDKType | undefined; +} +/** QueryFanTokensRequest is request type for the Query/FanTokens RPC method */ +export interface QueryFanTokensRequest { + authority: string; + /** pagination defines an optional pagination for the request. */ + pagination?: PageRequest | undefined; +} +export interface QueryFanTokensRequestProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokensRequest"; + value: Uint8Array; +} +/** QueryFanTokensRequest is request type for the Query/FanTokens RPC method */ +export interface QueryFanTokensRequestAmino { + authority?: string; + /** pagination defines an optional pagination for the request. */ + pagination?: PageRequestAmino | undefined; +} +export interface QueryFanTokensRequestAminoMsg { + type: "/bitsong.fantoken.v1beta1.QueryFanTokensRequest"; + value: QueryFanTokensRequestAmino; +} +/** QueryFanTokensRequest is request type for the Query/FanTokens RPC method */ +export interface QueryFanTokensRequestSDKType { + authority: string; + pagination?: PageRequestSDKType | undefined; +} +/** QueryFanTokensResponse is response type for the Query/FanTokens RPC method */ +export interface QueryFanTokensResponse { + fantokens: FanToken[]; + pagination?: PageResponse | undefined; +} +export interface QueryFanTokensResponseProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokensResponse"; + value: Uint8Array; +} +/** QueryFanTokensResponse is response type for the Query/FanTokens RPC method */ +export interface QueryFanTokensResponseAmino { + fantokens?: FanTokenAmino[]; + pagination?: PageResponseAmino | undefined; +} +export interface QueryFanTokensResponseAminoMsg { + type: "/bitsong.fantoken.v1beta1.QueryFanTokensResponse"; + value: QueryFanTokensResponseAmino; +} +/** QueryFanTokensResponse is response type for the Query/FanTokens RPC method */ +export interface QueryFanTokensResponseSDKType { + fantokens: FanTokenSDKType[]; + pagination?: PageResponseSDKType | undefined; +} +/** QueryParametersRequest is request type for the Query/Parameters RPC method */ +export interface QueryParamsRequest {} +export interface QueryParamsRequestProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.QueryParamsRequest"; + value: Uint8Array; +} +/** QueryParametersRequest is request type for the Query/Parameters RPC method */ +export interface QueryParamsRequestAmino {} +export interface QueryParamsRequestAminoMsg { + type: "/bitsong.fantoken.v1beta1.QueryParamsRequest"; + value: QueryParamsRequestAmino; +} +/** QueryParametersRequest is request type for the Query/Parameters RPC method */ +export interface QueryParamsRequestSDKType {} +/** QueryParametersResponse is response type for the Query/Parameters RPC method */ +export interface QueryParamsResponse { + params: Params | undefined; +} +export interface QueryParamsResponseProtoMsg { + typeUrl: "/bitsong.fantoken.v1beta1.QueryParamsResponse"; + value: Uint8Array; +} +/** QueryParametersResponse is response type for the Query/Parameters RPC method */ +export interface QueryParamsResponseAmino { + params?: ParamsAmino | undefined; +} +export interface QueryParamsResponseAminoMsg { + type: "/bitsong.fantoken.v1beta1.QueryParamsResponse"; + value: QueryParamsResponseAmino; +} +/** QueryParametersResponse is response type for the Query/Parameters RPC method */ +export interface QueryParamsResponseSDKType { + params: ParamsSDKType | undefined; +} +function createBaseQueryFanTokenRequest(): QueryFanTokenRequest { + return { + denom: "" + }; +} +export const QueryFanTokenRequest = { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokenRequest", + encode(message: QueryFanTokenRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.denom !== "") { + writer.uint32(10).string(message.denom); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): QueryFanTokenRequest { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryFanTokenRequest(); + 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): QueryFanTokenRequest { + const message = createBaseQueryFanTokenRequest(); + message.denom = object.denom ?? ""; + return message; + }, + fromAmino(object: QueryFanTokenRequestAmino): QueryFanTokenRequest { + const message = createBaseQueryFanTokenRequest(); + if (object.denom !== undefined && object.denom !== null) { + message.denom = object.denom; + } + return message; + }, + toAmino(message: QueryFanTokenRequest, useInterfaces: boolean = false): QueryFanTokenRequestAmino { + const obj: any = {}; + obj.denom = message.denom; + return obj; + }, + fromAminoMsg(object: QueryFanTokenRequestAminoMsg): QueryFanTokenRequest { + return QueryFanTokenRequest.fromAmino(object.value); + }, + fromProtoMsg(message: QueryFanTokenRequestProtoMsg, useInterfaces: boolean = false): QueryFanTokenRequest { + return QueryFanTokenRequest.decode(message.value, undefined, useInterfaces); + }, + toProto(message: QueryFanTokenRequest): Uint8Array { + return QueryFanTokenRequest.encode(message).finish(); + }, + toProtoMsg(message: QueryFanTokenRequest): QueryFanTokenRequestProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokenRequest", + value: QueryFanTokenRequest.encode(message).finish() + }; + } +}; +function createBaseQueryFanTokenResponse(): QueryFanTokenResponse { + return { + fantoken: undefined + }; +} +export const QueryFanTokenResponse = { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokenResponse", + encode(message: QueryFanTokenResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.fantoken !== undefined) { + FanToken.encode(message.fantoken, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): QueryFanTokenResponse { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryFanTokenResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.fantoken = FanToken.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): QueryFanTokenResponse { + const message = createBaseQueryFanTokenResponse(); + message.fantoken = object.fantoken !== undefined && object.fantoken !== null ? FanToken.fromPartial(object.fantoken) : undefined; + return message; + }, + fromAmino(object: QueryFanTokenResponseAmino): QueryFanTokenResponse { + const message = createBaseQueryFanTokenResponse(); + if (object.fantoken !== undefined && object.fantoken !== null) { + message.fantoken = FanToken.fromAmino(object.fantoken); + } + return message; + }, + toAmino(message: QueryFanTokenResponse, useInterfaces: boolean = false): QueryFanTokenResponseAmino { + const obj: any = {}; + obj.fantoken = message.fantoken ? FanToken.toAmino(message.fantoken, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: QueryFanTokenResponseAminoMsg): QueryFanTokenResponse { + return QueryFanTokenResponse.fromAmino(object.value); + }, + fromProtoMsg(message: QueryFanTokenResponseProtoMsg, useInterfaces: boolean = false): QueryFanTokenResponse { + return QueryFanTokenResponse.decode(message.value, undefined, useInterfaces); + }, + toProto(message: QueryFanTokenResponse): Uint8Array { + return QueryFanTokenResponse.encode(message).finish(); + }, + toProtoMsg(message: QueryFanTokenResponse): QueryFanTokenResponseProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokenResponse", + value: QueryFanTokenResponse.encode(message).finish() + }; + } +}; +function createBaseQueryFanTokensRequest(): QueryFanTokensRequest { + return { + authority: "", + pagination: undefined + }; +} +export const QueryFanTokensRequest = { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokensRequest", + encode(message: QueryFanTokensRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.authority !== "") { + writer.uint32(10).string(message.authority); + } + if (message.pagination !== undefined) { + PageRequest.encode(message.pagination, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): QueryFanTokensRequest { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryFanTokensRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.authority = reader.string(); + break; + case 2: + message.pagination = PageRequest.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): QueryFanTokensRequest { + const message = createBaseQueryFanTokensRequest(); + message.authority = object.authority ?? ""; + message.pagination = object.pagination !== undefined && object.pagination !== null ? PageRequest.fromPartial(object.pagination) : undefined; + return message; + }, + fromAmino(object: QueryFanTokensRequestAmino): QueryFanTokensRequest { + const message = createBaseQueryFanTokensRequest(); + if (object.authority !== undefined && object.authority !== null) { + message.authority = object.authority; + } + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageRequest.fromAmino(object.pagination); + } + return message; + }, + toAmino(message: QueryFanTokensRequest, useInterfaces: boolean = false): QueryFanTokensRequestAmino { + const obj: any = {}; + obj.authority = message.authority; + obj.pagination = message.pagination ? PageRequest.toAmino(message.pagination, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: QueryFanTokensRequestAminoMsg): QueryFanTokensRequest { + return QueryFanTokensRequest.fromAmino(object.value); + }, + fromProtoMsg(message: QueryFanTokensRequestProtoMsg, useInterfaces: boolean = false): QueryFanTokensRequest { + return QueryFanTokensRequest.decode(message.value, undefined, useInterfaces); + }, + toProto(message: QueryFanTokensRequest): Uint8Array { + return QueryFanTokensRequest.encode(message).finish(); + }, + toProtoMsg(message: QueryFanTokensRequest): QueryFanTokensRequestProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokensRequest", + value: QueryFanTokensRequest.encode(message).finish() + }; + } +}; +function createBaseQueryFanTokensResponse(): QueryFanTokensResponse { + return { + fantokens: [], + pagination: undefined + }; +} +export const QueryFanTokensResponse = { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokensResponse", + encode(message: QueryFanTokensResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + for (const v of message.fantokens) { + FanToken.encode(v!, writer.uint32(10).fork()).ldelim(); + } + if (message.pagination !== undefined) { + PageResponse.encode(message.pagination, writer.uint32(18).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): QueryFanTokensResponse { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryFanTokensResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.fantokens.push(FanToken.decode(reader, reader.uint32(), useInterfaces)); + break; + case 2: + message.pagination = PageResponse.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): QueryFanTokensResponse { + const message = createBaseQueryFanTokensResponse(); + message.fantokens = object.fantokens?.map(e => FanToken.fromPartial(e)) || []; + message.pagination = object.pagination !== undefined && object.pagination !== null ? PageResponse.fromPartial(object.pagination) : undefined; + return message; + }, + fromAmino(object: QueryFanTokensResponseAmino): QueryFanTokensResponse { + const message = createBaseQueryFanTokensResponse(); + message.fantokens = object.fantokens?.map(e => FanToken.fromAmino(e)) || []; + if (object.pagination !== undefined && object.pagination !== null) { + message.pagination = PageResponse.fromAmino(object.pagination); + } + return message; + }, + toAmino(message: QueryFanTokensResponse, useInterfaces: boolean = false): QueryFanTokensResponseAmino { + const obj: any = {}; + if (message.fantokens) { + obj.fantokens = message.fantokens.map(e => e ? FanToken.toAmino(e, useInterfaces) : undefined); + } else { + obj.fantokens = []; + } + obj.pagination = message.pagination ? PageResponse.toAmino(message.pagination, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: QueryFanTokensResponseAminoMsg): QueryFanTokensResponse { + return QueryFanTokensResponse.fromAmino(object.value); + }, + fromProtoMsg(message: QueryFanTokensResponseProtoMsg, useInterfaces: boolean = false): QueryFanTokensResponse { + return QueryFanTokensResponse.decode(message.value, undefined, useInterfaces); + }, + toProto(message: QueryFanTokensResponse): Uint8Array { + return QueryFanTokensResponse.encode(message).finish(); + }, + toProtoMsg(message: QueryFanTokensResponse): QueryFanTokensResponseProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.QueryFanTokensResponse", + value: QueryFanTokensResponse.encode(message).finish() + }; + } +}; +function createBaseQueryParamsRequest(): QueryParamsRequest { + return {}; +} +export const QueryParamsRequest = { + typeUrl: "/bitsong.fantoken.v1beta1.QueryParamsRequest", + encode(_: QueryParamsRequest, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): QueryParamsRequest { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryParamsRequest(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(_: Partial): QueryParamsRequest { + const message = createBaseQueryParamsRequest(); + return message; + }, + fromAmino(_: QueryParamsRequestAmino): QueryParamsRequest { + const message = createBaseQueryParamsRequest(); + return message; + }, + toAmino(_: QueryParamsRequest, useInterfaces: boolean = false): QueryParamsRequestAmino { + const obj: any = {}; + return obj; + }, + fromAminoMsg(object: QueryParamsRequestAminoMsg): QueryParamsRequest { + return QueryParamsRequest.fromAmino(object.value); + }, + fromProtoMsg(message: QueryParamsRequestProtoMsg, useInterfaces: boolean = false): QueryParamsRequest { + return QueryParamsRequest.decode(message.value, undefined, useInterfaces); + }, + toProto(message: QueryParamsRequest): Uint8Array { + return QueryParamsRequest.encode(message).finish(); + }, + toProtoMsg(message: QueryParamsRequest): QueryParamsRequestProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.QueryParamsRequest", + value: QueryParamsRequest.encode(message).finish() + }; + } +}; +function createBaseQueryParamsResponse(): QueryParamsResponse { + return { + params: Params.fromPartial({}) + }; +} +export const QueryParamsResponse = { + typeUrl: "/bitsong.fantoken.v1beta1.QueryParamsResponse", + encode(message: QueryParamsResponse, writer: BinaryWriter = BinaryWriter.create()): BinaryWriter { + if (message.params !== undefined) { + Params.encode(message.params, writer.uint32(10).fork()).ldelim(); + } + return writer; + }, + decode(input: BinaryReader | Uint8Array, length?: number, useInterfaces: boolean = false): QueryParamsResponse { + const reader = input instanceof BinaryReader ? input : new BinaryReader(input); + let end = length === undefined ? reader.len : reader.pos + length; + const message = createBaseQueryParamsResponse(); + while (reader.pos < end) { + const tag = reader.uint32(); + switch (tag >>> 3) { + case 1: + message.params = Params.decode(reader, reader.uint32(), useInterfaces); + break; + default: + reader.skipType(tag & 7); + break; + } + } + return message; + }, + fromPartial(object: Partial): QueryParamsResponse { + const message = createBaseQueryParamsResponse(); + message.params = object.params !== undefined && object.params !== null ? Params.fromPartial(object.params) : undefined; + return message; + }, + fromAmino(object: QueryParamsResponseAmino): QueryParamsResponse { + const message = createBaseQueryParamsResponse(); + if (object.params !== undefined && object.params !== null) { + message.params = Params.fromAmino(object.params); + } + return message; + }, + toAmino(message: QueryParamsResponse, useInterfaces: boolean = false): QueryParamsResponseAmino { + const obj: any = {}; + obj.params = message.params ? Params.toAmino(message.params, useInterfaces) : undefined; + return obj; + }, + fromAminoMsg(object: QueryParamsResponseAminoMsg): QueryParamsResponse { + return QueryParamsResponse.fromAmino(object.value); + }, + fromProtoMsg(message: QueryParamsResponseProtoMsg, useInterfaces: boolean = false): QueryParamsResponse { + return QueryParamsResponse.decode(message.value, undefined, useInterfaces); + }, + toProto(message: QueryParamsResponse): Uint8Array { + return QueryParamsResponse.encode(message).finish(); + }, + toProtoMsg(message: QueryParamsResponse): QueryParamsResponseProtoMsg { + return { + typeUrl: "/bitsong.fantoken.v1beta1.QueryParamsResponse", + value: QueryParamsResponse.encode(message).finish() + }; + } +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/bitsong/rpc.query.ts b/packages/types/protobuf/codegen/bitsong/rpc.query.ts new file mode 100644 index 0000000000..23ff1b423a --- /dev/null +++ b/packages/types/protobuf/codegen/bitsong/rpc.query.ts @@ -0,0 +1,61 @@ +import { Tendermint34Client, HttpEndpoint } from "@cosmjs/tendermint-rpc"; +import { QueryClient } from "@cosmjs/stargate"; +export const createRPCQueryClient = async ({ + rpcEndpoint +}: { + rpcEndpoint: string | HttpEndpoint; +}) => { + const tmClient = await Tendermint34Client.connect(rpcEndpoint); + const client = new QueryClient(tmClient); + return { + bitsong: { + fantoken: { + v1beta1: (await import("./fantoken/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + } + }, + cosmos: { + auth: { + v1beta1: (await import("../cosmos/auth/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + authz: { + v1beta1: (await import("../cosmos/authz/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + bank: { + v1beta1: (await import("../cosmos/bank/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + base: { + tendermint: { + v1beta1: (await import("../cosmos/base/tendermint/v1beta1/query.rpc.Service")).createRpcQueryExtension(client) + } + }, + distribution: { + v1beta1: (await import("../cosmos/distribution/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + feegrant: { + v1beta1: (await import("../cosmos/feegrant/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + gov: { + v1: (await import("../cosmos/gov/v1/query.rpc.Query")).createRpcQueryExtension(client), + v1beta1: (await import("../cosmos/gov/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + mint: { + v1beta1: (await import("../cosmos/mint/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + params: { + v1beta1: (await import("../cosmos/params/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + slashing: { + v1beta1: (await import("../cosmos/slashing/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + staking: { + v1beta1: (await import("../cosmos/staking/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + }, + tx: { + v1beta1: (await import("../cosmos/tx/v1beta1/service.rpc.Service")).createRpcQueryExtension(client) + }, + upgrade: { + v1beta1: (await import("../cosmos/upgrade/v1beta1/query.rpc.Query")).createRpcQueryExtension(client) + } + } + }; +}; \ No newline at end of file diff --git a/packages/types/protobuf/codegen/circle/bundle.ts b/packages/types/protobuf/codegen/circle/bundle.ts index 606d608b86..58897f45bf 100644 --- a/packages/types/protobuf/codegen/circle/bundle.ts +++ b/packages/types/protobuf/codegen/circle/bundle.ts @@ -14,12 +14,12 @@ import * as _24 from "./cctp/v1/sending_and_receiving_messages_paused"; import * as _25 from "./cctp/v1/signature_threshold"; import * as _26 from "./cctp/v1/token_pair"; import * as _27 from "./cctp/v1/tx"; -import * as _376 from "./cctp/v1/tx.amino"; -import * as _377 from "./cctp/v1/tx.registry"; -import * as _378 from "./cctp/v1/query.rpc.Query"; -import * as _379 from "./cctp/v1/tx.rpc.msg"; -import * as _627 from "./rpc.query"; -import * as _628 from "./rpc.tx"; +import * as _377 from "./cctp/v1/tx.amino"; +import * as _378 from "./cctp/v1/tx.registry"; +import * as _379 from "./cctp/v1/query.rpc.Query"; +import * as _380 from "./cctp/v1/tx.rpc.msg"; +import * as _629 from "./rpc.query"; +import * as _630 from "./rpc.tx"; export namespace circle { export namespace cctp { export const v1 = { @@ -39,14 +39,14 @@ export namespace circle { ..._25, ..._26, ..._27, - ..._376, ..._377, ..._378, - ..._379 + ..._379, + ..._380 }; } export const ClientFactory = { - ..._627, - ..._628 + ..._629, + ..._630 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/cosmos/bundle.ts b/packages/types/protobuf/codegen/cosmos/bundle.ts index 4613157a41..51413f1db1 100644 --- a/packages/types/protobuf/codegen/cosmos/bundle.ts +++ b/packages/types/protobuf/codegen/cosmos/bundle.ts @@ -60,55 +60,55 @@ import * as _87 from "./tx/v1beta1/tx"; import * as _88 from "./upgrade/v1beta1/query"; import * as _89 from "./upgrade/v1beta1/tx"; import * as _90 from "./upgrade/v1beta1/upgrade"; -import * as _380 from "./auth/v1beta1/tx.amino"; -import * as _381 from "./authz/v1beta1/tx.amino"; -import * as _382 from "./bank/v1beta1/tx.amino"; -import * as _383 from "./distribution/v1beta1/tx.amino"; -import * as _384 from "./feegrant/v1beta1/tx.amino"; -import * as _385 from "./gov/v1/tx.amino"; -import * as _386 from "./gov/v1beta1/tx.amino"; -import * as _387 from "./mint/v1beta1/tx.amino"; -import * as _388 from "./slashing/v1beta1/tx.amino"; -import * as _389 from "./staking/v1beta1/tx.amino"; -import * as _390 from "./upgrade/v1beta1/tx.amino"; -import * as _391 from "./auth/v1beta1/tx.registry"; -import * as _392 from "./authz/v1beta1/tx.registry"; -import * as _393 from "./bank/v1beta1/tx.registry"; -import * as _394 from "./distribution/v1beta1/tx.registry"; -import * as _395 from "./feegrant/v1beta1/tx.registry"; -import * as _396 from "./gov/v1/tx.registry"; -import * as _397 from "./gov/v1beta1/tx.registry"; -import * as _398 from "./mint/v1beta1/tx.registry"; -import * as _399 from "./slashing/v1beta1/tx.registry"; -import * as _400 from "./staking/v1beta1/tx.registry"; -import * as _401 from "./upgrade/v1beta1/tx.registry"; -import * as _402 from "./auth/v1beta1/query.rpc.Query"; -import * as _403 from "./authz/v1beta1/query.rpc.Query"; -import * as _404 from "./bank/v1beta1/query.rpc.Query"; -import * as _405 from "./base/tendermint/v1beta1/query.rpc.Service"; -import * as _406 from "./distribution/v1beta1/query.rpc.Query"; -import * as _407 from "./feegrant/v1beta1/query.rpc.Query"; -import * as _408 from "./gov/v1/query.rpc.Query"; -import * as _409 from "./gov/v1beta1/query.rpc.Query"; -import * as _410 from "./mint/v1beta1/query.rpc.Query"; -import * as _411 from "./params/v1beta1/query.rpc.Query"; -import * as _412 from "./slashing/v1beta1/query.rpc.Query"; -import * as _413 from "./staking/v1beta1/query.rpc.Query"; -import * as _414 from "./tx/v1beta1/service.rpc.Service"; -import * as _415 from "./upgrade/v1beta1/query.rpc.Query"; -import * as _416 from "./auth/v1beta1/tx.rpc.msg"; -import * as _417 from "./authz/v1beta1/tx.rpc.msg"; -import * as _418 from "./bank/v1beta1/tx.rpc.msg"; -import * as _419 from "./distribution/v1beta1/tx.rpc.msg"; -import * as _420 from "./feegrant/v1beta1/tx.rpc.msg"; -import * as _421 from "./gov/v1/tx.rpc.msg"; -import * as _422 from "./gov/v1beta1/tx.rpc.msg"; -import * as _423 from "./mint/v1beta1/tx.rpc.msg"; -import * as _424 from "./slashing/v1beta1/tx.rpc.msg"; -import * as _425 from "./staking/v1beta1/tx.rpc.msg"; -import * as _426 from "./upgrade/v1beta1/tx.rpc.msg"; -import * as _629 from "./rpc.query"; -import * as _630 from "./rpc.tx"; +import * as _381 from "./auth/v1beta1/tx.amino"; +import * as _382 from "./authz/v1beta1/tx.amino"; +import * as _383 from "./bank/v1beta1/tx.amino"; +import * as _384 from "./distribution/v1beta1/tx.amino"; +import * as _385 from "./feegrant/v1beta1/tx.amino"; +import * as _386 from "./gov/v1/tx.amino"; +import * as _387 from "./gov/v1beta1/tx.amino"; +import * as _388 from "./mint/v1beta1/tx.amino"; +import * as _389 from "./slashing/v1beta1/tx.amino"; +import * as _390 from "./staking/v1beta1/tx.amino"; +import * as _391 from "./upgrade/v1beta1/tx.amino"; +import * as _392 from "./auth/v1beta1/tx.registry"; +import * as _393 from "./authz/v1beta1/tx.registry"; +import * as _394 from "./bank/v1beta1/tx.registry"; +import * as _395 from "./distribution/v1beta1/tx.registry"; +import * as _396 from "./feegrant/v1beta1/tx.registry"; +import * as _397 from "./gov/v1/tx.registry"; +import * as _398 from "./gov/v1beta1/tx.registry"; +import * as _399 from "./mint/v1beta1/tx.registry"; +import * as _400 from "./slashing/v1beta1/tx.registry"; +import * as _401 from "./staking/v1beta1/tx.registry"; +import * as _402 from "./upgrade/v1beta1/tx.registry"; +import * as _403 from "./auth/v1beta1/query.rpc.Query"; +import * as _404 from "./authz/v1beta1/query.rpc.Query"; +import * as _405 from "./bank/v1beta1/query.rpc.Query"; +import * as _406 from "./base/tendermint/v1beta1/query.rpc.Service"; +import * as _407 from "./distribution/v1beta1/query.rpc.Query"; +import * as _408 from "./feegrant/v1beta1/query.rpc.Query"; +import * as _409 from "./gov/v1/query.rpc.Query"; +import * as _410 from "./gov/v1beta1/query.rpc.Query"; +import * as _411 from "./mint/v1beta1/query.rpc.Query"; +import * as _412 from "./params/v1beta1/query.rpc.Query"; +import * as _413 from "./slashing/v1beta1/query.rpc.Query"; +import * as _414 from "./staking/v1beta1/query.rpc.Query"; +import * as _415 from "./tx/v1beta1/service.rpc.Service"; +import * as _416 from "./upgrade/v1beta1/query.rpc.Query"; +import * as _417 from "./auth/v1beta1/tx.rpc.msg"; +import * as _418 from "./authz/v1beta1/tx.rpc.msg"; +import * as _419 from "./bank/v1beta1/tx.rpc.msg"; +import * as _420 from "./distribution/v1beta1/tx.rpc.msg"; +import * as _421 from "./feegrant/v1beta1/tx.rpc.msg"; +import * as _422 from "./gov/v1/tx.rpc.msg"; +import * as _423 from "./gov/v1beta1/tx.rpc.msg"; +import * as _424 from "./mint/v1beta1/tx.rpc.msg"; +import * as _425 from "./slashing/v1beta1/tx.rpc.msg"; +import * as _426 from "./staking/v1beta1/tx.rpc.msg"; +import * as _427 from "./upgrade/v1beta1/tx.rpc.msg"; +import * as _631 from "./rpc.query"; +import * as _632 from "./rpc.tx"; export namespace cosmos { export namespace auth { export const v1beta1 = { @@ -116,10 +116,10 @@ export namespace cosmos { ..._30, ..._31, ..._32, - ..._380, - ..._391, - ..._402, - ..._416 + ..._381, + ..._392, + ..._403, + ..._417 }; } export namespace authz { @@ -129,10 +129,10 @@ export namespace cosmos { ..._35, ..._36, ..._37, - ..._381, - ..._392, - ..._403, - ..._417 + ..._382, + ..._393, + ..._404, + ..._418 }; } export namespace bank { @@ -142,10 +142,10 @@ export namespace cosmos { ..._40, ..._41, ..._42, - ..._382, - ..._393, - ..._404, - ..._418 + ..._383, + ..._394, + ..._405, + ..._419 }; } export namespace base { @@ -163,7 +163,7 @@ export namespace cosmos { export const v1beta1 = { ..._45, ..._46, - ..._405 + ..._406 }; } export const v1beta1 = { @@ -187,10 +187,10 @@ export namespace cosmos { ..._52, ..._53, ..._54, - ..._383, - ..._394, - ..._406, - ..._419 + ..._384, + ..._395, + ..._407, + ..._420 }; } export namespace feegrant { @@ -199,10 +199,10 @@ export namespace cosmos { ..._56, ..._57, ..._58, - ..._384, - ..._395, - ..._407, - ..._420 + ..._385, + ..._396, + ..._408, + ..._421 }; } export namespace gov { @@ -211,20 +211,20 @@ export namespace cosmos { ..._60, ..._61, ..._62, - ..._385, - ..._396, - ..._408, - ..._421 + ..._386, + ..._397, + ..._409, + ..._422 }; export const v1beta1 = { ..._63, ..._64, ..._65, ..._66, - ..._386, - ..._397, - ..._409, - ..._422 + ..._387, + ..._398, + ..._410, + ..._423 }; } export namespace mint { @@ -233,10 +233,10 @@ export namespace cosmos { ..._68, ..._69, ..._70, - ..._387, - ..._398, - ..._410, - ..._423 + ..._388, + ..._399, + ..._411, + ..._424 }; } export namespace msg { @@ -253,7 +253,7 @@ export namespace cosmos { export const v1beta1 = { ..._73, ..._74, - ..._411 + ..._412 }; } export namespace query { @@ -267,10 +267,10 @@ export namespace cosmos { ..._77, ..._78, ..._79, - ..._388, - ..._399, - ..._412, - ..._424 + ..._389, + ..._400, + ..._413, + ..._425 }; } export namespace staking { @@ -280,10 +280,10 @@ export namespace cosmos { ..._82, ..._83, ..._84, - ..._389, - ..._400, - ..._413, - ..._425 + ..._390, + ..._401, + ..._414, + ..._426 }; } export namespace tx { @@ -295,7 +295,7 @@ export namespace cosmos { export const v1beta1 = { ..._86, ..._87, - ..._414 + ..._415 }; } export namespace upgrade { @@ -303,14 +303,14 @@ export namespace cosmos { ..._88, ..._89, ..._90, - ..._390, - ..._401, - ..._415, - ..._426 + ..._391, + ..._402, + ..._416, + ..._427 }; } export const ClientFactory = { - ..._629, - ..._630 + ..._631, + ..._632 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/cosmwasm/bundle.ts b/packages/types/protobuf/codegen/cosmwasm/bundle.ts index 462214bacd..50213bfc23 100644 --- a/packages/types/protobuf/codegen/cosmwasm/bundle.ts +++ b/packages/types/protobuf/codegen/cosmwasm/bundle.ts @@ -10,16 +10,16 @@ import * as _99 from "./wasm/v1/proposal"; import * as _100 from "./wasm/v1/query"; import * as _101 from "./wasm/v1/tx"; import * as _102 from "./wasm/v1/types"; -import * as _427 from "./tokenfactory/v1beta1/tx.amino"; -import * as _428 from "./wasm/v1/tx.amino"; -import * as _429 from "./tokenfactory/v1beta1/tx.registry"; -import * as _430 from "./wasm/v1/tx.registry"; -import * as _431 from "./tokenfactory/v1beta1/query.rpc.Query"; -import * as _432 from "./wasm/v1/query.rpc.Query"; -import * as _433 from "./tokenfactory/v1beta1/tx.rpc.msg"; -import * as _434 from "./wasm/v1/tx.rpc.msg"; -import * as _631 from "./rpc.query"; -import * as _632 from "./rpc.tx"; +import * as _428 from "./tokenfactory/v1beta1/tx.amino"; +import * as _429 from "./wasm/v1/tx.amino"; +import * as _430 from "./tokenfactory/v1beta1/tx.registry"; +import * as _431 from "./wasm/v1/tx.registry"; +import * as _432 from "./tokenfactory/v1beta1/query.rpc.Query"; +import * as _433 from "./wasm/v1/query.rpc.Query"; +import * as _434 from "./tokenfactory/v1beta1/tx.rpc.msg"; +import * as _435 from "./wasm/v1/tx.rpc.msg"; +import * as _633 from "./rpc.query"; +import * as _634 from "./rpc.tx"; export namespace cosmwasm { export namespace tokenfactory { export const v1beta1 = { @@ -28,10 +28,10 @@ export namespace cosmwasm { ..._93, ..._94, ..._95, - ..._427, - ..._429, - ..._431, - ..._433 + ..._428, + ..._430, + ..._432, + ..._434 }; } export namespace wasm { @@ -43,14 +43,14 @@ export namespace cosmwasm { ..._100, ..._101, ..._102, - ..._428, - ..._430, - ..._432, - ..._434 + ..._429, + ..._431, + ..._433, + ..._435 }; } export const ClientFactory = { - ..._631, - ..._632 + ..._633, + ..._634 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/cosmwasm/wasm/v1/types.ts b/packages/types/protobuf/codegen/cosmwasm/wasm/v1/types.ts index 2038d7725e..2ede42783e 100644 --- a/packages/types/protobuf/codegen/cosmwasm/wasm/v1/types.ts +++ b/packages/types/protobuf/codegen/cosmwasm/wasm/v1/types.ts @@ -569,7 +569,7 @@ export const Params = { toAmino(message: Params, useInterfaces: boolean = false): ParamsAmino { const obj: any = {}; obj.code_upload_access = message.codeUploadAccess ? AccessConfig.toAmino(message.codeUploadAccess, useInterfaces) : AccessConfig.fromPartial({}); - obj.instantiate_default_permission = accessTypeToJSON(message.instantiateDefaultPermission); + obj.instantiate_default_permission = message.instantiateDefaultPermission; return obj; }, fromAminoMsg(object: ParamsAminoMsg): Params { diff --git a/packages/types/protobuf/codegen/feemarket/bundle.ts b/packages/types/protobuf/codegen/feemarket/bundle.ts index bccbbb731c..d033a329e7 100644 --- a/packages/types/protobuf/codegen/feemarket/bundle.ts +++ b/packages/types/protobuf/codegen/feemarket/bundle.ts @@ -2,12 +2,12 @@ import * as _103 from "./feemarket/v1/genesis"; import * as _104 from "./feemarket/v1/params"; import * as _105 from "./feemarket/v1/query"; import * as _106 from "./feemarket/v1/tx"; -import * as _435 from "./feemarket/v1/tx.amino"; -import * as _436 from "./feemarket/v1/tx.registry"; -import * as _437 from "./feemarket/v1/query.rpc.Query"; -import * as _438 from "./feemarket/v1/tx.rpc.msg"; -import * as _633 from "./rpc.query"; -import * as _634 from "./rpc.tx"; +import * as _436 from "./feemarket/v1/tx.amino"; +import * as _437 from "./feemarket/v1/tx.registry"; +import * as _438 from "./feemarket/v1/query.rpc.Query"; +import * as _439 from "./feemarket/v1/tx.rpc.msg"; +import * as _635 from "./rpc.query"; +import * as _636 from "./rpc.tx"; export namespace feemarket { export namespace feemarket { export const v1 = { @@ -15,14 +15,14 @@ export namespace feemarket { ..._104, ..._105, ..._106, - ..._435, ..._436, ..._437, - ..._438 + ..._438, + ..._439 }; } export const ClientFactory = { - ..._633, - ..._634 + ..._635, + ..._636 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/gaia/bundle.ts b/packages/types/protobuf/codegen/gaia/bundle.ts index 4811e38b3e..44d95e3de7 100644 --- a/packages/types/protobuf/codegen/gaia/bundle.ts +++ b/packages/types/protobuf/codegen/gaia/bundle.ts @@ -1,26 +1,26 @@ import * as _107 from "./globalfee/v1beta1/genesis"; import * as _108 from "./globalfee/v1beta1/query"; import * as _109 from "./globalfee/v1beta1/tx"; -import * as _439 from "./globalfee/v1beta1/tx.amino"; -import * as _440 from "./globalfee/v1beta1/tx.registry"; -import * as _441 from "./globalfee/v1beta1/query.rpc.Query"; -import * as _442 from "./globalfee/v1beta1/tx.rpc.msg"; -import * as _635 from "./rpc.query"; -import * as _636 from "./rpc.tx"; +import * as _440 from "./globalfee/v1beta1/tx.amino"; +import * as _441 from "./globalfee/v1beta1/tx.registry"; +import * as _442 from "./globalfee/v1beta1/query.rpc.Query"; +import * as _443 from "./globalfee/v1beta1/tx.rpc.msg"; +import * as _637 from "./rpc.query"; +import * as _638 from "./rpc.tx"; export namespace gaia { export namespace globalfee { export const v1beta1 = { ..._107, ..._108, ..._109, - ..._439, ..._440, ..._441, - ..._442 + ..._442, + ..._443 }; } export const ClientFactory = { - ..._635, - ..._636 + ..._637, + ..._638 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/ibc/bundle.ts b/packages/types/protobuf/codegen/ibc/bundle.ts index 5d1baf6dfd..2b548c61a3 100644 --- a/packages/types/protobuf/codegen/ibc/bundle.ts +++ b/packages/types/protobuf/codegen/ibc/bundle.ts @@ -20,28 +20,28 @@ import * as _136 from "./core/client/v1/client"; import * as _137 from "./core/client/v1/genesis"; import * as _138 from "./core/client/v1/query"; import * as _139 from "./core/client/v1/tx"; -import * as _443 from "./applications/interchain_accounts/controller/v1/tx.amino"; -import * as _444 from "./applications/interchain_accounts/host/v1/tx.amino"; -import * as _445 from "./applications/transfer/v1/tx.amino"; -import * as _446 from "./core/channel/v1/tx.amino"; -import * as _447 from "./core/client/v1/tx.amino"; -import * as _448 from "./applications/interchain_accounts/controller/v1/tx.registry"; -import * as _449 from "./applications/interchain_accounts/host/v1/tx.registry"; -import * as _450 from "./applications/transfer/v1/tx.registry"; -import * as _451 from "./core/channel/v1/tx.registry"; -import * as _452 from "./core/client/v1/tx.registry"; -import * as _453 from "./applications/interchain_accounts/controller/v1/query.rpc.Query"; -import * as _454 from "./applications/interchain_accounts/host/v1/query.rpc.Query"; -import * as _455 from "./applications/transfer/v1/query.rpc.Query"; -import * as _456 from "./core/channel/v1/query.rpc.Query"; -import * as _457 from "./core/client/v1/query.rpc.Query"; -import * as _458 from "./applications/interchain_accounts/controller/v1/tx.rpc.msg"; -import * as _459 from "./applications/interchain_accounts/host/v1/tx.rpc.msg"; -import * as _460 from "./applications/transfer/v1/tx.rpc.msg"; -import * as _461 from "./core/channel/v1/tx.rpc.msg"; -import * as _462 from "./core/client/v1/tx.rpc.msg"; -import * as _637 from "./rpc.query"; -import * as _638 from "./rpc.tx"; +import * as _444 from "./applications/interchain_accounts/controller/v1/tx.amino"; +import * as _445 from "./applications/interchain_accounts/host/v1/tx.amino"; +import * as _446 from "./applications/transfer/v1/tx.amino"; +import * as _447 from "./core/channel/v1/tx.amino"; +import * as _448 from "./core/client/v1/tx.amino"; +import * as _449 from "./applications/interchain_accounts/controller/v1/tx.registry"; +import * as _450 from "./applications/interchain_accounts/host/v1/tx.registry"; +import * as _451 from "./applications/transfer/v1/tx.registry"; +import * as _452 from "./core/channel/v1/tx.registry"; +import * as _453 from "./core/client/v1/tx.registry"; +import * as _454 from "./applications/interchain_accounts/controller/v1/query.rpc.Query"; +import * as _455 from "./applications/interchain_accounts/host/v1/query.rpc.Query"; +import * as _456 from "./applications/transfer/v1/query.rpc.Query"; +import * as _457 from "./core/channel/v1/query.rpc.Query"; +import * as _458 from "./core/client/v1/query.rpc.Query"; +import * as _459 from "./applications/interchain_accounts/controller/v1/tx.rpc.msg"; +import * as _460 from "./applications/interchain_accounts/host/v1/tx.rpc.msg"; +import * as _461 from "./applications/transfer/v1/tx.rpc.msg"; +import * as _462 from "./core/channel/v1/tx.rpc.msg"; +import * as _463 from "./core/client/v1/tx.rpc.msg"; +import * as _639 from "./rpc.query"; +import * as _640 from "./rpc.tx"; export namespace ibc { export namespace applications { export namespace interchain_accounts { @@ -50,10 +50,10 @@ export namespace ibc { ..._118, ..._119, ..._120, - ..._443, - ..._448, - ..._453, - ..._458 + ..._444, + ..._449, + ..._454, + ..._459 }; } export namespace host { @@ -61,10 +61,10 @@ export namespace ibc { ..._121, ..._122, ..._123, - ..._444, - ..._449, - ..._454, - ..._459 + ..._445, + ..._450, + ..._455, + ..._460 }; } export const v1 = { @@ -80,10 +80,10 @@ export namespace ibc { ..._129, ..._130, ..._131, - ..._445, - ..._450, - ..._455, - ..._460 + ..._446, + ..._451, + ..._456, + ..._461 }; } } @@ -94,10 +94,10 @@ export namespace ibc { ..._133, ..._134, ..._135, - ..._446, - ..._451, - ..._456, - ..._461 + ..._447, + ..._452, + ..._457, + ..._462 }; } export namespace client { @@ -106,15 +106,15 @@ export namespace ibc { ..._137, ..._138, ..._139, - ..._447, - ..._452, - ..._457, - ..._462 + ..._448, + ..._453, + ..._458, + ..._463 }; } } export const ClientFactory = { - ..._637, - ..._638 + ..._639, + ..._640 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/juno/bundle.ts b/packages/types/protobuf/codegen/juno/bundle.ts index 5870586885..2f3eca9f9b 100644 --- a/packages/types/protobuf/codegen/juno/bundle.ts +++ b/packages/types/protobuf/codegen/juno/bundle.ts @@ -6,16 +6,16 @@ import * as _144 from "./mint/genesis"; import * as _145 from "./mint/mint"; import * as _146 from "./mint/query"; import * as _147 from "./mint/tx"; -import * as _463 from "./feeshare/v1/tx.amino"; -import * as _464 from "./mint/tx.amino"; -import * as _465 from "./feeshare/v1/tx.registry"; -import * as _466 from "./mint/tx.registry"; -import * as _467 from "./feeshare/v1/query.rpc.Query"; -import * as _468 from "./mint/query.rpc.Query"; -import * as _469 from "./feeshare/v1/tx.rpc.msg"; -import * as _470 from "./mint/tx.rpc.msg"; -import * as _639 from "./rpc.query"; -import * as _640 from "./rpc.tx"; +import * as _464 from "./feeshare/v1/tx.amino"; +import * as _465 from "./mint/tx.amino"; +import * as _466 from "./feeshare/v1/tx.registry"; +import * as _467 from "./mint/tx.registry"; +import * as _468 from "./feeshare/v1/query.rpc.Query"; +import * as _469 from "./mint/query.rpc.Query"; +import * as _470 from "./feeshare/v1/tx.rpc.msg"; +import * as _471 from "./mint/tx.rpc.msg"; +import * as _641 from "./rpc.query"; +import * as _642 from "./rpc.tx"; export namespace juno { export namespace feeshare { export const v1 = { @@ -23,10 +23,10 @@ export namespace juno { ..._141, ..._142, ..._143, - ..._463, - ..._465, - ..._467, - ..._469 + ..._464, + ..._466, + ..._468, + ..._470 }; } export const mint = { @@ -34,13 +34,13 @@ export namespace juno { ..._145, ..._146, ..._147, - ..._464, - ..._466, - ..._468, - ..._470 + ..._465, + ..._467, + ..._469, + ..._471 }; export const ClientFactory = { - ..._639, - ..._640 + ..._641, + ..._642 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/kujira/bundle.ts b/packages/types/protobuf/codegen/kujira/bundle.ts index 95969085d2..cffefb99ef 100644 --- a/packages/types/protobuf/codegen/kujira/bundle.ts +++ b/packages/types/protobuf/codegen/kujira/bundle.ts @@ -12,17 +12,17 @@ import * as _158 from "./scheduler/hook"; import * as _159 from "./scheduler/params"; import * as _160 from "./scheduler/proposal"; import * as _161 from "./scheduler/query"; -import * as _471 from "./denom/tx.amino"; -import * as _472 from "./oracle/tx.amino"; -import * as _473 from "./denom/tx.registry"; -import * as _474 from "./oracle/tx.registry"; -import * as _475 from "./denom/query.rpc.Query"; -import * as _476 from "./oracle/query.rpc.Query"; -import * as _477 from "./scheduler/query.rpc.Query"; -import * as _478 from "./denom/tx.rpc.msg"; -import * as _479 from "./oracle/tx.rpc.msg"; -import * as _641 from "./rpc.query"; -import * as _642 from "./rpc.tx"; +import * as _472 from "./denom/tx.amino"; +import * as _473 from "./oracle/tx.amino"; +import * as _474 from "./denom/tx.registry"; +import * as _475 from "./oracle/tx.registry"; +import * as _476 from "./denom/query.rpc.Query"; +import * as _477 from "./oracle/query.rpc.Query"; +import * as _478 from "./scheduler/query.rpc.Query"; +import * as _479 from "./denom/tx.rpc.msg"; +import * as _480 from "./oracle/tx.rpc.msg"; +import * as _643 from "./rpc.query"; +import * as _644 from "./rpc.tx"; export namespace kujira { export const denom = { ..._148, @@ -30,20 +30,20 @@ export namespace kujira { ..._150, ..._151, ..._152, - ..._471, - ..._473, - ..._475, - ..._478 + ..._472, + ..._474, + ..._476, + ..._479 }; export const oracle = { ..._153, ..._154, ..._155, ..._156, - ..._472, - ..._474, - ..._476, - ..._479 + ..._473, + ..._475, + ..._477, + ..._480 }; export const scheduler = { ..._157, @@ -51,10 +51,10 @@ export namespace kujira { ..._159, ..._160, ..._161, - ..._477 + ..._478 }; export const ClientFactory = { - ..._641, - ..._642 + ..._643, + ..._644 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/neutron/bundle.ts b/packages/types/protobuf/codegen/neutron/bundle.ts index 7d3d1d7057..d0c8b91d30 100644 --- a/packages/types/protobuf/codegen/neutron/bundle.ts +++ b/packages/types/protobuf/codegen/neutron/bundle.ts @@ -36,32 +36,32 @@ import * as _196 from "./interchaintxs/v1/genesis"; import * as _197 from "./interchaintxs/v1/params"; import * as _198 from "./interchaintxs/v1/query"; import * as _199 from "./interchaintxs/v1/tx"; -import * as _480 from "./cron/tx.amino"; -import * as _481 from "./dex/tx.amino"; -import * as _482 from "./feeburner/tx.amino"; -import * as _483 from "./feerefunder/tx.amino"; -import * as _484 from "./interchainqueries/tx.amino"; -import * as _485 from "./interchaintxs/v1/tx.amino"; -import * as _486 from "./cron/tx.registry"; -import * as _487 from "./dex/tx.registry"; -import * as _488 from "./feeburner/tx.registry"; -import * as _489 from "./feerefunder/tx.registry"; -import * as _490 from "./interchainqueries/tx.registry"; -import * as _491 from "./interchaintxs/v1/tx.registry"; -import * as _492 from "./cron/query.rpc.Query"; -import * as _493 from "./dex/query.rpc.Query"; -import * as _494 from "./feeburner/query.rpc.Query"; -import * as _495 from "./feerefunder/query.rpc.Query"; -import * as _496 from "./interchainqueries/query.rpc.Query"; -import * as _497 from "./interchaintxs/v1/query.rpc.Query"; -import * as _498 from "./cron/tx.rpc.msg"; -import * as _499 from "./dex/tx.rpc.msg"; -import * as _500 from "./feeburner/tx.rpc.msg"; -import * as _501 from "./feerefunder/tx.rpc.msg"; -import * as _502 from "./interchainqueries/tx.rpc.msg"; -import * as _503 from "./interchaintxs/v1/tx.rpc.msg"; -import * as _643 from "./rpc.query"; -import * as _644 from "./rpc.tx"; +import * as _481 from "./cron/tx.amino"; +import * as _482 from "./dex/tx.amino"; +import * as _483 from "./feeburner/tx.amino"; +import * as _484 from "./feerefunder/tx.amino"; +import * as _485 from "./interchainqueries/tx.amino"; +import * as _486 from "./interchaintxs/v1/tx.amino"; +import * as _487 from "./cron/tx.registry"; +import * as _488 from "./dex/tx.registry"; +import * as _489 from "./feeburner/tx.registry"; +import * as _490 from "./feerefunder/tx.registry"; +import * as _491 from "./interchainqueries/tx.registry"; +import * as _492 from "./interchaintxs/v1/tx.registry"; +import * as _493 from "./cron/query.rpc.Query"; +import * as _494 from "./dex/query.rpc.Query"; +import * as _495 from "./feeburner/query.rpc.Query"; +import * as _496 from "./feerefunder/query.rpc.Query"; +import * as _497 from "./interchainqueries/query.rpc.Query"; +import * as _498 from "./interchaintxs/v1/query.rpc.Query"; +import * as _499 from "./cron/tx.rpc.msg"; +import * as _500 from "./dex/tx.rpc.msg"; +import * as _501 from "./feeburner/tx.rpc.msg"; +import * as _502 from "./feerefunder/tx.rpc.msg"; +import * as _503 from "./interchainqueries/tx.rpc.msg"; +import * as _504 from "./interchaintxs/v1/tx.rpc.msg"; +import * as _645 from "./rpc.query"; +import * as _646 from "./rpc.tx"; export namespace neutron { export namespace contractmanager { export const v1 = { @@ -74,10 +74,10 @@ export namespace neutron { ..._165, ..._166, ..._167, - ..._480, - ..._486, - ..._492, - ..._498 + ..._481, + ..._487, + ..._493, + ..._499 }; export const dex = { ..._168, @@ -94,10 +94,10 @@ export namespace neutron { ..._179, ..._180, ..._181, - ..._481, - ..._487, - ..._493, - ..._499 + ..._482, + ..._488, + ..._494, + ..._500 }; export const feeburner = { ..._182, @@ -105,10 +105,10 @@ export namespace neutron { ..._184, ..._185, ..._186, - ..._482, - ..._488, - ..._494, - ..._500 + ..._483, + ..._489, + ..._495, + ..._501 }; export const feerefunder = { ..._187, @@ -116,20 +116,20 @@ export namespace neutron { ..._189, ..._190, ..._191, - ..._483, - ..._489, - ..._495, - ..._501 + ..._484, + ..._490, + ..._496, + ..._502 }; export const interchainqueries = { ..._192, ..._193, ..._194, ..._195, - ..._484, - ..._490, - ..._496, - ..._502 + ..._485, + ..._491, + ..._497, + ..._503 }; export namespace interchaintxs { export const v1 = { @@ -137,14 +137,14 @@ export namespace neutron { ..._197, ..._198, ..._199, - ..._485, - ..._491, - ..._497, - ..._503 + ..._486, + ..._492, + ..._498, + ..._504 }; } export const ClientFactory = { - ..._643, - ..._644 + ..._645, + ..._646 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/noble/bundle.ts b/packages/types/protobuf/codegen/noble/bundle.ts index 6b12c7bd29..cab89031f9 100644 --- a/packages/types/protobuf/codegen/noble/bundle.ts +++ b/packages/types/protobuf/codegen/noble/bundle.ts @@ -1,16 +1,16 @@ import * as _356 from "../tariff/genesis"; import * as _357 from "../tariff/params"; import * as _358 from "../tariff/query"; -import * as _623 from "../tariff/query.rpc.Query"; -import * as _655 from "./rpc.query"; +import * as _624 from "../tariff/query.rpc.Query"; +import * as _657 from "./rpc.query"; export namespace noble { export const tariff = { ..._356, ..._357, ..._358, - ..._623 + ..._624 }; export const ClientFactory = { - ..._655 + ..._657 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/osmosis/bundle.ts b/packages/types/protobuf/codegen/osmosis/bundle.ts index b5429427a4..df38b2ad0e 100644 --- a/packages/types/protobuf/codegen/osmosis/bundle.ts +++ b/packages/types/protobuf/codegen/osmosis/bundle.ts @@ -74,63 +74,63 @@ import * as _272 from "./txfees/v1beta1/tx"; import * as _273 from "./valset-pref/v1beta1/query"; import * as _274 from "./valset-pref/v1beta1/state"; import * as _275 from "./valset-pref/v1beta1/tx"; -import * as _504 from "./concentratedliquidity/poolmodel/concentrated/v1beta1/tx.amino"; -import * as _505 from "./concentratedliquidity/v1beta1/tx.amino"; -import * as _506 from "./gamm/pool-models/balancer/tx/tx.amino"; -import * as _507 from "./gamm/pool-models/stableswap/tx.amino"; -import * as _508 from "./gamm/v1beta1/tx.amino"; -import * as _509 from "./incentives/tx.amino"; -import * as _510 from "./lockup/tx.amino"; -import * as _511 from "./poolmanager/v1beta1/tx.amino"; -import * as _512 from "./protorev/v1beta1/tx.amino"; -import * as _513 from "./smartaccount/v1beta1/tx.amino"; -import * as _514 from "./superfluid/tx.amino"; -import * as _515 from "./tokenfactory/v1beta1/tx.amino"; -import * as _516 from "./txfees/v1beta1/tx.amino"; -import * as _517 from "./valset-pref/v1beta1/tx.amino"; -import * as _518 from "./concentratedliquidity/poolmodel/concentrated/v1beta1/tx.registry"; -import * as _519 from "./concentratedliquidity/v1beta1/tx.registry"; -import * as _520 from "./gamm/pool-models/balancer/tx/tx.registry"; -import * as _521 from "./gamm/pool-models/stableswap/tx.registry"; -import * as _522 from "./gamm/v1beta1/tx.registry"; -import * as _523 from "./incentives/tx.registry"; -import * as _524 from "./lockup/tx.registry"; -import * as _525 from "./poolmanager/v1beta1/tx.registry"; -import * as _526 from "./protorev/v1beta1/tx.registry"; -import * as _527 from "./smartaccount/v1beta1/tx.registry"; -import * as _528 from "./superfluid/tx.registry"; -import * as _529 from "./tokenfactory/v1beta1/tx.registry"; -import * as _530 from "./txfees/v1beta1/tx.registry"; -import * as _531 from "./valset-pref/v1beta1/tx.registry"; -import * as _532 from "./concentratedliquidity/v1beta1/query.rpc.Query"; -import * as _533 from "./cosmwasmpool/v1beta1/query.rpc.Query"; -import * as _534 from "./gamm/v1beta1/query.rpc.Query"; -import * as _535 from "./incentives/query.rpc.Query"; -import * as _536 from "./lockup/query.rpc.Query"; -import * as _537 from "./pool-incentives/v1beta1/query.rpc.Query"; -import * as _538 from "./poolmanager/v1beta1/query.rpc.Query"; -import * as _539 from "./protorev/v1beta1/query.rpc.Query"; -import * as _540 from "./smartaccount/v1beta1/query.rpc.Query"; -import * as _541 from "./superfluid/query.rpc.Query"; -import * as _542 from "./tokenfactory/v1beta1/query.rpc.Query"; -import * as _543 from "./txfees/v1beta1/query.rpc.Query"; -import * as _544 from "./valset-pref/v1beta1/query.rpc.Query"; -import * as _545 from "./concentratedliquidity/poolmodel/concentrated/v1beta1/tx.rpc.msg"; -import * as _546 from "./concentratedliquidity/v1beta1/tx.rpc.msg"; -import * as _547 from "./gamm/pool-models/balancer/tx/tx.rpc.msg"; -import * as _548 from "./gamm/pool-models/stableswap/tx.rpc.msg"; -import * as _549 from "./gamm/v1beta1/tx.rpc.msg"; -import * as _550 from "./incentives/tx.rpc.msg"; -import * as _551 from "./lockup/tx.rpc.msg"; -import * as _552 from "./poolmanager/v1beta1/tx.rpc.msg"; -import * as _553 from "./protorev/v1beta1/tx.rpc.msg"; -import * as _554 from "./smartaccount/v1beta1/tx.rpc.msg"; -import * as _555 from "./superfluid/tx.rpc.msg"; -import * as _556 from "./tokenfactory/v1beta1/tx.rpc.msg"; -import * as _557 from "./txfees/v1beta1/tx.rpc.msg"; -import * as _558 from "./valset-pref/v1beta1/tx.rpc.msg"; -import * as _645 from "./rpc.query"; -import * as _646 from "./rpc.tx"; +import * as _505 from "./concentratedliquidity/poolmodel/concentrated/v1beta1/tx.amino"; +import * as _506 from "./concentratedliquidity/v1beta1/tx.amino"; +import * as _507 from "./gamm/pool-models/balancer/tx/tx.amino"; +import * as _508 from "./gamm/pool-models/stableswap/tx.amino"; +import * as _509 from "./gamm/v1beta1/tx.amino"; +import * as _510 from "./incentives/tx.amino"; +import * as _511 from "./lockup/tx.amino"; +import * as _512 from "./poolmanager/v1beta1/tx.amino"; +import * as _513 from "./protorev/v1beta1/tx.amino"; +import * as _514 from "./smartaccount/v1beta1/tx.amino"; +import * as _515 from "./superfluid/tx.amino"; +import * as _516 from "./tokenfactory/v1beta1/tx.amino"; +import * as _517 from "./txfees/v1beta1/tx.amino"; +import * as _518 from "./valset-pref/v1beta1/tx.amino"; +import * as _519 from "./concentratedliquidity/poolmodel/concentrated/v1beta1/tx.registry"; +import * as _520 from "./concentratedliquidity/v1beta1/tx.registry"; +import * as _521 from "./gamm/pool-models/balancer/tx/tx.registry"; +import * as _522 from "./gamm/pool-models/stableswap/tx.registry"; +import * as _523 from "./gamm/v1beta1/tx.registry"; +import * as _524 from "./incentives/tx.registry"; +import * as _525 from "./lockup/tx.registry"; +import * as _526 from "./poolmanager/v1beta1/tx.registry"; +import * as _527 from "./protorev/v1beta1/tx.registry"; +import * as _528 from "./smartaccount/v1beta1/tx.registry"; +import * as _529 from "./superfluid/tx.registry"; +import * as _530 from "./tokenfactory/v1beta1/tx.registry"; +import * as _531 from "./txfees/v1beta1/tx.registry"; +import * as _532 from "./valset-pref/v1beta1/tx.registry"; +import * as _533 from "./concentratedliquidity/v1beta1/query.rpc.Query"; +import * as _534 from "./cosmwasmpool/v1beta1/query.rpc.Query"; +import * as _535 from "./gamm/v1beta1/query.rpc.Query"; +import * as _536 from "./incentives/query.rpc.Query"; +import * as _537 from "./lockup/query.rpc.Query"; +import * as _538 from "./pool-incentives/v1beta1/query.rpc.Query"; +import * as _539 from "./poolmanager/v1beta1/query.rpc.Query"; +import * as _540 from "./protorev/v1beta1/query.rpc.Query"; +import * as _541 from "./smartaccount/v1beta1/query.rpc.Query"; +import * as _542 from "./superfluid/query.rpc.Query"; +import * as _543 from "./tokenfactory/v1beta1/query.rpc.Query"; +import * as _544 from "./txfees/v1beta1/query.rpc.Query"; +import * as _545 from "./valset-pref/v1beta1/query.rpc.Query"; +import * as _546 from "./concentratedliquidity/poolmodel/concentrated/v1beta1/tx.rpc.msg"; +import * as _547 from "./concentratedliquidity/v1beta1/tx.rpc.msg"; +import * as _548 from "./gamm/pool-models/balancer/tx/tx.rpc.msg"; +import * as _549 from "./gamm/pool-models/stableswap/tx.rpc.msg"; +import * as _550 from "./gamm/v1beta1/tx.rpc.msg"; +import * as _551 from "./incentives/tx.rpc.msg"; +import * as _552 from "./lockup/tx.rpc.msg"; +import * as _553 from "./poolmanager/v1beta1/tx.rpc.msg"; +import * as _554 from "./protorev/v1beta1/tx.rpc.msg"; +import * as _555 from "./smartaccount/v1beta1/tx.rpc.msg"; +import * as _556 from "./superfluid/tx.rpc.msg"; +import * as _557 from "./tokenfactory/v1beta1/tx.rpc.msg"; +import * as _558 from "./txfees/v1beta1/tx.rpc.msg"; +import * as _559 from "./valset-pref/v1beta1/tx.rpc.msg"; +import * as _647 from "./rpc.query"; +import * as _648 from "./rpc.tx"; export namespace osmosis { export namespace accum { export const v1beta1 = { @@ -142,17 +142,17 @@ export namespace osmosis { poolmodel: { concentrated: { v1beta1: { - ..._504, - ..._518, - ..._545 + ..._505, + ..._519, + ..._546 } } }, v1beta1: { - ..._505, - ..._519, - ..._532, - ..._546 + ..._506, + ..._520, + ..._533, + ..._547 } }; export namespace cosmwasmpool { @@ -169,7 +169,7 @@ export namespace osmosis { ..._211, ..._212, ..._213, - ..._533 + ..._534 }; } export namespace gamm { @@ -180,27 +180,27 @@ export namespace osmosis { ..._217, ..._218, ..._219, - ..._508, - ..._522, - ..._534, - ..._549 + ..._509, + ..._523, + ..._535, + ..._550 }; export namespace poolmodels { export namespace balancer { export const v1beta1 = { ..._220, - ..._506, - ..._520, - ..._547 + ..._507, + ..._521, + ..._548 }; } export namespace stableswap { export const v1beta1 = { ..._221, ..._222, - ..._507, - ..._521, - ..._548 + ..._508, + ..._522, + ..._549 }; } } @@ -213,10 +213,10 @@ export namespace osmosis { ..._227, ..._228, ..._229, - ..._509, - ..._523, - ..._535, - ..._550 + ..._510, + ..._524, + ..._536, + ..._551 }; export const lockup = { ..._230, @@ -224,10 +224,10 @@ export namespace osmosis { ..._232, ..._233, ..._234, - ..._510, - ..._524, - ..._536, - ..._551 + ..._511, + ..._525, + ..._537, + ..._552 }; export namespace poolincentives { export const v1beta1 = { @@ -236,7 +236,7 @@ export namespace osmosis { ..._237, ..._238, ..._239, - ..._537 + ..._538 }; } export namespace poolmanager { @@ -247,10 +247,10 @@ export namespace osmosis { ..._243, ..._244, ..._245, - ..._511, - ..._525, - ..._538, - ..._552 + ..._512, + ..._526, + ..._539, + ..._553 }; } export namespace protorev { @@ -261,10 +261,10 @@ export namespace osmosis { ..._249, ..._250, ..._251, - ..._512, - ..._526, - ..._539, - ..._553 + ..._513, + ..._527, + ..._540, + ..._554 }; } export namespace smartaccount { @@ -274,10 +274,10 @@ export namespace osmosis { ..._254, ..._255, ..._256, - ..._513, - ..._527, - ..._540, - ..._554 + ..._514, + ..._528, + ..._541, + ..._555 }; } export const superfluid = { @@ -286,10 +286,10 @@ export namespace osmosis { ..._259, ..._260, ..._261, - ..._514, - ..._528, - ..._541, - ..._555 + ..._515, + ..._529, + ..._542, + ..._556 }; export namespace tokenfactory { export const v1beta1 = { @@ -298,10 +298,10 @@ export namespace osmosis { ..._264, ..._265, ..._266, - ..._515, - ..._529, - ..._542, - ..._556 + ..._516, + ..._530, + ..._543, + ..._557 }; } export namespace txfees { @@ -312,10 +312,10 @@ export namespace osmosis { ..._270, ..._271, ..._272, - ..._516, - ..._530, - ..._543, - ..._557 + ..._517, + ..._531, + ..._544, + ..._558 }; } export namespace valsetpref { @@ -323,14 +323,14 @@ export namespace osmosis { ..._273, ..._274, ..._275, - ..._517, - ..._531, - ..._544, - ..._558 + ..._518, + ..._532, + ..._545, + ..._559 }; } export const ClientFactory = { - ..._645, - ..._646 + ..._647, + ..._648 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/pstake/bundle.ts b/packages/types/protobuf/codegen/pstake/bundle.ts index be67c481a2..a413991539 100644 --- a/packages/types/protobuf/codegen/pstake/bundle.ts +++ b/packages/types/protobuf/codegen/pstake/bundle.ts @@ -19,24 +19,24 @@ import * as _293 from "./ratesync/v1beta1/params"; import * as _294 from "./ratesync/v1beta1/query"; import * as _295 from "./ratesync/v1beta1/ratesync"; import * as _296 from "./ratesync/v1beta1/tx"; -import * as _559 from "./liquidstake/v1beta1/tx.amino"; -import * as _560 from "./liquidstakeibc/v1beta1/msgs.amino"; -import * as _561 from "./lscosmos/v1beta1/msgs.amino"; -import * as _562 from "./ratesync/v1beta1/tx.amino"; -import * as _563 from "./liquidstake/v1beta1/tx.registry"; -import * as _564 from "./liquidstakeibc/v1beta1/msgs.registry"; -import * as _565 from "./lscosmos/v1beta1/msgs.registry"; -import * as _566 from "./ratesync/v1beta1/tx.registry"; -import * as _567 from "./liquidstake/v1beta1/query.rpc.Query"; -import * as _568 from "./liquidstakeibc/v1beta1/query.rpc.Query"; -import * as _569 from "./lscosmos/v1beta1/query.rpc.Query"; -import * as _570 from "./ratesync/v1beta1/query.rpc.Query"; -import * as _571 from "./liquidstake/v1beta1/tx.rpc.msg"; -import * as _572 from "./liquidstakeibc/v1beta1/msgs.rpc.msg"; -import * as _573 from "./lscosmos/v1beta1/msgs.rpc.msg"; -import * as _574 from "./ratesync/v1beta1/tx.rpc.msg"; -import * as _647 from "./rpc.query"; -import * as _648 from "./rpc.tx"; +import * as _560 from "./liquidstake/v1beta1/tx.amino"; +import * as _561 from "./liquidstakeibc/v1beta1/msgs.amino"; +import * as _562 from "./lscosmos/v1beta1/msgs.amino"; +import * as _563 from "./ratesync/v1beta1/tx.amino"; +import * as _564 from "./liquidstake/v1beta1/tx.registry"; +import * as _565 from "./liquidstakeibc/v1beta1/msgs.registry"; +import * as _566 from "./lscosmos/v1beta1/msgs.registry"; +import * as _567 from "./ratesync/v1beta1/tx.registry"; +import * as _568 from "./liquidstake/v1beta1/query.rpc.Query"; +import * as _569 from "./liquidstakeibc/v1beta1/query.rpc.Query"; +import * as _570 from "./lscosmos/v1beta1/query.rpc.Query"; +import * as _571 from "./ratesync/v1beta1/query.rpc.Query"; +import * as _572 from "./liquidstake/v1beta1/tx.rpc.msg"; +import * as _573 from "./liquidstakeibc/v1beta1/msgs.rpc.msg"; +import * as _574 from "./lscosmos/v1beta1/msgs.rpc.msg"; +import * as _575 from "./ratesync/v1beta1/tx.rpc.msg"; +import * as _649 from "./rpc.query"; +import * as _650 from "./rpc.tx"; export namespace pstake { export namespace liquidstake { export const v1beta1 = { @@ -44,10 +44,10 @@ export namespace pstake { ..._277, ..._278, ..._279, - ..._559, - ..._563, - ..._567, - ..._571 + ..._560, + ..._564, + ..._568, + ..._572 }; } export namespace liquidstakeibc { @@ -57,10 +57,10 @@ export namespace pstake { ..._282, ..._283, ..._284, - ..._560, - ..._564, - ..._568, - ..._572 + ..._561, + ..._565, + ..._569, + ..._573 }; } export namespace lscosmos { @@ -71,10 +71,10 @@ export namespace pstake { ..._288, ..._289, ..._290, - ..._561, - ..._565, - ..._569, - ..._573 + ..._562, + ..._566, + ..._570, + ..._574 }; } export namespace ratesync { @@ -85,14 +85,14 @@ export namespace pstake { ..._294, ..._295, ..._296, - ..._562, - ..._566, - ..._570, - ..._574 + ..._563, + ..._567, + ..._571, + ..._575 }; } export const ClientFactory = { - ..._647, - ..._648 + ..._649, + ..._650 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/publicawesome/bundle.ts b/packages/types/protobuf/codegen/publicawesome/bundle.ts index d025cc08e9..93dceea07b 100644 --- a/packages/types/protobuf/codegen/publicawesome/bundle.ts +++ b/packages/types/protobuf/codegen/publicawesome/bundle.ts @@ -16,21 +16,21 @@ import * as _311 from "./stargaze/mint/v1beta1/genesis"; import * as _312 from "./stargaze/mint/v1beta1/mint"; import * as _313 from "./stargaze/mint/v1beta1/query"; import * as _314 from "./stargaze/mint/v1beta1/tx"; -import * as _575 from "./stargaze/alloc/v1beta1/tx.amino"; -import * as _576 from "./stargaze/cron/v1/tx.amino"; -import * as _577 from "./stargaze/globalfee/v1/tx.amino"; -import * as _578 from "./stargaze/alloc/v1beta1/tx.registry"; -import * as _579 from "./stargaze/cron/v1/tx.registry"; -import * as _580 from "./stargaze/globalfee/v1/tx.registry"; -import * as _581 from "./stargaze/alloc/v1beta1/query.rpc.Query"; -import * as _582 from "./stargaze/cron/v1/query.rpc.Query"; -import * as _583 from "./stargaze/globalfee/v1/query.rpc.Query"; -import * as _584 from "./stargaze/mint/v1beta1/query.rpc.Query"; -import * as _585 from "./stargaze/alloc/v1beta1/tx.rpc.msg"; -import * as _586 from "./stargaze/cron/v1/tx.rpc.msg"; -import * as _587 from "./stargaze/globalfee/v1/tx.rpc.msg"; -import * as _649 from "./rpc.query"; -import * as _650 from "./rpc.tx"; +import * as _576 from "./stargaze/alloc/v1beta1/tx.amino"; +import * as _577 from "./stargaze/cron/v1/tx.amino"; +import * as _578 from "./stargaze/globalfee/v1/tx.amino"; +import * as _579 from "./stargaze/alloc/v1beta1/tx.registry"; +import * as _580 from "./stargaze/cron/v1/tx.registry"; +import * as _581 from "./stargaze/globalfee/v1/tx.registry"; +import * as _582 from "./stargaze/alloc/v1beta1/query.rpc.Query"; +import * as _583 from "./stargaze/cron/v1/query.rpc.Query"; +import * as _584 from "./stargaze/globalfee/v1/query.rpc.Query"; +import * as _585 from "./stargaze/mint/v1beta1/query.rpc.Query"; +import * as _586 from "./stargaze/alloc/v1beta1/tx.rpc.msg"; +import * as _587 from "./stargaze/cron/v1/tx.rpc.msg"; +import * as _588 from "./stargaze/globalfee/v1/tx.rpc.msg"; +import * as _651 from "./rpc.query"; +import * as _652 from "./rpc.tx"; export namespace publicawesome { export namespace stargaze { export namespace alloc { @@ -39,10 +39,10 @@ export namespace publicawesome { ..._298, ..._299, ..._300, - ..._575, - ..._578, - ..._581, - ..._585 + ..._576, + ..._579, + ..._582, + ..._586 }; } export namespace cron { @@ -52,10 +52,10 @@ export namespace publicawesome { ..._303, ..._304, ..._305, - ..._576, - ..._579, - ..._582, - ..._586 + ..._577, + ..._580, + ..._583, + ..._587 }; } export namespace globalfee { @@ -65,10 +65,10 @@ export namespace publicawesome { ..._308, ..._309, ..._310, - ..._577, - ..._580, - ..._583, - ..._587 + ..._578, + ..._581, + ..._584, + ..._588 }; } export namespace mint { @@ -77,12 +77,12 @@ export namespace publicawesome { ..._312, ..._313, ..._314, - ..._584 + ..._585 }; } } export const ClientFactory = { - ..._649, - ..._650 + ..._651, + ..._652 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/regen/bundle.ts b/packages/types/protobuf/codegen/regen/bundle.ts index 20954122ca..734fb2f2b0 100644 --- a/packages/types/protobuf/codegen/regen/bundle.ts +++ b/packages/types/protobuf/codegen/regen/bundle.ts @@ -25,30 +25,30 @@ import * as _338 from "./ecocredit/v1alpha1/tx"; import * as _339 from "./ecocredit/v1alpha1/types"; import * as _340 from "./intertx/v1/query"; import * as _341 from "./intertx/v1/tx"; -import * as _588 from "./data/v1/tx.amino"; -import * as _589 from "./data/v2/tx.amino"; -import * as _590 from "./ecocredit/basket/v1/tx.amino"; -import * as _591 from "./ecocredit/marketplace/v1/tx.amino"; -import * as _592 from "./ecocredit/v1/tx.amino"; -import * as _593 from "./ecocredit/v1alpha1/tx.amino"; -import * as _594 from "./intertx/v1/tx.amino"; -import * as _595 from "./data/v1/tx.registry"; -import * as _596 from "./data/v2/tx.registry"; -import * as _597 from "./ecocredit/basket/v1/tx.registry"; -import * as _598 from "./ecocredit/marketplace/v1/tx.registry"; -import * as _599 from "./ecocredit/v1/tx.registry"; -import * as _600 from "./ecocredit/v1alpha1/tx.registry"; -import * as _601 from "./intertx/v1/tx.registry"; -import * as _602 from "./intertx/v1/query.rpc.Query"; -import * as _603 from "./data/v1/tx.rpc.msg"; -import * as _604 from "./data/v2/tx.rpc.msg"; -import * as _605 from "./ecocredit/basket/v1/tx.rpc.msg"; -import * as _606 from "./ecocredit/marketplace/v1/tx.rpc.msg"; -import * as _607 from "./ecocredit/v1/tx.rpc.msg"; -import * as _608 from "./ecocredit/v1alpha1/tx.rpc.msg"; -import * as _609 from "./intertx/v1/tx.rpc.msg"; -import * as _651 from "./rpc.query"; -import * as _652 from "./rpc.tx"; +import * as _589 from "./data/v1/tx.amino"; +import * as _590 from "./data/v2/tx.amino"; +import * as _591 from "./ecocredit/basket/v1/tx.amino"; +import * as _592 from "./ecocredit/marketplace/v1/tx.amino"; +import * as _593 from "./ecocredit/v1/tx.amino"; +import * as _594 from "./ecocredit/v1alpha1/tx.amino"; +import * as _595 from "./intertx/v1/tx.amino"; +import * as _596 from "./data/v1/tx.registry"; +import * as _597 from "./data/v2/tx.registry"; +import * as _598 from "./ecocredit/basket/v1/tx.registry"; +import * as _599 from "./ecocredit/marketplace/v1/tx.registry"; +import * as _600 from "./ecocredit/v1/tx.registry"; +import * as _601 from "./ecocredit/v1alpha1/tx.registry"; +import * as _602 from "./intertx/v1/tx.registry"; +import * as _603 from "./intertx/v1/query.rpc.Query"; +import * as _604 from "./data/v1/tx.rpc.msg"; +import * as _605 from "./data/v2/tx.rpc.msg"; +import * as _606 from "./ecocredit/basket/v1/tx.rpc.msg"; +import * as _607 from "./ecocredit/marketplace/v1/tx.rpc.msg"; +import * as _608 from "./ecocredit/v1/tx.rpc.msg"; +import * as _609 from "./ecocredit/v1alpha1/tx.rpc.msg"; +import * as _610 from "./intertx/v1/tx.rpc.msg"; +import * as _653 from "./rpc.query"; +import * as _654 from "./rpc.tx"; export namespace regen { export namespace data { export const v1 = { @@ -56,18 +56,18 @@ export namespace regen { ..._316, ..._317, ..._318, - ..._588, - ..._595, - ..._603 + ..._589, + ..._596, + ..._604 }; export const v2 = { ..._319, ..._320, ..._321, ..._322, - ..._589, - ..._596, - ..._604 + ..._590, + ..._597, + ..._605 }; } export namespace ecocredit { @@ -77,9 +77,9 @@ export namespace regen { ..._324, ..._325, ..._326, - ..._590, - ..._597, - ..._605 + ..._591, + ..._598, + ..._606 }; } export namespace marketplace { @@ -88,9 +88,9 @@ export namespace regen { ..._328, ..._329, ..._330, - ..._591, - ..._598, - ..._606 + ..._592, + ..._599, + ..._607 }; } export namespace orderbook { @@ -103,32 +103,32 @@ export namespace regen { ..._333, ..._334, ..._335, - ..._592, - ..._599, - ..._607 + ..._593, + ..._600, + ..._608 }; export const v1alpha1 = { ..._336, ..._337, ..._338, ..._339, - ..._593, - ..._600, - ..._608 + ..._594, + ..._601, + ..._609 }; } export namespace intertx { export const v1 = { ..._340, ..._341, - ..._594, - ..._601, + ..._595, ..._602, - ..._609 + ..._603, + ..._610 }; } export const ClientFactory = { - ..._651, - ..._652 + ..._653, + ..._654 }; } \ No newline at end of file diff --git a/packages/types/protobuf/codegen/secret/bundle.ts b/packages/types/protobuf/codegen/secret/bundle.ts index 203747186b..70ec6d3536 100644 --- a/packages/types/protobuf/codegen/secret/bundle.ts +++ b/packages/types/protobuf/codegen/secret/bundle.ts @@ -12,21 +12,21 @@ import * as _352 from "./registration/v1beta1/genesis"; import * as _353 from "./registration/v1beta1/msg"; import * as _354 from "./registration/v1beta1/query"; import * as _355 from "./registration/v1beta1/types"; -import * as _610 from "./compute/v1beta1/msg.amino"; -import * as _611 from "./emergencybutton/v1beta1/tx.amino"; -import * as _612 from "./intertx/v1beta1/tx.amino"; -import * as _613 from "./compute/v1beta1/msg.registry"; -import * as _614 from "./emergencybutton/v1beta1/tx.registry"; -import * as _615 from "./intertx/v1beta1/tx.registry"; -import * as _616 from "./compute/v1beta1/query.rpc.Query"; -import * as _617 from "./emergencybutton/v1beta1/query.rpc.Query"; -import * as _618 from "./intertx/v1beta1/query.rpc.Query"; -import * as _619 from "./registration/v1beta1/query.rpc.Query"; -import * as _620 from "./compute/v1beta1/msg.rpc.msg"; -import * as _621 from "./emergencybutton/v1beta1/tx.rpc.msg"; -import * as _622 from "./intertx/v1beta1/tx.rpc.msg"; -import * as _653 from "./rpc.query"; -import * as _654 from "./rpc.tx"; +import * as _611 from "./compute/v1beta1/msg.amino"; +import * as _612 from "./emergencybutton/v1beta1/tx.amino"; +import * as _613 from "./intertx/v1beta1/tx.amino"; +import * as _614 from "./compute/v1beta1/msg.registry"; +import * as _615 from "./emergencybutton/v1beta1/tx.registry"; +import * as _616 from "./intertx/v1beta1/tx.registry"; +import * as _617 from "./compute/v1beta1/query.rpc.Query"; +import * as _618 from "./emergencybutton/v1beta1/query.rpc.Query"; +import * as _619 from "./intertx/v1beta1/query.rpc.Query"; +import * as _620 from "./registration/v1beta1/query.rpc.Query"; +import * as _621 from "./compute/v1beta1/msg.rpc.msg"; +import * as _622 from "./emergencybutton/v1beta1/tx.rpc.msg"; +import * as _623 from "./intertx/v1beta1/tx.rpc.msg"; +import * as _655 from "./rpc.query"; +import * as _656 from "./rpc.tx"; export namespace secret { export namespace compute { export const v1beta1 = { @@ -34,10 +34,10 @@ export namespace secret { ..._343, ..._344, ..._345, - ..._610, - ..._613, - ..._616, - ..._620 + ..._611, + ..._614, + ..._617, + ..._621 }; } export namespace emergencybutton { @@ -46,20 +46,20 @@ export namespace secret { ..._347, ..._348, ..._349, - ..._611, - ..._614, - ..._617, - ..._621 + ..._612, + ..._615, + ..._618, + ..._622 }; } export namespace intertx { export const v1beta1 = { ..._350, ..._351, - ..._612, - ..._615, - ..._618, - ..._622 + ..._613, + ..._616, + ..._619, + ..._623 }; } export namespace registration { @@ -68,11 +68,11 @@ export namespace secret { ..._353, ..._354, ..._355, - ..._619 + ..._620 }; } export const ClientFactory = { - ..._653, - ..._654 + ..._655, + ..._656 }; } \ No newline at end of file diff --git a/packages/types/protobuf/scripts/codegen.js b/packages/types/protobuf/scripts/codegen.js index 247dde379e..f21dfd5f02 100644 --- a/packages/types/protobuf/scripts/codegen.js +++ b/packages/types/protobuf/scripts/codegen.js @@ -117,6 +117,7 @@ telescope({ 'pstake.lscosmos.v1beta1', 'pstake.ratesync.v1beta1', 'bitsong.fantoken', + 'bitsong.fantoken.v1beta1', 'feemarket.feemarket.v1', 'secret.compute.v1beta1', 'secret.emergencybutton.v1beta1', diff --git a/packages/utils/client.ts b/packages/utils/client.ts index 9b21c2059b..cf918f0aec 100644 --- a/packages/utils/client.ts +++ b/packages/utils/client.ts @@ -9,6 +9,7 @@ import { } from '@cosmjs/tendermint-rpc' import { + bitsong, cosmos, cosmwasm, feemarket, @@ -293,6 +294,22 @@ export const feemarketProtoRpcClientRouter = new ChainClientRouter({ ), }) +/* + * Router for connecting to an RPC client with BitSong protobufs. + */ +export const bitsongProtoRpcClientRouter = new ChainClientRouter({ + handleConnect: async (chainId: string) => + retry( + 10, + async (attempt) => + ( + await bitsong.ClientFactory.createRPCQueryClient({ + rpcEndpoint: getRpcForChainId(chainId, attempt - 1), + }) + ).bitsong + ), +}) + /** * Get CosmWasmClient for the appropriate chain. * diff --git a/packages/utils/constants/chains.ts b/packages/utils/constants/chains.ts index 8fc79742ca..d3511f2aa9 100644 --- a/packages/utils/constants/chains.ts +++ b/packages/utils/constants/chains.ts @@ -2084,33 +2084,33 @@ export const SUPPORTED_CHAINS: SupportedChainConfig[] = [ name: 'bitsong', mainnet: false, accentColor: '#c53381', - // Token creation factory not yet ready. - tokenCreationUnderDevelopment: true, factoryContractAddress: - 'bitsong1ewd84afkxwxmqeu56p5mt3h446mgh3nh8yvmj2238akvu4ax7kss4a3u5c', + 'bitsong143q5c9ceafcve0xcllxlnk3a8kw3q4xjyk0j27mpye9gamdaaxvq8d7f7h', + tokenCreationFactoryAddress: + 'bitsong1czmxw9memalgt7823ud5r9hpknhcq2jzz7skah803rx0ug0xpx9qxsq6gx', codeIdsVersion: ContractVersion.V242, codeIds: { // https://github.com/CosmWasm/cw-plus - Cw1Whitelist: 7, - Cw4Group: 8, // v0.16 + Cw1Whitelist: 30, + Cw4Group: 31, // v0.16 // https://github.com/CosmWasm/cw-nfts - Cw721Base: 9, + Cw721Base: 32, - CwPayrollFactory: 11, - CwTokenSwap: 12, - CwTokenfactoryIssuerMain: 27, - CwVesting: 13, - DaoCore: 14, + CwPayrollFactory: 33, + CwTokenSwap: 34, + CwTokenfactoryIssuerMain: 46, + CwVesting: 35, + DaoCore: 36, DaoMigrator: -1, // not needed since only v2 DAOs exist - DaoPreProposeApprovalSingle: 16, - DaoPreProposeApprover: 17, - DaoPreProposeMultiple: 18, - DaoPreProposeSingle: 19, - DaoProposalMultiple: 20, - DaoProposalSingle: 21, - DaoVotingCw4: 22, - DaoVotingCw721Staked: 23, - DaoVotingTokenStaked: 28, + DaoPreProposeApprovalSingle: 38, + DaoPreProposeApprover: 39, + DaoPreProposeMultiple: 40, + DaoPreProposeSingle: 41, + DaoProposalMultiple: 42, + DaoProposalSingle: 43, + DaoVotingCw4: 44, + DaoVotingCw721Staked: 45, + DaoVotingTokenStaked: 47, }, }, // TODO(secret-testnet)