Tx stake pool
Transacción de registro de la stake pool.
Vamos al directorio cnode, creamos el archivo poolmeta.json y añadimos los metadatos del pool.
poolmeta.json
1
{
2
"name": "CASSO POOL",
3
"description": "Personal pool to help decentralize the system",
4
"ticker": "CASSO",
5
"homepage": "https://jimcase.github.io/cassoweb/"
6
}
Copied!
El ticker debe tener entre 3 y 5 caracteres. Estos caracteres solo pueden ser alfanuméricos, exactamente de la A a la Z y del 0 al 9.
La descripción no puede superar los 255 caracteres.
Calculamos el hash de archivo metapool.json y lo guardamos en poolmetaHash.txt
1
cardano-cli stake-pool metadata-hash --pool-metadata-file poolmeta.json > poolmetaHash.txt
Copied!
Establecemos la variable de entorno CARDANO_NODE_SOCKET_PATH para que apunte al socket del nodo. De este modo podemos interactuar con la información que hay almacenada en la cadena.
Para ello necesitamos encontrar la ruta completa a node.socket
1
sudo find / -name node.socket -print
Copied!
~/cnode/sockets/node.socket
Una vez que conocemos la ruta al socket exportamos la variable de entorno.
1
export CARDANO_NODE_SOCKET_PATH=~/cnode/sockets/node.socket
Copied!
Encontrar el costo mínimo de la stake-pool.
1
minPoolCost=$(cat protocol.json | jq -r .minPoolCost)
2
echo minPoolCost: ${minPoolCost}
Copied!
minPoolCost: 340000000
El costo mínimo es 340000000 lovelaces o 340 ADA. Por lo tanto, el --pool-cost debe ser como mínimo de esta cantidad.
Crear un certificado de registro para su stake pool. Añada su URL de metadatos y dirección IP del nodo relay.
Procura que la url que apunta tu archivo de metadatos no supere los 64 caracteres.
1
cardano-cli registration-certificate \
2
--cold-verification-key-file ~/cold-keys/node.vkey \
3
--vrf-verification-key-file vrf.vkey \
4
--pool-pledge 1000000000 \
5
--pool-cost 340000000 \
6
--pool-margin 0.028 \
7
--pool-reward-account-verification-key-file stake.vkey \
8
--pool-owner-stake-verification-key-file stake.vkey \
9
--mainnet \
10
--pool-relay-port 3001 \
11
--pool-relay-ipv4 <your relay IP address> \
12
--metadata-url <url to poolMetaData.json> \
13
--metadata-hash $(cat poolmetaHash.txt) \
14
--out-file pool.cert
Copied!
Versión con 1 DNS por ip/relay.
1
cardano-cli stake-pool registration-certificate \
2
--cold-verification-key-file ~/cold-keys/node.vkey \
3
--vrf-verification-key-file vrf.vkey \
4
--pool-pledge 1000000000 \
5
--pool-cost 340000000 \
6
--pool-margin 0.028 \
7
--pool-reward-account-verification-key-file stake.vkey \
8
--pool-owner-stake-verification-key-file stake.vkey \
9
--mainnet \
10
--single-host-pool-relay <dns-relay> \
11
--pool-relay-port 3001 \
12
--single-host-pool-relay <dns-relay2> \
13
--pool-relay-port 3001 \
14
--metadata-url <url-metadata-file> \
15
--metadata-hash $(cat poolmetaHash.txt) \
16
--out-file pool.cert
Copied!

Certificado del pledge

Tenemos que cumplir nuestro compromiso delegando al menos la cantidad prometida a nuestro grupo , por lo que tenemos que crear un certificado de delegación para lograrlo:
1
cardano-cli stake-address delegation-certificate \
2
--stake-verification-key-file ~/cnode/keys/stake.vkey \
3
--cold-verification-key-file ~/cold-keys/node.vkey \
4
--out-file deleg.cert
Copied!
Esto crea un certificado de delegación que delega fondos de todas las direcciones de participación asociadas con key stake.vkey al grupo que pertenece a cold key node.vkey. Si hubiéramos utilizado diferentes claves de participación para los propietarios del grupo en el primer paso, necesitaríamos crear certificados de delegación para todos ellos.

