portfolio

Refund a `DepositPlan` where no leg has executed yet. Closes the plan PDA and returns `deposit_amount` from `Market.base_asset_vault` to the depositor. Depositor-only — agent cannot force a refund.

Refund a `WithdrawPlan` where no leg has executed yet. Closes the plan PDA only — no token movement (prepare_withdraw doesn't lock funds; shares stay intact on `Portfolio.shares`). Owner-only.

Push a `DepositPlan`'s deadline forward. Depositor or `Market.agent` may call. Bounded extension; re-call for more. See `ix::portfolio::extend_deposit_deadline` for the rationale.

Push a `WithdrawPlan`'s deadline forward. Owner or `Market.agent` may call. Same bound as `extend_deposit_deadline`.

Admin-only. Marks a Pending `deposit_leg` as `Skipped` so the plan can settle when the leg's route is permanently broken. See `ix::portfolio::force_skip_leg` for the trade-off (skipped leg's base slice contributes to NAV; depositor still gets full shares).

Admin-only. Force-skip a permanently-broken `withdraw_leg` so the user can settle. See `ix::portfolio::force_skip_leg` for the trade-off (user is short the leg's expected proceeds).

Agent-only one-shot ix for legacy-pool backfill. Initialises a Portfolio + credits the user with `initial_total_value` shares (1:1 with the assumed total NAV in base atomic units). Tokens must already be in the Market's vaults before this runs. Gated by `Market.total_shares == 0`.

no fields

no fields

no fields

no fields

no fields

no fields

no fields

no fields

• NoChange
• Clear
• Set

• mintpubkey
• new_target_weight_bpsu16

• mintpubkey
• amount_inu64

• marketpubkey
• depositorpubkey
• nonceu64
• deadlinei64
• deposit_amountu64Base-asset amount pulled into the market's base vault at prepare-time. Each leg consumes a fraction proportional to its asset's target weight.
• shares_to_mintu64Shares the depositor will receive at settle. Computed at prepare-time against the NAV cache; locked into the plan PDA so price drift between prepare and settle doesn't change the depositor's allocation.
• leg_statusVec<LegStatus>Per-leg execution state. Parallel to the market's registry walk at prepare-time. Length captured then so settle can verify the market hasn't grown/shrunk mid-deposit.
• bumpu8

• authoritypubkey
• fee_vaultpubkeyOwner of the platform-fee ATAs. The post-swap fee split transfer inside `rebalance_leg` deposits Avo's cut into an ATA whose `owner == fee_vault` and `mint == leg.output_mint`.
• platform_fee_bpsu16Avo's platform fee in basis points. Applied to the gross output of every swap leg by setting `platform_fee_bps = global.platform_fee_bps + market.market_fee_bps` on the router CPI; the program then splits the resulting referral-ATA balance into `fee_vault` and `market.agent` ATAs at the proportional ratio.
• registrypubkey
• bumpu8

• Pending
• Done
• Skipped

• agentpubkey
• indexu16
• bumpu8
• base_asset_mintpubkey
• base_asset_vaultpubkey
• target_asset_countu8
• base_target_weight_bpsu16Target allocation weight for the base asset, in basis points. Sum of `base_target_weight_bps` + every `MarketAsset.target_weight_bps` for this market = 10_000. Maintained by `rebalance` zero-sum deltas.
• market_fee_bpsu16Market owner's fee in basis points. The total fee taken out of each swap leg is `global.platform_fee_bps + market.market_fee_bps`. The market owner ATA receives the `market_fee_bps` share. Capped at `10_000 - global.platform_fee_bps` on every write so the total never exceeds the bps universe.
• fee_asset_mintpubkeyMint in which platform + market fees are denominated. Per-leg fee destinations (`agent_fee_ata` + `platform_fee_ata`) must be ATAs in this mint. When a swap's output mint matches `fee_asset_mint`, the fee is withheld directly from the output. When it doesn't, the leg ix is expected to drive a secondary router CPI to convert the fee portion into `fee_asset_mint` — that mechanism lands in a follow-up to D3-P4.5; the field itself is set + persisted now so create_market + update flows can begin populating it.
• market_share_mintOption<pubkey>
• total_sharesu64
• last_total_valueu64Last computed total value in atomic units of base
• last_nav_tsi64Timestamp of last NAV update.
• prev_entrypubkeyDead field — kept only to preserve byte-layout compatibility with existing on-chain Market accounts. The intrusive registry linked list this belonged to was never wired up (`create_market` never populated it), so `close_market` no longer touches it. Always `Pubkey::default()`. Do not read.
• next_entrypubkeyDead field — see `prev_entry`. Always `Pubkey::default()`.
• agent_identity_collectionOption<pubkey>Optional MPL-8004 collection gate (Metaplex MPL Agent Registry, program id `1DREGFgysWYxLnRnKQnwrxnJQeSMk2HmGaC6whw2B2p`). When `Some`, `create_market` (and any future ix that rotates the agent) requires the agent to own a Metaplex Core asset whose update authority points at this collection — see `crate::auth::verify_agent_identity`. Identity is checked once at create-time; subsequent agent-signed ixs only re-check `market.agent == signer` (cheaper, and the NFT-ownership world model can't change without an off-chain transfer the operator is responsible for).
• market_metadata_uristringOff-chain metadata pointer for this market — typically an IPFS / Arweave / HTTPS URL to a JSON document describing the market's branding (name, description, image, asset thesis). Analogous to a Metaplex Core asset's `uri` field; serialised as a borsh `String` (4-byte LE length prefix + UTF-8 bytes), so the account size grows/shrinks with the URI. Use `update_market_metadata_uri` to mutate; it reallocs the account in-place. Cap: `MAX_METADATA_URI_LEN` bytes — a generous limit that still rejects pathological inputs. Distinct from `Agent.agent_uri` (off-chain): the agent URI is the MPL-8004 identity manifest pointer (per-agent); this is the per-market metadata pointer. An agent can operate multiple markets, each with its own metadata.

• marketpubkey
• mintpubkey
• vaultpubkeySPL token account owned by the Market PDA.
• last_known_balanceu64Cached vault balance, updated on every swap leg.
• target_weight_bpsu16Target allocation weight for this asset, in basis points. Sum across all MarketAssets + Market.base_target_weight_bps = 10_000. Adjusted only by `rebalance` (zero-sum delta with the swap counterpart).
• bumpu8

• authorityOption<pubkey>
• platform_fee_bpsOption<u16>New platform fee in basis points. Caller must keep `platform_fee_bps + max(market.market_fee_bps for any market) <= 10_000` off-chain — we can't enforce per-market caps from here without iterating the registry. `update_market_fee` re-validates per market.
• fee_vaultOption<pubkey>

• ownerpubkey
• marketpubkey
• sharesu64
• bumpu8

• marketpubkey
• agentpubkey
• nonceu64
• deadlinei64
• new_base_target_weight_bpsu16New base-asset target weight (bps). Written into the Market by `settle_rebalance`, not by individual legs — keeps the Market's `base_target_weight_bps` consistent until the whole plan lands.
• asset_targetsVec<AssetTarget>Per-asset targets, parallel to `leg_status`.
• leg_statusVec<LegStatus>Per-leg execution state. `rebalance_leg(idx)` advances entry `idx`.
• bumpu8

• head_entrypubkeyDead field — kept only to preserve byte-layout compatibility with the existing on-chain Registry account. The linked-list wiring was never populated; `close_market` no longer touches it. Always `Pubkey::default()` on new inits. Do not read.
• tail_entrypubkeyDead field — see `head_entry`. Always `Pubkey::default()`.
• lenu16Monotonic count of markets ever created. Doubles as the index assigned to the next market — Market PDA seed is `[b"market", &index.to_le_bytes()]`. Never decremented; closing a market leaves a gap in the index space rather than recycling the id (recycling would collide with a fresh PDA at the same seed).
• bumpu8

• Jupiter
• Dflow

• marketpubkey
• ownerpubkey
• nonceu64
• deadlinei64
• shares_to_burnu64Shares to burn at settle. Locked at prepare so concurrent share movements (theoretical — `Portfolio.shares` only changes via deposit/withdraw, which are serialized per-owner) can't drift the withdraw amount mid-flight.
• base_pro_ratau64Snapshot of the user's pro-rata claim on the market's base vault (`shares_to_burn × base_vault_balance / total_shares`). Paid out at settle alongside `accumulated_swap_proceeds`.
• accumulated_swap_proceedsu64Running total of swap net-of-fee proceeds (in base mint units), accumulated as each `withdraw_leg` lands. Fresh at prepare = 0. Paid out to the owner at settle alongside `base_pro_rata`.
• per_assetVec<AssetWithdrawSnapshot>Snapshot of the user's pro-rata claim on each registered MarketAsset (`shares_to_burn × ma.last_known_balance / total_shares`), captured at prepare. Each leg liquidates exactly `amount_in` of its `mint` to base.
• leg_statusVec<LegStatus>Per-leg execution state. Same length as `per_asset`.
• bumpu8