How RebelFi Works

Flow of Funds Overview

RebelFi operates as a non-custodial orchestration layer that optimizes your stablecoin operations while you maintain complete control over custody and execution.

Key Principle: RebelFi never holds your private keys or controls your funds. We generate optimized transaction strategies which your custody solution executes.

The Five-Step Process

Step 1: Monitor & Analyze

RebelFi monitors your designated stablecoin wallets for:

Balance changes and inbound transactions
Deployed allocation performance
Buffer levels and liquidity requirements

Based on configured parameters (buffer amounts, yield enablement), our engine continuously analyzes optimization opportunities.

Step 2: Generate Operations

When optimization opportunities arise, RebelFi creates Operations — structured workflows that describe business intent:

Supply Operations: Deploy idle funds to yield-generating protocols
Disburse Operations: Withdraw funds from yield back to operational wallets
Rebalance Operations: Shift allocations between protocols for optimal returns

Each operation includes:

Financial reservations (locks on available balances)
Multi-step execution plans
Expected blockchain transactions
State management and tracking

Step 3: Your Review & Approval

Operations can be configured for:

Automatic Execution
Manual Approval

Operations proceed automatically for hands-off yield optimizationBest for: Trusted operational flows, yield-only deployments

You can query pending operations:

// Check operations queue
const queue = await rebelfi.operations.getQueue();

// Approve specific operation
await rebelfi.operations.approve(operationId);

// Or reject
await rebelfi.operations.reject(operationId);

Step 4: Custody Integration & Execution

RebelFi integrates with your custody solution through flexible patterns that fit your infrastructure:

Integration Type	How It Works	Best For
Agent Polling	Deploy your own agent or use RebelFi’s managed agent to poll for transactions, sign them, and report execution status	Maximum control, any custody solution, custom infrastructure
Direct API	Provide custody API credentials (e.g., Fireblocks API key) and RebelFi submits transactions directly to your custody provider	Streamlined workflow with API-first custody providers like Fireblocks, BitGo
Custom Adapter	Work with RebelFi to build custom integration for home-grown or specialized custody solutions	Proprietary custody systems, unique requirements

All integration patterns ensure you maintain complete signing authority. RebelFi cannot execute transactions without your custody solution’s approval and signature.

Example: Agent Polling Flow

// Agent polls for pending transactions
const pollResponse = await rebelfi.agent.transactions.poll({
  leaseDurationMs: 30000
});

if (pollResponse.transaction) {
  // Sign with your custody solution
  const signedTx = await custodySolution.sign(pollResponse.transaction.unsignedTx);

  // Submit to blockchain
  const txHash = await blockchain.submit(signedTx);

  // Report back to RebelFi
  await rebelfi.agent.transactions.report(pollResponse.transaction.id, {
    status: 'SUBMITTED',
    txHash: txHash
  });
}

Step 5: Track & Confirm

RebelFi’s monitoring system:

Observes blockchain for transaction confirmation
Matches confirmed transactions to expected operations
Updates financial state (reservations → allocations)
Tracks yield accrual and performance

You can track operation status:

// Get operation history
const history = await rebelfi.operations.getHistory({
  limit: 50,
  status: 'COMPLETED'
});

// Get allocation details
const allocations = await rebelfi.allocations.list();

Architecture Deep Dive

Non-Custodial Design

Your Custody Provider

You maintain custody through Fireblocks, BitGo, Privy, or a custom solution. Private keys never leave your infrastructure.

RebelFi Orchestration

RebelFi monitors wallets, generates operation plans, and provides transaction payloads. We operate in advisory capacity only.

You Control Execution

Your custody solution reviews, signs, and broadcasts transactions. You maintain complete control over every on-chain action.

Blockchain Settlement

Transactions settle on-chain (Solana, EVM chains). Funds deploy to battle-tested DeFi protocols earning yield.

Real-Time Tracking

RebelFi monitors blockchain, confirms settlement, and provides real-time visibility into positions and performance.

Operation Lifecycle

PLANNING → PENDING_APPROVAL → EXECUTING → CONFIRMING → COMPLETED
   ↓             ↓                 ↓            ↓           ↓
Created     (Manual)          Signing     On-chain    Allocation
           Approval         by Custody   Settlement    Active

Key States:

PLANNING: Operation created, financial reservation locked
PENDING_APPROVAL: Awaiting manual approval (if required)
EXECUTING: Transaction being signed and submitted by custody
CONFIRMING: Submitted to blockchain, awaiting confirmation
COMPLETED: Confirmed on-chain, financial state updated

Financial State Management

RebelFi maintains a complete financial ledger using double-entry accounting:

Reservations - Temporary locks on funds while operations are in-flight
Expected Receipts - Anticipated inbound transactions (matched upon arrival)
Journal Entries - Immutable record of all financial state changes
Positions - Read-optimized view of current wallet balances
Allocations - Deployed funds earning yield in protocols

Example: Supply Operation Financial Flow

Initial State:

Wallet has 10,000 USDC available

Operation Created (PLANNING):

Create Reservation: Lock 5,000 USDC
Available balance: 5,000 USDC
Reserved balance: 5,000 USDC

Transaction Confirmed (COMPLETED):

