PundiX CLI Guide
pundixd
pundixd is the tool that enables you to interact with the node that runs on the pundixd. In order to install it, follow the installation procedure.
Setting Up pundixd
The main command used to set up pundixd is the following:
This command will change parameters in client.toml. It also allows you to set a default value for each given flag.
First, set up the address of the full-node you want to connect to:
Then, let us set the default value of the --trust-node flag:
Finally, let us set the chain-id of the blockchain we want to interact with:
Main Structure of pundixd Commands
The pundixd help commands are nested. So, in terminal, pundixd will output docs for the top level commands (status, config, query, and tx). You can access documentation for sub commands with further help commands.
The very first command to generate a list of available commands:
Return:
The return value will include:
a header which explains what the command is, for example
PundiX Chain Appthe usage for example
pundixd [command]where you will need to input pundixd and a follow up command likepundixd txall available commands
and all flags which might be needed for commands
We will be going through a common command along with the various sub commands and flags. Selecting the tx command:
Return:
You may either choose to insert a flag or a command after pundixd tx:
Example: tx gov
If you have already start pundixd, you can use the gov command to interact with the governance module.
It will return:
Continuing:
Return:
Now if you use the --help flag:
Return:
For example:
Where proposal.json contains:
Which is equivalent to:
Denom
In general case, users can leave fees and gas price details as default values without input any flags.
Otherwise, a transaction fee must be set! So do remember to add --fees and --gas-prices in your command. If you did not input the --gas-prices flag, you will be prompted to add it in your command since you changed all gas cost into fees. This will help people set all fees in one flag.
For example transaction is 0.5PUNDIX which after multiplying by 10^18 is 500000000000000000ibc/55367b7b6572631b78a93c66ef9fdfce87cde372cc4ed7848da78c1eb1dcdd78. For the mainnet denom, we will use PUNDIX in general case. For the number, the 200000000000000000 means the result of multiplying the default value of gas-prices and gas-limit. The default value of --gas-prices is 2000000000000 and gas-limit is 100000. --gas-adjustment=1.2 means that there will be a 20% buffer added to the automatically assessed gas amount.
Beseides, if users want to set gas price mannually, they need to care gas-prices, gas-limit and gas-adjustment. A more universal command is --gas=auto. --gas=auto automatically assesses the gas used for that transaction. This depends on the transaction itself and also the state of the blockchain. For more details on gas, kindly refer to the section on gas below.
Return:
After inputting y:
Keys
Key Types
There are three types of key representations that are used:
px:Derived from account keys generated by
pundixd keys addUsed to receive funds
Addresses that only have a preceding
pxare wallet addressesFor example:
px15h6vd5f0wqps26zjlwrc6chah08ryu4hzzdwhc
pxvaloper:Used to associate a validator to it's operator
Used to invoke staking commands
Addresses preceding with
pxvaloperare validator consensus addressFor example:
pxvaloper1carzvgq3e6y3z5kz5y6gxp3wpy3qdrv928vyah
Generate Keys
You'll need an account with a private and public key pair (a.k.a. sk,pk respectively) to be able to receive funds, send txs, bond tx, etc.
To generate an old secp256k1 key, follow this guide. New eth_secp256k1 will be the default key generation scheme when PundiX becomes EVM compatible.
To generate a new eth_secp256k1 key by default:
It returns some information about the key and the address it was generated for:
The output of the above command will contain a mnemonic like ``. It is recommended to save the mnemonic in a safe place so that in case you forget the password of the operating system's credentials store, you could eventually regenerate the key from the mnemonic with the following command:
It require to input y:
The user need to input mnemonic:
Then all the account information shows:
If you check your private keys in any time, you'll now see <account_name>:
Additionally and importantly, if you wish to have an added layer of protection on your keys, you may add the --keyring-backend flag and specify the file name. Setting your key up this way will ensure another layer of protection for signing any transactions.
you will be prompted for a keyring passphrase (password must be at least 8 characters) :
In the future, whenever you use this account to sign off on a transaction, you will have to add the --keyring-backend <file_name> flag and enter the keyring passphrase.
Save a backup of your keyring passphrase in a secure place. Losing your keyring passphrase will result in the lost of all your funds created using the keyring passphrase❗
Also to access your keys in the keyring file DO NOT forget to add the --keyring flag.
View the validator operator's address via:
You can see all your available keys by typing:
Note that this return with account address is quite different with the validator operator's address.
View the validator pubkey for your node by typing:
This is the Tendermint signing key, NOT the operator key you will use in delegation transactions.
Warning: We strongly recommend NOT using the same passphrase for multiple keys. The PundiX team will not be responsible for the loss of funds.
Generate Multisig Public Keys
You can generate and print a multisig public key by typing:
For multisig accounts, if you were to create any transaction, for example --from=<multisig_account>.
The <multisig_account> needs to be the wallet address ie px123l3kjltjwlfgjslfg.... not the account name.
Only for those non-multisig accounts can you use the name of the account ie --from=sheldoncooper.
K is the minimum number of private keys that must have signed the transactions that carry the public key's address as signer.
The --multisig flag must contain the name of public keys that will be combined into a public key that will be generated and stored as new_key_name in the local database. All names supplied through --multisig must already exist in the local database. Unless the flag --nosort is set, the order in which the keys are supplied on the command line does not matter, for example the following commands generate two identical keys:
Multisig addresses can also be generated on-the-fly and printed through the which command:
The above command will generate a multisig address and print it to the console. But this time the order of the multisig names does matter. For example the command line with a1 a2 a3 and a2 a1 a3 will generate two different multisig addresses. With same --multisig-threshold=2, the bk key is the same as the order a3 a1 a2 generated.
For more information regarding how to generate, sign and broadcast transactions with a multi signature account see Multisig Transactions.
Migrate Keys From Legacy On-Disk Keybase To OS Built-in Secret Store
Older versions of pundixd used store keys in the user's home directory. If you are migrating from an old version of pundixd you will need to migrate your old keys into your operating system's credentials storage by running the following command:
The command will prompt for each passphrase. If a passphrase is incorrect, it will skip the respective key. The detail information of keys migration is here
Fees & Gas
Each transaction may either use the --fees or --gas flags, but not both.
Validator's have a minimum gas price (multi-denom) configuration and they use this value when determining if they should include the transaction in a block during CheckTx, where gasPrices >= minGasPrices. Note, your transaction must use fees that are greater than or equal to any of the denominations the validator requires.
Note: With such a mechanism in place, validators may start to prioritize txs by gas-prices in the mempool, so providing higher fees or gas prices may yield higher tx priority.
To query the gas price of your current node:
You may want to cap the maximum gas that can be consumed by the transaction via the --gas flag. If you pass --gas="auto", the gas supply will be automatically estimated before executing the transaction.
Gas estimate might be inaccurate as state changes could occur in between the end of the simulation and the actual execution of a transaction, thus an adjustment is applied on top of the original estimate in order to ensure the transaction is broadcasted successfully. The adjustment can be controlled via the --gas-adjustment flag. The default value is 1.2.
Account
Get Testnet Tokens
On a testnet, getting tokens is usually done via a faucet. You may refer to this link.
Query Account Balance
After receiving tokens to your address, you can view your account's balance by typing:
If the generated account has no tokens. It shows:
If the account had no transaction history, the address will not be detected on the chain.
It shows:
This can also happen if you fund the account before your node has fully synced with the chain. These are both normal.
Send Tokens
The following command could be used to send coins from one account to another:
The amount argument accepts the format <value|coin_name>, for example 10PUNDIX which is equivalent to 10000000000000000000ibc/55367B7B6572631B78A93C66EF9FDFCE87CDE372CC4ED7848DA78C1EB1DCDD78.
Now, view the updated balances of the origin and destination accounts:
You can also check your balance at a given block by using the --height flag:
Furthermore, you can build a transaction and print its JSON format to STDOUT by appending --generate-only to the list of the command line arguments. Running the following command will store build the transaction and store it in a file named "unsignedSendTx.json":
The --generate-only flag prevents pundixd from accessing the local keybase. Thus when such flag is supplied <sender_key_name_or_address> must be an address.
You can broadcast the signed transaction to a node by providing the JSON file to the following command:
Tx Broadcasting
When broadcasting transactions, pundixd accepts a --broadcast-mode flag. This flag can have a value of sync (default), async, or block, where sync makes the client return a CheckTx response, async makes the client return immediately, and block makes the client wait for the tx to be committed (or timing out).
It is important to note that the block mode should NOT be used in most circumstances. This is because broadcasting can timeout but the tx may still be included in a block. This can result in many undesirable situations. Therefore, it is best to use sync or async and query by tx hash to determine when the tx is included in a block.
Query Transactions
Matching a Set of Events
You can use the transaction search command to query for transactions that match a specific set of events, which are added on every transaction.
Each event is composed by a key-value pair in the form of {eventType}.{eventAttribute}={value}. Events can also be combined to query for a more specific result using the & symbol.
You can query transactions by events as follows:
And for using multiple events:
The pagination is supported as well via page and limit:
The action tag always equals the message type returned by the Type() function of the relevant message.
You can find a list of available events on each of the SDK modules:
Matching a Transaction's Hash
You can also query a single transaction by its hash using the following command:
tx hash on the block explorer are preceded with 0x. Please omit the 0x from the tx hash
Staking
Set up a Validator
Please refer to the Validator Setup section for a more complete guide on how to set up a validator.
Delegate to a Validator
On the upcoming mainnet, you can delegate PUNDIX to a validator. These delegators can receive part of the validator's fee revenue. Read more about the incentives.
Query Validators
You can query the list of all validators of a specific chain:
If you want to get the information of a single validator you can check it with:
Bond Tokens
On the PundiX mainnet, we delegate PUNDIX. Here's how you can bond tokens to a testnet validator (for example, delegate):
<validator_operator_address> is the operator address of the validator to which you intend to delegate. If you are running a local testnet, you can find this with:
Where <account_name> is the name of the key you specified when you initialized pundixd.
While tokens are bonded, they are pooled with all the other bonded tokens in the network. Validators and delegators obtain a percentage of shares that equal their stake in this pool.
Query Delegations
In this section and the next, do make sure you check if the command has a plural form or not. Adding an (s) behind delegation to delegations results in a different command.
Once submitted a delegation to a validator, you can see it's information by using the following command:
Or if you want to check all your current delegations with disctinct validators:
You can also query all of the delegations to a particular validator:
Unbond Tokens
If for any reason the validator misbehaves, or you just want to unbond a certain amount of tokens, use this following command.
The unbonding will be automatically completed when the unbonding period has passed.
Query Unbonding-Delegations
Once you begin an unbonding-delegation, you can see it's information by using the following command:
If you want to check all your current unbonding-delegations with disctinct validators:
Additionally, as you can get all the unbonding-delegations from a particular validator:
Redelegate Tokens
A redelegation is a type delegation that allows you to bond illiquid tokens from one validator to another:
Here you can also redelegate a specific shares-amount or a shares-fraction with the corresponding flags.
The redelegation will be automatically completed when the unbonding period has passed.
Query Redelegations
Once you begin a redelegation, you can see it's information by using the following command:
It returns:
If you want to check all your current unbonding-delegations with distinct validators:
It returns:
Additionally, as you can get all the outgoing redelegations from a particular validator:
It returns:
However, there is a limit to how frequent you can redelegate. For more information on redelegation.
Query Parameters
Parameters define high level settings for staking. You can get the current values by using:
It returns:
With the above command you will get the values for:
Unbonding time
Maximum numbers of validators
Coin denomination for staking
All these values will be subject to updates through a governance process by ParameterChange proposals.
Query Pool
A staking Pool defines the dynamic parameters of the current state. You can query them with the following command:
With the pool command you will get the values for:
Bonded tokens
Not-bonded tokens
Slashing
Unjailing
To unjail your jailed validator:
Signing Info
To retrieve a validator's signing info:
Query Parameters
You can get the current slashing parameters via:
Minting
You can query for the minting/inflation parameters via:
It returns:
To query for the current inflation value:
It returns:
To query for the current annual provisions value:
It returns:
Checking Block Information and Validators Signatures
The following command will query for a transaction by hash in a committed block:
The following command will get verified data for a the block at given height:
Using these commands and filtering out the necessary information, you will be able to deduce the uptime of other validators by checking if they missed any signatures for that block.
A sample query to check for any missing validator signature given a particular block height:
Governance
Governance is the process from which users in the PundiX can come to consensus on software upgrades, parameters of the mainnet or signaling mechanisms through text proposals. This is done through voting on proposals, which will be submitted by PUNDIX holders on the mainnet.
Some considerations about the voting process:
Voting is done by bonded
PUNDIXholders on a 100 bondedPUNDIX1 vote basisDelegators who DO NOT vote will inherit the vote of their validator
Votes are tallied at the end of the voting period (2 weeks on mainnet). Addresses can vote multiple times before the end of the voting period to update their
Optionvalue (incurring transaction fees each time), only the most recently casted vote will count as validVoters can choose between options
Yes,No,NoWithVetoandAbstainBy the end of the voting period, a proposal is accepted if:
(YesVotes / (YesVotes+NoVotes+NoWithVetoVotes)) > 1/2(NoWithVetoVotes / (YesVotes+NoVotes+NoWithVetoVotes)) < 1/3((YesVotes+NoVotes+NoWithVetoVotes) / totalBondedStake) >= quorum
For more information about the governance process and how it works, please check out the Governance module specification.
The minimum deposit for a governance proposal is 10,000PUNDIX (through the command line, this amounts to 10000000000000000000000ibc/55367b7b6572631b78a93c66ef9fdfce87cde372cc4ed7848da78c1eb1dcdd78 after multiplying by 10^18). Since the ibc token denom is too long, we will only use PUNDIX in general case.
Create a Governance Proposal
In order to create a governance proposal, you must submit an initial deposit along with a title and description. Various modules outside of governance may implement their own proposal types and handlers (for example parameter changes), where the governance module itself supports Text proposals. Any module outside of governance has it's command mounted on top of submit-proposal.
To submit a Text proposal (the title and description fields will be string input so enclose the input in ""):
You may also provide the proposal directly through the --proposal flag which points to a JSON file containing the proposal. Create proposal.json which contains the following:
To submit a parameter change proposal, you must provide a proposal file as its contents are less friendly to CLI input:
Currently parameter changes are evaluated but not validated, so it is very important that any value change is valid (for example correct type and within bounds) for its respective parameter, for example MaxValidators should be an integer and not a decimal.
Proper vetting of a parameter change proposal should prevent this from happening (no deposits should occur during the governance process), but it should be noted regardless.
The SoftwareUpgrade command is currently not supported as it's not implemented and currently does not differ from the semantics of a Text proposal.
Query Proposals
Once created, you can now query information of the proposal:
It returns:
Or query all available proposals:
You can also query proposals filtered by voter or depositor by using the corresponding flags.
To query for the proposer of a given governance proposal:
It returns:
Increase Deposit
In order for a proposal to be broadcasted to the network, the amount deposited must be above a minDeposit value (initial value: 10000PUNDIX). If the proposal you previously created didn't meet this requirement, you can still increase the total amount deposited to activate it. Once the minimum deposit is reached, the proposal enters voting period:
Proposals that don't meet this requirement will be deleted after MaxDepositPeriod is reached.
Query Deposits
Once a new proposal is created, you can query all the deposits submitted to it:
It returns:
You can also query a deposit submitted by a specific address:
It returns:
Vote on a Proposal
After a proposal's deposit reaches the MinDeposit value, the voting period opens. Bonded PUNDIX holders can then cast vote on it:
Query Votes
Check the vote with the option you just submitted:
You can also get all the previous votes submitted to the proposal with:
Query proposal tally results
To check the current tally of a given proposal you can use the tally command:
Query Governance Parameters
To check the current governance parameters run:
To query subsets of the governance parameters run:
Fee Distribution
Query Distribution Parameters
To check the current distribution parameters, run:
Query Distribution Ecosystem Genesis Fund
To query all coins in the Ecosystem Genesis Fund which is under Governance control:
Query Outstanding Rewards
To check the current total outstanding (un-withdrawn) rewards of a particular validator (validator's + delegators' rewards), run:
Query Validator Commission
To check the current outstanding commission for a validator (excluding the rewards of the wallet tied to that validator address), run:
Query Validator Slashes
To check historical slashes for a validator, run:
Query Delegator Rewards
To check current rewards for a delegation (were they to be withdrawn), run:
Query All Delegator Rewards
To check all current rewards for a delegation (were they to be withdrawn), run:
Claiming Rewards
Claiming rewards for delegators and validators
Withdraw rewards from a given delegation address, and optionally withdraw validator commission (by adding in a --commission flag, see below) if the delegation address given is a validator operator:
Withdraw the validator's commission in addition to the rewards:
Multisig Transactions
Multisig transactions require signatures of multiple private keys. Thus, generating and signing a transaction from a multisig account involve cooperation among the parties involved. A multisig transaction can be initiated by any of the key holders, and at least one of them would need to import other parties' public keys into their Keybase and generate a multisig public key in order to finalize and broadcast the transaction.
For example, given a multisig key comprising the keys p1, p2, and p3, each of which is held by a distinct party, the user holding p1 would require to import both p2 and p3 in order to generate the multisig account public key:
A new multisig public key bk has been stored, and its address will be used as signer of multisig transactions:
You may also view multisig threshold, pubkey constituents and respective weights by viewing the JSON output of the key or passing the --show-multisig flag:
The first step to create a multisig transaction is to initiate it on behalf of the multisig address created above:
For multisig accounts, if you were to create any transaction, for example --from=<multisig_account> your <multisig_account> needs to be the wallet address ie px123l3kjltjwlfgjslfg..... Only for those non-multisig accounts can you use the name of the account ie --from=heimendinger.
The file unsignedTx.json contains the unsigned transaction encoded in JSON. p1 can now sign the transaction with its own private key:
Once the signature is generated, p1 transmits both unsignedTx.json and p1signature.json to p2 or p3, which in turn will generate their respective signature:
The Mainnet ChainID should be pundix
bk is a 2-of-3 multisig key, therefore one additional signature is sufficient. Any the key holders can now generate the multisig transaction by combining the required signature files:
The transaction can now be sent to the node:
Shells Completion Scripts
Completion scripts for popular UNIX shell interpreters such as Bash and Zsh can be generated through the completion command, which is available for both pundixd and pundixd.
If you want to generate Bash completion scripts run the following command:
If you want to generate Zsh completion scripts run the following command:
On most UNIX systems, such scripts may be loaded in .bashrc or .bash_profile to enable Bash autocompletion:
Refer to the user's manual of your interpreter provided by your operating system for information on how to enable shell autocompletion.
Last updated