@glamsystems/glam-sdk 1.1.0 → 1.1.1-alpha.0

package/src/client/phoenix.d.ts

@@ -1,214 +0,0 @@
-import { BN, type IdlTypes } from "@coral-xyz/anchor";
-import { type AccountMeta, PublicKey, type TransactionInstruction, type TransactionSignature, type VersionedTransaction } from "@solana/web3.js";
-import { PhoenixPolicy } from "../deser/integrationPolicies";
-import type { ExtPhoenix } from "../glamExports";
-import { PhoenixApiClient, PhoenixSnapshot } from "../utils/phoenixApi";
-import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "./base";
-export type PhoenixIdlTypes = IdlTypes<ExtPhoenix>;
-export type PhoenixBaseLots = PhoenixIdlTypes["baseLots"];
-export type PhoenixCancelUpToInstruction = PhoenixIdlTypes["cancelUpToInstruction"];
-export type PhoenixDepositFundsInstruction = PhoenixIdlTypes["depositFundsInstruction"];
-export type PhoenixDepositParams = PhoenixIdlTypes["depositParams"];
-export type PhoenixOrderFlags = PhoenixIdlTypes["orderFlags"];
-export type PhoenixOrderIds = PhoenixIdlTypes["orderIds"];
-export type PhoenixOrderPacket = PhoenixIdlTypes["orderPacket"];
-export type PhoenixQuoteLots = PhoenixIdlTypes["quoteLots"];
-export type PhoenixRegisterTraderParams = PhoenixIdlTypes["registerTraderParams"];
-export type PhoenixSelfTradeBehavior = PhoenixIdlTypes["selfTradeBehavior"];
-export type PhoenixSide = PhoenixIdlTypes["side"];
-export type PhoenixTicks = PhoenixIdlTypes["ticks"];
-export type PhoenixWithdrawFundsInstruction = PhoenixIdlTypes["withdrawFundsInstruction"];
-export type PhoenixWithdrawParams = PhoenixIdlTypes["withdrawParams"];
-export type PhoenixPolicyInput = PhoenixIdlTypes["phoenixPolicy"];
-export type PhoenixTraderIndexes = {
-    traderPdaIndex?: number;
-    subaccountIndex?: number;
-};
-export type PhoenixRemainingAccounts = {
-    remainingAccounts: AccountMeta[];
-};
-export type PhoenixRegisterTraderAccounts = {
-    traderAccount?: PublicKey;
-    logAuthority?: PublicKey;
-    globalConfig?: PublicKey;
-};
-export type PhoenixEmberAccounts = {
-    inputMint: PublicKey;
-    outputMint: PublicKey;
-    inputTokenAccount?: PublicKey;
-    outputTokenAccount?: PublicKey;
-    emberState?: PublicKey;
-    emberVault?: PublicKey;
-    tokenProgram?: PublicKey;
-};
-export declare function getPhoenixTraderPda(authority: PublicKey, traderPdaIndex?: number, subaccountIndex?: number): PublicKey;
-export declare function getPhoenixSplineCollectionPda(market: PublicKey): PublicKey;
-export declare function getPhoenixGlobalVaultPda(mint: PublicKey): PublicKey;
-export declare function getEmberStatePda(): PublicKey;
-export declare function getEmberVaultPda(): PublicKey;
-declare class TxBuilder extends BaseTxBuilder<PhoenixClient> implements ProtocolPolicyTxBuilder<PhoenixPolicy> {
-    getEmberCpiAccounts(accounts: PhoenixEmberAccounts, signer?: PublicKey): {
-        glamState: PublicKey;
-        glamVault: PublicKey;
-        glamSigner: PublicKey;
-        integrationAuthority: PublicKey;
-        cpiProgram: PublicKey;
-        glamProtocolProgram: PublicKey;
-        systemProgram: PublicKey;
-        emberState: PublicKey;
-        inputMint: PublicKey;
-        outputMint: PublicKey;
-        inputTokenAccount: PublicKey;
-        outputTokenAccount: PublicKey;
-        emberVault: PublicKey;
-        tokenProgram: PublicKey;
-    };
-    /**
-     * Account map shared by every ext_phoenix Phoenix-CPI instruction
-     * (`glam_state`, `glam_vault`, `glam_signer`, integration authority,
-     * `cpi_program=Phoenix`, the GLAM protocol program, system program).
-     */
-    getPhoenixCpiAccounts(signer?: PublicKey): {
-        glamState: PublicKey;
-        glamVault: PublicKey;
-        glamSigner: PublicKey;
-        integrationAuthority: PublicKey;
-        cpiProgram: PublicKey;
-        glamProtocolProgram: PublicKey;
-        systemProgram: PublicKey;
-    };
-    registerTraderIx(params: PhoenixRegisterTraderParams, accounts?: PhoenixRegisterTraderAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    updateTraderStateIx(accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    emberDepositIx(params: PhoenixDepositParams, accounts: PhoenixEmberAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    depositFundsIx(params: PhoenixDepositFundsInstruction, accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    emberWithdrawIx(params: PhoenixWithdrawParams, accounts: PhoenixEmberAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    withdrawFundsIx(params: PhoenixWithdrawFundsInstruction, accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    placeLimitOrderIx(packet: PhoenixOrderPacket, accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    placeMarketOrderIx(packet: PhoenixOrderPacket, accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    cancelAllIx(accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    cancelOrdersByIdIx(orderIds: PhoenixOrderIds, accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    cancelUpToIx(args: PhoenixCancelUpToInstruction, accounts: PhoenixRemainingAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyIx(policy: PhoenixPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: PhoenixPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    registerTraderTx(params: PhoenixRegisterTraderParams, accounts?: PhoenixRegisterTraderAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    updateTraderStateTx(accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Remaining-accounts list for `deposit_funds` — the vault token account
-     * holding the canonical collateral, the trader PDA, Phoenix's global vault
-     * for that mint, the SPL token program, and the trader-index/active-buffer
-     * chunks from the snapshot.
-     */
-    getDepositRemainingAccounts(snapshot: PhoenixSnapshot, indexes?: PhoenixTraderIndexes): AccountMeta[];
-    /**
-     * Remaining-accounts list for `withdraw_funds`. Same shape as the deposit
-     * variant plus the perp asset map and the global withdraw queue, which the
-     * withdraw path mutates.
-     */
-    getWithdrawRemainingAccounts(snapshot: PhoenixSnapshot, indexes?: PhoenixTraderIndexes): AccountMeta[];
-    deposit(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdraw(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositFundsTx(params: PhoenixDepositFundsInstruction, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawFundsTx(params: PhoenixWithdrawFundsInstruction, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    placeLimitOrderTx(packet: PhoenixOrderPacket, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    placeMarketOrderTx(packet: PhoenixOrderPacket, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelAllTx(accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelOrdersByIdTx(orderIds: PhoenixOrderIds, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelUpToTx(args: PhoenixCancelUpToInstruction, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class PhoenixClient implements ProtocolPolicyClient<PhoenixPolicy> {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    readonly phoenixApi: PhoenixApiClient;
-    constructor(base: BaseClient);
-    /** The ext_phoenix program id this client talks to. */
-    get programId(): PublicKey;
-    /** Bit flag identifying Phoenix inside the GLAM integration ACL bitmask. */
-    get protocolBitflag(): number;
-    /** PDA the ext_phoenix program signs CPIs with into Phoenix and Ember. */
-    getIntegrationAuthorityPda(): PublicKey;
-    /**
-     * PDA of a Phoenix trader account owned by the GLAM vault (defaults to the
-     * vault PDA as authority). `traderPdaIndex` selects the parent trader and
-     * `subaccountIndex` selects a child subaccount under that parent.
-     */
-    getTraderPda(traderPdaIndex?: number, subaccountIndex?: number, authority?: PublicKey): PublicKey;
-    /** PDA of the spline-collection account associated with a Phoenix market. */
-    getSplineCollectionPda(market: PublicKey): PublicKey;
-    /** PDA of Phoenix's global-vault token account for a given mint. */
-    getGlobalVaultPda(mint: PublicKey): PublicKey;
-    /** PDA of the Ember exchange-state account that backs Phoenix conversions. */
-    getEmberStatePda(): PublicKey;
-    /** PDA of Ember's USDC vault that mints/burns canonical collateral. */
-    getEmberVaultPda(): PublicKey;
-    /**
-     * The three accounts every Phoenix CPI begins with (program, log authority,
-     * global config). `globalConfigWritable` toggles the writable flag on the
-     * global config — set true for instructions that mutate exchange state.
-     */
-    getPhoenixRemainingPrefix(globalConfigWritable: boolean): AccountMeta[];
-    /**
-     * Remaining-accounts list for place/cancel/order-book CPIs against a single
-     * Phoenix market. Includes the trader PDA, perp asset map, trader indices,
-     * the market itself, and its spline collection.
-     */
-    getMarketRemainingAccounts(snapshot: PhoenixSnapshot, market: PublicKey | string, indexes?: PhoenixTraderIndexes): AccountMeta[];
-    /**
-     * Remaining-accounts list for `update_trader_state` — settles funding for
-     * the trader and may evict it from the active-trader buffer once it no
-     * longer holds resting orders.
-     */
-    getUpdateTraderStateRemainingAccounts(snapshot: PhoenixSnapshot, indexes?: PhoenixTraderIndexes): AccountMeta[];
-    /** Fetches the on-chain PhoenixPolicy stored under this vault, if any. */
-    fetchPolicy(): Promise<PhoenixPolicy | null>;
-    /** Writes the PhoenixPolicy (market allowlist, order types, etc.). */
-    setPolicy(policy: PhoenixPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /** Deletes the stored PhoenixPolicy. Future Phoenix policy checks fail closed. */
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Creates a Phoenix trader account for the vault (parent or child subaccount)
-     * sized to hold `maxPositions`.
-     */
-    registerTrader(params: PhoenixRegisterTraderParams, accounts?: PhoenixRegisterTraderAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Settles funding for the vault's trader and may evict it from the active
-     * buffer when no resting orders remain. Idempotent housekeeping call.
-     */
-    updateTraderState(accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Full deposit flow in one transaction: converts USDC to canonical
-     * collateral via Ember, then deposits the canonical amount into the vault's
-     * Phoenix trader account.
-     */
-    deposit(amount: BN | number, txOptions?: TxOptions): Promise<string>;
-    /**
-     * Full withdraw flow in one transaction: withdraws canonical collateral
-     * from Phoenix and converts it back to USDC via Ember.
-     */
-    withdraw(amount: BN | number, txOptions?: TxOptions): Promise<string>;
-    /**
-     * Phoenix-only `deposit_funds` (no Ember leg) — moves an already-canonical
-     * token balance from the vault's token account into Phoenix.
-     */
-    depositFunds(params: PhoenixDepositFundsInstruction, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Phoenix-only `withdraw_funds` (no Ember leg) — pulls canonical collateral
-     * out of Phoenix back to the vault's token account.
-     */
-    withdrawFunds(params: PhoenixWithdrawFundsInstruction, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /** Places a Phoenix limit order against the market in `accounts`. */
-    placeLimitOrder(packet: PhoenixOrderPacket, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /** Places an immediate-or-cancel market order against the market. */
-    placeMarketOrder(packet: PhoenixOrderPacket, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /** Cancels all resting orders the vault has on the given market. */
-    cancelAll(accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /** Cancels the specific resting orders identified by `orderIds`. */
-    cancelOrdersById(orderIds: PhoenixOrderIds, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Cancels up to `num_orders_to_cancel` resting orders on a side, optionally
-     * bounded by a price tick limit.
-     */
-    cancelUpTo(args: PhoenixCancelUpToInstruction, accounts: PhoenixRemainingAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/price.d.ts

@@ -1,182 +0,0 @@
-import { AccountMeta, AddressLookupTableAccount, Commitment, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BN } from "@coral-xyz/anchor";
-import { KaminoLendingClient, KaminoVaultsClient } from "./kamino";
-import { BaseClient } from "./base";
-import { StateModel } from "../models";
-import { PkMap, PkSet } from "../utils";
-import { KVaultState, Reserve } from "../deser";
-import { JupiterApiClient, TokenListItem } from "../utils/jupiterApi";
-import { BridgeClient } from "./bridge";
-import { EpiClient } from "./epi";
-import { LoopscaleBorrowClient, LoopscaleLendClient, LoopscaleVaultClient } from "./loopscale";
-/**
- * Represents a single asset holding within a vault.
- *
- * @param mintAddress - The SPL token mint address of the held asset
- * @param decimals - Number of decimal places for the token (e.g., 6 for USDC, 9 for SOL)
- * @param amount - Unsigned token amount in native units; direction (deposit/borrow) is in protocolMeta
- * @param price - Current price of the asset denominated in the base asset (e.g., USD, SOL)
- * @param priceMeta - Additional pricing context (e.g., source, slot, base asset). Default base asset, if not specified, is USD.
- * @param protocol - Protocol identifier where the asset is allocated
- * @param protocolMeta - Protocol-specific metadata (e.g., market index, position direction, reserve address)
- */
-export declare class Holding {
-    readonly mintAddress: PublicKey;
-    readonly decimals: number;
-    readonly amount: BN;
-    readonly price: number;
-    readonly priceMeta: Record<string, any>;
-    readonly protocol: string;
-    readonly protocolMeta: Record<string, any>;
-    readonly uiAmount: number;
-    constructor(mintAddress: PublicKey, decimals: number, amount: BN, price: number, priceMeta: Record<string, any> | undefined, protocol: string, protocolMeta?: Record<string, any>);
-}
-/**
- * Aggregates all holdings for a GLAM vault.
- * Includes token balances and supported DeFi positions.
- *
- * @param vaultState - The vault's state account address (stores vault configuration)
- * @param vaultPda - The vault's PDA that holds tokens and positions
- * @param priceBaseAssetMint - The base asset mint used for pricing (e.g., PublicKey.default for USD, So11111111111111111111111111111111111111112 for SOL)
- * @param slot - The Solana slot at which holdings were fetched
- * @param timestamp - Unix timestamp (seconds) when holdings were fetched
- * @param commitment - The Solana commitment level used for fetching account data
- */
-export declare class VaultHoldings {
-    readonly vaultState: PublicKey;
-    readonly vaultPda: PublicKey;
-    readonly priceBaseAssetMint: PublicKey;
-    readonly slot: number;
-    readonly timestamp: number;
-    readonly commitment: Commitment;
-    holdings: Holding[];
-    constructor(vaultState: PublicKey, vaultPda: PublicKey, priceBaseAssetMint: PublicKey, slot: number, timestamp: number, commitment: Commitment);
-    add(holding: Holding): void;
-    toJson(): string;
-}
-type PricingChunk = {
-    ixs: TransactionInstruction[];
-    kaminoReserves: PublicKey[];
-};
-export declare class PriceClient {
-    readonly base: BaseClient;
-    readonly klend: KaminoLendingClient;
-    readonly kvaults: KaminoVaultsClient;
-    readonly bridge: BridgeClient;
-    readonly epi: EpiClient;
-    readonly loopscaleBorrow: LoopscaleBorrowClient;
-    readonly loopscaleLend: LoopscaleLendClient;
-    readonly loopscaleVault: LoopscaleVaultClient;
-    private readonly getJupiterApi;
-    private _stateModel;
-    private _lookupTables;
-    private _kaminoVaults;
-    private _priceVaultIxsQueue;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, bridge: BridgeClient, epi: EpiClient, loopscaleBorrow: LoopscaleBorrowClient, loopscaleLend: LoopscaleLendClient, loopscaleVault: LoopscaleVaultClient, getJupiterApi: () => JupiterApiClient);
-    get jupiterApi(): JupiterApiClient;
-    get cachedStateModel(): StateModel | null;
-    set cachedStateModel(stateModel: StateModel);
-    get lookupTables(): AddressLookupTableAccount[];
-    get kaminoVaults(): PublicKey[];
-    private getKaminoObligationReserveSets;
-    /**
-     * Fetches all holdings in the vault.
-     *
-     * The source of truth for external positions is the `externalPositions` array
-     * from the state account, which tracks:
-     * - Kamino obligation accounts (lending positions)
-     * - Kamino vault share ATAs (shares in kamino vaults)
-     *
-     * @param commitment Commitment level for fetching accounts
-     * @param priceBaseAssetMint Price reference/numeraire asset mint (default: PublicKey.default for USD).
-     *                           Pass a token mint (e.g., WSOL) to get prices denominated in that asset.
-     * @returns VaultHoldings object containing all holdings
-     */
-    getVaultHoldings(commitment: Commitment, priceBaseAssetMint?: PublicKey): Promise<VaultHoldings>;
-    getPubkeysForTokenHoldings(externalPositionsSet: PkSet, commitment?: Commitment): Promise<PublicKey[]>;
-    /**
-     * Gets kamino obligation reserves from known obligation pubkeys.
-     */
-    getPubkeysForKaminoHoldings(obligationPubkeys: PublicKey[], commitment?: Commitment): Promise<PkMap<PkSet>>;
-    /**
-     * Gets kamino vault states from known share ATA pubkeys.
-     * Used by getVaultHoldingsV2 to process vault shares from externalPositions.
-     */
-    getKaminoVaultStatesFromAtas(shareAtaPubkeys: PublicKey[], commitment?: Commitment): Promise<PkMap<KVaultState>>;
-    /**
-     * Fetches token price from the prefetched map, falling back to Jupiter API if not found.
-     * @throws Error if price cannot be fetched from either source
-     */
-    private getTokenPrice;
-    private getHoldingTokenPrice;
-    private getTokenMintDecimals;
-    getTokenHoldings(tokenAccountPubkeys: PublicKey[], accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, tokenMintDecimalsMap: PkMap<number>, priceSource: string): Promise<Holding[]>;
-    getKaminoLendHoldings(obligationPubkeys: Iterable<PublicKey>, reservesMap: PkMap<Reserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getKaminoVaultsHoldings(kvaultAtasAndStates: PkMap<KVaultState>, reservesMap: PkMap<Reserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    /**
-     * Returns an instruction that prices Kamino obligations.
-     * If there are no Kamino obligations, returns null.
-     */
-    priceKaminoObligationsIxs(): Promise<PricingChunk>;
-    priceKaminoVaultSharesIx(): Promise<PricingChunk | null>;
-    /**
-     * Returns an instruction that prices vault balance and tokens
-     */
-    priceVaultTokensIx(): Promise<PricingChunk>;
-    /**
-     * Returns an instruction that prices stake accounts.
-     * If there are no stake accounts, returns null.
-     */
-    priceStakeAccountsIx(): Promise<TransactionInstruction | null>;
-    private findPhoenixTraderAccounts;
-    private getPhoenixPerpAssetMap;
-    /**
-     * Returns the program instruction that prices Phoenix trader external positions.
-     * If there are no registered Phoenix trader accounts, returns null.
-     */
-    pricePhoenixTradersIx(stateModel?: StateModel | null): Promise<TransactionInstruction | null>;
-    /**
-     * Returns Phoenix trader pricing instructions with required compute budget pre-instructions.
-     * If there are no registered Phoenix trader accounts, returns null.
-     */
-    pricePhoenixTradersIxs(stateModel?: StateModel | null): Promise<PricingChunk | null>;
-    /**
-     * Returns the program instruction that prices Loopscale loan external positions.
-     * If there are no registered Loopscale loans, returns null.
-     *
-     * Remaining accounts are laid out as N loan accounts followed by the oracle
-     * accounts needed to price the loans' collateral and debt.
-     */
-    priceLoopscaleLoansIx(): Promise<TransactionInstruction | null>;
-    /**
-     * Returns the program instruction that prices Loopscale strategy external positions.
-     * If there are no registered Loopscale strategies, returns null.
-     *
-     * Remaining accounts are laid out as N strategy accounts followed by the
-     * oracle accounts needed to price the strategies' principal mints.
-     */
-    priceLoopscaleStrategiesIx(): Promise<TransactionInstruction | null>;
-    /**
-     * Returns the program instruction that prices registered Loopscale vault LP
-     * token accounts and registered staked LP positions.
-     * If there are no registered Loopscale vault LP positions, returns null.
-     *
-     * Remaining accounts are laid out as N (vault, vault strategy, GLAM vault LP
-     * ATA) groups for vaults with tracked LP or stake positions, followed by
-     * VaultStake accounts, followed by oracle accounts.
-     */
-    priceLoopscaleVaultPositionsIx(): Promise<TransactionInstruction | null>;
-    priceOrcaWhirlpoolPositionsIxs(stateModel?: StateModel | null): Promise<PricingChunk | null>;
-    priceVaultIxs(): Promise<TransactionInstruction[]>;
-    private enqueuePriceVaultIxs;
-    private priceManagedTransfersIxs;
-    private priceEpiValidatedPositionsIx;
-    private _priceVaultIxsImpl;
-    validateAumIx(): Promise<TransactionInstruction>;
-    getBaseAssetOracle(): Promise<PublicKey>;
-    remainingAccountsForPricingVaultAssets(): Promise<[
-        AccountMeta[],
-        PublicKey[]
-    ]>;
-}
-export {};

package/src/client/stake-pool.d.ts

@@ -1,39 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { MarinadeClient } from "./marinade";
-import { StakeClient } from "./stake";
-interface StakePoolAccountData {
-    programId: PublicKey;
-    depositAuthority: PublicKey;
-    withdrawAuthority: PublicKey;
-    poolMint: PublicKey;
-    feeAccount: PublicKey;
-    reserveStake: PublicKey;
-    tokenProgramId: PublicKey;
-    validatorList: PublicKey;
-}
-declare class TxBuilder extends BaseTxBuilder<StakePoolClient> {
-    depositSolIxs(stakePool: PublicKey, lamports: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositSolTx(stakePool: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositStakeIxs(stakePool: PublicKey, stakeAccount: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositStakeTx(stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawStakeIxs(stakePool: PublicKey, amount: BN, deactivate: boolean | undefined, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
-    withdrawStakeTx(stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
-}
-export declare class StakePoolClient {
-    readonly base: BaseClient;
-    readonly stake: StakeClient;
-    readonly marinade: MarinadeClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, stake: StakeClient, marinade: MarinadeClient);
-    unstake(asset: PublicKey, amount: number | BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositSol(stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositStake(stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdrawStake(stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    getStakePoolWithdrawAuthority(programId: PublicKey, stakePool: PublicKey): PublicKey;
-    getStakePoolDepositAuthority(programId: PublicKey, stakePool: PublicKey): PublicKey;
-    getStakeAccountVoter(stakeAccount: PublicKey): Promise<PublicKey | null>;
-    getStakePoolAccountData(stakePool: PublicKey): Promise<StakePoolAccountData>;
-}
-export {};

package/src/client/stake.d.ts

@@ -1,34 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-declare class TxBuilder extends BaseTxBuilder<StakeClient> {
-    initializeAndDelegateStakeIxs(vote: PublicKey, amount: BN, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
-    initializeAndDelegateStakeTx(vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
-    deactivateStakesIx(stakeAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
-    deactivateStakesTx(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawStakesIx(stakeAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
-    withdrawStakesTx(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    mergeStakeIx(destinationStake: PublicKey, sourceStake: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    mergeStakeTx(destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    splitStakeIxs(existingStake: PublicKey, lamports: BN, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
-    splitStakeTx(existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
-    moveStakeIx(sourceStake: PublicKey, destinationStake: PublicKey, amount: BN, glamSigner: PublicKey): Promise<any>;
-    moveStakeTx(sourceStake: PublicKey, destinationStake: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class StakeClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    initializeAndDelegateStake(vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    deactivate(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdraw(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    merge(destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    split(existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<{
-        newStake: PublicKey;
-        txSig: TransactionSignature;
-    }>;
-    move(sourceStake: PublicKey, destinationStake: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    getStakeAccountVoter(stakeAccount: PublicKey): Promise<PublicKey | null>;
-    createStakeAccount(signer: PublicKey): Promise<[PublicKey, TransactionInstruction]>;
-}
-export {};

package/src/client/state.d.ts

@@ -1,56 +0,0 @@
-import { VersionedTransaction, TransactionSignature, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { StateIdlModel, StateAccountType } from "../models";
-export type InitStateParams = {
-    accountType: StateAccountType;
-    name: number[];
-    baseAssetMint: PublicKey;
-} & Partial<StateIdlModel>;
-/**
- * A subset of StateIdlModel fields that are updatable using updateState instruction
- */
-export type UpdateStateParams = {
-    name?: number[];
-    owner?: PublicKey;
-    portfolioManagerName?: number[];
-    timelockDuration?: number;
-    assets?: PublicKey[];
-    borrowable?: PublicKey[];
-};
-declare class TxBuilder extends BaseTxBuilder<StateClient> {
-    initializeIx(params: InitStateParams, glamSigner: PublicKey): Promise<[TransactionInstruction, PublicKey]>;
-    initializeTx(params: InitStateParams, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
-    updateIx(params: UpdateStateParams, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    updateTx(params: UpdateStateParams, txOptions: TxOptions): Promise<VersionedTransaction>;
-    extendIx(newBytes: number, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    extendTx(newBytes: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    closeIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
-    closeTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class StateClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    /**
-     * Creates a new GLAM state
-     */
-    initialize(params: InitStateParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Updates the GLAM state account.
-     *
-     * If no timelock , the updates will be applied immediately.
-     * If timelock is enabled, the updates will be staged and can be applied after the timelock period.
-     *
-     * Only the fields provided in `params` will be updated; omitted fields remain unchanged.
-     */
-    update(params: UpdateStateParams, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Extends GLAM state account size
-     */
-    extend(newBytes: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Closes GLAM state account
-     */
-    close(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/timelock.d.ts

@@ -1,31 +0,0 @@
-import { VersionedTransaction, TransactionSignature, PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { StateClient } from "./state";
-declare class TxBuilder extends BaseTxBuilder<TimelockClient> {
-    applyStateTimelockIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
-    applyStateTimelockTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    applyMintTimelockIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
-    applyMintTimelockTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelTimelockIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
-    cancelTimelockTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class TimelockClient {
-    readonly base: BaseClient;
-    readonly stateClient: StateClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, stateClient: StateClient);
-    /**
-     * Sets the timelock duration in seconds
-     * @param durationSeconds Duration in seconds for timelock period
-     */
-    set(durationSeconds: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Applies pending timelock updates after timelock expires.
-     */
-    apply(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Cancels pending timelock updates
-     */
-    cancel(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/vault.d.ts

@@ -1,98 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, ProtocolPolicyClient, ProtocolPolicyTxBuilder, TxOptions } from "./base";
-import { TransferPolicy } from "../deser/integrationPolicies";
-declare class TxBuilder extends BaseTxBuilder<VaultClient> implements ProtocolPolicyTxBuilder<TransferPolicy> {
-    setPolicyIx(policy: TransferPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: TransferPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    wrapIxs(amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    wrapTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    unwrapIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
-    unwrapTx(txOptions: TxOptions): Promise<VersionedTransaction>;
-    systemTransferIx(amount: BN, to: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    systemTransferTx(amount: BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Returns an instruction that closes the specified vault token account
-     */
-    closeTokenAccountIx(tokenAccount: PublicKey, tokenProgram: PublicKey, signer?: PublicKey): Promise<TransactionInstruction>;
-    closeTokenAccountsTx(pubkeys: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
-    depositSolIxs(lamports: number | BN, wrap: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositSolTx(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositIxs(asset: PublicKey, amount: number | BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositTx(asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    /**
-     * Transfers tokens held by the vault to the specified recipient
-     */
-    tokenTransferIxs(mint: PublicKey, amount: number | BN, to: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    tokenTransferTx(mint: PublicKey, amount: number | BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class VaultClient implements ProtocolPolicyClient<TransferPolicy> {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    fetchPolicy(): Promise<TransferPolicy | null>;
-    setPolicy(policy: TransferPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Wraps vault SOL to wSOL
-     *
-     * @param amount
-     * @param txOptions
-     */
-    wrap(amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Unwraps vault wSOL to SOL
-     *
-     * @param txOptions
-     */
-    unwrap(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Transfers SOL from vault to another account
-     *
-     * @param amount
-     * @param to
-     * @param txOptions
-     */
-    systemTransfer(amount: BN | number, to: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Transfers token from vault to another account
-     *
-     * @param mint
-     * @param amount
-     * @param txOptions
-     */
-    tokenTransfer(mint: PublicKey | string, amount: number | BN, to: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Closes multiple vault token accounts
-     *
-     * @param tokenAccounts
-     * @param txOptions
-     */
-    closeTokenAccounts(tokenAccounts: PublicKey[] | string[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Deposits token to vault
-     *
-     * @param mint Token mint
-     * @param amount
-     * @param txOptions
-     */
-    deposit(mint: PublicKey | string, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Deposits SOL to vault
-     *
-     * @param lamports
-     * @param wrap Whether to wrap SOL to wSOL or not
-     * @param txOptions
-     */
-    depositSol(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Generates instructions to wrap SOL into wSOL if the vault doesn't have enough wSOL
-     *
-     * @param lamports Desired amount of wSOL
-     * @returns Array of instructions, empty if wSOL is sufficient
-     */
-    maybeWrapSol(lamports: number | BN, signer?: PublicKey): Promise<TransactionInstruction[]>;
-}
-export {};