wasabi-solana-ts 1.2.3 → 1.2.4

package/dist/base/base.d.ts

@@ -1,7 +1,7 @@
 import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction, TransactionSignature, PublicKey, AccountMeta } from '@solana/web3.js';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils/mintCache';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type ProcessResult<T> = {
     accounts: T;
     args?: any;
@@ -13,7 +13,7 @@ export type ConfigArgs<TArgs, TAccounts> = {
     program: Program<WasabiSolana>;
     accounts: TAccounts;
     args?: TArgs;
-    mintCache?: MintCache;
+    mintCache?: TokenMintCache;
 };
 export type MethodCallArgs<TArgs, TAccounts, TProgramAccounts> = {
     config: BaseMethodConfig<TArgs, TAccounts, TProgramAccounts>;

package/dist/cache/BaseAccountCache.d.ts

@@ -0,0 +1,44 @@
+import { AccountInfo, Connection, PublicKey } from '@solana/web3.js';
+import NodeCache from 'node-cache';
+/**
+ * Base class for account caches
+ *
+ * @template T - The type of the parsed accounts
+ */
+export declare abstract class BaseAccountCache<T> {
+    protected readonly connection: Connection;
+    protected readonly cache: NodeCache;
+    /**
+     * Create a new account cache
+     *
+     * @param connection - The connection to use
+     * @param options - The options for the cache
+     */
+    constructor(connection: Connection, options?: NodeCache.Options);
+    /**
+     * Get multiple accounts from the cache or the connection and parse them
+     *
+     * @param addresses - The addresses of the accounts to get
+     * @returns A map of the addresses to the parsed accounts
+     */
+    getAccountsStr(addresses: string[]): Promise<Map<string, T>>;
+    /**
+     * Get multiple accounts from the cache or the connection and parse them
+     *
+     * @param addresses - The addresses of the accounts to get
+     * @returns A map of the addresses to the parsed accounts
+     */
+    getAccounts(addresses: PublicKey[]): Promise<Map<string, T>>;
+    /**
+     * Get a single account from the cache or the connection and parse it
+     *
+     * @param address - The address of the account to get
+     * @returns The parsed account
+     */
+    getAccount(address: PublicKey): Promise<T>;
+    /**
+     * Parse an account from its raw data
+     * @param account - The raw account data
+     */
+    protected abstract parseAccount(account: AccountInfo<Buffer>): T;
+}

package/dist/cache/BaseAccountCache.js

@@ -0,0 +1,80 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseAccountCache = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const node_cache_1 = __importDefault(require("node-cache"));
+/**
+ * Base class for account caches
+ *
+ * @template T - The type of the parsed accounts
+ */
+class BaseAccountCache {
+    connection;
+    cache;
+    /**
+     * Create a new account cache
+     *
+     * @param connection - The connection to use
+     * @param options - The options for the cache
+     */
+    constructor(connection, options) {
+        this.connection = connection;
+        this.cache = new node_cache_1.default(options);
+    }
+    /**
+     * Get multiple accounts from the cache or the connection and parse them
+     *
+     * @param addresses - The addresses of the accounts to get
+     * @returns A map of the addresses to the parsed accounts
+     */
+    async getAccountsStr(addresses) {
+        return this.getAccounts(addresses.map(addr => new web3_js_1.PublicKey(addr)));
+    }
+    /**
+     * Get multiple accounts from the cache or the connection and parse them
+     *
+     * @param addresses - The addresses of the accounts to get
+     * @returns A map of the addresses to the parsed accounts
+     */
+    async getAccounts(addresses) {
+        const result = new Map();
+        const missingAddresses = new Set();
+        for (const address of addresses) {
+            const cachedAccount = this.cache.get(address.toString());
+            if (cachedAccount) {
+                result.set(address.toString(), cachedAccount);
+            }
+            else {
+                missingAddresses.add(address);
+            }
+        }
+        if (missingAddresses.size > 0) {
+            const missingAddressesArray = Array.from(missingAddresses);
+            const accounts = await this.connection.getMultipleAccountsInfo(missingAddressesArray);
+            for (let i = 0; i < accounts.length; i++) {
+                const account = accounts[i];
+                const address = missingAddressesArray[i];
+                if (account) {
+                    const parsedAccount = this.parseAccount(account);
+                    result.set(address.toString(), parsedAccount);
+                    this.cache.set(address.toString(), parsedAccount);
+                }
+            }
+        }
+        return result;
+    }
+    /**
+     * Get a single account from the cache or the connection and parse it
+     *
+     * @param address - The address of the account to get
+     * @returns The parsed account
+     */
+    async getAccount(address) {
+        const result = await this.getAccounts([address]);
+        return result.get(address.toString());
+    }
+}
+exports.BaseAccountCache = BaseAccountCache;

package/dist/cache/TokenMintCache.d.ts

@@ -0,0 +1,14 @@
+import { AccountInfo, PublicKey } from '@solana/web3.js';
+import { BaseAccountCache } from './BaseAccountCache';
+import { RawMint } from '@solana/spl-token';
+export type TokenMintData = {
+    program: PublicKey;
+    mintData: RawMint;
+};
+/**
+ * A class that caches token mint account data
+ */
+export declare class TokenMintCache extends BaseAccountCache<TokenMintData> {
+    protected parseAccount(account: AccountInfo<Buffer>): TokenMintData;
+    getMintToDecimals(mints: PublicKey[]): Promise<Map<string, number>>;
+}

package/dist/cache/TokenMintCache.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TokenMintCache = void 0;
+const BaseAccountCache_1 = require("./BaseAccountCache");
+const spl_token_1 = require("@solana/spl-token");
+/**
+ * A class that caches token mint account data
+ */
+class TokenMintCache extends BaseAccountCache_1.BaseAccountCache {
+    parseAccount(account) {
+        return {
+            program: account.owner,
+            mintData: spl_token_1.MintLayout.decode(account.data),
+        };
+    }
+    async getMintToDecimals(mints) {
+        const m = await this.getAccounts(mints);
+        const mintMap = new Map();
+        m.forEach((value, key) => {
+            mintMap.set(key, value.mintData.decimals);
+        });
+        return mintMap;
+    }
+}
+exports.TokenMintCache = TokenMintCache;

package/dist/index.d.ts

@@ -13,15 +13,15 @@ import { WasabiSolana } from './idl/wasabi_solana.js';
 import * as idl from './idl/wasabi_solana.json';
 export { idl };
 import { Program } from '@coral-xyz/anchor';
-import { MintCache } from './utils/mintCache.js';
 import { OpenPositionCleanupAccounts, OpenPositionSetupAccounts, OpenPositionSetupArgs } from './instructions/openPosition.js';
 import { TransactionInstruction } from '@solana/web3.js';
 import { ClosePositionCleanupAccounts, ClosePositionSetupAccounts, ClosePositionSetupArgs } from './instructions/closePosition.js';
 import { OpenPositionArgs, OpenPositionAccounts } from './instructions';
+import { TokenMintCache } from "./cache/TokenMintCache";
 export declare class Wasabi {
     program: Program<WasabiSolana>;
-    mintCache: MintCache;
-    constructor(program: Program<WasabiSolana>, mintCache: MintCache);
+    mintCache: TokenMintCache;
+    constructor(program: Program<WasabiSolana>, mintCache: TokenMintCache);
     createOpenLongPositionInstruction(args: OpenPositionArgs, accounts: OpenPositionAccounts): Promise<TransactionInstruction[]>;
     createOpenLongWithSharesInstruction(args: OpenPositionArgs, accounts: OpenPositionAccounts): Promise<TransactionInstruction[]>;
     createOpenShortPositionInstruction(args: OpenPositionArgs, accounts: OpenPositionAccounts): Promise<TransactionInstruction[]>;

package/dist/instructions/closeLongPosition.d.ts

@@ -2,6 +2,6 @@ import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction } from '@solana/web3.js';
 import { ClosePositionSetupArgs, ClosePositionSetupAccounts, ClosePositionCleanupAccounts } from './closePosition';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils';
-export declare function createCloseLongPositionSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createCloseLongPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createCloseLongPositionSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createCloseLongPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/closePosition.d.ts

@@ -1,7 +1,7 @@
 import { Program, BN } from '@coral-xyz/anchor';
 import { PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils/mintCache';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type CloseType = 'MARKET' | 'LIQUIDATION' | 'TAKE_PROFIT' | 'STOP_LOSS';
 export type ExitOrderSetupInstructionAccounts = {
     closePositionSetup: ClosePositionSetupInstructionAccounts;
@@ -99,7 +99,7 @@ export declare function transformArgs(args: ClosePositionSetupArgs): {
     executionFee: BN;
     expiration: BN;
 };
-export declare function getClosePositionSetupInstructionAccounts(program: Program<WasabiSolana>, accounts: ClosePositionSetupAccounts, closeType?: CloseType, mintCache?: MintCache, amount?: number): Promise<CpsuAndIx>;
+export declare function getClosePositionSetupInstructionAccounts(program: Program<WasabiSolana>, accounts: ClosePositionSetupAccounts, closeType?: CloseType, mintCache?: TokenMintCache, amount?: number): Promise<CpsuAndIx>;
 export declare function handleOrdersCheck(program: Program<WasabiSolana>, positionAddress: PublicKey, closeType?: CloseType, amount?: number): Promise<TransactionInstruction[]>;
 export declare function getClosePositionCleanupInstructionAccounts(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, isTriggeredByAuthority?: boolean): Promise<CpcuAndIx>;
 export {};

package/dist/instructions/closePositionV2.d.ts

@@ -1,7 +1,7 @@
 import { PublicKey, TransactionInstruction } from '@solana/web3.js';
 import { WasabiSolana } from '../idl';
 import { Program } from '@coral-xyz/anchor';
-import { MintCache } from '../utils';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type ClosePositionArgs = {
     amount: number | bigint;
     minTargetAmount: number | bigint;
@@ -43,4 +43,4 @@ export type ClosePositionInternalInstructionAccounts = {
     collateralTokenProgram: PublicKey;
     systemProgram: PublicKey;
 };
-export declare function createClosePositionInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+export declare function createClosePositionInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/closeShortPosition.d.ts

@@ -2,6 +2,6 @@ import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction } from '@solana/web3.js';
 import { ClosePositionSetupArgs, ClosePositionSetupAccounts, ClosePositionCleanupAccounts } from './closePosition';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils';
-export declare function createCloseShortPositionSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createCloseShortPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createCloseShortPositionSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createCloseShortPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/donate.d.ts

@@ -1,11 +1,11 @@
 import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction, PublicKey } from '@solana/web3.js';
-import { MintCache } from '../utils';
 import { WasabiSolana } from '../idl/wasabi_solana';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type DonateArgs = {
     amount: bigint;
 };
 export type DonateAccounts = {
     currency: PublicKey;
 };
-export declare function createDonateInstruction(program: Program<WasabiSolana>, args: DonateArgs, accounts: DonateAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+export declare function createDonateInstruction(program: Program<WasabiSolana>, args: DonateArgs, accounts: DonateAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/increaseLongPositionSetup.d.ts

@@ -1,6 +1,6 @@
 import { OpenPositionSetupAccounts, OpenPositionSetupArgs } from './openPosition';
-import { MintCache } from '../utils';
 import { TransactionInstruction } from '@solana/web3.js';
 import { Program } from '@coral-xyz/anchor';
 import { WasabiSolana } from '../idl/wasabi_solana';
-export declare function createIncreaseLongPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createIncreaseLongPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/increaseShortPositionSetup.d.ts

@@ -1,6 +1,6 @@
 import { OpenPositionSetupAccounts, OpenPositionSetupArgs } from './openPosition';
-import { MintCache } from '../utils';
 import { TransactionInstruction } from '@solana/web3.js';
 import { Program } from '@coral-xyz/anchor';
 import { WasabiSolana } from '../idl/wasabi_solana';
-export declare function createIncreaseShortPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createIncreaseShortPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/initPool.d.ts

@@ -1,7 +1,7 @@
 import { Program } from '@coral-xyz/anchor';
 import { PublicKey } from '@solana/web3.js';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils/mintCache';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type InitPoolAccounts = {
     currency: PublicKey;
     collateral: PublicKey;
@@ -21,4 +21,4 @@ export type InitPoolInstructionAccounts = {
     associatedTokenProgram: PublicKey;
     systemProgram: PublicKey;
 };
-export declare function getInitPoolInstructionAccounts(program: Program<WasabiSolana>, accounts: InitPoolAccounts, pool_type: 'long' | 'short', mintCache?: MintCache): Promise<InitPoolInstructionAccounts>;
+export declare function getInitPoolInstructionAccounts(program: Program<WasabiSolana>, accounts: InitPoolAccounts, pool_type: 'long' | 'short', mintCache?: TokenMintCache): Promise<InitPoolInstructionAccounts>;

package/dist/instructions/liquidatePosition.d.ts

@@ -2,6 +2,6 @@ import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction } from '@solana/web3.js';
 import { ClosePositionSetupArgs, ClosePositionSetupAccounts, ClosePositionCleanupAccounts } from './closePosition';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils';
-export declare function createLiquidatePositionSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createLiquidatePositionCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createLiquidatePositionSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createLiquidatePositionCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/liquidatePositionV2.d.ts

@@ -2,5 +2,5 @@ import { ClosePositionAccounts, ClosePositionArgs } from './closePositionV2';
 import { TransactionInstruction } from '@solana/web3.js';
 import { Program } from '@coral-xyz/anchor';
 import { WasabiSolana } from '../idl';
-import { MintCache } from '../utils';
-export declare function createLiquidatePositionInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createLiquidatePositionInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/openLongPosition.d.ts

@@ -2,12 +2,12 @@ import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction, PublicKey } from '@solana/web3.js';
 import { OpenPositionSetupArgs, OpenPositionSetupAccounts, OpenPositionCleanupAccounts, OpenPositionSetupInstructionBaseAccounts } from './openPosition';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils/mintCache';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type OpenLongPositionSetupInstructionAccounts = {
     ownerCollateralAccount: PublicKey;
     openPositionRequest: PublicKey;
     debtController: PublicKey;
     tokenProgram: PublicKey;
 } & OpenPositionSetupInstructionBaseAccounts;
-export declare function createOpenLongPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createOpenLongPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: OpenPositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+export declare function createOpenLongPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createOpenLongPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: OpenPositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/openLongPosition.js

@@ -59,7 +59,7 @@ const openLongPositionSetupConfig = {
 };
 const openLongPositionCleanupConfig = {
     process: async (config) => {
-        const { currencyMint, collateralMint, currencyTokenProgram, collateralTokenProgram } = await (0, utils_1.handleMintsAndTokenProgram)(config.program.provider.connection, config.accounts.currency, config.accounts.collateral, { owner: config.accounts.pool, mintCache: config.mintCache });
+        const { currencyMint, collateralMint, currencyTokenProgram, collateralTokenProgram } = await (0, utils_1.handleMintsAndTokenProgram)(config.program.provider.connection, config.accounts.currency, config.accounts.collateral, { mintCache: config.mintCache });
         return {
             accounts: {
                 owner: config.accounts.owner,

package/dist/instructions/openShortPosition.d.ts

@@ -2,7 +2,7 @@ import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction, PublicKey } from '@solana/web3.js';
 import { OpenPositionSetupArgs, OpenPositionSetupAccounts, OpenPositionCleanupAccounts } from './openPosition';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from '../utils/mintCache';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export type OpenShortPositionSetupInstructionAccounts = {
     owner: PublicKey;
     ownerCurrencyAccount: PublicKey;
@@ -40,5 +40,5 @@ export type OpenShortPositionCleanupInstructionAccounts = {
     debtController: PublicKey;
     tokenProgram: PublicKey;
 };
-export declare function createOpenShortPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createOpenShortPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: OpenPositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+export declare function createOpenShortPositionSetupInstruction(program: Program<WasabiSolana>, args: OpenPositionSetupArgs, accounts: OpenPositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createOpenShortPositionCleanupInstruction(program: Program<WasabiSolana>, accounts: OpenPositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/openShortPosition.js

@@ -58,7 +58,7 @@ const openShortPositionSetupConfig = {
 };
 const openShortPositionCleanupConfig = {
     process: async (config) => {
-        const { currencyMint, collateralMint, currencyTokenProgram, collateralTokenProgram } = await (0, utils_1.handleMintsAndTokenProgram)(config.program.provider.connection, config.accounts.currency, config.accounts.collateral, { owner: config.accounts.pool, mintCache: config.mintCache });
+        const { currencyMint, collateralMint, currencyTokenProgram, collateralTokenProgram } = await (0, utils_1.handleMintsAndTokenProgram)(config.program.provider.connection, config.accounts.currency, config.accounts.collateral, { mintCache: config.mintCache });
         const lpVault = utils_1.PDA.getLpVault(config.accounts.currency);
         return {
             accounts: {

package/dist/instructions/stopLoss.d.ts

@@ -1,7 +1,7 @@
 import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction } from '@solana/web3.js';
 import { ClosePositionSetupArgs, ClosePositionSetupAccounts, ClosePositionCleanupAccounts } from './closePosition';
-import { MintCache } from '../utils';
 import { WasabiSolana } from '../idl/wasabi_solana';
-export declare function createStopLossSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createStopLossCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createStopLossSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createStopLossCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/stopLossV2.d.ts

@@ -2,5 +2,5 @@ import { ClosePositionAccounts, ClosePositionArgs } from './closePositionV2';
 import { TransactionInstruction } from '@solana/web3.js';
 import { WasabiSolana } from '../idl';
 import { Program } from '@coral-xyz/anchor';
-import { MintCache } from '../utils';
-export declare function createStopLossInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createStopLossInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/takeProfit.d.ts

@@ -1,7 +1,7 @@
 import { Program } from '@coral-xyz/anchor';
 import { TransactionInstruction } from '@solana/web3.js';
 import { ClosePositionSetupArgs, ClosePositionSetupAccounts, ClosePositionCleanupAccounts } from './closePosition';
-import { MintCache } from '../utils';
 import { WasabiSolana } from '../idl/wasabi_solana';
-export declare function createTakeProfitSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
-export declare function createTakeProfitCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createTakeProfitSetupInstruction(program: Program<WasabiSolana>, args: ClosePositionSetupArgs, accounts: ClosePositionSetupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;
+export declare function createTakeProfitCleanupInstruction(program: Program<WasabiSolana>, accounts: ClosePositionCleanupAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/instructions/takeProfitV2.d.ts

@@ -2,5 +2,5 @@ import { ClosePositionAccounts, ClosePositionArgs } from './closePositionV2';
 import { TransactionInstruction } from '@solana/web3.js';
 import { Program } from '@coral-xyz/anchor';
 import { WasabiSolana } from '../idl';
-import { MintCache } from '../utils';
-export declare function createTakeProfitInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: MintCache): Promise<TransactionInstruction[]>;
+import { TokenMintCache } from "../cache/TokenMintCache";
+export declare function createTakeProfitInstruction(program: Program<WasabiSolana>, args: ClosePositionArgs, accounts: ClosePositionAccounts, mintCache?: TokenMintCache): Promise<TransactionInstruction[]>;

package/dist/utils/index.d.ts

@@ -1,2 +1 @@
 export * from './utils.js';
-export * from './mintCache.js';

package/dist/utils/index.js

@@ -15,4 +15,3 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./utils.js"), exports);
-__exportStar(require("./mintCache.js"), exports);

package/dist/utils/utils.d.ts

@@ -1,7 +1,7 @@
 import { PublicKey, Connection, TransactionInstruction } from '@solana/web3.js';
 import { Program, BN, IdlAccounts } from '@coral-xyz/anchor';
 import { WasabiSolana } from '../idl/wasabi_solana';
-import { MintCache } from './mintCache';
+import { TokenMintCache } from "../cache/TokenMintCache";
 export declare const SOL_MINT: PublicKey;
 export declare const WASABI_PROGRAM_ID: PublicKey;
 export declare const METADATA_PROGRAM_ID: PublicKey;
@@ -25,7 +25,7 @@ export declare const SEED_PREFIX: {
 export declare function getPermission(program: Program<WasabiSolana>, admin: PublicKey): Promise<PublicKey>;
 export declare function uiAmountToAmount(uiAmount: number, decimals: number): BN;
 export declare function amountToUiAmount(amount: BN, decimals: number): number;
-export declare function getTokenProgram(connection: Connection, mint: PublicKey, mintCache?: MintCache): Promise<PublicKey | null>;
+export declare function getTokenProgram(connection: Connection, mint: PublicKey, mintCache?: TokenMintCache): Promise<PublicKey | null>;
 export declare function getTokenProgramAndDecimals(connection: Connection, mint: PublicKey): Promise<[PublicKey, number] | null>;
 export declare const PDA: {
     getLongPool(collateral: PublicKey, currency: PublicKey): PublicKey;
@@ -107,21 +107,20 @@ export declare function handleMint(connection: Connection, mint: PublicKey, opti
     owner?: PublicKey;
     wrapMode?: WrapMode;
     amount?: number | bigint;
-    mintCache?: MintCache;
+    mintCache?: TokenMintCache;
 }): Promise<MintResult>;
 export declare function handleMintsAndTokenProgram(connection: Connection, currency: PublicKey, collateral: PublicKey, options: {
-    owner?: PublicKey;
-    mintCache?: MintCache;
+    mintCache?: TokenMintCache;
 }): Promise<TokenProgramsResult>;
-export declare function handleMintsAndTokenProgramWithSetupAndCleanup(connection: Connection, owner: PublicKey, currency: PublicKey, collateral: PublicKey, wrapMode: WrapMode, amount?: number | bigint, mintCache?: MintCache): Promise<TokenProgramsWithSetupResult>;
-export declare function handlePaymentTokenMint(connection: Connection, owner: PublicKey, paymentToken: PublicKey, currency: PublicKey, collateral: PublicKey, wrapMode: WrapMode, amount?: number | bigint, mintCache?: MintCache): Promise<TokenProgramsWithSetupResult>;
-export declare function handlePaymentTokenMintWithAuthority(connection: Connection, authority: PublicKey, owner: PublicKey, paymentToken: PublicKey, currency: PublicKey, collateral: PublicKey, wrapMode: WrapMode, amount?: number | bigint, mintCache?: MintCache): Promise<TokenProgramsWithSetupResult>;
+export declare function handleMintsAndTokenProgramWithSetupAndCleanup(connection: Connection, owner: PublicKey, currency: PublicKey, collateral: PublicKey, wrapMode: WrapMode, amount?: number | bigint, mintCache?: TokenMintCache): Promise<TokenProgramsWithSetupResult>;
+export declare function handlePaymentTokenMint(connection: Connection, owner: PublicKey, paymentToken: PublicKey, currency: PublicKey, collateral: PublicKey, wrapMode: WrapMode, amount?: number | bigint, mintCache?: TokenMintCache): Promise<TokenProgramsWithSetupResult>;
+export declare function handlePaymentTokenMintWithAuthority(connection: Connection, authority: PublicKey, owner: PublicKey, paymentToken: PublicKey, currency: PublicKey, collateral: PublicKey, wrapMode: WrapMode, amount?: number | bigint, mintCache?: TokenMintCache): Promise<TokenProgramsWithSetupResult>;
 type OpenTokenAccountArgs = {
     program: Program<WasabiSolana>;
     owner: PublicKey;
     downPayment: number | bigint;
     fee: number | bigint;
-    mintCache?: MintCache;
+    mintCache?: TokenMintCache;
     isLongPool: boolean;
     currency: PublicKey;
     collateral: PublicKey;
@@ -149,7 +148,7 @@ export type CloseTokenAccounts = {
 export declare function handleCloseTokenAccounts(config: {
     program: Program<WasabiSolana>;
     owner: PublicKey;
-    mintCache: MintCache;
+    mintCache: TokenMintCache;
     authority?: PublicKey;
 }, poolAccount: {
     isLongPool: boolean;
@@ -158,5 +157,5 @@ export declare function handleCloseTokenAccounts(config: {
 }): Promise<CloseTokenAccounts>;
 export declare function validateArgs<T>(args: T): NonNullable<T>;
 export declare function validateProviderPubkey(payer: PublicKey | undefined): NonNullable<PublicKey>;
-export declare function validateMintCache(mintCache: MintCache | undefined): NonNullable<MintCache>;
+export declare function validateMintCache(mintCache: TokenMintCache | undefined): NonNullable<TokenMintCache>;
 export {};