wasabi-solana-ts 1.2.2 → 1.2.4

package/dist/instructions/swapJupiter.d.ts

@@ -1,90 +0,0 @@
-import { TransactionInstruction, PublicKey } from '@solana/web3.js';
-import { SwapMode } from './swap';
-type MarketInfo = {
-    id: string;
-    label: string;
-    inputMint: string;
-    outputMint: string;
-    notEnoughLiquidity: boolean;
-    inAmount: string;
-    outAmount: string;
-    lpFee: {
-        amount: string;
-        mint: string;
-        pct: number;
-    };
-    platformFee: {
-        amount: string;
-        mint: string;
-        pct: number;
-    };
-    priceImpactPc: number;
-};
-type Route = {
-    inAmount: string;
-    outAmount: string;
-    priceImpactPc: number;
-    marketInfos: MarketInfo[];
-    amount: string;
-    slippageBps: number;
-    otherAmountThreshold: string;
-    swapMode: SwapMode;
-    fees: {
-        signatureFee: number;
-        openOrdersDeposits: number[];
-        ataDeposits: number[];
-        totalFeeAndDeposits: number;
-        minimumSOLForTransaction: number;
-    };
-    accountMetas: {
-        pubkey: string;
-        isSigner: boolean;
-        isWritable: boolean;
-    }[];
-};
-type TokenInfo = {
-    address: string;
-    chainId: number;
-    decimals: number;
-    name: string;
-    symbol: string;
-    logoURI?: string;
-    tags?: string[];
-};
-type QuoteResponse = {
-    inputMint: string;
-    outputMint: string;
-    amount: string;
-    swapMode: SwapMode;
-    slippageBps: number;
-    otherAmountThreshold: string;
-    routes: Route[];
-    contextSlot: number;
-    timeTaken: number;
-    priceImpactPct: number;
-    inputTokenInfo: TokenInfo;
-    outputTokenInfo: TokenInfo;
-};
-type JupiterInstructionResponse = {
-    tokenLedgerInstruction?: TransactionInstruction;
-    computeBudgetInstructions?: TransactionInstruction[];
-    setupInstructions?: TransactionInstruction[];
-    swapInstruction: TransactionInstruction;
-    cleanupInstruction?: TransactionInstruction;
-    addressLookupTableAddresses?: string[];
-};
-type CreateSwapInstructionArgs = {
-    quoteResponse: QuoteResponse;
-    ownerPubkey: PublicKey;
-    authorityPubkey?: PublicKey;
-    wrapUnwrapSOL?: boolean;
-    computeUnitPriceMicroLamports?: number;
-    computeUnitsLimit?: number;
-};
-export declare function getJupiterQuote(inputMint: PublicKey, outputMint: PublicKey, amount: number, slippageBps: number, swapMode: SwapMode, options?: {
-    onlyDirectRoutes?: boolean;
-    asLegacyTransaction?: boolean;
-    maxAccounts?: number;
-}): Promise<QuoteResponse>;
-export declare function createJupiterSwapInstructions({ quoteResponse, ownerPubkey, authorityPubkey, wrapUnwrapSOL, computeUnitPriceMicroLamports, computeUnitsLimit }: CreateSwapInstructionArgs): Promise<JupiterInstructionResponse>;
-export {};

package/dist/instructions/swapJupiter.js

