import BN from 'bn.js';
import { AccountMeta, Address, Instruction, TransactionSigner, UnixTimestamp } from '@solana/kit';
import { DepositAccounts, WithdrawAccounts, WithdrawFromAvailableAccounts } from '../@codegen/kvault/instructions';
import Decimal from 'decimal.js/decimal';
/** the populateLUTIxs should be executed in a separate transaction as we cannot create and populate a lookup table in the same tx */
export type InitVaultIxs = {
    createAtaIfNeededIxs: Instruction[];
    initVaultIxs: Instruction[];
    createLUTIx: Instruction;
    populateLUTIxs: Instruction[];
    cleanupIxs: Instruction[];
    initSharesMetadataIx: Instruction;
    createVaultFarms: CreateVaultFarms;
    setFarmToVaultIxs: SetFarmsToVaultIxs;
};
export type CreateVaultFarms = {
    createVaultFarmIxs: CreateVaultFarm;
    createFLCVaultFarmIxs?: CreateVaultFarm;
};
export type SetFarmsToVaultIxs = {
    setFarmToVaultIx: Instruction;
    setFLCFarmToVaultIx?: Instruction;
};
export type AcceptVaultOwnershipIxs = {
    acceptVaultOwnershipIx: Instruction;
    acceptFLCFarmOwnershipIx?: Instruction;
    initNewLUTIx: Instruction;
    updateLUTIxs: Instruction[];
};
export type UpdateReserveAllocationIxs = {
    updateReserveAllocationIx: Instruction;
    updateLUTIxs: Instruction[];
};
export type WithdrawAndBlockReserveIxs = {
    updateReserveAllocationIxs: Instruction[];
    investIxs: Instruction[];
};
export type DisinvestAllReservesIxs = {
    updateReserveAllocationIxs: Instruction[];
    investIxs: Instruction[];
};
export type UpdateVaultConfigIxs = {
    updateVaultConfigIx: Instruction;
    updateLUTIxs: Instruction[];
    extraIxs: Instruction[];
};
export type VaultComputedAllocation = {
    /** Target unallocated amount in token units, not lamports. */
    targetUnallocatedAmount: Decimal;
    /** Target amount per reserve in token units, not lamports. */
    targetReservesAllocation: Map<Address, Decimal>;
};
/** If there are ixs to setup the LUT it means it doesn't already exist and it needs to be created in a separate tx before inserting into it */
export type SyncVaultLUTIxs = {
    setupLUTIfNeededIxs: Instruction[];
    syncLUTIxs: Instruction[];
};
/** If present, execute exactly one of the stake arrays after deposit so the received shares are staked in the selected farm. */
export type DepositIxs = {
    depositIxs: Instruction[];
    stakeInFarmIfNeededIxs: Instruction[];
    stakeInFlcFarmIfNeededIxs: Instruction[];
};
/** The ixs to unstake shares from the selected farm and withdraw them from the vault. `unstakeFromFarmIfNeededIxs` should come before `withdrawIxs`. */
export type WithdrawIxs = {
    unstakeFromFarmIfNeededIxs: Instruction[];
    withdrawIxs: Instruction[];
    postWithdrawIxs: Instruction[];
};
export type ShareExitLiquidityPlan = {
    shareLamportsToWithdraw: Decimal;
    grossTokenLamportsToWithdraw: Decimal;
    /**
     * Penalty computed once on the aggregate gross amount. The program charges
     * max(bps * gross, flat lamports) per withdraw instruction, so for exits split across multiple
     * reserves the actual total penalty is higher (up to N * flat for N instructions).
     */
    withdrawalPenaltyLamports: Decimal;
    /** Estimate based on the aggregate penalty; overstates the received amount for split reserve exits. */
    netTokenLamportsToWithdraw: Decimal;
    availableTokenLamportsToWithdraw: Decimal;
    reserveTokenLamportsToWithdraw: Map<Address, Decimal>;
    remainingNetTokenLamportsToWithdraw: Decimal;
    burnAllUserShares: boolean;
    canBurnAllUserShares: boolean;
};
/** The shares an user has in a vault (staked and unstaked), in tokens */
export type UserSharesForVault = {
    unstakedShares: Decimal;
    stakedShares: Decimal;
    totalShares: Decimal;
};
export type ReserveAllocationOverview = {
    /** Target allocation weight; unitless relative weight. */
    targetWeight: Decimal;
    /** Token allocation cap from vault state, in vault-token lamports. */
    tokenAllocationCapLamports: Decimal;
    /** Optional ctoken allocation cap from vault state, in ctoken lamports. */
    ctokenAllocationCapLamports?: Decimal;
    /** Current reserve allocation from vault state, in ctoken lamports. */
    ctokenAllocationLamports: Decimal;
    /** @deprecated use tokenAllocationCapLamports. */
    tokenAllocationCap: Decimal;
    /** @deprecated use ctokenAllocationCapLamports. */
    ctokenAllocationCap?: Decimal;
    /** @deprecated use ctokenAllocationLamports. */
    ctokenAllocation: Decimal;
};
export type APYs = {
    grossAPY: Decimal;
    netAPY: Decimal;
};
/** `prerequisiteIxs` (payer token ATA creation and wSOL wrapping, if any) must be executed before `topupIxs`; `cleanupIxs` (wSOL ATA close, if any) after */
export type TopupVaultRewardsIxs = {
    prerequisiteIxs: Instruction[];
    topupIxs: Instruction[];
    cleanupIxs: Instruction[];
};
/** `prerequisiteIxs` (admin token ATA creation, if any) must be executed before `withdrawIxs`; `cleanupIxs` (wSOL ATA close, if any) after */
export type WithdrawVaultRewardsIxs = {
    prerequisiteIxs: Instruction[];
    withdrawIxs: Instruction[];
    cleanupIxs: Instruction[];
};
/** The vault rewards state; rewards are paid in the vault token and increase the share value */
export type VaultRewardsOverview = {
    /** raw reward rate, in token lamports per second */
    rewardPerSecondLamports: Decimal;
    /** reward rate, in tokens per second */
    rewardPerSecondTokens: Decimal;
    /** rewards topped up and not distributed yet, in tokens */
    rewardsAvailableTokens: Decimal;
    /** rewards distributed to depositors since the vault inception, in tokens */
    cumulativeRewardsDistributedTokens: Decimal;
    /** last on-chain rewards issuance checkpoint (updated on distribution, rate change, and topup) */
    lastIssuanceTs: UnixTimestamp;
    /** yearly reward rate relative to the vault AUM; 0 when the stream is paused (rate is 0 or rewards are depleted — a paused stream distributes nothing and never catches up retroactively) or the vault has no net AUM; for percentage it needs multiplication by 100 */
    apr: Decimal;
    /** fixed-emission annualized yield; equal to APR because the token-per-second stream does not compound as AUM grows; for percentage it needs multiplication by 100 */
    apy: Decimal;
};
export type CreateVaultFarm = {
    farm: TransactionSigner;
    setupFarmIxs: Instruction[];
    updateFarmIxs: Instruction[];
};
export type RefreshObligationIxs = {
    firstRefreshObligationIx?: Instruction;
    refreshObligationIx?: Instruction;
};
export type VaultReleaseCheckResult = {
    errors: string[];
    warnings: string[];
    success: boolean;
};
export type AllDepositAccounts = {
    depositAccounts: DepositAccounts;
    remainingAccounts: AccountMeta[];
    stakeSharesIxs?: Instruction[];
    stakeInFlcFarmIxs?: Instruction[];
};
export type AllWithdrawAccounts = {
    withdrawAccounts: WithdrawAccounts | WithdrawFromAvailableAccounts;
    remainingAccounts: AccountMeta[];
    unstakeSharesIxs?: Instruction[];
};
export type RedeemInKindReserveIx = {
    ix: Instruction;
    reserve: Address;
    ctokenAmount: BN;
};
export type RedeemInKindIxs = {
    setupIxs: Instruction[];
    redeemInKindIxs: RedeemInKindReserveIx[];
    cleanupIxs: Instruction[];
    luts: Address[];
};
export type WithdrawAndRedeemInKindIxs = {
    withdrawIxs: WithdrawIxs;
    redeemInKindIxs: RedeemInKindIxs;
    /** Shares that could not be exited after routing as much as possible through
     *  withdraw and redeem-in-kind. Zero when the exit is complete. */
    skippedShares: Decimal;
};
export type EnqueueToWithdrawIxs = {
    setupIxs: Instruction[];
    enqueueIxs: Instruction[];
    cleanupIxs: Instruction[];
};
export type WithdrawRedeemAndEnqueueIxs = {
    withdrawIxs: WithdrawIxs;
    redeemInKindIxs: RedeemInKindIxs;
    enqueueIxs: EnqueueToWithdrawIxs;
    /** Shares that could not be exited after routing as much as possible through
     *  withdraw and redeem-in-kind. Zero when the exit is complete. */
    skippedShares: Decimal;
};
//# sourceMappingURL=vault_types.d.ts.map