@glamsystems/glam-sdk 0.1.7 → 0.1.9

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "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.git"
+    "url": "git@github.com:glamsystems/glam-sdk.git"
   },
   "keywords": [
     "glam",
@@ -18,9 +18,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@coral-xyz/anchor": "^0.30.1",
-    "@coral-xyz/borsh": "^0.30.1",
-    "@drift-labs/sdk": "2.96.0-beta.14",
+    "@coral-xyz/anchor": "^0.31.0",
+    "@coral-xyz/borsh": "^0.31.0",
+    "@drift-labs/sdk": "2.114.0-beta.3",
     "@marinade.finance/marinade-ts-sdk": "^5.0.15",
     "@pythnetwork/client": "^2.21.1",
     "@solana/spl-stake-pool": "^1.1.5",
@@ -40,10 +40,12 @@
   "pnpm": {
     "overrides": {
       "@solana/web3.js@>=0.0.1": "^1.98.0",
-      "@solana/spl-token@>=0.0.1": "^0.3.9",
+      "@solana/spl-token@>=0.0.1": "^0.4.6",
       "@solana/spl-stake-pool@>=0.0.1": "^1.1.5",
       "typescript@>=0.0.1": "^5.5.3",
+      "@coral-xyz/anchor": "^0.28.0",
       "solana-bankrun@>=0.0.1": "^0.3.0"
     }
-  }
+  },
+  "types": "./index.esm.d.ts"
 }

package/src/client/base.d.ts

@@ -1,4 +1,5 @@
 import * as anchor from "@coral-xyz/anchor";
