feat: adding devnet tests

.github/workflows/nightly-devnet-test.yml

@@ -0,0 +1,62 @@
+name: Devnet network tests
+on:
+  # TODO(ek): Remove this after testing
+  pull_request:
+    paths:
+      - '**.yml'
+  workflow_dispatch:
+  schedule:
+    # Run nightly at 0300
+    - cron: "0 3 * * *"
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+env:
+  # This path is a workaround because the runner does not have perms to upload files anywhere else
+  STATE_S3_BASE_PATH: s3://aztec-ci-artifacts/build-cache
+  AZTEC_VERSION: 0.84.0-alpha-testnet.1
+  NODE_URL: http://104.198.9.75:8080
+  SPONSORED_FPC_ADDRESS: "0x2742bae7b298acd9ae3f09ff48f6e6254f1e28bb71fbec9b6e79fe9955adf83c"
+  L1_URL: http://34.169.129.31:8545
+  FAUCET_URL: http://104.199.115.217:8086
+
+jobs:
+  cli-wallet:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Configure AWS credentials
+        uses: aws-actions/configure-aws-credentials@v1
+        with:
+          aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
+          aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
+          aws-region: eu-west-2
+
+      - name: Checkout smoke tests (note that this is not pinned to a version, the CLI wallet installed is though)
+        uses: actions/checkout@v4
+        with:
+          sparse-checkout: |
+            spartan/devnet-smoke-tests
+
+      # TODO: Remove after we see this script succeed consistently
+      - name: Reset state for testing
+        run: |
+          echo '{"accounts": [], "contracts": []}'> state.json
+          aws s3 cp ./state.json ${{ env.STATE_S3_BASE_PATH }}/devnet-nightly-tests-state.json
+
+      - name: Retrieve state or set default if not
+        run: |
+          aws s3 cp ${{ env.STATE_S3_BASE_PATH }}/devnet-nightly-tests-state.json ./state.json || echo '{"accounts": [], "contracts": []}'> state.json
+          cat ./state.json
+
+      - name: Run smoke tests
+        run: |
+          ./spartan/devnet-smoke-tests/main.sh
+
+      - name: Re-commit state
+        run: |
+          jq '.last_modified = (now | tostring)' state.json > tmp.json && mv tmp.json state.json
+          cat ./state.json
+
+          aws s3 cp ./state.json ${{ env.STATE_S3_BASE_PATH }}/devnet-nightly-tests-state.json

spartan/devnet-smoke-tests/create_new_accounts.sh

