agentBuilder

Overview

agentBuilder is a convenience factory function that creates a fully configured SolanaAgentKit instance with built-in plugins. It simplifies agent creation by automatically:

Setting up the Solana RPC connection
Configuring the wallet interface
Loading default plugins (TokenPlugin and DefiPlugin)
Applying configuration options

This is the recommended way to create agents in Synto Mobile applications.

Function signature

agentBuilder(fns: FNs, config?: Config): SolanaAgentKit

Parameters

fns

FNs

required

Object containing wallet function implementations.

Show FNs properties

publicKey

PublicKey

required

The wallet’s public key from @solana/web3.js.

import { PublicKey } from '@solana/web3.js';

publicKey: new PublicKey('YourPublicKeyString')

signTransaction

<T>(transaction: T) => Promise<T>

required

Function that signs a single transaction.

Generic type: T extends Transaction | VersionedTransaction
Returns: Promise resolving to the signed transaction

signTransaction: async (tx) => {
  // Use wallet adapter or custom signing logic
  return await wallet.signTransaction(tx);
}

signAllTransactions

<T>(transactions: T[]) => Promise<T[]>

required

Function that signs multiple transactions in a batch.

Generic type: T extends Transaction | VersionedTransaction
Returns: Promise resolving to array of signed transactions

signAllTransactions: async (txs) => {
  return await wallet.signAllTransactions(txs);
}

signMessage

(msg: Uint8Array) => Promise<Uint8Array>

required

Function that signs an arbitrary message.

signMessage: async (message) => {
  return await wallet.signMessage(message);
}

signAndSendTransaction

<T>(transaction: T) => Promise<{signature: string}>

required

Function that signs and sends a transaction to the network.

Generic type: T extends Transaction | VersionedTransaction
Returns: Promise resolving to an object with the transaction signature

signAndSendTransaction: async (tx) => {
  const signature = await wallet.sendTransaction(tx, connection);
  return { signature };
}

sendTransaction

<T>(transaction: T) => Promise<string>

required

Function that sends a transaction to the network.

Generic type: T extends Transaction | VersionedTransaction
Returns: Promise resolving to the transaction signature string

sendTransaction: async (tx) => {
  const signature = await connection.sendRawTransaction(
    tx.serialize()
  );
  return signature;
}

config

Config

Optional configuration object. If not provided, defaults to { signOnly: false }.

Show Config properties

signOnly

boolean

When true, transactions are only signed but not sent. Defaults to false.

OPENAI_API_KEY

string

API key for OpenAI integration.

JUPITER_REFERRAL_ACCOUNT

string

Referral account address for earning fees on Jupiter swaps.

JUPITER_FEE_BPS

number

Fee in basis points (BPS) for Jupiter swaps. 100 BPS = 1%.

HELIUS_API_KEY

string

API key for Helius RPC and webhook services.

PRIORITY_LEVEL

'medium' | 'high' | 'veryHigh'

Transaction priority fee level. Higher priority means faster confirmation.

OTHER_API_KEYS

Record<string, string>

Additional API keys for extended services.

Returns

agent

SolanaAgentKit

Fully configured agent instance with the following plugins pre-loaded:

TokenPlugin - Token operations (balance, transfer, swap, staking)
DefiPlugin - DeFi operations (lending, borrowing through Rainfi)

The agent is ready to use with all plugin methods available via agent.methods.

Built-in plugins

The agentBuilder automatically loads these plugins:

TokenPlugin

Provides token and wallet management capabilities:Methods:

get_balance() - Get SOL balance
get_token_balance() - Get SPL token balance
transfer() - Transfer SOL or tokens
trade() - Swap tokens via Jupiter
stakeWithJup() - Stake tokens with Jupiter
fetchPrice() - Get token prices
getTokenDataByAddress() - Get token metadata
getTPS() - Get current Solana TPS
closeEmptyTokenAccounts() - Clean up empty token accounts

Note: The LAUNCH_PUMPFUN_TOKEN action is filtered out for security.

DefiPlugin

Provides DeFi protocol integrations:Methods:

quoteLoanCalculator() - Calculate loan quotes on Rainfi
RainfiTransactionBuilder() - Build Rainfi transactions
GetUserLoans() - Retrieve user’s active loans
RepayLoan() - Repay loans on Rainfi

Supports lending and borrowing operations through the Rainfi protocol.

Examples

import { agentBuilder } from '@synto/agent';
import { useWallet } from '@solana/wallet-adapter-react';

function MyComponent() {
  const wallet = useWallet();
  
  const agent = agentBuilder(
    {
      publicKey: wallet.publicKey!,
      signTransaction: wallet.signTransaction!,
      signAllTransactions: wallet.signAllTransactions!,
      signMessage: wallet.signMessage!,
      signAndSendTransaction: async (tx) => {
        const signature = await wallet.sendTransaction(tx, connection);
        return { signature };
      },
      sendTransaction: async (tx) => {
        return await wallet.sendTransaction(tx, connection);
      },
    },
    {
      JUPITER_FEE_BPS: 50, // 0.5% referral fee
      PRIORITY_LEVEL: 'high',
    }
  );
  
  // Use the agent
  const balance = await agent.methods.get_balance();
  
  return <View>{/* Your UI */}</View>;
}