+import { BN } from "@coral-xyz/anchor";
 import { Wallet } from "@coral-xyz/anchor";
 import { AddressLookupTableAccount, Keypair, PublicKey, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
 import { Mint } from "@solana/spl-token";
@@ -7,8 +8,7 @@ import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
 import { StateAccount, OpenfundsMetadataAccount, StateModel } from "../models";
 import { AssetMeta } from "./assets";
 import { BlockhashWithCache } from "../utils/blockhash";
-export declare const JUPITER_API_DEFAULT = "https://quote-api.jup.ag/v6";
-export declare const JITO_TIP_DEFAULT: anchor.web3.PublicKey;
+export declare const JUPITER_API_DEFAULT = "https://lite-api.jup.ag";
 export declare const isBrowser: string | boolean;
 export type TxOptions = {
     signer?: PublicKey;
@@ -50,7 +50,7 @@ export declare class BaseClient {
     getAssetMeta(assetMint: string): AssetMeta;
     private getComputeBudgetIxs;
     intoVersionedTransaction(tx: Transaction, { lookupTables, signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee, jitoTipLamports, simulate, }: TxOptions): Promise<VersionedTransaction>;
-    sendAndConfirm(tx: VersionedTransaction | Transaction, signerOverride?: Keypair): Promise<TransactionSignature>;
+    sendAndConfirm(tx: VersionedTransaction | Transaction, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
     parseProgramLogs(logs?: null | string[]): string;
     getAdressLookupTableAccounts(keys?: string[]): Promise<AddressLookupTableAccount[]>;
     getWallet(): Wallet;
@@ -58,7 +58,8 @@ export declare class BaseClient {
     getAta(mint: PublicKey, owner: PublicKey, tokenProgram?: anchor.web3.PublicKey): PublicKey;
     getStatePda(stateModel: Partial<StateModel>): PublicKey;
     getVaultPda(statePda: PublicKey): PublicKey;
-    getVaultAta(statePda: PublicKey, mint: PublicKey, programId?: PublicKey): PublicKey;
+    getEscrowPda(statePda: PublicKey): PublicKey;
+    getVaultAta(glamState: PublicKey, mint: PublicKey, programId?: PublicKey): PublicKey;
     /**
      * Fetch all the token accounts (including token program and token 2022 program) owned by a public key.
      *
@@ -67,7 +68,7 @@ export declare class BaseClient {
      */
     getTokenAccountsByOwner(owner: PublicKey): Promise<TokenAccount[]>;
     getVaultBalance(statePda: PublicKey): Promise<number>;
-    getVaultTokenBalance(statePda: PublicKey, mint: PublicKey, programId?: PublicKey): Promise<number>;
+    getVaultTokenBalance(glamState: PublicKey, mint: PublicKey, programId?: PublicKey): Promise<number>;
     fetchMintWithOwner(asset: PublicKey): Promise<{
         mint: Mint;
         tokenProgram: anchor.web3.PublicKey;
@@ -75,7 +76,10 @@ export declare class BaseClient {
     getOpenfundsPda(statePda: PublicKey): PublicKey;
     getMintPda(statePda: PublicKey, mintIdx?: number): PublicKey;
     getMintAta(user: PublicKey, mintPda: PublicKey): PublicKey;
+    getExtraMetasPda(glamState: PublicKey, mintIdx?: number): PublicKey;
+    getAccountPolicyPda(glamState: PublicKey, subject: PublicKey, mintIdx?: number): PublicKey;
     getName(stateModel: Partial<StateModel>): string;
+    isLockupEnabled(statePda: PublicKey, mintIdx?: number): Promise<boolean>;
     fetchStateAccount(statePda: PublicKey): Promise<StateAccount>;
     fetchOpenfundsMetadataAccount(state: PublicKey): Promise<OpenfundsMetadataAccount>;
     fetchMintAccount(state: PublicKey, mintIdx: number): Promise<Mint>;
@@ -83,9 +87,9 @@ export declare class BaseClient {
      * Generates instructions to wrap SOL into wSOL if the vault doesn't have enough wSOL
      *
      * @param lamports Desired amount of wSOL
-     * @returns
+     * @returns Array of instructions, null if no instructions are needed
      */
-    maybeWrapSol(state: PublicKey, amount: number | anchor.BN, signer?: PublicKey): Promise<TransactionInstruction | null>;
+    maybeWrapSol(glamState: PublicKey, lamports: number | BN, signer?: PublicKey): Promise<TransactionInstruction[]>;
     getAssetIdFromCurrency(currency: string): string;
     listGlamStates(): Promise<PublicKey[]>;
     /**
@@ -95,5 +99,15 @@ export declare class BaseClient {
      * @returns
      */
     fetchState(statePda: PublicKey): Promise<StateModel>;
-    fetchAllGlamStates(): Promise<StateModel[]>;
+    /**
+     * Fetch all glam states if no filter options provided
+     *
+     * @param filterOptions
+     * @returns
+     */
+    fetchGlamStates(filterOptions?: {
+        owner?: PublicKey;
+        delegate?: PublicKey;
+        type?: string;
+    }): Promise<StateModel[]>;
 }

package/src/client/drift.d.ts

@@ -1,5 +1,5 @@
 import * as anchor from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
 import { MarketType, OrderParams, PositionDirection, SpotPosition, PerpPosition, ModifyOrderParams } from "@drift-labs/sdk";
 import { BaseClient, TxOptions } from "./base";
 import { AccountMeta } from "@solana/web3.js";
@@ -45,31 +45,38 @@ export interface DriftMarketConfigs {
 export interface GlamDriftUser {
     delegate: string;
     name: string;
-    spotPositions: SpotPosition[];
+    spotPositions: (SpotPosition & {
+        balance: string;
+    })[];
     perpPositions: PerpPosition[];
     marginMode: string;
     subAccountId: number;
     isMarginTradingEnabled: boolean;
+    maxMarginRatio: number;
 }
 export declare class DriftClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    initialize(statePda: PublicKey): Promise<TransactionSignature>;
+    initialize(statePda: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     updateUserCustomMarginRatio(statePda: PublicKey, maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
     subAccountId?: number): Promise<TransactionSignature>;
-    updateUserMarginTradingEnabled(statePda: PublicKey, marginTradingEnabled: boolean, subAccountId?: number): Promise<TransactionSignature>;
-    updateUserDelegate(statePda: PublicKey | String, delegate: PublicKey | String, subAccountId?: number): Promise<TransactionSignature>;
-    deleteUser(statePda: PublicKey | String, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    deposit(statePda: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdraw(statePda: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    placeOrder(statePda: PublicKey, orderParams: OrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    modifyOrder(statePda: PublicKey, modifyOrderParams: ModifyOrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelOrders(statePda: PublicKey, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelOrdersByIds(statePda: PublicKey, orderIds: number[], subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
-    DRIFT_PROGRAM: anchor.web3.PublicKey;
-    getUser(statePda: PublicKey, subAccountId?: number): PublicKey[];
-    getPositions(statePda: PublicKey, subAccountId?: number): Promise<{
-        spotPositions: SpotPosition[];
+    updateUserMarginTradingEnabled(statePda: PublicKey, marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateUserDelegate(statePda: PublicKey | string, delegate: PublicKey | string, subAccountId?: number): Promise<TransactionSignature>;
+    deleteUser(statePda: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deposit(statePda: PublicKey | string, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(statePda: PublicKey | string, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    placeOrder(statePda: PublicKey | string, orderParams: OrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    modifyOrder(statePda: PublicKey | string, modifyOrderParams: ModifyOrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelOrders(statePda: PublicKey | string, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelOrdersByIds(statePda: PublicKey | string, orderIds: number[], subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    priceDrift(statePda: PublicKey | string, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<TransactionSignature>;
+    getUser(statePda: PublicKey | string, subAccountId?: number): PublicKey[];
+    fetchMarketConfigs(): Promise<DriftMarketConfigs>;
+    fetchGlamDriftUser(glamState: PublicKey | string, subAccountId?: number): Promise<GlamDriftUser>;
+    getPositions(statePda: PublicKey | string, subAccountId?: number): Promise<{
+        spotPositions: (SpotPosition & {
+            balance: string;
+        })[];
         perpPositions: PerpPosition[];
     }>;
     fetchPolicyConfig(glamState: StateModel): Promise<{
@@ -81,18 +88,26 @@ export declare class DriftClient {
         driftEnableSpot: any;
         driftMarketIndexesSpot: number[];
     }>;
+    marketTypeEquals: (a: MarketType | undefined, b: MarketType) => boolean;
     composeRemainingAccounts(glamState: PublicKey, subAccountId: number, marketConfigs: DriftMarketConfigs, marketType?: MarketType, marketIndex?: number): Promise<AccountMeta[]>;
-    initializeTx(glamState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    initializeUserStatsIx(glamState: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    initializeUserIx(glamState: PublicKey, glamSigner: PublicKey, subAccountId: number): Promise<TransactionInstruction>;
+    initializeTx(glamState: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserCustomMarginRatioIx(glamState: PublicKey, maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
+    subAccountId?: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
     updateUserCustomMarginRatioTx(glamState: PublicKey, maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
     subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserMarginTradingEnabledIx(glamState: PublicKey, marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
     updateUserMarginTradingEnabledTx(glamState: PublicKey, marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserDelegateIx(glamState: PublicKey, delegate: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
     updateUserDelegateTx(glamState: PublicKey, delegate: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
     deleteUserTx(glamState: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositTx(statePda: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositTx(glamState: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
     withdrawTx(statePda: PublicKey, amount: anchor.BN, marketIndex: number, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
     placeOrderTx(glamState: PublicKey, orderParams: OrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
     modifyOrderTx(statePda: PublicKey, modifyOrderParams: ModifyOrderParams, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
     cancelOrdersTx(glamState: PublicKey, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
     cancelOrdersByIdsTx(glamState: PublicKey, orderIds: number[], subAccountId: number, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    priceDriftTx(glamState: PublicKey, marketConfigs: DriftMarketConfigs, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export {};

package/src/client/investor.d.ts

@@ -1,12 +1,17 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
 import { BaseClient, TxOptions } from "./base";
-import { StateModel } from "../models";
 export declare class InvestorClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    subscribe(statePda: PublicKey, asset: PublicKey, amount: BN, stateModel?: StateModel, mintId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    redeem(statePda: PublicKey, amount: BN, inKind?: boolean, stateModel?: StateModel, mintId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    subscribeTx(statePda: PublicKey, asset: PublicKey, amount: BN, stateModel?: StateModel, mintId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    redeemTx(statePda: PublicKey, amount: BN, inKind?: boolean, stateModel?: StateModel, mintId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    subscribe(statePda: PublicKey, asset: PublicKey, amount: BN, mintId?: number, queued?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    queuedRedeem(statePda: PublicKey, asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fulfill(statePda: PublicKey, asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    claim(statePda: PublicKey, asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    subscribeTx(glamState: PublicKey, asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    queuedSubscribeTx(glamState: PublicKey, asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    queuedRedeemTx(glamState: PublicKey, asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    fulfillTx(glamState: PublicKey, asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    claimAssetTx(glamState: PublicKey, asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    claimShareTx(glamState: PublicKey, asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }

package/src/client/jupiter.d.ts

@@ -51,10 +51,21 @@ type SwapInstructions = {
 export declare class JupiterSwapClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    swap(statePda: PublicKey, quoteParams?: QuoteParams, quoteResponse?: QuoteResponse, swapInstructions?: SwapInstructions, txOptions?: TxOptions): Promise<TransactionSignature>;
+    swap(glamState: PublicKey, options: {
+        quoteParams?: QuoteParams;
+        quoteResponse?: QuoteResponse;
+        swapInstructions?: SwapInstructions;
+    }, txOptions?: TxOptions): Promise<TransactionSignature>;
     setMaxSwapSlippage(statePda: PublicKey, slippageBps: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    swapTx(statePda: PublicKey, quoteParams?: QuoteParams, quoteResponse?: QuoteResponse, swapInstructions?: SwapInstructions, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    setMaxSwapSlippageTx(statePda: PublicKey, slippageBps: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    fetchProgramLabels(): Promise<any>;
+    fetchTokenPrices(pubkeys: string[]): Promise<any>;
+    swapTx(glamState: PublicKey, options: {
+        quoteParams?: QuoteParams;
+        quoteResponse?: QuoteResponse;
+        swapInstructions?: SwapInstructions;
+    }, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setMaxSwapSlippageTx(glamState: PublicKey, slippageBps: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setMaxSwapSlippageIx(glamState: PublicKey, slippageBps: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
     getPreInstructions: (statePda: PublicKey, signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, inputTokenProgram?: PublicKey, outputTokenProgram?: PublicKey) => Promise<TransactionInstruction[]>;
     getTokenProgram: (mint: PublicKey) => Promise<PublicKey>;
     toTransactionInstruction: (ixPayload: InstructionFromJupiter, vaultStr: string) => TransactionInstruction;
@@ -82,6 +93,7 @@ export declare class JupiterVoteClient {
      */
     unstakeJup(statePda: PublicKey, txOptions?: TxOptions): Promise<string>;
     withdrawJup(statePda: PublicKey, txOptions?: TxOptions): Promise<string>;
+    claimAndStake(statePda: PublicKey, distributor: PublicKey, amountUnlocked: BN, amountLocked: BN, proof: number[][], txOptions?: TxOptions): Promise<string>;
     cancelUnstake(statePda: PublicKey, txOptions?: TxOptions): Promise<string>;
     /**
      * Vote on a proposal. The vote account will be created if it doesn't exist.
@@ -93,7 +105,15 @@ export declare class JupiterVoteClient {
      * @returns
      */
     voteOnProposal(glamState: PublicKey, proposal: PublicKey, side: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchVotes(glamState: PublicKey, proposals: PublicKey[] | string[]): Promise<{
+        proposal: PublicKey;
+        voter: PublicKey;
+        side: number;
+    }[]>;
     get stakeLocker(): PublicKey;
+    getClaimStatus(claimant: PublicKey, distributor: PublicKey): PublicKey;
     getEscrowPda(owner: PublicKey): PublicKey;
+    getVotePda(proposal: PublicKey, voter: PublicKey): PublicKey;
+    getGovernorPda(): PublicKey;
 }
 export {};

package/src/client/marinade.d.ts

@@ -1,21 +1,22 @@
 import { BN } from "@coral-xyz/anchor";
 import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
 import { BaseClient, TxOptions } from "./base";
+export type Ticket = {
+    address: PublicKey;
+    lamports: number;
+    createdEpoch: number;
+    isDue: boolean;
+    isClaimable: boolean;
+};
 export declare class MarinadeClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    depositSol(statePda: PublicKey, amount: BN): Promise<TransactionSignature>;
-    depositStake(statePda: PublicKey, stakeAccount: PublicKey): Promise<TransactionSignature>;
-    liquidUnstake(statePda: PublicKey, amount: BN): Promise<TransactionSignature>;
-    delayedUnstake(statePda: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    claimTickets(statePda: PublicKey, tickets: PublicKey[]): Promise<TransactionSignature>;
-    getExistingTickets(state: PublicKey): Promise<PublicKey[]>;
-    getTickets(state: PublicKey): Promise<{
-        address: PublicKey;
-        lamports: number;
-        createdEpoch: number;
-        isDue: boolean;
-    }[]>;
+    deposit(statePda: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositStakeAccount(statePda: PublicKey, stakeAccount: PublicKey): Promise<TransactionSignature>;
+    orderUnstake(statePda: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    claim(statePda: PublicKey, tickets: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    getTickets(state: PublicKey): Promise<PublicKey[]>;
+    getParsedTickets(state: PublicKey): Promise<Ticket[]>;
     getMarinadeState(): {
         marinadeStateAddress: PublicKey;
         msolMintAddress: PublicKey;
@@ -27,9 +28,8 @@ export declare class MarinadeClient {
         solLeg: PublicKey;
     };
     getParsedStakeAccountInfo(stakeAccount: PublicKey): Promise<any>;
-    depositSolTx(statePda: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    depositStakeTx(statePda: PublicKey, stakeAccount: PublicKey, txOptions: TxOptions): Promise<any>;
-    delayedUnstakeTx(state: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    claimTicketsTx(state: PublicKey, tickets: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
-    liquidUnstakeTx(statePda: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    depositTx(glamState: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    depositStakeAccountTx(glamState: PublicKey, stakeAccount: PublicKey, txOptions: TxOptions): Promise<any>;
+    orderUnstakeTx(glamState: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    claimTx(glamState: PublicKey, tickets: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
 }

package/src/client/meteora.d.ts

@@ -0,0 +1,31 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionSignature } from "@solana/web3.js";
+import DLMM, { Strategy } from "@meteora-ag/dlmm";
+import { BaseClient, TxOptions } from "./base";
+export declare class MeteoraDlmmClient {
+    readonly base: BaseClient;
+    private _dlmmPool;
+    constructor(base: BaseClient);
+    getDlmmPool(pool: PublicKey | string): Promise<DLMM>;
+    initializePosition(statePda: PublicKey | string, pool: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    initializePositionPda(statePda: PublicKey | string, pool: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    addLiquidityByStrategy(statePda: PublicKey | string, position: PublicKey | string, amountX: BN | number, amountY: BN | number, strategyType: keyof typeof Strategy, txOptions?: TxOptions): Promise<string>;
+    removeLiquidityByRange(statePda: PublicKey | string, position: PublicKey | string, bpsToRemove: number, txOptions?: TxOptions): Promise<string>;
+    claimFee(statePda: PublicKey | string, position: PublicKey | string, txOptions?: TxOptions): Promise<string>;
+    closePosition(statePda: PublicKey | string, position: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    getPositionPda(lbPair: PublicKey, base: PublicKey, lowerBinId: number, // i32
+    width: number): PublicKey;
+    fetchPositions(owner: PublicKey): Promise<PublicKey[]>;
+    parsePosition(position: PublicKey): Promise<{
+        lowerBinId: number;
+        upperBinId: number;
+        binArrayLower: PublicKey;
+        binArrayUpper: PublicKey;
+        lbPair: PublicKey;
+    }>;
+    autoFillY(dlmmPool: DLMM, amountX: BN): Promise<{
+        amountX: BN;
+        amountY: BN;
+        activeBinId: number;
+    }>;
+}

package/src/client/mint.d.ts

@@ -1,44 +1,72 @@
 import * as anchor from "@coral-xyz/anchor";
 import { PublicKey, TransactionSignature } from "@solana/web3.js";
 import { BaseClient, TokenAccount, TxOptions } from "./base";
+import { MintModel } from "../models";
 export declare class MintClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
+    fetchTokenHolders(state: PublicKey): Promise<TokenAccount[]>;
     getHolders(state: PublicKey, mintId?: number): Promise<TokenAccount[]>;
-    closeMintIx(state: PublicKey, mintId?: number): Promise<anchor.web3.TransactionInstruction>;
-    closeMint(state: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<string>;
+    update(glamState: PublicKey, mintId: number, mintModel: Partial<MintModel>): Promise<string>;
+    closeMintIx(glamState: PublicKey, mintId?: number): Promise<anchor.web3.TransactionInstruction>;
+    closeMint(glamState: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<string>;
     /**
-     * Create a share class token account for a specific user
+     * Create a glam mint token account for a specific user
      *
-     * @param state
-     * @param owner
-     * @param mintId
+     * @param glamState
+     * @param owner Owner of the token account
+     * @param mintId ID of the mint (only 0 is supported)
+     * @param setFrozen If true, the token account will be frozen
      * @param txOptions
-     * @returns
+     * @returns Transaction signature
      */
-    createTokenAccount(state: PublicKey, owner: PublicKey, mintId?: number, setFrozen?: boolean, txOptions?: TxOptions): Promise<string>;
+    createTokenAccount(glamState: PublicKey, owner: PublicKey, mintId?: number, setFrozen?: boolean, txOptions?: TxOptions): Promise<string>;
     /**
-     * Freeze or thaw token accounts of a share class
+     * Freeze or unfreeze token accounts of a glam mint
      *
-     * @param state
-     * @param mintId
-     * @param frozen
+     * @param glamState
+     * @param mintId ID of the mint (only 0 is supported)
+     * @param tokenAccounts List of token accounts to freeze or unfreeze
+     * @param frozen If true, the token accounts will be frozen; otherwise, they will be unfrozen
      * @param txOptions
-     * @returns
+     * @returns Transaction signature
+     */
+    setTokenAccountsStates(glamState: PublicKey, mintId: number, tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<string>;
+    /**
+     * Mint tokens to recipient. Token account will be created if it does not exist.
+     *
+     * @param glamState
+     * @param mintId ID of the mint (only 0 is supported)
+     * @param recipient Recipient public key
+     * @param amount Amount of tokens to mint
+     * @param forceThaw If true, automatically unfreeze the token account before minting
+     * @param txOptions
+     * @returns Transaction signature
      */
-    setTokenAccountsStates(state: PublicKey, mintId: number, tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<string>;
+    mint(glamState: PublicKey, mintId: number, recipient: PublicKey, amount: anchor.BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
-     * Mint share to recipient
+     * Burn tokens from a token account
      *
-     * @param state
-     * @param mintId
-     * @param recipient Recipient's wallet address
-     * @param amount Amount of shares to mint
-     * @param forceThaw If true, force unfreezing token account before minting
+     * @param glamState
+     * @param mintId ID of the mint (only 0 is supported)
+     * @param amount Amount of tokens to burn
+     * @param from Owner of the token account
+     * @param forceThaw If true, automatically unfree the token account before burning
      * @param txOptions
      * @returns Transaction signature
      */
-    mint(state: PublicKey, mintId: number, recipient: PublicKey, amount: anchor.BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    burn(state: PublicKey, mintId: number, amount: anchor.BN, from: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    forceTransfer(state: PublicKey, mintId: number, amount: anchor.BN, from: PublicKey, to: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    burn(glamState: PublicKey, mintId: number, amount: anchor.BN, from: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Transfer tokens from one token account to another
+     *
+     * @param glamState
+     * @param mintId ID of the mint (only 0 is supported)
+     * @param amount Amount of tokens to transfer
+     * @param from Owner of the sender token account
+     * @param to Owner of the recipient token account
+     * @param forceThaw If true, automatically unfree the token accounts before transfer
+     * @param txOptions
+     * @returns
+     */
+    forceTransfer(glamState: PublicKey, mintId: number, amount: anchor.BN, from: PublicKey, to: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
 }

package/src/client/price.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+import { BaseClient } from "./base";
+export declare class PriceClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    /**
+     * !! 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>;
+    priceVaultIxs(glamState: PublicKey): Promise<TransactionInstruction[]>;
+    remainingAccountsForPricing: (glamState: PublicKey) => Promise<{
+        pubkey: PublicKey;
+        isSigner: boolean;
+        isWritable: boolean;
+    }[]>;
+}

package/src/client/staking.d.ts

@@ -22,42 +22,41 @@ export declare class StakingClient {
     readonly base: BaseClient;
     readonly marinade: MarinadeClient;
     constructor(base: BaseClient, marinade: MarinadeClient);
-    unstake(statePda: PublicKey, asset: PublicKey, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    stakePoolDepositSol(statePda: PublicKey, stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    stakePoolDepositStake(statePda: PublicKey, stakePool: PublicKey, stakeAccount: PublicKey): Promise<TransactionSignature>;
-    stakePoolWithdrawStake(statePda: PublicKey, stakePool: PublicKey, amount: BN): Promise<TransactionSignature>;
-    initializeAndDelegateStake(statePda: PublicKey, vote: PublicKey, amount: BN): Promise<TransactionSignature>;
-    deactivateStakeAccounts(statePda: PublicKey, stakeAccounts: PublicKey[]): Promise<TransactionSignature>;
-    withdrawFromStakeAccounts(statePda: PublicKey, stakeAccounts: PublicKey[]): Promise<TransactionSignature>;
-    mergeStakeAccounts(statePda: PublicKey, toStake: PublicKey, fromStake: PublicKey): Promise<TransactionSignature>;
-    splitStakeAccount(statePda: PublicKey, existingStake: PublicKey, lamports: BN): Promise<{
+    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<{
         newStake: PublicKey;
         txSig: TransactionSignature;
     }>;
-    redelegateStake(statePda: PublicKey, existingStake: PublicKey, vote: PublicKey): Promise<{
+    redelegate(glamState: PublicKey, 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;
-    getStakeAccounts(withdrawAuthority: PublicKey): Promise<PublicKey[]>;
     getStakeAccountsWithStates(withdrawAuthority: PublicKey): Promise<StakeAccountInfo[]>;
     getStakeAccountVoter(stakeAccount: PublicKey): Promise<PublicKey | null>;
     getStakePoolAccountData(stakePool: PublicKey): Promise<StakePoolAccountData>;
     createStakeAccount(signer: PublicKey): Promise<[PublicKey, TransactionInstruction]>;
-    stakePoolDepositSolTx(statePda: PublicKey, stakePool: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    stakePoolDepositStakeTx(statePda: PublicKey, stakePool: PublicKey, stakeAccount: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    stakePoolWithdrawStakeTx(statePda: PublicKey, stakePool: PublicKey, amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    initializeAndDelegateStakeTx(statePda: PublicKey, vote: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    deactivateStakeAccountsTx(statePda: PublicKey, stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawFromStakeAccountsTx(statePda: PublicKey, stakeAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-    mergeStakeAccountsTx(statePda: PublicKey, toStake: PublicKey, fromStake: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    splitStakeAccountTx(state: PublicKey, existingStake: PublicKey, lamports: BN, txOptions?: TxOptions): Promise<{
+    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<{
         tx: VersionedTransaction;
         newStake: PublicKey;
     }>;
-    redelegateStakeTx(statePda: PublicKey, existingStake: PublicKey, vote: PublicKey, txOptions?: TxOptions): Promise<{
+    redelegateStakeTx(glamState: PublicKey, existingStake: PublicKey, vote: PublicKey, txOptions?: TxOptions): Promise<{
         tx: VersionedTransaction;
         newStake: PublicKey;
     }>;

package/src/client/state.d.ts

@@ -7,9 +7,9 @@ export declare class StateClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
     createState(partialStateModel: Partial<StateModel>, singleTx?: boolean, txOptions?: TxOptions): Promise<[TransactionSignature, PublicKey]>;
-    updateState(statePda: PublicKeyOrString, updated: Partial<StateModel>, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateStateTx(statePda: PublicKey, updated: Partial<StateModel>, txOptions: TxOptions): Promise<VersionedTransaction>;
-    closeState(statePda: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    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 a full state model from a partial state model
      */
@@ -22,23 +22,19 @@ export declare class StateClient {
      * @returns
      */
     deleteDelegateAcls(statePda: PublicKey, delegates: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    upsertDelegateAcls(statePda: PublicKey, delegateAcls: DelegateAcl[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    setSubscribeRedeemEnabled(statePda: PublicKey, enabled: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    closeTokenAccounts(statePda: PublicKey, tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertDelegateAcls(glamState: PublicKey, delegateAcls: DelegateAcl[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    closeTokenAccounts(glamState: PublicKey, tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
-     * Close fund treasury's token accounts
-     *
-     * @param statePda
-     * @param tokenAccounts
-     * @param txOptions
-     * @returns
+     * Close vault's token accounts, all token accounts must use the same token program
      */
-    closeTokenAccountsIx(statePda: PublicKey, tokenAccounts: PublicKey[]): Promise<TransactionInstruction>;
-    closeTokenAccountsTx(statePda: PublicKey, tokenAccounts: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
-    deposit(statePda: PublicKey, asset: PublicKey, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdraw(statePda: PublicKey, asset: PublicKey, amount: number | BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    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(statePda: PublicKey, asset: PublicKey, amount: number | BN, txOptions: TxOptions): Promise<TransactionInstruction[]>;
-    withdrawTx(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>;
 }
 export {};

package/src/client/wsol.d.ts

@@ -4,8 +4,8 @@ import { BaseClient, TxOptions } from "./base";
 export declare class WSolClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    wrap(statePda: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    unwrap(statePda: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    wrapTx(statePda: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    unwrapTx(statePda: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
+    wrap(glamState: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    unwrap(glamState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    wrapTx(glamState: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    unwrapTx(glamState: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
 }