Quickstart Guide

Deploy your first AI agent with autonomous onchain banking capabilities in 10 minutes. This guide walks through creating a Solana PDA account, configuring token delegations, and executing your first onchain transaction.

---

Prerequisites

• Node.js 18+ or Python 3.9+

• Solana wallet (Phantom, Solflare, or Backpack)

• MoltFi API key (sign up)

• Some SOL for transaction fees (~0.01 SOL, or use MoltFi's fee sponsorship)

---

Installation

TypeScript/Node.js

npm install @moltfi/sdk @solana/web3.js @solana/spl-token

Python

pip install moltfi solana solders

Rust

cargo add moltfi solana-sdk spl-token

---

Step 1: Initialize SDK

TypeScript

import { MoltFi } from '@moltfi/sdk';
import { Connection, Keypair, PublicKey, clusterApiUrl } 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 || clusterApiUrl('mainnet-beta')
});

// Connect to Solana
const connection = new Connection(
  process.env.SOLANA_RPC_URL || clusterApiUrl('mainnet-beta'),
  'confirmed'
);

Python

import moltfi
import os
from solana.rpc.api import Client
from solders.keypair import Keypair

client = moltfi.Client(
    api_key=os.environ.get('MOLTFI_API_KEY'),
    network='mainnet-beta',
    rpc_url=os.environ.get('SOLANA_RPC_URL')
)

# Connect to Solana
solana_client = Client(os.environ.get('SOLANA_RPC_URL'))

Rust

use moltfi::MoltFi;
use solana_client::rpc_client::RpcClient;
use solana_sdk::commitment_config::CommitmentConfig;

fn main() {
    let moltfi = MoltFi::new(
        std::env::var("MOLTFI_API_KEY").unwrap(),
        "mainnet-beta",
        None,
    );

    let rpc_client = RpcClient::new_with_commitment(
        std::env::var("SOLANA_RPC_URL").unwrap(),
        CommitmentConfig::confirmed(),
    );
}

---

Step 2: Create PDA Account

Deploy a program-derived address (PDA) account for your AI agent. The PDA is derived from MoltFi's program and your owner keypair.

// Load or create owner keypair (maintains custody)
const ownerKeypair = Keypair.fromSecretKey(
  Uint8Array.from(JSON.parse(process.env.OWNER_KEYPAIR))
);

// Or load from filesystem
// const ownerKeypair = Keypair.fromSecretKey(
//   new Uint8Array(JSON.parse(fs.readFileSync('owner-keypair.json')))
// );

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

console.log('Agent PDA:', agent.address.toBase58());
console.log('Account Type: Program-Derived Address');
console.log('Network: Solana Mainnet Beta');
console.log('USDC Balance:', agent.balance.usdc);
console.log('SOL Balance:', agent.balance.sol);

// PDA is derived as: PublicKey.findProgramAddressSync(
//   [Buffer.from('agent'), owner.toBuffer(), seed],
//   MOLTFI_PROGRAM_ID
// )

What just happened:

1. MoltFi created a PDA account on Solana for your agent

2. Your keypair is set as the owner (you maintain custody)

3. Account funded with 1,000 USDC via SPL token transfer

4. Agent can now receive delegated token permissions

---

Step 3: Configure Token Delegation

Create a token delegation that gives your AI agent limited, time-bound spending authority.

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

console.log('Agent Public Key:', agentKeypair.publicKey.toBase58());
console.log('⚠️  Save private key securely!');

