DEV Community: Wallet Guy

Telegram Bot Approvals: Mobile-First Transaction Signing for AI Agents

Wallet Guy — Sun, 19 Apr 2026 07:50:22 +0000

AI agents with crypto wallets need guardrails, but most developers bolt on security as an afterthought. The result? Agents that can drain wallets, approve unlimited token spending, or execute trades without human oversight when things go wrong.

Why Security-First Matters

The crypto space is littered with stories of smart contracts gone rogue, bots that emptied treasuries, and AI systems that made catastrophic trades. When you give an AI agent direct wallet access, you're essentially handing over the keys to your digital vault to an algorithm that might hallucinate, misinterpret instructions, or get compromised.

Traditional wallet integrations for AI agents follow a "request permission" model—the agent asks for broad access upfront, then operates freely within those bounds. But this approach fails when agents encounter edge cases, when policies need real-time updates, or when humans need to intervene quickly.

3-Layer Security Architecture

WAIaaS implements defense in depth with three security layers: session authentication, policy enforcement with time delays, and human approval channels.

Layer 1: Session Authentication

Every AI agent gets a scoped session token instead of direct wallet access. Sessions have configurable time limits, renewal restrictions, and absolute lifetimes:

curl -X POST http://127.0.0.1:3100/v1/sessions \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "ttl": 3600,
    "maxRenewals": 5,
    "absoluteLifetime": 86400
  }'

The session token (wai_sess_...) provides limited access—agents can query balances and submit transactions, but cannot modify policies, create new wallets, or access master controls.

Layer 2: Policy Engine with Time Delays

The policy engine uses 21 policy types with 4 security tiers: INSTANT, NOTIFY, DELAY, and APPROVAL. The key insight: different transaction amounts and types require different security measures.

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 300,
      "daily_limit_usd": 500
    }
  }'

Small transactions (under $10) execute instantly. Medium transactions ($10-100) execute but trigger notifications. Large transactions ($100-1000) get queued for a 5-minute delay—giving you time to cancel if needed. Anything over $1000 requires explicit human approval.

Layer 3: Human Approval Channels

When transactions exceed policy limits, WAIaaS routes them through human approval channels. The Telegram bot integration provides mobile-first transaction signing, letting you approve or reject agent transactions from anywhere.

Default-Deny Token Policy

The most critical security feature is default-deny for token operations. Without explicit token whitelisting, agents cannot transfer, approve, or interact with any tokens:

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "ALLOWED_TOKENS",
    "rules": {
      "tokens": [
        {"address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "symbol": "USDC", "chain": "solana"}
      ]
    }
  }'

This prevents the classic attack vector where agents interact with malicious tokens or approve unlimited spending on legitimate ones.

Contract Interaction Whitelist

Similarly, smart contract calls are blocked by default unless explicitly allowed:

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "CONTRACT_WHITELIST",
    "rules": {
      "contracts": [
        {"address": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4", "name": "Jupiter", "chain": "solana"}
      ]
    }
  }'

This ensures agents can only interact with DeFi protocols you've explicitly approved, preventing interaction with unverified or malicious contracts.

Telegram Bot Setup for Mobile Approvals

The Telegram signing channel provides secure mobile approvals using the push-relay service. When agents submit transactions requiring approval, you receive a Telegram message with transaction details and approve/reject buttons.

First, configure the Telegram bot credentials and notification setup through the CLI:

waiaas notification setup

This walks you through connecting your Telegram bot and configuring approval workflows. The push-relay service handles secure message delivery while keeping your bot token isolated from the main daemon.

Emergency Controls

Every wallet has an owner authentication system separate from agent sessions. Owner auth uses message signing (SIWS/SIWE) and provides emergency controls:

Kill switch: Instantly revoke all agent sessions
Policy overrides: Bypass policies for urgent transactions
Recovery mode: Regain control if master password is compromised

# Emergency session termination
curl -X DELETE http://127.0.0.1:3100/v1/sessions/<session-id> \
  -H "X-Owner-Signature: <ed25519-or-secp256k1-signature>" \
  -H "X-Owner-Message: <signed-message>"

Transaction Simulation

Before executing any transaction, agents can simulate the outcome using the dry-run API:

curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "TRANSFER",
    "to": "recipient-address",
    "amount": "0.1",
    "dryRun": true
  }'

Simulation shows gas costs, slippage estimates, and potential failures without spending actual funds or gas. This prevents agents from submitting transactions that will fail on-chain.

7-Stage Transaction Pipeline

Every transaction flows through a 7-stage pipeline with validation, authentication, policy enforcement, delays, execution, and confirmation:

Validate: Schema validation, balance checks, network connectivity
Authenticate: Session token verification, permission checks
Policy: Apply all 21 policy types, determine security tier
Wait: Queue transactions requiring delays or approvals
Execute: Submit to blockchain with proper gas estimation
Confirm: Wait for block confirmation, handle failures
Notify: Send notifications based on policy configuration

Each stage can halt the transaction if security conditions aren't met.

Quick Start: Secure Agent Setup

Here's how to set up a security-first AI agent in 5 steps:

Install and initialize WAIaaS:

npm install -g @waiaas/cli
waiaas init
waiaas start

Create wallet with restricted session:

waiaas wallet create --chain solana --environment mainnet
waiaas session create --wallet-id <uuid>

Configure default-deny policies:

# Allow only USDC transfers
curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "ALLOWED_TOKENS",
    "rules": {"tokens": [{"address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "symbol": "USDC", "chain": "solana"}]}
  }'

Set up spending limits:

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 5,
      "notify_max_usd": 50,
      "delay_max_usd": 200,
      "delay_seconds": 600,
      "daily_limit_usd": 100
    }
  }'

Configure Telegram approvals:

waiaas notification setup
# Follow prompts to connect Telegram bot

Your agent now operates within strict guardrails—it can only transfer USDC, amounts over $5 trigger notifications, amounts over $50 require a 10-minute delay, and amounts over $200 need your explicit approval via Telegram.

What's Next

Security isn't a feature you add later—it's a foundation you build on. WAIaaS provides the infrastructure for AI agents that are powerful but not dangerous, autonomous but not uncontrolled.

Ready to build secure AI agents? Check out the full implementation at GitHub or explore the complete security documentation at waiaas.ai.

Argon2id Master Passwords: Securing Your Self-Hosted AI Agent Wallet

Wallet Guy — Sat, 18 Apr 2026 14:05:38 +0000

Securing AI agent wallets with Argon2id master passwords isn't just about hashing—it's about building defense-in-depth around autonomous systems that can move real money. When your AI agent has direct access to crypto wallets, password security becomes the foundation of a multi-layer protection system that includes session controls, policy enforcement, and human oversight channels.

Why Master Password Security Matters for AI Agents

Traditional password security focuses on protecting human access to applications. But AI agent wallets face a different threat model: autonomous systems making financial decisions at machine speed, often without direct human supervision. A compromised master password doesn't just expose user data—it potentially gives attackers control over an AI agent that can drain wallets, approve unlimited token spending, or bypass all security policies.

The stakes are higher because AI agents operate continuously. While a human might log in once per day, an AI agent might authenticate thousands of times, creating more attack surface. And unlike humans, AI agents can't recognize social engineering or suspicious requests—they follow their programming.

WAIaaS Security Architecture: Beyond Just Password Hashing

WAIaaS implements a 3-layer security model where Argon2id master passwords serve as the foundation:

Layer 1: Argon2id Master Authentication
The master password uses Argon2id hashing—the winner of the Password Hashing Competition and the algorithm recommended by OWASP. Unlike bcrypt or PBKDF2, Argon2id resists both time-memory trade-off attacks and GPU/ASIC acceleration.

Layer 2: Session-Based Agent Authentication
AI agents receive JWT tokens with configurable TTL, maxRenewals, and absoluteLifetime. This creates a clear separation: humans control wallet creation and policies via master auth, while agents operate within bounded sessions.

Layer 3: Policy Enforcement and Human Approval
Default-deny policies block transactions unless explicitly allowed. Spending limits trigger 4 security tiers: INSTANT (small amounts), NOTIFY (medium amounts), DELAY (large amounts with cancellation window), and APPROVAL (human authorization required).

Here's how the authentication system works in practice:

# Master auth: Create wallet and set policies (human administrator)
curl -X POST http://127.0.0.1:3100/v1/wallets \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secure-password" \
  -d '{"name": "ai-trading-bot", "chain": "solana", "environment": "mainnet"}'

# Create bounded session for AI agent
curl -X POST http://127.0.0.1:3100/v1/sessions \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secure-password" \
  -d '{"walletId": "<wallet-uuid>", "ttl": 3600, "maxRenewals": 24}'

The AI agent receives a session token that cannot create new wallets, modify policies, or access other wallets:

# Agent can only operate within session bounds
curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_eyJhbGciOiJIUzI1NiJ9..." \
  -d '{
    "type": "TRANSFER",
    "to": "recipient-address",
    "amount": "0.1"
  }'

Policy-Based Protection: Default-Deny by Design

Even with a compromised session token, WAIaaS policies limit damage. The system implements default-deny enforcement: transactions are blocked unless explicitly allowed by policy configuration.

Setting up a spending limit policy with Argon2id-protected master auth:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secure-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 900,
      "daily_limit_usd": 5000
    }
  }'

WAIaaS supports 21 policy types across 4 security tiers. Critical policies include:

ALLOWED_TOKENS: Whitelist specific tokens (blocks transactions to unlisted tokens)
CONTRACT_WHITELIST: Restrict contract interactions to approved addresses
APPROVED_SPENDERS: Control which contracts can receive token approvals
RATE_LIMIT: Prevent transaction spam attacks
TIME_RESTRICTION: Limit agent activity to specific hours

For token transfers, you must explicitly allow each token:

# Without this policy, all token transfers are blocked
curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secure-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "ALLOWED_TOKENS",
    "rules": {
      "tokens": [
        {"address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "symbol": "USDC", "chain": "solana"}
      ]
    }
  }'

Secure Deployment with Docker and Auto-Provisioning

WAIaaS supports secure deployment patterns that protect the Argon2id-hashed master password. For development, you can set passwords manually, but production deployments should use auto-provisioning:

# Auto-generate cryptographically secure master password
docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/minhoyoo-iotrust/waiaas:latest

# Retrieve the generated password (store securely, then delete from container)
docker exec waiaas cat /data/recovery.key

For production environments with secrets management:

# docker-compose.secrets.yml
services:
  daemon:
    secrets:
      - master_password
    environment:
      - WAIAAS_MASTER_PASSWORD_FILE=/run/secrets/master_password

