@glamsystems/glam-sdk 1.1.0-alpha.0 → 1.1.0-alpha.2

package/src/utils/glamPDAs.d.ts

@@ -1,15 +0,0 @@
-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/index.d.ts

@@ -1,16 +0,0 @@
-export * from "./accounts";
-export * from "./bitmask";
-export * from "./blockhash";
-export * from "./computeBudget";
-export * from "./evm";
-export * from "./common";
-export * from "./glamPDAs";
-export * from "./lookupTables";
-export * from "./rpc";
-export * from "./timelock";
-export * from "./transaction";
-export * from "./pkmap";
-export * from "./pkset";
-export * from "./fraction";
-export * from "./jupiterApi";
-export * from "./positionCategorizer";

package/src/utils/jupiterApi.d.ts

@@ -1,89 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-export type QuoteParams = {
-    inputMint: string;
-    outputMint: string;
-    amount: number;
-    slippageBps?: number;
-    swapMode?: string;
-    onlyDirectRoutes?: boolean;
-    asLegacyTransaction?: boolean;
-    maxAccounts?: number;
-    dexes?: string[];
-    excludeDexes?: string[];
-    instructionVersion: "V1" | "V2";
-};
-export type QuoteResponse = {
-    inputMint: string;
-    inAmount: string;
-    outputMint: string;
-    outAmount: string;
-    otherAmountThreshold: string;
-    swapMode: string;
-    slippageBps: number;
-    platformFee: any;
-    priceImpactPct: string;
-    routePlan: any[];
-    contextSlot: number;
-    timeTaken: number;
-};
-export type TokenListItem = {
-    address: string;
-    name: string;
-    symbol: string;
-    decimals: number;
-    logoURI: string;
-    tags: string[];
-    usdPrice: number;
-    slot: number;
-};
-export declare class JupTokenList {
-    readonly tokens: TokenListItem[];
-    readonly mintMap: Map<string, TokenListItem>;
-    constructor(tokens: TokenListItem[]);
-    getByMint(mintAddress: string | PublicKey): TokenListItem | undefined;
-    getBySymbol(symbol: string): TokenListItem | undefined;
-}
-export type JupiterInstruction = {
-    programId: string;
-    accounts: {
-        pubkey: string;
-        isSigner: boolean;
-        isWritable: boolean;
-    }[];
-    data: string;
-};
-export type SwapInstructions = {
-    tokenLedgerInstruction?: JupiterInstruction | null;
-    otherInstructions?: JupiterInstruction[];
-    computeBudgetInstructions: JupiterInstruction[];
-    setupInstructions?: JupiterInstruction[];
-    swapInstruction: JupiterInstruction;
-    cleanupInstruction?: JupiterInstruction;
-    addressLookupTableAddresses: string[];
-};
-export declare const JUPITER_API_DEFAULT = "https://api.jup.ag";
-export type TokenPrice = {
-    mint: string;
-    usdPrice: number;
-    decimals: number;
-    blockId: number;
-};
-export declare class JupiterApiClient {
-    swapApiBaseUrl: string;
-    isCustomSwapApi: boolean;
-    apiKey: string | null;
-    private tokenListCache;
-    private tokenListCacheTtl;
-    constructor(options?: {
-        apiKey?: string;
-        swapApiBaseUrl?: string;
-        cacheTtl?: number;
-    });
-    fetchTokenPrices(mints: string[]): Promise<TokenPrice[]>;
-    fetchTokensList(forceRefresh?: boolean): Promise<JupTokenList>;
-    fetchProgramLabels(): Promise<{
-        [key: string]: string;
-    }>;
-    getQuoteResponse(quoteParams: QuoteParams): Promise<any>;
-    getSwapInstructions(quoteResponse: any, from: PublicKey, trackingAccount?: PublicKey): Promise<SwapInstructions>;
-}

package/src/utils/lookupTables.d.ts