// Create delegation with spending limits
const delegation = await moltfi.delegations.create({
  pda: agent.address,
  delegate: agentKeypair.publicKey, // AI agent's keypair
  policy: {
    // Spending limits
    dailyLimit: '500 USDC',
    perTransactionLimit: '100 USDC',
    monthlyLimit: '10000 USDC',

    // Recipient allowlist (only these wallets)
    allowedRecipients: [
      new PublicKey('...'), // AWS payment wallet
      new PublicKey('...'), // GCP payment wallet
      new PublicKey('...'), // Vercel payment wallet
    ],

    // Program allowlist (SPL Token + DeFi protocols)
    allowedPrograms: [
      new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'), // SPL Token
      new PublicKey('JUP6LkbZbjS1jKKwapdHNy74zcZ3tLUZoi5QNyVTaV4'), // Jupiter Aggregator
      new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'), // USDC Token
    ],

    // Operation allowlist
    allowedOperations: [
      'transfer',      // SPL token transfers
      'swap',          // Jupiter DEX swaps
      'approve',       // Token account approvals
    ],

    // Time constraints
    expiresIn: '30 days',

    // Optional: Time-of-day restrictions
    schedule: {
      allowedDays: [1, 2, 3, 4, 5], // Monday-Friday
      allowedHours: [9, 17],          // 9 AM - 5 PM UTC
      timezone: 'UTC'
    }
  }
});

console.log('Delegation ID:', delegation.id);
console.log('Delegate:', delegation.delegate.toBase58());
console.log('Expires:', delegation.expiresAt);
console.log('Status:', delegation.status); // 'active'

Security Note: The AI agent keypair can only execute operations within these bounds. Your wallet maintains custody of the PDA.

---

Step 4: Execute First Transaction

Now your AI agent can execute USDC transfers autonomously within the policy boundaries.

// Agent executes a USDC transfer
const tx = await moltfi.transactions.execute({
  pda: agent.address,
  delegate: agentKeypair.publicKey, // Must match delegation
  operation: {
    type: 'transfer',
    token: 'USDC',
    recipient: new PublicKey('...recipient-wallet'),
    amount: '50',
    memo: 'Payment for API services'
  }
});

console.log('Transaction submitted:', tx.signature);
console.log('Explorer:', `https://explorer.solana.com/tx/${tx.signature}`);
console.log('Status:', tx.confirmationStatus); // 'confirmed'
console.log('Slot:', tx.slot);
console.log('Block time:', tx.blockTime); // ~400ms from submission
console.log('Fee sponsored:', tx.feeSponsored); // true (tx < $100)
console.log('Policy check:', tx.policyValidation);
// {
//   passed: true,
//   dailySpent: '50.00',
//   dailyRemaining: '450.00'
// }

// Wait for finality (optional, ~13 seconds)
await connection.confirmTransaction({
  signature: tx.signature,
  blockhash: tx.blockhash,
  lastValidBlockHeight: tx.lastValidBlockHeight
}, 'finalized');

console.log('Transaction finalized!');

---

Step 5: Monitor Agent Activity

Query transaction history and spending analytics.

// Get current balance
const balance = await moltfi.accounts.getBalance(agent.address);
console.log('USDC Balance:', balance.usdc);
console.log('SOL Balance:', balance.sol);
console.log('Available USDC:', balance.available.usdc);
console.log('Pending USDC:', balance.pending.usdc);

// List recent transactions
const transactions = await moltfi.transactions.list({
  pda: agent.address,
  limit: 10,
  status: 'confirmed'
});

transactions.forEach(tx => {
  console.log(`${new Date(tx.blockTime * 1000).toISOString()}: ${tx.operation.type} - ${tx.operation.amount} USDC`);
  console.log(`  Signature: ${tx.signature}`);
  console.log(`  Slot: ${tx.slot}`);
});

// Get spending summary
const spending = await moltfi.analytics.getSpending({
  pda: agent.address,
  period: 'daily'
});

console.log('Today\'s spending:', spending.total);
console.log('Transaction count:', spending.count);
console.log('Remaining daily limit:', spending.remainingLimit);

---

Complete Example: OpenClaw Agent Setup

Full example integrating MoltFi with an OpenClaw agent for autonomous cloud operations:

import { MoltFi } from '@moltfi/sdk';
import { Connection, Keypair, PublicKey, clusterApiUrl } from '@solana/web3.js';
import fs from 'fs';