secrets:
  master_password:
    file: ./secrets/master_password.txt

The master password protects wallet private keys, policy configurations, and session management. Even with container access, an attacker cannot decrypt wallet data without the password.

Human-in-the-Loop Approval Channels

For transactions exceeding policy limits, WAIaaS routes approval requests through secure human channels. The system supports 3 signing channels:

WalletConnect: Mobile wallet approval with cryptographic signatures
Telegram Bot: Encrypted approval messages
Push Notifications: Real-time transaction alerts

When an AI agent attempts a large transaction:

# Agent tries to send $5000 (exceeds delay_max_usd from policy above)
curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{"type": "TRANSFER", "to": "...", "amount": "5000"}'

# Response: {"id": "tx_123", "status": "PENDING_APPROVAL", "reason": "SPENDING_LIMIT"}

The transaction enters APPROVAL tier, sending a notification to configured channels. Humans can approve using owner authentication:

# Human approves with cryptographic signature (not master password)
curl -X POST http://127.0.0.1:3100/v1/transactions/tx_123/approve \
  -H "X-Owner-Signature: <ed25519-signature>" \
  -H "X-Owner-Message: <signed-message>"

This creates separation of concerns: master passwords protect system configuration, while owner signatures authorize individual transactions.

Session Management and Token Security

WAIaaS issues JWT tokens using HS256 signing. Session tokens include wallet binding, expiration, and renewal limits:

{
  "walletId": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
  "ttl": 3600,
  "maxRenewals": 24,
  "absoluteLifetime": 86400,
  "permissions": ["TRANSACTION", "BALANCE_READ"]
}

AI agents can renew tokens without master password access, but cannot:

Create new wallets
Modify policies
Access other wallets
Extend beyond absoluteLifetime

Session revocation happens immediately across all API endpoints.

Quick Start: Secure AI Agent Wallet Setup

Install and Initialize with Auto-Provisioning

npm install -g @waiaas/cli
waiaas init --auto-provision  # Generates secure master password
waiaas start

Create Wallet and Security Policies

# Retrieve auto-generated password
waiaas status --show-recovery-key

# Create wallet (uses auto-generated master password)
waiaas wallet create --name ai-agent --chain ethereum --network mainnet

# Set default-deny spending policy
waiaas quickset --mode mainnet  # Creates policies automatically

Deploy with Docker Secrets (Production)

# Generate secure master password
openssl rand -base64 32 > secrets/master_password.txt
chmod 600 secrets/master_password.txt

# Deploy with secrets
docker compose -f docker-compose.yml -f docker-compose.secrets.yml up -d

Create Bounded Session for AI Agent

# Session expires in 1 hour, renewable 24 times, absolute limit 24 hours
waiaas session create --ttl 3600 --max-renewals 24

Configure MCP for Claude/AI Frameworks

waiaas mcp setup --all  # Auto-registers with Claude Desktop

Your AI agent now operates within security boundaries: Argon2id-protected configuration, session-based access, default-deny policies, and human approval for large transactions.

What's Next

Security in AI agent wallets requires ongoing attention as attack vectors evolve. Consider implementing additional monitoring through WAIaaS's transaction pipeline and exploring ERC-8004 onchain reputation systems for agent validation.

WAIaaS is open-source and self-hosted, giving you complete control over your AI agent wallet security. Get started at GitHub or visit waiaas.ai for documentation and deployment guides.

The Rise of Autonomous Economic Machines: AI Agents with Real Purchasing Power

Wallet Guy — Sat, 18 Apr 2026 07:37:47 +0000

AI agents will need to pay for compute, data, and API calls autonomously — but today's payment infrastructure requires human intervention at every step. As AI systems become more capable and independent, they're hitting a fundamental bottleneck: the inability to make economic decisions and payments without human oversight.

Why Autonomous Economic Activity Matters

We're witnessing the emergence of AI agents that can write code, analyze markets, and execute complex workflows. But there's a critical missing piece: economic autonomy. Current AI systems depend entirely on human-controlled payment methods — credit cards, bank accounts, and custodied crypto wallets that require manual approval for every transaction.

This dependency creates a ceiling on agent capabilities. An AI agent that can identify profitable arbitrage opportunities is useless if it can't execute trades. A research agent that can process vast datasets hits a wall when it can't pay for additional compute resources. The bottleneck isn't intelligence — it's economic infrastructure.

The stakes extend beyond convenience. As AI agents become integral to business operations, the inability to operate financially independent systems creates single points of failure. Human gatekeepers become bottlenecks, manual approvals slow critical processes, and the full potential of autonomous systems remains unrealized.

Self-Custodied Infrastructure for Machine Economics

WAIaaS addresses this infrastructure gap by providing genuine wallet autonomy for AI agents. Unlike custodied solutions that require human approval, WAIaaS gives agents direct control over cryptographic keys and transaction execution within policy-defined boundaries.

The architecture centers on three authentication layers that balance autonomy with security:

# sessionAuth — AI agent operates independently
curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Authorization: Bearer wai_sess_eyJhbGciOiJIUzI1NiJ9..." \
  -d '{
    "type": "TRANSFER",
    "to": "merchant-address",
    "amount": "0.1"
  }'

# masterAuth — system configuration (human)
curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 100,
      "daily_limit_usd": 1000
    }
  }'

# ownerAuth — emergency controls (human)
curl -X POST http://127.0.0.1:3100/v1/transactions/<tx-id>/approve \
  -H "X-Owner-Signature: <signature>"

This creates a practical framework where agents operate autonomously within human-defined guardrails. The agent can make thousands of microtransactions without approval, while humans retain ultimate control over spending limits and emergency situations.

x402 Protocol: HTTP Payments for Machine Services

The x402 HTTP payment protocol represents a breakthrough in machine-to-machine commerce. It extends HTTP with standardized payment flows, enabling AI agents to automatically pay for API services, compute resources, and data feeds.

import { WAIaaSClient } from '@waiaas/sdk';

const client = new WAIaaSClient({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN,
});

// Agent pays for API call automatically
const response = await client.x402Fetch('https://api.premium-data.com/market-data', {
  method: 'GET',
  headers: { 'Accept': 'application/json' }
});

// The x402 payment happened transparently:
// 1. API returned 402 Payment Required
// 2. WAIaaS paid the lightning invoice
// 3. API fulfilled the request
// Data is now available without human intervention

This eliminates the friction that prevents true machine-to-machine commerce. Instead of pre-negotiated API keys with monthly billing, agents can discover and pay for services on-demand, opening up entirely new economic models.

DeFi Integration: Agents as Financial Participants

WAIaaS integrates with 15 DeFi protocols, enabling agents to participate directly in decentralized finance. This isn't theoretical — agents can execute sophisticated financial strategies autonomously.

# Agent executes yield farming strategy
curl -X POST http://127.0.0.1:3100/v1/actions/jupiter-swap/swap \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "inputMint": "So11111111111111111111111111111111111111112",
    "outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "amount": "1000000000"
  }'

# Then immediately deploy to lending
curl -X POST http://127.0.0.1:3100/v1/actions/kamino/lend \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "asset": "USDC",
    "amount": "1000"
  }'

Policy controls ensure agents operate within risk parameters:

{
  "type": "PERP_MAX_LEVERAGE",
  "rules": {"maxLeverage": 2.0}
}

The result is AI agents that can manage portfolios, execute arbitrage, and respond to market conditions without human intervention — while remaining constrained by predefined risk limits.

Multi-Chain Economic Participation

Modern economic activity spans multiple blockchains, and agents need to operate across this fragmented landscape. WAIaaS supports 18 networks across Ethereum and Solana ecosystems, with integrated bridging via LI.FI and Across protocols.

# Agent bridges assets across chains automatically
curl -X POST http://127.0.0.1:3100/v1/actions/lifi/bridge \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "fromChain": "ethereum",
    "toChain": "polygon",
    "fromToken": "USDC",
    "toToken": "USDC",
    "amount": "1000"
  }'

This cross-chain capability is crucial for agent autonomy. Economic opportunities don't respect blockchain boundaries, and agents that can move value seamlessly have significant advantages over those constrained to single networks.

Policy-Driven Risk Management

Autonomous economic activity requires sophisticated risk controls. WAIaaS implements 21 policy types across 4 security tiers, creating a framework where agents operate independently while remaining within safe boundaries.

The policy engine follows a default-deny approach — agents can only interact with explicitly approved tokens and contracts:

