If you don't want to have to remember the command to open the console, you can create a simple bash script to open it. First, open a document called openconsole.sh
nano openconsole.sh
That will open a text editor. In the text editor, copy and paste the below:
Then type ctrl-x then y to save and exit. To make it executable:
chmod u+x openconsolecc.sh
The console can now be opened by executing the command ./openconsolecc.sh
Once the console opens, you will see something like this:
Welcome to the Pchain JavaScript console!
instance: pchain/linux-amd64/go1.12.5
coinbase: 0x00000017f6f17ce18faa53d7010fa66acd0e1fb9
at block: 20346346 (Sun, 07 Feb 2021 05:59:12 UTC)
datadir: /root/.pchain/pchain
modules: admin:1.0 chain:1.0 debug:1.0 del:1.0 eth:1.0 miner:1.0 net:1.0 personal:1.0 pi:1.0 rpc:1.0 tdm:1.0 txpool:1.0 web3:1.0
>
Don't worry if you don't have a coinbase line as that only shows when you have generated/imported a key.
How to Use It For General Node Maintenance
Import Keys
Imports the given unencrypted private key (hex string) into the key store, encrypting it with the passphrase.
Returns the address of the new account.
personal.importRawKey(keydata, passphrase)
Create New Account
Generates a new private key and stores it in the key store directory. The key file is encrypted with the given passphrase. Returns the address of the new account.
At the Pchain console, newAccount will prompt for a passphrase when it is not supplied as the argument.
personal.newAccount()
Unlock Your Account
Decrypts the key with the given address from the key store.
Both passphrase and unlock duration are optional when using the JavaScript console. If the passphrase is not supplied as an argument, the console will prompt for the passphrase interactively.
The unencrypted key will be held in memory until the unlock duration expires. If the unlock duration defaults to 300 seconds. An explicit duration of zero seconds unlocks the key until Pchain exits.
The account can be used with eth_sign and eth_sendTransaction while it is unlocked.
Creates a new message call transaction or a contract creation, if the data field contains code.
Parameters
from: DATA, 20 Bytes - The address the transaction is sent from.
to: DATA, 20 Bytes - (optional when creating a new contract) The address the transaction is directed to.
gas: QUANTITY - (optional, default: 90000) Integer of the gas provided for the transaction execution. It will return unused gas.
gasPrice: QUANTITY - (optional, default: To-Be-Determined) Integer of the gasPrice used for each paid gas
value: QUANTITY - (optional) Integer of the value sent with this transaction
nonce: QUANTITY - (optional) Integer of a nonce. This allows to overwrite your own pending transactions that use the same nonce.
personal.sendTransaction({from: "youraddress", to: "toaddress", value: "amount"})
Where the amount is in p-wei. Alternatively, you can replace the "amount" with another fuction to convert PI to p-wei:
personal.sendTransaction({from: "youraddress", to: "toaddress", value: web3.toWei(1.23, "pi")})
This will error if your account is not unlocked, so you can either unlock it, or pass it your password:
personal.sendTransaction({from: "youraddress", to: "toaddress", value: web3.toWei(1.23, "pi")}, "password")
Sign Message
The sign method calculates a Pchain specific signature with: sign(keccack256("\x19Pchain Signed Message:\n" + len(message) + message))).
By adding a prefix to the message makes the calculated signature recognisable as a Pchain specific signature. This prevents misuse where a malicious DApp can sign arbitrary data (e.g. transaction) and use the signature to impersonate the victim.
See ecRecover to verify the signature.
personal.sign(message, account, [password])
Check If Your Node Is Syncing
pi.syncing
Returns either true or false. False can also mean you are fully synced.
Check If Your Node Is Mining
pi.mining
Returns either true or false depending on whether your node is a member of the validation set for the current epoch.
Check Current Block Number
pi.blockNumber
Returns the current block number your node is synced to.
Check Current Epoch
tdm.getCurrentEpochNumber
Returns the current epoch number your node is synced to in hex.
Check Epoch Details
tdm.getEpoch("epochNumber")
where epochNumber is the epoch number you want to get details on in hex, e.g. 0x16 for epoch 22. Returns details on epoch phases and the list of validators.
balance: QUANTITY - integer of the current balance in p-wei.
total_delegateBalance: QUANTITY - total delegate balance in p-wei to other address
total_depositBalance: QUANTITY - deposit balance in p-wei for Validator Stake
total_depositProxiedBalance: QUANTITY - total deposit proxied balance in p-wei for Validator Stake
total_pendingRefundBalance: QUANTITY - total pending refund balance in p-wei which will be return to delegate at the end of Current Epoch
total_proxiedBalance: QUANTITY - total proxied balance in p-wei delegate from other address
total_rewardBalance: QUANTITY - total pending reward balance in p-wei of this address
proxied_detail: Object - detail record of each address's proxied data, including proxied balance, deposit proxied balance and pending refund balance
reward_detail: Object - detail record of this address's reward data, including how much balance in p-wei will be given at the end of each epoch
pi.getFullBalance('address','latest',true)
Check Number of Peers Your Node is Connected To
web3.net.peerCount
Returns the number of other nodes your node is connected to.
How to Use It For More Complex Purposes
Since it is a JavaScript console, you have complete ECMA5 functionality(Go Pchain uses Otto JS VM, which is a JS interpreter written in Go). You can declare variables, use control structures, define new methods, and even use any of setInterval, clearInterval, setTimeout, and clearTimeout.
Example: Check For Number of Transactions Between a Range of Blocks
From within the console, you can write a Javascript function
function checkTransactionCount(startBlockNumber, endBlockNumber) {
console.log("Searching for non-zero transaction counts between blocks " + startBlockNumber + " and " + endBlockNumber);
for (var i = startBlockNumber; i <= endBlockNumber; i++) {
var block = pi.getBlock(i);
if (block != null) {
if (block.transactions != null && block.transactions.length != 0) {
console.log("Block #" + i + " has " + block.transactions.length + " transactions")
}
}
}
}
Then you can execute this function with:
checkTransactionCount(20370000,20375688)
Which returns:
Searching for non-zero transaction counts between blocks 20370000 and 20375688
Block #20370175 has 1 transactions
Block #20370692 has 1 transactions
Block #20371258 has 1 transactions
Block #20372828 has 1 transactions
Block #20373711 has 1 transactions
Block #20373743 has 1 transactions
Block #20375586 has 1 transactions
Example: Check For Blocks Your Node Has Mined
This one is a bit more complicated, requiring multiple function definitions. In practice, you can write these in a separate text editor as one concatenated function and paste it as one in order to simplify it down. This is broken down for simplicity.
Then, a function to print block info from a specific miner.
function getMinedBlocks(miner, startBlockNumber, endBlockNumber) {
if (endBlockNumber == null) {
endBlockNumber = pi.blockNumber;
console.log("Using endBlockNumber: " + endBlockNumber);
}
if (startBlockNumber == null) {
startBlockNumber = endBlockNumber - 10000;
console.log("Using startBlockNumber: " + startBlockNumber);
}
console.log("Searching for miner \"" + miner + "\" within blocks " + startBlockNumber + " and " + endBlockNumber + "\"");
for (var i = startBlockNumber; i <= endBlockNumber; i++) {
if (i % 1000 == 0) {
console.log("Searching block " + i);
}
var block = pi.getBlock(i);
if (block != null) {
if (block.miner == miner || miner == "*") {
console.log("Found block " + block.number);
printBlock(block);
}
}
}
}
If startBlockNumber is not specified, it will default to the last 10,000 blocks. This takes some time to scan, so reduce this number to 1000 to reduce the scanning time.
If endBlockNumber is not specified, it will default to the latest block number.
Then one last one just to make entering your node address easier:
function getMyMinedBlocks(startBlockNumber, endBlockNumber) {
getMinedBlocks(pi.accounts[0], startBlockNumber, endBlockNumber);
}
Now you can use this to see block details of the blocks your node mined:
getMyMinedBlocks(startblock,endblock)
Which returns for example from getMyMinedBlocks(20376850,20376860)
data: DATA - The compiled code of a contract OR the hash of the invoked method signature and encoded parameters. For details see
QUANTITY|TAG - integer block number, or the string "latest", "earliest" or "pending", see the
The Javascript console allows you to not only use predefined functions to pull information from the network, but you can also create custom functions using Javascript to do anything you can think of using the variety of functions defined in the and .
