wasabi-solana-ts 1.2.3 → 1.2.5

package/dist/instructions/initStopLossOrder.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInitStopLossInstruction = createInitStopLossInstruction;
-exports.initStopLoss = initStopLoss;
-const anchor_1 = require("@coral-xyz/anchor");
-const web3_js_1 = require("@solana/web3.js");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const initStopLossConfig = {
-    process: async (config) => {
-        const trader = await config.program.account.position
-            .fetch(config.accounts.position)
-            .then((pos) => pos.trader);
-        const allAccounts = {
-            trader,
-            position: config.accounts.position,
-            stopLossOrder: utils_1.PDA.getStopLossOrder(config.accounts.position),
-            systemProgram: web3_js_1.SystemProgram.programId
-        };
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    trader,
-                    position: allAccounts.position
-                },
-            args: {
-                makerAmount: new anchor_1.BN(config.args.makerAmount),
-                takerAmount: new anchor_1.BN(config.args.takerAmount)
-            }
-        };
-    },
-    getMethod: (program) => (args) => program.methods.initStopLossOrder(args.makerAmount, args.takerAmount)
-};
-function createInitStopLossInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, initStopLossConfig, 'instruction', strict, increaseCompute, args));
-}
-function initStopLoss(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, initStopLossConfig, 'transaction', strict, increaseCompute, args));
-}

package/dist/instructions/initTakeProfitOrder.d.ts

@@ -1,12 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionSignature, TransactionInstruction, PublicKey } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type InitTakeProfitArgs = {
-    makerAmount: number;
-    takerAmount: number;
-};
-export type InitTakeProfitAccounts = {
-    position: PublicKey;
-};
-export declare function createInitTakeProfitInstruction(program: Program<WasabiSolana>, args: InitTakeProfitArgs, accounts: InitTakeProfitAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function initTakeProfit(program: Program<WasabiSolana>, args: InitTakeProfitArgs, accounts: InitTakeProfitAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/initTakeProfitOrder.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createInitTakeProfitInstruction = createInitTakeProfitInstruction;
-exports.initTakeProfit = initTakeProfit;
-const anchor_1 = require("@coral-xyz/anchor");
-const web3_js_1 = require("@solana/web3.js");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const initTakeProfitConfig = {
-    process: async (config) => {
-        const trader = await config.program.account.position
-            .fetch(config.accounts.position)
-            .then((pos) => pos.trader);
-        const allAccounts = {
-            trader,
-            position: config.accounts.position,
-            stopLossOrder: utils_1.PDA.getTakeProfitOrder(config.accounts.position),
-            systemProgram: web3_js_1.SystemProgram.programId
-        };
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    trader,
-                    position: allAccounts.position
-                },
-            args: {
-                makerAmount: new anchor_1.BN(config.args.makerAmount),
-                takerAmount: new anchor_1.BN(config.args.takerAmount)
-            }
-        };
-    },
-    getMethod: (program) => (args) => program.methods.initTakeProfitOrder(args.makerAmount, args.takerAmount)
-};
-function createInitTakeProfitInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, initTakeProfitConfig, 'instruction', strict, increaseCompute, args));
-}
-function initTakeProfit(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, initTakeProfitConfig, 'transaction', strict, increaseCompute, args));
-}

package/dist/instructions/mint.d.ts

@@ -1,8 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionSignature, TransactionInstruction } from '@solana/web3.js';
-import { BaseMethodConfig } from '../base';
-import { MintArgs, MintAccounts, TokenInstructionAccounts, TokenInstructionAccountsStrict } from './tokenAccounts';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export declare const mintConfig: BaseMethodConfig<MintArgs, MintAccounts, TokenInstructionAccounts | TokenInstructionAccountsStrict>;
-export declare function createMintInstruction(program: Program<WasabiSolana>, args: MintArgs, accounts: MintAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function mint(program: Program<WasabiSolana>, args: MintArgs, accounts: MintAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/mint.js

@@ -1,35 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mintConfig = void 0;
-exports.createMintInstruction = createMintInstruction;
-exports.mint = mint;
-const anchor_1 = require("@coral-xyz/anchor");
-const base_1 = require("../base");
-const tokenAccounts_1 = require("./tokenAccounts");
-const utils_1 = require("../utils");
-exports.mintConfig = {
-    process: async (config) => {
-        const { mint, tokenProgram, setupIx, cleanupIx, } = await (0, utils_1.handleMint)(config.program.provider.connection, config.accounts.assetMint, config.program.provider.publicKey, 'wrap', config.args.amount);
-        const allAccounts = await (0, tokenAccounts_1.getTokenInstructionAccounts)(config.program, mint, tokenProgram);
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    owner: config.program.provider.publicKey,
-                    lpVault: allAccounts.lpVault,
-                    assetMint: mint,
-                    assetTokenProgram: tokenProgram,
-                },
-            args: config.args ? new anchor_1.BN(config.args.amount.toString()) : undefined,
-            setup: setupIx,
-            cleanup: cleanupIx,
-        };
-    },
-    getMethod: (program) => (args) => program.methods.mint(args)
-};
-async function createMintInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, exports.mintConfig, 'instruction', strict, increaseCompute, args));
-}
-async function mint(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, exports.mintConfig, 'transaction', strict, increaseCompute, args));
-}