{
  "type": "ALLOWED_TOKENS",
  "rules": {
    "tokens": [
      {"address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "symbol": "USDC"},
      {"address": "So11111111111111111111111111111111111111112", "symbol": "SOL"}
    ]
  }
}

This creates a practical balance: agents gain genuine autonomy within carefully defined operational boundaries. They can respond to market conditions and execute strategies in real-time, while remaining unable to interact with unauthorized protocols or exceed spending limits.

Real-World Economic Scenarios

Consider a trading agent that discovers an arbitrage opportunity between Jupiter and a centralized exchange. With traditional infrastructure, the agent would need to:

Alert a human operator
Wait for manual verification
Request transaction approval
Execute after the opportunity has likely disappeared

With autonomous wallet infrastructure, the agent:

Detects the arbitrage opportunity
Verifies it meets policy constraints
Executes the trade immediately
Captures the profit within risk parameters

This speed advantage compounds across thousands of micro-opportunities that humans couldn't practically capture manually.

Another scenario: an AI research agent that needs additional compute resources during peak demand. Instead of waiting for human approval to increase cloud spending, the agent can:

Pay for additional GPU time using x402 HTTP payments
Scale compute resources dynamically based on workload
Optimize costs by automatically reducing resources when demand drops
Operate within predefined spending budgets without human intervention

Getting Started with Agent Economics

Setting up autonomous wallet infrastructure for AI agents takes minutes:

Deploy WAIaaS: Use Docker for instant setup

git clone https://github.com/minhoyoo-iotrust/WAIaaS.git
cd WAIaaS
docker compose up -d

Create agent wallet and session:

npx -y @waiaas/cli quickset --mode mainnet

Configure MCP for Claude integration:

npx -y @waiaas/cli mcp setup --all

Set spending policies:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "X-Master-Password: <password>" \
  -d '{"type": "SPENDING_LIMIT", "rules": {"daily_limit_usd": 1000}}'

Test autonomous payments:

const client = new WAIaaSClient({
  sessionToken: process.env.WAIAAS_SESSION_TOKEN
});
const tx = await client.sendToken({to: "recipient", amount: "0.1"});

Your AI agent now has genuine economic autonomy within defined boundaries.

How to Build AI Trading Bots with Real Money Using WAIaaS provides practical examples of agents making profitable trading decisions autonomously. AI Agents That Pay Their Own Bills: x402 HTTP Payments explores how agents can automatically pay for the services they consume.

What's Next

The infrastructure for autonomous economic machines exists today. As more AI agents gain access to genuine wallet autonomy, we'll see the emergence of a machine-driven economy operating parallel to human commerce. The question isn't whether this will happen — it's whether you'll be building the agents that participate in it.

Explore the complete autonomous wallet infrastructure at GitHub and learn more about the economic future of AI at waiaas.ai.

DeFi Provider Health Monitoring: Keep Your AI Agent's Protocols Online

Wallet Guy — Fri, 17 Apr 2026 14:23:54 +0000

DeFi protocol downtime can kill your trading bot's performance before you even know something's wrong. While you're hunting profitable arbitrage opportunities across Jupiter, Drift, and Hyperliquid, a single failing RPC endpoint or protocol maintenance window can leave your bot blind and unable to execute trades.

Why Protocol Health Monitoring Matters for Trading Bots

In algorithmic trading, milliseconds matter. Your bot might identify a perfect arbitrage spread between Solana and Ethereum, but if your Jupiter swap fails due to high slippage or your Hyperliquid position can't close because of API issues, that profitable opportunity becomes a loss. Traditional trading infrastructure forces you to build your own monitoring, retry logic, and failover systems for each protocol.

The stakes get higher with complex strategies. A sophisticated MEV bot might need to: check Aave lending rates, execute a Jupiter swap, open a Drift perpetual position, and bridge funds via LI.FI — all within the same block. If any step fails silently, your entire strategy breaks down.

Built-in Protocol Health Monitoring

WAIaaS provides 15 DeFi protocol providers with automatic health monitoring and failover logic. Instead of building separate integrations for Jupiter, Hyperliquid, Drift, and others, your bot gets unified API access with real-time protocol status tracking.

Here's how to check protocol status before executing trades:

curl http://127.0.0.1:3100/v1/providers/status \
  -H "Authorization: Bearer wai_sess_<token>"

This returns health status for all integrated protocols:

{
  "providers": {
    "jupiter-swap": {
      "status": "healthy",
      "lastChecked": "2024-03-26T15:30:00Z",
      "latency": 45,
      "errorRate": 0.02
    },
    "hyperliquid": {
      "status": "degraded", 
      "lastChecked": "2024-03-26T15:30:00Z",
      "latency": 850,
      "errorRate": 0.15
    },
    "drift": {
      "status": "healthy",
      "latency": 120
    }
  }
}

Your trading bot can adapt strategy based on real-time conditions. If Hyperliquid shows degraded performance, route perpetual trades through Drift instead.

Gas Conditional Execution for Cost-Optimized Trading

High gas fees destroy arbitrage profits. WAIaaS includes gas conditional execution — your transactions only execute when gas prices meet your threshold. Perfect for MEV bots that need precise cost control.

curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "TRANSFER",
    "to": "recipient-address",
    "amount": "0.1",
    "gasCondition": {
      "maxGasPrice": "20000000000",
      "timeout": 3600
    }
  }'

The transaction queues until gas drops below 20 gwei, then executes automatically. Your arbitrage strategy stays profitable even during network congestion.

Multi-Protocol Trading Strategies in One API

Complex trading strategies often span multiple protocols. Here's a Solana arbitrage bot that swaps on Jupiter, then hedges with a Drift perpetual:

# Step 1: Swap SOL to USDC on Jupiter
curl -X POST http://127.0.0.1:3100/v1/actions/jupiter-swap/swap \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "inputMint": "So11111111111111111111111111111111111111112",
    "outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", 
    "amount": "1000000000"
  }'

# Step 2: Open short position on Drift to hedge
curl -X POST http://127.0.0.1:3100/v1/actions/drift/open-position \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "market": "SOL-PERP",
    "side": "short",
    "amount": "1.0",
    "leverage": 5
  }'

Both actions use the same wallet, authentication, and risk controls. No need to manage separate API keys, nonces, or signing logic for each protocol.

Automated Risk Controls for Trading Bots

Trading bots need automated risk management to prevent runaway losses. WAIaaS provides policy-based controls that activate without manual intervention.

Set spending limits with 4-tier security:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT", 
    "rules": {
      "instant_max_usd": 1000,
      "notify_max_usd": 5000,
      "delay_max_usd": 20000,
      "delay_seconds": 300,
      "daily_limit_usd": 50000
    }
  }'

Small trades execute instantly, medium trades trigger notifications, large trades get a 5-minute delay (cancellable), and huge trades require manual approval. Your bot can't drain the wallet even if logic goes wrong.

Add perpetual-specific risk controls:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "PERP_MAX_LEVERAGE",
    "rules": {
      "maxLeverage": 10
    }
  }'

This prevents your bot from opening positions above 10x leverage, regardless of protocol limits.

Real-Time Transaction Monitoring

Trading bots need immediate feedback on transaction status. WAIaaS provides real-time monitoring with detailed execution data:

# Check transaction status
curl http://127.0.0.1:3100/v1/transactions/<tx-id> \
  -H "Authorization: Bearer wai_sess_<token>"

Response includes detailed execution info:

{
  "id": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
  "status": "COMPLETED",
  "txHash": "5KzqQ...",
  "gasUsed": "21000",
  "gasPrice": "15000000000",
  "executedAt": "2024-03-26T15:32:15Z",
  "protocolUsed": "jupiter-swap",
  "slippage": "0.05%"
}

Your bot gets precise execution data for strategy optimization and performance analysis.

Cross-Chain Arbitrage with Automated Bridging

Multi-chain arbitrage requires seamless bridging. WAIaaS integrates LI.FI and Across protocols for automated cross-chain transfers:

curl -X POST http://127.0.0.1:3100/v1/actions/lifi/bridge \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "fromChain": "ethereum",
    "toChain": "polygon", 
    "fromToken": "USDC",
    "toToken": "USDC",
    "amount": "1000.0"
  }'

Your arbitrage bot can move funds between chains automatically, exploiting price differences across ecosystems without manual intervention.

Quick Start for Trading Bot Integration

Get your trading bot connected to WAIaaS in five steps:

Deploy with Docker: docker run -d -p 127.0.0.1:3100:3100 -e WAIAAS_AUTO_PROVISION=true ghcr.io/minhoyoo-iotrust/waiaas:latest
Create trading wallets: Use the CLI to create Solana and Ethereum wallets for your strategies
Set up risk policies: Configure spending limits and protocol-specific controls before funding wallets
Create session tokens: Generate long-lived API tokens for your bot to use
Start trading: Your bot can now execute across 15 DeFi protocols with built-in monitoring and risk controls

The 7-stage transaction pipeline handles validation, authentication, policy checks, and execution automatically. Your bot focuses on strategy while WAIaaS handles infrastructure.

What's Next

WAIaaS provides the wallet infrastructure your trading bot needs: multi-protocol access, automated risk management, and real-time monitoring in one API. Check out the full protocol list and start building more reliable trading strategies.

Get started at GitHub or learn more at waiaas.ai.

Smart Contract Interaction: Calldata Encoding Tools for AI Agents

Wallet Guy — Fri, 17 Apr 2026 08:08:05 +0000

Smart contract interaction for DeFi developers has always been a maze of protocol-specific APIs, custom calldata encoding, and fragmented documentation across 15+ protocols. Whether you're building trading bots, yield strategies, or multi-chain applications, you end up maintaining separate integrations for Jupiter, Aave, Lido, Drift, Hyperliquid, and dozens of other protocols — each with their own quirks, parameters, and ABI formats.

Why Protocol Fragmentation Kills Productivity

The DeFi ecosystem spans multiple chains with incompatible transaction formats. Solana uses different instruction layouts than EVM chains. Jupiter's swap parameters look nothing like Uniswap's. Aave V3 has different method signatures than Compound. Your trading bot ends up with 13 different SDKs, each handling calldata encoding differently.

Then there's the operational overhead: monitoring gas prices across chains, handling failed transactions, managing approvals and slippage, keeping track of which protocols support which tokens. A simple arbitrage strategy becomes 2,000 lines of boilerplate before you write any actual trading logic.

One API for 15 DeFi Protocols

WAIaaS provides a unified interface for DeFi operations across EVM and Solana. Instead of learning Jupiter's API, then Aave's API, then Lido's staking interface, you make the same REST call regardless of the underlying protocol.

Here's swapping SOL for USDC on Jupiter:

curl -X POST http://127.0.0.1:3100/v1/actions/jupiter-swap/swap \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "inputMint": "So11111111111111111111111111111111111111112",
    "outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "amount": "1000000000"
  }'

And here's lending USDC on Aave V3:

curl -X POST http://127.0.0.1:3100/v1/actions/aave-v3/supply \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "asset": "0xA0b86a33E6417c0F4Fe77c96dbD46bb1e4F8a4eE",
    "amount": "1000000000",
    "onBehalfOf": "<wallet-address>"
  }'

Same authentication, same response format, same error handling — whether you're interacting with Solana programs or Ethereum contracts.

15 Protocols, Same Interface

WAIaaS integrates 15 DeFi protocol providers: aave-v3, across, dcent-swap, drift, erc8004, hyperliquid, jito-staking, jupiter-swap, kamino, lido-staking, lifi, pendle, polymarket, xrpl-dex, zerox-swap. Each provider exposes its functionality through the same /v1/actions/{provider}/{action} endpoint.

Want to check your DeFi positions across all protocols?

curl http://127.0.0.1:3100/v1/defi/positions \
  -H "Authorization: Bearer wai_sess_<token>"

This returns lending positions from Aave and Kamino, staking positions from Lido and Jito, perpetual positions from Drift and Hyperliquid, and liquidity positions from DEXs — all in one response.

Smart Calldata Encoding

Behind the scenes, WAIaaS handles the complexity of encoding contract calls correctly. When you call the Aave V3 supply action, WAIaaS encodes the proper ABI call to the Pool contract, handles token approvals automatically, and manages gas estimation.

For more advanced use cases, you can encode arbitrary contract calls directly:

curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "ContractCall",
    "to": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2",
    "data": "0x617ba037000000000000000000000000a0b86a33e6417c0f4fe77c96dbd46bb1e4f8a4ee0000000000000000000000000000000000000000000000000000000077359400"
  }'

The encode-calldata tool lets you build these calls programmatically:

curl -X POST http://127.0.0.1:3100/v1/calldata/encode \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "contractAddress": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2",
    "method": "supply",
    "params": ["0xA0b86a33E6417c0F4Fe77c96dbD46bb1e4F8a4eE", "2000000000", "0x123..."]
  }'

