@velocity-exchange/sdk 0.0.1

package/lib/browser/titan/titanClient.js

@@ -0,0 +1,227 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TitanClient = exports.SwapMode = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const msgpack_1 = require("@msgpack/msgpack");
+var SwapMode;
+(function (SwapMode) {
+    SwapMode["ExactIn"] = "ExactIn";
+    SwapMode["ExactOut"] = "ExactOut";
+})(SwapMode || (exports.SwapMode = SwapMode = {}));
+const TITAN_API_URL = 'https://api.titan.exchange';
+class TitanClient {
+    constructor({ connection, authToken, url, proxyUrl, }) {
+        this.connection = connection;
+        this.authToken = authToken;
+        this.url = url !== null && url !== void 0 ? url : TITAN_API_URL;
+        this.proxyUrl = proxyUrl;
+    }
+    buildParams({ inputMint, outputMint, amount, userPublicKey, maxAccounts, slippageBps, swapMode, onlyDirectRoutes, excludeDexes, sizeConstraint, accountsLimitWritable, }) {
+        // Normalize swapMode to enum value
+        const normalizedSwapMode = swapMode === 'ExactOut' || swapMode === SwapMode.ExactOut
+            ? SwapMode.ExactOut
+            : SwapMode.ExactIn;
+        return new URLSearchParams({
+            inputMint: inputMint.toString(),
+            outputMint: outputMint.toString(),
+            amount: amount.toString(),
+            userPublicKey: userPublicKey.toString(),
+            ...(slippageBps && { slippageBps: slippageBps.toString() }),
+            ...(swapMode && { swapMode: normalizedSwapMode.toString() }),
+            ...(maxAccounts && { accountsLimitTotal: maxAccounts.toString() }),
+            ...(excludeDexes && { excludeDexes: excludeDexes.join(',') }),
+            ...(onlyDirectRoutes && {
+                onlyDirectRoutes: onlyDirectRoutes.toString(),
+            }),
+            ...(sizeConstraint && { sizeConstraint: sizeConstraint.toString() }),
+            ...(accountsLimitWritable && {
+                accountsLimitWritable: accountsLimitWritable.toString(),
+            }),
+        });
+    }
+    /**
+     * Get routes for a swap
+     */
+    async getQuote({ inputMint, outputMint, amount, userPublicKey, maxAccounts = 50, // 50 is an estimated amount with buffer
+    slippageBps, swapMode, onlyDirectRoutes, excludeDexes, sizeConstraint, accountsLimitWritable, }) {
+        var _a;
+        const params = this.buildParams({
+            inputMint,
+            outputMint,
+            amount,
+            userPublicKey,
+            maxAccounts,
+            slippageBps,
+            swapMode,
+            onlyDirectRoutes,
+            excludeDexes,
+            sizeConstraint,
+            accountsLimitWritable,
+        });
+        let response;
+        if (this.proxyUrl) {
+            // Use proxy route - send parameters in request body
+            response = await fetch(this.proxyUrl, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(Object.fromEntries(params.entries())),
+            });
+        }
+        else {
+            // Direct request to Titan API
+            response = await fetch(`${this.url}/api/v1/quote/swap?${params.toString()}`, {
+                headers: {
+                    Accept: 'application/vnd.msgpack',
+                    'Accept-Encoding': 'gzip, deflate, br',
+                    Authorization: `Bearer ${this.authToken}`,
+                },
+            });
+        }
+        if (!response.ok) {
+            throw new Error(`Titan API error: ${response.status} ${response.statusText}`);
+        }
+        const buffer = await response.arrayBuffer();
+        const data = (0, msgpack_1.decode)(buffer);
+        // Cache the quote data and parameters for later use in getSwap
+        this.lastQuoteData = data;
+        this.lastQuoteParams = params.toString();
+        // We are only querying for the best avaiable route so use that
+        const route = data.quotes[Object.keys(data.quotes)[0]];
+        if (!route) {
+            throw new Error('No routes available');
+        }
+        return {
+            inputMint: inputMint.toString(),
+            inAmount: amount.toString(),
+            outputMint: outputMint.toString(),
+            outAmount: route.outAmount.toString(),
+            swapMode: data.swapMode,
+            slippageBps: route.slippageBps,
+            platformFee: route.platformFee
+                ? {
+                    amount: route.platformFee.amount.toString(),
+                    feeBps: route.platformFee.fee_bps,
+                }
+                : undefined,
+            routePlan: ((_a = route.steps) === null || _a === void 0 ? void 0 : _a.map((step) => {
+                var _a;
+                return ({
+                    swapInfo: {
+                        ammKey: new web3_js_1.PublicKey(step.ammKey).toString(),
+                        label: step.label,
+                        inputMint: new web3_js_1.PublicKey(step.inputMint).toString(),
+                        outputMint: new web3_js_1.PublicKey(step.outputMint).toString(),
+                        inAmount: step.inAmount.toString(),
+                        outAmount: step.outAmount.toString(),
+                        feeAmount: ((_a = step.feeAmount) === null || _a === void 0 ? void 0 : _a.toString()) || '0',
+                        feeMint: step.feeMint ? new web3_js_1.PublicKey(step.feeMint).toString() : '',
+                    },
+                    percent: 100,
+                });
+            })) || [],
+            contextSlot: route.contextSlot,
+            timeTaken: route.timeTaken,
+        };
+    }
+    /**
+     * Get a swap transaction for quote
+     */
+    async getSwap({ userPublicKey, }) {
+        // Check if we have cached quote data that matches the current parameters
+        if (!this.lastQuoteData) {
+            throw new Error('No matching quote data found. Please get a fresh quote before attempting to swap.');
+        }
+        // Reuse the cached quote data
+        const data = this.lastQuoteData;
+        // We are only querying for the best avaiable route so use that
+        const route = data.quotes[Object.keys(data.quotes)[0]];
+        if (!route) {
+            throw new Error('No routes available');
+        }
+        if (route.instructions && route.instructions.length > 0) {
+            try {
+                const { transactionMessage, lookupTables } = await this.getTransactionMessageAndLookupTables(route, userPublicKey);
+                return { transactionMessage, lookupTables };
+            }
+            catch (err) {
+                throw new Error('Something went wrong with creating the Titan swap transaction. Please try again.');
+            }
+            finally {
+                // Clear cached quote data after use
+                this.lastQuoteData = undefined;
+                this.lastQuoteParams = undefined;
+            }
+        }
+        throw new Error('No instructions provided in the route');
+    }
+    /**
+     * Get the titan instructions from transaction by filtering out instructions to compute budget and associated token programs
+     * @param transactionMessage the transaction message
+     * @param inputMint the input mint
+     * @param outputMint the output mint
+     */
+    getTitanInstructions({ transactionMessage, inputMint, outputMint, }) {
+        // Filter out common system instructions that can be handled by VelocityClient
+        const filteredInstructions = transactionMessage.instructions.filter((instruction) => {
+            const programId = instruction.programId.toString();
+            // Filter out system programs
+            if (programId === 'ComputeBudget111111111111111111111111111111') {
+                return false;
+            }
+            if (programId === 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA') {
+                return false;
+            }
+            if (programId === '11111111111111111111111111111111') {
+                return false;
+            }
+            // Filter out Associated Token Account creation for input/output mints
+            if (programId === 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL') {
+                if (instruction.keys.length > 3) {
+                    const mint = instruction.keys[3].pubkey;
+                    if (mint.equals(inputMint) || mint.equals(outputMint)) {
+                        return false;
+                    }
+                }
+            }
+            return true;
+        });
+        return filteredInstructions;
+    }
+    async getTransactionMessageAndLookupTables(route, userPublicKey) {
+        const solanaInstructions = route.instructions.map((instruction) => ({
+            programId: new web3_js_1.PublicKey(instruction.p),
+            keys: instruction.a.map((meta) => ({
+                pubkey: new web3_js_1.PublicKey(meta.p),
+                isSigner: meta.s,
+                isWritable: meta.w,
+            })),
+            data: Buffer.from(instruction.d),
+        }));
+        // Get recent blockhash
+        const { blockhash } = await this.connection.getLatestBlockhash();
+        // Build address lookup tables if provided
+        const addressLookupTables = [];
+        if (route.addressLookupTables && route.addressLookupTables.length > 0) {
+            for (const altPubkey of route.addressLookupTables) {
+                try {
+                    const altAccount = await this.connection.getAddressLookupTable(new web3_js_1.PublicKey(altPubkey));
+                    if (altAccount.value) {
+                        addressLookupTables.push(altAccount.value);
+                    }
+                }
+                catch (err) {
+                    console.warn(`Failed to fetch address lookup table:`, err);
+                }
+            }
+        }
+        const transactionMessage = new web3_js_1.TransactionMessage({
+            payerKey: userPublicKey,
+            recentBlockhash: blockhash,
+            instructions: solanaInstructions,
+        });
+        return { transactionMessage, lookupTables: addressLookupTables };
+    }
+}
+exports.TitanClient = TitanClient;