@@ -1,53 +0,0 @@
-import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
-/**
- * Fetches multiple address lookup table accounts
- *
- * @param connection Solana connection
- * @param pubkeys Array of lookup table public keys
- * @returns Array of address lookup table accounts
- */
-export declare function fetchAddressLookupTableAccounts(connection: Connection, pubkeys?: string[] | PublicKey[]): Promise<AddressLookupTableAccount[]>;
-export interface VaultAccountsInfo {
-    statePda: PublicKey;
-    vaultPda: PublicKey;
-    mintPda: PublicKey;
-    escrowPda: PublicKey;
-    requestQueuePda: PublicKey;
-    extraMetasPda: PublicKey;
-    protocolProgramId: PublicKey;
-    mintProgramId: PublicKey;
-    connection: Connection;
-    stateAccount: {
-        mint: PublicKey;
-        baseAssetMint: PublicKey;
-        assets: PublicKey[];
-        externalPositions: PublicKey[];
-        integrationAcls: {
-            integrationProgram: PublicKey;
-        }[];
-    };
-    borrowable?: PublicKey[];
-}
-/**
- * Collects all pubkeys that should be included in a vault's Address Lookup Table.
- *
- * The first 3 entries are fixed (statePda, vaultPda, GLAM_CONFIG_PROGRAM) to
- * match the ALT discovery filter offsets used by findGlamLookupTables().
- */
-export declare function collectVaultLookupTableAddresses(info: VaultAccountsInfo): Promise<PublicKey[]>;
-export interface CreateAltResult {
-    createIx: TransactionInstruction;
-    lookupTableAddress: PublicKey;
-    extendIxBatches: TransactionInstruction[];
-}
-/**
- * Builds instructions to create an ALT and extend it with the given addresses.
- * Returns the create instruction, the derived lookup table address, and batched
- * extend instructions (each batch fits within a single transaction).
- */
-export declare function buildCreateAltInstructions(addresses: PublicKey[], authority: PublicKey, payer: PublicKey, recentSlot: number): CreateAltResult;
-/**
- * Builds batched extend instructions for an existing ALT.
- * Each instruction extends the table with up to 20 addresses.
- */
-export declare function buildExtendAltInstructions(lookupTableAddress: PublicKey, newAddresses: PublicKey[], authority: PublicKey, payer: PublicKey): TransactionInstruction[];

package/src/utils/pkmap.d.ts

@@ -1,87 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-type PkMapKey = PublicKey | string;
-/**
- * A Map implementation that uses PublicKey-compatible keys.
- *
- * This class extends the standard Map and allows using PublicKey objects
- * or base58 strings as keys by converting them to base58 strings internally.
- * This solves the problem of PublicKey object reference equality - two
- * PublicKey objects with the same address would normally be considered
- * different keys in a Map.
- *
- * @example
- * ```typescript
- * // Create empty map
- * const map = new PkMap<string>();
- * const key = new PublicKey("11111111111111111111111111111111");
- * map.set(key, "value");
- *
- * // Create with initial entries
- * const map2 = new PkMap<string>([
- *   ["11111111111111111111111111111111", "value1"],
- *   [new PublicKey("22222222222222222222222222222222"), "value2"]
- * ]);
- *
- * // Can retrieve with a different PublicKey object with same address
- * const sameKey = new PublicKey("11111111111111111111111111111111");
- * console.log(map.get(sameKey)); // "value"
- * ```
- */
-export declare class PkMap<V> {
-    private readonly _map;
-    /**
-     * Creates a new PkMap instance.
-     * @param entries - Optional initial entries as [PublicKey|string, V] pairs
-     */
-    constructor();
-    constructor(entries?: readonly (readonly [PkMapKey, V])[] | null);
-    constructor(entries?: Iterable<readonly [PkMapKey, V]> | null);
-    /**
-     * Associates the specified value with the specified PublicKey in this map.
-     * @param key - The PublicKey or base58 string to use as the key
-     * @param value - The value to associate with the key
-     * @returns This PkMap instance for chaining
-     */
-    set(key: PkMapKey, value: V): this;
-    /**
-     * Returns the value associated with the specified key, or undefined if not found.
-     * @param key - The PublicKey or base58 string whose associated value is to be returned
-     * @returns The value associated with the specified key, or undefined
-     */
-    get(key: PkMapKey): V | undefined;
-    /**
-     * Returns true if this map contains a mapping for the specified key.
-     * @param key - The PublicKey or base58 string whose presence in this map is to be tested
-     * @returns true if this map contains a mapping for the specified key
-     */
-    has(key: PkMapKey): boolean;
-    /**
-     * Removes the mapping for the specified key from this map if present.
-     * @param key - The PublicKey or base58 string whose mapping is to be removed
-     * @returns true if the element was removed, false otherwise
-     */
-    delete(key: PkMapKey): boolean;
-    /**
-     * Returns an iterator of all PublicKey keys in this map.
-     * Note: This reconstructs PublicKey objects from the stored base58 strings.
-     * @returns An iterator of PublicKey objects
-     */
-    pkKeys(): IterableIterator<PublicKey>;
-    /**
-     * Returns an iterator of [PublicKey, value] pairs for every entry in the map.
-     * Note: This reconstructs PublicKey objects from the stored base58 strings.
-     * @returns An iterator of [PublicKey, V] tuples
-     */
-    pkEntries(): IterableIterator<[PublicKey, V]>;
-    /**
-     * Executes a provided function once per each PublicKey/value pair in the Map.
-     * @param callbackfn - Function to execute for each entry
-     * @param thisArg - Value to use as this when executing callback
-     */
-    forEach(callbackfn: (value: V, key: PublicKey, map: PkMap<V>) => void, thisArg?: any): void;
-    get size(): number;
-    clear(): void;
-    values(): IterableIterator<V>;
-    [Symbol.iterator](): IterableIterator<[PublicKey, V]>;
-}
-export {};