Consume Reservation: Release 5,000 USDC lock
Create Allocation: 5,000 USDC deployed to Protocol X
Journal Entry: TRANSFER_OUT 5,000 USDC from wallet

Final State:

Available: 5,000 USDC
Deployed: 5,000 USDC (earning yield)
Total: 10,000 USDC

Security Model

Zero Trust Architecture

RebelFi is designed with zero trust principles:

No Key Access - We cannot access your private keys under any circumstances
No Fund Control - We cannot move funds without your custody solution signing
No Direct Execution - All transactions require your explicit signing authority
Complete Audit Trail - Every operation, reservation, and state change is logged

Transaction Safety

Operations include safety mechanisms:

Atomic Reservations: Funds are locked during operations to prevent double-spending
Idempotency: Operations can be safely retried without duplicate effects
State Validation: Each state transition is validated against allowed progressions
Timeout Handling: Operations that don’t complete within timeframes are automatically released

Protocol Vetting

Yield protocols are carefully evaluated for:

Smart contract audits
Historical performance and uptime
Total value locked (TVL)
Institutional usage
Risk-adjusted returns

Initially, RebelFi focuses on battle-tested protocols with institutional adoption and comprehensive audit histories.

Integration Patterns

Pattern 1: Agent Polling

Deploy an agent (your own or RebelFi’s managed agent) that polls for transactions:

Your Agent: Run your own polling service that integrates with your custody infrastructure
RebelFi Agent: Use our managed agent service with your custody credentials

The agent polls for pending transactions, signs using your custody infrastructure, and reports execution status. Best for: Maximum control, any custody solution, custom infrastructure

Learn More

Complete guide to agent-based custody integration

Pattern 2: Direct API Integration

Provide custody API credentials (e.g., Fireblocks API key) to RebelFi:

RebelFi submits transactions directly to your custody provider’s API
Custody provider’s policy engine reviews and signs
Automated or manual approval flows based on your policies
Real-time status updates

Best for: Fireblocks, BitGo, and other API-first custody providers

Pattern 3: White-Label Deployment

RebelFi powers your branded yield product:

Your API wraps RebelFi infrastructure
Your branding and user experience
We handle orchestration, monitoring, optimization
You own customer relationship

Best for: Wallets, neobanks offering yield to end users

Pattern 4: Custom Adapters

For home-grown or specialized custody solutions:

Work with RebelFi to build custom integration adapters
Support for proprietary custody systems
Flexible integration patterns based on your architecture
Maintained compatibility as your system evolves

Best for: Proprietary custody infrastructure, unique security requirements, specialized workflows

RebelFi works with any custody solution. We either use an existing adapter (Tatum, Fireblocks, BitGo, etc.) or work with you to build a custom adapter for your infrastructure.

Multi-Blockchain Support

RebelFi supports multiple blockchain networks:

Solana - Native SPL token support, sub-second finality
EVM Chains - Ethereum, Base, Arbitrum, Polygon

Blockchain adapters provide:

Unified address monitoring
Chain-specific transaction building
Cross-chain balance aggregation
Protocol abstraction

What Makes RebelFi Different?

Operations Model

Structured business workflows, not just transaction builders. Operations express what you want to accomplish.

Financial Ledger

Complete double-entry accounting provides accurate financial state and audit trails.

Agent Architecture

Your custody, your keys, your control. We generate strategies; you execute them.

API-First

Everything is accessible via API. Build custom workflows, integrate with existing systems.

Next Steps

Quick Start

Integrate RebelFi in 10 minutes

Custody Integration

Set up your custody agent

API Reference

Explore the API documentation

Use Cases

See real-world examples

Getting Started

Integration

Use Cases

​Flow of Funds Overview

​The Five-Step Process

​Step 1: Monitor & Analyze

​Step 2: Generate Operations

​Step 3: Your Review & Approval

​Step 4: Custody Integration & Execution

​Step 5: Track & Confirm

​Architecture Deep Dive

​Non-Custodial Design

​Operation Lifecycle

​Financial State Management

​Security Model

​Zero Trust Architecture

​Transaction Safety

​Protocol Vetting

​Integration Patterns

​Pattern 1: Agent Polling

Learn More

​Pattern 2: Direct API Integration

​Pattern 3: White-Label Deployment

​Pattern 4: Custom Adapters

​Multi-Blockchain Support

​What Makes RebelFi Different?

Operations Model

Financial Ledger

Agent Architecture

API-First

​Next Steps

Quick Start

Custody Integration

API Reference

Use Cases

Flow of Funds Overview

The Five-Step Process

Step 1: Monitor & Analyze

Step 2: Generate Operations

Step 3: Your Review & Approval

Step 4: Custody Integration & Execution

Step 5: Track & Confirm

Architecture Deep Dive

Non-Custodial Design

Operation Lifecycle

Financial State Management

Security Model

Zero Trust Architecture

Transaction Safety

Protocol Vetting

Integration Patterns

Pattern 1: Agent Polling

Pattern 2: Direct API Integration

Pattern 3: White-Label Deployment

Pattern 4: Custom Adapters

Multi-Blockchain Support

What Makes RebelFi Different?

Next Steps