@glamsystems/glam-sdk 1.1.0-alpha.5 → 1.1.0

package/src/globalConfig.d.ts

@@ -0,0 +1,27 @@
+import { Connection, PublicKey } from "@solana/web3.js";
+import { Decodable } from "./deser/base";
+import { PkMap } from "./utils";
+type RawAssetMeta = {
+    asset: PublicKey;
+    decimals: number;
+    oracle: PublicKey;
+    oracleSourceOrdinal: number;
+    maxAgeSeconds: number;
+    priority: number;
+    padding: number[];
+};
+export declare function fetchGlobalConfig(connection: Connection, address?: PublicKey): Promise<GlobalConfig>;
+export declare class GlobalConfig extends Decodable {
+    discriminator: number[];
+    admin: PublicKey;
+    feeAuthority: PublicKey;
+    referrer: PublicKey;
+    baseFeeBps: number;
+    flowFeeBps: number;
+    assetMetas: RawAssetMeta[];
+    static _layout: any;
+    static encode(data: any): Buffer;
+}
+export declare function getOracleName(ordinal: number): string;
+export declare function fetchOnchainAssetMetas(connection: Connection, address?: PublicKey): Promise<PkMap<RawAssetMeta>>;
+export {};

package/src/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./glamExports";
+export * from "./models";
+export * from "./clientConfig";
+export * from "./client";
+export * from "./client/jupiter";
+export * from "./client/timelock";
+export * from "./client/cctp";
+export * from "./client/bridge";
+export * from "./client/epi";
+export * from "./client/loopscale";
+export * from "./client/phoenix";
+export * from "./client/jupiter-lend";
+export * from "./client/orca";
+export * from "./client/price";
+export * from "./deser/integrationPolicies";
+export * from "./deser/loopscaleLayouts";
+export * from "./deser/tokenAclLayouts";
+export * from "./client/base";
+export * from "./assets";
+export * from "./globalConfig";
+export * from "./constants";
+export * from "./protocols";
+export * from "./error";
+export * from "./utils";

package/src/models/acl.d.ts

@@ -0,0 +1,43 @@
+import { IdlTypes } from "@coral-xyz/anchor";
+import { GlamProtocol } from "../glamExports";
+import { PublicKey } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+export type IntegrationPermissionsType = IdlTypes<GlamProtocol>["integrationPermissions"];
+export type ProtocolPermissionsType = IdlTypes<GlamProtocol>["protocolPermissions"];
+export declare class IntegrationPermissions implements IntegrationPermissionsType {
+    integrationProgram: PublicKey;
+    protocolPermissions: ProtocolPermissionsType[];
+    constructor(obj: Partial<IntegrationPermissionsType>);
+}
+export declare class ProtocolPermissions implements ProtocolPermissionsType {
+    protocolBitflag: number;
+    permissionsBitmask: BN;
+    constructor(obj: Partial<ProtocolPermissionsType>);
+}
+export type ProtocolPolicyType = IdlTypes<GlamProtocol>["protocolPolicy"];
+export declare class ProtocolPolicy implements ProtocolPolicyType {
+    protocolBitflag: number;
+    data: Buffer;
+    constructor(obj: Partial<ProtocolPolicyType>);
+}
+export type IntegrationAclType = IdlTypes<GlamProtocol>["integrationAcl"];
+export declare class IntegrationAcl implements IntegrationAclType {
+    integrationProgram: PublicKey;
+    protocolsBitmask: number;
+    protocolPolicies: ProtocolPolicy[];
+    constructor(obj: Partial<IntegrationAclType>);
+}
+export type DelegateAclType = IdlTypes<GlamProtocol>["delegateAcl"];
+export declare class DelegateAcl implements DelegateAclType {
+    pubkey: PublicKey;
+    integrationPermissions: IntegrationPermissions[];
+    expiresAt: BN;
+    constructor(obj: Partial<DelegateAclType>);
+}
+export type EmergencyAccessUpdateArgsType = IdlTypes<GlamProtocol>["emergencyAccessUpdateArgs"];
+export declare class EmergencyAccessUpdateArgs implements EmergencyAccessUpdateArgsType {
+    disabledIntegrations: PublicKey[];
+    disabledDelegates: PublicKey[];
+    stateEnabled: boolean | null;
+    constructor(obj: Partial<EmergencyAccessUpdateArgsType>);
+}

