Overview

Onchain Banking Infrastructure for Autonomous AI Agents

---

Welcome to MoltFi

MoltFi is the first authorization-based onchain neobank purpose-built for AI agents. Built on Solana, MoltFi enables AI agents—particularly OpenClaw agents—to execute payments, manage assets, and coordinate services autonomously with enterprise-grade security and programmable spending controls.

Leveraging Solana's high-throughput architecture (400ms block times, 65,000 TPS capacity), MoltFi provides professional banking infrastructure that allows AI agents to transact onchain without requiring human approval for each payment while maintaining complete custody and security through program-derived addresses (PDAs) and token delegation.

---

Core Capabilities

Program-Derived Address (PDA) Accounts

Every AI agent gets its own Solana PDA account with programmable authorization logic. Sub-second finality (~400ms), ultra-low transaction costs ($0.00025 per transaction), and native multi-signature support.

Token Delegation Framework

Create time-bound, limited-scope token delegations that give AI agents spending authority without custody risk. Define granular permissions—spending limits, recipient allowlists, operation restrictions—all enforced onchain via Solana programs.

Authorization Engine

Proprietary policy enforcement system implementing fine-grained access controls. Spending limits per transaction/day/month, vendor allowlists, operational constraints, and multi-party approval workflows enforced by on-chain Solana programs.

USDC-Native Infrastructure

Built on Solana's native USDC with Circle's infrastructure. Instant settlement, zero internal transfer fees, and integration with Visa's USDC settlement network. Agent-controlled DeFi interactions (Jupiter, Marinade, Kamino) within policy boundaries.

Real-Time Performance

Average transaction confirmation: 400ms. API response time: <50ms p95. Policy validation: <20ms onchain verification. 99.99% uptime SLA.

Cross-Program Composability

Native integration with Solana DeFi ecosystem. Agents can interact with Jupiter (DEX aggregator), Marinade (liquid staking), Kamino (lending), and other Solana programs within configured policy limits.

---

Quick Start

1. Create PDA Account for Your Agent

import { MoltFi } from '@moltfi/sdk';
import { Keypair } from '@solana/web3.js';

const moltfi = new MoltFi({
  apiKey: process.env.MOLTFI_API_KEY,
  network: 'mainnet-beta', // or 'devnet' for testing
  rpcUrl: process.env.SOLANA_RPC_URL
});

// Your wallet maintains ownership
const ownerKeypair = Keypair.fromSecretKey(/* your keypair */);

// Create PDA account for agent
const agent = await moltfi.agents.create({
  name: 'OpenClaw Infrastructure Agent',
  owner: ownerKeypair.publicKey,
  initialFunding: {
    amount: '1000',
    token: 'USDC'
  }
});

console.log('Agent PDA:', agent.address.toBase58());
console.log('USDC Balance:', agent.balance.usdc);

2. Configure Token Delegation

// Generate agent keypair (or use existing)
const agentKeypair = Keypair.generate();

// Create time-bound delegation
const delegation = await moltfi.delegations.create({
  pda: agent.address,
  delegate: agentKeypair.publicKey,
  policy: {
    dailyLimit: '500 USDC',
    perTransactionLimit: '100 USDC',

    // Allowlist recipient addresses
    allowedRecipients: [
      new PublicKey('...'), // Payment processor
      new PublicKey('...'), // Vendor wallet
    ],

    // Allowlist programs
    allowedPrograms: [
      new PublicKey('JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'), // Jupiter
      new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'), // USDC
    ],

    expiresIn: '30 days'
  }
});

console.log('Delegation created:', delegation.id);
console.log('Expires:', delegation.expiresAt);

3. Agent Executes Onchain Transaction

// Agent executes transaction via delegation
const tx = await moltfi.transactions.execute({
  pda: agent.address,
  delegate: agentKeypair.publicKey, // Agent's keypair
  operation: {
    type: 'transfer',
    token: 'USDC',
    recipient: new PublicKey('...merchant-wallet'),
    amount: '50',
    memo: 'API subscription payment'
  }
});

// Policy validated onchain before execution
console.log('Transaction signature:', tx.signature);
console.log('Slot:', tx.slot);
console.log('Confirmation status:', tx.confirmationStatus); // 'confirmed'
console.log('Block time:', tx.blockTime); // ~400ms

---

Documentation Structure

Getting Started

• Quickstart Guide - Deploy your first agent in 10 minutes

• Authentication - Keypairs, wallets, and security

Operations

• Agent Accounts - PDA account creation and management

• Onchain Payments - USDC transfers and SPL token operations

• Delegation Policies - Token delegation configuration

• Webhooks - Real-time event notifications

Technical Documentation

• Platform Architecture - System design and Solana programs

• Authorization Engine - Policy enforcement system

API Reference

• REST API - Complete endpoint documentation

• SDKs - TypeScript, Python, Rust client libraries

• Error Codes - Error handling reference

---

Key Concepts

Program-Derived Address (PDA)

A Solana account derived from a program ID and seeds. PDAs enable programs to sign transactions programmatically without private keys. MoltFi uses PDAs to create agent accounts with programmable authorization logic.

Token Delegation

A time-bound, limited-scope permission grant that allows an AI agent keypair to execute specific SPL token operations on behalf of a PDA account. The owner maintains custody while the agent operates autonomously within defined boundaries.

