@glamsystems/glam-sdk 0.1.4

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@glamsystems/glam-sdk",
+  "version": "0.1.4",
+  "description": "TypeScript SDK for 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"
+  },
+  "keywords": [
+    "glam-protocol",
+    "solana"
+  ],
+  "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@coral-xyz/anchor": "^0.30.1",
+    "@drift-labs/sdk": "2.96.0-beta.14",
+    "@marinade.finance/marinade-ts-sdk": "^5.0.15",
+    "@pythnetwork/client": "^2.21.1",
+    "@solana/spl-stake-pool": "^1.1.5",
+    "@solana/spl-token": "^0.4.9",
+    "@solana/spl-token-metadata": "^0.1.4",
+    "@solana/web3.js": "^1.98.0",
+    "bs58": "^5.0.0",
+    "buffer": "^6.0.3"
+  },
+  "engines": {
+    "node": ">=20.18.0"
+  },
+  "devDependencies": {
+    "@rollup/plugin-terser": "^0.4.4",
+    "rollup-plugin-javascript-obfuscator": "^1.0.4"
+  },
+  "pnpm": {
+    "overrides": {
+      "@solana/web3.js@>=0.0.1": "^1.98.0",
+      "@solana/spl-token@>=0.0.1": "^0.3.9",
+      "@solana/spl-stake-pool@>=0.0.1": "^1.1.5",
+      "typescript@>=0.0.1": "^5.5.3",
+      "solana-bankrun@>=0.0.1": "^0.3.0"
+    }
+  }
+}

package/src/client/assets.d.ts

@@ -0,0 +1,18 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Metadata for an asset for pricing
+ */
+export declare class AssetMeta {
+    pricingAccount?: PublicKey;
+    stateAccount?: PublicKey;
+    priceFeed?: string;
+    programId?: PublicKey;
+}
+/**
+ * We use sponsored feed listed on https://docs.pyth.network/price-feeds/sponsored-feeds/solana for popular tokens.
+ *
+ * For PYUSD, we use the price feed from Drift.
+ * For LSTs, we use the state account to calculate the price based on the number of SOLs locked.
+ */
+export declare const ASSETS_MAINNET: Map<string, AssetMeta>;
+export declare const ASSETS_TESTS: Map<string, AssetMeta>;

package/src/client/base.d.ts

