mkfiles.sh

#!/usr/bin/env bash

set -e
# Unofficial bash strict mode.
# See: http://redsymbol.net/articles/unofficial-bash-strict-mode/
set -u
set -o pipefail

# This script sets up a cluster that starts out in Byron, and can transition to Mary.
#
# The script generates all the files needed for the setup, and prints commands
# to be run manually (to start the nodes, post transactions, etc.).
#
# One option to ensure you are running with repo matched cardano-cli and cardano-node
# versions is to enter a nix shell: `nix shell .#cardano-cli .#cardano-node`
#
# There are two ways of triggering the transition to Shelley:
# 1. Trigger transition at protocol version 2.0.0 (as on mainnet).
#    The system starts at 0.0.0, and we can only increase it by 1 in the major
#    version, so this does require to:
#
#    a) post an update proposal and votes to transition to 1.0.0,
#
#    b) wait for the protocol to change (end of the epoch, or end of the last
#       epoch if it's posted near the end of the epoch),
#
#    c) post an update proposal and votes to transition to 2.0.0
#
#    d) change configuration.yaml to have 'LastKnownBlockVersion-Major: 2',
#       and restart the nodes
#
#    This is what will happen on the mainnet, so it's vital to test this, but
#    it does contain some manual steps.
#
# 2. Starting in a declared era.
#    If you want to start a node in a specific era epoch 0, supply the script
#    with a shelley, allegra, mary, alonzo string argument. E.g
#    mkfiles.sh mary. This is quite convenient, but it does not test that we
#    can do the transition by posting update proposals to the network.

[ -n "${DEBUG:-}" ] && set -x

ROOT=example

BFT_NODES="node-bft1 node-bft2"
BFT_NODES_N="1 2"
NUM_BFT_NODES=2

POOL_NODES="node-pool1"

ALL_NODES="${BFT_NODES} ${POOL_NODES}"

INIT_SUPPLY=10020000000
FUNDS_PER_GENESIS_ADDRESS=$((INIT_SUPPLY / NUM_BFT_NODES))

# We need to allow for a fee to transfer the funds out of the genesis.
# We don't care too much, 1 ada is more than enough.
FUNDS_PER_BYRON_ADDRESS=$((FUNDS_PER_GENESIS_ADDRESS - 1000000))

NETWORK_MAGIC=42
SECURITY_PARAM=10

UNAME=$(uname -s) DATE=
case $UNAME in
  Darwin )      DATE="gdate";;
  Linux )       DATE="date";;
  MINGW64_NT* ) UNAME="Windows_NT"
                DATE="date";;
esac

UNAME=$(uname -s) SED=
case $UNAME in
  Darwin )      SED="gsed";;
  Linux )       SED="sed";;
esac

sprocket() {
  if [ "$UNAME" == "Windows_NT" ]; then
    # Named pipes names on Windows must have the structure: "\\.\pipe\PipeName"
    # See https://docs.microsoft.com/en-us/windows/win32/ipc/pipe-names
    # shellcheck disable=SC1003
    printf "%s" '\\.\pipe\'
    echo "${1//\//\\}"
  else
    echo "$1"
  fi
}

START_TIME="$(${DATE} -d "now + 30 seconds" +%s)"

if ! mkdir "${ROOT}"; then
  echo "The ${ROOT} directory already exists, please move or remove it"
  exit
fi

