Deploying a Folio

Learn how to deploy a new Folio instance with custom configuration and governance

Overview

Folios can be deployed in two ways:

1. Raw Folio - with manually assigned roles
2. Governed Folio - with fully automated governance structure including timelocks and voting mechanisms

Prerequisites

• Deployment wallet with sufficient ETH for gas
• Initial basket assets and amounts
• Fee registry and version registry addresses
• Trusted filler registry address (optional)

Deploying a Raw Folio

A raw Folio gives you direct control over role assignments.

1. Prepare Basic Details

   Define your Folio’s core parameters:

   IFolio.FolioBasicDetails memory basicDetails = IFolio.FolioBasicDetails({
       name: "My Custom Folio",
       symbol: "MCF",
       assets: [address(usdc), address(weth), address(dai)],
       amounts: [1000e6, 1e18, 1000e18], // Initial basket amounts
       initialShares: 1000e18 // Shares minted to creator
   });
   

   The amounts array must match the length of the assets array. Each amount represents the initial quantity of each asset required.

2. Configure Additional Details

   Set up fees, mandate, and auction parameters:

   IFolio.FeeRecipient[] memory recipients = new IFolio.FeeRecipient[](1);
   recipients[0] = IFolio.FeeRecipient({
       recipient: feeRecipientAddress,
       portion: 1e18 // 100% in D18 format
   });
   
   IFolio.FolioAdditionalDetails memory additionalDetails = IFolio.FolioAdditionalDetails({
       maxAuctionLength: 3 days,
       feeRecipients: recipients,
       tvlFee: 317097919837645, // ~1% annual (D18/second)
       mintFee: 0.01e18, // 1%
       folioFeeForSelf: 0, // No self-burn
       mandate: "A diversified stablecoin basket"
   });
   

   Fee Limits:

   • TVL Fee: Max 10% annually
   • Mint Fee: Max 5%
   • DAO takes minimum 15bps from all fees
3. Set Folio Flags

   Configure rebalancing behavior:

   IFolio.FolioFlags memory flags = IFolio.FolioFlags({
       trustedFillerEnabled: true,
       rebalanceControl: IFolio.RebalanceControl({
           weightControl: true, // AUCTION_LAUNCHER can adjust weights
           priceControl: IFolio.PriceControl.PARTIAL // Can narrow prices
       }),
       bidsEnabled: true // Allow permissionless bidding
   });
   

   Price Control Options:

   • NONE - Cannot change prices from initial
   • PARTIAL - Can narrow price ranges within initial bounds
   • ATOMIC_SWAP - Can set instant swaps (start price = end price)
4. Approve Token Transfers

   The deployer must approve the FolioDeployer to transfer initial basket assets:

   IERC20(usdc).approve(address(folioDeployer), 1000e6);
   IERC20(weth).approve(address(folioDeployer), 1e18);
   IERC20(dai).approve(address(folioDeployer), 1000e18);
   
5. Deploy the Folio

   Call the deployment function:

   address[] memory basketManagers = new address[](1);
   basketManagers[0] = rebalanceManagerAddress;
   
   address[] memory auctionLaunchers = new address[](1);
   auctionLaunchers[0] = auctionLauncherAddress;
   
   address[] memory brandManagers = new address[](0);
   
   (Folio folio, address proxyAdmin) = folioDeployer.deployFolio(
       basicDetails,
       additionalDetails,
       flags,
       ownerAddress, // Admin
       basketManagers, // REBALANCE_MANAGER role
       auctionLaunchers, // AUCTION_LAUNCHER role
       brandManagers, // BRAND_MANAGER role (optional)
       keccak256(abi.encode("unique_salt")) // Deployment nonce
   );
   

   After deployment:

   • Verify the Folio address
   • Check that roles are assigned correctly
   • Confirm initial shares were minted
   • Ensure basket tokens were transferred

Deploying a Governed Folio

A governed Folio includes complete governance infrastructure with voting tokens and timelocks.

1. Prepare Governance Parameters

   Define governance settings for the owner and trading governors:

   // Owner governance controls admin functions
   IGovernanceDeployer.GovParams memory ownerGovParams = IGovernanceDeployer.GovParams({
       votingDelay: 1 days,
       votingPeriod: 7 days,
       proposalThreshold: 1000e18, // Min tokens to propose
       quorumThreshold: 4, // 4% quorum (in percentage)
       timelockDelay: 2 days,
       guardians: new address[](0) // Can cancel proposals
   });
   
   // Trading governance controls rebalancing
   IGovernanceDeployer.GovParams memory tradingGovParams = IGovernanceDeployer.GovParams({
       votingDelay: 6 hours,
       votingPeriod: 3 days,
       proposalThreshold: 500e18,
       quorumThreshold: 3,
       timelockDelay: 1 days,
       guardians: new address[](0)
   });
   
2. Configure Role Assignments

   Specify existing role holders (or leave empty for governance-only control):

   IFolioDeployer.GovRoles memory govRoles = IFolioDeployer.GovRoles({
       existingBasketManagers: new address[](0), // Empty = deploy trading gov
       auctionLaunchers: [auctionLauncherEOA],
       brandManagers: new address[](0)
   });
   

   Leave existingBasketManagers empty to automatically deploy a separate trading governor. Otherwise, use your own addresses.

3. Choose Governance Model

   Decide between self-governance (Folio shares = voting power) or separate staking token:

   // Option 1: Self-governed (stToken = address(0))
   IVotes stToken = IVotes(address(0));
   
   // Option 2: Separate staking token
   // IVotes stToken = IVotes(existingVotingTokenAddress);
   
4. Deploy Governed Folio

   Execute the deployment:

   (Folio folio, address proxyAdmin) = folioDeployer.deployGovernedFolio(
       stToken, // address(0) for self-governance
       basicDetails,
       additionalDetails,
       flags,
       ownerGovParams,
       tradingGovParams,
       govRoles,
       keccak256(abi.encode("unique_salt_2"))
   );
   

   This will deploy:

   • Folio contract
   • Owner governor + timelock
   • Trading governor + timelock (if applicable)
   • Vote-locked staking vault (if self-governed)
5. Verify Deployment

   Check the emitted events for deployed addresses:

   // Listen for GovernedFolioDeployed event
   event GovernedFolioDeployed(
       address stToken,
       address folio,
       address ownerGovernor,
       address ownerTimelock,
       address tradingGovernor,
       address tradingTimelock
   );
   

   All admin functions must now go through the governance timelock. Immediate changes are no longer possible.

Post-Deployment

After deployment, you can:

• Set up additional role holders
• Configure trade allowlists (if needed)
• Add trusted fillers to the registry
• Begin minting shares
• Initiate your first rebalance

Code Reference

• Deployment logic: contracts/deployer/FolioDeployer.sol:45-203
• Governance setup: contracts/deployer/GovernanceDeployer.sol:40-109
• Initialization: contracts/Folio.sol:207-250

Next Steps

Mint Shares

Learn how users can mint and redeem Folio shares

Start Rebalancing

Configure and execute your first rebalance