Cross-Chain Operations Made Simple

DeFi strategies often require moving assets between chains. WAIaaS integrates both LI.FI and Across protocols for cross-chain bridging, so you can bridge from Ethereum to Arbitrum and immediately start trading on GMX — all through the same API.

# Bridge USDC from Ethereum to Arbitrum
curl -X POST http://127.0.0.1:3100/v1/actions/lifi/bridge \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "fromChain": "ethereum-mainnet",
    "toChain": "arbitrum-mainnet",
    "fromToken": "0xA0b86a33E6417c0F4Fe77c96dbD46bb1e4F8a4eE",
    "toToken": "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",
    "amount": "1000000000"
  }'

WAIaaS supports 2 chain types (solana, evm) with 18 networks, so your trading strategies can span the entire DeFi ecosystem.

TypeScript SDK for Complex Strategies

For more sophisticated trading bots, the TypeScript SDK provides 40+ methods with full type safety:

import { WAIaaSClient } from '@waiaas/sdk';

const client = new WAIaaSClient({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN,
});

// Execute multiple DeFi actions in sequence
async function yieldStrategy() {
  // 1. Swap ETH for USDC
  const swapTx = await client.executeAction('zerox-swap', 'swap', {
    sellToken: '0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2',
    buyToken: '0xA0b86a33E6417c0F4Fe77c96dbD46bb1e4F8a4eE',
    sellAmount: '1000000000000000000'
  });

  // 2. Supply USDC to Aave
  const lendTx = await client.executeAction('aave-v3', 'supply', {
    asset: '0xA0b86a33E6417c0F4Fe77c96dbD46bb1e4F8a4eE',
    amount: '2000000000',
    onBehalfOf: await client.getAddress()
  });

  // 3. Check new positions
  const positions = await client.getDeFiPositions();
  console.log('New lending APY:', positions.lending[0].apy);
}

The SDK handles authentication, retries, and error parsing automatically. No need to manage HTTP clients, parse API responses, or handle authentication tokens.

Transaction Simulation and Safety

Before executing expensive DeFi transactions, use the dry-run API to simulate outcomes:

curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "ContractCall",
    "to": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2",
    "data": "0x617ba037...",
    "dryRun": true
  }'

This returns gas estimates, potential errors, and expected state changes without broadcasting the transaction. Perfect for testing complex multi-step strategies.

The policy engine adds another layer of protection with 21 policy types. Set spending limits, whitelist approved contracts, or require human approval for large positions:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "CONTRACT_WHITELIST",
    "rules": {
      "contracts": [
        {"address": "0x87870bca3f3fd6335c3f4ce8392d69350b4fa4e2", "name": "Aave Pool", "chain": "ethereum"},
        {"address": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4", "name": "Jupiter", "chain": "solana"}
      ]
    }
  }'

Quick Start for DeFi Developers

Get your unified DeFi API running in 5 minutes:

Start WAIaaS with Docker:

   git clone https://github.com/minhoyoo-iotrust/WAIaaS.git
   cd WAIaaS
   docker compose up -d

Create wallets and sessions:

   npm install -g @waiaas/cli
   waiaas quickset --mode mainnet

Test a DeFi action:

   curl http://127.0.0.1:3100/v1/defi/positions \
     -H "Authorization: Bearer wai_sess_<your-token>"

Install the SDK for your trading bot:

   npm install @waiaas/sdk

Start building cross-protocol strategies using the same API for all 15 providers.

Your next DeFi project just got 10x simpler. One API, 15 protocols, infinite possibilities. Check out the full documentation and source code at GitHub, or explore the interactive API reference at waiaas.ai.

Nonce Management in Multi-Chain AI Agent Transactions

Wallet Guy — Thu, 16 Apr 2026 15:05:32 +0000

Trading bot developers face a critical challenge: managing transaction nonces across multiple blockchains while maintaining execution speed and preventing costly failed transactions. When your arbitrage bot spots an opportunity across Ethereum and Solana simultaneously, nonce conflicts can mean the difference between profit and loss.

Why Nonce Management Breaks Trading Bots

Your trading bot operates in microseconds, but blockchain nonces operate in sequential order. Send two Ethereum transactions with the same nonce? The second fails. Skip a nonce? Your transaction gets stuck behind the gap. Worse, when running multi-chain strategies, you're juggling separate nonce sequences across EVM networks while Solana uses an entirely different transaction model with recent blockhashes.

Most trading bots hack together nonce management with local counters and prayer. When network congestion hits or your bot restarts mid-sequence, those counters desync from reality. Your profitable arbitrage opportunity becomes a series of failed transactions and wasted gas fees.

Built-in Nonce Management for Trading Performance

WAIaaS handles nonce management automatically across 18 networks through its 7-stage transaction pipeline. When your trading bot submits multiple transactions, the pipeline queues them correctly and maintains nonce sequences without conflicts.

The system tracks nonce state per network, automatically increments for pending transactions, and handles the complexity of EVM vs Solana transaction models. Your bot focuses on trading logic while WAIaaS ensures reliable execution.

# Check current nonce state
curl http://127.0.0.1:3100/v1/wallet/nonce \
  -H "Authorization: Bearer wai_sess_<token>"

Multi-Protocol Trading in One API Call

Here's how your arbitrage bot executes a cross-chain strategy without nonce headaches:

# Step 1: Swap SOL → USDC on Jupiter (Solana)
curl -X POST http://127.0.0.1:3100/v1/actions/jupiter-swap/swap \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "inputMint": "So11111111111111111111111111111111111111112",
    "outputMint": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "amount": "1000000000"
  }'

# Step 2: Bridge USDC to Ethereum via LI.FI
curl -X POST http://127.0.0.1:3100/v1/actions/lifi/bridge \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "fromChain": "sol",
    "toChain": "eth",
    "fromToken": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    "toToken": "0xA0b86a33E6411A3d8a8269B7f9C86dfE8b68b2A0",
    "amount": "100000000"
  }'

# Step 3: Execute on Ethereum DeFi (WAIaaS manages nonce automatically)
curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "ContractCall",
    "to": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
    "data": "0x...",
    "value": "0"
  }'

Each transaction gets the correct nonce automatically. No local state tracking, no race conditions, no failed transactions from nonce gaps.

Gas-Conditional Execution for Profitable Trading

Trading bots need gas optimization built-in. WAIaaS includes gas conditional execution — your transactions only execute when gas prices meet your thresholds:

# Only execute when gas < 20 gwei
curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "TRANSFER",
    "to": "0x...",
    "amount": "0.1",
    "gasCondition": {
      "maxGasPrice": "20000000000"
    }
  }'

The transaction pipeline queues your trade and waits for favorable gas conditions. Your MEV bot captures opportunities without overpaying for execution.

Batch Transactions with Automatic Nonce Sequencing

High-frequency trading requires transaction batching. WAIaaS handles nonce sequencing across batch operations:

curl -X POST http://127.0.0.1:3100/v1/transactions/send \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "type": "Batch",
    "transactions": [
      {
        "type": "Approve",
        "spender": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
        "token": "0xA0b86a33E6411A3d8a8269B7f9C86dfE8b68b2A0",
        "amount": "1000000000"
      },
      {
        "type": "ContractCall",
        "to": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
        "data": "0x38ed1739..."
      }
    ]
  }'

The approve gets nonce N, the swap gets nonce N+1. No manual nonce calculation required.

Account Abstraction for Gasless Trading

For sophisticated trading strategies, WAIaaS supports ERC-4337 Account Abstraction with UserOp bundling. Your bot can execute gasless transactions or pay gas in tokens:

# Build UserOp with automatic nonce management
curl -X POST http://127.0.0.1:3100/v1/userop/build \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "callData": "0x...",
    "target": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D"
  }'

Risk Controls for Trading Automation

Trading bots need guardrails. WAIaaS includes 21 policy types with 4 security tiers. Set spending limits, rate limits, and contract whitelists:

# Create trading bot policy
curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: <password>" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 1000,
      "daily_limit_usd": 50000,
      "hourly_limit_usd": 10000
    }
  }'

Quick Start: Build a Trading Bot in 5 Steps

Install and initialize WAIaaS

npm install -g @waiaas/cli
waiaas init --auto-provision
waiaas start

Create trading wallets

waiaas wallet create --name "trading-eth" --chain evm --network ethereum-mainnet
waiaas wallet create --name "trading-sol" --chain solana --network solana-mainnet

Create sessions for your bot

# Returns session tokens for API auth
waiaas session create --wallet trading-eth
waiaas session create --wallet trading-sol

Set trading policies

# Configure risk limits
waiaas policy create --wallet trading-eth --type SPENDING_LIMIT \
  --rule instant_max_usd=500 --rule daily_limit_usd=10000

Execute your first cross-chain trade

import { WAIaaSClient } from '@waiaas/sdk';

const client = new WAIaaSClient({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN,
});

// WAIaaS handles nonces automatically
const swap = await client.executeAction('jupiter-swap', 'swap', {
  inputMint: 'So11111111111111111111111111111111111111112',
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
  amount: '1000000000'
});

Your trading bot now has enterprise-grade wallet infrastructure with automatic nonce management, gas optimization, and risk controls across 18 networks. No more failed transactions from nonce conflicts — just reliable execution for profitable trading.

What's Next

Ready to eliminate nonce headaches from your trading infrastructure? Clone WAIaaS from GitHub and deploy your production-ready trading bot wallet in minutes. Check out the full documentation and examples at waiaas.ai.

Asset Resolution for AI Agents: From Symbols to Contract Addresses

Wallet Guy — Thu, 16 Apr 2026 08:08:26 +0000

Your AI agent can handle natural language like "swap 100 USDC for SOL" but struggles with the technical reality: blockchains need exact contract addresses, not human-friendly symbols. Asset resolution bridges this gap, automatically converting token symbols and names into the precise addresses your agent needs to execute transactions across different networks.

Modern AI agents excel at understanding user intent but hit a wall when that intent involves blockchain transactions. A user might say "stake some ETH" or "buy PEPE token," but the underlying smart contracts require exact addresses like 0xA0b86a33E6441b3D6B36b2C4e0e7A3a1b5c4b3d2. This translation layer—asset resolution—becomes critical for any AI agent operating in DeFi.

Why Asset Resolution Matters for AI Agents

The disconnect between human language and blockchain precision creates friction. Users think in terms of "Bitcoin" or "USDC," while smart contracts expect 42-character hexadecimal addresses on Ethereum or 44-character base58 strings on Solana. Without proper asset resolution, your AI agent either fails silently or, worse, interacts with the wrong token entirely.