Authorization Engine

MoltFi's proprietary Solana program that validates transactions against configured policies before execution. Implements spending limits, recipient allowlists, operational constraints, and multi-party approval workflows.

SPL Token Operations

Standard Program Library (SPL) token transfers and interactions. MoltFi primarily uses USDC (Circle's SPL token) for payments, with support for other SPL tokens within policy boundaries.

Cross-Program Invocation (CPI)

Solana's mechanism for programs to call other programs. MoltFi's authorization program uses CPIs to enable agents to interact with DeFi protocols (Jupiter, Marinade, Kamino) within policy limits.

---

Performance Metrics

Metric	Specification
Transaction Confirmation	~400ms average (Solana block time)
Transaction Finality	~13 seconds (32 confirmations)
API Response Time	<50ms p95
Policy Validation	<20ms onchain verification
Transaction Cost	$0.00025 average (5,000 lamports)
Uptime SLA	99.99%
Network	Solana Mainnet Beta
Supported Tokens	USDC, USDT, SOL, major SPL tokens

---

Use Cases

Autonomous Cloud Infrastructure Management

Deploy an OpenClaw agent with delegated authority to pay for cloud services. The agent optimizes resource allocation and pays invoices autonomously within $10,000/month spending policy via USDC transfers.

AI Agent Marketplaces

Enable agents to purchase API access, computational resources, and datasets from other agents. Agent-to-agent payments settled in ~400ms via Solana with cryptographic finality.

Automated DeFi Operations

Configure agents to manage Solana DeFi positions—swapping on Jupiter, staking with Marinade, lending on Kamino—within risk-controlled policy boundaries.

High-Frequency Trading Agents

Leverage Solana's 400ms block times for algorithmic trading agents. Execute thousands of transactions per day with ultra-low fees ($0.00025 per tx).

Research & Development Budgets

Give research teams agent-controlled budgets for compute, data, and tools. Agents autonomously allocate resources while respecting spending constraints and recipient allowlists.

---

Security Model

Owner Maintains Custody

Users retain private keys to their keypairs. AI agents receive only delegated token permissions via MoltFi's Solana program, never custody of the PDA account.

Onchain Policy Enforcement

All spending rules enforced via Solana programs with deterministic execution. No centralized party can override policies—validation is transparent and verifiable onchain.

Time-Bound Permissions

Delegations automatically expire after configured period (e.g., 30 days). Agents lose authority unless delegation is explicitly renewed via on-chain instruction.

Emergency Controls

Owners can revoke delegations instantly, freeze accounts, or modify policies at any time via dashboard or API, executed as Solana transactions.

---

Why Solana?

Performance

• 400ms block times: Near-instant transaction confirmation

• 65,000 TPS capacity: Scales to millions of agent transactions

• Ultra-low fees: $0.00025 per transaction vs $1-50 on Ethereum

Developer Experience

• Rust-based programs: Type-safe, high-performance smart contracts

• Rich ecosystem: Jupiter DEX, Marinade staking, Kamino lending

• Excellent tooling: Anchor framework, Solana CLI, comprehensive SDKs

USDC Infrastructure

• Native USDC: Circle's official SPL token implementation

• High liquidity: Billions in USDC on Solana

• Visa integration: Direct settlement to Visa USDC network

AI Agent Optimization

• Sub-second finality: Agents can react in real-time

• Predictable costs: No gas price volatility

• High throughput: Thousands of agent transactions per second

---

Network Information

Mainnet Beta

• Cluster: https://api.mainnet-beta.solana.com

• Explorer: https://explorer.solana.com

• USDC Program: EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v

• MoltFi Program: [To be deployed]

Devnet (Testing)

• Cluster: https://api.devnet.solana.com

• Explorer: https://explorer.solana.com?cluster=devnet

• Faucet: solana airdrop 2 (2 SOL for testing)

---

Getting Started

Prerequisites

• OpenClaw agent deployment or AI agent framework

• Solana wallet (Phantom, Solflare, or Backpack)

• MoltFi API key (sign up)

• Solana RPC access (Helius, QuickNode, or Triton)

Next Steps

1. Get started with the Quickstart Guide - Deploy your first agent account

2. Configure delegation policies - Set spending limits and controls

3. Explore PDA account operations - Fund accounts and manage balances

4. Review the complete API reference - Integrate with your agent framework

---

Support & Community

• Documentation: docs.moltfi.com

• Discord: discord.gg/moltfi

• X/Twitter: @getmoltfi

• Email: [email protected]

• GitHub: github.com/moltfi

• Status Page: status.moltfi.com

---

Solana Ecosystem

MoltFi integrates with the Solana DeFi ecosystem:

• Jupiter - DEX aggregator for token swaps

• Marinade Finance - Liquid staking (mSOL)

• Kamino Finance - Lending and liquidity

• Circle USDC - Native stablecoin infrastructure

• Squads - Multi-signature wallet infrastructure

---

Technical Standards

MoltFi implements the following Solana standards:

• SPL Token Program - Fungible token operations (USDC, USDT, SOL)

• Associated Token Account - Token account management

• Anchor Framework - Solana program development framework

• Token Extensions - Advanced token features (future support)

---

Professional-grade banking infrastructure for the autonomous AI economy, built on Solana