LJ's Blog

Secure Pledge and Rewards Wallet

Introduction

The aim of this text is to show you, the reader, a procedure for modyfing an existing pool to use a hardware wallet as a pledging and rewards wallet while at the same time preserving the cli-wallet as the operational-wallet.

Only read this if you are interested to know how the process works behind the scene. If not, you can use ready made scripts to manage your pool. In essence, you will modify your pool to become a multi-owner pool. To pay for any future transactions, the operational-wallet must be used.

This procedure assumes that you already have a running pool with an active operational-wallet. This operational-wallet is a hot-wallet with around 500 Ada left after the pool has been created.

At first sight, doing this via the cli-method might look like a tedious process, and in some ways it is. However, once you understand the logic of the process you will see that most is just a repetition of the same steps over and over.

Overview

In this section the concept of submitting a change to the cardano blockchain is explained.

Basically, for every change you make to the blockchain, you need to do the following steps:

  1. Make a certificate containing your request.
  2. Compose a raw transaction request.
  3. Sign/witness/consent the transaction request.
  4. Submit the signed transaction request to the blockchain.

If for instance you want to register your Ada wallet as a stake wallet and to next delegate your wallet to a stake pool, you need to make one certificate for each request/transaction:

  1. A stake certificate
  2. A delegation certificate

For each transaction you must calculate the cost. The cost calculation is mostly a generic step and only differs depending on the type of transaction. Sometimes the fee is 0, like is the case when modifying a pool certificate. Even when the fee is 0, you must provide the fee amount because it is always expected.

Signing is a synonym for witnessing or digital consent - it means that all stakeholders must give their permission by witnessing / signing the transaction with their corresponding private key in order to proof ownership. A stakeholder can be the pool itself or the pool with all the owners.

To create a transaction request you always need to follow this process:

  1. Get the protocol parameters
  2. Find the current slot slot for the blockchain
  3. Draft the transaction
  4. Calculate the minimum fee
  5. Build the raw transaction

To validate a raw transaction you must witness/sign the transaction

  1. Sign the transaction

Once the transaction is signed it can be submitted to the blockchain

  1. Submit the transaction

A transaction must prove that it has the right to spend its inputs. In the most common case, this means that a transaction must be signed by the signing keys belonging to the payment addresses of the inputs. If a transaction contains certificates, it must additionally be signed by somebody with the right to issue those certificates. For example, a stake address registration certificate must be signed by the signing key of the corresponding stake key pair.

As an example of signing / witnessing keys:

  1. cold.skey (signing key for your particular pool)
  2. payment.skey (signing key for your particular operational-wallet)
  3. owner.skey (but NOT rewards.skey if different from owner.skey)

Cardano Hardware-Wallet

Preliminary steps

Prepare HW-Wallet

Connect your hw-wallet to your desktop-computer and unlock it and open the Cardano app.

Verification payment key and hardware wallet signing file

Do the following on your desktop-computer connected to your hw-wallet. You will have to authorise on your hw-wallet to export your public key.

1
2
3
4
./cardano-hw-cli shelley address key-gen \
--path 1852H/1815H/0H/0/0 \
--verification-key-file hw-wallet/payment.vkey \
--hw-signing-file hw-wallet/payment.hwsfile

Should create payment.vkey and payment.hwsfile files.

Verification stake key and hardware-wallet signing file

Do the following on your desktop-computer connected to your hw-wallet. You will have to authorise on your hw-wallet to export your public key.

1
2
3
4
./cardano-hw-cli shelley address key-gen \
--path 1852H/1815H/0H/2/0 \
--verification-key-file hw-wallet/stake.vkey \
--hw-signing-file hw-wallet/stake.hwsfile

Should create stake.vkey and stake.hwsfile files.

Payment address

Copy the payment.vkey and stake.vkey to your Block Producing Node and generate the payment address.

1
2
3
4
5
cardano-cli address build \
--payment-verification-key-file hw-wallet/payment.vkey \
--stake-verification-key-file hw-wallet/stake.vkey \
--out-file hw-wallet/payment.addr \
--mainnet

Should create payment.addr file. The payment.addr is the hw-wallet address which will be used to hold your pool’s pledge.