Cross-chain complexity multiplies this challenge. USDC exists on Ethereum, Polygon, Arbitrum, and Solana—but with completely different contract addresses on each network. Your agent needs to resolve not just the symbol but the symbol within the correct network context.

How WAIaaS Handles Asset Resolution

WAIaaS provides built-in asset resolution through its REST API and MCP tools, handling the complexity behind a simple interface. The system maintains token registries for all supported networks and resolves symbols to addresses automatically.

Basic Asset Resolution via REST API

# Resolve USDC on Solana
curl http://127.0.0.1:3100/v1/assets/resolve \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{"symbol": "USDC", "chain": "solana"}'

# Response
{
  "address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
  "symbol": "USDC",
  "name": "USD Coin",
  "decimals": 6,
  "chain": "solana",
  "network": "mainnet"
}

MCP Integration for Claude

With the MCP setup, Claude can resolve assets naturally within conversation:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_SESSION_TOKEN": "wai_sess_<token>"
      }
    }
  }
}

Now Claude can handle requests like "What's the contract address for WETH on Polygon?" by calling the resolve-asset MCP tool automatically.

SDK Implementation

The TypeScript SDK abstracts asset resolution entirely:

import { WAIaaSClient } from '@waiaas/sdk';

const client = new WAIaaSClient({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN,
});

// Agent can work with symbols directly
const tx = await client.sendToken({
  to: 'recipient-address',
  amount: '100',
  tokenSymbol: 'USDC'  // WAIaaS resolves this automatically
});

Multi-Chain Asset Resolution

WAIaaS supports 2 chain types across 18 networks, each with its own token addressing scheme. The resolution system handles this complexity transparently.

Network-Specific Resolution

# Same symbol, different networks
curl http://127.0.0.1:3100/v1/assets/resolve \
  -d '{"symbol": "USDC", "chain": "evm", "network": "ethereum-mainnet"}'
# Returns: 0xA0b86a33E6441b3D6B36b2C4e0e7A3a1b5c4b3d2

curl http://127.0.0.1:3100/v1/assets/resolve \
  -d '{"symbol": "USDC", "chain": "solana", "network": "mainnet"}'
# Returns: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v

Fuzzy Matching and Aliases

The resolution system handles common variations and aliases:

"WETH" → "Wrapped Ether" → 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2
"BTC" on Ethereum → "Wrapped Bitcoin" → 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599
"SOL" on Solana → Native token → So11111111111111111111111111111111111111112

Integration Patterns for AI Frameworks

LangChain Tools

from waiaas import WAIaaSClient
from langchain.tools import BaseTool

class ResolveAssetTool(BaseTool):
    name = "resolve_asset"
    description = "Resolve token symbol to contract address"

    async def _arun(self, symbol: str, chain: str):
        async with WAIaaSClient("http://localhost:3100", "wai_sess_xxx") as client:
            asset = await client.resolve_asset(symbol=symbol, chain=chain)
            return f"{symbol} address on {chain}: {asset.address}"

CrewAI Integration

from crewai import Agent, Task
from waiaas import WAIaaSClient

wallet_agent = Agent(
    role='DeFi Trading Agent',
    goal='Execute token swaps based on market analysis',
    tools=[resolve_asset_tool, execute_swap_tool],
    backstory='Expert at converting trading signals into blockchain transactions'
)

Claude MCP Direct Usage

After MCP setup, Claude automatically has access to the resolve-asset tool among 45 MCP tools:

User: "What's the contract address for LINK on Polygon?"
Claude: I'll look up the LINK token address on Polygon for you.

[Calls resolve-asset tool with symbol="LINK", chain="evm", network="polygon-mainnet"]

The LINK token address on Polygon is: 0x53E0bca35eC356BD5ddDFebbD1Fc0fD03FaBad39

Error Handling and Edge Cases

Asset resolution can fail for various reasons. WAIaaS provides clear error handling:

try {
  const asset = await client.resolveAsset({
    symbol: 'UNKNOWNTOKEN',
    chain: 'solana'
  });
} catch (error) {
  if (error.code === 'ASSET_NOT_FOUND') {
    console.log('Token not found in registry');
  }
}

Common Edge Cases

Ambiguous symbols: Multiple tokens with same symbol
Network mismatches: Token doesn't exist on requested chain
Deprecated tokens: Old contract addresses no longer valid
Case sensitivity: "usdc" vs "USDC" vs "UsDbC"

WAIaaS handles these gracefully with detailed error messages and suggested alternatives.

Quick Start: Asset-Aware AI Agent

Here's how to build an AI agent that can resolve and work with blockchain assets:

Install and start WAIaaS:

npm install -g @waiaas/cli
waiaas init
waiaas start
waiaas quickset --mode mainnet

Set up MCP for Claude (or install SDK for custom agents):

waiaas mcp setup --all

Test asset resolution in Claude:

User: "What's the WETH contract address on Arbitrum?"
Claude: [Uses resolve-asset tool] → Returns exact address

Execute token operations:

User: "Swap 0.1 ETH for USDC on Arbitrum"
Claude: [Resolves symbols → Executes swap via Jupiter/0x providers]

Monitor the transaction:

User: "What's the status of that swap?"
Claude: [Checks transaction status] → "Completed, received 185.42 USDC"

Advanced: Custom Resolution Logic

For specialized use cases, you can extend WAIaaS's resolution with custom logic:

# Add custom token to resolution registry
curl -X POST http://127.0.0.1:3100/v1/assets/custom \
  -H "X-Master-Password: <password>" \
  -d '{
    "symbol": "MYTOKEN",
    "address": "0x...",
    "name": "My Custom Token",
    "decimals": 18,
    "chain": "evm",
    "network": "ethereum-mainnet"
  }'

Asset resolution transforms AI agents from text processors into blockchain-capable entities. With proper symbol-to-address mapping, your agent can seamlessly bridge the gap between natural language requests and precise blockchain execution.

For deeper integration patterns, check out Building AI Trading Bots with WAIaaS MCP Integration and Policy-Based Security for AI Agent Wallets.

Ready to give your AI agent blockchain superpowers? Start with the WAIaaS GitHub repository or explore the full documentation at waiaas.ai. Your agent's first token swap is just a few commands away.

OpenClaw Plugin: 5 Tool Categories for External AI Agent Frameworks

Wallet Guy — Wed, 15 Apr 2026 14:50:12 +0000

Your AI agent can browse the web, write code, and manage files. But can it swap tokens, pay for API calls, or manage DeFi positions? The OpenClaw plugin from WAIaaS bridges this gap by providing 5 tool categories that enable external AI agent frameworks like LangChain, CrewAI, and AutoGPT to interact with blockchains safely and autonomously.

Why AI Agents Need Wallet Access

AI agents are becoming increasingly capable, but they hit a wall when money is involved. They can analyze market data but can't execute trades. They can research DeFi protocols but can't deposit funds or claim rewards. They can monitor NFT collections but can't mint or transfer tokens.

This limitation exists because blockchain interactions require private key management, transaction signing, and security policies — capabilities that general-purpose AI frameworks don't provide. Most developers end up building custom wallet integrations for each project, creating security risks and duplicating effort across the ecosystem.

How OpenClaw Solves This

WAIaaS provides the OpenClaw plugin — a standardized interface that gives external AI agent frameworks access to wallet operations through 5 organized tool categories. Instead of managing private keys or building blockchain integrations from scratch, your agent connects to a secure wallet service and calls tools based on what it needs to accomplish.

The OpenClaw plugin exposes 5 tool categories, each designed for specific blockchain operations:

// OpenClaw tools: defi, nft, transfer, utility, wallet

Each tool category provides focused functionality without overwhelming your agent with dozens of individual methods. Here's how they break down:

Wallet Tools

Basic wallet operations like checking balances, getting addresses, and viewing transaction history. These are the foundation tools your agent needs before making any blockchain decisions.

Transfer Tools

Token sending, batch transfers, and payment operations. Whether your agent needs to send ETH, transfer USDC, or make multiple payments in one transaction, these tools handle the complexity.

DeFi Tools

Decentralized finance operations across 15 integrated protocols including Jupiter swap, Lido staking, Aave lending, and Hyperliquid perpetuals. Your agent can analyze yields, execute swaps, manage lending positions, and trade derivatives.

NFT Tools

Non-fungible token operations for both EVM (ERC-721/ERC-1155) and Solana (Metaplex) standards. Your agent can mint, transfer, and query NFT metadata with built-in caching for performance.

Utility Tools

Cross-cutting operations like transaction simulation, gas optimization, contract interaction, and the x402 payment protocol for AI agents that need to pay for API calls automatically.

Setting Up OpenClaw with Your Agent Framework

The setup process depends on your AI framework, but the core pattern is the same: register WAIaaS as a tool provider and configure authentication.

For LangChain Agents

from langchain.tools import Tool
from waiaas.openclaw import OpenClawProvider

# Initialize OpenClaw provider
openclaw = OpenClawProvider(
    base_url="http://127.0.0.1:3100",
    session_token="wai_sess_eyJhbGciOiJIUzI1NiJ9..."
)

# Register tools with your agent
tools = openclaw.get_tools(categories=["wallet", "transfer", "defi"])

agent = initialize_agent(tools, llm, agent=AgentType.STRUCTURED_CHAT)

For CrewAI

from crewai import Agent, Tool
from waiaas.openclaw import OpenClawProvider

trading_agent = Agent(
    role="DeFi Trading Specialist",
    goal="Execute optimal trading strategies",
    backstory="Expert in DeFi protocols and yield optimization",
    tools=OpenClawProvider().get_tools(categories=["wallet", "defi"])
)

For Custom Agent Frameworks

const { OpenClawProvider } = require('@waiaas/openclaw-plugin');

const provider = new OpenClawProvider({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN
});

// Get wallet tools
const walletTools = await provider.getTools(['wallet']);

// Your agent can now call:
// - checkBalance()
// - getAddress() 
// - listTransactions()

Security Through Policy Integration

OpenClaw tools inherit WAIaaS's 21 policy types and 4-tier security system. Your AI agent operates within predefined guardrails:

# Create spending limits for your agent
curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 100,
      "notify_max_usd": 500,
      "delay_max_usd": 2000,
      "delay_seconds": 900,
      "daily_limit_usd": 5000
    }
  }'

Small transactions execute instantly, medium amounts trigger notifications, large transfers include time delays, and huge amounts require human approval. Your agent can operate autonomously within safe boundaries.

Real-World Agent Examples

DeFi Yield Farmer