RPC configuration

The agentBuilder determines the RPC URL in the following order:

Environment variable: process.env.NEXT_PUBLIC_SOLANA_RPC
Default fallback: Devnet cluster URL from @solana/web3.js

For production applications, always set NEXT_PUBLIC_SOLANA_RPC to a dedicated RPC provider URL (Helius, QuickNode, etc.) for better performance and reliability.

.env.local

NEXT_PUBLIC_SOLANA_RPC=https://mainnet.helius-rpc.com/?api-key=YOUR_KEY

Default agent builder

For testing or development without a connected wallet, use defaultAgentBuilder:

import { defaultAgentBuilder } from '@synto/agent';

const agent = defaultAgentBuilder();

// This agent has all plugins loaded but with stub wallet functions
// Useful for:
// - Testing UI components
// - Development without wallet connection
// - Simulating agent behavior

defaultAgentBuilder() creates an agent with empty/stub wallet functions. It cannot sign or send real transactions. Only use it for testing and development.

Type definitions

FNs

Wallet function interface for the agent builder.

type FNs = {
  signAndSendTransaction: <T extends Transaction | VersionedTransaction>(
    transaction: T
  ) => Promise<{ signature: TransactionSignature }>;
  
  signTransaction: <T extends Transaction | VersionedTransaction>(
    transaction: T
  ) => Promise<T>;
  
  signMessage: (msg: Uint8Array) => Promise<Uint8Array>;
  
  sendTransaction: <T extends Transaction | VersionedTransaction>(
    transaction: T
  ) => Promise<string>;
  
  signAllTransactions: <T extends Transaction | VersionedTransaction>(
    transactions: T[]
  ) => Promise<T[]>;
  
  publicKey: PublicKey;
}

Best practices

Wallet integration

Always ensure wallet functions are properly connected before creating the agent:

if (!wallet.connected || !wallet.publicKey) {
  throw new Error('Wallet not connected');
}

const agent = agentBuilder({
  publicKey: wallet.publicKey,
  // ... other functions
});

Error handling

Wrap agent operations in try-catch blocks:

try {
  const result = await agent.methods.transfer(recipient, amount);
  console.log('Success:', result);
} catch (error) {
  if (error.message.includes('insufficient funds')) {
    // Handle insufficient balance
  } else if (error.message.includes('User rejected')) {
    // Handle user rejection
  } else {
    // Handle other errors
  }
}

Configuration management

Store sensitive configuration in environment variables:

const agent = agentBuilder(walletFunctions, {
  HELIUS_API_KEY: process.env.HELIUS_API_KEY,
  JUPITER_REFERRAL_ACCOUNT: process.env.JUPITER_REFERRAL,
  JUPITER_FEE_BPS: Number(process.env.JUPITER_FEE_BPS),
});

Performance optimization

Create the agent once and reuse it:

// In React
const agent = useMemo(
  () => agentBuilder(walletFunctions, config),
  [wallet.publicKey] // Only recreate when wallet changes
);

Troubleshooting

Transaction failed: Wallet does not support signAndSendTransaction

Ensure your wallet adapter implements the signAndSendTransaction method, or set signOnly: true in the config:

const agent = agentBuilder(walletFunctions, { signOnly: true });

Method not found in agent.methods

The method you’re trying to use might not be available in the default plugins. Check that the required plugin is loaded:

// List available methods
console.log(Object.keys(agent.methods));

// Add custom plugin if needed
const extendedAgent = agent.use(customPlugin);

RPC rate limit errors

Configure a dedicated RPC provider:

NEXT_PUBLIC_SOLANA_RPC=https://your-dedicated-rpc.com

Consider using rate limit headers and implementing retry logic.

SolanaAgentKit

Core agent class for advanced usage

Plugins

Available plugins and custom plugin development

Wallet integration

Guide to setting up wallet connections

Actions

Working with agent actions

Agent Core

Token Plugin

DeFi Plugin

Components

Overview

Function signature

Parameters

Returns

Built-in plugins

Examples

RPC configuration

Default agent builder

Type definitions

FNs

Best practices

Troubleshooting

SolanaAgentKit

Plugins

Wallet integration

Actions

Build docs developers (and LLMs) love

Agent Core

Token Plugin

DeFi Plugin

Components

​Overview

​Function signature

​Parameters

​Returns

​Built-in plugins

​Examples

​RPC configuration

​Default agent builder

​Type definitions

​FNs

​Best practices

​Troubleshooting

​Related

SolanaAgentKit

Plugins

Wallet integration

Actions

Build docs developers (and LLMs) love

Overview

Function signature

Parameters

Returns

Built-in plugins

Examples

RPC configuration

Default agent builder

Type definitions

FNs

Best practices

Troubleshooting

Related