API Reference

import { SpongeWallet } from "@spongewallet/sdk";

const wallet = await SpongeWallet.connect({
  testnet?: boolean;           // Request test or live key
  agentName?: string;          // Custom agent name
  keyType?: "agent" | "master"; // Key type to request
  onVerification?: (info: VerificationInfo) => void;
  credentialStorage?: CredentialStorage;
});

const wallet = await SpongeWallet.fromApiKey("sponge_test_...");

wallet.agentId // "agent_abc123"

wallet.isTestMode // true

const addresses = await wallet.getAddresses();
// { evm: "0x...", solana: "7nYB..." }

const address = await wallet.getAddress("base");
// "0x1234..."

const balances = await wallet.getBalances();

interface Balance {
  chain: string;
  chainId: number;
  address: string;
  balance: string;
  symbol: string;
  usdValue: string;
  tokenBalances?: TokenBalance[];
}
 
interface TokenBalance {
  tokenAddress: string;
  symbol: string;
  name: string;
  decimals: number;
  balance: string;
  formatted: string;
  usdValue?: string;
}

const balance = await wallet.getBalance("ethereum");

const tokens = await wallet.getSolanaTokens();

const tx = await wallet.transfer({
  chain: "base",
  to: "0x...",
  amount: "10.0",
  currency: "USDC"
});

interface TransferOptions {
  chain: string;      // Chain identifier
  to: string;         // Recipient address
  amount: string;     // Amount as decimal string
  currency: string;   // Token symbol (ETH, USDC, SOL, etc.)
}

interface Transaction {
  id: string;
  hash: string;           // EVM tx hash or Solana signature
  status: "pending" | "confirmed" | "failed";
  explorerUrl: string;
  chain: string;
  from: string;
  to: string;
  amount: string;
  currency: string;
  gasUsed?: string;
  timestamp: string;
}

const swap = await wallet.swap({
  chain: "solana",
  fromToken: "SOL",
  toToken: "USDC",
  amount: "1.0",
  slippage: 0.5
});

interface SwapOptions {
  chain: "solana" | "solana-devnet";
  fromToken: string;   // Token symbol or mint address
  toToken: string;     // Token symbol or mint address
  amount: string;      // Amount of fromToken
  slippage?: number;   // Slippage tolerance in % (default: 0.5)
}

const quote = await wallet.getSwapQuote({
  chain: "solana",
  fromToken: "SOL",
  toToken: "USDC",
  amount: "1.0"
});

interface SwapQuote {
  fromToken: string;
  toToken: string;
  fromAmount: string;
  expectedOutput: string;
  minimumOutput: string;
  priceImpact: string;
  route: string[];
}

const status = await wallet.getTransactionStatus({
  hash: "0x...",        // or signature for Solana
  chain: "ethereum"
});

interface TransactionStatus {
  status: "pending" | "confirmed" | "failed";
  confirmations: number;
  blockNumber?: number;
  error?: string;
}

const history = await wallet.getTransactionHistory({
  limit?: number;     // Max results (default: 50)
  offset?: number;    // Pagination offset
  chain?: string;     // Filter by chain
});

const request = await wallet.requestFunding({
  chain: "base",
  amount: "100.0",
  currency: "USDC",
  reason: "Trading operations"
});

const withdrawal = await wallet.withdraw({
  chain: "base",
  amount: "50.0",
  currency: "USDC"
});

const faucet = await wallet.requestFaucet({
  chain: "tempo"
});

const config = wallet.mcp();
// Use with Anthropic SDK mcp_servers option

const tools = wallet.tools({
  include?: string[];   // Only these tools
  exclude?: string[];   // Exclude these tools
  debug?: boolean;      // Enable debug logging
  beforeExecute?: (name: string, input: any) => Promise<void>;
});

interface Tools {
  definitions: AnthropicTool[];
  execute: (name: string, input: any) => Promise<any>;
}

const chains = await wallet.getAvailableChains();

const available = await wallet.isChainAvailable("ethereum");

await wallet.disconnect();

await wallet.refresh();

const admin = await SpongeAdmin.connect();

const admin = await SpongeAdmin.fromApiKey("master_xxx_...");

const agent = await admin.createAgent({
  name: string;
  description?: string;
  testnet?: boolean;
  dailySpendingLimit?: string;
  weeklySpendingLimit?: string;
  monthlySpendingLimit?: string;
  metadata?: Record<string, unknown>;
});

interface CreateAgentResponse {
  id: string;
  name: string;
  apiKey: string;  // Only shown on creation
  wallets: {
    evm: string;
    solana: string;
  };
}

const agents = await admin.listAgents({
  includeBalances?: boolean;
  testMode?: boolean;
});

const agent = await admin.getAgent("agent_abc123");

await admin.deleteAgent("agent_abc123");

await admin.pauseAgent("agent_abc123");

await admin.resumeAgent("agent_abc123");

const result = await admin.rotateAgentKey("agent_abc123");
// { apiKey: "sponge_test_new...", previousKeyRevoked: true }

await admin.setSpendingLimit("agent_abc123", {
  type: "daily" | "weekly" | "monthly" | "per_transaction" | "per_minute" | "hourly";
  amount: string;
  currency: "USD";
});

const limits = await admin.getSpendingLimits("agent_abc123");

await admin.addToAllowlist("agent_abc123", {
  chain: "base";
  address: "0x...";
  label?: string;
});

const allowlist = await admin.getAgentAllowlist("agent_abc123");

await admin.removeFromAllowlist("agent_abc123", "entry_id");

const logs = await admin.getAgentAuditLogs("agent_abc123", {
  limit?: number;
  offset?: number;
});

interface AuditLog {
  id: string;
  action: string;
  entityType: string;
  entityId: string;
  changes?: { before?: any; after?: any };
  metadata?: Record<string, unknown>;
  timestamp: string;
}

type ChainName =
  | "ethereum"
  | "base"
  | "solana"
  | "sepolia"
  | "base-sepolia"
  | "solana-devnet"
  | "tempo";

type ChainType = "evm" | "solana";

type TransactionStatus = "pending" | "confirmed" | "failed";

type AgentStatus = "active" | "paused" | "suspended";

import { SpongeError } from "@spongewallet/sdk";
 
try {
  await wallet.transfer(...);
} catch (error) {
  if (error instanceof SpongeError) {
    console.log(error.code);    // "INSUFFICIENT_FUNDS"
    console.log(error.message); // "Insufficient balance"
  }
}

import {
  InsufficientFundsError,
  InvalidAddressError,
  SpendingLimitError,
  AllowlistError
} from "@spongewallet/sdk";