# Agent checks current positions
positions = openclaw.call_tool("defi", "get_positions")

# Analyzes yields across protocols  
if aave_yield > current_yield * 1.1:
    # Withdraws from current protocol
    openclaw.call_tool("defi", "withdraw", {"protocol": "compound", "amount": "1000"})

    # Deposits to higher-yield protocol
    openclaw.call_tool("defi", "deposit", {"protocol": "aave", "amount": "1000"})

Trading Bot

// Agent monitors market conditions
const balance = await openclaw.callTool("wallet", "getBalance");

if (shouldSwap) {
  // Executes swap on Jupiter
  await openclaw.callTool("defi", "swap", {
    provider: "jupiter-swap",
    inputMint: "So11111111111111111111111111111111111111112",
    outputMint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
    amount: balance.amount * 0.1
  });
}

NFT Portfolio Manager

# Agent monitors NFT collections
collections = openclaw.call_tool("nft", "get_collections")

for collection in collections:
    if collection.floor_price > collection.avg_purchase * 2:
        # Lists profitable NFTs
        openclaw.call_tool("nft", "list", {
            "tokenId": collection.token_id,
            "price": collection.floor_price * 0.95
        })

Quick Start: Give Your Agent a Wallet

Here's how to get OpenClaw working with your AI agent in 5 steps:

Install WAIaaS daemon

npm install -g @waiaas/cli
waiaas init
waiaas start

Create a wallet and session

waiaas quickset --mode testnet

Install OpenClaw plugin

npm install @waiaas/openclaw-plugin
# or
pip install waiaas

Configure your agent framework

from waiaas.openclaw import OpenClawProvider

provider = OpenClawProvider(
    base_url="http://127.0.0.1:3100",
    session_token="wai_sess_<your-token>"
)

tools = provider.get_tools(categories=["wallet", "transfer"])

Test wallet access

# Your agent can now check its balance
balance = provider.call_tool("wallet", "get_balance")
print(f"Agent wallet: {balance['balance']} {balance['symbol']}")

The OpenClaw plugin transforms your AI agent from a information processor into an autonomous economic actor. Whether you're building trading bots, yield farmers, or NFT managers, your agent now has the tools it needs to interact with blockchain protocols safely and effectively.

For a complete integration guide, check out Building AI Agents with MCP Integration and Docker Deployment Guide for Production AI Agents.

What's Next

Ready to give your AI agent blockchain superpowers? Start with the OpenClaw plugin at GitHub or explore the full documentation at waiaas.ai. Your agent is about to become a lot more interesting.

Python SDK for AI Agents: Async Wallet Control with Zero Dependencies

Wallet Guy — Wed, 15 Apr 2026 08:09:35 +0000

Your AI agents can browse the web, write code, and manage files—but can they control a crypto wallet? Most AI agent frameworks stop at the edge of financial transactions, leaving a critical gap for agents that need to interact with DeFi protocols, pay for API calls with crypto, or manage digital assets autonomously.

Why Wallet Integration Matters for AI Agents

AI agents are becoming increasingly autonomous, but they hit a wall when they need to handle money. Whether it's an agent that needs to:

Pay for premium API calls using crypto micropayments
Execute DeFi strategies based on market conditions
Manage NFT portfolios automatically
Bridge assets between different blockchain networks

The missing piece has always been secure, programmable wallet access. Traditional wallet solutions require manual approval for every transaction, breaking the autonomous flow that makes AI agents powerful.

Python SDK: Zero Dependencies, Maximum Control

WAIaaS provides a Python SDK (waiaas) with async/await support and zero external dependencies. This means your AI agents can control wallets without bloating your dependency tree or introducing security vulnerabilities from third-party packages.

The Python SDK gives your agents access to 18 networks across 2 chain types (solana, evm), with built-in support for 15 DeFi protocol providers integrated including Jupiter swap, Lido staking, Hyperliquid perpetual futures, and Polymarket prediction markets.

Getting Started with the Python SDK

Here's how to give your AI agent wallet superpowers:

pip install waiaas

First, you'll need a running WAIaaS daemon. The fastest way is with Docker:

docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/minhoyoo-iotrust/waiaas:latest

# Retrieve auto-generated master password
docker exec waiaas cat /data/recovery.key

Now your agent can interact with the wallet:

from waiaas import WAIaaSClient

async with WAIaaSClient("http://localhost:3100", "wai_sess_xxx") as client:
    balance = await client.get_balance()
    print(balance.balance, balance.symbol)

Real-World Agent Integration Example

Let's build an agent that can autonomously manage a DeFi portfolio. This example shows how an AI agent can check balances, execute swaps, and monitor positions:

from waiaas import WAIaaSClient
import asyncio

class DeFiAgent:
    def __init__(self, session_token):
        self.client = WAIaaSClient("http://localhost:3100", session_token)

    async def rebalance_portfolio(self, target_usdc_ratio=0.5):
        """Rebalance portfolio to maintain target USDC ratio"""

        # Check current positions
        balance = await self.client.get_balance()
        assets = await self.client.get_assets()

        print(f"Current balance: {balance.balance} {balance.symbol}")

        # Calculate if rebalancing is needed
        total_value_usd = float(balance.balance) * balance.price_usd
        usdc_balance = next((a for a in assets if a.symbol == "USDC"), None)
        current_usdc_ratio = (usdc_balance.balance_usd / total_value_usd) if usdc_balance else 0

        if abs(current_usdc_ratio - target_usdc_ratio) > 0.05:  # 5% threshold
            # Execute rebalancing trade
            if current_usdc_ratio < target_usdc_ratio:
                # Need more USDC - sell SOL for USDC
                amount_to_swap = (target_usdc_ratio - current_usdc_ratio) * float(balance.balance)
                await self.swap_tokens("SOL", "USDC", str(amount_to_swap))
            else:
                # Need less USDC - buy SOL with USDC  
                amount_to_swap = (current_usdc_ratio - target_usdc_ratio) * usdc_balance.balance_usd
                await self.swap_tokens("USDC", "SOL", str(amount_to_swap))

    async def swap_tokens(self, from_token, to_token, amount):
        """Execute token swap via Jupiter"""
        try:
            result = await self.client.execute_action(
                "jupiter-swap", 
                "swap",
                {
                    "inputMint": self.get_token_mint(from_token),
                    "outputMint": self.get_token_mint(to_token), 
                    "amount": amount
                }
            )
            print(f"Swap executed: {result.id}")
            return result
        except Exception as e:
            print(f"Swap failed: {e}")
            return None

    async def monitor_positions(self):
        """Monitor DeFi positions across protocols"""
        positions = await self.client.get_defi_positions()

        for position in positions:
            if position.health_factor and position.health_factor < 1.2:
                print(f"WARNING: Low health factor on {position.protocol}: {position.health_factor}")
                # Agent could automatically add collateral or reduce leverage here

    def get_token_mint(self, symbol):
        """Get token mint address for common tokens"""
        mints = {
            "SOL": "So11111111111111111111111111111111111111112",
            "USDC": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
        }
        return mints.get(symbol)

# Usage
async def main():
    agent = DeFiAgent("wai_sess_your_token_here")

    # Run autonomous rebalancing
    await agent.rebalance_portfolio(target_usdc_ratio=0.6)

    # Monitor positions for risk
    await agent.monitor_positions()

if __name__ == "__main__":
    asyncio.run(main())

Security Through Policy Engine

The key to safe autonomous operation is WAIaaS's policy engine with 21 policy types and 4 security tiers: INSTANT, NOTIFY, DELAY, APPROVAL. You can configure policies that allow your agent to operate within safe boundaries:

# Set spending limits via REST API
curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 300,
      "daily_limit_usd": 500
    }
  }'

This creates a 4-tier security system where small transactions execute instantly, medium amounts trigger notifications, larger amounts have a time delay for review, and the largest amounts require explicit human approval via WalletConnect integration for owner approval of agent transactions.

Advanced Features for AI Agents

x402 HTTP Payment Protocol

Your agents can automatically pay for API calls using the x402 HTTP payment protocol support:

# Agent pays for premium API access automatically
response = await client.x402_fetch("https://api.premium-service.com/data")

Multi-Chain Operation

The Python SDK supports 18 networks across Ethereum, Solana, and other chains. Your agent can bridge assets automatically:

# Bridge from Ethereum to Solana via LI.FI
await client.execute_action("lifi", "bridge", {
    "fromChain": "ethereum",
    "toChain": "solana", 
    "amount": "100.0",
    "token": "USDC"
})

NFT Operations

Agents can manage NFT portfolios with NFT support for EVM (ERC-721/ERC-1155) and Solana (Metaplex) with metadata caching:

# List agent's NFT collection
nfts = await client.list_nfts()

# Transfer NFT to another address  
await client.transfer_nft({
    "to": "recipient-address",
    "tokenId": "123",
    "contractAddress": "0x..."
})

Quick Start: Agent-Ready Wallet in 5 Minutes

Start WAIaaS daemon:

docker run -d --name waiaas -p 127.0.0.1:3100:3100 -v waiaas-data:/data -e WAIAAS_AUTO_PROVISION=true ghcr.io/minhoyoo-iotrust/waiaas:latest

Get the master password:

docker exec waiaas cat /data/recovery.key

Create wallet and session (using CLI for convenience):

npm install -g @waiaas/cli
waiaas quickset --mode mainnet

Install Python SDK:

pip install waiaas

Test agent wallet access:

from waiaas import WAIaaSClient

async with WAIaaSClient("http://localhost:3100", "your_session_token") as client:
    balance = await client.get_balance()
    print(f"Agent wallet ready! Balance: {balance.balance} {balance.symbol}")

MCP Integration for Claude and Other AI Frameworks

If you're building with Claude Desktop, LangChain, or other MCP-compatible frameworks, WAIaaS provides 45 MCP tools for AI agent integration. The MCP server can be configured alongside the Python SDK for maximum flexibility:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_SESSION_TOKEN": "wai_sess_<your-token>"
      }
    }
  }
}

This gives your Claude agent direct access to wallet operations through natural language commands, while your Python agents can use the SDK for programmatic control.

The Python SDK's async/await design makes it perfect for building reactive agents that respond to market conditions, user requests, or scheduled tasks without blocking execution. Combined with the policy engine's safety guarantees, you can deploy autonomous financial agents with confidence.

Ready to give your AI agents financial superpowers? Check out the full documentation and examples on GitHub or explore more advanced integrations at waiaas.ai.

What's next? Try integrating WAIaaS with your existing AI agent framework, set up some basic spending policies, and watch your agents start interacting with DeFi protocols autonomously. The combination of zero-dependency architecture and comprehensive blockchain support makes it the fastest path from idea to autonomous financial agent.

