@glamsystems/glam-sdk 1.0.2 → 1.0.3-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "1.0.2",
+  "version": "1.0.3-alpha.0",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
@@ -20,15 +20,16 @@
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.1",
     "@coral-xyz/borsh": "^0.31.1",
+    "@glamsystems/sanctum-lst-list": "^0.2.54",
     "@marinade.finance/marinade-ts-sdk": "^5.0.15",
     "@meteora-ag/dlmm": "^1.4.11",
     "@solana/spl-stake-pool": "^1.1.5",
     "@solana/spl-token": "^0.4.9",
     "@solana/spl-token-metadata": "^0.1.4",
     "@solana/web3.js": "^1.98.0",
-    "@glamsystems/sanctum-lst-list": "^0.2.54",
     "bs58": "^5.0.0",
-    "buffer": "^6.0.3"
+    "buffer": "^6.0.3",
+    "decimal.js": "^10.6.0"
   },
   "engines": {
     "node": ">=20.18.0"

package/src/client/cctp.d.ts

@@ -0,0 +1,45 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, Keypair } from "@solana/web3.js";
+import { BaseClient, TxOptions } from "./base";
+export declare class CctpClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    /**
+     * Bridge USDC to another chain using Circle's CCTP protocol
+     *
+     * @param amount Amount of USDC to bridge (in smallest units)
+     * @param domain Destination domain (e.g., 0 for Ethereum, 1 for Avalanche)
+     * @param recipient Recipient address on destination chain
+     * @param params Additional parameters (maxFee, minFinalityThreshold)
+     * @param txOptions Transaction options
+     */
+    bridgeUsdc(amount: BN | number, domain: number, recipient: PublicKey, params: {
+        maxFee: BN;
+        minFinalityThreshold: number;
+    }, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Create transaction for bridging USDC to another chain
+     *
+     * @param amount Amount of USDC to bridge (in smallest units)
+     * @param domain Destination domain
+     * @param recipient Recipient address on destination chain
+     * @param params Additional parameters
+     * @param txOptions Transaction options
+     * @returns Tuple of [transaction, message event keypair]
+     */
+    bridgeUsdcTx(amount: BN, domain: number, recipient: PublicKey, params: {
+        maxFee: BN;
+        minFinalityThreshold: number;
+    }, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
+    /**
+     * Get all PDAs required for CCTP deposit for burn operation
+     *
+     * @param messageTransmitterProgram Message transmitter program ID
+     * @param tokenMessengerMinterProgram Token messenger minter program ID
+     * @param usdcAddress USDC mint address
+     * @param destinationDomain Destination domain
+     * @returns Object containing all required PDAs
+     */
+    private getDepositForBurnPdas;
+    findV2Messages(sender: PublicKey): Promise<PublicKey[]>;
+}

package/src/client/drift.d.ts

@@ -81,12 +81,13 @@ export declare class DriftClient {
         user: PublicKey;
         userStats: PublicKey;
     };
-    parsePerpMarket(data: Buffer): PerpMarket;
-    parseSpotMarket(data: Buffer): SpotMarket;
-    calcSpotBalance(marketIndex: number, scaledBalance: BN, scaledBalanceType: SpotBalanceType): Promise<{
+    parsePerpMarket(address: PublicKey, data: Buffer): PerpMarket;
+    parseSpotMarket(address: PublicKey, data: Buffer): SpotMarket;
+    calcSpotBalance(scaledBalance: BN, scaledBalanceType: SpotBalanceType, decimals: number, cumulativeDepositInterest: BN, cumulativeBorrowInterest: BN): {
         amount: number;
         uiAmount: number;
-    }>;
+    };
+    calcSpotBalanceBn(scaledBalance: BN, decimals: number, interest: BN): BN;
     getDriftUserPdas(subAccountId?: number): {
         user: PublicKey;
         userStats: PublicKey;

package/src/client/jupiter.d.ts

@@ -37,6 +37,7 @@ export type TokenListItem = {
     decimals: number;
     logoURI: string;
     tags: string[];
+    usdPrice: number;
 };
 export type TokenPrice = {
     mint: string;

package/src/client/kamino.d.ts

@@ -3,6 +3,8 @@ import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstr
 import { BaseClient, TxOptions } from "./base";
 import { KVaultAllocation, KVaultState } from "../deser/kaminoLayouts";
 import { VaultClient } from "./vault";
+import Decimal from "decimal.js";
+import { BigFractionBytes } from "../utils";
 interface RefreshObligationAccounts {
     lendingMarket: PublicKey;
     obligation: PublicKey;
@@ -33,27 +35,55 @@ interface RefreshObligationFarmsForReserveAccounts {
     rent: PublicKey;
     systemProgram: PublicKey;
 }
-interface ParsedReserve {
+export interface ParsedReserve {
     address: PublicKey;
     market: PublicKey;
     farmCollateral: PublicKey | null;
     farmDebt: PublicKey | null;
     liquidityMint: PublicKey;
+    liquidityMintDecimals: number;
     liquiditySupplyVault: PublicKey;
     collateralMint: PublicKey;
     collateralSupplyVault: PublicKey;
+    scopePriceFeed: PublicKey;
     feeVault: PublicKey;
+    collateralExchangeRate: Decimal;
+    cumulativeBorrowRate: Decimal;
 }
-interface ParsedObligation {
+export interface ParsedObligation {
     address: PublicKey;
-    lendingMarket: PublicKey | null;
+    lendingMarket: PublicKey;
     deposits: {
         reserve: PublicKey;
+        depositedAmount: BN;
+        marketValueSf: BN;
     }[];
     borrows: {
         reserve: PublicKey;
+        borrowedAmountSf: BN;
+        marketValueSf: BN;
+        cumulativeBorrowRateBsf: BigFractionBytes;
+    }[];
+}
+interface ParsedFarmState {
+    globalConfig: PublicKey;
+    farmTokenMint: PublicKey;
+    farmTokenDecimals: BN;
+    farmTokenProgram: PublicKey;
+    farmVault: PublicKey;
+    rewards: {
+        index: number;
+        mint: PublicKey;
+        minClaimDurationSeconds: BN;
+        tokenProgram: PublicKey;
+        rewardsVault: PublicKey;
     }[];
 }
+interface ParsedFarmUser {
+    pubkey: PublicKey;
+    farmState: PublicKey;
+    unclaimedRewards: BN[];
+}
 export declare class KaminoLendingClient {
     readonly base: BaseClient;
     readonly vault: VaultClient;
@@ -114,12 +144,14 @@ export declare class KaminoLendingClient {
         tag: number;
         id: number;
     }): PublicKey;
-    getObligationFarmState(obligation: PublicKey, farm: PublicKey): PublicKey;
+    getFarmUserState(farmUser: PublicKey, farm: PublicKey): PublicKey;
     refreshObligationIx(accounts: RefreshObligationAccounts, programId?: PublicKey): TransactionInstruction;
     refreshReserveIx(accounts: RefreshReserveAccounts, programId?: PublicKey): TransactionInstruction;
     refreshObligationFarmsForReserveIx(args: RefreshObligationFarmsForReserveArgs, accounts: RefreshObligationFarmsForReserveAccounts, programId?: PublicKey): TransactionInstruction;
     refreshReservesBatchIx(reserves: PublicKey[], lendingMarkets: PublicKey[], skipPriceUpdates: boolean, programId?: PublicKey): TransactionInstruction;
+    refreshReservesBatchIxV2(reserves: ParsedReserve[], skipPriceUpdates: boolean, programId?: PublicKey): TransactionInstruction;
     refreshReserveIxs(lendingMarket: PublicKey, reserves: PublicKey[]): TransactionInstruction[];
+    refreshReserveIxsV2(lendingMarket: PublicKey, reserves: ParsedReserve[]): TransactionInstruction[];
     refreshObligationCollateralFarmsForReservesIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
     refreshObligationDebtFarmsForReservesIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
     getMarketAuthority(market: PublicKey): PublicKey;
@@ -134,9 +166,15 @@ export declare class KaminoLendingClient {
      * Fetches and parses an obligation account
      */
     fetchAndParseObligation(obligation: PublicKey): Promise<ParsedObligation>;
-    pubkeyArraysEqual: (a: PublicKey[], b: PublicKey[]) => boolean;
-    parseReserveAccount(reserve: PublicKey, data: Buffer): ParsedReserve;
+    parseReserveAccount(pubkey: PublicKey, data: Buffer): ParsedReserve;
     fetchAndParseReserves(reserves: PublicKey[]): Promise<ParsedReserve[]>;
+    /**
+     * Finds and parses a reserve account for a given market and asset
+     *
+     * @param market The lending market public key
+     * @param asset The asset public key
+     * @returns The parsed reserve account
+     */
     findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<ParsedReserve>;
     /**
      * Finds and parses Kamino obligations for a given owner and market (optional)
@@ -150,28 +188,15 @@ export declare class KaminoLendingClient {
 }
 export declare class KaminoFarmClient {
     readonly base: BaseClient;
-    constructor(base: BaseClient);
+    readonly kaminoLending: KaminoLendingClient;
+    constructor(base: BaseClient, kaminoLending: KaminoLendingClient);
     /**
      * Finds and parses farm states for the given owner
-     * @param owner
-     * @returns
      */
-    findAndParseStates(owner: PublicKey): Promise<{
-        userState: PublicKey;
-        farmState: PublicKey;
-        unclaimedRewards: BN[];
-    }[]>;
-    parseFarm(data: Buffer): Promise<{
-        globalConfig: PublicKey;
-        rewards: {
-            index: number;
-            mint: PublicKey;
-            minClaimDurationSeconds: any;
-            tokenProgram: PublicKey;
-            rewardsVault: PublicKey;
-        }[];
-    }>;
-    fetchAndParseFarms(farms: PublicKey[]): Promise<Map<any, any>>;
+    findAndParseFarmUserStates(owner: PublicKey): Promise<ParsedFarmUser[]>;
+    parseFarmState(data: Buffer): Promise<ParsedFarmState>;
+    fetchAndParseFarmStates(farms: PublicKey[]): Promise<Map<string, ParsedFarmState>>;
+    farmVaultTokenAccount: (farm: PublicKey, mint: PublicKey) => PublicKey;
     farmVaultsAuthority: (farm: PublicKey) => PublicKey;
     rewardsTreasuryVault: (globalConfig: PublicKey, mint: PublicKey) => PublicKey;
     /**
@@ -180,7 +205,15 @@ export declare class KaminoFarmClient {
      * @param vaultFarmStates GLAM vault's farm states to harvest rewards from
      */
     harvest(vaultFarmStates: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    harvestTx(vaultFarmStates: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    stake(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    unstake(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * farmState.isFarmDelegated = 0
+     * farmState.token.mint !== PublicKey.default
+     */
+    stakeTx(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    unstakeTx(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    harvestTx(farmUesrStates: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class KaminoVaultsClient {
     readonly base: BaseClient;

package/src/client/mint.d.ts

@@ -69,7 +69,7 @@ declare class MintTxBuilder extends BaseTxBuilder {
     forceTransfer(from: PublicKey, to: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 declare class TxBuilder extends BaseTxBuilder {
-    initialize(initMintParams: InitMintParams, stateParams?: UpdateStateParams, txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
+    initialize(initMintParams: InitMintParams, stateParams: UpdateStateParams | null, txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
     update(mintModel: Partial<MintIdlModel>, txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
     pauseSubscription(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;
     unpauseSubscription(txOptions?: TxOptions): Promise<anchor.web3.VersionedTransaction>;

package/src/client/price.d.ts

@@ -1,23 +1,66 @@
-import { AccountMeta, PublicKey, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
-import { KaminoLendingClient, KaminoVaultsClient } from "./kamino";
-import { BaseClient, TxOptions } from "./base";
+import { AccountMeta, Commitment, PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+import { KaminoLendingClient, KaminoVaultsClient, ParsedReserve } from "./kamino";
+import { BaseClient } from "./base";
 import { StateModel } from "../models";
-import { DriftClient, DriftVaultsClient } from "./drift";
+import { DriftClient, DriftVaultsClient, SpotMarket } from "./drift";
+import { PkMap, PkSet } from "../utils";
+import { CctpClient } from "./cctp";
+import { TokenListItem } from "./jupiter";
+export declare abstract class Holding {
+    mintAddress: PublicKey;
+    decimals: number;
+    amount: BN;
+    uiAmount: number;
+    price: number;
+    protocol: string;
+}
+export declare class KaminoLendHolding extends Holding {
+    obligation: PublicKey;
+    market: PublicKey;
+    reserve: PublicKey;
+    direction: "deposit" | "borrow";
+}
+export declare class DriftSpotHolding extends Holding {
+    user: PublicKey;
+    marketIndex: number;
+    direction: "deposit" | "borrow";
+}
+export declare class OutgoingBridgeHolding extends Holding {
+    destinationDomain: number;
+    destinationAddress: PublicKey;
+    status: string;
+    delayReason: string | null;
+    attestation: string;
+}
+export declare class TokenHolding extends Holding {
+    tokenAccount: PublicKey;
+}
+export declare class VaultHoldings {
+    readonly vaultState: PublicKey;
+    readonly slot: BN;
+    holdings: Holding[];
+    constructor(vaultState: PublicKey, slot: BN);
+    add(holding: Holding): void;
+}
 export declare class PriceClient {
     readonly base: BaseClient;
     readonly klend: KaminoLendingClient;
     readonly kvaults: KaminoVaultsClient;
     readonly drift: DriftClient;
     readonly dvaults: DriftVaultsClient;
+    readonly cctp: CctpClient;
     private _stateModel;
     private _lookupTables;
     private _kaminoVaults;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftClient, dvaults: DriftVaultsClient);
+    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftClient, dvaults: DriftVaultsClient, cctp: CctpClient);
     get cachedStateModel(): StateModel | null;
     set cachedStateModel(stateModel: StateModel);
     get lookupTables(): PublicKey[];
     get kaminoVaults(): PublicKey[];
     /**
+     * @deprecated
+     *
      * Calculates the Assets Under Management (AUM) based on cached pricing data.
      *
      * @warning This is a convenience method for testing purposes only and should NOT be used in production.
@@ -31,14 +74,25 @@ export declare class PriceClient {
      */
     getAum(): Promise<BN>;
     /**
-     * Resets the priced protocols data stored in glam state account.
+     * Fetches all holdings in the vault.
+     *
+     * @param commitment Commitment level for fetching accounts
+     * @param priceBaseAssetMint Price denominator asset mint (USDC, SOL, JLP etc.)
+     * @returns VaultHoldings object containing all holdings
      */
-    resetPricedProtocols(txOptions?: TxOptions): Promise<TransactionSignature>;
+    getVaultHoldings(commitment: Commitment, priceBaseAssetMint?: PublicKey): Promise<VaultHoldings>;
+    getPubkeysForTokenHoldings(commitment?: Commitment): Promise<PublicKey[]>;
+    getPubkeysForSpotHoldings(commitment?: Commitment): Promise<PkMap<PkSet>>;
+    getPubkeysForKaminoHoldings(commitment?: Commitment): Promise<PkMap<PkSet>>;
+    getTokenHoldings(tokenAccountPubkeys: PublicKey[], accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>): TokenHolding[];
+    getDriftSpotHoldings(userPubkeys: Iterable<PublicKey>, spotMarketsMap: PkMap<SpotMarket>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>): DriftSpotHolding[];
+    getKaminoLendHoldings(obligationPubkeys: Iterable<PublicKey>, reservesMap: PkMap<ParsedReserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>): KaminoLendHolding[];
+    getOutgoingBridgeHoldings(messagePubkeys: PublicKey[], tokenPricesMap: PkMap<TokenListItem>): Promise<OutgoingBridgeHolding[]>;
     /**
      * Returns an instruction that prices Kamino obligations.
      * If there are no Kamino obligations, returns null.
      */
-    priceKaminoObligationsIx(): Promise<TransactionInstruction | null>;
+    priceKaminoObligationsIxs(): Promise<TransactionInstruction[]>;
     priceKaminoVaultSharesIx(): Promise<TransactionInstruction[] | null>;
     /**
      * Returns an instruction that prices all Drift users (aka sub-accounts) controlled by the GLAM vault.
@@ -62,6 +116,7 @@ export declare class PriceClient {
      * If there are no Meteora positions, returns null.
      */
     priceVaultIxs(): Promise<TransactionInstruction[]>;
+    validateAumIx(): Promise<TransactionInstruction>;
     getbaseAssetOracle(): Promise<PublicKey>;
     remainingAccountsForPricingDriftVaultDepositors(parsedVaultDepositors: {
         address: PublicKey;

package/src/client/vault.d.ts

@@ -1,5 +1,5 @@
 import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction, Keypair } from "@solana/web3.js";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
 import { BaseClient, TxOptions } from "./base";
 export declare class VaultClient {
     readonly base: BaseClient;
@@ -17,10 +17,6 @@ export declare class VaultClient {
      * @param txOptions
      */
     unwrap(txOptions?: TxOptions): Promise<TransactionSignature>;
-    bridgeUsdc(amount: BN | number, domain: number, recipient: PublicKey, params: {
-        maxFee: BN;
-        minFinalityThreshold: number;
-    }, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Transfers SOL from vault to another account
      *
@@ -77,19 +73,6 @@ export declare class VaultClient {
     closeTokenAccountsTx(pubkeys: 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>;
-    getDepositForBurnPdas: (messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, usdcAddress: PublicKey, destinationDomain: Number) => {
-        messageTransmitterAccount: PublicKey;
-        tokenMessengerAccount: PublicKey;
-        tokenMinterAccount: PublicKey;
-        localToken: PublicKey;
-        remoteTokenMessengerKey: PublicKey;
-        authorityPda: PublicKey;
-        tokenMessengerEventAuthority: PublicKey;
-    };
     tokenTransferIxs(mint: PublicKey, amount: number | BN, to: PublicKey, txOptions?: TxOptions): Promise<TransactionInstruction[]>;
     tokenTransferTx(mint: PublicKey, amount: number | BN, to: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
-    bridgeUsdcTx(amount: BN, domain: number, recipient: PublicKey, params: {
-        maxFee: BN;
-        minFinalityThreshold: number;
-    }, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
 }

package/src/client.d.ts

@@ -4,7 +4,6 @@ import { DriftClient, DriftVaultsClient } from "./client/drift";
 import { JupiterSwapClient } from "./client/jupiter";
 import { MarinadeClient } from "./client/marinade";
 import { VaultClient } from "./client/vault";
-import { StakingClient } from "./client/staking";
 import { StateClient } from "./client/state";
 import { KaminoLendingClient, KaminoFarmClient, KaminoVaultsClient } from "./client/kamino";
 import { InvestClient } from "./client/invest";
@@ -13,6 +12,8 @@ import { FeesClient } from "./client/fees";
 import { MintClient } from "./client/mint";
 import { AccessClient } from "./client/access";
 import { TimelockClient } from "./client/timelock";
+import { StakingClient } from "./client/staking";
+import { CctpClient } from "./client/cctp";
 /**
  * Main entrypoint for the GLAM SDK
  *
@@ -35,6 +36,7 @@ export declare class GlamClient extends BaseClient {
     private _kaminoVaults?;
     private _fees?;
     private _timelock?;
+    private _cctp?;
     constructor(config?: GlamClientConfig);
     get drift(): DriftClient;
     get driftVaults(): DriftVaultsClient;
@@ -52,4 +54,5 @@ export declare class GlamClient extends BaseClient {
     get kaminoFarm(): KaminoFarmClient;
     get kaminoVaults(): KaminoVaultsClient;
     get timelock(): TimelockClient;
+    get cctp(): CctpClient;
 }

package/src/constants.d.ts

@@ -12,6 +12,7 @@ export declare const SEED_INTEGRATION_AUTHORITY = "integration-authority";
 export declare const STAKE_ACCOUNT_SIZE = 200;
 export declare const METEORA_POSITION_SIZE = 8120;
 export declare const KAMINO_OBTRIGATION_SIZE = 3344;
+export declare const KAMINO_RESERVE_SIZE = 8624;
 export declare const DRIFT_VAULT_DEPOSITOR_SIZE = 272;
 export declare const JUPITER_API_DEFAULT = "https://lite-api.jup.ag";
 export declare const JITO_TIP_DEFAULT: PublicKey;

package/src/deser/base.d.ts

@@ -0,0 +1,17 @@
+import { struct } from "@coral-xyz/borsh";
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Base class for decodable on-chain account structures.
+ *
+ * This class provides a generic decode method that can be inherited by all
+ * account deserializer classes, eliminating the need to implement the same
+ * decode logic in each class.
+ */
+export declare abstract class Decodable {
+    readonly _address: PublicKey;
+    static _layout: ReturnType<typeof struct>;
+    static decode<T extends Decodable>(this: {
+        new (): T;
+        _layout: ReturnType<typeof struct>;
+    }, address: PublicKey, buffer: Buffer): T;
+}

package/src/deser/driftLayouts.d.ts

@@ -1,6 +1,7 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey } from "@solana/web3.js";
-export declare class DriftVault {
+import { Decodable } from "./base";
+export declare class DriftVault extends Decodable {
     discriminator: number[];
     name: number[];
     pubkey: PublicKey;
@@ -48,10 +49,9 @@ export declare class DriftVault {
     cumulativeFuel: BN;
     padding: BN[];
     static _layout: any;
-    static decode(buffer: Buffer): DriftVault;
     get nameStr(): string;
 }
-export declare class DriftSpotMarket {
+export declare class DriftSpotMarket extends Decodable {
     discriminator: number[];
     marketPda: PublicKey;
     oracle: PublicKey;
@@ -71,10 +71,9 @@ export declare class DriftSpotMarket {
     poolId: number;
     padding5: number[];
     static _layout: any;
-    static decode(buffer: Buffer): DriftSpotMarket;
     get nameStr(): string;
 }
-export declare class DriftPerpMarket {
+export declare class DriftPerpMarket extends Decodable {
     discriminator: number[];
     marketPda: PublicKey;
     oracle: PublicKey;
@@ -85,6 +84,5 @@ export declare class DriftPerpMarket {
     padding3: number[];
     marketIndex: number;
     static _layout: any;
-    static decode(buffer: Buffer): DriftPerpMarket;
     get nameStr(): string;
 }

package/src/deser/index.d.ts

@@ -0,0 +1,3 @@
+export { Decodable } from "./base";
+export * from "./driftLayouts";
+export * from "./kaminoLayouts";