package/dist/instructions/removePermission.d.ts

@@ -1,16 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionInstruction, TransactionSignature, PublicKey } from '@solana/web3.js';
-import { BaseMethodConfig } from '../base';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type RemovePermissionAccounts = {
-    permission: PublicKey;
-};
-type RemovePermissionInstructionAccounts = {
-    authority: PublicKey;
-    superAdminPermission: PublicKey;
-    permission: PublicKey;
-};
-export declare const removePermissionConfig: BaseMethodConfig<null, RemovePermissionAccounts, RemovePermissionInstructionAccounts | null>;
-export declare function createRemovePermissionInstruction(program: Program<WasabiSolana>, accounts: RemovePermissionAccounts, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function removePermission(program: Program<WasabiSolana>, accounts: RemovePermissionAccounts, increaseCompute?: boolean): Promise<TransactionSignature>;
-export {};

package/dist/instructions/removePermission.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removePermissionConfig = void 0;
-exports.createRemovePermissionInstruction = createRemovePermissionInstruction;
-exports.removePermission = removePermission;
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-exports.removePermissionConfig = {
-    process: async (config) => {
-        return {
-            accounts: {
-                authority: config.program.provider.publicKey,
-                superAdminPermission: utils_1.PDA.getSuperAdmin(),
-                permission: config.accounts.permission,
-            },
-        };
-    },
-    getMethod: (program) => () => program.methods.removePermission()
-};
-async function createRemovePermissionInstruction(program, accounts, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, exports.removePermissionConfig, 'INSTRUCTION', null, increaseCompute));
-}
-async function removePermission(program, accounts, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, exports.removePermissionConfig, 'INSTRUCTION', null, increaseCompute));
-}

package/dist/instructions/repay.d.ts

@@ -1,11 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionSignature, TransactionInstruction, PublicKey } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type RepayArgs = {
-    amount: number | bigint;
-};
-export type RepayAccounts = {
-    mint: PublicKey;
-};
-export declare function createRepayInstruction(program: Program<WasabiSolana>, args: RepayArgs, accounts: RepayAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function repay(program: Program<WasabiSolana>, args: RepayArgs, accounts: RepayAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/repay.js

@@ -1,44 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRepayInstruction = createRepayInstruction;
-exports.repay = repay;
-const anchor_1 = require("@coral-xyz/anchor");
-const spl_token_1 = require("@solana/spl-token");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const repayConfig = {
-    process: async (config) => {
-        const { mint, tokenProgram, setupIx, cleanupIx, } = await (0, utils_1.handleMint)(config.program.provider.connection, config.accounts.mint, config.program.provider.publicKey, 'wrap');
-        const lpVault = utils_1.PDA.getLpVault(mint);
-        const lpVaultInfo = await config.program.account.lpVault.fetch(lpVault);
-        const allAccounts = {
-            payer: config.program.provider.publicKey,
-            mint,
-            source: (0, spl_token_1.getAssociatedTokenAddressSync)(mint, config.program.provider.publicKey, false, tokenProgram),
-            lpVault,
-            vault: (0, spl_token_1.getAssociatedTokenAddressSync)(mint, lpVault, true, tokenProgram),
-            tokenProgram
-        };
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    payer: allAccounts.payer,
-                    mint: allAccounts.mint,
-                    source: allAccounts.source,
-                    lpVault,
-                    tokenProgram
-                },
-            args: lpVaultInfo.totalBorrowed.add(new anchor_1.BN(config.args.amount.toString())),
-            setup: setupIx,
-            cleanup: cleanupIx,
-        };
-    },
-    getMethod: (program) => (args) => program.methods.repay(args)
-};
-async function createRepayInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, repayConfig, 'instruction', strict, increaseCompute, args));
-}
-async function repay(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, repayConfig, 'transaction', strict, increaseCompute, args));
-}

