Search & Filtering

The Renesis Stellar DEX Vaults API provides powerful search and filtering capabilities to help you discover and query vaults efficiently. This section covers the advanced search endpoint with comprehensive filtering, pagination, and sorting options.

GET /api/vaults/search

Advanced search endpoint for discovering vaults with flexible filtering, pagination, and sorting capabilities.

Parameters

Query Parameters

page (number, optional): Page number for pagination (default: 1, min: 1)
limit (number, optional): Number of items per page (default: 10, min: 1, max: 100)
owner (string, optional): Filter by vault owner Stellar address (must start with ‘G’, 56 characters)
tradePermission (boolean, optional): Filter by trade permission status (true or false)
search (string, optional): Search vault names using case-insensitive partial matching
sortBy (string, optional): Sort field - creationDate, creationLedger, vaultName, updatedAt (default: creationDate)
sortOrder (string, optional): Sort order - asc or desc (default: desc)
minLedger (number, optional): Filter vaults created after this ledger number (inclusive)
maxLedger (number, optional): Filter vaults created before this ledger number (inclusive)

Request Examples

Basic Search with Pagination

curl -X GET "https://api.renesis.fi/api/vaults/search?page=1&limit=20" \
  -H "Authorization: Bearer YOUR_API_KEY"

Search by Vault Name

curl -X GET "https://api.renesis.fi/api/vaults/search?search=trading&page=1&limit=10" \
  -H "Authorization: Bearer YOUR_API_KEY"

Filter by Owner and Trade Permission

curl -X GET "https://api.renesis.fi/api/vaults/search?owner=GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ&tradePermission=true&page=1&limit=10" \
  -H "Authorization: Bearer YOUR_API_KEY"

Filter by Ledger Range with Sorting

curl -X GET "https://api.renesis.fi/api/vaults/search?minLedger=123400000&maxLedger=123500000&sortBy=creationLedger&sortOrder=asc&page=1&limit=25" \
  -H "Authorization: Bearer YOUR_API_KEY"

Complex Multi-Filter Search

curl -X GET "https://api.renesis.fi/api/vaults/search?search=vault&owner=GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ&tradePermission=true&minLedger=123450000&sortBy=vaultName&sortOrder=asc&page=2&limit=15" \
  -H "Authorization: Bearer YOUR_API_KEY"

Response Example

{
  "success": true,
  "message": "Vaults retrieved successfully",
  "data": [
    {
      "id": "507f1f77bcf86cd799439011",
      "vaultName": "My Trading Vault",
      "vaultOwner": "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      "vaultAddress": "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      "creationDate": "2024-01-15T10:30:00.000Z",
      "creationLedger": 123456789,
      "tradePermission": true,
      "maxTradeSize": 10,
      "dailyTradeLimit": 5,
      "slippageTolerance": 0.5,
      "updatedAt": "2024-01-15T10:30:00.000Z",
      "createdAt": "2024-01-15T10:30:00.000Z"
    },
    {
      "id": "507f1f77bcf86cd799439012",
      "vaultName": "Advanced Trading Vault",
      "vaultOwner": "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      "vaultAddress": "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGX",
      "creationDate": "2024-01-14T09:15:00.000Z",
      "creationLedger": 123456788,
      "tradePermission": true,
      "maxTradeSize": 15,
      "dailyTradeLimit": 10,
      "slippageTolerance": 0.3,
      "updatedAt": "2024-01-14T09:15:00.000Z",
      "createdAt": "2024-01-14T09:15:00.000Z"
    }
  ],
  "pagination": {
    "page": 1,
    "limit": 10,
    "totalItems": 25,
    "totalPages": 3,
    "hasNext": true,
    "hasPrev": false
  }
}

Error Responses

400 Bad Request - Invalid Parameters

{
  "success": false,
  "message": "Invalid query parameters",
  "errors": [
    {
      "field": "limit",
      "message": "Limit must be between 1 and 100",
      "value": 150
    },
    {
      "field": "sortBy",
      "message": "Sort field must be one of: creationDate, creationLedger, vaultName, updatedAt",
      "value": "invalidField"
    }
  ]
}

400 Bad Request - Invalid Owner Address