# Copy and tweak the configuration
cp configuration/defaults/byron-mainnet/configuration.yaml ${ROOT}/
$SED -i "${ROOT}/configuration.yaml" \
    -e 's/Protocol: RealPBFT/Protocol: Cardano/' \
    -e '/^Protocol:/ aPBftSignatureThreshold: 0.6' \
    -e 's/minSeverity: Info/minSeverity: Debug/' \
    -e 's|GenesisFile: genesis.json|ByronGenesisFile: byron/genesis.json|' \
    -e '/ByronGenesisFile/ aShelleyGenesisFile: shelley/genesis.json' \
    -e '/ByronGenesisFile/ aAlonzoGenesisFile: shelley/genesis.alonzo.json' \
    -e '/ByronGenesisFile/ aConwayGenesisFile: shelley/genesis.conway.json' \
    -e '/ByronGenesisFile/ aUseTraceDispatcher: False' \
    -e 's/RequiresNoMagic/RequiresMagic/' \
    -e 's/LastKnownBlockVersion-Major: 0/LastKnownBlockVersion-Major: 1/' \
    -e 's/LastKnownBlockVersion-Minor: 2/LastKnownBlockVersion-Minor: 0/'

# Create the node directories
for NODE in ${ALL_NODES}; do
  mkdir -p "${ROOT}/${NODE}/byron" "${ROOT}/${NODE}/shelley"
done

# Make topology files
# TODO: generalise this over the N BFT nodes and pool nodes
cat > "${ROOT}/node-bft1/topology.json" <<EOF
{
   "Producers": [
     {
       "addr": "127.0.0.1",
       "port": 3002,
       "valency": 1
     }
   , {
       "addr": "127.0.0.1",
       "port": 3003,
       "valency": 1
     }
   ]
 }
EOF
echo 3001 > "${ROOT}/node-bft1/port"

cat > "${ROOT}/node-bft2/topology.json" <<EOF
{
   "Producers": [
     {
       "addr": "127.0.0.1",
       "port": 3001,
       "valency": 1
     }
   , {
       "addr": "127.0.0.1",
       "port": 3003,
       "valency": 1
     }
   ]
 }
EOF
echo 3002 > "${ROOT}/node-bft2/port"

cat > "${ROOT}/node-pool1/topology.json" <<EOF
{
   "Producers": [
     {
       "addr": "127.0.0.1",
       "port": 3001,
       "valency": 1
     }
   , {
       "addr": "127.0.0.1",
       "port": 3002,
       "valency": 1
     }
   ]
 }
EOF
echo 3003 > "${ROOT}/node-pool1/port"


cat > "${ROOT}/byron.genesis.spec.json" <<EOF
{
  "heavyDelThd":     "300000000000",
  "maxBlockSize":    "2000000",
  "maxTxSize":       "4096",
  "maxHeaderSize":   "2000000",
  "maxProposalSize": "700",
  "mpcThd": "20000000000000",
  "scriptVersion": 0,
  "slotDuration": "1000",
  "softforkRule": {
    "initThd": "900000000000000",
    "minThd": "600000000000000",
    "thdDecrement": "50000000000000"
  },
  "txFeePolicy": {
    "multiplier": "43946000000",
    "summand": "155381000000000"
  },
  "unlockStakeEpoch": "18446744073709551615",
  "updateImplicit": "10000",
  "updateProposalThd": "100000000000000",
  "updateVoteThd": "1000000000000"
}
EOF

cardano-cli byron genesis genesis \
  --protocol-magic ${NETWORK_MAGIC} \
  --start-time "${START_TIME}" \
  --k ${SECURITY_PARAM} \
  --n-poor-addresses 0 \
  --n-delegate-addresses ${NUM_BFT_NODES} \
  --total-balance ${INIT_SUPPLY} \
  --delegate-share 1 \
  --avvm-entry-count 0 \
  --avvm-entry-balance 0 \
  --protocol-parameters-file "${ROOT}/byron.genesis.spec.json" \
  --genesis-output-dir "${ROOT}/byron"
mv "${ROOT}/byron.genesis.spec.json" "${ROOT}/byron/genesis.spec.json"

pwd

# Symlink the BFT operator keys from the genesis delegates, for uniformity
for N in ${BFT_NODES_N}; do
  ln -s "../../byron/delegate-keys.00$((N - 1)).key"     "${ROOT}/node-bft${N}/byron/delegate.key"
  ln -s "../../byron/delegation-cert.00$((N - 1)).json"  "${ROOT}/node-bft${N}/byron/delegate.cert"