package/src/models/index.d.ts

@@ -0,0 +1,8 @@
+export { StateIdlModel, StateModel, CreatedModel, StateAccountType, } from "./state";
+export type { StateAccount, StateModelType, CreatedModelType } from "./state";
+export { MintIdlModel, MintModel, EmergencyUpdateMintArgs, RequestType, } from "./mint";
+export type { MintModelType, EmergencyUpdateMintArgsType, FeeStructure, FeeParams, AccruedFees, NotifyAndSettle, } from "./mint";
+export { IntegrationPermissions, ProtocolPermissions, ProtocolPolicy, IntegrationAcl, DelegateAcl, EmergencyAccessUpdateArgs, } from "./acl";
+export type { IntegrationPermissionsType, ProtocolPermissionsType, ProtocolPolicyType, IntegrationAclType, DelegateAclType, EmergencyAccessUpdateArgsType, } from "./acl";
+export { PriceDenom, TimeUnit, VoteAuthorize } from "./types";
+export type { RequestQueue, PendingRequest } from "./types";

package/src/models/mint.d.ts

@@ -0,0 +1,57 @@
+import { IdlTypes } from "@coral-xyz/anchor";
+import { GlamProtocol, GlamMint } from "../glamExports";
+import { PublicKey } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+export type FeeStructure = IdlTypes<GlamProtocol>["feeStructure"];
+export type FeeParams = IdlTypes<GlamProtocol>["feeParams"];
+export type AccruedFees = IdlTypes<GlamProtocol>["accruedFees"];
+export type NotifyAndSettle = IdlTypes<GlamProtocol>["notifyAndSettle"];
+export type MintModelType = IdlTypes<GlamMint>["mintModel"];
+export declare class MintIdlModel implements MintModelType {
+    symbol: string | null;
+    name: number[] | null;
+    uri: string | null;
+    yearInSeconds: number | null;
+    permanentDelegate: PublicKey | null;
+    defaultAccountStateFrozen: boolean | null;
+    feeStructure: FeeStructure | null;
+    notifyAndSettle: NotifyAndSettle | null;
+    lockupPeriod: number | null;
+    maxCap: BN | null;
+    minSubscription: BN | null;
+    minRedemption: BN | null;
+    allowlist: PublicKey[] | null;
+    blocklist: PublicKey[] | null;
+    constructor(data: Partial<MintModelType>);
+}
+export declare class MintModel extends MintIdlModel {
+    statePda: PublicKey | null;
+    baseAssetMint: PublicKey | null;
+    transferHookProgram: PublicKey | null;
+    claimableFees: AccruedFees | null;
+    claimedFees: AccruedFees | null;
+    feeParams: FeeParams | null;
+    subscriptionPaused: boolean | null;
+    redemptionPaused: boolean | null;
+    pendingRequests: any[] | null;
+    constructor(data: Partial<MintModel>);
+    get nameStr(): string;
+}
+export type EmergencyUpdateMintArgsType = IdlTypes<GlamMint>["emergencyUpdateMintArgs"];
+export type RequestType = EmergencyUpdateMintArgsType["requestType"];
+export declare class EmergencyUpdateMintArgs implements EmergencyUpdateMintArgsType {
+    requestType: RequestType;
+    setPaused: boolean;
+}
+export declare const RequestType: {
+    SUBSCRIPTION: RequestType;
+    REDEMPTION: RequestType;
+    equals(a: RequestType, b: RequestType): boolean;
+    fromInt(int: number): RequestType;
+};
+export type OracleConfigsType = IdlTypes<GlamProtocol>["oracleConfigs"];
+export declare class OracleConfigs implements OracleConfigsType {
+    readonly maxAgesSeconds: number[][];
+    padding: number[];
+    constructor(maxAgesSeconds: number[][]);
+}

