TypeScript SDK Deep Dive: 40+ Methods for AI Agent Wallet Control

Your Claude agent can browse the web, write code, and manage files. But can it swap tokens, check DeFi positions, or pay for its own API calls? WAIaaS TypeScript SDK gives AI agents everything they need for blockchain interactions through 40+ wallet control methods.

Why AI Agents Need Wallet SDKs

Most AI agents today can read from the blockchain but can't write to it. They can fetch token prices but can't execute trades. They can analyze DeFi protocols but can't manage positions. Without wallet functionality, agents remain observers rather than participants in the crypto economy.

The challenge isn't just technical — it's also about security. AI agents need the ability to transact, but with proper guardrails to prevent catastrophic mistakes. They need session-based authentication that can be revoked, spending limits that prevent ruination, and policy engines that encode human judgment.

WAIaaS TypeScript SDK: Full Wallet Control

The WAIaaS TypeScript SDK provides 40+ methods that transform AI agents from blockchain observers into active participants. Unlike simple RPC wrappers, it provides session authentication, built-in error handling, and integration with WAIaaS's policy engine.

Installation and Setup

npm install @waiaas/sdk

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

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

The SDK requires a session token that you create once through the CLI or admin interface. Sessions can have TTLs, renewal limits, and absolute lifetimes — giving you precise control over how long agents can operate autonomously.

Core Wallet Methods

Every AI agent needs to know where it stands financially. The SDK provides comprehensive wallet introspection:

// Get native token balance
const balance = await client.getBalance();
console.log(`${balance.balance} ${balance.symbol}`);

// Get all token balances
const assets = await client.getAssets();
assets.forEach(asset => {
  console.log(`${asset.balance} ${asset.symbol} (${asset.usdValue} USD)`);
});

// Get wallet address
const address = await client.getAddress();
console.log(`Wallet: ${address}`);

These methods work across all 18 networks supported by WAIaaS, from Ethereum mainnet to Solana devnet.

Transaction Methods

The SDK handles 7 transaction types through a unified interface:

// Simple transfer
const tx = await client.sendToken({
  to: 'recipient-address',
  amount: '0.1',
});

// Token transfer with specific mint
const tokenTx = await client.sendToken({
  type: 'TokenTransfer',
  to: 'recipient-address',
  amount: '100',
  token: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
});

// Contract interaction
const contractTx = await client.executeTransaction({
  type: 'ContractCall',
  to: 'contract-address',
  data: '0x...',
  value: '0',
});

The SDK automatically handles chain-specific details like gas estimation on EVM chains and priority fees on Solana.

DeFi Integration Methods

Rather than building separate integrations for each protocol, the SDK provides a unified DeFi interface across 15 protocol providers:

// Get all DeFi positions
const positions = await client.getDeFiPositions();
positions.forEach(position => {
  console.log(`${position.protocol}: ${position.type} - ${position.value} USD`);
});

// Execute DeFi action (Jupiter swap example)
const swapResult = await client.executeAction('jupiter-swap', 'swap', {
  inputMint: 'So11111111111111111111111111111111111111112', // SOL
  outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
  amount: '1000000000', // 1 SOL
});

This works across protocols like Jupiter, Uniswap, Aave, Lido, and 11 others. The agent doesn't need to understand protocol-specific APIs.

Advanced Methods

The SDK includes specialized methods for complex use cases:

// Dry-run transactions before execution
const simulation = await client.simulateTransaction({
  type: 'Transfer',
  to: 'recipient',
  amount: '1.0',
  dryRun: true,
});

// Sign arbitrary messages
const signature = await client.signMessage('Hello, blockchain!');

// x402 HTTP payments — agent pays for API calls automatically
const response = await client.x402Fetch('https://api.example.com/premium-endpoint');

The x402 method is particularly powerful — it lets agents pay for premium APIs automatically when they encounter HTTP 402 (Payment Required) responses.

Error Handling

The SDK provides structured error handling with specific error codes:

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

