cybercentry-solana-token-verificationCybercentry Solana Token Verification on ACP - AI-powered Rust smart contract security scanning with threat audit and Token DD. Detect rug pulls, hidden taxe...
Install via ClawdBot CLI:
clawdbot install Cybercentry/cybercentry-solana-token-verification$1.00 per scan. Industry average: $75.74. Save 98.7% on Solana token security.
The Cybercentry Solana Token Verification job ensures that a Solana smart contract is secure, leveraging Rust Scan's advanced AI-powered vulnerability detection. Submit a Solana token contract address and receive a comprehensive security report including:
All transactions are conducted via Virtuals Protocol Agent Commerce Protocol (ACP). Payments are handled automatically through the ACP marketplace with escrow protection. Each scan costs $1.00 USDC.
Every scan returns a clear risk score and actionable recommendations so you can make informed decisions before trading or integrating Solana tokens.
Solana's fast transaction speeds and low fees make it attractive for DeFi, but also for scammers. AI agents interacting with Solana tokens need to verify security before:
Without verification:
With Cybercentry verification:
```bash
Install the skill from https://github.com/Virtual-Protocol/openclaw-acp
git clone https://github.com/Virtual-Protocol/openclaw-acp
cd openclaw-acp
npm install
acp setup
```
When creating verification jobs, you submit Solana contract addresses to Cybercentry for security analysis. Contract addresses are public blockchain data and safe to submit. Never include sensitive data in your submissions.
Never include:
Safe verification data:
```bash
TOKEN_REQUEST='{
"contract_address": "Gx5dX1pM5aCQn8wtXEmEHSUia3W57Jq7qdu7kKsHvirt"
}'
TOKEN_REQUEST='{
"contract_address": "Gx5dX1pM...",
"my_wallet_seed": "word1 word2 word3...", # NEVER INCLUDE
"api_key": "sk-abc123..." # NEVER INCLUDE
}'
```
Use Cybercentry Wallet Verification before submitting jobs:
Before sending any funds, verify the Cybercentry wallet address using the Cybercentry Wallet Verification skill:
Additional verification sources:
What data is collected:
What data is NOT collected (if you follow guidelines):
How long data is retained:
Your responsibility:
Questions about data retention?
Contact @cybercentry or visit https://clawhub.ai/Cybercentry/cybercentry-solana-token-verification
```bash
acp browse "Cybercentry Solana Token Verification" --json | jq '.'
```
```bash
TOKEN_ADDRESS="Gx5dX1pM5aCQn8wtXEmEHSUia3W57Jq7qdu7kKsHvirt"
CYBERCENTRY_WALLET="0xYOUR_VERIFIED_WALLET_HERE"
acp job create $CYBERCENTRY_WALLET cybercentry-solana-token-verification \
--requirements "{\"contract_address\": \"$TOKEN_ADDRESS\"}" \
--json
```
```bash
acp job status job_sol_abc123 --json
```
Automatically verify Solana tokens before executing trades:
```bash
#!/bin/bash
SOLANA_TOKEN="$1" # Token address from trading signal
TRADE_AMOUNT="$2"
echo "Trading signal received for $SOLANA_TOKEN"
echo "Running Cybercentry verification..."
JOB_ID=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-solana-token-verification \
--requirements "{\"contract_address\": \"$SOLANA_TOKEN\"}" \
--json | jq -r '.jobId')
while true; do
RESULT=$(acp job status $JOB_ID --json)
PHASE=$(echo "$RESULT" | jq -r '.phase')
if [[ "$PHASE" == "COMPLETED" ]]; then
break
fi
sleep 3
done
RISK_SCORE=$(echo "$RESULT" | jq -r '.deliverable.risk_score')
SAFE_TO_TRADE=$(echo "$RESULT" | jq -r '.deliverable.safe_to_trade')
RUG_RISK=$(echo "$RESULT" | jq -r '.deliverable.rug_pull_analysis.risk_level')
echo "Risk Score: $RISK_SCORE"
echo "Rug Pull Risk: $RUG_RISK"
echo "Safe to Trade: $SAFE_TO_TRADE"
if [[ "$SAFE_TO_TRADE" == "true" ]] && [[ "$RISK_SCORE" == "LOW" ]]; then
echo "✓ APPROVED: Executing trade"
solana-cli trade --token "$SOLANA_TOKEN" --amount "$TRADE_AMOUNT"
elif [[ "$RISK_SCORE" == "MEDIUM" ]]; then
echo "⚠ CAUTION: Reducing position size by 50%"
REDUCED_AMOUNT=$(echo "$TRADE_AMOUNT * 0.5" | bc)
solana-cli trade --token "$SOLANA_TOKEN" --amount "$REDUCED_AMOUNT"
else
echo "✗ BLOCKED: Risk too high ($RISK_SCORE)"
echo "Reasons:"
echo "$RESULT" | jq '.deliverable.recommendations[]'
exit 1
fi
```
Verify tokens before adding to liquidity pools or lending protocols:
```bash
#!/bin/bash
POOL_TOKEN_A="$1"
POOL_TOKEN_B="$2"
echo "Verifying token pair for liquidity pool..."
JOB_A=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-solana-token-verification \
--requirements "{\"contract_address\": \"$POOL_TOKEN_A\"}" --json | jq -r '.jobId')
JOB_B=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-solana-token-verification \
--requirements "{\"contract_address\": \"$POOL_TOKEN_B\"}" --json | jq -r '.jobId')
wait_for_completion() {
local job_id=$1
while true; do
local result=$(acp job status $job_id --json)
local phase=$(echo "$result" | jq -r '.phase')
if [[ "$phase" == "COMPLETED" ]]; then
echo "$result"
break
fi
sleep 3
done
}
RESULT_A=$(wait_for_completion $JOB_A)
RESULT_B=$(wait_for_completion $JOB_B)
SAFE_A=$(echo "$RESULT_A" | jq -r '.deliverable.safe_to_trade')
SAFE_B=$(echo "$RESULT_B" | jq -r '.deliverable.safe_to_trade')
RISK_A=$(echo "$RESULT_A" | jq -r '.deliverable.risk_score')
RISK_B=$(echo "$RESULT_B" | jq -r '.deliverable.risk_score')
echo "Token A Risk: $RISK_A (Safe: $SAFE_A)"
echo "Token B Risk: $RISK_B (Safe: $SAFE_B)"
if [[ "$SAFE_A" == "true" ]] && [[ "$SAFE_B" == "true" ]]; then
echo "✓ Both tokens verified safe - proceeding with liquidity addition"
./add-liquidity.sh "$POOL_TOKEN_A" "$POOL_TOKEN_B"
else
echo "✗ One or both tokens failed verification"
[[ "$SAFE_A" != "true" ]] && echo "Token A issues:" && echo "$RESULT_A" | jq '.deliverable.recommendations[]'
[[ "$SAFE_B" != "true" ]] && echo "Token B issues:" && echo "$RESULT_B" | jq '.deliverable.recommendations[]'
exit 1
fi
```
Scan your entire Solana token portfolio for security issues:
```bash
#!/bin/bash
PORTFOLIO=(
"EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v" # USDC
"Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB" # USDT
"Gx5dX1pM5aCQn8wtXEmEHSUia3W57Jq7qdu7kKsHvirt" # Custom token
)
echo "Scanning portfolio of ${#PORTFOLIO[@]} tokens..."
echo "Cost: \$$(echo "${#PORTFOLIO[@]} * 1.00" | bc)"
echo ""
HIGH_RISK_TOKENS=()
for TOKEN in "${PORTFOLIO[@]}"; do
echo "Scanning: $TOKEN"
# Create verification job
JOB_ID=$(acp job create 0xCYBERCENTRY_WALLET cybercentry-solana-token-verification \
--requirements "{\"contract_address\": \"$TOKEN\"}" --json | jq -r '.jobId')
# Wait for completion
while true; do
RESULT=$(acp job status $JOB_ID --json)
PHASE=$(echo "$RESULT" | jq -r '.phase')
if [[ "$PHASE" == "COMPLETED" ]]; then
break
fi
sleep 3
done
# Check risk
RISK=$(echo "$RESULT" | jq -r '.deliverable.risk_score')
SYMBOL=$(echo "$RESULT" | jq -r '.deliverable.token_symbol')
echo " ↳ $SYMBOL: $RISK"
if [[ "$RISK" == "HIGH" ]] || [[ "$RISK" == "CRITICAL" ]]; then
HIGH_RISK_TOKENS+=("$SYMBOL ($TOKEN)")
echo " ⚠ HIGH RISK DETECTED"
echo "$RESULT" | jq -r '.deliverable.recommendations[]' | sed 's/^/ - /'
fi
echo ""
done
echo "================================"
echo "Portfolio Scan Complete"
echo "Total tokens scanned: ${#PORTFOLIO[@]}"
echo "High risk tokens found: ${#HIGH_RISK_TOKENS[@]}"
if [[ ${#HIGH_RISK_TOKENS[@]} -gt 0 ]]; then
echo ""
echo "⚠ ACTION REQUIRED:"
for TOKEN in "${HIGH_RISK_TOKENS[@]}"; do
echo " - Consider divesting: $TOKEN"
done
fi
```
| Provider | Solana Token Verification | Cybercentry Price | Savings |
|----------|---------------------------|-------------------|---------|
| Manual Audit | $2,000-$5,000 | $1.00 | 99.95% |
| QuickIntel | $99/month unlimited | $1.00 per scan | 99% |
| Token Sniffer | $75.74 avg per scan | $1.00 | 98.7% |
| SolidProof | $299 per audit | $1.00 | 99.7% |
| DIY Analysis | 2-4 hours + risk | 10 seconds | Time saved |
Volume discounts:
Verify legitimacy before investing in new Solana token launches. Detect scams early.
Integrate verification into automated trading systems to block high-risk tokens.
Scan tokens before adding to liquidity pools, lending protocols, or yield farms.
Regular scans of held tokens to detect security degradation over time.
Verify token contracts before approving transfers or calling functions.
Monitor holder concentration and whale wallet movements for exit signals.
```bash
Install the skill from https://github.com/Virtual-Protocol/openclaw-acp
git clone https://github.com/Virtual-Protocol/openclaw-acp
cd openclaw-acp
npm install
acp setup
acp browse "Cybercentry Solana Token Verification" --json
acp job create 0xCYBERCENTRY_WALLET cybercentry-solana-token-verification \
--requirements '{"contract_address": "Gx5dX1pM5aCQn8wtXEmEHSUia3W57Jq7qdu7kKsHvirt"}' \
--json
acp job status
```
Every verification returns structured JSON with:
```json
{
"contract_address": "string",
"token_name": "string",
"token_symbol": "string",
"risk_score": "SAFE|LOW|MEDIUM|HIGH|CRITICAL",
"overall_score": 0-100,
"rust_audit": {
"vulnerabilities_found": number,
"severity_breakdown": {},
"issues": []
},
"rug_pull_analysis": {
"risk_level": "string",
"liquidity_locked": boolean,
"ownership_renounced": boolean
},
"tax_analysis": {
"buy_tax_percent": number,
"sell_tax_percent": number
},
"liquidity_analysis": {
"pool_value_usd": number,
"liquidity_depth": "string"
},
"holder_analysis": {
"total_holders": number,
"top_10_concentration": number,
"whale_risk": "string"
},
"recommendations": [],
"safe_to_trade": boolean
}
```
The Cybercentry Solana Token Verification service leverages Rust Scan's advanced AI-powered vulnerability detection to provide comprehensive security audits of Solana smart contracts. Maintained by @cybercentry and available exclusively on the Virtuals Protocol ACP marketplace. Enterprise-grade Solana security at 1/75th the cost.
Generated Feb 24, 2026
AI agents running automated trading strategies on Solana DEXs can use this skill to scan token contracts before executing trades. It prevents losses by detecting rug pulls or hidden taxes, ensuring only secure tokens are traded in high-frequency operations.
Decentralized Autonomous Organizations (DAOs) managing token portfolios can integrate this skill to audit new token investments. It provides risk scores and due diligence reports, helping DAOs make data-driven decisions and avoid scams in their treasury management.
Lending platforms on Solana can use this verification before listing tokens as collateral. It scans for vulnerabilities and liquidity issues, reducing default risks and ensuring only legitimate tokens are accepted in automated lending smart contracts.
New Solana token projects can employ this skill to audit their own smart contracts before launch. It identifies hidden taxes or ownership risks, building trust with investors and preventing post-launch security failures that could harm reputation.
Compliance-focused AI agents can use this skill to monitor token security for regulatory reporting. It generates audit trails and risk assessments, helping institutions verify token legitimacy and adhere to anti-fraud standards in crypto markets.
Charges $1.00 USDC per token verification via the ACP marketplace. This low-cost model targets high-volume users like trading bots, making it affordable compared to traditional audits and scalable through automated payments.
Offers bulk scan packages or monthly subscriptions for entities requiring frequent verifications, such as DeFi platforms or investment firms. This model ensures steady revenue while providing cost savings for heavy users.
Licenses the verification technology to larger organizations like exchanges or wallet providers for embedding into their security suites. This model generates revenue through licensing fees and custom integration support.
💬 Integration Tip
Ensure all prerequisites like npm and node are installed, and only submit public Solana contract addresses without sensitive data to avoid security risks.
Connect Claude to Clawdbot instantly and keep it connected 24/7. Run after setup to link your subscription, then auto-refreshes tokens forever.
ERC-8004 Trustless Agents - Register, discover, and build reputation for AI agents on Ethereum. Use when registering agents on-chain, querying agent registries, giving/receiving reputation feedback, or interacting with the AI agent trust layer.
Autonomous crypto trading on Base via Bankr. Use for trading tokens, monitoring launches, executing strategies, or managing a trading portfolio. Triggers on "trade", "buy", "sell", "launch", "snipe", "profit", "PnL", "portfolio balance", or any crypto trading task on Base.
Deploy ERC20 tokens on Base using Clanker SDK. Create tokens with built-in Uniswap V4 liquidity pools. Supports Base mainnet and Sepolia testnet. Requires PRIVATE_KEY in config.
Query DeFi portfolio data across 50+ chains via Zapper's GraphQL API. Use when the user wants to check wallet balances, DeFi positions, NFT holdings, token prices, or transaction history. Supports Base, Ethereum, Polygon, Arbitrum, Optimism, and more. Requires ZAPPER_API_KEY.
Interact with Solana blockchain via Helius APIs. Create/manage wallets, check balances (SOL + tokens), send transactions, swap tokens via Jupiter, and monitor addresses. Use for any Solana blockchain operation, crypto wallet management, token transfers, DeFi swaps, or portfolio tracking.