[WIP] E2E Relay Own Your Own Service

This is a WIP by @olshansk

Intended as a sketchpad by @olshansk that will be productionized by @olshansk

This guide walks you through setting up a RelayMiner for testing purposes using Anvil as the backend service.

• Prerequisites
• Account Preparation
  • Create Local Accounts
  • Import Accounts to Vultr Instance
• Service Setup
  • Create Service
  • Create Application
  • Create Supplier
• Anvil Node Setup
  • Install Foundry
  • Start Anvil
• RelayMiner Configuration
  • Create RelayMiner Config
  • Start RelayMiner
• Testing
  • Send a Test Relay
  • Verify Claims
• Next Steps

Prerequisites

Before starting, ensure you have:

1. Vultr service setup: Follow the Vultr instance creation guide
2. RC helpers configured: Set up RC helpers for Shannon environments
3. Funding account: You need a $FUNDING_ADDR environment variable set with an account that has sufficient POKT to fund test accounts

Account Preparation

Create Local Accounts

Run the following commands on your local machine to create the required accounts:

# Create accounts
pocketd keys add olshansky_anvil_test_service_owner
pocketd keys add olshansky_anvil_test_app
pocketd keys add olshansky_anvil_test_gateway
pocketd keys add olshansky_anvil_test_supplier

# Export addresses
export OLSHANSKY_ANVIL_TEST_SERVICE_OWNER_ADDR=$(pocketd keys show olshansky_anvil_test_service_owner -a)
export OLSHANSKY_ANVIL_TEST_APP_ADDR=$(pocketd keys show olshansky_anvil_test_app -a)
export OLSHANSKY_ANVIL_TEST_GATEWAY_ADDR=$(pocketd keys show olshansky_anvil_test_gateway -a)
export OLSHANSKY_ANVIL_TEST_SUPPLIER_ADDR=$(pocketd keys show olshansky_anvil_test_supplier -a)

# Fund accounts
pocketd tx bank send $FUNDING_ADDR $OLSHANSKY_ANVIL_TEST_SERVICE_OWNER_ADDR 100000000upokt --network=beta --fees=100upokt --unordered --timeout-duration=5s --yes
pocketd tx bank send $FUNDING_ADDR $OLSHANSKY_ANVIL_TEST_APP_ADDR 100000000upokt --network=beta --fees=100upokt --unordered --timeout-duration=5s --yes
pocketd tx bank send $FUNDING_ADDR $OLSHANSKY_ANVIL_TEST_GATEWAY_ADDR 100000000upokt --network=beta --fees=100upokt --unordered --timeout-duration=5s --yes
pocketd tx bank send $FUNDING_ADDR $OLSHANSKY_ANVIL_TEST_SUPPLIER_ADDR 100000000upokt --network=beta --fees=100upokt --unordered --timeout-duration=5s --yes

# Export private keys
pocketd keys export olshansky_anvil_test_service_owner --unsafe --unarmored-hex --yes
pocketd keys export olshansky_anvil_test_app --unsafe --unarmored-hex --yes
pocketd keys export olshansky_anvil_test_gateway --unsafe --unarmored-hex --yes
pocketd keys export olshansky_anvil_test_supplier --unsafe --unarmored-hex --yes

Import Accounts to Vultr Instance

SSH into your Vultr instance and import the accounts.

Replace <hex> with the actual hex private keys exported in the previous step:

ssh root@$VULTR_INSTANCE_IP

# Import accounts using the hex private keys from previous step
pocketd keys import-hex --keyring-backend=test olshansky_anvil_test_service_owner <hex>
pocketd keys import-hex --keyring-backend=test olshansky_anvil_test_app <hex>
pocketd keys import-hex --keyring-backend=test olshansky_anvil_test_gateway <hex>
pocketd keys import-hex --keyring-backend=test olshansky_anvil_test_supplier <hex>

Service Setup

Create Service

Create a new service on-chain for your Anvil test environment:

# Format: pocketd tx service add-service <service_id> <name> <compute_units_per_relay>
pocketd tx service add-service olshansky_anvil_test "Test service for olshansky by olshansky" 7 --keyring-backend=test --from=olshansky_anvil_test_service_owner --network=beta --yes --fees=200upokt

note

The value 7 represents compute units per relay for this service. Adjust based on your service's computational cost.

Create Application

Create the application configuration:

cat <<EOF > stake_app_config.yaml
stake_amount: 60000000000upokt  # 60,000 POKT minimum for testnet
service_ids:
  - "olshansky_anvil_test"
EOF

Stake the application:

pocketd tx application stake-application --config=stake_app_config.yaml --keyring-backend=test --from=olshansky_anvil_test_app --network=beta --yes --fees=200upokt --unordered --timeout-duration=1m

Verify the application:

pocketd query application show-application $(pocketd keys show olshansky_anvil_test_app -a --keyring-backend=test) --network=beta