package/src/utils/pkset.d.ts

@@ -1,73 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-/**
- * A Set implementation that uses PublicKey as values.
- *
- * This class extends the standard Set and allows using PublicKey objects
- * as values by converting them to base58 strings internally. This solves the
- * problem of PublicKey object reference equality - two PublicKey objects
- * with the same address would normally be considered different values in a Set.
- *
- * @example
- * ```typescript
- * // Create empty set
- * const set = new PkSet();
- * const key = new PublicKey("11111111111111111111111111111111");
- * set.add(key);
- *
- * // Create with initial values
- * const set2 = new PkSet([
- *   new PublicKey("11111111111111111111111111111111"),
- *   new PublicKey("22222222222222222222222222222222")
- * ]);
- *
- * // Can check with a different PublicKey object with same address
- * const sameKey = new PublicKey("11111111111111111111111111111111");
- * console.log(set.has(sameKey)); // true
- * ```
- */
-export declare class PkSet {
-    private readonly _set;
-    /**
-     * Creates a new PkSet instance.
-     * @param values - Optional initial values as PublicKey array
-     */
-    constructor(values?: readonly PublicKey[] | null);
-    /**
-     * Adds the specified PublicKey to this set.
-     * @param value - The PublicKey to add to the set
-     * @returns This PkSet instance for chaining
-     */
-    add(value: PublicKey): this;
-    /**
-     * Returns true if this set contains the specified PublicKey.
-     * @param value - The PublicKey whose presence in this set is to be tested
-     * @returns true if this set contains the specified PublicKey
-     */
-    has(value: PublicKey): boolean;
-    /**
-     * Removes the specified PublicKey from this set if present.
-     * @param value - The PublicKey to be removed
-     * @returns true if the element was removed, false otherwise
-     */
-    delete(value: PublicKey): boolean;
-    /**
-     * Returns an iterator of all PublicKey values in this set.
-     * Note: This reconstructs PublicKey objects from the stored base58 strings.
-     * @returns An iterator of PublicKey objects
-     */
-    pkValues(): IterableIterator<PublicKey>;
-    /**
-     * Executes a provided function once per each PublicKey in the Set.
-     * @param callbackfn - Function to execute for each value
-     * @param thisArg - Value to use as this when executing callback
-     */
-    forEach(callbackfn: (value: PublicKey, value2: PublicKey, set: PkSet) => void, thisArg?: any): void;
-    get size(): number;
-    clear(): void;
-    [Symbol.iterator](): IterableIterator<PublicKey>;
-    equals(other: PkSet): boolean;
-    /**
-     * @returns true if this set contains all the PublicKeys in the other set
-     */
-    includes(other: PkSet): boolean;
-}

package/src/utils/positionCategorizer.d.ts

@@ -1,36 +0,0 @@
-import { Commitment, Connection, PublicKey } from "@solana/web3.js";
-/**
- * Categorized external positions by protocol type.
- */
-export interface CategorizedPositions {
-    /** Kamino lending obligation accounts */
-    kaminoObligations: PublicKey[];
-    /** Kamino vault share token accounts */
-    kaminoVaultShareAtas: PublicKey[];
-    /** Positions that couldn't be categorized */
-    unknown: PublicKey[];
-}
-/**
- * Utility class for categorizing external positions by protocol type.
- *
- * External positions in GLAM vaults can be:
- * - Kamino obligation accounts (lending positions)
- * - Kamino vault share ATAs (shares in kamino vaults)
- *
- * This class determines the type of each position to enable proper pricing.
- */
-export declare class PositionCategorizer {
-    private readonly connection;
-    constructor(connection: Connection, _vaultPda?: PublicKey);
-    /**
-     * Categorizes external positions by protocol type.
-     *
-     * Algorithm:
-     * 1. Batch fetch positions
-     * 2. Categorize based on account owner and size
-     *
-     * @param externalPositions - Array of external position pubkeys from state account
-     * @returns Categorized positions by protocol type
-     */
-    categorizePositions(externalPositions: PublicKey[], commitment: Commitment): Promise<CategorizedPositions>;
-}

package/src/utils/rpc.d.ts