Envíe el certificado del pool y el certificado del pledge a la blockchain

Finalmente, debemos enviar el certificado de registro del grupo y los certificados de delegación a la blockchain incluyéndolos en una o más transacciones. Podemos utilizar una transacción para varios certificados, los certificados se aplicarán en orden. Como antes, averiguamos los fondos y UTXOs.
1
cardano-cli query utxo \
2
--address $(cat paymentwithstake.addr) \
3
--mainnet > fullUtxo.out
4
5
tail -n +3 fullUtxo.out | sort -k3 -nr > balance.out
6
7
cat balance.out
8
9
tx_in=""
10
total_balance=0
11
while read -r utxo; do
12
in_addr=$(awk '{ print $1 }' <<< "${utxo}")
13
idx=$(awk '{ print $2 }' <<< "${utxo}")
14
utxo_balance=$(awk '{ print $3 }' <<< "${utxo}")
15
total_balance=$((${total_balance}+${utxo_balance}))
16
echo TxHash: ${in_addr}#${idx}
17
echo ADA: ${utxo_balance}
18
tx_in="${tx_in} --tx-in ${in_addr}#${idx}"
19
done < balance.out
20
txcnt=$(cat balance.out | wc -l)
21
echo Total ADA balance: ${total_balance}
22
echo Number of UTXOs: ${txcnt}
Copied!
Obtenemos el último slot:
1
currentSlot=$(cardano-cli query tip --mainnet | jq -r '.slot')
2
echo $currentSlot
Copied!
Tenemos que pagar un depósito por el registro del grupo de participación. El monto del depósito se especifica en el archivo genesis y en protocol.json . Cuando retiras el pool, el deposito se devuelve.
1
cat protocol.json | grep poolDeposit
2
poolDeposit=$(cat ~/cnode/keys/protocol.json | jq -r '.poolDeposit')
3
echo poolDeposit: $poolDeposit
Copied!
poolDeposit: 500000000
Los fondos disponibles deben ser mayores que deposit + pledge
Comenzamos por redactar la transacción:
1
cardano-cli transaction build-raw \
2
${tx_in} \
3
--tx-out $(cat paymentwithstake.addr)+$(( ${total_balance} - ${poolDeposit})) \
4
--invalid-hereafter $(( ${currentSlot} + 10000)) \
5
--fee 0 \
6
--certificate-file pool.cert \
7
--certificate-file deleg.cert \
8
--out-file tx.tmp
Copied!
Calculamos la comisión de transacción:
1
fee=$(cardano-cli transaction calculate-min-fee \
2
--tx-body-file tx.tmp \
3
--tx-in-count ${txcnt} \
4
--tx-out-count 1 \
5
--mainnet \
6
--witness-count 1 \
7
--byron-witness-count 0 \
8
--protocol-params-file protocol.json | awk '{ print $1 }')
9
echo fee: $fee
Copied!
Calculamos el cambio:
1
txOut=$((${total_balance}-${poolDeposit}-${fee}))
2
echo txOut: ${txOut}
Copied!
Ahora podemos construir la transacción:
1
cardano-cli transaction build-raw \
2
${tx_in} \
3
--tx-out $(cat paymentwithstake.addr)+${txOut} \
4
--invalid-hereafter $(( ${currentSlot} + 1200)) \
5
--fee ${fee} \
6
--certificate-file pool.cert \
7
--certificate-file deleg.cert \
8
--out-file tx.raw
Copied!
Firmamos la transacción:
1
cardano-cli transaction sign \
2
--tx-body-file tx.raw \
3
--signing-key-file payment.skey \
4
--signing-key-file stake.skey \
5
--signing-key-file ~/cold-keys/node.skey \
6
--mainnet \
7
--out-file tx.signed
8
Copied!
Finalmente, enviamos la transacción firmada:
1
cardano-cli transaction submit \
2
--tx-file tx.signed \
3
--mainnet
Copied!
Recuerde tener el nodo corriendo y sincronizado, necesitas utilizarlo para lanzar la transacción a la red.
Última actualización 4mo ago