{
  "success": false,
  "message": "Invalid Stellar address format",
  "errors": [
    {
      "field": "owner",
      "message": "Must be a valid Stellar address starting with 'G' and 56 characters long",
      "value": "invalid-address"
    }
  ]
}

400 Bad Request - Invalid Ledger Range

{
  "success": false,
  "message": "Invalid ledger range",
  "errors": [
    {
      "field": "minLedger",
      "message": "Minimum ledger must be less than maximum ledger",
      "value": 123500000
    },
    {
      "field": "maxLedger",
      "message": "Maximum ledger must be greater than minimum ledger",
      "value": 123400000
    }
  ]
}

Pagination Structure

The search endpoint returns comprehensive pagination information to help you navigate through large result sets efficiently.

Pagination Response Fields

page (number): Current page number (1-based indexing)
limit (number): Number of items per page as requested
totalItems (number): Total number of vaults matching the search criteria
totalPages (number): Total number of pages available
hasNext (boolean): Whether there are more pages after the current page
hasPrev (boolean): Whether there are pages before the current page

Pagination Example

{
  "pagination": {
    "page": 2,
    "limit": 10,
    "totalItems": 47,
    "totalPages": 5,
    "hasNext": true,
    "hasPrev": true
  }
}

Pagination Best Practices

Start Small: Begin with a reasonable page size (10-25 items) to optimize performance
Check Boundaries: Always check hasNext and hasPrev before navigating
Handle Empty Results: Be prepared for empty result sets when no vaults match criteria
Respect Limits: The maximum page size is 100 items to prevent performance issues

Filtering Options

Owner Filtering

Filter vaults by their owner’s Stellar address. The owner parameter must be a valid Stellar address starting with ‘G’ and exactly 56 characters long.

# Find all vaults owned by a specific address
curl -X GET "https://api.renesis.fi/api/vaults/search?owner=GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ" \
  -H "Authorization: Bearer YOUR_API_KEY"

Trade Permission Filtering

Filter vaults based on their trading permission status. Use true to find vaults with trading enabled, or false for vaults with trading disabled.

# Find all trade-enabled vaults
curl -X GET "https://api.renesis.fi/api/vaults/search?tradePermission=true" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Find all vaults with trading disabled
curl -X GET "https://api.renesis.fi/api/vaults/search?tradePermission=false" \
  -H "Authorization: Bearer YOUR_API_KEY"

Name Search Filtering

Search vault names using case-insensitive partial matching. The search parameter will match any vault name containing the specified text.

# Find vaults with "trading" in the name
curl -X GET "https://api.renesis.fi/api/vaults/search?search=trading" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Find vaults with "vault" in the name
curl -X GET "https://api.renesis.fi/api/vaults/search?search=vault" \
  -H "Authorization: Bearer YOUR_API_KEY"

Ledger Range Filtering

Filter vaults based on their creation ledger numbers. Use minLedger and maxLedger to define a range of ledger numbers.

# Find vaults created between specific ledger numbers
curl -X GET "https://api.renesis.fi/api/vaults/search?minLedger=123400000&maxLedger=123500000" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Find vaults created after a specific ledger
curl -X GET "https://api.renesis.fi/api/vaults/search?minLedger=123450000" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Find vaults created before a specific ledger
curl -X GET "https://api.renesis.fi/api/vaults/search?maxLedger=123450000" \
  -H "Authorization: Bearer YOUR_API_KEY"

Sorting Options

Available Sort Fields

creationDate: Sort by vault creation timestamp (default)
creationLedger: Sort by Stellar ledger number when vault was created
vaultName: Sort alphabetically by vault name
updatedAt: Sort by last modification timestamp

Sort Orders

desc: Descending order (newest/highest first) - default
asc: Ascending order (oldest/lowest first)

Sorting Examples

# Sort by creation date (newest first)
curl -X GET "https://api.renesis.fi/api/vaults/search?sortBy=creationDate&sortOrder=desc" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Sort by vault name alphabetically
curl -X GET "https://api.renesis.fi/api/vaults/search?sortBy=vaultName&sortOrder=asc" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Sort by creation ledger (oldest first)
curl -X GET "https://api.renesis.fi/api/vaults/search?sortBy=creationLedger&sortOrder=asc" \
  -H "Authorization: Bearer YOUR_API_KEY"