@@ -1,61 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getJupiterQuote = getJupiterQuote;
-exports.createJupiterSwapInstructions = createJupiterSwapInstructions;
-const cross_fetch_1 = __importDefault(require("cross-fetch"));
-async function getJupiterQuote(inputMint, outputMint, amount, slippageBps, swapMode, options) {
-    const url = new URL('https://quote-api.jup.ag/v6/quote');
-    const args = {
-        inputMint: inputMint.toString(),
-        outputMint: outputMint.toString(),
-        amount: amount.toString(),
-        slippageBps: slippageBps.toString()
-    };
-    if (swapMode === 'EXACT_OUT') {
-        args.swapMode = 'ExactOut';
-    }
-    if (options) {
-        if (options.onlyDirectRoutes) {
-            args.onlyDirectRoutes = 'true';
-        }
-        if (options.asLegacyTransaction) {
-            args.asLegacyTransaction = 'true';
-        }
-        if (options.maxAccounts) {
-            args.maxAccounts = options.maxAccounts.toString();
-        }
-    }
-    url.search = new URLSearchParams(args).toString();
-    const response = await (0, cross_fetch_1.default)(url.toString());
-    if (!response.ok) {
-        throw new Error(`Jupiter API error: ${response.status} - ${response.statusText}`);
-    }
-    return response.json();
-}
-async function createJupiterSwapInstructions({ quoteResponse, ownerPubkey, authorityPubkey, wrapUnwrapSOL = true, computeUnitPriceMicroLamports, computeUnitsLimit }) {
-    const body = {
-        quoteResponse,
-        userPubkey: ownerPubkey.toString(),
-        wrapUnwrapSOL,
-        computeUnitPriceMicroLamports,
-        computeUnitsLimit
-    };
-    if (authorityPubkey) {
-        body.delegateWallet = authorityPubkey.toString();
-        body.useDelegate = true;
-    }
-    const response = await (0, cross_fetch_1.default)('https://quote-api.jup.ag/v6/swap-instructions', {
-        method: 'POST',
-        headers: {
-            'Content-Type': 'application/json'
-        },
-        body: JSON.stringify(body)
-    });
-    if (!response.ok) {
-        throw new Error(`Swap instruction API error: ${response.status} - ${response.statusText}`);
-    }
-    return response.json();
-}

package/dist/instructions/swapRaydium.d.ts