package/dist/instructions/setLpState.d.ts

@@ -1,11 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { PublicKey, TransactionSignature, TransactionInstruction } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type LpStateArgs = {
-    allow_trading: boolean;
-};
-export type LpStateAccounts = {
-    authority: PublicKey;
-};
-export declare function createSetLpStateInstruction(program: Program<WasabiSolana>, args: LpStateArgs, accounts: LpStateAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function setLpState(program: Program<WasabiSolana>, args: LpStateArgs, accounts: LpStateAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/setLpState.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSetLpStateInstruction = createSetLpStateInstruction;
-exports.setLpState = setLpState;
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const tradeStateConfig = {
-    process: async (config) => {
-        const allAccounts = {
-            authority: config.accounts.authority,
-            globalSettings: utils_1.PDA.getGlobalSettings(),
-            superAdmin: utils_1.PDA.getSuperAdmin()
-        };
-        return {
-            accounts: config.strict ? allAccounts : {
-                authority: allAccounts.authority,
-            },
-            args: config.args.allow_trading
-        };
-    },
-    getMethod: (program) => (args) => program.methods.setLpState(args),
-};
-async function createSetLpStateInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, tradeStateConfig, 'INSTRUCTION', strict, increaseCompute, args));
-}
-async function setLpState(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, tradeStateConfig, 'TRANSACTION', strict, increaseCompute, args));
-}

package/dist/instructions/setMaxApy.d.ts

@@ -1,11 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionSignature, TransactionInstruction, PublicKey } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type SetMaxApyArgs = {
-    maxApy: number;
-};
-export type SetMaxApyAccounts = {
-    authority: PublicKey;
-};
-export declare function createSetMaxApyInstruction(program: Program<WasabiSolana>, args: SetMaxApyArgs, accounts: SetMaxApyAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function setMaxApy(program: Program<WasabiSolana>, args: SetMaxApyArgs, accounts: SetMaxApyAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/setMaxApy.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSetMaxApyInstruction = createSetMaxApyInstruction;
-exports.setMaxApy = setMaxApy;
-const anchor_1 = require("@coral-xyz/anchor");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const setMaxApyConfig = {
-    process: async (config) => {
-        const allAccounts = {
-            authority: config.accounts.authority,
-            superAdminPermission: utils_1.PDA.getSuperAdmin(),
-            debtController: utils_1.PDA.getDebtController()
-        };
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    authority: config.accounts.authority
-                },
-            args: config.args ? new anchor_1.BN(config.args.maxApy) : undefined
-        };
-    },
-    getMethod: (program) => (args) => program.methods.setMaxApy(args)
-};
-async function createSetMaxApyInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, setMaxApyConfig, 'INSTRUCTION', strict, increaseCompute, args));
-}
-async function setMaxApy(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, setMaxApyConfig, 'TRANSACTION', strict, increaseCompute, args));
-}

package/dist/instructions/setMaxLeverage.d.ts

@@ -1,11 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { TransactionInstruction, TransactionSignature, PublicKey } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type SetMaxLeverageArgs = {
-    maxLeverage: number;
-};
-export type SetMaxLeverageAccounts = {
-    authority: PublicKey;
-};
-export declare function createSetMaxLeverageInstruction(program: Program<WasabiSolana>, args: SetMaxLeverageArgs, accounts: SetMaxLeverageAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function setMaxLeverage(program: Program<WasabiSolana>, args: SetMaxLeverageArgs, accounts: SetMaxLeverageAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/setMaxLeverage.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSetMaxLeverageInstruction = createSetMaxLeverageInstruction;
-exports.setMaxLeverage = setMaxLeverage;
-const anchor_1 = require("@coral-xyz/anchor");
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const setMaxLeverageConfig = {
-    process: async (config) => {
-        const allAccounts = {
-            authority: config.accounts.authority,
-            superAdminPermission: utils_1.PDA.getSuperAdmin(),
-            debtController: utils_1.PDA.getDebtController()
-        };
-        return {
-            accounts: config.strict
-                ? allAccounts
-                : {
-                    authority: config.accounts.authority
-                },
-            args: config.args ? new anchor_1.BN(config.args.maxLeverage) : undefined
-        };
-    },
-    getMethod: (program) => (args) => program.methods.setMaxLeverage(args)
-};
-async function createSetMaxLeverageInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, setMaxLeverageConfig, 'INSTRUCTION', strict, increaseCompute, args));
-}
-async function setMaxLeverage(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, setMaxLeverageConfig, 'TRANSACTION', strict, increaseCompute, args));
-}

