import _m0 from "protobufjs/minimal";
import { Timestamp, TimestampSeconds } from "./timestamp";
export declare const protobufPackage = "proto";
/**
* Possible Token Types (IWA Compatibility).
* Apart from fungible and non-fungible, Tokens can have either a common or unique representation.
* This distinction might seem subtle, but it is important when considering how tokens can be traced
* and if they can have isolated and unique properties.
*/
export declare enum TokenType {
/**
* FUNGIBLE_COMMON - Interchangeable value with one another, where any quantity of them has the same value as
* another equal quantity if they are in the same class. Share a single set of properties, not
* distinct from one another. Simply represented as a balance or quantity to a given Hedera
* account.
*/
FUNGIBLE_COMMON = 0,
/**
* NON_FUNGIBLE_UNIQUE - Unique, not interchangeable with other tokens of the same type as they typically have
* different values. Individually traced and can carry unique properties (e.g. serial number).
*/
NON_FUNGIBLE_UNIQUE = 1,
UNRECOGNIZED = -1
}
export declare function tokenTypeFromJSON(object: any): TokenType;
export declare function tokenTypeToJSON(object: TokenType): string;
/**
* Allows a set of resource prices to be scoped to a certain type of a HAPI operation.
*
* For example, the resource prices for a TokenMint operation are different between minting fungible
* and non-fungible tokens. This enum allows us to "mark" a set of prices as applying to one or the
* other.
*
* Similarly, the resource prices for a basic TokenCreate without a custom fee schedule yield a
* total price of $1. The resource prices for a TokenCreate with a custom fee schedule are different
* and yield a total base price of $2.
*/
export declare enum SubType {
/** DEFAULT - The resource prices have no special scope */
DEFAULT = 0,
/** TOKEN_FUNGIBLE_COMMON - The resource prices are scoped to an operation on a fungible common token */
TOKEN_FUNGIBLE_COMMON = 1,
/** TOKEN_NON_FUNGIBLE_UNIQUE - The resource prices are scoped to an operation on a non-fungible unique token */
TOKEN_NON_FUNGIBLE_UNIQUE = 2,
/**
* TOKEN_FUNGIBLE_COMMON_WITH_CUSTOM_FEES - The resource prices are scoped to an operation on a fungible common
* token with a custom fee schedule
*/
TOKEN_FUNGIBLE_COMMON_WITH_CUSTOM_FEES = 3,
/**
* TOKEN_NON_FUNGIBLE_UNIQUE_WITH_CUSTOM_FEES - The resource prices are scoped to an operation on a non-fungible unique
* token with a custom fee schedule
*/
TOKEN_NON_FUNGIBLE_UNIQUE_WITH_CUSTOM_FEES = 4,
/** SCHEDULE_CREATE_CONTRACT_CALL - The resource prices are scoped to a ScheduleCreate containing a ContractCall. */
SCHEDULE_CREATE_CONTRACT_CALL = 5,
UNRECOGNIZED = -1
}
export declare function subTypeFromJSON(object: any): SubType;
export declare function subTypeToJSON(object: SubType): string;
/**
* Possible Token Supply Types (IWA Compatibility).
* Indicates how many tokens can have during its lifetime.
*/
export declare enum TokenSupplyType {
/** INFINITE - Indicates that tokens of that type have an upper bound of Long.MAX_VALUE. */
INFINITE = 0,
/**
* FINITE - Indicates that tokens of that type have an upper bound of maxSupply,
* provided on token creation.
*/
FINITE = 1,
UNRECOGNIZED = -1
}
export declare function tokenSupplyTypeFromJSON(object: any): TokenSupplyType;
export declare function tokenSupplyTypeToJSON(object: TokenSupplyType): string;
/**
* Possible Freeze statuses returned on TokenGetInfoQuery or CryptoGetInfoResponse in
* TokenRelationship
*/
export declare enum TokenFreezeStatus {
/** FreezeNotApplicable - UNDOCUMENTED */
FreezeNotApplicable = 0,
/** Frozen - UNDOCUMENTED */
Frozen = 1,
/** Unfrozen - UNDOCUMENTED */
Unfrozen = 2,
UNRECOGNIZED = -1
}
export declare function tokenFreezeStatusFromJSON(object: any): TokenFreezeStatus;
export declare function tokenFreezeStatusToJSON(object: TokenFreezeStatus): string;
/** Possible KYC statuses returned on TokenGetInfoQuery or CryptoGetInfoResponse in TokenRelationship */
export declare enum TokenKycStatus {
/** KycNotApplicable - UNDOCUMENTED */
KycNotApplicable = 0,
/** Granted - UNDOCUMENTED */
Granted = 1,
/** Revoked - UNDOCUMENTED */
Revoked = 2,
UNRECOGNIZED = -1
}
export declare function tokenKycStatusFromJSON(object: any): TokenKycStatus;
export declare function tokenKycStatusToJSON(object: TokenKycStatus): string;
/** Possible Pause statuses returned on TokenGetInfoQuery */
export declare enum TokenPauseStatus {
/** PauseNotApplicable - Indicates that a Token has no pauseKey */
PauseNotApplicable = 0,
/** Paused - Indicates that a Token is Paused */
Paused = 1,
/** Unpaused - Indicates that a Token is Unpaused. */
Unpaused = 2,
UNRECOGNIZED = -1
}
export declare function tokenPauseStatusFromJSON(object: any): TokenPauseStatus;
export declare function tokenPauseStatusToJSON(object: TokenPauseStatus): string;
/** The transactions and queries supported by Hedera Hashgraph. */
export declare enum HederaFunctionality {
/**
* NONE - UNSPECIFIED - Need to keep first value as unspecified because first element is ignored and
* not parsed (0 is ignored by parser)
*/
NONE = 0,
/** CryptoTransfer - crypto transfer */
CryptoTransfer = 1,
/** CryptoUpdate - crypto update account */
CryptoUpdate = 2,
/** CryptoDelete - crypto delete account */
CryptoDelete = 3,
/** CryptoAddLiveHash - Add a livehash to a crypto account */
CryptoAddLiveHash = 4,
/** CryptoDeleteLiveHash - Delete a livehash from a crypto account */
CryptoDeleteLiveHash = 5,
/** ContractCall - Smart Contract Call */
ContractCall = 6,
/** ContractCreate - Smart Contract Create Contract */
ContractCreate = 7,
/** ContractUpdate - Smart Contract update contract */
ContractUpdate = 8,
/** FileCreate - File Operation create file */
FileCreate = 9,
/** FileAppend - File Operation append file */
FileAppend = 10,
/** FileUpdate - File Operation update file */
FileUpdate = 11,
/** FileDelete - File Operation delete file */
FileDelete = 12,
/** CryptoGetAccountBalance - crypto get account balance */
CryptoGetAccountBalance = 13,
/** CryptoGetAccountRecords - crypto get account record */
CryptoGetAccountRecords = 14,
/** CryptoGetInfo - Crypto get info */
CryptoGetInfo = 15,
/** ContractCallLocal - Smart Contract Call */
ContractCallLocal = 16,
/** ContractGetInfo - Smart Contract get info */
ContractGetInfo = 17,
/** ContractGetBytecode - Smart Contract, get the runtime code */
ContractGetBytecode = 18,
/** GetBySolidityID - Smart Contract, get by solidity ID */
GetBySolidityID = 19,
/** GetByKey - Smart Contract, get by key */
GetByKey = 20,
/** CryptoGetLiveHash - Get a live hash from a crypto account */
CryptoGetLiveHash = 21,
/** CryptoGetStakers - Crypto, get the stakers for the node */
CryptoGetStakers = 22,
/** FileGetContents - File Operations get file contents */
FileGetContents = 23,
/** FileGetInfo - File Operations get the info of the file */
FileGetInfo = 24,
/** TransactionGetRecord - Crypto get the transaction records */
TransactionGetRecord = 25,
/** ContractGetRecords - Contract get the transaction records */
ContractGetRecords = 26,
/** CryptoCreate - crypto create account */
CryptoCreate = 27,
/** SystemDelete - system delete file */
SystemDelete = 28,
/** SystemUndelete - system undelete file */
SystemUndelete = 29,
/** ContractDelete - delete contract */
ContractDelete = 30,
/** Freeze - freeze */
Freeze = 31,
/** CreateTransactionRecord - Create Tx Record */
CreateTransactionRecord = 32,
/** CryptoAccountAutoRenew - Crypto Auto Renew */
CryptoAccountAutoRenew = 33,
/** ContractAutoRenew - Contract Auto Renew */
ContractAutoRenew = 34,
/** GetVersionInfo - Get Version */
GetVersionInfo = 35,
/** TransactionGetReceipt - Transaction Get Receipt */
TransactionGetReceipt = 36,
/** ConsensusCreateTopic - Create Topic */
ConsensusCreateTopic = 50,
/** ConsensusUpdateTopic - Update Topic */
ConsensusUpdateTopic = 51,
/** ConsensusDeleteTopic - Delete Topic */
ConsensusDeleteTopic = 52,
/** ConsensusGetTopicInfo - Get Topic information */
ConsensusGetTopicInfo = 53,
/** ConsensusSubmitMessage - Submit message to topic */
ConsensusSubmitMessage = 54,
UncheckedSubmit = 55,
/** TokenCreate - Create Token */
TokenCreate = 56,
/** TokenGetInfo - Get Token information */
TokenGetInfo = 58,
/** TokenFreezeAccount - Freeze Account */
TokenFreezeAccount = 59,
/** TokenUnfreezeAccount - Unfreeze Account */
TokenUnfreezeAccount = 60,
/** TokenGrantKycToAccount - Grant KYC to Account */
TokenGrantKycToAccount = 61,
/** TokenRevokeKycFromAccount - Revoke KYC from Account */
TokenRevokeKycFromAccount = 62,
/** TokenDelete - Delete Token */
TokenDelete = 63,
/** TokenUpdate - Update Token */
TokenUpdate = 64,
/** TokenMint - Mint tokens to treasury */
TokenMint = 65,
/** TokenBurn - Burn tokens from treasury */
TokenBurn = 66,
/** TokenAccountWipe - Wipe token amount from Account holder */
TokenAccountWipe = 67,
/** TokenAssociateToAccount - Associate tokens to an account */
TokenAssociateToAccount = 68,
/** TokenDissociateFromAccount - Dissociate tokens from an account */
TokenDissociateFromAccount = 69,
/** ScheduleCreate - Create Scheduled Transaction */
ScheduleCreate = 70,
/** ScheduleDelete - Delete Scheduled Transaction */
ScheduleDelete = 71,
/** ScheduleSign - Sign Scheduled Transaction */
ScheduleSign = 72,
/** ScheduleGetInfo - Get Scheduled Transaction Information */
ScheduleGetInfo = 73,
/** TokenGetAccountNftInfos - Get Token Account Nft Information */
TokenGetAccountNftInfos = 74,
/** TokenGetNftInfo - Get Token Nft Information */
TokenGetNftInfo = 75,
/** TokenGetNftInfos - Get Token Nft List Information */
TokenGetNftInfos = 76,
/** TokenFeeScheduleUpdate - Update a token's custom fee schedule, if permissible */
TokenFeeScheduleUpdate = 77,
/** NetworkGetExecutionTime - Get execution time(s) by TransactionID, if available */
NetworkGetExecutionTime = 78,
/** TokenPause - Pause the Token */
TokenPause = 79,
/** TokenUnpause - Unpause the Token */
TokenUnpause = 80,
/** CryptoApproveAllowance - Approve allowance for a spender relative to the owner account */
CryptoApproveAllowance = 81,
/** CryptoDeleteAllowance - Deletes granted allowances on owner account */
CryptoDeleteAllowance = 82,
/**
* GetAccountDetails - Gets all the information about an account, including balance and allowances. This does not get the list of
* account records.
*/
GetAccountDetails = 83,
/** EthereumTransaction - Ethereum Transaction */
EthereumTransaction = 84,
/** NodeStakeUpdate - Updates the staking info at the end of staking period to indicate new staking period has started. */
NodeStakeUpdate = 85,
/** UtilPrng - Generates a pseudorandom number. */
UtilPrng = 86,
UNRECOGNIZED = -1
}
export declare function hederaFunctionalityFromJSON(object: any): HederaFunctionality;
export declare function hederaFunctionalityToJSON(object: HederaFunctionality): string;
/**
* Each shard has a nonnegative shard number. Each realm within a given shard has a nonnegative
* realm number (that number might be reused in other shards). And each account, file, and smart
* contract instance within a given realm has a nonnegative number (which might be reused in other
* realms). Every account, file, and smart contract instance is within exactly one realm. So a
* FileID is a triplet of numbers, like 0.1.2 for entity number 2 within realm 1 within shard 0.
* Each realm maintains a single counter for assigning numbers, so if there is a file with ID
* 0.1.2, then there won't be an account or smart contract instance with ID 0.1.2.
*
* Everything is partitioned into realms so that each Solidity smart contract can access everything
* in just a single realm, locking all those entities while it's running, but other smart contracts
* could potentially run in other realms in parallel. So realms allow Solidity to be parallelized
* somewhat, even though the language itself assumes everything is serial.
*/
export interface ShardID {
/** the shard number (nonnegative) */
shardNum: number;
}
/**
* The ID for a realm. Within a given shard, every realm has a unique ID. Each account, file, and
* contract instance belongs to exactly one realm.
*/
export interface RealmID {
/** The shard number (nonnegative) */
shardNum: number;
/** The realm number (nonnegative) */
realmNum: number;
}
/** The ID for an a cryptocurrency account */
export interface AccountID {
/** The shard number (nonnegative) */
shardNum: number;
/** The realm number (nonnegative) */
realmNum: number;
account?: {
$case: "accountNum";
accountNum: number;
} | {
$case: "alias";
alias: Uint8Array;
} | undefined;
}
/** Identifier for a unique token (or "NFT"), used by both contract and token services. */
export interface NftID {
/** The (non-fungible) token of which this NFT is an instance */
tokenId: TokenID | undefined;
/** The serial number of this NFT within its token type */
serialNumber: number;
}
/** The ID for a file */
export interface FileID {
/** The shard number (nonnegative) */
shardNum: number;
/** The realm number (nonnegative) */
realmNum: number;
/** A nonnegative File number unique within its realm */
fileNum: number;
}
/** The ID for a smart contract instance */
export interface ContractID {
/** The shard number (nonnegative) */
shardNum: number;
/** The realm number (nonnegative) */
realmNum: number;
contract?: {
$case: "contractNum";
contractNum: number;
} | {
$case: "evmAddress";
evmAddress: Uint8Array;
} | undefined;
}
/**
* The ID for a transaction. This is used for retrieving receipts and records for a transaction, for
* appending to a file right after creating it, for instantiating a smart contract with bytecode in
* a file just created, and internally by the network for detecting when duplicate transactions are
* submitted. A user might get a transaction processed faster by submitting it to N nodes, each with
* a different node account, but all with the same TransactionID. Then, the transaction will take
* effect when the first of all those nodes submits the transaction and it reaches consensus. The
* other transactions will not take effect. So this could make the transaction take effect faster,
* if any given node might be slow. However, the full transaction fee is charged for each
* transaction, so the total fee is N times as much if the transaction is sent to N nodes.
*
* Applicable to Scheduled Transactions:
* - The ID of a Scheduled Transaction has transactionValidStart and accountIDs inherited from the
* ScheduleCreate transaction that created it. That is to say that they are equal
* - The scheduled property is true for Scheduled Transactions
* - transactionValidStart, accountID and scheduled properties should be omitted
*/
export interface TransactionID {
/** The transaction is invalid if consensusTimestamp < transactionID.transactionStartValid */
transactionValidStart: Timestamp | undefined;
/** The Account ID that paid for this transaction */
accountID: AccountID | undefined;
/** Whether the Transaction is of type Scheduled or no */
scheduled: boolean;
/**
* The identifier for an internal transaction that was spawned as part
* of handling a user transaction. (These internal transactions share the
* transactionValidStart and accountID of the user transaction, so a
* nonce is necessary to give them a unique TransactionID.)
*
* An example is when a "parent" ContractCreate or ContractCall transaction
* calls one or more HTS precompiled contracts; each of the "child"
* transactions spawned for a precompile has a id with a different nonce.
*/
nonce: number;
}
/** An account, and the amount that it sends or receives during a cryptocurrency or token transfer. */
export interface AccountAmount {
/** The Account ID that sends/receives cryptocurrency or tokens */
accountID: AccountID | undefined;
/**
* The amount of tinybars (for Crypto transfers) or in the lowest
* denomination (for Token transfers) that the account sends(negative) or
* receives(positive)
*/
amount: number;
/**
* If true then the transfer is expected to be an approved allowance and the
* accountID is expected to be the owner. The default is false (omitted).
*/
isApproval: boolean;
}
/** A list of accounts and amounts to transfer out of each account (negative) or into it (positive). */
export interface TransferList {
/**
* Multiple list of AccountAmount pairs, each of which has an account and
* an amount to transfer into it (positive) or out of it (negative)
*/
accountAmounts: AccountAmount[];
}
/**
* A sender account, a receiver account, and the serial number of an NFT of a Token with
* NON_FUNGIBLE_UNIQUE type. When minting NFTs the sender will be the default AccountID instance
* (0.0.0) and when burning NFTs, the receiver will be the default AccountID instance.
*/
export interface NftTransfer {
/** The accountID of the sender */
senderAccountID: AccountID | undefined;
/** The accountID of the receiver */
receiverAccountID: AccountID | undefined;
/** The serial number of the NFT */
serialNumber: number;
/**
* If true then the transfer is expected to be an approved allowance and the
* senderAccountID is expected to be the owner. The default is false (omitted).
*/
isApproval: boolean;
}
/**
* A list of token IDs and amounts representing the transferred out (negative) or into (positive)
* amounts, represented in the lowest denomination of the token
*/
export interface TokenTransferList {
/** The ID of the token */
token: TokenID | undefined;
/**
* Applicable to tokens of type FUNGIBLE_COMMON. Multiple list of AccountAmounts, each of which
* has an account and amount
*/
transfers: AccountAmount[];
/**
* Applicable to tokens of type NON_FUNGIBLE_UNIQUE. Multiple list of NftTransfers, each of
* which has a sender and receiver account, including the serial number of the NFT
*/
nftTransfers: NftTransfer[];
/**
* If present, the number of decimals this fungible token type is expected to have. The transfer
* will fail with UNEXPECTED_TOKEN_DECIMALS if the actual decimals differ.
*/
expectedDecimals: number | undefined;
}
/** A rational number, used to set the amount of a value transfer to collect as a custom fee */
export interface Fraction {
/** The rational's numerator */
numerator: number;
/** The rational's denominator; a zero value will result in FRACTION_DIVIDES_BY_ZERO */
denominator: number;
}
/** Unique identifier for a topic (used by the consensus service) */
export interface TopicID {
/** The shard number (nonnegative) */
shardNum: number;
/** The realm number (nonnegative) */
realmNum: number;
/** Unique topic identifier within a realm (nonnegative). */
topicNum: number;
}
/** Unique identifier for a token */
export interface TokenID {
/** A nonnegative shard number */
shardNum: number;
/** A nonnegative realm number */
realmNum: number;
/** A nonnegative token number */
tokenNum: number;
}
/** Unique identifier for a Schedule */
export interface ScheduleID {
/** A nonnegative shard number */
shardNum: number;
/** A nonnegative realm number */
realmNum: number;
/** A nonnegative schedule number */
scheduleNum: number;
}
/**
* A Key can be a public key from either the Ed25519 or ECDSA(secp256k1) signature schemes, where
* in the ECDSA(secp256k1) case we require the 33-byte compressed form of the public key. We call
* these public keys primitive keys.
*
* If an account has primitive key associated to it, then the corresponding private key must sign
* any transaction to transfer cryptocurrency out of it.
*
* A Key can also be the ID of a smart contract instance, which is then authorized to perform any
* precompiled contract action that requires this key to sign.
*
* Note that when a Key is a smart contract ID, it doesn't mean the contract with that ID
* will actually create a cryptographic signature. It only means that when the contract calls a
* precompiled contract, the resulting "child transaction" will be authorized to perform any action
* controlled by the Key.
*
* A Key can be a "threshold key", which means a list of M keys, any N of which must sign in order
* for the threshold signature to be considered valid. The keys within a threshold signature may
* themselves be threshold signatures, to allow complex signature requirements.
*
* A Key can be a "key list" where all keys in the list must sign unless specified otherwise in the
* documentation for a specific transaction type (e.g. FileDeleteTransactionBody). Their use is
* dependent on context. For example, a Hedera file is created with a list of keys, where all of
* them must sign a transaction to create or modify the file, but only one of them is needed to sign
* a transaction to delete the file. So it's a single list that sometimes acts as a 1-of-M threshold
* key, and sometimes acts as an M-of-M threshold key. A key list is always an M-of-M, unless
* specified otherwise in documentation. A key list can have nested key lists or threshold keys.
* Nested key lists are always M-of-M. A key list can have repeated primitive public keys, but all
* repeated keys are only required to sign once.
*
* A Key can contain a ThresholdKey or KeyList, which in turn contain a Key, so this mutual
* recursion would allow nesting arbitrarily deep. A ThresholdKey which contains a list of primitive
* keys has 3 levels: ThresholdKey -> KeyList -> Key. A KeyList which contains several primitive
* keys has 2 levels: KeyList -> Key. A Key with 2 levels of nested ThresholdKeys has 7 levels:
* Key -> ThresholdKey -> KeyList -> Key -> ThresholdKey -> KeyList -> Key.
*
* Each Key should not have more than 46 levels, which implies 15 levels of nested ThresholdKeys.
*/
export interface Key {
key?: {
$case: "contractID";
contractID: ContractID;
} | {
$case: "ed25519";
ed25519: Uint8Array;
} | {
$case: "rsa3072";
rsa3072: Uint8Array;
} | {
$case: "ecdsa384";
ecdsa384: Uint8Array;
} | {
$case: "thresholdKey";
thresholdKey: ThresholdKey;
} | {
$case: "keyList";
keyList: KeyList;
} | {
$case: "ECDSASecp256k1";
ECDSASecp256k1: Uint8Array;
} | {
$case: "delegatableContractId";
delegatableContractId: ContractID;
} | undefined;
}
/**
* A set of public keys that are used together to form a threshold signature. If the threshold is N
* and there are M keys, then this is an N of M threshold signature. If an account is associated
* with ThresholdKeys, then a transaction to move cryptocurrency out of it must be signed by a list
* of M signatures, where at most M-N of them are blank, and the other at least N of them are valid
* signatures corresponding to at least N of the public keys listed here.
*/
export interface ThresholdKey {
/** A valid signature set must have at least this many signatures */
threshold: number;
/** List of all the keys that can sign */
keys: KeyList | undefined;
}
/**
* A list of keys that requires all keys (M-of-M) to sign unless otherwise specified in
* documentation. A KeyList may contain repeated keys, but all repeated keys are only required to
* sign once.
*/
export interface KeyList {
/** list of keys */
keys: Key[];
}
/**
* This message is DEPRECATED and UNUSABLE with network nodes. It is retained
* here only for historical reasons.
*
* Please use the SignaturePair and SignatureMap messages.
*
* @deprecated
*/
export interface Signature {
signature?: {
$case: "contract";
contract: Uint8Array;
} | {
$case: "ed25519";
ed25519: Uint8Array;
} | {
$case: "rsa3072";
rsa3072: Uint8Array;
} | {
$case: "ecdsa384";
ecdsa384: Uint8Array;
} | {
$case: "thresholdSignature";
thresholdSignature: ThresholdSignature;
} | {
$case: "signatureList";
signatureList: SignatureList;
} | undefined;
}
/**
* This message is DEPRECATED and UNUSABLE with network nodes. It is retained
* here only for historical reasons.
*
* Please use the SignaturePair and SignatureMap messages.
*
* @deprecated
*/
export interface ThresholdSignature {
/**
* for an N-of-M threshold key, this is a list of M signatures, at least N of which must be
* non-null
*/
sigs: SignatureList | undefined;
}
/**
* This message is DEPRECATED and UNUSABLE with network nodes. It is retained
* here only for historical reasons.
*
* Please use the SignaturePair and SignatureMap messages.
*
* @deprecated
*/
export interface SignatureList {
/** each signature corresponds to a Key in the KeyList */
sigs: Signature[];
}
/**
* The client may use any number of bytes from zero to the whole length of the public key for
* pubKeyPrefix. If zero bytes are used, then it must be that only one primitive key is required
* to sign the linked transaction; it will surely resolve to INVALID_SIGNATURE otherwise.
*
* IMPORTANT: In the special case that a signature is being provided for a key used to
* authorize a precompiled contract, the pubKeyPrefix must contain the entire public
* key! That is, if the key is a Ed25519 key, the pubKeyPrefix should be 32 bytes
* long. If the key is a ECDSA(secp256k1) key, the pubKeyPrefix should be 33 bytes long,
* since we require the compressed form of the public key.
*
* Only Ed25519 and ECDSA(secp256k1) keys and hence signatures are currently supported.
*/
export interface SignaturePair {
/** First few bytes of the public key */
pubKeyPrefix: Uint8Array;
signature?: {
$case: "contract";
contract: Uint8Array;
} | {
$case: "ed25519";
ed25519: Uint8Array;
} | {
$case: "rsa3072";
rsa3072: Uint8Array;
} | {
$case: "ecdsa384";
ecdsa384: Uint8Array;
} | {
$case: "ECDSASecp256k1";
ECDSASecp256k1: Uint8Array;
} | undefined;
}
/**
* A set of signatures corresponding to every unique public key used to sign a given transaction. If
* one public key matches more than one prefixes on the signature map, the transaction containing
* the map will fail immediately with the response code KEY_PREFIX_MISMATCH.
*/
export interface SignatureMap {
/** Each signature pair corresponds to a unique Key required to sign the transaction. */
sigPair: SignaturePair[];
}
/**
* A set of prices the nodes use in determining transaction and query fees, and constants involved
* in fee calculations. Nodes multiply the amount of resources consumed by a transaction or query
* by the corresponding price to calculate the appropriate fee. Units are one-thousandth of a
* tinyCent.
*/
export interface FeeComponents {
/** A minimum, the calculated fee must be greater than this value */
min: number;
/** A maximum, the calculated fee must be less than this value */
max: number;
/** A constant contribution to the fee */
constant: number;
/** The price of bandwidth consumed by a transaction, measured in bytes */
bpt: number;
/** The price per signature verification for a transaction */
vpt: number;
/** The price of RAM consumed by a transaction, measured in byte-hours */
rbh: number;
/** The price of storage consumed by a transaction, measured in byte-hours */
sbh: number;
/** The price of computation for a smart contract transaction, measured in gas */
gas: number;
/** The price per hbar transferred for a transfer */
tv: number;
/** The price of bandwidth for data retrieved from memory for a response, measured in bytes */
bpr: number;
/** The price of bandwidth for data retrieved from disk for a response, measured in bytes */
sbpr: number;
}
/** The fees for a specific transaction or query based on the fee data. */
export interface TransactionFeeSchedule {
/** A particular transaction or query */
hederaFunctionality: HederaFunctionality;
/**
* Resource price coefficients
*
* @deprecated
*/
feeData: FeeData | undefined;
/** Resource price coefficients. Supports subtype price definition. */
fees: FeeData[];
}
/**
* The total fee charged for a transaction. It is composed of three components – a node fee that
* compensates the specific node that submitted the transaction, a network fee that compensates the
* network for assigning the transaction a consensus timestamp, and a service fee that compensates
* the network for the ongoing maintenance of the consequences of the transaction.
*/
export interface FeeData {
/** Fee paid to the submitting node */
nodedata: FeeComponents | undefined;
/** Fee paid to the network for processing a transaction into consensus */
networkdata: FeeComponents | undefined;
/**
* Fee paid to the network for providing the service associated with the
* transaction; for instance, storing a file
*/
servicedata: FeeComponents | undefined;
/**
* SubType distinguishing between different types of FeeData, correlating
* to the same HederaFunctionality
*/
subType: SubType;
}
/**
* A list of resource prices fee for different transactions and queries and the time period at which
* this fee schedule will expire. Nodes use the prices to determine the fees for all transactions
* based on how much of those resources each transaction uses.
*/
export interface FeeSchedule {
/** List of price coefficients for network resources */
transactionFeeSchedule: TransactionFeeSchedule[];
/** FeeSchedule expiry time */
expiryTime: TimestampSeconds | undefined;
}
/** This contains two Fee Schedules with expiry timestamp. */
export interface CurrentAndNextFeeSchedule {
/** Contains current Fee Schedule */
currentFeeSchedule: FeeSchedule | undefined;
/** Contains next Fee Schedule */
nextFeeSchedule: FeeSchedule | undefined;
}
/**
* Contains the IP address and the port representing a service endpoint of a Node in a network. Used
* to reach the Hedera API and submit transactions to the network.
*/
export interface ServiceEndpoint {
/**
* The 32-bit IPv4 address of the node encoded in left to right order (e.g. 127.0.0.1 has 127
* as its first byte)
*/
ipAddressV4: Uint8Array;
/** The port of the node */
port: number;
}
/**
* The data about a node, including its service endpoints and the Hedera account to be paid for
* services provided by the node (that is, queries answered and transactions submitted.)
*
* If the serviceEndpoint list is not set, or empty, then the endpoint given by the
* (deprecated) ipAddress and portno fields should be used.
*
* All fields are populated in the 0.0.102 address book file while only fields that start with # are
* populated in the 0.0.101 address book file.
*/
export interface NodeAddress {
/**
* The IP address of the Node with separator & octets encoded in UTF-8. Usage is deprecated,
* ServiceEndpoint is preferred to retrieve a node's list of IP addresses and ports
*
* @deprecated
*/
ipAddress: Uint8Array;
/**
* The port number of the grpc server for the node. Usage is deprecated, ServiceEndpoint is
* preferred to retrieve a node's list of IP addresses and ports
*
* @deprecated
*/
portno: number;
/**
* Usage is deprecated, nodeAccountId is preferred to retrieve a node's account ID
*
* @deprecated
*/
memo: Uint8Array;
/**
* The node's X509 RSA public key used to sign stream files (e.g., record stream
* files). Precisely, this field is a string of hexadecimal characters which,
* translated to binary, are the public key's DER encoding.
*/
RSAPubKey: string;
/** # A non-sequential identifier for the node */
nodeId: number;
/** # The account to be paid for queries and transactions sent to this node */
nodeAccountId: AccountID | undefined;
/**
* # Hash of the node's TLS certificate. Precisely, this field is a string of
* hexadecimal characters which, translated to binary, are the SHA-384 hash of
* the UTF-8 NFKD encoding of the node's TLS cert in PEM format. Its value can be
* used to verify the node's certificate it presents during TLS negotiations.
*/
nodeCertHash: Uint8Array;
/** # A node's service IP addresses and ports */
serviceEndpoint: ServiceEndpoint[];
/** A description of the node, with UTF-8 encoding up to 100 bytes */
description: string;
/**
* [Deprecated] The amount of tinybars staked to the node
*
* @deprecated
*/
stake: number;
}
/**
* A list of nodes and their metadata that contains all details of the nodes for the network. Used
* to parse the contents of system files 0.0.101 and 0.0.102.
*/
export interface NodeAddressBook {
/** Metadata of all nodes in the network */
nodeAddress: NodeAddress[];
}
/**
* Hedera follows semantic versioning (https://semver.org/) for both the HAPI protobufs and the
* Services software. This type allows the getVersionInfo query in the
* NetworkService to return the deployed versions of both protobufs and software on the
* node answering the query.
*/
export interface SemanticVersion {
/** Increases with incompatible API changes */
major: number;
/** Increases with backwards-compatible new functionality */
minor: number;
/** Increases with backwards-compatible bug fixes */
patch: number;
/**
* A pre-release version MAY be denoted by appending a hyphen and a series of dot separated
* identifiers (https://semver.org/#spec-item-9); so given a semver 0.14.0-alpha.1+21AF26D3,
* this field would contain 'alpha.1'
*/
pre: string;
/**
* Build metadata MAY be denoted by appending a plus sign and a series of dot separated
* identifiers immediately following the patch or pre-release version
* (https://semver.org/#spec-item-10); so given a semver 0.14.0-alpha.1+21AF26D3, this field
* would contain '21AF26D3'
*/
build: string;
}
/** UNDOCUMENTED */
export interface Setting {
/** name of the property */
name: string;
/** value of the property */
value: string;
/** any data associated with property */
data: Uint8Array;
}
/** UNDOCUMENTED */
export interface ServicesConfigurationList {
/** list of name value pairs of the application properties */
nameValue: Setting[];
}
/** Token's information related to the given Account */
export interface TokenRelationship {
/** The ID of the token */
tokenId: TokenID | undefined;
/** The Symbol of the token */
symbol: string;
/**
* For token of type FUNGIBLE_COMMON - the balance that the Account holds in the smallest
* denomination. For token of type NON_FUNGIBLE_UNIQUE - the number of NFTs held by the account
*/
balance: number;
/**
* The KYC status of the account (KycNotApplicable, Granted or Revoked). If the token does not
* have KYC key, KycNotApplicable is returned
*/
kycStatus: TokenKycStatus;
/**
* The Freeze status of the account (FreezeNotApplicable, Frozen or Unfrozen). If the token does
* not have Freeze key, FreezeNotApplicable is returned
*/
freezeStatus: TokenFreezeStatus;
/** Tokens divide into 10decimals pieces */
decimals: number;
/**
* Specifies if the relationship is created implicitly. False : explicitly associated, True :
* implicitly associated.
*/
automaticAssociation: boolean;
}
/**
* A number of transferable units of a certain token.
*
* The transferable unit of a token is its smallest denomination, as given by the token's
* decimals property---each minted token contains 10decimals
* transferable units. For example, we could think of the cent as the transferable unit of the US
* dollar (decimals=2); and the tinybar as the transferable unit of hbar
* (decimals=8).
*
* Transferable units are not directly comparable across different tokens.
*/
export interface TokenBalance {
/** A unique token id */
tokenId: TokenID | undefined;
/**
* Number of transferable units of the identified token. For token of type FUNGIBLE_COMMON -
* balance in the smallest denomination. For token of type NON_FUNGIBLE_UNIQUE - the number of
* NFTs held by the account
*/
balance: number;
/** Tokens divide into 10decimals pieces */
decimals: number;
}
/** A sequence of token balances */
export interface TokenBalances {
tokenBalances: TokenBalance[];
}
/** A token - account association */
export interface TokenAssociation {
/** The token involved in the association */
tokenId: TokenID | undefined;
/** The account involved in the association */
accountId: AccountID | undefined;
}
/** Staking metadata for an account or a contract returned in CryptoGetInfo or ContractGetInfo queries */
export interface StakingInfo {
/** If true, this account or contract declined to receive a staking reward. */
declineReward: boolean;
/**
* The staking period during which either the staking settings for this account or contract changed (such as starting
* staking or changing staked_node_id) or the most recent reward was earned, whichever is later. If this account or contract
* is not currently staked to a node, then this field is not set.
*/
stakePeriodStart: Timestamp | undefined;
/** The amount in tinybars that will be received in the next reward situation. */
pendingReward: number;
/** The total of balance of all accounts staked to this account or contract. */
stakedToMe: number;
stakedId?: {
$case: "stakedAccountId";
stakedAccountId: AccountID;
} | {
$case: "stakedNodeId";
stakedNodeId: number;
} | undefined;
}
export declare const ShardID: {
encode(message: ShardID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ShardID;
fromJSON(object: any): ShardID;
toJSON(message: ShardID): unknown;
create(base?: DeepPartial): ShardID;
fromPartial(object: DeepPartial): ShardID;
};
export declare const RealmID: {
encode(message: RealmID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): RealmID;
fromJSON(object: any): RealmID;
toJSON(message: RealmID): unknown;
create(base?: DeepPartial): RealmID;
fromPartial(object: DeepPartial): RealmID;
};
export declare const AccountID: {
encode(message: AccountID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): AccountID;
fromJSON(object: any): AccountID;
toJSON(message: AccountID): unknown;
create(base?: DeepPartial): AccountID;
fromPartial(object: DeepPartial): AccountID;
};
export declare const NftID: {
encode(message: NftID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): NftID;
fromJSON(object: any): NftID;
toJSON(message: NftID): unknown;
create(base?: DeepPartial): NftID;
fromPartial(object: DeepPartial): NftID;
};
export declare const FileID: {
encode(message: FileID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FileID;
fromJSON(object: any): FileID;
toJSON(message: FileID): unknown;
create(base?: DeepPartial): FileID;
fromPartial(object: DeepPartial): FileID;
};
export declare const ContractID: {
encode(message: ContractID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ContractID;
fromJSON(object: any): ContractID;
toJSON(message: ContractID): unknown;
create(base?: DeepPartial): ContractID;
fromPartial(object: DeepPartial): ContractID;
};
export declare const TransactionID: {
encode(message: TransactionID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TransactionID;
fromJSON(object: any): TransactionID;
toJSON(message: TransactionID): unknown;
create(base?: DeepPartial): TransactionID;
fromPartial(object: DeepPartial): TransactionID;
};
export declare const AccountAmount: {
encode(message: AccountAmount, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): AccountAmount;
fromJSON(object: any): AccountAmount;
toJSON(message: AccountAmount): unknown;
create(base?: DeepPartial): AccountAmount;
fromPartial(object: DeepPartial): AccountAmount;
};
export declare const TransferList: {
encode(message: TransferList, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TransferList;
fromJSON(object: any): TransferList;
toJSON(message: TransferList): unknown;
create(base?: DeepPartial): TransferList;
fromPartial(object: DeepPartial): TransferList;
};
export declare const NftTransfer: {
encode(message: NftTransfer, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): NftTransfer;
fromJSON(object: any): NftTransfer;
toJSON(message: NftTransfer): unknown;
create(base?: DeepPartial): NftTransfer;
fromPartial(object: DeepPartial): NftTransfer;
};
export declare const TokenTransferList: {
encode(message: TokenTransferList, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TokenTransferList;
fromJSON(object: any): TokenTransferList;
toJSON(message: TokenTransferList): unknown;
create(base?: DeepPartial): TokenTransferList;
fromPartial(object: DeepPartial): TokenTransferList;
};
export declare const Fraction: {
encode(message: Fraction, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): Fraction;
fromJSON(object: any): Fraction;
toJSON(message: Fraction): unknown;
create(base?: DeepPartial): Fraction;
fromPartial(object: DeepPartial): Fraction;
};
export declare const TopicID: {
encode(message: TopicID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TopicID;
fromJSON(object: any): TopicID;
toJSON(message: TopicID): unknown;
create(base?: DeepPartial): TopicID;
fromPartial(object: DeepPartial): TopicID;
};
export declare const TokenID: {
encode(message: TokenID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TokenID;
fromJSON(object: any): TokenID;
toJSON(message: TokenID): unknown;
create(base?: DeepPartial): TokenID;
fromPartial(object: DeepPartial): TokenID;
};
export declare const ScheduleID: {
encode(message: ScheduleID, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ScheduleID;
fromJSON(object: any): ScheduleID;
toJSON(message: ScheduleID): unknown;
create(base?: DeepPartial): ScheduleID;
fromPartial(object: DeepPartial): ScheduleID;
};
export declare const Key: {
encode(message: Key, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): Key;
fromJSON(object: any): Key;
toJSON(message: Key): unknown;
create(base?: DeepPartial): Key;
fromPartial(object: DeepPartial): Key;
};
export declare const ThresholdKey: {
encode(message: ThresholdKey, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ThresholdKey;
fromJSON(object: any): ThresholdKey;
toJSON(message: ThresholdKey): unknown;
create(base?: DeepPartial): ThresholdKey;
fromPartial(object: DeepPartial): ThresholdKey;
};
export declare const KeyList: {
encode(message: KeyList, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): KeyList;
fromJSON(object: any): KeyList;
toJSON(message: KeyList): unknown;
create(base?: DeepPartial): KeyList;
fromPartial(object: DeepPartial): KeyList;
};
export declare const Signature: {
encode(message: Signature, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): Signature;
fromJSON(object: any): Signature;
toJSON(message: Signature): unknown;
create(base?: DeepPartial): Signature;
fromPartial(object: DeepPartial): Signature;
};
export declare const ThresholdSignature: {
encode(message: ThresholdSignature, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ThresholdSignature;
fromJSON(object: any): ThresholdSignature;
toJSON(message: ThresholdSignature): unknown;
create(base?: DeepPartial): ThresholdSignature;
fromPartial(object: DeepPartial): ThresholdSignature;
};
export declare const SignatureList: {
encode(message: SignatureList, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureList;
fromJSON(object: any): SignatureList;
toJSON(message: SignatureList): unknown;
create(base?: DeepPartial): SignatureList;
fromPartial(object: DeepPartial): SignatureList;
};
export declare const SignaturePair: {
encode(message: SignaturePair, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SignaturePair;
fromJSON(object: any): SignaturePair;
toJSON(message: SignaturePair): unknown;
create(base?: DeepPartial): SignaturePair;
fromPartial(object: DeepPartial): SignaturePair;
};
export declare const SignatureMap: {
encode(message: SignatureMap, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SignatureMap;
fromJSON(object: any): SignatureMap;
toJSON(message: SignatureMap): unknown;
create(base?: DeepPartial): SignatureMap;
fromPartial(object: DeepPartial): SignatureMap;
};
export declare const FeeComponents: {
encode(message: FeeComponents, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FeeComponents;
fromJSON(object: any): FeeComponents;
toJSON(message: FeeComponents): unknown;
create(base?: DeepPartial): FeeComponents;
fromPartial(object: DeepPartial): FeeComponents;
};
export declare const TransactionFeeSchedule: {
encode(message: TransactionFeeSchedule, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TransactionFeeSchedule;
fromJSON(object: any): TransactionFeeSchedule;
toJSON(message: TransactionFeeSchedule): unknown;
create(base?: DeepPartial): TransactionFeeSchedule;
fromPartial(object: DeepPartial): TransactionFeeSchedule;
};
export declare const FeeData: {
encode(message: FeeData, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FeeData;
fromJSON(object: any): FeeData;
toJSON(message: FeeData): unknown;
create(base?: DeepPartial): FeeData;
fromPartial(object: DeepPartial): FeeData;
};
export declare const FeeSchedule: {
encode(message: FeeSchedule, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): FeeSchedule;
fromJSON(object: any): FeeSchedule;
toJSON(message: FeeSchedule): unknown;
create(base?: DeepPartial): FeeSchedule;
fromPartial(object: DeepPartial): FeeSchedule;
};
export declare const CurrentAndNextFeeSchedule: {
encode(message: CurrentAndNextFeeSchedule, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): CurrentAndNextFeeSchedule;
fromJSON(object: any): CurrentAndNextFeeSchedule;
toJSON(message: CurrentAndNextFeeSchedule): unknown;
create(base?: DeepPartial): CurrentAndNextFeeSchedule;
fromPartial(object: DeepPartial): CurrentAndNextFeeSchedule;
};
export declare const ServiceEndpoint: {
encode(message: ServiceEndpoint, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ServiceEndpoint;
fromJSON(object: any): ServiceEndpoint;
toJSON(message: ServiceEndpoint): unknown;
create(base?: DeepPartial): ServiceEndpoint;
fromPartial(object: DeepPartial): ServiceEndpoint;
};
export declare const NodeAddress: {
encode(message: NodeAddress, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): NodeAddress;
fromJSON(object: any): NodeAddress;
toJSON(message: NodeAddress): unknown;
create(base?: DeepPartial): NodeAddress;
fromPartial(object: DeepPartial): NodeAddress;
};
export declare const NodeAddressBook: {
encode(message: NodeAddressBook, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): NodeAddressBook;
fromJSON(object: any): NodeAddressBook;
toJSON(message: NodeAddressBook): unknown;
create(base?: DeepPartial): NodeAddressBook;
fromPartial(object: DeepPartial): NodeAddressBook;
};
export declare const SemanticVersion: {
encode(message: SemanticVersion, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): SemanticVersion;
fromJSON(object: any): SemanticVersion;
toJSON(message: SemanticVersion): unknown;
create(base?: DeepPartial): SemanticVersion;
fromPartial(object: DeepPartial): SemanticVersion;
};
export declare const Setting: {
encode(message: Setting, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): Setting;
fromJSON(object: any): Setting;
toJSON(message: Setting): unknown;
create(base?: DeepPartial): Setting;
fromPartial(object: DeepPartial): Setting;
};
export declare const ServicesConfigurationList: {
encode(message: ServicesConfigurationList, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): ServicesConfigurationList;
fromJSON(object: any): ServicesConfigurationList;
toJSON(message: ServicesConfigurationList): unknown;
create(base?: DeepPartial): ServicesConfigurationList;
fromPartial(object: DeepPartial): ServicesConfigurationList;
};
export declare const TokenRelationship: {
encode(message: TokenRelationship, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TokenRelationship;
fromJSON(object: any): TokenRelationship;
toJSON(message: TokenRelationship): unknown;
create(base?: DeepPartial): TokenRelationship;
fromPartial(object: DeepPartial): TokenRelationship;
};
export declare const TokenBalance: {
encode(message: TokenBalance, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TokenBalance;
fromJSON(object: any): TokenBalance;
toJSON(message: TokenBalance): unknown;
create(base?: DeepPartial): TokenBalance;
fromPartial(object: DeepPartial): TokenBalance;
};
export declare const TokenBalances: {
encode(message: TokenBalances, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TokenBalances;
fromJSON(object: any): TokenBalances;
toJSON(message: TokenBalances): unknown;
create(base?: DeepPartial): TokenBalances;
fromPartial(object: DeepPartial): TokenBalances;
};
export declare const TokenAssociation: {
encode(message: TokenAssociation, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): TokenAssociation;
fromJSON(object: any): TokenAssociation;
toJSON(message: TokenAssociation): unknown;
create(base?: DeepPartial): TokenAssociation;
fromPartial(object: DeepPartial): TokenAssociation;
};
export declare const StakingInfo: {
encode(message: StakingInfo, writer?: _m0.Writer): _m0.Writer;
decode(input: _m0.Reader | Uint8Array, length?: number): StakingInfo;
fromJSON(object: any): StakingInfo;
toJSON(message: StakingInfo): unknown;
create(base?: DeepPartial): StakingInfo;
fromPartial(object: DeepPartial): StakingInfo;
};
type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
export type DeepPartial = T extends Builtin ? T : T extends Array ? Array> : T extends ReadonlyArray ? ReadonlyArray> : T extends {
$case: string;
} ? {
[K in keyof Omit]?: DeepPartial;
} & {
$case: T["$case"];
} : T extends {} ? {
[K in keyof T]?: DeepPartial;
} : Partial;
export {};
//# sourceMappingURL=basic_types.d.ts.map