@@ -1,33 +0,0 @@
-import { Connection, Finality, GetProgramAccountsConfig, GetProgramAccountsResponse, PublicKey, SignaturesForAddressOptions, VersionedTransaction, VersionedTransactionResponse } from "@solana/web3.js";
-/**
- * Fetches program accounts using Helius getProgramAccountsV2 if available.
- * Otherwise falls back to standard getProgramAccounts with retry logic.
- */
-export declare function getProgramAccounts(connection: Connection, programId: PublicKey, config: GetProgramAccountsConfig & HeliusGetProgramAccountsV2Config): Promise<GetProgramAccountsResponse>;
-export type HeliusGetProgramAccountsV2Config = {
-    limit?: number;
-    changedSinceSlot?: number;
-};
-/**
- * Standard getProgramAccounts with retry logic for transient errors.
- */
-export declare function getProgramAccountsWithRetry(connection: Connection, programId: PublicKey, config: GetProgramAccountsConfig): Promise<GetProgramAccountsResponse>;
-export interface GetTransactionsOptions {
-    commitment?: Finality;
-    sinceSlot?: number;
-    transactionDetails?: "full" | "signatures";
-}
-/**
- * Fetches transactions for an address using Helius getTransactionsForAddress if available.
- * Otherwise falls back to getSignaturesForAddress + getTransaction.
- */
-export declare function getTransactionsForAddress(connection: Connection, address: PublicKey, options?: SignaturesForAddressOptions & GetTransactionsOptions): Promise<VersionedTransactionResponse[]>;
-export type PriorityLevel = "Recommended" | "Min" | "Low" | "Medium" | "High" | "VeryHigh" | "UnsafeMax" | "Default";
-type GetPriorityFeeEstimateOptions = {
-    heliusApiKey?: string;
-    tx?: VersionedTransaction;
-    accountKeys?: string[];
-    priorityLevel?: PriorityLevel;
-};
-export declare function getPriorityFeeEstimate(options: GetPriorityFeeEstimateOptions): Promise<number>;
-export {};

package/src/utils/timelock.d.ts

@@ -1,52 +0,0 @@
-import { PublicKey } from "@solana/web3.js";
-import { BN } from "@coral-xyz/anchor";
-import { IntegrationAcl, DelegateAcl } from "../models";
-/**
- * Get protocol names from a bitmask for a given integration program
- * Uses the SDK's parseProtocolsBitmask function
- */
-export declare function getProtocolNamesFromBitmask(integrationProgram: PublicKey, bitmask: number, staging: boolean): string[];
-/**
- * Get permission names from a permissions bitmask for a protocol
- * Uses the SDK's parseProtocolPermissionsBitmask function
- */
-export declare function getPermissionNamesFromBitmask(integrationProgram: PublicKey, protocolBitflag: number, permissionsBitmask: BN, staging: boolean): string[];
-/**
- * Compare current and staged PublicKey arrays and return added/removed keys
- */
-export declare function comparePublicKeyArrays(current: PublicKey[] | null, staged: PublicKey[]): {
-    added: PublicKey[];
-    removed: PublicKey[];
-};
-/**
- * Compare current and staged integrationAcls and return the differences
- */
-export declare function compareIntegrationAcls(current: IntegrationAcl[] | null, staged: IntegrationAcl[] | null, staging: boolean): {
-    added: IntegrationAcl[];
-    removed: IntegrationAcl[];
-    modified: Array<{
-        integrationProgram: PublicKey;
-        currentBitmask: number;
-        stagedBitmask: number;
-        enabledProtocols: string[];
-        disabledProtocols: string[];
-    }>;
-};
-/**
- * Compare current and staged delegateAcls and return the differences
- */
-export declare function compareDelegateAcls(current: DelegateAcl[] | null, staged: DelegateAcl[] | null, staging: boolean): {
-    added: DelegateAcl[];
-    removed: DelegateAcl[];
-    modified: Array<{
-        pubkey: PublicKey;
-        currentExpiresAt: BN;
-        stagedExpiresAt: BN;
-        permissionChanges: Array<{
-            integrationProgram: PublicKey;
-            protocolName: string;
-            addedPermissions: string[];
-            removedPermissions: string[];
-        }>;
-    }>;
-};

package/src/utils/transaction.d.ts

@@ -1,13 +0,0 @@
-import { Connection, PublicKey, TransactionInstruction, AddressLookupTableAccount } from "@solana/web3.js";
-/**
- * Parses program logs to extract error message.
- * Checks in order: Anchor "Error Message:", insufficient funds/lamports,
- * and custom program error codes (resolved via IDL when possible).
- * Returns "Unknown error" if no recognizable error pattern is found.
- */
-export declare function parseProgramLogs(logs: string[], staging: boolean): string;
-export declare const getSimulationResult: (connection: Connection, instructions: Array<TransactionInstruction>, payer: PublicKey, lookupTables?: Array<AddressLookupTableAccount>, staging?: boolean) => Promise<{
-    unitsConsumed?: number;
-    error?: Error;
-    serializedTx?: String;
-}>;