Production Docker Setup: Healthcheck, Auto-Updates, and Non-Root Security

Wallet Guy — Tue, 14 Apr 2026 14:56:37 +0000

Setting up production Docker infrastructure for AI agents requires careful attention to security, monitoring, and maintenance. WAIaaS provides a hardened Docker deployment with healthchecks, automatic updates, and non-root containers to keep your wallet infrastructure running reliably in production environments.

Why Production Docker Setup Matters

When AI agents handle real cryptocurrency transactions, infrastructure reliability becomes critical. A crashed container means stuck transactions, missed trading opportunities, or worse — agents that can't respond to market conditions. Production setups need automated health monitoring, security isolation, and hands-off maintenance to minimize operational overhead while maximizing uptime.

WAIaaS Production-Ready Docker Features

WAIaaS includes several production-hardened Docker features out of the box:

Built-in Healthcheck

The Docker container includes a native healthcheck that monitors the API endpoint:

healthcheck:
  test: ["CMD", "curl", "-f", "http://localhost:3100/health"]
  interval: 30s
  timeout: 5s
  start_period: 10s
  retries: 3

This configuration checks the /health endpoint every 30 seconds. If three consecutive checks fail, Docker marks the container as unhealthy, enabling orchestration systems to restart or replace it automatically.

Non-Root Security

The WAIaaS Docker image runs as UID 1001, not root:

# From the Dockerfile
USER 1001

This follows security best practices by limiting container privileges. Even if an attacker compromises the application, they can't escalate to root or modify system files.

Auto-Provisioning for Unattended Deployment

For production deployments where manual password entry isn't practical, enable auto-provisioning:

docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/minhoyoo-iotrust/waiaas:latest

# Retrieve the auto-generated master password
docker exec waiaas cat /data/recovery.key

The auto-provision feature generates a cryptographically secure master password and saves it to /data/recovery.key for later retrieval.

Docker Compose Production Configuration

For production deployments, use the complete Docker Compose setup with monitoring and restart policies:

services:
  daemon:
    image: ghcr.io/minhoyoo-iotrust/waiaas:latest
    container_name: waiaas-daemon
    ports:
      - "127.0.0.1:3100:3100"
    volumes:
      - waiaas-data:/data
    environment:
      - WAIAAS_DATA_DIR=/data
      - WAIAAS_DAEMON_HOSTNAME=0.0.0.0
      - WAIAAS_AUTO_PROVISION=true
      - WAIAAS_DAEMON_LOG_LEVEL=info
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3100/health"]
      interval: 30s
      timeout: 5s
      start_period: 10s
      retries: 3

  # Watchtower for automatic updates
  watchtower:
    image: containrrr/watchtower
    container_name: waiaas-watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    environment:
      - WATCHTOWER_POLL_INTERVAL=3600
      - WATCHTOWER_CLEANUP=true
      - WATCHTOWER_INCLUDE_STOPPED=true
    restart: unless-stopped

volumes:
  waiaas-data:
    driver: local

This configuration includes Watchtower for automatic container updates, ensuring your wallet infrastructure stays current with security patches and feature updates.

Secrets Management for Production

For production environments with sensitive configuration, use Docker Secrets to avoid exposing credentials in environment variables:

