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

package/src/utils/index.d.ts

@@ -0,0 +1,17 @@
+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 "./phoenixApi";
+export * from "./positionCategorizer";

package/src/utils/jupiterApi.d.ts

@@ -0,0 +1,95 @@
+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 type FetchTokensListOptions = {
+    forceRefresh?: boolean;
+    includeStakePools?: boolean;
+};
+export declare function withStakePoolTokens(tokenList: JupTokenList): JupTokenList;
+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>;
+    fetchTokensListV2(options?: FetchTokensListOptions): 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

@@ -0,0 +1,83 @@
+import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction } from "@solana/web3.js";
+export type LookupTableInput = string | PublicKey | AddressLookupTableAccount;
+/**
+ * Returns the public key for an address lookup table input.
+ *
+ * @param lookupTable Lookup table account, public key, or base58 address
+ * @returns Lookup table public key
+ */
+export declare function getLookupTableKey(lookupTable: LookupTableInput): PublicKey;
+/**
+ * Merges lookup table inputs while preserving the first occurrence of each key.
+ *
+ * Accepts one or more lookup table arrays as separate arguments. Passing a
+ * single array merges and deduplicates that one group.
+ *
+ * @param lookupTableGroups Lookup table arrays to merge, in priority order
+ * @returns Deduplicated lookup table inputs
+ */
+export declare function mergeLookupTables(...lookupTableGroups: LookupTableInput[][]): LookupTableInput[];
+/**
+ * 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[]>;
+/**
+ * Resolves lookup table inputs to address lookup table accounts.
+ *
+ * Already-resolved accounts are preserved, while public keys and base58
+ * addresses are fetched from the provided connection. Missing accounts are
+ * omitted from the result.
+ *
+ * @param connection Solana connection
+ * @param lookupTables Lookup table accounts, public keys, or base58 addresses
+ * @returns Resolved address lookup table accounts
+ */
+export declare function resolveAddressLookupTableAccounts(connection: Connection, lookupTables: LookupTableInput[]): 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/phoenixApi.d.ts