@@ -0,0 +1,81 @@
+new_accounts_per_run=2
+new_accounts="[]"
+max_accounts=2
+
+total_account_count=$(jq '.accounts | length' state.json)
+if [ "$total_account_count" -lt "$max_accounts" ]; then
+
+  # New accounts should be the min(num_new_accounts, max_accounts - total_account_count)
+  num_new_accounts=$(( new_accounts_per_run < (max_accounts - total_account_count) ? new_accounts_per_run : (max_accounts - total_account_count) ))
+  for i in $(seq 1 $num_new_accounts); do
+    new_account=$(aztec-wallet \
+      create-account \
+      -a main \
+      --register-only \
+      --json \
+      | grep -Pzo '(?s)\{.*\}')
+
+    new_account=$(echo "$new_account" | jq '. + {"needs_setup": true}')
+
+    echo "$new_account" | jq '.'
+
+    # We assume we are an end user without access to the prefunded L1 account. Thus we have to
+    # create an L1 account, drip eth to it, then use this account to bridge fee juice.
+    l1_account=$(aztec \
+      create-l1-account \
+      --json)
+
+    l1_private_key=$(echo "$l1_account" | jq -r '.privateKey')
+    l1_address=$(echo "$l1_account" | jq -r '.address')
+
+    aztec \
+      drip-faucet \
+      -t ETH \
+      -a $l1_address \
+      -u $FAUCET_URL
+
+    aztec-wallet \
+      bridge-fee-juice 1000000000000000000 accounts:main \
+      --mint \
+      --l1-rpc-urls $L1_URL \
+      --l1-chain-id 1337 \
+      --l1-private-key $l1_private_key
+
+    # We sleep here because it seems that the wait option on bridging is a bit flaky and sometimes we need to
+    # wait another block (slot duration is 36s and picked 40s due to it being a nice round number)
+    echo "Sleeping 40 seconds before deploying to wait for L1 -> L2 message existence"
+    sleep 40s
+
+    # We only use the prover on the first iteration of the loop to avoid duplicating identical proofs
+    prover_to_use=$(get_prover $((i == 1)))
+
+    aztec-wallet $prover_to_use \
+     deploy-account \
+     -f accounts:main \
+     --payment method=fee_juice,claim
+
+    new_accounts=$(echo "$new_accounts" | jq --argjson acc "$new_account" '. += [$acc]')
+  done
+fi
+
+echo "$new_accounts" | jq '.'
+
+add_to_state ".accounts" "$new_accounts"
+
+# Test account deployment works with sponsoredFPC, we don't actually save this account though because we would like
+# the persistent accounts that we use to have a healthy balance of fee juice
+aztec-wallet \
+  create-account \
+  -a sponsored-fpc \
+  --register-only
+
+aztec-wallet \
+  register-contract $SPONSORED_FPC_ADDRESS SponsoredFPC \
+  -f accounts:sponsored-fpc \
+  --salt 0
+
+prover_to_use="-p native"
+aztec-wallet $prover_to_use \
+  deploy-account \
+  -f accounts:sponsored-fpc \
+  $SPONSORED_FPC_PAYMENT_METHOD

spartan/devnet-smoke-tests/deploy_amm_contracts.sh

@@ -0,0 +1,60 @@
+amm_contract_count=$(jq '.contracts | map(select(.type=="amm")) | length' state.json)
+max_amm_contracts=1
+amm_contracts_per_run=1
+accounts=$(jq -c '.accounts[]' state.json)
+
+# Check the amm contract count and create more if current < max_amm_contracts
+if [ "$amm_contract_count" -lt "$max_amm_contracts" ]; then
+  new_amm_contracts="[]"
+
+  num_new_amm_contracts=$(( amm_contracts_per_run < (max_amm_contracts - amm_contract_count) ? amm_contracts_per_run : (max_amm_contracts - amm_contract_count) ))
+  for i in $(seq 1 $num_new_amm_contracts); do
+    admin_and_minter_address=$(select_random_account "$accounts")
+
+    token_symbol_base="$((amm_contract_count + i))_TKN"
+    token_name_base="$((amm_contract_count + i))_Token"
+
+    # We don't want to prove any token deployments because we already have done so in the token tests
+    prover_to_use_when_deploying_token="-p none"
+
+    token_0_address=$(aztec-wallet $prover_to_use_when_deploying_token \
+      deploy Token \
+      --args $admin_and_minter_address "${token_name_base}_0" "${token_symbol_base}_0" 18 \
+      -f $admin_and_minter_address \
+      | get_contract_address)
+
+    token_1_address=$(aztec-wallet $prover_to_use_when_deploying_token \
+      deploy Token \
+      --args $admin_and_minter_address "${token_name_base}_1" "${token_symbol_base}_1" 18 \
+      -f $admin_and_minter_address \
+      | get_contract_address)
+
+    token_liquidity_address=$(aztec-wallet $prover_to_use_when_deploying_token \
+      deploy Token \
+      --args $admin_and_minter_address "${token_name_base}_liquidity" "${token_symbol_base}_liquidity" 18 \
+      -f $admin_and_minter_address \
+      | get_contract_address)
+
+    # We only use the prover on the first iteration of the loop to avoid duplicating identical proofs
+    prover_to_use_when_deploying_amm=$(get_prover $((i == 1)))
+
+    amm_address=$(aztec-wallet $prover_to_use_when_deploying_amm \
+      deploy AMM \
+      --args $token_0_address $token_1_address $token_liquidity_address \
+      -f $admin_and_minter_address \
+      | get_contract_address)
+
+    new_amm_contract=$(jq -n \
+      --arg token_0_address "$token_0_address" \
+      --arg token_1_address "$token_1_address" \
+      --arg token_liquidity_address "$token_liquidity_address" \
+      --arg amm_address "$amm_address" \
+      --arg admin_and_minter "$admin_and_minter_address" \
+      '{"token_0_address": $token_0_address, "token_1_address": $token_1_address, "token_liquidity_address": $token_liquidity_address, "amm_address": $amm_address, "type": "amm", "admin_and_minter": $admin_and_minter, "needs_setup": true}')
+    new_amm_contracts=$(echo "$new_amm_contracts" | jq --argjson contract "$new_amm_contract" '. += [$contract]')
+  done
+
+  echo "$new_amm_contracts" | jq '.'
+
+  add_to_state ".contracts" "$new_amm_contracts"
+fi