@@ -0,0 +1,100 @@
+import * as anchor from "@coral-xyz/anchor";
+import { Wallet } from "@coral-xyz/anchor";
+import { AddressLookupTableAccount, BlockhashWithExpiryBlockHeight, Keypair, PublicKey, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { Mint } from "@solana/spl-token";
+import { GlamProgram } from "../glamExports";
+import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
+import { StateAccount, MetadataAccount, 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 isBrowser: string | boolean;
+export type TxOptions = {
+    signer?: PublicKey;
+    computeUnitLimit?: number;
+    getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
+    jitoTipLamports?: number;
+    preInstructions?: TransactionInstruction[];
+};
+export type TokenAccount = {
+    owner: PublicKey;
+    pubkey: PublicKey;
+    mint: PublicKey;
+    programId: PublicKey;
+    decimals: number;
+    amount: string;
+    uiAmount: number;
+    frozen: boolean;
+};
+export declare class BaseClient {
+    cluster: ClusterNetwork;
+    provider: anchor.Provider;
+    program: GlamProgram;
+    jupiterApi: string;
+    blockhashWithCache: BlockhashWithCache;
+    constructor(config?: GlamClientConfig);
+    isMainnet(): boolean;
+    isPhantom(): boolean;
+    /**
+     * Get metadata of an asset for pricing
+     *
+     * @param assetMint Token mint of the asset
+     * @returns Metadata of the asset
+     */
+    getAssetMeta(assetMint: string): AssetMeta;
+    intoVersionedTransaction({ tx, lookupTables, signer, computeUnitLimit, getPriorityFeeMicroLamports, jitoTipLamports, latestBlockhash, }: {
+        tx: Transaction;
+        lookupTables?: Array<AddressLookupTableAccount> | [];
+        signer?: PublicKey;
+        computeUnitLimit?: number;
+        getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
+        jitoTipLamports?: number;
+        latestBlockhash?: BlockhashWithExpiryBlockHeight;
+    }): Promise<VersionedTransaction>;
+    sendAndConfirm(tx: VersionedTransaction | Transaction, signerOverride?: Keypair): Promise<TransactionSignature>;
+    parseProgramLogs(logs?: null | string[]): string;
+    getWallet(): Wallet;
+    getSigner(): PublicKey;
+    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;
+    /**
+     * Fetch all the token accounts (including token program and token 2022 program) owned by a public key.
+     *
+     * @param owner
+     * @returns
+     */
+    getTokenAccountsByOwner(owner: PublicKey): Promise<TokenAccount[]>;
+    getVaultBalance(statePda: PublicKey): Promise<number>;
+    getVaultTokenBalance(statePda: PublicKey, mint: PublicKey, programId?: PublicKey): Promise<number>;
+    fetchMintWithOwner(asset: PublicKey): Promise<{
+        mint: Mint;
+        tokenProgram: anchor.web3.PublicKey;
+    }>;
+    getOpenfundsPda(statePda: PublicKey): PublicKey;
+    getShareClassPda(statePda: PublicKey, mintIdx?: number): PublicKey;
+    getShareClassAta(user: PublicKey, shareClassPDA: PublicKey): PublicKey;
+    getName(stateModel: Partial<StateModel>): string;
+    fetchStateAccount(statePda: PublicKey): Promise<StateAccount>;
+    fetchMetadataAccount(state: PublicKey): Promise<MetadataAccount>;
+    fetchShareClassAccount(state: PublicKey, mintIdx: number): Promise<Mint>;
+    /**
+     * Generates instructions to wrap SOL into wSOL if the vault doesn't have enough wSOL
+     *
+     * @param lamports Desired amount of wSOL
+     * @returns
+     */
+    maybeWrapSol(state: PublicKey, amount: number | anchor.BN, signer?: PublicKey): Promise<TransactionInstruction | null>;
+    getAssetIdFromCurrency(currency: string): string;
+    listGlamStates(): Promise<PublicKey[]>;
+    /**
+     * Fetch glam state from onchain accounts and build a StateModel
+     *
+     * @param statePda
+     * @returns
+     */
+    fetchState(statePda: PublicKey): Promise<StateModel>;
+    fetchAllGlamStates(): Promise<StateModel[]>;
+}

package/src/client/drift.d.ts

@@ -0,0 +1,92 @@
+import * as anchor from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
+import { MarketType, OrderParams, PositionDirection, SpotPosition, PerpPosition } from "@drift-labs/sdk";
+import { BaseClient, TxOptions } from "./base";
+import { AccountMeta } from "@solana/web3.js";
+import { StateModel } from "../models";
+interface OrderConstants {
+    perpBaseScale: number;
+    quoteScale: number;
+}
+export interface PerpMarketConfig {
+    fullName: string;
+    categories: string[];
+    symbol: string;
+    baseAsset: string;
+    marketIndex: number;
+    launchTs: string;
+    oracle: string;
+    oracleSource: string;
+    pythPullOraclePDA: string;
+    pythFeedId: string;
+    marketPDA: string;
+}
+export interface SpotMarketConfig {
+    symbol: string;
+    decimals: number;
+    marketIndex: number;
+    launchTs?: string;
+    oracle: string;
+    oracleSource: string;
+    pythPullOraclePDA: string;
+    pythFeedId: string;
+    marketPDA: string;
+    mint: string;
+    serumMarket?: string;
+    phoenixMarket?: string;
+    openBookMarket?: string;
+    vaultPDA: string;
+}
+export interface DriftMarketConfigs {
+    orderConstants: OrderConstants;
+    perp: PerpMarketConfig[];
+    spot: SpotMarketConfig[];
+}
+export interface GlamDriftUser {
+    delegate: string;
+    name: string;
+    spotPositions: SpotPosition[];
+    perpPositions: PerpPosition[];
+    marginMode: string;
+    subAccountId: number;
+    isMarginTradingEnabled: boolean;
+}
+export declare class DriftClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    initialize(statePda: PublicKey): 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, delegate: PublicKey, subAccountId?: number): 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>;
+    cancelOrders(statePda: PublicKey, marketType: MarketType, marketIndex: number, direction: PositionDirection, 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[];
+        perpPositions: PerpPosition[];
+    }>;
+    fetchPolicyConfig(glamState: StateModel): Promise<{
+        driftAccessControl: number;
+        driftDelegatedAccount: any;
+        driftMarketIndexesPerp: number[];
+        driftOrderTypes: number[];
+        driftMaxLeverage: number;
+        driftEnableSpot: any;
+        driftMarketIndexesSpot: number[];
+    }>;
+    composeRemainingAccounts(glamState: PublicKey, subAccountId: number, marketType: MarketType, marketIndex: number, marketConfigs: DriftMarketConfigs): Promise<AccountMeta[]>;
+    initializeTx(statePda: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserCustomMarginRatioTx(statePda: PublicKey, maxLeverage: number, // 1=1x, 2=2x ... 50=50x leverage
+    subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserMarginTradingEnabledTx(statePda: PublicKey, marginTradingEnabled: boolean, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateUserDelegateTx(statePda: PublicKey, delegate: PublicKey, subAccountId?: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositTx(statePda: 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(statePda: PublicKey, orderParams: OrderParams, 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>;
+}
+export {};

package/src/client/investor.d.ts

@@ -0,0 +1,12 @@
+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, shareClassId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    redeem(statePda: PublicKey, amount: BN, inKind?: boolean, stateModel?: StateModel, shareClassId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    subscribeTx(statePda: PublicKey, asset: PublicKey, amount: BN, stateModel?: StateModel, shareClassId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    redeemTx(statePda: PublicKey, amount: BN, inKind?: boolean, stateModel?: StateModel, shareClassId?: number, skipState?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}

package/src/client/jupiter.d.ts

@@ -0,0 +1,84 @@
+import { BN } from "@coral-xyz/anchor";
+import { AddressLookupTableAccount, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, TxOptions } from "./base";
+export type QuoteParams = {
+    inputMint: string;
+    outputMint: string;
+    amount: number;
+    autoSlippage?: boolean;
+    autoSlippageCollisionUsdValue?: number;
+    slippageBps?: number;
+    swapMode?: string;
+    onlyDirectRoutes?: boolean;
+    asLegacyTransaction?: boolean;
+    maxAccounts?: number;
+    dexes?: string[];
+    excludeDexes?: string[];
+};
+export type QuoteResponse = {
+    inputMint: string;
+    inAmount: number | string;
+    outputMint: string;
+    outAmount: number | string;
+    otherAmountThreshold: number | string;
+    swapMode: string;
+    slippageBps: number;
+    platformFee: number | null;
+    priceImpactPct: number | string;
+    routePlan: any[];
+    contextSlot: number;
+    timeTaken: number;
+};
+type JsonAccountMeta = {
+    pubkey: string;
+    isSigner: boolean;
+    isWritable: boolean;
+};
+type InstructionFromJupiter = {
+    programId: string;
+    accounts: JsonAccountMeta[];
+    data: string;
+};
+type SwapInstructions = {
+    tokenLedgerInstruction?: InstructionFromJupiter | null;
+    otherInstructions?: InstructionFromJupiter[];
+    computeBudgetInstructions: InstructionFromJupiter[];
+    setupInstructions?: InstructionFromJupiter[];
+    swapInstruction: InstructionFromJupiter;
+    cleanupInstruction?: InstructionFromJupiter;
+    addressLookupTableAddresses: string[];
+};
+export declare class JupiterClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    swap(statePda: PublicKey, quoteParams?: QuoteParams, quoteResponse?: QuoteResponse, swapInstructions?: SwapInstructions, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Stake JUP. The escrow account will be created if it doesn't exist.
+     *
+     * @param statePda
+     * @param amount
+     * @param txOptions
+     * @returns
+     */
+    stakeJup(statePda: PublicKey, amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    unstakeJup(statePda: PublicKey, txOptions?: TxOptions): Promise<string>;
+    /**
+     * Vote on a proposal. The vote account will be created if it doesn't exist.
+     *
+     * @param statePda
+     * @param proposal
+     * @param governor
+     * @param side
+     * @param txOptions
+     * @returns
+     */
+    voteOnProposal(statePda: PublicKey, proposal: PublicKey, governor: PublicKey, side: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    swapTx(statePda: PublicKey, quoteParams?: QuoteParams, quoteResponse?: QuoteResponse, swapInstructions?: SwapInstructions, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    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) => TransactionInstruction;
+    getAdressLookupTableAccounts: (keys?: string[]) => Promise<AddressLookupTableAccount[]>;
+    getQuoteResponse(quoteParams: QuoteParams): Promise<any>;
+    getSwapInstructions(quoteResponse: any, from: PublicKey): Promise<any>;
+}
+export {};

package/src/client/marinade.d.ts

@@ -0,0 +1,27 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
+import { BaseClient, TxOptions } from "./base";
+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): Promise<TransactionSignature>;
+    claimTickets(statePda: PublicKey, tickets: PublicKey[]): Promise<TransactionSignature>;
+    getMarinadeTicketPda(state: PublicKey, ticketId: string): [PublicKey, number];
+    getExistingTickets(state: PublicKey): Promise<PublicKey[]>;
+    getTickets(state: PublicKey): Promise<{
+        address: PublicKey;
+        lamports: number;
+        createdEpoch: number;
+        isDue: boolean;
+    }[]>;
+    getMarinadeState(): any;
+    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>;
+}

package/src/client/shareclass.d.ts

@@ -0,0 +1,44 @@
+import * as anchor from "@coral-xyz/anchor";
+import { PublicKey, TransactionSignature } from "@solana/web3.js";
+import { BaseClient, TokenAccount, TxOptions } from "./base";
+export declare class ShareClassClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    getHolders(state: PublicKey, shareClassId?: number): Promise<TokenAccount[]>;
+    closeShareClassIx(state: PublicKey, shareClassId?: number): Promise<anchor.web3.TransactionInstruction>;
+    closeShareClass(state: PublicKey, shareClassId?: number, txOptions?: TxOptions): Promise<string>;
+    /**
+     * Create a share class token account for a specific user
+     *
+     * @param state
+     * @param owner
+     * @param shareClassId
+     * @param txOptions
+     * @returns
+     */
+    createTokenAccount(state: PublicKey, owner: PublicKey, shareClassId?: number, setFrozen?: boolean, txOptions?: TxOptions): Promise<string>;
+    /**
+     * Freeze or thaw token accounts of a share class
+     *
+     * @param state
+     * @param shareClassId
+     * @param frozen
+     * @param txOptions
+     * @returns
+     */
+    setTokenAccountsStates(state: PublicKey, shareClassId: number, tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<string>;
+    /**
+     * Mint share to recipient
+     *
+     * @param state
+     * @param shareClassId
+     * @param recipient Recipient's wallet address
+     * @param amount Amount of shares to mint
+     * @param forceThaw If true, force thaw token account before minting
+     * @param txOptions
+     * @returns Transaction signature
+     */
+    mintShare(state: PublicKey, shareClassId: number, recipient: PublicKey, amount: anchor.BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    burnShare(state: PublicKey, shareClassId: number, amount: anchor.BN, from: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    forceTransferShare(state: PublicKey, shareClassId: number, amount: anchor.BN, from: PublicKey, to: PublicKey, forceThaw?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+}

package/src/client/staking.d.ts

@@ -0,0 +1,58 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
+import { BaseClient, TxOptions } from "./base";
+import { MarinadeClient } from "./marinade";
+interface StakePoolAccountData {
+    programId: PublicKey;
+    depositAuthority: PublicKey;
+    withdrawAuthority: PublicKey;
+    poolMint: PublicKey;
+    feeAccount: PublicKey;
+    reserveStake: PublicKey;
+    tokenProgramId: PublicKey;
+    validatorList: PublicKey;
+}
+type StakeAccountInfo = {
+    address: PublicKey;
+    lamports: number;
+    state: string;
+    voter?: PublicKey;
+};
+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<{
+        newStake: PublicKey;
+        txSig: TransactionSignature;
+    }>;
+    redelegateStake(statePda: PublicKey, existingStake: PublicKey, vote: PublicKey): 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>;
+    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, newStake: PublicKey, newStakeAccountId: string, newStakeAccountBump: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    redelegateStakeTx(statePda: PublicKey, existingStake: PublicKey, vote: PublicKey, newStake: PublicKey, newStakeAccountId: string, newStakeAccountBump: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export {};

package/src/client/state.d.ts

@@ -0,0 +1,41 @@
+import { PublicKey, VersionedTransaction, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+import { BaseClient, TxOptions } from "./base";
+import { DelegateAcl, StateModel } from "../models";
+export declare class StateClient {
+    readonly base: BaseClient;
+    constructor(base: BaseClient);
+    createState(partialStateModel: Partial<StateModel>, singleTx?: boolean, txOptions?: TxOptions): Promise<[TransactionSignature, PublicKey]>;
+    updateState(statePda: PublicKey, updated: Partial<StateModel>, txOptions?: TxOptions): Promise<TransactionSignature>;
+    closeState(statePda: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Create a full state model from a partial state model
+     */
+    enrichStateModel(partialStateModel: Partial<StateModel>): StateModel;
+    /**
+     * Delete delegates' access to the fund
+     *
+     * @param statePda
+     * @param delegates Public keys of delegates to be deleted
+     * @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>;
+    /**
+     * Close fund treasury's token accounts
+     *
+     * @param statePda
+     * @param tokenAccounts
+     * @param txOptions
+     * @returns
+     */
+    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>;
+    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>;
+}

package/src/client/wsol.d.ts

@@ -0,0 +1,11 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
+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>;
+}

package/src/client.d.ts

@@ -0,0 +1,35 @@
+import { GlamClientConfig } from "./clientConfig";
+import { BaseClient } from "./client/base";
+import { DriftClient } from "./client/drift";
+import { InvestorClient } from "./client/investor";
+import { JupiterClient } from "./client/jupiter";
+import { MarinadeClient } from "./client/marinade";
+import { WSolClient } from "./client/wsol";
+import { StakingClient } from "./client/staking";
+import { StateClient } from "./client/state";
+import { ShareClassClient } from "./client/shareclass";
+export { JUPITER_API_DEFAULT } from "./client/base";
+/**
+ * Main entrypoint for the GLAM SDK
+ *
+ * Lazy loads each client/module at first use
+ */
+export declare class GlamClient extends BaseClient {
+    private _drift?;
+    private _investor?;
+    private _jupiter?;
+    private _marinade?;
+    private _wsol?;
+    private _staking?;
+    private _state?;
+    private _shareClass?;
+    constructor(config?: GlamClientConfig);
+    get drift(): DriftClient;
+    get investor(): InvestorClient;
+    get jupiter(): JupiterClient;
+    get marinade(): MarinadeClient;
+    get wsol(): WSolClient;
+    get staking(): StakingClient;
+    get state(): StateClient;
+    get shareClass(): ShareClassClient;
+}

package/src/clientConfig.d.ts

@@ -0,0 +1,13 @@
+import { Provider, Wallet } from "@coral-xyz/anchor";
+export declare enum ClusterNetwork {
+    Mainnet = "mainnet-beta",
+    Testnet = "testnet",
+    Devnet = "devnet",
+    Custom = "custom"
+}
+export type GlamClientConfig = {
+    provider?: Provider;
+    wallet?: Wallet;
+    cluster?: ClusterNetwork;
+    jupiterApi?: string;
+};

package/src/constants.d.ts

@@ -0,0 +1,31 @@
+import { PublicKey } from "@solana/web3.js";
+/**
+ * Token mints. If no devnet version is defined, assume mainnet and devnet addresses are the same.
+ *
+ * Unless otherwise noted, all mints have 9 decimals.
+ */
+export declare const WSOL: PublicKey;
+export declare const MSOL: PublicKey;
+export declare const JITOSOL: PublicKey;
+export declare const USDC: PublicKey;
+export declare const WETH: PublicKey;
+export declare const WBTC: PublicKey;
+export declare const JUP: PublicKey;
+/**
+ * Program IDs
+ */
+export declare const MARINADE_PROGRAM_ID: PublicKey;
+export declare const DRIFT_PROGRAM_ID: PublicKey;
+export declare const JUPITER_PROGRAM_ID: PublicKey;
+export declare const SANCTUM_STAKE_POOL_PROGRAM_ID: PublicKey;
+export declare const GOVERNANCE_PROGRAM_ID: PublicKey;
+/**
+ * Stake pools
+ */
+export declare const JITO_STAKE_POOL: PublicKey;
+export declare const JUPSOL_STAKE_POOL: PublicKey;
+/**
+ * JUP staking & voting
+ */
+export declare const JUP_STAKE_LOCKER: PublicKey;
+export declare const JUP_VOTE_PROGRAM: PublicKey;

package/src/error.d.ts

@@ -0,0 +1,7 @@
+import { TransactionError } from "@solana/web3.js";
+export declare class GlamError extends Error {
+    message: string;
+    rawError?: TransactionError;
+    programLogs?: string[];
+    constructor(message: string, rawError?: TransactionError, programLogs?: string[]);
+}

package/src/glamExports.d.ts

@@ -0,0 +1,11 @@
+import { Program } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import type { ClusterNetwork } from "./clientConfig";
+import type { Glam } from "../target/types/glam";
+import GlamIDLJson from "../target/idl/glam.json";
+declare const GlamIDL: Glam;
+export { Glam, GlamIDL, GlamIDLJson };
+export type GlamProgram = Program<Glam>;
+export declare const GLAM_PROGRAM_ID_DEV: PublicKey;
+export declare const GLAM_PROGRAM_ID_MAINNET: PublicKey;
+export declare function getGlamProgramId(cluster: ClusterNetwork): PublicKey;

package/src/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./glamExports";
+export * from "./models";
+export * from "./clientConfig";
+export * from "./client";
+export * from "./client/jupiter";
+export * from "./client/drift";
+export * from "./utils/helpers";
+export * from "./utils/priorityfee";
+export * from "./constants";
+export * from "./error";