@exponent-labs/exponent-vaults-fetcher 0.9.0

package/build/constants.d.ts

@@ -0,0 +1,9 @@
+/** Seed used for withdrawal PDA derivation on-chain. */
+export declare const WITHDRAWAL_ACCOUNT_SEED: "withdrawal";
+/**
+ * Set of vault addresses to ignore during fetching.
+ * These accounts cannot be deserialized due to program updates and should be skipped.
+ */
+export declare const IGNORED_VAULTS: Set<string>;
+/** Singleton ExponentPrices account address */
+export declare const EXPONENT_PRICES_ADDRESS: string;

package/build/constants.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EXPONENT_PRICES_ADDRESS = exports.IGNORED_VAULTS = exports.WITHDRAWAL_ACCOUNT_SEED = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const exponent_vaults_idl_1 = require("@exponent-labs/exponent-vaults-idl");
+const EXPONENT_PRICES_SEED = new TextEncoder().encode("exponent_prices");
+/** Seed used for withdrawal PDA derivation on-chain. */
+exports.WITHDRAWAL_ACCOUNT_SEED = "withdrawal";
+/**
+ * Set of vault addresses to ignore during fetching.
+ * These accounts cannot be deserialized due to program updates and should be skipped.
+ */
+exports.IGNORED_VAULTS = new Set([
+    "Fo7vvPsSqNAYy2S7CpQoVFP8Ygnr22xB3fJVhde9GjcB",
+    "7apbV7QJHFhh5Ueczg35n6StyNdqeMmDdRwKDNCSRm7i",
+    "GsT257ZWjLboYAbWE1qDX2irHSyvCviQatyu3g2DSqmb",
+    "3KUQ8H5v4pLthqCsdPZuMnwjHVJcdkiFeWZGdX3Mr7MX",
+    "79aYbxCzLNFiF3tibivW6kva8B5qcFUAPAGweDuAyfMY",
+    "99RpUEbUMe1chVgpJNV16iXaJqdfvm459siFX9SA75nq",
+    "E957xxdpgsCbmqHo9AyHkLRTvgppxgQbZ9V8QXpQegg5",
+    "F9Tv2qBbS1YnsR4hYyaq6ztPUcTpht1ZT5Gb22DFwyg1",
+    "FKif7QNqt6cSaFj9cGL8eCz9cuSncKvbVNHxzd92r2hY",
+    "GfT6RcToh5mmkJ5DpPSBsBSJzun2WyVcsWXzNCtEfVUa",
+    "HUXvqaGbjX8kZ65ZhMhJgzfrjEX5By2gA8x9Z9mEFfQH",
+    "Hyi6LoTzcHpaQueSz4qqFdWeBydihpkRR8CqFvLWspqH",
+]);
+/** Singleton ExponentPrices account address */
+exports.EXPONENT_PRICES_ADDRESS = anchor_1.web3.PublicKey.findProgramAddressSync([EXPONENT_PRICES_SEED], new anchor_1.web3.PublicKey(exponent_vaults_idl_1.PROGRAM_ID))[0].toBase58();
+//# sourceMappingURL=constants.js.map

package/build/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":";;;AAAA,8CAAwC;AAExC,4EAA+D;AAE/D,MAAM,oBAAoB,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,iBAAiB,CAAC,CAAA;AAExE,wDAAwD;AAC3C,QAAA,uBAAuB,GAAG,YAAqB,CAAA;AAE5D;;;GAGG;AACU,QAAA,cAAc,GAAG,IAAI,GAAG,CAAC;IACpC,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;IAC9C,8CAA8C;CAC/C,CAAC,CAAA;AAEF,+CAA+C;AAClC,QAAA,uBAAuB,GAAG,aAAI,CAAC,SAAS,CAAC,sBAAsB,CAC1E,CAAC,oBAAoB,CAAC,EACtB,IAAI,aAAI,CAAC,SAAS,CAAC,gCAAU,CAAC,CAC/B,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE,CAAA"}

package/build/fetcher.d.ts