package/lib/browser/token/index.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Account } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+export declare function parseTokenAccount(data: Buffer, pubkey: PublicKey): Account;

package/lib/browser/token/index.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTokenAccount = void 0;
+const spl_token_1 = require("@solana/spl-token");
+function parseTokenAccount(data, pubkey) {
+    // mock AccountInfo so unpackAccount can be used
+    const accountInfo = {
+        data,
+        owner: spl_token_1.TOKEN_PROGRAM_ID,
+        executable: false,
+        lamports: 0,
+    };
+    return (0, spl_token_1.unpackAccount)(pubkey, accountInfo, spl_token_1.TOKEN_PROGRAM_ID);
+}
+exports.parseTokenAccount = parseTokenAccount;

package/lib/browser/tokenFaucet.d.ts

@@ -0,0 +1,41 @@
+/// <reference types="bn.js" />
+import * as anchor from './isomorphic/anchor29';
+import { AnchorProvider, Program } from './isomorphic/anchor29';
+import { Account } from '@solana/spl-token';
+import { ConfirmOptions, Connection, PublicKey, TransactionInstruction, TransactionSignature } from '@solana/web3.js';
+import { IWallet } from './types';
+import { BankrunContextWrapper } from './bankrun/bankrunConnection';
+import { BN } from './isomorphic/anchor';
+export declare class TokenFaucet {
+    context?: BankrunContextWrapper;
+    connection: Connection;
+    wallet: IWallet;
+    program: Program;
+    provider: AnchorProvider;
+    mint: PublicKey;
+    opts?: ConfirmOptions;
+    constructor(connection: Connection, wallet: IWallet, programId: PublicKey, mint: PublicKey, opts?: ConfirmOptions, context?: BankrunContextWrapper);
+    getFaucetConfigPublicKeyAndNonce(): Promise<[
+        PublicKey,
+        number
+    ]>;
+    getMintAuthority(): Promise<PublicKey>;
+    getFaucetConfigPublicKey(): Promise<PublicKey>;
+    initialize(): Promise<TransactionSignature>;
+    fetchState(): Promise<any>;
+    private mintToUserIx;
+    mintToUser(userTokenAccount: PublicKey, amount: BN): Promise<TransactionSignature>;
+    transferMintAuthority(): Promise<TransactionSignature>;
+    createAssociatedTokenAccountAndMintTo(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionSignature]>;
+    createAssociatedTokenAccountAndMintToInstructions(userPublicKey: PublicKey, amount: BN): Promise<[PublicKey, TransactionInstruction, TransactionInstruction]>;
+    getAssosciatedMockUSDMintAddress(props: {
+        userPubKey: PublicKey;
+    }): Promise<anchor.web3.PublicKey>;
+    getTokenAccountInfo(props: {
+        userPubKey: PublicKey;
+    }): Promise<Account>;
+    subscribeToTokenAccount(props: {
+        userPubKey: PublicKey;
+        callback: (accountInfo: Account) => void;
+    }): Promise<boolean>;
+}

