@exponent-labs/exponent-sdk 0.1.7 → 0.9.0

package/build/exponentVaults/loopscale-client.d.ts

@@ -0,0 +1,541 @@
+import { type AccountMeta, type Commitment, type SendOptions, type Signer, Connection, PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { type LoopscaleInstruction } from "./vault-interaction";
+export interface LoopscaleClientConfig {
+    connection: Connection;
+    /** Wallet address sent as `user-wallet` / `payer` header to the Loopscale API. */
+    userWallet: PublicKey | string;
+    /** Loopscale API base URL (default: https://tars.loopscale.com/v1). */
+    baseUrl?: string;
+    /** Known bs_auth public key (default: CyNKPf...). */
+    bsAuth?: PublicKey;
+    /** Use Luke's batch-based MPC endpoint for co-signing (default: true). */
+    useMpcCoSign?: boolean;
+    /** Log request/response details to console. */
+    debug?: boolean;
+}
+export interface LoopscaleQuoteParams {
+    durationType: number;
+    duration: number;
+    principal: PublicKey | string;
+    collateral: (PublicKey | string)[];
+    limit?: number;
+    offset?: number;
+}
+export interface LoopscaleCreateStrategyParams {
+    principalMint: PublicKey | string;
+    lender: PublicKey | string;
+    amount: bigint | number;
+    originationsEnabled?: boolean;
+    liquidityBuffer?: number;
+    interestFee?: number;
+    originationFee?: number;
+    originationCap?: number;
+    collateralTerms?: Array<{
+        apy: number;
+        indices: Array<{
+            collateralIndex: number;
+            durationIndex: number;
+        }>;
+    }>;
+    marketInformation?: PublicKey | string;
+    externalYieldSourceArgs?: TxnExternalYieldSourceArgs;
+}
+export interface LoopscaleDepositStrategyParams {
+    strategy: PublicKey | string;
+    amount: bigint | number;
+}
+export interface LoopscaleWithdrawStrategyParams {
+    strategy: PublicKey | string;
+    amount: bigint | number;
+    withdrawAll: boolean;
+}
+export interface LoopscaleCloseStrategyParams {
+    strategy: PublicKey | string;
+}
+export interface ExternalYieldSourceParams {
+    newExternalYieldSource: number;
+}
+export interface TxnExternalYieldSourceArgs extends ExternalYieldSourceParams {
+    createExternalYieldAccount: boolean;
+}
+export interface StrategyDuration {
+    duration: number;
+    durationType: number;
+}
+export interface AddCollateralArgs {
+    durationsAndApys?: Record<string, string>;
+    externalMarketInformationAddress?: string;
+    marketInformation?: Record<string, unknown>;
+}
+export interface RemoveCollateralArgs {
+    durations: StrategyDuration[];
+    removeFromMarketInformation: boolean;
+}
+export interface CollateralParamsUpdateArgs {
+    ltvUpdate?: Record<string, unknown>;
+    apyUpdate?: Record<string, string>;
+}
+export interface CollateralAllocationUpdateArgs {
+    assetIdentifier: string;
+    maxAllocationPct: string;
+}
+export interface StrategyCollateralUpdates {
+    addCollateral?: Record<string, AddCollateralArgs>;
+    removeCollateral?: Record<string, RemoveCollateralArgs>;
+    updateCollateral?: Record<string, CollateralParamsUpdateArgs>;
+    updateAssetAllocation?: CollateralAllocationUpdateArgs[];
+}
+export interface EditStrategySettingsArgs {
+    originationsEnabled?: boolean;
+    liquidityBuffer?: number;
+    interestFee?: number;
+    originationFee?: number;
+    principalFee?: number;
+    originationCap?: number;
+    externalYieldSource?: ExternalYieldSourceParams;
+}
+export interface LoopscaleUpdateStrategyParams {
+    strategy: PublicKey | string;
+    collateralTerms?: StrategyCollateralUpdates;
+    updateParams?: EditStrategySettingsArgs;
+}
+export interface LoopscaleBorrowPrincipalParams {
+    /** Borrower / vault address (also the payer for ATA creation). */
+    borrower: PublicKey | string;
+    /** Existing loan with collateral already deposited. */
+    loan: PublicKey | string;
+    /** Strategy supplying principal liquidity. */
+    strategy: PublicKey | string;
+    /** MarketInformation account for the borrow strategy. */
+    marketInformation: PublicKey | string;
+    /** Mint of the borrowed asset. */
+    principalMint: PublicKey | string;
+    /** Amount of principal to borrow (lamports). */
+    amount: bigint | number;
+    /** Duration index (0=1day, 1=1week, 2=1month, 3=3months, 4=5min). */
+    durationIndex: number;
+    /** Byte buffer consumed by sync_risk_matrices + validate_loan_health. */
+    assetIndexGuidance: number[];
+    /** Oracle remaining accounts for health check (MarketInformation + oracle pubkeys). */
+    healthCheckAccounts: AccountMeta[];
+    expectedApy?: bigint | number;
+    /** Expected liquidation thresholds per collateral index [5 entries]. */
+    expectedLqt?: number[];
+    /** Keep result as wSOL instead of unwrapping (default: false). */
+    skipSolUnwrap?: boolean;
+}
+export interface LoopscaleRepayLoanParams {
+    loan: PublicKey | string;
+    repayParams: Array<{
+        amount: bigint | number;
+        ledgerIndex: number;
+        repayAll: boolean;
+    }>;
+    collateralWithdrawalParams?: Array<{
+        amount: bigint | number;
+        collateralMint: PublicKey | string;
+    }>;
+    closeIfPossible?: boolean;
+}
+export interface LoopscaleCloseLoanParams {
+    loan: PublicKey | string;
+}
+export interface LoopscaleCreateLoanParams {
+    borrower: PublicKey | string;
+    depositCollateral: Array<{
+        collateralAmount: bigint | number;
+        collateralAssetData: {
+            Spl: {
+                mint: string;
+            };
+        } | {
+            Orca: {
+                positionMint: string;
+                whirlpool: string;
+            };
+        };
+    }>;
+    principalRequested: Array<{
+        ledgerIndex: number;
+        principalAmount: bigint | number;
+        principalMint: PublicKey | string;
+        strategy: PublicKey | string;
+        durationIndex: number;
+        expectedLoanValues?: {
+            expectedApy?: number;
+            expectedLqt?: number[];
+        };
+    }>;
+    assetIndexGuidance?: number[];
+    loanNonce?: string;
+    isLoop?: boolean;
+}
+export interface LoopscaleApiBorrowPrincipalParams {
+    loan: PublicKey | string;
+    borrowParams: {
+        amount: bigint | number;
+        durationIndex: number;
+        expectedLoanValues?: {
+            expectedApy?: number;
+            expectedLqt?: number[];
+        };
+    };
+    strategy: PublicKey | string;
+    refinanceParams?: {
+        ledgerIndex: number;
+        durationIndex: number;
+    };
+    isLoop?: boolean;
+}
+export interface LoopscaleDepositCollateralParams {
+    loan: PublicKey | string;
+    depositMint: PublicKey | string;
+    amount: bigint | number;
+    assetType: number;
+    assetIdentifier: PublicKey | string;
+    assetIndexGuidance?: number[];
+    expectedLoanValues?: {
+        expectedApy?: number;
+        expectedLqt?: number[];
+    };
+}
+export interface LoopscaleWithdrawCollateralParams {
+    loan: PublicKey | string;
+    collateralMint: PublicKey | string;
+    amount: bigint | number;
+    collateralIndex: number;
+    expectedLoanValues?: {
+        expectedApy?: number;
+        expectedLqt?: number[];
+    };
+    assetIndexGuidance?: number[];
+}
+export interface LoopscaleRefinanceLoanParams {
+    loan: PublicKey | string;
+    oldStrategy: PublicKey | string;
+    newStrategy: PublicKey | string;
+    refinanceParams: {
+        ledgerIndex: number;
+        durationIndex: number;
+    };
+}
+export interface LoopscaleMaxQuoteParams {
+    durationType: number;
+    duration: number;
+    principalMint: PublicKey | string;
+    collateralFilter: Array<{
+        amount: bigint | number;
+        assetData: {
+            Spl: {
+                mint: string;
+            };
+        } | {
+            Orca: {
+                positionMint: string;
+                whirlpool: string;
+            };
+        };
+    }>;
+}
+export interface LoopscaleMaxQuote {
+    apy: number;
+    strategy: string;
+    collateralIdentifier: string;
+    ltv: number;
+    lqt: number;
+    amount: number;
+}
+export interface LoopscaleLoanInfoParams {
+    loanAddresses?: string[];
+    lenders?: string[];
+    borrowers?: string[];
+    filterType?: number;
+    principalMints?: string[];
+    collateralMints?: string[];
+    orderFundingType?: number;
+    page?: number;
+    pageSize?: number;
+    sortDirection?: number;
+    sortType?: number;
+    assetTypes?: number;
+    excludeCollateralIdentifiers?: string[];
+    excludePrincipalMints?: string[];
+}
+export interface LoopscaleLoanInfoResponse {
+    totalCount: number;
+    loanInfos: Array<{
+        loan: {
+            address: string;
+            loanStatus: number;
+            borrower: string;
+            startTime: number;
+            [key: string]: unknown;
+        };
+        loanType: number;
+        ledgers: Array<{
+            ledgerIndex: number;
+            strategy: string;
+            principalMint: string;
+            principalDue: number;
+            interestOutstanding: number;
+            apy: number;
+            endTime: number;
+            [key: string]: unknown;
+        }>;
+        collateral: Array<{
+            assetMint: string;
+            amount: number;
+            assetType: number;
+            [key: string]: unknown;
+        }>;
+        [key: string]: unknown;
+    }>;
+}
+export interface LoopscaleGetStrategiesParams {
+    userAddress?: string;
+    addresses?: string[];
+    principalMints?: string[];
+    page?: number;
+    pageSize?: number;
+}
+export interface LoopscaleStrategyInfoResponse {
+    strategies: Array<{
+        strategy: {
+            address: string;
+            principalMint: string;
+            tokenBalance: number;
+            currentDeployedAmount: number;
+            outstandingInterestAmount: number;
+            [key: string]: unknown;
+        };
+        externalYieldInfo?: {
+            apy: number;
+        };
+    }>;
+    total: number;
+}
+export interface LoopscaleCollateralHoldersParams {
+    mints: string[];
+    pdas?: boolean;
+}
+export interface LoopscaleCollateralHolder {
+    collateralMint: string;
+    totalDeposits: number;
+    userDeposits: Record<string, number>;
+}
+export interface LoopscaleHistoricalCollateralHoldersParams {
+    mint: string;
+    rangeStart?: number;
+    rangeEnd?: number;
+    pdas?: boolean;
+}
+export interface LoopscaleHistoricalCollateralHolder {
+    collateralMint: string;
+    rangeStart: number;
+    rangeEnd: number;
+    userDepositSeconds: Record<string, number>;
+}
+export interface LoopscaleVaultDepositorsParams {
+    vaultAddresses?: string[];
+    principalMints?: string[];
+}
+export interface LoopscaleVaultDepositor {
+    vaultAddress: string;
+    userDeposits: Array<{
+        userAddress: string;
+        amountSupplied: string;
+    }>;
+}
+export interface LoopscaleVaultInfoParams {
+    vaultAddresses?: string[];
+    vaultIdentifiers?: string[];
+    principalMints?: string[];
+    includeRewards?: boolean;
+    page: number;
+    pageSize: number;
+}
+export interface LoopscaleVaultInfoResponse {
+    lendVaults: Array<{
+        vault: {
+            address: string;
+            vaultIdentifier: string;
+            principalMint: string;
+            lpMint: string;
+        };
+        vaultMetadata: {
+            name: string;
+            description: string;
+            managerName: string;
+            depositCap: number;
+        };
+        vaultStrategy: {
+            strategy: {
+                address: string;
+                tokenBalance: number;
+                currentDeployedAmount: number;
+                [key: string]: unknown;
+            };
+        };
+        [key: string]: unknown;
+    }>;
+    total: number;
+}
+export interface LoopscaleLoopInfoParams {
+    loopVaults?: string[];
+    tags?: string[];
+}
+export interface LoopscaleLoopVaultInfo {
+    collateralMint: string;
+    principalMint: string;
+    collateralDeposited: number;
+    collateralApyPct: number;
+    maxLeverage: number;
+    name: string;
+    maxLeveragedApyPct: number;
+    principalAmountAvailable: number;
+    [key: string]: unknown;
+}
+export interface LoopscaleGeneratedInstruction {
+    name: LoopscaleInstructionName | null;
+    instruction: TransactionInstruction;
+}
+export interface LoopscaleGeneratedInstructionBundle {
+    transaction: VersionedTransaction;
+    instructions: TransactionInstruction[];
+    loopscaleInstructions: LoopscaleGeneratedInstruction[];
+}
+export interface LoopscaleTxResult {
+    /** Loopscale instructions wrapped via loopscaleAction.* — ready for createVaultSyncTransaction. */
+    syncActions: LoopscaleInstruction[];
+    /** Non-Loopscale instructions that belong outside the sync tx (compute budget, etc.). */
+    topLevelInstructions: TransactionInstruction[];
+    /** Raw decompiled bundle. */
+    raw: LoopscaleGeneratedInstructionBundle;
+}
+export interface LoopscaleStrategyBatch {
+    /** Loopscale instructions wrapped via loopscaleAction.* — ready for createVaultSyncTransaction. */
+    syncActions: LoopscaleInstruction[];
+    /** Non-Loopscale instructions that belong outside the sync tx (compute budget, oracles, etc.). */
+    topLevelInstructions: TransactionInstruction[];
+    /** Setup instructions returned by Loopscale that should not be wrapped in the sync tx. */
+    setupInstructions: TransactionInstruction[];
+    /** Raw decompiled batch. */
+    raw: LoopscaleGeneratedInstructionBundle;
+}
+export interface LoopscaleStrategyBatchesResult {
+    batches: LoopscaleStrategyBatch[];
+}
+export interface LoopscaleStrategyResult extends LoopscaleStrategyBatchesResult {
+    strategyAddress: PublicKey;
+    noncePublicKey: PublicKey;
+}
+export interface LoopscaleUpdateStrategyResult extends LoopscaleStrategyBatchesResult {
+}
+export interface LoopscaleCreateLoanResult extends LoopscaleTxResult {
+    loanAddress: PublicKey;
+}
+export interface VaultExecutionContext {
+    owner: PublicKey;
+    vaultPda: PublicKey;
+    signer: PublicKey;
+    signers: Signer[];
+    vaultAddress?: PublicKey;
+    accountIndex?: number;
+    policyPda?: PublicKey;
+    constraintIndices?: number[];
+    leadingAccounts?: PublicKey[] | AccountMeta[];
+    preHookAccounts?: PublicKey[] | AccountMeta[];
+    postHookAccounts?: PublicKey[] | AccountMeta[];
+    squadsProgram?: PublicKey;
+    addressLookupTableAccounts?: import("@solana/web3.js").AddressLookupTableAccount[];
+    prependInstructions?: TransactionInstruction[];
+    sendOptions?: SendOptions;
+    commitment?: Commitment;
+}
+export interface BatchExecutionResult {
+    batchIndex: number;
+    signature: string;
+    logs: string[] | null;
+    error: unknown;
+}
+export interface ExecutionResult {
+    error: unknown;
+    results: BatchExecutionResult[];
+}
+export interface ClassifiedInstructions {
+    /** Loopscale instructions to wrap in sync tx. */
+    loopscale: LoopscaleGeneratedInstruction[];
+    /** Compute budget, oracles, etc. for outer tx. */
+    topLevel: TransactionInstruction[];
+    /** ATA creation etc. — safe to skip. */
+    setup: TransactionInstruction[];
+}
+export interface LoopscaleQuote {
+    apy: number;
+    ltv: number;
+    liquidationThreshold: number;
+    maxPrincipalAvailable: number;
+    strategy?: string;
+    [key: string]: unknown;
+}
+type LoopscaleInstructionName = "createLoan" | "depositCollateral" | "borrowPrincipal" | "repayPrincipal" | "withdrawCollateral" | "closeLoan" | "updateWeightMatrix" | "lockLoan" | "unlockLoan" | "createStrategy" | "depositStrategy" | "withdrawStrategy" | "closeStrategy" | "updateStrategy" | "refinanceLedger";
+export declare class LoopscaleClient {
+    private readonly connection;
+    private readonly baseUrl;
+    private readonly userWallet;
+    private readonly bsAuth;
+    private readonly useMpcCoSign;
+    private readonly debug;
+    private vaultCtx;
+    constructor(config: LoopscaleClientConfig);
+    setVaultContext(ctx: VaultExecutionContext): void;
+    private requireVaultContext;
+    executeBatches(batches: LoopscaleStrategyBatch[]): Promise<ExecutionResult>;
+    executeSyncTx(syncActions: LoopscaleInstruction[]): Promise<BatchExecutionResult>;
+    private executePrebuiltBatch;
+    private executeSyncBatch;
+    private sendAndConfirm;
+    getQuotes(params: LoopscaleQuoteParams): Promise<LoopscaleQuote[]>;
+    getMaxQuote(params: LoopscaleMaxQuoteParams): Promise<LoopscaleMaxQuote[]>;
+    getLoanInfo(params: LoopscaleLoanInfoParams): Promise<LoopscaleLoanInfoResponse>;
+    getStrategies(params: LoopscaleGetStrategiesParams): Promise<LoopscaleStrategyInfoResponse>;
+    getCollateralHolders(params: LoopscaleCollateralHoldersParams): Promise<LoopscaleCollateralHolder[]>;
+    getHistoricalCollateralHolders(params: LoopscaleHistoricalCollateralHoldersParams): Promise<LoopscaleHistoricalCollateralHolder[]>;
+    getVaultDepositors(params: LoopscaleVaultDepositorsParams): Promise<LoopscaleVaultDepositor[]>;
+    getVaultInfo(params: LoopscaleVaultInfoParams): Promise<LoopscaleVaultInfoResponse>;
+    getLoopInfo(params: LoopscaleLoopInfoParams): Promise<Record<string, LoopscaleLoopVaultInfo>>;
+    createStrategy(params: LoopscaleCreateStrategyParams): Promise<LoopscaleStrategyResult>;
+    depositStrategy(params: LoopscaleDepositStrategyParams): Promise<LoopscaleTxResult>;
+    withdrawStrategy(params: LoopscaleWithdrawStrategyParams): Promise<LoopscaleTxResult>;
+    closeStrategy(params: LoopscaleCloseStrategyParams): Promise<LoopscaleTxResult>;
+    updateStrategy(params: LoopscaleUpdateStrategyParams): Promise<LoopscaleUpdateStrategyResult>;
+    /**
+     * Build a standalone borrow_principal instruction (no lock/unlock needed).
+     * Requires collateral to already be deposited in the loan.
+     */
+    buildBorrowPrincipalInstruction(params: LoopscaleBorrowPrincipalParams): TransactionInstruction;
+    /**
+     * Build a standalone borrow_principal wrapped as a LoopscaleInstruction for sync tx.
+     * Requires collateral to already be deposited in the loan.
+     */
+    buildBorrowPrincipalAction(params: LoopscaleBorrowPrincipalParams): LoopscaleInstruction;
+    repayLoan(params: LoopscaleRepayLoanParams): Promise<LoopscaleTxResult>;
+    closeLoan(params: LoopscaleCloseLoanParams): Promise<LoopscaleTxResult>;
+    createLoan(params: LoopscaleCreateLoanParams): Promise<LoopscaleCreateLoanResult>;
+    apiBorrowPrincipal(params: LoopscaleApiBorrowPrincipalParams): Promise<LoopscaleTxResult>;
+    depositCollateral(params: LoopscaleDepositCollateralParams): Promise<LoopscaleTxResult>;
+    withdrawCollateral(params: LoopscaleWithdrawCollateralParams): Promise<LoopscaleTxResult>;
+    refinanceLoan(params: LoopscaleRefinanceLoanParams): Promise<LoopscaleTxResult>;
+    coSign(transaction: VersionedTransaction): Promise<VersionedTransaction>;
+    classifyInstructions(instructions: TransactionInstruction[]): ClassifiedInstructions;
+    static identifyInstruction(ix: TransactionInstruction): LoopscaleInstructionName | null;
+    private buildSyncActions;
+    private buildRawBundle;
+    private toSingleTxResult;
+    private parseTransactionEntry;
+    private parseStrategyBatches;
+    private fetchAndClassifyWrappedTx;
+    private fetchAndClassifySingleTx;
+    private post;
+}
+export {};