spartan/devnet-smoke-tests/deploy_nft_contracts.sh

@@ -0,0 +1,36 @@
+nft_contract_count=$(jq '.contracts | map(select(.type=="nft")) | length' state.json)
+max_nft_contracts=1
+nft_contracts_per_run=1
+accounts=$(jq -c '.accounts[]' state.json)
+
+# Check the current nft contract count and create more if current < max_nft_contract
+if [ "$nft_contract_count" -lt "$max_nft_contracts" ]; then
+  new_nft_contracts="[]"
+
+  num_new_nft_contracts=$(( nft_contracts_per_run < (max_nft_contracts - nft_contract_count) ? nft_contracts_per_run : (max_nft_contracts - nft_contract_count) ))
+  for i in $(seq 1 $num_new_nft_contracts); do
+    admin_and_minter_address=$(select_random_account "$accounts")
+
+    nft_symbol="NFB_$((nft_contract_count + i))}"
+    nft_name="NonFungibullish_$((nft_contract_count + i))"
+
+    # We only use the prover on the first iteration of the loop to avoid duplicating idential proofs
+    prover_to_use=$(get_prover $((i == 1)))
+
+    new_nft_contract_address=$(aztec-wallet $prover_to_use \
+      deploy NFT \
+      --args $admin_and_minter_address $nft_name $nft_symbol \
+      -f $admin_and_minter_address \
+      | get_contract_address)
+
+    new_nft_contract=$(jq -n \
+      --arg address "$new_nft_contract_address" \
+      --arg admin_and_minter "$admin_and_minter_address" \
+      '{"address": $address, "type": "nft", "token_id": 1, "admin_and_minter": $admin_and_minter, "needs_setup": true}')
+    new_nft_contracts=$(echo "$new_nft_contracts" | jq --argjson contract "$new_nft_contract" '. += [$contract]')
+  done
+
+  echo "$new_nft_contracts" | jq '.'
+
+  add_to_state ".contracts" "$new_nft_contracts"
+fi

spartan/devnet-smoke-tests/deploy_token_contracts.sh