# Sort by last update (most recently updated first)
curl -X GET "https://api.renesis.fi/api/vaults/search?sortBy=updatedAt&sortOrder=desc" \
  -H "Authorization: Bearer YOUR_API_KEY"

Comprehensive Filtering Examples

Example 1: Find Recent Trading Vaults

Find all vaults with trading enabled that were created in the last 1000 ledgers, sorted by creation date.

curl -X GET "https://api.renesis.fi/api/vaults/search?tradePermission=true&minLedger=123456000&sortBy=creationDate&sortOrder=desc&limit=20" \
  -H "Authorization: Bearer YOUR_API_KEY"

Example 2: Owner’s Trading Vaults with Name Search

Find all vaults owned by a specific address that have “trading” in the name and have trading enabled.

curl -X GET "https://api.renesis.fi/api/vaults/search?owner=GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ&search=trading&tradePermission=true&sortBy=vaultName&sortOrder=asc" \
  -H "Authorization: Bearer YOUR_API_KEY"

Example 3: Historical Vault Analysis

Find all vaults created within a specific ledger range, sorted by creation ledger for historical analysis.

curl -X GET "https://api.renesis.fi/api/vaults/search?minLedger=123400000&maxLedger=123450000&sortBy=creationLedger&sortOrder=asc&limit=50" \
  -H "Authorization: Bearer YOUR_API_KEY"

Example 4: Recently Updated Vaults

Find vaults that have been recently updated, regardless of other criteria.

curl -X GET "https://api.renesis.fi/api/vaults/search?sortBy=updatedAt&sortOrder=desc&limit=25" \
  -H "Authorization: Bearer YOUR_API_KEY"

Example 5: Complex Multi-Criteria Search

Find vaults owned by a specific address, with trading disabled, created after a certain ledger, with “storage” in the name.

curl -X GET "https://api.renesis.fi/api/vaults/search?owner=GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ&tradePermission=false&search=storage&minLedger=123450000&sortBy=creationDate&sortOrder=desc&page=1&limit=15" \
  -H "Authorization: Bearer YOUR_API_KEY"

Performance Considerations

Optimization Tips

Use Specific Filters: More specific filters reduce the result set and improve performance
Reasonable Page Sizes: Keep page sizes between 10-50 items for optimal performance
Index-Friendly Sorting: Sorting by creationDate or creationLedger is most efficient
Combine Filters: Use multiple filters together to narrow results effectively

Query Performance

Fast Queries: Owner filtering, trade permission filtering, ledger range filtering
Moderate Queries: Name search (uses text indexing)
Complex Queries: Multiple combined filters with large result sets

Caching Recommendations

Cache frequently used search results for short periods (1-5 minutes)
Cache pagination metadata for consistent user experience
Invalidate cache when vault data is modified

Common Search Patterns

Dashboard Queries

# Recent vaults for dashboard
curl -X GET "https://api.renesis.fi/api/vaults/search?sortBy=creationDate&sortOrder=desc&limit=10" \
  -H "Authorization: Bearer YOUR_API_KEY"

# User's vaults for profile page
curl -X GET "https://api.renesis.fi/api/vaults/search?owner=GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ&sortBy=updatedAt&sortOrder=desc" \
  -H "Authorization: Bearer YOUR_API_KEY"

Trading Interface Queries

# Available trading vaults
curl -X GET "https://api.renesis.fi/api/vaults/search?tradePermission=true&sortBy=vaultName&sortOrder=asc" \
  -H "Authorization: Bearer YOUR_API_KEY"

# High-activity trading vaults
curl -X GET "https://api.renesis.fi/api/vaults/search?tradePermission=true&sortBy=updatedAt&sortOrder=desc&limit=20" \
  -H "Authorization: Bearer YOUR_API_KEY"

Analytics Queries

# Vaults by creation period
curl -X GET "https://api.renesis.fi/api/vaults/search?minLedger=123400000&maxLedger=123500000&sortBy=creationLedger&sortOrder=asc&limit=100" \
  -H "Authorization: Bearer YOUR_API_KEY"