package/lib/browser/tokenFaucet.js

@@ -0,0 +1,188 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenFaucet = void 0;
+const anchor = __importStar(require("./isomorphic/anchor29"));
+const anchor29_1 = require("./isomorphic/anchor29");
+const spl_token_1 = require("@solana/spl-token");
+const web3_js_1 = require("@solana/web3.js");
+const token_faucet_json_1 = __importDefault(require("./idl/token_faucet.json"));
+const config_1 = require("./config");
+class TokenFaucet {
+    constructor(connection, wallet, programId, mint, opts, context) {
+        this.connection = connection;
+        this.context = context;
+        this.wallet = wallet;
+        this.opts = opts || config_1.DEFAULT_CONFIRMATION_OPTS;
+        // @ts-ignore
+        const provider = new anchor29_1.AnchorProvider(context ? context.connection.toConnection() : this.connection, 
+        // @ts-ignore
+        wallet, this.opts);
+        this.provider = provider;
+        this.program = new anchor29_1.Program(token_faucet_json_1.default, programId, provider);
+        this.mint = mint;
+    }
+    async getFaucetConfigPublicKeyAndNonce() {
+        return anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('faucet_config')),
+            this.mint.toBuffer(),
+        ], this.program.programId);
+    }
+    async getMintAuthority() {
+        return (await anchor.web3.PublicKey.findProgramAddress([
+            Buffer.from(anchor.utils.bytes.utf8.encode('mint_authority')),
+            this.mint.toBuffer(),
+        ], this.program.programId))[0];
+    }
+    async getFaucetConfigPublicKey() {
+        return (await this.getFaucetConfigPublicKeyAndNonce())[0];
+    }
+    async initialize() {
+        const [faucetConfigPublicKey] = await this.getFaucetConfigPublicKeyAndNonce();
+        const ix = this.program.instruction.initialize({
+            accounts: {
+                faucetConfig: faucetConfigPublicKey,
+                admin: this.wallet.publicKey,
+                mintAccount: this.mint,
+                rent: web3_js_1.SYSVAR_RENT_PUBKEY,
+                systemProgram: anchor.web3.SystemProgram.programId,
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+        const tx = new web3_js_1.Transaction().add(ix);
+        const txSig = await this.context.sendTransaction(tx);
+        return txSig;
+    }
+    async fetchState() {
+        return await this.program.account.faucetConfig.fetch(await this.getFaucetConfigPublicKey());
+    }
+    async mintToUserIx(userTokenAccount, amount) {
+        return this.program.instruction.mintToUser(amount, {
+            accounts: {
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
+                userTokenAccount,
+                mintAuthority: await this.getMintAuthority(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+            },
+        });
+    }
+    async mintToUser(userTokenAccount, amount) {
+        const mintIx = await this.mintToUserIx(userTokenAccount, amount);
+        const tx = new web3_js_1.Transaction().add(mintIx);
+        if (this.context) {
+            return await this.context.sendTransaction(tx);
+        }
+        else {
+            return await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        }
+    }
+    async transferMintAuthority() {
+        if (this.context) {
+            const ix = this.program.instruction.transferMintAuthority({
+                accounts: {
+                    faucetConfig: await this.getFaucetConfigPublicKey(),
+                    mintAccount: this.mint,
+                    mintAuthority: await this.getMintAuthority(),
+                    tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                    admin: this.wallet.publicKey,
+                },
+            });
+            const tx = new web3_js_1.Transaction().add(ix);
+            const txSig = await this.context.sendTransaction(tx);
+            return txSig;
+        }
+        return await this.program.rpc.transferMintAuthority({
+            accounts: {
+                faucetConfig: await this.getFaucetConfigPublicKey(),
+                mintAccount: this.mint,
+                mintAuthority: await this.getMintAuthority(),
+                tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
+                admin: this.wallet.publicKey,
+            },
+        });
+    }
+    async createAssociatedTokenAccountAndMintTo(userPublicKey, amount) {
+        const tx = new web3_js_1.Transaction();
+        const [associatedTokenPublicKey, createAssociatedAccountIx, mintToTx] = await this.createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount);
+        let associatedTokenAccountExists = false;
+        try {
+            const assosciatedTokenAccount = await this.context.connection.getAccountInfo(associatedTokenPublicKey);
+            associatedTokenAccountExists = !!assosciatedTokenAccount;
+        }
+        catch (e) {
+            // token account doesn't exist
+            associatedTokenAccountExists = false;
+        }
+        const skipAccountCreation = associatedTokenAccountExists;
+        if (!skipAccountCreation)
+            tx.add(createAssociatedAccountIx);
+        tx.add(mintToTx);
+        let txSig;
+        if (this.context) {
+            txSig = await this.context.sendTransaction(tx);
+        }
+        else {
+            txSig = await this.program.provider.sendAndConfirm(tx, [], this.opts);
+        }
+        return [associatedTokenPublicKey, txSig];
+    }
+    async createAssociatedTokenAccountAndMintToInstructions(userPublicKey, amount) {
+        const state = await this.fetchState();
+        const associateTokenPublicKey = await this.getAssosciatedMockUSDMintAddress({ userPubKey: userPublicKey });
+        const createAssociatedAccountIx = (0, spl_token_1.createAssociatedTokenAccountInstruction)(this.wallet.publicKey, associateTokenPublicKey, userPublicKey, state.mint);
+        const mintToIx = await this.mintToUserIx(associateTokenPublicKey, amount);
+        return [associateTokenPublicKey, createAssociatedAccountIx, mintToIx];
+    }
+    async getAssosciatedMockUSDMintAddress(props) {
+        const state = await this.fetchState();
+        return (0, spl_token_1.getAssociatedTokenAddress)(state.mint, props.userPubKey);
+    }
+    async getTokenAccountInfo(props) {
+        const associatedKey = await this.getAssosciatedMockUSDMintAddress(props);
+        if (this.context) {
+            return await this.context.connection.getTokenAccount(associatedKey);
+        }
+        return await (0, spl_token_1.getAccount)(this.connection, associatedKey);
+    }
+    async subscribeToTokenAccount(props) {
+        try {
+            const tokenAccountKey = await this.getAssosciatedMockUSDMintAddress(props);
+            props.callback(await this.getTokenAccountInfo(props));
+            // Couldn't find a way to do it using anchor framework subscription — fall back to onAccountChange.
+            this.context.connection.onAccountChange(tokenAccountKey, async (_accountInfo /* accountInfo is a buffer which we don't know how to deserialize */) => {
+                props.callback(await this.getTokenAccountInfo(props));
+            });
+            return true;
+        }
+        catch (e) {
+            return false;
+        }
+    }
+}
+exports.TokenFaucet = TokenFaucet;

package/lib/browser/tx/baseTxSender.d.ts

@@ -0,0 +1,59 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ConfirmationStrategy, TxSender, TxSigAndSlot } from './types';
+import { Commitment, ConfirmOptions, RpcResponseAndContext, Signer, SignatureResult, Transaction, TransactionSignature, Connection, VersionedTransaction, TransactionInstruction, AddressLookupTableAccount, BlockhashWithExpiryBlockHeight } from '@solana/web3.js';
+import { TxHandler } from './txHandler';
+import { IWallet } from '../types';
+import NodeCache from 'node-cache';
+export declare abstract class BaseTxSender implements TxSender {
+    connection: Connection;
+    wallet: IWallet;
+    opts: ConfirmOptions;
+    timeout: number;
+    additionalConnections: Connection[];
+    timeoutCount: number;
+    confirmationStrategy: ConfirmationStrategy;
+    additionalTxSenderCallbacks: ((base58EncodedTx: string) => void)[];
+    txHandler: TxHandler;
+    trackTxLandRate?: boolean;
+    throwOnTimeoutError: boolean;
+    throwOnTransactionError: boolean;
+    lookbackWindowMinutes: number;
+    txSigCache?: NodeCache;
+    txLandRate: number;
+    lastPriorityFeeSuggestion: number;
+    landRateToFeeFunc: (landRate: number) => number;
+    constructor({ connection, wallet, opts, timeout, additionalConnections, confirmationStrategy, additionalTxSenderCallbacks, trackTxLandRate, txHandler, txLandRateLookbackWindowMinutes, landRateToFeeFunc, throwOnTimeoutError, throwOnTransactionError, }: {
+        connection: Connection;
+        wallet: IWallet;
+        opts?: ConfirmOptions;
+        timeout?: number;
+        additionalConnections?: any;
+        confirmationStrategy?: ConfirmationStrategy;
+        additionalTxSenderCallbacks?: ((base58EncodedTx: string) => void)[];
+        txHandler?: TxHandler;
+        trackTxLandRate?: boolean;
+        txLandRateLookbackWindowMinutes?: number;
+        landRateToFeeFunc?: (landRate: number) => number;
+        throwOnTimeoutError?: boolean;
+        throwOnTransactionError?: boolean;
+    });
+    send(tx: Transaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    prepareTx(tx: Transaction, additionalSigners: Array<Signer>, opts: ConfirmOptions, preSigned?: boolean): Promise<Transaction>;
+    getVersionedTransaction(ixs: TransactionInstruction[], lookupTableAccounts: AddressLookupTableAccount[], _additionalSigners?: Array<Signer>, opts?: ConfirmOptions, blockhash?: BlockhashWithExpiryBlockHeight): Promise<VersionedTransaction>;
+    sendVersionedTransaction(tx: VersionedTransaction, additionalSigners?: Array<Signer>, opts?: ConfirmOptions, preSigned?: boolean): Promise<TxSigAndSlot>;
+    sendRawTransaction(rawTransaction: Buffer | Uint8Array, opts: ConfirmOptions): Promise<TxSigAndSlot>;
+    simulateTransaction(tx: VersionedTransaction): Promise<boolean>;
+    confirmTransactionWebSocket(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    confirmTransactionPolling(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult> | undefined>;
+    confirmTransaction(signature: TransactionSignature, commitment?: Commitment): Promise<RpcResponseAndContext<SignatureResult>>;
+    getTimestamp(): number;
+    promiseTimeout<T>(promises: Promise<T>[], timeoutMs: number): Promise<T | null>;
+    sendToAdditionalConnections(rawTx: Buffer | Uint8Array, opts: ConfirmOptions): void;
+    addAdditionalConnection(newConnection: Connection): void;
+    getTimeoutCount(): number;
+    checkConfirmationResultForError(txSig: string, result: SignatureResult): Promise<void>;
+    getTxLandRate(): number;
+    private defaultLandRateToFeeFunc;
+    getSuggestedPriorityFeeMultiplier(): number;
+}