DEV Community: Wallet Guy

API Key Security for AI Agents: Credential Management in Self-Hosted Wallets

Wallet Guy — Sun, 12 Apr 2026 14:03:50 +0000

API key security for AI agents becomes critical when those agents control cryptocurrency wallets — one leaked credential or compromised system could drain entire treasury balances. Unlike traditional API keys that might expose data or incur service charges, wallet credentials give direct access to irreversible financial transactions.

Why This Matters More Than Traditional API Security

Traditional API security focuses on rate limiting, token expiration, and access logging. But when AI agents hold wallet private keys, the stakes escalate dramatically. A compromised trading bot doesn't just leak your customer database — it can transfer your entire SOL balance to an attacker's address in seconds.

The challenge multiplies with autonomous agents. While a human developer might notice suspicious API activity, AI agents operate continuously, making thousands of micro-decisions without human oversight. Standard security practices like "rotate keys monthly" become meaningless when the key unlocks actual money.

The Three-Layer Security Model

WAIaaS addresses these risks through layered defense: session authentication controls what agents can access, policy engines enforce spending rules, and human approval channels provide final oversight for high-risk transactions.

Layer 1: Session-Based Authentication

Instead of giving AI agents direct wallet access, WAIaaS uses session tokens with limited scope and automatic expiration:

# Create a session for AI agent (masterAuth required)
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>"}'

Sessions use JWT HS256 tokens with configurable TTL, maximum renewals, and absolute lifetime limits. Even if an agent's session token leaks, the exposure window is bounded. The agent never sees the actual private key — only a time-limited session that can be revoked instantly.

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

const client = new WAIaaSClient({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN, // Limited-scope token, not private key
});

// Agent can check balance
const balance = await client.getBalance();

// But transactions require policy approval
const tx = await client.sendToken({
  to: 'recipient-address',
  amount: '0.1',
});

Layer 2: Default-Deny Policy Engine

WAIaaS implements 21 policy types across 4 security tiers (INSTANT, NOTIFY, DELAY, APPROVAL). The critical principle: transactions are denied unless explicitly allowed by policy configuration.

# Create spending limit 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": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 10,
      "notify_max_usd": 100,
      "delay_max_usd": 1000,
      "delay_seconds": 900,
      "daily_limit_usd": 5000
    }
  }'

This spending policy creates a security gradient: small amounts execute instantly, medium amounts trigger notifications, larger amounts wait 15 minutes (allowing cancellation), and amounts above $1000 require explicit human approval.

The default-deny approach prevents the classic attack vector where agents interact with malicious contracts not anticipated during development. Without CONTRACT_WHITELIST and ALLOWED_TOKENS policies, the agent simply cannot execute those transactions:

# Whitelist specific tokens only
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": "ALLOWED_TOKENS",
    "rules": {
      "tokens": [
        {"address": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v", "symbol": "USDC", "chain": "solana"}
      ]
    }
  }'

Layer 3: Human Approval Channels

For high-value transactions exceeding policy thresholds, WAIaaS routes approval requests through 3 signing channels: push notifications, Telegram bots, and WalletConnect integration.

# Transaction exceeding limits gets queued for approval
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": "5.0"
  }'

# Returns: {"id": "tx-uuid", "status": "PENDING_APPROVAL"}

The human owner receives push notification with transaction details and can approve/deny through their preferred channel. This creates an air gap between the AI agent and high-value transactions while maintaining operational efficiency for routine activities.

Credential Isolation and Recovery

WAIaaS separates three distinct credential types with different privilege levels:

masterAuth (Argon2id): System administration — wallet creation, policy configuration, session management
sessionAuth (JWT HS256): AI agent operations — balance queries, small transactions, DeFi interactions
ownerAuth (SIWS/SIWE): Fund owner control — transaction approval, emergency kill switch

This separation means compromising one credential doesn't grant access to others. An agent's leaked session token cannot modify spending policies or create new wallets. A compromised master password cannot approve pending transactions — that requires cryptographic signatures from the fund owner.

# Different auth for different operations
# AI agent checks balance (sessionAuth)
curl http://127.0.0.1:3100/v1/wallet/balance \
  -H "Authorization: Bearer wai_sess_<token>"

# Human approves large transaction (ownerAuth)
curl -X POST http://127.0.0.1:3100/v1/transactions/<tx-id>/approve \
  -H "X-Owner-Signature: <ed25519-signature>" \
  -H "X-Owner-Message: <signed-message>"

Operational Security in Practice

The 7-stage transaction pipeline validates every request through multiple checkpoints before execution:

Validate — Schema validation, parameter checking
Auth — Session token verification, scope checking
Policy — Rule evaluation, tier assignment
Wait — Delay enforcement for DELAY-tier transactions
Execute — Blockchain transaction submission
Confirm — Transaction monitoring and finalization
Log — Audit trail recording

# Simulate before executing to catch policy violations
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
  }'

The dry-run capability lets agents validate transactions against current policies without submitting to the blockchain. This prevents failed transactions and helps agents adapt their behavior to policy constraints.

Self-Hosted Control

Since WAIaaS runs entirely self-hosted, credential security doesn't depend on third-party services. Your session tokens, master passwords, and private keys never leave your infrastructure:

services:
  daemon:
    image: ghcr.io/minhoyoo-iotrust/waiaas:latest
    ports:
      - "127.0.0.1:3100:3100"  # Localhost only by default
    volumes:
      - waiaas-data:/data      # Local encrypted storage
    environment:
      - WAIAAS_DATA_DIR=/data

The Docker deployment binds to localhost by default, preventing external network exposure. All sensitive data stays encrypted in local volumes under your direct control.

Quick Start: Secure Agent Setup

Deploy with auto-provisioning:

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

Retrieve auto-generated master password:

docker exec waiaas cat /data/recovery.key

Create wallet with spending limits:

waiaas quickset --mode testnet  # Creates wallet + policies + session

Connect AI agent with session token:

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

Test with small transaction to verify policy enforcement before production use.

Understanding these security layers helps you deploy AI agents with confidence, knowing that multiple failsafes protect against both technical vulnerabilities and operational mistakes.

Self-Hosting Wallet Infrastructure: Docker Deployment Guide for AI Agents provides detailed deployment security configurations, while Policy Engine Deep Dive: 4-Tier Security for AI Agent Transactions explores advanced policy patterns for different risk profiles.

What's Next

Start with testnet deployment to experiment with policy configurations before handling real funds. The WAIaaS documentation at https://waiaas.ai covers advanced topics like multi-signature integration and custom policy development. Explore the complete implementation on GitHub at https://github.com/minhoyoo-iotrust/WAIaaS to understand the security architecture in detail.

Beyond Transactions: How AI Agents Execute Offchain Actions

Wallet Guy — Sun, 12 Apr 2026 07:47:24 +0000

Your AI agents can analyze market data, generate trading strategies, and even write smart contracts. But when it comes to actually executing transactions, they hit a wall. Most agents are stuck in read-only mode, unable to interact with DeFi protocols or handle real money. WAIaaS changes this by giving AI agents secure wallet capabilities through a self-hosted API that integrates with popular frameworks like Claude MCP.

Why Offchain Actions Matter for AI Agents

Traditional blockchain interactions focus on transactions — moving tokens, calling smart contracts, minting NFTs. But real AI agent workflows require much more. Your agent might need to check DeFi positions across multiple protocols, pay for API calls automatically using crypto, or execute complex multi-step strategies that combine onchain and offchain operations.

The challenge isn't just about having a wallet. It's about giving agents the right level of access without compromising security. You need granular policies, multi-layered approval systems, and the ability to revoke access instantly if something goes wrong.

WAIaaS Offchain Action Framework

WAIaaS provides 45 MCP tools that extend far beyond basic transactions. These tools are organized into categories that mirror how AI agents actually work:

Wallet Operations: Balance checks, address resolution, and asset management across multiple chains. Your agent can query positions across 15 DeFi protocols and get a unified view.

Transaction Pipeline: Not just sending transactions, but simulating them first, checking policy compliance, and handling multi-step approvals. Every transaction goes through a 7-stage pipeline with built-in safety checks.

DeFi Integration: Direct protocol integration means agents can interact with Aave, Jupiter, Lido, and other protocols without writing custom smart contract code.

Cross-Chain Actions: Bridge assets automatically using LI.FI and Across protocols when the agent's strategy requires tokens on different chains.

Payment Automation: The x402 HTTP payment protocol lets agents pay for API calls using crypto, enabling truly autonomous operation.

Here's how an AI agent checks DeFi positions across all protocols:

curl http://127.0.0.1:3100/v1/defi/positions \
  -H "Authorization: Bearer wai_sess_eyJhbGciOiJIUzI1NiJ9..."

The response includes lending positions, staking rewards, and LP positions with USD values calculated automatically:

{
  "positions": [
    {
      "protocol": "aave-v3",
      "type": "lending",
      "asset": "USDC",
      "amount": "1500.00",
      "apy": "4.2%",
      "health_factor": "2.1"
    },
    {
      "protocol": "lido",
      "type": "staking",
      "asset": "stETH",
      "amount": "0.5",
      "rewards_earned": "0.002"
    }
  ]
}

Policy-Driven Security for Autonomous Agents

The biggest concern with AI agents handling money is security. WAIaaS addresses this with 21 policy types and 4 security tiers. Instead of giving agents unlimited access, you define exactly what they can do:

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
    }
  }'

This policy creates a 4-tier system:

INSTANT: Transactions under $100 execute immediately
NOTIFY: $100-500 transactions execute with notifications
DELAY: $500-2000 transactions wait 15 minutes (cancellable)
APPROVAL: Anything over $2000 requires human approval

You can also restrict which tokens, contracts, and DeFi protocols the agent can access. The default-deny approach means agents are blocked from unexpected actions unless explicitly permitted.

