@hubbleprotocol/farms-sdk/dist/utils/operations.js

Farms SDK

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.initializeGlobalConfig = initializeGlobalConfig;
exports.updateGlobalConfig = updateGlobalConfig;
exports.updateGlobalConfigAdmin = updateGlobalConfigAdmin;
exports.updateFarmAdmin = updateFarmAdmin;
exports.initializeFarm = initializeFarm;
exports.initializeReward = initializeReward;
exports.addReward = addReward;
exports.withdrawReward = withdrawReward;
exports.updateFarmConfig = updateFarmConfig;
exports.refreshFarm = refreshFarm;
exports.initializeUser = initializeUser;
exports.transferOwnership = transferOwnership;
exports.stake = stake;
exports.unstake = unstake;
exports.harvestReward = harvestReward;
exports.withdrawTreasury = withdrawTreasury;
exports.refreshUserState = refreshUserState;
exports.withdrawUnstakedDeposit = withdrawUnstakedDeposit;
exports.withdrawFromFarmVault = withdrawFromFarmVault;
exports.depositToFarmVault = depositToFarmVault;
exports.serializeConfigValue = serializeConfigValue;
exports.serializeRewardCurvePoint = serializeRewardCurvePoint;
const Instructions = __importStar(require("../rpc_client/instructions"));
const anchor = __importStar(require("@coral-xyz/anchor"));
const utils_1 = require("./utils");
const spl_token_1 = require("@solana/spl-token");
const types_1 = require("../rpc_client/types");
function initializeGlobalConfig(globalAdmin, globalConfig, treasuryVaultAuthority) {
    let accounts = {
        globalAdmin,
        globalConfig: globalConfig,
        treasuryVaultsAuthority: treasuryVaultAuthority,
        systemProgram: anchor.web3.SystemProgram.programId,
    };
    let ix = Instructions.initializeGlobalConfig(accounts);
    return ix;
}
function updateGlobalConfig(globalAdmin, globalConfig, mode, flagValue, flagValueType) {
    let formattedValue = (0, utils_1.getGlobalConfigValue)(flagValueType, flagValue);
    let accounts = {
        globalAdmin,
        globalConfig: globalConfig,
    };
    let args = {
        mode: mode.discriminator,
        value: formattedValue,
    };
    let ix = Instructions.updateGlobalConfig(args, accounts);
    return ix;
}
function updateGlobalConfigAdmin(pendingGlobalAdmin, globalConfig) {
    let accounts = {
        pendingGlobalAdmin,
        globalConfig: globalConfig,
    };
    let ix = Instructions.updateGlobalConfigAdmin(accounts);
    return ix;
}
function updateFarmAdmin(pendingFarmAdmin, farm) {
    let accounts = {
        pendingFarmAdmin,
        farmState: farm,
    };
    let ix = Instructions.updateFarmAdmin(accounts);
    return ix;
}
function initializeFarm(globalConfig, farmAdmin, farmState, farmVault, farmVaultAuthority, tokenMint) {
    let accounts = {
        farmAdmin,
        farmState: farmState,
        globalConfig: globalConfig,
        farmVault: farmVault,
        farmVaultsAuthority: farmVaultAuthority,
        tokenMint: tokenMint,
        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
        systemProgram: anchor.web3.SystemProgram.programId,
        rent: anchor.web3.SYSVAR_RENT_PUBKEY,
    };
    let ix = Instructions.initializeFarm(accounts);
    return ix;
}
function initializeReward(globalConfig, treasuryVaultAuthority, treasuryVault, farmAdmin, farmState, rewardVault, farmVaultAuthority, rewardMint, tokenProgram) {
    let accounts = {
        farmAdmin,
        farmState: farmState,
        globalConfig: globalConfig,
        rewardVault: rewardVault,
        farmVaultsAuthority: farmVaultAuthority,
        treasuryVaultsAuthority: treasuryVaultAuthority,
        rewardTreasuryVault: treasuryVault,
        rewardMint: rewardMint,
        tokenProgram,
        systemProgram: anchor.web3.SystemProgram.programId,
        rent: anchor.web3.SYSVAR_RENT_PUBKEY,
    };
    let ix = Instructions.initializeReward(accounts);
    return ix;
}
function addReward(payer, farmState, rewardVault, farmVaultAuthority, payerRewardAta, rewardMint, scopePrices, rewardIndex, tokenProgram, amount) {
    let accounts = {
        payer,
        farmState: farmState,
        rewardVault: rewardVault,
        farmVaultsAuthority: farmVaultAuthority,
        payerRewardTokenAta: payerRewardAta,
        rewardMint: rewardMint,
        tokenProgram,
        scopePrices,
    };
    let args = {
        amount: amount,
        rewardIndex: new anchor.BN(rewardIndex),
    };
    let ix = Instructions.addRewards(args, accounts);
    return ix;
}
function withdrawReward(admin, farmState, rewardMint, rewardVault, farmVaultAuthority, adminRewardAta, scopePrices, tokenProgram, rewardIndex, amount) {
    let accounts = {
        farmAdmin: admin,
        farmState: farmState,
        rewardVault: rewardVault,
        rewardMint,
        farmVaultsAuthority: farmVaultAuthority,
        adminRewardTokenAta: adminRewardAta,
        tokenProgram,
        scopePrices,
    };
    let args = {
        amount: amount,
        rewardIndex: new anchor.BN(rewardIndex),
    };
    let ix = Instructions.withdrawReward(args, accounts);
    return ix;
}
function updateFarmConfig(farmAdmin, farmState, scopePrices, rewardIndex, mode, value) {
    let accounts = {
        farmAdmin,
        farmState: farmState,
        scopePrices,
    };
    let data = new Uint8Array();
    let buffer;
    switch (mode.discriminator) {
        case types_1.FarmConfigOption.LockingStartTimestamp.discriminator:
        case types_1.FarmConfigOption.LockingDuration.discriminator:
        case types_1.FarmConfigOption.DepositCapAmount.discriminator:
        case types_1.FarmConfigOption.LockingEarlyWithdrawalPenaltyBps.discriminator:
        case types_1.FarmConfigOption.LockingMode.discriminator:
        case types_1.FarmConfigOption.ScopeOracleMaxAge.discriminator:
            buffer = Buffer.alloc(8);
            buffer.writeBigUint64LE(BigInt(value), 0);
            data = Uint8Array.from(buffer);
            break;
        case types_1.FarmConfigOption.DepositWarmupPeriod.discriminator:
        case types_1.FarmConfigOption.WithdrawCooldownPeriod.discriminator:
            buffer = Buffer.alloc(4);
            buffer.writeInt32LE(value, 0);
            data = Uint8Array.from(buffer);
            break;
        case types_1.FarmConfigOption.ScopeOraclePriceId.discriminator:
            buffer = Buffer.alloc(2);
            buffer.writeUInt16LE(value, 0);
            data = Uint8Array.from(buffer);
            break;
        case types_1.FarmConfigOption.UpdateStrategyId.discriminator:
        case types_1.FarmConfigOption.UpdatePendingFarmAdmin.discriminator:
        case types_1.FarmConfigOption.ScopePricesAccount.discriminator:
        case types_1.FarmConfigOption.SlashedAmountSpillAddress.discriminator:
        case types_1.FarmConfigOption.WithdrawAuthority.discriminator:
            data = value.toBytes();
            break;
        case types_1.FarmConfigOption.UpdateRewardScheduleCurvePoints.discriminator:
            let points = value;
            data = serializeRewardCurvePoint(rewardIndex, points);
            break;
        default:
            data = serializeConfigValue(BigInt(rewardIndex), BigInt(value));
            break;
    }
    let args = {
        mode: mode.discriminator,
        data,
    };
    let ix = Instructions.updateFarmConfig(args, accounts);
    return ix;
}
function refreshFarm(farmState, scopePrices) {
    let accounts = {
        farmState: farmState,
        scopePrices,
    };
    let ix = Instructions.refreshFarm(accounts);
    return ix;
}
function initializeUser(farmState, owner, userState) {
    let accounts = {
        authority: owner,
        payer: owner,
        delegatee: owner,
        owner,
        userState: userState,
        farmState: farmState,
        systemProgram: anchor.web3.SystemProgram.programId,
        rent: anchor.web3.SYSVAR_RENT_PUBKEY,
    };
    let ix = Instructions.initializeUser(accounts);
    return ix;
}
function transferOwnership(owner, userState, newOwner) {
    let accounts = {
        owner: owner,
        userState: userState,
    };
    let args = {
        newOwner,
    };
    let ix = Instructions.transferOwnership(args, accounts);
    return ix;
}
function stake(owner, userState, ownerTokenAta, farmState, farmVault, tokenMint, scopePrices, amount) {
    let accounts = {
        owner: owner,
        userState: userState,
        farmState: farmState,
        farmVault: farmVault,
        userAta: ownerTokenAta,
        tokenMint: tokenMint,
        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
        scopePrices,
    };
    let args = {
        amount,
    };
    let ix = Instructions.stake(args, accounts);
    return ix;
}
function unstake(owner, userState, farmState, scopePrices, amount) {
    let accounts = {
        owner: owner,
        userState: userState,
        farmState: farmState,
        scopePrices,
    };
    let args = {
        stakeSharesScaled: amount,
    };
    let ix = Instructions.unstake(args, accounts);
    return ix;
}
function harvestReward(owner, userState, userRewardAta, globalConfig, treasuryVault, farmState, rewardMint, rewardVault, farmVaultAuthority, scopePrices, tokenProgram, rewardIndex) {
    let accounts = {
        owner: owner,
        userState: userState,
        farmState: farmState,
        globalConfig: globalConfig,
        rewardMint,
        rewardsVault: rewardVault,
        rewardsTreasuryVault: treasuryVault,
        userRewardAta: userRewardAta,
        farmVaultsAuthority: farmVaultAuthority,
        tokenProgram,
        scopePrices,
    };
    let args = {
        rewardIndex: new anchor.BN(rewardIndex),
    };
    let ix = Instructions.harvestReward(args, accounts);
    return ix;
}
function withdrawTreasury(globalAdmin, globalConfig, treasuryVault, treasuryVaultAuthority, globalAdminWithdrawAta, amount, rewardMint) {
    let accounts = {
        globalAdmin,
        globalConfig: globalConfig,
        rewardTreasuryVault: treasuryVault,
        treasuryVaultAuthority: treasuryVaultAuthority,
        withdrawDestinationTokenAccount: globalAdminWithdrawAta,
        rewardMint: rewardMint,
        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
    };
    let args = {
        amount,
    };
    let ix = Instructions.withdrawTreasury(args, accounts);
    return ix;
}
function refreshUserState(userState, farmState, scopePrices) {
    let accounts = {
        userState,
        farmState,
        scopePrices,
    };
    let ix = Instructions.refreshUserState(accounts);
    return ix;
}
function withdrawUnstakedDeposit(owner, userState, farmState, userAta, farmVault, farmVaultsAuthority) {
    let accounts = {
        owner,
        userState,
        farmState,
        userAta,
        farmVault,
        farmVaultsAuthority,
        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
    };
    let ix = Instructions.withdrawUnstakedDeposits(accounts);
    return ix;
}
function withdrawFromFarmVault(withdrawAuthority, farmState, withdrawerTokenAccount, farmVault, farmVaultsAuthority, amount) {
    let accounts = {
        farmState,
        withdrawAuthority,
        withdrawerTokenAccount,
        farmVault,
        farmVaultsAuthority,
        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
    };
    let args = {
        amount,
    };
    let ix = Instructions.withdrawFromFarmVault(args, accounts);
    return ix;
}
function depositToFarmVault(depositor, farmState, farmVault, depositorAta, amount) {
    let accounts = {
        depositor,
        farmState,
        farmVault,
        depositorAta,
        tokenProgram: spl_token_1.TOKEN_PROGRAM_ID,
    };
    let args = {
        amount,
    };
    let ix = Instructions.depositToFarmVault(args, accounts);
    return ix;
}
function serializeConfigValue(reward_index, value) {
    let buffer;
    buffer = Buffer.alloc(16);
    buffer.writeBigUint64LE(reward_index, 0);
    buffer.writeBigUInt64LE(value, 8);
    return Uint8Array.from(buffer);
}
function serializeRewardCurvePoint(reward_index, points) {
    let buffer;
    buffer = Buffer.alloc(8 + 4 + 16 * points.length);
    buffer.writeBigUint64LE(BigInt(reward_index), 0);
    buffer.writeUInt32LE(points.length, 8);
    for (let i = 0; i < points.length; i++) {
        buffer.writeBigUint64LE(BigInt(points[i].startTs), 12 + 16 * i);
        buffer.writeBigUint64LE(BigInt(points[i].rps), 20 + 16 * i);
    }
    return Uint8Array.from(buffer);
}
//# sourceMappingURL=operations.js.map