async function setupOpenClawAgent() {
  // 1. Initialize MoltFi SDK
  const moltfi = new MoltFi({
    apiKey: process.env.MOLTFI_API_KEY,
    network: 'mainnet-beta',
    rpcUrl: process.env.SOLANA_RPC_URL
  });

  const connection = new Connection(
    process.env.SOLANA_RPC_URL || clusterApiUrl('mainnet-beta'),
    'confirmed'
  );

  // 2. Load owner keypair
  const ownerKeypair = Keypair.fromSecretKey(
    new Uint8Array(JSON.parse(fs.readFileSync('owner-keypair.json')))
  );

  console.log('Owner:', ownerKeypair.publicKey.toBase58());

  // 3. Create PDA account for agent
  const agent = await moltfi.agents.create({
    name: 'OpenClaw - Cloud Operations',
    owner: ownerKeypair.publicKey,
    initialFunding: {
      amount: '5000',
      token: 'USDC'
    },
    metadata: {
      agent_type: 'openclaw',
      purpose: 'cloud_infrastructure',
      cost_center: 'eng-001'
    }
  });

  console.log(`✅ PDA account created: ${agent.address.toBase58()}`);
  console.log(`   View on Explorer: https://explorer.solana.com/address/${agent.address.toBase58()}`);

  // 4. Generate agent keypair
  const agentKeypair = Keypair.generate();

  // Save agent keypair securely (use a secrets manager in production!)
  fs.writeFileSync(
    'agent-keypair.json',
    JSON.stringify(Array.from(agentKeypair.secretKey))
  );

  console.log(`🔑 Agent keypair: ${agentKeypair.publicKey.toBase58()}`);
  console.log(`⚠️  Keypair saved to agent-keypair.json - Store securely!`);

  // 5. Create delegation with cloud service policies
  const delegation = await moltfi.delegations.create({
    pda: agent.address,
    delegate: agentKeypair.publicKey,
    policy: {
      // Allow $500/day for cloud services
      dailyLimit: '500 USDC',
      perTransactionLimit: '200 USDC',

      // Allowlist cloud service payment wallets
      allowedRecipients: [
        new PublicKey('...'), // AWS payment wallet
        new PublicKey('...'), // GCP payment wallet
        new PublicKey('...'), // Vercel payment wallet
      ],

      // Allowlist SPL Token program for transfers
      allowedPrograms: [
        new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA'),
        new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v'),
      ],

      allowedOperations: ['transfer'],

      expiresIn: '30 days',

      // Business hours (24/7 for infrastructure)
      schedule: {
        allowedDays: [1, 2, 3, 4, 5, 6, 7],
        allowedHours: [0, 23],
        timezone: 'UTC'
      }
    }
  });

  console.log(`✅ Delegation created: ${delegation.id}`);
  console.log(`⏰ Expires: ${delegation.expiresAt}`);

  // 6. Setup webhook notifications
  const webhook = await moltfi.webhooks.create({
    url: 'https://api.yourcompany.com/webhooks/moltfi',
    events: [
      'transaction.confirmed',
      'transaction.finalized',
      'policy.violated',
      'delegation.expiring',
      'balance.low'
    ],
    secret: process.env.WEBHOOK_SECRET
  });

  console.log(`✅ Webhook configured: ${webhook.id}`);

  // 7. Configure balance alerts
  await moltfi.alerts.create({
    pda: agent.address,
    type: 'balance_threshold',
    threshold: {
      amount: '500',
      token: 'USDC'
    },
    notificationChannels: ['webhook', 'email']
  });

  console.log('✅ Low balance alerts configured');

  // 8. Fund PDA with SOL for transaction fees
  const solFundingTx = await connection.requestAirdrop(
    agent.address,
    0.1 * 1e9 // 0.1 SOL
  );
  await connection.confirmTransaction(solFundingTx);

  console.log('✅ PDA funded with 0.1 SOL for fees');

  // 9. Return agent credentials
  return {
    pda: agent.address.toBase58(),
    agentKeypair: {
      publicKey: agentKeypair.publicKey.toBase58(),
      secretKey: Array.from(agentKeypair.secretKey) // STORE SECURELY
    },
    delegation: {
      id: delegation.id,
      expiresAt: delegation.expiresAt
    },
    dashboard: `https://app.moltfi.com/agents/${agent.address.toBase58()}`,
    explorer: `https://explorer.solana.com/address/${agent.address.toBase58()}`
  };
}