At this point you have the following files from your hardware wallet:

  1. payment.vkey
  2. stake.vkey
  3. payment.addr

Step 1, Register HW-Wallet address on the Blockchain - create, sign and submit a register certificate

First, obtain the protocol-parameters.

On the Block Producing Node

1
2
3
4
cardano-cli query protocol-parameters \
   --mainnet \
   --allegra-era \
   --out-file params.json

should create params.json file.

Payment keys are used to send and receive payments and stake keys are used to manage stake delegations.

Critical Operational Security Advice: payment and stake keys must be generated and used to build transactions in a cold-environment. Since we are signing transactions using a HW wallet, we can do these steps on a Offline Computer. The real cold-environment becomes the hw-wallet.

The steps performed online on the block-producing-node are those steps that require an active connection to the blockchain;

  1. querying the current slot tip
  2. querying the balance of an address
  3. submitting a transaction

Create a certificate, stake.cert, using the stake.vkey

On the Block Producing Node

1
2
3
cardano-cli stake-address registration-certificate \
    --stake-verification-key-file hw-wallet/stake.vkey \
    --out-file hw-wallet/stake.cert

should create stake.cert file.

At this stage, you have the following files from your hardware wallet:

  1. payment.vkey
  2. stake.vkey
  3. payment.addr
  4. stake.cert

Make a script for producing the raw request

From here on, all the steps until the last step where the register-tx.raw file is produced, should be executed by a single script. For your convenience I have marked these parts with a begin and end script statement. You can copy all the code blocks into a single file named build-register-tx-raw.sh and execute it.

The following steps are generic steps and need to be executed each time a transaction-fee must be payed. In this particular case a transaction fee is needed to register your hw-wallet address on the cardano blockchain.

On the Block Producing Node

begin script build-register-tx-raw.sh

Find your balance and UTXOs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
cardano-cli query utxo \
    --address $(cat hw-wallet/payment.addr) \
    --allegra-era \
    --mainnet > fullUtxo.out

tail -n +3 fullUtxo.out | sort -k3 -nr > balance.out

cat balance.out

tx_in=""
total_balance=0
while read -r utxo; do
    in_addr=$(awk '{ print $1 }' <<< "${utxo}")
    idx=$(awk '{ print $2 }' <<< "${utxo}")
    utxo_balance=$(awk '{ print $3 }' <<< "${utxo}")
    total_balance=$((${total_balance}+${utxo_balance}))
    echo TxHash: ${in_addr}#${idx}
    echo ADA: ${utxo_balance}
    tx_in="${tx_in} --tx-in ${in_addr}#${idx}"

done < balance.out

txcnt=$(cat balance.out | wc -l)
echo Total ADA balance: ${total_balance}
echo Number of UTXOs: ${txcnt}

Find the key deposit fee.

1
2
keyDeposit=$(cat params.json | jq -r '.keyDeposit')
echo keyDeposit: $keyDeposit

Registration of a stake address certificate (keyDeposit) costs 2000000 lovelace.**

Second, find the tip of the blockchain to set the TTL (invalid-hereafter) parameter properly.

1
2
currentSlot=$(cardano-cli query tip --mainnet | jq -r '.slotNo')
echo Current Slot: $currentSlot

The TTL (Time To Live - Validity Period) value must be greater than the current tip. In this example, we use current slot + 10000.

Third, make a draft for the transaction and save it in register-tx.draft.

1
2
3
4
5
6
7
8
cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat hw-wallet/payment.addr)+0 \
    --invalid-hereafter $(( ${currentSlot} + 10000)) \
    --fee 0 \
    --out-file register-tx.draft \
    --allegra-era \
    --certificate hw-wallet/stake.cert

Fourth, calculate the current minimum fee.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
fee=$(cardano-cli transaction calculate-min-fee \
    --tx-body-file register-tx.draft \
    --tx-in-count ${txcnt} \
    --tx-out-count 1 \
    --mainnet \
    --witness-count 2 \
    --byron-witness-count 0 \
    --protocol-params-file params.json | awk '{ print $1 }')

echo fee: $fee

Ensure that your balance is greater than “cost of fee + keyDeposit” or this will not work. In effect, by now you should have deposited like 1000 Ada on your hw-wallet addrress.