@@ -0,0 +1,441 @@
+/// <reference types="bn.js" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { Program, web3 } from "@coral-xyz/anchor";
+import { ExponentVaults } from "@exponent-labs/exponent-vaults-idl";
+import { ActionProposal, ExponentPrices, ExponentVault, WithdrawalAccount } from "./types";
+export declare class ExponentVaultsFetcher {
+    readonly program: Program<ExponentVaults>;
+    readonly programId: web3.PublicKey;
+    constructor(connection: web3.Connection, programId?: web3.PublicKey | string);
+    fetchVault(address: web3.PublicKey): Promise<{
+        addressLookupTable: web3.PublicKey;
+        squadsSettings: web3.PublicKey;
+        squadsVault: web3.PublicKey;
+        tokenEntries: {
+            mint: web3.PublicKey;
+            priceId: ({
+                multiply?: never;
+            } & {
+                simple: {
+                    priceId: import("bn.js");
+                };
+            }) | ({
+                simple?: never;
+            } & {
+                multiply: {
+                    priceIds: import("bn.js")[];
+                };
+            });
+            tokenSquadsAccount: web3.PublicKey;
+            tokenAccountVault: web3.PublicKey;
+            forceDeallocatePolicyIds: import("bn.js")[];
+        }[];
+        underlyingMint: web3.PublicKey;
+        mintLp: web3.PublicKey;
+        tokenLpEscrow: web3.PublicKey;
+        normalWithdrawalCutBp: number;
+        feeTreasury: web3.PublicKey;
+        selfAddress: web3.PublicKey;
+        signerBump: number[];
+        statusFlags: number;
+        financials: {
+            lpBalance: import("bn.js");
+            aumInBase: import("bn.js");
+            aumInBaseInPositions: import("bn.js");
+            lpLockedForWithdrawal: import("bn.js");
+            pendingManagementFeeLp: import("bn.js");
+            lastManagementFeeAccruedAt: import("bn.js");
+            pendingWithdrawalBacklogDueAt: number;
+            instantWithdrawalWindowEnd: number;
+            instantWithdrawalWindowCapAum: import("bn.js");
+            instantWithdrawnAumInWindow: import("bn.js");
+            reserved1: number[];
+            totalLpStakedInVotes: import("bn.js");
+            totalLpPendingWithdrawals: import("bn.js");
+        };
+        strategyPositions: (({
+            orderbook?: never;
+            tokenAccount?: never;
+            yieldPosition?: never;
+            clmmPosition?: never;
+            loopscaleLoan?: never;
+            loopscaleStrategy?: never;
+        } & {
+            obligation: {
+                0: {} & {
+                    kaminoObligation: {
+                        0: {
+                            obligation: web3.PublicKey;
+                            lendingProgramId: web3.PublicKey;
+                            quotePriceId: ({
+                                multiply?: never;
+                            } & {
+                                simple: {
+                                    priceId: import("bn.js");
+                                };
+                            }) | ({
+                                simple?: never;
+                            } & {
+                                multiply: {
+                                    priceIds: import("bn.js")[];
+                                };
+                            });
+                            reservePriceMappings: {
+                                reserve: web3.PublicKey;
+                                reservePriceId: unknown;
+                            }[];
+                            remainingAccountsAmount: import("bn.js");
+                            minPriceStatusFlags: number;
+                        };
+                    };
+                };
+            };
+        }) | ({
+            obligation?: never;
+            tokenAccount?: never;
+            yieldPosition?: never;
+            clmmPosition?: never;
+            loopscaleLoan?: never;
+            loopscaleStrategy?: never;
+        } & {
+            orderbook: {
+                0: {
+                    orderbook: web3.PublicKey;
+                    userEscrowIdx: number;
+                    mint: web3.PublicKey;
+                    offerIdxVec: number[];
+                    priceIdPt: ({
+                        multiply?: never;
+                    } & {
+                        simple: {
+                            priceId: import("bn.js");
+                        };
+                    }) | ({
+                        simple?: never;
+                    } & {
+                        multiply: {
+                            priceIds: import("bn.js")[];
+                        };
+                    });
+                    baseMint: web3.PublicKey;
+                };
+            };
+        }) | ({
+            obligation?: never;
+            orderbook?: never;
+            yieldPosition?: never;
+            clmmPosition?: never;
+            loopscaleLoan?: never;
+            loopscaleStrategy?: never;
+        } & {
+            tokenAccount: {
+                0: {
+                    tokenMint: web3.PublicKey;
+                    balances: {
+                        tokenAccount: web3.PublicKey;
+                        mint: web3.PublicKey;
+                        priceId: ({
+                            multiply?: never;
+                        } & {
+                            simple: {
+                                priceId: import("bn.js");
+                            };
+                        }) | ({
+                            simple?: never;
+                        } & {
+                            multiply: {
+                                priceIds: import("bn.js")[];
+                            };
+                        });
+                    }[];
+                };
+            };
+        }) | ({
+            obligation?: never;
+            orderbook?: never;
+            tokenAccount?: never;
+            clmmPosition?: never;
+            loopscaleLoan?: never;
+            loopscaleStrategy?: never;
+        } & {
+            yieldPosition: {
+                0: {
+                    yieldPosition: web3.PublicKey;
+                    vault: web3.PublicKey;
+                    priceIdPt: ({
+                        multiply?: never;
+                    } & {
+                        simple: {
+                            priceId: import("bn.js");
+                        };
+                    }) | ({
+                        simple?: never;
+                    } & {
+                        multiply: {
+                            priceIds: import("bn.js")[];
+                        };
+                    });
+                };
+            };
+        }) | ({
+            obligation?: never;
+            orderbook?: never;
+            tokenAccount?: never;
+            yieldPosition?: never;
+            loopscaleLoan?: never;
+            loopscaleStrategy?: never;
+        } & {
+            clmmPosition: {
+                0: {
+                    lpPosition: web3.PublicKey;
+                    market: web3.PublicKey;
+                    priceIdPt: ({
+                        multiply?: never;
+                    } & {
+                        simple: {
+                            priceId: import("bn.js");
+                        };
+                    }) | ({
+                        simple?: never;
+                    } & {
+                        multiply: {
+                            priceIds: import("bn.js")[];
+                        };
+                    });
+                    priceIdSy: ({
+                        multiply?: never;
+                    } & {
+                        simple: {
+                            priceId: import("bn.js");
+                        };
+                    }) | ({
+                        simple?: never;
+                    } & {
+                        multiply: {
+                            priceIds: import("bn.js")[];
+                        };
+                    });
+                };
+            };
+        }) | ({
+            obligation?: never;
+            orderbook?: never;
+            tokenAccount?: never;
+            yieldPosition?: never;
+            clmmPosition?: never;
+            loopscaleStrategy?: never;
+        } & {
+            loopscaleLoan: {
+                0: {
+                    loan: web3.PublicKey;
+                };
+            };
+        }) | ({
+            obligation?: never;
+            orderbook?: never;
+            tokenAccount?: never;
+            yieldPosition?: never;
+            clmmPosition?: never;
+            loopscaleLoan?: never;
+        } & {
+            loopscaleStrategy: {
+                0: {
+                    strategy: web3.PublicKey;
+                };
+            };
+        }))[];
+        maxAumSupply: import("bn.js");
+        seedId: number[];
+        roles: {
+            manager: web3.PublicKey[];
+            curator: web3.PublicKey[];
+            allocator: web3.PublicKey[];
+            sentinel: web3.PublicKey[];
+        };
+        proposalVoteConfig: {
+            minVotingPeriodSeconds: number;
+            maxVotingPeriodSeconds: number;
+            defaultVotingPeriodSeconds: number;
+            defaultTimelockSeconds: number;
+            rejectionThresholdBps: import("bn.js");
+            nextProposalId: import("bn.js");
+            votingEnabled: boolean;
+            liveProposalsCount: number;
+            maxConcurrentLiveProposals: number;
+            reserved: number[];
+        };
+        reservesConfig: {
+            reservesShareBp: number;
+            withdrawalPeriod: ({
+                weeklySchedule?: never;
+            } & {
+                interval: {
+                    lockTimeSeconds: number;
+                };
+            }) | ({
+                interval?: never;
+            } & {
+                weeklySchedule: {
+                    daysOfWeek: number;
+                    weekInterval: number;
+                    referenceTimestamp: number;
+                };
+            });
+            fastWithdrawalCutBp: number;
+            instantWithdrawalWindowLimitBp: number;
+            managementFeeBps: import("bn.js");
+            withdrawalCancelCooldownSeconds: number;
+            padding: number[];
+            padding1: number[];
+            padding2: number[];
+            padding3: number[];
+        };
+    }>;
+    fetchWithdrawalAccount(address: web3.PublicKey): Promise<{
+        vault: web3.PublicKey;
+        owner: web3.PublicKey;
+        lpAmountRequested: import("bn.js");
+        lpAmountRemaining: import("bn.js");
+        fills: {
+            mint: web3.PublicKey;
+            sourceTokenAccount: web3.PublicKey;
+            tokenAmount: import("bn.js");
+        }[];
+        createdAt: number;
+        updatedAt: number;
+        reserved: number[];
+    }>;
+    fetchActionProposal(address: web3.PublicKey): Promise<{
+        vault: web3.PublicKey;
+        proposalId: import("bn.js");
+        proposer: web3.PublicKey;
+        actionData: Buffer;
+        createdAt: import("bn.js");
+        votingEndsAt: import("bn.js");
+        timelockSeconds: number;
+        executableAt: import("bn.js");
+        status: ({
+            approved?: never;
+            rejected?: never;
+            executed?: never;
+            cancelled?: never;
+            draft?: never;
+        } & {
+            active: Record<string, never>;
+        }) | ({
+            active?: never;
+            rejected?: never;
+            executed?: never;
+            cancelled?: never;
+            draft?: never;
+        } & {
+            approved: Record<string, never>;
+        }) | ({
+            active?: never;
+            approved?: never;
+            executed?: never;
+            cancelled?: never;
+            draft?: never;
+        } & {
+            rejected: Record<string, never>;
+        }) | ({
+            active?: never;
+            approved?: never;
+            rejected?: never;
+            cancelled?: never;
+            draft?: never;
+        } & {
+            executed: Record<string, never>;
+        }) | ({
+            active?: never;
+            approved?: never;
+            rejected?: never;
+            executed?: never;
+            draft?: never;
+        } & {
+            cancelled: Record<string, never>;
+        }) | ({
+            active?: never;
+            approved?: never;
+            rejected?: never;
+            executed?: never;
+            cancelled?: never;
+        } & {
+            draft: Record<string, never>;
+        });
+        rejectVotes: import("bn.js");
+        optOutVotes: import("bn.js");
+        bump: number;
+        lpSupplySnapshot: import("bn.js");
+        rejectionRequiredSnapshot: import("bn.js");
+        reserved: number[];
+    }>;
+    fetchAllVaults(filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: any;
+    }[]>;
+    fetchAllActionProposals(filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: any;
+    }[]>;
+    fetchAllWithdrawalAccounts(filters?: web3.GetProgramAccountsFilter[]): Promise<import("@coral-xyz/anchor").ProgramAccount<{
+        vault: web3.PublicKey;
+        owner: web3.PublicKey;
+        lpAmountRequested: import("bn.js");
+        lpAmountRemaining: import("bn.js");
+        fills: {
+            mint: web3.PublicKey;
+            sourceTokenAccount: web3.PublicKey;
+            tokenAmount: import("bn.js");
+        }[];
+        createdAt: number;
+        updatedAt: number;
+        reserved: number[];
+    }>[]>;
+    fetchAllActionProposalsForVault(vaultAddress: web3.PublicKey, filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: any;
+    }[]>;
+    fetchVaultDeserialized(address: web3.PublicKey): Promise<ExponentVault>;
+    fetchActionProposalDeserialized(address: web3.PublicKey): Promise<ActionProposal>;
+    fetchWithdrawalAccountDeserialized(address: web3.PublicKey): Promise<WithdrawalAccount>;
+    fetchAllVaultsDeserialized(filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: ExponentVault;
+    }[]>;
+    fetchAllActionProposalsDeserialized(filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: ActionProposal;
+    }[]>;
+    fetchAllActionProposalsForVaultDeserialized(vaultAddress: web3.PublicKey, filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: ActionProposal;
+    }[]>;
+    fetchAllWithdrawalAccountsDeserialized(filters?: web3.GetProgramAccountsFilter[]): Promise<{
+        publicKey: web3.PublicKey;
+        account: {
+            vault: web3.PublicKey;
+            owner: web3.PublicKey;
+            lpAmountRequested: bigint;
+            lpAmountRemaining: bigint;
+            fills: {
+                mint: web3.PublicKey;
+                sourceTokenAccount: web3.PublicKey;
+                tokenAmount: bigint;
+            }[];
+            createdAt: number;
+            updatedAt: number;
+            reserved: number[];
+        };
+    }[]>;
+    /**
+     * Fetch the singleton ExponentPrices account.
+     */
+    fetchExponentPrices(): Promise<ExponentPrices>;
+    /**
+     * Get all unique price IDs required by a vault's token account positions.
+     * Returns a set of price IDs that should exist in an ExponentPrices account.
+     */
+    getRequiredPriceIds(vault: ExponentVault): Set<bigint>;
+}