Overview
BaseClient provides core functionality used by all GLAM SDK clients. It manages connections, programs, transactions, and common utilities.
Constructor
new BaseClient(config?: GlamClientConfig)
Configuration options for the client
Anchor provider instance. If not provided, uses anchor.AnchorProvider.env()
Wallet instance for signing transactions
Solana cluster network. Auto-detected from provider URL if not specified
State account public key to connect to a vault
Jupiter API key for swap operations
Custom Jupiter API client instance
Use staging programs instead of production
Properties
cluster
client.cluster: ClusterNetwork
provider
client.provider: anchor.Provider
connection
client.connection: Connection
signer
Public key of the transaction signer from the provider.
wallet
Wallet instance for signing transactions.
statePda
client.statePda: PublicKey
client.statePda = new PublicKey("...");
vaultPda
client.vaultPda: PublicKey
statePda.
mintPda
client.mintPda: PublicKey
statePda.
escrowPda
client.escrowPda: PublicKey
mintPda. Used for queued subscriptions/redemptions.
isVaultConnected
client.isVaultConnected: boolean
true if a vault state PDA has been set.
isMainnet
client.isMainnet: boolean
true if connected to mainnet-beta.
Program accessors
These getters provide access to GLAM program instances. All are lazy-loaded.
protocolProgram
client.protocolProgram: GlamProtocolProgram
mintProgram
client.mintProgram: GlamMintProgram
extSplProgram
client.extSplProgram: ExtSplProgram
extDriftProgram
client.extDriftProgram: ExtDriftProgram
extKaminoProgram
client.extKaminoProgram: ExtKaminoProgram
extMarinadeProgram
client.extMarinadeProgram: ExtMarinadeProgram
extStakePoolProgram
client.extStakePoolProgram: ExtStakePoolProgram
extCctpProgram
client.extCctpProgram: ExtCctpProgram
extOffchainProgram
client.extOffchainProgram: ExtOffchainProgram
Transaction methods
intoVersionedTransaction
async intoVersionedTransaction(
tx: Transaction,
options: TxOptions
): Promise<VersionedTransaction>
Legacy transaction to convert
Transaction signer. Defaults to client.signer
Compute unit limit. Auto-calculated via simulation if not provided
getPriorityFeeMicroLamports
(tx: VersionedTransaction) => Promise<number>
Function to calculate priority fee
lookupTables
PublicKey[] | AddressLookupTableAccount[]
Address lookup tables
Throw error if simulation fails
This method automatically:
- Simulates the transaction to compute optimal CU limit
- Adds compute budget instructions
- Includes GLAM-specific lookup tables
- Fetches fresh blockhash
sendAndConfirm
async sendAndConfirm(
tx: VersionedTransaction | Transaction,
additionalSigners?: Keypair[]
): Promise<TransactionSignature>
tx
VersionedTransaction | Transaction
required
Transaction to send
Additional keypair signers
const tx = await client.intoVersionedTransaction(transaction, {});
const signature = await client.sendAndConfirm(tx);
console.log("Transaction:", signature);
This method:
- Uses a dedicated TX RPC endpoint on mainnet if configured via
TX_RPC env var
- Skips preflight since simulation already occurred
- Waits for confirmation via WebSocket or polling
- Throws
GlamError with parsed program logs on failure
Account data methods
fetchStateAccount
async fetchStateAccount(statePda?: PublicKey): Promise<StateAccount>
fetchStateModel
async fetchStateModel(statePda?: PublicKey): Promise<StateModel>
const state = await client.fetchStateModel();
console.log("Vault name:", state.nameStr);
console.log("Assets:", state.assets);
console.log("Base asset:", state.baseAssetMint);
fetchGlamStates
async fetchGlamStates(filterOptions?: {
owner?: PublicKey;
delegate?: PublicKey;
type?: string;
}): Promise<StateModel[]>
Filter by account type (e.g., “tokenizedVault”)
// Get all vaults owned by a manager
const vaults = await client.fetchGlamStates({
owner: managerPublicKey,
type: "tokenizedVault"
});
fetchRequestQueue
async fetchRequestQueue(requestQueuePda?: PublicKey): Promise<RequestQueue>
fetchProtocolPolicy
async fetchProtocolPolicy<T>(
integProgramId: PublicKey,
protocolBitflag: number,
policyClass: { decode(buffer: Buffer, staging?: boolean): T }
): Promise<T | null>
Balance methods
getSolAndTokenBalances
async getSolAndTokenBalances(owner: PublicKey): Promise<{
balanceLamports: number;
uiAmount: number;
tokenAccounts: TokenAccount[];
}>
getVaultBalance
async getVaultBalance(): Promise<number>
getVaultLamports
async getVaultLamports(): Promise<number>
getVaultTokenBalance
async getVaultTokenBalance(mintPubkey: PublicKey): Promise<{
amount: BN;
uiAmount: number;
}>
const balance = await client.getVaultTokenBalance(USDC_MINT);
console.log("USDC balance:", balance.uiAmount);
getMintTokenBalance
async getMintTokenBalance(owner?: PublicKey): Promise<{
amount: BN;
uiAmount: number;
}>
ATA helpers
getAta
getAta(
mint: PublicKey,
owner: PublicKey,
tokenProgram?: PublicKey
): PublicKey
getVaultAta
getVaultAta(mint: PublicKey, tokenProgramId?: PublicKey): PublicKey
getMintAta
getMintAta(user?: PublicKey): PublicKey
Utility methods
isLockupEnabled
async isLockupEnabled(): Promise<boolean>
Types
TxOptions
type TxOptions = {
signer?: PublicKey;
computeUnitLimit?: number;
getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
maxFeeLamports?: number;
useMaxFee?: boolean;
preInstructions?: TransactionInstruction[];
postInstructions?: TransactionInstruction[];
lookupTables?: PublicKey[] | AddressLookupTableAccount[];
simulate?: boolean;
}
TokenAccount
type TokenAccount = {
owner: PublicKey;
pubkey: PublicKey;
mint: PublicKey;
programId: PublicKey;
decimals: number;
amount: string;
uiAmount: number;
frozen: boolean;
}