MCP Integration: Plug and Play AI Wallets

Model Context Protocol (MCP) makes it trivial to give existing AI frameworks wallet capabilities. WAIaaS provides an MCP server with all 45 tools pre-configured:

npm install -g @waiaas/cli
waiaas quickset --mode mainnet
waiaas mcp setup --all

This automatically registers WAIaaS with Claude Desktop. Your Claude agent immediately gains access to wallet operations:

{
  "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>",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}

Now Claude can perform complex blockchain operations through natural language:

User: "Check my DeFi positions and rebalance if my Aave health factor is below 1.5"

Claude: Uses get_defi_positions tool → sees health factor of 1.2 → uses action_provider tool to repay some debt → confirms with get_defi_positions again.

Advanced Use Cases: x402 and ERC-8004

WAIaaS enables AI agent patterns that aren't possible with traditional wallets. The x402 HTTP payment protocol lets agents pay for API services automatically:

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 when service returns HTTP 402
const response = await client.x402Fetch('https://api.market-data.ai/analysis', {
  method: 'POST',
  body: JSON.stringify({ symbol: 'BTC' }),
});

console.log('Paid for analysis:', await response.json());

The agent's wallet automatically handles the payment negotiation, making API services truly frictionless.

ERC-8004 integration provides onchain agent reputation. Your agents can prove their track record and gain access to higher-value operations based on historical performance:

curl http://127.0.0.1:3100/v1/erc8004/agent-info/<agent-address> \
  -H "Authorization: Bearer wai_sess_<token>"

Multi-Chain Agent Strategies

Real AI trading agents need to work across multiple chains. WAIaaS supports 18 networks across EVM and Solana, with automatic bridging when strategies require cross-chain execution.

Here's an agent executing a cross-chain arbitrage strategy:

# 1. Check prices on both chains
curl http://127.0.0.1:3100/v1/actions/jupiter-swap/quote \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{"inputMint": "SOL", "outputMint": "USDC", "amount": "1"}'

curl http://127.0.0.1:3100/v1/actions/zerox-swap/quote \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{"sellToken": "ETH", "buyToken": "USDC", "sellAmount": "0.6"}'

# 2. Bridge assets to optimal chain
curl -X POST http://127.0.0.1:3100/v1/actions/lifi/bridge \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "fromChain": "solana",
    "toChain": "ethereum",
    "fromToken": "USDC",
    "toToken": "USDC",
    "amount": "1000"
  }'

# 3. Execute optimal trade
curl -X POST http://127.0.0.1:3100/v1/actions/zerox-swap/swap \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{"sellToken": "USDC", "buyToken": "ETH", "sellAmount": "1000"}'

The agent handles all the complexity — quote comparison, bridge execution, and final trades — while WAIaaS ensures each step complies with your security policies.

Quick Start: Give Your Agent a Wallet

Step 1: Install and initialize WAIaaS

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

Step 2: Create wallets and sessions

waiaas quickset --mode mainnet

Step 3: Set up MCP integration

waiaas mcp setup --all

Step 4: Configure policies

waiaas quickstart
# Follow prompts to set spending limits and token whitelist

Step 5: Test with Claude
Open Claude Desktop and ask: "What's my wallet balance?" Your agent now has full blockchain capabilities.

What's Next

WAIaaS transforms AI agents from observers to participants in the crypto economy. Your agents can now execute complex DeFi strategies, pay for services automatically, and operate with the security controls you need for production use.

Ready to give your AI agent a wallet? Check out the WAIaaS GitHub repository for full documentation and examples. Visit waiaas.ai to explore all capabilities and join the community building the future of AI-powered finance.

Keep Your AI Agent Solvent: Health Factor Monitoring for DeFi Lending

Wallet Guy — Sat, 11 Apr 2026 14:00:47 +0000

When DeFi lending protocols liquidate positions at 1.05x health factor, your AI trading bot can lose thousands in seconds. If you're building automated yield strategies or DeFi bots, you need real-time health factor monitoring across multiple protocols — but each one has different APIs, calculation methods, and liquidation thresholds.

Why Health Factor Monitoring Is Critical

In DeFi lending, your health factor is the difference between profit and liquidation. Aave liquidates at 1.0, Kamino at 1.1, and each protocol calculates it differently. Your AI agent might be managing positions across multiple protocols simultaneously — a profitable arbitrage strategy on one platform could trigger a liquidation cascade on another if you're not monitoring cross-protocol risk.

Manual monitoring doesn't scale. By the time you check each protocol's dashboard, volatile markets have already moved. You need programmatic access to health factors, collateral ratios, and liquidation thresholds — ideally through a single API that normalizes data across protocols.

Unified Health Factor Monitoring with WAIaaS

WAIaaS provides real-time DeFi position monitoring across 15 protocols through a single REST API. Your AI agent gets normalized health factor data from Aave V3, Kamino, Drift, and other major protocols without managing multiple SDKs or RPC connections.

Here's how to check your health factor across all protocols:

curl http://127.0.0.1:3100/v1/wallet/defi-positions \
  -H "Authorization: Bearer wai_sess_eyJhbGciOiJIUzI1NiJ9..."

The response includes health factors, liquidation thresholds, and collateral values in USD:

{
  "positions": [
    {
      "protocol": "aave-v3",
      "network": "ethereum-mainnet",
      "healthFactor": 1.85,
      "liquidationThreshold": 1.0,
      "totalCollateralUsd": 5420.30,
      "totalBorrowedUsd": 2930.15,
      "assets": [
        {
          "asset": "WETH",
          "type": "collateral",
          "amount": "2.1",
          "valueUsd": 4200.30,
          "apy": 0.0245
        }
      ]
    },
    {
      "protocol": "kamino",
      "network": "solana-mainnet", 
      "healthFactor": 2.34,
      "liquidationThreshold": 1.1,
      "totalCollateralUsd": 8750.25,
      "totalBorrowedUsd": 3740.10
    }
  ],
  "summary": {
    "totalCollateralUsd": 14170.55,
    "totalBorrowedUsd": 6670.25,
    "aggregateHealthFactor": 2.12,
    "lowestHealthFactor": 1.85,
    "protocolsAtRisk": 0
  }
}

Setting Up Health Factor Alerts

WAIaaS includes policy-based monitoring that can trigger notifications when health factors drop below thresholds. Create a lending policy with health factor limits:

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": "LENDING_LTV_LIMIT",
    "rules": {
      "max_ltv_ratio": 0.75,
      "health_factor_warning": 1.5,
      "health_factor_critical": 1.2,
      "auto_deleverage_threshold": 1.1,
      "notification_channels": ["telegram", "webhook"]
    }
  }'

When your health factor drops below 1.5, WAIaaS sends a warning notification. At 1.2, it triggers a critical alert. Below 1.1, it can automatically trigger deleveraging actions to prevent liquidation.

Automated Position Management

Beyond monitoring, WAIaaS lets your AI agent automatically manage positions based on health factor changes. Here's how to set up an automated deleveraging strategy:

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

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

async function monitorAndDeleverage() {
  const positions = await client.getDeFiPositions();

  for (const position of positions.positions) {
    if (position.healthFactor < 1.3) {
      console.log(`⚠️ Health factor ${position.healthFactor} on ${position.protocol}`);

      // Calculate repayment needed to reach safe health factor (>2.0)
      const targetHealthFactor = 2.0;
      const repaymentNeeded = calculateRepayment(position, targetHealthFactor);

      // Execute repayment through WAIaaS
      const tx = await client.executeAction('aave-v3', 'repay', {
        asset: position.borrowedAsset,
        amount: repaymentNeeded.toString(),
        walletAddress: position.walletAddress
      });

      console.log(`🔧 Deleveraging tx: ${tx.id}`);
    }
  }
}

function calculateRepayment(position, targetHF) {
  // Simplified calculation - real implementation should account for
  // liquidation thresholds, price impact, and protocol-specific factors
  const currentLTV = position.totalBorrowedUsd / position.totalCollateralUsd;
  const targetLTV = currentLTV / targetHF;
  const repaymentUsd = position.totalBorrowedUsd * (currentLTV - targetLTV);
  return repaymentUsd / position.borrowAssetPrice;
}

// Run monitoring every 30 seconds
setInterval(monitorAndDeleverage, 30000);

Cross-Protocol Risk Assessment

WAIaaS aggregates positions across all protocols to give you portfolio-wide risk metrics. This prevents situations where closing a position on one protocol inadvertently triggers liquidation on another due to collateral interdependencies.

The aggregateHealthFactor in the API response considers cross-protocol correlations and shared collateral assets. If you're using the same WETH as collateral on both Aave and Compound, WAIaaS factors this into the risk calculation.

You can also set protocol-specific limits through policies:

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": "LENDING_ASSET_WHITELIST",
    "rules": {
      "allowed_collateral": [
        {"asset": "WETH", "max_ltv": 0.8},
        {"asset": "WBTC", "max_ltv": 0.75},
        {"asset": "USDC", "max_ltv": 0.9}
      ],
      "allowed_borrow": ["USDC", "DAI", "USDT"],
      "protocol_limits": {
        "aave-v3": {"max_position_usd": 50000},
        "kamino": {"max_position_usd": 25000}
      }
    }
  }'

Integration with Trading Strategies

Health factor monitoring becomes powerful when integrated with your existing trading logic. WAIaaS provides WebSocket subscriptions for real-time position updates:

// Subscribe to position updates
const ws = new WebSocket('ws://127.0.0.1:3100/v1/subscriptions/defi-positions');

ws.on('message', (data) => {
  const update = JSON.parse(data);

  if (update.type === 'health_factor_change') {
    const { protocol, oldHealthFactor, newHealthFactor, change } = update;

    if (newHealthFactor < 1.5 && change < -0.1) {
      // Health factor dropped significantly - pause new borrows
      pauseBorrowingStrategy(protocol);

      // Consider taking profits on related positions
      await reduceExposure(protocol, 0.2); // Reduce by 20%
    }
  }
});