@@ -1,38 +0,0 @@
-import { AmmRpcData, AmmV4Keys } from '@raydium-io/raydium-sdk-v2';
-import { Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
-import { SwapMode } from './swap';
-type RouteHop = {
-    poolId: string;
-    inputMint: string;
-    outputMint: string;
-    quotedInAmount: string;
-    quotedOutAmount: string;
-    priceImpactPct: number;
-    poolKeys?: AmmV4Keys;
-    poolRpcData?: AmmRpcData;
-};
-export type RouteQuoteResponse = {
-    inputMint: string;
-    outputMint: string;
-    inAmount: string;
-    outAmount: string;
-    priceImpactPct: number;
-    route: RouteHop[];
-    swapMode: SwapMode;
-    slippageBps: number;
-};
-export type RaydiumInstructionResponse = {
-    computeBudgetInstructions?: TransactionInstruction[];
-    setupInstructions: TransactionInstruction[];
-    swapInstructions: TransactionInstruction[];
-    cleanupInstructions: TransactionInstruction[];
-    addressLookupTableAddresses?: string[];
-};
-export declare function getRaydiumRouteQuote(inputMint: PublicKey, outputMint: PublicKey, amount: number, slippageBps: number, poolIds: string[], swapMode: SwapMode, connection: Connection): Promise<RouteQuoteResponse>;
-export declare function createRaydiumRouteSwapInstructions({ quoteResponse, ownerPubkey, authorityPubkey, }: {
-    quoteResponse: RouteQuoteResponse;
-    ownerPubkey: PublicKey;
-    authorityPubkey?: PublicKey;
-}): Promise<RaydiumInstructionResponse>;
-export declare function calculatePriceImpact(amountIn: string | number, amountOut: string | number, reserveIn: string | number, reserveOut: string | number): number;
-export {};

package/dist/instructions/swapRaydium.js

@@ -1,170 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRaydiumRouteQuote = getRaydiumRouteQuote;
-exports.createRaydiumRouteSwapInstructions = createRaydiumRouteSwapInstructions;
-exports.calculatePriceImpact = calculatePriceImpact;
-const raydium_sdk_v2_1 = require("@raydium-io/raydium-sdk-v2");
-const anchor_1 = require("@coral-xyz/anchor");
-const web3_js_1 = require("@solana/web3.js");
-const spl_token_1 = require("@solana/spl-token");
-async function getRaydiumRouteQuote(inputMint, outputMint, amount, slippageBps, poolIds, swapMode = 'EXACT_IN', connection) {
-    const raydium = await raydium_sdk_v2_1.Raydium.load({
-        owner: inputMint,
-        connection,
-        disableFeatureCheck: true,
-        disableLoadToken: true, // TODO: investigate if we need
-        blockhashCommitment: 'confirmed'
-    });
-    const poolDataPromises = poolIds.map(poolId => raydium.liquidity.getPoolInfoFromRpc({ poolId }));
-    const poolsData = await Promise.all(poolDataPromises);
-    const poolDataMap = new Map();
-    poolIds.forEach((poolId, index) => {
-        poolDataMap.set(poolId, poolsData[index]);
-    });
-    let currentAmount = new anchor_1.BN(amount);
-    const route = [];
-    let totalPriceImpact = 0;
-    if (swapMode === 'EXACT_OUT') {
-        let currentOutputMint = outputMint;
-        for (let i = poolIds.length - 1; i >= 0; i--) {
-            const poolId = poolIds[i];
-            const poolData = poolDataMap.get(poolId);
-            const { poolInfo, poolKeys, poolRpcData } = poolData;
-            const currentInputMint = i === 0
-                ? inputMint
-                : determineOutputMint(new web3_js_1.PublicKey(poolDataMap.get(poolIds[i - 1]).poolKeys.mintA.address), poolKeys);
-            const computeResult = raydium.liquidity.computeAmountIn({
-                poolInfo: {
-                    ...poolInfo,
-                    baseReserve: poolRpcData.baseReserve,
-                    quoteReserve: poolRpcData.quoteReserve,
-                    status: poolRpcData.status.toNumber(),
-                    version: 4
-                },
-                amountOut: currentAmount,
-                mintIn: currentInputMint,
-                mintOut: currentOutputMint,
-                slippage: slippageBps / 10000
-            });
-            const priceImpact = calculatePriceImpact(computeResult.amountIn.toString(), currentAmount.toString(), poolRpcData.baseReserve.toString(), poolRpcData.quoteReserve.toString());
-            route.unshift({
-                poolId,
-                inputMint: currentInputMint.toString(),
-                outputMint: currentOutputMint.toString(),
-                quotedInAmount: computeResult.maxAmountIn.toString(),
-                quotedOutAmount: currentAmount.toString(),
-                priceImpactPct: priceImpact,
-                poolKeys,
-                poolRpcData
-            });
-            currentAmount = computeResult.maxAmountIn;
-            currentOutputMint = currentInputMint;
-            totalPriceImpact += priceImpact;
-        }
-        return {
-            inputMint: inputMint.toString(),
-            outputMint: outputMint.toString(),
-            inAmount: route[0].quotedInAmount,
-            outAmount: amount.toString(),
-            priceImpactPct: totalPriceImpact,
-            route,
-            swapMode,
-            slippageBps
-        };
-    }
-    else {
-        let currentInputMint = inputMint;
-        for (let i = 0; i < poolIds.length; i++) {
-            const poolId = poolIds[i];
-            const poolData = poolDataMap.get(poolId);
-            const { poolInfo, poolKeys, poolRpcData } = poolData;
-            const currentOutputMint = i === poolIds.length - 1
-                ? outputMint
-                : determineOutputMint(currentInputMint, poolDataMap.get(poolIds[i + 1]).poolKeys);
-            const computeResult = raydium.liquidity.computeAmountOut({
-                poolInfo: {
-                    ...poolInfo,
-                    baseReserve: poolRpcData.baseReserve,
-                    quoteReserve: poolRpcData.quoteReserve,
-                    status: poolRpcData.status.toNumber(),
-                    version: 4
-                },
-                amountIn: currentAmount,
-                mintIn: currentInputMint,
-                mintOut: currentOutputMint,
-                slippage: slippageBps / 10000
-            });
-            const priceImpact = calculatePriceImpact(currentAmount.toString(), computeResult.amountOut.toString(), poolRpcData.baseReserve.toString(), poolRpcData.quoteReserve.toString());
-            route.push({
-                poolId,
-                inputMint: currentInputMint.toString(),
-                outputMint: currentOutputMint.toString(),
-                quotedInAmount: currentAmount.toString(),
-                quotedOutAmount: computeResult.amountOut.toString(),
-                priceImpactPct: priceImpact,
-                poolKeys,
-                poolRpcData
-            });
-            currentAmount = computeResult.amountOut;
-            currentInputMint = currentOutputMint;
-            totalPriceImpact += priceImpact;
-        }
-        return {
-            inputMint: inputMint.toString(),
-            outputMint: outputMint.toString(),
-            inAmount: amount.toString(),
-            outAmount: route[route.length - 1].quotedOutAmount,
-            priceImpactPct: totalPriceImpact,
-            route,
-            swapMode,
-            slippageBps
-        };
-    }
-}
-function determineOutputMint(currentInputMint, nextPoolKeys) {
-    const mintA = new web3_js_1.PublicKey(nextPoolKeys.mintA.address);
-    return currentInputMint.equals(mintA)
-        ? new web3_js_1.PublicKey(nextPoolKeys.mintB.address)
-        : mintA;
-}
-async function createRaydiumRouteSwapInstructions({ quoteResponse, ownerPubkey, authorityPubkey, }) {
-    const swapInstructions = [];
-    for (let i = 0; i < quoteResponse.route.length; i++) {
-        const hop = quoteResponse.route[i];
-        if (!hop.poolKeys || !hop.poolRpcData) {
-            throw new Error(`Hop ${i} missing required pool information`);
-        }
-        const inputMint = new web3_js_1.PublicKey(hop.inputMint);
-        const outputMint = new web3_js_1.PublicKey(hop.outputMint);
-        const tokenAccountIn = (0, spl_token_1.getAssociatedTokenAddressSync)(inputMint, ownerPubkey, true);
-        const tokenAccountOut = (0, spl_token_1.getAssociatedTokenAddressSync)(outputMint, ownerPubkey, true);
-        const instructionParams = {
-            version: 4,
-            poolKeys: hop.poolKeys,
-            userKeys: {
-                tokenAccountIn,
-                tokenAccountOut,
-                owner: authorityPubkey ? authorityPubkey : ownerPubkey
-            },
-            amountIn: new anchor_1.BN(hop.quotedInAmount),
-            amountOut: new anchor_1.BN(hop.quotedOutAmount),
-            fixedSide: quoteResponse.swapMode === 'EXACT_IN' ? 'in' : 'out'
-        };
-        const swapInstruction = (0, raydium_sdk_v2_1.makeAMMSwapInstruction)(instructionParams);
-        swapInstructions.push(swapInstruction);
-    }
-    return {
-        setupInstructions: [],
-        swapInstructions,
-        cleanupInstructions: []
-    };
-}
-function calculatePriceImpact(amountIn, amountOut, reserveIn, reserveOut) {
-    const in_bn = new anchor_1.BN(amountIn.toString()).toNumber() / 10 ** 6;
-    const out_bn = new anchor_1.BN(amountOut.toString()).toNumber() / 10 ** 6;
-    const reserveIn_bn = new anchor_1.BN(reserveIn.toString()).toNumber() / 10 ** 6;
-    const reserveOut_bn = new anchor_1.BN(reserveOut.toString()).toNumber() / 10 ** 6;
-    const priceBefore = reserveOut_bn / reserveIn_bn;
-    const priceAfter = (reserveOut_bn - out_bn) / (reserveIn_bn + in_bn);
-    return (priceBefore - priceAfter) * 100 / priceBefore;
-}

package/dist/instructions/updateLongPosition.d.ts

@@ -1,6 +0,0 @@
-import { TransactionInstruction } from '@solana/web3.js';
-import { OpenPositionAccounts, OpenPositionArgs } from './openPosition';
-import { MintCache } from '../utils';
-import { Program } from '@coral-xyz/anchor';
-import { WasabiSolana } from '../idl';
-export declare function createUpdateLongPositionInstruction(program: Program<WasabiSolana>, args: OpenPositionArgs, accounts: OpenPositionAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/updateLongPosition.js

@@ -1,69 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUpdateLongPositionInstruction = createUpdateLongPositionInstruction;
-const web3_js_1 = require("@solana/web3.js");
-const base_1 = require("../base");
-const shared_1 = require("./shared");
-const utils_1 = require("../utils");
-const spl_token_1 = require("@solana/spl-token");
-const anchor_1 = require("@coral-xyz/anchor");
-const updateLongPositionConfig = {
-    process: async (config) => {
-        const { hops, data, remainingAccounts } = (0, shared_1.extractInstructionData)(config.args.instructions);
-        const lpVault = utils_1.PDA.getLpVault(config.accounts.currency);
-        const pool = utils_1.PDA.getLongPool(config.accounts.collateral, config.accounts.currency);
-        if (!config.args.positionId) {
-            throw new Error('positionId is required for `UpdateLongPosition`');
-        }
-        const position = new web3_js_1.PublicKey(config.args.positionId);
-        const { ownerPaymentAta, currencyTokenProgram, collateralTokenProgram, setupIx, cleanupIx } = await (0, utils_1.handleOpenTokenAccounts)({
-            program: config.program,
-            owner: config.accounts.owner,
-            downPayment: config.args.downPayment,
-            fee: config.args.fee,
-            mintCache: config.mintCache,
-            isLongPool: true,
-            currency: config.accounts.currency,
-            collateral: config.accounts.collateral
-        });
-        return {
-            accounts: {
-                owner: config.accounts.owner,
-                ownerCurrencyAccount: ownerPaymentAta,
-                lpVault,
-                vault: (0, spl_token_1.getAssociatedTokenAddressSync)(config.accounts.currency, lpVault, true, currencyTokenProgram),
-                pool,
-                currencyVault: (0, spl_token_1.getAssociatedTokenAddressSync)(config.accounts.currency, pool, true, currencyTokenProgram),
-                collateralVault: (0, spl_token_1.getAssociatedTokenAddressSync)(config.accounts.collateral, pool, true, collateralTokenProgram),
-                currency: config.accounts.currency,
-                collateral: config.accounts.collateral,
-                position,
-                authority: config.accounts.authority,
-                permission: utils_1.PDA.getAdmin(config.accounts.authority),
-                feeWallet: config.accounts.feeWallet,
-                tokenProgram: currencyTokenProgram,
-                debtController: utils_1.PDA.getDebtController(),
-                globalSettings: utils_1.PDA.getGlobalSettings(),
-                systemProgram: web3_js_1.SystemProgram.programId
-            },
-            args: {
-                ...config.args,
-                hops,
-                data
-            },
-            setup: setupIx,
-            cleanup: cleanupIx,
-            remainingAccounts
-        };
-    },
-    getMethod: (program) => (args) => program.methods.updateLongPosition(new anchor_1.BN(args.minTargetAmount), new anchor_1.BN(args.downPayment), new anchor_1.BN(args.principal), new anchor_1.BN(args.fee), new anchor_1.BN(args.expiration), { hops: args.hops }, args.data)
-};
-async function createUpdateLongPositionInstruction(program, args, accounts, mintCache) {
-    return (0, base_1.handleMethodCall)({
-        program,
-        accounts,
-        config: updateLongPositionConfig,
-        args,
-        mintCache
-    });
-}

package/dist/instructions/updateLpVaultMaxBorrow.d.ts

@@ -1,12 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionInstruction, TransactionSignature, PublicKey } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type UpdateVaultMaxBorrowArgs = {
-    maxBorrow: number;
-};
-export type UpdateVaultMaxBorrowAccounts = {
-    authority: PublicKey;
-    assetMint: PublicKey;
-};
-export declare function createUpdateVaultMaxBorrowInstruction(program: Program<WasabiSolana>, args: UpdateVaultMaxBorrowArgs, accounts: UpdateVaultMaxBorrowAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function updateVaultMaxBorrow(program: Program<WasabiSolana>, args: UpdateVaultMaxBorrowArgs, accounts: UpdateVaultMaxBorrowAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/updateLpVaultMaxBorrow.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createUpdateVaultMaxBorrowInstruction = createUpdateVaultMaxBorrowInstruction;
-exports.updateVaultMaxBorrow = updateVaultMaxBorrow;
-const anchor_1 = require("@coral-xyz/anchor");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const updateVaultMaxBorrowConfig = {
-    process: async (config) => {
-        const admin = utils_1.PDA.getAdmin(config.accounts.authority);
-        const allAccounts = {
-            payer: config.program.provider.publicKey,
-            authority: config.accounts.authority,
-            permission: await (0, utils_1.getPermission)(config.program, admin),
-            lpVault: utils_1.PDA.getLpVault(config.accounts.assetMint)
-        };
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    payer: allAccounts.payer,
-                    permission: allAccounts.permission,
-                    lpVault: allAccounts.lpVault
-                },
-            args: config.args ? new anchor_1.BN(config.args.maxBorrow) : undefined
-        };
-    },
-    getMethod: (program) => (args) => program.methods.updateLpVaultMaxBorrow(args)
-};
-async function createUpdateVaultMaxBorrowInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, updateVaultMaxBorrowConfig, 'INSTRUCTION', strict, increaseCompute, args));
-}
-async function updateVaultMaxBorrow(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, updateVaultMaxBorrowConfig, 'TRANSACTION', strict, increaseCompute, args));
-}

