Overview
InvestClient manages investor operations including subscribing to funds, redeeming shares, and managing queued requests.
Access
const client = new GlamClient();
client.invest.subscribe(...);
Methods
subscribe
async subscribe(
amount: BN,
queued?: boolean,
txOptions?: TxOptions
): Promise<TransactionSignature>
Amount of base asset to deposit (in smallest unit)
Whether to queue the subscription for later fulfillment or execute immediately
import { BN } from "@coral-xyz/anchor";
// Immediate subscription - get shares right away
await client.invest.subscribe(new BN(100_000_000)); // 100 USDC
// Queued subscription - request is pending until fulfilled by manager
await client.invest.subscribe(new BN(100_000_000), true);
Immediate vs Queued subscriptions:
-
Immediate (queued=false): Investor receives shares immediately at current share price. Used when the vault accepts instant subscriptions.
-
Queued (queued=true): Subscription is added to request queue. The manager must fulfill it later at the NAV calculated at fulfillment time. Investor must then claim their shares.
For SOL/wSOL deposits, the method automatically wraps and unwraps as needed. queuedRedeem
async queuedRedeem(
amount: BN,
txOptions?: TxOptions
): Promise<TransactionSignature>
Amount of share tokens to redeem (in smallest unit, typically 9 decimals)
// Queue redemption of 50 share tokens
await client.invest.queuedRedeem(new BN(50_000_000_000));
Redemptions are always queued. The manager must fulfill the request, then the investor can claim their base asset.If lockup is enabled on the fund, share tokens are transferred to escrow until the redemption is fulfilled or cancelled.
cancel
async cancel(txOptions?: TxOptions): Promise<TransactionSignature>
// Cancel my pending request
await client.invest.cancel();
cancelForUser
async cancelForUser(
user: PublicKey,
txOptions?: TxOptions
): Promise<TransactionSignature>
User whose request to cancel
// Manager cancels a user's request
await client.invest.cancelForUser(userPubkey);
fulfill
async fulfill(
limit: number | null,
txOptions?: TxOptions
): Promise<TransactionSignature>
Maximum number of requests to fulfill in this transaction, or null to fulfill all
// Fulfill up to 10 pending requests
await client.invest.fulfill(10);
// Fulfill all pending requests
await client.invest.fulfill(null);
Fulfillment calculates the current NAV and determines how many shares to mint (for subscriptions) or how much base asset to return (for redemptions). Investors must call claim() after fulfillment to receive their tokens.
claim
async claim(txOptions?: TxOptions): Promise<TransactionSignature>
// Claim my fulfilled request
await client.invest.claim();
For subscriptions, this transfers share tokens from escrow to the investor.For redemptions, this transfers the base asset from escrow to the investor. If the base asset is wSOL, the account is automatically closed to return native SOL.
claimForUser
async claimForUser(
user: PublicKey,
txOptions?: TxOptions
): Promise<TransactionSignature>
User whose request to claim
// Claim for a user
await client.invest.claimForUser(userPubkey);
fetchPendingRequest
async fetchPendingRequest(
user?: PublicKey
): Promise<PendingRequest | null>
User to fetch request for. Defaults to signer
PendingRequest object or null if no pending request exists.
// Check if I have a pending request
const myRequest = await client.invest.fetchPendingRequest();
if (myRequest) {
console.log("Request type:", myRequest.requestType);
console.log("Amount:", myRequest.amount.toString());
console.log("Fulfilled:", myRequest.fulfilled);
}
// Check another user's pending request
const userRequest = await client.invest.fetchPendingRequest(userPubkey);
Transaction builder
For advanced use cases, access the transaction builder directly:
client.invest.txBuilder: TxBuilder
subscribeIxs
async subscribeIxs(
amount: BN,
signer: PublicKey
): Promise<TransactionInstruction[]>
subscribeTx
async subscribeTx(
amount: BN,
txOptions: TxOptions
): Promise<VersionedTransaction>
queuedSubscribeIxs
async queuedSubscribeIxs(
amount: BN,
signer: PublicKey
): Promise<TransactionInstruction[]>
queuedSubscribeTx
async queuedSubscribeTx(
amount: BN,
txOptions: TxOptions
): Promise<VersionedTransaction>
queuedRedeemIx
async queuedRedeemIx(
amount: BN,
signer: PublicKey
): Promise<TransactionInstruction>
queuedRedeemTx
async queuedRedeemTx(
amount: BN,
txOptions: TxOptions
): Promise<VersionedTransaction>
cancelIx
async cancelIx(
pubkey: PublicKey | null,
signer: PublicKey
): Promise<TransactionInstruction>
cancelTx
async cancelTx(
pubkey: PublicKey | null,
txOptions: TxOptions
): Promise<VersionedTransaction>
fulfillIx
async fulfillIx(
limit: number | null,
signer: PublicKey
): Promise<TransactionInstruction>
fulfillTx
async fulfillTx(
limit: number | null,
txOptions: TxOptions
): Promise<VersionedTransaction>
claimIx
async claimIx(
user: PublicKey | null,
signer: PublicKey
): Promise<TransactionInstruction>
claimTx
async claimTx(
user: PublicKey | null,
txOptions: TxOptions
): Promise<VersionedTransaction>
Types
PendingRequest
type PendingRequest = {
user: PublicKey;
requestType: RequestType;
amount: BN;
fulfilled: boolean;
// ... additional fields
}
RequestType
class RequestType {
static readonly SUBSCRIPTION = { subscription: {} };
static readonly REDEMPTION = { redemption: {} };
static equals(a: RequestType, b: RequestType): boolean;
}
Example usage
import { GlamClient } from "@glam/sdk";
import { PublicKey } from "@solana/web3.js";
import { BN } from "@coral-xyz/anchor";
const client = new GlamClient();
client.statePda = new PublicKey("your-vault-state-pda");
// Investor subscribes with 100 USDC (queued)
await client.invest.subscribe(new BN(100_000_000), true);
// Check pending request
const pending = await client.invest.fetchPendingRequest();
console.log("Pending subscription:", pending?.amount.toString());
// Manager fulfills requests
await client.invest.fulfill(null);
// Investor claims their shares
await client.invest.claim();
// Check share balance
const balance = await client.getMintTokenBalance();
console.log("Share tokens:", balance.uiAmount);
// Later, investor redeems 50 shares
await client.invest.queuedRedeem(new BN(50_000_000_000));
// Manager fulfills redemption
await client.invest.fulfill(null);
// Investor claims base asset
await client.invest.claim();