Open Index Protocol Architecture

Sections

  1. Overview

  2. Core Protocol

  3. Modules

  4. Design Principles

  5. Code Repository

1. Overview

Open Index Protocol is a Solana-native index fund engine that allows users or DAOs to create tokenized indexes. Each index represents a basket of SPL tokens. Users can mint and redeem index tokens based on the composition, and rebalancing logic is modularized for future extensions.

The protocol follows an SPL-style architecture, with clearly separated state accounts and support for plug-in modules such as rebalancers, swap executors and DeFI strategies . This design enables strategy-specific customization while remaining secure and composable.

2. Core Protocol

Features Implemented

  • InitProtocol: Initializes global protocol config

  • InitController: Sets up authority that can create indexes. Has a one to many relationship with protocol config

  • CreateIndex: Creates an index tied to a controller

  • AddIndexComponents: Adds SPL token components and weights

  • Mint / Redeem: Mints and burns index tokens using underlying tokens

  • InitModule: Registers external programs for advanced features eg Rebalancing, Amm Swap, DEFI Strategies

2.1. Key Accounts

PDA Account
PDA Seed(s)
Purpose

Protocol

["open_index"]

Global protocol settings, initialization guard

ControllerGlobalConfig

["open_index_controller_global"]

Stores authority and global controller settings

Controller

["open_index_controller", controller_id]

Stores settings for the controller and its indexes

Index

["open_index_index", controller_key, index_id]

Main state object representing an index

Component

["open_index_component", index_id, mint]

Represents each token component in the index

IndexMints

["open_index_mints_data", controller_id, index_id]

Tracks index mints and associated metadata

Module

["open_index_module", module_signer]

Holds registration & status (active/paused) for a plug-in program allowed to CPI into the core open index protocol

2.2 Roles & Access

Role
Permissions

Protocol Admin

Initialize protocol and global configs

Controller Owner

A controller is an administrative domain that can own multiple indexes and has its own configuration and governance. Create indexes, assign index managers , manage index components

User

Mint/redeem index tokens

Future DAO

Replace controller owner, vote on rebalance triggers

2.3 Instructions & Flow

A high-level view of user interactions with the protocol instructions and resulting accounts

Figure 1 – High level view of Open Index protocol instructions implemented in Phase 1

1 init_protocol

  • Initializes the top-level protocol state

  • Called once by the deployer or initializer

2 init_controller

  • Creates a controller for a specific index set - A controller is an administrative domain that can own multiple indexes and has its own configuration and governance.

  • Tied to an index ID

3 init_controller_global_config

  • Sets up controller-wide configuration (authority, parameters)

4 create_index

  • Creates a new index

  • Defines its component tokens and initial composition

5 add_index_components

  • Adds component tokens under an index created at step 4

6 mint

  • Mints index tokens by depositing the proportional component tokens into their vaults

7redeem

  • Burns index tokens and returns proportional amounts of underlying component tokens

8 init_module

  • Registers an external module / program (like the Trade Module) to be used by the protocol or a specific index

rebalance (planned)

  • To be called (by authority or DAO) to adjust vaults based on price drift and unit ratio

  • Relies on the Trade Module to execute token swaps via CPI to DEX routers

3. Modules (Coming Soon)

Open Index Protocol's extensibility is achieved through Solana programs (modules) registered via the core protocol's init_module instruction. This instruction (implemented in the main open_index program) authorizes external modules to perform CPI calls into protocol functions while enforcing PDAs and authority checks.

3.1 Issuance Module

  1. Pre-Issuance Hooks

    • Whitelist Verification: Supports address allowlists ( could also include NFT ownership checks, or DAO vote verification)

    • Fee Pre-Calculation: Computes protocol/manager fees before minting

    • Custom Business Logic: Developers can register additional pre-issuance checks

  2. Post-Redemption Hooks

    • Execute after tokens are redeemed but before assets are released

    Figure 2: Issuance module registration & hooks registration

Figure 3: Mint / Redeem execution flow with hooks interceptions

3.2 Rebalance Architecture - Rebalance & Trade Modules

This section explains how rebalancing is achieved using two stand-alone programs (rebalancer module & Trade Module) that plug into the core Open Index protocol via CPI calls after they have been registered using the init_module instruction (see instruction 8 in figure 1) and authorized to invoke the index.

Figure 4: Rebalancing Architecuture

3.2.1 Rebalance Module

Deployed per-index or shared across indexes (configurable)

  • A separate on-chain program registered via init_module on the core protocol

  • Reads vault balances and oracle prices

  • Computes rebalance plan (which tokens to sell/buy)

  • Does not perform swaps directly

  • Triggers Trade Module via CPI to execute

3.2.2 Trade Module

  • Also registered via init_module

  • Handles DEX routing via a supported DEX e.g Raydium , Orca etc

  • Executes swaps securely

  • Deposits swapped tokens into index vaults

3.2.3 Oracle Integration

Price feed addresses registered in init_oracle_accounts (future instruction)

  • Pyth or Switchboard feeds

  • Prices used to calculate USD value of each component

  • Confidence interval and freshness checks enforced

3.3 Governance Architecture

Open Index Protocol supports multi-tier governance, where both the protocol and controllers can define their own rules and constraints.

3.3.1 Protocol-Level Governance

  Managed by a global DAO, multisig, or protocol council.

Responsibilities:

  • Initialize the protocol

  • Whitelist or restrict modules via init_module

  • Approve upgrades or feature flags

  • Set global rate limits or constraints (optional)

pub struct ProtocolGovernanceConfig {
  pub global_paused: bool,
  pub allowed_modules: Vec<Pubkey>, // Could be accounts for registered modules
  pub protocol_admin: Pubkey,
}

3.3.2 Controller-Level Governance

Managed by the controller owner (a wallet, multisig, or DAO).

Responsibilities:

  • Manage index creation, component updates, rebalancing

  • Set controller-level access policies

  • Pause or resume minting/redeeming

  • Define rebalancing logic and authorities

pub struct ControllerGovernanceConfig {
  pub paused: bool,
  pub rebalance_authority: Pubkey,
  pub mint_authority: Pubkey,
  pub max_components: u32,
  pub rebalance_interval: u64,
}

This config is stored directly in the Controller account. Each instruction (e.g. mint, redeem, rebalance) checks this configuration before proceeding.

4 Design Principles

4.1 Modular:

  • Programs can be added, upgraded, or replaced via init_module

4.2 Composable:

  • Supports DAO plug-ins and custom strategies

4.3 Secure:

  • Vaults and critical instructions protected by PDA validation and authority checks

4.4 Public Good:

  • All logic open-source and designed for DAO use

5. Code Repository

Last updated