# All vaults for statistical analysis
curl -X GET "https://api.renesis.fi/api/vaults/search?limit=100&page=1" \
  -H "Authorization: Bearer YOUR_API_KEY"

TypeScript Interfaces

Search Parameters Interface

interface VaultSearchParams {
  page?: number;                 // Page number (default: 1, min: 1)
  limit?: number;                // Items per page (default: 10, min: 1, max: 100)
  owner?: string;                // Stellar address filter (56 chars, starts with 'G')
  tradePermission?: boolean;     // Trade permission filter
  search?: string;               // Vault name search (case-insensitive)
  sortBy?: 'creationDate' | 'creationLedger' | 'vaultName' | 'updatedAt';
  sortOrder?: 'asc' | 'desc';    // Sort order (default: 'desc')
  minLedger?: number;            // Minimum creation ledger (inclusive)
  maxLedger?: number;            // Maximum creation ledger (inclusive)
}

interface VaultSearchResponse {
  success: boolean;
  message: string;
  data: Vault[];
  pagination: {
    page: number;
    limit: number;
    totalItems: number;
    totalPages: number;
    hasNext: boolean;
    hasPrev: boolean;
  };
}

interface SearchFilters {
  owner?: {
    address: string;
    displayName?: string;
  };
  tradePermission?: boolean;
  nameSearch?: string;
  ledgerRange?: {
    min?: number;
    max?: number;
  };
  dateRange?: {
    start?: string;
    end?: string;
  };
}

interface SearchMetadata {
  totalResults: number;
  searchTime: number;
  appliedFilters: string[];
  suggestedFilters?: string[];
}

Example Search Responses

// Example comprehensive search response
const exampleSearchResponse: VaultSearchResponse = {
  success: true,
  message: "Vaults retrieved successfully",
  data: [
    {
      id: "507f1f77bcf86cd799439011",
      vaultName: "DeFi Trading Vault",
      vaultOwner: "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      vaultAddress: "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      creationDate: "2024-01-15T10:30:00.000Z",
      creationLedger: 123456789,
      tradePermission: true,
      maxTradeSize: 15,
      dailyTradeLimit: 10,
      slippageTolerance: 0.5,
      updatedAt: "2024-01-15T14:22:30.000Z",
      createdAt: "2024-01-15T10:30:00.000Z"
    },
    {
      id: "507f1f77bcf86cd799439012",
      vaultName: "Yield Farming Vault",
      vaultOwner: "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      vaultAddress: "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGX",
      creationDate: "2024-01-14T09:15:00.000Z",
      creationLedger: 123456788,
      tradePermission: true,
      maxTradeSize: 20,
      dailyTradeLimit: 15,
      slippageTolerance: 0.3,
      updatedAt: "2024-01-14T16:45:00.000Z",
      createdAt: "2024-01-14T09:15:00.000Z"
    },
    {
      id: "507f1f77bcf86cd799439013",
      vaultName: "Conservative Storage Vault",
      vaultOwner: "GB8QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      vaultAddress: "CB8QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
      creationDate: "2024-01-13T14:20:00.000Z",
      creationLedger: 123456787,
      tradePermission: false,
      maxTradeSize: 0,
      dailyTradeLimit: 0,
      slippageTolerance: 1.0,
      updatedAt: "2024-01-13T14:20:00.000Z",
      createdAt: "2024-01-13T14:20:00.000Z"
    }
  ],
  pagination: {
    page: 1,
    limit: 10,
    totalItems: 47,
    totalPages: 5,
    hasNext: true,
    hasPrev: false
  }
};

// Example empty search response
const exampleEmptyResponse: VaultSearchResponse = {
  success: true,
  message: "No vaults found matching the search criteria",
  data: [],
  pagination: {
    page: 1,
    limit: 10,
    totalItems: 0,
    totalPages: 0,
    hasNext: false,
    hasPrev: false
  }
};

Advanced Search Examples

// Complex search with multiple filters
const advancedSearchParams: VaultSearchParams = {
  owner: "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
  tradePermission: true,
  search: "trading",
  minLedger: 123450000,
  maxLedger: 123460000,
  sortBy: "updatedAt",
  sortOrder: "desc",
  page: 2,
  limit: 25
};

