@scalecrx/sdk 0.4.0

package/dist/scaleAmm.js

@@ -0,0 +1,465 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScaleSdkError = exports.ScaleAmm = void 0;
+const anchor_1 = require("@coral-xyz/anchor");
+const web3_js_1 = require("@solana/web3.js");
+const spl_token_1 = require("@solana/spl-token");
+const utils_1 = require("./utils");
+const errors_1 = require("./errors");
+Object.defineProperty(exports, "ScaleSdkError", { enumerable: true, get: function () { return errors_1.ScaleSdkError; } });
+const scale_amm_json_1 = __importDefault(require("./idl/scale_amm.json"));
+class ScaleAmm {
+    constructor(provider, programId, idlOverride, hasWallet = true) {
+        this.provider = provider;
+        this.programId = programId;
+        const resolvedIdl = idlOverride ?? scale_amm_json_1.default;
+        this.idl = { ...resolvedIdl, address: programId.toBase58() };
+        this.program = new anchor_1.Program(this.idl, provider);
+        this.idlErrors = (0, anchor_1.parseIdlErrors)(this.idl);
+        this.hasWallet = hasWallet;
+    }
+    getConfigAddress() {
+        return (0, utils_1.getConfigAddress)(this.programId);
+    }
+    getPoolAddress(owner, mintA, mintB) {
+        return (0, utils_1.getPoolAddress)(this.programId, owner, mintA, mintB);
+    }
+    getVaultAddress(pool, mint) {
+        return (0, utils_1.getVaultAddress)(this.programId, pool, mint);
+    }
+    async getPlatformConfig() {
+        const config = this.getConfigAddress();
+        try {
+            return await this.program.account.platformConfig.fetch(config);
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async getPlatformBaseToken() {
+        const config = await this.getPlatformConfig();
+        return config ? config.baseToken : null;
+    }
+    async getFeeBeneficiaries(poolInput) {
+        const pool = await this.resolvePool(poolInput);
+        return pool.data.feeBeneficiaries.slice(0, pool.data.feeBeneficiaryCount);
+    }
+    async getFeeShare(poolInput, wallet) {
+        const beneficiaries = await this.getFeeBeneficiaries(poolInput);
+        const entry = beneficiaries.find((beneficiary) => beneficiary.wallet.equals(wallet));
+        return entry ? entry.shareBps : 0;
+    }
+    async getTotalCreatorFeeBps(poolInput) {
+        const beneficiaries = await this.getFeeBeneficiaries(poolInput);
+        return beneficiaries.reduce((acc, beneficiary) => acc + beneficiary.shareBps, 0);
+    }
+    async getPool(poolOrAddress) {
+        const resolved = await this.resolvePool(poolOrAddress);
+        return resolved;
+    }
+    async getPoolByAddress(pool) {
+        try {
+            const data = (await this.program.account.pool.fetch(pool));
+            return {
+                address: pool,
+                owner: data.owner,
+                mintA: data.mintA,
+                mintB: data.mintB,
+                data,
+            };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("getPoolByAddress failed", err, this.idlErrors);
+        }
+    }
+    async getPoolByMints(owner, mintA, mintB) {
+        const pool = this.getPoolAddress(owner, mintA, mintB);
+        return this.getPoolByAddress(pool);
+    }
+    async createPool(params, mintA, mintB, options = {}) {
+        const payer = options.payer ?? this.provider.wallet.publicKey;
+        const owner = options.owner ?? this.provider.wallet.publicKey;
+        const tokenWalletAuthority = options.tokenWalletAuthority ?? this.provider.wallet.publicKey;
+        try {
+            const { instructions, pool, vaultA, vaultB, signers } = await this.createPoolInstructions(params, mintA, mintB, options);
+            const tx = new web3_js_1.Transaction();
+            instructions.forEach((instruction) => tx.add(instruction));
+            const signature = await this.sendTransaction(tx, signers ?? [], "confirmed");
+            return { pool, vaultA, vaultB, signature };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("createPool failed", err, this.idlErrors);
+        }
+    }
+    async createPoolInstructions(params, mintA, mintB, options = {}) {
+        const payer = options.payer ?? this.provider.wallet.publicKey;
+        const owner = options.owner ?? this.provider.wallet.publicKey;
+        const tokenWalletAuthority = options.tokenWalletAuthority ?? this.provider.wallet.publicKey;
+        try {
+            const tokenProgramA = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, mintA);
+            const tokenProgramB = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, mintB);
+            const pool = this.getPoolAddress(owner, mintA, mintB);
+            const vaultA = this.getVaultAddress(pool, mintA);
+            const vaultB = this.getVaultAddress(pool, mintB);
+            const config = this.getConfigAddress();
+            let tokenWalletB = options.tokenWalletB;
+            const instructions = [];
+            if (!tokenWalletB) {
+                const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, payer, tokenWalletAuthority, mintB, tokenProgramB);
+                tokenWalletB = ataResult.ata;
+                if (ataResult.instruction) {
+                    instructions.push(ataResult.instruction);
+                }
+            }
+            const createParams = {
+                shift: (0, utils_1.toBN)(params.shift),
+                initialTokenBReserves: (0, utils_1.toBN)(params.initialTokenBReserves),
+                curve: params.curve,
+                feeBeneficiaries: params.feeBeneficiaries ?? [],
+            };
+            const ix = await this.program.methods
+                .create(createParams)
+                .accounts({
+                payer,
+                owner,
+                tokenWalletAuthority,
+                mintA,
+                mintB,
+                tokenWalletB,
+                pool,
+                vaultA,
+                vaultB,
+                tokenProgramA,
+                tokenProgramB,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                config,
+            })
+                .instruction();
+            instructions.push(ix);
+            return { instructions, pool, vaultA, vaultB, signers: options.signers };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("createPoolInstructions failed", err, this.idlErrors);
+        }
+    }
+    async createWithDevBuyInstructions(params, mintA, mintB, buyParams, options = {}) {
+        try {
+            const owner = options.owner ?? this.provider.wallet.publicKey;
+            const { instructions: createInstructions, pool, vaultA, vaultB, signers } = await this.createPoolInstructions(params, mintA, mintB, options);
+            const swapParams = { amount: (0, utils_1.toBN)(buyParams.amount), limit: (0, utils_1.toBN)(buyParams.limit) };
+            const user = this.provider.wallet.publicKey;
+            const autoCreateAta = options.autoCreateAta ?? true;
+            const wrapSol = options.wrapSol ?? true;
+            const unwrapSol = options.unwrapSol ?? false;
+            const tokenProgramA = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, mintA);
+            const tokenProgramB = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, mintB);
+            const preInstructions = [];
+            const postInstructions = [];
+            let userTaA = options.userTokenAccountA;
+            let userTaB = options.userTokenAccountB;
+            let createdAtaA = false;
+            if (!userTaA) {
+                const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, user, mintA, tokenProgramA);
+                userTaA = ataResult.ata;
+                if (ataResult.instruction && !autoCreateAta) {
+                    throw new Error(`Missing ATA for mintA: ${mintA.toBase58()}`);
+                }
+                if (ataResult.instruction) {
+                    createdAtaA = true;
+                    preInstructions.push(ataResult.instruction);
+                }
+            }
+            if (!userTaB) {
+                const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, user, mintB, tokenProgramB);
+                userTaB = ataResult.ata;
+                if (ataResult.instruction && !autoCreateAta) {
+                    throw new Error(`Missing ATA for mintB: ${mintB.toBase58()}`);
+                }
+                if (ataResult.instruction) {
+                    preInstructions.push(ataResult.instruction);
+                }
+            }
+            const isNativeA = mintA.equals(spl_token_1.NATIVE_MINT);
+            if (isNativeA && wrapSol) {
+                preInstructions.push((0, utils_1.transferSolInstruction)(user, userTaA, swapParams.amount));
+                preInstructions.push((0, spl_token_1.createSyncNativeInstruction)(userTaA));
+            }
+            if (isNativeA && unwrapSol && createdAtaA) {
+                postInstructions.push((0, spl_token_1.createCloseAccountInstruction)(userTaA, user, user));
+            }
+            const config = this.getConfigAddress();
+            const configState = (await this.program.account.platformConfig.fetch(config));
+            const feeBeneficiary = configState.feeBeneficiary;
+            let platformFeeTaA = options.platformFeeTokenAccount;
+            if (!platformFeeTaA) {
+                const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, feeBeneficiary, mintA, tokenProgramA, true);
+                platformFeeTaA = ataResult.ata;
+                if (ataResult.instruction && !autoCreateAta) {
+                    throw new Error(`Missing platform fee ATA for mintA: ${mintA.toBase58()}`);
+                }
+                if (ataResult.instruction) {
+                    preInstructions.push(ataResult.instruction);
+                }
+            }
+            const beneficiaries = params.feeBeneficiaries ?? [];
+            if (options.beneficiaryTokenAccounts &&
+                options.beneficiaryTokenAccounts.length !== beneficiaries.length) {
+                throw new Error("beneficiaryTokenAccounts length mismatch");
+            }
+            const remainingAccounts = options.beneficiaryTokenAccounts ??
+                (await Promise.all(beneficiaries.map(async (beneficiary) => {
+                    const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, beneficiary.wallet, mintA, tokenProgramA, true);
+                    if (ataResult.instruction && !autoCreateAta) {
+                        throw new Error(`Missing beneficiary ATA for mintA: ${mintA.toBase58()}`);
+                    }
+                    if (ataResult.instruction) {
+                        preInstructions.push(ataResult.instruction);
+                    }
+                    return ataResult.ata;
+                })));
+            const ix = await this.program.methods.buy(swapParams)
+                .accounts({
+                pool,
+                user,
+                owner,
+                mintA,
+                mintB,
+                userTaA,
+                userTaB,
+                vaultA,
+                vaultB,
+                platformFeeTaA,
+                tokenProgramA,
+                tokenProgramB,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                config,
+            })
+                .remainingAccounts(remainingAccounts.map((pubkey) => ({
+                pubkey,
+                isWritable: true,
+                isSigner: false,
+            })))
+                .instruction();
+            return {
+                instructions: [...createInstructions, ...preInstructions, ix, ...postInstructions],
+                signers,
+                pool,
+                vaultA,
+                vaultB,
+                userTokenAccountA: userTaA,
+                userTokenAccountB: userTaB,
+            };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("createWithDevBuyInstructions failed", err, this.idlErrors);
+        }
+    }
+    async buy(poolInput, params, options = {}) {
+        try {
+            const { instructions, signers } = await this.buyInstructions(poolInput, params, options);
+            const tx = new web3_js_1.Transaction();
+            instructions.forEach((instruction) => tx.add(instruction));
+            return await this.sendTransaction(tx, signers ?? [], "confirmed");
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("buy failed", err, this.idlErrors);
+        }
+    }
+    async sell(poolInput, params, options = {}) {
+        try {
+            const { instructions, signers } = await this.sellInstructions(poolInput, params, options);
+            const tx = new web3_js_1.Transaction();
+            instructions.forEach((instruction) => tx.add(instruction));
+            return await this.sendTransaction(tx, signers ?? [], "confirmed");
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("sell failed", err, this.idlErrors);
+        }
+    }
+    async buyInstructions(poolInput, params, options = {}) {
+        try {
+            const pool = await this.resolvePool(poolInput);
+            return await this.swapInstructions("buy", pool, params, options);
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("buyInstructions failed", err, this.idlErrors);
+        }
+    }
+    async sellInstructions(poolInput, params, options = {}) {
+        try {
+            const pool = await this.resolvePool(poolInput);
+            return await this.swapInstructions("sell", pool, params, options);
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("sellInstructions failed", err, this.idlErrors);
+        }
+    }
+    async estimateBuy(poolInput, params) {
+        return this.estimate("quoteBuy", poolInput, params);
+    }
+    async estimateSell(poolInput, params) {
+        return this.estimate("quoteSell", poolInput, params);
+    }
+    async estimate(method, poolInput, params) {
+        try {
+            const pool = await this.resolvePool(poolInput);
+            const swapParams = { amount: (0, utils_1.toBN)(params.amount), limit: (0, utils_1.toBN)(params.limit) };
+            const config = this.getConfigAddress();
+            const result = await this.program.methods[method](swapParams)
+                .accounts({
+                pool: pool.address,
+                owner: pool.owner,
+                mintA: pool.mintA,
+                mintB: pool.mintB,
+                config,
+            })
+                .view();
+            return {
+                newReservesA: result.newReservesA,
+                newReservesB: result.newReservesB,
+                amountA: result.amountA,
+                amountB: result.amountB,
+                feeA: result.feeA,
+            };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)(`${method} failed`, err, this.idlErrors);
+        }
+    }
+    async resolvePool(poolInput) {
+        if (poolInput instanceof web3_js_1.PublicKey) {
+            return this.getPoolByAddress(poolInput);
+        }
+        return this.getPoolByAddress(poolInput.address);
+    }
+    async swapInstructions(action, pool, params, options) {
+        const swapParams = { amount: (0, utils_1.toBN)(params.amount), limit: (0, utils_1.toBN)(params.limit) };
+        const user = this.provider.wallet.publicKey;
+        const autoCreateAta = options.autoCreateAta ?? true;
+        const wrapSol = options.wrapSol ?? action === "buy";
+        const unwrapSol = options.unwrapSol ?? action === "sell";
+        const tokenProgramA = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, pool.mintA);
+        const tokenProgramB = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, pool.mintB);
+        const preInstructions = [];
+        const postInstructions = [];
+        let userTaA = options.userTokenAccountA;
+        let userTaB = options.userTokenAccountB;
+        let createdAtaA = false;
+        if (!userTaA) {
+            const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, user, pool.mintA, tokenProgramA);
+            userTaA = ataResult.ata;
+            if (ataResult.instruction && !autoCreateAta) {
+                throw new Error(`Missing ATA for mintA: ${pool.mintA.toBase58()}`);
+            }
+            if (ataResult.instruction) {
+                createdAtaA = true;
+                preInstructions.push(ataResult.instruction);
+            }
+        }
+        if (!userTaB) {
+            const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, user, pool.mintB, tokenProgramB);
+            userTaB = ataResult.ata;
+            if (ataResult.instruction && !autoCreateAta) {
+                throw new Error(`Missing ATA for mintB: ${pool.mintB.toBase58()}`);
+            }
+            if (ataResult.instruction) {
+                preInstructions.push(ataResult.instruction);
+            }
+        }
+        const isNativeA = pool.mintA.equals(spl_token_1.NATIVE_MINT);
+        if (isNativeA && wrapSol) {
+            preInstructions.push((0, utils_1.transferSolInstruction)(user, userTaA, swapParams.amount));
+            preInstructions.push((0, spl_token_1.createSyncNativeInstruction)(userTaA));
+        }
+        if (isNativeA && unwrapSol && createdAtaA) {
+            postInstructions.push((0, spl_token_1.createCloseAccountInstruction)(userTaA, user, user));
+        }
+        const vaultA = this.getVaultAddress(pool.address, pool.mintA);
+        const vaultB = this.getVaultAddress(pool.address, pool.mintB);
+        const config = this.getConfigAddress();
+        const configState = (await this.program.account.platformConfig.fetch(config));
+        const feeBeneficiary = configState.feeBeneficiary;
+        let platformFeeTaA = options.platformFeeTokenAccount;
+        if (!platformFeeTaA) {
+            const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, feeBeneficiary, pool.mintA, tokenProgramA, true);
+            platformFeeTaA = ataResult.ata;
+            if (ataResult.instruction && !autoCreateAta) {
+                throw new Error(`Missing platform fee ATA for mintA: ${pool.mintA.toBase58()}`);
+            }
+            if (ataResult.instruction) {
+                preInstructions.push(ataResult.instruction);
+            }
+        }
+        const beneficiaries = pool.data.feeBeneficiaries.slice(0, pool.data.feeBeneficiaryCount);
+        if (options.beneficiaryTokenAccounts &&
+            options.beneficiaryTokenAccounts.length !== beneficiaries.length) {
+            throw new Error("beneficiaryTokenAccounts length mismatch");
+        }
+        const remainingAccounts = options.beneficiaryTokenAccounts ??
+            (await Promise.all(beneficiaries.map(async (beneficiary) => {
+                const ataResult = await (0, utils_1.maybeCreateAtaInstruction)(this.provider.connection, user, beneficiary.wallet, pool.mintA, tokenProgramA, true);
+                if (ataResult.instruction && !autoCreateAta) {
+                    throw new Error(`Missing beneficiary ATA for mintA: ${pool.mintA.toBase58()}`);
+                }
+                if (ataResult.instruction) {
+                    preInstructions.push(ataResult.instruction);
+                }
+                return ataResult.ata;
+            })));
+        const ix = await this.program.methods[action](swapParams)
+            .accounts({
+            pool: pool.address,
+            user,
+            owner: pool.owner,
+            mintA: pool.mintA,
+            mintB: pool.mintB,
+            userTaA,
+            userTaB,
+            vaultA,
+            vaultB,
+            platformFeeTaA,
+            tokenProgramA,
+            tokenProgramB,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            config,
+        })
+            .remainingAccounts(remainingAccounts.map((pubkey) => ({
+            pubkey,
+            isWritable: true,
+            isSigner: false,
+        })))
+            .instruction();
+        const instructions = [...preInstructions, ix, ...postInstructions];
+        return {
+            instructions,
+            userTokenAccountA: userTaA,
+            userTokenAccountB: userTaB,
+        };
+    }
+    async sendTransaction(tx, signers = [], commitment) {
+        try {
+            if (!this.hasWallet) {
+                throw new errors_1.ScaleSdkError("No wallet provided. Direct execution requires an Anchor wallet.", "transaction failed", null);
+            }
+            if (!tx.feePayer) {
+                tx.feePayer = this.provider.wallet.publicKey;
+            }
+            const { blockhash, lastValidBlockHeight } = await this.provider.connection.getLatestBlockhash(commitment ?? "confirmed");
+            tx.recentBlockhash = blockhash;
+            if (signers.length) {
+                tx.partialSign(...signers);
+            }
+            const signedTx = await this.provider.wallet.signTransaction(tx);
+            const signature = await this.provider.connection.sendRawTransaction(signedTx.serialize(), { preflightCommitment: commitment });
+            await this.provider.connection.confirmTransaction({ signature, blockhash, lastValidBlockHeight }, commitment);
+            return signature;
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("transaction failed", err, this.idlErrors);
+        }
+    }
+}
+exports.ScaleAmm = ScaleAmm;

