@glamsystems/glam-sdk 0.1.4

package/src/models.d.ts

@@ -0,0 +1,164 @@
+import { IdlTypes, IdlAccounts } from "@coral-xyz/anchor";
+import { Glam } from "./glamExports";
+import { PublicKey } from "@solana/web3.js";
+import { Mint } from "@solana/spl-token";
+export declare const GlamIntegrations: any[];
+export declare const GlamPermissions: any[];
+export declare const VaultIntegrations: any[];
+export type StateAccount = IdlAccounts<Glam>["fundAccount"];
+export type MetadataAccount = IdlAccounts<Glam>["fundMetadataAccount"];
+export type StateModelType = IdlTypes<Glam>["stateModel"];
+export declare class StateIdlModel implements StateModelType {
+    id: PublicKey | null;
+    name: string | null;
+    uri: string | null;
+    metadataUri: string | null;
+    isEnabled: boolean | null;
+    assets: PublicKey[];
+    externalVaultAccounts: PublicKey[];
+    mints: ShareClassModel[];
+    company: CompanyModel | null;
+    owner: ManagerModel | null;
+    created: CreatedModel | null;
+    delegateAcls: DelegateAcl[];
+    integrationAcls: IntegrationAcl[];
+    driftMarketIndexesPerp: number[];
+    driftMarketIndexesSpot: number[];
+    driftOrderTypes: number[];
+    isRawOpenfunds: boolean;
+    rawOpenfunds: FundOpenfundsModel | null;
+    constructor(data: Partial<StateModelType>);
+}
+export declare class StateModel extends StateIdlModel {
+    readonly glamProgramId: PublicKey;
+    constructor(data: Partial<StateIdlModel>, glamProgramId?: PublicKey);
+    get idStr(): string;
+    get vaultPda(): PublicKey;
+    get openfundsPda(): PublicKey;
+    get productType(): "Mint" | "Vault" | "Fund";
+    get shareClassMints(): PublicKey[];
+    get sparkleKey(): string;
+    /**
+     * Build a StateModel from onchain accounts
+     *
+     * @param stateAccount provides core fund data
+     * @param openfundsAccount includes fund rawOpenfunds data and share class rawOpenfunds data
+     * @param shareClassMint provides share class data
+     */
+    static fromOnchainAccounts(statePda: PublicKey, stateAccount: StateAccount, openfundsAccount?: MetadataAccount, shareClassMint?: Mint, glamProgramId?: PublicKey): StateModel;
+}
+export type FundOpenfundsModelType = IdlTypes<Glam>["fundOpenfundsModel"];
+export declare class FundOpenfundsModel implements FundOpenfundsModelType {
+    fundDomicileAlpha2: string | null;
+    legalFundNameIncludingUmbrella: string | null;
+    fiscalYearEnd: string | null;
+    fundCurrency: string | null;
+    fundLaunchDate: string | null;
+    investmentObjective: string | null;
+    isEtc: boolean | null;
+    isEuDirectiveRelevant: boolean | null;
+    isFundOfFunds: boolean | null;
+    isPassiveFund: boolean | null;
+    isReit: boolean | null;
+    legalForm: string | null;
+    legalFundNameOnly: string | null;
+    openEndedOrClosedEndedFundStructure: string | null;
+    typeOfEuDirective: string | null;
+    ucitsVersion: string | null;
+    constructor(data: Partial<FundOpenfundsModelType>);
+}
+export type ShareClassModelType = IdlTypes<Glam>["shareClassModel"];
+export declare class ShareClassIdlModel implements ShareClassModelType {
+    symbol: string | null;
+    name: string | null;
+    uri: string | null;
+    fundId: PublicKey | null;
+    asset: PublicKey | null;
+    imageUri: string | null;
+    isRawOpenfunds: boolean;
+    rawOpenfunds: ShareClassOpenfundsModel | null;
+    allowlist: PublicKey[];
+    blocklist: PublicKey[];
+    lockUpPeriodInSeconds: number;
+    permanentDelegate: PublicKey | null;
+    defaultAccountStateFrozen: boolean;
+    constructor(data: Partial<ShareClassModelType>);
+}
+export declare class ShareClassModel extends ShareClassIdlModel {
+    constructor(data: Partial<ShareClassIdlModel>);
+    static mintAddress(statePda: PublicKey, idx?: number, glamProgramId?: PublicKey): PublicKey;
+}
+export type ShareClassOpenfundsModelType = IdlTypes<Glam>["shareClassOpenfundsModel"];
+export declare class ShareClassOpenfundsModel implements ShareClassOpenfundsModelType {
+    isin: string | null;
+    shareClassCurrency: string | null;
+    currencyOfMinimalSubscription: string | null;
+    fullShareClassName: string | null;
+    investmentStatus: string | null;
+    minimalInitialSubscriptionCategory: string | null;
+    minimalInitialSubscriptionInAmount: string | null;
+    minimalInitialSubscriptionInShares: string | null;
+    shareClassDistributionPolicy: string | null;
+    shareClassExtension: string | null;
+    shareClassLaunchDate: string | null;
+    shareClassLifecycle: string | null;
+    launchPrice: string | null;
+    launchPriceCurrency: string | null;
+    launchPriceDate: string | null;
+    currencyOfMinimalOrMaximumRedemption: string | null;
+    hasLockUpForRedemption: boolean | null;
+    isValidIsin: boolean | null;
+    lockUpComment: string | null;
+    lockUpPeriodInDays: string | null;
+    maximumInitialRedemptionInAmount: string | null;
+    maximumInitialRedemptionInShares: string | null;
+    minimalInitialRedemptionInAmount: string | null;
+    minimalInitialRedemptionInShares: string | null;
+    minimalRedemptionCategory: string | null;
+    shareClassDividendType: string | null;
+    cusip: string | null;
+    valor: string | null;
+    constructor(obj: Partial<ShareClassOpenfundsModelType>);
+}
+export type CompanyModelType = IdlTypes<Glam>["companyModel"];
+export declare class CompanyModel implements CompanyModelType {
+    fundGroupName: string | null;
+    manCo: string | null;
+    domicileOfManCo: string | null;
+    emailAddressOfManCo: string | null;
+    fundWebsiteOfManCo: string | null;
+    constructor(data: Partial<CompanyModelType>);
+}
+export type ManagerModelType = IdlTypes<Glam>["managerModel"];
+export declare class ManagerModel implements ManagerModelType {
+    portfolioManagerName: string | null;
+    pubkey: PublicKey | null;
+    kind: {
+        wallet: {};
+    } | {
+        squads: {};
+    } | null;
+    constructor(data: Partial<ManagerModelType>);
+}
+export type CreatedModelType = IdlTypes<Glam>["createdModel"];
+export declare class CreatedModel implements CreatedModelType {
+    key: number[];
+    owner: PublicKey | null;
+    constructor(obj: Partial<CreatedModelType>);
+}
+export type Permission = IdlTypes<Glam>["permission"];
+export type DelegateAclType = IdlTypes<Glam>["delegateAcl"];
+export declare class DelegateAcl implements DelegateAclType {
+    pubkey: PublicKey;
+    permissions: Permission[];
+    constructor(obj: Partial<DelegateAclType>);
+}
+export type IntegrationName = IdlTypes<Glam>["integrationName"];
+export type IntegrationAclType = IdlTypes<Glam>["integrationAcl"];
+export declare class IntegrationAcl implements IntegrationAclType {
+    name: IntegrationName;
+    features: {
+        all: {};
+    }[];
+    constructor(obj: Partial<IntegrationAclType>);
+}

