goosefx-ssl-sdk/dist/public/ssl.js

SDK for interacting with GooseFX Single-sided Liquidity pools

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.SSL = void 0;
const anchor_1 = require("@project-serum/anchor");
const spl_token_1 = require("@solana/spl-token");
const web3_js_1 = require("@solana/web3.js");
const constants_1 = require("../constants");
const layouts_1 = require("../layouts");
const utils_1 = require("./utils");
class SSL {
    constructor(ai, programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        this.inner = layouts_1.SSL_LAYOUT.decode(ai.data);
        this.address = SSL.findAddress(this.controller, this.mint, programId);
    }
    static async loadByMint(connection, controller, mint, programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        return await SSL.loadByAddress(connection, SSL.findAddress(controller, mint, programId));
    }
    static async loadByAddress(connection, address, programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        let ai = (await connection.getAccountInfo(address));
        if (ai === undefined) {
            return undefined;
        }
        let ssl = new SSL(ai, programId);
        return ssl;
    }
    static async liabilityVault(connection, controller, mint, otherMint, programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        if (otherMint === undefined) {
            otherMint = mint;
        }
        let address = (0, utils_1.findAssociatedTokenAddress)(SSL.findAddress(controller, mint, programId), otherMint);
        let account = await (0, spl_token_1.getAccount)(connection, address);
        return account;
    }
    static findAddress(controller, mint, programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        return web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from("GFX-SSL", "utf-8"),
            controller.toBuffer(),
            mint.toBuffer(),
        ], programId)[0];
    }
    ;
    isSuspended() {
        return this.inner.suspended;
    }
    async deposit(program, controller, wallet, amount, programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        const inst = program.instruction;
        const accounts = {
            controller,
            ssl: this.address,
            liquidityAccount: SSL.getLiquidityAccountAddress(controller, this.mint, wallet, programId),
            rtVault: (0, utils_1.findAssociatedTokenAddress)(this.address, this.mint),
            userRtAta: (0, utils_1.findAssociatedTokenAddress)(wallet, this.mint),
            userWallet: wallet,
            tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
        };
        return await inst.deposit(new anchor_1.BN(amount.toString()), { accounts });
    }
    static getLiquidityAccountAddress(controller, mint, wallet, programId) {
        return web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from("GFX-LIQUIDITYACCOUNT", "utf-8"),
            controller.toBuffer(),
            mint.toBuffer(),
            wallet.toBuffer()
        ], programId)[0];
    }
    get controller() {
        return this.inner.controller;
    }
    get mint() {
        return this.inner.mint;
    }
    get decimals() {
        return this.inner.decimals;
    }
    poolTokenMint(programId = constants_1.ADDRESSES["MAINNET"].SSL_PROGRAM_ID) {
        return web3_js_1.PublicKey.findProgramAddressSync([
            Buffer.from("GFX-SSL-PTMINT", "utf-8"),
            this.controller.toBuffer(),
            this.mint.toBuffer(),
        ], programId)[0];
    }
    get suspended() {
        return this.inner.suspended;
    }
    get weight() {
        return this.inner.weight;
    }
    get swappedLiabilityNative() {
        return this.inner.swappedLiabilityNative;
    }
    get totalShare() {
        return this.inner.totalShare;
    }
}
exports.SSL = SSL;
//# sourceMappingURL=ssl.js.map