lifinity-sdk

Installation

yarn install @lifinity/sdk

Usage

• Get pools

import { getPoolList } from '@lifinity/sdks';

const pools = getPoolList();

console.log("pools =", pools);

• Get swap amount

import { Connection, PublicKey } from '@solana/web3.js';
import { getAmountOut, AmountOut } from '@lifinity/sdk';

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const amountIn: number = 1; // Input amount
const fromMint: PublicKey = new PublicKey("---Mint address of the input token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");
const slippage: number = 1; // Slippage (%)

const res : AmountOut = await getAmountOut(
    connection,
    amountIn,
    fromMint,
    toMint,
    slippage
);

console.log("amountIn: number =", res.amountIn);
console.log("amountOut: number =", res.amountOut);
console.log("amountOutWithSlippage: number =", res.amountOutWithSlippage);
console.log("priceImpact: number =", res.priceImpact);
console.log("fee: number =", res.fee);
console.log("feePercent: number =", res.feePercent);

• Breakdown of get swap amount Please use the SDK for calculating amount out (getCurveAmount) as the protocol is still in beta and the math may be updated

import { Connection, PublicKey } from '@solana/web3.js';
import BigNumber from 'bignumber.js'
import { getPool, getMultipleAccounts, getParsedData, getCurveAmount, TradeDirection } from '@lifinity/sdk'


const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const amountIn: number = 1; // Input amount
const fromMint: PublicKey = new PublicKey("---Mint address of the intput token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");
const slippage: number = 1; // Slippage (%)

const poolInfo = getPool(fromMint.toString(), toMint.toString());
if (poolInfo) {

    let amount = new BigNumber(amountIn);
    let tradeDirection: string;
    let inDecimal: number;
    let outDecimal: number;

    if (poolInfo.poolCoinMint === fromMint.toString()){
        amount = amount.multipliedBy(new BigNumber(10).pow(poolInfo.poolCoinDecimal));
        inDecimal = poolInfo.poolCoinDecimal;
        outDecimal = poolInfo.poolPcDecimal;
        tradeDirection = TradeDirection.AtoB;
    }else{
        amount = amount.multipliedBy(new BigNumber(10).pow(poolInfo.poolPcDecimal));
        inDecimal = poolInfo.poolPcDecimal;
        outDecimal = poolInfo.poolCoinDecimal
        tradeDirection = TradeDirection.BtoA;
    }

    const publicKeys = [
        new PublicKey(poolInfo.amm),
        new PublicKey(poolInfo.poolCoinTokenAccount),
        new PublicKey(poolInfo.poolPcTokenAccount),
        new PublicKey(poolInfo.configAccount),
        new PublicKey(poolInfo.pythAccount),
    ];

    if (poolInfo.pythAccount !== poolInfo.pythPcAccount){
        publicKeys.push(new PublicKey(poolInfo.pythPcAccount));
    }

    try {
        const multipleInfo = await getMultipleAccounts(connection, publicKeys);

        const data: IAmmData = getParsedData(
            multipleInfo,
            poolInfo
        );

        const slot = await connection.getSlot();

        const curveAmount: ICurveAmount = getCurveAmount(
            amount,
            slot,
            data.amm,
            data.fees,
            data.coinBalance,
            data.pcBalance,
            data.config,
            data.pyth,
            data.pythPc,
            tradeDirection,
        );
        console.log("amountSwapped: BigNumber =", curveAmount.amountSwapped);
        console.log("priceImpact: BigNumber =", curveAmount.priceImpact);
        console.log("fee: BigNumber =", curveAmount.fee);
        console.log("feePercent: BigNumber =", curveAmount.feePercent);

        const slippagePercent = new BigNumber(slippage).div(100);
        const amountOutWithSlippage = new BigNumber(Math.floor(curveAmount.amountSwapped.multipliedBy(new BigNumber(1).minus(slippagePercent)).toNumber()));
        const amountOutWithSlippageTokenAmount = amountOutWithSlippage.div(new BigNumber(10).pow(outDecimal)).toNumber();
        const amountOutTokenAmount = curveAmount.amountSwapped.div(new BigNumber(10).pow(outDecimal)).toNumber();
        const feeTokenAmount = curveAmount.fee.div(new BigNumber(10).pow(inDecimal)).toNumber();

        console.log("slippagePercent: BigNumber =", slippagePercent);
        console.log("amountOutWithSlippage: BigNumber =", amountOutWithSlippage);
        console.log("amountOutWithSlippageTokenAmount: BigNumber =", amountOutWithSlippageTokenAmount);
        console.log("amountOutTokenAmount: BigNumber =", amountOutTokenAmount);
        console.log("feeTokenAmount: BigNumber =", feeTokenAmount);

    }catch (error) {
        console.log(error)
        // Errors include failures to obtain accurate price feed from the oracle
    }
}

• Get swap instruction

import { Connection, PublicKey } from '@solana/web3.js';
import { getSwapInstruction } from '@lifinity/sdk'

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const ownerAccount: PublicKey = new PublicKey("---User's Solana address---")
const amountIn: number = 1; // Input amount
const minimumOut: number = 100; // Output amount
const fromMint: PublicKey = new PublicKey("---Mint address of the input token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");
const fromUserAccount: PublicKey = new PublicKey("---User's input token account---");
const toUserAccount: PublicKey = new PublicKey("---User's output token account---");
const approve = true; // Set false to skip approve instruction

const { approveInstruction, swapInstruction, signers } = await getSwapInstruction(
    connection,
    ownerAccount,
    amountIn, 
    minimumOut,
    fromMint,
    toMint,
    fromUserAccount,
    toUserAccount,
    approve,
);

console.log("approveInstruction: TransactionInstruction =", approveInstruction);
console.log("swapInstruction: TransactionInstruction =", swapInstruction);
console.log("signers: any[] =", signers);

• Swap

import { Lifinity } from '@lifinity/sdk'

const connection: Connection = new Connection("https://api.mainnet-beta.solana.com");
const wallet: any = "---User wallet---"
const amountIn: number = 1; // Input amount
const minimumOut: number = 100; // Output amount
const fromMint: PublicKey = new PublicKey("---Mint address of the input token---");
const toMint: PublicKey = new PublicKey("---Mint address of the output token---");

const lifinitySdk = await Lifinity.build(
    connection,
    wallet
);

const transactionId: string = await lifinitySdk.swap(
    amountIn,
    minimumOut,
    fromMint,
    toMint
);

console.log("transactionId: string =",transactionId)

Copyright © 2022 LIFINITY FOUNDATION All Rights Reserved.