// Search for high-activity vaults
const highActivitySearch: VaultSearchParams = {
  tradePermission: true,
  sortBy: "updatedAt",
  sortOrder: "desc",
  limit: 50
};

// Search for new vaults
const newVaultsSearch: VaultSearchParams = {
  minLedger: 123456000,
  sortBy: "creationDate",
  sortOrder: "desc",
  limit: 20
};

// Search for specific owner's vaults
const ownerVaultsSearch: VaultSearchParams = {
  owner: "GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ",
  sortBy: "vaultName",
  sortOrder: "asc"
};

Integration Examples

JavaScript/TypeScript Integration

class VaultSearchClient {
  private apiKey: string;
  private baseUrl: string;

  constructor(apiKey: string, baseUrl = 'https://api.renesis.fi') {
    this.apiKey = apiKey;
    this.baseUrl = baseUrl;
  }

  async searchVaults(params: VaultSearchParams): Promise<VaultSearchResponse> {
    const queryString = new URLSearchParams();
    
    Object.entries(params).forEach(([key, value]) => {
      if (value !== undefined && value !== null) {
        queryString.append(key, value.toString());
      }
    });

    const response = await fetch(`${this.baseUrl}/api/vaults/search?${queryString}`, {
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });

    if (!response.ok) {
      throw new Error(`Search failed: ${response.statusText}`);
    }

    return response.json();
  }

  // Helper method for paginated searches
  async searchAllPages(params: VaultSearchParams): Promise<Vault[]> {
    const allVaults: Vault[] = [];
    let currentPage = 1;
    let hasMore = true;

    while (hasMore) {
      const response = await this.searchVaults({
        ...params,
        page: currentPage
      });

      allVaults.push(...response.data);
      hasMore = response.pagination.hasNext;
      currentPage++;
    }

    return allVaults;
  }

  // Helper method for filtered searches
  async searchWithFilters(filters: SearchFilters): Promise<VaultSearchResponse> {
    const params: VaultSearchParams = {};

    if (filters.owner) {
      params.owner = filters.owner.address;
    }

    if (filters.tradePermission !== undefined) {
      params.tradePermission = filters.tradePermission;
    }

    if (filters.nameSearch) {
      params.search = filters.nameSearch;
    }

    if (filters.ledgerRange) {
      if (filters.ledgerRange.min) params.minLedger = filters.ledgerRange.min;
      if (filters.ledgerRange.max) params.maxLedger = filters.ledgerRange.max;
    }

    return this.searchVaults(params);
  }
}

// Usage examples
const client = new VaultSearchClient('YOUR_API_KEY');

// Basic search
const recentVaults = await client.searchVaults({
  sortBy: 'creationDate',
  sortOrder: 'desc',
  limit: 20
});

// Search with filters
const tradingVaults = await client.searchWithFilters({
  tradePermission: true,
  nameSearch: 'trading',
  owner: {
    address: 'GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ'
  }
});

// Get all vaults for analysis
const allUserVaults = await client.searchAllPages({
  owner: 'GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ'
});

// Advanced search with error handling
try {
  const results = await client.searchVaults({
    search: 'defi',
    tradePermission: true,
    minLedger: 123450000,
    sortBy: 'updatedAt',
    sortOrder: 'desc',
    page: 1,
    limit: 50
  });

  console.log(`Found ${results.pagination.totalItems} vaults`);
  results.data.forEach(vault => {
    console.log(`${vault.vaultName} - ${vault.vaultOwner}`);
  });
} catch (error) {
  console.error('Search failed:', error);
}

React Hook Example

import { useState, useEffect } from 'react';

interface UseVaultSearchResult {
  vaults: Vault[];
  loading: boolean;
  error: string | null;
  pagination: VaultSearchResponse['pagination'] | null;
  search: (params: VaultSearchParams) => Promise<void>;
  loadMore: () => Promise<void>;
}