package/src/models/state.d.ts

@@ -0,0 +1,94 @@
+import { IdlTypes, IdlAccounts } from "@coral-xyz/anchor";
+import { GlamProtocol } from "../glamExports";
+import { PublicKey } from "@solana/web3.js";
+import { Mint } from "@solana/spl-token";
+import { BN } from "@coral-xyz/anchor";
+import { MintModel } from "./mint";
+import type { RequestQueue } from "./types";
+import type { IntegrationAcl, DelegateAcl } from "./acl";
+export type StateAccount = IdlAccounts<GlamProtocol>["stateAccount"];
+export type StateModelType = IdlTypes<GlamProtocol>["stateModel"];
+export type StateAccountType = NonNullable<StateModelType["accountType"]>;
+export type OracleConfigsType = IdlTypes<GlamProtocol>["oracleConfigs"];
+type StateIdlModelInput = Partial<StateModelType> & {
+    oracleConfigs?: OracleConfigsType | null;
+};
+/**
+ * State model class as defined in the IDL.
+ */
+export declare class StateIdlModel implements StateModelType {
+    accountType: StateAccountType | null;
+    name: number[] | null;
+    uri: string | null;
+    enabled: boolean | null;
+    oracleConfigs: OracleConfigsType | null;
+    assets: PublicKey[] | null;
+    created: CreatedModel | null;
+    owner: PublicKey | null;
+    portfolioManagerName: number[] | null;
+    borrowable: PublicKey[] | null;
+    timelockDuration: number | null;
+    integrationAcls: IntegrationAcl[] | null;
+    delegateAcls: DelegateAcl[] | null;
+    constructor(data: StateIdlModelInput);
+}
+/**
+ * Enriched state model built from multiple onchain accounts
+ */
+export declare class StateModel extends StateIdlModel {
+    accountType: StateAccountType;
+    name: number[];
+    enabled: boolean;
+    assets: PublicKey[];
+    created: CreatedModel;
+    owner: PublicKey;
+    portfolioManagerName: number[];
+    timelockDuration: number;
+    integrationAcls: IntegrationAcl[];
+    delegateAcls: DelegateAcl[];
+    id: PublicKey;
+    vault: PublicKey;
+    mint: PublicKey | null;
+    mintModel: MintModel | null;
+    baseAssetMint: PublicKey;
+    baseAssetTokenProgram: number;
+    baseAssetDecimals: number;
+    pendingStateUpdates: any | null;
+    pendingMintUpdates: any | null;
+    timelockExpiresAt: number | null;
+    externalPositions: PublicKey[];
+    pricedProtocols: any[];
+    constructor(data: Partial<StateModel>);
+    get idStr(): string;
+    get nameStr(): string;
+    get productType(): string;
+    get launchDate(): string;
+    get sparkleKey(): string;
+    get baseAssetTokenProgramId(): PublicKey;
+    get assetsForPricing(): PublicKey[];
+    /**
+     * Build a StateModel from onchain data
+     *
+     * @param stateAccount provides core fund data
+     * @param openfundsMetadataAccount includes fund rawOpenfunds data and share class rawOpenfunds data
+     * @param glamMint
+     */
+    static fromOnchainAccounts(statePda: PublicKey, stateAccount: StateAccount, staging: boolean, glamMint?: Mint, requestQueue?: RequestQueue): StateModel;
+}
+export type CreatedModelType = IdlTypes<GlamProtocol>["createdModel"];
+export declare class CreatedModel implements CreatedModelType {
+    key: number[];
+    createdBy: PublicKey;
+    createdAt: BN;
+    constructor(obj: Partial<CreatedModelType>);
+}
+export declare const StateAccountType: {
+    VAULT: StateAccountType;
+    TOKENIZED_VAULT: StateAccountType;
+    MINT: StateAccountType;
+    SINGLE_ASSET_VAULT: StateAccountType;
+    equals(a: StateAccountType, b: StateAccountType): boolean;
+    from(s: string): StateAccountType;
+    hasRequestQueue(accountType: StateAccountType): boolean;
+};
+export {};