package/dist/instructions/setSuperAdmin.d.ts

@@ -1,11 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { PublicKey, TransactionSignature, TransactionInstruction } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type SuperAdminArgs = {
-    allow_trading: boolean;
-};
-export type SuperAdminAccounts = {
-    authority: PublicKey;
-};
-export declare function createSetSuperAdminInstruction(program: Program<WasabiSolana>, args: SuperAdminArgs, accounts: SuperAdminAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function setSuperAdmin(program: Program<WasabiSolana>, args: SuperAdminArgs, accounts: SuperAdminAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/setSuperAdmin.js

@@ -1,27 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSetSuperAdminInstruction = createSetSuperAdminInstruction;
-exports.setSuperAdmin = setSuperAdmin;
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const tradeStateConfig = {
-    process: async (config) => {
-        const allAccounts = {
-            authority: config.accounts.authority,
-            superAdmin: utils_1.PDA.getSuperAdmin()
-        };
-        return {
-            accounts: config.strict ? allAccounts : {
-                authority: allAccounts.authority,
-            },
-            args: config.args.allow_trading
-        };
-    },
-    getMethod: (program) => (args) => program.methods.setSuperAdmin(args),
-};
-async function createSetSuperAdminInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, tradeStateConfig, 'INSTRUCTION', strict, increaseCompute, args));
-}
-async function setSuperAdmin(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, tradeStateConfig, 'TRANSACTION', strict, increaseCompute, args));
-}

package/dist/instructions/setTradeState.d.ts

@@ -1,11 +0,0 @@
-import { Program } from '@coral-xyz/anchor';
-import { PublicKey, TransactionSignature, TransactionInstruction } from '@solana/web3.js';
-import { WasabiSolana } from '../idl/wasabi_solana';
-export type TradeStateArgs = {
-    allow_trading: boolean;
-};
-export type TradeStateAccounts = {
-    authority: PublicKey;
-};
-export declare function createSetTradeStateInstruction(program: Program<WasabiSolana>, args: TradeStateArgs, accounts: TradeStateAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionInstruction[]>;
-export declare function setTradeState(program: Program<WasabiSolana>, args: TradeStateArgs, accounts: TradeStateAccounts, strict?: boolean, increaseCompute?: boolean): Promise<TransactionSignature>;

package/dist/instructions/setTradeState.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSetTradeStateInstruction = createSetTradeStateInstruction;
-exports.setTradeState = setTradeState;
-const base_1 = require("../base");
-const utils_1 = require("../utils");
-const tradeStateConfig = {
-    process: async (config) => {
-        const allAccounts = {
-            authority: config.accounts.authority,
-            globalSettings: utils_1.PDA.getGlobalSettings(),
-            superAdmin: utils_1.PDA.getSuperAdmin()
-        };
-        return {
-            accounts: config.strict ? allAccounts : {
-                authority: allAccounts.authority,
-            },
-            args: config.args.allow_trading
-        };
-    },
-    getMethod: (program) => (args) => program.methods.setTradingState(args),
-};
-async function createSetTradeStateInstruction(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, tradeStateConfig, 'INSTRUCTION', strict, increaseCompute, args));
-}
-async function setTradeState(program, args, accounts, strict = true, increaseCompute = false) {
-    return (0, base_1.handleMethodCall)((0, base_1.constructMethodCallArgs)(program, accounts, tradeStateConfig, 'TRANSACTION', strict, increaseCompute, args));
-}

package/dist/instructions/swap.d.ts

@@ -1,30 +0,0 @@
-import { TransactionInstruction, PublicKey, Connection } from '@solana/web3.js';
-export type SwapMode = 'EXACT_IN' | 'EXACT_OUT';
-export type SwapProvider = 'jupiter' | 'raydium';
-export type SwapInstructionGroup = {
-    computeBudgetInstructions?: TransactionInstruction[];
-    setupInstructions: TransactionInstruction[];
-    swapInstructions: TransactionInstruction[];
-    cleanupInstructions: TransactionInstruction[];
-    addressLookupTableAddresses?: string[];
-};
-export type CreateSwapInstructionArgs = {
-    connection: Connection;
-    inputMint: PublicKey;
-    outputMint: PublicKey;
-    amount: number;
-    slippageBps: number;
-    ownerPubkey: PublicKey;
-    authorityPubkey?: PublicKey;
-    swapMode?: SwapMode;
-    preferredProvider?: SwapProvider;
-    options?: {
-        raydiumPoolIds?: string[];
-        jupiterOptions?: {
-            onlyDirectRoutes?: boolean;
-            asLegacyTransaction?: boolean;
-            maxAccounts?: number;
-        };
-    };
-};
-export declare function createSwapInstructionGroup({ connection, inputMint, outputMint, amount, slippageBps, ownerPubkey, authorityPubkey, swapMode, preferredProvider, options }: CreateSwapInstructionArgs): Promise<SwapInstructionGroup>;