export function useVaultSearch(initialParams?: VaultSearchParams): UseVaultSearchResult {
  const [vaults, setVaults] = useState<Vault[]>([]);
  const [loading, setLoading] = useState(false);
  const [error, setError] = useState<string | null>(null);
  const [pagination, setPagination] = useState<VaultSearchResponse['pagination'] | null>(null);
  const [currentParams, setCurrentParams] = useState<VaultSearchParams>(initialParams || {});

  const client = new VaultSearchClient(process.env.REACT_APP_API_KEY!);

  const search = async (params: VaultSearchParams) => {
    setLoading(true);
    setError(null);
    
    try {
      const response = await client.searchVaults(params);
      setVaults(response.data);
      setPagination(response.pagination);
      setCurrentParams(params);
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Search failed');
    } finally {
      setLoading(false);
    }
  };

  const loadMore = async () => {
    if (!pagination?.hasNext) return;

    setLoading(true);
    try {
      const response = await client.searchVaults({
        ...currentParams,
        page: pagination.page + 1
      });
      
      setVaults(prev => [...prev, ...response.data]);
      setPagination(response.pagination);
    } catch (err) {
      setError(err instanceof Error ? err.message : 'Load more failed');
    } finally {
      setLoading(false);
    }
  };

  useEffect(() => {
    if (initialParams) {
      search(initialParams);
    }
  }, []);

  return {
    vaults,
    loading,
    error,
    pagination,
    search,
    loadMore
  };
}

// Usage in React component
function VaultSearchComponent() {
  const { vaults, loading, error, pagination, search, loadMore } = useVaultSearch({
    sortBy: 'creationDate',
    sortOrder: 'desc',
    limit: 20
  });

  const handleSearch = (searchTerm: string) => {
    search({
      search: searchTerm,
      sortBy: 'vaultName',
      sortOrder: 'asc',
      limit: 20
    });
  };

  if (loading && vaults.length === 0) return <div>Loading...</div>;
  if (error) return <div>Error: {error}</div>;

  return (
    <div>
      <input 
        type="text" 
        placeholder="Search vaults..."
        onChange={(e) => handleSearch(e.target.value)}
      />
      
      {vaults.map(vault => (
        <div key={vault.id}>
          <h3>{vault.vaultName}</h3>
          <p>Owner: {vault.vaultOwner}</p>
          <p>Trading: {vault.tradePermission ? 'Enabled' : 'Disabled'}</p>
        </div>
      ))}
      
      {pagination?.hasNext && (
        <button onClick={loadMore} disabled={loading}>
          {loading ? 'Loading...' : 'Load More'}
        </button>
      )}
    </div>
  );
}

Python Integration

import requests
from typing import Optional, Literal

def search_vaults(
    api_key: str,
    page: Optional[int] = None,
    limit: Optional[int] = None,
    owner: Optional[str] = None,
    trade_permission: Optional[bool] = None,
    search: Optional[str] = None,
    sort_by: Optional[Literal['creationDate', 'creationLedger', 'vaultName', 'updatedAt']] = None,
    sort_order: Optional[Literal['asc', 'desc']] = None,
    min_ledger: Optional[int] = None,
    max_ledger: Optional[int] = None
):
    params = {}
    
    if page is not None:
        params['page'] = page
    if limit is not None:
        params['limit'] = limit
    if owner is not None:
        params['owner'] = owner
    if trade_permission is not None:
        params['tradePermission'] = str(trade_permission).lower()
    if search is not None:
        params['search'] = search
    if sort_by is not None:
        params['sortBy'] = sort_by
    if sort_order is not None:
        params['sortOrder'] = sort_order
    if min_ledger is not None:
        params['minLedger'] = min_ledger
    if max_ledger is not None:
        params['maxLedger'] = max_ledger
    
    response = requests.get(
        'https://api.renesis.fi/api/vaults/search',
        params=params,
        headers={'Authorization': f'Bearer {api_key}'}
    )
    
    return response.json()

# Usage examples
recent_vaults = search_vaults(
    api_key=API_KEY,
    sort_by='creationDate',
    sort_order='desc',
    limit=20
)

user_trading_vaults = search_vaults(
    api_key=API_KEY,
    owner='GA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJVSGZ',
    trade_permission=True,
    search='trading'
)

Next Steps

Vault Endpoints - Core vault management operations
Token Endpoints - Token holdings and balance management
Error Handling - Error codes and troubleshooting
API Overview - Authentication and general API information

Getting Started

Vaults

Smart Contracts

Order Execution

Swap Infrastructure

Contract Addresses

API Reference

Disclaimers