Calculate the change output.

txOut=$((${total_balance}-${keyDeposit}-${fee})) echo Change Output: ${txOut}

Fifth, build the transaction for registering your address.

1
2
3
4
5
6
7
8
cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat hw-wallet/payment.addr)+${txOut} \
    --invalid-hereafter $(( ${currentSlot} + 10000)) \
    --fee ${fee} \
    --certificate-file hw-wallet/stake.cert \
    --allegra-era \
    --out-file register-tx.raw

end script build-register-tx-raw.sh

should create register-tx.raw file.

copy register-tx.raw to your Offline Computer.

Now, sign the transaction by authorising with your HW wallet.

1
2
3
4
5
6
cardano-hw-cli shelley transaction sign \
    --tx-body-file register-tx.raw \
    --hw-signing-file hw-wallet/payment.hwsfile \
    --hw-signing-file hw-wallet/stake.hwsfile \
    --mainnet \
    --out-file register-tx.signed

copy tx.signed to your Block Producing Node.

On the Block Producing Node

Submit the signed transaction.

1
2
3
cardano-cli transaction submit \
    --tx-file register-tx.signed \
    --mainnet

You are now done registering your hw-wallet address on the Cardano blockchain.

Step 2, delegate wallet to the pool - create, sign and submit a delegation certificate

Now that you have registered your hw-wallet address on the blockchain, the next step is to use this address to delegate to your pool.

Create a delegation certificate.

On the Air-Gapped Node (aka offline-computer)

1
2
3
4
cardano-cli stake-address delegation-certificate \
    --stake-verification-key-file hw-wallet/stake.vkey \
    --cold-verification-key-file pool/cold.vkey \
    --out-file hw-wallet/delegation.cert

should create delegation.cert file.

This operation creates a delegation certificate which delegates funds from all stake addresses associated with key stake.vkey to the pool belonging to cold key cold.vkey. At this point you are setting up to delegate to the pool.

You now have the following files from your hardware wallet:

  1. payment.vkey
  2. stake.vkey
  3. payment.addr
  4. stake.cert
  5. delegation.cert

First, obtain the protocol-parameters.

On the Block Producing Node

1
2
3
4
cardano-cli query protocol-parameters \
   --mainnet \
   --allegra-era \
   --out-file params.json

should create params.json file. this step doesn’t have to be repeated twice since the protocol-parameters were already obtained above. However, the step is included to make the process clear.

Make a script for producing the raw request

From here on, all the steps until the last step where the tx.raw file is produced, should be executed by one script. For your convenience I have marked these parts with a begin and end script statement. You can copy all the code blocks into a single file named build-delegation-tx-raw.sh.

The following steps are generic steps and need to be executed each time a transaction-fee must be payed. In this particular case a transaction-fee is needed to register your hw-wallet address on the cardano blockchain as a delegator to your pool.

On the Block Producing Node

begin script build-delegation-tx-raw.sh

Find your balance and UTXOs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
cardano-cli query utxo \
    --address $(cat hw-wallet/payment.addr) \
    --allegra-era \
    --mainnet > fullUtxo.out

tail -n +3 fullUtxo.out | sort -k3 -nr > balance.out

cat balance.out

tx_in=""
total_balance=0
while read -r utxo; do
    in_addr=$(awk '{ print $1 }' <<< "${utxo}")
    idx=$(awk '{ print $2 }' <<< "${utxo}")
    utxo_balance=$(awk '{ print $3 }' <<< "${utxo}")
    total_balance=$((${total_balance}+${utxo_balance}))
    echo TxHash: ${in_addr}#${idx}
    echo ADA: ${utxo_balance}
    tx_in="${tx_in} --tx-in ${in_addr}#${idx}"
done < balance.out

txcnt=$(cat balance.out | wc -l)
echo Total ADA balance: ${total_balance}
echo Number of UTXOs: ${txcnt}

Find the pool deposit fee.

1
2
poolDeposit=$(cat params.json | jq -r '.poolDeposit')
echo poolDeposit: $poolDeposit

In this step, you are building a transaction in which you bind the pool certificate with the delegation certificate from the hardware wallet.

Second, find the tip of the blockchain to set the TTL (invalid-hereafter) parameter properly.