package/src/models/types.d.ts

@@ -0,0 +1,28 @@
+import { IdlTypes } from "@coral-xyz/anchor";
+import { GlamMint } from "../glamExports";
+export type RequestQueue = IdlTypes<GlamMint>["requestQueue"];
+export type PendingRequest = IdlTypes<GlamMint>["pendingRequest"];
+export declare class PriceDenom {
+    static readonly SOL: {
+        sol: {};
+    };
+    static readonly USD: {
+        usd: {};
+    };
+}
+export declare class TimeUnit {
+    static readonly Slot: {
+        slot: {};
+    };
+    static readonly Second: {
+        second: {};
+    };
+}
+export declare class VoteAuthorize {
+    static readonly Voter: {
+        voter: {};
+    };
+    static readonly Withdrawer: {
+        withdrawer: {};
+    };
+}

package/src/protocols.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Protocol bitmask values and priced protocol identifiers.
+ *
+ * Keep these separate from program-id constants so call sites are explicit
+ * about whether they are selecting an integration program or a protocol bit.
+ */
+export declare const SYSTEM_PROTOCOL: number;
+export declare const STAKE_PROTOCOL: number;
+export declare const JUPITER_SWAP_PROTOCOL: number;
+export declare const GLAM_MINT_PROTOCOL: number;
+export declare const SPL_TOKEN_PROTOCOL: number;
+export declare const CCTP_PROTOCOL: number;
+export declare const PHOENIX_PROTOCOL: number;
+export declare const KAMINO_LENDING_PROTOCOL: number;
+export declare const KAMINO_VAULTS_PROTOCOL: number;
+export declare const KAMINO_FARMS_PROTOCOL: number;
+export declare const JUPITER_EARN_PROTOCOL: number;
+export declare const JUPITER_BORROW_PROTOCOL: number;
+export declare const ORCA_WHIRLPOOLS_PROTOCOL: number;
+export declare const LOOPSCALE_BORROW_PROTOCOL: number;
+export declare const LOOPSCALE_LENDING_PROTOCOL: number;
+export declare const LOOPSCALE_VAULT_PROTOCOL: number;
+export declare const LAYERZERO_OFT_PROTOCOL: number;
+export declare const BRIDGE_MANAGED_TRANSFERS_PROTOCOL = 0;
+export declare const EPI_PROTOCOL: number;
+export declare const MARINADE_PROTOCOL: number;
+export declare const STAKE_POOL_PROTOCOL: number;
+export declare const SANCTUM_SINGLE_VALIDATOR_STAKE_POOL_PROTOCOL: number;
+export declare const SANCTUM_MULTI_VALIDATOR_STAKE_POOL_PROTOCOL: number;

package/src/utils/accounts.d.ts