@@ -0,0 +1,146 @@
+import { PublicKey } from "@solana/web3.js";
+export declare const DEFAULT_PHOENIX_API_URL = "https://perp-api.phoenix.trade";
+export type PhoenixSnapshot = {
+    slot?: number;
+    exchange: {
+        programId: string;
+        globalConfig: string;
+        currentAuthorities?: {
+            rootAuthority?: string;
+            riskAuthority?: string;
+            marketAuthority?: string;
+            oracleAuthority?: string;
+            adlAuthority?: string;
+            cancelAuthority?: string;
+            backstopAuthority?: string;
+        };
+        canonicalMint: string;
+        usdcMint: string;
+        globalVault: string;
+        perpAssetMap: string;
+        globalTraderIndex: string[];
+        activeTraderBuffer: string[];
+        withdrawQueue: string;
+        active?: boolean;
+        gated?: boolean;
+    };
+    markets: PhoenixMarket[];
+};
+export type PhoenixMarket = {
+    symbol: string;
+    marketPubkey: string;
+    splinePubkey?: string;
+    tickSize: number | string;
+    baseLotsDecimals: number;
+    marketStatus?: string;
+    isolatedOnly?: boolean;
+    takerFee?: number;
+    makerFee?: number;
+};
+export type TraderCapabilityAccess = {
+    immediate?: boolean;
+    viaColdActivation?: boolean;
+};
+export type DisplayAmount = string | number | {
+    ui?: string;
+    value?: string | number;
+    decimals?: number;
+};
+export type LimitOrder = {
+    price?: DisplayAmount;
+    side?: string;
+    orderSequenceNumber?: string | number;
+    initialTradeSize?: DisplayAmount;
+    tradeSizeRemaining?: DisplayAmount;
+    marginRequirement?: DisplayAmount;
+    marginFactor?: DisplayAmount;
+    isReduceOnly?: boolean;
+    isConditionalOrder?: boolean;
+    isStopLoss?: boolean;
+    isStopLossDirection?: boolean;
+    nodePointer?: string | number;
+    node_pointer?: string | number;
+    priceInTicks?: string | number;
+    priceTicks?: string | number;
+    price_in_ticks?: string | number;
+    orderId?: {
+        priceInTicks?: string | number;
+        price_in_ticks?: string | number;
+        orderSequenceNumber?: string | number;
+        order_sequence_number?: string | number;
+    };
+};
+export type TraderPositionView = {
+    symbol?: string;
+    positionSize?: DisplayAmount;
+    virtualQuotePosition?: DisplayAmount;
+    entryPrice?: DisplayAmount;
+    unrealizedPnl?: DisplayAmount;
+    discountedUnrealizedPnl?: DisplayAmount;
+    positionInitialMargin?: DisplayAmount;
+    initialMargin?: DisplayAmount;
+    maintenanceMargin?: DisplayAmount;
+    backstopMargin?: DisplayAmount;
+    limitOrderMargin?: DisplayAmount;
+    positionValue?: DisplayAmount;
+    unsettledFunding?: DisplayAmount;
+    accumulatedFunding?: DisplayAmount;
+    liquidationPrice?: DisplayAmount | null;
+    takeProfitPrice?: DisplayAmount | null;
+    stopLossPrice?: DisplayAmount | null;
+};
+export type TraderView = {
+    flags?: number;
+    state?: string;
+    slot?: number;
+    slotIndex?: number;
+    traderKey?: string;
+    traderPdaIndex?: number;
+    traderSubaccountIndex?: number;
+    authority?: string;
+    capabilities?: {
+        placeLimitOrder?: TraderCapabilityAccess;
+        placeMarketOrder?: TraderCapabilityAccess;
+        riskIncreasingTrade?: TraderCapabilityAccess;
+        riskReducingTrade?: TraderCapabilityAccess;
+        depositCollateral?: TraderCapabilityAccess;
+        withdrawCollateral?: TraderCapabilityAccess;
+    };
+    collateralBalance?: DisplayAmount;
+    effectiveCollateral?: DisplayAmount;
+    effectiveCollateralForWithdrawals?: DisplayAmount;
+    unrealizedPnl?: DisplayAmount;
+    discountedUnrealizedPnl?: DisplayAmount;
+    unsettledFundingOwed?: DisplayAmount;
+    accumulatedFunding?: DisplayAmount;
+    portfolioValue?: DisplayAmount;
+    maintenanceMargin?: DisplayAmount;
+    cancelMargin?: DisplayAmount;
+    initialMargin?: DisplayAmount;
+    initialMarginForWithdrawals?: DisplayAmount;
+    riskState?: string;
+    riskTier?: string;
+    positions?: TraderPositionView[];
+    limitOrders?: Record<string, LimitOrder[]>;
+    makerFeeOverrideMultiplier?: number;
+    takerFeeOverrideMultiplier?: number;
+    maxPositions?: number;
+    lastDepositSlot?: number;
+    isInActiveTraders?: boolean;
+};
+export type TraderStateResponse = {
+    slot?: number;
+    slotIndex?: number;
+    authority?: string;
+    pdaIndex?: number;
+    traders?: TraderView[];
+};
+export declare function normalizePhoenixApiUrl(apiUrl: string): string;
+export declare class PhoenixApiClient {
+    apiUrl: string;
+    constructor();
+    private url;
+    fetchPhoenixSnapshot(): Promise<PhoenixSnapshot>;
+    fetchTraderView(trader: PublicKey | string): Promise<TraderView | null>;
+    fetchTraderState(authority: PublicKey | string, pdaIndex: number): Promise<TraderStateResponse | null>;
+}

package/src/utils/pkmap.d.ts

@@ -0,0 +1,87 @@
+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

@@ -0,0 +1,73 @@
+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

@@ -0,0 +1,38 @@
+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[];
+    /** Orca Whirlpools position PDA accounts */
+    orcaWhirlpoolPositions: 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

@@ -0,0 +1,18 @@
+import { Connection, GetProgramAccountsConfig, GetProgramAccountsResponse, PublicKey, SignaturesForAddressOptions, VersionedTransactionResponse } from "@solana/web3.js";
+import { GetTransactionsOptions, HeliusGetProgramAccountsV2Config } from "./helius";
+export { getAsset, getHeliusApiKey, getHeliusRpcUrl, getPriorityFeeEstimate, getTokenAccountsByMint, getTokenAccountsByMintResult, heliusFetch, heliusGetProgramAccountsV2, heliusGetTransactionsForAddress, isHeliusRpc, } from "./helius";
+export type { GetTokenAccountsByMintOptions, GetPriorityFeeEstimateOptions, GetTransactionsOptions, HeliusAsset, HeliusFetchOptions, HeliusGetProgramAccountsV2Config, HeliusTokenAccount, HeliusTokenAccountsByMintResult, PriorityLevel, } from "./helius";
+/**
+ * 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>;
+/**
+ * Standard getProgramAccounts with retry logic for transient errors.
+ */
+export declare function getProgramAccountsWithRetry(connection: Connection, programId: PublicKey, config: GetProgramAccountsConfig): Promise<GetProgramAccountsResponse>;
+/**
+ * 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[]>;

package/src/utils/timelock.d.ts

@@ -0,0 +1,52 @@
+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

@@ -0,0 +1,13 @@
+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;
+}>;