package/dist/scaleVmm.d.ts

@@ -0,0 +1,77 @@
+import { AnchorProvider, BN, Idl, Program } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+import { CreatePairInstructionResult, CreatePairOptions, CreatePairParamsInput, CurveTypeInput, CreatePairWithDevBuyInstructionResult, EstimateResult, PairAddress, PairRef, SwapInstructionResult, SwapParamsInput, VmmSwapOptions } from "./types";
+import { ScaleSdkError } from "./errors";
+export type PairAccount = {
+    enabled: boolean;
+    graduated: boolean;
+    mintA: PublicKey;
+    mintB: PublicKey;
+    tokenAReserves: BN;
+    tokenBReserves: BN;
+    shift: BN;
+    curve: CurveTypeInput;
+    bump: number;
+    feeBeneficiaryCount: number;
+    feeBeneficiaries: Array<{
+        wallet: PublicKey;
+        shareBps: number;
+    }>;
+    ammPool: PublicKey;
+};
+export declare class ScaleVmm {
+    readonly provider: AnchorProvider;
+    readonly programId: PublicKey;
+    readonly program: Program;
+    readonly idl: Idl;
+    readonly idlErrors: Map<number, string>;
+    readonly ammProgramId?: PublicKey;
+    readonly hasWallet: boolean;
+    constructor(provider: AnchorProvider, programId: PublicKey, idlOverride?: Idl, ammProgramId?: PublicKey, hasWallet?: boolean);
+    getConfigAddress(): PublicKey;
+    getPairAddress(mintA: PublicKey, mintB: PublicKey): PublicKey;
+    getVaultAddress(pair: PublicKey, mint: PublicKey): PublicKey;
+    getAmmPoolAddress(pair: PublicKey, mintA: PublicKey, mintB: PublicKey): PublicKey;
+    getAmmVaultAddress(pool: PublicKey, mint: PublicKey): PublicKey;
+    getPlatformConfig(): Promise<any>;
+    getPlatformConfigView(): Promise<any>;
+    getPlatformBaseToken(): Promise<PublicKey | null>;
+    getGraduationThreshold(): Promise<any>;
+    setGraduationThreshold(threshold: BN | number): Promise<string>;
+    setGraduationThresholdInstruction(threshold: BN | number): Promise<TransactionInstruction>;
+    getFeeBeneficiaries(pairInput: PairAddress | PairRef): Promise<{
+        wallet: PublicKey;
+        shareBps: number;
+    }[]>;
+    getFeeShare(pairInput: PairAddress | PairRef, wallet: PublicKey): Promise<number>;
+    getTotalCreatorFeeBps(pairInput: PairAddress | PairRef): Promise<number>;
+    getPair(pairOrAddress: PairAddress | PairRef): Promise<PairRef & {
+        data: PairAccount;
+    }>;
+    getPairByAddress(pair: PublicKey): Promise<PairRef & {
+        data: PairAccount;
+    }>;
+    getPairByMints(mintA: PublicKey, mintB: PublicKey): Promise<PairRef & {
+        data: PairAccount;
+    }>;
+    createPair(params: CreatePairParamsInput, mintA: PublicKey, mintB: PublicKey, options?: CreatePairOptions): Promise<{
+        pair: PublicKey;
+        vaultA: PublicKey;
+        vaultB: PublicKey;
+        signature: string;
+    }>;
+    createPairInstructions(params: CreatePairParamsInput, mintA: PublicKey, mintB: PublicKey, options?: CreatePairOptions): Promise<CreatePairInstructionResult>;
+    createWithDevBuyInstructions(params: CreatePairParamsInput, mintA: PublicKey, mintB: PublicKey, buyParams: SwapParamsInput, options?: (CreatePairOptions & VmmSwapOptions)): Promise<CreatePairWithDevBuyInstructionResult>;
+    buy(pairInput: PairAddress | PairRef, params: SwapParamsInput, options?: VmmSwapOptions): Promise<string>;
+    sell(pairInput: PairAddress | PairRef, params: SwapParamsInput, options?: VmmSwapOptions): Promise<string>;
+    buyInstructions(pairInput: PairAddress | PairRef, params: SwapParamsInput, options?: VmmSwapOptions): Promise<SwapInstructionResult>;
+    sellInstructions(pairInput: PairAddress | PairRef, params: SwapParamsInput, options?: VmmSwapOptions): Promise<SwapInstructionResult>;
+    estimateBuy(pairInput: PairAddress | PairRef, params: SwapParamsInput): Promise<EstimateResult>;
+    estimateSell(pairInput: PairAddress | PairRef, params: SwapParamsInput): Promise<EstimateResult>;
+    private estimate;
+    private resolvePair;
+    private swapInstructions;
+    private resolveAmmProgramId;
+    private sendTransaction;
+}
+export { ScaleSdkError };