@@ -0,0 +1,71 @@
+import { AccountInfo, Connection, PublicKey, AddressLookupTableAccount } from "@solana/web3.js";
+import { type TokenAccount } from "../client/base";
+import { Mint } from "@solana/spl-token";
+export type StakeAccountInfo = {
+    address: PublicKey;
+    lamports: number;
+    state: string;
+    voter?: PublicKey;
+};
+export declare const getStakeDelegationState: (activationEpoch: string | number, deactivationEpoch: string | number, currentEpoch: string | number) => "active" | "inactive" | "activating" | "deactivating";
+/**
+ * Fetches all the token accounts owned by the specified pubkey.
+ */
+export declare function getTokenAccountsByOwner(connection: Connection, owner: PublicKey): Promise<TokenAccount[]>;
+export declare function getSolAndTokenBalances(connection: Connection, owner: PublicKey): Promise<{
+    balanceLamports: number;
+    uiAmount: number;
+    tokenAccounts: TokenAccount[];
+}>;
+export declare const findStakeAccounts: (connection: Connection, withdrawAuthority: PublicKey) => Promise<PublicKey[]>;
+export declare const getStakeAccountsWithStates: (connection: Connection, withdrawAuthority: PublicKey) => Promise<StakeAccountInfo[]>;
+/**
+ * Parses mint account info to extract mint and token program
+ *
+ * @param accountInfo The account info buffer
+ * @param pubkey The mint public key
+ * @returns Mint object and token program ID
+ */
+export declare function parseMintAccountInfo(accountInfo: AccountInfo<Buffer>, pubkey: PublicKey): {
+    mint: Mint;
+    tokenProgram: PublicKey;
+};
+/**
+ * Fetches mint accounts and token program IDs for the given mint pubkeys
+ *
+ * @param connection Solana connection
+ * @param mintPubkeys Array of mint public keys
+ * @returns Array of mint objects with their token program IDs
+ */
+export declare function fetchMintsAndTokenPrograms(connection: Connection, mintPubkeys: PublicKey[]): Promise<{
+    mint: Mint;
+    tokenProgram: PublicKey;
+}[]>;
+/**
+ * Fetches mint account and token program ID for the given mint pubkey
+ *
+ * @param connection Solana connection
+ * @param mintPubkey Mint public key
+ * @returns Mint object and token program ID
+ */
+export declare function fetchMintAndTokenProgram(connection: Connection, mintPubkey: PublicKey): Promise<{
+    mint: Mint;
+    tokenProgram: PublicKey;
+}>;
+/**
+ * Checks if Token ACL (sRFC-37) is enabled for the given mint by verifying
+ * the freeze authority is set to the Token ACL program.
+ */
+export declare function isTokenAclEnabled(connection: Connection, mintPubkey: PublicKey): Promise<boolean>;
+/**
+ * Finds all Address Lookup Tables (ALTs) associated with the current vault.
+ *
+ * Queries the ALT program directly using `getProgramAccounts` with filters.
+ *
+ * @returns Array of AddressLookupTableAccount objects for the vault
+ * @throws RPC errors from `getProgramAccounts`. Callers that only use the
+ * result to optimize transaction size may want to catch and fall back to an
+ * empty list; callers that rely on the result for correctness (e.g. ALT
+ * management commands) should let the error propagate.
+ */
+export declare function findGlamLookupTables(statePda: PublicKey, vaultPda: PublicKey, connection: Connection): Promise<AddressLookupTableAccount[]>;

package/src/utils/bitmask.d.ts

@@ -0,0 +1,53 @@
+import { PublicKey } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+export declare function resolveStateAclsStaging(integrationAcls: Array<{
+    integrationProgram: PublicKey;
+}> | null | undefined, fallback: boolean): boolean;
+/**
+ * Formats a bitmask as a binary string.
+ *
+ * @param bitmask - The bitmask to format, either a number or a BN.
+ * @param padding - The number of bits to pad the bitmask with.
+ * @returns e.g. '0000000000001100' if bitmask is 12 and padding is 16.
+ */
+export declare function formatBits(bitmask: number | BN, padding?: number): string;
+/**
+ * Parses a bitmask into a binary string and a list of protocol names.
+ *
+ * @param integrationProgram - The integration program ID.
+ * @param protocolsBitmask - The bitmask to parse.
+ * @returns An object containing the bitmask string and a list of protocol names.
+ */
+export declare function parseProtocolsBitmask(integrationProgram: PublicKey, protocolsBitmask: number | BN, staging: boolean): {
+    protocols: {
+        bitflag: number | BN;
+        name: string;
+    }[];
+};
+/**
+ * Parses a permissions bitmask for a specific protocol to get permission names.
+ *
+ * @param integrationProgram - The integration program ID.
+ * @param protocolBitflag - The protocol bitflag to identify which protocol.
+ * @param permissionsBitmask - The permissions bitmask to parse.
+ * @returns An object containing the bitmask string and a list of permission names.
+ */
+export declare function parseProtocolPermissionsBitmask(integrationProgram: PublicKey, protocolBitflag: number | BN, permissionsBitmask: number | BN, staging: boolean): {
+    protocol: string;
+    permissions: {
+        bitflag: number | BN;
+        name: string;
+    }[];
+};
+/**
+ * Given the protocol name and a list of permission names, returns the permissions bitmask.
+ */
+export declare function parsePermissionNames({ protocolName, permissionNames, staging, }: {
+    protocolName: string;
+    permissionNames: string[];
+    staging: boolean;
+}): {
+    integrationProgram: PublicKey;
+    protocolBitflag: number;
+    permissionsBitmask: BN;
+};

