jeremylongshore/tons-of-skills-marketplace / plugins/crypto/wallet-security-auditor/skills/auditing-wallet-security
auditing-wallet-security
VerifiedAudit wallet security by analyzing token approvals, permissions, and transaction patterns. Use when checking wallet security, reviewing approvals, or assessing risk exposure. Trigger with phrases like "audit wallet", "check approvals", "security scan", or "revoke tokens".
| File | Kind | Size |
|---|---|---|
| ARD.md | markdown | 5.5 KB |
| PRD.md | markdown | 2.0 KB |
| SKILL.md | skill md | 6.8 KB |
| config/settings.yaml | config | 4.5 KB |
| references/errors.md | markdown | 6.1 KB |
| references/examples.md | markdown | 13.5 KB |
| references/implementation.md | markdown | 1.5 KB |
| scripts/approval_scanner.py | script | 12.3 KB |
| scripts/formatters.py | script | 16.5 KB |
| scripts/risk_scorer.py | script | 12.1 KB |
| scripts/tx_analyzer.py | script | 17.8 KB |
| scripts/wallet_auditor.py | script | 17.6 KB |
scripts/formatters.py
View on GitHub#!/usr/bin/env python3
"""
Output Formatters for Wallet Security Auditor
Format security audit results for display.
Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 1.0.0
License: MIT
"""
import json
from dataclasses import asdict
from typing import List, Any
from decimal import Decimal
from approval_scanner import TokenApproval, ApprovalSummary
from risk_scorer import SecurityScore, RiskFactor, Recommendation
class DecimalEncoder(json.JSONEncoder):
"""JSON encoder that handles Decimal types."""
def default(self, obj):
if isinstance(obj, Decimal):
return str(obj)
return super().default(obj)
def format_address(address: str, length: int = 10) -> str:
"""Format address for display."""
if len(address) <= length * 2 + 2:
return address
return f"{address[:length]}...{address[-8:]}"
def format_allowance(allowance: Decimal, is_unlimited: bool) -> str:
"""Format allowance for display."""
if is_unlimited:
return "UNLIMITED"
if allowance >= 1_000_000_000:
return f"{allowance / 1_000_000_000:.2f}B"
if allowance >= 1_000_000:
return f"{allowance / 1_000_000:.2f}M"
if allowance >= 1_000:
return f"{allowance / 1_000:.2f}K"
return f"{allowance:.4f}"
def format_risk_badge(severity: str) -> str:
"""Format risk severity badge."""
badges = {
"critical": "[CRITICAL]",
"high": "[HIGH]",
"medium": "[MEDIUM]",
"low": "[LOW]",
"info": "[INFO]",
}
return badges.get(severity.lower(), "[UNKNOWN]")
def format_score_bar(score: int, width: int = 20) -> str:
"""Format score as visual bar."""
filled = int((score / 100) * width)
empty = width - filled
if score >= 80:
char = "█"
elif score >= 50:
char = "▓"
elif score >= 30:
char = "▒"
else:
char = "░"
return f"[{char * filled}{'·' * empty}] {score}/100"
def format_approvals_table(approvals: List[TokenApproval], show_all: bool = False, max_rows: int = 20) -> str:
"""Format approvals as ASCII table.
Args:
approvals: List of token approvals
show_all: Show all approvals (ignore max_rows)
max_rows: Maximum rows to display
Returns:
Formatted table string
"""
if not approvals:
return "No active approvals found."
display_approvals = approvals if show_all else approvals[:max_rows]
# Header
lines = [
"",
"┌" + "─" * 12 + "┬" + "─" * 25 + "┬" + "─" * 18 + "┬" + "─" * 10 + "┐",
"│ {:^10} │ {:^23} │ {:^16} │ {:^8} │".format("Token", "Spender", "Allowance", "Risk"),
"├" + "─" * 12 + "┼" + "─" * 25 + "┼" + "─" * 18 + "┼" + "─" * 10 + "┤",
]
for approval in display_approvals:
spender_display = approval.spender_name or format_address(approval.spender, 8)
allowance_display = format_allowance(approval.allowance, approval.is_unlimited)
risk_display = ""
if approval.is_risky:
risk_display = "RISKY"
elif approval.is_unlimited:
risk_display = "UNLIM"
else:
risk_display = "OK"
lines.append(
"│ {:>10} │ {:>23} │ {:>16} │ {:^8} │".format(
approval.token_symbol[:10],
spender_display[:23],
allowance_display[:16],
risk_display,
)
)
lines.append("└" + "─" * 12 + "┴" + "─" * 25 + "┴" + "─" * 18 + "┴" + "─" * 10 + "┘")
if not show_all and len(approvals) > max_rows:
lines.append(f"\n... and {len(approvals) - max_rows} more approvals")
return "\n".join(lines)
def format_approval_summary(summary: ApprovalSummary) -> str:
"""Format approval summary statistics.
Args:
summary: ApprovalSummary data
Returns:
Formatted summary string
"""
lines = [
"",
"═══════════════════════════════════════════════════════════════════",
" APPROVAL SUMMARY ",
"═══════════════════════════════════════════════════════════════════",
"",
f" Total Active Approvals: {summary.total_approvals}",
f" Unlimited Approvals: {summary.unlimited_approvals}",
f" Risky Approvals: {summary.risky_approvals}",
f" Unique Spenders: {summary.unique_spenders}",
f" Unique Tokens: {summary.unique_tokens}",
"",
]
if summary.unlimited_approvals > 0:
lines.append(f" ⚠️ {summary.unlimited_approvals} unlimited approval(s) detected")
if summary.risky_approvals > 0:
lines.append(f" 🚨 {summary.risky_approvals} risky approval(s) detected")
lines.append("═══════════════════════════════════════════════════════════════════")
return "\n".join(lines)
def format_security_score(score: SecurityScore) -> str:
"""Format security score report.
Args:
score: SecurityScore data
Returns:
Formatted report string
"""
# Risk level colors/indicators
level_indicators = {
"critical": "🔴 CRITICAL",
"high": "🟠 HIGH",
"medium": "🟡 MEDIUM",
"low": "🟢 LOW",
"safe": "✅ SAFE",
}
level_display = level_indicators.get(score.risk_level, score.risk_level.upper())
lines = [
"",
"╔═══════════════════════════════════════════════════════════════════╗",
"║ WALLET SECURITY SCORE ║",
"╠═══════════════════════════════════════════════════════════════════╣",
"║ ║",
f"║ Overall Score: {format_score_bar(score.total_score):<40} ║",
f"║ Risk Level: {level_display:<40} ║",
"║ ║",
"╠═══════════════════════════════════════════════════════════════════╣",
"║ Component Scores: ║",
f"║ Approvals: {format_score_bar(score.approval_score):<40} ║",
f"║ Interactions: {format_score_bar(score.interaction_score):<40} ║",
f"║ Patterns: {format_score_bar(score.pattern_score):<40} ║",
"║ ║",
"╚═══════════════════════════════════════════════════════════════════╝",
]
return "\n".join(lines)
def format_risk_factors(factors: List[RiskFactor], max_display: int = 10) -> str:
"""Format risk factors list.
Args:
factors: List of risk factors
max_display: Maximum factors to show
Returns:
Formatted factors string
"""
if not factors:
return "\nNo risk factors identified."
lines = [
"",
"═══════════════════════════════════════════════════════════════════",
" RISK FACTORS ",
"═══════════════════════════════════════════════════════════════════",
]
for i, factor in enumerate(factors[:max_display], 1):
badge = format_risk_badge(factor.severity)
lines.extend(
[
"",
f" {i}. {badge} {factor.description}",
f" Category: {factor.category}",
]
)
if factor.affected_items:
lines.append(f" Affected: {', '.join(factor.affected_items[:3])}")
if factor.mitigation:
lines.append(f" Action: {factor.mitigation}")
lines.append(f" Impact: {factor.score_impact:+d} points")
if len(factors) > max_display:
lines.append(f"\n ... and {len(factors) - max_display} more factors")
lines.append("\n═══════════════════════════════════════════════════════════════════")
return "\n".join(lines)
def format_recommendations(recommendations: List[Recommendation]) -> str:
"""Format recommendations list.
Args:
recommendations: List of recommendations
Returns:
Formatted recommendations string
"""
if not recommendations:
return "\nNo recommendations at this time."
priority_icons = {
1: "🚨",
2: "⚠️",
3: "💡",
4: "ℹ️",
}
lines = [
"",
"═══════════════════════════════════════════════════════════════════",
" RECOMMENDATIONS ",
"═══════════════════════════════════════════════════════════════════",
]
for rec in recommendations:
icon = priority_icons.get(rec.priority, "•")
lines.extend(
[
"",
f" {icon} Priority {rec.priority}: {rec.action}",
f" Reason: {rec.reason}",
]
)
if rec.items:
lines.append(" Items:")
for item in rec.items[:5]:
lines.append(f" - {item}")
lines.append("\n═══════════════════════════════════════════════════════════════════")
return "\n".join(lines)
def format_full_report(
address: str, chain: str, summary: ApprovalSummary, score: SecurityScore, explorer_url: str = ""
) -> str:
"""Format complete security audit report.
Args:
address: Wallet address
chain: Chain name
summary: Approval summary
score: Security score
explorer_url: Block explorer URL
Returns:
Full formatted report
"""
lines = [
"",
"╔═══════════════════════════════════════════════════════════════════╗",
"║ WALLET SECURITY AUDIT REPORT ║",
"╚═══════════════════════════════════════════════════════════════════╝",
"",
f" Address: {address}",
f" Chain: {chain.capitalize()}",
]
if explorer_url:
lines.append(f" Explorer: {explorer_url}/address/{address}")
lines.append("")
# Add security score
lines.append(format_security_score(score))
# Add approval summary
lines.append(format_approval_summary(summary))
# Add approvals table
lines.append("\n--- Active Approvals ---")
lines.append(format_approvals_table(summary.approvals))
# Add risk factors
if score.risk_factors:
lines.append(format_risk_factors(score.risk_factors))
# Add recommendations
if score.recommendations:
lines.append(format_recommendations(score.recommendations))
# Footer
lines.extend(
[
"",
"═══════════════════════════════════════════════════════════════════",
" Report generated by Wallet Security Auditor",
" For detailed analysis, use: wallet_auditor.py scan --verbose",
"═══════════════════════════════════════════════════════════════════",
]
)
return "\n".join(lines)
def format_revoke_list(approvals: List[TokenApproval]) -> str:
"""Format list of approvals to revoke.
Args:
approvals: List of approvals to revoke
Returns:
Formatted revoke list
"""
if not approvals:
return "No approvals recommended for revocation."
lines = [
"",
"═══════════════════════════════════════════════════════════════════",
" REVOKE RECOMMENDATIONS ",
"═══════════════════════════════════════════════════════════════════",
"",
" The following approvals should be reviewed and potentially revoked:",
"",
]
for i, approval in enumerate(approvals, 1):
spender_display = approval.spender_name or format_address(approval.spender)
risk_indicator = " 🚨 RISKY" if approval.is_risky else ""
lines.extend(
[
f" {i}. {approval.token_symbol} → {spender_display}{risk_indicator}",
f" Token: {approval.token_address}",
f" Spender: {approval.spender}",
]
)
if approval.is_unlimited:
lines.append(" Amount: UNLIMITED (max uint256)")
else:
lines.append(f" Amount: {format_allowance(approval.allowance, False)}")
if approval.risk_reason:
lines.append(f" Risk: {approval.risk_reason}")
lines.append("")
lines.extend(
[
" To revoke, use:",
" - revoke.cash",
" - Etherscan Token Approval Checker",
" - Your wallet's built-in approval manager",
"",
"═══════════════════════════════════════════════════════════════════",
]
)
return "\n".join(lines)
def to_json(data: Any, indent: int = 2) -> str:
"""Convert data to JSON string.
Args:
data: Data to convert (dataclass or dict)
indent: JSON indentation
Returns:
JSON string
"""
if hasattr(data, "__dataclass_fields__"):
data = asdict(data)
return json.dumps(data, indent=indent, cls=DecimalEncoder)
def main():
"""Test formatters."""
from approval_scanner import ApprovalScanner
from risk_scorer import RiskScorer
print("=== Formatter Test ===")
# Create mock data
scanner = ApprovalScanner(chain="ethereum", verbose=True)
test_address = "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"
print(f"Scanning {test_address[:20]}...")
summary = scanner.get_all_approvals(test_address)
print(format_approval_summary(summary))
print(format_approvals_table(summary.approvals))
# Calculate score
scorer = RiskScorer()
score = scorer.get_total_score(summary)
print(format_security_score(score))
print(format_risk_factors(score.risk_factors))
print(format_recommendations(score.recommendations))
if __name__ == "__main__":
main()
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |