@marinade.finance/kamino-sdk/dist/utils/utils.js

Kamino SDK

"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.isVaultInitialized = exports.rebalanceFieldsDictToInfo = exports.readBigUint128LE = exports.lamportsToNumberDecimal = exports.collToLamportsDecimal = exports.getUpdateStrategyConfigIx = exports.numberToRebalanceType = exports.buildStrategyRebalanceParams = exports.getStrategyConfigValue = exports.getDexProgramId = exports.numberToDex = exports.dexToNumber = exports.Dex = exports.sleep = exports.RebalanceParamOffset = exports.ProportionalMintingMethod = exports.DolarBasedMintingMethod = void 0;
const web3_js_1 = require("@solana/web3.js");
const programId_1 = require("../whirpools-client/programId");
const programId_2 = require("../raydium_client/programId");
const decimal_js_1 = __importDefault(require("decimal.js"));
const types_1 = require("../kamino-client/types");
const instructions_1 = require("../kamino-client/instructions");
const raydium_sdk_1 = require("@raydium-io/raydium-sdk");
exports.DolarBasedMintingMethod = new decimal_js_1.default(0);
exports.ProportionalMintingMethod = new decimal_js_1.default(1);
exports.RebalanceParamOffset = new decimal_js_1.default(256);
function sleep(ms) {
    return new Promise((resolve) => setTimeout(resolve, ms));
}
exports.sleep = sleep;
exports.Dex = ['ORCA', 'RAYDIUM', 'CREMA'];
function dexToNumber(dex) {
    for (let i = 0; i < exports.Dex.length; i++) {
        if (exports.Dex[i] === dex) {
            return i;
        }
    }
    throw new Error(`Unknown DEX ${dex}`);
}
exports.dexToNumber = dexToNumber;
function numberToDex(num) {
    const dex = exports.Dex[num];
    if (!dex) {
        throw new Error(`Unknown DEX ${num}`);
    }
    return dex;
}
exports.numberToDex = numberToDex;
function getDexProgramId(strategyState) {
    if (strategyState.strategyDex.toNumber() == dexToNumber('ORCA')) {
        return programId_1.WHIRLPOOL_PROGRAM_ID;
    }
    else if (strategyState.strategyDex.toNumber() == dexToNumber('RAYDIUM')) {
        return programId_2.PROGRAM_ID;
    }
    else {
        throw Error(`Invalid DEX ${strategyState.strategyDex.toString()}`);
    }
}
exports.getDexProgramId = getDexProgramId;
function getStrategyConfigValue(value) {
    let buffer = Buffer.alloc(128);
    buffer.writeBigUInt64LE(BigInt(value.toString()));
    return [...buffer];
}
exports.getStrategyConfigValue = getStrategyConfigValue;
function buildStrategyRebalanceParams(params, rebalance_type, tokenADecimals, tokenBDecimals) {
    let buffer = Buffer.alloc(128);
    if (rebalance_type.kind == types_1.RebalanceType.Manual.kind) {
        // Manual has no params
    }
    else if (rebalance_type.kind == types_1.RebalanceType.PricePercentage.kind) {
        buffer.writeUint16LE(params[0].toNumber());
        buffer.writeUint16LE(params[1].toNumber(), 2);
    }
    else if (rebalance_type.kind == types_1.RebalanceType.PricePercentageWithReset.kind) {
        buffer.writeUint16LE(params[0].toNumber());
        buffer.writeUint16LE(params[1].toNumber(), 2);
        buffer.writeUint16LE(params[2].toNumber(), 4);
        buffer.writeUint16LE(params[3].toNumber(), 6);
    }
    else if (rebalance_type.kind == types_1.RebalanceType.Drift.kind) {
        buffer.writeInt32LE(params[0].toNumber());
        buffer.writeInt32LE(params[1].toNumber(), 4);
        buffer.writeInt32LE(params[2].toNumber(), 8);
        buffer.writeBigUint64LE(BigInt(params[3].toString()), 12);
        buffer.writeUint8(params[4].toNumber(), 20);
    }
    else if (rebalance_type.kind == types_1.RebalanceType.TakeProfit.kind) {
        const lowerPrice = raydium_sdk_1.SqrtPriceMath.priceToSqrtPriceX64(params[0], tokenADecimals, tokenBDecimals);
        const upperPrice = raydium_sdk_1.SqrtPriceMath.priceToSqrtPriceX64(params[1], tokenADecimals, tokenBDecimals);
        writeBigUint128LE(buffer, BigInt(lowerPrice.toString()), 0);
        writeBigUint128LE(buffer, BigInt(upperPrice.toString()), 16);
        buffer.writeUint8(params[2].toNumber(), 32);
    }
    else if (rebalance_type.kind == types_1.RebalanceType.PeriodicRebalance.kind) {
        buffer.writeBigUint64LE(BigInt(params[0].toString()), 0);
        buffer.writeUInt16LE(params[1].toNumber(), 8);
        buffer.writeUInt16LE(params[2].toNumber(), 10);
    }
    else if (rebalance_type.kind == types_1.RebalanceType.Expander.kind) {
        buffer.writeUInt16LE(params[0].toNumber(), 0);
        buffer.writeUInt16LE(params[1].toNumber(), 2);
        buffer.writeUInt16LE(params[2].toNumber(), 4);
        buffer.writeUInt16LE(params[3].toNumber(), 6);
        buffer.writeUInt16LE(params[4].toNumber(), 8);
        buffer.writeUInt16LE(params[5].toNumber(), 10);
        buffer.writeUInt8(params[6].toNumber(), 12);
    }
    else {
        throw 'Rebalance type not valid ' + rebalance_type;
    }
    return [...buffer];
}
exports.buildStrategyRebalanceParams = buildStrategyRebalanceParams;
function numberToRebalanceType(rebalance_type) {
    if (rebalance_type == 0) {
        return new types_1.RebalanceType.Manual();
    }
    else if (rebalance_type == 1) {
        return new types_1.RebalanceType.PricePercentage();
    }
    else if (rebalance_type == 2) {
        return new types_1.RebalanceType.PricePercentageWithReset();
    }
    else if (rebalance_type == 3) {
        return new types_1.RebalanceType.Drift();
    }
    else if (rebalance_type == 4) {
        return new types_1.RebalanceType.TakeProfit();
    }
    else if (rebalance_type == 5) {
        return new types_1.RebalanceType.PeriodicRebalance();
    }
    else if (rebalance_type == 6) {
        return new types_1.RebalanceType.Expander();
    }
    else {
        throw new Error(`Invalid rebalance type ${rebalance_type.toString()}`);
    }
}
exports.numberToRebalanceType = numberToRebalanceType;
async function getUpdateStrategyConfigIx(signer, globalConfig, strategy, mode, amount, newAccount = web3_js_1.PublicKey.default) {
    let args = {
        mode: mode.discriminator,
        value: getStrategyConfigValue(amount),
    };
    let accounts = {
        adminAuthority: signer,
        newAccount,
        globalConfig,
        strategy,
        systemProgram: web3_js_1.SystemProgram.programId,
    };
    return (0, instructions_1.updateStrategyConfig)(args, accounts);
}
exports.getUpdateStrategyConfigIx = getUpdateStrategyConfigIx;
function collToLamportsDecimal(amount, decimals) {
    let factor = new decimal_js_1.default(10).pow(decimals);
    return amount.mul(factor);
}
exports.collToLamportsDecimal = collToLamportsDecimal;
function lamportsToNumberDecimal(amount, decimals) {
    const factor = new decimal_js_1.default(10).pow(decimals);
    return new decimal_js_1.default(amount).div(factor);
}
exports.lamportsToNumberDecimal = lamportsToNumberDecimal;
function readBigUint128LE(buffer, offset) {
    return buffer.readBigUint64LE(offset) + (buffer.readBigUint64LE(offset + 8) << BigInt(64));
}
exports.readBigUint128LE = readBigUint128LE;
function writeBigUint128LE(buffer, value, offset) {
    const lower_half = value & ((BigInt(1) << BigInt(64)) - BigInt(64));
    const upper_half = value >> BigInt(64);
    buffer.writeBigUint64LE(lower_half, offset);
    buffer.writeBigUint64LE(upper_half, offset + 8);
}
function rebalanceFieldsDictToInfo(rebalanceFields) {
    let rebalanceFieldsInfo = [];
    for (let key in rebalanceFields) {
        let value = rebalanceFields[key];
        rebalanceFieldsInfo.push({
            label: key,
            type: 'number',
            value: value,
            enabled: false,
        });
    }
    return rebalanceFieldsInfo;
}
exports.rebalanceFieldsDictToInfo = rebalanceFieldsDictToInfo;
function isVaultInitialized(vault, decimals) {
    return !vault.equals(web3_js_1.PublicKey.default) && decimals.toNumber() > 0;
}
exports.isVaultInitialized = isVaultInitialized;
//# sourceMappingURL=utils.js.map