@unloc-xyz/unloc-sdk/dist/cjs/src/buyback-burn/buyback-utils.d.ts

Unloc SDK

/// <reference types="bn.js" />
import { Account, Connection, Keypair, PublicKey, Transaction } from '@solana/web3.js';
import * as anchor from "@project-serum/anchor";
import { Market as MarketSerum } from '@project-serum/serum';
import { LiquidityAssociatedPoolKeys } from "@raydium-io/raydium-sdk/src/liquidity";
export declare function getAssociatedPoolKeys({ programId, serumProgramId, marketId, baseMint, quoteMint, }: {
    programId: PublicKey;
    serumProgramId: PublicKey;
    marketId: PublicKey;
    baseMint: PublicKey;
    quoteMint: PublicKey;
}): Promise<LiquidityAssociatedPoolKeys>;
export declare function createAssociatedTokenAccountIfNotExist(owner: PublicKey, mint: PublicKey, transaction: Transaction, conn: any): Promise<PublicKey>;
export declare function sendTransaction(connection: Connection, wallet: any, transaction: Transaction, signers?: Array<Account>): Promise<string>;
export declare function getBigNumber(num: any): number;
export declare function getMarket(conn: any, marketAddress: string, serumProgramId: string): Promise<Market>;
export declare class Market extends MarketSerum {
    baseVault: PublicKey | null;
    quoteVault: PublicKey | null;
    requestQueue: PublicKey | null;
    eventQueue: PublicKey | null;
    bids: PublicKey | null;
    asks: PublicKey | null;
    baseLotSize: number;
    quoteLotSize: number;
    quoteMint: PublicKey | null;
    baseMint: PublicKey | null;
    vaultSignerNonce: Number | null;
    static load(connection: Connection, address: PublicKey, options: any, programId: PublicKey): Promise<Market>;
}
export declare function getMintDecimals(connection: Connection, mint: PublicKey): Promise<number>;
export declare function getFilteredTokenAccountsByOwner(connection: Connection, programId: PublicKey, mint: PublicKey): Promise<{
    context: {};
    value: [];
}>;
export declare function checkTxid(conn: Connection, txid: any): Promise<void>;
export declare function createMintPair(provider: anchor.AnchorProvider): Promise<{
    tokenAMintAddress: PublicKey;
    tokenBMintAddress: PublicKey;
}>;
export declare function createSerumMarket({ connection, wallet, baseMint, quoteMint, baseLotSize, quoteLotSize, dexProgram, market }: {
    connection: Connection;
    wallet: anchor.Wallet;
    baseMint: PublicKey;
    quoteMint: PublicKey;
    baseLotSize: number;
    quoteLotSize: number;
    dexProgram: PublicKey;
    market: Keypair;
}): Promise<SerumMarketInfo>;
export interface SerumMarketInfo {
    market: PublicKey;
    requestQueue: PublicKey;
    eventQueue: PublicKey;
    bids: PublicKey;
    asks: PublicKey;
    baseVault: PublicKey;
    quoteVault: PublicKey;
    baseMint: PublicKey;
    quoteMint: PublicKey;
    baseLotSize: anchor.BN;
    quoteLotSize: anchor.BN;
    feeRateBps: number;
    vaultOwner: PublicKey;
    vaultSignerNonce: anchor.BN;
    quoteDustThreshold: any;
    programId: any;
}
export declare function getVaultOwnerAndNonce(marketId: PublicKey, dexProgramId: PublicKey): Promise<{
    vaultOwner: PublicKey;
    vaultNonce: anchor.BN;
}>;
export declare function signTransactions({ transactionsAndSigners, wallet, connection, }: {
    transactionsAndSigners: {
        transaction: Transaction;
        signers?: Array<Keypair>;
    }[];
    wallet: anchor.Wallet;
    connection: Connection;
}): Promise<Transaction[]>;
export declare function sendSignedTransaction({ signedTransaction, connection, timeout, }: {
    signedTransaction: Transaction;
    connection: Connection;
    timeout?: number;
}): Promise<string>;
export declare const getUnixTs: () => number;
export declare function sleep(ms: any): Promise<unknown>;
//# sourceMappingURL=buyback-utils.d.ts.map