try {
  const tx = await client.sendToken({ to: '...', amount: '1000.0' });
} catch (error) {
  if (error instanceof WAIaaSError) {
    switch (error.code) {
      case 'INSUFFICIENT_BALANCE':
        console.log('Not enough funds');
        break;
      case 'POLICY_DENIED':
        console.log('Blocked by spending limit');
        break;
      case 'TOKEN_EXPIRED':
        console.log('Session expired, need to refresh');
        break;
    }
  }
}

This allows agents to make intelligent decisions when transactions fail — like trying smaller amounts when hitting spending limits.

Transaction Lifecycle Management

Unlike simple send-and-forget APIs, the SDK helps agents manage the complete transaction lifecycle:

// Submit transaction
const result = await client.sendToken({
  to: 'recipient-address',
  amount: '0.1',
});

// Poll for confirmation
const POLL_TIMEOUT_MS = 60_000;
const startTime = Date.now();

while (Date.now() - startTime < POLL_TIMEOUT_MS) {
  const tx = await client.getTransaction(result.id);
  
  if (tx.status === 'COMPLETED') {
    console.log(`Confirmed! Hash: ${tx.txHash}`);
    break;
  }
  
  if (tx.status === 'FAILED') {
    console.error(`Failed: ${tx.error}`);
    break;
  }
  
  // Still pending, wait and retry
  await new Promise(resolve => setTimeout(resolve, 2000));
}

This pattern is essential for agents that need to know when transactions actually settle before proceeding.

Integration with Policy Engine

The SDK automatically enforces the 21 policy types configured in WAIaaS. When an agent attempts a transaction that violates policy, the SDK returns structured information about why it was blocked:

try {
  await client.sendToken({ to: 'unknown-address', amount: '100' });
} catch (error) {
  if (error.code === 'POLICY_DENIED') {
    // Could be SPENDING_LIMIT, WHITELIST, ALLOWED_TOKENS, etc.
    console.log(`Blocked by policy: ${error.message}`);
  }
}

This allows agents to adapt their behavior based on policy constraints rather than blindly retrying failed transactions.

Real Agent Example

Here's how an AI trading agent might use multiple SDK methods together:

async function tradingAgent() {
  // 1. Check current positions
  const balance = await client.getBalance();
  const positions = await client.getDeFiPositions();
  
  console.log(`Current balance: ${balance.balance} ${balance.symbol}`);
  console.log(`Active DeFi positions: ${positions.length}`);
  
  // 2. Decide if we should trade (agent logic here)
  if (shouldSwapToUSDC(balance, positions)) {
    try {
      // 3. Execute swap with dry-run first
      const simulation = await client.executeAction('jupiter-swap', 'swap', {
        inputMint: 'So11111111111111111111111111111111111111112',
        outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
        amount: (parseFloat(balance.balance) * 0.1).toString(),
        dryRun: true,
      });
      
      if (simulation.success) {
        // 4. Execute for real
        const swap = await client.executeAction('jupiter-swap', 'swap', {
          inputMint: 'So11111111111111111111111111111111111111112',
          outputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v',
          amount: (parseFloat(balance.balance) * 0.1).toString(),
        });
        
        console.log(`Swap initiated: ${swap.id}`);
      }
    } catch (error) {
      console.error(`Trading failed: ${error.message}`);
    }
  }
}

Quick Start: Add Wallet to Your Agent

Step 1: Install and start WAIaaS

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

Step 2: Install SDK in your agent project

npm install @waiaas/sdk

Step 3: Add wallet functionality

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

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

// Your agent can now check balances, send tokens, interact with DeFi

Step 4: Set spending policies

waiaas policy add --type SPENDING_LIMIT --instant 10 --notify 100 --delay 1000

Step 5: Test with a simple balance check

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

Ready to give your AI agents the financial tools they need? Check out the GitHub repository for the complete codebase or visit waiaas.ai to get started. Your agents are about to become a lot more capable.