Skip to main content
This guide walks you through deploying a strategy for your Conduit. By the end, you will have a fully deployed strategy ecosystem that you own and control, with authorized yield sources ready for an asset manager to operate.
If you are an asset manager deploying your own Strategy, see Create an Allocation Strategy instead.

​
Prerequisites

  • A wallet with funds — the deposit asset (e.g. USDC) for the initial deposit and ETH for gas
  • The FACTORY_SPAWN role on the Multi-Vehicle factory (or access to a public factory)
  • The factory must not be deprecated
1

Deploy External Access Control (EAC)

The EAC is the central permission contract for your entire strategy. As the Conduit owner, you are the initial admin — you control who can do what across all contracts.Set initialDelay to a non-zero value (e.g. 48 hours) for production deployments. This protects admin transfers with a time delay.
ExternalAccessControlFactory.SpawnParams memory params = ExternalAccessControlFactory.SpawnParams({
    initialDelay: 48 hours,              // Time-delayed admin transfer for security
    initialDefaultAdmin: platformAdmin,   // Your platform's admin address (use multisig)
    initialRoles: new ExternalAccessControlFactory.RoleAttribution[](0),
    deploymentSalt: keccak256("platform-eac-v1")
});

ExternalAccessControl eac = eacFactory.spawn(params);
Use a multisig wallet (e.g. Safe) as the initialDefaultAdmin. This is the most privileged role in the system — it can grant and revoke any role.
2

Deploy Fee Manager

Configure the fee structure for your strategy. You control fee rates, max caps, and recipient splits through the Fee Manager.
FeeManagerFactory.SpawnParams memory params = FeeManagerFactory.SpawnParams({
    accessControl: externalAccessControl,
    initialFees: FeeManager.Fees({
        performanceFeeBps: 1000,  // 10% performance fee
        managementFeeBps: 200,    // 2% annual management fee
        depositFeeBps: 0,
        redeemFeeBps: 0
    }),
    initialMaxFees: FeeManager.Fees({
        performanceFeeBps: 2000,  // 20% max
        managementFeeBps: 500,    // 5% max
        depositFeeBps: 100,       // 1% max
        redeemFeeBps: 100         // 1% max
    }),
    initialRecipients: recipients,  // See "Configure fees" for recipient setup
    deploymentSalt: keccak256("platform-fee-manager-v1")
});

FeeManager feeManager = feeManagerFactory.spawn(params);
initialMaxFees are immutable — they can never be increased. Set them high enough to allow future adjustments, but low enough to provide guarantees to users.
See Fee Manager reference for detailed guidance on fee calculation formulas and recipient setup.
3

Approve the initial deposit

Every strategy deployment requires an initial deposit as a security measure to prevent inflation attacks. The shares minted from this deposit are sent to the burn address.
uint256 initialDepositAmount = 1e6; // 1 USDC (6 decimals)
IERC20(usdc).approve(address(multiVehicleFactory), initialDepositAmount);
4

Deploy the Strategy

Deploy the full strategy ecosystem in a single transaction. The factory creates five interconnected contracts — all correctly linked and initialized.
MultiVehicleFactory.SpawnParams memory params = MultiVehicleFactory.SpawnParams({
    asset: IERC20(usdc),
    name: "Platform Yield Strategy",
    symbol: "pYLD",
    initialInterceptions: new Interceptor.Interception[](0),
    accessControl: externalAccessControl,
    feeManager: feeManager,
    modulesManager: modulesManager,
    salts: MultiVehicleFactory.Salts({
        multiVehicle: keccak256("mv"),
        queryRedeemQueue: keccak256("qrq"),
        queueStrategyEngine: keccak256("qse"),
        sectorAccountingEngine: keccak256("sae"),
        subQueryEngine: keccak256("sqe"),
        vehicleRegistry: keccak256("vr"),
        initialDepositQuery: keccak256("idq")
    }),
    initialDepositSize: 1e6,
    initialExpectedSupply: 1e18
});

MultiVehicleFactory.Contracts memory contracts = factory.spawn(params);
5

Authorize yield sources

Decide which yield sources your strategy can use. Only authorized yield sources can receive assets from the strategy. This is one of the key guardrails you control as the Conduit owner.Requires: MULTI_VEHICLE_SET_VEHICLE_AUTHORIZATION role scoped to the Sector Accounting Engine.
ISectorAccountingEngine accounting = contracts.multiVehicle.accountingEngine();

// Grant yourself the authorization role
eac.grantScopedRole(
    keccak256("MULTI_VEHICLE_SET_VEHICLE_AUTHORIZATION"),
    address(accounting),
    platformAdmin
);

// Authorize yield sources for your strategy
accounting.syncVehicleActivationStatus(aaveVehicle, true);
accounting.syncVehicleActivationStatus(compoundVehicle, true);
The Vehicle Registry validates that yield sources use the same base asset as the strategy and implement the STEAM standard as SingleAsset vehicles.
6

Verify the deployment

Confirm your strategy is correctly deployed and configured.
address multiVehicle = address(contracts.multiVehicle);

// Verify the asset
address asset = MultiVehicle(multiVehicle).asset();

// Verify the total supply (should reflect initial deposit)
uint256 totalSupply = MultiVehicle(multiVehicle).totalSupply();

// Verify the accounting engine link
ISectorAccountingEngine accounting = MultiVehicle(multiVehicle).accountingEngine();
You can also verify via the Railnet subgraph:
query VerifyDeployment($address: String!) {
  Vehicle(where: { address: { _ilike: $address } }) {
    address
    id
    name
    vehicleType
    symbol
    supply
  }
}

​
What you deployed

ContractPurpose
External Access ControlCentral permission system — you are the admin
Fee ManagerFee collection and distribution — you set the structure
Multi-VehicleMain Strategy contract — users deposit and receive ERC-20 shares
Sector Accounting EngineTracks all asset allocations across yield sources
Queue Strategy EngineDeposit and redeem priority manager
Sub Query EngineYield source query executor
Query Redeem QueueAsynchronous redemption handler

​
The platform journey

1

Deploy your strategy

You just completed this step — your strategy is deployed with access control and fee infrastructure.
2

Configure fees and revenue distribution

Set up fee rates, max caps, and recipient splits for your strategy. You can also add Conduit-level distribution fees when you deploy your Conduit.Configure Conduit fees · Fee Manager reference
3

Delegate to an asset manager

Define the mandate terms, grant operational roles, and set guardrails — while retaining control over yield source authorization, fees, and admin access.Mandate a strategy
4

Distribute via your Conduit

Once your strategy is running, deploy a Conduit to let your users access it through your platform’s interface.Quick start

​
Next steps

Configure fees

Set up fee structures and revenue distribution for your Conduit.

Mandate a strategy

Define guardrails and delegate operations to an asset manager.