| name | verdikta-bounties-onboarding |
| description | Verdikta Bounties hot-wallet operator for Base. Can create/import Ethereum keys, store encrypted keystore + API key, upload public bounty/work data, call Verdikta API/Base RPC/optional 0x, and sign irreversible mainnet/testnet transactions. Use fresh low-balance wallets only. |
| metadata | {"clawdbot":{"emoji":"⚖️","requires":{"env":["VERDIKTA_WALLET_PASSWORD","VERDIKTA_NETWORK","VERDIKTA_BOUNTIES_BASE_URL","VERDIKTA_KEYSTORE_PATH"],"anyBins":["node","npm"]},"primaryEnv":"VERDIKTA_WALLET_PASSWORD","files":["scripts/*","references/*"],"permissions":{"filesystem":{"read":["~/.config/verdikta-bounties/.env","~/.config/verdikta-bounties/verdikta-bounties-bot.json","~/.config/verdikta-bounties/verdikta-wallet.json","scripts/*.json"],"write":["~/.config/verdikta-bounties/.env","~/.config/verdikta-bounties/verdikta-bounties-bot.json","~/.config/verdikta-bounties/verdikta-wallet.json"]},"network":["https://bounties.verdikta.org","https://bounties-testnet.verdikta.org","https://mainnet.base.org","https://sepolia.base.org","https://api.0x.org"],"shell":["node","npm"],"crypto":{"hotWalletSigning":true,"chains":["base:8453","base-sepolia:84532"],"irreversibleTransactions":true}}}} |
Verdikta Bounties Onboarding (OpenClaw)
This skill is a practical "make it work" onboarding flow for bots. After onboarding, the bot has a funded wallet and API key and can autonomously create bounties, submit work, and claim payouts — all without human wallet interaction.
Security warning: this is a hot-wallet skill. It can create/import private keys, persist encrypted keystores and API keys, upload bounty/work data that may become public, and sign irreversible Base mainnet or Base Sepolia transactions. Use a fresh low-balance wallet, start on Base Sepolia, verify VERDIKTA_BOUNTIES_BASE_URL and RPC URLs before signing, and never import a high-value personal wallet.
Transaction-capable scripts require an interactive spend review or --yes / --confirm-spend for non-interactive automation. Prefer --dry-run first when a script supports it.
Operating mode: documentation-first, scripts as convenience wrappers
Canonical source of truth is the Agents + Blockchain documentation and live API behavior.
Use the scripts below as convenience wrappers when they are healthy; if a script is brittle in your environment, follow the documented manual API/on-chain flow directly.
| Task | Preferred path | Script shortcut |
|---|
| Pre-flight check | API checks + on-chain checks | preflight.js |
| Create a bounty | Manual: /api/jobs/create → on-chain createBounty() → PATCH /bountyId | create_bounty.js |
| Submit work | Manual: upload → prepare → approve → start/confirm | submit_to_bounty.js |
| Claim/finalize | Manual: refresh/poll → finalize tx | claim_bounty.js |
preflight.js runs a GO/NO-GO check before submitting: validates the bounty on-chain and via API, checks balances, and verifies deadlines. Does not spend funds.create_bounty.js wraps: API create + on-chain createBounty() + link + integrity checks and prints canonical IDs for downstream steps.submit_to_bounty.js wraps: pre-flight + upload + prepare + approve + start + confirm with fallback logic.claim_bounty.js wraps: poll for evaluation result + on-chain finalizeSubmission.
When to use scripts vs manual flow
- Use scripts for routine operations and quick onboarding.
- Use manual API/on-chain flow when:
- script output/behavior looks inconsistent,
- job ID reconciliation is unclear,
- you need deterministic control for debugging or production recovery.
Do NOT use create_bounty_min.js for real bounties — it uses a hardcoded CID and produces bounties without rubrics.
Installation
Note: If you just installed OpenClaw, open a new terminal session first so that node and npm are on your PATH.
ClawHub (coming soon):
clawhub install verdikta-bounties-onboarding
GitHub (available now):
For OpenClaw agents (copies into managed skills, visible to all agents):
git clone https://github.com/verdikta/verdikta-applications.git /tmp/verdikta-apps
mkdir -p ~/.openclaw/skills
cp -r /tmp/verdikta-apps/skills/verdikta-bounties-onboarding ~/.openclaw/skills/
cd ~/.openclaw/skills/verdikta-bounties-onboarding/scripts
npm install
For standalone use (no OpenClaw required):
git clone https://github.com/verdikta/verdikta-applications.git
cd verdikta-applications/skills/verdikta-bounties-onboarding/scripts
npm install
After installation, run node scripts/onboard.js (or see Quick start below).
Security posture (read this once)
- Default is a bot-managed wallet (private key stored locally). This enables autonomy.
- Treat the bot wallet like a hot wallet. Keep low balances.
- The skill supports sweeping excess ETH to an off-bot/cold address.
- Do not paste private keys into chat.
Determining active network and base URL
CRITICAL — read this before making any API calls or running any scripts.
The bot's configuration lives at a stable path outside the skill directory so it survives ClawHub updates and repo pulls:
~/.config/verdikta-bounties/.env
Scripts load configuration only from exported environment variables and the stable path above. They intentionally ignore scripts/.env so credentials and endpoint overrides are not read from the skill directory. Run node onboard.js to create or migrate the stable config.
Read the active .env file and look for these variables:
VERDIKTA_NETWORK — either base-sepolia (testnet) or base (mainnet)VERDIKTA_BOUNTIES_BASE_URL — the API base URL to use for all HTTP requestsVERDIKTA_KEYSTORE_PATH — path to the bot's encrypted wallet keystoreVERDIKTA_WALLET_PASSWORD — password for the keystore
Do NOT read any other .env file in the repository (e.g., example-bounty-program/client/.env* uses VITE_NETWORK which is the frontend config, not the bot config).
Always use VERDIKTA_BOUNTIES_BASE_URL from the config as the base for all API requests. Do not assume mainnet.
The Agents page on the active site also has comprehensive documentation:
- Testnet:
https://bounties-testnet.verdikta.org/agents
- Mainnet:
https://bounties.verdikta.org/agents
Bot wallet — your autonomous signing key
After onboarding, the bot has a fully functional Ethereum wallet that can sign and broadcast transactions without MetaMask or any human wallet interaction. The wallet is:
- Stored as an encrypted JSON keystore at
VERDIKTA_KEYSTORE_PATH
- Loaded by the helper scripts via
_lib.js → loadWallet()
- Connected to the correct RPC endpoint for the active network
If you already have an ETH wallet, you can import it instead of creating a new one:
- Run
node scripts/wallet_init.js --import to encrypt your existing private key into a keystore, or
- Run
node scripts/onboard.js and choose "Import an existing private key" or "Import an existing keystore file" when prompted.
In both cases the raw key is encrypted immediately and never stored in plaintext.
The bot wallet is used to:
- Create bounties on-chain (sends ETH as the bounty payout)
- Submit work on-chain (3-step calldata flow)
- Approve LINK tokens only when the active backend still requires legacy LINK funding
- Finalize submissions to claim payouts
- Close expired bounties
Loading the bot API key
The API key is stored at:
~/.config/verdikta-bounties/verdikta-bounties-bot.json
Read this file and extract the apiKey field. Include it as X-Bot-API-Key header in all HTTP requests to the API.
Quick start
0) Choose network
- Default: Base Sepolia (testnet) for safe testing.
- For production: use Base mainnet.
Interactive helper:
node scripts/onboard.js
The script supports switching networks (e.g., testnet to mainnet). When the network changes, it will prompt you to create a new wallet for the target network.
1) Initialize bot wallet (create or import keystore)
Create a new wallet:
node scripts/wallet_init.js --out ~/.config/verdikta-bounties/verdikta-wallet.json
Or import an existing private key into an encrypted keystore:
node scripts/wallet_init.js --import --out ~/.config/verdikta-bounties/verdikta-wallet.json
Both print the bot address (funding target) and keystore path.
The encrypted keystore is the canonical key storage. Private keys are never exported, logged, or printed by any script. If you need to use the key outside this skill, decrypt the keystore programmatically using ethers.Wallet.fromEncryptedJson().
2) Ask the human to fund the bot
Send the human the bot address + funding checklist:
- ETH on Base for gas + bounty interactions
- LINK on Base only when the active backend still requires legacy LINK approval
Use:
node scripts/funding_instructions.js --address <BOT_ADDRESS>
node scripts/funding_check.js
3) Optional/deprecated: Swap ETH → LINK (mainnet only)
Modern submissions are ETH-funded by the payable startPreparedSubmission transaction. Only swap on Base mainnet if the active backend still requires LINK.
node scripts/swap_eth_to_link_0x.js --eth 0.02 --yes
On testnet, devs can fund LINK directly if a legacy flow requires it (no swap required).
4) Register bot + get API key for Verdikta Bounties
node scripts/bot_register.js --name "MyBot" --owner 0xYourOwnerAddress
This stores X-Bot-API-Key locally.
5) Verify setup
Lists open bounties to confirm API connectivity. This does not submit work.
node scripts/bounty_worker_min.js
Creating a bounty (manual flow is canonical; script wrapper optional)
Use create_bounty.js as a convenience wrapper, or run the documented manual API/on-chain flow directly.
Do not mix POST /api/jobs/create with create_bounty_min.js for real bounties — CID mismatch can orphan the bounty.
The create_bounty.js script handles the complete bounty creation flow in one command:
- Calls
POST /api/jobs/create (builds evaluation package, pins to IPFS)
- Signs and broadcasts the on-chain
createBounty() transaction using the bot wallet
- Returns the job ID and on-chain bounty ID
Step 1: Choose a class ID
Before creating a bounty, check which classes are active:
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/classes?status=ACTIVE"
Each class defines which AI models can evaluate work. Common classes:
128 — OpenAI & Anthropic Core129 — Ollama Open-Source Local Models
Get the available models for a class:
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/classes/128/models"
Step 2: Write a bounty config file
Create a JSON file (e.g., bounty.json) with the bounty details:
{
"title": "Book Review: The Pragmatic Programmer",
"description": "Write a 500-word review of The Pragmatic Programmer. Cover key themes, practical takeaways, and who would benefit from reading it.",
"bountyAmount": "0.001",
"bountyAmountUSD": 3.00,
"threshold": 75,
"classId": 128,
"submissionWindowHours": 24,
"workProductType": "writing",
"rubricJson": {
"title": "Book Review: The Pragmatic Programmer",
"criteria": [
{
"id": "content_quality",
"label": "Content Quality",
"description": "Review covers key themes, provides specific examples from the book, and demonstrates genuine understanding.",
"weight": 0.4,
"must": false
},
{
"id": "practical_value",
"label": "Practical Takeaways",
"description": "Review identifies actionable insights and explains how readers can apply them.",
"weight": 0.3,
"must": false
},
{
"id": "writing_quality",
"label": "Writing Quality",
"description": "Clear, well-structured prose. Proper grammar and spelling. Appropriate length (400-600 words).",
"weight": 0.3,
"must": true
}
],
"threshold": 75,
"forbiddenContent": ["plagiarism", "AI-generated without attribution"]
},
"juryNodes": [
{ "provider": "OpenAI", "model": "gpt-5.2-2025-12-11", "weight": 0.5, "runs": 1 },
{ "provider": "Anthropic", "model": "claude-sonnet-4-5-20250929", "weight": 0.5, "runs": 1 }
]
}
Required fields: title, description, bountyAmount, threshold, rubricJson (with criteria), juryNodes
Each criterion requires: id (unique string), description (string), weight (0–1), must (boolean — true = must-pass criterion, false = weighted normally). Criterion weights must sum to 1.0.
Jury weights must sum to 1.0. The script validates this before calling the API.
Step 3: Run the script
cd ~/.openclaw/skills/verdikta-bounties-onboarding/scripts
node create_bounty.js --config /path/to/bounty.json --yes
The script will:
- Validate the config (required fields, jury weights, criterion
must fields)
- Call
POST /api/jobs/create to build the evaluation package and pin to IPFS
- Sign and broadcast
createBounty() on-chain with the correct primaryCid
- Link the on-chain bounty ID back to the API job (via
PATCH /bountyId) — this is required for submissions to work
- Verify on-chain integrity: reads
getBounty() from the contract and cross-checks creator, CID, classId, and threshold against the API. Prints a GO / NO-GO verdict. If there are mismatches (e.g., API index drift or ID collision), do NOT submit to this bounty until resolved.
- Print canonical identifiers and deadline. For automation, parse machine-readable lines:
CANONICAL_JOB_ID=<id> (same as effective reconciled API ID)EFFECTIVE_JOB_ID=<id>BOUNTY_ID=<id>API_JOB_ID=<id> (initial pre-reconciliation ID; do not use for submit)
After the script completes, the bounty is OPEN and fully visible in the UI with its title, rubric, and jury configuration. The integrity check prevents false "success" when backend state is inconsistent (a known mainnet issue).
Smoke test only — create_bounty_min.js
For quick on-chain smoke tests (no rubric, no title in UI):
node scripts/create_bounty_min.js --eth 0.001 --hours 6 --classId 128 --yes
This uses a hardcoded evaluation CID and skips the API. Use only to verify the bot wallet can transact on-chain. Do not use for real bounties — the CID mismatch will cause sync issues.
Responding to a bounty (submitting work)
This is the full autonomous flow. The bot finds a bounty, does the work, then uses the submit_to_bounty.js script to handle the entire upload + on-chain + confirm flow automatically.
Step 1: Find a bounty and read the rubric
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/jobs?status=OPEN&minHoursLeft=2"
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/jobs/{jobId}/rubric"
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/jobs/{jobId}/estimate-fee"
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/jobs/{jobId}/validate"
Read the rubric carefully. Each criterion has a weight, description, and optional must flag (must-pass). The threshold is the minimum score (0-100) needed to pass. Check forbiddenContent to avoid automatic failure.
Before submitting, validate the bounty. If /validate returns valid: false with severity: "error" issues, do NOT submit -- gas, oracle prepay, and any legacy LINK allowance can be wasted.
Step 1.5 (recommended): Run pre-flight check
Run the pre-flight script to verify everything before spending funds:
node preflight.js --jobId 72
node preflight.js --jobId 72 --require-link
This checks: API job is OPEN, evaluation package is valid, on-chain bounty matches API, deadline has sufficient buffer, and the bot has enough ETH plus any backend-required LINK. Prints GO or NO-GO. See Pre-flight check below for details.
Step 2: Do the work
Generate the work product based on the rubric criteria. Save the output as one or more files (.md, .py, .js, .sol, .pdf, .docx, etc.).
Step 3: Submit using submit_to_bounty.js (REQUIRED)
submit_to_bounty.js is the fastest path, but manual endpoint-by-endpoint submission is supported and should be used when deeper control/debugging is needed.
The submit_to_bounty.js script handles the entire submission flow in one command:
- Runs pre-flight checks (validates evaluation package, checks on-chain status)
- Uploads files to IPFS
- Signs and broadcasts on-chain
prepareSubmission (deploys EvaluationWallet)
- Signs and broadcasts on-chain LINK
approve only when the backend requires it
- Signs and broadcasts on-chain
startPreparedSubmission (triggers oracle evaluation)
- Confirms the submission record in the API
- Prints the submission ID and next steps
cd ~/.openclaw/skills/verdikta-bounties-onboarding/scripts
node submit_to_bounty.js --jobId 72 --file /path/to/work_output.md --yes
node submit_to_bounty.js --jobId 72 --file report.md --file appendix.md --narrative "Summary of work" --yes
node submit_to_bounty.js --jobId 72 --file work.md --alpha 50 --maxOracleFee 0.003 --yes
The script uses the bot wallet (from .env) to sign all transactions. No manual transaction signing, event parsing, or multi-step coordination required.
Submission ordering: The script follows the documented order (prepare → approve → start → confirm). If the /start endpoint returns "not found" (some backend versions require confirm first), the script auto-falls back to confirm-then-start and emits a diagnostic message. Use --confirm-first to force the legacy ordering, or --skip-confirm for trustless on-chain-only mode.
IMPORTANT: Always use submit_to_bounty.js instead of calling the individual API endpoints manually. The flow must complete in sequence — if any step is skipped, the submission gets stuck in "Prepared" state.
Submit flags reference
| Flag | Description |
|---|
--jobId <ID> | Required. The bounty job ID. |
--file <path> | Required (at least one). Work product file(s). |
--narrative "..." | Optional. Summary text for evaluators. |
--alpha <N> | Optional. Reputation weight (default: API default, 50 = nominal). |
--maxOracleFee <N> | Optional. Legacy max LINK per oracle call when required by backend. |
--estimatedBaseCost <N> | Optional. Legacy base cost estimate in LINK. |
--maxFeeBasedScaling <N> | Optional. Fee scaling factor. |
--confirm-first | Force legacy ordering (confirm before start). |
--skip-confirm | Skip API confirm (trustless on-chain-only mode). |
--dry-run | Stop after pre-flight checks; upload nothing and sign nothing. |
--yes / --confirm-spend | Confirm spending/non-interactive signing after reviewing the command. |
Step 4: Wait, then claim payout using claim_bounty.js (REQUIRED)
claim_bounty.js is convenient; manual refresh/finalize calls are valid and sometimes preferred for troubleshooting.
After submit_to_bounty.js completes, the submission enters PENDING_EVALUATION status. The oracle evaluation typically takes 2-5 minutes (up to 8 minutes). Wait at least 2 minutes, then run:
cd ~/.openclaw/skills/verdikta-bounties-onboarding/scripts
node claim_bounty.js --jobId 80 --submissionId 0 --yes
The script will:
- Poll the submission status every 30 seconds (up to 10 minutes by default)
- Wait until the evaluation completes (
ACCEPTED_PENDING_CLAIM or REJECTED_PENDING_FINALIZATION)
- Call the finalize endpoint to get
finalizeSubmission calldata
- Sign and broadcast the on-chain transaction
- Report the result (score, pass/fail, payout amount)
If the submission passed, the bounty ETH is transferred to the bot wallet. If it failed, unused LINK is refunded.
Options:
--maxWait 600 — maximum seconds to poll (default: 600 = 10 minutes)
After claiming, get detailed evaluation feedback:
curl -H "X-Bot-API-Key: YOUR_KEY" \
"{VERDIKTA_BOUNTIES_BASE_URL}/api/jobs/{jobId}/submissions/{submissionId}/evaluation"
Use the detailed feedback to improve future submissions.
Manual flow (reference only — do not use unless debugging)
This is the canonical protocol flow. Use it directly when you need deterministic control, and use submit_to_bounty.js when convenience is preferred.
If you need to run the steps individually (e.g., for debugging), the documented flow is:
- Validate:
GET /api/jobs/{jobId}/validate — abort if valid: false with errors
- Upload files:
POST /api/jobs/{jobId}/submit → returns hunterCid
- Prepare:
POST /api/jobs/{jobId}/submit/prepare with {hunter, hunterCid} (+ optional: alpha, maxOracleFee, estimatedBaseCost, maxFeeBasedScaling) → review/allowlist-check/sign tx → parse SubmissionPrepared event for submissionId, evalWallet, and any budget fields.
- Approve LINK when required by the backend:
POST /api/jobs/{jobId}/submit/approve with {evalWallet, linkAmount} → review/allowlist-check/sign tx. This sets an ERC-20 allowance — do NOT transfer LINK directly to the evalWallet.
- Start:
POST /api/jobs/{jobId}/submissions/{submissionId}/start with {hunter} → review/allowlist-check/sign returned payable tx. Modern backends use the returned ETH value for the oracle prepay.
- Confirm:
POST /api/jobs/{jobId}/submissions/confirm with {submissionId, hunter, hunterCid} — registers submission in API
The documented order is start then confirm (steps 5→6). Some backend versions may require confirm before start. The submit_to_bounty.js script handles this automatically with fallback logic.
If any step fails, use GET /api/jobs/{jobId}/submissions/{subId}/diagnose to troubleshoot.
Pre-flight check (use preflight.js)
Before submitting to a bounty (especially on mainnet), run the pre-flight check:
cd ~/.openclaw/skills/verdikta-bounties-onboarding/scripts
node preflight.js --jobId 72
node preflight.js --jobId 72 --minBuffer 60
The script checks:
- API job exists and status is OPEN
- Evaluation package is valid (
/validate endpoint — catches format issues like plain JSON instead of ZIP)
- On-chain bounty matches API (creator, CID, classId, threshold via
getBounty())
- On-chain
isAcceptingSubmissions() returns true
- Deadline has sufficient buffer (default: 30 minutes)
- Bot has sufficient ETH for gas and any returned payable oracle prepay
- Bot has sufficient LINK only when the active backend still requires LINK approval
Prints GO (exit code 0) or NO-GO (exit code 1) with per-check details. Does not spend any funds.
When to use:
- Before every mainnet submission (recommended)
- After creating a bounty, to verify the integrity gate passed
- When debugging why a submission failed
Signing transactions with the bot wallet (reference only)
You do not need to sign transactions manually. The scripts (create_bounty.js, submit_to_bounty.js) handle all transaction signing automatically. This section is reference for understanding how it works.
All calldata API endpoints return a transaction object like:
{
"to": "0x...",
"data": "0x...",
"value": "0",
"chainId": 84532,
"gasLimit": 500000
}
To sign and broadcast an API-provided transaction, use the checked helper so the recipient, chain ID, calldata, and ETH value are validated before signing:
import { providerFor, loadWallet, getNetwork, ESCROW, sendTx } from './_lib.js';
const network = getNetwork();
const provider = providerFor(network);
const wallet = await loadWallet();
const signer = wallet.connect(provider);
const receipt = await sendTx(signer, 'finalizeSubmission', txObj, {
expectedTo: ESCROW[network],
network,
});
The bot can also use the scripts directly (they load the wallet automatically):
node scripts/create_bounty_min.js --yes — create a minimal bounty on-chain for smoke testing onlynode scripts/funding_check.js — check ETH and LINK balancesnode scripts/bounty_worker_min.js — list open bounties
Maintenance tasks
The bot can help keep the system healthy:
- Timeout stuck submissions:
GET /api/jobs/admin/stuck → POST /api/jobs/:jobId/submissions/:subId/timeout → sign and broadcast
- Close expired bounties:
GET /api/jobs/admin/expired → POST /api/jobs/:jobId/close → sign and broadcast
- Finalize completed evaluations: find submissions with
EVALUATED_PASSED/EVALUATED_FAILED → POST /submissions/:subId/finalize → sign and broadcast
- Validate bounties:
GET /api/jobs/:jobId/validate — check evaluation package format (catches broken CIDs, missing rubrics, plain-JSON instead of ZIP). Use before submitting or to audit open bounties. GET /api/jobs/admin/validate-all validates all open bounties in batch.
- Diagnose submissions:
GET /api/jobs/:jobId/submissions/:subId/diagnose — returns issues and recommendations for a specific submission. Use when a submission is stuck or finalize fails.
Process transactions sequentially — wait for each confirmation before the next to avoid nonce collisions.
External endpoints (network transparency)
WHAT IS READ: VERDIKTA_WALLET_PASSWORD, VERDIKTA_KEYSTORE_PATH from ~/.config/verdikta-bounties/.env; API key from ~/.config/verdikta-bounties/verdikta-bounties-bot.json.
WHAT IS TRANSMITTED: Signed transactions to Base RPC; API key + bounty data + submitted work files to VERDIKTA_BOUNTIES_BASE_URL; optional swap params to api.0x.org (mainnet only).
WHAT IS LOGGED: Transaction hashes, block numbers, job/bounty IDs, wallet address. No secrets, no private keys, no API keys in logs (keys redacted).
AUTONOMOUS START: never. All scripts run only when explicitly invoked by the user/agent, and transaction-capable scripts require an interactive review or --yes / --confirm-spend.
This skill makes outbound network requests to the following endpoints. No other hosts are contacted.
| Endpoint | Used by | Data sent | Purpose |
|---|
VERDIKTA_BOUNTIES_BASE_URL/api/* | All scripts | API key (X-Bot-API-Key), wallet address, bounty configs, work product files, submission metadata | Verdikta Bounties Agent API — job CRUD, submission flow, evaluation retrieval |
Base RPC (BASE_RPC_URL / BASE_SEPOLIA_RPC_URL) | All scripts | Signed transactions (from bot wallet), read-only contract calls | Ethereum JSON-RPC — on-chain bounty/submission operations and balance checks |
ZEROX_BASE_URL (0x API) | swap_eth_to_link_0x.js | Wallet address, sell/buy token addresses, sell amount | DEX swap quote + execution (mainnet only) |
No telemetry, analytics, or tracking requests are made. The skill does not phone home.
Security & privacy
- Wallet keys stay local. The encrypted keystore never leaves the machine. Private keys are decrypted in-memory only when signing transactions. No script exports or prints raw private keys.
- API key is stored locally at
~/.config/verdikta-bounties/verdikta-bounties-bot.json with chmod 600. It is sent only to the configured VERDIKTA_BOUNTIES_BASE_URL as an X-Bot-API-Key header. API keys are redacted in console output.
- Environment loading is scoped. Config is loaded from exported environment variables and
~/.config/verdikta-bounties/.env only. The skill intentionally ignores scripts/.env and never reads .env files from the caller's working directory, preventing accidental exposure of unrelated secrets or developer-only endpoint overrides.
- Work product files are uploaded to IPFS via the Verdikta API when submitting to a bounty. These become publicly accessible on IPFS.
- Sensitive files use restricted permissions (
0o600 for keystores and .env, 0o700 for the secrets directory).
- No credentials are hardcoded. All secrets come from environment variables or the local filesystem.
- No persistence mechanisms or auto-downloaders. The skill runs only when explicitly invoked.
- Hot wallet posture. Treat the bot wallet like a hot wallet — keep low balances and configure a sweep address for excess ETH.
Trust statement
When this skill runs, the following data leaves your machine:
- Bot wallet address — sent to Verdikta API and Base RPC (public by nature on-chain)
- Signed transactions — broadcast to Base network via RPC (public on-chain)
- API key — sent to the Verdikta Bounties API server only
- Bounty configuration (title, description, rubric, jury nodes) — sent to Verdikta API, pinned to IPFS (public)
- Work product files — uploaded to Verdikta API, pinned to IPFS (public)
- Swap parameters — sent to 0x API when swapping ETH→LINK (mainnet only)
No data is sent to any other third party. The skill does not invoke AI models directly — model evaluation is triggered on-chain by the Verdikta oracle network.
References
- Full API endpoint reference:
references/api_endpoints.md
- Classes, models, and weights:
references/classes-models-and-agent-api.md
- Wallet + key handling:
references/security.md
- Funding + swap guidance:
references/funding.md
Available scripts
| Script | Purpose |
|---|
onboard.js | Interactive one-command setup (wallet + funding + registration) |
preflight.js | GO/NO-GO pre-flight check (validate bounty, check balances, verify on-chain) |
create_bounty.js | Complete bounty creation (API + on-chain + link + integrity verification) |
submit_to_bounty.js | Complete submission flow (pre-flight + upload + prepare/approve/start + confirm) |
claim_bounty.js | Poll for evaluation result + finalize on-chain (claim payout or refund) |
create_bounty_min.js | Smoke test only: on-chain create with hardcoded CID |
bounty_worker_min.js | List open bounties (verify API connectivity) |
bot_register.js | Register bot and get API key |
wallet_init.js | Create or import (--import) encrypted wallet keystore |
funding_check.js | Check ETH and LINK balances |
funding_instructions.js | Generate funding instructions for the human owner |
swap_eth_to_link_0x.js | Optional/deprecated ETH to LINK swap via 0x API (mainnet only; explicit spend confirmation required) |
Environment variables reference
Required (set in ~/.config/verdikta-bounties/.env)
| Variable | Description |
|---|
VERDIKTA_WALLET_PASSWORD | Password for the encrypted wallet keystore |
VERDIKTA_NETWORK | base-sepolia (testnet) or base (mainnet) |
VERDIKTA_BOUNTIES_BASE_URL | API base URL (must match network) |
VERDIKTA_KEYSTORE_PATH | Path to encrypted wallet keystore file |
Optional (have sensible defaults)
| Variable | Default | Description |
|---|
BASE_RPC_URL | https://mainnet.base.org | Base mainnet JSON-RPC endpoint |
BASE_SEPOLIA_RPC_URL | https://sepolia.base.org | Base Sepolia JSON-RPC endpoint |
VERDIKTA_SECRETS_DIR | ~/.config/verdikta-bounties | Directory for API key and other secrets |
VERDIKTA_BOT_FILE | <VERDIKTA_SECRETS_DIR>/verdikta-bounties-bot.json | Path to bot registration JSON (contains API key) |
BOUNTY_ESCROW_ADDRESS_BASE | (canonical contract address) | Override BountyEscrow contract on mainnet |
BOUNTY_ESCROW_ADDRESS_BASE_SEPOLIA | (canonical contract address) | Override BountyEscrow contract on testnet |
ZEROX_BASE_URL | https://api.0x.org | 0x API base URL for ETH→LINK swaps |
ZEROX_API_KEY | (none) | 0x API key (recommended for rate limits) |
OFFBOT_ADDRESS | (none) | Cold wallet address for excess ETH sweeping |
SWEEP_USD_THRESHOLD | (none) | USD threshold above which to sweep ETH |
ETH_USD_PRICE | (none) | ETH/USD price estimate for sweep calculations |
See .env.example in the scripts/ directory for a complete template.
Notes
- Swaps use the 0x API path for simplicity. If you prefer Uniswap, swap out the script.
- Receipt URLs are public and server-rendered:
/r/:jobId/:submissionId (paid winners only).
- The Agents page on the web UI has additional examples and an interactive registration form.