package/src/utils/blockhash.d.ts

@@ -0,0 +1,11 @@
+import * as anchor from "@coral-xyz/anchor";
+import { BlockhashWithExpiryBlockHeight } from "@solana/web3.js";
+export declare class BlockhashWithCache {
+    readonly provider: anchor.Provider;
+    readonly ttl: number;
+    private cachedBlockhash;
+    private fetchPromise;
+    constructor(provider: anchor.Provider, ttl?: number);
+    get(): Promise<BlockhashWithExpiryBlockHeight>;
+    clear(): void;
+}

package/src/utils/common.d.ts

@@ -0,0 +1,73 @@
+import { BN } from "@coral-xyz/anchor";
+export declare const MAX_SAFE_INTEGER_BN: BN;
+export declare const U8_MAX = 255;
+export declare const U16_MAX = 65535;
+export declare const U32_MAX = 4294967295;
+export declare const U64_MAX_BIGINT: bigint;
+export declare const U128_MAX_BIGINT: bigint;
+export declare const U64_MAX_BN: BN;
+export declare const U128_MAX_BN: BN;
+/**
+ * Converts a buffer or array of character codes to a string
+ */
+export declare function charsToString(chars: number[] | Buffer): string;
+/**
+ * @deprecated Use `charsToString` instead.
+ */
+export declare function charsToName(chars: number[] | Buffer): string;
+/**
+ * Converts a string to an array of character codes
+ */
+export declare function stringToChars(name: string, length?: number): number[];
+/**
+ * @deprecated Use `stringToChars` instead.
+ */
+export declare function nameToChars(name: string, length?: number): number[];
+/**
+ * Returns the first 8 raw SHA-256 bytes for PDA seed derivation.
+ */
+export declare function sha256First8Bytes(chars: number[]): Promise<number[]>;
+/**
+ * Values accepted by helpers that normalize integer/base-unit values into BN.
+ */
+export type BnInput = BN | bigint | number | string;
+/**
+ * Normalizes an integer/base-unit value into a BN while preserving existing BN values.
+ */
+export declare function toBn(value: BnInput): BN;
+/**
+ * Backward-compatible alias for amount-oriented call sites.
+ *
+ * @deprecated Use `toBn` instead.
+ */
+export declare function toBnAmount(amount: BnInput): BN;
+/**
+ * Converts a BN to a JavaScript number when it is known to fit safely.
+ */
+export declare function bnToSafeNumber(value: BN, label?: string): number;
+/**
+ * Safely converts a BN amount to a UI amount (with decimals).
+ *
+ * @param amount - The amount in base units (BN)
+ * @param decimals - The number of decimals (e.g., 9)
+ * @returns The UI amount as a number
+ *
+ * @example
+ * // Convert 10010000000 base units with 9 decimals
+ * const uiAmount = toUiAmount(new BN(10010000000), 9); // Returns 10.01
+ *
+ * @throws Error if the BN amount is too large to safely convert to number
+ */
+export declare function toUiAmount(amount: BN, decimals: number): number;
+/**
+ * Safely converts a UI amount (with decimals) to a BN amount.
+ *
+ * @param amount - The UI amount (e.g., 10.01)
+ * @param decimals - The number of decimals (e.g., 9)
+ * @returns BN representing the amount in base units
+ *
+ * @example
+ * // Convert 10.01 with 9 decimals
+ * const amount = fromUiAmount(10.01, 9); // Returns BN(10010000000)
+ */
+export declare function fromUiAmount(amount: number | string, decimals: number): BN;

