@glamsystems/glam-sdk 0.1.22 → 0.1.24

package/src/client/price.d.ts

@@ -2,24 +2,26 @@ import { PublicKey, TransactionInstruction } from "@solana/web3.js";
 import { KaminoLendingClient } from "./kamino";
 import { BaseClient } from "./base";
 import { PriceDenom } from "../models";
+import { DriftClient } from "./drift";
 export declare class PriceClient {
     readonly base: BaseClient;
     readonly klend: KaminoLendingClient;
-    constructor(base: BaseClient, klend: KaminoLendingClient);
+    readonly drift: DriftClient;
+    constructor(base: BaseClient, klend: KaminoLendingClient, drift: DriftClient);
     /**
      * !! This is a convenience method that calculates the AUM of the vault based on priced assets.
      * !! It doesn't reflect the actual AUM of the vault.
      * !! If the vault has not been priced or pricing data is outdated, the number is NOT meaningful.
      */
-    getAum(glamState: PublicKey): Promise<BN>;
-    priceKaminoIxs(glamState: PublicKey, priceDenom: PriceDenom): Promise<any[]>;
-    priceVaultIxs(glamState: PublicKey, priceDenom: PriceDenom): Promise<TransactionInstruction[]>;
-    remainingAccountsForPricingMeteora: (glamState: PublicKey) => Promise<{
+    getAum(): Promise<BN>;
+    priceKaminoIx(priceDenom: PriceDenom): Promise<TransactionInstruction>;
+    priceVaultIxs(priceDenom: PriceDenom): Promise<TransactionInstruction[]>;
+    remainingAccountsForPricingMeteora: () => Promise<{
         pubkey: PublicKey;
         isSigner: boolean;
         isWritable: boolean;
     }[]>;
-    remainingAccountsForPricingVaultAssets: (glamState: PublicKey) => Promise<{
+    remainingAccountsForPricingVaultAssets: (baseAssetOnly?: boolean) => Promise<{
         pubkey: PublicKey;
         isSigner: boolean;
         isWritable: boolean;

package/src/client/staking.d.ts

@@ -2,6 +2,7 @@ import { BN } from "@coral-xyz/anchor";
 import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
 import { BaseClient, TxOptions } from "./base";
 import { MarinadeClient } from "./marinade";
+import { StakeAccountInfo } from "../utils/helpers";
 interface StakePoolAccountData {
     programId: PublicKey;
     depositAuthority: PublicKey;
@@ -12,51 +13,44 @@ interface StakePoolAccountData {
     tokenProgramId: PublicKey;
     validatorList: PublicKey;
 }
-type StakeAccountInfo = {
-    address: PublicKey;
-    lamports: number;
-    state: string;
-    voter?: PublicKey;
-};
 export declare class StakingClient {
     readonly base: BaseClient;
     readonly marinade: MarinadeClient;
     constructor(base: BaseClient, marinade: MarinadeClient);
-    unstake(glamState: PublicKey, asset: PublicKey, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    stakePoolDepositSol(glamState: PublicKey, stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    stakePoolDepositStake(glamState: PublicKey, stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    stakePoolWithdrawStake(glamState: PublicKey, stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    initializeAndDelegateStake(glamState: PublicKey, vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    deactivate(glamState: PublicKey, stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdraw(glamState: PublicKey, stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    merge(glamState: PublicKey, destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    split(glamState: PublicKey, existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<{
+    unstake(asset: PublicKey, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    stakePoolDepositSol(stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    stakePoolDepositStake(stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    stakePoolWithdrawStake(stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    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;
     }>;
-    redelegate(glamState: PublicKey, existingStake: PublicKey, vote: PublicKey, txOptions?: TxOptions): Promise<{
+    redelegate(existingStake: PublicKey, vote: PublicKey, txOptions?: TxOptions): Promise<{
         newStake: PublicKey;
         txSig: TransactionSignature;
     }>;
-    getStakeAccountPda(state: PublicKey, accountId: string): [PublicKey, number];
     getStakePoolWithdrawAuthority(programId: PublicKey, stakePool: PublicKey): PublicKey;
     getStakePoolDepositAuthority(programId: PublicKey, stakePool: PublicKey): PublicKey;
-    getStakeAccountsWithStates(withdrawAuthority: PublicKey): Promise<StakeAccountInfo[]>;
+    getStakeAccountsWithStates(withdrawAuthority?: PublicKey): Promise<StakeAccountInfo[]>;
     getStakeAccountVoter(stakeAccount: PublicKey): Promise<PublicKey | null>;
     getStakePoolAccountData(stakePool: PublicKey): Promise<StakePoolAccountData>;
     createStakeAccount(signer: PublicKey): Promise<[PublicKey, TransactionInstruction]>;
-    stakePoolDepositSolTx(glamState: PublicKey, stakePool: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    stakePoolDepositStakeTx(glamState: PublicKey, stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    stakePoolWithdrawStakeTx(glamState: PublicKey, stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    initializeAndDelegateStakeTx(glamState: PublicKey, vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    deactivateStakeTx(glamState: PublicKey, stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawStakeTx(glamState: PublicKey, stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    mergeStakeTx(glamState: PublicKey, destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    splitStakeTx(glamState: PublicKey, existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<{
+    stakePoolDepositSolTx(stakePool: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    stakePoolDepositStakeTx(stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    stakePoolWithdrawStakeTx(stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    initializeAndDelegateStakeTx(vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    deactivateStakeTx(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawStakeTx(stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    mergeStakeTx(destinationStake: PublicKey, sourceStake: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    splitStakeTx(existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<{
         tx: VersionedTransaction;
         newStake: PublicKey;
     }>;
-    redelegateStakeTx(glamState: PublicKey, existingStake: PublicKey, vote: PublicKey, txOptions?: TxOptions): Promise<{
+    redelegateStakeTx(existingStake: PublicKey, vote: PublicKey, txOptions?: TxOptions): Promise<{
         tx: VersionedTransaction;
         newStake: PublicKey;
     }>;

package/src/client/state.d.ts

@@ -1,15 +1,17 @@
-import { PublicKey, VersionedTransaction, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
-import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
 import { BaseClient, TxOptions } from "./base";
 import { DelegateAcl, StateModel } from "../models";
-type PublicKeyOrString = PublicKey | string;
 export declare class StateClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    createState(partialStateModel: Partial<StateModel>, singleTx?: boolean, txOptions?: TxOptions): Promise<[TransactionSignature, PublicKey]>;
-    updateState(glamState: PublicKeyOrString, updated: Partial<StateModel>, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateStateTx(glamState: PublicKey, updated: Partial<StateModel>, txOptions: TxOptions): Promise<VersionedTransaction>;
-    closeState(glamState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    create(partialStateModel: Partial<StateModel>, singleTx?: boolean, txOptions?: TxOptions): Promise<[TransactionSignature, PublicKey]>;
+    update(updated: Partial<StateModel>, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateApplyTimelock(txOptions?: TxOptions): Promise<string>;
+    emergencyUpdate(updated: Partial<StateModel>, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateStateTx(updated: Partial<StateModel>, txOptions: TxOptions): Promise<VersionedTransaction>;
+    updateStateApplyTimelockTx(txOptions: TxOptions): Promise<VersionedTransaction>;
+    emergencyUpdateStateTx(updated: Partial<StateModel>, txOptions: TxOptions): Promise<VersionedTransaction>;
+    close(txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Create a full state model from a partial state model
      */
@@ -21,20 +23,6 @@ export declare class StateClient {
      * @param delegates Public keys of delegates to be deleted
      * @returns
      */
-    deleteDelegateAcls(statePda: PublicKey, delegates: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    upsertDelegateAcls(glamState: PublicKey, delegateAcls: DelegateAcl[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    closeTokenAccounts(glamState: PublicKey, tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Close vault's token accounts, all token accounts must use the same token program
-     */
-    closeTokenAccountIx(glamState: PublicKey, tokenAccounts: PublicKey[], tokenProgram?: PublicKey, txOptions?: TxOptions): Promise<TransactionInstruction>;
-    closeTokenAccountsTx(glamState: PublicKey, accounts: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
-    deposit(glamState: PublicKey | string, asset: PublicKey | string, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositSol(glamState: PublicKey, lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositSolTx(glamState: PublicKey, lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdraw(glamState: PublicKey, asset: PublicKey | string, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositTx(statePda: PublicKey, asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    withdrawIxs(glamState: PublicKey, asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<TransactionInstruction[]>;
-    withdrawTx(glamState: PublicKey, asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    deleteDelegateAcls(delegates: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertDelegateAcls(delegateAcls: DelegateAcl[], txOptions?: TxOptions): Promise<TransactionSignature>;
 }
-export {};

package/src/client/vault.d.ts

@@ -0,0 +1,27 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { BaseClient, TxOptions } from "./base";
+export declare class VaultClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    wrap(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    unwrap(txOptions?: TxOptions): Promise<TransactionSignature>;
+    systemTransfer(amount: BN | number, to: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    closeTokenAccounts(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    deposit(asset: PublicKey | string, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositSol(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(asset: PublicKey | string, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    wrapTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    unwrapTx(txOptions: TxOptions): Promise<VersionedTransaction>;
+    systemTransferTx(amount: BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
+    /**
+     * Returns an instruction that closes multiple vault token accounts
+     * All token accounts must be owned by the same token program
+     */
+    closeTokenAccountIx(tokenAccounts: PublicKey[], tokenProgram?: PublicKey, txOptions?: TxOptions): Promise<TransactionInstruction>;
+    closeTokenAccountsTx(accounts: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
+    depositSolTx(lamports: number | BN, wrap?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositTx(asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    withdrawIxs(asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<TransactionInstruction[]>;
+    withdrawTx(asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+}

package/src/client.d.ts

@@ -4,7 +4,7 @@ import { DriftClient } from "./client/drift";
 import { JupiterSwapClient } from "./client/jupiter";
 import { JupiterVoteClient } from "./client/jupiter";
 import { MarinadeClient } from "./client/marinade";
-import { WSolClient } from "./client/wsol";
+import { VaultClient } from "./client/vault";
 import { StakingClient } from "./client/staking";
 import { StateClient } from "./client/state";
 import { MintClient } from "./client/mint";
@@ -24,7 +24,7 @@ export declare class GlamClient extends BaseClient {
     private _jupiterSwap?;
     private _jupiterVote?;
     private _marinade?;
-    private _wsol?;
+    private _vault?;
     private _price?;
     private _staking?;
     private _state?;
@@ -38,7 +38,7 @@ export declare class GlamClient extends BaseClient {
     get jupiterSwap(): JupiterSwapClient;
     get jupiterVote(): JupiterVoteClient;
     get marinade(): MarinadeClient;
-    get wsol(): WSolClient;
+    get vault(): VaultClient;
     get staking(): StakingClient;
     get price(): PriceClient;
     get state(): StateClient;

package/src/clientConfig.d.ts

@@ -1,4 +1,5 @@
 import { Provider, Wallet } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
 export declare enum ClusterNetwork {
     Mainnet = "mainnet-beta",
     Testnet = "testnet",
@@ -9,5 +10,6 @@ export type GlamClientConfig = {
     provider?: Provider;
     wallet?: Wallet;
     cluster?: ClusterNetwork;
+    statePda?: PublicKey;
     jupiterApi?: string;
 };

package/src/constants.d.ts

@@ -9,6 +9,8 @@ export declare const STAKE_ACCOUNT_SIZE = 200;
 export declare const METEORA_POSITION_SIZE = 8120;
 export declare const KAMINO_OBTRIGATION_SIZE = 3344;
 export declare const JITO_TIP_DEFAULT: PublicKey;
+export declare const KAMINO_SCOPE_PRICES: PublicKey;
+export declare const MARINADE_NATIVE_STAKE_AUTHORITY: PublicKey;
 /**
  * Token mints. If no devnet version is defined, assume mainnet and devnet addresses are the same.
  *
@@ -16,10 +18,7 @@ export declare const JITO_TIP_DEFAULT: PublicKey;
  */
 export declare const WSOL: PublicKey;
 export declare const MSOL: PublicKey;
-export declare const JITOSOL: PublicKey;
 export declare const USDC: PublicKey;
-export declare const WETH: PublicKey;
-export declare const WBTC: PublicKey;
 export declare const JUP: PublicKey;
 /**
  * Program IDs

package/src/index.d.ts

@@ -5,6 +5,7 @@ export * from "./client";
 export * from "./client/jupiter";
 export * from "./client/drift";
 export * from "./client/base";
+export * from "./utils/glamPDAs";
 export * from "./utils/helpers";
 export * from "./utils/priorityfee";
 export * from "./utils/driftOrderParams";

package/src/models.d.ts

@@ -22,25 +22,38 @@ export declare class StateIdlModel implements StateModelType {
     uri: string | null;
     enabled: boolean | null;
     assets: PublicKey[] | null;
-    externalVaultAccounts: PublicKey[] | null;
     mints: MintModel[] | null;
     company: CompanyModel | null;
     owner: ManagerModel | null;
     created: CreatedModel | null;
+    baseAsset: PublicKey | null;
+    updateTimelock: number | null;
+    timeUnit: {
+        slot: {};
+    } | {
+        second: {};
+    } | null;
     delegateAcls: DelegateAcl[] | null;
     integrations: Integration[] | null;
+    borrowableAssets: PublicKey[] | null;
     driftMarketIndexesPerp: number[] | null;
     driftMarketIndexesSpot: number[] | null;
     driftOrderTypes: number[] | null;
-    baseAsset: PublicKey | null;
-    maxCap: BN | null;
+    kaminoLendingMarkets: PublicKey[] | null;
+    meteoraDlmmPools: PublicKey[] | null;
+    maxSwapSlippageBps: number | null;
     metadata: Metadata | null;
     rawOpenfunds: FundOpenfundsModel | null;
     constructor(data: Partial<StateModelType>);
 }
 export declare class StateModel extends StateIdlModel {
     readonly glamProgramId: PublicKey;
-    constructor(data: Partial<StateIdlModel>, glamProgramId?: PublicKey);
+    externalVaultAccounts: PublicKey[] | null;
+    pricedAssets: any[] | null;
+    ledger: LedgerEntry[] | null;
+    timelockExpiresAt: number | null;
+    pendingUpdates: any | null;
+    constructor(data: Partial<StateModel>, glamProgramId?: PublicKey);
     get idStr(): string;
     get vaultPda(): PublicKey;
     get openfundsPda(): PublicKey;
@@ -49,7 +62,7 @@ export declare class StateModel extends StateIdlModel {
     get mintAddresses(): PublicKey[];
     get sparkleKey(): string;
     /**
-     * Build a StateModel from onchain accounts
+     * Build a StateModel from onchain data
      *
      * @param stateAccount provides core fund data
      * @param openfundsMetadataAccount includes fund rawOpenfunds data and share class rawOpenfunds data
@@ -87,20 +100,27 @@ export declare class MintIdlModel implements MintModelType {
     imageUri: string | null;
     allowlist: PublicKey[] | null;
     blocklist: PublicKey[] | null;
-    lockUpPeriodInSeconds: number | null;
+    lockUpPeriod: number | null;
+    yearInSeconds: number | null;
     permanentDelegate: PublicKey | null;
     defaultAccountStateFrozen: boolean | null;
     feeStructure: FeeStructure | null;
     feeParams: FeeParams | null;
-    valuation: Valuation | null;
+    notifyAndSettle: NotifyAndSettle | null;
+    maxCap: BN | null;
     minSubscription: BN | null;
     minRedemption: BN | null;
+    subscriptionPaused: boolean | null;
+    redemptionPaused: boolean | null;
     isRawOpenfunds: boolean | null;
     rawOpenfunds: MintOpenfundsModel | null;
     constructor(data: Partial<MintModelType>);
 }
 export declare class MintModel extends MintIdlModel {
     constructor(data: Partial<MintIdlModel>);
+    /**
+     * @deprecated
+     */
     static mintAddress(statePda: PublicKey, idx?: number, glamProgramId?: PublicKey): PublicKey;
 }
 export type MintOpenfundsModelType = IdlTypes<GlamProtocol>["mintOpenfundsModel"];
@@ -177,7 +197,8 @@ export type Integration = IdlTypes<GlamProtocol>["integration"];
 export type FeeStructure = IdlTypes<GlamProtocol>["feeStructure"];
 export type FeeParams = IdlTypes<GlamProtocol>["feeParams"];
 export type AccruedFees = IdlTypes<GlamProtocol>["accruedFees"];
-export type Valuation = IdlTypes<GlamProtocol>["valuation"];
+export type NotifyAndSettle = IdlTypes<GlamProtocol>["notifyAndSettle"];
+export type LedgerEntry = IdlTypes<GlamProtocol>["ledgerEntry"];
 export declare class PriceDenom {
     static readonly SOL: {
         sol: {};
@@ -185,4 +206,22 @@ export declare class PriceDenom {
     static readonly USD: {
         usd: {};
     };
+    static readonly ASSET: {
+        asset6: {};
+    };
+    static fromAsset(asset: PublicKey): {
+        sol: {};
+    } | {
+        usd: {};
+    } | {
+        asset6: {};
+    };
+}
+export declare class TimeUnit {
+    static readonly Slot: {
+        slot: {};
+    };
+    static readonly Second: {
+        second: {};
+    };
 }

package/src/react/glam.d.ts

@@ -36,8 +36,9 @@ interface GlamProviderContext {
     driftUser: DriftUser;
     setActiveGlamState: (f: GlamStateCache) => void;
     refresh: () => Promise<void>;
+    refetchGlamStates: () => Promise<void>;
 }
-interface UserWallet {
+export interface UserWallet {
     queryKey: string[];
     pubkey?: PublicKey;
     balanceLamports: number;
@@ -49,6 +50,7 @@ export interface Vault {
     balanceLamports: number;
     uiAmount: number;
     tokenAccounts: TokenAccount[];
+    driftUser?: DriftUser;
 }
 interface GlamStateCache {
     address: string;

package/src/utils/glamPDAs.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey } from "@solana/web3.js";
+import { StateModel } from "../models";
+/**
+ * Compute state account PDA from state model
+ */
+export declare function getStatePda(stateModel: Partial<StateModel>, programId: PublicKey, owner?: PublicKey): PublicKey;
+/**
+ * Compute vault PDA from state PDA
+ */
+export declare function getVaultPda(statePda: PublicKey, programId: PublicKey): PublicKey;
+/**
+ * Compute escrow PDA from state PDA
+ */
+export declare function getEscrowPda(statePda: PublicKey, programId: PublicKey): PublicKey;
+export declare function getOpenfundsPda(statePda: PublicKey, programId: PublicKey): PublicKey;
+export declare function getMintPda(statePda: PublicKey, mintIdx: number, programId: PublicKey): PublicKey;
+export declare function getExtraMetasPda(mint: PublicKey): PublicKey;
+export declare function getAccountPolicyPda(tokenAccount: PublicKey): PublicKey;

package/src/utils/helpers.d.ts

@@ -1,9 +1,13 @@
 import { Connection, PublicKey, TransactionInstruction, AddressLookupTableAccount } from "@solana/web3.js";
+export type StakeAccountInfo = {
+    address: PublicKey;
+    lamports: number;
+    state: string;
+    voter?: PublicKey;
+};
 export declare const fetchStakeAccounts: (connection: Connection, withdrawAuthority: PublicKey) => Promise<PublicKey[]>;
-export declare const fetchMarinadeTicketAccounts: (connection: Connection, beneficiary: PublicKey) => Promise<{
-    pubkey: PublicKey;
-    account: import("@solana/web3.js").AccountInfo<Buffer | import("@solana/web3.js").ParsedAccountData>;
-}[]>;
+export declare const getStakeAccountsWithStates: (connection: Connection, withdrawAuthority: PublicKey) => Promise<StakeAccountInfo[]>;
+export declare const fetchMarinadeTicketAccounts: (connection: Connection, beneficiary: PublicKey) => Promise<import("@solana/web3.js").GetProgramAccountsResponse>;
 export declare const fetchKaminoObligations: (connection: Connection, owner: PublicKey, market?: PublicKey) => Promise<PublicKey[]>;
 export declare const fetchMeteoraPositions: (connection: Connection, owner: PublicKey) => Promise<PublicKey[]>;
 export declare const parseMeteoraPosition: (connection: Connection, position: PublicKey) => Promise<{
@@ -13,5 +17,6 @@ export declare const parseMeteoraPosition: (connection: Connection, position: Pu
     binArrayLower: PublicKey;
     binArrayUpper: PublicKey;
 }>;
+export declare function fetchLookupTables(connection: Connection, authority: PublicKey, firstEntry: PublicKey): Promise<AddressLookupTableAccount[]>;
 export declare const getSimulationComputeUnits: (connection: Connection, instructions: Array<TransactionInstruction>, payer: PublicKey, lookupTables?: Array<AddressLookupTableAccount>) => Promise<number | undefined>;
 export declare const setsAreEqual: (a: Set<any>, b: Set<any>) => boolean;