Quick Start: Set Up Health Factor Monitoring

Here's how to get health factor monitoring running in under 5 minutes:

Start WAIaaS daemon:

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

Create a wallet and session:

waiaas quickset --mode mainnet
# Copy the session token from output

Check your current DeFi positions:

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

Set up health factor alerts:

curl -X POST http://127.0.0.1:3100/v1/policies \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: <your-password>" \
  -d '{
    "walletId": "<wallet-id>",
    "type": "LENDING_LTV_LIMIT", 
    "rules": {"health_factor_warning": 1.5}
  }'

Monitor programmatically:

import { WAIaaSClient } from '@waiaas/sdk';
const client = new WAIaaSClient({
  sessionToken: 'wai_sess_<your-token>'
});
const positions = await client.getDeFiPositions();
console.log(`Lowest health factor: ${positions.summary.lowestHealthFactor}`);

Advanced: Multi-Wallet Portfolio Monitoring

For institutional strategies managing multiple wallets, WAIaaS supports portfolio-wide risk monitoring. Each wallet can have different risk profiles and health factor thresholds:

# Conservative wallet - early warnings
curl -X POST http://127.0.0.1:3100/v1/policies \
  -d '{"walletId": "conservative-wallet", "type": "LENDING_LTV_LIMIT", 
       "rules": {"health_factor_warning": 2.0, "max_ltv_ratio": 0.6}}'

# Aggressive wallet - higher risk tolerance  
curl -X POST http://127.0.0.1:3100/v1/policies \
  -d '{"walletId": "aggressive-wallet", "type": "LENDING_LTV_LIMIT",
       "rules": {"health_factor_warning": 1.3, "max_ltv_ratio": 0.85}}'

WAIaaS aggregates risk metrics across all wallets, giving you portfolio-wide health factors and correlation analysis between positions.

What's Next

Health factor monitoring is just one piece of comprehensive DeFi risk management. WAIaaS also provides cross-chain bridging, automated rebalancing, and integration with 15 DeFi protocols through a single API.

Ready to protect your DeFi positions from liquidation? Get started at GitHub or learn more at waiaas.ai. Your trading bot's survival depends on staying ahead of health factor drops — don't wait for the next market crash to find out your monitoring isn't fast enough.

Self-Hosted RPC Proxy: Why Your AI Agent Shouldn't Hit Public Endpoints

Wallet Guy — Sat, 11 Apr 2026 07:31:10 +0000

RPC proxy management becomes critical when your AI agent is hitting rate limits, burning through API credits, or leaking transaction patterns to public endpoints. Most developers start with Infura or Alchemy, but quickly discover they're paying premium prices for basic infrastructure while sacrificing privacy and control.

Why RPC Proxies Matter for AI Agents

AI agents make hundreds of blockchain queries per hour — checking balances, simulating transactions, monitoring gas prices, and validating smart contract states. Unlike human users who might check their wallet a few times per day, autonomous agents are constantly polling the network.

Public RPC endpoints throttle requests, charge per call, and log every query. Your trading strategies, wallet addresses, and transaction patterns become visible to third parties. For production agents managing real funds, this creates both cost and security concerns.

WAIaaS Built-in RPC Proxy

WAIaaS includes a self-hosted RPC proxy that sits between your AI agent and blockchain networks. Instead of your agent hitting external endpoints directly, it routes all requests through your local WAIaaS instance, which then forwards them to your configured RPC providers.

Here's how to check your RPC proxy configuration:

curl http://127.0.0.1:3100/v1/rpc-proxy-url \
  -H "Authorization: Bearer wai_sess_<your-token>"

The proxy automatically handles:

Request caching to reduce upstream calls
Failover between multiple RPC providers
Rate limiting and retry logic
Request/response logging for debugging

Setting Up Your RPC Infrastructure

WAIaaS supports 2 chain types (EVM and Solana) across 18 networks. For each network you plan to use, configure at least one RPC endpoint in your environment variables:

# Ethereum mainnet
WAIAAS_RPC_EVM_ETHEREUM_MAINNET=https://eth-mainnet.g.alchemy.com/v2/your-key

# Solana mainnet  
WAIAAS_RPC_SOLANA_MAINNET=https://api.mainnet-beta.solana.com

# Base mainnet
WAIAAS_RPC_EVM_BASE_MAINNET=https://base-mainnet.g.alchemy.com/v2/your-key

# Polygon
WAIAAS_RPC_EVM_POLYGON_MAINNET=https://polygon-rpc.com

For production setups, configure multiple RPC providers per network for redundancy:

# Multiple providers for Ethereum (comma-separated)
WAIAAS_RPC_EVM_ETHEREUM_MAINNET=https://eth.llamarpc.com,https://rpc.ankr.com/eth,https://ethereum.publicnode.com

Docker Deployment with RPC Configuration

The Docker deployment makes RPC proxy setup straightforward. Create an .env file with your RPC endpoints:

# .env file
WAIAAS_RPC_SOLANA_MAINNET=https://api.mainnet-beta.solana.com
WAIAAS_RPC_EVM_ETHEREUM_MAINNET=https://eth-mainnet.g.alchemy.com/v2/your-key
WAIAAS_RPC_EVM_BASE_MAINNET=https://base-mainnet.g.alchemy.com/v2/your-key
WAIAAS_RPC_EVM_ARBITRUM_MAINNET=https://arb1.arbitrum.io/rpc

Then start WAIaaS with Docker Compose:

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
    env_file:
      - path: .env
        required: false
    restart: unless-stopped

volumes:
  waiaas-data:
    driver: local

Why Self-Hosted Beats Managed Services

Cost Control: Instead of paying per API call, you pay your RPC provider's flat rate (or run your own nodes). For high-frequency agents, this can reduce costs by 10x.

Privacy: Your transaction patterns stay local. No third party sees which tokens you're querying, which contracts you're analyzing, or when you're preparing transactions.

Reliability: Configure multiple RPC providers with automatic failover. If one goes down, your agent keeps running.

Customization: Built-in caching, custom retry logic, and request filtering. You control how your agent interacts with the blockchain.

No Vendor Lock-in: Switch RPC providers without changing your agent code. The proxy abstracts away provider-specific quirks.

Integration with AI Agent Frameworks

The RPC proxy works seamlessly with WAIaaS's 45 MCP tools for Claude Desktop and other AI frameworks. When your AI agent calls blockchain functions, it automatically routes through your local proxy:

# Configure MCP to use your WAIaaS instance
{
  "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>"
      }
    }
  }
}

Your AI agent's blockchain queries — balance checks, transaction simulations, DeFi position monitoring — all route through your self-hosted infrastructure.

Quick Start: Self-Hosted RPC Proxy

Clone and configure:

git clone https://github.com/minhoyoo-iotrust/WAIaaS.git
cd WAIaaS
echo "WAIAAS_RPC_SOLANA_MAINNET=https://api.mainnet-beta.solana.com" > .env

Start with Docker:

docker compose up -d

Create a wallet and session:

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

Test the RPC proxy:

curl http://127.0.0.1:3100/v1/rpc-proxy-url \
  -H "Authorization: Bearer wai_sess_<your-token>"

Set up MCP integration:

waiaas mcp setup --all

Your AI agent now has a self-hosted RPC proxy handling all blockchain interactions, with full control over providers, caching, and failover logic.

For deeper integration patterns and advanced configurations, check out the GitHub repository at https://github.com/minhoyoo-iotrust/WAIaaS and explore the full documentation at https://waiaas.ai.

What's Next

Ready to eliminate RPC bottlenecks and reclaim control of your AI agent's blockchain infrastructure? The self-hosted approach gives you the privacy, reliability, and cost control that production agents demand.

Push Relay + Telegram: Real-Time Transaction Approval for AI Agents

Wallet Guy — Fri, 10 Apr 2026 14:20:12 +0000

AI agents with crypto wallets need real-time approval systems to prevent unauthorized transactions while maintaining operational speed. When your trading bot or DeFi agent encounters a high-value transaction that exceeds policy limits, you need immediate notification and the ability to approve or deny the action without compromising security or custody control.

Why Real-Time Approval Matters

The challenge with autonomous AI agents isn't just preventing them from making bad trades—it's maintaining oversight without becoming a bottleneck. Traditional crypto security assumes human-only access, but AI agents operate at machine speed across multiple protocols simultaneously. A spending limit policy might catch obvious problems, but what about edge cases? Market opportunities that exceed your daily limits? Emergency liquidations during volatile conditions?

You need a system that can instantly notify you when agent actions require approval, provide transaction context, and let you respond immediately from any device. Email notifications are too slow, SMS lacks transaction details, and checking a web dashboard isn't practical when you're away from your computer.

How WAIaaS Implements Real-Time Approval

WAIaaS provides 2 real-time approval channels specifically designed for AI agent oversight: Push Relay notifications and Telegram integration. Both work with WAIaaS's 4-tier security system (INSTANT/NOTIFY/DELAY/APPROVAL) to give you precise control over when human approval is required.

Push Relay: Native Mobile Notifications

The Push Relay service sends native push notifications to your mobile device whenever an AI agent transaction requires approval. Unlike generic notification services, Push Relay is built specifically for crypto transaction approval workflows.

Here's how to set up Push Relay for transaction approval:

# Start both daemon and push-relay services
docker compose up -d

# The push-relay service runs on port 3101 by default
# Check if it's running
curl http://127.0.0.1:3101/health

Configure your wallet policies to trigger APPROVAL tier for high-value transactions:

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
    }
  }'

When your AI agent attempts a transaction exceeding these limits, Push Relay immediately sends a notification containing:

Transaction amount and recipient
Risk assessment and policy violation details
One-tap approve/deny buttons
Estimated gas costs and slippage
Market context (for DeFi actions)

Telegram Integration: Cross-Platform Approval

Telegram provides a more detailed approval interface with rich transaction previews and conversation history. The Telegram signing channel supports both individual and group-based approval workflows.

Set up Telegram notifications through the CLI:

waiaas notification setup --provider telegram --bot-token <your-bot-token>

Configure a policy to route APPROVAL-tier transactions to Telegram:

{
  "type": "SPENDING_LIMIT",
  "rules": {
    "instant_max_usd": 50,
    "approval_channel": "telegram",
    "delay_seconds": 300
  }
}

When an AI agent transaction requires approval, you receive a Telegram message with:

Formatted transaction details
Links to block explorers for verification
Inline buttons for approve/deny/delay
Transaction simulation results
Recent agent activity context

3-Layer Security Architecture

Push Relay and Telegram approval integrate with WAIaaS's broader security model:

Layer 1: Session Authentication - AI agents use short-lived JWT tokens with configurable TTL and renewal limits. Sessions can be instantly revoked if agent behavior becomes suspicious.

Layer 2: Policy Engine - 21 policy types provide default-deny protection. The ALLOWED_TOKENS and CONTRACT_WHITELIST policies ensure agents can only interact with pre-approved assets and protocols:

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"},
        {"address": "So11111111111111111111111111111111111111112", "symbol": "SOL", "chain": "solana"}
      ]
    }
  }'

Layer 3: Real-Time Approval - Push Relay and Telegram provide the final human oversight layer. Even if an agent finds a way around other protections, high-value transactions still require your explicit approval.

Advanced Approval Workflows

Time-Based Delays with Cancellation

Some transactions benefit from a cooling-off period. WAIaaS's DELAY tier queues transactions for a specified time, during which you can review and cancel if needed:

{
  "type": "SPENDING_LIMIT",
  "rules": {
    "delay_max_usd": 2000,
    "delay_seconds": 900,
    "delay_cancellable": true
  }
}

Push Relay sends notifications at three stages:

Immediate: "Transaction queued for 15-minute delay"
Mid-delay: "5 minutes remaining to cancel transaction"
Pre-execution: "Transaction executing in 30 seconds"

Multi-Signature Group Approval

For institutional use cases, Telegram group integration allows multiple team members to review and approve agent transactions:

# Add Telegram group as approval channel
waiaas notification setup --provider telegram --group-id <group-id> --required-approvals 2

Emergency Kill Switch

Both Push Relay and Telegram provide instant kill switch functionality. A single tap can:

Revoke all active agent sessions
Cancel all pending/delayed transactions
Freeze wallet activity until manual review
Export transaction logs for forensic analysis

Quick Start: Set Up Real-Time Approval

Here's how to get approval notifications working in under 5 minutes:

Step 1: Deploy WAIaaS with Push Relay enabled:

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

Step 2: Create a wallet and session for your AI agent:

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

Step 3: Set up approval policies that trigger for transactions over your comfort level:

curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <your-password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "SPENDING_LIMIT",
    "rules": {
      "instant_max_usd": 25,
      "approval_max_usd": 500
    }
  }'

Step 4: Configure Push Relay or Telegram notifications:

# Option A: Push Relay (iOS/Android app)
waiaas notification setup --provider push-relay --device-token <token>

# Option B: Telegram bot
waiaas notification setup --provider telegram --bot-token <bot-token>

Step 5: Test the approval flow by having your agent attempt a transaction above your instant limit. You should receive a notification within seconds.

What's Next

Real-time approval bridges the gap between AI agent autonomy and security requirements, but it's just one component of comprehensive agent wallet management. For production deployments, you'll also want to explore rate limiting, contract whitelisting, and DeFi-specific policies that understand protocol risks.

Ready to implement bulletproof AI agent security? Check out the full implementation on GitHub or explore the complete security model at waiaas.ai.

ERC-8128 Message Signing: Verifiable AI Agent Communications

Wallet Guy — Fri, 10 Apr 2026 08:03:06 +0000

ERC-8128 message signing enables verifiable communications between AI agents without requiring blockchain transactions. Developers building agent-to-agent systems need cryptographic proof that messages actually came from the claimed sender, but current solutions either require expensive on-chain transactions or rely on centralized intermediaries that compromise decentralization.

Why Message Verification Matters for AI Agents

AI agents increasingly communicate with each other — coordinating trades, sharing market intelligence, or negotiating resource allocation. Without cryptographic verification, any agent can impersonate another, leading to manipulation attacks, false information propagation, or unauthorized actions performed under a trusted agent's identity.

Traditional message signing requires agents to expose private keys or rely on centralized authentication servers. ERC-8128 provides a standardized way for agents to sign messages with their wallet keys, creating verifiable proof of authorship that any other agent can validate independently.

ERC-8128 in WAIaaS: Secure Agent Communications

WAIaaS implements ERC-8128 message signing as part of its comprehensive security framework. AI agents can sign messages with their wallet's private key, and recipients can cryptographically verify the signature without trusting third parties.

This fits into WAIaaS's 3-layer security model:

Session auth controls what actions agents can perform
Policy engine enforces spending limits and whitelists
Message signing proves agent identity in communications

Sign a Message with ERC-8128

curl -X POST http://127.0.0.1:3100/v1/erc8128/sign \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "message": "MarketAnalysis: BTC trend bullish, confidence 0.87",
    "domain": "agent-network.example.com"
  }'

The response includes the signature and metadata needed for verification:

{
  "signature": "0x1234567890abcdef...",
  "message": "MarketAnalysis: BTC trend bullish, confidence 0.87",
  "domain": "agent-network.example.com",
  "signer": "0xabcdef1234567890...",
  "timestamp": "2026-04-09T10:30:00Z"
}

Verify Message Signatures

Recipients verify signatures without network calls:

curl -X POST http://127.0.0.1:3100/v1/erc8128/verify \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer wai_sess_<token>" \
  -d '{
    "signature": "0x1234567890abcdef...",
    "message": "MarketAnalysis: BTC trend bullish, confidence 0.87",
    "domain": "agent-network.example.com",
    "signer": "0xabcdef1234567890..."
  }'

Returns verification status:

{
  "valid": true,
  "signer": "0xabcdef1234567890...",
  "recoveredAddress": "0xabcdef1234567890..."
}

Security Through Policy Control

WAIaaS enforces message signing through policy controls. The ERC8128_ALLOWED_DOMAINS policy restricts which domains agents can sign messages for:

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": "ERC8128_ALLOWED_DOMAINS",
    "rules": {
      "domains": ["agent-network.example.com", "trading-pool.dao"]
    }
  }'

This prevents agents from signing arbitrary messages for unauthorized domains, reducing the attack surface for signature replay or domain confusion attacks.

MCP Integration for Claude Desktop

The ERC-8128 tools integrate seamlessly with Claude Desktop through MCP:

erc8128-sign-request — Sign messages with wallet key
erc8128-verify-signature — Verify received signatures

After setting up MCP integration, Claude can sign and verify messages directly:

{
  "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>"
      }
    }
  }
}

Claude can then handle commands like "Sign this market analysis report" or "Verify this message from the trading agent."

Default-Deny Security Model

WAIaaS follows default-deny principles for message signing. Without an ERC8128_ALLOWED_DOMAINS policy, agents cannot sign messages at all. This prevents unauthorized signature generation even if session tokens are compromised.

The policy system enforces:

Domain restrictions — Only sign for whitelisted domains
Rate limiting — Prevent signature spam attacks
Time restrictions — Limit signing to business hours
Approval tiers — Require human approval for sensitive domains

Real-World Use Cases

Decentralized Trading Coordination

AI trading agents coordinate strategies by signing market analysis messages. Each agent verifies signatures before acting on intelligence, preventing manipulation by rogue agents.

Agent Reputation Systems

Combined with ERC-8004 onchain reputation, signed messages create verifiable agent communication histories. Bad actors can be identified and blacklisted based on their signature patterns.

Cross-Chain Agent Networks

Agents on different blockchains use ERC-8128 signatures to prove identity across chains, enabling unified agent networks spanning Ethereum, Solana, and other ecosystems.

Quick Start: Agent Message Signing

Install and start WAIaaS:

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

Create domain policy:

   curl -X POST http://127.0.0.1:3100/v1/policies \
     -H "Content-Type: application/json" \
     -H "X-Master-Password: <password>" \
     -d '{"walletId": "<uuid>", "type": "ERC8128_ALLOWED_DOMAINS", "rules": {"domains": ["your-domain.com"]}}'

Sign your first message:

   curl -X POST http://127.0.0.1:3100/v1/erc8128/sign \
     -H "Authorization: Bearer <session-token>" \
     -d '{"message": "Hello, agent network!", "domain": "your-domain.com"}'

Verify the signature using the returned data with the verify endpoint
Set up MCP for Claude Desktop integration using waiaas mcp setup --all

What's Next

ERC-8128 message signing provides the cryptographic foundation for trustless agent communications. Combined with WAIaaS's policy engine and session controls, you get verifiable agent identity with granular security controls.

Ready to build secure agent communication systems? Check out the code at GitHub or explore the full platform at waiaas.ai.

Production-Ready Docker Deployment: Secrets Overlay and Auto-Provisioning

Wallet Guy — Thu, 09 Apr 2026 14:59:53 +0000

Getting a production-ready Docker deployment for your AI agent's wallet infrastructure requires more than just docker run — you need secure secret management and automated provisioning that won't expose sensitive credentials to your deployment pipeline or containers. Self-hosting your wallet infrastructure means total control over private keys, policies, and transaction approvals without depending on third-party services that could leak data or impose rate limits.

Why Docker Security Matters for Wallet Infrastructure

