@glamsystems/glam-sdk 0.1.25 → 0.1.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "0.1.25",
+  "version": "0.1.27",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",

package/src/client/assets.d.ts

@@ -3,17 +3,19 @@ export declare const STAKE_POOLS: {
     name: string;
     symbol: string;
     mint: string;
+    decimals: number;
     logoURI: string;
-    tokenProgram: any;
-    poolState: any;
+    tokenProgram: PublicKey;
+    poolState: PublicKey;
 }[];
 export declare const STAKE_POOLS_MAP: Map<string, {
     name: string;
     symbol: string;
     mint: string;
+    decimals: number;
     logoURI: string;
-    tokenProgram: any;
-    poolState: any;
+    tokenProgram: PublicKey;
+    poolState: PublicKey;
 }>;
 /**
  * Metadata for an asset for pricing
@@ -27,3 +29,4 @@ export interface AssetMeta {
 export declare const ASSETS_MAINNET: Map<string, AssetMeta>;
 export declare const ASSETS_TESTS: Map<string, AssetMeta>;
 export declare const SOL_ORACLE: PublicKey;
+export declare const USDC_ORACLE: PublicKey;

package/src/client/base.d.ts

@@ -42,7 +42,7 @@ export declare class BaseClient {
     get detectedCluster(): ClusterNetwork;
     get statePda(): PublicKey;
     set statePda(statePda: PublicKey);
-    isMainnet(): boolean;
+    get isMainnet(): boolean;
     isPhantom(): boolean;
     /**
      * Get metadata of an asset for pricing
@@ -54,7 +54,6 @@ export declare class BaseClient {
     private getComputeBudgetIxs;
     intoVersionedTransaction(tx: Transaction, { lookupTables, signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee, jitoTipLamports, simulate, }: TxOptions): Promise<VersionedTransaction>;
     sendAndConfirm(tx: VersionedTransaction | Transaction, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
-    parseProgramLogs(logs?: null | string[]): string;
     getAdressLookupTableAccounts(keys?: string[] | PublicKey[]): Promise<AddressLookupTableAccount[]>;
     getWallet(): Wallet;
     getSigner(): PublicKey;

package/src/client/drift.d.ts

@@ -1,6 +1,7 @@
 import * as anchor from "@coral-xyz/anchor";
 import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
 import { MarketType, OrderParams, PositionDirection, SpotPosition, PerpPosition, ModifyOrderParams, OracleSource, SpotBalanceType, MarginMode, Order } from "../utils/driftTypes";
+import { DriftVault } from "../deser/driftLayouts";
 import { BaseClient, TxOptions } from "./base";
 import { AccountMeta } from "@solana/web3.js";
 import { StateModel } from "../models";
@@ -88,17 +89,17 @@ export declare class DriftClient {
         userStats: PublicKey;
     };
     get driftStatePda(): PublicKey;
-    fetchAndParseSpotMarket(marketIndex: number): Promise<SpotMarket>;
-    fetchAndParseSpotMarkets(marketIndexes: number[]): Promise<SpotMarket[]>;
-    fetchAndParsePerpMarket(marketIndex: number): Promise<PerpMarket>;
-    fetchAndParsePerpMarkets(marketIndexes: number[]): Promise<PerpMarket[]>;
-    fetchMarketConfigs(): Promise<DriftMarketConfigs>;
+    fetchAndParseSpotMarket(marketIndex: number, skipCache?: boolean): Promise<SpotMarket>;
+    fetchAndParseSpotMarkets(marketIndexes: number[], skipCache?: boolean): Promise<SpotMarket[]>;
+    fetchAndParsePerpMarket(marketIndex: number, skipCache?: boolean): Promise<PerpMarket>;
+    fetchAndParsePerpMarkets(marketIndexes: number[], skipCache?: boolean): Promise<PerpMarket[]>;
+    fetchMarketConfigs(skipCache?: boolean): Promise<DriftMarketConfigs>;
     charsToName(chars: number[] | Buffer): string;
-    fetchDriftUser(subAccountId?: number): Promise<DriftUser | null>;
+    fetchDriftUser(subAccountId?: number, skipCache?: boolean): Promise<DriftUser | null>;
     /**
      * @deprecated
      */
