Actualizar parámetros del pool

Es frecuente que necesitemos actualizar los parámetros de nuestra stake pool, metadatos, pledge, relays, etc. Esta práctica será habitual durante el mantenimiento de tu pool.

Cambiar la información que aparece en los metadatos de mi pool.

Vamos al directorio cnode, actualizamos el archivo poolmeta.json.

poolmeta.json

{
"name": "NEW CASSO POOL",
"description": "New Personal pool to help decentralize the system",
"ticker": "CASSO",
"homepage": "https://jimcase.github.io/cassoweb/"
}

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

cardano-cli stake-pool metadata-hash --pool-metadata-file poolmeta.json > poolmetaHash.txt

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

sudo find / -name node.socket -print

~/cnode/sockets/node.socket

Una vez que conocemos la ruta al socket exportamos la variable de entorno.

export CARDANO_NODE_SOCKET_PATH=~/cnode/sockets/node.socket

Obtener los parámetros del protocolo:

Calculamos los parámetros necesarios para crear las transacciones

cardano-cli query protocol-parameters \
    --mainnet \
    --out-file protocol.json

Encontrar el costo mínimo de la stake-pool.

minPoolCost=$(cat protocol.json | jq -r .minPoolCost)
echo minPoolCost: ${minPoolCost}

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.

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.

cardano-cli query utxo \
    --address $(cat paymentwithstake.addr) \
    --mainnet \
    --cardano-mode > 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}

Obtenemos el último slot

currentSlot=$(cardano-cli query tip --mainnet | jq -r '.slot')

echo $currentSlot

Nuevo certificado del 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.

cardano-cli stake-pool registration-certificate \
    --cold-verification-key-file ~/cold-keys/node.vkey \
    --vrf-verification-key-file vrf.vkey \
    --pool-pledge 4500000000 \
    --pool-cost 340000000 \
    --pool-margin 0.028 \
    --pool-reward-account-verification-key-file stake.vkey \
    --pool-owner-stake-verification-key-file stake.vkey \
    --mainnet \
    --pool-relay-port 3001 \
    --pool-relay-ipv4 <your relay IP address> \
    --metadata-url <url to poolMetaData.json> \
    --metadata-hash $(cat poolmetaHash.txt) \
    --out-file pool.cert

Versión con 1 DNS por ip/relay.

cardano-cli stake-pool registration-certificate \
    --cold-verification-key-file ~/cold-keys/node.vkey \
    --vrf-verification-key-file vrf.vkey \
    --pool-pledge 4500000000 \
    --pool-cost 340000000 \
    --pool-margin 0.028 \
    --pool-reward-account-verification-key-file stake.vkey \
    --pool-owner-stake-verification-key-file stake.vkey \
    --mainnet \
    --single-host-pool-relay <dns-relay> \
    --pool-relay-port 3001 \
    --single-host-pool-relay <dns-relay2> \
    --pool-relay-port 3001 \
    --metadata-url <url-metadata-file> \
    --metadata-hash $(cat poolmetaHash.txt) \
    --out-file pool.cert

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:

cardano-cli stake-address delegation-certificate \
--stake-verification-key-file ~/cnode/keys/stake.vkey \
--cold-verification-key-file ~/cold-keys/node.vkey \
--out-file delegation.cert

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.

El depósito solo se paga la primera vez que creas el pool, por lo que no necesitamos calcularlo ni tenerlo en cuenta en este proceso.

Comenzamos por redactar la transacción:

cardano-cli transaction build-raw \
    ${tx_in} \
    --tx-out $(cat paymentwithstake.addr)+$(( ${total_balance} ))  \
    --ttl $(( ${currentSlot} + 10000)) \
    --fee 0 \
    --certificate-file pool.cert \
    --certificate-file delegation.cert \
    --out-file tx.tmp

Calculamos la comisión de transacción:

fee=$(cardano-cli transaction calculate-min-fee \
    --tx-body-file tx.tmp \
    --tx-in-count ${txcnt} \
    --tx-out-count 1 \
    --mainnet \
    --witness-count 3 \
    --byron-witness-count 0 \
    --protocol-params-file protocol.json | awk '{ print $1 }')
echo $fee

202725

Calculamos el cambio:

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

Ahora podemos construir la transacción:

cardano-cli transaction build-raw \
 ${tx_in} \
--tx-out $(cat paymentwithstake.addr)+${txOut} \
--ttl $(( ${currentSlot} + 1200)) \
--fee $fee \
--certificate-file pool.cert \
--certificate-file delegation.cert \
--out-file tx.raw

Firmamos la transacción:

cardano-cli transaction sign \
--tx-body-file tx.raw \
--signing-key-file payment.skey \
--signing-key-file stake.skey \
--signing-key-file ~/cold-keys/node.skey \
--mainnet \
--out-file tx.signed

Finalmente, enviamos la transacción firmada:

cardano-cli transaction submit \
--tx-file tx.signed \
--mainnet

Recuerde tener el nodo corriendo y sincronizado, necesitas utilizarlo para lanzar la transacción a la red.

Verificar que los metadatos están actualizados:

curl https://smash.cardano-mainnet.iohk.io/api/v1/metadata/<pool-id>/<hash-metadata>

Recuerda actualizar el archivo json con tu nuevos datos y volver a servirlo a través de https

Apoya nuestro trabajo delegando al pool Ada Booster.