@symmetry-hq/baskets-v2-sdk/dist/index.d.ts

Symmetry Baskets V2 SDK

import { Connection, PublicKey, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
import { CreateBasketParams, EditBasketParams } from "./basketManager";
import { ParsedBasketState } from "./state/basket";
import { VersionedTxs } from "./utils/txUtils";
import { BasketState } from "./state/basket";
import { ParsedWithdrawState, WithdrawState } from "./state/withdrawState";
import { PoolInfo } from "./state/oracle";
export { BasketState, WithdrawState, VersionedTxs, };
export declare class BasketsSDK {
    private sdkParams;
    constructor(params: {
        connection: Connection;
        payer?: PublicKey;
        priorityFee?: number;
        jupiterApiKey?: string;
        maxAllowedAccounts?: number;
    });
    setPayer(payer: PublicKey): Promise<void>;
    createBasket(params: CreateBasketParams): Promise<{
        blockhash: string;
        lastValidBlockHeight: number;
        versionedTxs: VersionedTransaction[];
        batches: number[];
        address: PublicKey;
    }>;
    editBasketSettings(params: EditBasketParams): Promise<VersionedTxs>;
    addLamportsForAutomation(params: {
        basket: PublicKey;
        amount: number;
    }): Promise<VersionedTxs>;
    findPoolsForToken(params: {
        token: PublicKey;
    }): Promise<PoolInfo[]>;
    createPythSponsoredFeed(): Promise<VersionedTxs>;
    updatePythSponsoredFeed(params: {
        tokenMint: PublicKey;
        feedAccount: PublicKey;
        isActive: boolean;
    }): Promise<VersionedTxs>;
    addNewToken(params: {
        basket: PublicKey;
        token: PublicKey;
        tokenWeight: number;
        oracleType: number;
        oraclePool: PublicKey;
        oracle1: PublicKey;
        oracle2: PublicKey;
    }): Promise<VersionedTxs>;
    removeToken(params: {
        basket: PublicKey;
        token: PublicKey;
    }): Promise<VersionedTxs>;
    updateTokenWeights(params: {
        basket: PublicKey;
        tokenWeights: number[];
        writeVersion: number;
    }): Promise<VersionedTxs>;
    buyBasketBackend(params: {
        basket: PublicKey;
        depositAmount: number;
        depositMint: PublicKey;
    }): Promise<VersionedTxs>;
    buyBasket(params: {
        basket: PublicKey;
        depositAmount: number;
        depositMint: PublicKey;
    }): Promise<VersionedTxs>;
    sellBasketBackend(params: {
        basket: PublicKey;
        amountToWithdraw: number;
        destinationMint: PublicKey;
        rebalance: boolean;
    }): Promise<{
        blockhash: string;
        lastValidBlockHeight: number;
        versionedTxs: VersionedTransaction[];
        batches: number[];
        address: PublicKey;
    }>;
    sellBasket(params: {
        basket: PublicKey;
        amountToWithdraw: number;
        destinationMint: PublicKey;
        rebalance: boolean;
    }): Promise<{
        blockhash: string;
        lastValidBlockHeight: number;
        versionedTxs: VersionedTransaction[];
        batches: number[];
        address: PublicKey;
    }>;
    rebalanceSellState(params: {
        withdrawState: PublicKey;
    }): Promise<VersionedTxs>;
    claimTokens(params: {
        withdrawState: PublicKey;
    }): Promise<VersionedTxs>;
    generateSwapQuote(params: {
        fromToken: PublicKey;
        toToken: PublicKey;
        amount: number;
        slippageBps: number;
    }): Promise<any>;
    swapTokens(params: {
        basket: PublicKey;
        fromToken: PublicKey;
        toToken: PublicKey;
        fromAmount: number;
        quoteResponse: any;
        fromTokenWeight?: number;
        toTokenWeight?: number;
    }): Promise<VersionedTxs>;
    rebalanceBasketTokensBackend(params: {
        basket: PublicKey;
        fromToken?: PublicKey;
        toToken?: PublicKey;
        minSwapValue?: number;
        maxSellValuePerToken?: number;
        maxNumberOfSwaps?: number;
    }): Promise<VersionedTxs>;
    rebalanceBasketTokens(params: {
        basket: PublicKey;
        fromToken?: PublicKey;
        toToken?: PublicKey;
        minSwapValue?: number;
        maxSellValuePerToken?: number;
        maxNumberOfSwaps?: number;
    }): Promise<VersionedTxs>;
    getBasket(params: {
        basket: PublicKey;
        requestTvl?: boolean;
    }): Promise<ParsedBasketState>;
    getWithdrawState(params: {
        withdrawState: PublicKey;
    }): Promise<ParsedWithdrawState>;
    getAllBaskets(): Promise<ParsedBasketState[]>;
    getBasketsByCreator(creator: PublicKey): Promise<ParsedBasketState[]>;
    getWithdrawStatesByUser(user: PublicKey): Promise<ParsedWithdrawState[]>;
    sendSignedVersionedTxs(txs: VersionedTxs, simulateTransactions?: boolean): Promise<TransactionSignature[]>;
    addSwapListener(callback: (event: any, slot: number, signature: string) => void): number;
    removeEventListener(id: number): void;
}