When you're managing private keys and handling real cryptocurrency transactions, your deployment security becomes critical. A misconfigured container could expose master passwords in environment variables, process lists, or container logs. Traditional Docker deployments often require hardcoded secrets in docker-compose files or shell scripts — exactly what attackers look for.

WAIaaS addresses this with Docker Secrets integration and auto-provisioning features designed specifically for self-hosted wallet infrastructure. You get enterprise-grade secret management without the complexity of full orchestration platforms like Kubernetes.

The Two-Layer Security Approach

WAIaaS implements a dual-security model for production deployments:

Layer 1: Auto-Provisioning for First Boot
On initial startup, WAIaaS can generate cryptographically secure master passwords and save them to protected recovery files. This eliminates the chicken-and-egg problem of bootstrapping wallet infrastructure without manual intervention.

Layer 2: Docker Secrets Overlay
For ongoing operations, sensitive credentials are injected through Docker's built-in secrets mechanism, keeping passwords out of environment variables and container filesystems.

Docker Secrets Integration

The production deployment uses a secrets overlay pattern. Here's your base docker-compose.yml:

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
    env_file:
      - path: .env
        required: false
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3100/health"]
      interval: 30s
      timeout: 5s
      start_period: 10s
      retries: 3

volumes:
  waiaas-data:
    driver: local

For production, you add the secrets overlay (docker-compose.secrets.yml):

# Create secret files with proper permissions
mkdir -p secrets
echo "your-secure-master-password" > secrets/master_password.txt
chmod 600 secrets/master_password.txt
chown root:root secrets/master_password.txt

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

This approach keeps secrets out of your main compose file and git repository. The secrets overlay is loaded only in production environments and can be managed by your deployment automation without exposing credentials.

Auto-Provisioning for Zero-Touch Deployment

For fully automated deployments, WAIaaS supports auto-provisioning mode:

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 master password
docker exec waiaas cat /data/recovery.key

The auto-provision feature generates a cryptographically secure master password using the same entropy sources as wallet key generation. The password is saved to /data/recovery.key inside the container and mounted volume, allowing you to retrieve it programmatically for further automation.

This is especially valuable for infrastructure-as-code deployments where you can't provide interactive password input. Your deployment script can start the container, retrieve the generated password, and securely store it in your secret management system.

Production Environment Configuration

Key environment variables for production deployments:

WAIAAS_AUTO_PROVISION=true              # Generate master password on first start
WAIAAS_DAEMON_PORT=3100                 # Internal listening port
WAIAAS_DAEMON_HOSTNAME=0.0.0.0         # Bind to all interfaces (inside container)
WAIAAS_DAEMON_LOG_LEVEL=info            # Avoid debug logs in production
WAIAAS_DATA_DIR=/data                   # Persistent data location
WAIAAS_RPC_SOLANA_MAINNET=<url>         # Your Solana RPC endpoint
WAIAAS_RPC_EVM_ETHEREUM_MAINNET=<url>   # Your Ethereum RPC endpoint

The Docker image runs as a non-root user (UID 1001) by default, following security best practices. The healthcheck endpoint at /health integrates with Docker's health monitoring and orchestration platforms.

Network Security and Port Binding

Notice the port binding in the default configuration: 127.0.0.1:3100:3100. This binds only to localhost, preventing external network access to your wallet infrastructure. For production deployments, you typically want this behind a reverse proxy with TLS termination and authentication.

If you need direct external access, you can modify the port binding, but ensure you have proper firewall rules and consider the security implications of exposing wallet infrastructure to the internet.

Persistent Data and Backup Strategy

WAIaaS stores all persistent data in /data inside the container, mapped to a named Docker volume. This includes:

Wallet private keys (encrypted)
Transaction history and logs
Policy configurations
Session tokens and authentication state

For production backup strategies, you can mount a host directory instead of a named volume:

volumes:
  - /opt/waiaas-data:/data

This allows your existing backup systems to access the data directory directly. The CLI includes backup commands for consistent snapshots:

# Create backup inside container
docker exec waiaas-daemon waiaas backup create --name "daily-backup"

# List available backups
docker exec waiaas-daemon waiaas backup list

# Export backup to host
docker cp waiaas-daemon:/data/backups/daily-backup.tar.gz ./

Health Monitoring and Watchtower Integration

The Docker image includes a built-in healthcheck that verifies the API endpoint responds correctly. This integrates with Docker's health monitoring and orchestration platforms like Docker Swarm or Portainer.

For automatic updates, WAIaaS works with Watchtower out of the box:

services:
  watchtower:
    image: containrrr/watchtower
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
    command: --interval 30 waiaas-daemon

Watchtower will automatically pull new WAIaaS releases and restart the container while preserving your data volume and configuration.

Container Security Hardening

The WAIaaS Docker image follows container security best practices:

Non-root execution: Runs as UID 1001 to prevent privilege escalation
Minimal attack surface: Based on lightweight base images with only required dependencies
Read-only filesystem: Application files are immutable after container start
No package managers: Runtime container doesn't include npm, apt, or other package managers
Explicit healthchecks: Container health is verifiable by orchestration platforms

For additional hardening, you can run with read-only root filesystem:

docker run -d \
  --name waiaas \
  --read-only \
  --tmpfs /tmp \
  --tmpfs /var/log \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  ghcr.io/minhoyoo-iotrust/waiaas:latest

Integration with Reverse Proxies

For production deployments, you typically want WAIaaS behind a reverse proxy for TLS termination and additional security. Here's an example nginx configuration:

upstream waiaas {
    server 127.0.0.1:3100;
}

