@scalecrx/sdk 0.4.0

package/dist/scaleVmm.js

@@ -0,0 +1,527 @@
+"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.ScaleVmm = 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_vmm_json_1 = __importDefault(require("./idl/scale_vmm.json"));
+class ScaleVmm {
+    constructor(provider, programId, idlOverride, ammProgramId, hasWallet = true) {
+        this.provider = provider;
+        this.programId = programId;
+        const resolvedIdl = idlOverride ?? scale_vmm_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.ammProgramId = ammProgramId;
+        this.hasWallet = hasWallet;
+    }
+    getConfigAddress() {
+        return (0, utils_1.getConfigAddress)(this.programId);
+    }
+    getPairAddress(mintA, mintB) {
+        return (0, utils_1.getPairAddress)(this.programId, mintA, mintB);
+    }
+    getVaultAddress(pair, mint) {
+        return (0, utils_1.getVaultAddress)(this.programId, pair, mint);
+    }
+    getAmmPoolAddress(pair, mintA, mintB) {
+        const programId = this.resolveAmmProgramId();
+        return (0, utils_1.getPoolAddress)(programId, pair, mintA, mintB);
+    }
+    getAmmVaultAddress(pool, mint) {
+        const programId = this.resolveAmmProgramId();
+        return (0, utils_1.getVaultAddress)(programId, pool, mint);
+    }
+    async getPlatformConfig() {
+        const config = this.getConfigAddress();
+        try {
+            return await this.program.account.platformConfig.fetch(config);
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async getPlatformConfigView() {
+        const config = this.getConfigAddress();
+        try {
+            return await this.program.methods
+                .getPlatformConfig()
+                .accounts({ config })
+                .view();
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async getPlatformBaseToken() {
+        const config = await this.getPlatformConfig();
+        return config ? config.baseToken : null;
+    }
+    async getGraduationThreshold() {
+        const config = await this.getPlatformConfig();
+        return config ? config.graduationThreshold : null;
+    }
+    async setGraduationThreshold(threshold) {
+        try {
+            const instruction = await this.setGraduationThresholdInstruction(threshold);
+            const tx = new web3_js_1.Transaction().add(instruction);
+            return await this.sendTransaction(tx, [], "confirmed");
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("setGraduationThreshold failed", err, this.idlErrors);
+        }
+    }
+    async setGraduationThresholdInstruction(threshold) {
+        const config = this.getConfigAddress();
+        try {
+            return await this.program.methods
+                .setGraduationThreshold((0, utils_1.toBN)(threshold))
+                .accounts({
+                authority: this.provider.wallet.publicKey,
+                config,
+            })
+                .instruction();
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("setGraduationThresholdInstruction failed", err, this.idlErrors);
+        }
+    }
+    async getFeeBeneficiaries(pairInput) {
+        const pair = await this.resolvePair(pairInput);
+        return pair.data.feeBeneficiaries.slice(0, pair.data.feeBeneficiaryCount);
+    }
+    async getFeeShare(pairInput, wallet) {
+        const beneficiaries = await this.getFeeBeneficiaries(pairInput);
+        const entry = beneficiaries.find((beneficiary) => beneficiary.wallet.equals(wallet));
+        return entry ? entry.shareBps : 0;
+    }
+    async getTotalCreatorFeeBps(pairInput) {
+        const beneficiaries = await this.getFeeBeneficiaries(pairInput);
+        return beneficiaries.reduce((acc, beneficiary) => acc + beneficiary.shareBps, 0);
+    }
+    async getPair(pairOrAddress) {
+        const resolved = await this.resolvePair(pairOrAddress);
+        return resolved;
+    }
+    async getPairByAddress(pair) {
+        try {
+            const data = (await this.program.account.pairState.fetch(pair));
+            return {
+                address: pair,
+                mintA: data.mintA,
+                mintB: data.mintB,
+                data,
+            };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("getPairByAddress failed", err, this.idlErrors);
+        }
+    }
+    async getPairByMints(mintA, mintB) {
+        const pair = this.getPairAddress(mintA, mintB);
+        return this.getPairByAddress(pair);
+    }
+    async createPair(params, mintA, mintB, options = {}) {
+        try {
+            const { instructions, pair, vaultA, vaultB, signers } = await this.createPairInstructions(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 { pair, vaultA, vaultB, signature };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("createPair failed", err, this.idlErrors);
+        }
+    }
+    async createPairInstructions(params, mintA, mintB, options = {}) {
+        const payer = options.payer ?? 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 pair = this.getPairAddress(mintA, mintB);
+            const vaultA = this.getVaultAddress(pair, mintA);
+            const vaultB = this.getVaultAddress(pair, 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,
+                tokenWalletAuthority,
+                mintA,
+                mintB,
+                tokenWalletB,
+                pair,
+                vaultA,
+                vaultB,
+                tokenProgramA,
+                tokenProgramB,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                config,
+            })
+                .instruction();
+            instructions.push(ix);
+            return { instructions, pair, vaultA, vaultB, signers: options.signers };
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("createPairInstructions failed", err, this.idlErrors);
+        }
+    }
+    async createWithDevBuyInstructions(params, mintA, mintB, buyParams, options = {}) {
+        try {
+            const { instructions: createInstructions, pair, vaultA, vaultB, signers } = await this.createPairInstructions(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, true);
+                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 ammProgramId = options.ammProgramId ?? this.ammProgramId;
+            if (!ammProgramId) {
+                throw new Error("ammProgramId is required for VMM swaps");
+            }
+            const ammPool = options.ammPool ?? (0, utils_1.getPoolAddress)(ammProgramId, pair, mintA, mintB);
+            const ammVaultA = options.ammVaultA ?? (0, utils_1.getVaultAddress)(ammProgramId, ammPool, mintA);
+            const ammVaultB = options.ammVaultB ?? (0, utils_1.getVaultAddress)(ammProgramId, ammPool, mintB);
+            const ammConfig = options.ammConfig ?? (0, utils_1.getConfigAddress)(ammProgramId);
+            const ix = await this.program.methods.buy(swapParams)
+                .accounts({
+                pair,
+                user,
+                mintA,
+                mintB,
+                userTaA,
+                userTaB,
+                vaultA,
+                vaultB,
+                platformFeeTaA,
+                tokenProgramA,
+                tokenProgramB,
+                systemProgram: web3_js_1.SystemProgram.programId,
+                config,
+                ammProgram: ammProgramId,
+                ammPool,
+                ammVaultA,
+                ammVaultB,
+                ammConfig,
+            })
+                .remainingAccounts(remainingAccounts.map((pubkey) => ({
+                pubkey,
+                isWritable: true,
+                isSigner: false,
+            })))
+                .instruction();
+            return {
+                instructions: [...createInstructions, ...preInstructions, ix, ...postInstructions],
+                signers,
+                pair,
+                vaultA,
+                vaultB,
+                userTokenAccountA: userTaA,
+                userTokenAccountB: userTaB,
+            };
+        }
+        catch (err) {
+            console.error(err);
+            throw (0, errors_1.toSdkError)("createWithDevBuyInstructions failed", err, this.idlErrors);
+        }
+    }
+    async buy(pairInput, params, options = {}) {
+        try {
+            const { instructions, signers } = await this.buyInstructions(pairInput, 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(pairInput, params, options = {}) {
+        try {
+            const { instructions, signers } = await this.sellInstructions(pairInput, 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(pairInput, params, options = {}) {
+        try {
+            const pair = await this.resolvePair(pairInput);
+            return await this.swapInstructions("buy", pair, params, options);
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("buyInstructions failed", err, this.idlErrors);
+        }
+    }
+    async sellInstructions(pairInput, params, options = {}) {
+        try {
+            const pair = await this.resolvePair(pairInput);
+            return await this.swapInstructions("sell", pair, params, options);
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("sellInstructions failed", err, this.idlErrors);
+        }
+    }
+    async estimateBuy(pairInput, params) {
+        return this.estimate("quoteBuy", pairInput, params);
+    }
+    async estimateSell(pairInput, params) {
+        return this.estimate("quoteSell", pairInput, params);
+    }
+    async estimate(method, pairInput, params) {
+        try {
+            const pair = await this.resolvePair(pairInput);
+            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({
+                pair: pair.address,
+                mintA: pair.mintA,
+                mintB: pair.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 resolvePair(pairInput) {
+        if (pairInput instanceof web3_js_1.PublicKey) {
+            return this.getPairByAddress(pairInput);
+        }
+        return this.getPairByAddress(pairInput.address);
+    }
+    async swapInstructions(action, pair, 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, pair.mintA);
+        const tokenProgramB = await (0, utils_1.getTokenProgramForMint)(this.provider.connection, pair.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, pair.mintA, tokenProgramA);
+            userTaA = ataResult.ata;
+            if (ataResult.instruction && !autoCreateAta) {
+                throw new Error(`Missing ATA for mintA: ${pair.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, pair.mintB, tokenProgramB);
+            userTaB = ataResult.ata;
+            if (ataResult.instruction && !autoCreateAta) {
+                throw new Error(`Missing ATA for mintB: ${pair.mintB.toBase58()}`);
+            }
+            if (ataResult.instruction) {
+                preInstructions.push(ataResult.instruction);
+            }
+        }
+        const isNativeA = pair.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(pair.address, pair.mintA);
+        const vaultB = this.getVaultAddress(pair.address, pair.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, pair.mintA, tokenProgramA, true);
+            platformFeeTaA = ataResult.ata;
+            if (ataResult.instruction && !autoCreateAta) {
+                throw new Error(`Missing platform fee ATA for mintA: ${pair.mintA.toBase58()}`);
+            }
+            if (ataResult.instruction) {
+                preInstructions.push(ataResult.instruction);
+            }
+        }
+        const beneficiaries = pair.data.feeBeneficiaries.slice(0, pair.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, pair.mintA, tokenProgramA, true);
+                if (ataResult.instruction && !autoCreateAta) {
+                    throw new Error(`Missing beneficiary ATA for mintA: ${pair.mintA.toBase58()}`);
+                }
+                if (ataResult.instruction) {
+                    preInstructions.push(ataResult.instruction);
+                }
+                return ataResult.ata;
+            })));
+        const ammProgramId = options.ammProgramId ?? this.ammProgramId;
+        if (!ammProgramId) {
+            throw new Error("ammProgramId is required for VMM swaps");
+        }
+        const ammPool = options.ammPool ?? (0, utils_1.getPoolAddress)(ammProgramId, pair.address, pair.mintA, pair.mintB);
+        const ammVaultA = options.ammVaultA ?? (0, utils_1.getVaultAddress)(ammProgramId, ammPool, pair.mintA);
+        const ammVaultB = options.ammVaultB ?? (0, utils_1.getVaultAddress)(ammProgramId, ammPool, pair.mintB);
+        const ammConfig = options.ammConfig ?? (0, utils_1.getConfigAddress)(ammProgramId);
+        const ix = await this.program.methods[action](swapParams)
+            .accounts({
+            pair: pair.address,
+            user,
+            mintA: pair.mintA,
+            mintB: pair.mintB,
+            userTaA,
+            userTaB,
+            vaultA,
+            vaultB,
+            platformFeeTaA,
+            tokenProgramA,
+            tokenProgramB,
+            systemProgram: web3_js_1.SystemProgram.programId,
+            config,
+            ammProgram: ammProgramId,
+            ammPool,
+            ammVaultA,
+            ammVaultB,
+            ammConfig,
+        })
+            .remainingAccounts(remainingAccounts.map((pubkey) => ({
+            pubkey,
+            isWritable: true,
+            isSigner: false,
+        })))
+            .instruction();
+        const instructions = [...preInstructions, ix, ...postInstructions];
+        return {
+            instructions,
+            userTokenAccountA: userTaA,
+            userTokenAccountB: userTaB,
+        };
+    }
+    resolveAmmProgramId() {
+        if (!this.ammProgramId) {
+            throw new Error("ammProgramId is required for AMM derivations");
+        }
+        return this.ammProgramId;
+    }
+    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);
+            }
+            return await this.provider.sendAndConfirm(tx, signers, { commitment });
+        }
+        catch (err) {
+            throw (0, errors_1.toSdkError)("transaction failed", err, this.idlErrors);
+        }
+    }
+}
+exports.ScaleVmm = ScaleVmm;

package/dist/types.d.ts

@@ -0,0 +1,112 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, Signer, TransactionInstruction } from "@solana/web3.js";
+export type FeeBeneficiaryInput = {
+    wallet: PublicKey;
+    shareBps: number;
+};
+export type CurveTypeInput = {
+    constantProduct: {};
+} | {
+    exponential: {};
+};
+export type CreatePoolParamsInput = {
+    shift: BN | number;
+    initialTokenBReserves: BN | number;
+    curve: CurveTypeInput;
+    feeBeneficiaries: FeeBeneficiaryInput[];
+};
+export type CreatePairParamsInput = {
+    shift: BN | number;
+    initialTokenBReserves: BN | number;
+    curve: CurveTypeInput;
+    feeBeneficiaries: FeeBeneficiaryInput[];
+};
+export type SwapParamsInput = {
+    amount: BN | number;
+    limit: BN | number;
+};
+export type PoolAddress = PublicKey;
+export type PoolRef = {
+    address: PublicKey;
+    owner: PublicKey;
+    mintA: PublicKey;
+    mintB: PublicKey;
+};
+export type PairAddress = PublicKey;
+export type PairRef = {
+    address: PublicKey;
+    mintA: PublicKey;
+    mintB: PublicKey;
+};
+export type LaunchParams = {
+    baseToken: PublicKey;
+    programId?: PublicKey;
+};
+export type CreatePoolOptions = {
+    payer?: PublicKey;
+    owner?: PublicKey;
+    tokenWalletB?: PublicKey;
+    tokenWalletAuthority?: PublicKey;
+    signers?: Signer[];
+};
+export type CreatePairOptions = {
+    payer?: PublicKey;
+    tokenWalletB?: PublicKey;
+    tokenWalletAuthority?: PublicKey;
+    signers?: Signer[];
+};
+export type SwapOptions = {
+    userTokenAccountA?: PublicKey;
+    userTokenAccountB?: PublicKey;
+    platformFeeTokenAccount?: PublicKey;
+    beneficiaryTokenAccounts?: PublicKey[];
+    wrapSol?: boolean;
+    unwrapSol?: boolean;
+    autoCreateAta?: boolean;
+};
+export type VmmSwapOptions = SwapOptions & {
+    ammProgramId?: PublicKey;
+    ammPool?: PublicKey;
+    ammVaultA?: PublicKey;
+    ammVaultB?: PublicKey;
+    ammConfig?: PublicKey;
+};
+export type InstructionBundle = {
+    instructions: TransactionInstruction[];
+    signers?: Signer[];
+};
+export type CreatePoolInstructionResult = InstructionBundle & {
+    pool: PublicKey;
+    vaultA: PublicKey;
+    vaultB: PublicKey;
+};
+export type CreatePairInstructionResult = InstructionBundle & {
+    pair: PublicKey;
+    vaultA: PublicKey;
+    vaultB: PublicKey;
+};
+export type SwapInstructionResult = InstructionBundle & {
+    userTokenAccountA: PublicKey;
+    userTokenAccountB: PublicKey;
+};
+export type CreatePoolWithDevBuyInstructionResult = InstructionBundle & {
+    pool: PublicKey;
+    vaultA: PublicKey;
+    vaultB: PublicKey;
+    userTokenAccountA: PublicKey;
+    userTokenAccountB: PublicKey;
+};
+export type CreatePairWithDevBuyInstructionResult = InstructionBundle & {
+    pair: PublicKey;
+    vaultA: PublicKey;
+    vaultB: PublicKey;
+    userTokenAccountA: PublicKey;
+    userTokenAccountB: PublicKey;
+};
+export type EstimateResult = {
+    newReservesA: BN;
+    newReservesB: BN;
+    amountA: BN;
+    amountB: BN;
+    feeA: BN;
+};

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/utils.d.ts

@@ -0,0 +1,20 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction } from "@solana/web3.js";
+export declare const BPF_LOADER_UPGRADEABLE_PROGRAM_ID: PublicKey;
+export declare const getProgramDataAddress: (programId: PublicKey) => PublicKey;
+export declare const getPoolAddress: (programId: PublicKey, owner: PublicKey, mintA: PublicKey, mintB: PublicKey) => PublicKey;
+export declare const getVaultAddress: (programId: PublicKey, pool: PublicKey, mint: PublicKey) => PublicKey;
+export declare const getPairAddress: (programId: PublicKey, mintA: PublicKey, mintB: PublicKey) => PublicKey;
+export declare const getConfigAddress: (programId: PublicKey) => PublicKey;
+export declare const toBN: (value: BN | number) => any;
+export declare const getTokenProgramForMint: (connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<any>;
+}, mint: PublicKey) => Promise<PublicKey>;
+export declare const getAta: (mint: PublicKey, owner: PublicKey, tokenProgramId: PublicKey, allowOffCurve?: boolean) => PublicKey;
+export declare const maybeCreateAtaInstruction: (connection: {
+    getAccountInfo: (pubkey: PublicKey) => Promise<any>;
+}, payer: PublicKey, owner: PublicKey, mint: PublicKey, tokenProgramId: PublicKey, allowOffCurve?: boolean) => Promise<{
+    ata: PublicKey;
+    instruction?: TransactionInstruction;
+}>;
+export declare const transferSolInstruction: (from: PublicKey, to: PublicKey, lamports: number | BN) => TransactionInstruction;