Skip to content

Mulle Tranche Protocol

Reference for the Mulle Senior and Junior tranche vaults and the multichain settlement system.

Overview

Mulle Tranche splits one yield-source pool into two tranches with different risk. Senior takes a fixed annual return first. Junior takes the rest of the return and absorbs losses first.

A product can be sold on several chains. The hub chain keeps the ledger and runs settlement, and user assets stay on the spoke chains. On every chain, users enter through an ERC-7540 asynchronous vault, and the tranche and its price are the same on every chain.

Tranches and the Waterfall

SeniorJunior
ReturnFixed annual APR, paid firstEverything left after Senior is paid
LossOnly after Junior is fully wiped outAbsorbs losses first

Waterfall

At every settlement the product NAV is divided across the tranches. Senior NAV is min(Senior target, product NAV), where the target is principal plus accrued APR. Junior NAV is the remainder.

The Senior target accrues at each settlement as target += target × APR × elapsed ÷ 1 year, so it compounds at the settlement interval. A deposit raises the target by the principal added. A redemption lowers it by the fraction of shares burned.

Example

A product raises 1,000 as Senior 800 and Junior 200, with a Senior APR of 5%. After one year the Senior target is 840. Everything up to 840 belongs to Senior and everything above it belongs to Junior.

Product NAVTotal returnSenior NAVSenior returnJunior NAVJunior return
1,100+10%840+5%260+30%
1,040+4%840+5%2000%
1,0000%840+5%160−20%
840−16%840+5%0−100%
800−20%8000%0−100%
700−30%700−12.5%0−100%

Senior is unaffected down to a total return of −16%. Junior needs +4% to break even and takes all of the gain above that. Junior is 200 of the 1,000, which gives it 5x leverage.

Share Price

The share price of a tranche is tranche NAV ÷ shares outstanding. A deposit receives deposit ÷ price shares, and a redemption pays shares × price. Deposits that have not been issued shares are excluded from NAV, so new deposits do not change the price for existing holders.

Risk Model

Tranching divides the profit and loss of one pool into two claims ordered by priority. Senior returns are capped at the fixed APR and take no loss until the attachment point is crossed. Junior is leveraged by the ratio of the total pool to the Junior tranche.

SR attachment −16% JR break-even +4% −40% −30% −20% −10% 0% +10% Asset total return → −100% −50% 0% +50% Senior Junior Pool without tranching

The chart uses a Senior share (α) of 80% and a Senior APR (r) of 5%. The weighted average of the two tranche lines equals the pool line.

  1. Senior protection depends on α. At α = 80% Senior loses below −16%. At α = 90% the same APR puts the attachment point after one year at about −5.5% (0.9 × 1.05 = 0.945).
  2. If the yield source earns less than α × r, the Junior tranche shrinks even with no loss on the assets.
  3. Deposits set α. Senior investors should check the current ratio of tranche NAVs in addition to the APR.

ERC-7540 Vaults

Users enter through a TrancheVault that follows the ERC-7540 asynchronous vault standard. Deposits and redemptions run in three steps.

  1. Request: requestDeposit or requestRedeem. The chain's Manager holds the assets, or holds the shares in escrow, and the request is pending.
  2. Settle: at the daily settlement the hub fixes NAV and prices, and the request becomes claimable.
  3. Claim: deposit or mint returns shares, and redeem or withdraw returns assets. A claim can be made any time after settlement.

The price is fixed at settlement and the claim reads the fixed value on the local chain. This lets requests from several chains settle at one price.

  • The ERC-7540 requestId returned by the vault is always 0. Each request also has an internal id (see ID Scheme).
  • A claim must be for the full claimable amount. Any other amount reverts with ClaimMismatch.
  • preview* functions revert, as the standard requires for asynchronous vaults. setOperator is supported.

