lukechilds
/
docs
mirror of https://github.com/lukechilds/docs.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

docs: updates based on feedback

feat/stacks-js-updates
Alexander Graebe 4 years ago
parent
f311c525e8
commit
0e3344046a
2 changed files with 109 additions and 61 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 112
      src/pages/stacks-blockchain/integrate-stacking.md
  2. 28
      src/pages/stacks-blockchain/stacking.md

112
src/pages/stacks-blockchain/integrate-stacking.md
View File

@ -9,11 +9,11 @@ images:
sm: /images/pages/stacking-rounded.svg sm: /images/pages/stacking-rounded.svg
--- ---
![What you'll be creating in this tutorial](/images/stacking-view.png) ![What you'll create in this tutorial](/images/stacking-view.png)
## Introduction ## Introduction
In this tutorial, you will learn how to integrate Stacking by interacting with the respective smart contract and reading data from the Stacks blockchain. In this tutorial, you'll learn how to integrate Stacking by interacting with the respective smart contract, as well as reading data from the Stacks blockchain.
This tutorial highlights the following functionality: This tutorial highlights the following functionality:
@ -27,9 +27,9 @@ This tutorial highlights the following functionality:
## Requirements ## Requirements
First, you will need to understand the [Stacking mechanism](/stacks-blockchain/stacking). First, you'll need to understand the [Stacking mechanism](/stacks-blockchain/stacking).
You will also need [NodeJS](https://nodejs.org/en/download/) `8.12.0` or higher to complete this tutorial. You can verify your installation by opening up your terminal and run the following command: You'll also need [NodeJS](https://nodejs.org/en/download/) `8.12.0` or higher to complete this tutorial. You can verify your installation by opening up your terminal and run the following command:
```bash ```bash
node --version node --version
@ -37,16 +37,16 @@ node --version
## Overview ## Overview
In this tutorial, we will implement the Stacking flow laid out in the [Stacking guide](/stacks-blockchain/stacking#stacking-flow). In this tutorial, we'll implement the Stacking flow laid out in the [Stacking guide](/stacks-blockchain/stacking#stacking-flow).
-> Check out the sample source code for this tutorial in this GitHub repository: [stacking-integration-sample](https://github.com/agraebe/stacking-integration-sample) -> Check out the sample source code for this tutorial in this GitHub repository: [stacking-integration-sample](https://github.com/agraebe/stacking-integration-sample)
## Step 1: Integrate libraries ## Step 1: Integrate libraries
First install the stacks transactions library and an API client for the [Stacks 2.0 Blockchain API](/references/stacks-blockchain): Install the stacks transactions library and an API client for the [Stacks 2.0 Blockchain API](/references/stacks-blockchain):
```shell ```shell
npm install --save @blockstack/stacks-transactions @stacks/blockchain-api-client c32check npm install --save @blockstack/stacks-transactions @stacks/blockchain-api-client c32check cross-fetch bn.js
``` ```
-> The API client is generated from the [OpenAPI specification](https://github.com/blockstack/stacks-blockchain-api/blob/master/docs/openapi.yaml) ([openapi-generator](https://github.com/OpenAPITools/openapi-generator)). Many other languages and frameworks are be supported by the generator. -> The API client is generated from the [OpenAPI specification](https://github.com/blockstack/stacks-blockchain-api/blob/master/docs/openapi.yaml) ([openapi-generator](https://github.com/OpenAPITools/openapi-generator)). Many other languages and frameworks are be supported by the generator.
@ -56,6 +56,8 @@ npm install --save @blockstack/stacks-transactions @stacks/blockchain-api-client
To get started, let's create a new, random Stacks 2.0 account: To get started, let's create a new, random Stacks 2.0 account:
```js ```js
const fetch = require('cross-fetch');
const BN = require('bn.js');
const { const {
makeRandomPrivKey, makeRandomPrivKey,
privateKeyToString, privateKeyToString,
@ -115,9 +117,44 @@ console.log({ poxInfo, coreInfo, blocktimeInfo });
-> Check out the API references for the 3 endpoints used here: [GET /v2/info](https://blockstack.github.io/stacks-blockchain-api/#operation/get_core_api_info), [GET v2/pox](https://blockstack.github.io/stacks-blockchain-api/#operation/get_pox_info), and [GET /extended/v1/info/network_block_times](https://blockstack.github.io/stacks-blockchain-api/#operation/get_network_block_times) -> Check out the API references for the 3 endpoints used here: [GET /v2/info](https://blockstack.github.io/stacks-blockchain-api/#operation/get_core_api_info), [GET v2/pox](https://blockstack.github.io/stacks-blockchain-api/#operation/get_pox_info), and [GET /extended/v1/info/network_block_times](https://blockstack.github.io/stacks-blockchain-api/#operation/get_network_block_times)
The object, including PoX, core, and block time information, looks like this:
```js
{
poxInfo: {
contract_id: 'ST000000000000000000002AMW42H.pox',
first_burnchain_block_height: 0,
min_amount_ustx: 2000000000000,
registration_window_length: undefined,
rejection_fraction: 25,
reward_cycle_id: 4,
reward_cycle_length: 120
},
coreInfo: {
limit: undefined,
peer_version: 385875968,
burn_consensus: undefined,
burn_block_height: 605,
stable_burn_consensus: undefined,
stable_burn_block_height: 604,
server_version: 'blockstack-core 0.0.1 => 23.0.0.0 (master:5b816c2+, release build, linux [x86_64])',
network_id: 2147483648,
parent_network_id: 3669344250,
stacks_tip_height: 104,
stacks_tip: 'b05c6c5221b307ad41484ee527fa127ad1a09a0818ec64775309a3d4e4d40143',
stacks_tip_burn_block: undefined,
exit_at_block_height: null
},
blocktimeInfo: {
mainnet: { target_block_time: 600 },
testnet: { target_block_time: 120 }
}
}
```
-> Stacking execution will differ between mainnet and testnet in terms of cycle times and participation thresholds -> Stacking execution will differ between mainnet and testnet in terms of cycle times and participation thresholds
With the obtained PoX info, you can present if Stacking is executed in the next cycle, when the next cycle begins, the duration of a cycle, and the minimum micro-Stacks required to participate: With the obtained PoX info, you can present whether Stacking has been executed in the next cycle, when the next cycle begins, the duration of a cycle, and the minimum microstacks required to participate:
```js ```js
// will Stacking be executed in the next cycle? // will Stacking be executed in the next cycle?
@ -141,7 +178,7 @@ console.log({
stackingExecution, stackingExecution,
cycleDuration, cycleDuration,
nextCycleStartingAt, nextCycleStartingAt,
// mimnimum micro-Stacks required to participate // minimum microstacks required to participate
minimumUSTX: poxInfo.min_amount_ustx, minimumUSTX: poxInfo.min_amount_ustx,
}); });
``` ```
@ -155,14 +192,16 @@ const accountBalance = await accounts.getAccountBalance({
principal: stxAddress, principal: stxAddress,
}); });
const accountSTXBalance = accountBalance.stx.balance; const accountSTXBalance = new BN(accountBalance.stx.balance, 10);
const minAmountSTX = new BN(poxInfo.min_amount_ustx, 10);
// enough balance for participation? // enough balance for participation?
const canParticipate = accountSTXBalance >= poxInfo.min_amount_ustx; const canParticipate = accountSTXBalance.cmp(minAmountSTX) >= 0;
console.log({ res.json({
stxAddress, stxAddress,
accountSTXBalance, btcAddress: c32.c32ToB58(stxAddress),
accountSTXBalance: accountSTXBalance.toNumber(),
canParticipate, canParticipate,
}); });
``` ```
@ -173,7 +212,7 @@ For testing purposes, you can use a faucet to obtain STX tokens:
curl -XPOST "https://stacks-node-api.blockstack.org/extended/v1/faucets/stx?address=<stxAddress>&stacking=true" curl -XPOST "https://stacks-node-api.blockstack.org/extended/v1/faucets/stx?address=<stxAddress>&stacking=true"
``` ```
You will have to wait a few minutes for the transaction to complete. You'll have to wait a few minutes for the transaction to complete.
Users can select how many cycles they would like to participate in. To help with that decision, the unlocking time can be estimated: Users can select how many cycles they would like to participate in. To help with that decision, the unlocking time can be estimated:
@ -191,15 +230,15 @@ unlockingAt.setSeconds(
## Step 4: Verify stacking eligibility ## Step 4: Verify stacking eligibility
At this point, your app shows Stacking details. If Stacking is executed and the user has enough funds, the user should be asked to provide input for the amount of micro-STX to lockup and a bitcoin address to be used to pay out rewards. At this point, your app shows Stacking details. If Stacking is executed and the user has enough funds, the user should be asked to provide input for the amount of microstacks to lockup and a bitcoin address to be used to pay out rewards.
-> The sample code used assumes usage of the bitcoin address associated with the Stacks account. You can replace this with an address provided by the users or read from your database -> The sample code used assumes usage of the bitcoin address associated with the Stacks account. You can replace this with an address provided by the users or read from your database
With this input, and the data from previous steps, we can determine the eligibility for the next reward cycle: With this input, and the data from previous steps, we can determine the eligibility for the next reward cycle:
```js ```js
// micro-STX tokens to lockup, must be >= poxInfo.min_amount_ustx and <=accountSTXBalance // microstacks tokens to lockup, must be >= poxInfo.min_amount_ustx and <=accountSTXBalance
let microSTXoLockup = poxInfo.min_amount_ustx; let microstacksoLockup = poxInfo.min_amount_ustx;
// derive bitcoin address from Stacks account and convert into required format // derive bitcoin address from Stacks account and convert into required format
const hashbytes = bufferCV(Buffer.from(c32.c32addressDecode(stxAddress)[1], 'hex')); const hashbytes = bufferCV(Buffer.from(c32.c32addressDecode(stxAddress)[1], 'hex'));
@ -207,10 +246,12 @@ const version = bufferCV(Buffer.from('01', 'hex'));
const smartContracts = new SmartContractsApi(apiConfig); const smartContracts = new SmartContractsApi(apiConfig);
const [contractAddress, contractName] = poxInfo.contract_id.split('.');
// read-only contract call // read-only contract call
const isEligible = await smartContracts.callReadOnlyFunction({ const isEligible = await smartContracts.callReadOnlyFunction({
contractAddress: poxInfo.contract_id.split('.')[0], contractAddress,
contractName: poxInfo.contract_id.split('.')[1], contractName,
functionName: 'can-stack-stx', functionName: 'can-stack-stx',
readOnlyFunctionArgs: { readOnlyFunctionArgs: {
sender: stxAddress, sender: stxAddress,
@ -221,7 +262,7 @@ const isEligible = await smartContracts.callReadOnlyFunction({
version, version,
}) })
).toString('hex')}`, ).toString('hex')}`,
`0x${serializeCV(uintCV(microSTXoLockup)).toString('hex')}`, `0x${serializeCV(uintCV(microstacksoLockup)).toString('hex')}`,
// explicilty check eligibility for next cycle // explicilty check eligibility for next cycle
`0x${serializeCV(uintCV(poxInfo.reward_cycle_id)).toString('hex')}`, `0x${serializeCV(uintCV(poxInfo.reward_cycle_id)).toString('hex')}`,
`0x${serializeCV(uintCV(numberOfCycles)).toString('hex')}`, `0x${serializeCV(uintCV(numberOfCycles)).toString('hex')}`,
@ -235,6 +276,7 @@ if (response.startsWith(`(err `)) {
// user cannot participate in stacking // user cannot participate in stacking
// error codes: https://github.com/blockstack/stacks-blockchain/blob/master/src/chainstate/stacks/boot/pox.clar#L2 // error codes: https://github.com/blockstack/stacks-blockchain/blob/master/src/chainstate/stacks/boot/pox.clar#L2
console.log({ isEligible: false, errorCode: response })); console.log({ isEligible: false, errorCode: response }));
return;
} }
// success // success
console.log({ isEligible: true }); console.log({ isEligible: true });
@ -251,12 +293,15 @@ Next, the Stacking action should be implemented. Once the user confirms the acti
```js ```js
const tx = new TransactionsApi(apiConfig); const tx = new TransactionsApi(apiConfig);
const [contractAddress, contractName] = poxInfo.contract_id.split('.');
const network = new StacksTestnet();
const txOptions = { const txOptions = {
contractAddress: poxInfo.contract_id.split('.')[0], contractAddress,
contractName: poxInfo.contract_id.split('.')[1], contractName,
functionName: 'stack-stx', functionName: 'stack-stx',
functionArgs: [ functionArgs: [
uintCV(microSTXoLockup), uintCV(microstacksoLockup),
tupleCV({ tupleCV({
hashbytes, hashbytes,
version, version,
@ -265,7 +310,7 @@ const txOptions = {
], ],
senderKey: privateKey.data.toString('hex'), senderKey: privateKey.data.toString('hex'),
validateWithAbi: true, validateWithAbi: true,
network: new StacksTestnet(), network,
}; };
const transaction = await makeContractCall(txOptions); const transaction = await makeContractCall(txOptions);
@ -280,20 +325,24 @@ The transaction completion will take several minutes. Concurrent stacking action
## Step 6: Confirm lock-up ## Step 6: Confirm lock-up
The new transaction will not be completed immediately. It will stay in the `pending` status for a few minutes. We need to poll the status and wait until the transaction status changes to `success`: The new transaction will not be completed immediately. It'll stay in the `pending` status for a few minutes. We need to poll the status and wait until the transaction status changes to `success`:
```js ```js
let resp; const waitForTransactionSuccess = txId =>
new Promise((resolve, reject) => {
const pollingInterval = 3000;
const intervalID = setInterval(async () => { const intervalID = setInterval(async () => {
resp = await tx.getTransactionById({ contractCall.txId }); const resp = await tx.getTransactionById({ txId });
console.log(resp);
if (resp.tx_status === 'success') { if (resp.tx_status === 'success') {
// stop polling // stop polling
clearInterval(intervalID); clearInterval(intervalID);
// update UI to display stacking status // update UI to display stacking status
return resp; return resolve(resp);
} }
}, 3000); }, pollingInterval);
});
const resp = await waitForTransactionSuccess(contractCall.txId);
``` ```
-> More details on the lifecycle of transactions can be found in the [transactions guide](/stacks-blockchain/transactions#lifecycle) -> More details on the lifecycle of transactions can be found in the [transactions guide](/stacks-blockchain/transactions#lifecycle)
@ -316,8 +365,7 @@ await sub.unsubscribe();
With the completed transactions, Stacks tokens are locked up for the lockup duration. During that time, your application can display the following details: unlocking time, amount of Stacks locked, and bitcoin address used for rewards. With the completed transactions, Stacks tokens are locked up for the lockup duration. During that time, your application can display the following details: unlocking time, amount of Stacks locked, and bitcoin address used for rewards.
```js ```js
const contractAddress = poxInfo.contract_id.split('.')[0]; const [contractAddress, contractName] = poxInfo.contract_id.split('.');
const contractName = poxInfo.contract_id.split('.')[1];
const functionName = 'get-stacker-info'; const functionName = 'get-stacker-info';
const stackingInfo = await smartContracts.callReadOnlyFunction({ const stackingInfo = await smartContracts.callReadOnlyFunction({

28
src/pages/stacks-blockchain/stacking.md
View File

@ -7,7 +7,7 @@ images:
## Introduction ## Introduction
Stacking rewards Stacks token holders with bitcoins for providing a valuable service to the network by locking up their tokens for a certain time. Stacking rewards Stacks (STX) token holders with bitcoin for providing a valuable service to the network by locking up their tokens for a certain time.
Stacking is a built-in action, required by the "proof-of-transfer" (PoX) mechanism. The PoX mechanism is executed by every miner on the Stacks 2.0 network. Stacking is a built-in action, required by the "proof-of-transfer" (PoX) mechanism. The PoX mechanism is executed by every miner on the Stacks 2.0 network.
@ -20,9 +20,9 @@ The Stacking mechanism can be presented as a flow of actions:
![stacking flow](/images/stacking-illustration.png) ![stacking flow](/images/stacking-illustration.png)
1. Make API calls to get details about the upcoming reward cycle 1. Make API calls to get details about the upcoming reward cycle
2. For a specific Stacks account, confirm eligibility (minimum Stacks tokens available and more) 2. For a specific Stacks account, confirm eligibility
3. Confirm the BTC reward address and the lockup duration 3. Confirm the BTC reward address and the lockup duration
4. The transaction is broadcasted and the Stacks tokens will be locked-up 4. The transaction is broadcasted and the Stacks (STX) tokens will be locked-up
5. The Stacking mechanism executes reward cycles and sends out rewards to the set BTC reward address 5. The Stacking mechanism executes reward cycles and sends out rewards to the set BTC reward address
6. During the lockup period, details about unlocking timing, rewards and more can be obtained 6. During the lockup period, details about unlocking timing, rewards and more can be obtained
7. Once the lockup period is passed, the tokens are released and accessible again 7. Once the lockup period is passed, the tokens are released and accessible again
@ -37,25 +37,25 @@ If you would like to implement this flow in your own wallet, exchange, or any ot
PoX mining is a modification of Proof-of-Burn (PoB) mining, where instead of destroying the committed Bitcoin, it is transferred to eligible Stacks (STX) holders that participate in the Stacking protocol. PoX mining is a modification of Proof-of-Burn (PoB) mining, where instead of destroying the committed Bitcoin, it is transferred to eligible Stacks (STX) holders that participate in the Stacking protocol.
-> A PoX miner can only receive newly-minted Stacks (STX) tokens when they transfer bitcoins to eligible owners of Stacks tokens -> A PoX miner can only receive newly-minted Stacks (STX) tokens when they transfer bitcoin to eligible owners of Stacks (STX) tokens
Miners have to run a software (mining client, aka "miner") on their machines to participate in the PoX mechanism. The mining client implements the PoX mechanism, which ensures proper handling and incentives through four key phases: Miners have to run a software (mining client, aka "miner") on their machines to participate in the PoX mechanism. The mining client implements the PoX mechanism, which ensures proper handling and incentives through four key phases:
- Registration: Miners register for a future election by sending consensus data to the network - Registration: Miners register for a future election by sending consensus data to the network
- Commitment: Registered miners transfer bitcoins to participate in the election. Committed bitcoins are sent to a set eligible Stacks tokens holders - Commitment: Registered miners transfer bitcoin to participate in the election. Committed bitcoin are sent to a set eligible Stacks (STX) tokens holders
- Election: A verifiable random function chooses one miner to write a new block on the Stacks blockchain - Election: A verifiable random function chooses one miner to write a new block on the Stacks blockchain
- Assembly: The elected miner writes the new block and collects rewards in form of new Stacks tokens - Assembly: The elected miner writes the new block and collects rewards in form of new Stacks (STX) tokens
[@page-reference | inline] [@page-reference | inline]
| /mining | /mining
## Token holder eligibility ## Token holder eligibility
Stacks token holders do not automatically receive Stacking rewards. Instead, they must: Stacks (STX) token holders do not automatically receive Stacking rewards. Instead, they must:
- Commit to participation before a reward cycle begins - Commit to participation before a reward cycle begins
- Hold ~94.000 Stacks tokens - Hold ~94.000 Stacks (STX) tokens
- Lock up Stacks tokens for a specified period - Lock up Stacks (STX) tokens for a specified period
- Set a Bitcoin address to receive rewards - Set a Bitcoin address to receive rewards
Token holders will have to use software like apps, exchanges, or wallets that support participation in Stacking. Token holders will have to use software like apps, exchanges, or wallets that support participation in Stacking.
@ -68,7 +68,7 @@ Stacking is a built-in capability of PoX and is realized through a set of action
- A reward cycle consists of two phases: prepare and reward - A reward cycle consists of two phases: prepare and reward
- During the prepare phase, miners decide on an anchor block and a reward set. Mining any descendant forks of the anchor block requires transferring mining funds to the appropriate reward addresses. The reward set is the set of Bitcoin addresses which will receive funds in the reward cycle - During the prepare phase, miners decide on an anchor block and a reward set. Mining any descendant forks of the anchor block requires transferring mining funds to the appropriate reward addresses. The reward set is the set of Bitcoin addresses which will receive funds in the reward cycle
- Miners register as leader candidates for a future election by sending a key transaction that burns cryptocurrency (proof-of-burn). The transaction also registers the leader's preferred chain tip (must be a descendant of the anchor block) and commitment of funds to 2 addresses from the reward set - Miners register as leader candidates for a future election by sending a key transaction that burns cryptocurrency (proof-of-burn). The transaction also registers the leader's preferred chain tip (must be a descendant of the anchor block) and commitment of funds to 2 addresses from the reward set
- Token holders register for the next rewards cycle by broadcasting a signed message that locks up associated Stacks tokens for a protocol-specified lockup period, specifies a Bitcoin address to receive the funds, and votes on a Stacks chain tip - Token holders register for the next rewards cycle by broadcasting a signed message that locks up associated Stacks (STX) tokens for a protocol-specified lockup period, specifies a Bitcoin address to receive the funds, and votes on a Stacks chain tip
- Multiple leaders can commit to the same chain tip. The leader that wins the election and the peers who also burn for that leader collectively share the reward, proportional to how much each one burned - Multiple leaders can commit to the same chain tip. The leader that wins the election and the peers who also burn for that leader collectively share the reward, proportional to how much each one burned
- Token holders' locked up tokens automatically unlock as soon as the lockup period is completed - Token holders' locked up tokens automatically unlock as soon as the lockup period is completed
@ -79,12 +79,12 @@ Stacking is implemented as a smart contract using Clarity. On the testnet, you c
You can examine the contract sources ([`pox.clar`](https://github.com/blockstack/stacks-blockchain/blob/master/src/chainstate/stacks/boot/pox.clar)), but here is a summary of important methods: You can examine the contract sources ([`pox.clar`](https://github.com/blockstack/stacks-blockchain/blob/master/src/chainstate/stacks/boot/pox.clar)), but here is a summary of important methods:
| Method | Input | Output | Read-only | Description | | Method | Input | Output | Read-only | Description |
| ---------------------------- | --------------------------------------------------- | ---------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ---------------------------- | --------------------------------------------------- | --------------------- | --------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Configuration** | | **Configuration** |
| `get-reward-set-size` | Reward cycle | Number of addresses | ✅ | Get the size of the reward set | | `get-reward-set-size` | Reward cycle | Number of addresses | ✅ | Get the size of the reward set |
| `get-total-ustx-stacked` | Reward cycle | Amount of micro-Stacks | ✅ | Get amount stacked | | `get-total-ustx-stacked` | Reward cycle | Amount of microstacks | ✅ | Get amount stacked |
| `get-reward-set-pox-address` | Reward cycle | Tuple/None | ✅ | Get list of reward addresses and amount stacked | | `get-reward-set-pox-address` | Reward cycle | Tuple/None | ✅ | Get list of reward addresses and amount stacked |
| `get-stacking-minimum` | | | ✅ | Minimum number of micro-Stacks to participate in Stacking | | `get-stacking-minimum` | | | ✅ | Minimum number of microstacks to participate in Stacking |
| `get-pox-info` | | Object | ✅ | Get PoX parameters, including cycle id, length, block height, and more. Also available in [Stacks Blockchain API](https://blockstack.github.io/stacks-blockchain-api/#operation/get_pox_info) | | `get-pox-info` | | Object | ✅ | Get PoX parameters, including cycle id, length, block height, and more. Also available in [Stacks Blockchain API](https://blockstack.github.io/stacks-blockchain-api/#operation/get_pox_info) |
| **Stacking** | | **Stacking** |
| `can-stack-stx` | BTC address, amount, starting cycle, locking cycles | True/Error | ✅ | Check if stacking participation is possible | | `can-stack-stx` | BTC address, amount, starting cycle, locking cycles | True/Error | ✅ | Check if stacking participation is possible |
@ -93,4 +93,4 @@ You can examine the contract sources ([`pox.clar`](https://github.com/blockstack
| **Rejection** | | **Rejection** |
| `get-pox-rejection` | Stacks Address | Tuple/None | ✅ | Get rejection vote for Stacking address | | `get-pox-rejection` | Stacks Address | Tuple/None | ✅ | Get rejection vote for Stacking address |
| `is-pox-active` | Reward cycle | True/False | ✅ | Get PoX rejection status for a reward cycle. Also available in [Stacks Blockchain API](https://blockstack.github.io/stacks-blockchain-api/#operation/get_pox_info) | | `is-pox-active` | Reward cycle | True/False | ✅ | Get PoX rejection status for a reward cycle. Also available in [Stacks Blockchain API](https://blockstack.github.io/stacks-blockchain-api/#operation/get_pox_info) |
| `reject-pox` | | True | | Reject Stacking for this reward cycle. Sender votes all its micro-Stacks for rejection | | `reject-pox` | | True | | Reject Stacking for this reward cycle. Sender votes all its microstacks for rejection |

Write Preview
Loading…
Cancel
Save