1
2
currentSlot=$(cardano-cli query tip --mainnet | jq -r '.slotNo')
echo Current Slot: $currentSlot

The TTL value must be greater than the current tip. In this example, we use current slot + 10000.

Third, make a draft for the transaction and save it in delegation-tx.draft.

1
2
3
4
5
6
7
8
9
cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat hw-wallet/payment.addr)+$(( ${total_balance} - ${poolDeposit}))  \
    --invalid-hereafter $(( ${currentSlot} + 10000)) \
    --fee 0 \
    --certificate-file pool/pool.cert \
    --certificate-file hw-wallet/delegation.cert \
    --allegra-era \
    --out-file delegation-tx.draft

Fourth, calculate the minimum fee.

1
2
3
4
5
6
7
8
9
fee=$(cardano-cli transaction calculate-min-fee \
    --tx-body-file delegation-tx.draft \
    --tx-in-count ${txcnt} \
    --tx-out-count 1 \
    --mainnet \
    --witness-count 3 \
    --byron-witness-count 0 \
    --protocol-params-file params.json | awk '{ print $1 }')
echo fee: $fee

Ensure that your balance is greater than “cost of fee + poolDeposit” or this will not work. In effect, by now you should have deposited like 1000 Ada on your hw-wallet addrress.

Calculate your change output.

1
2
txOut=$((${total_balance}-${poolDeposit}-${fee}))
echo txOut: ${txOut}

Fifth, build the transaction for delegating the address.

1
2
3
4
5
6
7
8
9
cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat hw-wallet/payment.addr)+${txOut} \
    --invalid-hereafter $(( ${currentSlot} + 10000)) \
    --fee ${fee} \
    --certificate-file pool/pool.cert \
    --certificate-file hw-wallet/delegation.cert \
    --allegra-era \
    --out-file delegation-tx.raw

end script build-delegation-tx-raw.sh

should create delegation-tx.raw file.

Now that you have the delegation-tx.raw, you will need this to be signed and submitted to the blockchain.

As already mentioned, a pool (re)registration must be signed (witnessed) by:

  1. payment.skey (signing key of your operational wallet)
  2. cold.skey (signing key for your pool)
  3. owner.skey (in this particular case, the hw-wallet’s stake.hwsfile)

Create transaction witnesses

Pool keys and the spending/operational key must be managed by cardano-cli.

Operator witness - Signed by pool operator (payer of pool deposit and fees)

1
2
3
4
5
cardano-cli transaction witness \
--tx-body-file delegation-tx.raw \
--signing-key-file op-wallet/payment.skey \
--mainnet \
--out-file operator.witness

should create operator.witness file.

Pool witness - Signed by pool’s cold key.

1
2
3
4
5
cardano-cli transaction witness \
--tx-body-file delegation-tx.raw \
--signing-key-file pool/cold.skey \
--mainnet \
--out-file pool.witness

should create pool.witness file.

Owner witness - One or multiple hardware wallet pool owners

1
2
3
4
5
./cardano-hw-cli shelley transaction witness \
--tx-body-file delegation-tx.raw \
--hw-signing-file hw-wallet/stake.hwsfile \
--mainnet \
--out-file owner.witness

should create owner.witness file.

Create signed transaction

Use witnesses (signed files) from previous steps to assemble the signed pool (re)registration transaction file.

Only owner.witness must be copied to the bp node.

ATTENTION: Change to “TxWitness MaryEra” in all witness files before assembling for otherwise the assemble procedure will fail.

1
2
3
4
5
6
cardano-cli transaction assemble \
--tx-body-file delegation-tx.raw \
--witness-file operator.witness \
--witness-file pool.witness \
--witness-file owner.witness \
--out-file delegation-tx.signed

should create delegation-tx.signed file.

Submit the signed transaction

1
2
cardano-cli transaction submit \
--tx-file delegation-tx.signed --mainnet

You are done delegating your wallet to the pool.

Now that the hw-wallet has been registered on the blockchain and delegated to yout pool, it can be assigned as an owner wallet.

Step 3, Adding a 2nd owner (hw-wallet) - create, sign and submit a pool certificate

