@exponent-labs/exponent-sdk 0.1.8 → 0.9.0

package/build/exponentVaults/vault.d.ts

@@ -0,0 +1,613 @@
+import { AccountMeta, Connection, Keypair, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { ExponentPrices, ExponentVault as ExponentVaultAccountType, ExponentVaultsFetcher, PriceId } from "@exponent-labs/exponent-vaults-fetcher";
+import { ExponentVaultsPDA, SeedId } from "@exponent-labs/exponent-vaults-pda";
+import * as exponentVaults from "../client/vaults";
+import { Environment } from "../environment";
+import { AumCalculator } from "./aumCalculator";
+import { SquadsVaultTxnResolver } from "./squadsVaultTxnResolver";
+type Numeric = bigint | number;
+export declare const SYNTHETIC_USD_MINT: PublicKey;
+export declare const SYNTHETIC_USD_DECIMALS = 6;
+export declare const SYNTHETIC_USD9_MINT: PublicKey;
+export declare const SYNTHETIC_USD9_DECIMALS = 9;
+export declare const getSyntheticMintDecimals: (mint: PublicKey) => number | null;
+export type DataOperator = "Equals" | "NotEquals" | "GreaterThan" | "GreaterThanOrEqualTo" | "LessThan" | "LessThanOrEqualTo";
+export type DataValue = {
+    u8: number;
+} | {
+    u16Le: number;
+} | {
+    u32Le: number;
+} | {
+    u64Le: bigint;
+} | {
+    u128Le: bigint;
+} | {
+    u8Slice: number[];
+};
+export interface DataConstraint {
+    dataOffset: bigint;
+    dataValue: DataValue;
+    operator: DataOperator;
+}
+export interface AccountConstraint {
+    accountIndex: number;
+    accountKeys?: PublicKey[];
+    accountDataConstraints?: DataConstraint[];
+    owner?: PublicKey | null;
+}
+export interface InstructionConstraint {
+    programId: PublicKey;
+    accountConstraints: AccountConstraint[];
+    dataConstraints: DataConstraint[];
+}
+export type Period = "OneTime" | "Hourly" | "Daily" | "Weekly" | "Monthly" | "Quarterly" | "Yearly";
+export interface TimeConstraints {
+    start: bigint;
+    expiration: bigint | null;
+    period: Period;
+}
+export interface QuantityConstraints {
+    maxPerPeriod: bigint;
+}
+export interface SpendingLimit {
+    mint: PublicKey;
+    timeConstraints: TimeConstraints;
+    quantityConstraints: QuantityConstraints;
+}
+export type AllowedSettingsChange = "AddSigner" | "RemoveSigner" | "ChangeThreshold" | "ChangeTimeLock";
+export type PolicyType = {
+    programInteraction: {
+        accountIndex: number;
+        instructionsConstraints: InstructionConstraint[];
+        spendingLimits: SpendingLimit[];
+    };
+} | {
+    internalFundTransfer: {
+        sourceAccountMask: number[];
+        destinationAccountMask: number[];
+        allowedMints: PublicKey[];
+    };
+} | {
+    settingsChange: {
+        allowedActions: AllowedSettingsChange[];
+    };
+} | {
+    spendingLimit: {
+        sourceAccountIndex: number;
+        destinations: PublicKey[];
+        spendingLimit: SpendingLimit;
+    };
+};
+export type PolicyExpiration = {
+    timestamp: bigint;
+} | {
+    settingsState: {};
+};
+export interface PolicyConfig {
+    policyType: PolicyType;
+    threshold: number;
+    timeLock: number;
+    startTimestamp: bigint | null;
+    expiration: PolicyExpiration | null;
+}
+/** Interface type for adapter vaults */
+export type InterfaceType = {
+    generic: Record<string, never>;
+} | {
+    kamino: Record<string, never>;
+} | {
+    marginfi: Record<string, never>;
+} | {
+    jitoRestaking: Record<string, never>;
+} | {
+    perena: Record<string, never>;
+};
+export interface TokenEntryInput {
+    mint: PublicKey;
+    priceId: PriceId;
+    tokenSquadsAccount: PublicKey;
+    tokenAccountVault: PublicKey;
+    tokenEscrow: PublicKey;
+    shareBp: number;
+    currentLiquidity: bigint;
+    mintFlag: number;
+    interfaceType?: InterfaceType;
+    /** Force deallocate policy IDs (optional, defaults to empty) */
+    forceDeallocatePolicyIds?: bigint[];
+}
+type TotalAumInfo = {
+    aum: bigint;
+    aumHuman: number;
+    lpRate: number;
+    lpSupply: bigint;
+    lpDecimals: number;
+    underlyingDecimals: number;
+};
+export interface DepositLiquidityParams {
+    depositor: PublicKey;
+    mint: PublicKey;
+    tokenAmountIn: Numeric;
+    minLpOut: Numeric;
+    tokenSrc?: PublicKey;
+    /** Defaults to the Squads-controlled token account defined by the vault entry. */
+    entryTokenVault?: PublicKey;
+    tokenLpDst?: PublicKey;
+    tokenProgram?: PublicKey;
+    /** Additional remaining accounts (e.g., Kamino obligations) */
+    extraRemainingAccounts?: AccountMeta[];
+    /**
+     * When true, pass token_2022_program (TOKEN_2022_PROGRAM_ID) as the second token program account.
+     * Use for compatibility with older deployed programs that expect token_program + token_2022_program
+     * instead of token_program + token_program_lp. Required when running against Surfpool/mainnet fork.
+     */
+    useLegacyTokenAccounts?: boolean;
+}
+export interface UpdatePriceParams {
+    priceInterfaceAccounts?: PublicKey;
+    pythPriceFeedId?: PublicKey;
+    remainingAccounts?: PublicKey[];
+    priceId: number;
+}
+export interface QueueWithdrawalParams {
+    depositor: PublicKey;
+    lpAmount: Numeric;
+    tokenLpSrc?: PublicKey;
+    tokenProgram?: PublicKey;
+    systemProgram?: PublicKey;
+    tokenLpEscrow?: PublicKey;
+}
+export interface TokenAccountPair {
+    /** Source token account (vault's token escrow) */
+    tokenSrc: PublicKey;
+    /** Destination token account (user's token account) */
+    tokenDst: PublicKey;
+}
+export interface ExecuteWithdrawalParams {
+    owner: PublicKey;
+    withdrawalAccount: PublicKey;
+    /** Array of token account pairs matching the withdrawal fills */
+    tokenAccountPairs: TokenAccountPair[];
+    tokenProgram?: PublicKey;
+    token2022Program?: PublicKey;
+    tokenLpEscrow?: PublicKey;
+    mintLp?: PublicKey;
+}
+export interface ExecuteWithdrawalFromReservesParams {
+    owner: PublicKey;
+    /** Index of the token entry to withdraw */
+    entryIdx: number;
+    /** Amount of LP tokens to burn for withdrawal */
+    lpAmount: Numeric;
+    /** Source token account (owned by squads_vault) */
+    tokenSrc: PublicKey;
+    /** Source token account (owned by vault) */
+    tokenVaultSrc: PublicKey;
+    /** Destination token account (owned by the user) */
+    tokenDst: PublicKey;
+    squadsProgram: PublicKey;
+    tokenLpSrc?: PublicKey;
+    tokenProgram?: PublicKey;
+    token2022Program?: PublicKey;
+    tokenLpEscrow?: PublicKey;
+    mintLp?: PublicKey;
+}
+export interface FillWithdrawalFillParam {
+    /** Index of the token entry in vault.token_entries */
+    tokenEntryIdx: number;
+    /** Percentage of remaining LP to fill in basis points (10000 = 100%) */
+    percentOfTotalLpBp: Numeric;
+}
+export interface FillWithdrawalParams {
+    /** Withdrawal account to fill */
+    withdrawalAccount: PublicKey;
+    /** Fill parameters: which token entries and what percentage */
+    fills: FillWithdrawalFillParam[];
+    /** Token account pairs per fill: [{ tokenSrc (squads), tokenDst (vault escrow), tokenProgram }] */
+    tokenAccountTriples: Array<{
+        tokenSrc: PublicKey;
+        tokenDst: PublicKey;
+        tokenProgram: PublicKey;
+    }>;
+    mintLp?: PublicKey;
+    tokenLpEscrow?: PublicKey;
+}
+export interface WrapperExecuteWithdrawalParams {
+    owner: PublicKey;
+    withdrawalAccount: PublicKey;
+    /** Array of token account pairs matching the withdrawal fills */
+    tokenAccountPairs: TokenAccountPair[];
+    /** Index of the token entry for reserves withdrawal */
+    entryIdx: number;
+    /** Source token account for reserves withdrawal (owned by squads_vault) */
+    tokenSrc: PublicKey;
+    /** Source token account for reserves withdrawal (owned by vault) */
+    tokenVaultSrc: PublicKey;
+    /** Destination token account for reserves withdrawal (owned by user) */
+    tokenDst: PublicKey;
+    squadsProgram: PublicKey;
+    tokenProgram?: PublicKey;
+    token2022Program?: PublicKey;
+    tokenLpEscrow?: PublicKey;
+    mintLp?: PublicKey;
+}
+/** Vault type enum */
+export type VaultType = {
+    orderbook: Record<string, never>;
+} | {
+    generic: Record<string, never>;
+};
+/** Role membership lists for vault governance */
+export interface VaultRoles {
+    manager: PublicKey[];
+    curator: PublicKey[];
+    allocator: PublicKey[];
+    sentinel: PublicKey[];
+}
+/** Configuration for proposal voting system */
+export interface ProposalVoteConfig {
+    minVotingPeriodSeconds: number;
+    maxVotingPeriodSeconds: number;
+    defaultVotingPeriodSeconds: number;
+    defaultTimelockSeconds: number;
+    rejectionThresholdBps: bigint;
+    nextProposalId: bigint;
+    votingEnabled: boolean;
+    liveProposalsCount: number;
+    maxConcurrentLiveProposals: number;
+    reserved: number[];
+}
+export interface InitializeVaultParams {
+    /** Payer of the transaction (will also be the initial manager) */
+    payer: PublicKey;
+    /** Underlying mint used by vault-level price validation */
+    mint: PublicKey;
+    /** Manager of the vault (can be different from payer) */
+    manager: PublicKey;
+    /** 8-byte seed ID for the vault PDA */
+    seedId: SeedId;
+    /** Fee treasury account */
+    feeTreasury: PublicKey;
+    /** Fee treasury in basis points */
+    normalWithdrawalFeeBps: number;
+    /** Annualized management fee in basis points (1e6 precision) */
+    managementFeeBps: bigint;
+    /** Percentage of vault assets to keep as reserves in basis points (10000 = 100%) */
+    reservesShareBp: number;
+    /** Additional fee charged on fast withdrawals in basis points */
+    fastWithdrawalCutBp?: number;
+    /** Initial token entries for the vault */
+    tokenEntries: TokenEntryInput[];
+    /** Max LP token supply */
+    maxLpSupply: bigint;
+    /** Initial LP amount to mint */
+    initialLpAmount: bigint;
+    /** LP token decimals */
+    lpDecimals: number;
+    /** Deprecated: ignored by the vaults program */
+    vaultType?: VaultType;
+    /** Role membership lists */
+    roles: VaultRoles;
+    /** Proposal voting configuration (optional) */
+    proposalVoteConfig?: ProposalVoteConfig;
+    /** Address lookup table */
+    addressLookupTable: PublicKey;
+    /** Squads program ID */
+    squadsProgram: PublicKey;
+    /** Squads program config PDA (for creation fee) */
+    squadsProgramConfig: PublicKey;
+    /** Squads treasury (receives creation fee) */
+    squadsTreasury: PublicKey;
+    /** Squads settings account - derived as PDA("smart_account", "settings", index) */
+    squadsSettings: PublicKey;
+    /** Squads vault account - derived as PDA("smart_account", settings_key, "smart_account", 0) */
+    squadsVault: PublicKey;
+    /** Token program (defaults to Token) */
+    tokenProgram?: PublicKey;
+}
+/** Price type enum (matches on-chain PriceType) */
+export type PriceTypeParam = {
+    pyth: Record<string, never>;
+} | {
+    pythInverse: Record<string, never>;
+} | {
+    splStakePool: Record<string, never>;
+} | {
+    one: Record<string, never>;
+} | {
+    pt: Record<string, never>;
+} | {
+    yt: Record<string, never>;
+} | {
+    solstice: Record<string, never>;
+} | {
+    reflect: Record<string, never>;
+} | {
+    fragmetric: Record<string, never>;
+} | {
+    fragmetricSupportedAsset: Record<string, never>;
+} | {
+    jupiterLend: Record<string, never>;
+} | {
+    chainlink: Record<string, never>;
+} | {
+    ore: Record<string, never>;
+} | {
+    hyloLpToken: Record<string, never>;
+} | {
+    meteora: Record<string, never>;
+} | {
+    kaminoVault: Record<string, never>;
+};
+/** Action for managing price entries in ExponentPrices account */
+export type UpdatePriceActionParam = {
+    addPrice: {
+        priceType: PriceTypeParam;
+        priceMint: PublicKey;
+        underlyingMint: PublicKey;
+        interfaceAccounts?: PublicKey[];
+    };
+} | {
+    removePrice: {
+        priceId: bigint;
+        priceInterfaceAccounts?: PublicKey;
+    };
+} | {
+    updatePrice: {
+        priceId: bigint;
+        priceType: PriceTypeParam;
+        priceInterfaceAccounts?: PublicKey;
+    };
+} | {
+    addManager: {
+        manager: PublicKey;
+    };
+} | {
+    removeManager: {
+        manager: PublicKey;
+    };
+} | {
+    addPtPrice: {
+        priceMint: PublicKey;
+        underlyingMint: PublicKey;
+        interfaceAccounts?: PublicKey[];
+        impliedApyBps: number;
+    };
+} | {
+    addYtPrice: {
+        priceMint: PublicKey;
+        underlyingMint: PublicKey;
+        interfaceAccounts?: PublicKey[];
+        impliedApyBps: number;
+    };
+};
+export interface InitializePricesParams {
+    /** Manager of the vault (must sign, pays for account creation) */
+    manager: PublicKey;
+    /** Optional override for the exponent_vaults program ID */
+    programId?: PublicKey;
+}
+export interface ManagePricesParams {
+    /** Manager of the vault (must sign, pays for reallocation) */
+    manager: PublicKey;
+    /** List of price actions to execute */
+    actions: UpdatePriceActionParam[];
+    /** Optional override for the exponent_vaults program ID */
+    programId?: PublicKey;
+}
+export interface AddPolicyParams {
+    /** Payer for the transaction */
+    payer: PublicKey;
+    /** Policy configuration to add */
+    policyConfig: PolicyConfig;
+    /** Squads program ID */
+    squadsProgram: PublicKey;
+    /** Next policy seed (get from settings.nextPolicySeed) */
+    nextPolicySeed: bigint;
+    /** Next transaction index (get from settings.transactionIndex + 1) */
+    nextTransactionIndex: bigint;
+}
+export interface RemovePolicyParams {
+    /** Payer for the transaction */
+    payer: PublicKey;
+    /** Manager of the vault (must sign) */
+    manager: PublicKey;
+    /** Policy seed to remove */
+    policySeed: bigint;
+    /** Squads program ID */
+    squadsProgram: PublicKey;
+    /** Next transaction index (get from settings.transactionIndex + 1) */
+    nextTransactionIndex: bigint;
+}
+export interface UpdatePolicyParams {
+    payer: PublicKey;
+    manager: PublicKey;
+    policyConfig: PolicyConfig;
+    policySeed: bigint;
+    squadsProgram: PublicKey;
+    nextTransactionIndex: bigint;
+}
+export interface WrapperManageVaultSettingsParams {
+    manager: PublicKey;
+    actions: exponentVaults.VaultSettingsAction[];
+    remainingAccounts?: AccountMeta[];
+    exponentPrices?: PublicKey;
+    systemProgram?: PublicKey;
+}
+export interface WrapperManagerUpdatePositionParams {
+    manager: PublicKey;
+    update: exponentVaults.PositionUpdate;
+    remainingAccounts?: AccountMeta[];
+    exponentPrices?: PublicKey;
+    systemProgram?: PublicKey;
+}
+export type WrapperAddPolicyParams = AddPolicyParams;
+export type WrapperRemovePolicyParams = RemovePolicyParams;
+export type WrapperUpdatePolicyParams = UpdatePolicyParams;
+export interface CancelWithdrawalParams {
+    owner: PublicKey;
+    withdrawalAccount: PublicKey;
+    tokenLpDst?: PublicKey;
+    tokenProgram?: PublicKey;
+    tokenLpEscrow?: PublicKey;
+}
+export interface CollectManagementFeeParams {
+    manager: PublicKey;
+    mintLp?: PublicKey;
+    feeTreasury?: PublicKey;
+    tokenProgram?: PublicKey;
+}
+export declare class ExponentVault {
+    state: ExponentVaultAccountType;
+    readonly selfAddress: PublicKey;
+    readonly env: Environment;
+    connection: Connection;
+    readonly programId: PublicKey;
+    readonly fetcher: ExponentVaultsFetcher;
+    pda: ExponentVaultsPDA;
+    aumCalculator: AumCalculator;
+    private clmmTicksMap;
+    static squadsVaultTxnResolver: SquadsVaultTxnResolver;
+    constructor(params: {
+        state: ExponentVaultAccountType;
+        address: PublicKey;
+        env?: Environment;
+        connection: Connection;
+        programId?: PublicKey;
+    });
+    static load(params: {
+        env?: Environment;
+        connection: Connection;
+        address: PublicKey;
+    }): Promise<ExponentVault>;
+    static loadAll(params: {
+        env?: Environment;
+        connection: Connection;
+    }): Promise<ExponentVault[]>;
+    reload(connection?: Connection): Promise<ExponentVault>;
+    private populateClmmTicksCache;
+    /**
+     * Derive the PDA for a vault using its 8-byte seed identifier.
+     */
+    static deriveVaultAddress(seedId: Uint8Array | number[], programId?: PublicKey): [PublicKey, number];
+    get mintLp(): PublicKey;
+    get tokenLpEscrow(): PublicKey;
+    get eventAuthority(): PublicKey;
+    private getTokenEntryOrThrow;
+    fetchWithdrawalAccount(address: PublicKey): Promise<{
+        vault: PublicKey;
+        owner: PublicKey;
+        lpAmountRequested: bigint;
+        lpAmountRemaining: bigint;
+        fills: {
+            mint: PublicKey;
+            sourceTokenAccount: PublicKey;
+            tokenAmount: bigint;
+        }[];
+        createdAt: number;
+        updatedAt: number;
+        reserved: number[];
+    }>;
+    fetchAllActionProposals(): Promise<{
+        address: PublicKey;
+        data: exponentVaults.ActionProposalAccountData;
+    }[]>;
+    fetchLpTokenSupply(): Promise<bigint>;
+    /** Set DEBUG_VAULT_AUM=1 to log AUM remaining accounts (token entries + strategy positions) for debugging */
+    private static get debugAum();
+    private strategyPositionAccountMetas;
+    private tokenEntryAccountMetas;
+    private aumRemainingAccounts;
+    ixUpdatePrice({ priceInterfaceAccounts, pythPriceFeedId, remainingAccounts, priceId, }: UpdatePriceParams): TransactionInstruction;
+    ixsDepositLiquidity({ depositor, mint, tokenAmountIn, minLpOut, tokenSrc, entryTokenVault, tokenLpDst, tokenProgram, extraRemainingAccounts, useLegacyTokenAccounts, }: DepositLiquidityParams): Promise<TransactionInstruction[]>;
+    ixQueueWithdrawal({ depositor, lpAmount, tokenLpSrc, tokenProgram, systemProgram, tokenLpEscrow, }: QueueWithdrawalParams): {
+        ix: TransactionInstruction;
+        withdrawalKeypair: Keypair;
+    };
+    ixExecuteWithdrawal({ owner, withdrawalAccount, tokenAccountPairs, tokenProgram, token2022Program, tokenLpEscrow, mintLp, }: ExecuteWithdrawalParams): TransactionInstruction;
+    ixExecuteWithdrawalFromReserves({ owner, entryIdx, lpAmount, tokenSrc, tokenVaultSrc, tokenDst, tokenLpSrc, squadsProgram, tokenProgram, token2022Program, tokenLpEscrow, mintLp, }: ExecuteWithdrawalFromReservesParams): TransactionInstruction;
+    ixFillWithdrawal({ withdrawalAccount, fills, tokenAccountTriples, mintLp, tokenLpEscrow, }: FillWithdrawalParams): TransactionInstruction;
+    ixWrapperExecuteWithdrawal({ owner, withdrawalAccount, tokenAccountPairs, entryIdx, tokenSrc, tokenVaultSrc, tokenDst, squadsProgram, tokenProgram, token2022Program, tokenLpEscrow, mintLp, }: WrapperExecuteWithdrawalParams): TransactionInstruction;
+    ixCancelWithdrawal({ owner, withdrawalAccount, tokenLpDst, tokenProgram, tokenLpEscrow, }: CancelWithdrawalParams): TransactionInstruction;
+    /**
+     * Create instruction to call wrapper_manage_vault_settings.
+     */
+    ixWrapperManageVaultSettings({ manager, actions, remainingAccounts, exponentPrices, systemProgram, }: WrapperManageVaultSettingsParams): TransactionInstruction;
+    /**
+     * Create instruction to call wrapper_manager_update_position.
+     */
+    ixWrapperManagerUpdatePosition({ manager, update, remainingAccounts, exponentPrices, systemProgram, }: WrapperManagerUpdatePositionParams): TransactionInstruction;
+    /**
+     * Create instruction to add a policy to this vault.
+     * Direct policy management requires an empty vault; live vaults must use proposals.
+     */
+    ixAddPolicy({ payer, policyConfig, squadsProgram, nextPolicySeed, nextTransactionIndex }: AddPolicyParams): TransactionInstruction;
+    /**
+     * Create instruction to call wrapper_add_policy.
+     * Wrapper uses the same empty-vault guard as direct policy management.
+     */
+    ixWrapperAddPolicy({ payer, policyConfig, squadsProgram, nextPolicySeed, nextTransactionIndex, }: WrapperAddPolicyParams): TransactionInstruction;
+    /**
+     * Create instruction to remove a policy from this vault.
+     * Direct policy management requires an empty vault; live vaults must use proposals.
+     */
+    ixRemovePolicy({ payer, manager, policySeed, squadsProgram, nextTransactionIndex }: RemovePolicyParams): TransactionInstruction;
+    /**
+     * Create instruction to call wrapper_remove_policy.
+     * Wrapper uses the same empty-vault guard as direct policy management.
+     */
+    ixWrapperRemovePolicy({ payer, manager, policySeed, squadsProgram, nextTransactionIndex, }: WrapperRemovePolicyParams): TransactionInstruction;
+    /**
+     * Create instruction to call wrapper_update_policy.
+     * Wrapper uses the same empty-vault guard as direct policy management.
+     */
+    ixWrapperUpdatePolicy({ payer, manager, policyConfig, policySeed, squadsProgram, nextTransactionIndex, }: WrapperUpdatePolicyParams): TransactionInstruction;
+    /**
+     * Derive the ExponentPrices PDA for this vault.
+     */
+    deriveExponentPricesAddress(): [PublicKey, number];
+    /**
+     * Create instruction to initialize the global ExponentPrices account.
+     * The account is a singleton PDA derived from ["exponent_prices"].
+     */
+    static ixInitializePrices({ manager, programId: programIdOverride }: InitializePricesParams): TransactionInstruction;
+    /**
+     * Create instruction to manage price entries (add/remove/update) in the ExponentPrices account.
+     * Uses realloc to resize the account as prices are added or removed.
+     */
+    static ixManagePrices({ manager, actions, programId: programIdOverride }: ManagePricesParams): TransactionInstruction;
+    /**
+     * Create instruction to initialize a new vault.
+     * This is a static method since the vault doesn't exist yet.
+     */
+    static ixInitializeVault(params: InitializeVaultParams, env: Environment): TransactionInstruction;
+    fetchTotalAumInfo(pricesAccount: ExponentPrices, jitoBundleRpc?: string): Promise<TotalAumInfo>;
+    /**
+     * LP token price: AUM / LP supply.
+     * Returns 0 when LP supply is zero.
+     */
+    getLpPrice(): Promise<number>;
+    /**
+     * Total AUM: on-chain tracked base value + value held in strategy positions.
+     */
+    getTotalAum(): bigint;
+    /**
+     * Calculates total AUM by simulating a bundle that updates prices and deposits liquidity.
+     * Requires an RPC endpoint that supports the `simulateBundle` method (e.g., Jito, Helius).
+     */
+    getTotalAumViaJitoBundle(pricesAccount: ExponentPrices, jitoBundleRpc?: string): Promise<bigint>;
+    ixsUpdateStrategyVaultPrices(pricesAccount: ExponentPrices): Promise<TransactionInstruction[]>;
+    /**
+     * Converts vault `PolicyConfig` (policyType shape from policy builders) to the Codama/client codec shape
+     * required by the proposal action codecs used by staged proposal creation.
+     */
+    toCodamaPolicyConfig(config: PolicyConfig): exponentVaults.PolicyConfig;
+    private toCodamaPolicyPayload;
+    private toCodamaDataConstraint;
+    private toCodamaDataValue;
+    private toCodamaDataOperator;
+    private toCodamaPeriod;
+    private toCodamaPolicyExpiration;
+    private toCodamaAllowedSettingsChange;
+}
+export {};