diff --git a/dist/account.d.ts b/dist/account.d.ts new file mode 100644 index 0000000..8ffecbe --- /dev/null +++ b/dist/account.d.ts @@ -0,0 +1,49 @@ +/// +import { Payload, Signature } from './types'; +/** + * Registry account. + */ +export declare class Account { + _privateKey: Buffer; + _publicKey: Uint8Array; + _encodedPubkey: string; + _formattedCosmosAddress: string; + _registryPublicKey: string; + _registryAddress: string; + _ethAddress: string; + /** + * Generate bip39 mnemonic. + */ + static generateMnemonic(): string; + /** + * Generate private key from mnemonic. + */ + static generateFromMnemonic(mnemonic: string): Promise; + /** + * New Account. + */ + constructor(privateKey: Buffer); + get privateKey(): Buffer; + get encodedPubkey(): string; + get formattedCosmosAddress(): string; + get registryPublicKey(): string; + get registryAddress(): string; + init(): void; + /** + * Get private key. + */ + getPrivateKey(): string; + /** + * Get cosmos address. + */ + getCosmosAddress(): string; + /** + * Get record signature. + */ + signRecord(record: any): Promise; + signPayload(payload: Payload): Promise; + /** + * Sign message. + */ + sign(message: any): string; +} diff --git a/dist/account.js b/dist/account.js new file mode 100644 index 0000000..b2b6628 --- /dev/null +++ b/dist/account.js @@ -0,0 +1,178 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Account = void 0; +const assert_1 = __importDefault(require("assert")); +const bip32_1 = __importDefault(require("bip32")); +const ecc = __importStar(require("tiny-secp256k1")); +const bip39 = __importStar(require("bip39")); +const canonical_json_1 = __importDefault(require("canonical-json")); +const secp256k1_1 = __importDefault(require("secp256k1")); +const ethers_1 = require("ethers"); +const js_sha256_1 = require("js-sha256"); +const eth_sig_util_1 = require("@metamask/eth-sig-util"); +const crypto_1 = require("@cosmjs/crypto"); +const encoding_1 = require("@cosmjs/encoding"); +const address_converter_1 = require("@tharsis/address-converter"); +const amino_1 = require("@cosmjs/amino"); +const types_1 = require("./types"); +const AMINO_PREFIX = 'EB5AE98721'; +const HDPATH = "m/44'/60'/0'/0"; +const bip32 = (0, bip32_1.default)(ecc); +/** + * Registry account. + */ +class Account { + /** + * New Account. + */ + constructor(privateKey) { + (0, assert_1.default)(privateKey); + this._privateKey = privateKey; + this.init(); + } + /** + * Generate bip39 mnemonic. + */ + static generateMnemonic() { + return bip39.generateMnemonic(); + } + /** + * Generate private key from mnemonic. + */ + static generateFromMnemonic(mnemonic) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(mnemonic); + const seed = yield bip39.mnemonicToSeed(mnemonic); + const wallet = bip32.fromSeed(seed); + const account = wallet.derivePath(HDPATH); + const { privateKey } = account; + (0, assert_1.default)(privateKey); + return new Account(privateKey); + }); + } + get privateKey() { + return this._privateKey; + } + get encodedPubkey() { + return this._encodedPubkey; + } + get formattedCosmosAddress() { + return this._formattedCosmosAddress; + } + get registryPublicKey() { + return this._registryPublicKey; + } + get registryAddress() { + return this._registryAddress; + } + init() { + // Generate public key. + this._publicKey = secp256k1_1.default.publicKeyCreate(this._privateKey); + this._encodedPubkey = (0, amino_1.encodeSecp256k1Pubkey)(this._publicKey).value; + // 2. Generate eth address. + this._ethAddress = ethers_1.utils.computeAddress(this._publicKey); + // 3. Generate cosmos-sdk formatted address. + this._formattedCosmosAddress = (0, address_converter_1.ethToEthermint)(this._ethAddress); + // 4. Generate registry formatted public key. + const publicKeyInHex = AMINO_PREFIX + (0, encoding_1.toHex)(this._publicKey); + this._registryPublicKey = Buffer.from(publicKeyInHex, 'hex').toString('base64'); + // 5. Generate registry formatted address. + let publicKeySha256 = (0, js_sha256_1.sha256)(Buffer.from(publicKeyInHex, 'hex')); + this._registryAddress = new crypto_1.Ripemd160().update((0, encoding_1.fromHex)(publicKeySha256)).digest().toString(); + } + /** + * Get private key. + */ + getPrivateKey() { + return this._privateKey.toString('hex'); + } + /** + * Get cosmos address. + */ + getCosmosAddress() { + return this._formattedCosmosAddress; + } + /** + * Get record signature. + */ + signRecord(record) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(record); + const recordAsJson = (0, canonical_json_1.default)(record); + // Double sha256. + const recordBytesToSign = Buffer.from((0, js_sha256_1.sha256)(Buffer.from((0, js_sha256_1.sha256)(Buffer.from(recordAsJson)), 'hex')), 'hex'); + // Sign message + (0, assert_1.default)(recordBytesToSign); + const messageToSignSha256 = (0, js_sha256_1.sha256)(recordBytesToSign); + const messageToSignSha256InBytes = Buffer.from(messageToSignSha256, 'hex'); + const sigObj = secp256k1_1.default.ecdsaSign(messageToSignSha256InBytes, this.privateKey); + return Buffer.from(sigObj.signature); + }); + } + signPayload(payload) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(payload); + const { record } = payload; + const messageToSign = record.getMessageToSign(); + const sig = yield this.signRecord(messageToSign); + (0, assert_1.default)(this.registryPublicKey); + const signature = new types_1.Signature(this.registryPublicKey, sig.toString('base64')); + payload.addSignature(signature); + return signature; + }); + } + /** + * Sign message. + */ + sign(message) { + (0, assert_1.default)(message); + const eipMessageDomain = message.eipToSign.domain; + const signature = (0, eth_sig_util_1.signTypedData)({ + data: { + types: message.eipToSign.types, + primaryType: message.eipToSign.primaryType, + domain: eipMessageDomain, + message: message.eipToSign.message + }, + privateKey: this._privateKey, + version: eth_sig_util_1.SignTypedDataVersion.V4 + }); + return signature; + } +} +exports.Account = Account; diff --git a/dist/index.d.ts b/dist/index.d.ts new file mode 100644 index 0000000..0b53de9 --- /dev/null +++ b/dist/index.d.ts @@ -0,0 +1,183 @@ +import { Chain, Sender, Fee, MessageSendParams } from '@tharsis/transactions'; +import { RegistryClient } from "./registry-client"; +import { Account } from "./account"; +import { MessageMsgAssociateBond, MessageMsgCancelBond, MessageMsgCreateBond, MessageMsgDissociateBond, MessageMsgDissociateRecords, MessageMsgReAssociateRecords, MessageMsgRefillBond, MessageMsgWithdrawBond } from "./messages/bond"; +import { MessageMsgDeleteName, MessageMsgSetAuthorityBond, MessageMsgSetName, MessageMsgSetRecord } from './messages/nameservice'; +import { MessageMsgCommitBid, MessageMsgRevealBid } from './messages/auction'; +export declare const parseTxResponse: (result: any, parseResponse?: ((data: string) => any) | undefined) => any; +/** + * Create an auction bid. + */ +export declare const createBid: (chainId: string, auctionId: string, bidderAddress: string, bidAmount: string, noise?: string | undefined) => Promise<{ + commitHash: string; + reveal: { + chainId: string; + auctionId: string; + bidderAddress: string; + bidAmount: string; + noise: string; + }; + revealString: string; +}>; +export declare const isKeyValid: (key: string) => "" | RegExpMatchArray | null; +export declare class Registry { + _endpoints: { + [key: string]: string; + }; + _chainID: string; + _chain: Chain; + _client: RegistryClient; + static processWriteError(error: string): string; + constructor(restUrl: string, gqlUrl: string, chainId: string); + /** + * Get accounts by addresses. + */ + getAccounts(addresses: string[]): Promise; + get endpoints(): { + [key: string]: string; + }; + get chainID(): string; + /** + * Get server status. + */ + getStatus(): Promise; + /** + * Get records by ids. + */ + getRecordsByIds(ids: string[], refs?: boolean): Promise; + /** + * Get records by attributes. + */ + queryRecords(attributes: { + [key: string]: any; + }, all?: boolean, refs?: boolean): Promise; + /** + * Resolve names to records. + */ + resolveNames(names: string[], refs?: boolean): Promise; + /** + * Publish record. + * @param transactionPrivateKey - private key in HEX to sign transaction. + */ + setRecord(params: { + privateKey: string; + record: any; + bondId: string; + }, transactionPrivateKey: string, fee: Fee): Promise; + /** + * Send coins. + */ + sendCoins(params: MessageSendParams, privateKey: string, fee: Fee): Promise; + /** + * Computes the next bondId for the given account private key. + */ + getNextBondId(privateKey: string): Promise; + /** + * Get bonds by ids. + */ + getBondsByIds(ids: string[]): Promise; + /** + * Query bonds by attributes. + */ + queryBonds(attributes?: {}): Promise; + /** + * Create bond. + */ + createBond(params: MessageMsgCreateBond, privateKey: string, fee: Fee): Promise; + /** + * Refill bond. + */ + refillBond(params: MessageMsgRefillBond, privateKey: string, fee: Fee): Promise; + /** + * Withdraw (from) bond. + */ + withdrawBond(params: MessageMsgWithdrawBond, privateKey: string, fee: Fee): Promise; + /** + * Cancel bond. + */ + cancelBond(params: MessageMsgCancelBond, privateKey: string, fee: Fee): Promise; + /** + * Associate record with bond. + */ + associateBond(params: MessageMsgAssociateBond, privateKey: string, fee: Fee): Promise; + /** + * Dissociate record from bond. + */ + dissociateBond(params: MessageMsgDissociateBond, privateKey: string, fee: Fee): Promise; + /** + * Dissociate all records from bond. + */ + dissociateRecords(params: MessageMsgDissociateRecords, privateKey: string, fee: Fee): Promise; + /** + * Reassociate records (switch bond). + */ + reassociateRecords(params: MessageMsgReAssociateRecords, privateKey: string, fee: Fee): Promise; + /** + * Reserve authority. + */ + reserveAuthority(params: { + name: string; + owner?: string; + }, privateKey: string, fee: Fee): Promise; + /** + * Set authority bond. + */ + setAuthorityBond(params: MessageMsgSetAuthorityBond, privateKey: string, fee: Fee): Promise; + /** + * Commit auction bid. + */ + commitBid(params: MessageMsgCommitBid, privateKey: string, fee: Fee): Promise; + /** + * Reveal auction bid. + */ + revealBid(params: MessageMsgRevealBid, privateKey: string, fee: Fee): Promise; + /** + * Get records by ids. + */ + getAuctionsByIds(ids: string[]): Promise; + /** + * Lookup authorities by names. + */ + lookupAuthorities(names: string[], auction?: boolean): Promise; + /** + * Set name (CRN) to record ID (CID). + */ + setName(params: MessageMsgSetName, privateKey: string, fee: Fee): Promise; + /** + * Lookup naming information. + */ + lookupNames(names: string[], history?: boolean): Promise; + /** + * Delete name (CRN) mapping. + */ + deleteName(params: MessageMsgDeleteName, privateKey: string, fee: Fee): Promise; + /** + * Submit record transaction. + * @param privateKey - private key in HEX to sign message. + * @param txPrivateKey - private key in HEX to sign transaction. + */ + _submitRecordTx({ privateKey, record, bondId }: { + privateKey: string; + record: any; + bondId: string; + }, txPrivateKey: string, fee: Fee): Promise; + _submitRecordPayloadTx(params: MessageMsgSetRecord, privateKey: string, fee: Fee): Promise; + /** + * Submit a generic Tx to the chain. + */ + _submitTx(message: any, privateKey: string, sender: Sender): Promise; + /** + * https://evmos.dev/basics/chain_id.html + */ + _parseEthChainId(chainId: string): number; + /** + * Get sender used for creating message. + */ + _getSender(account: Account): Promise<{ + accountAddress: string; + sequence: any; + accountNumber: any; + pubkey: string; + }>; +} +export { Account }; diff --git a/dist/index.js b/dist/index.js new file mode 100644 index 0000000..f6e112a --- /dev/null +++ b/dist/index.js @@ -0,0 +1,510 @@ +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Account = exports.Registry = exports.isKeyValid = exports.createBid = exports.parseTxResponse = void 0; +const is_url_1 = __importDefault(require("is-url")); +const js_sha256_1 = require("js-sha256"); +const provider_1 = require("@tharsis/provider"); +const transactions_1 = require("@tharsis/transactions"); +const registry_client_1 = require("./registry-client"); +const account_1 = require("./account"); +Object.defineProperty(exports, "Account", { enumerable: true, get: function () { return account_1.Account; } }); +const txbuilder_1 = require("./txbuilder"); +const types_1 = require("./types"); +const util_1 = require("./util"); +const bond_1 = require("./messages/bond"); +const nameservice_1 = require("./messages/nameservice"); +const auction_1 = require("./messages/auction"); +const DEFAULT_WRITE_ERROR = 'Unable to write to laconicd.'; +// Parse Tx response from cosmos-sdk. +const parseTxResponse = (result, parseResponse) => { + const { txhash: hash, height } = result, txResponse = __rest(result, ["txhash", "height"]); + if (parseResponse) { + txResponse.data = parseResponse(txResponse.data); + } + txResponse.events.forEach((event) => { + event.attributes = event.attributes.map(({ key, value }) => ({ + key: Buffer.from(key, 'base64').toString('utf8'), + value: Buffer.from(value, 'base64').toString('utf8') + })); + }); + return Object.assign({ hash, height }, txResponse); +}; +exports.parseTxResponse = parseTxResponse; +/** + * Create an auction bid. + */ +const createBid = (chainId, auctionId, bidderAddress, bidAmount, noise) => __awaiter(void 0, void 0, void 0, function* () { + if (!noise) { + noise = account_1.Account.generateMnemonic(); + } + const reveal = { + chainId, + auctionId, + bidderAddress, + bidAmount, + noise + }; + const commitHash = yield util_1.Util.getContentId(reveal); + const revealString = Buffer.from(JSON.stringify(reveal)).toString('hex'); + return { + commitHash, + reveal, + revealString + }; +}); +exports.createBid = createBid; +const isKeyValid = (key) => key && key.match(/^[0-9a-fA-F]{64}$/); +exports.isKeyValid = isKeyValid; +class Registry { + constructor(restUrl, gqlUrl, chainId) { + if (!(0, is_url_1.default)(restUrl)) { + throw new Error('Path to a REST endpoint should be provided.'); + } + if (!(0, is_url_1.default)(gqlUrl)) { + throw new Error('Path to a GQL endpoint should be provided.'); + } + this._endpoints = { + rest: restUrl, + gql: gqlUrl + }; + this._client = new registry_client_1.RegistryClient(restUrl, gqlUrl); + this._chainID = chainId; + this._chain = { + cosmosChainId: chainId, + chainId: this._parseEthChainId(chainId) + }; + } + static processWriteError(error) { + // error string a stacktrace containing the message. + // https://gist.github.com/nikugogoi/de55d390574ded3466abad8bffd81952#file-txresponse-js-L7 + const errorMessage = nameservice_1.NAMESERVICE_ERRORS.find(message => error.includes(message)); + if (!errorMessage) { + console.error(error); + } + return errorMessage || DEFAULT_WRITE_ERROR; + } + /** + * Get accounts by addresses. + */ + getAccounts(addresses) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.getAccounts(addresses); + }); + } + get endpoints() { + return this._endpoints; + } + get chainID() { + return this._chainID; + } + /** + * Get server status. + */ + getStatus() { + return __awaiter(this, void 0, void 0, function* () { + return this._client.getStatus(); + }); + } + /** + * Get records by ids. + */ + getRecordsByIds(ids, refs = false) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.getRecordsByIds(ids, refs); + }); + } + /** + * Get records by attributes. + */ + queryRecords(attributes, all = false, refs = false) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.queryRecords(attributes, all, refs); + }); + } + /** + * Resolve names to records. + */ + resolveNames(names, refs = false) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.resolveNames(names, refs); + }); + } + /** + * Publish record. + * @param transactionPrivateKey - private key in HEX to sign transaction. + */ + setRecord(params, transactionPrivateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + result = yield this._submitRecordTx(params, transactionPrivateKey, fee); + return (0, exports.parseTxResponse)(result, nameservice_1.parseMsgSetRecordResponse); + }); + } + /** + * Send coins. + */ + sendCoins(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, transactions_1.createMessageSend)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Computes the next bondId for the given account private key. + */ + getNextBondId(privateKey) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const accounts = yield this.getAccounts([account.formattedCosmosAddress]); + if (!accounts.length) { + throw new Error('Account does not exist.'); + } + const [accountObj] = accounts; + const nextSeq = parseInt(accountObj.sequence, 10) + 1; + result = (0, js_sha256_1.sha256)(`${accountObj.address}:${accountObj.number}:${nextSeq}`); + return result; + }); + } + /** + * Get bonds by ids. + */ + getBondsByIds(ids) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.getBondsByIds(ids); + }); + } + /** + * Query bonds by attributes. + */ + queryBonds(attributes = {}) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.queryBonds(attributes); + }); + } + /** + * Create bond. + */ + createBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgCreateBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Refill bond. + */ + refillBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgRefillBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Withdraw (from) bond. + */ + withdrawBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgWithdrawBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Cancel bond. + */ + cancelBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgCancelBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Associate record with bond. + */ + associateBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgAssociateBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Dissociate record from bond. + */ + dissociateBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgDissociateBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Dissociate all records from bond. + */ + dissociateRecords(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgDissociateRecords)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Reassociate records (switch bond). + */ + reassociateRecords(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, bond_1.createTxMsgReAssociateRecords)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Reserve authority. + */ + reserveAuthority(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msgParams = { + name: params.name, + owner: params.owner || sender.accountAddress + }; + const msg = (0, nameservice_1.createTxMsgReserveAuthority)(this._chain, sender, fee, '', msgParams); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Set authority bond. + */ + setAuthorityBond(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, nameservice_1.createTxMsgSetAuthorityBond)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Commit auction bid. + */ + commitBid(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, auction_1.createTxMsgCommitBid)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Reveal auction bid. + */ + revealBid(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, auction_1.createTxMsgRevealBid)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Get records by ids. + */ + getAuctionsByIds(ids) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.getAuctionsByIds(ids); + }); + } + /** + * Lookup authorities by names. + */ + lookupAuthorities(names, auction = false) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.lookupAuthorities(names, auction); + }); + } + /** + * Set name (CRN) to record ID (CID). + */ + setName(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, nameservice_1.createTxMsgSetName)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Lookup naming information. + */ + lookupNames(names, history = false) { + return __awaiter(this, void 0, void 0, function* () { + return this._client.lookupNames(names, history); + }); + } + /** + * Delete name (CRN) mapping. + */ + deleteName(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + let result; + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, nameservice_1.createTxMsgDeleteName)(this._chain, sender, fee, '', params); + result = yield this._submitTx(msg, privateKey, sender); + return (0, exports.parseTxResponse)(result); + }); + } + /** + * Submit record transaction. + * @param privateKey - private key in HEX to sign message. + * @param txPrivateKey - private key in HEX to sign transaction. + */ + _submitRecordTx({ privateKey, record, bondId }, txPrivateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + if (!(0, exports.isKeyValid)(privateKey)) { + throw new Error('Registry privateKey should be a hex string.'); + } + if (!(0, exports.isKeyValid)(bondId)) { + throw new Error(`Invalid bondId: ${bondId}.`); + } + // Sign record. + const recordSignerAccount = new account_1.Account(Buffer.from(privateKey, 'hex')); + const registryRecord = new types_1.Record(record); + const payload = new types_1.Payload(registryRecord); + yield recordSignerAccount.signPayload(payload); + // Send record payload Tx. + txPrivateKey = txPrivateKey || recordSignerAccount.getPrivateKey(); + return this._submitRecordPayloadTx({ payload, bondId }, txPrivateKey, fee); + }); + } + _submitRecordPayloadTx(params, privateKey, fee) { + return __awaiter(this, void 0, void 0, function* () { + if (!(0, exports.isKeyValid)(privateKey)) { + throw new Error('Registry privateKey should be a hex string.'); + } + if (!(0, exports.isKeyValid)(params.bondId)) { + throw new Error(`Invalid bondId: ${params.bondId}.`); + } + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + const sender = yield this._getSender(account); + const msg = (0, nameservice_1.createTxMsgSetRecord)(this._chain, sender, fee, '', params); + return this._submitTx(msg, privateKey, sender); + }); + } + /** + * Submit a generic Tx to the chain. + */ + _submitTx(message, privateKey, sender) { + return __awaiter(this, void 0, void 0, function* () { + // Check private key. + if (!(0, exports.isKeyValid)(privateKey)) { + throw new Error('Registry privateKey should be a hex string.'); + } + // Check that the account exists on-chain. + const account = new account_1.Account(Buffer.from(privateKey, 'hex')); + // Generate signed Tx. + const transaction = (0, txbuilder_1.createTransaction)(message, account, sender, this._chain); + const tx = (0, provider_1.generatePostBodyBroadcast)(transaction, provider_1.BroadcastMode.Block); + // Submit Tx to chain. + const { tx_response: response } = yield this._client.submit(tx); + if (response.code !== 0) { + // Throw error when transaction is not successful. + // https://docs.starport.com/guide/nameservice/05-play.html#buy-name-transaction-details + throw new Error(Registry.processWriteError(response.raw_log)); + } + return response; + }); + } + /** + * https://evmos.dev/basics/chain_id.html + */ + _parseEthChainId(chainId) { + const [idWithChainNumber] = chainId.split('-'); + const [_, ethChainId] = idWithChainNumber.split('_'); + return Number(ethChainId); + } + /** + * Get sender used for creating message. + */ + _getSender(account) { + return __awaiter(this, void 0, void 0, function* () { + const accounts = yield this.getAccounts([account.formattedCosmosAddress]); + if (!accounts.length) { + throw new Error('Account does not exist.'); + } + const [{ number, sequence }] = accounts; + return { + accountAddress: account.formattedCosmosAddress, + sequence: sequence, + accountNumber: number, + pubkey: account.encodedPubkey, + }; + }); + } +} +exports.Registry = Registry; diff --git a/dist/messages/auction.d.ts b/dist/messages/auction.d.ts new file mode 100644 index 0000000..932f66a --- /dev/null +++ b/dist/messages/auction.d.ts @@ -0,0 +1,57 @@ +import { Chain, Sender, Fee } from '@tharsis/transactions'; +export interface MessageMsgCommitBid { + auctionId: string; + commitHash: string; +} +export interface MessageMsgRevealBid { + auctionId: string; + reveal: string; +} +export declare function createTxMsgCommitBid(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgCommitBid): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgRevealBid(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgRevealBid): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; diff --git a/dist/messages/auction.js b/dist/messages/auction.js new file mode 100644 index 0000000..f94b196 --- /dev/null +++ b/dist/messages/auction.js @@ -0,0 +1,99 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createTxMsgRevealBid = exports.createTxMsgCommitBid = void 0; +const eip712_1 = require("@tharsis/eip712"); +const auctionTx = __importStar(require("../proto/vulcanize/auction/v1beta1/tx")); +const util_1 = require("./util"); +const MSG_COMMIT_BID_TYPES = { + MsgValue: [ + { name: 'auction_id', type: 'string' }, + { name: 'commit_hash', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +const MSG_REVEAL_BID_TYPES = { + MsgValue: [ + { name: 'auction_id', type: 'string' }, + { name: 'reveal', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +function createTxMsgCommitBid(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_COMMIT_BID_TYPES); + const msg = createMsgCommitBid(params.auctionId, params.commitHash, sender.accountAddress); + const msgCosmos = protoCreateMsgCommitBid(params.auctionId, params.commitHash, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgCommitBid = createTxMsgCommitBid; +function createTxMsgRevealBid(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_REVEAL_BID_TYPES); + const msg = createMsgRevealBid(params.auctionId, params.reveal, sender.accountAddress); + const msgCosmos = protoCreateMsgRevealBid(params.auctionId, params.reveal, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgRevealBid = createTxMsgRevealBid; +function createMsgCommitBid(auctionId, commitHash, signer) { + return { + type: 'auction/MsgCommitBid', + value: { + auction_id: auctionId, + commit_hash: commitHash, + signer, + }, + }; +} +const protoCreateMsgCommitBid = (auctionId, commitHash, signer) => { + const commitBidMessage = new auctionTx.vulcanize.auction.v1beta1.MsgCommitBid({ + auction_id: auctionId, + commit_hash: commitHash, + signer, + }); + return { + message: commitBidMessage, + path: 'vulcanize.auction.v1beta1.MsgCommitBid', + }; +}; +function createMsgRevealBid(auctionId, reveal, signer) { + return { + type: 'auction/MsgRevealBid', + value: { + auction_id: auctionId, + reveal, + signer, + }, + }; +} +const protoCreateMsgRevealBid = (auctionId, reveal, signer) => { + const revealBidMessage = new auctionTx.vulcanize.auction.v1beta1.MsgRevealBid({ + auction_id: auctionId, + reveal, + signer, + }); + return { + message: revealBidMessage, + path: 'vulcanize.auction.v1beta1.MsgRevealBid', + }; +}; diff --git a/dist/messages/bond.d.ts b/dist/messages/bond.d.ts new file mode 100644 index 0000000..2ea8390 --- /dev/null +++ b/dist/messages/bond.d.ts @@ -0,0 +1,224 @@ +import { Chain, Sender, Fee } from '@tharsis/transactions'; +export interface MessageMsgCreateBond { + amount: string; + denom: string; +} +export interface MessageMsgRefillBond { + id: string; + amount: string; + denom: string; +} +export interface MessageMsgWithdrawBond { + id: string; + amount: string; + denom: string; +} +export interface MessageMsgCancelBond { + id: string; +} +export interface MessageMsgAssociateBond { + bondId: string; + recordId: string; +} +export interface MessageMsgDissociateBond { + recordId: string; +} +export interface MessageMsgDissociateRecords { + bondId: string; +} +export interface MessageMsgReAssociateRecords { + newBondId: string; + oldBondId: string; +} +export declare function createTxMsgCreateBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgCreateBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgRefillBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgRefillBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgWithdrawBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgWithdrawBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgCancelBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgCancelBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgAssociateBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgAssociateBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgDissociateBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgDissociateBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgDissociateRecords(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgDissociateRecords): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgReAssociateRecords(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgReAssociateRecords): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; diff --git a/dist/messages/bond.js b/dist/messages/bond.js new file mode 100644 index 0000000..21afd4e --- /dev/null +++ b/dist/messages/bond.js @@ -0,0 +1,338 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createTxMsgReAssociateRecords = exports.createTxMsgDissociateRecords = exports.createTxMsgDissociateBond = exports.createTxMsgAssociateBond = exports.createTxMsgCancelBond = exports.createTxMsgWithdrawBond = exports.createTxMsgRefillBond = exports.createTxMsgCreateBond = void 0; +const eip712_1 = require("@tharsis/eip712"); +const bondTx = __importStar(require("../proto/vulcanize/bond/v1beta1/tx")); +const nameserviceTx = __importStar(require("../proto/vulcanize/nameservice/v1beta1/tx")); +const coin = __importStar(require("../proto/cosmos/base/v1beta1/coin")); +const util_1 = require("./util"); +const MSG_CREATE_BOND_TYPES = { + MsgValue: [ + { name: 'signer', type: 'string' }, + { name: 'coins', type: 'TypeCoins[]' }, + ], + TypeCoins: [ + { name: 'denom', type: 'string' }, + { name: 'amount', type: 'string' }, + ], +}; +const MSG_REFILL_BOND_TYPES = { + MsgValue: [ + { name: 'id', type: 'string' }, + { name: 'signer', type: 'string' }, + { name: 'coins', type: 'TypeCoins[]' }, + ], + TypeCoins: [ + { name: 'denom', type: 'string' }, + { name: 'amount', type: 'string' }, + ], +}; +const MSG_WITHDRAW_BOND_TYPES = { + MsgValue: [ + { name: 'id', type: 'string' }, + { name: 'signer', type: 'string' }, + { name: 'coins', type: 'TypeCoins[]' }, + ], + TypeCoins: [ + { name: 'denom', type: 'string' }, + { name: 'amount', type: 'string' }, + ], +}; +const MSG_CANCEL_BOND_TYPES = { + MsgValue: [ + { name: 'id', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +const MSG_ASSOCIATE_BOND_TYPES = { + MsgValue: [ + { name: 'record_id', type: 'string' }, + { name: 'bond_id', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +const MSG_DISSOCIATE_BOND_TYPES = { + MsgValue: [ + { name: 'record_id', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +const MSG_DISSOCIATE_RECORDS_TYPES = { + MsgValue: [ + { name: 'bond_id', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +const MSG_REASSOCIATE_RECORDS_TYPES = { + MsgValue: [ + { name: 'new_bond_id', type: 'string' }, + { name: 'old_bond_id', type: 'string' }, + { name: 'signer', type: 'string' }, + ] +}; +function createTxMsgCreateBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_CREATE_BOND_TYPES); + const msg = createMsgCreateBond(sender.accountAddress, params.amount, params.denom); + const msgCosmos = protoCreateMsgCreateBond(sender.accountAddress, params.amount, params.denom); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgCreateBond = createTxMsgCreateBond; +function createTxMsgRefillBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_REFILL_BOND_TYPES); + const msg = createMsgRefillBond(params.id, sender.accountAddress, params.amount, params.denom); + const msgCosmos = protoCreateMsgRefillBond(params.id, sender.accountAddress, params.amount, params.denom); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgRefillBond = createTxMsgRefillBond; +function createTxMsgWithdrawBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_WITHDRAW_BOND_TYPES); + const msg = createMsgWithdrawBond(params.id, sender.accountAddress, params.amount, params.denom); + const msgCosmos = protoCreateMsgWithdrawBond(params.id, sender.accountAddress, params.amount, params.denom); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgWithdrawBond = createTxMsgWithdrawBond; +function createTxMsgCancelBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_CANCEL_BOND_TYPES); + const msg = createMsgCancelBond(params.id, sender.accountAddress); + const msgCosmos = protoCreateMsgCancelBond(params.id, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgCancelBond = createTxMsgCancelBond; +function createTxMsgAssociateBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_ASSOCIATE_BOND_TYPES); + const msg = createMsgAssociateBond(params.recordId, params.bondId, sender.accountAddress); + const msgCosmos = protoCreateMsgAssociateBond(params.recordId, params.bondId, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgAssociateBond = createTxMsgAssociateBond; +function createTxMsgDissociateBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_DISSOCIATE_BOND_TYPES); + const msg = createMsgDissociateBond(params.recordId, sender.accountAddress); + const msgCosmos = protoCreateMsgDissociateBond(params.recordId, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgDissociateBond = createTxMsgDissociateBond; +function createTxMsgDissociateRecords(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_DISSOCIATE_RECORDS_TYPES); + const msg = createMsgDissociateRecords(params.bondId, sender.accountAddress); + const msgCosmos = protoCreateMsgDissociateRecords(params.bondId, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgDissociateRecords = createTxMsgDissociateRecords; +function createTxMsgReAssociateRecords(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_REASSOCIATE_RECORDS_TYPES); + const msg = createMsgReAssociateRecords(params.newBondId, params.oldBondId, sender.accountAddress); + const msgCosmos = protoCreateMsgReAssociateRecords(params.newBondId, params.oldBondId, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgReAssociateRecords = createTxMsgReAssociateRecords; +function createMsgCreateBond(signer, amount, denom) { + return { + type: 'bond/MsgCreateBond', + value: { + coins: [ + { + amount, + denom, + }, + ], + signer + }, + }; +} +const protoCreateMsgCreateBond = (signer, amount, denom) => { + const value = new coin.cosmos.base.v1beta1.Coin({ + denom, + amount, + }); + const createBondMessage = new bondTx.vulcanize.bond.v1beta1.MsgCreateBond({ + signer, + coins: [value] + }); + return { + message: createBondMessage, + path: 'vulcanize.bond.v1beta1.MsgCreateBond', + }; +}; +function createMsgRefillBond(id, signer, amount, denom) { + return { + type: 'bond/MsgRefillBond', + value: { + coins: [ + { + amount, + denom, + }, + ], + id, + signer + }, + }; +} +const protoCreateMsgRefillBond = (id, signer, amount, denom) => { + const value = new coin.cosmos.base.v1beta1.Coin({ + denom, + amount, + }); + const refillBondMessage = new bondTx.vulcanize.bond.v1beta1.MsgRefillBond({ + id, + signer, + coins: [value] + }); + return { + message: refillBondMessage, + path: 'vulcanize.bond.v1beta1.MsgRefillBond', + }; +}; +function createMsgWithdrawBond(id, signer, amount, denom) { + return { + type: 'bond/MsgWithdrawBond', + value: { + id, + coins: [ + { + amount, + denom, + }, + ], + signer + }, + }; +} +const protoCreateMsgWithdrawBond = (id, signer, amount, denom) => { + const value = new coin.cosmos.base.v1beta1.Coin({ + denom, + amount, + }); + const withdrawBondMessage = new bondTx.vulcanize.bond.v1beta1.MsgWithdrawBond({ + id, + signer, + coins: [value] + }); + return { + message: withdrawBondMessage, + path: 'vulcanize.bond.v1beta1.MsgWithdrawBond', + }; +}; +function createMsgCancelBond(id, signer) { + return { + type: 'bond/MsgCancelBond', + value: { + id, + signer + }, + }; +} +const protoCreateMsgCancelBond = (id, signer) => { + const cancelBondMessage = new bondTx.vulcanize.bond.v1beta1.MsgCancelBond({ + id, + signer + }); + return { + message: cancelBondMessage, + path: 'vulcanize.bond.v1beta1.MsgCancelBond', + }; +}; +function createMsgAssociateBond(recordId, bondId, signer) { + return { + type: 'nameservice/AssociateBond', + value: { + record_id: recordId, + bond_id: bondId, + signer + }, + }; +} +const protoCreateMsgAssociateBond = (recordId, bondId, signer) => { + const associateBondMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgAssociateBond({ + record_id: recordId, + bond_id: bondId, + signer + }); + return { + message: associateBondMessage, + path: 'vulcanize.nameservice.v1beta1.MsgAssociateBond', + }; +}; +function createMsgDissociateBond(recordId, signer) { + return { + type: 'nameservice/DissociateBond', + value: { + record_id: recordId, + signer + }, + }; +} +const protoCreateMsgDissociateBond = (recordId, signer) => { + const dissociateBondMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgDissociateBond({ + record_id: recordId, + signer + }); + return { + message: dissociateBondMessage, + path: 'vulcanize.nameservice.v1beta1.MsgDissociateBond', + }; +}; +function createMsgDissociateRecords(bondId, signer) { + return { + type: 'nameservice/DissociateRecords', + value: { + bond_id: bondId, + signer + }, + }; +} +const protoCreateMsgDissociateRecords = (bondId, signer) => { + const dissociateRecordsMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgDissociateRecords({ + bond_id: bondId, + signer + }); + return { + message: dissociateRecordsMessage, + path: 'vulcanize.nameservice.v1beta1.MsgDissociateRecords', + }; +}; +function createMsgReAssociateRecords(newBondId, oldBondId, signer) { + return { + type: 'nameservice/ReassociateRecords', + value: { + new_bond_id: newBondId, + old_bond_id: oldBondId, + signer + }, + }; +} +const protoCreateMsgReAssociateRecords = (newBondId, oldBondId, signer) => { + const reAssociateRecordsMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgReAssociateRecords({ + new_bond_id: newBondId, + old_bond_id: oldBondId, + signer + }); + return { + message: reAssociateRecordsMessage, + path: 'vulcanize.nameservice.v1beta1.MsgReAssociateRecords', + }; +}; diff --git a/dist/messages/nameservice.d.ts b/dist/messages/nameservice.d.ts new file mode 100644 index 0000000..f73e50e --- /dev/null +++ b/dist/messages/nameservice.d.ts @@ -0,0 +1,145 @@ +import { Chain, Sender, Fee } from '@tharsis/transactions'; +import { Payload } from '../types'; +export declare const parseMsgSetRecordResponse: (data: string) => { + id: string; +}; +export declare const NAMESERVICE_ERRORS: string[]; +export interface MessageMsgReserveAuthority { + name: string; + owner: string; +} +export interface MessageMsgSetName { + crn: string; + cid: string; +} +export interface MessageMsgSetRecord { + bondId: string; + payload: Payload; +} +export interface MessageMsgSetAuthorityBond { + name: string; + bondId: string; +} +export interface MessageMsgDeleteName { + crn: string; +} +export declare function createTxMsgReserveAuthority(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgReserveAuthority): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgSetName(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgSetName): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgSetRecord(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgSetRecord): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgSetAuthorityBond(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgSetAuthorityBond): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export declare function createTxMsgDeleteName(chain: Chain, sender: Sender, fee: Fee, memo: string, params: MessageMsgDeleteName): { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; diff --git a/dist/messages/nameservice.js b/dist/messages/nameservice.js new file mode 100644 index 0000000..c2979f3 --- /dev/null +++ b/dist/messages/nameservice.js @@ -0,0 +1,240 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createTxMsgDeleteName = exports.createTxMsgSetAuthorityBond = exports.createTxMsgSetRecord = exports.createTxMsgSetName = exports.createTxMsgReserveAuthority = exports.NAMESERVICE_ERRORS = exports.parseMsgSetRecordResponse = void 0; +const eip712_1 = require("@tharsis/eip712"); +const nameserviceTx = __importStar(require("../proto/vulcanize/nameservice/v1beta1/tx")); +const nameservice = __importStar(require("../proto/vulcanize/nameservice/v1beta1/nameservice")); +const util_1 = require("./util"); +const MSG_RESERVE_AUTHORITY_TYPES = { + MsgValue: [ + { name: 'name', type: 'string' }, + { name: 'signer', type: 'string' }, + { name: 'owner', type: 'string' }, + ], +}; +const MSG_SET_NAME_TYPES = { + MsgValue: [ + { name: 'crn', type: 'string' }, + { name: 'cid', type: 'string' }, + { name: 'signer', type: 'string' }, + ], +}; +const MSG_SET_RECORD_TYPES = { + MsgValue: [ + { name: 'bond_id', type: 'string' }, + { name: 'signer', type: 'string' }, + { name: 'payload', type: 'TypePayload' }, + ], + TypePayload: [ + { name: 'record', type: 'TypePayloadRecord' }, + { name: 'signatures', type: 'TypePayloadSignatures[]' }, + ], + TypePayloadRecord: [ + { name: 'id', type: 'string' }, + { name: 'bond_id', type: 'string' }, + { name: 'create_time', type: 'string' }, + { name: 'expiry_time', type: 'string' }, + { name: 'deleted', type: 'bool' }, + { name: 'attributes', type: 'string' }, + ], + TypePayloadSignatures: [ + { name: 'sig', type: 'string' }, + { name: 'pub_key', type: 'string' } + ], +}; +const MSG_SET_AUTHORITY_BOND_TYPES = { + MsgValue: [ + { name: 'name', type: 'string' }, + { name: 'bond_id', type: 'string' }, + { name: 'signer', type: 'string' }, + ], +}; +const MSG_DELETE_NAME_TYPES = { + MsgValue: [ + { name: 'crn', type: 'string' }, + { name: 'signer', type: 'string' }, + ], +}; +const parseMsgSetRecordResponse = (data) => { + const responseBytes = Buffer.from(data, 'hex'); + // TODO: Decode response using protobuf. + // const msgSetRecordResponse = nameserviceTx.vulcanize.nameservice.v1beta1.MsgSetRecordResponse.deserialize(responseBytes); + // return msgSetRecordResponse.toObject(); + // Workaround as proto based decoding is not working. + const [_, id] = responseBytes.toString().split(';'); + return { id }; +}; +exports.parseMsgSetRecordResponse = parseMsgSetRecordResponse; +exports.NAMESERVICE_ERRORS = [ + 'Name already reserved.', + 'Authority bond not found.', + 'Name authority not found.', + 'Access denied.', +]; +function createTxMsgReserveAuthority(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_RESERVE_AUTHORITY_TYPES); + const msg = createMsgReserveAuthority(params.name, sender.accountAddress, params.owner); + const msgCosmos = protoCreateMsgReserveAuthority(params.name, sender.accountAddress, params.owner); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgReserveAuthority = createTxMsgReserveAuthority; +function createTxMsgSetName(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_SET_NAME_TYPES); + const msg = createMsgSetName(params.crn, params.cid, sender.accountAddress); + const msgCosmos = protoCreateMsgSetName(params.crn, params.cid, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgSetName = createTxMsgSetName; +function createTxMsgSetRecord(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_SET_RECORD_TYPES); + const msg = createMsgSetRecord(params.bondId, params.payload, sender.accountAddress); + const msgCosmos = protoCreateMsgSetRecord(params.bondId, params.payload, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgSetRecord = createTxMsgSetRecord; +function createTxMsgSetAuthorityBond(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_SET_AUTHORITY_BOND_TYPES); + const msg = createMsgSetAuthorityBond(params.name, params.bondId, sender.accountAddress); + const msgCosmos = protoCreateMsgSetAuthorityBond(params.name, params.bondId, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgSetAuthorityBond = createTxMsgSetAuthorityBond; +function createTxMsgDeleteName(chain, sender, fee, memo, params) { + const types = (0, eip712_1.generateTypes)(MSG_DELETE_NAME_TYPES); + const msg = createMsgDeleteName(params.crn, sender.accountAddress); + const msgCosmos = protoCreateMsgDeleteName(params.crn, sender.accountAddress); + return (0, util_1.createTx)(chain, sender, fee, memo, types, msg, msgCosmos); +} +exports.createTxMsgDeleteName = createTxMsgDeleteName; +function createMsgReserveAuthority(name, signer, owner) { + return { + type: 'nameservice/ReserveAuthority', + value: { + name, + signer, + owner + }, + }; +} +const protoCreateMsgReserveAuthority = (name, signer, owner) => { + const reserveAuthorityMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgReserveAuthority({ + name, + signer, + owner + }); + return { + message: reserveAuthorityMessage, + path: 'vulcanize.nameservice.v1beta1.MsgReserveAuthority', + }; +}; +function createMsgSetName(crn, cid, signer) { + return { + type: 'nameservice/SetName', + value: { + crn, + cid, + signer + }, + }; +} +const protoCreateMsgSetName = (crn, cid, signer) => { + const setNameMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgSetName({ + crn, + cid, + signer, + }); + return { + message: setNameMessage, + path: 'vulcanize.nameservice.v1beta1.MsgSetName', + }; +}; +function createMsgSetRecord(bondId, payload, signer) { + return { + type: 'nameservice/SetRecord', + value: { + bond_id: bondId, + signer, + payload: payload.serialize() + }, + }; +} +const protoCreateMsgSetRecord = (bondId, payloadData, signer) => { + const record = new nameservice.vulcanize.nameservice.v1beta1.Record(payloadData.record.serialize()); + const signatures = payloadData.signatures.map(signature => new nameservice.vulcanize.nameservice.v1beta1.Signature(signature.serialize())); + const payload = new nameserviceTx.vulcanize.nameservice.v1beta1.Payload({ + record, + signatures + }); + const setNameMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgSetRecord({ + bond_id: bondId, + signer, + payload + }); + return { + message: setNameMessage, + path: 'vulcanize.nameservice.v1beta1.MsgSetRecord', + }; +}; +function createMsgSetAuthorityBond(name, bondId, signer) { + return { + type: 'nameservice/SetAuthorityBond', + value: { + name, + bond_id: bondId, + signer + }, + }; +} +const protoCreateMsgSetAuthorityBond = (name, bondId, signer) => { + const setAuthorityBondMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgSetAuthorityBond({ + name, + bond_id: bondId, + signer, + }); + return { + message: setAuthorityBondMessage, + path: 'vulcanize.nameservice.v1beta1.MsgSetAuthorityBond', + }; +}; +function createMsgDeleteName(crn, signer) { + return { + type: 'nameservice/DeleteAuthority', + value: { + crn, + signer + }, + }; +} +const protoCreateMsgDeleteName = (crn, signer) => { + const deleteNameAutorityMessage = new nameserviceTx.vulcanize.nameservice.v1beta1.MsgDeleteNameAuthority({ + crn, + signer, + }); + return { + message: deleteNameAutorityMessage, + path: 'vulcanize.nameservice.v1beta1.MsgDeleteNameAuthority', + }; +}; diff --git a/dist/messages/util.d.ts b/dist/messages/util.d.ts new file mode 100644 index 0000000..08ecb15 --- /dev/null +++ b/dist/messages/util.d.ts @@ -0,0 +1,41 @@ +import { Message } from "google-protobuf"; +import { Chain, Sender, Fee } from '@tharsis/transactions'; +interface Msg { + type: string; + value: any; +} +interface MsgCosmos { + message: Message; + path: string; +} +interface Types { + [key: string]: Array<{ + name: string; + type: string; + }>; +} +export declare const createTx: (chain: Chain, sender: Sender, fee: Fee, memo: string, messageTypes: Types, msg: Msg, msgCosmos: MsgCosmos) => { + signDirect: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + legacyAmino: { + body: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxBody; + authInfo: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.AuthInfo; + signBytes: string; + }; + eipToSign: { + types: object; + primaryType: string; + domain: { + name: string; + version: string; + chainId: number; + verifyingContract: string; + salt: string; + }; + message: object; + }; +}; +export {}; diff --git a/dist/messages/util.js b/dist/messages/util.js new file mode 100644 index 0000000..6bd1da2 --- /dev/null +++ b/dist/messages/util.js @@ -0,0 +1,20 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createTx = void 0; +const eip712_1 = require("@tharsis/eip712"); +const proto_1 = require("@tharsis/proto"); +const createTx = (chain, sender, fee, memo, messageTypes, msg, msgCosmos) => { + // EIP712 + const feeObject = (0, eip712_1.generateFee)(fee.amount, fee.denom, fee.gas, sender.accountAddress); + const types = (0, eip712_1.generateTypes)(messageTypes); + const messages = (0, eip712_1.generateMessage)(sender.accountNumber.toString(), sender.sequence.toString(), chain.cosmosChainId, memo, feeObject, msg); + const eipToSign = (0, eip712_1.createEIP712)(types, chain.chainId, messages); + // Cosmos + const tx = (0, proto_1.createTransaction)(msgCosmos, memo, fee.amount, fee.denom, parseInt(fee.gas, 10), 'ethsecp256', sender.pubkey, sender.sequence, sender.accountNumber, chain.cosmosChainId); + return { + signDirect: tx.signDirect, + legacyAmino: tx.legacyAmino, + eipToSign, + }; +}; +exports.createTx = createTx; diff --git a/dist/proto/cosmos/base/query/v1beta1/pagination.d.ts b/dist/proto/cosmos/base/query/v1beta1/pagination.d.ts new file mode 100644 index 0000000..1c268d3 --- /dev/null +++ b/dist/proto/cosmos/base/query/v1beta1/pagination.d.ts @@ -0,0 +1,69 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: cosmos/base/query/v1beta1/pagination.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as pb_1 from "google-protobuf"; +export declare namespace cosmos.base.query.v1beta1 { + class PageRequest extends pb_1.Message { + constructor(data?: any[] | { + key?: Uint8Array; + offset?: number; + limit?: number; + count_total?: boolean; + reverse?: boolean; + }); + get key(): Uint8Array; + set key(value: Uint8Array); + get offset(): number; + set offset(value: number); + get limit(): number; + set limit(value: number); + get count_total(): boolean; + set count_total(value: boolean); + get reverse(): boolean; + set reverse(value: boolean); + static fromObject(data: { + key?: Uint8Array; + offset?: number; + limit?: number; + count_total?: boolean; + reverse?: boolean; + }): PageRequest; + toObject(): { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): PageRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): PageRequest; + } + class PageResponse extends pb_1.Message { + constructor(data?: any[] | { + next_key?: Uint8Array; + total?: number; + }); + get next_key(): Uint8Array; + set next_key(value: Uint8Array); + get total(): number; + set total(value: number); + static fromObject(data: { + next_key?: Uint8Array; + total?: number; + }): PageResponse; + toObject(): { + next_key?: Uint8Array | undefined; + total?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): PageResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): PageResponse; + } +} diff --git a/dist/proto/cosmos/base/query/v1beta1/pagination.js b/dist/proto/cosmos/base/query/v1beta1/pagination.js new file mode 100644 index 0000000..473bc65 --- /dev/null +++ b/dist/proto/cosmos/base/query/v1beta1/pagination.js @@ -0,0 +1,264 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cosmos = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: cosmos/base/query/v1beta1/pagination.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const pb_1 = __importStar(require("google-protobuf")); +var cosmos; +(function (cosmos) { + var base; + (function (base) { + var query; + (function (query) { + var v1beta1; + (function (v1beta1) { + class PageRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("key" in data && data.key != undefined) { + this.key = data.key; + } + if ("offset" in data && data.offset != undefined) { + this.offset = data.offset; + } + if ("limit" in data && data.limit != undefined) { + this.limit = data.limit; + } + if ("count_total" in data && data.count_total != undefined) { + this.count_total = data.count_total; + } + if ("reverse" in data && data.reverse != undefined) { + this.reverse = data.reverse; + } + } + } + get key() { + return pb_1.Message.getField(this, 1); + } + set key(value) { + pb_1.Message.setField(this, 1, value); + } + get offset() { + return pb_1.Message.getField(this, 2); + } + set offset(value) { + pb_1.Message.setField(this, 2, value); + } + get limit() { + return pb_1.Message.getField(this, 3); + } + set limit(value) { + pb_1.Message.setField(this, 3, value); + } + get count_total() { + return pb_1.Message.getField(this, 4); + } + set count_total(value) { + pb_1.Message.setField(this, 4, value); + } + get reverse() { + return pb_1.Message.getField(this, 5); + } + set reverse(value) { + pb_1.Message.setField(this, 5, value); + } + static fromObject(data) { + const message = new PageRequest({}); + if (data.key != null) { + message.key = data.key; + } + if (data.offset != null) { + message.offset = data.offset; + } + if (data.limit != null) { + message.limit = data.limit; + } + if (data.count_total != null) { + message.count_total = data.count_total; + } + if (data.reverse != null) { + message.reverse = data.reverse; + } + return message; + } + toObject() { + const data = {}; + if (this.key != null) { + data.key = this.key; + } + if (this.offset != null) { + data.offset = this.offset; + } + if (this.limit != null) { + data.limit = this.limit; + } + if (this.count_total != null) { + data.count_total = this.count_total; + } + if (this.reverse != null) { + data.reverse = this.reverse; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.key !== undefined) + writer.writeBytes(1, this.key); + if (this.offset !== undefined) + writer.writeUint64(2, this.offset); + if (this.limit !== undefined) + writer.writeUint64(3, this.limit); + if (this.count_total !== undefined) + writer.writeBool(4, this.count_total); + if (this.reverse !== undefined) + writer.writeBool(5, this.reverse); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new PageRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.key = reader.readBytes(); + break; + case 2: + message.offset = reader.readUint64(); + break; + case 3: + message.limit = reader.readUint64(); + break; + case 4: + message.count_total = reader.readBool(); + break; + case 5: + message.reverse = reader.readBool(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return PageRequest.deserialize(bytes); + } + } + v1beta1.PageRequest = PageRequest; + class PageResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("next_key" in data && data.next_key != undefined) { + this.next_key = data.next_key; + } + if ("total" in data && data.total != undefined) { + this.total = data.total; + } + } + } + get next_key() { + return pb_1.Message.getField(this, 1); + } + set next_key(value) { + pb_1.Message.setField(this, 1, value); + } + get total() { + return pb_1.Message.getField(this, 2); + } + set total(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new PageResponse({}); + if (data.next_key != null) { + message.next_key = data.next_key; + } + if (data.total != null) { + message.total = data.total; + } + return message; + } + toObject() { + const data = {}; + if (this.next_key != null) { + data.next_key = this.next_key; + } + if (this.total != null) { + data.total = this.total; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.next_key !== undefined) + writer.writeBytes(1, this.next_key); + if (this.total !== undefined) + writer.writeUint64(2, this.total); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new PageResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.next_key = reader.readBytes(); + break; + case 2: + message.total = reader.readUint64(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return PageResponse.deserialize(bytes); + } + } + v1beta1.PageResponse = PageResponse; + })(v1beta1 = query.v1beta1 || (query.v1beta1 = {})); + })(query = base.query || (base.query = {})); + })(base = cosmos.base || (cosmos.base = {})); +})(cosmos = exports.cosmos || (exports.cosmos = {})); diff --git a/dist/proto/cosmos/base/v1beta1/coin.d.ts b/dist/proto/cosmos/base/v1beta1/coin.d.ts new file mode 100644 index 0000000..61b17d0 --- /dev/null +++ b/dist/proto/cosmos/base/v1beta1/coin.d.ts @@ -0,0 +1,85 @@ +import * as pb_1 from "google-protobuf"; +export declare namespace cosmos.base.v1beta1 { + class Coin extends pb_1.Message { + constructor(data?: any[] | { + denom?: string; + amount?: string; + }); + get denom(): string; + set denom(value: string); + get amount(): string; + set amount(value: string); + static fromObject(data: { + denom?: string; + amount?: string; + }): Coin; + toObject(): { + denom?: string | undefined; + amount?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Coin; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Coin; + } + class DecCoin extends pb_1.Message { + constructor(data?: any[] | { + denom?: string; + amount?: string; + }); + get denom(): string; + set denom(value: string); + get amount(): string; + set amount(value: string); + static fromObject(data: { + denom?: string; + amount?: string; + }): DecCoin; + toObject(): { + denom?: string | undefined; + amount?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DecCoin; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): DecCoin; + } + class IntProto extends pb_1.Message { + constructor(data?: any[] | { + int?: string; + }); + get int(): string; + set int(value: string); + static fromObject(data: { + int?: string; + }): IntProto; + toObject(): { + int?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): IntProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): IntProto; + } + class DecProto extends pb_1.Message { + constructor(data?: any[] | { + dec?: string; + }); + get dec(): string; + set dec(value: string); + static fromObject(data: { + dec?: string; + }): DecProto; + toObject(): { + dec?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DecProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): DecProto; + } +} diff --git a/dist/proto/cosmos/base/v1beta1/coin.js b/dist/proto/cosmos/base/v1beta1/coin.js new file mode 100644 index 0000000..7d95dd9 --- /dev/null +++ b/dist/proto/cosmos/base/v1beta1/coin.js @@ -0,0 +1,312 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.cosmos = void 0; +const pb_1 = __importStar(require("google-protobuf")); +var cosmos; +(function (cosmos) { + var base; + (function (base) { + var v1beta1; + (function (v1beta1) { + class Coin extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("denom" in data && data.denom != undefined) { + this.denom = data.denom; + } + if ("amount" in data && data.amount != undefined) { + this.amount = data.amount; + } + } + } + get denom() { + return pb_1.Message.getField(this, 1); + } + set denom(value) { + pb_1.Message.setField(this, 1, value); + } + get amount() { + return pb_1.Message.getField(this, 2); + } + set amount(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new Coin({}); + if (data.denom != null) { + message.denom = data.denom; + } + if (data.amount != null) { + message.amount = data.amount; + } + return message; + } + toObject() { + const data = {}; + if (this.denom != null) { + data.denom = this.denom; + } + if (this.amount != null) { + data.amount = this.amount; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.denom === "string" && this.denom.length) + writer.writeString(1, this.denom); + if (typeof this.amount === "string" && this.amount.length) + writer.writeString(2, this.amount); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Coin(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.denom = reader.readString(); + break; + case 2: + message.amount = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Coin.deserialize(bytes); + } + } + v1beta1.Coin = Coin; + class DecCoin extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("denom" in data && data.denom != undefined) { + this.denom = data.denom; + } + if ("amount" in data && data.amount != undefined) { + this.amount = data.amount; + } + } + } + get denom() { + return pb_1.Message.getField(this, 1); + } + set denom(value) { + pb_1.Message.setField(this, 1, value); + } + get amount() { + return pb_1.Message.getField(this, 2); + } + set amount(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new DecCoin({}); + if (data.denom != null) { + message.denom = data.denom; + } + if (data.amount != null) { + message.amount = data.amount; + } + return message; + } + toObject() { + const data = {}; + if (this.denom != null) { + data.denom = this.denom; + } + if (this.amount != null) { + data.amount = this.amount; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.denom === "string" && this.denom.length) + writer.writeString(1, this.denom); + if (typeof this.amount === "string" && this.amount.length) + writer.writeString(2, this.amount); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new DecCoin(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.denom = reader.readString(); + break; + case 2: + message.amount = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return DecCoin.deserialize(bytes); + } + } + v1beta1.DecCoin = DecCoin; + class IntProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("int" in data && data.int != undefined) { + this.int = data.int; + } + } + } + get int() { + return pb_1.Message.getField(this, 1); + } + set int(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new IntProto({}); + if (data.int != null) { + message.int = data.int; + } + return message; + } + toObject() { + const data = {}; + if (this.int != null) { + data.int = this.int; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.int === "string" && this.int.length) + writer.writeString(1, this.int); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new IntProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.int = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return IntProto.deserialize(bytes); + } + } + v1beta1.IntProto = IntProto; + class DecProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("dec" in data && data.dec != undefined) { + this.dec = data.dec; + } + } + } + get dec() { + return pb_1.Message.getField(this, 1); + } + set dec(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new DecProto({}); + if (data.dec != null) { + message.dec = data.dec; + } + return message; + } + toObject() { + const data = {}; + if (this.dec != null) { + data.dec = this.dec; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.dec === "string" && this.dec.length) + writer.writeString(1, this.dec); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new DecProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.dec = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return DecProto.deserialize(bytes); + } + } + v1beta1.DecProto = DecProto; + })(v1beta1 = base.v1beta1 || (base.v1beta1 = {})); + })(base = cosmos.base || (cosmos.base = {})); +})(cosmos = exports.cosmos || (exports.cosmos = {})); diff --git a/dist/proto/gogoproto/gogo.d.ts b/dist/proto/gogoproto/gogo.d.ts new file mode 100644 index 0000000..bcf3ec7 --- /dev/null +++ b/dist/proto/gogoproto/gogo.d.ts @@ -0,0 +1 @@ +export declare namespace gogoproto { } diff --git a/dist/proto/gogoproto/gogo.js b/dist/proto/gogoproto/gogo.js new file mode 100644 index 0000000..c8ad2e5 --- /dev/null +++ b/dist/proto/gogoproto/gogo.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/dist/proto/google/api/annotations.d.ts b/dist/proto/google/api/annotations.d.ts new file mode 100644 index 0000000..505d0aa --- /dev/null +++ b/dist/proto/google/api/annotations.d.ts @@ -0,0 +1 @@ +export declare namespace google.api { } diff --git a/dist/proto/google/api/annotations.js b/dist/proto/google/api/annotations.js new file mode 100644 index 0000000..c8ad2e5 --- /dev/null +++ b/dist/proto/google/api/annotations.js @@ -0,0 +1,2 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); diff --git a/dist/proto/google/api/http.d.ts b/dist/proto/google/api/http.d.ts new file mode 100644 index 0000000..89746c2 --- /dev/null +++ b/dist/proto/google/api/http.d.ts @@ -0,0 +1,185 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/api/http.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as pb_1 from "google-protobuf"; +export declare namespace google.api { + class Http extends pb_1.Message { + constructor(data?: any[] | { + rules?: HttpRule[]; + fully_decode_reserved_expansion?: boolean; + }); + get rules(): HttpRule[]; + set rules(value: HttpRule[]); + get fully_decode_reserved_expansion(): boolean; + set fully_decode_reserved_expansion(value: boolean); + static fromObject(data: { + rules?: ReturnType[]; + fully_decode_reserved_expansion?: boolean; + }): Http; + toObject(): { + rules?: { + selector?: string | undefined; + get?: string | undefined; + put?: string | undefined; + post?: string | undefined; + delete?: string | undefined; + patch?: string | undefined; + custom?: { + kind?: string | undefined; + path?: string | undefined; + } | undefined; + body?: string | undefined; + response_body?: string | undefined; + additional_bindings?: any[] | undefined; + }[] | undefined; + fully_decode_reserved_expansion?: boolean | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Http; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Http; + } + class HttpRule extends pb_1.Message { + constructor(data?: any[] | ({ + selector?: string; + body?: string; + response_body?: string; + additional_bindings?: HttpRule[]; + } & (({ + get?: string; + put?: never; + post?: never; + delete?: never; + patch?: never; + custom?: never; + } | { + get?: never; + put?: string; + post?: never; + delete?: never; + patch?: never; + custom?: never; + } | { + get?: never; + put?: never; + post?: string; + delete?: never; + patch?: never; + custom?: never; + } | { + get?: never; + put?: never; + post?: never; + delete?: string; + patch?: never; + custom?: never; + } | { + get?: never; + put?: never; + post?: never; + delete?: never; + patch?: string; + custom?: never; + } | { + get?: never; + put?: never; + post?: never; + delete?: never; + patch?: never; + custom?: CustomHttpPattern; + })))); + get selector(): string; + set selector(value: string); + get get(): string; + set get(value: string); + get put(): string; + set put(value: string); + get post(): string; + set post(value: string); + get delete(): string; + set delete(value: string); + get patch(): string; + set patch(value: string); + get custom(): CustomHttpPattern; + set custom(value: CustomHttpPattern); + get body(): string; + set body(value: string); + get response_body(): string; + set response_body(value: string); + get additional_bindings(): HttpRule[]; + set additional_bindings(value: HttpRule[]); + get pattern(): "patch" | "get" | "put" | "post" | "delete" | "custom" | "none"; + static fromObject(data: { + selector?: string; + get?: string; + put?: string; + post?: string; + delete?: string; + patch?: string; + custom?: ReturnType; + body?: string; + response_body?: string; + additional_bindings?: ReturnType[]; + }): HttpRule; + toObject(): { + selector?: string | undefined; + get?: string | undefined; + put?: string | undefined; + post?: string | undefined; + delete?: string | undefined; + patch?: string | undefined; + custom?: { + kind?: string | undefined; + path?: string | undefined; + } | undefined; + body?: string | undefined; + response_body?: string | undefined; + additional_bindings?: { + selector?: string | undefined; + get?: string | undefined; + put?: string | undefined; + post?: string | undefined; + delete?: string | undefined; + patch?: string | undefined; + custom?: { + kind?: string | undefined; + path?: string | undefined; + } | undefined; + body?: string | undefined; + response_body?: string | undefined; + additional_bindings?: any[] | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): HttpRule; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): HttpRule; + } + class CustomHttpPattern extends pb_1.Message { + constructor(data?: any[] | { + kind?: string; + path?: string; + }); + get kind(): string; + set kind(value: string); + get path(): string; + set path(value: string); + static fromObject(data: { + kind?: string; + path?: string; + }): CustomHttpPattern; + toObject(): { + kind?: string | undefined; + path?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): CustomHttpPattern; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): CustomHttpPattern; + } +} diff --git a/dist/proto/google/api/http.js b/dist/proto/google/api/http.js new file mode 100644 index 0000000..e2126dc --- /dev/null +++ b/dist/proto/google/api/http.js @@ -0,0 +1,449 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.google = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/api/http.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const pb_1 = __importStar(require("google-protobuf")); +var google; +(function (google) { + var api; + (function (api) { + class Http extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("rules" in data && data.rules != undefined) { + this.rules = data.rules; + } + if ("fully_decode_reserved_expansion" in data && data.fully_decode_reserved_expansion != undefined) { + this.fully_decode_reserved_expansion = data.fully_decode_reserved_expansion; + } + } + } + get rules() { + return pb_1.Message.getRepeatedWrapperField(this, HttpRule, 1); + } + set rules(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get fully_decode_reserved_expansion() { + return pb_1.Message.getField(this, 2); + } + set fully_decode_reserved_expansion(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new Http({}); + if (data.rules != null) { + message.rules = data.rules.map(item => HttpRule.fromObject(item)); + } + if (data.fully_decode_reserved_expansion != null) { + message.fully_decode_reserved_expansion = data.fully_decode_reserved_expansion; + } + return message; + } + toObject() { + const data = {}; + if (this.rules != null) { + data.rules = this.rules.map((item) => item.toObject()); + } + if (this.fully_decode_reserved_expansion != null) { + data.fully_decode_reserved_expansion = this.fully_decode_reserved_expansion; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.rules !== undefined) + writer.writeRepeatedMessage(1, this.rules, (item) => item.serialize(writer)); + if (this.fully_decode_reserved_expansion !== undefined) + writer.writeBool(2, this.fully_decode_reserved_expansion); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Http(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.rules, () => pb_1.Message.addToRepeatedWrapperField(message, 1, HttpRule.deserialize(reader), HttpRule)); + break; + case 2: + message.fully_decode_reserved_expansion = reader.readBool(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Http.deserialize(bytes); + } + } + api.Http = Http; + class HttpRule extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [11], [[2, 3, 4, 5, 6, 8]]); + if (!Array.isArray(data) && typeof data == "object") { + if ("selector" in data && data.selector != undefined) { + this.selector = data.selector; + } + if ("get" in data && data.get != undefined) { + this.get = data.get; + } + if ("put" in data && data.put != undefined) { + this.put = data.put; + } + if ("post" in data && data.post != undefined) { + this.post = data.post; + } + if ("delete" in data && data.delete != undefined) { + this.delete = data.delete; + } + if ("patch" in data && data.patch != undefined) { + this.patch = data.patch; + } + if ("custom" in data && data.custom != undefined) { + this.custom = data.custom; + } + if ("body" in data && data.body != undefined) { + this.body = data.body; + } + if ("response_body" in data && data.response_body != undefined) { + this.response_body = data.response_body; + } + if ("additional_bindings" in data && data.additional_bindings != undefined) { + this.additional_bindings = data.additional_bindings; + } + } + } + get selector() { + return pb_1.Message.getField(this, 1); + } + set selector(value) { + pb_1.Message.setField(this, 1, value); + } + get get() { + return pb_1.Message.getField(this, 2); + } + set get(value) { + pb_1.Message.setOneofField(this, 2, [2, 3, 4, 5, 6, 8], value); + } + get put() { + return pb_1.Message.getField(this, 3); + } + set put(value) { + pb_1.Message.setOneofField(this, 3, [2, 3, 4, 5, 6, 8], value); + } + get post() { + return pb_1.Message.getField(this, 4); + } + set post(value) { + pb_1.Message.setOneofField(this, 4, [2, 3, 4, 5, 6, 8], value); + } + get delete() { + return pb_1.Message.getField(this, 5); + } + set delete(value) { + pb_1.Message.setOneofField(this, 5, [2, 3, 4, 5, 6, 8], value); + } + get patch() { + return pb_1.Message.getField(this, 6); + } + set patch(value) { + pb_1.Message.setOneofField(this, 6, [2, 3, 4, 5, 6, 8], value); + } + get custom() { + return pb_1.Message.getWrapperField(this, CustomHttpPattern, 8); + } + set custom(value) { + pb_1.Message.setOneofWrapperField(this, 8, [2, 3, 4, 5, 6, 8], value); + } + get body() { + return pb_1.Message.getField(this, 7); + } + set body(value) { + pb_1.Message.setField(this, 7, value); + } + get response_body() { + return pb_1.Message.getField(this, 12); + } + set response_body(value) { + pb_1.Message.setField(this, 12, value); + } + get additional_bindings() { + return pb_1.Message.getRepeatedWrapperField(this, HttpRule, 11); + } + set additional_bindings(value) { + pb_1.Message.setRepeatedWrapperField(this, 11, value); + } + get pattern() { + const cases = { + 0: "none", + 2: "get", + 3: "put", + 4: "post", + 5: "delete", + 6: "patch", + 8: "custom" + }; + return cases[pb_1.Message.computeOneofCase(this, [2, 3, 4, 5, 6, 8])]; + } + static fromObject(data) { + const message = new HttpRule({}); + if (data.selector != null) { + message.selector = data.selector; + } + if (data.get != null) { + message.get = data.get; + } + if (data.put != null) { + message.put = data.put; + } + if (data.post != null) { + message.post = data.post; + } + if (data.delete != null) { + message.delete = data.delete; + } + if (data.patch != null) { + message.patch = data.patch; + } + if (data.custom != null) { + message.custom = CustomHttpPattern.fromObject(data.custom); + } + if (data.body != null) { + message.body = data.body; + } + if (data.response_body != null) { + message.response_body = data.response_body; + } + if (data.additional_bindings != null) { + message.additional_bindings = data.additional_bindings.map(item => HttpRule.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.selector != null) { + data.selector = this.selector; + } + if (this.get != null) { + data.get = this.get; + } + if (this.put != null) { + data.put = this.put; + } + if (this.post != null) { + data.post = this.post; + } + if (this.delete != null) { + data.delete = this.delete; + } + if (this.patch != null) { + data.patch = this.patch; + } + if (this.custom != null) { + data.custom = this.custom.toObject(); + } + if (this.body != null) { + data.body = this.body; + } + if (this.response_body != null) { + data.response_body = this.response_body; + } + if (this.additional_bindings != null) { + data.additional_bindings = this.additional_bindings.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.selector === "string" && this.selector.length) + writer.writeString(1, this.selector); + if (typeof this.get === "string" && this.get.length) + writer.writeString(2, this.get); + if (typeof this.put === "string" && this.put.length) + writer.writeString(3, this.put); + if (typeof this.post === "string" && this.post.length) + writer.writeString(4, this.post); + if (typeof this.delete === "string" && this.delete.length) + writer.writeString(5, this.delete); + if (typeof this.patch === "string" && this.patch.length) + writer.writeString(6, this.patch); + if (this.custom !== undefined) + writer.writeMessage(8, this.custom, () => this.custom.serialize(writer)); + if (typeof this.body === "string" && this.body.length) + writer.writeString(7, this.body); + if (typeof this.response_body === "string" && this.response_body.length) + writer.writeString(12, this.response_body); + if (this.additional_bindings !== undefined) + writer.writeRepeatedMessage(11, this.additional_bindings, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new HttpRule(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.selector = reader.readString(); + break; + case 2: + message.get = reader.readString(); + break; + case 3: + message.put = reader.readString(); + break; + case 4: + message.post = reader.readString(); + break; + case 5: + message.delete = reader.readString(); + break; + case 6: + message.patch = reader.readString(); + break; + case 8: + reader.readMessage(message.custom, () => message.custom = CustomHttpPattern.deserialize(reader)); + break; + case 7: + message.body = reader.readString(); + break; + case 12: + message.response_body = reader.readString(); + break; + case 11: + reader.readMessage(message.additional_bindings, () => pb_1.Message.addToRepeatedWrapperField(message, 11, HttpRule.deserialize(reader), HttpRule)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return HttpRule.deserialize(bytes); + } + } + api.HttpRule = HttpRule; + class CustomHttpPattern extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("kind" in data && data.kind != undefined) { + this.kind = data.kind; + } + if ("path" in data && data.path != undefined) { + this.path = data.path; + } + } + } + get kind() { + return pb_1.Message.getField(this, 1); + } + set kind(value) { + pb_1.Message.setField(this, 1, value); + } + get path() { + return pb_1.Message.getField(this, 2); + } + set path(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new CustomHttpPattern({}); + if (data.kind != null) { + message.kind = data.kind; + } + if (data.path != null) { + message.path = data.path; + } + return message; + } + toObject() { + const data = {}; + if (this.kind != null) { + data.kind = this.kind; + } + if (this.path != null) { + data.path = this.path; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.kind === "string" && this.kind.length) + writer.writeString(1, this.kind); + if (typeof this.path === "string" && this.path.length) + writer.writeString(2, this.path); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new CustomHttpPattern(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.kind = reader.readString(); + break; + case 2: + message.path = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return CustomHttpPattern.deserialize(bytes); + } + } + api.CustomHttpPattern = CustomHttpPattern; + })(api = google.api || (google.api = {})); +})(google = exports.google || (exports.google = {})); diff --git a/dist/proto/google/protobuf/descriptor.d.ts b/dist/proto/google/protobuf/descriptor.d.ts new file mode 100644 index 0000000..a3b68a6 --- /dev/null +++ b/dist/proto/google/protobuf/descriptor.d.ts @@ -0,0 +1,1211 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/protobuf/descriptor.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as pb_1 from "google-protobuf"; +export declare namespace google.protobuf { + class FileDescriptorSet extends pb_1.Message { + constructor(data?: any[] | { + file: FileDescriptorProto[]; + }); + get file(): FileDescriptorProto[]; + set file(value: FileDescriptorProto[]); + static fromObject(data: { + file: ReturnType[]; + }): FileDescriptorSet; + toObject(): { + file: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FileDescriptorSet; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): FileDescriptorSet; + } + class FileDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + package?: string; + dependency: string[]; + public_dependency: number[]; + weak_dependency: number[]; + message_type: DescriptorProto[]; + enum_type: EnumDescriptorProto[]; + service: ServiceDescriptorProto[]; + extension: FieldDescriptorProto[]; + options?: FileOptions; + source_code_info?: SourceCodeInfo; + syntax?: string; + }); + get name(): string; + set name(value: string); + get package(): string; + set package(value: string); + get dependency(): string[]; + set dependency(value: string[]); + get public_dependency(): number[]; + set public_dependency(value: number[]); + get weak_dependency(): number[]; + set weak_dependency(value: number[]); + get message_type(): DescriptorProto[]; + set message_type(value: DescriptorProto[]); + get enum_type(): EnumDescriptorProto[]; + set enum_type(value: EnumDescriptorProto[]); + get service(): ServiceDescriptorProto[]; + set service(value: ServiceDescriptorProto[]); + get extension(): FieldDescriptorProto[]; + set extension(value: FieldDescriptorProto[]); + get options(): FileOptions; + set options(value: FileOptions); + get source_code_info(): SourceCodeInfo; + set source_code_info(value: SourceCodeInfo); + get syntax(): string; + set syntax(value: string); + static fromObject(data: { + name?: string; + package?: string; + dependency: string[]; + public_dependency: number[]; + weak_dependency: number[]; + message_type: ReturnType[]; + enum_type: ReturnType[]; + service: ReturnType[]; + extension: ReturnType[]; + options?: ReturnType; + source_code_info?: ReturnType; + syntax?: string; + }): FileDescriptorProto; + toObject(): { + name?: string | undefined; + package?: string | undefined; + dependency: string[]; + public_dependency: number[]; + weak_dependency: number[]; + message_type: ReturnType[]; + enum_type: ReturnType[]; + service: ReturnType[]; + extension: ReturnType[]; + options?: { + java_package?: string | undefined; + java_outer_classname?: string | undefined; + java_multiple_files?: boolean | undefined; + java_generate_equals_and_hash?: boolean | undefined; + java_string_check_utf8?: boolean | undefined; + optimize_for?: FileOptions.OptimizeMode | undefined; + go_package?: string | undefined; + cc_generic_services?: boolean | undefined; + java_generic_services?: boolean | undefined; + py_generic_services?: boolean | undefined; + php_generic_services?: boolean | undefined; + deprecated?: boolean | undefined; + cc_enable_arenas?: boolean | undefined; + objc_class_prefix?: string | undefined; + csharp_namespace?: string | undefined; + swift_prefix?: string | undefined; + php_class_prefix?: string | undefined; + php_namespace?: string | undefined; + php_metadata_namespace?: string | undefined; + ruby_package?: string | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + source_code_info?: { + location: { + path: number[]; + span: number[]; + leading_comments?: string | undefined; + trailing_comments?: string | undefined; + leading_detached_comments: string[]; + }[]; + } | undefined; + syntax?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FileDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): FileDescriptorProto; + } + class DescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + field: FieldDescriptorProto[]; + extension: FieldDescriptorProto[]; + nested_type: DescriptorProto[]; + enum_type: EnumDescriptorProto[]; + extension_range: DescriptorProto.ExtensionRange[]; + oneof_decl: OneofDescriptorProto[]; + options?: MessageOptions; + reserved_range: DescriptorProto.ReservedRange[]; + reserved_name: string[]; + }); + get name(): string; + set name(value: string); + get field(): FieldDescriptorProto[]; + set field(value: FieldDescriptorProto[]); + get extension(): FieldDescriptorProto[]; + set extension(value: FieldDescriptorProto[]); + get nested_type(): DescriptorProto[]; + set nested_type(value: DescriptorProto[]); + get enum_type(): EnumDescriptorProto[]; + set enum_type(value: EnumDescriptorProto[]); + get extension_range(): DescriptorProto.ExtensionRange[]; + set extension_range(value: DescriptorProto.ExtensionRange[]); + get oneof_decl(): OneofDescriptorProto[]; + set oneof_decl(value: OneofDescriptorProto[]); + get options(): MessageOptions; + set options(value: MessageOptions); + get reserved_range(): DescriptorProto.ReservedRange[]; + set reserved_range(value: DescriptorProto.ReservedRange[]); + get reserved_name(): string[]; + set reserved_name(value: string[]); + static fromObject(data: { + name?: string; + field: ReturnType[]; + extension: ReturnType[]; + nested_type: ReturnType[]; + enum_type: ReturnType[]; + extension_range: ReturnType[]; + oneof_decl: ReturnType[]; + options?: ReturnType; + reserved_range: ReturnType[]; + reserved_name: string[]; + }): any; + toObject(): { + name?: string | undefined; + field: ReturnType[]; + extension: ReturnType[]; + nested_type: ReturnType[]; + enum_type: ReturnType[]; + extension_range: ReturnType[]; + oneof_decl: ReturnType[]; + options?: { + message_set_wire_format?: boolean | undefined; + no_standard_descriptor_accessor?: boolean | undefined; + deprecated?: boolean | undefined; + map_entry?: boolean | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + reserved_range: ReturnType[]; + reserved_name: string[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): DescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): DescriptorProto; + } + namespace DescriptorProto { + class ExtensionRange extends pb_1.Message { + constructor(data?: any[] | { + start?: number; + end?: number; + options?: ExtensionRangeOptions; + }); + get start(): number; + set start(value: number); + get end(): number; + set end(value: number); + get options(): ExtensionRangeOptions; + set options(value: ExtensionRangeOptions); + static fromObject(data: { + start?: number; + end?: number; + options?: ReturnType; + }): ExtensionRange; + toObject(): { + start?: number | undefined; + end?: number | undefined; + options?: { + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ExtensionRange; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ExtensionRange; + } + class ReservedRange extends pb_1.Message { + constructor(data?: any[] | { + start?: number; + end?: number; + }); + get start(): number; + set start(value: number); + get end(): number; + set end(value: number); + static fromObject(data: { + start?: number; + end?: number; + }): ReservedRange; + toObject(): { + start?: number | undefined; + end?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ReservedRange; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ReservedRange; + } + } + class ExtensionRangeOptions extends pb_1.Message { + constructor(data?: any[] | { + uninterpreted_option: UninterpretedOption[]; + }); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + uninterpreted_option: ReturnType[]; + }): ExtensionRangeOptions; + toObject(): { + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ExtensionRangeOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ExtensionRangeOptions; + } + class FieldDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + number?: number; + label?: FieldDescriptorProto.Label; + type?: FieldDescriptorProto.Type; + type_name?: string; + extendee?: string; + default_value?: string; + oneof_index?: number; + json_name?: string; + options?: FieldOptions; + proto3_optional?: boolean; + }); + get name(): string; + set name(value: string); + get number(): number; + set number(value: number); + get label(): FieldDescriptorProto.Label; + set label(value: FieldDescriptorProto.Label); + get type(): FieldDescriptorProto.Type; + set type(value: FieldDescriptorProto.Type); + get type_name(): string; + set type_name(value: string); + get extendee(): string; + set extendee(value: string); + get default_value(): string; + set default_value(value: string); + get oneof_index(): number; + set oneof_index(value: number); + get json_name(): string; + set json_name(value: string); + get options(): FieldOptions; + set options(value: FieldOptions); + get proto3_optional(): boolean; + set proto3_optional(value: boolean); + static fromObject(data: { + name?: string; + number?: number; + label?: FieldDescriptorProto.Label; + type?: FieldDescriptorProto.Type; + type_name?: string; + extendee?: string; + default_value?: string; + oneof_index?: number; + json_name?: string; + options?: ReturnType; + proto3_optional?: boolean; + }): FieldDescriptorProto; + toObject(): { + name?: string | undefined; + number?: number | undefined; + label?: FieldDescriptorProto.Label | undefined; + type?: FieldDescriptorProto.Type | undefined; + type_name?: string | undefined; + extendee?: string | undefined; + default_value?: string | undefined; + oneof_index?: number | undefined; + json_name?: string | undefined; + options?: { + ctype?: FieldOptions.CType | undefined; + packed?: boolean | undefined; + jstype?: FieldOptions.JSType | undefined; + lazy?: boolean | undefined; + deprecated?: boolean | undefined; + weak?: boolean | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + proto3_optional?: boolean | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FieldDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): FieldDescriptorProto; + } + namespace FieldDescriptorProto { + enum Type { + TYPE_DOUBLE = 1, + TYPE_FLOAT = 2, + TYPE_INT64 = 3, + TYPE_UINT64 = 4, + TYPE_INT32 = 5, + TYPE_FIXED64 = 6, + TYPE_FIXED32 = 7, + TYPE_BOOL = 8, + TYPE_STRING = 9, + TYPE_GROUP = 10, + TYPE_MESSAGE = 11, + TYPE_BYTES = 12, + TYPE_UINT32 = 13, + TYPE_ENUM = 14, + TYPE_SFIXED32 = 15, + TYPE_SFIXED64 = 16, + TYPE_SINT32 = 17, + TYPE_SINT64 = 18 + } + enum Label { + LABEL_OPTIONAL = 1, + LABEL_REQUIRED = 2, + LABEL_REPEATED = 3 + } + } + class OneofDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + options?: OneofOptions; + }); + get name(): string; + set name(value: string); + get options(): OneofOptions; + set options(value: OneofOptions); + static fromObject(data: { + name?: string; + options?: ReturnType; + }): OneofDescriptorProto; + toObject(): { + name?: string | undefined; + options?: { + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): OneofDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): OneofDescriptorProto; + } + class EnumDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + value: EnumValueDescriptorProto[]; + options?: EnumOptions; + reserved_range: EnumDescriptorProto.EnumReservedRange[]; + reserved_name: string[]; + }); + get name(): string; + set name(value: string); + get value(): EnumValueDescriptorProto[]; + set value(value: EnumValueDescriptorProto[]); + get options(): EnumOptions; + set options(value: EnumOptions); + get reserved_range(): EnumDescriptorProto.EnumReservedRange[]; + set reserved_range(value: EnumDescriptorProto.EnumReservedRange[]); + get reserved_name(): string[]; + set reserved_name(value: string[]); + static fromObject(data: { + name?: string; + value: ReturnType[]; + options?: ReturnType; + reserved_range: ReturnType[]; + reserved_name: string[]; + }): EnumDescriptorProto; + toObject(): { + name?: string | undefined; + value: ReturnType[]; + options?: { + allow_alias?: boolean | undefined; + deprecated?: boolean | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + reserved_range: ReturnType[]; + reserved_name: string[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EnumDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): EnumDescriptorProto; + } + namespace EnumDescriptorProto { + class EnumReservedRange extends pb_1.Message { + constructor(data?: any[] | { + start?: number; + end?: number; + }); + get start(): number; + set start(value: number); + get end(): number; + set end(value: number); + static fromObject(data: { + start?: number; + end?: number; + }): EnumReservedRange; + toObject(): { + start?: number | undefined; + end?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EnumReservedRange; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): EnumReservedRange; + } + } + class EnumValueDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + number?: number; + options?: EnumValueOptions; + }); + get name(): string; + set name(value: string); + get number(): number; + set number(value: number); + get options(): EnumValueOptions; + set options(value: EnumValueOptions); + static fromObject(data: { + name?: string; + number?: number; + options?: ReturnType; + }): EnumValueDescriptorProto; + toObject(): { + name?: string | undefined; + number?: number | undefined; + options?: { + deprecated?: boolean | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EnumValueDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): EnumValueDescriptorProto; + } + class ServiceDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + method: MethodDescriptorProto[]; + options?: ServiceOptions; + }); + get name(): string; + set name(value: string); + get method(): MethodDescriptorProto[]; + set method(value: MethodDescriptorProto[]); + get options(): ServiceOptions; + set options(value: ServiceOptions); + static fromObject(data: { + name?: string; + method: ReturnType[]; + options?: ReturnType; + }): ServiceDescriptorProto; + toObject(): { + name?: string | undefined; + method: ReturnType[]; + options?: { + deprecated?: boolean | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ServiceDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ServiceDescriptorProto; + } + class MethodDescriptorProto extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + input_type?: string; + output_type?: string; + options?: MethodOptions; + client_streaming?: boolean; + server_streaming?: boolean; + }); + get name(): string; + set name(value: string); + get input_type(): string; + set input_type(value: string); + get output_type(): string; + set output_type(value: string); + get options(): MethodOptions; + set options(value: MethodOptions); + get client_streaming(): boolean; + set client_streaming(value: boolean); + get server_streaming(): boolean; + set server_streaming(value: boolean); + static fromObject(data: { + name?: string; + input_type?: string; + output_type?: string; + options?: ReturnType; + client_streaming?: boolean; + server_streaming?: boolean; + }): MethodDescriptorProto; + toObject(): { + name?: string | undefined; + input_type?: string | undefined; + output_type?: string | undefined; + options?: { + deprecated?: boolean | undefined; + idempotency_level?: MethodOptions.IdempotencyLevel | undefined; + uninterpreted_option: { + name: { + name_part: string; + is_extension: boolean; + }[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }[]; + } | undefined; + client_streaming?: boolean | undefined; + server_streaming?: boolean | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MethodDescriptorProto; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MethodDescriptorProto; + } + class FileOptions extends pb_1.Message { + constructor(data?: any[] | { + java_package?: string; + java_outer_classname?: string; + java_multiple_files?: boolean; + /** @deprecated*/ + java_generate_equals_and_hash?: boolean; + java_string_check_utf8?: boolean; + optimize_for?: FileOptions.OptimizeMode; + go_package?: string; + cc_generic_services?: boolean; + java_generic_services?: boolean; + py_generic_services?: boolean; + php_generic_services?: boolean; + deprecated?: boolean; + cc_enable_arenas?: boolean; + objc_class_prefix?: string; + csharp_namespace?: string; + swift_prefix?: string; + php_class_prefix?: string; + php_namespace?: string; + php_metadata_namespace?: string; + ruby_package?: string; + uninterpreted_option: UninterpretedOption[]; + }); + get java_package(): string; + set java_package(value: string); + get java_outer_classname(): string; + set java_outer_classname(value: string); + get java_multiple_files(): boolean; + set java_multiple_files(value: boolean); + /** @deprecated*/ + get java_generate_equals_and_hash(): boolean; + /** @deprecated*/ + set java_generate_equals_and_hash(value: boolean); + get java_string_check_utf8(): boolean; + set java_string_check_utf8(value: boolean); + get optimize_for(): FileOptions.OptimizeMode; + set optimize_for(value: FileOptions.OptimizeMode); + get go_package(): string; + set go_package(value: string); + get cc_generic_services(): boolean; + set cc_generic_services(value: boolean); + get java_generic_services(): boolean; + set java_generic_services(value: boolean); + get py_generic_services(): boolean; + set py_generic_services(value: boolean); + get php_generic_services(): boolean; + set php_generic_services(value: boolean); + get deprecated(): boolean; + set deprecated(value: boolean); + get cc_enable_arenas(): boolean; + set cc_enable_arenas(value: boolean); + get objc_class_prefix(): string; + set objc_class_prefix(value: string); + get csharp_namespace(): string; + set csharp_namespace(value: string); + get swift_prefix(): string; + set swift_prefix(value: string); + get php_class_prefix(): string; + set php_class_prefix(value: string); + get php_namespace(): string; + set php_namespace(value: string); + get php_metadata_namespace(): string; + set php_metadata_namespace(value: string); + get ruby_package(): string; + set ruby_package(value: string); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + java_package?: string; + java_outer_classname?: string; + java_multiple_files?: boolean; + java_generate_equals_and_hash?: boolean; + java_string_check_utf8?: boolean; + optimize_for?: FileOptions.OptimizeMode; + go_package?: string; + cc_generic_services?: boolean; + java_generic_services?: boolean; + py_generic_services?: boolean; + php_generic_services?: boolean; + deprecated?: boolean; + cc_enable_arenas?: boolean; + objc_class_prefix?: string; + csharp_namespace?: string; + swift_prefix?: string; + php_class_prefix?: string; + php_namespace?: string; + php_metadata_namespace?: string; + ruby_package?: string; + uninterpreted_option: ReturnType[]; + }): FileOptions; + toObject(): { + java_package?: string | undefined; + java_outer_classname?: string | undefined; + java_multiple_files?: boolean | undefined; + java_generate_equals_and_hash?: boolean | undefined; + java_string_check_utf8?: boolean | undefined; + optimize_for?: FileOptions.OptimizeMode | undefined; + go_package?: string | undefined; + cc_generic_services?: boolean | undefined; + java_generic_services?: boolean | undefined; + py_generic_services?: boolean | undefined; + php_generic_services?: boolean | undefined; + deprecated?: boolean | undefined; + cc_enable_arenas?: boolean | undefined; + objc_class_prefix?: string | undefined; + csharp_namespace?: string | undefined; + swift_prefix?: string | undefined; + php_class_prefix?: string | undefined; + php_namespace?: string | undefined; + php_metadata_namespace?: string | undefined; + ruby_package?: string | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FileOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): FileOptions; + } + namespace FileOptions { + enum OptimizeMode { + SPEED = 1, + CODE_SIZE = 2, + LITE_RUNTIME = 3 + } + } + class MessageOptions extends pb_1.Message { + constructor(data?: any[] | { + message_set_wire_format?: boolean; + no_standard_descriptor_accessor?: boolean; + deprecated?: boolean; + map_entry?: boolean; + uninterpreted_option: UninterpretedOption[]; + }); + get message_set_wire_format(): boolean; + set message_set_wire_format(value: boolean); + get no_standard_descriptor_accessor(): boolean; + set no_standard_descriptor_accessor(value: boolean); + get deprecated(): boolean; + set deprecated(value: boolean); + get map_entry(): boolean; + set map_entry(value: boolean); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + message_set_wire_format?: boolean; + no_standard_descriptor_accessor?: boolean; + deprecated?: boolean; + map_entry?: boolean; + uninterpreted_option: ReturnType[]; + }): MessageOptions; + toObject(): { + message_set_wire_format?: boolean | undefined; + no_standard_descriptor_accessor?: boolean | undefined; + deprecated?: boolean | undefined; + map_entry?: boolean | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MessageOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MessageOptions; + } + class FieldOptions extends pb_1.Message { + constructor(data?: any[] | { + ctype?: FieldOptions.CType; + packed?: boolean; + jstype?: FieldOptions.JSType; + lazy?: boolean; + deprecated?: boolean; + weak?: boolean; + uninterpreted_option: UninterpretedOption[]; + }); + get ctype(): FieldOptions.CType; + set ctype(value: FieldOptions.CType); + get packed(): boolean; + set packed(value: boolean); + get jstype(): FieldOptions.JSType; + set jstype(value: FieldOptions.JSType); + get lazy(): boolean; + set lazy(value: boolean); + get deprecated(): boolean; + set deprecated(value: boolean); + get weak(): boolean; + set weak(value: boolean); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + ctype?: FieldOptions.CType; + packed?: boolean; + jstype?: FieldOptions.JSType; + lazy?: boolean; + deprecated?: boolean; + weak?: boolean; + uninterpreted_option: ReturnType[]; + }): FieldOptions; + toObject(): { + ctype?: FieldOptions.CType | undefined; + packed?: boolean | undefined; + jstype?: FieldOptions.JSType | undefined; + lazy?: boolean | undefined; + deprecated?: boolean | undefined; + weak?: boolean | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): FieldOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): FieldOptions; + } + namespace FieldOptions { + enum CType { + STRING = 0, + CORD = 1, + STRING_PIECE = 2 + } + enum JSType { + JS_NORMAL = 0, + JS_STRING = 1, + JS_NUMBER = 2 + } + } + class OneofOptions extends pb_1.Message { + constructor(data?: any[] | { + uninterpreted_option: UninterpretedOption[]; + }); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + uninterpreted_option: ReturnType[]; + }): OneofOptions; + toObject(): { + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): OneofOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): OneofOptions; + } + class EnumOptions extends pb_1.Message { + constructor(data?: any[] | { + allow_alias?: boolean; + deprecated?: boolean; + uninterpreted_option: UninterpretedOption[]; + }); + get allow_alias(): boolean; + set allow_alias(value: boolean); + get deprecated(): boolean; + set deprecated(value: boolean); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + allow_alias?: boolean; + deprecated?: boolean; + uninterpreted_option: ReturnType[]; + }): EnumOptions; + toObject(): { + allow_alias?: boolean | undefined; + deprecated?: boolean | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EnumOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): EnumOptions; + } + class EnumValueOptions extends pb_1.Message { + constructor(data?: any[] | { + deprecated?: boolean; + uninterpreted_option: UninterpretedOption[]; + }); + get deprecated(): boolean; + set deprecated(value: boolean); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + deprecated?: boolean; + uninterpreted_option: ReturnType[]; + }): EnumValueOptions; + toObject(): { + deprecated?: boolean | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): EnumValueOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): EnumValueOptions; + } + class ServiceOptions extends pb_1.Message { + constructor(data?: any[] | { + deprecated?: boolean; + uninterpreted_option: UninterpretedOption[]; + }); + get deprecated(): boolean; + set deprecated(value: boolean); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + deprecated?: boolean; + uninterpreted_option: ReturnType[]; + }): ServiceOptions; + toObject(): { + deprecated?: boolean | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ServiceOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ServiceOptions; + } + class MethodOptions extends pb_1.Message { + constructor(data?: any[] | { + deprecated?: boolean; + idempotency_level?: MethodOptions.IdempotencyLevel; + uninterpreted_option: UninterpretedOption[]; + }); + get deprecated(): boolean; + set deprecated(value: boolean); + get idempotency_level(): MethodOptions.IdempotencyLevel; + set idempotency_level(value: MethodOptions.IdempotencyLevel); + get uninterpreted_option(): UninterpretedOption[]; + set uninterpreted_option(value: UninterpretedOption[]); + static fromObject(data: { + deprecated?: boolean; + idempotency_level?: MethodOptions.IdempotencyLevel; + uninterpreted_option: ReturnType[]; + }): MethodOptions; + toObject(): { + deprecated?: boolean | undefined; + idempotency_level?: MethodOptions.IdempotencyLevel | undefined; + uninterpreted_option: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MethodOptions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MethodOptions; + } + namespace MethodOptions { + enum IdempotencyLevel { + IDEMPOTENCY_UNKNOWN = 0, + NO_SIDE_EFFECTS = 1, + IDEMPOTENT = 2 + } + } + class UninterpretedOption extends pb_1.Message { + constructor(data?: any[] | { + name: UninterpretedOption.NamePart[]; + identifier_value?: string; + positive_int_value?: number; + negative_int_value?: number; + double_value?: number; + string_value?: Uint8Array; + aggregate_value?: string; + }); + get name(): UninterpretedOption.NamePart[]; + set name(value: UninterpretedOption.NamePart[]); + get identifier_value(): string; + set identifier_value(value: string); + get positive_int_value(): number; + set positive_int_value(value: number); + get negative_int_value(): number; + set negative_int_value(value: number); + get double_value(): number; + set double_value(value: number); + get string_value(): Uint8Array; + set string_value(value: Uint8Array); + get aggregate_value(): string; + set aggregate_value(value: string); + static fromObject(data: { + name: ReturnType[]; + identifier_value?: string; + positive_int_value?: number; + negative_int_value?: number; + double_value?: number; + string_value?: Uint8Array; + aggregate_value?: string; + }): UninterpretedOption; + toObject(): { + name: ReturnType[]; + identifier_value?: string | undefined; + positive_int_value?: number | undefined; + negative_int_value?: number | undefined; + double_value?: number | undefined; + string_value?: Uint8Array | undefined; + aggregate_value?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): UninterpretedOption; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): UninterpretedOption; + } + namespace UninterpretedOption { + class NamePart extends pb_1.Message { + constructor(data?: any[] | { + name_part: string; + is_extension: boolean; + }); + get name_part(): string; + set name_part(value: string); + get is_extension(): boolean; + set is_extension(value: boolean); + static fromObject(data: { + name_part: string; + is_extension: boolean; + }): NamePart; + toObject(): { + name_part: string; + is_extension: boolean; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): NamePart; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): NamePart; + } + } + class SourceCodeInfo extends pb_1.Message { + constructor(data?: any[] | { + location: SourceCodeInfo.Location[]; + }); + get location(): SourceCodeInfo.Location[]; + set location(value: SourceCodeInfo.Location[]); + static fromObject(data: { + location: ReturnType[]; + }): SourceCodeInfo; + toObject(): { + location: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): SourceCodeInfo; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): SourceCodeInfo; + } + namespace SourceCodeInfo { + class Location extends pb_1.Message { + constructor(data?: any[] | { + path: number[]; + span: number[]; + leading_comments?: string; + trailing_comments?: string; + leading_detached_comments: string[]; + }); + get path(): number[]; + set path(value: number[]); + get span(): number[]; + set span(value: number[]); + get leading_comments(): string; + set leading_comments(value: string); + get trailing_comments(): string; + set trailing_comments(value: string); + get leading_detached_comments(): string[]; + set leading_detached_comments(value: string[]); + static fromObject(data: { + path: number[]; + span: number[]; + leading_comments?: string; + trailing_comments?: string; + leading_detached_comments: string[]; + }): Location; + toObject(): { + path: number[]; + span: number[]; + leading_comments?: string | undefined; + trailing_comments?: string | undefined; + leading_detached_comments: string[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Location; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Location; + } + } + class GeneratedCodeInfo extends pb_1.Message { + constructor(data?: any[] | { + annotation: GeneratedCodeInfo.Annotation[]; + }); + get annotation(): GeneratedCodeInfo.Annotation[]; + set annotation(value: GeneratedCodeInfo.Annotation[]); + static fromObject(data: { + annotation: ReturnType[]; + }): GeneratedCodeInfo; + toObject(): { + annotation: ReturnType[]; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GeneratedCodeInfo; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): GeneratedCodeInfo; + } + namespace GeneratedCodeInfo { + class Annotation extends pb_1.Message { + constructor(data?: any[] | { + path: number[]; + source_file?: string; + begin?: number; + end?: number; + }); + get path(): number[]; + set path(value: number[]); + get source_file(): string; + set source_file(value: string); + get begin(): number; + set begin(value: number); + get end(): number; + set end(value: number); + static fromObject(data: { + path: number[]; + source_file?: string; + begin?: number; + end?: number; + }): Annotation; + toObject(): { + path: number[]; + source_file?: string | undefined; + begin?: number | undefined; + end?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Annotation; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Annotation; + } + } +} diff --git a/dist/proto/google/protobuf/descriptor.js b/dist/proto/google/protobuf/descriptor.js new file mode 100644 index 0000000..e065eca --- /dev/null +++ b/dist/proto/google/protobuf/descriptor.js @@ -0,0 +1,3476 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.google = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/protobuf/descriptor.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const pb_1 = __importStar(require("google-protobuf")); +var google; +(function (google) { + var protobuf; + (function (protobuf) { + class FileDescriptorSet extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + this.file = data.file; + } + } + get file() { + return pb_1.Message.getRepeatedWrapperField(this, FileDescriptorProto, 1); + } + set file(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new FileDescriptorSet({ + file: data.file.map(item => FileDescriptorProto.fromObject(item)) + }); + return message; + } + toObject() { + const data = { + file: this.file.map((item) => item.toObject()) + }; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.file !== undefined) + writer.writeRepeatedMessage(1, this.file, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new FileDescriptorSet(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.file, () => pb_1.Message.addToRepeatedWrapperField(message, 1, FileDescriptorProto.deserialize(reader), FileDescriptorProto)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return FileDescriptorSet.deserialize(bytes); + } + } + protobuf.FileDescriptorSet = FileDescriptorSet; + class FileDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3, 10, 11, 4, 5, 6, 7], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("package" in data && data.package != undefined) { + this.package = data.package; + } + this.dependency = data.dependency; + this.public_dependency = data.public_dependency; + this.weak_dependency = data.weak_dependency; + this.message_type = data.message_type; + this.enum_type = data.enum_type; + this.service = data.service; + this.extension = data.extension; + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + if ("source_code_info" in data && data.source_code_info != undefined) { + this.source_code_info = data.source_code_info; + } + if ("syntax" in data && data.syntax != undefined) { + this.syntax = data.syntax; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get package() { + return pb_1.Message.getField(this, 2); + } + set package(value) { + pb_1.Message.setField(this, 2, value); + } + get dependency() { + return pb_1.Message.getField(this, 3); + } + set dependency(value) { + pb_1.Message.setField(this, 3, value); + } + get public_dependency() { + return pb_1.Message.getField(this, 10); + } + set public_dependency(value) { + pb_1.Message.setField(this, 10, value); + } + get weak_dependency() { + return pb_1.Message.getField(this, 11); + } + set weak_dependency(value) { + pb_1.Message.setField(this, 11, value); + } + get message_type() { + return pb_1.Message.getRepeatedWrapperField(this, DescriptorProto, 4); + } + set message_type(value) { + pb_1.Message.setRepeatedWrapperField(this, 4, value); + } + get enum_type() { + return pb_1.Message.getRepeatedWrapperField(this, EnumDescriptorProto, 5); + } + set enum_type(value) { + pb_1.Message.setRepeatedWrapperField(this, 5, value); + } + get service() { + return pb_1.Message.getRepeatedWrapperField(this, ServiceDescriptorProto, 6); + } + set service(value) { + pb_1.Message.setRepeatedWrapperField(this, 6, value); + } + get extension() { + return pb_1.Message.getRepeatedWrapperField(this, FieldDescriptorProto, 7); + } + set extension(value) { + pb_1.Message.setRepeatedWrapperField(this, 7, value); + } + get options() { + return pb_1.Message.getWrapperField(this, FileOptions, 8); + } + set options(value) { + pb_1.Message.setWrapperField(this, 8, value); + } + get source_code_info() { + return pb_1.Message.getWrapperField(this, SourceCodeInfo, 9); + } + set source_code_info(value) { + pb_1.Message.setWrapperField(this, 9, value); + } + get syntax() { + return pb_1.Message.getField(this, 12); + } + set syntax(value) { + pb_1.Message.setField(this, 12, value); + } + static fromObject(data) { + const message = new FileDescriptorProto({ + dependency: data.dependency, + public_dependency: data.public_dependency, + weak_dependency: data.weak_dependency, + message_type: data.message_type.map(item => DescriptorProto.fromObject(item)), + enum_type: data.enum_type.map(item => EnumDescriptorProto.fromObject(item)), + service: data.service.map(item => ServiceDescriptorProto.fromObject(item)), + extension: data.extension.map(item => FieldDescriptorProto.fromObject(item)) + }); + if (data.name != null) { + message.name = data.name; + } + if (data.package != null) { + message.package = data.package; + } + if (data.options != null) { + message.options = FileOptions.fromObject(data.options); + } + if (data.source_code_info != null) { + message.source_code_info = SourceCodeInfo.fromObject(data.source_code_info); + } + if (data.syntax != null) { + message.syntax = data.syntax; + } + return message; + } + toObject() { + const data = { + dependency: this.dependency, + public_dependency: this.public_dependency, + weak_dependency: this.weak_dependency, + message_type: this.message_type.map((item) => item.toObject()), + enum_type: this.enum_type.map((item) => item.toObject()), + service: this.service.map((item) => item.toObject()), + extension: this.extension.map((item) => item.toObject()) + }; + if (this.name != null) { + data.name = this.name; + } + if (this.package != null) { + data.package = this.package; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + if (this.source_code_info != null) { + data.source_code_info = this.source_code_info.toObject(); + } + if (this.syntax != null) { + data.syntax = this.syntax; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (typeof this.package === "string" && this.package.length) + writer.writeString(2, this.package); + if (this.dependency !== undefined) + writer.writeRepeatedString(3, this.dependency); + if (this.public_dependency !== undefined) + writer.writeRepeatedInt32(10, this.public_dependency); + if (this.weak_dependency !== undefined) + writer.writeRepeatedInt32(11, this.weak_dependency); + if (this.message_type !== undefined) + writer.writeRepeatedMessage(4, this.message_type, (item) => item.serialize(writer)); + if (this.enum_type !== undefined) + writer.writeRepeatedMessage(5, this.enum_type, (item) => item.serialize(writer)); + if (this.service !== undefined) + writer.writeRepeatedMessage(6, this.service, (item) => item.serialize(writer)); + if (this.extension !== undefined) + writer.writeRepeatedMessage(7, this.extension, (item) => item.serialize(writer)); + if (this.options !== undefined) + writer.writeMessage(8, this.options, () => this.options.serialize(writer)); + if (this.source_code_info !== undefined) + writer.writeMessage(9, this.source_code_info, () => this.source_code_info.serialize(writer)); + if (typeof this.syntax === "string" && this.syntax.length) + writer.writeString(12, this.syntax); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new FileDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + message.package = reader.readString(); + break; + case 3: + pb_1.Message.addToRepeatedField(message, 3, reader.readString()); + break; + case 10: + pb_1.Message.addToRepeatedField(message, 10, reader.readInt32()); + break; + case 11: + pb_1.Message.addToRepeatedField(message, 11, reader.readInt32()); + break; + case 4: + reader.readMessage(message.message_type, () => pb_1.Message.addToRepeatedWrapperField(message, 4, DescriptorProto.deserialize(reader), DescriptorProto)); + break; + case 5: + reader.readMessage(message.enum_type, () => pb_1.Message.addToRepeatedWrapperField(message, 5, EnumDescriptorProto.deserialize(reader), EnumDescriptorProto)); + break; + case 6: + reader.readMessage(message.service, () => pb_1.Message.addToRepeatedWrapperField(message, 6, ServiceDescriptorProto.deserialize(reader), ServiceDescriptorProto)); + break; + case 7: + reader.readMessage(message.extension, () => pb_1.Message.addToRepeatedWrapperField(message, 7, FieldDescriptorProto.deserialize(reader), FieldDescriptorProto)); + break; + case 8: + reader.readMessage(message.options, () => message.options = FileOptions.deserialize(reader)); + break; + case 9: + reader.readMessage(message.source_code_info, () => message.source_code_info = SourceCodeInfo.deserialize(reader)); + break; + case 12: + message.syntax = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return FileDescriptorProto.deserialize(bytes); + } + } + protobuf.FileDescriptorProto = FileDescriptorProto; + class DescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 6, 3, 4, 5, 8, 9, 10], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + this.field = data.field; + this.extension = data.extension; + this.nested_type = data.nested_type; + this.enum_type = data.enum_type; + this.extension_range = data.extension_range; + this.oneof_decl = data.oneof_decl; + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + this.reserved_range = data.reserved_range; + this.reserved_name = data.reserved_name; + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get field() { + return pb_1.Message.getRepeatedWrapperField(this, FieldDescriptorProto, 2); + } + set field(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + get extension() { + return pb_1.Message.getRepeatedWrapperField(this, FieldDescriptorProto, 6); + } + set extension(value) { + pb_1.Message.setRepeatedWrapperField(this, 6, value); + } + get nested_type() { + return pb_1.Message.getRepeatedWrapperField(this, DescriptorProto, 3); + } + set nested_type(value) { + pb_1.Message.setRepeatedWrapperField(this, 3, value); + } + get enum_type() { + return pb_1.Message.getRepeatedWrapperField(this, EnumDescriptorProto, 4); + } + set enum_type(value) { + pb_1.Message.setRepeatedWrapperField(this, 4, value); + } + get extension_range() { + return pb_1.Message.getRepeatedWrapperField(this, DescriptorProto.ExtensionRange, 5); + } + set extension_range(value) { + pb_1.Message.setRepeatedWrapperField(this, 5, value); + } + get oneof_decl() { + return pb_1.Message.getRepeatedWrapperField(this, OneofDescriptorProto, 8); + } + set oneof_decl(value) { + pb_1.Message.setRepeatedWrapperField(this, 8, value); + } + get options() { + return pb_1.Message.getWrapperField(this, MessageOptions, 7); + } + set options(value) { + pb_1.Message.setWrapperField(this, 7, value); + } + get reserved_range() { + return pb_1.Message.getRepeatedWrapperField(this, DescriptorProto.ReservedRange, 9); + } + set reserved_range(value) { + pb_1.Message.setRepeatedWrapperField(this, 9, value); + } + get reserved_name() { + return pb_1.Message.getField(this, 10); + } + set reserved_name(value) { + pb_1.Message.setField(this, 10, value); + } + static fromObject(data) { + const message = new DescriptorProto({ + field: data.field.map(item => FieldDescriptorProto.fromObject(item)), + extension: data.extension.map(item => FieldDescriptorProto.fromObject(item)), + nested_type: data.nested_type.map(item => DescriptorProto.fromObject(item)), + enum_type: data.enum_type.map(item => EnumDescriptorProto.fromObject(item)), + extension_range: data.extension_range.map(item => DescriptorProto.ExtensionRange.fromObject(item)), + oneof_decl: data.oneof_decl.map(item => OneofDescriptorProto.fromObject(item)), + reserved_range: data.reserved_range.map(item => DescriptorProto.ReservedRange.fromObject(item)), + reserved_name: data.reserved_name + }); + if (data.name != null) { + message.name = data.name; + } + if (data.options != null) { + message.options = MessageOptions.fromObject(data.options); + } + return message; + } + toObject() { + const data = { + field: this.field.map((item) => item.toObject()), + extension: this.extension.map((item) => item.toObject()), + nested_type: this.nested_type.map((item) => item.toObject()), + enum_type: this.enum_type.map((item) => item.toObject()), + extension_range: this.extension_range.map((item) => item.toObject()), + oneof_decl: this.oneof_decl.map((item) => item.toObject()), + reserved_range: this.reserved_range.map((item) => item.toObject()), + reserved_name: this.reserved_name + }; + if (this.name != null) { + data.name = this.name; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.field !== undefined) + writer.writeRepeatedMessage(2, this.field, (item) => item.serialize(writer)); + if (this.extension !== undefined) + writer.writeRepeatedMessage(6, this.extension, (item) => item.serialize(writer)); + if (this.nested_type !== undefined) + writer.writeRepeatedMessage(3, this.nested_type, (item) => item.serialize(writer)); + if (this.enum_type !== undefined) + writer.writeRepeatedMessage(4, this.enum_type, (item) => item.serialize(writer)); + if (this.extension_range !== undefined) + writer.writeRepeatedMessage(5, this.extension_range, (item) => item.serialize(writer)); + if (this.oneof_decl !== undefined) + writer.writeRepeatedMessage(8, this.oneof_decl, (item) => item.serialize(writer)); + if (this.options !== undefined) + writer.writeMessage(7, this.options, () => this.options.serialize(writer)); + if (this.reserved_range !== undefined) + writer.writeRepeatedMessage(9, this.reserved_range, (item) => item.serialize(writer)); + if (this.reserved_name !== undefined) + writer.writeRepeatedString(10, this.reserved_name); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new DescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + reader.readMessage(message.field, () => pb_1.Message.addToRepeatedWrapperField(message, 2, FieldDescriptorProto.deserialize(reader), FieldDescriptorProto)); + break; + case 6: + reader.readMessage(message.extension, () => pb_1.Message.addToRepeatedWrapperField(message, 6, FieldDescriptorProto.deserialize(reader), FieldDescriptorProto)); + break; + case 3: + reader.readMessage(message.nested_type, () => pb_1.Message.addToRepeatedWrapperField(message, 3, DescriptorProto.deserialize(reader), DescriptorProto)); + break; + case 4: + reader.readMessage(message.enum_type, () => pb_1.Message.addToRepeatedWrapperField(message, 4, EnumDescriptorProto.deserialize(reader), EnumDescriptorProto)); + break; + case 5: + reader.readMessage(message.extension_range, () => pb_1.Message.addToRepeatedWrapperField(message, 5, DescriptorProto.ExtensionRange.deserialize(reader), DescriptorProto.ExtensionRange)); + break; + case 8: + reader.readMessage(message.oneof_decl, () => pb_1.Message.addToRepeatedWrapperField(message, 8, OneofDescriptorProto.deserialize(reader), OneofDescriptorProto)); + break; + case 7: + reader.readMessage(message.options, () => message.options = MessageOptions.deserialize(reader)); + break; + case 9: + reader.readMessage(message.reserved_range, () => pb_1.Message.addToRepeatedWrapperField(message, 9, DescriptorProto.ReservedRange.deserialize(reader), DescriptorProto.ReservedRange)); + break; + case 10: + pb_1.Message.addToRepeatedField(message, 10, reader.readString()); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return DescriptorProto.deserialize(bytes); + } + } + protobuf.DescriptorProto = DescriptorProto; + (function (DescriptorProto) { + class ExtensionRange extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("start" in data && data.start != undefined) { + this.start = data.start; + } + if ("end" in data && data.end != undefined) { + this.end = data.end; + } + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + } + } + get start() { + return pb_1.Message.getField(this, 1); + } + set start(value) { + pb_1.Message.setField(this, 1, value); + } + get end() { + return pb_1.Message.getField(this, 2); + } + set end(value) { + pb_1.Message.setField(this, 2, value); + } + get options() { + return pb_1.Message.getWrapperField(this, ExtensionRangeOptions, 3); + } + set options(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new ExtensionRange({}); + if (data.start != null) { + message.start = data.start; + } + if (data.end != null) { + message.end = data.end; + } + if (data.options != null) { + message.options = ExtensionRangeOptions.fromObject(data.options); + } + return message; + } + toObject() { + const data = {}; + if (this.start != null) { + data.start = this.start; + } + if (this.end != null) { + data.end = this.end; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.start !== undefined) + writer.writeInt32(1, this.start); + if (this.end !== undefined) + writer.writeInt32(2, this.end); + if (this.options !== undefined) + writer.writeMessage(3, this.options, () => this.options.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ExtensionRange(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.start = reader.readInt32(); + break; + case 2: + message.end = reader.readInt32(); + break; + case 3: + reader.readMessage(message.options, () => message.options = ExtensionRangeOptions.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ExtensionRange.deserialize(bytes); + } + } + DescriptorProto.ExtensionRange = ExtensionRange; + class ReservedRange extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("start" in data && data.start != undefined) { + this.start = data.start; + } + if ("end" in data && data.end != undefined) { + this.end = data.end; + } + } + } + get start() { + return pb_1.Message.getField(this, 1); + } + set start(value) { + pb_1.Message.setField(this, 1, value); + } + get end() { + return pb_1.Message.getField(this, 2); + } + set end(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new ReservedRange({}); + if (data.start != null) { + message.start = data.start; + } + if (data.end != null) { + message.end = data.end; + } + return message; + } + toObject() { + const data = {}; + if (this.start != null) { + data.start = this.start; + } + if (this.end != null) { + data.end = this.end; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.start !== undefined) + writer.writeInt32(1, this.start); + if (this.end !== undefined) + writer.writeInt32(2, this.end); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ReservedRange(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.start = reader.readInt32(); + break; + case 2: + message.end = reader.readInt32(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ReservedRange.deserialize(bytes); + } + } + DescriptorProto.ReservedRange = ReservedRange; + })(DescriptorProto = protobuf.DescriptorProto || (protobuf.DescriptorProto = {})); + class ExtensionRangeOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + this.uninterpreted_option = data.uninterpreted_option; + } + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new ExtensionRangeOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ExtensionRangeOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ExtensionRangeOptions.deserialize(bytes); + } + } + protobuf.ExtensionRangeOptions = ExtensionRangeOptions; + class FieldDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("number" in data && data.number != undefined) { + this.number = data.number; + } + if ("label" in data && data.label != undefined) { + this.label = data.label; + } + if ("type" in data && data.type != undefined) { + this.type = data.type; + } + if ("type_name" in data && data.type_name != undefined) { + this.type_name = data.type_name; + } + if ("extendee" in data && data.extendee != undefined) { + this.extendee = data.extendee; + } + if ("default_value" in data && data.default_value != undefined) { + this.default_value = data.default_value; + } + if ("oneof_index" in data && data.oneof_index != undefined) { + this.oneof_index = data.oneof_index; + } + if ("json_name" in data && data.json_name != undefined) { + this.json_name = data.json_name; + } + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + if ("proto3_optional" in data && data.proto3_optional != undefined) { + this.proto3_optional = data.proto3_optional; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get number() { + return pb_1.Message.getField(this, 3); + } + set number(value) { + pb_1.Message.setField(this, 3, value); + } + get label() { + return pb_1.Message.getField(this, 4); + } + set label(value) { + pb_1.Message.setField(this, 4, value); + } + get type() { + return pb_1.Message.getField(this, 5); + } + set type(value) { + pb_1.Message.setField(this, 5, value); + } + get type_name() { + return pb_1.Message.getField(this, 6); + } + set type_name(value) { + pb_1.Message.setField(this, 6, value); + } + get extendee() { + return pb_1.Message.getField(this, 2); + } + set extendee(value) { + pb_1.Message.setField(this, 2, value); + } + get default_value() { + return pb_1.Message.getField(this, 7); + } + set default_value(value) { + pb_1.Message.setField(this, 7, value); + } + get oneof_index() { + return pb_1.Message.getField(this, 9); + } + set oneof_index(value) { + pb_1.Message.setField(this, 9, value); + } + get json_name() { + return pb_1.Message.getField(this, 10); + } + set json_name(value) { + pb_1.Message.setField(this, 10, value); + } + get options() { + return pb_1.Message.getWrapperField(this, FieldOptions, 8); + } + set options(value) { + pb_1.Message.setWrapperField(this, 8, value); + } + get proto3_optional() { + return pb_1.Message.getField(this, 17); + } + set proto3_optional(value) { + pb_1.Message.setField(this, 17, value); + } + static fromObject(data) { + const message = new FieldDescriptorProto({}); + if (data.name != null) { + message.name = data.name; + } + if (data.number != null) { + message.number = data.number; + } + if (data.label != null) { + message.label = data.label; + } + if (data.type != null) { + message.type = data.type; + } + if (data.type_name != null) { + message.type_name = data.type_name; + } + if (data.extendee != null) { + message.extendee = data.extendee; + } + if (data.default_value != null) { + message.default_value = data.default_value; + } + if (data.oneof_index != null) { + message.oneof_index = data.oneof_index; + } + if (data.json_name != null) { + message.json_name = data.json_name; + } + if (data.options != null) { + message.options = FieldOptions.fromObject(data.options); + } + if (data.proto3_optional != null) { + message.proto3_optional = data.proto3_optional; + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.number != null) { + data.number = this.number; + } + if (this.label != null) { + data.label = this.label; + } + if (this.type != null) { + data.type = this.type; + } + if (this.type_name != null) { + data.type_name = this.type_name; + } + if (this.extendee != null) { + data.extendee = this.extendee; + } + if (this.default_value != null) { + data.default_value = this.default_value; + } + if (this.oneof_index != null) { + data.oneof_index = this.oneof_index; + } + if (this.json_name != null) { + data.json_name = this.json_name; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + if (this.proto3_optional != null) { + data.proto3_optional = this.proto3_optional; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.number !== undefined) + writer.writeInt32(3, this.number); + if (this.label !== undefined) + writer.writeEnum(4, this.label); + if (this.type !== undefined) + writer.writeEnum(5, this.type); + if (typeof this.type_name === "string" && this.type_name.length) + writer.writeString(6, this.type_name); + if (typeof this.extendee === "string" && this.extendee.length) + writer.writeString(2, this.extendee); + if (typeof this.default_value === "string" && this.default_value.length) + writer.writeString(7, this.default_value); + if (this.oneof_index !== undefined) + writer.writeInt32(9, this.oneof_index); + if (typeof this.json_name === "string" && this.json_name.length) + writer.writeString(10, this.json_name); + if (this.options !== undefined) + writer.writeMessage(8, this.options, () => this.options.serialize(writer)); + if (this.proto3_optional !== undefined) + writer.writeBool(17, this.proto3_optional); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new FieldDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 3: + message.number = reader.readInt32(); + break; + case 4: + message.label = reader.readEnum(); + break; + case 5: + message.type = reader.readEnum(); + break; + case 6: + message.type_name = reader.readString(); + break; + case 2: + message.extendee = reader.readString(); + break; + case 7: + message.default_value = reader.readString(); + break; + case 9: + message.oneof_index = reader.readInt32(); + break; + case 10: + message.json_name = reader.readString(); + break; + case 8: + reader.readMessage(message.options, () => message.options = FieldOptions.deserialize(reader)); + break; + case 17: + message.proto3_optional = reader.readBool(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return FieldDescriptorProto.deserialize(bytes); + } + } + protobuf.FieldDescriptorProto = FieldDescriptorProto; + (function (FieldDescriptorProto) { + let Type; + (function (Type) { + Type[Type["TYPE_DOUBLE"] = 1] = "TYPE_DOUBLE"; + Type[Type["TYPE_FLOAT"] = 2] = "TYPE_FLOAT"; + Type[Type["TYPE_INT64"] = 3] = "TYPE_INT64"; + Type[Type["TYPE_UINT64"] = 4] = "TYPE_UINT64"; + Type[Type["TYPE_INT32"] = 5] = "TYPE_INT32"; + Type[Type["TYPE_FIXED64"] = 6] = "TYPE_FIXED64"; + Type[Type["TYPE_FIXED32"] = 7] = "TYPE_FIXED32"; + Type[Type["TYPE_BOOL"] = 8] = "TYPE_BOOL"; + Type[Type["TYPE_STRING"] = 9] = "TYPE_STRING"; + Type[Type["TYPE_GROUP"] = 10] = "TYPE_GROUP"; + Type[Type["TYPE_MESSAGE"] = 11] = "TYPE_MESSAGE"; + Type[Type["TYPE_BYTES"] = 12] = "TYPE_BYTES"; + Type[Type["TYPE_UINT32"] = 13] = "TYPE_UINT32"; + Type[Type["TYPE_ENUM"] = 14] = "TYPE_ENUM"; + Type[Type["TYPE_SFIXED32"] = 15] = "TYPE_SFIXED32"; + Type[Type["TYPE_SFIXED64"] = 16] = "TYPE_SFIXED64"; + Type[Type["TYPE_SINT32"] = 17] = "TYPE_SINT32"; + Type[Type["TYPE_SINT64"] = 18] = "TYPE_SINT64"; + })(Type = FieldDescriptorProto.Type || (FieldDescriptorProto.Type = {})); + let Label; + (function (Label) { + Label[Label["LABEL_OPTIONAL"] = 1] = "LABEL_OPTIONAL"; + Label[Label["LABEL_REQUIRED"] = 2] = "LABEL_REQUIRED"; + Label[Label["LABEL_REPEATED"] = 3] = "LABEL_REPEATED"; + })(Label = FieldDescriptorProto.Label || (FieldDescriptorProto.Label = {})); + })(FieldDescriptorProto = protobuf.FieldDescriptorProto || (protobuf.FieldDescriptorProto = {})); + class OneofDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get options() { + return pb_1.Message.getWrapperField(this, OneofOptions, 2); + } + set options(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new OneofDescriptorProto({}); + if (data.name != null) { + message.name = data.name; + } + if (data.options != null) { + message.options = OneofOptions.fromObject(data.options); + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.options !== undefined) + writer.writeMessage(2, this.options, () => this.options.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new OneofDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + reader.readMessage(message.options, () => message.options = OneofOptions.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return OneofDescriptorProto.deserialize(bytes); + } + } + protobuf.OneofDescriptorProto = OneofDescriptorProto; + class EnumDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 4, 5], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + this.value = data.value; + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + this.reserved_range = data.reserved_range; + this.reserved_name = data.reserved_name; + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get value() { + return pb_1.Message.getRepeatedWrapperField(this, EnumValueDescriptorProto, 2); + } + set value(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + get options() { + return pb_1.Message.getWrapperField(this, EnumOptions, 3); + } + set options(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + get reserved_range() { + return pb_1.Message.getRepeatedWrapperField(this, EnumDescriptorProto.EnumReservedRange, 4); + } + set reserved_range(value) { + pb_1.Message.setRepeatedWrapperField(this, 4, value); + } + get reserved_name() { + return pb_1.Message.getField(this, 5); + } + set reserved_name(value) { + pb_1.Message.setField(this, 5, value); + } + static fromObject(data) { + const message = new EnumDescriptorProto({ + value: data.value.map(item => EnumValueDescriptorProto.fromObject(item)), + reserved_range: data.reserved_range.map(item => EnumDescriptorProto.EnumReservedRange.fromObject(item)), + reserved_name: data.reserved_name + }); + if (data.name != null) { + message.name = data.name; + } + if (data.options != null) { + message.options = EnumOptions.fromObject(data.options); + } + return message; + } + toObject() { + const data = { + value: this.value.map((item) => item.toObject()), + reserved_range: this.reserved_range.map((item) => item.toObject()), + reserved_name: this.reserved_name + }; + if (this.name != null) { + data.name = this.name; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.value !== undefined) + writer.writeRepeatedMessage(2, this.value, (item) => item.serialize(writer)); + if (this.options !== undefined) + writer.writeMessage(3, this.options, () => this.options.serialize(writer)); + if (this.reserved_range !== undefined) + writer.writeRepeatedMessage(4, this.reserved_range, (item) => item.serialize(writer)); + if (this.reserved_name !== undefined) + writer.writeRepeatedString(5, this.reserved_name); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new EnumDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + reader.readMessage(message.value, () => pb_1.Message.addToRepeatedWrapperField(message, 2, EnumValueDescriptorProto.deserialize(reader), EnumValueDescriptorProto)); + break; + case 3: + reader.readMessage(message.options, () => message.options = EnumOptions.deserialize(reader)); + break; + case 4: + reader.readMessage(message.reserved_range, () => pb_1.Message.addToRepeatedWrapperField(message, 4, EnumDescriptorProto.EnumReservedRange.deserialize(reader), EnumDescriptorProto.EnumReservedRange)); + break; + case 5: + pb_1.Message.addToRepeatedField(message, 5, reader.readString()); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return EnumDescriptorProto.deserialize(bytes); + } + } + protobuf.EnumDescriptorProto = EnumDescriptorProto; + (function (EnumDescriptorProto) { + class EnumReservedRange extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("start" in data && data.start != undefined) { + this.start = data.start; + } + if ("end" in data && data.end != undefined) { + this.end = data.end; + } + } + } + get start() { + return pb_1.Message.getField(this, 1); + } + set start(value) { + pb_1.Message.setField(this, 1, value); + } + get end() { + return pb_1.Message.getField(this, 2); + } + set end(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new EnumReservedRange({}); + if (data.start != null) { + message.start = data.start; + } + if (data.end != null) { + message.end = data.end; + } + return message; + } + toObject() { + const data = {}; + if (this.start != null) { + data.start = this.start; + } + if (this.end != null) { + data.end = this.end; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.start !== undefined) + writer.writeInt32(1, this.start); + if (this.end !== undefined) + writer.writeInt32(2, this.end); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new EnumReservedRange(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.start = reader.readInt32(); + break; + case 2: + message.end = reader.readInt32(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return EnumReservedRange.deserialize(bytes); + } + } + EnumDescriptorProto.EnumReservedRange = EnumReservedRange; + })(EnumDescriptorProto = protobuf.EnumDescriptorProto || (protobuf.EnumDescriptorProto = {})); + class EnumValueDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("number" in data && data.number != undefined) { + this.number = data.number; + } + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get number() { + return pb_1.Message.getField(this, 2); + } + set number(value) { + pb_1.Message.setField(this, 2, value); + } + get options() { + return pb_1.Message.getWrapperField(this, EnumValueOptions, 3); + } + set options(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new EnumValueDescriptorProto({}); + if (data.name != null) { + message.name = data.name; + } + if (data.number != null) { + message.number = data.number; + } + if (data.options != null) { + message.options = EnumValueOptions.fromObject(data.options); + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.number != null) { + data.number = this.number; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.number !== undefined) + writer.writeInt32(2, this.number); + if (this.options !== undefined) + writer.writeMessage(3, this.options, () => this.options.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new EnumValueDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + message.number = reader.readInt32(); + break; + case 3: + reader.readMessage(message.options, () => message.options = EnumValueOptions.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return EnumValueDescriptorProto.deserialize(bytes); + } + } + protobuf.EnumValueDescriptorProto = EnumValueDescriptorProto; + class ServiceDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + this.method = data.method; + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get method() { + return pb_1.Message.getRepeatedWrapperField(this, MethodDescriptorProto, 2); + } + set method(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + get options() { + return pb_1.Message.getWrapperField(this, ServiceOptions, 3); + } + set options(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new ServiceDescriptorProto({ + method: data.method.map(item => MethodDescriptorProto.fromObject(item)) + }); + if (data.name != null) { + message.name = data.name; + } + if (data.options != null) { + message.options = ServiceOptions.fromObject(data.options); + } + return message; + } + toObject() { + const data = { + method: this.method.map((item) => item.toObject()) + }; + if (this.name != null) { + data.name = this.name; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.method !== undefined) + writer.writeRepeatedMessage(2, this.method, (item) => item.serialize(writer)); + if (this.options !== undefined) + writer.writeMessage(3, this.options, () => this.options.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ServiceDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + reader.readMessage(message.method, () => pb_1.Message.addToRepeatedWrapperField(message, 2, MethodDescriptorProto.deserialize(reader), MethodDescriptorProto)); + break; + case 3: + reader.readMessage(message.options, () => message.options = ServiceOptions.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ServiceDescriptorProto.deserialize(bytes); + } + } + protobuf.ServiceDescriptorProto = ServiceDescriptorProto; + class MethodDescriptorProto extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("input_type" in data && data.input_type != undefined) { + this.input_type = data.input_type; + } + if ("output_type" in data && data.output_type != undefined) { + this.output_type = data.output_type; + } + if ("options" in data && data.options != undefined) { + this.options = data.options; + } + if ("client_streaming" in data && data.client_streaming != undefined) { + this.client_streaming = data.client_streaming; + } + if ("server_streaming" in data && data.server_streaming != undefined) { + this.server_streaming = data.server_streaming; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get input_type() { + return pb_1.Message.getField(this, 2); + } + set input_type(value) { + pb_1.Message.setField(this, 2, value); + } + get output_type() { + return pb_1.Message.getField(this, 3); + } + set output_type(value) { + pb_1.Message.setField(this, 3, value); + } + get options() { + return pb_1.Message.getWrapperField(this, MethodOptions, 4); + } + set options(value) { + pb_1.Message.setWrapperField(this, 4, value); + } + get client_streaming() { + return pb_1.Message.getFieldWithDefault(this, 5, false); + } + set client_streaming(value) { + pb_1.Message.setField(this, 5, value); + } + get server_streaming() { + return pb_1.Message.getFieldWithDefault(this, 6, false); + } + set server_streaming(value) { + pb_1.Message.setField(this, 6, value); + } + static fromObject(data) { + const message = new MethodDescriptorProto({}); + if (data.name != null) { + message.name = data.name; + } + if (data.input_type != null) { + message.input_type = data.input_type; + } + if (data.output_type != null) { + message.output_type = data.output_type; + } + if (data.options != null) { + message.options = MethodOptions.fromObject(data.options); + } + if (data.client_streaming != null) { + message.client_streaming = data.client_streaming; + } + if (data.server_streaming != null) { + message.server_streaming = data.server_streaming; + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.input_type != null) { + data.input_type = this.input_type; + } + if (this.output_type != null) { + data.output_type = this.output_type; + } + if (this.options != null) { + data.options = this.options.toObject(); + } + if (this.client_streaming != null) { + data.client_streaming = this.client_streaming; + } + if (this.server_streaming != null) { + data.server_streaming = this.server_streaming; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (typeof this.input_type === "string" && this.input_type.length) + writer.writeString(2, this.input_type); + if (typeof this.output_type === "string" && this.output_type.length) + writer.writeString(3, this.output_type); + if (this.options !== undefined) + writer.writeMessage(4, this.options, () => this.options.serialize(writer)); + if (this.client_streaming !== undefined) + writer.writeBool(5, this.client_streaming); + if (this.server_streaming !== undefined) + writer.writeBool(6, this.server_streaming); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MethodDescriptorProto(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + message.input_type = reader.readString(); + break; + case 3: + message.output_type = reader.readString(); + break; + case 4: + reader.readMessage(message.options, () => message.options = MethodOptions.deserialize(reader)); + break; + case 5: + message.client_streaming = reader.readBool(); + break; + case 6: + message.server_streaming = reader.readBool(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MethodDescriptorProto.deserialize(bytes); + } + } + protobuf.MethodDescriptorProto = MethodDescriptorProto; + class FileOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("java_package" in data && data.java_package != undefined) { + this.java_package = data.java_package; + } + if ("java_outer_classname" in data && data.java_outer_classname != undefined) { + this.java_outer_classname = data.java_outer_classname; + } + if ("java_multiple_files" in data && data.java_multiple_files != undefined) { + this.java_multiple_files = data.java_multiple_files; + } + if ("java_generate_equals_and_hash" in data && data.java_generate_equals_and_hash != undefined) { + this.java_generate_equals_and_hash = data.java_generate_equals_and_hash; + } + if ("java_string_check_utf8" in data && data.java_string_check_utf8 != undefined) { + this.java_string_check_utf8 = data.java_string_check_utf8; + } + if ("optimize_for" in data && data.optimize_for != undefined) { + this.optimize_for = data.optimize_for; + } + if ("go_package" in data && data.go_package != undefined) { + this.go_package = data.go_package; + } + if ("cc_generic_services" in data && data.cc_generic_services != undefined) { + this.cc_generic_services = data.cc_generic_services; + } + if ("java_generic_services" in data && data.java_generic_services != undefined) { + this.java_generic_services = data.java_generic_services; + } + if ("py_generic_services" in data && data.py_generic_services != undefined) { + this.py_generic_services = data.py_generic_services; + } + if ("php_generic_services" in data && data.php_generic_services != undefined) { + this.php_generic_services = data.php_generic_services; + } + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + if ("cc_enable_arenas" in data && data.cc_enable_arenas != undefined) { + this.cc_enable_arenas = data.cc_enable_arenas; + } + if ("objc_class_prefix" in data && data.objc_class_prefix != undefined) { + this.objc_class_prefix = data.objc_class_prefix; + } + if ("csharp_namespace" in data && data.csharp_namespace != undefined) { + this.csharp_namespace = data.csharp_namespace; + } + if ("swift_prefix" in data && data.swift_prefix != undefined) { + this.swift_prefix = data.swift_prefix; + } + if ("php_class_prefix" in data && data.php_class_prefix != undefined) { + this.php_class_prefix = data.php_class_prefix; + } + if ("php_namespace" in data && data.php_namespace != undefined) { + this.php_namespace = data.php_namespace; + } + if ("php_metadata_namespace" in data && data.php_metadata_namespace != undefined) { + this.php_metadata_namespace = data.php_metadata_namespace; + } + if ("ruby_package" in data && data.ruby_package != undefined) { + this.ruby_package = data.ruby_package; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get java_package() { + return pb_1.Message.getField(this, 1); + } + set java_package(value) { + pb_1.Message.setField(this, 1, value); + } + get java_outer_classname() { + return pb_1.Message.getField(this, 8); + } + set java_outer_classname(value) { + pb_1.Message.setField(this, 8, value); + } + get java_multiple_files() { + return pb_1.Message.getFieldWithDefault(this, 10, false); + } + set java_multiple_files(value) { + pb_1.Message.setField(this, 10, value); + } + /** @deprecated*/ + get java_generate_equals_and_hash() { + return pb_1.Message.getField(this, 20); + } + /** @deprecated*/ + set java_generate_equals_and_hash(value) { + pb_1.Message.setField(this, 20, value); + } + get java_string_check_utf8() { + return pb_1.Message.getFieldWithDefault(this, 27, false); + } + set java_string_check_utf8(value) { + pb_1.Message.setField(this, 27, value); + } + get optimize_for() { + return pb_1.Message.getFieldWithDefault(this, 9, FileOptions.OptimizeMode.SPEED); + } + set optimize_for(value) { + pb_1.Message.setField(this, 9, value); + } + get go_package() { + return pb_1.Message.getField(this, 11); + } + set go_package(value) { + pb_1.Message.setField(this, 11, value); + } + get cc_generic_services() { + return pb_1.Message.getFieldWithDefault(this, 16, false); + } + set cc_generic_services(value) { + pb_1.Message.setField(this, 16, value); + } + get java_generic_services() { + return pb_1.Message.getFieldWithDefault(this, 17, false); + } + set java_generic_services(value) { + pb_1.Message.setField(this, 17, value); + } + get py_generic_services() { + return pb_1.Message.getFieldWithDefault(this, 18, false); + } + set py_generic_services(value) { + pb_1.Message.setField(this, 18, value); + } + get php_generic_services() { + return pb_1.Message.getFieldWithDefault(this, 42, false); + } + set php_generic_services(value) { + pb_1.Message.setField(this, 42, value); + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 23, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 23, value); + } + get cc_enable_arenas() { + return pb_1.Message.getFieldWithDefault(this, 31, true); + } + set cc_enable_arenas(value) { + pb_1.Message.setField(this, 31, value); + } + get objc_class_prefix() { + return pb_1.Message.getField(this, 36); + } + set objc_class_prefix(value) { + pb_1.Message.setField(this, 36, value); + } + get csharp_namespace() { + return pb_1.Message.getField(this, 37); + } + set csharp_namespace(value) { + pb_1.Message.setField(this, 37, value); + } + get swift_prefix() { + return pb_1.Message.getField(this, 39); + } + set swift_prefix(value) { + pb_1.Message.setField(this, 39, value); + } + get php_class_prefix() { + return pb_1.Message.getField(this, 40); + } + set php_class_prefix(value) { + pb_1.Message.setField(this, 40, value); + } + get php_namespace() { + return pb_1.Message.getField(this, 41); + } + set php_namespace(value) { + pb_1.Message.setField(this, 41, value); + } + get php_metadata_namespace() { + return pb_1.Message.getField(this, 44); + } + set php_metadata_namespace(value) { + pb_1.Message.setField(this, 44, value); + } + get ruby_package() { + return pb_1.Message.getField(this, 45); + } + set ruby_package(value) { + pb_1.Message.setField(this, 45, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new FileOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.java_package != null) { + message.java_package = data.java_package; + } + if (data.java_outer_classname != null) { + message.java_outer_classname = data.java_outer_classname; + } + if (data.java_multiple_files != null) { + message.java_multiple_files = data.java_multiple_files; + } + if (data.java_generate_equals_and_hash != null) { + message.java_generate_equals_and_hash = data.java_generate_equals_and_hash; + } + if (data.java_string_check_utf8 != null) { + message.java_string_check_utf8 = data.java_string_check_utf8; + } + if (data.optimize_for != null) { + message.optimize_for = data.optimize_for; + } + if (data.go_package != null) { + message.go_package = data.go_package; + } + if (data.cc_generic_services != null) { + message.cc_generic_services = data.cc_generic_services; + } + if (data.java_generic_services != null) { + message.java_generic_services = data.java_generic_services; + } + if (data.py_generic_services != null) { + message.py_generic_services = data.py_generic_services; + } + if (data.php_generic_services != null) { + message.php_generic_services = data.php_generic_services; + } + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + if (data.cc_enable_arenas != null) { + message.cc_enable_arenas = data.cc_enable_arenas; + } + if (data.objc_class_prefix != null) { + message.objc_class_prefix = data.objc_class_prefix; + } + if (data.csharp_namespace != null) { + message.csharp_namespace = data.csharp_namespace; + } + if (data.swift_prefix != null) { + message.swift_prefix = data.swift_prefix; + } + if (data.php_class_prefix != null) { + message.php_class_prefix = data.php_class_prefix; + } + if (data.php_namespace != null) { + message.php_namespace = data.php_namespace; + } + if (data.php_metadata_namespace != null) { + message.php_metadata_namespace = data.php_metadata_namespace; + } + if (data.ruby_package != null) { + message.ruby_package = data.ruby_package; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.java_package != null) { + data.java_package = this.java_package; + } + if (this.java_outer_classname != null) { + data.java_outer_classname = this.java_outer_classname; + } + if (this.java_multiple_files != null) { + data.java_multiple_files = this.java_multiple_files; + } + if (this.java_generate_equals_and_hash != null) { + data.java_generate_equals_and_hash = this.java_generate_equals_and_hash; + } + if (this.java_string_check_utf8 != null) { + data.java_string_check_utf8 = this.java_string_check_utf8; + } + if (this.optimize_for != null) { + data.optimize_for = this.optimize_for; + } + if (this.go_package != null) { + data.go_package = this.go_package; + } + if (this.cc_generic_services != null) { + data.cc_generic_services = this.cc_generic_services; + } + if (this.java_generic_services != null) { + data.java_generic_services = this.java_generic_services; + } + if (this.py_generic_services != null) { + data.py_generic_services = this.py_generic_services; + } + if (this.php_generic_services != null) { + data.php_generic_services = this.php_generic_services; + } + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + if (this.cc_enable_arenas != null) { + data.cc_enable_arenas = this.cc_enable_arenas; + } + if (this.objc_class_prefix != null) { + data.objc_class_prefix = this.objc_class_prefix; + } + if (this.csharp_namespace != null) { + data.csharp_namespace = this.csharp_namespace; + } + if (this.swift_prefix != null) { + data.swift_prefix = this.swift_prefix; + } + if (this.php_class_prefix != null) { + data.php_class_prefix = this.php_class_prefix; + } + if (this.php_namespace != null) { + data.php_namespace = this.php_namespace; + } + if (this.php_metadata_namespace != null) { + data.php_metadata_namespace = this.php_metadata_namespace; + } + if (this.ruby_package != null) { + data.ruby_package = this.ruby_package; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.java_package === "string" && this.java_package.length) + writer.writeString(1, this.java_package); + if (typeof this.java_outer_classname === "string" && this.java_outer_classname.length) + writer.writeString(8, this.java_outer_classname); + if (this.java_multiple_files !== undefined) + writer.writeBool(10, this.java_multiple_files); + if (this.java_generate_equals_and_hash !== undefined) + writer.writeBool(20, this.java_generate_equals_and_hash); + if (this.java_string_check_utf8 !== undefined) + writer.writeBool(27, this.java_string_check_utf8); + if (this.optimize_for !== undefined) + writer.writeEnum(9, this.optimize_for); + if (typeof this.go_package === "string" && this.go_package.length) + writer.writeString(11, this.go_package); + if (this.cc_generic_services !== undefined) + writer.writeBool(16, this.cc_generic_services); + if (this.java_generic_services !== undefined) + writer.writeBool(17, this.java_generic_services); + if (this.py_generic_services !== undefined) + writer.writeBool(18, this.py_generic_services); + if (this.php_generic_services !== undefined) + writer.writeBool(42, this.php_generic_services); + if (this.deprecated !== undefined) + writer.writeBool(23, this.deprecated); + if (this.cc_enable_arenas !== undefined) + writer.writeBool(31, this.cc_enable_arenas); + if (typeof this.objc_class_prefix === "string" && this.objc_class_prefix.length) + writer.writeString(36, this.objc_class_prefix); + if (typeof this.csharp_namespace === "string" && this.csharp_namespace.length) + writer.writeString(37, this.csharp_namespace); + if (typeof this.swift_prefix === "string" && this.swift_prefix.length) + writer.writeString(39, this.swift_prefix); + if (typeof this.php_class_prefix === "string" && this.php_class_prefix.length) + writer.writeString(40, this.php_class_prefix); + if (typeof this.php_namespace === "string" && this.php_namespace.length) + writer.writeString(41, this.php_namespace); + if (typeof this.php_metadata_namespace === "string" && this.php_metadata_namespace.length) + writer.writeString(44, this.php_metadata_namespace); + if (typeof this.ruby_package === "string" && this.ruby_package.length) + writer.writeString(45, this.ruby_package); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new FileOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.java_package = reader.readString(); + break; + case 8: + message.java_outer_classname = reader.readString(); + break; + case 10: + message.java_multiple_files = reader.readBool(); + break; + case 20: + message.java_generate_equals_and_hash = reader.readBool(); + break; + case 27: + message.java_string_check_utf8 = reader.readBool(); + break; + case 9: + message.optimize_for = reader.readEnum(); + break; + case 11: + message.go_package = reader.readString(); + break; + case 16: + message.cc_generic_services = reader.readBool(); + break; + case 17: + message.java_generic_services = reader.readBool(); + break; + case 18: + message.py_generic_services = reader.readBool(); + break; + case 42: + message.php_generic_services = reader.readBool(); + break; + case 23: + message.deprecated = reader.readBool(); + break; + case 31: + message.cc_enable_arenas = reader.readBool(); + break; + case 36: + message.objc_class_prefix = reader.readString(); + break; + case 37: + message.csharp_namespace = reader.readString(); + break; + case 39: + message.swift_prefix = reader.readString(); + break; + case 40: + message.php_class_prefix = reader.readString(); + break; + case 41: + message.php_namespace = reader.readString(); + break; + case 44: + message.php_metadata_namespace = reader.readString(); + break; + case 45: + message.ruby_package = reader.readString(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return FileOptions.deserialize(bytes); + } + } + protobuf.FileOptions = FileOptions; + (function (FileOptions) { + let OptimizeMode; + (function (OptimizeMode) { + OptimizeMode[OptimizeMode["SPEED"] = 1] = "SPEED"; + OptimizeMode[OptimizeMode["CODE_SIZE"] = 2] = "CODE_SIZE"; + OptimizeMode[OptimizeMode["LITE_RUNTIME"] = 3] = "LITE_RUNTIME"; + })(OptimizeMode = FileOptions.OptimizeMode || (FileOptions.OptimizeMode = {})); + })(FileOptions = protobuf.FileOptions || (protobuf.FileOptions = {})); + class MessageOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("message_set_wire_format" in data && data.message_set_wire_format != undefined) { + this.message_set_wire_format = data.message_set_wire_format; + } + if ("no_standard_descriptor_accessor" in data && data.no_standard_descriptor_accessor != undefined) { + this.no_standard_descriptor_accessor = data.no_standard_descriptor_accessor; + } + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + if ("map_entry" in data && data.map_entry != undefined) { + this.map_entry = data.map_entry; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get message_set_wire_format() { + return pb_1.Message.getFieldWithDefault(this, 1, false); + } + set message_set_wire_format(value) { + pb_1.Message.setField(this, 1, value); + } + get no_standard_descriptor_accessor() { + return pb_1.Message.getFieldWithDefault(this, 2, false); + } + set no_standard_descriptor_accessor(value) { + pb_1.Message.setField(this, 2, value); + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 3, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 3, value); + } + get map_entry() { + return pb_1.Message.getField(this, 7); + } + set map_entry(value) { + pb_1.Message.setField(this, 7, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new MessageOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.message_set_wire_format != null) { + message.message_set_wire_format = data.message_set_wire_format; + } + if (data.no_standard_descriptor_accessor != null) { + message.no_standard_descriptor_accessor = data.no_standard_descriptor_accessor; + } + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + if (data.map_entry != null) { + message.map_entry = data.map_entry; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.message_set_wire_format != null) { + data.message_set_wire_format = this.message_set_wire_format; + } + if (this.no_standard_descriptor_accessor != null) { + data.no_standard_descriptor_accessor = this.no_standard_descriptor_accessor; + } + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + if (this.map_entry != null) { + data.map_entry = this.map_entry; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.message_set_wire_format !== undefined) + writer.writeBool(1, this.message_set_wire_format); + if (this.no_standard_descriptor_accessor !== undefined) + writer.writeBool(2, this.no_standard_descriptor_accessor); + if (this.deprecated !== undefined) + writer.writeBool(3, this.deprecated); + if (this.map_entry !== undefined) + writer.writeBool(7, this.map_entry); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MessageOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.message_set_wire_format = reader.readBool(); + break; + case 2: + message.no_standard_descriptor_accessor = reader.readBool(); + break; + case 3: + message.deprecated = reader.readBool(); + break; + case 7: + message.map_entry = reader.readBool(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MessageOptions.deserialize(bytes); + } + } + protobuf.MessageOptions = MessageOptions; + class FieldOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("ctype" in data && data.ctype != undefined) { + this.ctype = data.ctype; + } + if ("packed" in data && data.packed != undefined) { + this.packed = data.packed; + } + if ("jstype" in data && data.jstype != undefined) { + this.jstype = data.jstype; + } + if ("lazy" in data && data.lazy != undefined) { + this.lazy = data.lazy; + } + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + if ("weak" in data && data.weak != undefined) { + this.weak = data.weak; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get ctype() { + return pb_1.Message.getFieldWithDefault(this, 1, FieldOptions.CType.STRING); + } + set ctype(value) { + pb_1.Message.setField(this, 1, value); + } + get packed() { + return pb_1.Message.getField(this, 2); + } + set packed(value) { + pb_1.Message.setField(this, 2, value); + } + get jstype() { + return pb_1.Message.getFieldWithDefault(this, 6, FieldOptions.JSType.JS_NORMAL); + } + set jstype(value) { + pb_1.Message.setField(this, 6, value); + } + get lazy() { + return pb_1.Message.getFieldWithDefault(this, 5, false); + } + set lazy(value) { + pb_1.Message.setField(this, 5, value); + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 3, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 3, value); + } + get weak() { + return pb_1.Message.getFieldWithDefault(this, 10, false); + } + set weak(value) { + pb_1.Message.setField(this, 10, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new FieldOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.ctype != null) { + message.ctype = data.ctype; + } + if (data.packed != null) { + message.packed = data.packed; + } + if (data.jstype != null) { + message.jstype = data.jstype; + } + if (data.lazy != null) { + message.lazy = data.lazy; + } + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + if (data.weak != null) { + message.weak = data.weak; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.ctype != null) { + data.ctype = this.ctype; + } + if (this.packed != null) { + data.packed = this.packed; + } + if (this.jstype != null) { + data.jstype = this.jstype; + } + if (this.lazy != null) { + data.lazy = this.lazy; + } + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + if (this.weak != null) { + data.weak = this.weak; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.ctype !== undefined) + writer.writeEnum(1, this.ctype); + if (this.packed !== undefined) + writer.writeBool(2, this.packed); + if (this.jstype !== undefined) + writer.writeEnum(6, this.jstype); + if (this.lazy !== undefined) + writer.writeBool(5, this.lazy); + if (this.deprecated !== undefined) + writer.writeBool(3, this.deprecated); + if (this.weak !== undefined) + writer.writeBool(10, this.weak); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new FieldOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.ctype = reader.readEnum(); + break; + case 2: + message.packed = reader.readBool(); + break; + case 6: + message.jstype = reader.readEnum(); + break; + case 5: + message.lazy = reader.readBool(); + break; + case 3: + message.deprecated = reader.readBool(); + break; + case 10: + message.weak = reader.readBool(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return FieldOptions.deserialize(bytes); + } + } + protobuf.FieldOptions = FieldOptions; + (function (FieldOptions) { + let CType; + (function (CType) { + CType[CType["STRING"] = 0] = "STRING"; + CType[CType["CORD"] = 1] = "CORD"; + CType[CType["STRING_PIECE"] = 2] = "STRING_PIECE"; + })(CType = FieldOptions.CType || (FieldOptions.CType = {})); + let JSType; + (function (JSType) { + JSType[JSType["JS_NORMAL"] = 0] = "JS_NORMAL"; + JSType[JSType["JS_STRING"] = 1] = "JS_STRING"; + JSType[JSType["JS_NUMBER"] = 2] = "JS_NUMBER"; + })(JSType = FieldOptions.JSType || (FieldOptions.JSType = {})); + })(FieldOptions = protobuf.FieldOptions || (protobuf.FieldOptions = {})); + class OneofOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + this.uninterpreted_option = data.uninterpreted_option; + } + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new OneofOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new OneofOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return OneofOptions.deserialize(bytes); + } + } + protobuf.OneofOptions = OneofOptions; + class EnumOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("allow_alias" in data && data.allow_alias != undefined) { + this.allow_alias = data.allow_alias; + } + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get allow_alias() { + return pb_1.Message.getField(this, 2); + } + set allow_alias(value) { + pb_1.Message.setField(this, 2, value); + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 3, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 3, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new EnumOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.allow_alias != null) { + message.allow_alias = data.allow_alias; + } + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.allow_alias != null) { + data.allow_alias = this.allow_alias; + } + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.allow_alias !== undefined) + writer.writeBool(2, this.allow_alias); + if (this.deprecated !== undefined) + writer.writeBool(3, this.deprecated); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new EnumOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 2: + message.allow_alias = reader.readBool(); + break; + case 3: + message.deprecated = reader.readBool(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return EnumOptions.deserialize(bytes); + } + } + protobuf.EnumOptions = EnumOptions; + class EnumValueOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 1, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 1, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new EnumValueOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.deprecated !== undefined) + writer.writeBool(1, this.deprecated); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new EnumValueOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.deprecated = reader.readBool(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return EnumValueOptions.deserialize(bytes); + } + } + protobuf.EnumValueOptions = EnumValueOptions; + class ServiceOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 33, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 33, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new ServiceOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.deprecated !== undefined) + writer.writeBool(33, this.deprecated); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ServiceOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 33: + message.deprecated = reader.readBool(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ServiceOptions.deserialize(bytes); + } + } + protobuf.ServiceOptions = ServiceOptions; + class MethodOptions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [999], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("deprecated" in data && data.deprecated != undefined) { + this.deprecated = data.deprecated; + } + if ("idempotency_level" in data && data.idempotency_level != undefined) { + this.idempotency_level = data.idempotency_level; + } + this.uninterpreted_option = data.uninterpreted_option; + } + } + get deprecated() { + return pb_1.Message.getFieldWithDefault(this, 33, false); + } + set deprecated(value) { + pb_1.Message.setField(this, 33, value); + } + get idempotency_level() { + return pb_1.Message.getFieldWithDefault(this, 34, MethodOptions.IdempotencyLevel.IDEMPOTENCY_UNKNOWN); + } + set idempotency_level(value) { + pb_1.Message.setField(this, 34, value); + } + get uninterpreted_option() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption, 999); + } + set uninterpreted_option(value) { + pb_1.Message.setRepeatedWrapperField(this, 999, value); + } + static fromObject(data) { + const message = new MethodOptions({ + uninterpreted_option: data.uninterpreted_option.map(item => UninterpretedOption.fromObject(item)) + }); + if (data.deprecated != null) { + message.deprecated = data.deprecated; + } + if (data.idempotency_level != null) { + message.idempotency_level = data.idempotency_level; + } + return message; + } + toObject() { + const data = { + uninterpreted_option: this.uninterpreted_option.map((item) => item.toObject()) + }; + if (this.deprecated != null) { + data.deprecated = this.deprecated; + } + if (this.idempotency_level != null) { + data.idempotency_level = this.idempotency_level; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.deprecated !== undefined) + writer.writeBool(33, this.deprecated); + if (this.idempotency_level !== undefined) + writer.writeEnum(34, this.idempotency_level); + if (this.uninterpreted_option !== undefined) + writer.writeRepeatedMessage(999, this.uninterpreted_option, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MethodOptions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 33: + message.deprecated = reader.readBool(); + break; + case 34: + message.idempotency_level = reader.readEnum(); + break; + case 999: + reader.readMessage(message.uninterpreted_option, () => pb_1.Message.addToRepeatedWrapperField(message, 999, UninterpretedOption.deserialize(reader), UninterpretedOption)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MethodOptions.deserialize(bytes); + } + } + protobuf.MethodOptions = MethodOptions; + (function (MethodOptions) { + let IdempotencyLevel; + (function (IdempotencyLevel) { + IdempotencyLevel[IdempotencyLevel["IDEMPOTENCY_UNKNOWN"] = 0] = "IDEMPOTENCY_UNKNOWN"; + IdempotencyLevel[IdempotencyLevel["NO_SIDE_EFFECTS"] = 1] = "NO_SIDE_EFFECTS"; + IdempotencyLevel[IdempotencyLevel["IDEMPOTENT"] = 2] = "IDEMPOTENT"; + })(IdempotencyLevel = MethodOptions.IdempotencyLevel || (MethodOptions.IdempotencyLevel = {})); + })(MethodOptions = protobuf.MethodOptions || (protobuf.MethodOptions = {})); + class UninterpretedOption extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + this.name = data.name; + if ("identifier_value" in data && data.identifier_value != undefined) { + this.identifier_value = data.identifier_value; + } + if ("positive_int_value" in data && data.positive_int_value != undefined) { + this.positive_int_value = data.positive_int_value; + } + if ("negative_int_value" in data && data.negative_int_value != undefined) { + this.negative_int_value = data.negative_int_value; + } + if ("double_value" in data && data.double_value != undefined) { + this.double_value = data.double_value; + } + if ("string_value" in data && data.string_value != undefined) { + this.string_value = data.string_value; + } + if ("aggregate_value" in data && data.aggregate_value != undefined) { + this.aggregate_value = data.aggregate_value; + } + } + } + get name() { + return pb_1.Message.getRepeatedWrapperField(this, UninterpretedOption.NamePart, 2); + } + set name(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + get identifier_value() { + return pb_1.Message.getField(this, 3); + } + set identifier_value(value) { + pb_1.Message.setField(this, 3, value); + } + get positive_int_value() { + return pb_1.Message.getField(this, 4); + } + set positive_int_value(value) { + pb_1.Message.setField(this, 4, value); + } + get negative_int_value() { + return pb_1.Message.getField(this, 5); + } + set negative_int_value(value) { + pb_1.Message.setField(this, 5, value); + } + get double_value() { + return pb_1.Message.getField(this, 6); + } + set double_value(value) { + pb_1.Message.setField(this, 6, value); + } + get string_value() { + return pb_1.Message.getField(this, 7); + } + set string_value(value) { + pb_1.Message.setField(this, 7, value); + } + get aggregate_value() { + return pb_1.Message.getField(this, 8); + } + set aggregate_value(value) { + pb_1.Message.setField(this, 8, value); + } + static fromObject(data) { + const message = new UninterpretedOption({ + name: data.name.map(item => UninterpretedOption.NamePart.fromObject(item)) + }); + if (data.identifier_value != null) { + message.identifier_value = data.identifier_value; + } + if (data.positive_int_value != null) { + message.positive_int_value = data.positive_int_value; + } + if (data.negative_int_value != null) { + message.negative_int_value = data.negative_int_value; + } + if (data.double_value != null) { + message.double_value = data.double_value; + } + if (data.string_value != null) { + message.string_value = data.string_value; + } + if (data.aggregate_value != null) { + message.aggregate_value = data.aggregate_value; + } + return message; + } + toObject() { + const data = { + name: this.name.map((item) => item.toObject()) + }; + if (this.identifier_value != null) { + data.identifier_value = this.identifier_value; + } + if (this.positive_int_value != null) { + data.positive_int_value = this.positive_int_value; + } + if (this.negative_int_value != null) { + data.negative_int_value = this.negative_int_value; + } + if (this.double_value != null) { + data.double_value = this.double_value; + } + if (this.string_value != null) { + data.string_value = this.string_value; + } + if (this.aggregate_value != null) { + data.aggregate_value = this.aggregate_value; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.name !== undefined) + writer.writeRepeatedMessage(2, this.name, (item) => item.serialize(writer)); + if (typeof this.identifier_value === "string" && this.identifier_value.length) + writer.writeString(3, this.identifier_value); + if (this.positive_int_value !== undefined) + writer.writeUint64(4, this.positive_int_value); + if (this.negative_int_value !== undefined) + writer.writeInt64(5, this.negative_int_value); + if (this.double_value !== undefined) + writer.writeDouble(6, this.double_value); + if (this.string_value !== undefined) + writer.writeBytes(7, this.string_value); + if (typeof this.aggregate_value === "string" && this.aggregate_value.length) + writer.writeString(8, this.aggregate_value); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new UninterpretedOption(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 2: + reader.readMessage(message.name, () => pb_1.Message.addToRepeatedWrapperField(message, 2, UninterpretedOption.NamePart.deserialize(reader), UninterpretedOption.NamePart)); + break; + case 3: + message.identifier_value = reader.readString(); + break; + case 4: + message.positive_int_value = reader.readUint64(); + break; + case 5: + message.negative_int_value = reader.readInt64(); + break; + case 6: + message.double_value = reader.readDouble(); + break; + case 7: + message.string_value = reader.readBytes(); + break; + case 8: + message.aggregate_value = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return UninterpretedOption.deserialize(bytes); + } + } + protobuf.UninterpretedOption = UninterpretedOption; + (function (UninterpretedOption) { + class NamePart extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + this.name_part = data.name_part; + this.is_extension = data.is_extension; + } + } + get name_part() { + return pb_1.Message.getField(this, 1); + } + set name_part(value) { + pb_1.Message.setField(this, 1, value); + } + get is_extension() { + return pb_1.Message.getField(this, 2); + } + set is_extension(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new NamePart({ + name_part: data.name_part, + is_extension: data.is_extension + }); + return message; + } + toObject() { + const data = { + name_part: this.name_part, + is_extension: this.is_extension + }; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name_part === "string" && this.name_part.length) + writer.writeString(1, this.name_part); + if (this.is_extension !== undefined) + writer.writeBool(2, this.is_extension); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new NamePart(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name_part = reader.readString(); + break; + case 2: + message.is_extension = reader.readBool(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return NamePart.deserialize(bytes); + } + } + UninterpretedOption.NamePart = NamePart; + })(UninterpretedOption = protobuf.UninterpretedOption || (protobuf.UninterpretedOption = {})); + class SourceCodeInfo extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + this.location = data.location; + } + } + get location() { + return pb_1.Message.getRepeatedWrapperField(this, SourceCodeInfo.Location, 1); + } + set location(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new SourceCodeInfo({ + location: data.location.map(item => SourceCodeInfo.Location.fromObject(item)) + }); + return message; + } + toObject() { + const data = { + location: this.location.map((item) => item.toObject()) + }; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.location !== undefined) + writer.writeRepeatedMessage(1, this.location, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new SourceCodeInfo(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.location, () => pb_1.Message.addToRepeatedWrapperField(message, 1, SourceCodeInfo.Location.deserialize(reader), SourceCodeInfo.Location)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return SourceCodeInfo.deserialize(bytes); + } + } + protobuf.SourceCodeInfo = SourceCodeInfo; + (function (SourceCodeInfo) { + class Location extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1, 2, 6], []); + if (!Array.isArray(data) && typeof data == "object") { + this.path = data.path; + this.span = data.span; + if ("leading_comments" in data && data.leading_comments != undefined) { + this.leading_comments = data.leading_comments; + } + if ("trailing_comments" in data && data.trailing_comments != undefined) { + this.trailing_comments = data.trailing_comments; + } + this.leading_detached_comments = data.leading_detached_comments; + } + } + get path() { + return pb_1.Message.getField(this, 1); + } + set path(value) { + pb_1.Message.setField(this, 1, value); + } + get span() { + return pb_1.Message.getField(this, 2); + } + set span(value) { + pb_1.Message.setField(this, 2, value); + } + get leading_comments() { + return pb_1.Message.getField(this, 3); + } + set leading_comments(value) { + pb_1.Message.setField(this, 3, value); + } + get trailing_comments() { + return pb_1.Message.getField(this, 4); + } + set trailing_comments(value) { + pb_1.Message.setField(this, 4, value); + } + get leading_detached_comments() { + return pb_1.Message.getField(this, 6); + } + set leading_detached_comments(value) { + pb_1.Message.setField(this, 6, value); + } + static fromObject(data) { + const message = new Location({ + path: data.path, + span: data.span, + leading_detached_comments: data.leading_detached_comments + }); + if (data.leading_comments != null) { + message.leading_comments = data.leading_comments; + } + if (data.trailing_comments != null) { + message.trailing_comments = data.trailing_comments; + } + return message; + } + toObject() { + const data = { + path: this.path, + span: this.span, + leading_detached_comments: this.leading_detached_comments + }; + if (this.leading_comments != null) { + data.leading_comments = this.leading_comments; + } + if (this.trailing_comments != null) { + data.trailing_comments = this.trailing_comments; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.path !== undefined) + writer.writePackedInt32(1, this.path); + if (this.span !== undefined) + writer.writePackedInt32(2, this.span); + if (typeof this.leading_comments === "string" && this.leading_comments.length) + writer.writeString(3, this.leading_comments); + if (typeof this.trailing_comments === "string" && this.trailing_comments.length) + writer.writeString(4, this.trailing_comments); + if (this.leading_detached_comments !== undefined) + writer.writeRepeatedString(6, this.leading_detached_comments); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Location(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.path = reader.readPackedInt32(); + break; + case 2: + message.span = reader.readPackedInt32(); + break; + case 3: + message.leading_comments = reader.readString(); + break; + case 4: + message.trailing_comments = reader.readString(); + break; + case 6: + pb_1.Message.addToRepeatedField(message, 6, reader.readString()); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Location.deserialize(bytes); + } + } + SourceCodeInfo.Location = Location; + })(SourceCodeInfo = protobuf.SourceCodeInfo || (protobuf.SourceCodeInfo = {})); + class GeneratedCodeInfo extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + this.annotation = data.annotation; + } + } + get annotation() { + return pb_1.Message.getRepeatedWrapperField(this, GeneratedCodeInfo.Annotation, 1); + } + set annotation(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new GeneratedCodeInfo({ + annotation: data.annotation.map(item => GeneratedCodeInfo.Annotation.fromObject(item)) + }); + return message; + } + toObject() { + const data = { + annotation: this.annotation.map((item) => item.toObject()) + }; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.annotation !== undefined) + writer.writeRepeatedMessage(1, this.annotation, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new GeneratedCodeInfo(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.annotation, () => pb_1.Message.addToRepeatedWrapperField(message, 1, GeneratedCodeInfo.Annotation.deserialize(reader), GeneratedCodeInfo.Annotation)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return GeneratedCodeInfo.deserialize(bytes); + } + } + protobuf.GeneratedCodeInfo = GeneratedCodeInfo; + (function (GeneratedCodeInfo) { + class Annotation extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + this.path = data.path; + if ("source_file" in data && data.source_file != undefined) { + this.source_file = data.source_file; + } + if ("begin" in data && data.begin != undefined) { + this.begin = data.begin; + } + if ("end" in data && data.end != undefined) { + this.end = data.end; + } + } + } + get path() { + return pb_1.Message.getField(this, 1); + } + set path(value) { + pb_1.Message.setField(this, 1, value); + } + get source_file() { + return pb_1.Message.getField(this, 2); + } + set source_file(value) { + pb_1.Message.setField(this, 2, value); + } + get begin() { + return pb_1.Message.getField(this, 3); + } + set begin(value) { + pb_1.Message.setField(this, 3, value); + } + get end() { + return pb_1.Message.getField(this, 4); + } + set end(value) { + pb_1.Message.setField(this, 4, value); + } + static fromObject(data) { + const message = new Annotation({ + path: data.path + }); + if (data.source_file != null) { + message.source_file = data.source_file; + } + if (data.begin != null) { + message.begin = data.begin; + } + if (data.end != null) { + message.end = data.end; + } + return message; + } + toObject() { + const data = { + path: this.path + }; + if (this.source_file != null) { + data.source_file = this.source_file; + } + if (this.begin != null) { + data.begin = this.begin; + } + if (this.end != null) { + data.end = this.end; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.path !== undefined) + writer.writePackedInt32(1, this.path); + if (typeof this.source_file === "string" && this.source_file.length) + writer.writeString(2, this.source_file); + if (this.begin !== undefined) + writer.writeInt32(3, this.begin); + if (this.end !== undefined) + writer.writeInt32(4, this.end); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Annotation(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.path = reader.readPackedInt32(); + break; + case 2: + message.source_file = reader.readString(); + break; + case 3: + message.begin = reader.readInt32(); + break; + case 4: + message.end = reader.readInt32(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Annotation.deserialize(bytes); + } + } + GeneratedCodeInfo.Annotation = Annotation; + })(GeneratedCodeInfo = protobuf.GeneratedCodeInfo || (protobuf.GeneratedCodeInfo = {})); + })(protobuf = google.protobuf || (google.protobuf = {})); +})(google = exports.google || (exports.google = {})); diff --git a/dist/proto/google/protobuf/duration.d.ts b/dist/proto/google/protobuf/duration.d.ts new file mode 100644 index 0000000..18b3d49 --- /dev/null +++ b/dist/proto/google/protobuf/duration.d.ts @@ -0,0 +1,31 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/protobuf/duration.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as pb_1 from "google-protobuf"; +export declare namespace google.protobuf { + class Duration extends pb_1.Message { + constructor(data?: any[] | { + seconds?: number; + nanos?: number; + }); + get seconds(): number; + set seconds(value: number); + get nanos(): number; + set nanos(value: number); + static fromObject(data: { + seconds?: number; + nanos?: number; + }): Duration; + toObject(): { + seconds?: number | undefined; + nanos?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Duration; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Duration; + } +} diff --git a/dist/proto/google/protobuf/duration.js b/dist/proto/google/protobuf/duration.js new file mode 100644 index 0000000..dd1093d --- /dev/null +++ b/dist/proto/google/protobuf/duration.js @@ -0,0 +1,119 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.google = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/protobuf/duration.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const pb_1 = __importStar(require("google-protobuf")); +var google; +(function (google) { + var protobuf; + (function (protobuf) { + class Duration extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("seconds" in data && data.seconds != undefined) { + this.seconds = data.seconds; + } + if ("nanos" in data && data.nanos != undefined) { + this.nanos = data.nanos; + } + } + } + get seconds() { + return pb_1.Message.getField(this, 1); + } + set seconds(value) { + pb_1.Message.setField(this, 1, value); + } + get nanos() { + return pb_1.Message.getField(this, 2); + } + set nanos(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new Duration({}); + if (data.seconds != null) { + message.seconds = data.seconds; + } + if (data.nanos != null) { + message.nanos = data.nanos; + } + return message; + } + toObject() { + const data = {}; + if (this.seconds != null) { + data.seconds = this.seconds; + } + if (this.nanos != null) { + data.nanos = this.nanos; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.seconds !== undefined) + writer.writeInt64(1, this.seconds); + if (this.nanos !== undefined) + writer.writeInt32(2, this.nanos); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Duration(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.seconds = reader.readInt64(); + break; + case 2: + message.nanos = reader.readInt32(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Duration.deserialize(bytes); + } + } + protobuf.Duration = Duration; + })(protobuf = google.protobuf || (google.protobuf = {})); +})(google = exports.google || (exports.google = {})); diff --git a/dist/proto/google/protobuf/timestamp.d.ts b/dist/proto/google/protobuf/timestamp.d.ts new file mode 100644 index 0000000..7b776bd --- /dev/null +++ b/dist/proto/google/protobuf/timestamp.d.ts @@ -0,0 +1,31 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/protobuf/timestamp.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as pb_1 from "google-protobuf"; +export declare namespace google.protobuf { + class Timestamp extends pb_1.Message { + constructor(data?: any[] | { + seconds?: number; + nanos?: number; + }); + get seconds(): number; + set seconds(value: number); + get nanos(): number; + set nanos(value: number); + static fromObject(data: { + seconds?: number; + nanos?: number; + }): Timestamp; + toObject(): { + seconds?: number | undefined; + nanos?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Timestamp; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Timestamp; + } +} diff --git a/dist/proto/google/protobuf/timestamp.js b/dist/proto/google/protobuf/timestamp.js new file mode 100644 index 0000000..d41afdd --- /dev/null +++ b/dist/proto/google/protobuf/timestamp.js @@ -0,0 +1,119 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.google = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: google/protobuf/timestamp.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const pb_1 = __importStar(require("google-protobuf")); +var google; +(function (google) { + var protobuf; + (function (protobuf) { + class Timestamp extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("seconds" in data && data.seconds != undefined) { + this.seconds = data.seconds; + } + if ("nanos" in data && data.nanos != undefined) { + this.nanos = data.nanos; + } + } + } + get seconds() { + return pb_1.Message.getField(this, 1); + } + set seconds(value) { + pb_1.Message.setField(this, 1, value); + } + get nanos() { + return pb_1.Message.getField(this, 2); + } + set nanos(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new Timestamp({}); + if (data.seconds != null) { + message.seconds = data.seconds; + } + if (data.nanos != null) { + message.nanos = data.nanos; + } + return message; + } + toObject() { + const data = {}; + if (this.seconds != null) { + data.seconds = this.seconds; + } + if (this.nanos != null) { + data.nanos = this.nanos; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.seconds !== undefined) + writer.writeInt64(1, this.seconds); + if (this.nanos !== undefined) + writer.writeInt32(2, this.nanos); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Timestamp(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.seconds = reader.readInt64(); + break; + case 2: + message.nanos = reader.readInt32(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Timestamp.deserialize(bytes); + } + } + protobuf.Timestamp = Timestamp; + })(protobuf = google.protobuf || (google.protobuf = {})); +})(google = exports.google || (exports.google = {})); diff --git a/dist/proto/vulcanize/auction/v1beta1/genesis.d.ts b/dist/proto/vulcanize/auction/v1beta1/genesis.d.ts new file mode 100644 index 0000000..2960587 --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/genesis.d.ts @@ -0,0 +1,85 @@ +import * as dependency_2 from "./types"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.auction.v1beta1 { + class GenesisState extends pb_1.Message { + constructor(data?: any[] | { + params?: dependency_2.vulcanize.auction.v1beta1.Params; + auctions?: dependency_2.vulcanize.auction.v1beta1.Auction[]; + }); + get params(): dependency_2.vulcanize.auction.v1beta1.Params; + set params(value: dependency_2.vulcanize.auction.v1beta1.Params); + get auctions(): dependency_2.vulcanize.auction.v1beta1.Auction[]; + set auctions(value: dependency_2.vulcanize.auction.v1beta1.Auction[]); + static fromObject(data: { + params?: ReturnType; + auctions?: ReturnType[]; + }): GenesisState; + toObject(): { + params?: { + commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + auctions?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GenesisState; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): GenesisState; + } +} diff --git a/dist/proto/vulcanize/auction/v1beta1/genesis.js b/dist/proto/vulcanize/auction/v1beta1/genesis.js new file mode 100644 index 0000000..a05453e --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/genesis.js @@ -0,0 +1,116 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./types")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var auction; + (function (auction) { + var v1beta1; + (function (v1beta1) { + class GenesisState extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("params" in data && data.params != undefined) { + this.params = data.params; + } + if ("auctions" in data && data.auctions != undefined) { + this.auctions = data.auctions; + } + } + } + get params() { + return pb_1.Message.getWrapperField(this, dependency_2.vulcanize.auction.v1beta1.Params, 1); + } + set params(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get auctions() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.auction.v1beta1.Auction, 2); + } + set auctions(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new GenesisState({}); + if (data.params != null) { + message.params = dependency_2.vulcanize.auction.v1beta1.Params.fromObject(data.params); + } + if (data.auctions != null) { + message.auctions = data.auctions.map(item => dependency_2.vulcanize.auction.v1beta1.Auction.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.params != null) { + data.params = this.params.toObject(); + } + if (this.auctions != null) { + data.auctions = this.auctions.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.params !== undefined) + writer.writeMessage(1, this.params, () => this.params.serialize(writer)); + if (this.auctions !== undefined) + writer.writeRepeatedMessage(2, this.auctions, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new GenesisState(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.params, () => message.params = dependency_2.vulcanize.auction.v1beta1.Params.deserialize(reader)); + break; + case 2: + reader.readMessage(message.auctions, () => pb_1.Message.addToRepeatedWrapperField(message, 2, dependency_2.vulcanize.auction.v1beta1.Auction.deserialize(reader), dependency_2.vulcanize.auction.v1beta1.Auction)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return GenesisState.deserialize(bytes); + } + } + v1beta1.GenesisState = GenesisState; + })(v1beta1 = auction.v1beta1 || (auction.v1beta1 = {})); + })(auction = vulcanize.auction || (vulcanize.auction = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/auction/v1beta1/query.d.ts b/dist/proto/vulcanize/auction/v1beta1/query.d.ts new file mode 100644 index 0000000..a3c503a --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/query.d.ts @@ -0,0 +1,528 @@ +import * as dependency_3 from "./../../../cosmos/base/query/v1beta1/pagination"; +import * as dependency_4 from "./../../../cosmos/base/v1beta1/coin"; +import * as dependency_5 from "./types"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.auction.v1beta1 { + class AuctionsRequest extends pb_1.Message { + constructor(data?: any[] | { + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + pagination?: ReturnType; + }): AuctionsRequest; + toObject(): { + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionsRequest; + } + class AuctionsResponse extends pb_1.Message { + constructor(data?: any[] | { + auctions?: dependency_5.vulcanize.auction.v1beta1.Auctions; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get auctions(): dependency_5.vulcanize.auction.v1beta1.Auctions; + set auctions(value: dependency_5.vulcanize.auction.v1beta1.Auctions); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + auctions?: ReturnType; + pagination?: ReturnType; + }): AuctionsResponse; + toObject(): { + auctions?: { + auctions?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }[] | undefined; + } | undefined; + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionsResponse; + } + class AuctionRequest extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + }); + get id(): string; + set id(value: string); + static fromObject(data: { + id?: string; + }): AuctionRequest; + toObject(): { + id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionRequest; + } + class AuctionResponse extends pb_1.Message { + constructor(data?: any[] | { + auction?: dependency_5.vulcanize.auction.v1beta1.Auction; + }); + get auction(): dependency_5.vulcanize.auction.v1beta1.Auction; + set auction(value: dependency_5.vulcanize.auction.v1beta1.Auction); + static fromObject(data: { + auction?: ReturnType; + }): AuctionResponse; + toObject(): { + auction?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionResponse; + } + class BidRequest extends pb_1.Message { + constructor(data?: any[] | { + auction_id?: string; + bidder?: string; + }); + get auction_id(): string; + set auction_id(value: string); + get bidder(): string; + set bidder(value: string); + static fromObject(data: { + auction_id?: string; + bidder?: string; + }): BidRequest; + toObject(): { + auction_id?: string | undefined; + bidder?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BidRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BidRequest; + } + class BidResponse extends pb_1.Message { + constructor(data?: any[] | { + bid?: dependency_5.vulcanize.auction.v1beta1.Bid; + }); + get bid(): dependency_5.vulcanize.auction.v1beta1.Bid; + set bid(value: dependency_5.vulcanize.auction.v1beta1.Bid); + static fromObject(data: { + bid?: ReturnType; + }): BidResponse; + toObject(): { + bid?: { + auction_id?: string | undefined; + bidder_address?: string | undefined; + status?: string | undefined; + commit_hash?: string | undefined; + commit_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + bid_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BidResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BidResponse; + } + class BidsRequest extends pb_1.Message { + constructor(data?: any[] | { + auction_id?: string; + }); + get auction_id(): string; + set auction_id(value: string); + static fromObject(data: { + auction_id?: string; + }): BidsRequest; + toObject(): { + auction_id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BidsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BidsRequest; + } + class BidsResponse extends pb_1.Message { + constructor(data?: any[] | { + bids?: dependency_5.vulcanize.auction.v1beta1.Bid[]; + }); + get bids(): dependency_5.vulcanize.auction.v1beta1.Bid[]; + set bids(value: dependency_5.vulcanize.auction.v1beta1.Bid[]); + static fromObject(data: { + bids?: ReturnType[]; + }): BidsResponse; + toObject(): { + bids?: { + auction_id?: string | undefined; + bidder_address?: string | undefined; + status?: string | undefined; + commit_hash?: string | undefined; + commit_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + bid_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BidsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BidsResponse; + } + class AuctionsByBidderRequest extends pb_1.Message { + constructor(data?: any[] | { + bidder_address?: string; + }); + get bidder_address(): string; + set bidder_address(value: string); + static fromObject(data: { + bidder_address?: string; + }): AuctionsByBidderRequest; + toObject(): { + bidder_address?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionsByBidderRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionsByBidderRequest; + } + class AuctionsByBidderResponse extends pb_1.Message { + constructor(data?: any[] | { + auctions?: dependency_5.vulcanize.auction.v1beta1.Auctions; + }); + get auctions(): dependency_5.vulcanize.auction.v1beta1.Auctions; + set auctions(value: dependency_5.vulcanize.auction.v1beta1.Auctions); + static fromObject(data: { + auctions?: ReturnType; + }): AuctionsByBidderResponse; + toObject(): { + auctions?: { + auctions?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionsByBidderResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionsByBidderResponse; + } + class AuctionsByOwnerRequest extends pb_1.Message { + constructor(data?: any[] | { + owner_address?: string; + }); + get owner_address(): string; + set owner_address(value: string); + static fromObject(data: { + owner_address?: string; + }): AuctionsByOwnerRequest; + toObject(): { + owner_address?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionsByOwnerRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionsByOwnerRequest; + } + class AuctionsByOwnerResponse extends pb_1.Message { + constructor(data?: any[] | { + auctions?: dependency_5.vulcanize.auction.v1beta1.Auctions; + }); + get auctions(): dependency_5.vulcanize.auction.v1beta1.Auctions; + set auctions(value: dependency_5.vulcanize.auction.v1beta1.Auctions); + static fromObject(data: { + auctions?: ReturnType; + }): AuctionsByOwnerResponse; + toObject(): { + auctions?: { + auctions?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionsByOwnerResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionsByOwnerResponse; + } + class QueryParamsRequest extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): QueryParamsRequest; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryParamsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryParamsRequest; + } + class QueryParamsResponse extends pb_1.Message { + constructor(data?: any[] | { + params?: dependency_5.vulcanize.auction.v1beta1.Params; + }); + get params(): dependency_5.vulcanize.auction.v1beta1.Params; + set params(value: dependency_5.vulcanize.auction.v1beta1.Params); + static fromObject(data: { + params?: ReturnType; + }): QueryParamsResponse; + toObject(): { + params?: { + commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryParamsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryParamsResponse; + } + class BalanceRequest extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): BalanceRequest; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BalanceRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BalanceRequest; + } + class BalanceResponse extends pb_1.Message { + constructor(data?: any[] | { + balance?: dependency_4.cosmos.base.v1beta1.Coin[]; + }); + get balance(): dependency_4.cosmos.base.v1beta1.Coin[]; + set balance(value: dependency_4.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + balance?: ReturnType[]; + }): BalanceResponse; + toObject(): { + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BalanceResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BalanceResponse; + } +} diff --git a/dist/proto/vulcanize/auction/v1beta1/query.js b/dist/proto/vulcanize/auction/v1beta1/query.js new file mode 100644 index 0000000..21c3760 --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/query.js @@ -0,0 +1,981 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_3 = __importStar(require("./../../../cosmos/base/query/v1beta1/pagination")); +const dependency_4 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const dependency_5 = __importStar(require("./types")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var auction; + (function (auction) { + var v1beta1; + (function (v1beta1) { + class AuctionsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 1); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionsRequest({}); + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.pagination !== undefined) + writer.writeMessage(1, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionsRequest.deserialize(bytes); + } + } + v1beta1.AuctionsRequest = AuctionsRequest; + class AuctionsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auctions" in data && data.auctions != undefined) { + this.auctions = data.auctions; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get auctions() { + return pb_1.Message.getWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Auctions, 1); + } + set auctions(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new AuctionsResponse({}); + if (data.auctions != null) { + message.auctions = dependency_5.vulcanize.auction.v1beta1.Auctions.fromObject(data.auctions); + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.auctions != null) { + data.auctions = this.auctions.toObject(); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auctions !== undefined) + writer.writeMessage(1, this.auctions, () => this.auctions.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auctions, () => message.auctions = dependency_5.vulcanize.auction.v1beta1.Auctions.deserialize(reader)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionsResponse.deserialize(bytes); + } + } + v1beta1.AuctionsResponse = AuctionsResponse; + class AuctionRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionRequest({}); + if (data.id != null) { + message.id = data.id; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionRequest.deserialize(bytes); + } + } + v1beta1.AuctionRequest = AuctionRequest; + class AuctionResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction" in data && data.auction != undefined) { + this.auction = data.auction; + } + } + } + get auction() { + return pb_1.Message.getWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Auction, 1); + } + set auction(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionResponse({}); + if (data.auction != null) { + message.auction = dependency_5.vulcanize.auction.v1beta1.Auction.fromObject(data.auction); + } + return message; + } + toObject() { + const data = {}; + if (this.auction != null) { + data.auction = this.auction.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auction !== undefined) + writer.writeMessage(1, this.auction, () => this.auction.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auction, () => message.auction = dependency_5.vulcanize.auction.v1beta1.Auction.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionResponse.deserialize(bytes); + } + } + v1beta1.AuctionResponse = AuctionResponse; + class BidRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + if ("bidder" in data && data.bidder != undefined) { + this.bidder = data.bidder; + } + } + } + get auction_id() { + return pb_1.Message.getField(this, 1); + } + set auction_id(value) { + pb_1.Message.setField(this, 1, value); + } + get bidder() { + return pb_1.Message.getField(this, 2); + } + set bidder(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new BidRequest({}); + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + if (data.bidder != null) { + message.bidder = data.bidder; + } + return message; + } + toObject() { + const data = {}; + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + if (this.bidder != null) { + data.bidder = this.bidder; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(1, this.auction_id); + if (typeof this.bidder === "string" && this.bidder.length) + writer.writeString(2, this.bidder); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BidRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.auction_id = reader.readString(); + break; + case 2: + message.bidder = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BidRequest.deserialize(bytes); + } + } + v1beta1.BidRequest = BidRequest; + class BidResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bid" in data && data.bid != undefined) { + this.bid = data.bid; + } + } + } + get bid() { + return pb_1.Message.getWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Bid, 1); + } + set bid(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new BidResponse({}); + if (data.bid != null) { + message.bid = dependency_5.vulcanize.auction.v1beta1.Bid.fromObject(data.bid); + } + return message; + } + toObject() { + const data = {}; + if (this.bid != null) { + data.bid = this.bid.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.bid !== undefined) + writer.writeMessage(1, this.bid, () => this.bid.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BidResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.bid, () => message.bid = dependency_5.vulcanize.auction.v1beta1.Bid.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BidResponse.deserialize(bytes); + } + } + v1beta1.BidResponse = BidResponse; + class BidsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + } + } + get auction_id() { + return pb_1.Message.getField(this, 1); + } + set auction_id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new BidsRequest({}); + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + return message; + } + toObject() { + const data = {}; + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(1, this.auction_id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BidsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.auction_id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BidsRequest.deserialize(bytes); + } + } + v1beta1.BidsRequest = BidsRequest; + class BidsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bids" in data && data.bids != undefined) { + this.bids = data.bids; + } + } + } + get bids() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Bid, 1); + } + set bids(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new BidsResponse({}); + if (data.bids != null) { + message.bids = data.bids.map(item => dependency_5.vulcanize.auction.v1beta1.Bid.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.bids != null) { + data.bids = this.bids.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.bids !== undefined) + writer.writeRepeatedMessage(1, this.bids, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BidsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.bids, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_5.vulcanize.auction.v1beta1.Bid.deserialize(reader), dependency_5.vulcanize.auction.v1beta1.Bid)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BidsResponse.deserialize(bytes); + } + } + v1beta1.BidsResponse = BidsResponse; + class AuctionsByBidderRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bidder_address" in data && data.bidder_address != undefined) { + this.bidder_address = data.bidder_address; + } + } + } + get bidder_address() { + return pb_1.Message.getField(this, 1); + } + set bidder_address(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionsByBidderRequest({}); + if (data.bidder_address != null) { + message.bidder_address = data.bidder_address; + } + return message; + } + toObject() { + const data = {}; + if (this.bidder_address != null) { + data.bidder_address = this.bidder_address; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.bidder_address === "string" && this.bidder_address.length) + writer.writeString(1, this.bidder_address); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionsByBidderRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.bidder_address = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionsByBidderRequest.deserialize(bytes); + } + } + v1beta1.AuctionsByBidderRequest = AuctionsByBidderRequest; + class AuctionsByBidderResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auctions" in data && data.auctions != undefined) { + this.auctions = data.auctions; + } + } + } + get auctions() { + return pb_1.Message.getWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Auctions, 1); + } + set auctions(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionsByBidderResponse({}); + if (data.auctions != null) { + message.auctions = dependency_5.vulcanize.auction.v1beta1.Auctions.fromObject(data.auctions); + } + return message; + } + toObject() { + const data = {}; + if (this.auctions != null) { + data.auctions = this.auctions.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auctions !== undefined) + writer.writeMessage(1, this.auctions, () => this.auctions.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionsByBidderResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auctions, () => message.auctions = dependency_5.vulcanize.auction.v1beta1.Auctions.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionsByBidderResponse.deserialize(bytes); + } + } + v1beta1.AuctionsByBidderResponse = AuctionsByBidderResponse; + class AuctionsByOwnerRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("owner_address" in data && data.owner_address != undefined) { + this.owner_address = data.owner_address; + } + } + } + get owner_address() { + return pb_1.Message.getField(this, 1); + } + set owner_address(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionsByOwnerRequest({}); + if (data.owner_address != null) { + message.owner_address = data.owner_address; + } + return message; + } + toObject() { + const data = {}; + if (this.owner_address != null) { + data.owner_address = this.owner_address; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.owner_address === "string" && this.owner_address.length) + writer.writeString(1, this.owner_address); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionsByOwnerRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.owner_address = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionsByOwnerRequest.deserialize(bytes); + } + } + v1beta1.AuctionsByOwnerRequest = AuctionsByOwnerRequest; + class AuctionsByOwnerResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auctions" in data && data.auctions != undefined) { + this.auctions = data.auctions; + } + } + } + get auctions() { + return pb_1.Message.getWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Auctions, 1); + } + set auctions(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new AuctionsByOwnerResponse({}); + if (data.auctions != null) { + message.auctions = dependency_5.vulcanize.auction.v1beta1.Auctions.fromObject(data.auctions); + } + return message; + } + toObject() { + const data = {}; + if (this.auctions != null) { + data.auctions = this.auctions.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auctions !== undefined) + writer.writeMessage(1, this.auctions, () => this.auctions.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionsByOwnerResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auctions, () => message.auctions = dependency_5.vulcanize.auction.v1beta1.Auctions.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionsByOwnerResponse.deserialize(bytes); + } + } + v1beta1.AuctionsByOwnerResponse = AuctionsByOwnerResponse; + class QueryParamsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new QueryParamsRequest({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryParamsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryParamsRequest.deserialize(bytes); + } + } + v1beta1.QueryParamsRequest = QueryParamsRequest; + class QueryParamsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("params" in data && data.params != undefined) { + this.params = data.params; + } + } + } + get params() { + return pb_1.Message.getWrapperField(this, dependency_5.vulcanize.auction.v1beta1.Params, 1); + } + set params(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryParamsResponse({}); + if (data.params != null) { + message.params = dependency_5.vulcanize.auction.v1beta1.Params.fromObject(data.params); + } + return message; + } + toObject() { + const data = {}; + if (this.params != null) { + data.params = this.params.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.params !== undefined) + writer.writeMessage(1, this.params, () => this.params.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryParamsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.params, () => message.params = dependency_5.vulcanize.auction.v1beta1.Params.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryParamsResponse.deserialize(bytes); + } + } + v1beta1.QueryParamsResponse = QueryParamsResponse; + class BalanceRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new BalanceRequest({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BalanceRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BalanceRequest.deserialize(bytes); + } + } + v1beta1.BalanceRequest = BalanceRequest; + class BalanceResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("balance" in data && data.balance != undefined) { + this.balance = data.balance; + } + } + } + get balance() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 1); + } + set balance(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new BalanceResponse({}); + if (data.balance != null) { + message.balance = data.balance.map(item => dependency_4.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.balance != null) { + data.balance = this.balance.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.balance !== undefined) + writer.writeRepeatedMessage(1, this.balance, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BalanceResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.balance, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_4.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BalanceResponse.deserialize(bytes); + } + } + v1beta1.BalanceResponse = BalanceResponse; + })(v1beta1 = auction.v1beta1 || (auction.v1beta1 = {})); + })(auction = vulcanize.auction || (vulcanize.auction = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/auction/v1beta1/tx.d.ts b/dist/proto/vulcanize/auction/v1beta1/tx.d.ts new file mode 100644 index 0000000..7a7f9de --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/tx.d.ts @@ -0,0 +1,273 @@ +import * as dependency_2 from "./../../../google/protobuf/duration"; +import * as dependency_3 from "./../../../cosmos/base/v1beta1/coin"; +import * as dependency_4 from "./types"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.auction.v1beta1 { + class MsgCreateAuction extends pb_1.Message { + constructor(data?: any[] | { + commits_duration?: dependency_2.google.protobuf.Duration; + reveals_duration?: dependency_2.google.protobuf.Duration; + commit_fee?: dependency_3.cosmos.base.v1beta1.Coin; + reveal_fee?: dependency_3.cosmos.base.v1beta1.Coin; + minimum_bid?: dependency_3.cosmos.base.v1beta1.Coin; + signer?: string; + }); + get commits_duration(): dependency_2.google.protobuf.Duration; + set commits_duration(value: dependency_2.google.protobuf.Duration); + get reveals_duration(): dependency_2.google.protobuf.Duration; + set reveals_duration(value: dependency_2.google.protobuf.Duration); + get commit_fee(): dependency_3.cosmos.base.v1beta1.Coin; + set commit_fee(value: dependency_3.cosmos.base.v1beta1.Coin); + get reveal_fee(): dependency_3.cosmos.base.v1beta1.Coin; + set reveal_fee(value: dependency_3.cosmos.base.v1beta1.Coin); + get minimum_bid(): dependency_3.cosmos.base.v1beta1.Coin; + set minimum_bid(value: dependency_3.cosmos.base.v1beta1.Coin); + get signer(): string; + set signer(value: string); + static fromObject(data: { + commits_duration?: ReturnType; + reveals_duration?: ReturnType; + commit_fee?: ReturnType; + reveal_fee?: ReturnType; + minimum_bid?: ReturnType; + signer?: string; + }): MsgCreateAuction; + toObject(): { + commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCreateAuction; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCreateAuction; + } + class MsgCreateAuctionResponse extends pb_1.Message { + constructor(data?: any[] | { + auction?: dependency_4.vulcanize.auction.v1beta1.Auction; + }); + get auction(): dependency_4.vulcanize.auction.v1beta1.Auction; + set auction(value: dependency_4.vulcanize.auction.v1beta1.Auction); + static fromObject(data: { + auction?: ReturnType; + }): MsgCreateAuctionResponse; + toObject(): { + auction?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCreateAuctionResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCreateAuctionResponse; + } + class MsgCommitBid extends pb_1.Message { + constructor(data?: any[] | { + auction_id?: string; + commit_hash?: string; + signer?: string; + }); + get auction_id(): string; + set auction_id(value: string); + get commit_hash(): string; + set commit_hash(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + auction_id?: string; + commit_hash?: string; + signer?: string; + }): MsgCommitBid; + toObject(): { + auction_id?: string | undefined; + commit_hash?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCommitBid; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCommitBid; + } + class MsgRevealBid extends pb_1.Message { + constructor(data?: any[] | { + auction_id?: string; + reveal?: string; + signer?: string; + }); + get auction_id(): string; + set auction_id(value: string); + get reveal(): string; + set reveal(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + auction_id?: string; + reveal?: string; + signer?: string; + }): MsgRevealBid; + toObject(): { + auction_id?: string | undefined; + reveal?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgRevealBid; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgRevealBid; + } + class MsgCommitBidResponse extends pb_1.Message { + constructor(data?: any[] | { + bid?: dependency_4.vulcanize.auction.v1beta1.Bid; + }); + get bid(): dependency_4.vulcanize.auction.v1beta1.Bid; + set bid(value: dependency_4.vulcanize.auction.v1beta1.Bid); + static fromObject(data: { + bid?: ReturnType; + }): MsgCommitBidResponse; + toObject(): { + bid?: { + auction_id?: string | undefined; + bidder_address?: string | undefined; + status?: string | undefined; + commit_hash?: string | undefined; + commit_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + bid_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCommitBidResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCommitBidResponse; + } + class MsgRevealBidResponse extends pb_1.Message { + constructor(data?: any[] | { + auction?: dependency_4.vulcanize.auction.v1beta1.Auction; + }); + get auction(): dependency_4.vulcanize.auction.v1beta1.Auction; + set auction(value: dependency_4.vulcanize.auction.v1beta1.Auction); + static fromObject(data: { + auction?: ReturnType; + }): MsgRevealBidResponse; + toObject(): { + auction?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgRevealBidResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgRevealBidResponse; + } +} diff --git a/dist/proto/vulcanize/auction/v1beta1/tx.js b/dist/proto/vulcanize/auction/v1beta1/tx.js new file mode 100644 index 0000000..519de98 --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/tx.js @@ -0,0 +1,573 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./../../../google/protobuf/duration")); +const dependency_3 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const dependency_4 = __importStar(require("./types")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var auction; + (function (auction) { + var v1beta1; + (function (v1beta1) { + class MsgCreateAuction extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("commits_duration" in data && data.commits_duration != undefined) { + this.commits_duration = data.commits_duration; + } + if ("reveals_duration" in data && data.reveals_duration != undefined) { + this.reveals_duration = data.reveals_duration; + } + if ("commit_fee" in data && data.commit_fee != undefined) { + this.commit_fee = data.commit_fee; + } + if ("reveal_fee" in data && data.reveal_fee != undefined) { + this.reveal_fee = data.reveal_fee; + } + if ("minimum_bid" in data && data.minimum_bid != undefined) { + this.minimum_bid = data.minimum_bid; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get commits_duration() { + return pb_1.Message.getWrapperField(this, dependency_2.google.protobuf.Duration, 1); + } + set commits_duration(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get reveals_duration() { + return pb_1.Message.getWrapperField(this, dependency_2.google.protobuf.Duration, 2); + } + set reveals_duration(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + get commit_fee() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.v1beta1.Coin, 3); + } + set commit_fee(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + get reveal_fee() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.v1beta1.Coin, 4); + } + set reveal_fee(value) { + pb_1.Message.setWrapperField(this, 4, value); + } + get minimum_bid() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.v1beta1.Coin, 5); + } + set minimum_bid(value) { + pb_1.Message.setWrapperField(this, 5, value); + } + get signer() { + return pb_1.Message.getField(this, 6); + } + set signer(value) { + pb_1.Message.setField(this, 6, value); + } + static fromObject(data) { + const message = new MsgCreateAuction({}); + if (data.commits_duration != null) { + message.commits_duration = dependency_2.google.protobuf.Duration.fromObject(data.commits_duration); + } + if (data.reveals_duration != null) { + message.reveals_duration = dependency_2.google.protobuf.Duration.fromObject(data.reveals_duration); + } + if (data.commit_fee != null) { + message.commit_fee = dependency_3.cosmos.base.v1beta1.Coin.fromObject(data.commit_fee); + } + if (data.reveal_fee != null) { + message.reveal_fee = dependency_3.cosmos.base.v1beta1.Coin.fromObject(data.reveal_fee); + } + if (data.minimum_bid != null) { + message.minimum_bid = dependency_3.cosmos.base.v1beta1.Coin.fromObject(data.minimum_bid); + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.commits_duration != null) { + data.commits_duration = this.commits_duration.toObject(); + } + if (this.reveals_duration != null) { + data.reveals_duration = this.reveals_duration.toObject(); + } + if (this.commit_fee != null) { + data.commit_fee = this.commit_fee.toObject(); + } + if (this.reveal_fee != null) { + data.reveal_fee = this.reveal_fee.toObject(); + } + if (this.minimum_bid != null) { + data.minimum_bid = this.minimum_bid.toObject(); + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.commits_duration !== undefined) + writer.writeMessage(1, this.commits_duration, () => this.commits_duration.serialize(writer)); + if (this.reveals_duration !== undefined) + writer.writeMessage(2, this.reveals_duration, () => this.reveals_duration.serialize(writer)); + if (this.commit_fee !== undefined) + writer.writeMessage(3, this.commit_fee, () => this.commit_fee.serialize(writer)); + if (this.reveal_fee !== undefined) + writer.writeMessage(4, this.reveal_fee, () => this.reveal_fee.serialize(writer)); + if (this.minimum_bid !== undefined) + writer.writeMessage(5, this.minimum_bid, () => this.minimum_bid.serialize(writer)); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(6, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCreateAuction(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.commits_duration, () => message.commits_duration = dependency_2.google.protobuf.Duration.deserialize(reader)); + break; + case 2: + reader.readMessage(message.reveals_duration, () => message.reveals_duration = dependency_2.google.protobuf.Duration.deserialize(reader)); + break; + case 3: + reader.readMessage(message.commit_fee, () => message.commit_fee = dependency_3.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 4: + reader.readMessage(message.reveal_fee, () => message.reveal_fee = dependency_3.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 5: + reader.readMessage(message.minimum_bid, () => message.minimum_bid = dependency_3.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 6: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCreateAuction.deserialize(bytes); + } + } + v1beta1.MsgCreateAuction = MsgCreateAuction; + class MsgCreateAuctionResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction" in data && data.auction != undefined) { + this.auction = data.auction; + } + } + } + get auction() { + return pb_1.Message.getWrapperField(this, dependency_4.vulcanize.auction.v1beta1.Auction, 1); + } + set auction(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new MsgCreateAuctionResponse({}); + if (data.auction != null) { + message.auction = dependency_4.vulcanize.auction.v1beta1.Auction.fromObject(data.auction); + } + return message; + } + toObject() { + const data = {}; + if (this.auction != null) { + data.auction = this.auction.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auction !== undefined) + writer.writeMessage(1, this.auction, () => this.auction.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCreateAuctionResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auction, () => message.auction = dependency_4.vulcanize.auction.v1beta1.Auction.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCreateAuctionResponse.deserialize(bytes); + } + } + v1beta1.MsgCreateAuctionResponse = MsgCreateAuctionResponse; + class MsgCommitBid extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + if ("commit_hash" in data && data.commit_hash != undefined) { + this.commit_hash = data.commit_hash; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get auction_id() { + return pb_1.Message.getField(this, 1); + } + set auction_id(value) { + pb_1.Message.setField(this, 1, value); + } + get commit_hash() { + return pb_1.Message.getField(this, 2); + } + set commit_hash(value) { + pb_1.Message.setField(this, 2, value); + } + get signer() { + return pb_1.Message.getField(this, 3); + } + set signer(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgCommitBid({}); + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + if (data.commit_hash != null) { + message.commit_hash = data.commit_hash; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + if (this.commit_hash != null) { + data.commit_hash = this.commit_hash; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(1, this.auction_id); + if (typeof this.commit_hash === "string" && this.commit_hash.length) + writer.writeString(2, this.commit_hash); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(3, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCommitBid(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.auction_id = reader.readString(); + break; + case 2: + message.commit_hash = reader.readString(); + break; + case 3: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCommitBid.deserialize(bytes); + } + } + v1beta1.MsgCommitBid = MsgCommitBid; + class MsgRevealBid extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + if ("reveal" in data && data.reveal != undefined) { + this.reveal = data.reveal; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get auction_id() { + return pb_1.Message.getField(this, 1); + } + set auction_id(value) { + pb_1.Message.setField(this, 1, value); + } + get reveal() { + return pb_1.Message.getField(this, 2); + } + set reveal(value) { + pb_1.Message.setField(this, 2, value); + } + get signer() { + return pb_1.Message.getField(this, 3); + } + set signer(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgRevealBid({}); + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + if (data.reveal != null) { + message.reveal = data.reveal; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + if (this.reveal != null) { + data.reveal = this.reveal; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(1, this.auction_id); + if (typeof this.reveal === "string" && this.reveal.length) + writer.writeString(2, this.reveal); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(3, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgRevealBid(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.auction_id = reader.readString(); + break; + case 2: + message.reveal = reader.readString(); + break; + case 3: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgRevealBid.deserialize(bytes); + } + } + v1beta1.MsgRevealBid = MsgRevealBid; + class MsgCommitBidResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bid" in data && data.bid != undefined) { + this.bid = data.bid; + } + } + } + get bid() { + return pb_1.Message.getWrapperField(this, dependency_4.vulcanize.auction.v1beta1.Bid, 1); + } + set bid(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new MsgCommitBidResponse({}); + if (data.bid != null) { + message.bid = dependency_4.vulcanize.auction.v1beta1.Bid.fromObject(data.bid); + } + return message; + } + toObject() { + const data = {}; + if (this.bid != null) { + data.bid = this.bid.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.bid !== undefined) + writer.writeMessage(1, this.bid, () => this.bid.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCommitBidResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.bid, () => message.bid = dependency_4.vulcanize.auction.v1beta1.Bid.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCommitBidResponse.deserialize(bytes); + } + } + v1beta1.MsgCommitBidResponse = MsgCommitBidResponse; + class MsgRevealBidResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction" in data && data.auction != undefined) { + this.auction = data.auction; + } + } + } + get auction() { + return pb_1.Message.getWrapperField(this, dependency_4.vulcanize.auction.v1beta1.Auction, 1); + } + set auction(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new MsgRevealBidResponse({}); + if (data.auction != null) { + message.auction = dependency_4.vulcanize.auction.v1beta1.Auction.fromObject(data.auction); + } + return message; + } + toObject() { + const data = {}; + if (this.auction != null) { + data.auction = this.auction.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auction !== undefined) + writer.writeMessage(1, this.auction, () => this.auction.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgRevealBidResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auction, () => message.auction = dependency_4.vulcanize.auction.v1beta1.Auction.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgRevealBidResponse.deserialize(bytes); + } + } + v1beta1.MsgRevealBidResponse = MsgRevealBidResponse; + })(v1beta1 = auction.v1beta1 || (auction.v1beta1 = {})); + })(auction = vulcanize.auction || (vulcanize.auction = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/auction/v1beta1/types.d.ts b/dist/proto/vulcanize/auction/v1beta1/types.d.ts new file mode 100644 index 0000000..1cd4d07 --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/types.d.ts @@ -0,0 +1,284 @@ +import * as dependency_2 from "./../../../google/protobuf/duration"; +import * as dependency_3 from "./../../../google/protobuf/timestamp"; +import * as dependency_4 from "./../../../cosmos/base/v1beta1/coin"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.auction.v1beta1 { + class Params extends pb_1.Message { + constructor(data?: any[] | { + commits_duration?: dependency_2.google.protobuf.Duration; + reveals_duration?: dependency_2.google.protobuf.Duration; + commit_fee?: dependency_4.cosmos.base.v1beta1.Coin; + reveal_fee?: dependency_4.cosmos.base.v1beta1.Coin; + minimum_bid?: dependency_4.cosmos.base.v1beta1.Coin; + }); + get commits_duration(): dependency_2.google.protobuf.Duration; + set commits_duration(value: dependency_2.google.protobuf.Duration); + get reveals_duration(): dependency_2.google.protobuf.Duration; + set reveals_duration(value: dependency_2.google.protobuf.Duration); + get commit_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set commit_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get reveal_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set reveal_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get minimum_bid(): dependency_4.cosmos.base.v1beta1.Coin; + set minimum_bid(value: dependency_4.cosmos.base.v1beta1.Coin); + static fromObject(data: { + commits_duration?: ReturnType; + reveals_duration?: ReturnType; + commit_fee?: ReturnType; + reveal_fee?: ReturnType; + minimum_bid?: ReturnType; + }): Params; + toObject(): { + commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Params; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Params; + } + class Auction extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + status?: string; + owner_address?: string; + create_time?: dependency_3.google.protobuf.Timestamp; + commits_end_time?: dependency_3.google.protobuf.Timestamp; + reveals_end_time?: dependency_3.google.protobuf.Timestamp; + commit_fee?: dependency_4.cosmos.base.v1beta1.Coin; + reveal_fee?: dependency_4.cosmos.base.v1beta1.Coin; + minimum_bid?: dependency_4.cosmos.base.v1beta1.Coin; + winner_address?: string; + winning_bid?: dependency_4.cosmos.base.v1beta1.Coin; + winning_price?: dependency_4.cosmos.base.v1beta1.Coin; + }); + get id(): string; + set id(value: string); + get status(): string; + set status(value: string); + get owner_address(): string; + set owner_address(value: string); + get create_time(): dependency_3.google.protobuf.Timestamp; + set create_time(value: dependency_3.google.protobuf.Timestamp); + get commits_end_time(): dependency_3.google.protobuf.Timestamp; + set commits_end_time(value: dependency_3.google.protobuf.Timestamp); + get reveals_end_time(): dependency_3.google.protobuf.Timestamp; + set reveals_end_time(value: dependency_3.google.protobuf.Timestamp); + get commit_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set commit_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get reveal_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set reveal_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get minimum_bid(): dependency_4.cosmos.base.v1beta1.Coin; + set minimum_bid(value: dependency_4.cosmos.base.v1beta1.Coin); + get winner_address(): string; + set winner_address(value: string); + get winning_bid(): dependency_4.cosmos.base.v1beta1.Coin; + set winning_bid(value: dependency_4.cosmos.base.v1beta1.Coin); + get winning_price(): dependency_4.cosmos.base.v1beta1.Coin; + set winning_price(value: dependency_4.cosmos.base.v1beta1.Coin); + static fromObject(data: { + id?: string; + status?: string; + owner_address?: string; + create_time?: ReturnType; + commits_end_time?: ReturnType; + reveals_end_time?: ReturnType; + commit_fee?: ReturnType; + reveal_fee?: ReturnType; + minimum_bid?: ReturnType; + winner_address?: string; + winning_bid?: ReturnType; + winning_price?: ReturnType; + }): Auction; + toObject(): { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Auction; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Auction; + } + class Auctions extends pb_1.Message { + constructor(data?: any[] | { + auctions?: Auction[]; + }); + get auctions(): Auction[]; + set auctions(value: Auction[]); + static fromObject(data: { + auctions?: ReturnType[]; + }): Auctions; + toObject(): { + auctions?: { + id?: string | undefined; + status?: string | undefined; + owner_address?: string | undefined; + create_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commits_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveals_end_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winner_address?: string | undefined; + winning_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + winning_price?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Auctions; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Auctions; + } + class Bid extends pb_1.Message { + constructor(data?: any[] | { + auction_id?: string; + bidder_address?: string; + status?: string; + commit_hash?: string; + commit_time?: dependency_3.google.protobuf.Timestamp; + commit_fee?: dependency_4.cosmos.base.v1beta1.Coin; + reveal_time?: dependency_3.google.protobuf.Timestamp; + reveal_fee?: dependency_4.cosmos.base.v1beta1.Coin; + bid_amount?: dependency_4.cosmos.base.v1beta1.Coin; + }); + get auction_id(): string; + set auction_id(value: string); + get bidder_address(): string; + set bidder_address(value: string); + get status(): string; + set status(value: string); + get commit_hash(): string; + set commit_hash(value: string); + get commit_time(): dependency_3.google.protobuf.Timestamp; + set commit_time(value: dependency_3.google.protobuf.Timestamp); + get commit_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set commit_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get reveal_time(): dependency_3.google.protobuf.Timestamp; + set reveal_time(value: dependency_3.google.protobuf.Timestamp); + get reveal_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set reveal_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get bid_amount(): dependency_4.cosmos.base.v1beta1.Coin; + set bid_amount(value: dependency_4.cosmos.base.v1beta1.Coin); + static fromObject(data: { + auction_id?: string; + bidder_address?: string; + status?: string; + commit_hash?: string; + commit_time?: ReturnType; + commit_fee?: ReturnType; + reveal_time?: ReturnType; + reveal_fee?: ReturnType; + bid_amount?: ReturnType; + }): Bid; + toObject(): { + auction_id?: string | undefined; + bidder_address?: string | undefined; + status?: string | undefined; + commit_hash?: string | undefined; + commit_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + reveal_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + bid_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Bid; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Bid; + } +} diff --git a/dist/proto/vulcanize/auction/v1beta1/types.js b/dist/proto/vulcanize/auction/v1beta1/types.js new file mode 100644 index 0000000..7cf679c --- /dev/null +++ b/dist/proto/vulcanize/auction/v1beta1/types.js @@ -0,0 +1,735 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./../../../google/protobuf/duration")); +const dependency_3 = __importStar(require("./../../../google/protobuf/timestamp")); +const dependency_4 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var auction; + (function (auction) { + var v1beta1; + (function (v1beta1) { + class Params extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("commits_duration" in data && data.commits_duration != undefined) { + this.commits_duration = data.commits_duration; + } + if ("reveals_duration" in data && data.reveals_duration != undefined) { + this.reveals_duration = data.reveals_duration; + } + if ("commit_fee" in data && data.commit_fee != undefined) { + this.commit_fee = data.commit_fee; + } + if ("reveal_fee" in data && data.reveal_fee != undefined) { + this.reveal_fee = data.reveal_fee; + } + if ("minimum_bid" in data && data.minimum_bid != undefined) { + this.minimum_bid = data.minimum_bid; + } + } + } + get commits_duration() { + return pb_1.Message.getWrapperField(this, dependency_2.google.protobuf.Duration, 1); + } + set commits_duration(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get reveals_duration() { + return pb_1.Message.getWrapperField(this, dependency_2.google.protobuf.Duration, 2); + } + set reveals_duration(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + get commit_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 3); + } + set commit_fee(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + get reveal_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 4); + } + set reveal_fee(value) { + pb_1.Message.setWrapperField(this, 4, value); + } + get minimum_bid() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 5); + } + set minimum_bid(value) { + pb_1.Message.setWrapperField(this, 5, value); + } + static fromObject(data) { + const message = new Params({}); + if (data.commits_duration != null) { + message.commits_duration = dependency_2.google.protobuf.Duration.fromObject(data.commits_duration); + } + if (data.reveals_duration != null) { + message.reveals_duration = dependency_2.google.protobuf.Duration.fromObject(data.reveals_duration); + } + if (data.commit_fee != null) { + message.commit_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.commit_fee); + } + if (data.reveal_fee != null) { + message.reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.reveal_fee); + } + if (data.minimum_bid != null) { + message.minimum_bid = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.minimum_bid); + } + return message; + } + toObject() { + const data = {}; + if (this.commits_duration != null) { + data.commits_duration = this.commits_duration.toObject(); + } + if (this.reveals_duration != null) { + data.reveals_duration = this.reveals_duration.toObject(); + } + if (this.commit_fee != null) { + data.commit_fee = this.commit_fee.toObject(); + } + if (this.reveal_fee != null) { + data.reveal_fee = this.reveal_fee.toObject(); + } + if (this.minimum_bid != null) { + data.minimum_bid = this.minimum_bid.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.commits_duration !== undefined) + writer.writeMessage(1, this.commits_duration, () => this.commits_duration.serialize(writer)); + if (this.reveals_duration !== undefined) + writer.writeMessage(2, this.reveals_duration, () => this.reveals_duration.serialize(writer)); + if (this.commit_fee !== undefined) + writer.writeMessage(3, this.commit_fee, () => this.commit_fee.serialize(writer)); + if (this.reveal_fee !== undefined) + writer.writeMessage(4, this.reveal_fee, () => this.reveal_fee.serialize(writer)); + if (this.minimum_bid !== undefined) + writer.writeMessage(5, this.minimum_bid, () => this.minimum_bid.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Params(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.commits_duration, () => message.commits_duration = dependency_2.google.protobuf.Duration.deserialize(reader)); + break; + case 2: + reader.readMessage(message.reveals_duration, () => message.reveals_duration = dependency_2.google.protobuf.Duration.deserialize(reader)); + break; + case 3: + reader.readMessage(message.commit_fee, () => message.commit_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 4: + reader.readMessage(message.reveal_fee, () => message.reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 5: + reader.readMessage(message.minimum_bid, () => message.minimum_bid = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Params.deserialize(bytes); + } + } + v1beta1.Params = Params; + class Auction extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("status" in data && data.status != undefined) { + this.status = data.status; + } + if ("owner_address" in data && data.owner_address != undefined) { + this.owner_address = data.owner_address; + } + if ("create_time" in data && data.create_time != undefined) { + this.create_time = data.create_time; + } + if ("commits_end_time" in data && data.commits_end_time != undefined) { + this.commits_end_time = data.commits_end_time; + } + if ("reveals_end_time" in data && data.reveals_end_time != undefined) { + this.reveals_end_time = data.reveals_end_time; + } + if ("commit_fee" in data && data.commit_fee != undefined) { + this.commit_fee = data.commit_fee; + } + if ("reveal_fee" in data && data.reveal_fee != undefined) { + this.reveal_fee = data.reveal_fee; + } + if ("minimum_bid" in data && data.minimum_bid != undefined) { + this.minimum_bid = data.minimum_bid; + } + if ("winner_address" in data && data.winner_address != undefined) { + this.winner_address = data.winner_address; + } + if ("winning_bid" in data && data.winning_bid != undefined) { + this.winning_bid = data.winning_bid; + } + if ("winning_price" in data && data.winning_price != undefined) { + this.winning_price = data.winning_price; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get status() { + return pb_1.Message.getField(this, 2); + } + set status(value) { + pb_1.Message.setField(this, 2, value); + } + get owner_address() { + return pb_1.Message.getField(this, 3); + } + set owner_address(value) { + pb_1.Message.setField(this, 3, value); + } + get create_time() { + return pb_1.Message.getWrapperField(this, dependency_3.google.protobuf.Timestamp, 4); + } + set create_time(value) { + pb_1.Message.setWrapperField(this, 4, value); + } + get commits_end_time() { + return pb_1.Message.getWrapperField(this, dependency_3.google.protobuf.Timestamp, 5); + } + set commits_end_time(value) { + pb_1.Message.setWrapperField(this, 5, value); + } + get reveals_end_time() { + return pb_1.Message.getWrapperField(this, dependency_3.google.protobuf.Timestamp, 6); + } + set reveals_end_time(value) { + pb_1.Message.setWrapperField(this, 6, value); + } + get commit_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 7); + } + set commit_fee(value) { + pb_1.Message.setWrapperField(this, 7, value); + } + get reveal_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 8); + } + set reveal_fee(value) { + pb_1.Message.setWrapperField(this, 8, value); + } + get minimum_bid() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 9); + } + set minimum_bid(value) { + pb_1.Message.setWrapperField(this, 9, value); + } + get winner_address() { + return pb_1.Message.getField(this, 10); + } + set winner_address(value) { + pb_1.Message.setField(this, 10, value); + } + get winning_bid() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 11); + } + set winning_bid(value) { + pb_1.Message.setWrapperField(this, 11, value); + } + get winning_price() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 12); + } + set winning_price(value) { + pb_1.Message.setWrapperField(this, 12, value); + } + static fromObject(data) { + const message = new Auction({}); + if (data.id != null) { + message.id = data.id; + } + if (data.status != null) { + message.status = data.status; + } + if (data.owner_address != null) { + message.owner_address = data.owner_address; + } + if (data.create_time != null) { + message.create_time = dependency_3.google.protobuf.Timestamp.fromObject(data.create_time); + } + if (data.commits_end_time != null) { + message.commits_end_time = dependency_3.google.protobuf.Timestamp.fromObject(data.commits_end_time); + } + if (data.reveals_end_time != null) { + message.reveals_end_time = dependency_3.google.protobuf.Timestamp.fromObject(data.reveals_end_time); + } + if (data.commit_fee != null) { + message.commit_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.commit_fee); + } + if (data.reveal_fee != null) { + message.reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.reveal_fee); + } + if (data.minimum_bid != null) { + message.minimum_bid = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.minimum_bid); + } + if (data.winner_address != null) { + message.winner_address = data.winner_address; + } + if (data.winning_bid != null) { + message.winning_bid = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.winning_bid); + } + if (data.winning_price != null) { + message.winning_price = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.winning_price); + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.status != null) { + data.status = this.status; + } + if (this.owner_address != null) { + data.owner_address = this.owner_address; + } + if (this.create_time != null) { + data.create_time = this.create_time.toObject(); + } + if (this.commits_end_time != null) { + data.commits_end_time = this.commits_end_time.toObject(); + } + if (this.reveals_end_time != null) { + data.reveals_end_time = this.reveals_end_time.toObject(); + } + if (this.commit_fee != null) { + data.commit_fee = this.commit_fee.toObject(); + } + if (this.reveal_fee != null) { + data.reveal_fee = this.reveal_fee.toObject(); + } + if (this.minimum_bid != null) { + data.minimum_bid = this.minimum_bid.toObject(); + } + if (this.winner_address != null) { + data.winner_address = this.winner_address; + } + if (this.winning_bid != null) { + data.winning_bid = this.winning_bid.toObject(); + } + if (this.winning_price != null) { + data.winning_price = this.winning_price.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (typeof this.status === "string" && this.status.length) + writer.writeString(2, this.status); + if (typeof this.owner_address === "string" && this.owner_address.length) + writer.writeString(3, this.owner_address); + if (this.create_time !== undefined) + writer.writeMessage(4, this.create_time, () => this.create_time.serialize(writer)); + if (this.commits_end_time !== undefined) + writer.writeMessage(5, this.commits_end_time, () => this.commits_end_time.serialize(writer)); + if (this.reveals_end_time !== undefined) + writer.writeMessage(6, this.reveals_end_time, () => this.reveals_end_time.serialize(writer)); + if (this.commit_fee !== undefined) + writer.writeMessage(7, this.commit_fee, () => this.commit_fee.serialize(writer)); + if (this.reveal_fee !== undefined) + writer.writeMessage(8, this.reveal_fee, () => this.reveal_fee.serialize(writer)); + if (this.minimum_bid !== undefined) + writer.writeMessage(9, this.minimum_bid, () => this.minimum_bid.serialize(writer)); + if (typeof this.winner_address === "string" && this.winner_address.length) + writer.writeString(10, this.winner_address); + if (this.winning_bid !== undefined) + writer.writeMessage(11, this.winning_bid, () => this.winning_bid.serialize(writer)); + if (this.winning_price !== undefined) + writer.writeMessage(12, this.winning_price, () => this.winning_price.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Auction(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.status = reader.readString(); + break; + case 3: + message.owner_address = reader.readString(); + break; + case 4: + reader.readMessage(message.create_time, () => message.create_time = dependency_3.google.protobuf.Timestamp.deserialize(reader)); + break; + case 5: + reader.readMessage(message.commits_end_time, () => message.commits_end_time = dependency_3.google.protobuf.Timestamp.deserialize(reader)); + break; + case 6: + reader.readMessage(message.reveals_end_time, () => message.reveals_end_time = dependency_3.google.protobuf.Timestamp.deserialize(reader)); + break; + case 7: + reader.readMessage(message.commit_fee, () => message.commit_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 8: + reader.readMessage(message.reveal_fee, () => message.reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 9: + reader.readMessage(message.minimum_bid, () => message.minimum_bid = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 10: + message.winner_address = reader.readString(); + break; + case 11: + reader.readMessage(message.winning_bid, () => message.winning_bid = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 12: + reader.readMessage(message.winning_price, () => message.winning_price = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Auction.deserialize(bytes); + } + } + v1beta1.Auction = Auction; + class Auctions extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auctions" in data && data.auctions != undefined) { + this.auctions = data.auctions; + } + } + } + get auctions() { + return pb_1.Message.getRepeatedWrapperField(this, Auction, 1); + } + set auctions(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new Auctions({}); + if (data.auctions != null) { + message.auctions = data.auctions.map(item => Auction.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.auctions != null) { + data.auctions = this.auctions.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.auctions !== undefined) + writer.writeRepeatedMessage(1, this.auctions, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Auctions(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.auctions, () => pb_1.Message.addToRepeatedWrapperField(message, 1, Auction.deserialize(reader), Auction)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Auctions.deserialize(bytes); + } + } + v1beta1.Auctions = Auctions; + class Bid extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + if ("bidder_address" in data && data.bidder_address != undefined) { + this.bidder_address = data.bidder_address; + } + if ("status" in data && data.status != undefined) { + this.status = data.status; + } + if ("commit_hash" in data && data.commit_hash != undefined) { + this.commit_hash = data.commit_hash; + } + if ("commit_time" in data && data.commit_time != undefined) { + this.commit_time = data.commit_time; + } + if ("commit_fee" in data && data.commit_fee != undefined) { + this.commit_fee = data.commit_fee; + } + if ("reveal_time" in data && data.reveal_time != undefined) { + this.reveal_time = data.reveal_time; + } + if ("reveal_fee" in data && data.reveal_fee != undefined) { + this.reveal_fee = data.reveal_fee; + } + if ("bid_amount" in data && data.bid_amount != undefined) { + this.bid_amount = data.bid_amount; + } + } + } + get auction_id() { + return pb_1.Message.getField(this, 1); + } + set auction_id(value) { + pb_1.Message.setField(this, 1, value); + } + get bidder_address() { + return pb_1.Message.getField(this, 2); + } + set bidder_address(value) { + pb_1.Message.setField(this, 2, value); + } + get status() { + return pb_1.Message.getField(this, 3); + } + set status(value) { + pb_1.Message.setField(this, 3, value); + } + get commit_hash() { + return pb_1.Message.getField(this, 4); + } + set commit_hash(value) { + pb_1.Message.setField(this, 4, value); + } + get commit_time() { + return pb_1.Message.getWrapperField(this, dependency_3.google.protobuf.Timestamp, 5); + } + set commit_time(value) { + pb_1.Message.setWrapperField(this, 5, value); + } + get commit_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 6); + } + set commit_fee(value) { + pb_1.Message.setWrapperField(this, 6, value); + } + get reveal_time() { + return pb_1.Message.getWrapperField(this, dependency_3.google.protobuf.Timestamp, 7); + } + set reveal_time(value) { + pb_1.Message.setWrapperField(this, 7, value); + } + get reveal_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 8); + } + set reveal_fee(value) { + pb_1.Message.setWrapperField(this, 8, value); + } + get bid_amount() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 9); + } + set bid_amount(value) { + pb_1.Message.setWrapperField(this, 9, value); + } + static fromObject(data) { + const message = new Bid({}); + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + if (data.bidder_address != null) { + message.bidder_address = data.bidder_address; + } + if (data.status != null) { + message.status = data.status; + } + if (data.commit_hash != null) { + message.commit_hash = data.commit_hash; + } + if (data.commit_time != null) { + message.commit_time = dependency_3.google.protobuf.Timestamp.fromObject(data.commit_time); + } + if (data.commit_fee != null) { + message.commit_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.commit_fee); + } + if (data.reveal_time != null) { + message.reveal_time = dependency_3.google.protobuf.Timestamp.fromObject(data.reveal_time); + } + if (data.reveal_fee != null) { + message.reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.reveal_fee); + } + if (data.bid_amount != null) { + message.bid_amount = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.bid_amount); + } + return message; + } + toObject() { + const data = {}; + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + if (this.bidder_address != null) { + data.bidder_address = this.bidder_address; + } + if (this.status != null) { + data.status = this.status; + } + if (this.commit_hash != null) { + data.commit_hash = this.commit_hash; + } + if (this.commit_time != null) { + data.commit_time = this.commit_time.toObject(); + } + if (this.commit_fee != null) { + data.commit_fee = this.commit_fee.toObject(); + } + if (this.reveal_time != null) { + data.reveal_time = this.reveal_time.toObject(); + } + if (this.reveal_fee != null) { + data.reveal_fee = this.reveal_fee.toObject(); + } + if (this.bid_amount != null) { + data.bid_amount = this.bid_amount.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(1, this.auction_id); + if (typeof this.bidder_address === "string" && this.bidder_address.length) + writer.writeString(2, this.bidder_address); + if (typeof this.status === "string" && this.status.length) + writer.writeString(3, this.status); + if (typeof this.commit_hash === "string" && this.commit_hash.length) + writer.writeString(4, this.commit_hash); + if (this.commit_time !== undefined) + writer.writeMessage(5, this.commit_time, () => this.commit_time.serialize(writer)); + if (this.commit_fee !== undefined) + writer.writeMessage(6, this.commit_fee, () => this.commit_fee.serialize(writer)); + if (this.reveal_time !== undefined) + writer.writeMessage(7, this.reveal_time, () => this.reveal_time.serialize(writer)); + if (this.reveal_fee !== undefined) + writer.writeMessage(8, this.reveal_fee, () => this.reveal_fee.serialize(writer)); + if (this.bid_amount !== undefined) + writer.writeMessage(9, this.bid_amount, () => this.bid_amount.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Bid(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.auction_id = reader.readString(); + break; + case 2: + message.bidder_address = reader.readString(); + break; + case 3: + message.status = reader.readString(); + break; + case 4: + message.commit_hash = reader.readString(); + break; + case 5: + reader.readMessage(message.commit_time, () => message.commit_time = dependency_3.google.protobuf.Timestamp.deserialize(reader)); + break; + case 6: + reader.readMessage(message.commit_fee, () => message.commit_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 7: + reader.readMessage(message.reveal_time, () => message.reveal_time = dependency_3.google.protobuf.Timestamp.deserialize(reader)); + break; + case 8: + reader.readMessage(message.reveal_fee, () => message.reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 9: + reader.readMessage(message.bid_amount, () => message.bid_amount = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Bid.deserialize(bytes); + } + } + v1beta1.Bid = Bid; + })(v1beta1 = auction.v1beta1 || (auction.v1beta1 = {})); + })(auction = vulcanize.auction || (vulcanize.auction = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/bond/v1beta1/bond.d.ts b/dist/proto/vulcanize/bond/v1beta1/bond.d.ts new file mode 100644 index 0000000..c4b7d4a --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/bond.d.ts @@ -0,0 +1,56 @@ +import * as dependency_2 from "./../../../cosmos/base/v1beta1/coin"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.bond.v1beta1 { + class Params extends pb_1.Message { + constructor(data?: any[] | { + max_bond_amount?: dependency_2.cosmos.base.v1beta1.Coin; + }); + get max_bond_amount(): dependency_2.cosmos.base.v1beta1.Coin; + set max_bond_amount(value: dependency_2.cosmos.base.v1beta1.Coin); + static fromObject(data: { + max_bond_amount?: ReturnType; + }): Params; + toObject(): { + max_bond_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Params; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Params; + } + class Bond extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + owner?: string; + balance?: dependency_2.cosmos.base.v1beta1.Coin[]; + }); + get id(): string; + set id(value: string); + get owner(): string; + set owner(value: string); + get balance(): dependency_2.cosmos.base.v1beta1.Coin[]; + set balance(value: dependency_2.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + id?: string; + owner?: string; + balance?: ReturnType[]; + }): Bond; + toObject(): { + id?: string | undefined; + owner?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Bond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Bond; + } +} diff --git a/dist/proto/vulcanize/bond/v1beta1/bond.js b/dist/proto/vulcanize/bond/v1beta1/bond.js new file mode 100644 index 0000000..928daa3 --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/bond.js @@ -0,0 +1,195 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var bond; + (function (bond) { + var v1beta1; + (function (v1beta1) { + class Params extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("max_bond_amount" in data && data.max_bond_amount != undefined) { + this.max_bond_amount = data.max_bond_amount; + } + } + } + get max_bond_amount() { + return pb_1.Message.getWrapperField(this, dependency_2.cosmos.base.v1beta1.Coin, 1); + } + set max_bond_amount(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new Params({}); + if (data.max_bond_amount != null) { + message.max_bond_amount = dependency_2.cosmos.base.v1beta1.Coin.fromObject(data.max_bond_amount); + } + return message; + } + toObject() { + const data = {}; + if (this.max_bond_amount != null) { + data.max_bond_amount = this.max_bond_amount.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.max_bond_amount !== undefined) + writer.writeMessage(1, this.max_bond_amount, () => this.max_bond_amount.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Params(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.max_bond_amount, () => message.max_bond_amount = dependency_2.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Params.deserialize(bytes); + } + } + v1beta1.Params = Params; + class Bond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("owner" in data && data.owner != undefined) { + this.owner = data.owner; + } + if ("balance" in data && data.balance != undefined) { + this.balance = data.balance; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get owner() { + return pb_1.Message.getField(this, 2); + } + set owner(value) { + pb_1.Message.setField(this, 2, value); + } + get balance() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.cosmos.base.v1beta1.Coin, 3); + } + set balance(value) { + pb_1.Message.setRepeatedWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new Bond({}); + if (data.id != null) { + message.id = data.id; + } + if (data.owner != null) { + message.owner = data.owner; + } + if (data.balance != null) { + message.balance = data.balance.map(item => dependency_2.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.owner != null) { + data.owner = this.owner; + } + if (this.balance != null) { + data.balance = this.balance.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (typeof this.owner === "string" && this.owner.length) + writer.writeString(2, this.owner); + if (this.balance !== undefined) + writer.writeRepeatedMessage(3, this.balance, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Bond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.owner = reader.readString(); + break; + case 3: + reader.readMessage(message.balance, () => pb_1.Message.addToRepeatedWrapperField(message, 3, dependency_2.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_2.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Bond.deserialize(bytes); + } + } + v1beta1.Bond = Bond; + })(v1beta1 = bond.v1beta1 || (bond.v1beta1 = {})); + })(bond = vulcanize.bond || (vulcanize.bond = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/bond/v1beta1/genesis.d.ts b/dist/proto/vulcanize/bond/v1beta1/genesis.d.ts new file mode 100644 index 0000000..313b56e --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/genesis.d.ts @@ -0,0 +1,39 @@ +import * as dependency_2 from "./bond"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.bond.v1beta1 { + class GenesisState extends pb_1.Message { + constructor(data?: any[] | { + params?: dependency_2.vulcanize.bond.v1beta1.Params; + bonds?: dependency_2.vulcanize.bond.v1beta1.Bond[]; + }); + get params(): dependency_2.vulcanize.bond.v1beta1.Params; + set params(value: dependency_2.vulcanize.bond.v1beta1.Params); + get bonds(): dependency_2.vulcanize.bond.v1beta1.Bond[]; + set bonds(value: dependency_2.vulcanize.bond.v1beta1.Bond[]); + static fromObject(data: { + params?: ReturnType; + bonds?: ReturnType[]; + }): GenesisState; + toObject(): { + params?: { + max_bond_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + bonds?: { + id?: string | undefined; + owner?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GenesisState; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): GenesisState; + } +} diff --git a/dist/proto/vulcanize/bond/v1beta1/genesis.js b/dist/proto/vulcanize/bond/v1beta1/genesis.js new file mode 100644 index 0000000..9c59323 --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/genesis.js @@ -0,0 +1,116 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./bond")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var bond; + (function (bond) { + var v1beta1; + (function (v1beta1) { + class GenesisState extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("params" in data && data.params != undefined) { + this.params = data.params; + } + if ("bonds" in data && data.bonds != undefined) { + this.bonds = data.bonds; + } + } + } + get params() { + return pb_1.Message.getWrapperField(this, dependency_2.vulcanize.bond.v1beta1.Params, 1); + } + set params(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get bonds() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.bond.v1beta1.Bond, 2); + } + set bonds(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new GenesisState({}); + if (data.params != null) { + message.params = dependency_2.vulcanize.bond.v1beta1.Params.fromObject(data.params); + } + if (data.bonds != null) { + message.bonds = data.bonds.map(item => dependency_2.vulcanize.bond.v1beta1.Bond.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.params != null) { + data.params = this.params.toObject(); + } + if (this.bonds != null) { + data.bonds = this.bonds.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.params !== undefined) + writer.writeMessage(1, this.params, () => this.params.serialize(writer)); + if (this.bonds !== undefined) + writer.writeRepeatedMessage(2, this.bonds, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new GenesisState(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.params, () => message.params = dependency_2.vulcanize.bond.v1beta1.Params.deserialize(reader)); + break; + case 2: + reader.readMessage(message.bonds, () => pb_1.Message.addToRepeatedWrapperField(message, 2, dependency_2.vulcanize.bond.v1beta1.Bond.deserialize(reader), dependency_2.vulcanize.bond.v1beta1.Bond)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return GenesisState.deserialize(bytes); + } + } + v1beta1.GenesisState = GenesisState; + })(v1beta1 = bond.v1beta1 || (bond.v1beta1 = {})); + })(bond = vulcanize.bond || (vulcanize.bond = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/bond/v1beta1/query.d.ts b/dist/proto/vulcanize/bond/v1beta1/query.d.ts new file mode 100644 index 0000000..cde1757 --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/query.d.ts @@ -0,0 +1,229 @@ +import * as dependency_2 from "./bond"; +import * as dependency_4 from "./../../../cosmos/base/query/v1beta1/pagination"; +import * as dependency_5 from "./../../../cosmos/base/v1beta1/coin"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.bond.v1beta1 { + class QueryParamsRequest extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): QueryParamsRequest; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryParamsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryParamsRequest; + } + class QueryParamsResponse extends pb_1.Message { + constructor(data?: any[] | { + params?: dependency_2.vulcanize.bond.v1beta1.Params; + }); + get params(): dependency_2.vulcanize.bond.v1beta1.Params; + set params(value: dependency_2.vulcanize.bond.v1beta1.Params); + static fromObject(data: { + params?: ReturnType; + }): QueryParamsResponse; + toObject(): { + params?: { + max_bond_amount?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryParamsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryParamsResponse; + } + class QueryGetBondsRequest extends pb_1.Message { + constructor(data?: any[] | { + pagination?: dependency_4.cosmos.base.query.v1beta1.PageRequest; + }); + get pagination(): dependency_4.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_4.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + pagination?: ReturnType; + }): QueryGetBondsRequest; + toObject(): { + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondsRequest; + } + class QueryGetBondsResponse extends pb_1.Message { + constructor(data?: any[] | { + bonds?: dependency_2.vulcanize.bond.v1beta1.Bond[]; + pagination?: dependency_4.cosmos.base.query.v1beta1.PageResponse; + }); + get bonds(): dependency_2.vulcanize.bond.v1beta1.Bond[]; + set bonds(value: dependency_2.vulcanize.bond.v1beta1.Bond[]); + get pagination(): dependency_4.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_4.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + bonds?: ReturnType[]; + pagination?: ReturnType; + }): QueryGetBondsResponse; + toObject(): { + bonds?: { + id?: string | undefined; + owner?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondsResponse; + } + class QueryGetBondByIdRequest extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + }); + get id(): string; + set id(value: string); + static fromObject(data: { + id?: string; + }): QueryGetBondByIdRequest; + toObject(): { + id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondByIdRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondByIdRequest; + } + class QueryGetBondByIdResponse extends pb_1.Message { + constructor(data?: any[] | { + bond?: dependency_2.vulcanize.bond.v1beta1.Bond; + }); + get bond(): dependency_2.vulcanize.bond.v1beta1.Bond; + set bond(value: dependency_2.vulcanize.bond.v1beta1.Bond); + static fromObject(data: { + bond?: ReturnType; + }): QueryGetBondByIdResponse; + toObject(): { + bond?: { + id?: string | undefined; + owner?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondByIdResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondByIdResponse; + } + class QueryGetBondsByOwnerRequest extends pb_1.Message { + constructor(data?: any[] | { + owner?: string; + pagination?: dependency_4.cosmos.base.query.v1beta1.PageResponse; + }); + get owner(): string; + set owner(value: string); + get pagination(): dependency_4.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_4.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + owner?: string; + pagination?: ReturnType; + }): QueryGetBondsByOwnerRequest; + toObject(): { + owner?: string | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondsByOwnerRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondsByOwnerRequest; + } + class QueryGetBondsByOwnerResponse extends pb_1.Message { + constructor(data?: any[] | { + bonds?: dependency_2.vulcanize.bond.v1beta1.Bond[]; + pagination?: dependency_4.cosmos.base.query.v1beta1.PageResponse; + }); + get bonds(): dependency_2.vulcanize.bond.v1beta1.Bond[]; + set bonds(value: dependency_2.vulcanize.bond.v1beta1.Bond[]); + get pagination(): dependency_4.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_4.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + bonds?: ReturnType[]; + pagination?: ReturnType; + }): QueryGetBondsByOwnerResponse; + toObject(): { + bonds?: { + id?: string | undefined; + owner?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondsByOwnerResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondsByOwnerResponse; + } + class QueryGetBondModuleBalanceRequest extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): QueryGetBondModuleBalanceRequest; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondModuleBalanceRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondModuleBalanceRequest; + } + class QueryGetBondModuleBalanceResponse extends pb_1.Message { + constructor(data?: any[] | { + balance?: dependency_5.cosmos.base.v1beta1.Coin[]; + }); + get balance(): dependency_5.cosmos.base.v1beta1.Coin[]; + set balance(value: dependency_5.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + balance?: ReturnType[]; + }): QueryGetBondModuleBalanceResponse; + toObject(): { + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetBondModuleBalanceResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetBondModuleBalanceResponse; + } +} diff --git a/dist/proto/vulcanize/bond/v1beta1/query.js b/dist/proto/vulcanize/bond/v1beta1/query.js new file mode 100644 index 0000000..c0434f7 --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/query.js @@ -0,0 +1,647 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./bond")); +const dependency_4 = __importStar(require("./../../../cosmos/base/query/v1beta1/pagination")); +const dependency_5 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var bond; + (function (bond) { + var v1beta1; + (function (v1beta1) { + class QueryParamsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new QueryParamsRequest({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryParamsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryParamsRequest.deserialize(bytes); + } + } + v1beta1.QueryParamsRequest = QueryParamsRequest; + class QueryParamsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("params" in data && data.params != undefined) { + this.params = data.params; + } + } + } + get params() { + return pb_1.Message.getWrapperField(this, dependency_2.vulcanize.bond.v1beta1.Params, 1); + } + set params(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryParamsResponse({}); + if (data.params != null) { + message.params = dependency_2.vulcanize.bond.v1beta1.Params.fromObject(data.params); + } + return message; + } + toObject() { + const data = {}; + if (this.params != null) { + data.params = this.params.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.params !== undefined) + writer.writeMessage(1, this.params, () => this.params.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryParamsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.params, () => message.params = dependency_2.vulcanize.bond.v1beta1.Params.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryParamsResponse.deserialize(bytes); + } + } + v1beta1.QueryParamsResponse = QueryParamsResponse; + class QueryGetBondsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.query.v1beta1.PageRequest, 1); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryGetBondsRequest({}); + if (data.pagination != null) { + message.pagination = dependency_4.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.pagination !== undefined) + writer.writeMessage(1, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.pagination, () => message.pagination = dependency_4.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondsRequest.deserialize(bytes); + } + } + v1beta1.QueryGetBondsRequest = QueryGetBondsRequest; + class QueryGetBondsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bonds" in data && data.bonds != undefined) { + this.bonds = data.bonds; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get bonds() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.bond.v1beta1.Bond, 1); + } + set bonds(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryGetBondsResponse({}); + if (data.bonds != null) { + message.bonds = data.bonds.map(item => dependency_2.vulcanize.bond.v1beta1.Bond.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_4.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.bonds != null) { + data.bonds = this.bonds.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.bonds !== undefined) + writer.writeRepeatedMessage(1, this.bonds, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.bonds, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_2.vulcanize.bond.v1beta1.Bond.deserialize(reader), dependency_2.vulcanize.bond.v1beta1.Bond)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_4.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondsResponse.deserialize(bytes); + } + } + v1beta1.QueryGetBondsResponse = QueryGetBondsResponse; + class QueryGetBondByIdRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new QueryGetBondByIdRequest({}); + if (data.id != null) { + message.id = data.id; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondByIdRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondByIdRequest.deserialize(bytes); + } + } + v1beta1.QueryGetBondByIdRequest = QueryGetBondByIdRequest; + class QueryGetBondByIdResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bond" in data && data.bond != undefined) { + this.bond = data.bond; + } + } + } + get bond() { + return pb_1.Message.getWrapperField(this, dependency_2.vulcanize.bond.v1beta1.Bond, 1); + } + set bond(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryGetBondByIdResponse({}); + if (data.bond != null) { + message.bond = dependency_2.vulcanize.bond.v1beta1.Bond.fromObject(data.bond); + } + return message; + } + toObject() { + const data = {}; + if (this.bond != null) { + data.bond = this.bond.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.bond !== undefined) + writer.writeMessage(1, this.bond, () => this.bond.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondByIdResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.bond, () => message.bond = dependency_2.vulcanize.bond.v1beta1.Bond.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondByIdResponse.deserialize(bytes); + } + } + v1beta1.QueryGetBondByIdResponse = QueryGetBondByIdResponse; + class QueryGetBondsByOwnerRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("owner" in data && data.owner != undefined) { + this.owner = data.owner; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get owner() { + return pb_1.Message.getField(this, 1); + } + set owner(value) { + pb_1.Message.setField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryGetBondsByOwnerRequest({}); + if (data.owner != null) { + message.owner = data.owner; + } + if (data.pagination != null) { + message.pagination = dependency_4.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.owner != null) { + data.owner = this.owner; + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.owner === "string" && this.owner.length) + writer.writeString(1, this.owner); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondsByOwnerRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.owner = reader.readString(); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_4.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondsByOwnerRequest.deserialize(bytes); + } + } + v1beta1.QueryGetBondsByOwnerRequest = QueryGetBondsByOwnerRequest; + class QueryGetBondsByOwnerResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bonds" in data && data.bonds != undefined) { + this.bonds = data.bonds; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get bonds() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.bond.v1beta1.Bond, 1); + } + set bonds(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryGetBondsByOwnerResponse({}); + if (data.bonds != null) { + message.bonds = data.bonds.map(item => dependency_2.vulcanize.bond.v1beta1.Bond.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_4.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.bonds != null) { + data.bonds = this.bonds.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.bonds !== undefined) + writer.writeRepeatedMessage(1, this.bonds, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondsByOwnerResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.bonds, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_2.vulcanize.bond.v1beta1.Bond.deserialize(reader), dependency_2.vulcanize.bond.v1beta1.Bond)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_4.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondsByOwnerResponse.deserialize(bytes); + } + } + v1beta1.QueryGetBondsByOwnerResponse = QueryGetBondsByOwnerResponse; + class QueryGetBondModuleBalanceRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new QueryGetBondModuleBalanceRequest({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondModuleBalanceRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondModuleBalanceRequest.deserialize(bytes); + } + } + v1beta1.QueryGetBondModuleBalanceRequest = QueryGetBondModuleBalanceRequest; + class QueryGetBondModuleBalanceResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("balance" in data && data.balance != undefined) { + this.balance = data.balance; + } + } + } + get balance() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_5.cosmos.base.v1beta1.Coin, 2); + } + set balance(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryGetBondModuleBalanceResponse({}); + if (data.balance != null) { + message.balance = data.balance.map(item => dependency_5.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.balance != null) { + data.balance = this.balance.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.balance !== undefined) + writer.writeRepeatedMessage(2, this.balance, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetBondModuleBalanceResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 2: + reader.readMessage(message.balance, () => pb_1.Message.addToRepeatedWrapperField(message, 2, dependency_5.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_5.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetBondModuleBalanceResponse.deserialize(bytes); + } + } + v1beta1.QueryGetBondModuleBalanceResponse = QueryGetBondModuleBalanceResponse; + })(v1beta1 = bond.v1beta1 || (bond.v1beta1 = {})); + })(bond = vulcanize.bond || (vulcanize.bond = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/bond/v1beta1/tx.d.ts b/dist/proto/vulcanize/bond/v1beta1/tx.d.ts new file mode 100644 index 0000000..43e83bd --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/tx.d.ts @@ -0,0 +1,163 @@ +import * as dependency_2 from "./../../../cosmos/base/v1beta1/coin"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.bond.v1beta1 { + class MsgCreateBond extends pb_1.Message { + constructor(data?: any[] | { + signer?: string; + coins?: dependency_2.cosmos.base.v1beta1.Coin[]; + }); + get signer(): string; + set signer(value: string); + get coins(): dependency_2.cosmos.base.v1beta1.Coin[]; + set coins(value: dependency_2.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + signer?: string; + coins?: ReturnType[]; + }): MsgCreateBond; + toObject(): { + signer?: string | undefined; + coins?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCreateBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCreateBond; + } + class MsgCreateBondResponse extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + }); + get id(): string; + set id(value: string); + static fromObject(data: { + id?: string; + }): MsgCreateBondResponse; + toObject(): { + id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCreateBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCreateBondResponse; + } + class MsgRefillBond extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + signer?: string; + coins?: dependency_2.cosmos.base.v1beta1.Coin[]; + }); + get id(): string; + set id(value: string); + get signer(): string; + set signer(value: string); + get coins(): dependency_2.cosmos.base.v1beta1.Coin[]; + set coins(value: dependency_2.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + id?: string; + signer?: string; + coins?: ReturnType[]; + }): MsgRefillBond; + toObject(): { + id?: string | undefined; + signer?: string | undefined; + coins?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgRefillBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgRefillBond; + } + class MsgRefillBondResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgRefillBondResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgRefillBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgRefillBondResponse; + } + class MsgWithdrawBond extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + signer?: string; + coins?: dependency_2.cosmos.base.v1beta1.Coin[]; + }); + get id(): string; + set id(value: string); + get signer(): string; + set signer(value: string); + get coins(): dependency_2.cosmos.base.v1beta1.Coin[]; + set coins(value: dependency_2.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + id?: string; + signer?: string; + coins?: ReturnType[]; + }): MsgWithdrawBond; + toObject(): { + id?: string | undefined; + signer?: string | undefined; + coins?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgWithdrawBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgWithdrawBond; + } + class MsgWithdrawBondResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgWithdrawBondResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgWithdrawBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgWithdrawBondResponse; + } + class MsgCancelBond extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + signer?: string; + }); + get id(): string; + set id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + id?: string; + signer?: string; + }): MsgCancelBond; + toObject(): { + id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCancelBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCancelBond; + } + class MsgCancelBondResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgCancelBondResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgCancelBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgCancelBondResponse; + } +} diff --git a/dist/proto/vulcanize/bond/v1beta1/tx.js b/dist/proto/vulcanize/bond/v1beta1/tx.js new file mode 100644 index 0000000..11a052e --- /dev/null +++ b/dist/proto/vulcanize/bond/v1beta1/tx.js @@ -0,0 +1,566 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var bond; + (function (bond) { + var v1beta1; + (function (v1beta1) { + class MsgCreateBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + if ("coins" in data && data.coins != undefined) { + this.coins = data.coins; + } + } + } + get signer() { + return pb_1.Message.getField(this, 1); + } + set signer(value) { + pb_1.Message.setField(this, 1, value); + } + get coins() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.cosmos.base.v1beta1.Coin, 2); + } + set coins(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new MsgCreateBond({}); + if (data.signer != null) { + message.signer = data.signer; + } + if (data.coins != null) { + message.coins = data.coins.map(item => dependency_2.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.signer != null) { + data.signer = this.signer; + } + if (this.coins != null) { + data.coins = this.coins.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(1, this.signer); + if (this.coins !== undefined) + writer.writeRepeatedMessage(2, this.coins, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCreateBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.signer = reader.readString(); + break; + case 2: + reader.readMessage(message.coins, () => pb_1.Message.addToRepeatedWrapperField(message, 2, dependency_2.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_2.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCreateBond.deserialize(bytes); + } + } + v1beta1.MsgCreateBond = MsgCreateBond; + class MsgCreateBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new MsgCreateBondResponse({}); + if (data.id != null) { + message.id = data.id; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCreateBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCreateBondResponse.deserialize(bytes); + } + } + v1beta1.MsgCreateBondResponse = MsgCreateBondResponse; + class MsgRefillBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + if ("coins" in data && data.coins != undefined) { + this.coins = data.coins; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + get coins() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.cosmos.base.v1beta1.Coin, 3); + } + set coins(value) { + pb_1.Message.setRepeatedWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new MsgRefillBond({}); + if (data.id != null) { + message.id = data.id; + } + if (data.signer != null) { + message.signer = data.signer; + } + if (data.coins != null) { + message.coins = data.coins.map(item => dependency_2.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.signer != null) { + data.signer = this.signer; + } + if (this.coins != null) { + data.coins = this.coins.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (this.coins !== undefined) + writer.writeRepeatedMessage(3, this.coins, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgRefillBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + case 3: + reader.readMessage(message.coins, () => pb_1.Message.addToRepeatedWrapperField(message, 3, dependency_2.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_2.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgRefillBond.deserialize(bytes); + } + } + v1beta1.MsgRefillBond = MsgRefillBond; + class MsgRefillBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgRefillBondResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgRefillBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgRefillBondResponse.deserialize(bytes); + } + } + v1beta1.MsgRefillBondResponse = MsgRefillBondResponse; + class MsgWithdrawBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + if ("coins" in data && data.coins != undefined) { + this.coins = data.coins; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + get coins() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.cosmos.base.v1beta1.Coin, 3); + } + set coins(value) { + pb_1.Message.setRepeatedWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new MsgWithdrawBond({}); + if (data.id != null) { + message.id = data.id; + } + if (data.signer != null) { + message.signer = data.signer; + } + if (data.coins != null) { + message.coins = data.coins.map(item => dependency_2.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.signer != null) { + data.signer = this.signer; + } + if (this.coins != null) { + data.coins = this.coins.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (this.coins !== undefined) + writer.writeRepeatedMessage(3, this.coins, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgWithdrawBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + case 3: + reader.readMessage(message.coins, () => pb_1.Message.addToRepeatedWrapperField(message, 3, dependency_2.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_2.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgWithdrawBond.deserialize(bytes); + } + } + v1beta1.MsgWithdrawBond = MsgWithdrawBond; + class MsgWithdrawBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgWithdrawBondResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgWithdrawBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgWithdrawBondResponse.deserialize(bytes); + } + } + v1beta1.MsgWithdrawBondResponse = MsgWithdrawBondResponse; + class MsgCancelBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new MsgCancelBond({}); + if (data.id != null) { + message.id = data.id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCancelBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCancelBond.deserialize(bytes); + } + } + v1beta1.MsgCancelBond = MsgCancelBond; + class MsgCancelBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgCancelBondResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgCancelBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgCancelBondResponse.deserialize(bytes); + } + } + v1beta1.MsgCancelBondResponse = MsgCancelBondResponse; + })(v1beta1 = bond.v1beta1 || (bond.v1beta1 = {})); + })(bond = vulcanize.bond || (vulcanize.bond = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/nameservice/v1beta1/genesis.d.ts b/dist/proto/vulcanize/nameservice/v1beta1/genesis.d.ts new file mode 100644 index 0000000..ad97223 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/genesis.d.ts @@ -0,0 +1,114 @@ +import * as dependency_2 from "./nameservice"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.nameservice.v1beta1 { + class GenesisState extends pb_1.Message { + constructor(data?: any[] | { + params?: dependency_2.vulcanize.nameservice.v1beta1.Params; + records?: dependency_2.vulcanize.nameservice.v1beta1.Record[]; + authorities?: dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry[]; + names?: dependency_2.vulcanize.nameservice.v1beta1.NameEntry[]; + }); + get params(): dependency_2.vulcanize.nameservice.v1beta1.Params; + set params(value: dependency_2.vulcanize.nameservice.v1beta1.Params); + get records(): dependency_2.vulcanize.nameservice.v1beta1.Record[]; + set records(value: dependency_2.vulcanize.nameservice.v1beta1.Record[]); + get authorities(): dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry[]; + set authorities(value: dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry[]); + get names(): dependency_2.vulcanize.nameservice.v1beta1.NameEntry[]; + set names(value: dependency_2.vulcanize.nameservice.v1beta1.NameEntry[]); + static fromObject(data: { + params?: ReturnType; + records?: ReturnType[]; + authorities?: ReturnType[]; + names?: ReturnType[]; + }): GenesisState; + toObject(): { + params?: { + record_rent?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + record_rent_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_rent?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_rent_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_grace_period?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_enabled?: boolean | undefined; + authority_auction_commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_auction_reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_auction_minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + records?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + }[] | undefined; + authorities?: { + name?: string | undefined; + entry?: { + owner_public_key?: string | undefined; + owner_address?: string | undefined; + height?: number | undefined; + status?: string | undefined; + auction_id?: string | undefined; + bond_id?: string | undefined; + expiry_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + } | undefined; + }[] | undefined; + names?: { + name?: string | undefined; + entry?: { + latest?: { + id?: string | undefined; + height?: number | undefined; + } | undefined; + history?: { + id?: string | undefined; + height?: number | undefined; + }[] | undefined; + } | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GenesisState; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): GenesisState; + } +} diff --git a/dist/proto/vulcanize/nameservice/v1beta1/genesis.js b/dist/proto/vulcanize/nameservice/v1beta1/genesis.js new file mode 100644 index 0000000..e54b609 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/genesis.js @@ -0,0 +1,156 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./nameservice")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var nameservice; + (function (nameservice) { + var v1beta1; + (function (v1beta1) { + class GenesisState extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3, 4], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("params" in data && data.params != undefined) { + this.params = data.params; + } + if ("records" in data && data.records != undefined) { + this.records = data.records; + } + if ("authorities" in data && data.authorities != undefined) { + this.authorities = data.authorities; + } + if ("names" in data && data.names != undefined) { + this.names = data.names; + } + } + } + get params() { + return pb_1.Message.getWrapperField(this, dependency_2.vulcanize.nameservice.v1beta1.Params, 1); + } + set params(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get records() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.nameservice.v1beta1.Record, 2); + } + set records(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + get authorities() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry, 3); + } + set authorities(value) { + pb_1.Message.setRepeatedWrapperField(this, 3, value); + } + get names() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.nameservice.v1beta1.NameEntry, 4); + } + set names(value) { + pb_1.Message.setRepeatedWrapperField(this, 4, value); + } + static fromObject(data) { + const message = new GenesisState({}); + if (data.params != null) { + message.params = dependency_2.vulcanize.nameservice.v1beta1.Params.fromObject(data.params); + } + if (data.records != null) { + message.records = data.records.map(item => dependency_2.vulcanize.nameservice.v1beta1.Record.fromObject(item)); + } + if (data.authorities != null) { + message.authorities = data.authorities.map(item => dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry.fromObject(item)); + } + if (data.names != null) { + message.names = data.names.map(item => dependency_2.vulcanize.nameservice.v1beta1.NameEntry.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.params != null) { + data.params = this.params.toObject(); + } + if (this.records != null) { + data.records = this.records.map((item) => item.toObject()); + } + if (this.authorities != null) { + data.authorities = this.authorities.map((item) => item.toObject()); + } + if (this.names != null) { + data.names = this.names.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.params !== undefined) + writer.writeMessage(1, this.params, () => this.params.serialize(writer)); + if (this.records !== undefined) + writer.writeRepeatedMessage(2, this.records, (item) => item.serialize(writer)); + if (this.authorities !== undefined) + writer.writeRepeatedMessage(3, this.authorities, (item) => item.serialize(writer)); + if (this.names !== undefined) + writer.writeRepeatedMessage(4, this.names, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new GenesisState(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.params, () => message.params = dependency_2.vulcanize.nameservice.v1beta1.Params.deserialize(reader)); + break; + case 2: + reader.readMessage(message.records, () => pb_1.Message.addToRepeatedWrapperField(message, 2, dependency_2.vulcanize.nameservice.v1beta1.Record.deserialize(reader), dependency_2.vulcanize.nameservice.v1beta1.Record)); + break; + case 3: + reader.readMessage(message.authorities, () => pb_1.Message.addToRepeatedWrapperField(message, 3, dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry.deserialize(reader), dependency_2.vulcanize.nameservice.v1beta1.AuthorityEntry)); + break; + case 4: + reader.readMessage(message.names, () => pb_1.Message.addToRepeatedWrapperField(message, 4, dependency_2.vulcanize.nameservice.v1beta1.NameEntry.deserialize(reader), dependency_2.vulcanize.nameservice.v1beta1.NameEntry)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return GenesisState.deserialize(bytes); + } + } + v1beta1.GenesisState = GenesisState; + })(v1beta1 = nameservice.v1beta1 || (nameservice.v1beta1 = {})); + })(nameservice = vulcanize.nameservice || (vulcanize.nameservice = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/nameservice/v1beta1/nameservice.d.ts b/dist/proto/vulcanize/nameservice/v1beta1/nameservice.d.ts new file mode 100644 index 0000000..c7fb09d --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/nameservice.d.ts @@ -0,0 +1,423 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: vulcanize/nameservice/v1beta1/nameservice.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as dependency_1 from "./../../../google/protobuf/duration"; +import * as dependency_2 from "./../../../google/protobuf/timestamp"; +import * as dependency_4 from "./../../../cosmos/base/v1beta1/coin"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.nameservice.v1beta1 { + class Params extends pb_1.Message { + constructor(data?: any[] | { + record_rent?: dependency_4.cosmos.base.v1beta1.Coin; + record_rent_duration?: dependency_1.google.protobuf.Duration; + authority_rent?: dependency_4.cosmos.base.v1beta1.Coin; + authority_rent_duration?: dependency_1.google.protobuf.Duration; + authority_grace_period?: dependency_1.google.protobuf.Duration; + authority_auction_enabled?: boolean; + authority_auction_commits_duration?: dependency_1.google.protobuf.Duration; + authority_auction_reveals_duration?: dependency_1.google.protobuf.Duration; + authority_auction_commit_fee?: dependency_4.cosmos.base.v1beta1.Coin; + authority_auction_reveal_fee?: dependency_4.cosmos.base.v1beta1.Coin; + authority_auction_minimum_bid?: dependency_4.cosmos.base.v1beta1.Coin; + }); + get record_rent(): dependency_4.cosmos.base.v1beta1.Coin; + set record_rent(value: dependency_4.cosmos.base.v1beta1.Coin); + get record_rent_duration(): dependency_1.google.protobuf.Duration; + set record_rent_duration(value: dependency_1.google.protobuf.Duration); + get authority_rent(): dependency_4.cosmos.base.v1beta1.Coin; + set authority_rent(value: dependency_4.cosmos.base.v1beta1.Coin); + get authority_rent_duration(): dependency_1.google.protobuf.Duration; + set authority_rent_duration(value: dependency_1.google.protobuf.Duration); + get authority_grace_period(): dependency_1.google.protobuf.Duration; + set authority_grace_period(value: dependency_1.google.protobuf.Duration); + get authority_auction_enabled(): boolean; + set authority_auction_enabled(value: boolean); + get authority_auction_commits_duration(): dependency_1.google.protobuf.Duration; + set authority_auction_commits_duration(value: dependency_1.google.protobuf.Duration); + get authority_auction_reveals_duration(): dependency_1.google.protobuf.Duration; + set authority_auction_reveals_duration(value: dependency_1.google.protobuf.Duration); + get authority_auction_commit_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set authority_auction_commit_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get authority_auction_reveal_fee(): dependency_4.cosmos.base.v1beta1.Coin; + set authority_auction_reveal_fee(value: dependency_4.cosmos.base.v1beta1.Coin); + get authority_auction_minimum_bid(): dependency_4.cosmos.base.v1beta1.Coin; + set authority_auction_minimum_bid(value: dependency_4.cosmos.base.v1beta1.Coin); + static fromObject(data: { + record_rent?: ReturnType; + record_rent_duration?: ReturnType; + authority_rent?: ReturnType; + authority_rent_duration?: ReturnType; + authority_grace_period?: ReturnType; + authority_auction_enabled?: boolean; + authority_auction_commits_duration?: ReturnType; + authority_auction_reveals_duration?: ReturnType; + authority_auction_commit_fee?: ReturnType; + authority_auction_reveal_fee?: ReturnType; + authority_auction_minimum_bid?: ReturnType; + }): Params; + toObject(): { + record_rent?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + record_rent_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_rent?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_rent_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_grace_period?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_enabled?: boolean | undefined; + authority_auction_commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_auction_reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_auction_minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Params; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Params; + } + class Record extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + bond_id?: string; + create_time?: string; + expiry_time?: string; + deleted?: boolean; + owners?: string[]; + attributes?: string; + names?: string[]; + }); + get id(): string; + set id(value: string); + get bond_id(): string; + set bond_id(value: string); + get create_time(): string; + set create_time(value: string); + get expiry_time(): string; + set expiry_time(value: string); + get deleted(): boolean; + set deleted(value: boolean); + get owners(): string[]; + set owners(value: string[]); + get attributes(): string; + set attributes(value: string); + get names(): string[]; + set names(value: string[]); + static fromObject(data: { + id?: string; + bond_id?: string; + create_time?: string; + expiry_time?: string; + deleted?: boolean; + owners?: string[]; + attributes?: string; + names?: string[]; + }): Record; + toObject(): { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Record; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Record; + } + class AuthorityEntry extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + entry?: NameAuthority; + }); + get name(): string; + set name(value: string); + get entry(): NameAuthority; + set entry(value: NameAuthority); + static fromObject(data: { + name?: string; + entry?: ReturnType; + }): AuthorityEntry; + toObject(): { + name?: string | undefined; + entry?: { + owner_public_key?: string | undefined; + owner_address?: string | undefined; + height?: number | undefined; + status?: string | undefined; + auction_id?: string | undefined; + bond_id?: string | undefined; + expiry_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuthorityEntry; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuthorityEntry; + } + class NameAuthority extends pb_1.Message { + constructor(data?: any[] | { + owner_public_key?: string; + owner_address?: string; + height?: number; + status?: string; + auction_id?: string; + bond_id?: string; + expiry_time?: dependency_2.google.protobuf.Timestamp; + }); + get owner_public_key(): string; + set owner_public_key(value: string); + get owner_address(): string; + set owner_address(value: string); + get height(): number; + set height(value: number); + get status(): string; + set status(value: string); + get auction_id(): string; + set auction_id(value: string); + get bond_id(): string; + set bond_id(value: string); + get expiry_time(): dependency_2.google.protobuf.Timestamp; + set expiry_time(value: dependency_2.google.protobuf.Timestamp); + static fromObject(data: { + owner_public_key?: string; + owner_address?: string; + height?: number; + status?: string; + auction_id?: string; + bond_id?: string; + expiry_time?: ReturnType; + }): NameAuthority; + toObject(): { + owner_public_key?: string | undefined; + owner_address?: string | undefined; + height?: number | undefined; + status?: string | undefined; + auction_id?: string | undefined; + bond_id?: string | undefined; + expiry_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): NameAuthority; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): NameAuthority; + } + class NameEntry extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + entry?: NameRecord; + }); + get name(): string; + set name(value: string); + get entry(): NameRecord; + set entry(value: NameRecord); + static fromObject(data: { + name?: string; + entry?: ReturnType; + }): NameEntry; + toObject(): { + name?: string | undefined; + entry?: { + latest?: { + id?: string | undefined; + height?: number | undefined; + } | undefined; + history?: { + id?: string | undefined; + height?: number | undefined; + }[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): NameEntry; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): NameEntry; + } + class NameRecord extends pb_1.Message { + constructor(data?: any[] | { + latest?: NameRecordEntry; + history?: NameRecordEntry[]; + }); + get latest(): NameRecordEntry; + set latest(value: NameRecordEntry); + get history(): NameRecordEntry[]; + set history(value: NameRecordEntry[]); + static fromObject(data: { + latest?: ReturnType; + history?: ReturnType[]; + }): NameRecord; + toObject(): { + latest?: { + id?: string | undefined; + height?: number | undefined; + } | undefined; + history?: { + id?: string | undefined; + height?: number | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): NameRecord; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): NameRecord; + } + class NameRecordEntry extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + height?: number; + }); + get id(): string; + set id(value: string); + get height(): number; + set height(value: number); + static fromObject(data: { + id?: string; + height?: number; + }): NameRecordEntry; + toObject(): { + id?: string | undefined; + height?: number | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): NameRecordEntry; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): NameRecordEntry; + } + class Signature extends pb_1.Message { + constructor(data?: any[] | { + sig?: string; + pub_key?: string; + }); + get sig(): string; + set sig(value: string); + get pub_key(): string; + set pub_key(value: string); + static fromObject(data: { + sig?: string; + pub_key?: string; + }): Signature; + toObject(): { + sig?: string | undefined; + pub_key?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Signature; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Signature; + } + class BlockChangeSet extends pb_1.Message { + constructor(data?: any[] | { + height?: number; + records?: string[]; + auctions?: string[]; + auction_bids?: AuctionBidInfo[]; + authorities?: string[]; + names?: string[]; + }); + get height(): number; + set height(value: number); + get records(): string[]; + set records(value: string[]); + get auctions(): string[]; + set auctions(value: string[]); + get auction_bids(): AuctionBidInfo[]; + set auction_bids(value: AuctionBidInfo[]); + get authorities(): string[]; + set authorities(value: string[]); + get names(): string[]; + set names(value: string[]); + static fromObject(data: { + height?: number; + records?: string[]; + auctions?: string[]; + auction_bids?: ReturnType[]; + authorities?: string[]; + names?: string[]; + }): BlockChangeSet; + toObject(): { + height?: number | undefined; + records?: string[] | undefined; + auctions?: string[] | undefined; + auction_bids?: { + auction_id?: string | undefined; + bidder_address?: string | undefined; + }[] | undefined; + authorities?: string[] | undefined; + names?: string[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): BlockChangeSet; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): BlockChangeSet; + } + class AuctionBidInfo extends pb_1.Message { + constructor(data?: any[] | { + auction_id?: string; + bidder_address?: string; + }); + get auction_id(): string; + set auction_id(value: string); + get bidder_address(): string; + set bidder_address(value: string); + static fromObject(data: { + auction_id?: string; + bidder_address?: string; + }): AuctionBidInfo; + toObject(): { + auction_id?: string | undefined; + bidder_address?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AuctionBidInfo; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AuctionBidInfo; + } +} diff --git a/dist/proto/vulcanize/nameservice/v1beta1/nameservice.js b/dist/proto/vulcanize/nameservice/v1beta1/nameservice.js new file mode 100644 index 0000000..702f807 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/nameservice.js @@ -0,0 +1,1316 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: vulcanize/nameservice/v1beta1/nameservice.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const dependency_1 = __importStar(require("./../../../google/protobuf/duration")); +const dependency_2 = __importStar(require("./../../../google/protobuf/timestamp")); +const dependency_4 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var nameservice; + (function (nameservice) { + var v1beta1; + (function (v1beta1) { + class Params extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record_rent" in data && data.record_rent != undefined) { + this.record_rent = data.record_rent; + } + if ("record_rent_duration" in data && data.record_rent_duration != undefined) { + this.record_rent_duration = data.record_rent_duration; + } + if ("authority_rent" in data && data.authority_rent != undefined) { + this.authority_rent = data.authority_rent; + } + if ("authority_rent_duration" in data && data.authority_rent_duration != undefined) { + this.authority_rent_duration = data.authority_rent_duration; + } + if ("authority_grace_period" in data && data.authority_grace_period != undefined) { + this.authority_grace_period = data.authority_grace_period; + } + if ("authority_auction_enabled" in data && data.authority_auction_enabled != undefined) { + this.authority_auction_enabled = data.authority_auction_enabled; + } + if ("authority_auction_commits_duration" in data && data.authority_auction_commits_duration != undefined) { + this.authority_auction_commits_duration = data.authority_auction_commits_duration; + } + if ("authority_auction_reveals_duration" in data && data.authority_auction_reveals_duration != undefined) { + this.authority_auction_reveals_duration = data.authority_auction_reveals_duration; + } + if ("authority_auction_commit_fee" in data && data.authority_auction_commit_fee != undefined) { + this.authority_auction_commit_fee = data.authority_auction_commit_fee; + } + if ("authority_auction_reveal_fee" in data && data.authority_auction_reveal_fee != undefined) { + this.authority_auction_reveal_fee = data.authority_auction_reveal_fee; + } + if ("authority_auction_minimum_bid" in data && data.authority_auction_minimum_bid != undefined) { + this.authority_auction_minimum_bid = data.authority_auction_minimum_bid; + } + } + } + get record_rent() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 1); + } + set record_rent(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get record_rent_duration() { + return pb_1.Message.getWrapperField(this, dependency_1.google.protobuf.Duration, 2); + } + set record_rent_duration(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + get authority_rent() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 3); + } + set authority_rent(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + get authority_rent_duration() { + return pb_1.Message.getWrapperField(this, dependency_1.google.protobuf.Duration, 4); + } + set authority_rent_duration(value) { + pb_1.Message.setWrapperField(this, 4, value); + } + get authority_grace_period() { + return pb_1.Message.getWrapperField(this, dependency_1.google.protobuf.Duration, 5); + } + set authority_grace_period(value) { + pb_1.Message.setWrapperField(this, 5, value); + } + get authority_auction_enabled() { + return pb_1.Message.getField(this, 6); + } + set authority_auction_enabled(value) { + pb_1.Message.setField(this, 6, value); + } + get authority_auction_commits_duration() { + return pb_1.Message.getWrapperField(this, dependency_1.google.protobuf.Duration, 7); + } + set authority_auction_commits_duration(value) { + pb_1.Message.setWrapperField(this, 7, value); + } + get authority_auction_reveals_duration() { + return pb_1.Message.getWrapperField(this, dependency_1.google.protobuf.Duration, 8); + } + set authority_auction_reveals_duration(value) { + pb_1.Message.setWrapperField(this, 8, value); + } + get authority_auction_commit_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 9); + } + set authority_auction_commit_fee(value) { + pb_1.Message.setWrapperField(this, 9, value); + } + get authority_auction_reveal_fee() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 10); + } + set authority_auction_reveal_fee(value) { + pb_1.Message.setWrapperField(this, 10, value); + } + get authority_auction_minimum_bid() { + return pb_1.Message.getWrapperField(this, dependency_4.cosmos.base.v1beta1.Coin, 11); + } + set authority_auction_minimum_bid(value) { + pb_1.Message.setWrapperField(this, 11, value); + } + static fromObject(data) { + const message = new Params({}); + if (data.record_rent != null) { + message.record_rent = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.record_rent); + } + if (data.record_rent_duration != null) { + message.record_rent_duration = dependency_1.google.protobuf.Duration.fromObject(data.record_rent_duration); + } + if (data.authority_rent != null) { + message.authority_rent = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.authority_rent); + } + if (data.authority_rent_duration != null) { + message.authority_rent_duration = dependency_1.google.protobuf.Duration.fromObject(data.authority_rent_duration); + } + if (data.authority_grace_period != null) { + message.authority_grace_period = dependency_1.google.protobuf.Duration.fromObject(data.authority_grace_period); + } + if (data.authority_auction_enabled != null) { + message.authority_auction_enabled = data.authority_auction_enabled; + } + if (data.authority_auction_commits_duration != null) { + message.authority_auction_commits_duration = dependency_1.google.protobuf.Duration.fromObject(data.authority_auction_commits_duration); + } + if (data.authority_auction_reveals_duration != null) { + message.authority_auction_reveals_duration = dependency_1.google.protobuf.Duration.fromObject(data.authority_auction_reveals_duration); + } + if (data.authority_auction_commit_fee != null) { + message.authority_auction_commit_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.authority_auction_commit_fee); + } + if (data.authority_auction_reveal_fee != null) { + message.authority_auction_reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.authority_auction_reveal_fee); + } + if (data.authority_auction_minimum_bid != null) { + message.authority_auction_minimum_bid = dependency_4.cosmos.base.v1beta1.Coin.fromObject(data.authority_auction_minimum_bid); + } + return message; + } + toObject() { + const data = {}; + if (this.record_rent != null) { + data.record_rent = this.record_rent.toObject(); + } + if (this.record_rent_duration != null) { + data.record_rent_duration = this.record_rent_duration.toObject(); + } + if (this.authority_rent != null) { + data.authority_rent = this.authority_rent.toObject(); + } + if (this.authority_rent_duration != null) { + data.authority_rent_duration = this.authority_rent_duration.toObject(); + } + if (this.authority_grace_period != null) { + data.authority_grace_period = this.authority_grace_period.toObject(); + } + if (this.authority_auction_enabled != null) { + data.authority_auction_enabled = this.authority_auction_enabled; + } + if (this.authority_auction_commits_duration != null) { + data.authority_auction_commits_duration = this.authority_auction_commits_duration.toObject(); + } + if (this.authority_auction_reveals_duration != null) { + data.authority_auction_reveals_duration = this.authority_auction_reveals_duration.toObject(); + } + if (this.authority_auction_commit_fee != null) { + data.authority_auction_commit_fee = this.authority_auction_commit_fee.toObject(); + } + if (this.authority_auction_reveal_fee != null) { + data.authority_auction_reveal_fee = this.authority_auction_reveal_fee.toObject(); + } + if (this.authority_auction_minimum_bid != null) { + data.authority_auction_minimum_bid = this.authority_auction_minimum_bid.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.record_rent !== undefined) + writer.writeMessage(1, this.record_rent, () => this.record_rent.serialize(writer)); + if (this.record_rent_duration !== undefined) + writer.writeMessage(2, this.record_rent_duration, () => this.record_rent_duration.serialize(writer)); + if (this.authority_rent !== undefined) + writer.writeMessage(3, this.authority_rent, () => this.authority_rent.serialize(writer)); + if (this.authority_rent_duration !== undefined) + writer.writeMessage(4, this.authority_rent_duration, () => this.authority_rent_duration.serialize(writer)); + if (this.authority_grace_period !== undefined) + writer.writeMessage(5, this.authority_grace_period, () => this.authority_grace_period.serialize(writer)); + if (this.authority_auction_enabled !== undefined) + writer.writeBool(6, this.authority_auction_enabled); + if (this.authority_auction_commits_duration !== undefined) + writer.writeMessage(7, this.authority_auction_commits_duration, () => this.authority_auction_commits_duration.serialize(writer)); + if (this.authority_auction_reveals_duration !== undefined) + writer.writeMessage(8, this.authority_auction_reveals_duration, () => this.authority_auction_reveals_duration.serialize(writer)); + if (this.authority_auction_commit_fee !== undefined) + writer.writeMessage(9, this.authority_auction_commit_fee, () => this.authority_auction_commit_fee.serialize(writer)); + if (this.authority_auction_reveal_fee !== undefined) + writer.writeMessage(10, this.authority_auction_reveal_fee, () => this.authority_auction_reveal_fee.serialize(writer)); + if (this.authority_auction_minimum_bid !== undefined) + writer.writeMessage(11, this.authority_auction_minimum_bid, () => this.authority_auction_minimum_bid.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Params(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.record_rent, () => message.record_rent = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 2: + reader.readMessage(message.record_rent_duration, () => message.record_rent_duration = dependency_1.google.protobuf.Duration.deserialize(reader)); + break; + case 3: + reader.readMessage(message.authority_rent, () => message.authority_rent = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 4: + reader.readMessage(message.authority_rent_duration, () => message.authority_rent_duration = dependency_1.google.protobuf.Duration.deserialize(reader)); + break; + case 5: + reader.readMessage(message.authority_grace_period, () => message.authority_grace_period = dependency_1.google.protobuf.Duration.deserialize(reader)); + break; + case 6: + message.authority_auction_enabled = reader.readBool(); + break; + case 7: + reader.readMessage(message.authority_auction_commits_duration, () => message.authority_auction_commits_duration = dependency_1.google.protobuf.Duration.deserialize(reader)); + break; + case 8: + reader.readMessage(message.authority_auction_reveals_duration, () => message.authority_auction_reveals_duration = dependency_1.google.protobuf.Duration.deserialize(reader)); + break; + case 9: + reader.readMessage(message.authority_auction_commit_fee, () => message.authority_auction_commit_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 10: + reader.readMessage(message.authority_auction_reveal_fee, () => message.authority_auction_reveal_fee = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + case 11: + reader.readMessage(message.authority_auction_minimum_bid, () => message.authority_auction_minimum_bid = dependency_4.cosmos.base.v1beta1.Coin.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Params.deserialize(bytes); + } + } + v1beta1.Params = Params; + class Record extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [6, 8], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("bond_id" in data && data.bond_id != undefined) { + this.bond_id = data.bond_id; + } + if ("create_time" in data && data.create_time != undefined) { + this.create_time = data.create_time; + } + if ("expiry_time" in data && data.expiry_time != undefined) { + this.expiry_time = data.expiry_time; + } + if ("deleted" in data && data.deleted != undefined) { + this.deleted = data.deleted; + } + if ("owners" in data && data.owners != undefined) { + this.owners = data.owners; + } + if ("attributes" in data && data.attributes != undefined) { + this.attributes = data.attributes; + } + if ("names" in data && data.names != undefined) { + this.names = data.names; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get bond_id() { + return pb_1.Message.getField(this, 2); + } + set bond_id(value) { + pb_1.Message.setField(this, 2, value); + } + get create_time() { + return pb_1.Message.getField(this, 3); + } + set create_time(value) { + pb_1.Message.setField(this, 3, value); + } + get expiry_time() { + return pb_1.Message.getField(this, 4); + } + set expiry_time(value) { + pb_1.Message.setField(this, 4, value); + } + get deleted() { + return pb_1.Message.getField(this, 5); + } + set deleted(value) { + pb_1.Message.setField(this, 5, value); + } + get owners() { + return pb_1.Message.getField(this, 6); + } + set owners(value) { + pb_1.Message.setField(this, 6, value); + } + get attributes() { + return pb_1.Message.getField(this, 7); + } + set attributes(value) { + pb_1.Message.setField(this, 7, value); + } + get names() { + return pb_1.Message.getField(this, 8); + } + set names(value) { + pb_1.Message.setField(this, 8, value); + } + static fromObject(data) { + const message = new Record({}); + if (data.id != null) { + message.id = data.id; + } + if (data.bond_id != null) { + message.bond_id = data.bond_id; + } + if (data.create_time != null) { + message.create_time = data.create_time; + } + if (data.expiry_time != null) { + message.expiry_time = data.expiry_time; + } + if (data.deleted != null) { + message.deleted = data.deleted; + } + if (data.owners != null) { + message.owners = data.owners; + } + if (data.attributes != null) { + message.attributes = data.attributes; + } + if (data.names != null) { + message.names = data.names; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.bond_id != null) { + data.bond_id = this.bond_id; + } + if (this.create_time != null) { + data.create_time = this.create_time; + } + if (this.expiry_time != null) { + data.expiry_time = this.expiry_time; + } + if (this.deleted != null) { + data.deleted = this.deleted; + } + if (this.owners != null) { + data.owners = this.owners; + } + if (this.attributes != null) { + data.attributes = this.attributes; + } + if (this.names != null) { + data.names = this.names; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (typeof this.bond_id === "string" && this.bond_id.length) + writer.writeString(2, this.bond_id); + if (typeof this.create_time === "string" && this.create_time.length) + writer.writeString(3, this.create_time); + if (typeof this.expiry_time === "string" && this.expiry_time.length) + writer.writeString(4, this.expiry_time); + if (this.deleted !== undefined) + writer.writeBool(5, this.deleted); + if (this.owners !== undefined) + writer.writeRepeatedString(6, this.owners); + if (typeof this.attributes === "string" && this.attributes.length) + writer.writeString(7, this.attributes); + if (this.names !== undefined) + writer.writeRepeatedString(8, this.names); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Record(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.bond_id = reader.readString(); + break; + case 3: + message.create_time = reader.readString(); + break; + case 4: + message.expiry_time = reader.readString(); + break; + case 5: + message.deleted = reader.readBool(); + break; + case 6: + pb_1.Message.addToRepeatedField(message, 6, reader.readString()); + break; + case 7: + message.attributes = reader.readString(); + break; + case 8: + pb_1.Message.addToRepeatedField(message, 8, reader.readString()); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Record.deserialize(bytes); + } + } + v1beta1.Record = Record; + class AuthorityEntry extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("entry" in data && data.entry != undefined) { + this.entry = data.entry; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get entry() { + return pb_1.Message.getWrapperField(this, NameAuthority, 2); + } + set entry(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new AuthorityEntry({}); + if (data.name != null) { + message.name = data.name; + } + if (data.entry != null) { + message.entry = NameAuthority.fromObject(data.entry); + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.entry != null) { + data.entry = this.entry.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.entry !== undefined) + writer.writeMessage(2, this.entry, () => this.entry.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuthorityEntry(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + reader.readMessage(message.entry, () => message.entry = NameAuthority.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuthorityEntry.deserialize(bytes); + } + } + v1beta1.AuthorityEntry = AuthorityEntry; + class NameAuthority extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("owner_public_key" in data && data.owner_public_key != undefined) { + this.owner_public_key = data.owner_public_key; + } + if ("owner_address" in data && data.owner_address != undefined) { + this.owner_address = data.owner_address; + } + if ("height" in data && data.height != undefined) { + this.height = data.height; + } + if ("status" in data && data.status != undefined) { + this.status = data.status; + } + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + if ("bond_id" in data && data.bond_id != undefined) { + this.bond_id = data.bond_id; + } + if ("expiry_time" in data && data.expiry_time != undefined) { + this.expiry_time = data.expiry_time; + } + } + } + get owner_public_key() { + return pb_1.Message.getField(this, 1); + } + set owner_public_key(value) { + pb_1.Message.setField(this, 1, value); + } + get owner_address() { + return pb_1.Message.getField(this, 2); + } + set owner_address(value) { + pb_1.Message.setField(this, 2, value); + } + get height() { + return pb_1.Message.getField(this, 3); + } + set height(value) { + pb_1.Message.setField(this, 3, value); + } + get status() { + return pb_1.Message.getField(this, 4); + } + set status(value) { + pb_1.Message.setField(this, 4, value); + } + get auction_id() { + return pb_1.Message.getField(this, 5); + } + set auction_id(value) { + pb_1.Message.setField(this, 5, value); + } + get bond_id() { + return pb_1.Message.getField(this, 6); + } + set bond_id(value) { + pb_1.Message.setField(this, 6, value); + } + get expiry_time() { + return pb_1.Message.getWrapperField(this, dependency_2.google.protobuf.Timestamp, 7); + } + set expiry_time(value) { + pb_1.Message.setWrapperField(this, 7, value); + } + static fromObject(data) { + const message = new NameAuthority({}); + if (data.owner_public_key != null) { + message.owner_public_key = data.owner_public_key; + } + if (data.owner_address != null) { + message.owner_address = data.owner_address; + } + if (data.height != null) { + message.height = data.height; + } + if (data.status != null) { + message.status = data.status; + } + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + if (data.bond_id != null) { + message.bond_id = data.bond_id; + } + if (data.expiry_time != null) { + message.expiry_time = dependency_2.google.protobuf.Timestamp.fromObject(data.expiry_time); + } + return message; + } + toObject() { + const data = {}; + if (this.owner_public_key != null) { + data.owner_public_key = this.owner_public_key; + } + if (this.owner_address != null) { + data.owner_address = this.owner_address; + } + if (this.height != null) { + data.height = this.height; + } + if (this.status != null) { + data.status = this.status; + } + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + if (this.bond_id != null) { + data.bond_id = this.bond_id; + } + if (this.expiry_time != null) { + data.expiry_time = this.expiry_time.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.owner_public_key === "string" && this.owner_public_key.length) + writer.writeString(1, this.owner_public_key); + if (typeof this.owner_address === "string" && this.owner_address.length) + writer.writeString(2, this.owner_address); + if (this.height !== undefined) + writer.writeUint64(3, this.height); + if (typeof this.status === "string" && this.status.length) + writer.writeString(4, this.status); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(5, this.auction_id); + if (typeof this.bond_id === "string" && this.bond_id.length) + writer.writeString(6, this.bond_id); + if (this.expiry_time !== undefined) + writer.writeMessage(7, this.expiry_time, () => this.expiry_time.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new NameAuthority(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.owner_public_key = reader.readString(); + break; + case 2: + message.owner_address = reader.readString(); + break; + case 3: + message.height = reader.readUint64(); + break; + case 4: + message.status = reader.readString(); + break; + case 5: + message.auction_id = reader.readString(); + break; + case 6: + message.bond_id = reader.readString(); + break; + case 7: + reader.readMessage(message.expiry_time, () => message.expiry_time = dependency_2.google.protobuf.Timestamp.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return NameAuthority.deserialize(bytes); + } + } + v1beta1.NameAuthority = NameAuthority; + class NameEntry extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("entry" in data && data.entry != undefined) { + this.entry = data.entry; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get entry() { + return pb_1.Message.getWrapperField(this, NameRecord, 2); + } + set entry(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new NameEntry({}); + if (data.name != null) { + message.name = data.name; + } + if (data.entry != null) { + message.entry = NameRecord.fromObject(data.entry); + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.entry != null) { + data.entry = this.entry.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (this.entry !== undefined) + writer.writeMessage(2, this.entry, () => this.entry.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new NameEntry(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + reader.readMessage(message.entry, () => message.entry = NameRecord.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return NameEntry.deserialize(bytes); + } + } + v1beta1.NameEntry = NameEntry; + class NameRecord extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("latest" in data && data.latest != undefined) { + this.latest = data.latest; + } + if ("history" in data && data.history != undefined) { + this.history = data.history; + } + } + } + get latest() { + return pb_1.Message.getWrapperField(this, NameRecordEntry, 1); + } + set latest(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get history() { + return pb_1.Message.getRepeatedWrapperField(this, NameRecordEntry, 2); + } + set history(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new NameRecord({}); + if (data.latest != null) { + message.latest = NameRecordEntry.fromObject(data.latest); + } + if (data.history != null) { + message.history = data.history.map(item => NameRecordEntry.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.latest != null) { + data.latest = this.latest.toObject(); + } + if (this.history != null) { + data.history = this.history.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.latest !== undefined) + writer.writeMessage(1, this.latest, () => this.latest.serialize(writer)); + if (this.history !== undefined) + writer.writeRepeatedMessage(2, this.history, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new NameRecord(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.latest, () => message.latest = NameRecordEntry.deserialize(reader)); + break; + case 2: + reader.readMessage(message.history, () => pb_1.Message.addToRepeatedWrapperField(message, 2, NameRecordEntry.deserialize(reader), NameRecordEntry)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return NameRecord.deserialize(bytes); + } + } + v1beta1.NameRecord = NameRecord; + class NameRecordEntry extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("height" in data && data.height != undefined) { + this.height = data.height; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get height() { + return pb_1.Message.getField(this, 2); + } + set height(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new NameRecordEntry({}); + if (data.id != null) { + message.id = data.id; + } + if (data.height != null) { + message.height = data.height; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.height != null) { + data.height = this.height; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (this.height !== undefined) + writer.writeUint64(2, this.height); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new NameRecordEntry(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + message.height = reader.readUint64(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return NameRecordEntry.deserialize(bytes); + } + } + v1beta1.NameRecordEntry = NameRecordEntry; + class Signature extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("sig" in data && data.sig != undefined) { + this.sig = data.sig; + } + if ("pub_key" in data && data.pub_key != undefined) { + this.pub_key = data.pub_key; + } + } + } + get sig() { + return pb_1.Message.getField(this, 1); + } + set sig(value) { + pb_1.Message.setField(this, 1, value); + } + get pub_key() { + return pb_1.Message.getField(this, 2); + } + set pub_key(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new Signature({}); + if (data.sig != null) { + message.sig = data.sig; + } + if (data.pub_key != null) { + message.pub_key = data.pub_key; + } + return message; + } + toObject() { + const data = {}; + if (this.sig != null) { + data.sig = this.sig; + } + if (this.pub_key != null) { + data.pub_key = this.pub_key; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.sig === "string" && this.sig.length) + writer.writeString(1, this.sig); + if (typeof this.pub_key === "string" && this.pub_key.length) + writer.writeString(2, this.pub_key); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Signature(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.sig = reader.readString(); + break; + case 2: + message.pub_key = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Signature.deserialize(bytes); + } + } + v1beta1.Signature = Signature; + class BlockChangeSet extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2, 3, 4, 5, 6], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("height" in data && data.height != undefined) { + this.height = data.height; + } + if ("records" in data && data.records != undefined) { + this.records = data.records; + } + if ("auctions" in data && data.auctions != undefined) { + this.auctions = data.auctions; + } + if ("auction_bids" in data && data.auction_bids != undefined) { + this.auction_bids = data.auction_bids; + } + if ("authorities" in data && data.authorities != undefined) { + this.authorities = data.authorities; + } + if ("names" in data && data.names != undefined) { + this.names = data.names; + } + } + } + get height() { + return pb_1.Message.getField(this, 1); + } + set height(value) { + pb_1.Message.setField(this, 1, value); + } + get records() { + return pb_1.Message.getField(this, 2); + } + set records(value) { + pb_1.Message.setField(this, 2, value); + } + get auctions() { + return pb_1.Message.getField(this, 3); + } + set auctions(value) { + pb_1.Message.setField(this, 3, value); + } + get auction_bids() { + return pb_1.Message.getRepeatedWrapperField(this, AuctionBidInfo, 4); + } + set auction_bids(value) { + pb_1.Message.setRepeatedWrapperField(this, 4, value); + } + get authorities() { + return pb_1.Message.getField(this, 5); + } + set authorities(value) { + pb_1.Message.setField(this, 5, value); + } + get names() { + return pb_1.Message.getField(this, 6); + } + set names(value) { + pb_1.Message.setField(this, 6, value); + } + static fromObject(data) { + const message = new BlockChangeSet({}); + if (data.height != null) { + message.height = data.height; + } + if (data.records != null) { + message.records = data.records; + } + if (data.auctions != null) { + message.auctions = data.auctions; + } + if (data.auction_bids != null) { + message.auction_bids = data.auction_bids.map(item => AuctionBidInfo.fromObject(item)); + } + if (data.authorities != null) { + message.authorities = data.authorities; + } + if (data.names != null) { + message.names = data.names; + } + return message; + } + toObject() { + const data = {}; + if (this.height != null) { + data.height = this.height; + } + if (this.records != null) { + data.records = this.records; + } + if (this.auctions != null) { + data.auctions = this.auctions; + } + if (this.auction_bids != null) { + data.auction_bids = this.auction_bids.map((item) => item.toObject()); + } + if (this.authorities != null) { + data.authorities = this.authorities; + } + if (this.names != null) { + data.names = this.names; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.height !== undefined) + writer.writeInt64(1, this.height); + if (this.records !== undefined) + writer.writeRepeatedString(2, this.records); + if (this.auctions !== undefined) + writer.writeRepeatedString(3, this.auctions); + if (this.auction_bids !== undefined) + writer.writeRepeatedMessage(4, this.auction_bids, (item) => item.serialize(writer)); + if (this.authorities !== undefined) + writer.writeRepeatedString(5, this.authorities); + if (this.names !== undefined) + writer.writeRepeatedString(6, this.names); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new BlockChangeSet(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.height = reader.readInt64(); + break; + case 2: + pb_1.Message.addToRepeatedField(message, 2, reader.readString()); + break; + case 3: + pb_1.Message.addToRepeatedField(message, 3, reader.readString()); + break; + case 4: + reader.readMessage(message.auction_bids, () => pb_1.Message.addToRepeatedWrapperField(message, 4, AuctionBidInfo.deserialize(reader), AuctionBidInfo)); + break; + case 5: + pb_1.Message.addToRepeatedField(message, 5, reader.readString()); + break; + case 6: + pb_1.Message.addToRepeatedField(message, 6, reader.readString()); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return BlockChangeSet.deserialize(bytes); + } + } + v1beta1.BlockChangeSet = BlockChangeSet; + class AuctionBidInfo extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("auction_id" in data && data.auction_id != undefined) { + this.auction_id = data.auction_id; + } + if ("bidder_address" in data && data.bidder_address != undefined) { + this.bidder_address = data.bidder_address; + } + } + } + get auction_id() { + return pb_1.Message.getField(this, 1); + } + set auction_id(value) { + pb_1.Message.setField(this, 1, value); + } + get bidder_address() { + return pb_1.Message.getField(this, 2); + } + set bidder_address(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new AuctionBidInfo({}); + if (data.auction_id != null) { + message.auction_id = data.auction_id; + } + if (data.bidder_address != null) { + message.bidder_address = data.bidder_address; + } + return message; + } + toObject() { + const data = {}; + if (this.auction_id != null) { + data.auction_id = this.auction_id; + } + if (this.bidder_address != null) { + data.bidder_address = this.bidder_address; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.auction_id === "string" && this.auction_id.length) + writer.writeString(1, this.auction_id); + if (typeof this.bidder_address === "string" && this.bidder_address.length) + writer.writeString(2, this.bidder_address); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AuctionBidInfo(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.auction_id = reader.readString(); + break; + case 2: + message.bidder_address = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AuctionBidInfo.deserialize(bytes); + } + } + v1beta1.AuctionBidInfo = AuctionBidInfo; + })(v1beta1 = nameservice.v1beta1 || (nameservice.v1beta1 = {})); + })(nameservice = vulcanize.nameservice || (vulcanize.nameservice = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/nameservice/v1beta1/query.d.ts b/dist/proto/vulcanize/nameservice/v1beta1/query.d.ts new file mode 100644 index 0000000..8d37555 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/query.d.ts @@ -0,0 +1,773 @@ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: vulcanize/nameservice/v1beta1/query.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +import * as dependency_1 from "./nameservice"; +import * as dependency_3 from "./../../../cosmos/base/query/v1beta1/pagination"; +import * as dependency_5 from "./../../../cosmos/base/v1beta1/coin"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.nameservice.v1beta1 { + class QueryParamsRequest extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): QueryParamsRequest; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryParamsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryParamsRequest; + } + class QueryParamsResponse extends pb_1.Message { + constructor(data?: any[] | { + params?: dependency_1.vulcanize.nameservice.v1beta1.Params; + }); + get params(): dependency_1.vulcanize.nameservice.v1beta1.Params; + set params(value: dependency_1.vulcanize.nameservice.v1beta1.Params); + static fromObject(data: { + params?: ReturnType; + }): QueryParamsResponse; + toObject(): { + params?: { + record_rent?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + record_rent_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_rent?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_rent_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_grace_period?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_enabled?: boolean | undefined; + authority_auction_commits_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_reveals_duration?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + authority_auction_commit_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_auction_reveal_fee?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + authority_auction_minimum_bid?: { + denom?: string | undefined; + amount?: string | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryParamsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryParamsResponse; + } + class QueryListRecordsRequest extends pb_1.Message { + constructor(data?: any[] | { + attributes?: QueryListRecordsRequest.KeyValueInput[]; + all?: boolean; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get attributes(): QueryListRecordsRequest.KeyValueInput[]; + set attributes(value: QueryListRecordsRequest.KeyValueInput[]); + get all(): boolean; + set all(value: boolean); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + attributes?: ReturnType[]; + all?: boolean; + pagination?: ReturnType; + }): QueryListRecordsRequest; + toObject(): { + attributes?: { + key?: string | undefined; + value?: { + type?: string | undefined; + string?: string | undefined; + int?: number | undefined; + float?: number | undefined; + boolean?: boolean | undefined; + reference?: { + id?: string | undefined; + } | undefined; + values?: any[] | undefined; + } | undefined; + }[] | undefined; + all?: boolean | undefined; + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryListRecordsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryListRecordsRequest; + } + namespace QueryListRecordsRequest { + class ReferenceInput extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + }); + get id(): string; + set id(value: string); + static fromObject(data: { + id?: string; + }): ReferenceInput; + toObject(): { + id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ReferenceInput; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ReferenceInput; + } + class ValueInput extends pb_1.Message { + constructor(data?: any[] | { + type?: string; + string?: string; + int?: number; + float?: number; + boolean?: boolean; + reference?: QueryListRecordsRequest.ReferenceInput; + values?: QueryListRecordsRequest.ValueInput[]; + }); + get type(): string; + set type(value: string); + get string(): string; + set string(value: string); + get int(): number; + set int(value: number); + get float(): number; + set float(value: number); + get boolean(): boolean; + set boolean(value: boolean); + get reference(): QueryListRecordsRequest.ReferenceInput; + set reference(value: QueryListRecordsRequest.ReferenceInput); + get values(): QueryListRecordsRequest.ValueInput[]; + set values(value: QueryListRecordsRequest.ValueInput[]); + static fromObject(data: { + type?: string; + string?: string; + int?: number; + float?: number; + boolean?: boolean; + reference?: ReturnType; + values?: ReturnType[]; + }): ValueInput; + toObject(): { + type?: string | undefined; + string?: string | undefined; + int?: number | undefined; + float?: number | undefined; + boolean?: boolean | undefined; + reference?: { + id?: string | undefined; + } | undefined; + values?: { + type?: string | undefined; + string?: string | undefined; + int?: number | undefined; + float?: number | undefined; + boolean?: boolean | undefined; + reference?: { + id?: string | undefined; + } | undefined; + values?: any[] | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ValueInput; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ValueInput; + } + class KeyValueInput extends pb_1.Message { + constructor(data?: any[] | { + key?: string; + value?: QueryListRecordsRequest.ValueInput; + }); + get key(): string; + set key(value: string); + get value(): QueryListRecordsRequest.ValueInput; + set value(value: QueryListRecordsRequest.ValueInput); + static fromObject(data: { + key?: string; + value?: ReturnType; + }): KeyValueInput; + toObject(): { + key?: string | undefined; + value?: { + type?: string | undefined; + string?: string | undefined; + int?: number | undefined; + float?: number | undefined; + boolean?: boolean | undefined; + reference?: { + id?: string | undefined; + } | undefined; + values?: any[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): KeyValueInput; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): KeyValueInput; + } + } + class QueryListRecordsResponse extends pb_1.Message { + constructor(data?: any[] | { + records?: dependency_1.vulcanize.nameservice.v1beta1.Record[]; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageResponse; + }); + get records(): dependency_1.vulcanize.nameservice.v1beta1.Record[]; + set records(value: dependency_1.vulcanize.nameservice.v1beta1.Record[]); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + records?: ReturnType[]; + pagination?: ReturnType; + }): QueryListRecordsResponse; + toObject(): { + records?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryListRecordsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryListRecordsResponse; + } + class QueryRecordByIdRequest extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + }); + get id(): string; + set id(value: string); + static fromObject(data: { + id?: string; + }): QueryRecordByIdRequest; + toObject(): { + id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryRecordByIdRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryRecordByIdRequest; + } + class QueryRecordByIdResponse extends pb_1.Message { + constructor(data?: any[] | { + record?: dependency_1.vulcanize.nameservice.v1beta1.Record; + }); + get record(): dependency_1.vulcanize.nameservice.v1beta1.Record; + set record(value: dependency_1.vulcanize.nameservice.v1beta1.Record); + static fromObject(data: { + record?: ReturnType; + }): QueryRecordByIdResponse; + toObject(): { + record?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryRecordByIdResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryRecordByIdResponse; + } + class QueryRecordByBondIdRequest extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get id(): string; + set id(value: string); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + id?: string; + pagination?: ReturnType; + }): QueryRecordByBondIdRequest; + toObject(): { + id?: string | undefined; + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryRecordByBondIdRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryRecordByBondIdRequest; + } + class QueryRecordByBondIdResponse extends pb_1.Message { + constructor(data?: any[] | { + records?: dependency_1.vulcanize.nameservice.v1beta1.Record[]; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageResponse; + }); + get records(): dependency_1.vulcanize.nameservice.v1beta1.Record[]; + set records(value: dependency_1.vulcanize.nameservice.v1beta1.Record[]); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + records?: ReturnType[]; + pagination?: ReturnType; + }): QueryRecordByBondIdResponse; + toObject(): { + records?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryRecordByBondIdResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryRecordByBondIdResponse; + } + class GetNameServiceModuleBalanceRequest extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): GetNameServiceModuleBalanceRequest; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetNameServiceModuleBalanceRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): GetNameServiceModuleBalanceRequest; + } + class GetNameServiceModuleBalanceResponse extends pb_1.Message { + constructor(data?: any[] | { + balances?: AccountBalance[]; + }); + get balances(): AccountBalance[]; + set balances(value: AccountBalance[]); + static fromObject(data: { + balances?: ReturnType[]; + }): GetNameServiceModuleBalanceResponse; + toObject(): { + balances?: { + account_name?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): GetNameServiceModuleBalanceResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): GetNameServiceModuleBalanceResponse; + } + class AccountBalance extends pb_1.Message { + constructor(data?: any[] | { + account_name?: string; + balance?: dependency_5.cosmos.base.v1beta1.Coin[]; + }); + get account_name(): string; + set account_name(value: string); + get balance(): dependency_5.cosmos.base.v1beta1.Coin[]; + set balance(value: dependency_5.cosmos.base.v1beta1.Coin[]); + static fromObject(data: { + account_name?: string; + balance?: ReturnType[]; + }): AccountBalance; + toObject(): { + account_name?: string | undefined; + balance?: { + denom?: string | undefined; + amount?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): AccountBalance; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): AccountBalance; + } + class QueryListNameRecordsRequest extends pb_1.Message { + constructor(data?: any[] | { + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + pagination?: ReturnType; + }): QueryListNameRecordsRequest; + toObject(): { + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryListNameRecordsRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryListNameRecordsRequest; + } + class QueryListNameRecordsResponse extends pb_1.Message { + constructor(data?: any[] | { + names?: dependency_1.vulcanize.nameservice.v1beta1.NameEntry[]; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageResponse; + }); + get names(): dependency_1.vulcanize.nameservice.v1beta1.NameEntry[]; + set names(value: dependency_1.vulcanize.nameservice.v1beta1.NameEntry[]); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + names?: ReturnType[]; + pagination?: ReturnType; + }): QueryListNameRecordsResponse; + toObject(): { + names?: { + name?: string | undefined; + entry?: { + latest?: { + id?: string | undefined; + height?: number | undefined; + } | undefined; + history?: { + id?: string | undefined; + height?: number | undefined; + }[] | undefined; + } | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryListNameRecordsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryListNameRecordsResponse; + } + class QueryWhoisRequest extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + }); + get name(): string; + set name(value: string); + static fromObject(data: { + name?: string; + }): QueryWhoisRequest; + toObject(): { + name?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryWhoisRequest; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryWhoisRequest; + } + class QueryWhoisResponse extends pb_1.Message { + constructor(data?: any[] | { + name_authority?: dependency_1.vulcanize.nameservice.v1beta1.NameAuthority; + }); + get name_authority(): dependency_1.vulcanize.nameservice.v1beta1.NameAuthority; + set name_authority(value: dependency_1.vulcanize.nameservice.v1beta1.NameAuthority); + static fromObject(data: { + name_authority?: ReturnType; + }): QueryWhoisResponse; + toObject(): { + name_authority?: { + owner_public_key?: string | undefined; + owner_address?: string | undefined; + height?: number | undefined; + status?: string | undefined; + auction_id?: string | undefined; + bond_id?: string | undefined; + expiry_time?: { + seconds?: number | undefined; + nanos?: number | undefined; + } | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryWhoisResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryWhoisResponse; + } + class QueryLookupCrn extends pb_1.Message { + constructor(data?: any[] | { + crn?: string; + }); + get crn(): string; + set crn(value: string); + static fromObject(data: { + crn?: string; + }): QueryLookupCrn; + toObject(): { + crn?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryLookupCrn; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryLookupCrn; + } + class QueryLookupCrnResponse extends pb_1.Message { + constructor(data?: any[] | { + name?: dependency_1.vulcanize.nameservice.v1beta1.NameRecord; + }); + get name(): dependency_1.vulcanize.nameservice.v1beta1.NameRecord; + set name(value: dependency_1.vulcanize.nameservice.v1beta1.NameRecord); + static fromObject(data: { + name?: ReturnType; + }): QueryLookupCrnResponse; + toObject(): { + name?: { + latest?: { + id?: string | undefined; + height?: number | undefined; + } | undefined; + history?: { + id?: string | undefined; + height?: number | undefined; + }[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryLookupCrnResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryLookupCrnResponse; + } + class QueryResolveCrn extends pb_1.Message { + constructor(data?: any[] | { + crn?: string; + }); + get crn(): string; + set crn(value: string); + static fromObject(data: { + crn?: string; + }): QueryResolveCrn; + toObject(): { + crn?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryResolveCrn; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryResolveCrn; + } + class QueryResolveCrnResponse extends pb_1.Message { + constructor(data?: any[] | { + record?: dependency_1.vulcanize.nameservice.v1beta1.Record; + }); + get record(): dependency_1.vulcanize.nameservice.v1beta1.Record; + set record(value: dependency_1.vulcanize.nameservice.v1beta1.Record); + static fromObject(data: { + record?: ReturnType; + }): QueryResolveCrnResponse; + toObject(): { + record?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryResolveCrnResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryResolveCrnResponse; + } + class QueryGetRecordExpiryQueue extends pb_1.Message { + constructor(data?: any[] | { + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + pagination?: ReturnType; + }): QueryGetRecordExpiryQueue; + toObject(): { + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetRecordExpiryQueue; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetRecordExpiryQueue; + } + class QueryGetRecordExpiryQueueResponse extends pb_1.Message { + constructor(data?: any[] | { + records?: ExpiryQueueRecord[]; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageResponse; + }); + get records(): ExpiryQueueRecord[]; + set records(value: ExpiryQueueRecord[]); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + records?: ReturnType[]; + pagination?: ReturnType; + }): QueryGetRecordExpiryQueueResponse; + toObject(): { + records?: { + id?: string | undefined; + value?: string[] | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetRecordExpiryQueueResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetRecordExpiryQueueResponse; + } + class ExpiryQueueRecord extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + value?: string[]; + }); + get id(): string; + set id(value: string); + get value(): string[]; + set value(value: string[]); + static fromObject(data: { + id?: string; + value?: string[]; + }): ExpiryQueueRecord; + toObject(): { + id?: string | undefined; + value?: string[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): ExpiryQueueRecord; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): ExpiryQueueRecord; + } + class QueryGetAuthorityExpiryQueue extends pb_1.Message { + constructor(data?: any[] | { + pagination?: dependency_3.cosmos.base.query.v1beta1.PageRequest; + }); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageRequest; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageRequest); + static fromObject(data: { + pagination?: ReturnType; + }): QueryGetAuthorityExpiryQueue; + toObject(): { + pagination?: { + key?: Uint8Array | undefined; + offset?: number | undefined; + limit?: number | undefined; + count_total?: boolean | undefined; + reverse?: boolean | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetAuthorityExpiryQueue; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetAuthorityExpiryQueue; + } + class QueryGetAuthorityExpiryQueueResponse extends pb_1.Message { + constructor(data?: any[] | { + authorities?: ExpiryQueueRecord[]; + pagination?: dependency_3.cosmos.base.query.v1beta1.PageResponse; + }); + get authorities(): ExpiryQueueRecord[]; + set authorities(value: ExpiryQueueRecord[]); + get pagination(): dependency_3.cosmos.base.query.v1beta1.PageResponse; + set pagination(value: dependency_3.cosmos.base.query.v1beta1.PageResponse); + static fromObject(data: { + authorities?: ReturnType[]; + pagination?: ReturnType; + }): QueryGetAuthorityExpiryQueueResponse; + toObject(): { + authorities?: { + id?: string | undefined; + value?: string[] | undefined; + }[] | undefined; + pagination?: { + next_key?: Uint8Array | undefined; + total?: number | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): QueryGetAuthorityExpiryQueueResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): QueryGetAuthorityExpiryQueueResponse; + } +} diff --git a/dist/proto/vulcanize/nameservice/v1beta1/query.js b/dist/proto/vulcanize/nameservice/v1beta1/query.js new file mode 100644 index 0000000..9fd1494 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/query.js @@ -0,0 +1,1939 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +// @ts-nocheck +/* eslint-disable */ +/** + * Generated by the protoc-gen-ts. DO NOT EDIT! + * compiler version: 3.14.0 + * source: vulcanize/nameservice/v1beta1/query.proto + * git: https://github.com/thesayyn/protoc-gen-ts */ +const dependency_1 = __importStar(require("./nameservice")); +const dependency_3 = __importStar(require("./../../../cosmos/base/query/v1beta1/pagination")); +const dependency_5 = __importStar(require("./../../../cosmos/base/v1beta1/coin")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var nameservice; + (function (nameservice) { + var v1beta1; + (function (v1beta1) { + class QueryParamsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new QueryParamsRequest({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryParamsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryParamsRequest.deserialize(bytes); + } + } + v1beta1.QueryParamsRequest = QueryParamsRequest; + class QueryParamsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("params" in data && data.params != undefined) { + this.params = data.params; + } + } + } + get params() { + return pb_1.Message.getWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.Params, 1); + } + set params(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryParamsResponse({}); + if (data.params != null) { + message.params = dependency_1.vulcanize.nameservice.v1beta1.Params.fromObject(data.params); + } + return message; + } + toObject() { + const data = {}; + if (this.params != null) { + data.params = this.params.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.params !== undefined) + writer.writeMessage(1, this.params, () => this.params.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryParamsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.params, () => message.params = dependency_1.vulcanize.nameservice.v1beta1.Params.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryParamsResponse.deserialize(bytes); + } + } + v1beta1.QueryParamsResponse = QueryParamsResponse; + class QueryListRecordsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("attributes" in data && data.attributes != undefined) { + this.attributes = data.attributes; + } + if ("all" in data && data.all != undefined) { + this.all = data.all; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get attributes() { + return pb_1.Message.getRepeatedWrapperField(this, QueryListRecordsRequest.KeyValueInput, 1); + } + set attributes(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get all() { + return pb_1.Message.getField(this, 2); + } + set all(value) { + pb_1.Message.setField(this, 2, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 3); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new QueryListRecordsRequest({}); + if (data.attributes != null) { + message.attributes = data.attributes.map(item => QueryListRecordsRequest.KeyValueInput.fromObject(item)); + } + if (data.all != null) { + message.all = data.all; + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.attributes != null) { + data.attributes = this.attributes.map((item) => item.toObject()); + } + if (this.all != null) { + data.all = this.all; + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.attributes !== undefined) + writer.writeRepeatedMessage(1, this.attributes, (item) => item.serialize(writer)); + if (this.all !== undefined) + writer.writeBool(2, this.all); + if (this.pagination !== undefined) + writer.writeMessage(3, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryListRecordsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.attributes, () => pb_1.Message.addToRepeatedWrapperField(message, 1, QueryListRecordsRequest.KeyValueInput.deserialize(reader), QueryListRecordsRequest.KeyValueInput)); + break; + case 2: + message.all = reader.readBool(); + break; + case 3: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryListRecordsRequest.deserialize(bytes); + } + } + v1beta1.QueryListRecordsRequest = QueryListRecordsRequest; + (function (QueryListRecordsRequest) { + class ReferenceInput extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new ReferenceInput({}); + if (data.id != null) { + message.id = data.id; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ReferenceInput(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ReferenceInput.deserialize(bytes); + } + } + QueryListRecordsRequest.ReferenceInput = ReferenceInput; + class ValueInput extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [7], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("type" in data && data.type != undefined) { + this.type = data.type; + } + if ("string" in data && data.string != undefined) { + this.string = data.string; + } + if ("int" in data && data.int != undefined) { + this.int = data.int; + } + if ("float" in data && data.float != undefined) { + this.float = data.float; + } + if ("boolean" in data && data.boolean != undefined) { + this.boolean = data.boolean; + } + if ("reference" in data && data.reference != undefined) { + this.reference = data.reference; + } + if ("values" in data && data.values != undefined) { + this.values = data.values; + } + } + } + get type() { + return pb_1.Message.getField(this, 1); + } + set type(value) { + pb_1.Message.setField(this, 1, value); + } + get string() { + return pb_1.Message.getField(this, 2); + } + set string(value) { + pb_1.Message.setField(this, 2, value); + } + get int() { + return pb_1.Message.getField(this, 3); + } + set int(value) { + pb_1.Message.setField(this, 3, value); + } + get float() { + return pb_1.Message.getField(this, 4); + } + set float(value) { + pb_1.Message.setField(this, 4, value); + } + get boolean() { + return pb_1.Message.getField(this, 5); + } + set boolean(value) { + pb_1.Message.setField(this, 5, value); + } + get reference() { + return pb_1.Message.getWrapperField(this, QueryListRecordsRequest.ReferenceInput, 6); + } + set reference(value) { + pb_1.Message.setWrapperField(this, 6, value); + } + get values() { + return pb_1.Message.getRepeatedWrapperField(this, QueryListRecordsRequest.ValueInput, 7); + } + set values(value) { + pb_1.Message.setRepeatedWrapperField(this, 7, value); + } + static fromObject(data) { + const message = new ValueInput({}); + if (data.type != null) { + message.type = data.type; + } + if (data.string != null) { + message.string = data.string; + } + if (data.int != null) { + message.int = data.int; + } + if (data.float != null) { + message.float = data.float; + } + if (data.boolean != null) { + message.boolean = data.boolean; + } + if (data.reference != null) { + message.reference = QueryListRecordsRequest.ReferenceInput.fromObject(data.reference); + } + if (data.values != null) { + message.values = data.values.map(item => QueryListRecordsRequest.ValueInput.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.type != null) { + data.type = this.type; + } + if (this.string != null) { + data.string = this.string; + } + if (this.int != null) { + data.int = this.int; + } + if (this.float != null) { + data.float = this.float; + } + if (this.boolean != null) { + data.boolean = this.boolean; + } + if (this.reference != null) { + data.reference = this.reference.toObject(); + } + if (this.values != null) { + data.values = this.values.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.type === "string" && this.type.length) + writer.writeString(1, this.type); + if (typeof this.string === "string" && this.string.length) + writer.writeString(2, this.string); + if (this.int !== undefined) + writer.writeInt64(3, this.int); + if (this.float !== undefined) + writer.writeDouble(4, this.float); + if (this.boolean !== undefined) + writer.writeBool(5, this.boolean); + if (this.reference !== undefined) + writer.writeMessage(6, this.reference, () => this.reference.serialize(writer)); + if (this.values !== undefined) + writer.writeRepeatedMessage(7, this.values, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ValueInput(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.type = reader.readString(); + break; + case 2: + message.string = reader.readString(); + break; + case 3: + message.int = reader.readInt64(); + break; + case 4: + message.float = reader.readDouble(); + break; + case 5: + message.boolean = reader.readBool(); + break; + case 6: + reader.readMessage(message.reference, () => message.reference = QueryListRecordsRequest.ReferenceInput.deserialize(reader)); + break; + case 7: + reader.readMessage(message.values, () => pb_1.Message.addToRepeatedWrapperField(message, 7, QueryListRecordsRequest.ValueInput.deserialize(reader), QueryListRecordsRequest.ValueInput)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ValueInput.deserialize(bytes); + } + } + QueryListRecordsRequest.ValueInput = ValueInput; + class KeyValueInput extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("key" in data && data.key != undefined) { + this.key = data.key; + } + if ("value" in data && data.value != undefined) { + this.value = data.value; + } + } + } + get key() { + return pb_1.Message.getField(this, 1); + } + set key(value) { + pb_1.Message.setField(this, 1, value); + } + get value() { + return pb_1.Message.getWrapperField(this, QueryListRecordsRequest.ValueInput, 2); + } + set value(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new KeyValueInput({}); + if (data.key != null) { + message.key = data.key; + } + if (data.value != null) { + message.value = QueryListRecordsRequest.ValueInput.fromObject(data.value); + } + return message; + } + toObject() { + const data = {}; + if (this.key != null) { + data.key = this.key; + } + if (this.value != null) { + data.value = this.value.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.key === "string" && this.key.length) + writer.writeString(1, this.key); + if (this.value !== undefined) + writer.writeMessage(2, this.value, () => this.value.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new KeyValueInput(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.key = reader.readString(); + break; + case 2: + reader.readMessage(message.value, () => message.value = QueryListRecordsRequest.ValueInput.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return KeyValueInput.deserialize(bytes); + } + } + QueryListRecordsRequest.KeyValueInput = KeyValueInput; + })(QueryListRecordsRequest = v1beta1.QueryListRecordsRequest || (v1beta1.QueryListRecordsRequest = {})); + class QueryListRecordsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("records" in data && data.records != undefined) { + this.records = data.records; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get records() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.Record, 1); + } + set records(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryListRecordsResponse({}); + if (data.records != null) { + message.records = data.records.map(item => dependency_1.vulcanize.nameservice.v1beta1.Record.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.records != null) { + data.records = this.records.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.records !== undefined) + writer.writeRepeatedMessage(1, this.records, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryListRecordsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.records, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_1.vulcanize.nameservice.v1beta1.Record.deserialize(reader), dependency_1.vulcanize.nameservice.v1beta1.Record)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryListRecordsResponse.deserialize(bytes); + } + } + v1beta1.QueryListRecordsResponse = QueryListRecordsResponse; + class QueryRecordByIdRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new QueryRecordByIdRequest({}); + if (data.id != null) { + message.id = data.id; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryRecordByIdRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryRecordByIdRequest.deserialize(bytes); + } + } + v1beta1.QueryRecordByIdRequest = QueryRecordByIdRequest; + class QueryRecordByIdResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record" in data && data.record != undefined) { + this.record = data.record; + } + } + } + get record() { + return pb_1.Message.getWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.Record, 1); + } + set record(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryRecordByIdResponse({}); + if (data.record != null) { + message.record = dependency_1.vulcanize.nameservice.v1beta1.Record.fromObject(data.record); + } + return message; + } + toObject() { + const data = {}; + if (this.record != null) { + data.record = this.record.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.record !== undefined) + writer.writeMessage(1, this.record, () => this.record.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryRecordByIdResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.record, () => message.record = dependency_1.vulcanize.nameservice.v1beta1.Record.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryRecordByIdResponse.deserialize(bytes); + } + } + v1beta1.QueryRecordByIdResponse = QueryRecordByIdResponse; + class QueryRecordByBondIdRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryRecordByBondIdRequest({}); + if (data.id != null) { + message.id = data.id; + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryRecordByBondIdRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryRecordByBondIdRequest.deserialize(bytes); + } + } + v1beta1.QueryRecordByBondIdRequest = QueryRecordByBondIdRequest; + class QueryRecordByBondIdResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("records" in data && data.records != undefined) { + this.records = data.records; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get records() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.Record, 1); + } + set records(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryRecordByBondIdResponse({}); + if (data.records != null) { + message.records = data.records.map(item => dependency_1.vulcanize.nameservice.v1beta1.Record.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.records != null) { + data.records = this.records.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.records !== undefined) + writer.writeRepeatedMessage(1, this.records, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryRecordByBondIdResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.records, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_1.vulcanize.nameservice.v1beta1.Record.deserialize(reader), dependency_1.vulcanize.nameservice.v1beta1.Record)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryRecordByBondIdResponse.deserialize(bytes); + } + } + v1beta1.QueryRecordByBondIdResponse = QueryRecordByBondIdResponse; + class GetNameServiceModuleBalanceRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new GetNameServiceModuleBalanceRequest({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new GetNameServiceModuleBalanceRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return GetNameServiceModuleBalanceRequest.deserialize(bytes); + } + } + v1beta1.GetNameServiceModuleBalanceRequest = GetNameServiceModuleBalanceRequest; + class GetNameServiceModuleBalanceResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("balances" in data && data.balances != undefined) { + this.balances = data.balances; + } + } + } + get balances() { + return pb_1.Message.getRepeatedWrapperField(this, AccountBalance, 1); + } + set balances(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new GetNameServiceModuleBalanceResponse({}); + if (data.balances != null) { + message.balances = data.balances.map(item => AccountBalance.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.balances != null) { + data.balances = this.balances.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.balances !== undefined) + writer.writeRepeatedMessage(1, this.balances, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new GetNameServiceModuleBalanceResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.balances, () => pb_1.Message.addToRepeatedWrapperField(message, 1, AccountBalance.deserialize(reader), AccountBalance)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return GetNameServiceModuleBalanceResponse.deserialize(bytes); + } + } + v1beta1.GetNameServiceModuleBalanceResponse = GetNameServiceModuleBalanceResponse; + class AccountBalance extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [3], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("account_name" in data && data.account_name != undefined) { + this.account_name = data.account_name; + } + if ("balance" in data && data.balance != undefined) { + this.balance = data.balance; + } + } + } + get account_name() { + return pb_1.Message.getField(this, 1); + } + set account_name(value) { + pb_1.Message.setField(this, 1, value); + } + get balance() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_5.cosmos.base.v1beta1.Coin, 3); + } + set balance(value) { + pb_1.Message.setRepeatedWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new AccountBalance({}); + if (data.account_name != null) { + message.account_name = data.account_name; + } + if (data.balance != null) { + message.balance = data.balance.map(item => dependency_5.cosmos.base.v1beta1.Coin.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.account_name != null) { + data.account_name = this.account_name; + } + if (this.balance != null) { + data.balance = this.balance.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.account_name === "string" && this.account_name.length) + writer.writeString(1, this.account_name); + if (this.balance !== undefined) + writer.writeRepeatedMessage(3, this.balance, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new AccountBalance(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.account_name = reader.readString(); + break; + case 3: + reader.readMessage(message.balance, () => pb_1.Message.addToRepeatedWrapperField(message, 3, dependency_5.cosmos.base.v1beta1.Coin.deserialize(reader), dependency_5.cosmos.base.v1beta1.Coin)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return AccountBalance.deserialize(bytes); + } + } + v1beta1.AccountBalance = AccountBalance; + class QueryListNameRecordsRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 1); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryListNameRecordsRequest({}); + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.pagination !== undefined) + writer.writeMessage(1, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryListNameRecordsRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryListNameRecordsRequest.deserialize(bytes); + } + } + v1beta1.QueryListNameRecordsRequest = QueryListNameRecordsRequest; + class QueryListNameRecordsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("names" in data && data.names != undefined) { + this.names = data.names; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get names() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.NameEntry, 1); + } + set names(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryListNameRecordsResponse({}); + if (data.names != null) { + message.names = data.names.map(item => dependency_1.vulcanize.nameservice.v1beta1.NameEntry.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.names != null) { + data.names = this.names.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.names !== undefined) + writer.writeRepeatedMessage(1, this.names, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryListNameRecordsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.names, () => pb_1.Message.addToRepeatedWrapperField(message, 1, dependency_1.vulcanize.nameservice.v1beta1.NameEntry.deserialize(reader), dependency_1.vulcanize.nameservice.v1beta1.NameEntry)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryListNameRecordsResponse.deserialize(bytes); + } + } + v1beta1.QueryListNameRecordsResponse = QueryListNameRecordsResponse; + class QueryWhoisRequest extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new QueryWhoisRequest({}); + if (data.name != null) { + message.name = data.name; + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryWhoisRequest(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryWhoisRequest.deserialize(bytes); + } + } + v1beta1.QueryWhoisRequest = QueryWhoisRequest; + class QueryWhoisResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name_authority" in data && data.name_authority != undefined) { + this.name_authority = data.name_authority; + } + } + } + get name_authority() { + return pb_1.Message.getWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.NameAuthority, 1); + } + set name_authority(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryWhoisResponse({}); + if (data.name_authority != null) { + message.name_authority = dependency_1.vulcanize.nameservice.v1beta1.NameAuthority.fromObject(data.name_authority); + } + return message; + } + toObject() { + const data = {}; + if (this.name_authority != null) { + data.name_authority = this.name_authority.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.name_authority !== undefined) + writer.writeMessage(1, this.name_authority, () => this.name_authority.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryWhoisResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.name_authority, () => message.name_authority = dependency_1.vulcanize.nameservice.v1beta1.NameAuthority.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryWhoisResponse.deserialize(bytes); + } + } + v1beta1.QueryWhoisResponse = QueryWhoisResponse; + class QueryLookupCrn extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("crn" in data && data.crn != undefined) { + this.crn = data.crn; + } + } + } + get crn() { + return pb_1.Message.getField(this, 1); + } + set crn(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new QueryLookupCrn({}); + if (data.crn != null) { + message.crn = data.crn; + } + return message; + } + toObject() { + const data = {}; + if (this.crn != null) { + data.crn = this.crn; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.crn === "string" && this.crn.length) + writer.writeString(1, this.crn); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryLookupCrn(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.crn = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryLookupCrn.deserialize(bytes); + } + } + v1beta1.QueryLookupCrn = QueryLookupCrn; + class QueryLookupCrnResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + } + } + get name() { + return pb_1.Message.getWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.NameRecord, 1); + } + set name(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryLookupCrnResponse({}); + if (data.name != null) { + message.name = dependency_1.vulcanize.nameservice.v1beta1.NameRecord.fromObject(data.name); + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.name !== undefined) + writer.writeMessage(1, this.name, () => this.name.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryLookupCrnResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.name, () => message.name = dependency_1.vulcanize.nameservice.v1beta1.NameRecord.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryLookupCrnResponse.deserialize(bytes); + } + } + v1beta1.QueryLookupCrnResponse = QueryLookupCrnResponse; + class QueryResolveCrn extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("crn" in data && data.crn != undefined) { + this.crn = data.crn; + } + } + } + get crn() { + return pb_1.Message.getField(this, 1); + } + set crn(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new QueryResolveCrn({}); + if (data.crn != null) { + message.crn = data.crn; + } + return message; + } + toObject() { + const data = {}; + if (this.crn != null) { + data.crn = this.crn; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.crn === "string" && this.crn.length) + writer.writeString(1, this.crn); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryResolveCrn(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.crn = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryResolveCrn.deserialize(bytes); + } + } + v1beta1.QueryResolveCrn = QueryResolveCrn; + class QueryResolveCrnResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record" in data && data.record != undefined) { + this.record = data.record; + } + } + } + get record() { + return pb_1.Message.getWrapperField(this, dependency_1.vulcanize.nameservice.v1beta1.Record, 1); + } + set record(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryResolveCrnResponse({}); + if (data.record != null) { + message.record = dependency_1.vulcanize.nameservice.v1beta1.Record.fromObject(data.record); + } + return message; + } + toObject() { + const data = {}; + if (this.record != null) { + data.record = this.record.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.record !== undefined) + writer.writeMessage(1, this.record, () => this.record.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryResolveCrnResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.record, () => message.record = dependency_1.vulcanize.nameservice.v1beta1.Record.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryResolveCrnResponse.deserialize(bytes); + } + } + v1beta1.QueryResolveCrnResponse = QueryResolveCrnResponse; + class QueryGetRecordExpiryQueue extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 1); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryGetRecordExpiryQueue({}); + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.pagination !== undefined) + writer.writeMessage(1, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetRecordExpiryQueue(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetRecordExpiryQueue.deserialize(bytes); + } + } + v1beta1.QueryGetRecordExpiryQueue = QueryGetRecordExpiryQueue; + class QueryGetRecordExpiryQueueResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("records" in data && data.records != undefined) { + this.records = data.records; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get records() { + return pb_1.Message.getRepeatedWrapperField(this, ExpiryQueueRecord, 1); + } + set records(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryGetRecordExpiryQueueResponse({}); + if (data.records != null) { + message.records = data.records.map(item => ExpiryQueueRecord.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.records != null) { + data.records = this.records.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.records !== undefined) + writer.writeRepeatedMessage(1, this.records, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetRecordExpiryQueueResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.records, () => pb_1.Message.addToRepeatedWrapperField(message, 1, ExpiryQueueRecord.deserialize(reader), ExpiryQueueRecord)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetRecordExpiryQueueResponse.deserialize(bytes); + } + } + v1beta1.QueryGetRecordExpiryQueueResponse = QueryGetRecordExpiryQueueResponse; + class ExpiryQueueRecord extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + if ("value" in data && data.value != undefined) { + this.value = data.value; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + get value() { + return pb_1.Message.getField(this, 2); + } + set value(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new ExpiryQueueRecord({}); + if (data.id != null) { + message.id = data.id; + } + if (data.value != null) { + message.value = data.value; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + if (this.value != null) { + data.value = this.value; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (this.value !== undefined) + writer.writeRepeatedString(2, this.value); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new ExpiryQueueRecord(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + case 2: + pb_1.Message.addToRepeatedField(message, 2, reader.readString()); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return ExpiryQueueRecord.deserialize(bytes); + } + } + v1beta1.ExpiryQueueRecord = ExpiryQueueRecord; + class QueryGetAuthorityExpiryQueue extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageRequest, 1); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + static fromObject(data) { + const message = new QueryGetAuthorityExpiryQueue({}); + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.pagination !== undefined) + writer.writeMessage(1, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetAuthorityExpiryQueue(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageRequest.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetAuthorityExpiryQueue.deserialize(bytes); + } + } + v1beta1.QueryGetAuthorityExpiryQueue = QueryGetAuthorityExpiryQueue; + class QueryGetAuthorityExpiryQueueResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [1], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("authorities" in data && data.authorities != undefined) { + this.authorities = data.authorities; + } + if ("pagination" in data && data.pagination != undefined) { + this.pagination = data.pagination; + } + } + } + get authorities() { + return pb_1.Message.getRepeatedWrapperField(this, ExpiryQueueRecord, 1); + } + set authorities(value) { + pb_1.Message.setRepeatedWrapperField(this, 1, value); + } + get pagination() { + return pb_1.Message.getWrapperField(this, dependency_3.cosmos.base.query.v1beta1.PageResponse, 2); + } + set pagination(value) { + pb_1.Message.setWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new QueryGetAuthorityExpiryQueueResponse({}); + if (data.authorities != null) { + message.authorities = data.authorities.map(item => ExpiryQueueRecord.fromObject(item)); + } + if (data.pagination != null) { + message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.fromObject(data.pagination); + } + return message; + } + toObject() { + const data = {}; + if (this.authorities != null) { + data.authorities = this.authorities.map((item) => item.toObject()); + } + if (this.pagination != null) { + data.pagination = this.pagination.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.authorities !== undefined) + writer.writeRepeatedMessage(1, this.authorities, (item) => item.serialize(writer)); + if (this.pagination !== undefined) + writer.writeMessage(2, this.pagination, () => this.pagination.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new QueryGetAuthorityExpiryQueueResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.authorities, () => pb_1.Message.addToRepeatedWrapperField(message, 1, ExpiryQueueRecord.deserialize(reader), ExpiryQueueRecord)); + break; + case 2: + reader.readMessage(message.pagination, () => message.pagination = dependency_3.cosmos.base.query.v1beta1.PageResponse.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return QueryGetAuthorityExpiryQueueResponse.deserialize(bytes); + } + } + v1beta1.QueryGetAuthorityExpiryQueueResponse = QueryGetAuthorityExpiryQueueResponse; + })(v1beta1 = nameservice.v1beta1 || (nameservice.v1beta1 = {})); + })(nameservice = vulcanize.nameservice || (vulcanize.nameservice = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/proto/vulcanize/nameservice/v1beta1/tx.d.ts b/dist/proto/vulcanize/nameservice/v1beta1/tx.d.ts new file mode 100644 index 0000000..9c4f774 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/tx.d.ts @@ -0,0 +1,422 @@ +import * as dependency_2 from "./nameservice"; +import * as pb_1 from "google-protobuf"; +export declare namespace vulcanize.nameservice.v1beta1 { + class MsgSetRecord extends pb_1.Message { + constructor(data?: any[] | { + bond_id?: string; + signer?: string; + payload?: Payload; + }); + get bond_id(): string; + set bond_id(value: string); + get signer(): string; + set signer(value: string); + get payload(): Payload; + set payload(value: Payload); + static fromObject(data: { + bond_id?: string; + signer?: string; + payload?: ReturnType; + }): MsgSetRecord; + toObject(): { + bond_id?: string | undefined; + signer?: string | undefined; + payload?: { + record?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + } | undefined; + signatures?: { + sig?: string | undefined; + pub_key?: string | undefined; + }[] | undefined; + } | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgSetRecord; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgSetRecord; + } + class MsgSetRecordResponse extends pb_1.Message { + constructor(data?: any[] | { + id?: string; + }); + get id(): string; + set id(value: string); + static fromObject(data: { + id?: string; + }): MsgSetRecordResponse; + toObject(): { + id?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgSetRecordResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgSetRecordResponse; + } + class Payload extends pb_1.Message { + constructor(data?: any[] | { + record?: dependency_2.vulcanize.nameservice.v1beta1.Record; + signatures?: dependency_2.vulcanize.nameservice.v1beta1.Signature[]; + }); + get record(): dependency_2.vulcanize.nameservice.v1beta1.Record; + set record(value: dependency_2.vulcanize.nameservice.v1beta1.Record); + get signatures(): dependency_2.vulcanize.nameservice.v1beta1.Signature[]; + set signatures(value: dependency_2.vulcanize.nameservice.v1beta1.Signature[]); + static fromObject(data: { + record?: ReturnType; + signatures?: ReturnType[]; + }): Payload; + toObject(): { + record?: { + id?: string | undefined; + bond_id?: string | undefined; + create_time?: string | undefined; + expiry_time?: string | undefined; + deleted?: boolean | undefined; + owners?: string[] | undefined; + attributes?: string | undefined; + names?: string[] | undefined; + } | undefined; + signatures?: { + sig?: string | undefined; + pub_key?: string | undefined; + }[] | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): Payload; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): Payload; + } + class MsgSetName extends pb_1.Message { + constructor(data?: any[] | { + crn?: string; + cid?: string; + signer?: string; + }); + get crn(): string; + set crn(value: string); + get cid(): string; + set cid(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + crn?: string; + cid?: string; + signer?: string; + }): MsgSetName; + toObject(): { + crn?: string | undefined; + cid?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgSetName; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgSetName; + } + class MsgSetNameResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgSetNameResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgSetNameResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgSetNameResponse; + } + class MsgReserveAuthority extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + signer?: string; + owner?: string; + }); + get name(): string; + set name(value: string); + get signer(): string; + set signer(value: string); + get owner(): string; + set owner(value: string); + static fromObject(data: { + name?: string; + signer?: string; + owner?: string; + }): MsgReserveAuthority; + toObject(): { + name?: string | undefined; + signer?: string | undefined; + owner?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgReserveAuthority; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgReserveAuthority; + } + class MsgReserveAuthorityResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgReserveAuthorityResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgReserveAuthorityResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgReserveAuthorityResponse; + } + class MsgSetAuthorityBond extends pb_1.Message { + constructor(data?: any[] | { + name?: string; + bond_id?: string; + signer?: string; + }); + get name(): string; + set name(value: string); + get bond_id(): string; + set bond_id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + name?: string; + bond_id?: string; + signer?: string; + }): MsgSetAuthorityBond; + toObject(): { + name?: string | undefined; + bond_id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgSetAuthorityBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgSetAuthorityBond; + } + class MsgSetAuthorityBondResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgSetAuthorityBondResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgSetAuthorityBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgSetAuthorityBondResponse; + } + class MsgDeleteNameAuthority extends pb_1.Message { + constructor(data?: any[] | { + crn?: string; + signer?: string; + }); + get crn(): string; + set crn(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + crn?: string; + signer?: string; + }): MsgDeleteNameAuthority; + toObject(): { + crn?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgDeleteNameAuthority; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgDeleteNameAuthority; + } + class MsgDeleteNameAuthorityResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgDeleteNameAuthorityResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgDeleteNameAuthorityResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgDeleteNameAuthorityResponse; + } + class MsgRenewRecord extends pb_1.Message { + constructor(data?: any[] | { + record_id?: string; + signer?: string; + }); + get record_id(): string; + set record_id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + record_id?: string; + signer?: string; + }): MsgRenewRecord; + toObject(): { + record_id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgRenewRecord; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgRenewRecord; + } + class MsgRenewRecordResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgRenewRecordResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgRenewRecordResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgRenewRecordResponse; + } + class MsgAssociateBond extends pb_1.Message { + constructor(data?: any[] | { + record_id?: string; + bond_id?: string; + signer?: string; + }); + get record_id(): string; + set record_id(value: string); + get bond_id(): string; + set bond_id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + record_id?: string; + bond_id?: string; + signer?: string; + }): MsgAssociateBond; + toObject(): { + record_id?: string | undefined; + bond_id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgAssociateBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgAssociateBond; + } + class MsgAssociateBondResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgAssociateBondResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgAssociateBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgAssociateBondResponse; + } + class MsgDissociateBond extends pb_1.Message { + constructor(data?: any[] | { + record_id?: string; + signer?: string; + }); + get record_id(): string; + set record_id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + record_id?: string; + signer?: string; + }): MsgDissociateBond; + toObject(): { + record_id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgDissociateBond; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgDissociateBond; + } + class MsgDissociateBondResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgDissociateBondResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgDissociateBondResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgDissociateBondResponse; + } + class MsgDissociateRecords extends pb_1.Message { + constructor(data?: any[] | { + bond_id?: string; + signer?: string; + }); + get bond_id(): string; + set bond_id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + bond_id?: string; + signer?: string; + }): MsgDissociateRecords; + toObject(): { + bond_id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgDissociateRecords; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgDissociateRecords; + } + class MsgDissociateRecordsResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgDissociateRecordsResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgDissociateRecordsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgDissociateRecordsResponse; + } + class MsgReAssociateRecords extends pb_1.Message { + constructor(data?: any[] | { + new_bond_id?: string; + old_bond_id?: string; + signer?: string; + }); + get new_bond_id(): string; + set new_bond_id(value: string); + get old_bond_id(): string; + set old_bond_id(value: string); + get signer(): string; + set signer(value: string); + static fromObject(data: { + new_bond_id?: string; + old_bond_id?: string; + signer?: string; + }): MsgReAssociateRecords; + toObject(): { + new_bond_id?: string | undefined; + old_bond_id?: string | undefined; + signer?: string | undefined; + }; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgReAssociateRecords; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgReAssociateRecords; + } + class MsgReAssociateRecordsResponse extends pb_1.Message { + constructor(data?: any[] | {}); + static fromObject(data: {}): MsgReAssociateRecordsResponse; + toObject(): {}; + serialize(): Uint8Array; + serialize(w: pb_1.BinaryWriter): void; + static deserialize(bytes: Uint8Array | pb_1.BinaryReader): MsgReAssociateRecordsResponse; + serializeBinary(): Uint8Array; + static deserializeBinary(bytes: Uint8Array): MsgReAssociateRecordsResponse; + } +} diff --git a/dist/proto/vulcanize/nameservice/v1beta1/tx.js b/dist/proto/vulcanize/nameservice/v1beta1/tx.js new file mode 100644 index 0000000..2d92c07 --- /dev/null +++ b/dist/proto/vulcanize/nameservice/v1beta1/tx.js @@ -0,0 +1,1427 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.vulcanize = void 0; +const dependency_2 = __importStar(require("./nameservice")); +const pb_1 = __importStar(require("google-protobuf")); +var vulcanize; +(function (vulcanize) { + var nameservice; + (function (nameservice) { + var v1beta1; + (function (v1beta1) { + class MsgSetRecord extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bond_id" in data && data.bond_id != undefined) { + this.bond_id = data.bond_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + if ("payload" in data && data.payload != undefined) { + this.payload = data.payload; + } + } + } + get bond_id() { + return pb_1.Message.getField(this, 1); + } + set bond_id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + get payload() { + return pb_1.Message.getWrapperField(this, Payload, 3); + } + set payload(value) { + pb_1.Message.setWrapperField(this, 3, value); + } + static fromObject(data) { + const message = new MsgSetRecord({}); + if (data.bond_id != null) { + message.bond_id = data.bond_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + if (data.payload != null) { + message.payload = Payload.fromObject(data.payload); + } + return message; + } + toObject() { + const data = {}; + if (this.bond_id != null) { + data.bond_id = this.bond_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + if (this.payload != null) { + data.payload = this.payload.toObject(); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.bond_id === "string" && this.bond_id.length) + writer.writeString(1, this.bond_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (this.payload !== undefined) + writer.writeMessage(3, this.payload, () => this.payload.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgSetRecord(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.bond_id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + case 3: + reader.readMessage(message.payload, () => message.payload = Payload.deserialize(reader)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgSetRecord.deserialize(bytes); + } + } + v1beta1.MsgSetRecord = MsgSetRecord; + class MsgSetRecordResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("id" in data && data.id != undefined) { + this.id = data.id; + } + } + } + get id() { + return pb_1.Message.getField(this, 1); + } + set id(value) { + pb_1.Message.setField(this, 1, value); + } + static fromObject(data) { + const message = new MsgSetRecordResponse({}); + if (data.id != null) { + message.id = data.id; + } + return message; + } + toObject() { + const data = {}; + if (this.id != null) { + data.id = this.id; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.id === "string" && this.id.length) + writer.writeString(1, this.id); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgSetRecordResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.id = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgSetRecordResponse.deserialize(bytes); + } + } + v1beta1.MsgSetRecordResponse = MsgSetRecordResponse; + class Payload extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [2], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record" in data && data.record != undefined) { + this.record = data.record; + } + if ("signatures" in data && data.signatures != undefined) { + this.signatures = data.signatures; + } + } + } + get record() { + return pb_1.Message.getWrapperField(this, dependency_2.vulcanize.nameservice.v1beta1.Record, 1); + } + set record(value) { + pb_1.Message.setWrapperField(this, 1, value); + } + get signatures() { + return pb_1.Message.getRepeatedWrapperField(this, dependency_2.vulcanize.nameservice.v1beta1.Signature, 2); + } + set signatures(value) { + pb_1.Message.setRepeatedWrapperField(this, 2, value); + } + static fromObject(data) { + const message = new Payload({}); + if (data.record != null) { + message.record = dependency_2.vulcanize.nameservice.v1beta1.Record.fromObject(data.record); + } + if (data.signatures != null) { + message.signatures = data.signatures.map(item => dependency_2.vulcanize.nameservice.v1beta1.Signature.fromObject(item)); + } + return message; + } + toObject() { + const data = {}; + if (this.record != null) { + data.record = this.record.toObject(); + } + if (this.signatures != null) { + data.signatures = this.signatures.map((item) => item.toObject()); + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (this.record !== undefined) + writer.writeMessage(1, this.record, () => this.record.serialize(writer)); + if (this.signatures !== undefined) + writer.writeRepeatedMessage(2, this.signatures, (item) => item.serialize(writer)); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new Payload(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + reader.readMessage(message.record, () => message.record = dependency_2.vulcanize.nameservice.v1beta1.Record.deserialize(reader)); + break; + case 2: + reader.readMessage(message.signatures, () => pb_1.Message.addToRepeatedWrapperField(message, 2, dependency_2.vulcanize.nameservice.v1beta1.Signature.deserialize(reader), dependency_2.vulcanize.nameservice.v1beta1.Signature)); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return Payload.deserialize(bytes); + } + } + v1beta1.Payload = Payload; + class MsgSetName extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("crn" in data && data.crn != undefined) { + this.crn = data.crn; + } + if ("cid" in data && data.cid != undefined) { + this.cid = data.cid; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get crn() { + return pb_1.Message.getField(this, 1); + } + set crn(value) { + pb_1.Message.setField(this, 1, value); + } + get cid() { + return pb_1.Message.getField(this, 2); + } + set cid(value) { + pb_1.Message.setField(this, 2, value); + } + get signer() { + return pb_1.Message.getField(this, 3); + } + set signer(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgSetName({}); + if (data.crn != null) { + message.crn = data.crn; + } + if (data.cid != null) { + message.cid = data.cid; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.crn != null) { + data.crn = this.crn; + } + if (this.cid != null) { + data.cid = this.cid; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.crn === "string" && this.crn.length) + writer.writeString(1, this.crn); + if (typeof this.cid === "string" && this.cid.length) + writer.writeString(2, this.cid); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(3, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgSetName(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.crn = reader.readString(); + break; + case 2: + message.cid = reader.readString(); + break; + case 3: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgSetName.deserialize(bytes); + } + } + v1beta1.MsgSetName = MsgSetName; + class MsgSetNameResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgSetNameResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgSetNameResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgSetNameResponse.deserialize(bytes); + } + } + v1beta1.MsgSetNameResponse = MsgSetNameResponse; + class MsgReserveAuthority extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + if ("owner" in data && data.owner != undefined) { + this.owner = data.owner; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + get owner() { + return pb_1.Message.getField(this, 3); + } + set owner(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgReserveAuthority({}); + if (data.name != null) { + message.name = data.name; + } + if (data.signer != null) { + message.signer = data.signer; + } + if (data.owner != null) { + message.owner = data.owner; + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.signer != null) { + data.signer = this.signer; + } + if (this.owner != null) { + data.owner = this.owner; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (typeof this.owner === "string" && this.owner.length) + writer.writeString(3, this.owner); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgReserveAuthority(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + case 3: + message.owner = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgReserveAuthority.deserialize(bytes); + } + } + v1beta1.MsgReserveAuthority = MsgReserveAuthority; + class MsgReserveAuthorityResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgReserveAuthorityResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgReserveAuthorityResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgReserveAuthorityResponse.deserialize(bytes); + } + } + v1beta1.MsgReserveAuthorityResponse = MsgReserveAuthorityResponse; + class MsgSetAuthorityBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("name" in data && data.name != undefined) { + this.name = data.name; + } + if ("bond_id" in data && data.bond_id != undefined) { + this.bond_id = data.bond_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get name() { + return pb_1.Message.getField(this, 1); + } + set name(value) { + pb_1.Message.setField(this, 1, value); + } + get bond_id() { + return pb_1.Message.getField(this, 2); + } + set bond_id(value) { + pb_1.Message.setField(this, 2, value); + } + get signer() { + return pb_1.Message.getField(this, 3); + } + set signer(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgSetAuthorityBond({}); + if (data.name != null) { + message.name = data.name; + } + if (data.bond_id != null) { + message.bond_id = data.bond_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.name != null) { + data.name = this.name; + } + if (this.bond_id != null) { + data.bond_id = this.bond_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.name === "string" && this.name.length) + writer.writeString(1, this.name); + if (typeof this.bond_id === "string" && this.bond_id.length) + writer.writeString(2, this.bond_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(3, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgSetAuthorityBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.name = reader.readString(); + break; + case 2: + message.bond_id = reader.readString(); + break; + case 3: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgSetAuthorityBond.deserialize(bytes); + } + } + v1beta1.MsgSetAuthorityBond = MsgSetAuthorityBond; + class MsgSetAuthorityBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgSetAuthorityBondResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgSetAuthorityBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgSetAuthorityBondResponse.deserialize(bytes); + } + } + v1beta1.MsgSetAuthorityBondResponse = MsgSetAuthorityBondResponse; + class MsgDeleteNameAuthority extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("crn" in data && data.crn != undefined) { + this.crn = data.crn; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get crn() { + return pb_1.Message.getField(this, 1); + } + set crn(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new MsgDeleteNameAuthority({}); + if (data.crn != null) { + message.crn = data.crn; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.crn != null) { + data.crn = this.crn; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.crn === "string" && this.crn.length) + writer.writeString(1, this.crn); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgDeleteNameAuthority(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.crn = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgDeleteNameAuthority.deserialize(bytes); + } + } + v1beta1.MsgDeleteNameAuthority = MsgDeleteNameAuthority; + class MsgDeleteNameAuthorityResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgDeleteNameAuthorityResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgDeleteNameAuthorityResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgDeleteNameAuthorityResponse.deserialize(bytes); + } + } + v1beta1.MsgDeleteNameAuthorityResponse = MsgDeleteNameAuthorityResponse; + class MsgRenewRecord extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record_id" in data && data.record_id != undefined) { + this.record_id = data.record_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get record_id() { + return pb_1.Message.getField(this, 1); + } + set record_id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new MsgRenewRecord({}); + if (data.record_id != null) { + message.record_id = data.record_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.record_id != null) { + data.record_id = this.record_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.record_id === "string" && this.record_id.length) + writer.writeString(1, this.record_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgRenewRecord(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.record_id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgRenewRecord.deserialize(bytes); + } + } + v1beta1.MsgRenewRecord = MsgRenewRecord; + class MsgRenewRecordResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgRenewRecordResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgRenewRecordResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgRenewRecordResponse.deserialize(bytes); + } + } + v1beta1.MsgRenewRecordResponse = MsgRenewRecordResponse; + class MsgAssociateBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record_id" in data && data.record_id != undefined) { + this.record_id = data.record_id; + } + if ("bond_id" in data && data.bond_id != undefined) { + this.bond_id = data.bond_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get record_id() { + return pb_1.Message.getField(this, 1); + } + set record_id(value) { + pb_1.Message.setField(this, 1, value); + } + get bond_id() { + return pb_1.Message.getField(this, 2); + } + set bond_id(value) { + pb_1.Message.setField(this, 2, value); + } + get signer() { + return pb_1.Message.getField(this, 3); + } + set signer(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgAssociateBond({}); + if (data.record_id != null) { + message.record_id = data.record_id; + } + if (data.bond_id != null) { + message.bond_id = data.bond_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.record_id != null) { + data.record_id = this.record_id; + } + if (this.bond_id != null) { + data.bond_id = this.bond_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.record_id === "string" && this.record_id.length) + writer.writeString(1, this.record_id); + if (typeof this.bond_id === "string" && this.bond_id.length) + writer.writeString(2, this.bond_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(3, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgAssociateBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.record_id = reader.readString(); + break; + case 2: + message.bond_id = reader.readString(); + break; + case 3: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgAssociateBond.deserialize(bytes); + } + } + v1beta1.MsgAssociateBond = MsgAssociateBond; + class MsgAssociateBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgAssociateBondResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgAssociateBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgAssociateBondResponse.deserialize(bytes); + } + } + v1beta1.MsgAssociateBondResponse = MsgAssociateBondResponse; + class MsgDissociateBond extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("record_id" in data && data.record_id != undefined) { + this.record_id = data.record_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get record_id() { + return pb_1.Message.getField(this, 1); + } + set record_id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new MsgDissociateBond({}); + if (data.record_id != null) { + message.record_id = data.record_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.record_id != null) { + data.record_id = this.record_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.record_id === "string" && this.record_id.length) + writer.writeString(1, this.record_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgDissociateBond(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.record_id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgDissociateBond.deserialize(bytes); + } + } + v1beta1.MsgDissociateBond = MsgDissociateBond; + class MsgDissociateBondResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgDissociateBondResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgDissociateBondResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgDissociateBondResponse.deserialize(bytes); + } + } + v1beta1.MsgDissociateBondResponse = MsgDissociateBondResponse; + class MsgDissociateRecords extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("bond_id" in data && data.bond_id != undefined) { + this.bond_id = data.bond_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get bond_id() { + return pb_1.Message.getField(this, 1); + } + set bond_id(value) { + pb_1.Message.setField(this, 1, value); + } + get signer() { + return pb_1.Message.getField(this, 2); + } + set signer(value) { + pb_1.Message.setField(this, 2, value); + } + static fromObject(data) { + const message = new MsgDissociateRecords({}); + if (data.bond_id != null) { + message.bond_id = data.bond_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.bond_id != null) { + data.bond_id = this.bond_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.bond_id === "string" && this.bond_id.length) + writer.writeString(1, this.bond_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(2, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgDissociateRecords(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.bond_id = reader.readString(); + break; + case 2: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgDissociateRecords.deserialize(bytes); + } + } + v1beta1.MsgDissociateRecords = MsgDissociateRecords; + class MsgDissociateRecordsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgDissociateRecordsResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgDissociateRecordsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgDissociateRecordsResponse.deserialize(bytes); + } + } + v1beta1.MsgDissociateRecordsResponse = MsgDissociateRecordsResponse; + class MsgReAssociateRecords extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { + if ("new_bond_id" in data && data.new_bond_id != undefined) { + this.new_bond_id = data.new_bond_id; + } + if ("old_bond_id" in data && data.old_bond_id != undefined) { + this.old_bond_id = data.old_bond_id; + } + if ("signer" in data && data.signer != undefined) { + this.signer = data.signer; + } + } + } + get new_bond_id() { + return pb_1.Message.getField(this, 1); + } + set new_bond_id(value) { + pb_1.Message.setField(this, 1, value); + } + get old_bond_id() { + return pb_1.Message.getField(this, 2); + } + set old_bond_id(value) { + pb_1.Message.setField(this, 2, value); + } + get signer() { + return pb_1.Message.getField(this, 3); + } + set signer(value) { + pb_1.Message.setField(this, 3, value); + } + static fromObject(data) { + const message = new MsgReAssociateRecords({}); + if (data.new_bond_id != null) { + message.new_bond_id = data.new_bond_id; + } + if (data.old_bond_id != null) { + message.old_bond_id = data.old_bond_id; + } + if (data.signer != null) { + message.signer = data.signer; + } + return message; + } + toObject() { + const data = {}; + if (this.new_bond_id != null) { + data.new_bond_id = this.new_bond_id; + } + if (this.old_bond_id != null) { + data.old_bond_id = this.old_bond_id; + } + if (this.signer != null) { + data.signer = this.signer; + } + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (typeof this.new_bond_id === "string" && this.new_bond_id.length) + writer.writeString(1, this.new_bond_id); + if (typeof this.old_bond_id === "string" && this.old_bond_id.length) + writer.writeString(2, this.old_bond_id); + if (typeof this.signer === "string" && this.signer.length) + writer.writeString(3, this.signer); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgReAssociateRecords(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + case 1: + message.new_bond_id = reader.readString(); + break; + case 2: + message.old_bond_id = reader.readString(); + break; + case 3: + message.signer = reader.readString(); + break; + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgReAssociateRecords.deserialize(bytes); + } + } + v1beta1.MsgReAssociateRecords = MsgReAssociateRecords; + class MsgReAssociateRecordsResponse extends pb_1.Message { + constructor(data) { + super(); + pb_1.Message.initialize(this, Array.isArray(data) ? data : [], 0, -1, [], []); + if (!Array.isArray(data) && typeof data == "object") { } + } + static fromObject(data) { + const message = new MsgReAssociateRecordsResponse({}); + return message; + } + toObject() { + const data = {}; + return data; + } + serialize(w) { + const writer = w || new pb_1.BinaryWriter(); + if (!w) + return writer.getResultBuffer(); + } + static deserialize(bytes) { + const reader = bytes instanceof pb_1.BinaryReader ? bytes : new pb_1.BinaryReader(bytes), message = new MsgReAssociateRecordsResponse(); + while (reader.nextField()) { + if (reader.isEndGroup()) + break; + switch (reader.getFieldNumber()) { + default: reader.skipField(); + } + } + return message; + } + serializeBinary() { + return this.serialize(); + } + static deserializeBinary(bytes) { + return MsgReAssociateRecordsResponse.deserialize(bytes); + } + } + v1beta1.MsgReAssociateRecordsResponse = MsgReAssociateRecordsResponse; + })(v1beta1 = nameservice.v1beta1 || (nameservice.v1beta1 = {})); + })(nameservice = vulcanize.nameservice || (vulcanize.nameservice = {})); +})(vulcanize = exports.vulcanize || (exports.vulcanize = {})); diff --git a/dist/registry-client.d.ts b/dist/registry-client.d.ts new file mode 100644 index 0000000..7bbb614 --- /dev/null +++ b/dist/registry-client.d.ts @@ -0,0 +1,65 @@ +/** + * Registry + */ +export declare class RegistryClient { + _restEndpoint: string; + _graph: any; + /** + * Get query result. + */ + static getResult(query: any, key: string, modifier?: (rows: any[]) => {}): Promise; + /** + * Prepare response attributes. + */ + static prepareAttributes(path: string): (rows: any[]) => any[]; + /** + * New Client. + */ + constructor(restEndpoint: string, gqlEndpoint: string); + /** + * Get server status. + */ + getStatus(): Promise; + /** + * Fetch Accounts. + */ + getAccounts(addresses: string[]): Promise; + /** + * Get records by ids. + */ + getRecordsByIds(ids: string[], refs?: boolean): Promise; + /** + * Get records by attributes. + */ + queryRecords(attributes: { + [key: string]: any; + }, all?: boolean, refs?: boolean): Promise; + /** + * Lookup authorities by names. + */ + lookupAuthorities(names: string[], auction?: boolean): Promise; + /** + * Get auctions by ids. + */ + getAuctionsByIds(ids: string[]): Promise; + /** + * Lookup names. + */ + lookupNames(names: string[], history?: boolean): Promise; + /** + * Resolve names to records. + */ + resolveNames(names: string[], refs?: boolean): Promise; + /** + * Get bonds by ids. + */ + getBondsByIds(ids: string[]): Promise; + /** + * Get records by attributes. + */ + queryBonds(attributes?: {}): Promise; + /** + * Submit transaction. + */ + submit(tx: string): Promise; +} diff --git a/dist/registry-client.js b/dist/registry-client.js new file mode 100644 index 0000000..4657f5c --- /dev/null +++ b/dist/registry-client.js @@ -0,0 +1,409 @@ +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.RegistryClient = void 0; +const assert_1 = __importDefault(require("assert")); +const axios_1 = __importDefault(require("axios")); +const graphql_js_1 = __importDefault(require("graphql.js")); +const lodash_1 = require("lodash"); +const provider_1 = require("@tharsis/provider"); +const util_1 = require("./util"); +const attributeField = ` + attributes { + key + value { + null + int + float + string + boolean + json + reference { + id + } + } + } +`; +const refsField = ` + references { + id + } +`; +const historyFields = ` + history { + id + height + } +`; +const auctionFields = ` + id + status + ownerAddress + createTime + commitsEndTime + revealsEndTime + commitFee { + type + quantity + } + revealFee { + type + quantity + } + minimumBid { + type + quantity + } + winnerAddress + winnerBid { + type + quantity + } + winnerPrice { + type + quantity + } + bids { + bidderAddress + status + commitHash + commitTime + revealTime + commitFee { + type + quantity + } + revealFee { + type + quantity + } + bidAmount { + type + quantity + } + } +`; +/** + * Registry + */ +class RegistryClient { + /** + * New Client. + */ + constructor(restEndpoint, gqlEndpoint) { + (0, assert_1.default)(restEndpoint); + this._restEndpoint = restEndpoint; + this._graph = (0, graphql_js_1.default)(gqlEndpoint, { + method: 'POST', + asJSON: true + }); + } + /** + * Get query result. + */ + static getResult(query, key, modifier) { + return __awaiter(this, void 0, void 0, function* () { + const result = yield query; + if (result && result[key] && result[key].length && result[key][0] !== null) { + if (modifier) { + return modifier(result[key]); + } + return result[key]; + } + return []; + }); + } + /** + * Prepare response attributes. + */ + static prepareAttributes(path) { + return (rows) => { + const result = rows.map(r => { + (0, lodash_1.set)(r, path, util_1.Util.fromGQLAttributes((0, lodash_1.get)(r, path))); + return r; + }); + return result; + }; + } + /** + * Get server status. + */ + getStatus() { + return __awaiter(this, void 0, void 0, function* () { + const query = `query { + getStatus { + version + node { + id + network + moniker + } + sync { + latest_block_hash + latest_block_height + latest_block_time + catching_up + } + validator { + address + voting_power + } + validators { + address + voting_power + proposer_priority + } + num_peers + peers { + node { + id + network + moniker + } + is_outbound + remote_ip + } + disk_usage + } + }`; + const { getStatus: status } = yield this._graph(query)(); + return status; + }); + } + /** + * Fetch Accounts. + */ + getAccounts(addresses) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(addresses); + (0, assert_1.default)(addresses.length); + const query = `query ($addresses: [String!]) { + getAccounts(addresses: $addresses) { + address + pubKey + number + sequence + balance { + type + quantity + } + } + }`; + const variables = { + addresses + }; + return RegistryClient.getResult(this._graph(query)(variables), 'getAccounts'); + }); + } + /** + * Get records by ids. + */ + getRecordsByIds(ids, refs = false) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(ids); + (0, assert_1.default)(ids.length); + const query = `query ($ids: [String!]) { + getRecordsByIds(ids: $ids) { + id + names + owners + bondId + createTime + expiryTime + ${attributeField} + ${refs ? refsField : ''} + } + }`; + const variables = { + ids + }; + return RegistryClient.getResult(this._graph(query)(variables), 'getRecordsByIds', RegistryClient.prepareAttributes('attributes')); + }); + } + /** + * Get records by attributes. + */ + queryRecords(attributes, all = false, refs = false) { + return __awaiter(this, void 0, void 0, function* () { + if (!attributes) { + attributes = {}; + } + const query = `query ($attributes: [KeyValueInput!], $all: Boolean) { + queryRecords(attributes: $attributes, all: $all) { + id + names + owners + bondId + createTime + expiryTime + ${attributeField} + ${refs ? refsField : ''} + } + }`; + const variables = { + attributes: util_1.Util.toGQLAttributes(attributes), + all + }; + let result = (yield this._graph(query)(variables))['queryRecords']; + result = RegistryClient.prepareAttributes('attributes')(result); + return result; + }); + } + /** + * Lookup authorities by names. + */ + lookupAuthorities(names, auction = false) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(names.length); + const query = `query ($names: [String!]) { + lookupAuthorities(names: $names) { + ownerAddress + ownerPublicKey + height + status + bondId + expiryTime + ${auction ? ('auction { ' + auctionFields + ' }') : ''} + } + }`; + const variables = { + names + }; + const result = yield this._graph(query)(variables); + return result['lookupAuthorities']; + }); + } + /** + * Get auctions by ids. + */ + getAuctionsByIds(ids) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(ids); + (0, assert_1.default)(ids.length); + const query = `query ($ids: [String!]) { + getAuctionsByIds(ids: $ids) { + ${auctionFields} + } + }`; + const variables = { + ids + }; + return RegistryClient.getResult(this._graph(query)(variables), 'getAuctionsByIds'); + }); + } + /** + * Lookup names. + */ + lookupNames(names, history = false) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(names.length); + const query = `query ($names: [String!]) { + lookupNames(names: $names) { + latest { + id + height + } + ${history ? historyFields : ''} + } + }`; + const variables = { + names + }; + const result = yield this._graph(query)(variables); + return result['lookupNames']; + }); + } + /** + * Resolve names to records. + */ + resolveNames(names, refs = false) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(names.length); + const query = `query ($names: [String!]) { + resolveNames(names: $names) { + id + names + owners + bondId + createTime + expiryTime + ${attributeField} + ${refs ? refsField : ''} + } + }`; + const variables = { + names + }; + let result = (yield this._graph(query)(variables))['resolveNames']; + result = RegistryClient.prepareAttributes('attributes')(result); + return result; + }); + } + /** + * Get bonds by ids. + */ + getBondsByIds(ids) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(ids); + (0, assert_1.default)(ids.length); + const query = `query ($ids: [String!]) { + getBondsByIds(ids: $ids) { + id + owner + balance { + type + quantity + } + } + }`; + const variables = { + ids + }; + return RegistryClient.getResult(this._graph(query)(variables), 'getBondsByIds'); + }); + } + /** + * Get records by attributes. + */ + queryBonds(attributes = {}) { + return __awaiter(this, void 0, void 0, function* () { + const query = `query ($attributes: [KeyValueInput!]) { + queryBonds(attributes: $attributes) { + id + owner + balance { + type + quantity + } + } + }`; + const variables = { + attributes: util_1.Util.toGQLAttributes(attributes) + }; + return RegistryClient.getResult(this._graph(query)(variables), 'queryBonds'); + }); + } + /** + * Submit transaction. + */ + submit(tx) { + return __awaiter(this, void 0, void 0, function* () { + (0, assert_1.default)(tx); + // Broadcast transaction. + const { data } = yield axios_1.default.post(`${this._restEndpoint}${(0, provider_1.generateEndpointBroadcast)()}`, tx); + return data; + }); + } +} +exports.RegistryClient = RegistryClient; diff --git a/dist/schema/record.json b/dist/schema/record.json new file mode 100644 index 0000000..3b7d3ba --- /dev/null +++ b/dist/schema/record.json @@ -0,0 +1,5 @@ +{ + "$schema": "http://json-schema.org/schema#", + "id": "/Record", + "type": "object" +} diff --git a/dist/testing/helper.d.ts b/dist/testing/helper.d.ts new file mode 100644 index 0000000..460c23f --- /dev/null +++ b/dist/testing/helper.d.ts @@ -0,0 +1,19 @@ +import { Fee } from '@tharsis/transactions'; +import { Registry } from '../index'; +export declare const ensureUpdatedConfig: (path: string) => Promise; +export declare const getBaseConfig: (path: string) => Promise; +/** + * Provision a bond for record registration. + */ +export declare const provisionBondId: (registry: Registry, privateKey: string, fee: Fee) => Promise; +export declare const getConfig: () => { + chainId: string; + privateKey: string; + restEndpoint: string; + gqlEndpoint: string; + fee: { + amount: string; + denom: string; + gas: string; + }; +}; diff --git a/dist/testing/helper.js b/dist/testing/helper.js new file mode 100644 index 0000000..ff160a1 --- /dev/null +++ b/dist/testing/helper.js @@ -0,0 +1,58 @@ +"use strict"; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.getConfig = exports.provisionBondId = exports.getBaseConfig = exports.ensureUpdatedConfig = void 0; +const assert_1 = __importDefault(require("assert")); +const node_yaml_1 = __importDefault(require("node-yaml")); +const semver_1 = __importDefault(require("semver")); +const ensureUpdatedConfig = (path) => __awaiter(void 0, void 0, void 0, function* () { + const conf = yield node_yaml_1.default.read(path); + conf.record.version = semver_1.default.inc(conf.record.version, 'patch'); + yield node_yaml_1.default.write(path, conf); + return conf; +}); +exports.ensureUpdatedConfig = ensureUpdatedConfig; +const getBaseConfig = (path) => __awaiter(void 0, void 0, void 0, function* () { + const conf = yield node_yaml_1.default.read(path); + conf.record.version = '0.0.1'; + return conf; +}); +exports.getBaseConfig = getBaseConfig; +/** + * Provision a bond for record registration. + */ +const provisionBondId = (registry, privateKey, fee) => __awaiter(void 0, void 0, void 0, function* () { + let bonds = yield registry.queryBonds(); + if (!bonds.length) { + yield registry.createBond({ denom: 'aphoton', amount: '1000000000' }, privateKey, fee); + bonds = yield registry.queryBonds(); + } + return bonds[0].id; +}); +exports.provisionBondId = provisionBondId; +const getConfig = () => { + (0, assert_1.default)(process.env.PRIVATE_KEY); + return { + chainId: process.env.COSMOS_CHAIN_ID || 'laconic_9000-1', + privateKey: process.env.PRIVATE_KEY, + restEndpoint: process.env.LACONICD_REST_ENDPOINT || 'http://localhost:1317', + gqlEndpoint: process.env.LACONICD_GQL_ENDPOINT || 'http://localhost:9473/api', + fee: { + amount: '20', + denom: 'aphoton', + gas: '200000', + } + }; +}; +exports.getConfig = getConfig; diff --git a/dist/txbuilder.d.ts b/dist/txbuilder.d.ts new file mode 100644 index 0000000..58afea2 --- /dev/null +++ b/dist/txbuilder.d.ts @@ -0,0 +1,9 @@ +import { Chain, Sender } from '@tharsis/transactions'; +import { Account } from './account'; +/** + * Generate a cosmos-sdk transaction. + */ +export declare const createTransaction: (message: any, account: Account, sender: Sender, chain: Chain) => { + message: import("@tharsis/proto/dist/proto/cosmos/tx/v1beta1/tx").cosmos.tx.v1beta1.TxRaw; + path: string; +}; diff --git a/dist/txbuilder.js b/dist/txbuilder.js new file mode 100644 index 0000000..3cc7ad1 --- /dev/null +++ b/dist/txbuilder.js @@ -0,0 +1,21 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.createTransaction = void 0; +const assert_1 = __importDefault(require("assert")); +const transactions_1 = require("@tharsis/transactions"); +/** + * Generate a cosmos-sdk transaction. + */ +const createTransaction = (message, account, sender, chain) => { + (0, assert_1.default)(message); + (0, assert_1.default)(account); + // Sign transaction. + const signature = account.sign(message); + let extension = (0, transactions_1.signatureToWeb3Extension)(chain, sender, signature); + // Create the txRaw. + return (0, transactions_1.createTxRawEIP712)(message.legacyAmino.body, message.legacyAmino.authInfo, extension); +}; +exports.createTransaction = createTransaction; diff --git a/dist/types.d.ts b/dist/types.d.ts new file mode 100644 index 0000000..8d6ac22 --- /dev/null +++ b/dist/types.d.ts @@ -0,0 +1,72 @@ +/** + * Record. + */ +export declare class Record { + _record: any; + /** + * New Record. + */ + constructor(record: any); + get attributes(): string; + /** + * Serialize record. + */ + serialize(): { + id: string; + bond_id: string; + create_time: string; + expiry_time: string; + deleted: boolean; + attributes: string; + }; + /** + * Get message to calculate record signature. + */ + getMessageToSign(): any; +} +/** + * Record Signature. + */ +export declare class Signature { + _pubKey: string; + _sig: string; + /** + * New Signature. + */ + constructor(pubKey: string, sig: string); + /** + * Serialize Signature. + */ + serialize(): any; +} +/** + * Message Payload. + */ +export declare class Payload { + _record: Record; + _signatures: Signature[]; + /** + * New Payload. + */ + constructor(record: Record, ...signatures: Signature[]); + get record(): Record; + get signatures(): Signature[]; + /** + * Add message signature to payload. + */ + addSignature(signature: any): void; + /** + * Serialize Payload. + */ + serialize(): { + record: { + id: string; + bond_id: string; + create_time: string; + expiry_time: string; + deleted: boolean; + attributes: string; + }; + signatures: any[]; + }; +} diff --git a/dist/types.js b/dist/types.js new file mode 100644 index 0000000..1502a98 --- /dev/null +++ b/dist/types.js @@ -0,0 +1,114 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Payload = exports.Signature = exports.Record = void 0; +const assert_1 = __importDefault(require("assert")); +const jsonschema_1 = require("jsonschema"); +const record_json_1 = __importDefault(require("./schema/record.json")); +const util_1 = require("./util"); +/** + * Record. + */ +class Record { + /** + * New Record. + */ + constructor(record) { + (0, assert_1.default)(record); + const validator = new jsonschema_1.Validator(); + const result = validator.validate(record, record_json_1.default); + if (!result.valid) { + result.errors.map(console.error); + throw new Error('Invalid record input.'); + } + this._record = record; + } + get attributes() { + return Buffer.from(JSON.stringify(this._record), 'binary').toString('base64'); + } + /** + * Serialize record. + */ + serialize() { + return { + 'id': '_', + 'bond_id': '_', + 'create_time': '_', + 'expiry_time': '_', + // Setting deleted as false (zero value) throws error in EIP712 signature verification. + 'deleted': true, + 'attributes': this.attributes, + }; + } + /** + * Get message to calculate record signature. + */ + getMessageToSign() { + return util_1.Util.sortJSON(this._record); + } +} +exports.Record = Record; +/** + * Record Signature. + */ +class Signature { + /** + * New Signature. + */ + constructor(pubKey, sig) { + (0, assert_1.default)(pubKey); + (0, assert_1.default)(sig); + this._pubKey = pubKey; + this._sig = sig; + } + /** + * Serialize Signature. + */ + serialize() { + return util_1.Util.sortJSON({ + 'pub_key': this._pubKey, + 'sig': this._sig + }); + } +} +exports.Signature = Signature; +/** + * Message Payload. + */ +class Payload { + /** + * New Payload. + */ + constructor(record, ...signatures) { + (0, assert_1.default)(record); + this._record = record; + this._signatures = signatures; + } + get record() { + return this._record; + } + get signatures() { + return this._signatures; + } + /** + * Add message signature to payload. + */ + addSignature(signature) { + (0, assert_1.default)(signature); + this._signatures.push(signature); + } + /** + * Serialize Payload. + */ + serialize() { + // return Util.sortJSON({ + // }); + return { + 'record': this._record.serialize(), + 'signatures': this._signatures.map(s => s.serialize()) + }; + } +} +exports.Payload = Payload; diff --git a/dist/util.d.ts b/dist/util.d.ts new file mode 100644 index 0000000..2eb69bb --- /dev/null +++ b/dist/util.d.ts @@ -0,0 +1,23 @@ +/** + * Utils + */ +export declare class Util { + /** + * Sorts JSON object. + */ + static sortJSON(object: any): any; + /** + * Marshal object into gql 'attributes' variable. + */ + static toGQLAttributes(object: any): any[]; + /** + * Unmarshal attributes array to object. + */ + static fromGQLAttributes(attributes?: any[]): { + [key: string]: any; + }; + /** + * Get record content ID. + */ + static getContentId(record: any): Promise; +} diff --git a/dist/util.js b/dist/util.js new file mode 100644 index 0000000..4b00446 --- /dev/null +++ b/dist/util.js @@ -0,0 +1,145 @@ +"use strict"; +var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + var desc = Object.getOwnPropertyDescriptor(m, k); + if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { + desc = { enumerable: true, get: function() { return m[k]; } }; + } + Object.defineProperty(o, k2, desc); +}) : (function(o, m, k, k2) { + if (k2 === undefined) k2 = k; + o[k2] = m[k]; +})); +var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) { + Object.defineProperty(o, "default", { enumerable: true, value: v }); +}) : function(o, v) { + o["default"] = v; +}); +var __importStar = (this && this.__importStar) || function (mod) { + if (mod && mod.__esModule) return mod; + var result = {}; + if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k); + __setModuleDefault(result, mod); + return result; +}; +var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) { + function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); } + return new (P || (P = Promise))(function (resolve, reject) { + function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } } + function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } } + function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); } + step((generator = generator.apply(thisArg, _arguments || [])).next()); + }); +}; +var __rest = (this && this.__rest) || function (s, e) { + var t = {}; + for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) + t[p] = s[p]; + if (s != null && typeof Object.getOwnPropertySymbols === "function") + for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { + if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) + t[p[i]] = s[p[i]]; + } + return t; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.Util = void 0; +const Block = __importStar(require("multiformats/block")); +const sha2_1 = require("multiformats/hashes/sha2"); +const dagCBOR = __importStar(require("@ipld/dag-cbor")); +const dagJSON = __importStar(require("@ipld/dag-json")); +/** + * Utils + */ +class Util { + /** + * Sorts JSON object. + */ + static sortJSON(object) { + if (object instanceof Array) { + for (let i = 0; i < object.length; i++) { + object[i] = Util.sortJSON(object[i]); + } + return object; + } + if (typeof object !== 'object' || object === null) + return object; + let keys = Object.keys(object); + keys = keys.sort(); + const newObject = {}; + for (let i = 0; i < keys.length; i++) { + newObject[keys[i]] = Util.sortJSON(object[keys[i]]); + } + return newObject; + } + /** + * Marshal object into gql 'attributes' variable. + */ + static toGQLAttributes(object) { + const vars = []; + Object.keys(object).forEach(key => { + let type = typeof object[key]; + if (object[key] === null) { + vars.push({ key, value: { 'null': true } }); + } + else if (type === 'number') { + type = (object[key] % 1 === 0) ? 'int' : 'float'; + vars.push({ key, value: { [type]: object[key] } }); + } + else if (type === 'string') { + vars.push({ key, value: { 'string': object[key] } }); + } + else if (type === 'boolean') { + vars.push({ key, value: { 'boolean': object[key] } }); + } + else if (type === 'object') { + const nestedObject = object[key]; + if (nestedObject['/'] !== undefined) { + vars.push({ key, value: { 'reference': { id: nestedObject['/'] } } }); + } + } + }); + return vars; + } + /** + * Unmarshal attributes array to object. + */ + static fromGQLAttributes(attributes = []) { + const res = {}; + attributes.forEach(attr => { + if (attr.value.null) { + res[attr.key] = null; + } + else if (attr.value.json) { + res[attr.key] = JSON.parse(attr.value.json); + } + else if (attr.value.reference) { + // Convert GQL reference to IPLD style link. + const ref = attr.value.reference; + res[attr.key] = { '/': ref.id }; + } + else { + const _a = attr.value, { values, null: n } = _a, types = __rest(_a, ["values", "null"]); + const value = Object.values(types).find(v => v !== null); + res[attr.key] = value; + } + }); + return res; + } + /** + * Get record content ID. + */ + static getContentId(record) { + return __awaiter(this, void 0, void 0, function* () { + const serialized = dagJSON.encode(record); + const recordData = dagJSON.decode(serialized); + const block = yield Block.encode({ + value: recordData, + codec: dagCBOR, + hasher: sha2_1.sha256 + }); + return block.cid.toString(); + }); + } +} +exports.Util = Util;