A stake pool owner’s promise to fund their own pool is called a Pledge.

  • Your balance needs to be greater than the pledge amount.
  • Your pledge funds are not moved anywhere. In this guide’s example, the pledge remains in the stake pool’s owner keys, specifically payment.addr
  • Failing to fulfill pledge will result in missed block minting opportunities and your delegators would miss rewards.
  • Your pledge is not locked up. You are free to transfer your funds.

Also be aware of the following:

WARNING: Once you are done, Transfer of funds from CLI wallet to HW wallet can ONLY be done after 2 snapshots, otherwise the pool will not meet pledge in next epoch and no rewards would be paid

Basically, you will be doing a pool re-registration and for that the transaction must be signed (also known as witnessed).

Modify pool certificate to add hw-wallet (as owner and for rewards)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
cardano-cli stake-pool registration-certificate \
  --cold-verification-key-file node-cold.vkey \
  --vrf-verification-key-file vrf.vkey \
  --pool-pledge <pledge> \
  --pool-cost <FixedFee> \
  --pool-margin <pool fee in fraction ie 0.011 for 1.1%> \
  --pool-reward-account-verification-key-file hw-stake.vkey \    <- Rewards go to hw-Wallet
  --pool-owner-stake-verification-key-file cli-stake.vkey \      <- previous CLI key
  --pool-owner-stake-verification-key-file hw-stake.vkey \       <- new hw-wallet key
  --mainnet \
  --single-host-pool-relay <IP of public relay 1> --pool-relay-port <port 1> \
  --single-host-pool-relay <IP of public relay 2> --pool-relay-port <port 2> \
  --metadata-url <domain>/<path>/metadata.json \
  --metadata-hash <hash of metadata file> \
  --out-file pool.cert

should create pool.cert file.

Make a script for producing the raw request

On the Block Producing Node

1
2
3
4
cardano-cli query protocol-parameters \
   --mainnet \
   --allegra-era \
   --out-file params.json

should create params.json file. this step doesn’t have to be repeated each time since the protocol-parameters were already obtained above. However, the step is included to make the process clear.

Make a script for producing the raw request

From here on, all the steps until the last step where the modidy-pool-tx.raw file is produced, should be executed by one script. For your convenience I have marked these parts with a begin and end script statement. You can copy all the code blocks into a single file named modify-pool-tx-raw.sh.

The following steps are generic steps and need to be executed each time a transaction-fee must be payed. In this particular case a transaction-fee is not needed since no fee is needed to modify a stake pool parameters.

On the Block Producing Node

begin script modify-pool-tx-raw.sh

Find your balance and UTXOs.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
cardano-cli query utxo \
    --address $(cat hw-wallet/payment.addr) \
    --allegra-era \
    --mainnet > fullUtxo.out

tail -n +3 fullUtxo.out | sort -k3 -nr > balance.out

cat balance.out

tx_in=""
total_balance=0
while read -r utxo; do
    in_addr=$(awk '{ print $1 }' <<< "${utxo}")
    idx=$(awk '{ print $2 }' <<< "${utxo}")
    utxo_balance=$(awk '{ print $3 }' <<< "${utxo}")
    total_balance=$((${total_balance}+${utxo_balance}))
    echo TxHash: ${in_addr}#${idx}
    echo ADA: ${utxo_balance}
    tx_in="${tx_in} --tx-in ${in_addr}#${idx}"
done < balance.out

txcnt=$(cat balance.out | wc -l)
echo Total ADA balance: ${total_balance}
echo Number of UTXOs: ${txcnt}

Find the pool deposit fee.

1
2
poolDeposit=$(cat params.json | jq -r '.poolDeposit')
echo poolDeposit: $poolDeposit

In this step, you are building a transaction in which you bind the pool certificate with the delegation certificate from the hardware wallet.

Second, find the tip of the blockchain to set the TTL (invalid-hereafter) parameter properly.

1
2
currentSlot=$(cardano-cli query tip --mainnet | jq -r '.slotNo')
echo Current Slot: $currentSlot

Third, make a draft for the transaction and save it in modify-pool-tx.draft.

The TTL value must be greater than the current tip. In this example, we use current slot + 10000. Take notice that the fee is 0 since this is a pool modification.