package/src/react/cluster-provider.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from "react";
+import { ClusterNetwork } from "../clientConfig";
+interface Cluster {
+    name: string;
+    endpoint: string;
+    network?: ClusterNetwork;
+    active?: boolean;
+}
+interface ClusterProviderContext {
+    cluster: Cluster;
+    clusters: Cluster[];
+    addCluster: (cluster: Cluster) => void;
+    deleteCluster: (cluster: Cluster) => void;
+    setCluster: (cluster: Cluster) => void;
+    getExplorerUrl(path: string): string;
+}
+export declare function ClusterProvider({ children }: {
+    children: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function useCluster(): ClusterProviderContext;
+export {};

package/src/react/glam.d.ts

@@ -0,0 +1,62 @@
+import type { DelegateAcl, StateModel } from "../models";
+import { GlamClient } from "../client";
+import { PublicKey } from "@solana/web3.js";
+import { DriftMarketConfigs, GlamDriftUser } from "../client/drift";
+import { TokenAccount } from "../client/base";
+declare global {
+    interface Window {
+        glamClient: GlamClient;
+    }
+}
+export interface JupTokenListItem {
+    address: string;
+    name: string;
+    symbol: string;
+    decimals: number;
+    logoURI: string;
+    tags: string[];
+}
+interface TokenPrice {
+    mint: string;
+    price: number;
+}
+interface GlamProviderContext {
+    glamClient: GlamClient;
+    vault: Vault;
+    activeGlamState?: GlamStateCache;
+    glamStatesList: GlamStateCache[];
+    delegateAcls: DelegateAcl[];
+    allGlamStates: StateModel[];
+    userWallet: UserWallet;
+    prices: TokenPrice[];
+    jupTokenList?: JupTokenListItem[];
+    driftMarketConfigs: DriftMarketConfigs;
+    driftUser: GlamDriftUser;
+    setActiveGlamState: (f: GlamStateCache) => void;
+    refresh: () => Promise<void>;
+}
+interface UserWallet {
+    queryKey: string[];
+    pubkey?: PublicKey;
+    balanceLamports: number;
+    uiAmount: number;
+    tokenAccounts: TokenAccount[];
+}
+interface Vault {
+    pubkey: PublicKey;
+    balanceLamports: number;
+    uiAmount: number;
+    tokenAccounts: TokenAccount[];
+}
+interface GlamStateCache {
+    address: string;
+    pubkey: PublicKey;
+    sparkleKey: string;
+    name: string;
+    product: "Mint" | "Vault" | "Fund";
+}
+export declare function GlamProvider({ children, }: Readonly<{
+    children: React.ReactNode;
+}>): import("react/jsx-runtime").JSX.Element;
+export declare const useGlam: () => GlamProviderContext;
+export {};

package/src/react/index.d.ts

@@ -0,0 +1,3 @@
+export * from "../index";
+export * from "./glam";
+export * from "./cluster-provider";

package/src/utils/blockhash.d.ts

@@ -0,0 +1,21 @@
+import * as anchor from "@coral-xyz/anchor";
+import { BlockhashWithExpiryBlockHeight } from "@solana/web3.js";
+type CachedBlockhash = {
+    blockhash: BlockhashWithExpiryBlockHeight;
+    expiresAt: number;
+};
+export declare class BlockhashWithCache {
+    provider: anchor.Provider;
+    isBrowser: boolean;
+    nodeCache: Map<string, any>;
+    cacheKey: string;
+    ttl: number;
+    constructor(provider: anchor.Provider, isBrowser: boolean, ttl?: number);
+    get(): Promise<BlockhashWithExpiryBlockHeight>;
+    set(data: CachedBlockhash): Promise<void>;
+    _getFromBrowserCache(): Promise<CachedBlockhash | undefined>;
+    _getFromNodeCache(): CachedBlockhash | undefined;
+    _setBrowserCache(data: CachedBlockhash): Promise<void>;
+    _setNodeCache(data: CachedBlockhash): void;
+}
+export {};

package/src/utils/helpers.d.ts

@@ -0,0 +1,2 @@
+import { Connection, PublicKey, TransactionInstruction, AddressLookupTableAccount } from "@solana/web3.js";
+export declare const getSimulationComputeUnits: (connection: Connection, instructions: Array<TransactionInstruction>, payer: PublicKey, lookupTables: Array<AddressLookupTableAccount> | []) => Promise<number | undefined>;

package/src/utils/priorityfee.d.ts

@@ -0,0 +1,3 @@
+import { VersionedTransaction } from "@solana/web3.js";
+export type PriorityLevel = "Min" | "Low" | "Medium" | "High" | "VeryHigh" | "UnsafeMax" | "Default";
+export declare const getPriorityFeeEstimate: (heliusApiKey: string, tx?: VersionedTransaction, accountKeys?: string[], priorityLevel?: PriorityLevel) => Promise<any>;