package/dist/sender-provider/baseSenderProvider.d.ts

@@ -1,42 +0,0 @@
-import { Connection, VersionedTransaction, Keypair, PublicKey, Transaction, Signer } from '@solana/web3.js';
-import { JitoClient } from './jitoTypes';
-export interface Sender {
-    transactions: VersionedTransaction[];
-    send: () => Promise<string>;
-}
-export interface ProviderOptions {
-    tipAmount?: number;
-    transactionLimit?: number;
-}
-export type TransactionSigner = {
-    signTransaction?: ((transaction: VersionedTransaction) => Promise<VersionedTransaction>) | (<T extends Transaction | VersionedTransaction>(transaction: T) => Promise<T>);
-    signAllTransactions?: ((transactions: VersionedTransaction[]) => Promise<VersionedTransaction[]>) | (<T extends Transaction | VersionedTransaction>(transactions: T[]) => Promise<T>);
-} | Keypair | Signer;
-export declare const baseSender: (connection: Connection, confirm?: boolean) => (transactions: VersionedTransaction[]) => Promise<Sender>;
-export declare class ProviderBuilder {
-    private connection;
-    private payer;
-    private simulateTransaction;
-    private confirmTransaction;
-    private providerClient?;
-    private options;
-    private transactions;
-    setConnection(connection: Connection): this;
-    setPayer(payer: PublicKey): this;
-    setSimulateTransaction(simulateTransaction: boolean): this;
-    setConfirmTransaction(confirmTransaction: boolean): this;
-    setProviderClient(providerClient: JitoClient): this;
-    setOptions(options: ProviderOptions): this;
-    addTransactions(...transactions: VersionedTransaction[]): this;
-    setTransactions(transactions: VersionedTransaction[]): this;
-    addSerializedTransactions(...transaction: string[]): this;
-    setSerializedTransactions(transactions: string[]): this;
-    setProviderOptions(options: ProviderOptions): this;
-    getTransactions(): VersionedTransaction[];
-    private getSender;
-    sign(transactions: VersionedTransaction[], signer: TransactionSigner): Promise<this>;
-    private simulate;
-    private validateSignatures;
-    private validateSignedTransactions;
-    build(signer: TransactionSigner): Promise<Sender>;
-}