-    fetchPolicyConfig(glamState: StateModel): Promise<{
+    fetchPolicyConfig(stateModel: StateModel): Promise<{
         driftAccessControl: number;
         driftDelegatedAccount: anchor.web3.PublicKey;
         driftMarketIndexesPerp: number[];
@@ -129,4 +130,34 @@ export declare class DriftClient {
     cancelOrdersByIdsTx(orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     settlePnlTx(marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
+export declare class DriftVaultsClient {
+    readonly base: BaseClient;
+    readonly drift: DriftClient;
+    constructor(base: BaseClient, drift: DriftClient);
+    fetchUserPositions(user: PublicKey): Promise<{
+        perpPositions: PerpPosition[];
+        spotPositions: SpotPosition[];
+    }>;
+    getDepositorPda(driftVault: PublicKey): anchor.web3.PublicKey;
+    parseDriftVault(driftVault: PublicKey): Promise<DriftVault>;
+    composeRemainingAccounts(user: PublicKey): Promise<AccountMeta[]>;
+    parseDepositor(depositor: PublicKey, data: Buffer): {
+        address: anchor.web3.PublicKey;
+        driftVault: anchor.web3.PublicKey;
+        shares: any;
+    };
+    /**
+     * Finds all drift vault depositors
+     */
+    findAndParseVaultDepositors(authority?: PublicKey): Promise<{
+        address: anchor.web3.PublicKey;
+        driftVault: anchor.web3.PublicKey;
+        shares: any;
+    }[]>;
+    initializeVaultDepositor(driftVault: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deposit(driftVault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    requestWithdraw(driftVault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelWithdrawRequest(driftVault: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(driftVault: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+}
 export {};

package/src/client/kamino.d.ts

@@ -1,8 +1,10 @@
 import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction, AccountMeta } from "@solana/web3.js";
 import { BaseClient, TxOptions } from "./base";
+import { KVaultAllocation, KVaultState } from "../deser/kaminoLayouts";
 interface ParsedReserve {
     address: PublicKey;
+    market: PublicKey;
     farmCollateral: PublicKey | null;
     farmDebt: PublicKey | null;
     liquidityMint: PublicKey;
@@ -81,7 +83,6 @@ export declare class KaminoLendingClient {
         id: number;
     }): PublicKey;
     getObligationFarmState(obligation: PublicKey, farm: PublicKey): PublicKey;
-    initUserMetadataTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
     refreshReserveIxs(lendingMarket: PublicKey, reserves: PublicKey[]): TransactionInstruction[];
     refreshObligationCollateralFarmsForReservesIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
     refreshObligationDebtFarmsForReservesIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
@@ -92,25 +93,20 @@ export declare class KaminoLendingClient {
         collateralSupplyVault: PublicKey;
         feeVault: PublicKey;
     };
+    parseObligation(obligation: PublicKey, data: Buffer): ParsedObligation;
     /**
-     * Fetches and parses obligation account
-     *
-     * @param obligation User obligation pubkey
-     * @returns Pubkeys of reserves for deposits and borrows
+     * Fetches and parses an obligation account
      */
     fetchAndParseObligation(obligation: PublicKey): Promise<ParsedObligation>;
     pubkeyArraysEqual: (a: PublicKey[], b: PublicKey[]) => boolean;
-    _parseReserveAccount(data: Buffer): {
-        liquiditySupplyVault: PublicKey;
-        collateralMint: PublicKey;
-        collateralSupplyVault: PublicKey;
-        feeVault: PublicKey;
-        farmCollateral: PublicKey;
-        farmDebt: PublicKey;
-        liquidityMint: PublicKey;
-    };
+    parseReserveAccount(reserve: PublicKey, data: Buffer): ParsedReserve;
     fetchAndParseReserves(reserves: PublicKey[]): Promise<ParsedReserve[]>;
     findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<ParsedReserve>;
+    /**
+     * Finds and parses Kamino obligations for a given owner and market (optional)
+     */
+    findAndParseObligations(owner: PublicKey, market?: PublicKey): Promise<ParsedObligation[]>;
+    initUserMetadataTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
     depositTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
     withdrawTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
     borrowTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
@@ -139,4 +135,19 @@ export declare class KaminoFarmClient {
     harvest(txOptions?: TxOptions): Promise<TransactionSignature>;
     harvestTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
+export declare class KaminoVaultsClient {
+    readonly base: BaseClient;
+    readonly kaminoLending: KaminoLendingClient;
+    private vaultStates;
+    private shareMintToVaultPdaMap;
+    constructor(base: BaseClient, kaminoLending: KaminoLendingClient);
+    deposit(vault: PublicKey, amount: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(vault: PublicKey, amount: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    findAndParseKaminoVaults(): Promise<KVaultState[]>;
+    getVaultPdasByShareMints(mints: PublicKey[]): Promise<PublicKey[]>;
+    fetchAndParseVaultState(vault: PublicKey): Promise<KVaultState>;
+    composeRemainingAccounts(allocationStrategies: KVaultAllocation[]): Promise<AccountMeta[]>;
+    depositTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawTx(vault: PublicKey, amount: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
 export {};

package/src/client/marinade.d.ts

@@ -16,11 +16,7 @@ export declare class MarinadeClient {
     deposit(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
     depositNative(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
     depositStakeAccount(stakeAccount: PublicKey): Promise<TransactionSignature>;
-    withdrawStakeAccount(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    orderUnstake(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    claim(tickets: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    getTickets(): Promise<PublicKey[]>;
-    getParsedTickets(): Promise<Ticket[]>;
+    withdrawStakeAccount(amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * @deprecated Use Marinade.getMarinadeState() instead
      */
@@ -45,7 +41,5 @@ export declare class MarinadeClient {
         stakeIndex: number;
         validatorIndex: number;
     }>;
-    withdrawStakeAccountTx(amount: BN, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
-    orderUnstakeTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    claimTx(tickets: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
+    withdrawStakeAccountTx(amount: BN, deactivate: boolean, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
 }

package/src/client/price.d.ts

@@ -1,20 +1,51 @@
 import { PublicKey, TransactionInstruction } from "@solana/web3.js";
-import { KaminoLendingClient } from "./kamino";
+import { KaminoLendingClient, KaminoVaultsClient } from "./kamino";
 import { BaseClient } from "./base";
 import { PriceDenom } from "../models";
-import { DriftClient } from "./drift";
+import { DriftClient, DriftVaultsClient } from "./drift";
 export declare class PriceClient {
     readonly base: BaseClient;
     readonly klend: KaminoLendingClient;
+    readonly kvaults: KaminoVaultsClient;
     readonly drift: DriftClient;
-    constructor(base: BaseClient, klend: KaminoLendingClient, drift: DriftClient);
+    readonly dvaults: DriftVaultsClient;
+    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftClient, dvaults: DriftVaultsClient);
     /**
      * !! 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(): Promise<BN>;
-    priceKaminoIx(priceDenom: PriceDenom): Promise<TransactionInstruction>;
+    /**
+     * Returns an instruction that prices Kamino obligations.
+     * If there are no Kamino obligations, returns null.
+     */
+    priceKaminoObligationsIx(priceDenom: PriceDenom): Promise<TransactionInstruction | null>;
+    priceKaminoVaultSharesIx(priceDenom: PriceDenom): Promise<TransactionInstruction | null>;
+    /**
+     * Returns an instruction that prices the all Drift users (aka sub-accounts) controlled by the GLAM vault.
+     * These Drift users must share the same user_stats that's also controlled by the GLAM vault.
+     */
+    priceDriftUsersIx(priceDenom: PriceDenom): Promise<TransactionInstruction | null>;
+    /**
+     * Returns an instruction that prices a drift vault depositor.
+     * If there are no vault depositor accounts, returns null.
+     */
+    priceDriftVaultDepositorsIx(priceDenom: PriceDenom): Promise<TransactionInstruction | null>;
+    /**
+     * Returns an instruction that prices vault balance and tokens the vault holds
+     */
+    priceVaultIx(priceDenom: PriceDenom): Promise<TransactionInstruction>;
+    /**
+     * Returns an instruction that prices stake accounts.
+     * If there are no stake accounts, returns null.
+     */
+    priceStakesIx(priceDenom: PriceDenom): Promise<TransactionInstruction | null>;
+    /**
+     * Returns an instruction that prices Meteora positions.
+     * If there are no Meteora positions, returns null.
+     */
+    priceMeteoraPositionsIx(priceDenom: PriceDenom): Promise<TransactionInstruction | null>;
     priceVaultIxs(priceDenom: PriceDenom): Promise<TransactionInstruction[]>;
     remainingAccountsForPricingMeteora: () => Promise<{
         pubkey: PublicKey;

package/src/client/staking.d.ts

@@ -17,10 +17,10 @@ export declare class StakingClient {
     readonly base: BaseClient;
     readonly marinade: MarinadeClient;
     constructor(base: BaseClient, marinade: MarinadeClient);
-    unstake(asset: PublicKey, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    unstake(asset: PublicKey, amount: number | BN, deactivate?: boolean, 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>;
+    stakePoolWithdrawStake(stakePool: PublicKey, amount: BN, deactivate?: boolean, 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>;

package/src/client/state.d.ts

@@ -11,6 +11,7 @@ export declare class StateClient {
     updateStateTx(updated: Partial<StateModel>, txOptions: TxOptions): Promise<VersionedTransaction>;
     updateStateApplyTimelockTx(txOptions: TxOptions): Promise<VersionedTransaction>;
     emergencyUpdateStateTx(updated: Partial<StateModel>, txOptions: TxOptions): Promise<VersionedTransaction>;
+    extend(newBytes: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     close(txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Create a full state model from a partial state model

package/src/client/vault.d.ts

@@ -22,6 +22,6 @@ export declare class VaultClient {
     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[]>;
+    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

@@ -1,6 +1,6 @@
 import { GlamClientConfig } from "./clientConfig";
 import { BaseClient } from "./client/base";
-import { DriftClient } from "./client/drift";
+import { DriftClient, DriftVaultsClient } from "./client/drift";
 import { JupiterSwapClient } from "./client/jupiter";
 import { JupiterVoteClient } from "./client/jupiter";
 import { MarinadeClient } from "./client/marinade";
@@ -8,7 +8,7 @@ import { VaultClient } from "./client/vault";
 import { StakingClient } from "./client/staking";
 import { StateClient } from "./client/state";
 import { MintClient } from "./client/mint";
-import { KaminoFarmClient, KaminoLendingClient } from "./client/kamino";
+import { KaminoFarmClient, KaminoLendingClient, KaminoVaultsClient } from "./client/kamino";
 import { MeteoraDlmmClient } from "./client/meteora";
 import { InvestorClient } from "./client/investor";
 import { PriceClient } from "./client/price";
@@ -20,6 +20,7 @@ export { JUPITER_API_DEFAULT } from "./client/base";
  */
 export declare class GlamClient extends BaseClient {
     private _drift?;
+    private _driftVaults?;
     private _investor?;
     private _jupiterSwap?;
     private _jupiterVote?;
@@ -31,9 +32,11 @@ export declare class GlamClient extends BaseClient {
     private _mint?;
     private _kaminoLending?;
     private _kaminoFarm?;
+    private _kaminoVaults?;
     private _meteoraDlmm?;
     constructor(config?: GlamClientConfig);
     get drift(): DriftClient;
+    get driftVaults(): DriftVaultsClient;
     get investor(): InvestorClient;
     get jupiterSwap(): JupiterSwapClient;
     get jupiterVote(): JupiterVoteClient;
@@ -45,5 +48,6 @@ export declare class GlamClient extends BaseClient {
     get mint(): MintClient;
     get kaminoLending(): KaminoLendingClient;
     get kaminoFarm(): KaminoFarmClient;
+    get kaminoVaults(): KaminoVaultsClient;
     get meteoraDlmm(): MeteoraDlmmClient;
 }

package/src/constants.d.ts

@@ -4,10 +4,10 @@ export declare const SEED_MINT: string;
 export declare const SEED_STATE: string;
 export declare const SEED_VAULT: string;
 export declare const SEED_ESCROW: string;
-export declare const MARINADE_TICKET_SIZE = 88;
 export declare const STAKE_ACCOUNT_SIZE = 200;
 export declare const METEORA_POSITION_SIZE = 8120;
 export declare const KAMINO_OBTRIGATION_SIZE = 3344;
+export declare const DRIFT_VAULT_DEPOSITOR_SIZE = 272;
 export declare const JITO_TIP_DEFAULT: PublicKey;
 export declare const KAMINO_SCOPE_PRICES: PublicKey;
 export declare const MARINADE_NATIVE_STAKE_AUTHORITY: PublicKey;
@@ -25,6 +25,7 @@ export declare const JUP: PublicKey;
  */
 export declare const MARINADE_PROGRAM_ID: PublicKey;
 export declare const DRIFT_PROGRAM_ID: PublicKey;
+export declare const DRIFT_VAULTS_PROGRAM_ID: PublicKey;
 export declare const JUPITER_PROGRAM_ID: PublicKey;
 export declare const SANCTUM_STAKE_POOL_PROGRAM_ID: PublicKey;
 export declare const GOVERNANCE_PROGRAM_ID: PublicKey;
@@ -33,6 +34,7 @@ export declare const MERKLE_DISTRIBUTOR_PROGRAM: PublicKey;
 export declare const TRANSFER_HOOK_PROGRAM: PublicKey;
 export declare const METEORA_DLMM_PROGRAM: PublicKey;
 export declare const KAMINO_LENDING_PROGRAM: PublicKey;
+export declare const KAMINO_VAULTS_PROGRAM: PublicKey;
 export declare const KAMINO_FARM_PROGRAM: PublicKey;
 export declare const MEMO_PROGRAM: PublicKey;
 /**

package/src/deser/driftLayouts.d.ts

@@ -0,0 +1,68 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+export declare const DriftVaultLayout: any;
+export interface DriftVault {
+    discriminator: number[];
+    name: number[];
+    pubkey: PublicKey;
+    manager: PublicKey;
+    tokenAccount: PublicKey;
+    userStats: PublicKey;
+    user: PublicKey;
+    delegate: PublicKey;
+    liquidationDelegate: PublicKey;
+    userShares: BN;
+    totalShares: BN;
+    lastFeeUpdateTs: BN;
+    liquidationStartTs: BN;
+    redeemPeriod: BN;
+    totalWithdrawRequested: BN;
+    maxTokens: BN;
+    managementFee: BN;
+    initTs: BN;
+    netDeposits: BN;
+    managerNetDeposits: BN;
+    totalDeposits: BN;
+    totalWithdraws: BN;
+    managerTotalDeposits: BN;
+    managerTotalWithdraws: BN;
+    managerTotalFee: BN;
+    managerTotalProfitShare: BN;
+    minDepositAmount: BN;
+    lastManagerWithdrawRequest: {
+        shares: BN;
+        amount: BN;
+        ts: BN;
+    };
+    sharesBase: number;
+    profitShare: number;
+    hurdleRate: number;
+    spotMarketIndex: number;
+    bump: number;
+    permissioned: boolean;
+    vaultProtocol: boolean;
+    fuelDistributionMode: number;
+    feeUpdateStatus: number;
+    padding1: number;
+    lastCumulativeFuelPerShareTs: number;
+    cumulativeFuelPerShare: BN;
+    cumulativeFuel: BN;
+    padding: BN[];
+}
+export declare const DriftSpotMarket: any;
+export interface DriftSpotMarket {
+    discriminator: number[];
+    marketPda: PublicKey;
+    oracle: PublicKey;
+    mint: PublicKey;
+    vault: PublicKey;
+    name: number[];
+    padding1: number[];
+    cumulativeDepositInterest: BN;
+    cumulativeBorrowInterest: BN;
+    padding2: number[];
+    decimals: number;
+    marketIndex: number;
+    padding3: number;
+    oracleSource: number;
+}

package/src/deser/kaminoLayouts.d.ts

@@ -0,0 +1,55 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+export declare const VaultAllocationLayout: any;
+export declare const KVaultStateLayout: any;
+export interface KVaultAllocation {
+    reserve: PublicKey;
+    ctokenVault: PublicKey;
+    targetAllocationWeight: BN;
+    tokenAllocationCap: BN;
+    ctokenVaultBump: BN;
+    configPadding: BN[];
+    ctokenAllocation: BN;
+    lastInvestSlot: BN;
+    tokenTargetAllocationSf: BN;
+    statePadding: BN[];
+}
+export interface KVaultState {
+    discriminator: number[];
+    vaultAdminAuthority: PublicKey;
+    baseVaultAuthority: PublicKey;
+    baseVaultAuthorityBump: BN;
+    tokenMint: PublicKey;
+    tokenMintDecimals: BN;
+    tokenVault: PublicKey;
+    tokenProgram: PublicKey;
+    sharesMint: PublicKey;
+    sharesMintDecimals: BN;
+    tokenAvailable: BN;
+    sharesIssued: BN;
+    availableCrankFunds: BN;
+    padding0: BN;
+    performanceFeeBps: BN;
+    managementFeeBps: BN;
+    lastFeeChargeTimestamp: BN;
+    prevAumSf: BN;
+    pendingFeesSf: BN;
+    vaultAllocationStrategy: KVaultAllocation[];
+    padding1: BN[];
+    minDepositAmount: BN;
+    minWithdrawAmount: BN;
+    minInvestAmount: BN;
+    minInvestDelaySlots: BN;
+    crankFundFeePerReserve: BN;
+    pendingAdmin: PublicKey;
+    cumulativeEarnedInterestSf: BN;
+    cumulativeMgmtFeesSf: BN;
+    cumulativePerfFeesSf: BN;
+    name: number[];
+    vaultLookupTable: PublicKey;
+    vaultFarm: PublicKey;
+    creationTimestamp: BN;
+    padding2: BN;
+    allocationAdmin: PublicKey;
+    padding3: BN[];
+}

package/src/utils/driftTypes.d.ts

@@ -210,6 +210,7 @@ export declare class OracleSource {
     static readonly PYTH_LAZER_STABLE_COIN: {
         pythLazerStableCoin: {};
     };
+    static fromString(name: string): OracleSource;
     static get(n: Number): any;
 }
 export declare class OracleSourceNum {

package/src/utils/helpers.d.ts

@@ -5,10 +5,8 @@ export type StakeAccountInfo = {
     state: string;
     voter?: PublicKey;
 };
-export declare const fetchStakeAccounts: (connection: Connection, withdrawAuthority: PublicKey) => Promise<PublicKey[]>;
+export declare const findStakeAccounts: (connection: Connection, withdrawAuthority: PublicKey) => Promise<PublicKey[]>;
 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<{
     lbPair: PublicKey;
@@ -18,5 +16,9 @@ export declare const parseMeteoraPosition: (connection: Connection, position: Pu
     binArrayUpper: PublicKey;
 }>;
 export declare function fetchLookupTables(connection: Connection, authority: PublicKey, firstEntry: PublicKey): Promise<AddressLookupTableAccount[]>;
+/**
+ * Parses program logs to extract error message
+ */
+export declare function parseProgramLogs(logs?: null | string[]): string;
 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;