package/src/utils/computeBudget.d.ts

@@ -0,0 +1,15 @@
+import { TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+export type ComputeBudgetOptions = {
+    vTx?: VersionedTransaction;
+    getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
+    maxFeeLamports?: number;
+    useMaxFee?: boolean;
+};
+/**
+ * Builds compute budget instructions for a transaction
+ *
+ * @param computeUnitLimit The compute unit limit
+ * @param options Compute budget options
+ * @returns Array of compute budget instructions
+ */
+export declare function buildComputeBudgetInstructions(computeUnitLimit: number, options?: ComputeBudgetOptions): Promise<Array<TransactionInstruction>>;

package/src/utils/evm.d.ts

@@ -0,0 +1,10 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const evmAddressToBytes32: (address: string) => string;
+export declare const hexToBytes: (hex: string) => number[];
+export declare const evmAddressToPublicKey: (address: string) => PublicKey;
+export declare const bytesToHex: (bytes: number[] | Uint8Array) => string;
+export declare const publicKeyToEvmAddress: (publicKey: PublicKey) => string;
+/**
+ * Validates if a string is a valid EVM address (40 hex characters)
+ */
+export declare const isValidEvmAddress: (addr: string) => boolean;

package/src/utils/fraction.d.ts

@@ -0,0 +1,29 @@
+import { BN } from "@coral-xyz/anchor";
+import Decimal from "decimal.js";
+export interface BigFractionBytes {
+    value: BN[];
+    padding: BN[];
+}
+/**
+ * Replicates the Fraction class from the klend-sdk:
+ * https://github.com/Kamino-Finance/klend-sdk/blob/2fbc31a5b165aca3e2ca2e3d0e6162848743192d/src/classes/fraction.ts#L26
+ */
+export declare class Fraction {
+    static MAX_SIZE_F: number;
+    static MAX_SIZE_BF: number;
+    static FRACTIONS: number;
+    static MULTIPLIER: Decimal;
+    static MAX_F_BN: BN;
+    static MAX_BF_BN: BN;
+    static MIN_BN: BN;
+    valueSf: BN;
+    constructor(valueSf: BN);
+    toDecimal(): Decimal;
+    getValue(): BN;
+    gt(x: Fraction): boolean;
+    lt(x: Fraction): boolean;
+    gte(x: Fraction): boolean;
+    lte(x: Fraction): boolean;
+    eq(x: Fraction): boolean;
+}
+export declare function bfToDecimal(x: BigFractionBytes): Decimal;

package/src/utils/glamPDAs.d.ts

@@ -0,0 +1,15 @@
+import { PublicKey } from "@solana/web3.js";
+export declare function getStatePda(initKey: Uint8Array | number[], owner: PublicKey, programId: PublicKey): PublicKey;
+export declare function getVaultPda(statePda: PublicKey, programId: PublicKey): PublicKey;
+export declare function getMintPda(statePda: PublicKey, mintIdx: number, programId: PublicKey): PublicKey;
+export declare function getEscrowPda(mintPda: PublicKey, programId: PublicKey): PublicKey;
+export declare function getRequestQueuePda(glamMint: PublicKey, programId: PublicKey): PublicKey;
+export declare function getExtraMetasPda(mint: PublicKey): PublicKey;
+export declare function getAccountPolicyPda(tokenAccount: PublicKey): PublicKey;
+export declare function getTokenAclMintConfigPda(mint: PublicKey): PublicKey;
+export declare function getTokenAclFlagAccountPda(tokenAccount: PublicKey): PublicKey;
+export declare function getTokenAclGateListConfigPda(authority: PublicKey, seed: Buffer): PublicKey;
+export declare function getTokenAclGateWalletEntryPda(listConfig: PublicKey, wallet: PublicKey): PublicKey;
+export declare function getTokenAclGateExtraMetasPda(mint: PublicKey): PublicKey;
+export declare function getGlobalConfigPda(): PublicKey;
+export declare function getIntegrationAuthorityPda(integrationProgram: PublicKey): PublicKey;

package/src/utils/helius.d.ts

@@ -0,0 +1,66 @@
+import { AccountInfo, Finality, GetProgramAccountsConfig, PublicKey, SignaturesForAddressOptions, VersionedTransaction, VersionedTransactionResponse } from "@solana/web3.js";
+export declare function isHeliusRpc(rpcUrl: string): boolean;
+export declare function getHeliusApiKey(): string | undefined;
+export declare function getHeliusRpcUrl(apiKey?: string): string;
+export type HeliusFetchOptions = {
+    rpcUrl?: string;
+    apiKey?: string;
+};
+export declare function heliusFetch<T = any>(method: string, params: unknown, options?: HeliusFetchOptions): Promise<T>;
+export type HeliusAsset = {
+    id: string;
+    content?: {
+        metadata?: {
+            name?: string;
+            symbol?: string;
+        };
+        links?: {
+            image?: string;
+        };
+    };
+    token_info?: {
+        symbol?: string;
+        decimals?: number;
+    };
+};
+export declare function getAsset(mint: string, options?: HeliusFetchOptions): Promise<HeliusAsset | null>;
+export type HeliusTokenAccount = {
+    address: string;
+    owner: string;
+    mint: string;
+    amount: string | number;
+    delegated_amount?: string | number;
+    frozen?: boolean;
+};
+export type GetTokenAccountsByMintOptions = HeliusFetchOptions & {
+    showZeroBalance?: boolean;
+    limit?: number;
+};
+export type HeliusTokenAccountsByMintResult = {
+    token_accounts: HeliusTokenAccount[];
+    total?: number;
+};
+export declare function getTokenAccountsByMintResult(mint: PublicKey | string, options?: GetTokenAccountsByMintOptions): Promise<HeliusTokenAccountsByMintResult>;
+export declare function getTokenAccountsByMint(mint: PublicKey | string, options?: GetTokenAccountsByMintOptions): Promise<HeliusTokenAccount[]>;
+export type PriorityLevel = "Recommended" | "Min" | "Low" | "Medium" | "High" | "VeryHigh" | "UnsafeMax" | "Default";
+export type GetPriorityFeeEstimateOptions = {
+    heliusApiKey?: string;
+    tx?: VersionedTransaction;
+    accountKeys?: string[];
+    priorityLevel?: PriorityLevel;
+};
+export declare function getPriorityFeeEstimate(options: GetPriorityFeeEstimateOptions): Promise<number>;
+export interface GetTransactionsOptions {
+    commitment?: Finality;
+    sinceSlot?: number;
+    transactionDetails?: "full" | "signatures";
+}
+export declare function heliusGetTransactionsForAddress(rpcUrl: string, address: PublicKey, options?: SignaturesForAddressOptions & GetTransactionsOptions): Promise<(VersionedTransactionResponse | null)[]>;
+export type HeliusGetProgramAccountsV2Config = {
+    limit?: number;
+    changedSinceSlot?: number;
+};
+export declare function heliusGetProgramAccountsV2(rpcUrl: string, programId: PublicKey, config: GetProgramAccountsConfig & HeliusGetProgramAccountsV2Config): Promise<{
+    pubkey: PublicKey;
+    account: AccountInfo<Buffer>;
+}[]>;