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

Software Development Kit for interacting with Symmetry Baskets Program

import { AddressLookupTableAccount, Connection, PublicKey, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
import { Program, Wallet, Idl } from "@coral-xyz/anchor";
import { BasketsIDL } from "./basketsIDL";
import { Basket } from "./basketState";
import { CreateBasketParams, FilterOption, TokenSettings, SimpleEditParams, SimpleCreateParams } from "./config";
import { BuyState } from "./buyState";
export * as BasketInstructions from "./basketInstructions";
export * from "./config";
export * from "./basketState";
export * from "./buyState";
export * from "./utils";
export * from "./basketsIDL";
export declare class BasketsSDK {
    private connection;
    private program;
    private swbProgram;
    private swbIDL;
    private tokenList;
    private lookups;
    private wallet?;
    private lamports;
    private jupAPIkey;
    constructor(connection: Connection, program: Program<BasketsIDL>, swbProgram: Program, swbIDL: Idl, tokenList: TokenSettings[], lookups: AddressLookupTableAccount[], wallet?: Wallet);
    static init(connection: Connection, wallet?: Wallet): Promise<BasketsSDK>;
    setWallet(wallet: Wallet): void;
    setPriorityFee(lamports: number): void;
    setJupAPIKey(apiKey: string): void;
    loadFromPubkey(pubkey: PublicKey): Promise<Basket>;
    getCurrentCompositions(baskets: Basket[]): Promise<any>;
    findBaskets(filters: FilterOption[]): Promise<Basket[]>;
    findActiveSellStates(user: PublicKey): Promise<Basket[]>;
    findActiveBuyStates(user: PublicKey): Promise<BuyState[]>;
    fetchAllBuyStates(filters: FilterOption[]): Promise<BuyState[]>;
    fetchBuyStateFromPubkey(pubkey: PublicKey): Promise<BuyState>;
    fetchAllSellStates(filters: FilterOption[]): Promise<Basket[]>;
    fetchAllHoldings(user: PublicKey): Promise<{
        basketAddress: string;
        mint: string;
        balance: number;
        basketData: any;
    }[]>;
    getTokenListData(): TokenSettings[];
    tokenIdFromMint(tokenMint: string): number;
    createBasket(createBasketParams: SimpleCreateParams): Promise<Basket>;
    simulateBasket(createBasketParams: CreateBasketParams, simulationDays: number): Promise<{
        price: number;
        currentCompAmount: number[];
        currentCompToken: number[];
    }[]>;
    editBasket(basket: Basket, editBasketParams: SimpleEditParams): Promise<TransactionSignature>;
    setMetadata(basket: Basket, symbol: string, name: string, uri?: string): Promise<TransactionSignature>;
    editManager(basket: Basket, newManager: PublicKey): Promise<TransactionSignature>;
    closeBasket(basket: Basket): Promise<TransactionSignature>;
    refilterBasketInstruction(basket: Basket): Promise<TransactionInstruction>;
    reweightBasketInstruction(basket: Basket): Promise<TransactionInstruction>;
    rebalanceBasket(basket: Basket, updateOracles?: boolean): Promise<TransactionSignature[]>;
    updateAllSwbOracles(): Promise<string[]>;
    rebalanceCronJob(basket: Basket, updateOracles?: boolean, maxAllowedAccounts?: number, softCap?: number, hardCap?: number, underTokens?: number, overTokens?: number): Promise<TransactionSignature[]>;
    filterCronJobBaskets(allBaskets: Basket[], softCap?: number): Promise<Basket[]>;
    buyBasket(basket: Basket, amountUsdc: number): Promise<BuyState>;
    getOraclePrices(): Promise<number[]>;
    computeMintAmountWithMultipleTokens(basket: Basket, contribution: {
        token: PublicKey;
        amount: number;
    }[]): Promise<number>;
    computeMintAmountWithSingleToken(basket: Basket, token: PublicKey, amount: number): Promise<number>;
    buyWithSingleToken(basket: Basket, token: PublicKey, amount: number, updateOracles?: boolean): Promise<TransactionSignature>;
    rebalanceBuyState(buyState: BuyState, updateOracles?: boolean): Promise<TransactionSignature[]>;
    mintBasket(buyState: BuyState, updateOracles?: boolean): Promise<TransactionSignature[]>;
    computeOutputAmountWithSingleToken(basket: Basket, withdrawToken: PublicKey, amount: number): Promise<number>;
    sellBasket(basket: Basket, amount: number, rebalance: number): Promise<Basket>;
    claimTokensFromBuyState(buyState: BuyState): Promise<TransactionSignature[]>;
    claimTokens(basket: Basket): Promise<TransactionSignature[]>;
    removeDust(basket: Basket, updateOracles?: boolean): Promise<TransactionSignature[]>;
    freezeProgram(): Promise<TransactionSignature>;
    unfreezeProgram(): Promise<TransactionSignature>;
}