package/dist/instructions/swap.js

@@ -1,91 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createSwapInstructionGroup = createSwapInstructionGroup;
-const swapJupiter_1 = require("./swapJupiter");
-const swapRaydium_1 = require("./swapRaydium");
-async function createSwapInstructionGroup({ connection, inputMint, outputMint, amount, slippageBps, ownerPubkey, authorityPubkey, swapMode = 'EXACT_IN', preferredProvider = 'jupiter', options = {} }) {
-    try {
-        return await createProviderSwapInstructions(preferredProvider, {
-            connection,
-            inputMint,
-            outputMint,
-            amount,
-            slippageBps,
-            ownerPubkey,
-            authorityPubkey,
-            swapMode,
-            options
-        });
-    }
-    catch (error) {
-        console.error(`${preferredProvider} swap failed:`, error);
-        const fallbackProvider = preferredProvider === 'jupiter' ? 'raydium' : 'jupiter';
-        try {
-            return await createProviderSwapInstructions(fallbackProvider, {
-                connection,
-                inputMint,
-                outputMint,
-                amount,
-                slippageBps,
-                ownerPubkey,
-                authorityPubkey,
-                swapMode,
-                options
-            });
-        }
-        catch (fallbackError) {
-            console.error(`${fallbackProvider} fallback failed:`, fallbackError);
-            throw new Error('All swap providers failed');
-        }
-    }
-}
-async function createProviderSwapInstructions(provider, params) {
-    if (provider === 'jupiter') {
-        return constructJupiterSwapInstructions(params);
-    }
-    else {
-        return constructRaydiumSwapInstructions(params);
-    }
-}
-async function constructJupiterSwapInstructions({ inputMint, outputMint, amount, slippageBps, ownerPubkey, authorityPubkey, swapMode, options }) {
-    const quoteResponse = await (0, swapJupiter_1.getJupiterQuote)(inputMint, outputMint, amount, slippageBps, swapMode, options?.jupiterOptions);
-    const jupiterInstructions = await (0, swapJupiter_1.createJupiterSwapInstructions)({
-        quoteResponse,
-        ownerPubkey: ownerPubkey,
-        wrapUnwrapSOL: true
-    });
-    return {
-        computeBudgetInstructions: jupiterInstructions.computeBudgetInstructions,
-        setupInstructions: [
-            ...(jupiterInstructions.setupInstructions || []),
-            ...(jupiterInstructions.tokenLedgerInstruction
-                ? [jupiterInstructions.tokenLedgerInstruction]
-                : [])
-        ],
-        swapInstructions: [jupiterInstructions.swapInstruction],
-        cleanupInstructions: [
-            ...(jupiterInstructions.cleanupInstruction
-                ? [jupiterInstructions.cleanupInstruction]
-                : [])
-        ],
-        addressLookupTableAddresses: jupiterInstructions.addressLookupTableAddresses
-    };
-}
-async function constructRaydiumSwapInstructions({ connection, inputMint, outputMint, amount, slippageBps, ownerPubkey, authorityPubkey, swapMode, options }) {
-    if (!options?.raydiumPoolId) {
-        throw new Error('Raydium pool ID is required');
-    }
-    const quoteResponse = await (0, swapRaydium_1.getRaydiumRouteQuote)(inputMint, outputMint, amount, slippageBps, [options.raydiumPoolId], swapMode, connection);
-    const raydiumInstructions = await (0, swapRaydium_1.createRaydiumRouteSwapInstructions)({
-        quoteResponse,
-        ownerPubkey,
-        authorityPubkey
-    });
-    return {
-        computeBudgetInstructions: raydiumInstructions.computeBudgetInstructions,
-        setupInstructions: raydiumInstructions.setupInstructions,
-        swapInstructions: raydiumInstructions.swapInstructions,
-        cleanupInstructions: raydiumInstructions.cleanupInstructions,
-        addressLookupTableAddresses: raydiumInstructions.addressLookupTableAddresses
-    };
-}