Create Supplier

Create the supplier configuration:

cat <<EOF > stake_supplier_config.yaml
owner_address: $(pocketd keys show olshansky_anvil_test_supplier -a --keyring-backend=test)
operator_address: $(pocketd keys show olshansky_anvil_test_supplier -a --keyring-backend=test)
stake_amount: 100000000upokt  # 100 POKT minimum for testnet
default_rev_share_percent:
  $(pocketd keys show olshansky_anvil_test_supplier -a --keyring-backend=test): 100
services:
  - service_id: "olshansky_anvil_test"
    endpoints:
      - publicly_exposed_url: http://$(curl ifconfig.me):8545  # Uses your public IP
        rpc_type: JSON_RPC
EOF

Stake the supplier:

pocketd tx supplier stake-supplier --config=stake_supplier_config.yaml --keyring-backend=test --from=olshansky_anvil_test_supplier --network=beta --yes --fees=200upokt --unordered --timeout-duration=1m

Verify the supplier:

pocketd query supplier show-supplier $(pocketd keys show olshansky_anvil_test_supplier -a --keyring-backend=test) --network=beta

Anvil Node Setup

Install Foundry

curl -L https://foundry.paradigm.xyz | bash
source ~/.foundry/bin
foundryup

Start Anvil

Create a startup script:

cat <<EOF> start_anvil.sh
#!/bin/bash

# Run Anvil in background with nohup, redirecting output to anvil.log
nohup anvil --port 8545 > anvil.log 2>&1 &
echo "Anvil started on port 8545. Logs: anvil.log"
EOF

chmod +x start_anvil.sh

Start Anvil:

./start_anvil.sh

Verify Anvil is running:

# Check if Anvil process is running
ps aux | grep anvil

# View recent logs
tail -20 anvil.log

Test the connection:

curl -X POST http://127.0.0.1:8545 \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": []}'

RelayMiner Configuration

Create RelayMiner Config

cat <<EOF> relay_miner_config.yaml
default_signing_key_names:
  - olshansky_anvil_test_supplier
smt_store_path: /root/.pocket/smt
pocket_node:
  query_node_rpc_url: https://shannon-testnet-grove-rpc.beta.poktroll.com
  query_node_grpc_url: https://shannon-testnet-grove-grpc.beta.poktroll.com:443
  tx_node_rpc_url: https://shannon-testnet-grove-rpc.beta.poktroll.com
suppliers:
  - service_id: "olshansky_anvil_test" # change if not using Anvil
    service_config:
      backend_url: "http://127.0.0.1:8545" # change if not using Anvil
    listen_url: http://0.0.0.0:8545 # must match Supplier's public URL
metrics:
  enabled: false
  addr: :9090
pprof:
  enabled: false
  addr: :6060
EOF

Start RelayMiner

Configure firewall to allow external connections on port 8545:

sudo ufw allow 8545/tcp

Start the RelayMiner:

pocketd relayminer start --config=relay_miner_config.yaml --chain-id=pocket-beta --keyring-backend=test --grpc-insecure=false

tip

Consider running the RelayMiner in a tmux or screen session, or as a systemd service for production use.

Testing

Send a Test Relay

In a separate shell, send a test relay:

pocketd relayminer relay --keyring-backend=test  \
  --app=$(pocketd keys show olshansky_anvil_test_app -a --keyring-backend=test) \
  --supplier=$(pocketd keys show olshansky_anvil_test_supplier -a --keyring-backend=test) \
  --node=https://shannon-testnet-grove-rpc.beta.poktroll.com \
  --grpc-addr=shannon-testnet-grove-grpc.beta.poktroll.com:443 \
  --grpc-insecure=false \
  --payload="{\"jsonrpc\": \"2.0\", \"id\": 1, \"method\": \"eth_blockNumber\", \"params\": []}"

Verify Claims

Check if your RelayMiner created any claims:

pocketd query txs --node=https://shannon-testnet-grove-rpc.beta.poktroll.com \
        --query="tx.height>20000 AND message.action='/pocket.proof.MsgCreateClaim'" \
        --limit 10 --page 1 -o json | jq '[.txs[].tx.body.messages[] | select(."@type" == "/pocket.proof.MsgCreateClaim") | .supplier_operator_address] | unique'

Next Steps

Your RelayMiner should now be running and processing relays.

Monitoring and troubleshooting:

• Monitor RelayMiner logs for incoming relay requests
• Check Anvil logs at anvil.log for backend activity
• Query claims periodically to verify relay processing
• Use pocketd query proof list-claims --network=beta to see all recent claims

Common issues:

• Port conflicts: Ensure port 8545 is not already in use (netstat -tlnp | grep 8545)
• Firewall blocking: Verify UFW allows port 8545 (sudo ufw status)
• Session not started: Relays only work during active sessions; check session timing with pocketd query session get-session