1
2
3
4
5
6
7
8
9
cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat hw-wallet/payment.addr)+$(( ${total_balance} - ${poolDeposit}))  \
    --invalid-hereafter $(( ${currentSlot} + 10000)) \
    --fee 0 \
    --certificate-file pool/pool.cert \
    --certificate-file hw-wallet/delegation.cert \
    --allegra-era \
    --out-file modify-pool-tx.draft

Fourth, calculate the minimum fee.

1
2
3
4
5
6
7
8
9
fee=$(cardano-cli transaction calculate-min-fee \
    --tx-body-file modify-pool-tx.draft \
    --tx-in-count ${txcnt} \
    --tx-out-count 1 \
    --mainnet \
    --witness-count 3 \
    --byron-witness-count 0 \
    --protocol-params-file params.json | awk '{ print $1 }')
echo fee: $fee

Ensure that your balance is greater than “cost of fee + poolDeposit” or this will not work. In effect, by now you should have deposited like 1000 Ada on your hw-wallet addrress.

Calculate your change output.

1
2
txOut=$((${total_balance}-${poolDeposit}-${fee}))
echo txOut: ${txOut}

Fifth, build the transaction for modifying the pool.

1
2
3
4
5
6
7
8
9
cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat hw-wallet/payment.addr)+${txOut} \
    --invalid-hereafter $(( ${currentSlot} + 10000)) \
    --fee ${fee} \
    --certificate-file pool/pool.cert \
    --certificate-file hw-wallet/delegation.cert \
    --allegra-era \
    --out-file modify-pool-tx.raw

end script build-delegation-tx-raw.sh

should create modify-pool-tx.raw file.

Now that you have the modify-pool-tx.raw, you will need this to be signed and submitted to the blockchain.

end script build-register-tx-raw.sh

should create modify-pool-tx.raw file.

copy modify-pool-tx.raw to your Offline Computer.

Now, sign the transaction by authorising with your HW wallet.

This transaction must be signed using witnesses (multi-sig)

4 witnesses are required

  • node-cold.vkey
  • hw-stake.vkey
  • cli-stake.vkey
  • cli-payment (to pay for tx fees)

On the offline server:

node-cold witness

1
2
3
4
5
cardano-cli transaction witness \
  --tx-body-file modify-pool-tx.raw \
  --signing-key-file node-cold.skey \
  --mainnet \
  --out-file node-cold.witness

should create node-cold.witness file.

cli-stake witness

1
2
3
4
5
cardano-cli transaction witness \
  --tx-body-file modify-pool-tx.raw \
  --signing-key-file cli-stake.skey \
  --mainnet \
  --out-file cli-stake.witness

should create cli-stake.witness file.

cli-payment witness

1
2
3
4
5
cardano-cli transaction witness \
  --tx-body-file modify-pool-tx.raw \
  --signing-key-file cli-payment.skey \
  --mainnet \
  --out-file cli-payment.witness

should create cli-paymet.witness file.

Copy modify-pool-tx.raw to your desktop-computer

Create a witness using the hw-stake.vkey on the desktop-computer (where you have the ledger connected)

hw-stake witness

1
2
3
4
5
cardano-hw-cli transaction witness \
  --tx-body-file modify-pool-tx.raw \
  --hw-signing-file hw-stake.hwsfile \
  --mainnet \
  --out-file hw-stake.witness

should create hw-stake.witness file.

Copy hw-stake.witness to the offline server

Sign transaction with witnesses on the offline server:

1
2
3
4
5
6
7
cardano-cli transaction assemble \
  --tx-body-file modify-pool-tx.raw \
  --witness-file node-cold.witness \
  --witness-file cli-stake.witness \
  --witness-file cli-payment.witness \
  --witness-file hw-stake.witness \
  --out-file modify-pool-tx.multisign

should create modify-pool-tx.multisign file.

Submit modify-pool-tx.multisign on the hot node

1
2
cardano-cli transaction submit \
  --tx-file modify-pool-tx.multisign --mainnet

CRITICAL NOTE: Transfer of funds from CLI wallet to HW wallet can ONLY be done after 2 snapshots, otherwise pool will not meet pledge in next epoch and no rewards would be paid

Comments

So what do you think? Did I miss something? Is any part unclear? Leave your comment below.

comments powered by Disqus