done

# Create keys, addresses and transactions to withdraw the initial UTxO into
# regular addresses.
for N in ${BFT_NODES_N}; do

  cardano-cli byron key keygen \
    --secret "${ROOT}/byron/payment-keys.00$((N - 1)).key"

  cardano-cli byron key signing-key-address \
    --testnet-magic ${NETWORK_MAGIC} \
    --secret "${ROOT}/byron/payment-keys.00$((N - 1)).key" > "${ROOT}/byron/address-00$((N - 1))"

  cardano-cli byron key signing-key-address \
    --testnet-magic ${NETWORK_MAGIC} \
    --secret "${ROOT}/byron/genesis-keys.00$((N - 1)).key" > "${ROOT}/byron/genesis-address-00$((N - 1))"

  cardano-cli byron transaction issue-genesis-utxo-expenditure \
    --genesis-json "${ROOT}/byron/genesis.json" \
    --testnet-magic ${NETWORK_MAGIC} \
    --tx "${ROOT}/tx$((N - 1)).tx" \
    --wallet-key "${ROOT}/byron/delegate-keys.00$((N - 1)).key" \
    --rich-addr-from "$(head -n 1 "${ROOT}/byron/genesis-address-00$((N - 1))")" \
    --txout "(\"$(head -n 1 "${ROOT}/byron/address-00$((N - 1))")\", $FUNDS_PER_BYRON_ADDRESS)"
done

# Update Proposal and votes
cardano-cli byron governance create-update-proposal \
            --filepath "${ROOT}/update-proposal" \
            --testnet-magic "${NETWORK_MAGIC}" \
            --signing-key "${ROOT}/byron/delegate-keys.000.key" \
            --protocol-version-major 1 \
            --protocol-version-minor 0 \
            --protocol-version-alt 0 \
            --application-name "cardano-sl" \
            --software-version-num 1 \
            --system-tag "linux" \
            --installer-hash 0

for N in ${BFT_NODES_N}; do
    cardano-cli byron governance create-proposal-vote \
                --proposal-filepath "${ROOT}/update-proposal" \
                --testnet-magic ${NETWORK_MAGIC} \
                --signing-key "${ROOT}/byron/delegate-keys.00$((N - 1)).key" \
                --vote-yes \
                --output-filepath "${ROOT}/update-vote.00$((N - 1))"
done

cardano-cli byron governance create-update-proposal \
            --filepath "${ROOT}/update-proposal-1" \
            --testnet-magic ${NETWORK_MAGIC} \
            --signing-key "${ROOT}/byron/delegate-keys.000.key" \
            --protocol-version-major 2 \
            --protocol-version-minor 0 \
            --protocol-version-alt 0 \
            --application-name "cardano-sl" \
            --software-version-num 1 \
            --system-tag "linux" \
            --installer-hash 0

for N in ${BFT_NODES_N}; do
    cardano-cli byron governance create-proposal-vote \
                --proposal-filepath "${ROOT}/update-proposal-1" \
                --testnet-magic ${NETWORK_MAGIC} \
                --signing-key "${ROOT}/byron/delegate-keys.00$((N - 1)).key" \
                --vote-yes \
                --output-filepath "${ROOT}/update-vote-1.00$((N - 1))"
done