# Create secret files
mkdir -p secrets
echo "your-secure-master-password" > secrets/master_password.txt
echo "your-rpc-endpoint" > secrets/solana_rpc.txt
chmod 600 secrets/*.txt

# Deploy with secrets overlay
docker compose -f docker-compose.yml -f docker-compose.secrets.yml up -d

The secrets overlay (docker-compose.secrets.yml) mounts secret files as read-only volumes, keeping sensitive data out of process environments where it might leak in logs or crash dumps.

Monitoring and Logging

Set up comprehensive logging for production troubleshooting:

# Follow logs from all services
docker compose logs -f

# Check container health status
docker ps --format "table {{.Names}}\t{{.Status}}"

# Monitor resource usage
docker stats waiaas-daemon

For structured logging, configure the log level via environment variable:

environment:
  - WAIAAS_DAEMON_LOG_LEVEL=info  # trace/debug/info/warn/error

Network Security Configuration

Bind the service to localhost only for security:

ports:
  - "127.0.0.1:3100:3100"  # Only accessible from localhost

If you need external access, use a reverse proxy like nginx with TLS termination rather than exposing the container port directly. This provides an additional security layer and enables features like rate limiting and authentication at the proxy level.

Backup and Data Persistence

The named volume waiaas-data persists wallet keys, transaction history, and configuration across container restarts:

# Create backup of wallet data
docker run --rm -v waiaas-data:/source -v $(pwd):/backup \
  ubuntu tar czf /backup/waiaas-backup-$(date +%Y%m%d).tar.gz -C /source .

# Restore from backup
docker run --rm -v waiaas-data:/target -v $(pwd):/backup \
  ubuntu tar xzf /backup/waiaas-backup-20240314.tar.gz -C /target

Resource Limits and Performance

Set resource constraints to prevent runaway resource usage:

services:
  daemon:
    # ... other config
    deploy:
      resources:
        limits:
          memory: 512M
          cpus: '1.0'
        reservations:
          memory: 256M
          cpus: '0.5'

WAIaaS is designed to be lightweight, typically using under 100MB RAM for normal operations.

Quick Production Deployment

Here's a complete 5-step production setup:

Clone and prepare configuration:

   git clone https://github.com/minhoyoo-iotrust/WAIaaS.git
   cd WAIaaS
   cp .env.example .env

Configure secrets (optional but recommended):

   mkdir secrets
   echo "$(openssl rand -base64 32)" > secrets/master_password.txt
   chmod 600 secrets/master_password.txt

Deploy with auto-provisioning:

   docker compose up -d

Retrieve credentials:

   docker exec waiaas-daemon cat /data/recovery.key

Verify deployment:

   curl http://127.0.0.1:3100/health
   docker compose logs daemon

Maintenance and Updates

The Watchtower integration automatically pulls new images and restarts containers when updates are available. To manually update:

docker compose pull    # Pull latest images
docker compose up -d   # Restart with new images

WAIaaS uses semantic versioning. Patch updates (1.0.1 → 1.0.2) are automatically applied via Watchtower. For major version updates, review the changelog before upgrading.

What's Next

With your production Docker infrastructure running, you're ready to create wallets and deploy AI agents with confidence. The hardened container setup provides the reliability foundation needed for autonomous trading systems and DeFi protocols.

Check out the WAIaaS GitHub repository for the latest Docker configurations and visit waiaas.ai for comprehensive deployment guides and production best practices.

Building Trustworthy AI Agents: ERC-8004 Onchain Reputation System

Wallet Guy — Tue, 14 Apr 2026 08:08:15 +0000

AI agents need reputation systems to operate safely in economic environments, but traditional web2 ratings are siloed and gameable. ERC-8004 brings onchain reputation to AI agents, creating a trustless system where autonomous agents can build and verify their track record across protocols. WAIaaS implements the complete ERC-8004 specification, letting you deploy agents with verifiable onchain reputation from day one.

Why Onchain Reputation Matters for AI Agents

As AI agents become economic actors — trading tokens, providing services, managing DeFi positions — we need systems to evaluate their trustworthiness. A trading agent with a proven track record should command higher trust than a newly deployed agent with no history.

Traditional reputation systems fail in multi-agent environments. Centralized ratings are platform-locked. An agent's stellar performance on one protocol doesn't transfer to another. Worse, these systems are vulnerable to manipulation through fake reviews or wash trading.

ERC-8004 solves this by moving reputation onchain. When an agent completes actions, other protocols can attest to their performance directly on the blockchain. This creates a portable, tamper-proof reputation score that follows the agent across all protocols and applications.

ERC-8004: Trustless Agents Standard

ERC-8004 defines how AI agents register, accumulate reputation, and prove their identity onchain. The standard includes three core components:

Agent Registration: Each agent gets a unique onchain identity tied to their wallet address. This prevents agents from abandoning bad reputations and starting fresh with new addresses.

Attestation System: Protocols can submit positive or negative attestations about an agent's performance. These attestations are weighted based on the attester's own reputation, preventing spam attacks.

Validation Queries: Any protocol can query an agent's reputation score, validation status, and attestation history before allowing the agent to participate.

WAIaaS provides 15 DeFi protocol providers integrated with this reputation system. When your agent trades on Jupiter, lends on Aave, or provides liquidity on Kamino, these actions can generate reputation attestations automatically.

How WAIaaS Implements ERC-8004

WAIaaS includes a complete ERC-8004 provider that handles agent registration, attestation management, and reputation queries. Here's how to register an agent and start building onchain reputation:

# Register your agent onchain
curl -X POST http://127.0.0.1:3100/v1/actions/erc8004/register \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "agentName": "trading-bot-v2",
    "agentType": "TRADING",
    "metadata": {
      "description": "Automated arbitrage trader",
      "version": "2.1.0",
      "strategies": ["arbitrage", "market-making"]
    }
  }'

The registration creates an onchain record linking your agent's wallet address to its identity and capabilities. Other protocols can now track this agent's performance and submit attestations.

To check an agent's current reputation:

# Get agent reputation data
curl http://127.0.0.1:3100/v1/actions/erc8004/reputation/<agent-address> \
  -H "Authorization: Bearer wai_sess_<token>"

This returns the agent's reputation score, validation status, total attestations, and performance metrics across different categories.

Policy Integration: Reputation-Based Access Control

WAIaaS policy engine includes REPUTATION_THRESHOLD policies that restrict actions based on onchain reputation scores. This lets you create agent hierarchies where higher-reputation agents get more privileges:

# Create reputation-based policy
curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "REPUTATION_THRESHOLD",
    "rules": {
      "minimum_score": 750,
      "required_attestations": 10,
      "max_negative_ratio": 0.1
    }
  }'

This policy blocks actions unless the agent has a reputation score above 750, at least 10 attestations, and negative attestations below 10% of total attestations. You can use different thresholds for different action types — requiring higher reputation for large trades but allowing smaller operations for newer agents.

Building Multi-Agent Systems with Reputation

ERC-8004's power emerges when multiple agents interact. Here's a pattern for creating agent hierarchies:

Supervisor Agent: High-reputation agent that coordinates strategy and risk management. Has broad permissions and can approve actions by subordinate agents.

Specialist Agents: Medium-reputation agents focused on specific tasks (arbitrage, yield farming, NFT trading). Can execute actions within their specialty but require supervisor approval for cross-domain operations.

Scout Agents: Low-reputation agents that gather market data and identify opportunities. Cannot execute trades but can submit recommendations to specialist agents.

The MCP integration makes this pattern natural. Each agent gets its own MCP server instance with different reputation thresholds and policy configurations:

{
  "mcpServers": {
    "supervisor-agent": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c47d6-51ef-7f43-a76b-d50e875d95f4",
        "WAIAAS_AGENT_NAME": "supervisor"
      }
    },
    "arbitrage-specialist": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_AGENT_ID": "019c4cd2-86e8-758f-a61e-9c560307c788",
        "WAIAAS_AGENT_NAME": "arbitrage-bot"
      }
    }
  }
}

The supervisor can query subordinate agents' reputation and performance before delegating tasks or approving their proposed actions.

Real-Time Reputation Monitoring

WAIaaS provides MCP tools for agents to monitor their own reputation and respond to changes:

// Agent checks its own reputation before major actions
const reputation = await client.executeAction('erc8004', 'get-reputation', {
  agentAddress: await client.getAddress()
});

if (reputation.score < 800) {
  console.log('Reputation below threshold, reducing position sizes');
  maxTradeSize = maxTradeSize * 0.5;
}

// Check if recent attestations indicate performance issues
const recentNegative = reputation.attestations
  .filter(a => a.timestamp > Date.now() - 86400000) // Last 24h
  .filter(a => a.score < 0);

if (recentNegative.length > 3) {
  console.log('Multiple negative attestations, entering conservative mode');
  pauseHighRiskStrategies();
}

This self-monitoring creates a feedback loop where agents automatically adjust their behavior based on reputation changes, reducing risk when their standing drops.

Cross-Protocol Reputation Portability

Unlike platform-specific ratings, ERC-8004 reputation follows agents across all protocols. An agent that performs well on Aave lending carries that reputation to Jupiter trading or Polymarket prediction markets.

This portability accelerates agent adoption. New protocols can bootstrap trust by accepting agents with strong reputation from other protocols, while agents can leverage their track record to access new opportunities immediately.

WAIaaS tracks attestations across all 15 integrated DeFi protocols, creating a unified reputation profile that reflects the agent's performance across lending, trading, staking, and prediction markets.

Quick Start: Deploy a Reputation-Enabled Agent

Here's how to launch an AI agent with onchain reputation in under 10 minutes:

Deploy WAIaaS: docker run -d -p 3100:3100 ghcr.io/minhoyoo-iotrust/waiaas:latest
Create agent wallet: waiaas wallet create --chain ethereum --name reputation-agent
Register agent onchain: Use the ERC-8004 provider to register your agent with its identity and capabilities
Configure reputation policies: Set minimum reputation thresholds for different action categories
Start building reputation: Execute small, low-risk actions to begin accumulating positive attestations

Your agent now has verifiable onchain identity and can begin building reputation across protocols. As it performs successful actions, other protocols will attest to its performance, gradually increasing its trustworthiness and access to higher-value opportunities.

The key insight is starting with conservative actions to build initial reputation, then expanding capabilities as trust increases. This mirrors how humans build professional reputations — proving competence in small tasks before being trusted with larger responsibilities.

Looking ahead, onchain reputation systems like ERC-8004 will become critical infrastructure as AI agents become more autonomous and economically active. The agents that establish strong reputations early will have significant advantages in accessing protocols, securing favorable terms, and participating in high-value opportunities.

Ready to build trustworthy AI agents with onchain reputation? Start with the WAIaaS repository or explore more at waiaas.ai.

UserOp Build and Sign: ERC-4337 Account Abstraction API for AI Agents

Wallet Guy — Mon, 13 Apr 2026 08:26:01 +0000

ERC-4337 Account Abstraction transforms how DeFi applications handle transactions, but building and signing UserOps manually is complex and error-prone. WAIaaS provides a simple REST API that abstracts the entire UserOp lifecycle — from building to signing to submission — letting your AI agents and DeFi applications focus on strategy rather than ERC-4337 implementation details.

Why Account Abstraction Matters for DeFi

Traditional externally owned accounts (EOAs) create friction in DeFi applications. Every transaction requires gas in ETH, users must manage private keys, and batch operations need complex coordination. ERC-4337 Account Abstraction solves these problems by introducing smart contract wallets that can:

Execute gasless transactions (gas sponsored by paymasters)
Batch multiple operations into a single UserOp
Implement custom validation logic and spending policies
Support social recovery and multi-signature schemes

However, ERC-4337's complexity has limited adoption. Building UserOps requires understanding the spec's intricate details, managing multiple contracts (EntryPoint, Account Factory, Paymaster), and handling gas estimation across different networks. WAIaaS eliminates this complexity with a unified API that works across all EVM chains.

The WAIaaS UserOp API

WAIaaS provides three endpoints that handle the complete UserOp lifecycle:

1. Build UserOp

The /v1/userop/build endpoint constructs a UserOperation from your transaction intent:

curl -X POST http://127.0.0.1:3100/v1/userop/build \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "transactions": [
      {
        "type": "ContractCall",
        "to": "0xA0b86a33E6441d78abf57Fe4e5dA14A6e7F8b57C",
        "data": "0xa9059cbb000000000000000000000000742b35Cc6Cf16CCBb0c5db86c5E5D12b06d67f2E0000000000000000000000000000000000000000000000000de0b6b3a7640000"
      }
    ],
    "gasOptions": {
      "maxFeePerGas": "20000000000",
      "maxPriorityFeePerGas": "1000000000"
    }
  }'

The API automatically:

Estimates gas limits using simulation
Sets nonce from the smart account state
Configures paymaster data if available
Validates the UserOp structure

2. Sign UserOp

The /v1/userop/sign endpoint signs the UserOperation hash:

curl -X POST http://127.0.0.1:3100/v1/userop/sign \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "userOp": {
      "sender": "0x1234...",
      "nonce": "0x1",
      "initCode": "0x",
      "callData": "0xa9059cbb...",
      "callGasLimit": "0x5208",
      "verificationGasLimit": "0x5208",
      "preVerificationGas": "0x5208",
      "maxFeePerGas": "0x4a817c800",
      "maxPriorityFeePerGas": "0x3b9aca00",
      "paymasterAndData": "0x",
      "signature": "0x"
    }
  }'

WAIaaS handles signature generation based on your smart account's validation scheme — whether it's ECDSA, multi-sig, or custom validation logic.

3. Combined Build and Sign

For convenience, you can build and sign in a single request:

curl -X POST http://127.0.0.1:3100/v1/userop/build-and-sign \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "transactions": [
      {
        "type": "TokenTransfer",
        "token": "0xA0b86a33E6441d78abf57Fe4e5dA14A6e7F8b57C",
        "to": "0x742b35Cc6Cf16CCBb0c5db86c5E5D12b06d67f2E",
        "amount": "1000000000000000000"
      }
    ],
    "submitToMempool": true
  }'

Setting submitToMempool: true automatically submits the signed UserOp to the bundler network.

Batch Operations Made Simple

One of ERC-4337's key benefits is batching multiple operations into a single UserOp. WAIaaS makes this trivial:

curl -X POST http://127.0.0.1:3100/v1/userop/build-and-sign \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "transactions": [
      {
        "type": "Approve",
        "token": "0xA0b86a33E6441d78abf57Fe4e5dA14A6e7F8b57C",
        "spender": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
        "amount": "1000000000000000000000000"
      },
      {
        "type": "ContractCall",
        "to": "0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D",
        "data": "0x791ac947..."
      }
    ],
    "submitToMempool": true
  }'

This example batches a token approval with a Uniswap swap, executing both operations atomically in a single UserOp.

Integration with WAIaaS Policy Engine

UserOps flow through WAIaaS's 7-stage transaction pipeline, including policy validation. You can configure ERC-4337-specific policies:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: <password>" \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 100,
      "notify_max_usd": 1000,
      "delay_max_usd": 10000,
      "delay_seconds": 300
    }
  }'

The policy engine evaluates UserOps just like regular transactions, enabling sophisticated risk management for smart contract wallets.

Real-World DeFi Example: Automated Yield Strategy

Here's how a yield farming bot might use the UserOp API to execute a complex strategy:

# Step 1: Build a multi-step yield strategy UserOp
curl -X POST http://127.0.0.1:3100/v1/userop/build-and-sign \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "transactions": [
      {
        "type": "Approve",
        "token": "0xA0b86a33E6441d78abf57Fe4e5dA14A6e7F8b57C",
        "spender": "0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9",
        "amount": "1000000000"
      },
      {
        "type": "ContractCall",
        "to": "0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9",
        "data": "0xe8eda9df000000000000000000000000a0b86a33e6441d78abf57fe4e5da14a6e7f8b57c000000000000000000000000000000000000000000000000000000003b9aca000000000000000000000000001234567890123456789012345678901234567890000000000000000000000000000000000000000000000000000000000000000000"
      }
    ],
    "submitToMempool": true,
    "gasOptions": {
      "maxFeePerGas": "30000000000",
      "maxPriorityFeePerGas": "2000000000"
    }
  }'

This UserOp approves USDC for Aave and supplies it to earn yield, all in a single atomic operation.

Quick Start with ERC-4337

Install WAIaaS CLI:

   npm install -g @waiaas/cli
   waiaas init
   waiaas start

Create an EVM wallet:

   curl -X POST http://127.0.0.1:3100/v1/wallets \
     -H "Content-Type: application/json" \
     -H "X-Master-Password: <password>" \
     -d '{"name": "aa-wallet", "chain": "evm", "environment": "mainnet"}'

Create a session for your application:

   curl -X POST http://127.0.0.1:3100/v1/sessions \
     -H "Content-Type: application/json" \
     -H "X-Master-Password: <password>" \
     -d '{"walletId": "<wallet-uuid>"}'

Test UserOp building:

   curl -X POST http://127.0.0.1:3100/v1/userop/build \
     -H "Authorization: Bearer <session-token>" \
     -d '{"transactions": [{"type": "Transfer", "to": "0x...", "amount": "0.01"}]}'

Check the interactive API docs: Open http://127.0.0.1:3100/reference to explore all UserOp endpoints.

The WAIaaS UserOp API eliminates the complexity of ERC-4337 Account Abstraction, letting you focus on building innovative DeFi applications rather than wrestling with UserOperation construction and signing. With support for batching, policy enforcement, and automatic gas estimation, it's the simplest way to add smart contract wallet capabilities to your AI agents and DeFi protocols.

Ready to simplify your ERC-4337 integration? Check out the full documentation at GitHub and start building with smart contract wallets at waiaas.ai.