server {
    listen 443 ssl http2;
    server_name wallet.yourdomain.com;

    ssl_certificate /path/to/cert.pem;
    ssl_certificate_key /path/to/key.pem;

    location / {
        proxy_pass http://waiaas;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

This provides TLS encryption and can integrate with authentication systems or IP allow-lists for additional access control.

Quick Start: Production Deployment

Here's how to get a production-ready WAIaaS deployment running:

Clone and configure:

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

Set up secrets directory:

   mkdir -p secrets
   openssl rand -base64 32 > secrets/master_password.txt
   chmod 600 secrets/master_password.txt

Deploy with secrets overlay:

   docker compose -f docker-compose.yml -f docker-compose.secrets.yml up -d

Verify deployment:

   curl http://127.0.0.1:3100/health
   docker compose logs -f

Access admin interface:

   open http://127.0.0.1:3100/admin

The admin interface provides a web UI for wallet management, policy configuration, and monitoring — all running entirely on your infrastructure without external dependencies.

What's Next

With your production WAIaaS deployment running, you can start integrating AI agents through the MCP protocol or REST API. Check out the OpenAPI documentation at http://127.0.0.1:3100/reference for interactive API exploration, and consider setting up monitoring and alerting for your wallet infrastructure.

Ready to deploy your own wallet infrastructure? Get started with the code at GitHub or explore more deployment options at waiaas.ai.

20 CLI Commands: Complete Wallet Management for Your Self-Hosted Setup

Wallet Guy — Thu, 09 Apr 2026 07:58:03 +0000

Self-hosting your crypto wallet infrastructure means full control over your private keys, transaction policies, and agent permissions — no third-party custody required. WAIaaS provides a complete CLI toolkit with 20 commands for managing wallets, sessions, and policies on your own infrastructure. Whether you're running a single AI trading bot or managing multiple autonomous agents, these CLI commands give you granular control over every aspect of your wallet-as-a-service deployment.

Why CLI Management Matters for Self-Hosters

When you're running your own wallet infrastructure, you need more than just a web interface. You need scriptable commands for automation, backup strategies that work with your existing systems, and the ability to provision wallets without touching a GUI. Traditional wallet solutions force you to click through interfaces or rely on their hosted APIs with rate limits and custody risks.

Self-hosted wallet management eliminates these constraints. Your private keys never leave your server, your transaction policies can't be overridden by external services, and your AI agents operate with the permissions you define — not what a SaaS provider allows.

The Complete CLI Toolkit

WAIaaS includes 20 CLI commands covering wallet lifecycle, session management, backups, and integrations. Here's how they solve real self-hosting challenges:

Initial Setup and Provisioning

The init command creates your data directory and configuration files:

# Standard setup with password prompt
waiaas init

# Auto-provision mode generates a random master password
waiaas init --auto-provision

Auto-provision is perfect for Docker deployments where you want zero interaction during container startup. The master password gets saved to recovery.key for later hardening.

Start your daemon with complete control over the process:

waiaas start                    # Foreground with logs
waiaas start --daemon          # Background process
waiaas status                  # Check if running
waiaas stop                    # Clean shutdown

Wallet and Session Management

Create wallets for different purposes without any external API calls:

# Create wallets for different chains
waiaas wallet create --name "trading-bot" --chain solana --environment mainnet
waiaas wallet create --name "ethereum-defi" --chain evm --environment mainnet

# Get wallet details
waiaas wallet info --wallet-id <uuid>

The quickset command creates a complete multi-chain setup in seconds:

# Creates Ethereum + Solana wallets with MCP sessions
waiaas quickset --mode mainnet

# Outputs ready-to-use MCP configuration for Claude Desktop

Sessions provide AI agents with scoped access to specific wallets:

# Create session for an AI agent
waiaas session prompt --wallet-id <uuid>

# Returns: "Add this to your agent's environment:"
# WAIAAS_SESSION_TOKEN=wai_sess_eyJhbGciOiJIUzI1NiJ9...

Backup and Recovery Strategy

Self-hosters need reliable backup strategies that integrate with existing infrastructure:

# Create encrypted backup bundle
waiaas backup create --output-file "./backups/waiaas-$(date +%Y%m%d).backup"

# List backup contents without restoring
waiaas backup inspect --file "./backups/waiaas-20240408.backup"

# View all available backups
waiaas backup list

# Restore from backup (destructive operation)
waiaas restore --file "./backups/waiaas-20240408.backup"

Backup files are encrypted and contain everything needed to restore your complete setup: wallet keys, policies, session configurations, and transaction history. This integrates cleanly with standard backup tools like rsync, rclone, or your favorite backup solution.

MCP Integration for AI Frameworks

Model Context Protocol (MCP) connects your wallets to AI frameworks like Claude Desktop:

# Auto-register all wallets with Claude Desktop
waiaas mcp setup --all

# Register specific wallet
waiaas mcp setup --wallet-id <uuid>

This writes configuration directly to Claude's config file, enabling your AI agents to access 45 MCP tools for wallet operations, DeFi actions, and transaction management.

Owner Connection and Security

The owner authentication system provides human oversight for high-value transactions:

# Connect hardware wallet or signing app
waiaas owner connect

# Check connection status
waiaas owner status

# Disconnect when done
waiaas owner disconnect

This establishes the cryptographic identity for transaction approvals and emergency controls, separate from your master password.

Notification Channels

Set up signing channels for transaction approvals:

# Configure push notifications for mobile approval
waiaas notification setup --channel push-relay

# Set up Telegram bot integration
waiaas notification setup --channel telegram

These channels enable human-in-the-loop approvals for transactions that exceed your instant execution policies.

Updates and Maintenance

Keep your self-hosted instance current:

# Update to latest version
waiaas update

# Check current status and version
waiaas status

Self-hosted updates give you control over when to upgrade, unlike SaaS platforms that force updates.

Docker Integration for Production

The CLI commands integrate seamlessly with Docker deployments. Here's a production-ready setup:

# Start with Docker Compose
git clone https://github.com/minhoyoo-iotrust/WAIaaS.git
cd WAIaaS
docker compose up -d

# Initialize through the container
docker exec waiaas-daemon waiaas init --auto-provision

# Create wallets via CLI
docker exec waiaas-daemon waiaas quickset --mode mainnet

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

Environment variables control daemon behavior:

# In your .env file or docker-compose.yml
WAIAAS_AUTO_PROVISION=true              # Skip password prompts
WAIAAS_DAEMON_PORT=3100                 # API port
WAIAAS_DATA_DIR=/data                   # Persistent storage
WAIAAS_RPC_SOLANA_MAINNET=<your-rpc>    # Custom RPC endpoints

Quick Start: Complete Self-Hosted Setup

Here's how to go from zero to running AI agents with wallet access in under 5 minutes:

Install and initialize:

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

Create wallets and sessions:

waiaas quickset --mode mainnet
# Outputs MCP configuration automatically

Set up Claude Desktop integration:

waiaas mcp setup --all

Create first backup:

waiaas backup create --output-file "./waiaas-backup-$(date +%Y%m%d).backup"

Test with Claude: Open Claude Desktop and ask "Check my wallet balance" — it should connect via MCP and return your wallet information.

Production Considerations

For production self-hosted deployments, consider these CLI patterns:

Automated backups with cron:

# Daily encrypted backups with 30-day retention
0 2 * * * /usr/local/bin/waiaas backup create --output-file "/backups/waiaas-$(date +\%Y\%m\%d).backup" && find /backups -name "waiaas-*.backup" -mtime +30 -delete

Health monitoring in your monitoring stack:

#!/bin/bash
# Health check script
waiaas status || {
  echo "WAIaaS daemon down, restarting..."
  waiaas start --daemon
}

Secure password rotation:

# After initial auto-provision, harden the master password
waiaas set-master
rm /data/recovery.key  # Remove auto-generated password file

The CLI's scriptable nature means it integrates with existing infrastructure automation tools like Ansible, Terraform, or simple bash scripts.

What's Next

These 20 CLI commands provide complete control over your self-hosted wallet infrastructure, from initial setup through production operations. The combination of Docker deployment, automated backups, and MCP integration creates a robust foundation for AI agent wallet access without third-party dependencies.

Ready to deploy your own wallet infrastructure? Clone the repository at https://github.com/minhoyoo-iotrust/WAIaaS and follow the self-hosting guide. For detailed configuration options and advanced deployment patterns, visit the documentation at https://waiaas.ai.

21 Policy Types, 4 Security Tiers: Building Bulletproof AI Agent Guardrails

Wallet Guy — Wed, 08 Apr 2026 14:49:21 +0000

AI agents with wallets need bulletproof security guardrails. One misconfigured prompt or compromised model could drain your funds faster than you can hit the emergency stop button. The solution isn't to avoid giving agents access to money — it's to build proper guardrails that protect your assets while letting legitimate transactions through.

Why Agent Security Can't Be an Afterthought

Traditional API keys can leak credentials or run up cloud bills. But crypto wallets hold real money that disappears permanently when sent to the wrong address. A trading bot that goes rogue doesn't just spam your logs — it can liquidate your entire portfolio in minutes.

Most developers building AI agents either go full paranoid (agents can only read, never transact) or full YOLO (give the agent a wallet and pray). Neither approach works for production systems that need to move real money safely.

The 3-Layer Security Architecture

WAIaaS implements defense in depth with three distinct security layers:

Layer 1: Session Authentication — AI agents get limited-scope JWT tokens, not raw private keys. Each session can be individually revoked, expired, or restricted to specific wallets.

Layer 2: Policy Engine — 21 policy types with 4 security tiers (INSTANT/NOTIFY/DELAY/APPROVAL) enforce spending limits, token whitelists, and time restrictions. Default-deny means transactions are blocked unless explicitly allowed.

Layer 3: Human Oversight — High-value transactions require human approval via WalletConnect, Telegram, or push notifications. Owners can monitor, delay, or kill-switch any agent activity.

The 21 Policy Types: Your Security Toolbox

WAIaaS provides 21 policy types that cover every attack vector:

Core Security Policies:

SPENDING_LIMIT — 4-tier amount-based restrictions
WHITELIST — Only approved recipient addresses
TIME_RESTRICTION — Trading hours enforcement
RATE_LIMIT — Max transactions per period

Token & Contract Protection:

ALLOWED_TOKENS — Default-deny token whitelist
CONTRACT_WHITELIST — Only approved smart contracts
APPROVED_SPENDERS — Token approval restrictions
METHOD_WHITELIST — Allowed function selectors only

DeFi-Specific Safeguards:

LENDING_LTV_LIMIT — Max loan-to-value ratios
PERP_MAX_LEVERAGE — Prevent over-leveraging
VENUE_WHITELIST — Approved trading venues only

Here's how to create a multi-layered spending policy:

# Layer 1: Amount-based 4-tier security
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
    }
  }'

The 4 security tiers automatically classify every transaction:

INSTANT (≤$10): Execute immediately, no notification
NOTIFY (≤$100): Execute immediately, send alert to owner
DELAY (≤$1000): Queue for 5 minutes, owner can cancel
APPROVAL (>$1000): Require explicit human approval

Default-Deny: The Security Foundation

WAIaaS follows a default-deny security model. Without explicit policies, agents can't interact with tokens or contracts:

# Layer 2: Token whitelist (required for any token operations)
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"},
        {"address": "native:solana", "symbol": "SOL", "chain": "solana"}
      ]
    }
  }'

# Layer 3: Contract whitelist (required for DeFi interactions)
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"}
      ]
    }
  }'

Without these whitelists, the agent's token transfers and DeFi actions are automatically blocked.

Advanced Security: Time and Rate Controls

Sophisticated attacks often happen outside business hours or in rapid bursts. WAIaaS prevents both:

# Time-based restrictions
curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "TIME_RESTRICTION",
    "rules": {
      "allowedHours": {"start": 9, "end": 17},
      "timezone": "UTC"
    }
  }'

# Rate limiting
curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "RATE_LIMIT",
    "rules": {
      "maxTransactions": 10,
      "period": "hourly"
    }
  }'

DeFi-Specific Protections

DeFi protocols introduce unique risks like liquidation cascades and over-leveraging. WAIaaS includes specialized policies:

# Prevent over-leveraging in perpetual futures
curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "PERP_MAX_LEVERAGE",
    "rules": {
      "maxLeverage": 5.0
    }
  }'

# Lending LTV limits
curl -X POST http://localhost:3100/v1/policies \
  -H 'Content-Type: application/json' \
  -H 'X-Master-Password: <password>' \
  -d '{
    "walletId": "<wallet-uuid>",
    "type": "LENDING_LTV_LIMIT",
    "rules": {
      "maxLtv": 0.75
    }
  }'

Human Approval Channels

When transactions exceed policy limits, WAIaaS routes them through human approval channels:

WalletConnect: Mobile wallet approval with transaction details
Telegram: Bot sends transaction for approval with one-tap buttons
Push notifications: Real-time alerts to multiple devices

The owner sees exactly what the agent is trying to do and can approve, deny, or kill-switch the entire session.

Real-World Security Scenario

Consider an AI trading agent that gets compromised. Here's how WAIaaS policies contain the damage:

Spending limit policy blocks any transaction over $1,000
Token whitelist prevents interaction with unknown/scam tokens
Contract whitelist blocks calls to unverified DeFi protocols
Rate limiting stops rapid-fire drain attempts
Time restrictions block 3 AM suspicious activity
Venue whitelist restricts trading to approved DEXes only

Even with full session compromise, the attacker is constrained to small amounts on approved tokens through verified protocols during business hours.

The Approval Override System

For emergency situations, WAIaaS includes multiple override mechanisms:

# Emergency: kill all sessions for a wallet
curl -X DELETE http://localhost:3100/v1/sessions/wallet/<wallet-id> \
  -H 'X-Master-Password: <password>'

# Approve a specific delayed transaction
curl -X POST http://localhost:3100/v1/transactions/<tx-id>/approve \
  -H 'X-Owner-Signature: <signature>' \
  -H 'X-Owner-Message: <signed-message>'