echo "====================================================================="
echo "Generated genesis keys and genesis files:"
echo
ls -1 "${ROOT}/byron"/*
echo "====================================================================="


# Set up our template
mkdir "${ROOT}/shelley"

# Copy the alonzo and conway testnet template genesis files
cp configuration/cardano/testnet-template-alonzo.json "${ROOT}/shelley/genesis.alonzo.spec.json"
cp configuration/cardano/testnet-template-conway.json "${ROOT}/shelley/genesis.conway.spec.json"

cardano-cli shelley genesis create --testnet-magic ${NETWORK_MAGIC} --genesis-dir "${ROOT}/shelley"

# Now generate for real:
cardano-cli shelley genesis create \
    --testnet-magic ${NETWORK_MAGIC} \
    --genesis-dir "${ROOT}/shelley/" \
    --gen-genesis-keys ${NUM_BFT_NODES} \
    --gen-utxo-keys 1

echo "What is in shelley"
ls ${ROOT}/shelley

cp "${ROOT}/shelley/genesis.json" "${ROOT}/shelley/copy-genesis.json"

# We're going to use really quick epochs (300 seconds), by using short slots 0.2s
# and K=10, but we'll keep long KES periods so we don't have to bother
# cycling KES keys
jq -M '. +
    { slotLength:0.1
    , securityParam:10
    , activeSlotsCoeff:0.1
    , securityParam:10
    , epochLength:500
    , maxLovelaceSupply:1000000000000
    , updateQuorum:2
    }' \
  "${ROOT}/shelley/copy-genesis.json" > "${ROOT}/shelley/copy2-genesis.json"
jq --raw-output '
      .protocolParams.protocolVersion.major = 2
    | .protocolParams.minFeeA = 44
    | .protocolParams.minFeeB = 155381
    | .protocolParams.minUTxOValue = 1000000
    | .protocolParams.decentralisationParam = 0.7
    | .protocolParams.rho = 0.1
    | .protocolParams.tau = 0.1' \
  "${ROOT}/shelley/copy2-genesis.json" > "${ROOT}/shelley/genesis.json"

rm "${ROOT}/shelley/copy2-genesis.json"
rm "${ROOT}/shelley/copy-genesis.json"

cardano-cli shelley stake-address key-gen \
  --verification-key-file "${ROOT}/shelley/utxo-keys/utxo-stake.vkey" \
  --signing-key-file "${ROOT}/shelley/utxo-keys/utxo-stake.skey"

cardano-cli address key-gen \
  --verification-key-file "${ROOT}/shelley/utxo-keys/utxo2.vkey" \
  --signing-key-file "${ROOT}/shelley/utxo-keys/utxo2.skey"

cardano-cli shelley stake-address key-gen \
  --verification-key-file "${ROOT}/shelley/utxo-keys/utxo2-stake.vkey" \
  --signing-key-file "${ROOT}/shelley/utxo-keys/utxo2-stake.skey"

# Create a symlink to all the payment keys in utxo-keys directory
mkdir -p "${ROOT}/utxo-keys"

find "${ROOT}/shelley/utxo-keys" -type f | while IFS= read -r FILE; do
  if jq -e 'select(
      false
      or .type == "GenesisUTxOVerificationKey_ed25519"
      or .type == "GenesisUTxOSigningKey_ed25519"
      or .type == "PaymentSigningKeyShelley_ed25519"
      or .type == "PaymentVerificationKeyShelley_ed25519"
      )' < "$FILE" > /dev/null; then
    ln -srf "$FILE" "${ROOT}/utxo-keys/$(basename "$FILE")"
  fi
done

echo "====================================================================="
echo "Generated genesis keys and genesis files:"
echo
ls -1 "${ROOT}/shelley"/*
echo "====================================================================="

echo "Generated shelley/genesis.json:"
echo
cat "${ROOT}/shelley/genesis.json"
echo
echo "====================================================================="

# Make the pool operator cold keys
# This was done already for the BFT nodes as part of the genesis creation
for NODE in ${POOL_NODES}; do
  cardano-cli node key-gen \
      --cold-verification-key-file                 "${ROOT}/${NODE}/shelley/operator.vkey" \
      --cold-signing-key-file                      "${ROOT}/${NODE}/shelley/operator.skey" \
      --operational-certificate-issue-counter-file "${ROOT}/${NODE}/shelley/operator.counter"

  cardano-cli node key-gen-VRF \
      --verification-key-file "${ROOT}/${NODE}/shelley/vrf.vkey" \
      --signing-key-file      "${ROOT}/${NODE}/shelley/vrf.skey"
done

# Symlink the BFT operator keys from the genesis delegates, for uniformity
for N in ${BFT_NODES_N}; do
  ln -s "../../shelley/delegate-keys/delegate${N}.skey" "${ROOT}/node-bft${N}/shelley/operator.skey"
  ln -s "../../shelley/delegate-keys/delegate${N}.vkey" "${ROOT}/node-bft${N}/shelley/operator.vkey"
  ln -s "../../shelley/delegate-keys/delegate${N}.counter" "${ROOT}/node-bft${N}/shelley/operator.counter"
  ln -s "../../shelley/delegate-keys/delegate${N}.vrf.vkey" "${ROOT}/node-bft${N}/shelley/vrf.vkey"
  ln -s "../../shelley/delegate-keys/delegate${N}.vrf.skey" "${ROOT}/node-bft${N}/shelley/vrf.skey"
done

# Make hot keys and for all nodes
for NODE in ${ALL_NODES}; do
  cardano-cli node key-gen-KES \
      --verification-key-file "${ROOT}/${NODE}/shelley/kes.vkey" \
      --signing-key-file      "${ROOT}/${NODE}/shelley/kes.skey"

  cardano-cli node issue-op-cert \
      --kes-period 0 \
      --kes-verification-key-file                  "${ROOT}/${NODE}/shelley/kes.vkey" \
      --cold-signing-key-file                      "${ROOT}/${NODE}/shelley/operator.skey" \
      --operational-certificate-issue-counter-file "${ROOT}/${NODE}/shelley/operator.counter" \
      --out-file                                   "${ROOT}/${NODE}/shelley/node.cert"
done

echo "Generated node operator keys (cold, hot) and operational certs:"
echo
for NODE in ${ALL_NODES}; do
  ls -1 "${ROOT}/${NODE}"
done
echo "====================================================================="

# Make some payment and stake addresses
# user1..n:       will own all the funds in the system, we'll set this up from
#                 initial utxo the
# pool-owner1..n: will be the owner of the pools and we'll use their reward
#                 account for pool rewards
USER_ADDRS="user1"
POOL_ADDRS="pool-owner1"

ADDRS="${USER_ADDRS} ${POOL_ADDRS}"

mkdir "${ROOT}/addresses"

for ADDR in ${ADDRS}; do

  # Payment address keys
  cardano-cli address key-gen \
      --verification-key-file "${ROOT}/addresses/${ADDR}.vkey" \
      --signing-key-file      "${ROOT}/addresses/${ADDR}.skey"

  # Stake address keys
  cardano-cli shelley stake-address key-gen \
      --verification-key-file "${ROOT}/addresses/${ADDR}-stake.vkey" \
      --signing-key-file      "${ROOT}/addresses/${ADDR}-stake.skey"

  # Payment addresses
  cardano-cli address build \
      --payment-verification-key-file "${ROOT}/addresses/${ADDR}.vkey" \
      --stake-verification-key-file "${ROOT}/addresses/${ADDR}-stake.vkey" \
      --testnet-magic ${NETWORK_MAGIC} \
      --out-file "${ROOT}/addresses/${ADDR}.addr"

  # Stake addresses
  cardano-cli shelley stake-address build \
      --stake-verification-key-file "${ROOT}/addresses/${ADDR}-stake.vkey" \
      --testnet-magic ${NETWORK_MAGIC} \
      --out-file "${ROOT}/addresses/${ADDR}-stake.addr"

  # Stake addresses registration certs
  cardano-cli shelley stake-address registration-certificate \
      --stake-verification-key-file "${ROOT}/addresses/${ADDR}-stake.vkey" \
      --out-file "${ROOT}/addresses/${ADDR}-stake.reg.cert"

done

# user N will delegate to pool N
USER_POOL_N="1"

for N in ${USER_POOL_N}; do
  # Stake address delegation certs
  cardano-cli shelley stake-address stake-delegation-certificate \
      --stake-verification-key-file "${ROOT}/addresses/user${N}-stake.vkey" \
      --cold-verification-key-file  "${ROOT}/node-pool${N}/shelley/operator.vkey" \
      --out-file "${ROOT}/addresses/user${N}-stake.deleg.cert"

  ln -s "../addresses/pool-owner${N}-stake.vkey" "${ROOT}/node-pool${N}/owner.vkey"
  ln -s "../addresses/pool-owner${N}-stake.skey" "${ROOT}/node-pool${N}/owner.skey"

done

echo "Generated payment address keys, stake address keys,"
echo "stake address registration certs, and stake address delegation certs"
echo
ls -1 "${ROOT}/addresses/"
echo "====================================================================="

# Next is to make the stake pool registration cert
for NODE in ${POOL_NODES}; do

  cardano-cli shelley stake-pool registration-certificate \
    --testnet-magic ${NETWORK_MAGIC} \
    --pool-pledge 0 --pool-cost 0 --pool-margin 0 \
    --cold-verification-key-file             "${ROOT}/${NODE}/shelley/operator.vkey" \
    --vrf-verification-key-file              "${ROOT}/${NODE}/shelley/vrf.vkey" \
    --reward-account-verification-key-file   "${ROOT}/${NODE}/owner.vkey" \
    --pool-owner-stake-verification-key-file "${ROOT}/${NODE}/owner.vkey" \
    --out-file                               "${ROOT}/${NODE}/registration.cert"
done

echo "Generated stake pool registration certs:"
ls -1 "${ROOT}/node-"*"/registration.cert"
echo "====================================================================="

echo "So you can now do various things:"
echo " * Start the nodes"
echo " * Initiate successive protocol updates"
echo " * Query the node's ledger state"
echo
echo "To start the nodes, in separate terminals use the following scripts:"
echo

mkdir -p "${ROOT}/run"

for NODE in ${BFT_NODES}; do
  (
    echo "#!/usr/bin/env bash"
    echo ""
    echo "cardano-node run \\"
    echo "  --config                          ${ROOT}/configuration.yaml \\"
    echo "  --topology                        ${ROOT}/${NODE}/topology.json \\"
    echo "  --database-path                   ${ROOT}/${NODE}/db \\"
    echo "  --socket-path                     '$(sprocket "${ROOT}/${NODE}/node.sock")' \\"
    echo "  --shelley-kes-key                 ${ROOT}/${NODE}/shelley/kes.skey \\"
    echo "  --shelley-vrf-key                 ${ROOT}/${NODE}/shelley/vrf.skey \\"
    echo "  --shelley-operational-certificate ${ROOT}/${NODE}/shelley/node.cert \\"
    echo "  --port                            $(cat "${ROOT}/${NODE}/port") \\"
    echo "  --delegation-certificate          ${ROOT}/${NODE}/byron/delegate.cert \\"
    echo "  --signing-key                     ${ROOT}/${NODE}/byron/delegate.key \\"
    echo "  | tee -a \"${ROOT}/${NODE}/node.log\""
  ) > "${ROOT}/run/${NODE}.sh"

  chmod a+x "${ROOT}/run/${NODE}.sh"

  echo "${ROOT}/run/${NODE}.sh"
done

for NODE in ${POOL_NODES}; do
  (
    echo "#!/usr/bin/env bash"
    echo ""
    echo "cardano-node run \\"
    echo "  --config                          ${ROOT}/configuration.yaml \\"
    echo "  --topology                        ${ROOT}/${NODE}/topology.json \\"
    echo "  --database-path                   ${ROOT}/${NODE}/db \\"
    echo "  --socket-path                     '$(sprocket "${ROOT}/${NODE}/node.sock")' \\"
    echo "  --shelley-kes-key                 ${ROOT}/${NODE}/shelley/kes.skey \\"
    echo "  --shelley-vrf-key                 ${ROOT}/${NODE}/shelley/vrf.skey \\"
    echo "  --shelley-operational-certificate ${ROOT}/${NODE}/shelley/node.cert \\"
    echo "  --port                            $(cat "${ROOT}/${NODE}/port") \\"
    echo "  | tee -a \"${ROOT}/${NODE}/node.log\""
  ) > "${ROOT}/run/${NODE}.sh"

  chmod a+x "${ROOT}/run/${NODE}.sh"

  echo "$ROOT/run/${NODE}.sh"
done

echo "#!/usr/bin/env bash" > "${ROOT}/run/all.sh"
echo "" >> "${ROOT}/run/all.sh"

chmod a+x "${ROOT}/run/all.sh"

for NODE in ${BFT_NODES}; do
  echo "$ROOT/run/${NODE}.sh &" >> "${ROOT}/run/all.sh"
done

for NODE in ${POOL_NODES}; do
  echo "$ROOT/run/${NODE}.sh &" >> "${ROOT}/run/all.sh"
done

echo "" >> "${ROOT}/run/all.sh"
echo "wait" >> "${ROOT}/run/all.sh"

chmod a+x "${ROOT}/run/all.sh"

echo
echo "Alternatively, you can run all the nodes in one go:"
echo
echo "$ROOT/run/all.sh"
echo
echo "One option to ensure you are running with repo matched"
echo "cardano-cli and cardano-node versions is to enter a nix shell"
echo "before starting the nodes:"
echo "  nix shell .#cardano-cli .#cardano-node"
echo
echo "In order to do the protocol updates, proceed as follows:"
echo
echo "  0. Invoke ./scripts/byron-to-alonzo/mkfiles.sh and"
echo "     start one or all nodes per above command examples."
echo
echo "  1. Wait for the nodes to start producing blocks."
echo
echo "  2. Invoke ./scripts/byron-to-alonzo/update-1.sh."
echo "     Wait for the next epoch for the update to take effect."
echo
echo "  3. Invoke ./scripts/byron-to-alonzo/update-2.sh."
echo
echo "  4. Restart the nodes."
echo "     Wait for the next epoch for the update to take effect."
echo "     You should be in the Shelley era if the update was successful."
echo
echo "  5. Invoke ./scripts/byron-to-alonzo/update-3.sh <N>."
echo "     Here, <N> the current epoch (2 if you're quick)."
echo "     If you provide the wrong epoch, you will see an error"
echo "     that will tell you the current epoch, and can run"
echo "     the script again."
echo
echo "  6. Restart the nodes."
echo "     Wait for the next epoch for the update to take effect."
echo "     You should be in the Allegra era if the update was successful."
echo
echo "  7. Invoke ./scripts/byron-to-alonzo/update-4.sh <N>."
echo
echo "  8. Restart the nodes."
echo "     Wait for the next epoch for the update to take effect."
echo "     You should be in the Mary era if the update was successful."
echo
echo "  a. Optionally, invoke ./scripts/byron-to-alonzo/mint.sh"
echo "     and then ./scripts/byron-to-alonzo/burn.sh for a native token"
echo "     minting and burning example in Mary."
echo
echo "  9. Invoke ./scripts/byron-to-alonzo/update-5.sh <N>."
echo "     Wait for the next epoch for the update to take effect."
echo "     You should be in the Alonzo era if the update was successful."
echo
echo "You can observe the status of the updates by grepping the logs, via"
echo
echo "  grep LedgerUpdate ${ROOT}/node-pool1/node.log"
echo
echo "When in Shelley (after step 3), you should be able"
echo "to look at the protocol parameters, or the ledger state,"
echo "using commands like:"
echo
echo "CARDANO_NODE_SOCKET_PATH=${ROOT}/node-bft1/node.sock \\"
echo "  cardano-cli query protocol-parameters --testnet-magic 42"
echo
echo "Occassionally on startup, the bft forgers in byron may encounter a"
echo "\"TraceNodeCannotForge\" error due to \"PBftCannotForgeThresholdExceeded\""
echo "during the first several blocks.  If this occurs, simply wipe state and retry."

# For an automatic transition at epoch 0, specifying mary, allegra or shelley
# as a cli arg will start the node in the appropriate era.
echo

# These are needed for cardano-submit-api
echo "EnableLogMetrics: False" >> "${ROOT}/configuration.yaml"
echo "EnableLogging: True" >> "${ROOT}/configuration.yaml"

if [ "${1:-}" = "babbage" ]; then
  {
    echo "TestShelleyHardForkAtEpoch: 0"
    echo "TestAllegraHardForkAtEpoch: 0"
    echo "TestMaryHardForkAtEpoch: 0"
    echo "TestAlonzoHardForkAtEpoch: 0"
    echo "TestBabbageHardForkAtEpoch: 0"
    echo "ExperimentalHardForksEnabled: True"
    echo "ExperimentalProtocolsEnabled: True"
  } >> "${ROOT}/configuration.yaml"

  $SED -i "${ROOT}/configuration.yaml" \
      -e 's/LastKnownBlockVersion-Major: 1/LastKnownBlockVersion-Major: 7/'

  echo "Nodes will start in Babbage era from epoch 0"
  echo "Caveat: forging will be disabled."

elif [ "${1:-}" = "alonzo" ]; then
  {
    echo "TestShelleyHardForkAtEpoch: 0"
    echo "TestAllegraHardForkAtEpoch: 0"
    echo "TestMaryHardForkAtEpoch: 0"
    echo "TestAlonzoHardForkAtEpoch: 0"
    echo "ExperimentalHardForksEnabled: True"
    echo "ExperimentalProtocolsEnabled: True"
  } >> "${ROOT}/configuration.yaml"

  $SED -i "${ROOT}/configuration.yaml" \
      -e 's/LastKnownBlockVersion-Major: 1/LastKnownBlockVersion-Major: 5/'

  echo "Nodes will start in Alonzo era from epoch 0"

elif [ "${1:-}" = "mary" ]; then
  {
    echo "TestShelleyHardForkAtEpoch: 0"
    echo "TestAllegraHardForkAtEpoch: 0"
    echo "TestMaryHardForkAtEpoch: 0"
  } >> "${ROOT}/configuration.yaml"

  $SED -i "${ROOT}/configuration.yaml" \
      -e 's/LastKnownBlockVersion-Major: 1/LastKnownBlockVersion-Major: 4/'
  echo "Nodes will start in Mary era from epoch 0"

elif [ "${1:-}" = "allegra" ]; then
  echo "TestShelleyHardForkAtEpoch: 0"  >> "${ROOT}/configuration.yaml"
  echo "TestAllegraHardForkAtEpoch: 0"  >> "${ROOT}/configuration.yaml"

  $SED -i "${ROOT}/configuration.yaml" \
      -e 's/LastKnownBlockVersion-Major: 1/LastKnownBlockVersion-Major: 3/'
  echo "Nodes will start in Allegra era from epoch 0"

elif [ "${1:-}" = "shelley" ]; then
  echo "TestShelleyHardForkAtEpoch: 0"  >> "${ROOT}/configuration.yaml"

  $SED -i "${ROOT}/configuration.yaml" \
      -e 's/LastKnownBlockVersion-Major: 1/LastKnownBlockVersion-Major: 2/'
  echo "Nodes will start in Shelley era from epoch 0"

else
  echo "Default yaml configuration applied."
fi

(cd "$ROOT"; ln -s "node-bft1/node.sock" "main.sock")