The share token is an ERC-20 separate from the vault (ERC-7575) and implements ERC-1404. On the current mainnet product, shares are allowlist-restricted and can only be minted to or transferred between listed wallets. Products that use an InvestorGate (testnet today, mainnet after its next upgrade) check eligibility at request time, and their shares are freely transferable. The vault has no mint authority. Only the Manager mints and burns shares.

Glossary

TermMeaning
shareTranche ownership token. Senior and Junior shares are separate ERC-20 tokens.
deposit holdDeposited assets held by the spoke Manager from request until the round close that places them into yield sources.
escrowWhere shares are held between a redeem request and its claim. The Manager holds them and burns them at claim.
payout fundsAssets a spoke has collected for redemptions. Approved payouts are reserved from them for claims.
waterfallThe rule that divides product NAV: Senior first, the remainder to Junior.
yield-source adapterA contract that wraps one yield source, such as an ERC-4626 vault or a looped lending position. It deploys, withdraws and values funds.
settlementThe round that fixes NAV and prices and approves pending requests.
requestIdIdentifier of one deposit or redeem request (bytes32), issued by the spoke Manager.
settlementIdRound number. It increases by 1 every time prices are fixed, including price-only rounds.
NAVNet asset value, at four levels: adapter NAV, chain NAV (one chain's sum), product NAV (after adjustment) and tranche NAV (after the waterfall).
hub and spokeThe hub keeps the ledger, fixes prices and decides allocation, and holds no user assets. Spokes hold vaults, user assets and yield sources.
hub ledgerThe record of products, requests, approvals and settlements kept on the hub chain. It is not a separate contract: the Valuation contract writes these records into the hub chain's built-in storage. Integrators read state from the spoke contracts.
CCCPThe cross-chain messaging protocol between the hub and the spokes. Relayers deliver its messages. A product can also use it to move assets between spokes through the hub.
curatorThe account that runs a product's allocation, fee and risk settings, behind a timelock.
keeperAn off-chain service that starts settlement rounds and moves them forward.

Hub and Spokes

A product can run on one or more EVM chains. The tranches are defined per product, so a deposit on any chain buys the same Senior or Junior tranche at the same price.

The hub only keeps records and does the accounting. It aggregates NAV, runs the waterfall, fixes prices, approves requests and decides allocation, and it holds no user assets. Spokes hold the vaults, share tokens, held deposits, redemption funds and yield-source adapters.

The hub and the spokes exchange messages over CCCP. Messages carry instructions and amounts. Assets move between spokes directly over the bridge set for the product: none (each chain keeps its own deposits), Circle CCTP V2, or CCCP (relayed through the hub in the same transaction). The mainnet product has a single spoke, Ethereum, so its assets stay on Ethereum.

Components

Spoke chain
Entry
Vault SR / JR
Core
Manager
Execution
MultichainAdapter
Hub chain
Endpoint
Orchestrator
Engine
Valuation
Curator
ProductManager
ComponentLocationRole
TrancheVault, ShareTokenPer spoke, product and trancheUser entry point. One vault and one share token per tranche.
ManagerOne per spoke chain, shared by all productsKeeps per-product storage. Issues requestIds, holds deposits until settlement, escrows redeem shares, keeps payout funds, mints and burns shares, sends and receives messages and answers settlement rounds (respond).
MultichainAdapterOne per chain and productSplits the chain's funds across the yield-source adapters by weight and values them. New deposits fill underweight adapters first.
Yield-source adaptersOne per yield sourceEach wraps one yield source. The mainnet product uses an ERC-4626 vault adapter (the reserve) and a Nest nOPAL loop on Morpho Blue.
InvestorGateOne per spoke chainEligibility check called by the vault on every request (gate-based products).
VaultWhitelistHookOne per spoke chainPer-vault allowlist behind the ERC-1404 share restriction (allowlist products).
OrchestratorOne on the hubThe hub's message endpoint. Routes inbound messages to the product and relays CCCP bridge transfers.
ValuationOne on the hub, shared by all productsSettlement engine. Aggregates chain NAVs, runs the waterfall, fixes prices, takes fees, approves requests and plans fund moves.
ProductManagerOne per product on the hubThe curator's account for the product.
KeeperOff-chainStarts settlement rounds, calls respond on the spokes and re-sends missed messages.
RelayersOff-chainDeliver CCCP messages to the receiving chain.

ID Scheme

productId (uint64)

The top 32 bits are the product class prefix and the low 32 bits are the sequence within that class. Product IDs are written in hex.

PrefixClassExample
0x00000004Multichain0x0000000400000001 (Ethereum mainnet)

requestId (bytes32)

Layout

requestId = productId (64 bits) | chainId (64 bits) | seq (128 bits)

The Manager issues the requestId. The top 64 bits are the full productId, the next 64 bits are the EVM chainId of the requesting chain, and the low 128 bits are the Manager's local sequence. The productId and chainId prefix makes every requestId globally unique.

settlementId (uint256)

The settlement round number. It increases by 1 every time prices are fixed, on daily settlements and price-only rounds, and it is the join key for settlement events. A request that arrives while a round is collecting moves to the next round.

Tranche Key

The hub ledger identifies a tranche by the pair (chainId, vault address). For one tranche type the share price is the same on every chain, and only the supply differs per vault.

Deposit Flow

A deposit stays on the chain where it was made. The Manager holds the assets until the hub approves the request, and the close of that round places them into the yield sources.

User
requestDeposit
Spoke
Vault
Spoke
Manager
held
Hub
Valuation
queued
Hub
Settlement
approved
User
Claim
shares minted
Hub
Round close
Spoke
Adapters
placed by weight
  1. Request: requestDeposit checks eligibility, the product minimum (BelowMinRequest) and the deposit gate. The gate rejects the request if the product is not seeded on the chain (NotSeeded), if deposits are halted after a Junior loss (DepositsHalted), or, for Senior, if the chain's Senior capacity is used up (SeniorCapReached).
  2. Hold: the vault moves the USDC to the Manager, which holds it, issues a requestId and sends DEPOSIT_REQUEST (kind 1) to the hub. The message carries no assets.
  3. Record: the hub records the request and queues it for the next settlement.
  4. Approve: at settlement every pending deposit is approved at the new price. The request becomes claimable when SETTLEMENT_FINALIZE (kind 5) arrives on the spoke.
  5. Place: at the round close, one ROUTE (kind 13) per chain moves the held deposits into the yield sources by weight. Underweight adapters are filled first. This step does not affect the claim.
  6. Claim: shares are minted when the user calls deposit or mint.

The Manager's depositGate(productId) returns whether the product is seeded, whether deposits are halted and the Senior capacity left on the chain.

Redeem Flow

A redeem request withdraws nothing from the yield sources. The hub orders the withdrawals at a round close, and a later settlement approves the redemption once the chain has the funds to pay it.

User
requestRedeem
Spoke
Escrow
Hub
Queue
Hub
Round close
Spoke
Payout funds
Hub
Next settlement
approved
User
Claim
shares burned
  1. Request: requestRedeem moves the shares into escrow at the Manager and sends REDEEM_REQUEST (kind 2) to the hub. The value of the shares at the last price must be at least the product minimum.
  2. Fund: at a round close the hub orders withdrawals for pending redemptions. Sources are used in this order: held deposits on the same chain, held deposits on other chains, adapters on the same chain, adapters on other chains. Within a chain, retired adapters are drained first, then the reserve, then the other adapters by weight.
  3. Approve: a chain approves a redemption only if its payout funds already cover it, first in, first out per chain. Other redemptions carry over to the next round. The payout is the number of shares times the price of the approving round.
  4. Claim: the user calls redeem or withdraw. The escrowed shares are burned and the payout is sent.

A redemption usually becomes claimable at the second daily settlement after the request. Withdrawals from the looped position can take longer. Claims are paid from the product's reserved payout pool, so the order of claims does not matter.

Settlement Cycle

A keeper starts each round on the hub. Neither round type has an on-chain interval.

RoundDescription
trySettle(productId)Fixes prices, approves pending requests, sends FINALIZE and moves funds. Mainnet runs it once a day at 17:00 KST (08:00 UTC).
tryUpdateNAV(productId)Fixes prices only and closes after the price fix. Pending requests keep waiting. It can start only after a minimum gap since the last round closed.
Hub
Start round
Spoke
respond()
Hub
Price fix
Hub
Approvals
Spoke
Claimable
Spoke
Funds moved
  1. Collect: the hub sends SETTLEMENT_COLLECT (kind 3) to each spoke, which records the round.
  2. Respond: anyone can call respond(productId, settlementId) on the spoke, and the keeper does so. It refreshes the adapters (the loop position can delever), moves ready asynchronous withdrawals into the payout funds, values each adapter and sends SETTLEMENT_RESPONSE (kind 4) in chunks. It waits until every earlier ROUTE and FINALIZE for the chain has been applied. respondGate shows what it is waiting for.
  3. Fix prices: after every chain has responded, the hub excludes deposits without issued shares, accrues the Senior target, runs the waterfall, takes fees and halts deposits if Junior has lost more than the product's limit. If product NAV has moved more than the product allows since the last round, price fixing pauses until the curator accepts the reported NAV or the round is aborted.
  4. Finalize: on a settle round the hub sends SETTLEMENT_FINALIZE (kind 5) in chunks with the approved requests and their amounts. Anyone can send the remaining chunks with continueFinalize(productId, maxChunks) on the hub. The spoke marks the requests claimable and reserves the approved payouts from its payout funds.
  5. Close: the hub sends one ROUTE (kind 13) per chain with the chain's fund moves, which place held deposits and fund redemptions.

The keeper re-sends messages that fail to arrive. Spokes apply each ROUTE and each FINALIZE chunk once, so a late duplicate has no effect.

Messages

Each message between the hub and a spoke has a kind number. Messages carry instructions and amounts. BRIDGE is the only kind that moves assets, and only products that use CCCP as their bridge send it.

KindNameDirectionPurpose
1DEPOSIT_REQUESTSpoke to hubReport a deposit request
2REDEEM_REQUESTSpoke to hubReport a redeem request
3SETTLEMENT_COLLECTHub to spokeStart a settlement round
4SETTLEMENT_RESPONSESpoke to hubChain NAV and per-adapter values (chunked)
5SETTLEMENT_FINALIZEHub to spokeApprovals and prices (chunked)
9WHITELIST_SYNCHub to spokeInvestor eligibility (allowlist products)
10ALLOCATION_SYNCHub to spokeAdapter weights
11PRODUCT_CONFIGHub to spokeProduct setup
13ROUTEHub to spokeFund moves at round close
15PRODUCT_DEPLOYEDSpoke to hubProduct contracts deployed
16BRIDGESpoke to hub to spokeAsset transfer between spokes (CCCP bridge)

Kinds 6, 7, 8, 12 and 14 are not used. On a spoke, CccpSent and CccpReceived record every outbound and inbound message with its raw bytes.

Eligibility and Allocation

Allowlist (Mainnet)

Mulle adds approved wallets to an allowlist. The curator registers a wallet on the hub, and WHITELIST_SYNC (kind 9) delivers it to the spoke's VaultWhitelistHook, which keeps one list per vault.

  • Shares are ERC-1404 restricted and can only be minted to or transferred between listed wallets.
  • A removed wallet cannot redeem, because the share transfer into escrow is refused.
  • Each update carries a nonce. A spoke ignores an update older than the latest one for the same vault and wallet (WhitelistStale), so the final state is correct even if messages arrive out of order.

InvestorGate (Testnet, and Mainnet After the Next Upgrade)

Each chain has one InvestorGate. The vault calls it on every request, and the request passes if one of the following holds:

  1. Partner attestation: an EIP-712 signature from a registered partner key, passed through the 4-argument requestDeposit or requestRedeem. The deposit counts toward that partner's volume.
  2. Operator allowlist: the wallet is listed for the vault. The 3-argument functions pass without a signature.
  3. Dojang KYC: on GIWA, the wallet is verified by the vault's Dojang attester. The 3-argument functions pass without a signature.

A deposit is checked against the controller and a redemption against the share owner. Claims are not checked, and shares are freely transferable. gate.isAllowed(vault, wallet) returns whether a wallet can use the 3-argument functions.

EIP-712 attestation

domain = { name: "Mulle InvestorGate", version: "1", chainId, verifyingContract: <gate address> }
Investor(address vault, address investor, uint64 expiry, bytes32 nonce)
data   = abi.encode((vault, investor, expiry, nonce), bytes signature)

expiry is the deadline of the signature. A nonce can be used once per gate and should be 32 random bytes. The signature names the vault and is not valid for another vault.

Allocation

A change to an allocation does not move funds when it is made. Funds move toward the new weights at later round closes. The timelock is 2 days on mainnet.

ChangeBehavior
Adapters within a chainThe curator sets the chain's adapter list and weights, which must sum to 10,000. Adding or removing an adapter or raising a weight is timelocked. The spoke receives the change as ALLOCATION_SYNC (kind 10). A removed adapter is retired: it is still valued and is drained first for redemptions.
Chain weightsRaising a chain's weight is timelocked. No message is sent to the spokes. Later round-close ROUTEs place new deposits toward underweight chains.
Keeper actionsWithin a chain, the keeper can move funds from the reserve to the loop position to defend it against liquidation, and can delever the loop.

Fees

Fees are set per product and per tranche. A product can charge a management fee on tranche NAV for the time elapsed, a performance fee on gains above the tranche's high-water mark, and a withdrawal fee on the vault of at most 10%.

Management and performance fees are taken at settlement by minting new shares of the tranche to the product's fee recipient. Only holders of that tranche are diluted. A fee increase waits for the product's timelock (2 days on mainnet).

The current mainnet product charges a 10% Junior performance fee and no other fee. Rates, the partner revenue share and partner claims are described on the Fees page.

Usage

  1. Choose the product and the chain to enter from.
  2. Confirm the wallet is eligible. On the current mainnet product it must be on the allowlist. On gate-based products it needs a partner attestation, the operator allowlist or Dojang KYC.
  3. Approve USDC to the vault and call requestDeposit for at least the product minimum.
  4. After the next settlement, claim the full amount with deposit(claimableDepositRequest(0, you), you).
  5. To redeem, approve the shares to the vault and call requestRedeem. When the request is claimable, call redeem(claimableRedeemRequest(0, you), you, you) or withdraw(maxWithdraw(you), you, you).

Warning

Requests cannot be cancelled. Every accepted request is handled at a later settlement.

The products are available in the Mulle app.

Functions

TrancheVault implements ERC-7540 and ERC-7575. The Manager functions below are public views on each spoke.

requestDeposit

Requests a deposit. Moves assets of USDC from owner to the Manager and returns 0.

Parameters

FieldTypeDescription
assetsuint256Amount of USDC to deposit
controlleraddressAccount that owns the request and can claim it
owneraddressAccount the USDC is taken from

Returns

FieldTypeDescription
requestIduint256Always 0

requestDeposit (with attestation)

Same as requestDeposit, with a partner attestation. Used on gate-based products.

Parameters

FieldTypeDescription
assetsuint256Amount of USDC to deposit
controlleraddressAccount that owns the request and can claim it
owneraddressAccount the USDC is taken from
databytesEncoded attestation and signature (see Eligibility and Allocation)

Returns

FieldTypeDescription
requestIduint256Always 0

deposit

Claims settled deposits and mints the shares. assets must equal the full claimable amount. A 2-argument form uses the caller as controller.

Parameters

FieldTypeDescription
assetsuint256Claimable deposit amount (claimableDepositRequest)
receiveraddressAccount that receives the shares
controlleraddressAccount that owns the request

Returns

FieldTypeDescription
sharesuint256Shares minted

mint

Claims settled deposits by share amount. shares must equal the full claimable share amount. A 2-argument form uses the caller as controller.

Parameters

FieldTypeDescription
sharesuint256Claimable shares (maxMint)
receiveraddressAccount that receives the shares
controlleraddressAccount that owns the request

Returns

FieldTypeDescription
assetsuint256Deposit amount claimed

requestRedeem

Requests a redemption. Moves shares from owner into escrow and returns 0. The vault must be approved to transfer the shares.

Parameters

FieldTypeDescription
sharesuint256Number of shares to redeem
controlleraddressAccount that owns the request and can claim it
owneraddressAccount the shares are taken from

Returns

FieldTypeDescription
requestIduint256Always 0

requestRedeem (with attestation)

Same as requestRedeem, with a partner attestation. Used on gate-based products.

Parameters

FieldTypeDescription
sharesuint256Number of shares to redeem
controlleraddressAccount that owns the request and can claim it
owneraddressAccount the shares are taken from
databytesEncoded attestation and signature

Returns

FieldTypeDescription
requestIduint256Always 0

redeem

Claims settled redemptions by share amount. The escrowed shares are burned and the payout is sent, less the withdrawal fee if one is set. shares must equal the full claimable share amount.

Parameters

FieldTypeDescription
sharesuint256Claimable shares (claimableRedeemRequest)
receiveraddressAccount that receives the USDC
controlleraddressAccount that owns the request

Returns

FieldTypeDescription
assetsuint256USDC received by receiver

withdraw

Claims settled redemptions by asset amount. assets must equal the full claimable amount before the withdrawal fee.

Parameters

FieldTypeDescription
assetsuint256Claimable amount (maxWithdraw)
receiveraddressAccount that receives the USDC
controlleraddressAccount that owns the request

Returns

FieldTypeDescription
sharesuint256Shares burned

setOperator

Allows or revokes an operator that can request and claim on behalf of the caller.

Parameters

FieldTypeDescription
operatoraddressAccount to allow or revoke
approvedbooltrue to allow, false to revoke

Returns

FieldTypeDescription
successboolAlways true

lastSharePrice

Manager view. Returns the last fixed share price of a tranche. This is the public price source.

Parameters

FieldTypeDescription
productIduint64Product ID
trancheuint80 for Senior, 1 for Junior

Returns

FieldTypeDescription
priceuint256Share price with 18 decimals

depositGate

Manager view. Returns whether deposits are open on the chain.

Parameters

FieldTypeDescription
productIduint64Product ID

Returns

FieldTypeDescription
seededboolThe product is seeded on the chain
gateSetboolThe hub has set a Senior capacity for the chain
haltedboolDeposits are halted after a Junior loss
seniorCapuint256Senior deposit capacity left on the chain

partnerVolumes

Manager view. Returns each partner's volume on the chain: the sum of partnerDeposit across the product's Senior and Junior vaults.

Parameters

FieldTypeDescription
productIduint64Product ID

Returns

FieldTypeDescription
partnersbytes32[]Partner addresses, left-padded to 32 bytes
volumeuint256[]Volume per partner, in the product's asset

Other Functions

FunctionDescription
pendingDepositRequest(0, controller), claimableDepositRequest(0, controller), pendingRedeemRequest(0, controller), claimableRedeemRequest(0, controller)Vault. Request state for a controller.
maxDeposit, maxMint, maxWithdraw, maxRedeem(controller)Vault. Claimable amounts for a controller.
convertToShares, convertToAssetsVault. Estimates from the tranche's assets and share supply. The settlement price is fixed at settlement.
share(), asset(), tranche(), manager()Vault. Connected contracts and the tranche index.
vaultOf(productId, tranche)Manager. Vault of a tranche on the chain.
userRequests(vault, controller, kind)Manager. Open requestIds for a controller (kind 1 for deposits, 0 for redemptions).
reqOf(requestId)Manager. Status, kind, tranche, controller, amount in and amount out of one request.
respondGate(productId, settlementId)Manager. Whether respond can run for a round and what it is waiting for.
respond(productId, settlementId)Manager. Callable by anyone. Values the chain and sends SETTLEMENT_RESPONSE for the current round. A repeat call for the same attempt has no effect.
continueFinalize(productId, maxChunks)Hub Valuation. Callable by anyone. Sends up to maxChunks pending FINALIZE chunks and closes the round after the last one.

Events

These events are emitted on the spoke chains. Request events join on requestId and settlement events join on settlementId.

EventParametersDescription
DepositRequestedrequestId, chainId, vault, controller, assetsManager. Deposit request accepted.
RedeemRequestedrequestId, chainId, vault, controller, sharesManager. Redeem request accepted.
SettleAppliedproductId, settlementId, depositCount, redeemCount, chunkIndex, chunkCount, requestIdsManager. A FINALIZE chunk was applied. Lists the requestIds that became claimable.
RequestClaimedrequestId, productId, controller, inAmt, outAmtManager. One request was claimed. This is the per-request join key. For a deposit, assets in and shares out. For a redemption, shares in and assets out.
DepositReceivedproductId, chainId, vault, controller, receiver, sharesManager. Total shares of one deposit claim.
RedeemReceivedproductId, chainId, vault, controller, receiver, assetsManager. Total assets of one redeem claim.
NavReportedproductId, settlementId, chainNav, respChunkCountManager. Chain NAV sent for a round.
DepositGateSetproductId, settlementId, halted, seniorCapManager. Deposit halt and Senior capacity updated by the hub.
WhitelistAppliedchainId, vault, who, grant, nonceManager. Allowlist update applied (allowlist products).
WhitelistStalechainId, vault, who, nonce, latestManager. Allowlist update ignored because a newer one was applied.
AllocationSyncedweightsVersionMultichainAdapter. New adapter weights applied.
FeeSharesMintedproductId, tranche, recipient, sharesManager. Fee shares minted at settlement.
FeeSharesPushedproductId, tranche, recipient, sharesManager. Fee shares sent to a contract recipient.
FeeSharesClaimedproductId, tranche, recipient, to, sharesManager. Fee shares claimed.
CccpSentdstChainId, to, amount, messageManager. Outbound message with its raw bytes.
CccpReceivedsrcChainId, sender, declared, received, messageManager. Inbound message with its raw bytes.
CctpSentproductId, dstChainId, purpose, ref, amountManager. Asset transfer sent over Circle CCTP.
CctpReceivedproductId, srcChainId, purpose, ref, amount, receivedManager. Asset transfer received over Circle CCTP.
DepositRequestcontroller, owner, requestId, sender, assetsVault. ERC-7540 deposit request (requestId 0).
RedeemRequestcontroller, owner, requestId, sender, sharesVault. ERC-7540 redeem request (requestId 0).
Depositcontroller, receiver, assets, sharesVault. Deposit claimed.
Withdrawsender, receiver, controller, assets, sharesVault. Redemption claimed.
OperatorSetcontroller, operator, approvedVault. Operator approval changed.
PartnerAssignedwallet, partnerVault. Wallet attributed to a partner by an attested deposit.
WithdrawFeecontroller, to, assetsVault. Withdrawal fee taken at a redeem claim.

Deployments

Mainnet Product

ParameterValue
productId0x0000000400000001
ChainEthereum
AssetUSDC
SeniorFixed 8% a year
JuniorResidual
Allocation10% reserve in Wintermute USDC Select, 90% in Nest nOPAL looped on Morpho
SettlementDaily at 17:00 KST (08:00 UTC)
Minimum request10 USDC
Fees10% Junior performance fee (see Fees)

Contract Addresses: Ethereum Mainnet

Testnet Products

productIdChains
0x0000000400000002Ethereum Sepolia, Base Sepolia
0x0000000400000003GIWA Sepolia, Ethereum Sepolia