// Execute setup
setupOpenClawAgent()
  .then(result => {
    console.log('\n🎉 OpenClaw agent setup complete!');
    console.log(JSON.stringify(result, null, 2));
  })
  .catch(error => {
    console.error('❌ Setup failed:', error);
    process.exit(1);
  });

---

Sandbox Testing

Test all functionality without real funds on Solana Devnet:

const moltfi = new MoltFi({
  apiKey: process.env.MOLTFI_SANDBOX_KEY,
  network: 'devnet',
  rpcUrl: clusterApiUrl('devnet')
});

// Everything works identically
// Use devnet USDC and SOL from faucets

Get testnet tokens:

• Devnet SOL: solana airdrop 2 or Solana Faucet

• Devnet USDC: MoltFi Faucet

---

Next Steps

Learn Core Concepts

• Authentication - Keypair management and security

• Agent Accounts - Advanced PDA operations

• Delegation Policies - Comprehensive policy configuration

• Onchain Payments - SPL token transfers and DeFi

Technical Deep Dives

• PDA Accounts - How PDAs work

• Token Delegation - Delegation framework internals

• Authorization Engine - Policy enforcement

• Solana Programs - On-chain program architecture

Integration Guides

• OpenClaw Integration - Complete OpenClaw setup

• Webhook Setup - Real-time event handling

• API Reference - Complete endpoint documentation

---

Common Issues

Issue: Transaction Failed - Policy Violation

Error: Transaction failed: Policy violation - daily limit exceeded

Solution: Check remaining spending limit:

const spending = await moltfi.analytics.getSpending({
  pda: agent.address,
  period: 'daily'
});
console.log('Remaining limit:', spending.remainingLimit);

Issue: Insufficient SOL for Fees

Error: Insufficient SOL for transaction fees

Solution: Fund PDA with SOL:

// On devnet
const airdropTx = await connection.requestAirdrop(
  agent.address,
  0.1 * 1e9 // 0.1 SOL
);
await connection.confirmTransaction(airdropTx);

// On mainnet (from your wallet)
const tx = new Transaction().add(
  SystemProgram.transfer({
    fromPubkey: ownerKeypair.publicKey,
    toPubkey: agent.address,
    lamports: 0.01 * 1e9 // 0.01 SOL
  })
);

await sendAndConfirmTransaction(connection, tx, [ownerKeypair]);

Issue: Recipient Not Allowed

Error: Recipient not in allowlist

Solution: Add recipient to delegation policy:

await moltfi.delegations.update(delegation.id, {
  policy: {
    allowedRecipients: [
      ...existingRecipients,
      new PublicKey('...new-recipient')
    ]
  }
});

Issue: Blockhash Not Found

Error: Blockhash not found

Solution: This is a temporary Solana network issue. Retry the transaction:

// Get recent blockhash with higher commitment
const { blockhash } = await connection.getLatestBlockhash('finalized');

---

Performance Tips

Use Optimized RPC Providers

For production, use premium RPC providers:

• Helius - Fastest, most reliable

• QuickNode - Enterprise-grade infrastructure

• Triton One - High-performance RPC

const connection = new Connection(
  'https://mainnet.helius-rpc.com/?api-key=YOUR_KEY',
  'confirmed'
);

Optimize Transaction Confirmation

// Use 'confirmed' commitment for speed
const tx = await moltfi.transactions.execute({
  pda: agent.address,
  operation: {...},
  commitment: 'confirmed' // ~400ms vs 'finalized' ~13s
});

// Only wait for 'finalized' when required
if (highValueTransaction) {
  await connection.confirmTransaction(tx.signature, 'finalized');
}

Batch Operations

// Execute multiple transfers in single transaction
const batchTx = await moltfi.transactions.batch({
  pda: agent.address,
  operations: [
    { type: 'transfer', recipient: wallet1, amount: '10' },
    { type: 'transfer', recipient: wallet2, amount: '20' },
    { type: 'transfer', recipient: wallet3, amount: '30' },
  ]
});

---

Support

• Documentation: docs.moltfi.com

• Discord: discord.gg/moltfi

• Email: [email protected]

• Status: status.moltfi.com

---

You're ready to build autonomous AI agents with professional banking infrastructure on Solana