@@ -0,0 +1,36 @@
+token_contract_count=$(jq '.contracts | map(select(.type=="token")) | length' state.json)
+max_token_contracts=1
+token_contracts_per_run=1
+accounts=$(jq -c '.accounts[]' state.json)
+
+# Check the current token contract count and create more if current < max_token_contracts
+if [ "$token_contract_count" -lt "$max_token_contracts" ]; then
+  new_token_contracts="[]"
+
+  num_new_token_contracts=$(( token_contracts_per_run < (max_token_contracts - token_contract_count) ? token_contracts_per_run : (max_token_contracts - token_contract_count) ))
+  for i in $(seq 1 $num_new_token_contracts); do
+    admin_and_minter_address=$(select_random_account "$accounts")
+
+    token_symbol="TKN_$((token_contract_count + i))"
+    token_name="Token_$((token_contract_count + i))"
+
+    # We only use the prover on the first iteration of the loop to avoid duplicating identical proofs
+    prover_to_use=$(get_prover $((i == 1)))
+
+    new_token_contract_address=$(aztec-wallet $prover_to_use \
+      deploy Token \
+      --args $admin_and_minter_address $token_name $token_symbol 18 \
+      -f $admin_and_minter_address \
+      | get_contract_address)
+
+    new_token_contract=$(jq -n \
+      --arg address "$new_token_contract_address" \
+      --arg admin_and_minter "$admin_and_minter_address" \
+      '{"address": $address, "type": "token", "admin_and_minter": $admin_and_minter, "needs_setup": true}')
+    new_token_contracts=$(echo "$new_token_contracts" | jq --argjson contract "$new_token_contract" '. += [$contract]')
+  done
+
+  echo "$new_token_contracts" | jq '.'
+
+  add_to_state ".contracts" "$new_token_contracts"
+fi

spartan/devnet-smoke-tests/install_aztec.sh

@@ -0,0 +1,7 @@
+# Install aztec and set version
+bash -i <(curl -s https://install.aztec.network)
+
+# Add the bin directory to the current PATH
+export PATH="$HOME/.aztec/bin:$PATH"
+
+aztec-up -v $AZTEC_VERSION

spartan/devnet-smoke-tests/main.sh

@@ -0,0 +1,52 @@
+set -eu -o pipefail
+
+# Get the directory where this script is located
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+
+# This script assumes the presence of state.json if trying to recreate from existing state. It is expected to
+# be structured something like this { "accounts": [], "contracts": [] }
+
+source "$SCRIPT_DIR/utils.sh"
+
+# Check all required environment variables
+check_env_var "STATE_S3_BASE_PATH"
+check_env_var "AZTEC_VERSION"
+check_env_var "NODE_URL"
+check_env_var "L1_URL"
+check_env_var "FAUCET_URL"
+check_env_var "SPONSORED_FPC_ADDRESS"
+
+SPONSORED_FPC_PAYMENT_METHOD="--payment method=fpc-sponsored,fpc=$SPONSORED_FPC_ADDRESS"
+
+print_header "Installing Aztec"
+source "$SCRIPT_DIR/install_aztec.sh"
+
+print_header "Registering existing accounts from state"
+source "$SCRIPT_DIR/register_existing_accounts_from_state.sh"
+
+print_header "Creating new accounts"
+source "$SCRIPT_DIR/create_new_accounts.sh"
+
+print_header "Deploying token contracts"
+source "$SCRIPT_DIR/deploy_token_contracts.sh"
+
+print_header "Deploying AMM contracts"
+source "$SCRIPT_DIR/deploy_amm_contracts.sh"
+
+print_header "Deploying NFT contracts"
+source "$SCRIPT_DIR/deploy_nft_contracts.sh"
+
+print_header "Registering senders"
+source "$SCRIPT_DIR/register_senders.sh"
+
+print_header "Processing token contracts"
+source "$SCRIPT_DIR/process_token_contracts.sh"
+
+print_header "Processing AMM contracts"
+source "$SCRIPT_DIR/process_amm_contracts.sh"
+
+print_header "Processing NFT contracts"
+source "$SCRIPT_DIR/process_nft_contracts.sh"
+
+print_header "Marking setup of new accounts / contracts to be completed"
+source "$SCRIPT_DIR/mark_setup_completed.sh"

spartan/devnet-smoke-tests/mark_setup_completed.sh

@@ -0,0 +1,5 @@
+# Update contracts to set needs_setup=false for all contracts and accounts
+jq '.contracts = (.contracts | map(. + {needs_setup: false}))' state.json > temp.json && mv temp.json state.json
+jq '.accounts = (.accounts | map(. + {needs_setup: false}))' state.json > temp.json && mv temp.json state.json
+
+echo "Updated all contracts and accounts in state.json with needs_setup=false"