[WIP] E2E Relay Own Your Own Service

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>

(Direct link to Import Accounts to Vultr Instance: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#import-accounts-to-vultr-instance)

Service Setup

(Direct link to Service Setup: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#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

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

(Direct link to Create Service: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#create-service)

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

(Direct link to Create Application: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#create-application)

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

(Direct link to Create Supplier: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#create-supplier)

Anvil Node Setup

(Direct link to Anvil Node Setup: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#anvil-node-setup)

Install Foundry

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

(Direct link to Install Foundry: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#install-foundry)

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": []}'

(Direct link to Start Anvil: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#start-anvil)

RelayMiner Configuration

(Direct link to RelayMiner Configuration: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#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

(Direct link to Create RelayMiner Config: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#create-relayminer-config)

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

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

(Direct link to Start RelayMiner: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#start-relayminer)

Testing

(Direct link to Testing: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#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\": []}"

(Direct link to Send a Test Relay: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#send-a-test-relay)

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'

(Direct link to Verify Claims: https://dev.poktroll.com/operate/cheat_sheets/relays_to_your_own_service_cheatsheet#verify-claims)

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

PreviousGateway & Application (~30 min)NextIntroduction, Guides & Walkthroughs (Advanced)

Was this helpful?