Quick Start: Secure Agent Setup

Set up a security-hardened AI agent in 5 steps:

Install and initialize WAIaaS:

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

Create a wallet with basic policies:

# Creates wallet + session
waiaas quickset --mode mainnet

# Add spending limits
waiaas create-policy --type SPENDING_LIMIT --instant-max 10 --notify-max 100

Configure token and contract whitelists:

# Only allow USDC and SOL
waiaas create-policy --type ALLOWED_TOKENS --tokens USDC,SOL

# Only allow Jupiter DEX
waiaas create-policy --type CONTRACT_WHITELIST --contracts JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4

Set up MCP for AI integration:

waiaas mcp setup --all

Test with a small transaction: Your AI agent can now execute small transactions instantly while larger ones require your approval.

Security isn't about making things harder — it's about making the right things easy and the wrong things impossible. With proper guardrails, your AI agents can operate autonomously within safe boundaries while you maintain ultimate control.

Check out the GitHub repository for complete documentation and examples, or visit waiaas.ai to get started with secure AI agent wallets today.

Auto-Generated OpenAPI 3.0 Spec: Interactive API Reference for AI Agent Wallets

Wallet Guy — Wed, 08 Apr 2026 07:56:16 +0000

Building AI agents that can actually handle money is trickier than you think. Your Claude agent can browse the web, write code, and manage files — but when it comes to blockchain transactions, token swaps, or DeFi operations, you're stuck building custom wallet integrations from scratch. WAIaaS changes that by providing auto-generated OpenAPI 3.0 specifications and interactive API documentation, making it dead simple to give your AI agents proper wallet capabilities.

Why Traditional Wallet APIs Don't Work for AI Agents

Most blockchain APIs are built for human developers, not autonomous agents. You end up juggling multiple SDKs, managing private keys, handling gas estimation, and writing custom retry logic for failed transactions. Even worse, there's no standardized way to add spending limits, approval workflows, or audit trails — all critical when an AI agent controls real funds.

The result? Developers either skip blockchain features entirely or spend months building wallet infrastructure instead of focusing on their agent's core intelligence.

Auto-Generated OpenAPI Spec: Your AI Agent's Wallet Blueprint

WAIaaS solves this with a comprehensive REST API that includes auto-generated OpenAPI 3.0 specifications. The daemon automatically generates complete API documentation at /doc and serves an interactive reference UI at /reference, giving you everything needed to integrate wallet functionality into any AI agent framework.

Here's what the OpenAPI spec covers:

# Download the complete OpenAPI 3.0 spec
curl http://127.0.0.1:3100/doc -o waiaas-openapi.json

# View interactive API reference
open http://127.0.0.1:3100/reference

The spec includes 39 REST API route modules covering everything from basic balance queries to complex DeFi operations across 15 integrated protocols. Each endpoint includes request/response schemas, authentication requirements, and error codes — perfect for AI agent frameworks that can consume OpenAPI specifications directly.

Interactive API Reference: Test Before You Build

The interactive Scalar API reference UI at /reference lets you test every endpoint directly in your browser. This is invaluable when building AI agents because you can verify the exact request/response format before writing integration code.

For example, here's how simple it is to check a wallet balance:

curl http://127.0.0.1:3100/v1/wallet/balance \
  -H "Authorization: Bearer wai_sess_eyJhbGciOiJIUzI1NiJ9..."

The response format is documented in the OpenAPI spec, making it trivial for AI agents to parse:

{
  "balance": "1.5",
  "symbol": "SOL",
  "chain": "solana",
  "network": "mainnet",
  "usd_value": 225.50
}

Three-Layer Authentication for AI Agent Security

WAIaaS implements a three-layer authentication system designed specifically for AI agents:

masterAuth — System administration (wallet creation, policy management)
sessionAuth — AI agent operations (transactions, balance queries)
ownerAuth — Human oversight (approvals, kill switches)

# Create a session for your AI agent (masterAuth)
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>"}'

The session token returned can be used by your AI agent for all transactions, while the human owner retains ultimate control through approval workflows.

Policy Engine: 21 Rule Types for Safe AI Agent Operations

The OpenAPI spec documents WAIaaS's policy engine with 21 policy types and 4 security tiers: INSTANT, NOTIFY, DELAY, and APPROVAL. This lets you configure exactly what your AI agent can do autonomously versus what requires human approval.

# Create spending limits for your AI 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
    }
  }'

The policy system ensures your AI agent can handle routine transactions instantly while routing larger operations through appropriate human oversight.

DeFi Integration: 15 Protocols Ready to Use

The OpenAPI spec includes endpoints for 15 DeFi protocol providers: aave-v3, across, dcent-swap, drift, erc8004, hyperliquid, jito-staking, jupiter-swap, kamino, lido-staking, lifi, pendle, polymarket, xrpl-dex, and zerox-swap.

Your AI agent can execute complex DeFi operations with simple REST calls:

# Execute a Jupiter swap on 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"
  }'

Error Handling: Structured Responses for AI Agents

The OpenAPI spec documents a consistent error format that AI agents can easily parse and respond to:

{
  "error": {
    "code": "POLICY_DENIED",
    "message": "Transaction denied by SPENDING_LIMIT policy",
    "domain": "POLICY",
    "retryable": false
  }
}

This structured approach lets your AI agent handle different error scenarios appropriately — retrying network failures but escalating policy violations to human operators.

Multi-Chain Support: EVM and Solana

The OpenAPI spec covers 2 chain types (solana, evm) with 18 networks, letting your AI agent operate across multiple blockchains with the same API interface. No need to learn different SDKs for each chain — WAIaaS handles the complexity.

Quick Start: OpenAPI Integration in 4 Steps

Here's how to integrate WAIaaS's OpenAPI spec into your AI agent:

Start WAIaaS daemon:

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

Download the OpenAPI spec:

curl http://127.0.0.1:3100/doc -o waiaas-openapi.json

Generate client code (optional, for typed languages):

# Generate TypeScript client
openapi-generator-cli generate -i waiaas-openapi.json -g typescript-axios -o ./waiaas-client

Test the interactive reference:

open http://127.0.0.1:3100/reference

Your AI agent framework can now consume the OpenAPI spec directly, giving it instant access to wallet functionality across multiple blockchains.

Beyond Basic Transactions: Advanced Capabilities

The OpenAPI spec includes advanced features like:

x402 HTTP payment protocol — AI agents can pay for API calls automatically
ERC-4337 Account Abstraction — Gasless transactions and batch operations
NFT operations — ERC-721/ERC-1155 and Solana Metaplex support
Cross-chain bridging — Move funds between networks automatically
Transaction simulation — Test operations before execution

These capabilities are all documented in the OpenAPI spec, making them accessible to any AI agent framework.

Real-World Integration Examples

The interactive API reference shows exactly how AI agents can:

Monitor incoming deposits with real-time notifications
Execute complex multi-step DeFi strategies
Handle failed transactions with appropriate retry logic
Maintain audit trails for compliance
Implement spending controls and approval workflows

Each endpoint in the spec includes practical examples your AI agent can adapt.

What's Next

The auto-generated OpenAPI 3.0 spec makes WAIaaS the fastest way to add blockchain capabilities to any AI agent. Download the spec, explore the interactive reference, and start building agents that can actually handle money.

Ready to give your AI agent a wallet? Check out the WAIaaS GitHub repository for installation instructions, or visit waiaas.ai to learn more about the platform's capabilities.

Real-Time Deposit Notifications for Your Self-Hosted AI Wallet

Wallet Guy — Tue, 07 Apr 2026 14:48:57 +0000

Real-time deposit notifications transform your self-hosted AI wallet from a passive vault into an intelligent agent that responds immediately to incoming funds, enabling autonomous trading, payment processing, and DeFi strategies without constant manual monitoring. Whether you're running a trading bot or a payment service, knowing when funds arrive is critical for automated workflows.

Why Deposit Monitoring Matters

Traditional crypto wallets are reactive — you check balances manually or refresh dashboards to see new transactions. But AI agents need to be proactive. When someone pays your bot, when DeFi yields are deposited, or when cross-chain bridges complete, your agent should know immediately and take action.

Self-hosted solutions give you complete control over this monitoring. No API rate limits from third-party services, no custody risks, and no dependency on external infrastructure that could go offline when you need it most.

WAIaaS Incoming Transaction Monitor

WAIaaS provides built-in real-time deposit monitoring with instant notifications across multiple channels. The system tracks all incoming transactions and can trigger immediate responses through your AI agents.

Here's how the monitoring system works:

# Start WAIaaS with Docker — monitoring starts automatically
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

# Check incoming transaction summary via API
curl http://127.0.0.1:3100/v1/wallet/incoming/summary \
  -H "Authorization: Bearer wai_sess_<token>"

The monitoring service automatically detects deposits across all supported networks (18 networks across Ethereum, Solana, and other chains) and categorizes them by type — native tokens, ERC-20/SPL tokens, NFTs, and DeFi protocol interactions.

Setting Up Notification Channels

WAIaaS supports 3 signing channels that double as notification channels: push notifications, Telegram, and WalletConnect. Configure them during setup:

# Set up notification channels via CLI
waiaas notification setup

# Or configure push notifications manually
curl -X POST http://127.0.0.1:3100/v1/notifications/push \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "endpoint": "https://fcm.googleapis.com/fcm/send/...",
    "keys": {
      "p256dh": "...",
      "auth": "..."
    }
  }'

Once configured, incoming deposits trigger real-time notifications with transaction details, amount, sender address, and confirmation status.

AI Agent Response to Deposits

Your AI agents can query incoming transactions through the MCP integration or SDK, enabling immediate automated responses:

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

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

