@glamsystems/glam-sdk 0.1.22 → 0.1.23

package/package.json

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

package/src/client/base.d.ts

@@ -37,8 +37,11 @@ export declare class BaseClient {
     program: GlamProgram;
     jupiterApi: string;
     blockhashWithCache: BlockhashWithCache;
+    private _statePda?;
     constructor(config?: GlamClientConfig);
     get detectedCluster(): ClusterNetwork;
+    get statePda(): PublicKey;
+    set statePda(statePda: PublicKey);
     isMainnet(): boolean;
     isPhantom(): boolean;
     /**
@@ -55,52 +58,66 @@ export declare class BaseClient {
     getAdressLookupTableAccounts(keys?: string[] | PublicKey[]): Promise<AddressLookupTableAccount[]>;
     getWallet(): Wallet;
     getSigner(): PublicKey;
-    getAta(mint: PublicKey, owner: PublicKey, tokenProgram?: anchor.web3.PublicKey): PublicKey;
-    getStatePda(stateModel: Partial<StateModel>): PublicKey;
-    getVaultPda(statePda: PublicKey): PublicKey;
-    getEscrowPda(statePda: PublicKey): PublicKey;
-    getVaultAta(glamState: PublicKey, mint: PublicKey, programId?: PublicKey): PublicKey;
+    get signer(): PublicKey;
+    get wallet(): Wallet;
+    get vaultPda(): PublicKey;
+    get escrowPda(): PublicKey;
+    get mintPda(): PublicKey;
+    get extraMetasPda(): PublicKey;
+    get openfundsPda(): PublicKey;
     /**
-     * Fetch all the token accounts (including token program and token 2022 program) owned by a public key.
+     * Fetch all the token accounts (including token program and token 2022 program) owned by the specified account.
      *
      * @param owner
      * @returns
      */
     getTokenAccountsByOwner(owner: PublicKey): Promise<TokenAccount[]>;
-    getVaultBalance(statePda: PublicKey): Promise<number>;
-    getVaultTokenBalance(glamState: PublicKey, mint: PublicKey, programId?: PublicKey): Promise<number>;
-    fetchMintWithOwner(asset: PublicKey): Promise<{
+    getSolAndTokenBalances(owner: PublicKey): Promise<{
+        balanceLamports: number;
+        uiAmount: number;
+        tokenAccounts: TokenAccount[];
+    }>;
+    getAta(mint: PublicKey, owner: PublicKey, tokenProgram?: anchor.web3.PublicKey): PublicKey;
+    getVaultAta(mint: PublicKey, tokenProgramId?: PublicKey): PublicKey;
+    getVaultBalance(): Promise<number>;
+    getVaultLamports(): Promise<number>;
+    getVaultTokenBalance(mintPubkey: PublicKey): Promise<{
+        amount: BN;
+        uiAmount: number;
+    }>;
+    fetchMintAndTokenProgram(mintPubkey: PublicKey): Promise<{
         mint: Mint;
         tokenProgram: anchor.web3.PublicKey;
     }>;
-    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;
+    getMintAta(user: PublicKey): PublicKey;
+    /**
+     * @deprecated
+     */
     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>;
+    isLockupEnabled(): Promise<boolean>;
+    fetchStateAccount(statePda?: PublicKey): Promise<StateAccount>;
+    fetchOpenfundsMetadataAccount(statePda?: PublicKey): Promise<OpenfundsMetadataAccount>;
     /**
      * Generates instructions to wrap SOL into wSOL if the vault doesn't have enough wSOL
      *
      * @param lamports Desired amount of wSOL
      * @returns Array of instructions, null if no instructions are needed
      */
-    maybeWrapSol(glamState: PublicKey, lamports: number | BN, signer?: PublicKey): Promise<TransactionInstruction[]>;
+    maybeWrapSol(lamports: number | BN, signer?: PublicKey): Promise<TransactionInstruction[]>;
+    /**
+     * @deprecated
+     */
     getAssetIdFromCurrency(currency: string): string;
     listGlamStates(): Promise<PublicKey[]>;
     /**
      * Fetch glam state from onchain accounts and build a StateModel
      *
-     * @param statePda
+     * @param statePda Optional state PDA, if not specified, use the client's state PDA
      * @returns
      */
-    fetchState(statePda: PublicKey): Promise<StateModel>;
+    fetchStateModel(statePda?: PublicKey): Promise<StateModel>;
     /**
-     * Fetch all glam states if no filter options provided
+     * Fetch all glam state models if no filter options provided
      *
      * @param filterOptions
      * @returns

package/src/client/drift.d.ts

@@ -3,7 +3,7 @@ import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstr
 import { MarketType, OrderParams, PositionDirection, SpotPosition, PerpPosition, ModifyOrderParams, OracleSource, SpotBalanceType, MarginMode, Order } from "../utils/driftTypes";
 import { BaseClient, TxOptions } from "./base";
 import { AccountMeta } from "@solana/web3.js";
-import { PriceDenom, StateModel } from "../models";
+import { StateModel } from "../models";
 import { BN } from "@coral-xyz/anchor";
 interface OrderConstants {
     perpBaseScale: number;
@@ -57,20 +57,19 @@ export declare class DriftClient {
     private perpMarkets;
     private marketConfigs;
     constructor(base: BaseClient);
-    initialize(statePda: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateUserCustomMarginRatio(statePda: PublicKey, maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
+    initialize(subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateUserCustomMarginRatio(maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
     subAccountId?: number): Promise<TransactionSignature>;
-    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, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdraw(statePda: PublicKey | string, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    placeOrder(statePda: PublicKey | string, orderParams: OrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    modifyOrder(statePda: PublicKey | string, modifyOrderParams: ModifyOrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelOrders(statePda: PublicKey | string, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelOrdersByIds(statePda: PublicKey | string, orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    settlePnl(statePda: PublicKey | string, marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    priceDrift(statePda: PublicKey | string, priceDenom: PriceDenom, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateUserMarginTradingEnabled(marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateUserDelegate(delegate: PublicKey | string, subAccountId?: number): Promise<TransactionSignature>;
+    deleteUser(subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deposit(amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    placeOrder(orderParams: OrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    modifyOrder(modifyOrderParams: ModifyOrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelOrders(marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelOrdersByIds(orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    settlePnl(marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     getMarketPda: (marketType: MarketType, marketIndex: number) => anchor.web3.PublicKey;
     getUserPda: (authority: PublicKey, subAccountId?: number) => anchor.web3.PublicKey;
     getUserStatsPda: (authority: PublicKey) => PublicKey;
@@ -84,7 +83,7 @@ export declare class DriftClient {
         amount: number;
         uiAmount: number;
     }>;
-    getDriftUserPdas(statePda: PublicKey | string, subAccountId?: number): {
+    getDriftUserPdas(subAccountId?: number): {
         user: PublicKey;
         userStats: PublicKey;
     };
@@ -95,7 +94,10 @@ export declare class DriftClient {
     fetchAndParsePerpMarkets(marketIndexes: number[]): Promise<PerpMarket[]>;
     fetchMarketConfigs(): Promise<DriftMarketConfigs>;
     charsToName(chars: number[] | Buffer): string;
-    fetchDriftUser(statePda: PublicKey | string, subAccountId?: number): Promise<DriftUser | null>;
+    fetchDriftUser(subAccountId?: number): Promise<DriftUser | null>;
+    /**
+     * @deprecated
+     */
     fetchPolicyConfig(glamState: StateModel): Promise<{
         driftAccessControl: number;
         driftDelegatedAccount: anchor.web3.PublicKey;
@@ -106,26 +108,25 @@ export declare class DriftClient {
         driftMarketIndexesSpot: number[];
     }>;
     marketTypeEquals: (a: MarketType | undefined, b: MarketType) => boolean;
-    composeRemainingAccounts(glamState: PublicKey, subAccountId: number, marketType?: MarketType, marketIndex?: number): Promise<AccountMeta[]>;
-    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
+    composeRemainingAccounts(subAccountId: number, marketType?: MarketType, marketIndex?: number): Promise<AccountMeta[]>;
+    initializeUserStatsIx(glamSigner: PublicKey): Promise<TransactionInstruction>;
+    initializeUserIx(glamSigner: PublicKey, subAccountId: number): Promise<TransactionInstruction>;
+    initializeTx(subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserCustomMarginRatioIx(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
+    updateUserCustomMarginRatioTx(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(glamState: PublicKey, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawTx(statePda: PublicKey, amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    placeOrderTx(glamState: PublicKey, orderParams: OrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    modifyOrderTx(statePda: PublicKey, modifyOrderParams: ModifyOrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelOrdersTx(glamState: PublicKey, marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelOrdersByIdsTx(glamState: PublicKey, orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    settlePnlTx(glamState: PublicKey, marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    priceDriftTx(glamState: PublicKey, priceDenom: PriceDenom, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserMarginTradingEnabledIx(marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
+    updateUserMarginTradingEnabledTx(marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserDelegateIx(delegate: PublicKey | string, subAccountId?: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
+    updateUserDelegateTx(delegate: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    deleteUserTx(subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositTx(amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawTx(amount: anchor.BN, marketIndex?: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    placeOrderTx(orderParams: OrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    modifyOrderTx(modifyOrderParams: ModifyOrderParams, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    cancelOrdersTx(marketType: MarketType, marketIndex: number, direction: PositionDirection, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    cancelOrdersByIdsTx(orderIds: number[], subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    settlePnlTx(marketIndex: number, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export {};

package/src/client/investor.d.ts

@@ -4,14 +4,14 @@ import { BaseClient, TxOptions } from "./base";
 export declare class InvestorClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    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>;
+    subscribe(asset: PublicKey, amount: BN, mintId?: number, queued?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    queuedRedeem(asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fulfill(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    claim(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    subscribeTx(asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    queuedSubscribeTx(asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    queuedRedeemTx(asset: PublicKey, amount: BN, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    fulfillTx(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    claimAssetTx(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    claimShareTx(asset: PublicKey, mintId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }

package/src/client/jupiter.d.ts

@@ -51,22 +51,22 @@ type SwapInstructions = {
 export declare class JupiterSwapClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    swap(glamState: PublicKey, options: {
+    swap(options: {
         quoteParams?: QuoteParams;
         quoteResponse?: QuoteResponse;
         swapInstructions?: SwapInstructions;
     }, txOptions?: TxOptions): Promise<TransactionSignature>;
-    setMaxSwapSlippage(statePda: PublicKey, slippageBps: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    setMaxSwapSlippage(slippageBps: number, txOptions?: TxOptions): Promise<TransactionSignature>;
     fetchProgramLabels(): Promise<any>;
     fetchTokenPrices(pubkeys: string[]): Promise<any>;
-    swapTx(glamState: PublicKey, options: {
+    swapTx(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[]>;
+    setMaxSwapSlippageTx(slippageBps: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setMaxSwapSlippageIx(slippageBps: number, txOptions?: TxOptions): Promise<TransactionInstruction>;
+    getPreInstructions: (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;
     getQuoteResponse(quoteParams: QuoteParams): Promise<any>;
@@ -83,7 +83,7 @@ export declare class JupiterVoteClient {
      * @param txOptions
      * @returns
      */
-    stakeJup(statePda: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    stakeJup(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Unstake all staked JUP.
      *
@@ -91,21 +91,20 @@ export declare class JupiterVoteClient {
      * @param txOptions
      * @returns
      */
-    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>;
+    unstakeJup(txOptions?: TxOptions): Promise<string>;
+    withdrawJup(txOptions?: TxOptions): Promise<string>;
+    claimAndStake(distributor: PublicKey, amountUnlocked: BN, amountLocked: BN, proof: number[][], txOptions?: TxOptions): Promise<string>;
+    cancelUnstake(txOptions?: TxOptions): Promise<string>;
     /**
      * Vote on a proposal. The vote account will be created if it doesn't exist.
      *
-     * @param statePda
      * @param proposal
      * @param side
      * @param txOptions
      * @returns
      */
-    voteOnProposal(glamState: PublicKey, proposal: PublicKey, side: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchVotes(glamState: PublicKey, proposals: PublicKey[] | string[]): Promise<{
+    voteOnProposal(proposal: PublicKey, side: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchVotes(proposals: PublicKey[] | string[]): Promise<{
         proposal: PublicKey;
         voter: PublicKey;
         side: number;

package/src/client/kamino.d.ts

@@ -29,64 +29,59 @@ export declare class KaminoLendingClient {
     /**
      * Initializes Kamino user metadata
      *
-     * @param statePda
      * @param market Lending market
      * @param referrer Referrer user metadata
      * @param txOptions
      * @returns
      */
-    initUserMetadata(statePda: PublicKey | string, referrer?: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    initUserMetadata(txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Deposits asset to the lending market.
      *
-     * @param statePda
      * @param market Lending market
      * @param asset Asset mint
      * @param amount Amount to deposit
      * @param txOptions
      * @returns
      */
-    deposit(statePda: PublicKey | string, market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deposit(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Withdraws asset from the lending market.
      *
-     * @param statePda
      * @param market Lending market
      * @param asset Asset mint
      * @param amount Amount to deposit
      * @param txOptions
      * @returns
      */
-    withdraw(statePda: PublicKey | string, market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Borrows asset from the lending market.
      *
-     * @param statePda GLAM state
      * @param market Lending market
      * @param asset Asset mint
      * @param amount Amount to borrow
      * @param txOptions
      * @returns
      */
-    borrow(statePda: PublicKey | string, market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    borrow(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Repays asset to the lending market.
      *
-     * @param statePda
      * @param market
      * @param asset
      * @param amount
      * @param txOptions
      * @returns
      */
-    repay(statePda: PublicKey | string, market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    repay(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
     getUserMetadataPda(owner: PublicKey): PublicKey;
     getObligationPda(owner: PublicKey, market: PublicKey, args?: {
         tag: number;
         id: number;
     }): PublicKey;
     getObligationFarmState(obligation: PublicKey, farm: PublicKey): PublicKey;
-    initUserMetadataTx(glamState: PublicKey, referrer: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    initUserMetadataTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
     refreshReserveIxs(lendingMarket: PublicKey, reserves: PublicKey[]): TransactionInstruction[];
     refreshObligationFarmsForReserveIxs(obligation: PublicKey, lendingMarket: PublicKey, parsedReserves: ParsedReserve[]): TransactionInstruction[];
     getRefreshIxs(obligation: PublicKey, refreshFarms?: boolean): Promise<TransactionInstruction[]>;
@@ -116,10 +111,10 @@ export declare class KaminoLendingClient {
     };
     fetchAndParseReserves(reserves: PublicKey[]): Promise<ParsedReserve[]>;
     findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<ParsedReserve>;
-    depositTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    withdrawTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    borrowTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    repayTx(glamState: PublicKey, market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    withdrawTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    borrowTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    repayTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class KaminoFarmClient {
     readonly base: BaseClient;
@@ -141,7 +136,7 @@ export declare class KaminoFarmClient {
     fetchAndParseFarms(farms: PublicKey[]): Promise<Map<any, any>>;
     farmVaultsAuthority: (farm: PublicKey) => PublicKey;
     rewardsTreasuryVault: (globalConfig: PublicKey, mint: PublicKey) => PublicKey;
-    harvest(statePda: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
-    harvestTx(glamState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    harvest(txOptions?: TxOptions): Promise<TransactionSignature>;
+    harvestTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export {};

package/src/client/marinade.d.ts

@@ -11,12 +11,12 @@ export type Ticket = {
 export declare class MarinadeClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    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[]>;
+    deposit(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositStakeAccount(stakeAccount: PublicKey): Promise<TransactionSignature>;
+    orderUnstake(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    claim(tickets: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    getTickets(): Promise<PublicKey[]>;
+    getParsedTickets(): Promise<Ticket[]>;
     getMarinadeState(): {
         marinadeStateAddress: PublicKey;
         msolMintAddress: PublicKey;
@@ -28,8 +28,8 @@ export declare class MarinadeClient {
         solLeg: PublicKey;
     };
     getParsedStakeAccountInfo(stakeAccount: PublicKey): Promise<any>;
-    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>;
+    depositTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    depositStakeAccountTx(stakeAccount: PublicKey, txOptions: TxOptions): Promise<any>;
+    orderUnstakeTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
+    claimTx(tickets: PublicKey[], txOptions: TxOptions): Promise<VersionedTransaction>;
 }

package/src/client/meteora.d.ts

@@ -7,12 +7,12 @@ export declare class MeteoraDlmmClient {
     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>;
+    initializePosition(pool: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    initializePositionPda(pool: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    addLiquidityByStrategy(position: PublicKey | string, amountX: BN | number, amountY: BN | number, strategyType: keyof typeof Strategy, txOptions?: TxOptions): Promise<string>;
+    removeLiquidityByRange(position: PublicKey | string, bpsToRemove: number, txOptions?: TxOptions): Promise<string>;
+    claimFee(position: PublicKey | string, txOptions?: TxOptions): Promise<string>;
+    closePosition(position: PublicKey | string, txOptions?: TxOptions): Promise<TransactionSignature>;
     getPositionPda(lbPair: PublicKey, base: PublicKey, lowerBinId: number, // i32
     width: number): PublicKey;
     autoFillY(dlmmPool: DLMM, amountX: BN): Promise<{

package/src/client/mint.d.ts

@@ -5,62 +5,54 @@ import { MintModel } from "../models";
 export declare class MintClient {
     readonly base: BaseClient;
     constructor(base: BaseClient);
-    fetchTokenHolders(state: PublicKey, mintId?: number): Promise<TokenAccount[]>;
-    getHolders(state: PublicKey, mintId?: number): Promise<TokenAccount[]>;
-    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>;
+    fetchTokenHolders(): Promise<TokenAccount[]>;
+    getHolders(): Promise<TokenAccount[]>;
+    update(mintModel: Partial<MintModel>, txOptions?: TxOptions): Promise<string>;
+    updateApplyTimelock(txOptions?: TxOptions): Promise<string>;
+    emergencyUpdate(mintModel: Partial<MintModel>, txOptions?: TxOptions): Promise<string>;
+    closeMintIx(): Promise<anchor.web3.TransactionInstruction>;
+    closeMint(txOptions?: TxOptions): Promise<string>;
     /**
-     * Create a glam mint token account for a specific user
+     * Create a glam mint token account for the specified user
      *
-     * @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 Transaction signature
      */
-    createTokenAccount(glamState: PublicKey, owner: PublicKey, mintId?: number, setFrozen?: boolean, txOptions?: TxOptions): Promise<string>;
+    createTokenAccount(owner: PublicKey, setFrozen?: boolean, txOptions?: TxOptions): Promise<string>;
     /**
      * Freeze or unfreeze token accounts of a glam mint
      *
-     * @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 Transaction signature
      */
-    setTokenAccountsStates(glamState: PublicKey, mintId: number, tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<string>;
+    setTokenAccountsStates(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
      */
-    mint(glamState: PublicKey, mintId: number, recipient: PublicKey, amount: anchor.BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    mint(recipient: PublicKey, amount: anchor.BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Burn tokens from a token account
      *
-     * @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
      */
-    burn(glamState: PublicKey, mintId: number, amount: anchor.BN, from: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    burn(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
@@ -68,5 +60,5 @@ export declare class MintClient {
      * @param txOptions
      * @returns
      */
-    forceTransfer(glamState: PublicKey, mintId: number, amount: anchor.BN, from: PublicKey, to: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    forceTransfer(amount: anchor.BN, from: PublicKey, to: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
 }

package/src/client/price.d.ts

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