@glamsystems/glam-sdk 1.0.13 → 1.0.14-alpha.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "1.0.13",
+  "version": "1.0.14-alpha.0",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
   "homepage": "https://www.glam.systems",
   "repository": {
     "type": "git",
-    "url": "git@github.com:glamsystems/glam-sdk.git"
+    "url": "git@github.com:glamsystems/glam-sdk-ts.git"
   },
   "keywords": [
     "glam",

package/src/assets.d.ts

@@ -1,5 +1,4 @@
 import { PublicKey } from "@solana/web3.js";
-import { ClusterNetwork } from "./clientConfig";
 export declare const STAKE_POOLS: {
     name: string;
     symbol: string;
@@ -24,26 +23,18 @@ export declare const STAKE_POOLS_MAP: Map<string, {
  * Metadata for an asset for pricing
  */
 export interface AssetMeta {
+    asset: PublicKey;
     decimals: number;
     oracle: PublicKey;
-    programId?: PublicKey;
-    aggIndex?: number;
+    programId: PublicKey;
     oracleSource?: string;
 }
 /**
- * Asset-Oracle mapping supported by the protocol. This map is a mirror of onchain mapping stored in `global_config` https://solscan.io/account/6avract7PxKqoq6hdmpAgGKgJWoJWdiXPPzzFZ62Hck6
+ * Legacy asset metadata snapshot retained for backward compatibility.
  *
- * Note that we use functional prices for LSTs, and the oracle pubkey of a LST asset is the pool state.
+ * Runtime consumers should prefer the onchain-backed helpers in `globalConfig.ts`.
+ * Note that we use functional prices for LSTs, and the oracle pubkey of a LST
+ * asset is the pool state.
  */
 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;
-/**
- * Get metadata of an asset for pricing
- *
- * @param assetMint Token mint of the asset
- * @param cluster The cluster network (defaults to mainnet)
- * @returns Metadata of the asset
- */
-export declare function getAssetMeta(assetMint: string | PublicKey, cluster?: ClusterNetwork): AssetMeta;

package/src/client/base.d.ts

@@ -2,11 +2,13 @@ import * as anchor from "@coral-xyz/anchor";
 import { BN } from "@coral-xyz/anchor";
 import { Wallet } from "@coral-xyz/anchor";
 import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { ExtCctpProgram, ExtDriftProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtOffchainProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
+import { ExtBridgeProgram, ExtEpiProgram, ExtCctpProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
 import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
+import type { GlobalConfigAccount } from "../globalConfig";
 import { RequestQueue, StateAccount, StateModel } from "../models";
 import { BlockhashWithCache } from "../utils/blockhash";
 import { JupiterApiClient } from "../utils";
+import { AssetMeta } from "../assets";
 export type TxOptions = {
     signer?: PublicKey;
     computeUnitLimit?: number;
@@ -39,23 +41,27 @@ export declare class BaseClient {
     private _protocolProgram?;
     private _mintProgram?;
     private _extSplProgram?;
-    private _extDriftProgram?;
     private _extKaminoProgram?;
     private _extMarinadeProgram?;
     private _extStakePoolProgram?;
     private _extCctpProgram?;
-    private _extOffchainProgram?;
+    private _extBridgeProgram?;
+    private _extEpiProgram?;
     private _statePda?;
+    private _globalConfig?;
+    private _globalConfigPromise?;
+    private _assetMetas?;
+    private _assetMetasPromise?;
     constructor(config?: GlamClientConfig);
     get protocolProgram(): GlamProtocolProgram;
     get mintProgram(): GlamMintProgram;
     get extSplProgram(): ExtSplProgram;
-    get extDriftProgram(): ExtDriftProgram;
     get extKaminoProgram(): ExtKaminoProgram;
     get extMarinadeProgram(): ExtMarinadeProgram;
     get extStakePoolProgram(): ExtStakePoolProgram;
     get extCctpProgram(): ExtCctpProgram;
-    get extOffchainProgram(): ExtOffchainProgram;
+    get extBridgeProgram(): ExtBridgeProgram;
+    get extEpiProgram(): ExtEpiProgram;
     get isVaultConnected(): boolean;
     get statePda(): PublicKey;
     set statePda(statePda: PublicKey);
@@ -117,6 +123,19 @@ export declare class BaseClient {
         uiAmount: number;
     }>;
     isLockupEnabled(): Promise<boolean>;
+    fetchGlobalConfig(options?: {
+        refresh?: boolean;
+    }): Promise<GlobalConfigAccount>;
+    fetchAssetMetas(options?: {
+        refresh?: boolean;
+    }): Promise<Map<string, AssetMeta>>;
+    refreshAssetMetaCache(): Promise<Map<string, AssetMeta>>;
+    getAssetMeta(assetMint: string | PublicKey, options?: {
+        refresh?: boolean;
+    }): Promise<AssetMeta>;
+    getSolOracle(options?: {
+        refresh?: boolean;
+    }): Promise<PublicKey>;
     fetchStateAccount(statePda?: PublicKey): Promise<StateAccount>;
     private getMintProgramIdForStateAccount;
     private getMintProgramForStateAccount;

package/src/client/bridge.d.ts

@@ -0,0 +1,184 @@
+import { BN } from "@coral-xyz/anchor";
+import { AccountMeta, Keypair, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { LayerzeroOftRouteProfile } from "./bridgeRegistry";
+import { LayerzeroOftPolicy, LayerzeroOftRoute, RouteManagementMode } from "../deser/integrationPolicies";
+type BufferLike32 = Uint8Array | number[] | Buffer;
+type BufferLike = Uint8Array | number[] | Buffer;
+type RouteManagementModeArg = RouteManagementMode | number | {
+    unmanagedOnly: Record<string, never>;
+} | {
+    managedOnly: Record<string, never>;
+} | {
+    either: Record<string, never>;
+};
+export type LayerzeroOftRouteInput = Omit<LayerzeroOftRoute, "managementMode"> & {
+    managementMode: RouteManagementModeArg;
+};
+export type OftTransferParams = {
+    transferId: BufferLike32;
+    sourceMint: PublicKey;
+    sourceAmount: BN;
+    providerInstructions: TransactionInstruction[];
+    providerReceipt: PublicKey;
+    sourceTokenAccount?: PublicKey;
+    managed?: boolean;
+    providerSigners?: Keypair[];
+    prepareRemainingAccounts?: AccountMeta[];
+    commitRemainingAccounts?: AccountMeta[];
+};
+export type LayerzeroOftSendParams = {
+    transferId?: BufferLike32;
+    sourceMint: PublicKey;
+    sourceAmount: BN;
+    destinationChain: number;
+    destinationRecipient: PublicKey;
+    nativeFee: BN;
+    minAmountLd?: BN;
+    lzTokenFee?: BN;
+    options?: BufferLike;
+    composeMsg?: BufferLike | null;
+    sourceTokenAccount?: PublicKey;
+    nonceAccount?: PublicKey;
+    managed?: boolean;
+    providerProgram?: PublicKey;
+};
+export declare function deriveLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
+export declare function deriveOftAuxiliaryAccountSeed(glamState: PublicKey, transferId: BufferLike32): Promise<string>;
+export declare function deriveOftAuxiliaryAccount(glamSigner: PublicKey, glamState: PublicKey, transferId: BufferLike32, tokenProgram: PublicKey): Promise<{
+    address: PublicKey;
+    seed: string;
+}>;
+declare class TxBuilder extends BaseTxBuilder<BridgeClient> {
+    addLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    updateLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    deleteLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    buildOftTransferTx(params: OftTransferParams, txOptions?: TxOptions): Promise<{
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        transferRecordPda: PublicKey;
+        auxiliaryTokenAccount: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+}
+declare class LayerzeroOftBridgeProtocolClient {
+    readonly bridge: BridgeClient;
+    constructor(bridge: BridgeClient);
+    buildSendTx(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<{
+        auxiliaryTokenAccount: PublicKey;
+        nonceAccount: PublicKey;
+        routeProfile: LayerzeroOftRouteProfile;
+        sendInstruction: TransactionInstruction;
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        transferRecordPda: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    send(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export declare class BridgeClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    readonly oft: LayerzeroOftBridgeProtocolClient;
+    constructor(base: BaseClient);
+    getRegistryPda(): PublicKey;
+    getSessionPda(transferId: BufferLike32): PublicKey;
+    getTransferRecordPda(transferId: BufferLike32): PublicKey;
+    getLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
+    deriveOftAuxiliaryTokenAccount(transferId: BufferLike32, sourceMint: PublicKey, signer?: PublicKey): Promise<{
+        tokenProgram: PublicKey;
+        address: PublicKey;
+        seed: string;
+    }>;
+    private resolveLayerzeroOftRouteProfile;
+    private resolveLayerzeroOftNonceAccount;
+    private materializeLayerzeroOftRemainingAccounts;
+    private buildLayerzeroOftInstructionBaseAccounts;
+    private buildLayerzeroOftSendInstruction;
+    fetchLayerzeroOftPolicy(): Promise<LayerzeroOftPolicy | null>;
+    fetchRegistry(): Promise<{
+        glamState: PublicKey;
+        managedTransferCount: BN;
+        bump: number;
+    } | null>;
+    fetchSession(transferId: BufferLike32): Promise<{
+        glamState: PublicKey;
+        signer: PublicKey;
+        transferId: number[];
+        protocol: number;
+        managed: boolean;
+        sourceMint: PublicKey;
+        sourceTokenAccount: PublicKey;
+        providerProgram: PublicKey;
+        providerConfig: PublicKey;
+        providerSender: PublicKey;
+        providerDelegate: PublicKey;
+        providerReceipt: PublicKey;
+        providerInstructionHash: number[];
+        providerInstructionCount: number;
+        sourceAmount: BN;
+        quotedOutAmount: BN;
+        initialSourceBalance: BN;
+        initialProviderSequence: BN;
+        destinationChain: number;
+        destinationRecipient: PublicKey;
+        quoteExpiresAt: BN;
+        preparedSlot: BN;
+        bump: number;
+    } | null>;
+    fetchTransferRecord(transferId: BufferLike32): Promise<{
+        glamState: PublicKey;
+        transferId: number[];
+        protocol: number;
+        status: any;
+        managed: boolean;
+        receiptVerified: boolean;
+        sourceMint: PublicKey;
+        sourceTokenAccount: PublicKey;
+        providerProgram: PublicKey;
+        providerConfig: PublicKey;
+        sourceAmount: BN;
+        quotedOutAmount: BN;
+        destinationChain: number;
+        destinationRecipient: PublicKey;
+        providerTransferId: number[];
+        providerEmitter: PublicKey;
+        providerSequence: BN;
+        committedSlot: BN;
+        settledSlot: BN;
+        reconciledSlot: BN;
+        failureReason: number;
+        bump: number;
+    }>;
+    addLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deleteLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    buildOftTransferTx(params: OftTransferParams, txOptions?: TxOptions): Promise<{
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        transferRecordPda: PublicKey;
+        auxiliaryTokenAccount: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    buildLayerzeroOftSendTx(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<{
+        auxiliaryTokenAccount: PublicKey;
+        nonceAccount: PublicKey;
+        routeProfile: LayerzeroOftRouteProfile;
+        sendInstruction: TransactionInstruction;
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        transferRecordPda: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    sendOft(params: OftTransferParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    private extendLookupTables;
+    settleManagedTransfer(transferId: BufferLike32, txOptions?: TxOptions): Promise<string>;
+    reconcileManagedTransfer(transferId: BufferLike32, txOptions?: TxOptions): Promise<string>;
+    failManagedTransfer(transferId: BufferLike32, failureReason: number, txOptions?: TxOptions): Promise<string>;
+    cleanupTransferRecord(transferId: BufferLike32, txOptions?: TxOptions): Promise<string>;
+}
+export {};

package/src/client/bridgeRegistry.d.ts

@@ -0,0 +1,32 @@
+import { PublicKey } from "@solana/web3.js";
+import { ClusterNetwork } from "../clientConfig";
+export type RouteAccountPlaceholder = "payer" | "nonce";
+export type SerializableRouteAccountMeta = {
+    pubkey?: PublicKey;
+    placeholder?: RouteAccountPlaceholder;
+    isSigner: boolean;
+    isWritable: boolean;
+};
+export type LayerzeroOftRouteProfile = {
+    sourceMint: PublicKey;
+    destinationChain: number;
+    providerProgram: PublicKey;
+    providerConfig: PublicKey;
+    nonceAccount?: PublicKey;
+    peerConfig: PublicKey;
+    providerSender: PublicKey;
+    enforcedOptions: PublicKey;
+    tokenEscrow: PublicKey;
+    eventAuthority: PublicKey;
+    lookupTables?: PublicKey[];
+    defaultOptions?: Uint8Array | number[] | Buffer;
+    defaultMinAmountBps?: number;
+    remainingAccounts: SerializableRouteAccountMeta[];
+    quoteRemainingAccounts?: SerializableRouteAccountMeta[];
+};
+export declare function resolveCanonicalLayerzeroOftRouteProfile(params: {
+    sourceMint: PublicKey;
+    destinationChain: number;
+    cluster: ClusterNetwork;
+    providerProgram?: PublicKey;
+}): LayerzeroOftRouteProfile | null;

package/src/client/epi.d.ts

@@ -0,0 +1,78 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+type BufferLike32 = Uint8Array | number[] | Buffer;
+export type EpiDenominationKindInput = {
+    usd: Record<string, never>;
+} | {
+    mint: Record<string, never>;
+};
+export type EpiDenominationSpecInput = {
+    denom: EpiDenominationKindInput;
+    mint: PublicKey;
+};
+export type EpiExternalPositionTypeInput = {
+    valued: Record<string, never>;
+} | {
+    tokenized: Record<string, never>;
+};
+export type EpiExternalSourceTypeInput = {
+    trusted: Record<string, never>;
+} | {
+    native: Record<string, never>;
+};
+export type EpiNativeCustodyKindInput = {
+    splToken: Record<string, never>;
+} | {
+    nativeSol: Record<string, never>;
+};
+export type UpsertExternalPositionParams = {
+    positionId: BufferLike32;
+    positionType: EpiExternalPositionTypeInput;
+    sourceType: EpiExternalSourceTypeInput;
+    denomination: EpiDenominationSpecInput;
+    nativeCustodyAccount?: PublicKey;
+    nativeCustodyKind?: EpiNativeCustodyKindInput;
+    enabled?: boolean;
+    freshnessOverrideSecs?: number;
+    submitAllowlist?: PublicKey[];
+    validateAllowlist?: PublicKey[];
+    configureAllowlist?: PublicKey[];
+};
+export type SubmitExternalObservationParams = {
+    positionId: BufferLike32;
+    amount: BN;
+    denomination: EpiDenominationSpecInput;
+    observationTimestamp: BN;
+    externalShares?: BN;
+    reserved?: Uint8Array | number[] | Buffer;
+};
+declare class TxBuilder extends BaseTxBuilder<EpiClient> {
+    upsertExternalPositionIx(params: UpsertExternalPositionParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    submitExternalObservationIx(params: SubmitExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    validateExternalObservationIx(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, signer?: PublicKey): Promise<TransactionInstruction>;
+    refreshPricedProtocolIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    submitExternalObservationTx(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    upsertExternalPositionTx(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    validateExternalObservationTx(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    refreshPricedProtocolTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class EpiClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    getObservationStatePda(): PublicKey;
+    getIntegrationAuthorityPda(): PublicKey;
+    fetchObservationState(): Promise<{
+        glamState: PublicKey;
+        bump: number;
+        positionsLen: number;
+        reserved: number[];
+        positions: any[];
+    } | null>;
+    submitExternalObservation(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertExternalPosition(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    validateExternalObservation(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, txOptions?: TxOptions): Promise<TransactionSignature>;
+    refreshPricedProtocol(txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

package/src/client/fees.d.ts

@@ -27,6 +27,7 @@ export declare class FeesClient {
     crystallizeFees(txOptions?: TxOptions): Promise<TransactionSignature>;
     claimFees(txOptions?: TxOptions): Promise<TransactionSignature>;
     chargeProtocolFee(protocolFeeAuthority: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    setProtocolFeesIx(baseFeeBps: number, flowFeeBps: number, signer?: PublicKey): Promise<TransactionInstruction>;
     setProtocolFees(baseFeeBps: number, flowFeeBps: number, txOptions?: TxOptions): Promise<TransactionSignature>;
 }
 export {};

package/src/client/jupiter.d.ts

@@ -3,22 +3,30 @@ import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTrans
 import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
 import { VaultClient } from "./vault";
 import { JupiterApiClient, JupiterInstruction, QuoteParams, QuoteResponse, SwapInstructions } from "../utils/jupiterApi";
+export type JupiterSwapOptions = {
+    quoteParams?: QuoteParams;
+    quoteResponse?: QuoteResponse;
+    swapInstructions?: SwapInstructions;
+    trackingAccount?: PublicKey;
+};
+export type JupiterSwapV2OracleAccounts = {
+    solUsdOracle?: PublicKey;
+    inputTokenOracle?: PublicKey;
+    outputTokenOracle?: PublicKey;
+};
+export type JupiterSwapV2Options = JupiterSwapOptions & {
+    skipQuotePriceCheck?: boolean;
+    oracleAccounts?: JupiterSwapV2OracleAccounts;
+};
 declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> {
+    private resolveSwapInstructionContext;
     /**
      * Returns the instructions for a Jupiter swap and the lookup tables
      */
-    swapIxs(options: {
-        quoteParams?: QuoteParams;
-        quoteResponse?: QuoteResponse;
-        swapInstructions?: SwapInstructions;
-        trackingAccount?: PublicKey;
-    }, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapTx(options: {
-        quoteParams?: QuoteParams;
-        quoteResponse?: QuoteResponse;
-        swapInstructions?: SwapInstructions;
-        trackingAccount?: PublicKey;
-    }, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    swapIxs(options: JupiterSwapOptions, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
+    swapV2Ixs(options: JupiterSwapV2Options, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
+    swapTx(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    swapV2Tx(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<VersionedTransaction>;
     getPreInstructions: (signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey) => Promise<TransactionInstruction[]>;
     toTransactionInstruction: (ix: JupiterInstruction) => TransactionInstruction;
 }
@@ -28,11 +36,7 @@ export declare class JupiterSwapClient {
     readonly txBuilder: TxBuilder;
     readonly jupApi: JupiterApiClient;
     constructor(base: BaseClient, vault: VaultClient);
-    swap(options: {
-        quoteParams?: QuoteParams;
-        quoteResponse?: QuoteResponse;
-        swapInstructions?: SwapInstructions;
-        trackingAccount?: PublicKey;
-    }, txOptions?: TxOptions): Promise<TransactionSignature>;
+    swap(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<TransactionSignature>;
+    swapV2(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<TransactionSignature>;
 }
 export {};

package/src/client/price.d.ts

@@ -3,9 +3,8 @@ import { BN } from "@coral-xyz/anchor";
 import { KaminoLendingClient, KaminoVaultsClient } from "./kamino";
 import { BaseClient } from "./base";
 import { StateModel } from "../models";
-import { DriftProtocolClient, DriftVaultsClient } from "./drift";
 import { PkMap, PkSet } from "../utils";
-import { DriftSpotMarket, DriftPerpMarket, DriftVault, KVaultState, Reserve, DriftVaultDepositor } from "../deser";
+import { KVaultState, Reserve } from "../deser";
 import { JupiterApiClient, TokenListItem } from "../utils/jupiterApi";
 /**
  * Represents a single asset holding within a vault.
@@ -31,7 +30,7 @@ export declare class Holding {
 }
 /**
  * Aggregates all holdings for a GLAM vault.
- * Includes token balances, DeFi positions (Drift, Kamino).
+ * 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
@@ -56,13 +55,12 @@ export declare class PriceClient {
     readonly base: BaseClient;
     readonly klend: KaminoLendingClient;
     readonly kvaults: KaminoVaultsClient;
-    readonly drift: DriftProtocolClient;
-    readonly dvaults: DriftVaultsClient;
     private readonly getJupiterApi;
     private _stateModel;
     private _lookupTables;
     private _kaminoVaults;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftProtocolClient, dvaults: DriftVaultsClient, getJupiterApi: () => JupiterApiClient);
+    private _priceVaultIxsQueue;
+    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, getJupiterApi: () => JupiterApiClient);
     get jupiterApi(): JupiterApiClient;
     get cachedStateModel(): StateModel | null;
     set cachedStateModel(stateModel: StateModel);
@@ -73,8 +71,6 @@ export declare class PriceClient {
      *
      * The source of truth for external positions is the `externalPositions` array
      * from the state account, which tracks:
-     * - Drift user PDAs (direct trading positions)
-     * - Drift vault depositor accounts (shares in drift vaults)
      * - Kamino obligation accounts (lending positions)
      * - Kamino vault share ATAs (shares in kamino vaults)
      *
@@ -85,12 +81,6 @@ export declare class PriceClient {
      */
     getVaultHoldings(commitment: Commitment, priceBaseAssetMint?: PublicKey): Promise<VaultHoldings>;
     getPubkeysForTokenHoldings(externalPositionsSet: PkSet, commitment?: Commitment): Promise<PublicKey[]>;
-    getPubkeysForSpotHoldings(driftUserPdas: PublicKey[], commitment?: Commitment): Promise<PkMap<PkSet>>;
-    getPubkeysForPerpHoldings(driftUserPdas: PublicKey[], commitment?: Commitment): Promise<PkMap<PkSet>>;
-    /**
-     * Parses drift vault depositors from known pubkeys.
-     */
-    getDepositorsAndDriftVaults(depositorPubkeys: PublicKey[], commitment?: Commitment): Promise<PkMap<DriftVault>>;
     /**
      * Gets kamino obligation reserves from known obligation pubkeys.
      */
@@ -106,8 +96,6 @@ export declare class PriceClient {
      */
     private getTokenPrice;
     getTokenHoldings(tokenAccountPubkeys: PublicKey[], accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getDriftHoldings(userPubkeys: Iterable<PublicKey>, spotMarketsMap: PkMap<DriftSpotMarket>, perpMarketsMap: PkMap<DriftPerpMarket>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getDriftVaultsHoldings(dvaultDepositorsAndVaults: PkMap<DriftVault>, dvaultDepositorsMap: PkMap<DriftVaultDepositor>, spotMarketsMap: PkMap<DriftSpotMarket>, perpMarketsMap: PkMap<DriftPerpMarket>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, 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[]>;
     /**
@@ -116,35 +104,23 @@ export declare class PriceClient {
      */
     priceKaminoObligationsIxs(): Promise<TransactionInstruction[]>;
     priceKaminoVaultSharesIx(): Promise<TransactionInstruction[] | null>;
-    /**
-     * Returns an instruction that prices all Drift users (aka sub-accounts) controlled by the GLAM vault.
-     */
-    priceDriftUsersIx(): Promise<TransactionInstruction | null>;
-    /**
-     * Returns an instruction that prices a drift vault depositor.
-     * If there are no vault depositor accounts, returns null.
-     */
-    priceDriftVaultDepositorsIx(): Promise<TransactionInstruction | null>;
     /**
      * Returns an instruction that prices vault balance and tokens
      */
-    priceVaultTokensIx(): Promise<TransactionInstruction>;
+    priceVaultTokensIx(): Promise<TransactionInstruction[]>;
     /**
      * Returns an instruction that prices stake accounts.
      * If there are no stake accounts, returns null.
      */
     priceStakeAccountsIx(): Promise<TransactionInstruction | null>;
     priceVaultIxs(): Promise<TransactionInstruction[]>;
+    private enqueuePriceVaultIxs;
+    private priceEpiValidatedPositionsIx;
+    private _priceVaultIxsImpl;
     validateAumIx(): Promise<TransactionInstruction>;
-    getbaseAssetOracle(): Promise<PublicKey>;
-    remainingAccountsForPricingDriftVaultDepositors(parsedVaultDepositors: {
-        address: PublicKey;
-        driftVault: PublicKey;
-        shares: any;
-    }[]): Promise<{
-        remainingAccounts: AccountMeta[];
-        numSpotMarkets: number;
-        numPerpMarkets: number;
-    }>;
-    remainingAccountsForPricingVaultAssets(): Promise<AccountMeta[]>;
+    getBaseAssetOracle(): Promise<PublicKey>;
+    remainingAccountsForPricingVaultAssets(): Promise<[
+        AccountMeta[],
+        PublicKey[]
+    ]>;
 }

package/src/client.d.ts

@@ -1,6 +1,5 @@
 import { GlamClientConfig } from "./clientConfig";
 import { BaseClient } from "./client/base";
-import { DriftProtocolClient, DriftVaultsClient } from "./client/drift";
 import { JupiterSwapClient } from "./client/jupiter";
 import { MarinadeClient } from "./client/marinade";
 import { VaultClient } from "./client/vault";
@@ -15,14 +14,14 @@ import { TimelockClient } from "./client/timelock";
 import { StakeClient } from "./client/stake";
 import { StakePoolClient } from "./client/stake-pool";
 import { CctpClient } from "./client/cctp";
+import { BridgeClient } from "./client/bridge";
+import { EpiClient } from "./client/epi";
 /**
  * Main entrypoint for the GLAM SDK
  *
  * Lazy loads each client/module at first use
  */
 export declare class GlamClient extends BaseClient {
-    private _drift?;
-    private _driftVaults?;
     private _invest?;
     private _jupiterSwap?;
     private _marinade?;
@@ -39,9 +38,9 @@ export declare class GlamClient extends BaseClient {
     private _fees?;
     private _timelock?;
     private _cctp?;
+    private _bridge?;
+    private _epi?;
     constructor(config?: GlamClientConfig);
-    get drift(): DriftProtocolClient;
-    get driftVaults(): DriftVaultsClient;
     get invest(): InvestClient;
     get fees(): FeesClient;
     get jupiterSwap(): JupiterSwapClient;
@@ -58,4 +57,6 @@ export declare class GlamClient extends BaseClient {
     get kaminoVaults(): KaminoVaultsClient;
     get timelock(): TimelockClient;
     get cctp(): CctpClient;
+    get bridge(): BridgeClient;
+    get epi(): EpiClient;
 }