// Poll for new deposits
async function checkDeposits() {
  const incoming = await client.listIncomingTransactions();

  for (const tx of incoming.filter(tx => tx.status === 'CONFIRMED' && !tx.processed)) {
    console.log(`New deposit: ${tx.amount} ${tx.symbol} from ${tx.from}`);

    // Trigger automated response
    if (tx.symbol === 'USDC' && parseFloat(tx.amount) >= 100) {
      await client.executeAction('jupiter-swap', 'swap', {
        inputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
        outputMint: 'So11111111111111111111111111111111111111112',  // SOL
        amount: (parseFloat(tx.amount) * 1000000).toString() // Convert to smallest unit
      });
    }
  }
}

setInterval(checkDeposits, 10000); // Check every 10 seconds

The system tracks transaction confirmations automatically, so you can reliably trigger actions only after deposits are final.

MCP Integration for Claude

If you're using Claude Desktop with the MCP integration, your AI assistant can monitor deposits conversationally:

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

After setup, you can ask Claude:

"Check for new deposits in the last hour"
"What's my largest incoming transaction today?"
"Auto-swap any USDC deposits over $500 to SOL"

Claude has access to all 45 MCP tools, including incoming transaction monitoring, so it can build complex deposit-triggered workflows.

Docker Compose for Production Monitoring

For production environments, use Docker Compose with persistent volumes and health checks:

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_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

volumes:
  waiaas-data:
    driver: local

The health check ensures monitoring stays online, and restart policies handle any connectivity issues with RPC endpoints.

Privacy and Self-Custody Benefits

Self-hosting your deposit monitoring infrastructure provides several advantages:

Complete Privacy: Transaction monitoring happens entirely on your infrastructure. No third-party services see your wallet addresses, transaction patterns, or balances.

No API Limits: Direct RPC connections to blockchain networks mean no rate limiting from hosted wallet services.

Sovereign Infrastructure: Your monitoring can't be shut down by external providers. As long as your server runs, monitoring continues.

Custom Logic: Implement any deposit-triggered logic without restrictions from hosted platforms.

Quick Start

Get real-time deposit notifications running in under 5 minutes:

Start WAIaaS with auto-provision:

   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 your master password:

   docker exec waiaas cat /data/recovery.key

Create a wallet and session:

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

Fund your wallet and watch the logs for incoming transaction detection.
Query deposits via API:

   curl http://127.0.0.1:3100/v1/wallet/incoming/summary \
     -H "Authorization: Bearer wai_sess_<token>"

What's Next

Real-time deposit monitoring is just the foundation. Combine it with WAIaaS's policy engine to create sophisticated automated workflows — auto-compound DeFi yields, rebalance portfolios based on incoming funds, or trigger cross-chain transfers when deposits hit certain thresholds.

Ready to build your own self-hosted AI wallet infrastructure? Clone the repository at GitHub or learn more at waiaas.ai.

Fine-Grained Control: Using the Admin Policy Editor for Agent Wallets

Wallet Guy — Tue, 07 Apr 2026 07:53:00 +0000

Giving an AI agent a wallet without proper security controls is like handing a toddler your credit card and hoping for the best. The Admin Policy Editor in WAIaaS provides fine-grained control over agent wallets through 21 policy types, 4 security tiers, and default-deny enforcement that ensures your AI can only access what you explicitly allow.

Why Agent Wallet Security Matters

AI agents are powerful but unpredictable. They can misinterpret instructions, fall victim to prompt injection attacks, or simply make expensive mistakes. Without proper guardrails, an agent with wallet access could drain your funds in seconds.

Traditional wallet security focuses on protecting private keys. But with AI agents, the threat model is different: the agent has legitimate access to the wallet, but you need to control what it can do with that access. This requires policy-based security that operates at the transaction level, not just the authentication level.

WAIaaS 3-Layer Security Architecture

WAIaaS implements a comprehensive security model with three distinct layers:

Layer 1: Session Authentication

AI agents never see your private keys. Instead, they authenticate using JWT session tokens with configurable time limits and renewal policies.

# Create a session for your AI agent (masterAuth required)
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>"}'

Sessions support per-session TTL, maximum renewals, and absolute lifetime limits. The defaults allow unlimited renewals, but you can lock them down for high-security environments.

Layer 2: Policy Engine with Default-Deny

The policy engine evaluates every transaction against 21 policy types. Unlike traditional allow-lists, WAIaaS uses default-deny: transactions are blocked unless explicitly permitted.

Key policies include:

ALLOWED_TOKENS: Whitelist which tokens the agent can transfer (blocks all others)
CONTRACT_WHITELIST: Whitelist which contracts the agent can interact with
SPENDING_LIMIT: Amount-based 4-tier security (INSTANT/NOTIFY/DELAY/APPROVAL)
APPROVED_SPENDERS: Control which protocols can receive token approvals
TIME_RESTRICTION: Limit trading to business hours
RATE_LIMIT: Prevent transaction spam

Layer 3: Human Approval Channels

For high-value transactions, WAIaaS can require human approval via WalletConnect, Telegram, or push notifications. The agent's transaction enters a pending state until you explicitly approve or reject it.

Using the Admin Policy Editor

The Admin Web UI at /admin provides a visual interface for creating and managing policies. Here's how to configure comprehensive security for an AI trading agent:

Step 1: Access the Admin Interface

# Start WAIaaS
waiaas start

# Open admin interface
open http://127.0.0.1:3100/admin

The admin interface provides wallet management, session control, policy editing, and DeFi positions monitoring in a single dashboard.

Step 2: Create a Spending Limit Policy

The SPENDING_LIMIT policy is the cornerstone of agent security. It creates four tiers based on transaction amounts:

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": 50,
      "notify_max_usd": 200,
      "delay_max_usd": 1000,
      "delay_seconds": 900,
      "daily_limit_usd": 2000,
      "monthly_limit_usd": 10000
    }
  }'

This configuration means:

Transactions ≤ $50: Execute immediately (INSTANT)
Transactions ≤ $200: Execute with notification (NOTIFY)
Transactions ≤ $1000: 15-minute delay, cancellable (DELAY)
Transactions > $1000: Require human approval (APPROVAL)

Step 3: Implement Default-Deny Token Control

Without an ALLOWED_TOKENS policy, your agent can transfer any token. Create a whitelist to lock this down:

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

Now your agent can only trade SOL and USDC. Attempts to transfer other tokens will be denied with a POLICY_DENIED error.

Step 4: Whitelist DeFi Protocols

For a DeFi trading agent, use CONTRACT_WHITELIST to restrict which protocols it can interact with:

{
  "type": "CONTRACT_WHITELIST",
  "rules": {
    "contracts": [
      {
        "address": "JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4",
        "name": "Jupiter",
        "chain": "solana"
      }
    ]
  }
}

The agent can now only swap on Jupiter. Attempts to interact with other protocols will be blocked.

Step 5: Configure Time-Based Restrictions

Limit your agent's trading to market hours to avoid volatile overnight price movements:

{
  "type": "TIME_RESTRICTION",
  "rules": {
    "allowedHours": {
      "start": 9,
      "end": 17
    },
    "timezone": "UTC"
  }
}

Step 6: Set Up Human Approval Channels

For APPROVAL-tier transactions, configure WalletConnect to receive approval requests on your mobile wallet:

# Connect your wallet for approvals
waiaas owner connect

# Check connection status
waiaas owner status

When your agent attempts a high-value transaction, you'll receive a WalletConnect request to approve or reject it.

Advanced Policy Configuration

Rate Limiting

Prevent your agent from spam trading:

{
  "type": "RATE_LIMIT",
  "rules": {
    "maxTransactions": 10,
    "period": "hourly"
  }
}

Network Restrictions

Lock your agent to specific chains:

{
  "type": "ALLOWED_NETWORKS",
  "rules": {
    "networks": [
      {"network": "solana-mainnet"},
      {"network": "ethereum-mainnet"}
    ]
  }
}

DeFi-Specific Policies

For lending agents, limit loan-to-value ratios:

{
  "type": "LENDING_LTV_LIMIT",
  "rules": {
    "maxLtv": 0.75
  }
}

For perpetual trading agents, limit leverage:

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

Monitoring and Alerts

The Admin UI provides real-time monitoring of:

Active sessions and their permissions
Pending transactions awaiting approval
Policy violations and denials
DeFi positions across all integrated protocols

Error Handling in Your Agent

Your AI agent should handle policy denials gracefully:

try {
  const tx = await client.sendToken({
    to: 'recipient-address',
    amount: '100'
  });
} catch (error) {
  if (error.code === 'POLICY_DENIED') {
    console.log('Transaction blocked by policy:', error.message);
    // Maybe try a smaller amount or different token
  }
}

The API returns structured errors with specific codes like POLICY_DENIED, INSUFFICIENT_BALANCE, and TOKEN_EXPIRED, making it easy to implement retry logic.

Quick Start: Secure Agent Setup

Here's how to create a secure AI agent wallet in 5 steps:

Install and initialize WAIaaS:

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

Create a wallet and session:

waiaas wallet create --name "trading-agent" --chain solana
waiaas quickset --mode mainnet

Configure basic security policies via the Admin UI:
- Open http://127.0.0.1:3100/admin
- Create SPENDING_LIMIT policy with conservative limits
- Add ALLOWED_TOKENS whitelist
- Set up CONTRACT_WHITELIST for approved DeFi protocols
Connect approval channel:

waiaas owner connect

Test with your agent:

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

const balance = await client.getBalance();
console.log(`Secured balance: ${balance.balance} ${balance.symbol}`);

What's Next

With proper policy configuration, you can give your AI agents powerful wallet capabilities while maintaining complete control over risk exposure. The Admin Policy Editor makes it easy to adjust security parameters as your agent's needs evolve.

Explore the full WAIaaS documentation at https://waiaas.ai and get started with the open-source code at https://github.com/minhoyoo-iotrust/WAIaaS.