@mihalex/farms-sdk-tests
Version:
625 lines • 30.4 kB
JavaScript
"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;
};
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.getCurrentRps = exports.getCurrentTimeUnit = exports.Farms = exports.farmsId = void 0;
const anchor_1 = require("@coral-xyz/anchor");
const farms_json_1 = __importDefault(require("./rpc_client/farms.json"));
const web3_js_1 = require("@solana/web3.js");
const utils_1 = require("./utils");
const utils_2 = require("./utils");
const accounts_1 = require("./rpc_client/accounts");
const accounts_2 = require("./rpc_client/accounts");
const farmOperations = __importStar(require("./utils/operations"));
const decimal_js_1 = __importDefault(require("decimal.js"));
const index_1 = require("./rpc_client/types/index");
exports.farmsId = new web3_js_1.PublicKey("FarmsPZpWu9i7Kky8tPN37rs2TpmMrAZrC7S7vJa91Hr");
class Farms {
_connection;
_provider;
_farmsProgram;
_farmsProgramId;
constructor(connection) {
this._connection = connection;
this._provider = new anchor_1.AnchorProvider(connection, (0, utils_1.getReadOnlyWallet)(), {
commitment: connection.commitment,
});
this._farmsProgramId = exports.farmsId;
this._farmsProgram = new anchor_1.Program(farms_json_1.default, this._farmsProgramId, this._provider);
}
getConnection() {
return this._connection;
}
getProgramID() {
return this._farmsProgramId;
}
getProgram() {
return this._farmsProgram;
}
async getAllUserStatesForUser(user) {
let filters = [];
filters.push({
memcmp: {
bytes: user.toBase58(),
offset: 48,
},
});
filters.push({
dataSize: accounts_1.UserState.layout.span + 8,
});
const userStates = (await this._farmsProgram.account.userState.all(filters)).map((x) => {
let res = {
userState: new accounts_1.UserState(x.account),
key: x.publicKey,
};
return res;
});
return userStates;
}
async getAllUserStates() {
return (await this._farmsProgram.account.userState.all([
{
dataSize: accounts_1.UserState.layout.span + 8,
},
])).map((x) => {
const userAndKey = {
userState: new accounts_1.UserState(x.account),
key: x.publicKey,
};
return userAndKey;
});
}
async getFarmsForMint(mint) {
let filters = [];
filters.push({
memcmp: {
bytes: mint.toBase58(),
offset: 72,
},
});
filters.push({
dataSize: accounts_2.FarmState.layout.span + 8,
});
const farms = (await this._farmsProgram.account.farmState.all(filters)).map((x) => {
let res = {
farmState: new accounts_2.FarmState(x.account),
key: x.publicKey,
};
return res;
});
return farms;
}
async getAllFarmStates() {
return (await this._farmsProgram.account.farmState.all([
{
dataSize: accounts_2.FarmState.layout.span + 8,
},
])).map((x) => {
const farmAndKey = {
farmState: new accounts_2.FarmState(x.account),
key: x.publicKey,
};
return farmAndKey;
});
}
async getAllFarmStatesByPubkeys(keys) {
return (await this._farmsProgram.account.farmState.all([
{
dataSize: accounts_2.FarmState.layout.span + 8,
},
]))
.filter((x) => {
return keys.includes(x.publicKey.toString());
})
.map((x) => {
const farmState = new accounts_2.FarmState(x.account);
return {
farmState,
key: x.publicKey,
};
});
}
async getStakedAmountForMintForFarm(mint, farm) {
const farms = await this.getFarmsForMint(mint);
for (let index = 0; index < farms.length; index++) {
if (farms[index].key.toString() === farm.toString()) {
return (0, utils_2.lamportsToCollDecimal)(new decimal_js_1.default((0, utils_2.scaleDownWads)(farms[index].farmState.totalActiveStakeScaled)), farms[index].farmState.token.decimals.toNumber());
}
}
throw Error("No Farm found");
}
async getStakedAmountForMint(mint) {
const farms = await this.getFarmsForMint(mint);
let totalStaked = new decimal_js_1.default(0);
for (let index = 0; index < farms.length; index++) {
totalStaked = totalStaked.add((0, utils_2.lamportsToCollDecimal)(new decimal_js_1.default(farms[index].farmState.totalStakedAmount.toString()), farms[index].farmState.token.decimals.toNumber()));
}
return totalStaked;
}
async getUserStateKeyForUserForFarm(user, farm) {
const userStates = await this.getAllUserStatesForUser(user);
const userStateKeysForFarm = [];
for (let index = 0; index < userStates.length; index++) {
if (userStates[index].userState.farmState.toString() === farm.toString()) {
userStateKeysForFarm.push(userStates[index].key);
}
}
if (userStateKeysForFarm.length === 0) {
throw Error("No user state found for user " + user + " for farm " + farm);
}
else {
return userStateKeysForFarm;
}
}
async getAllFarmsForUser(user) {
const userStates = await this.getAllUserStatesForUser(user);
const farmPks = new Array();
for (let i = 0; i < userStates.length; i++) {
farmPks[i] = userStates[i].userState.farmState.toString();
}
const farmStates = await this.getAllFarmStatesByPubkeys(farmPks);
if (!farmStates) {
throw new Error("Error fetching farms");
}
if (farmStates.length === 0) {
// Return empty if no serializable farm states found
return new Map();
}
const timestamp = new decimal_js_1.default((await this._connection.getBlockTime(await this._connection.getSlot())));
const userFarms = new Map();
for (let userState of userStates) {
const userPendingRewardAmounts = [];
let farmState = farmStates.find((farmState) => farmState.key.toString() === userState.userState.farmState.toString());
if (!farmState) {
// Skip farms that are not serializable anymore
continue;
}
let hasReward = false;
// calculate userState pending rewards
for (let indexReward = 0; indexReward < farmState.farmState.rewardInfos.length; indexReward++) {
userPendingRewardAmounts[indexReward] = (0, utils_1.calculatePendingRewards)(farmState.farmState, userState.userState, indexReward, timestamp);
if (userPendingRewardAmounts[indexReward].gt(0)) {
hasReward = true;
}
}
// add new userFarm state if non empty (has rewards or stake) and not already present
if (!userFarms.has(userState.userState.farmState.toString())) {
const userFarm = {
farm: userState.userState.farmState,
stakedToken: farmState.farmState.token.mint,
activeStakeByDelegatee: new Map(),
pendingDepositStakeByDelegatee: new Map(),
pendingWithdrawalUnstakeByDelegatee: new Map(),
pendingRewards: new Array(farmState.farmState.rewardInfos.length)
.fill(undefined)
.map(function () {
return {
rewardTokenMint: new web3_js_1.PublicKey(0),
cumulatedPendingRewards: new decimal_js_1.default(0),
pendingRewardsByDelegatee: new Map(),
};
}),
};
if (new decimal_js_1.default((0, utils_2.scaleDownWads)(userState.userState.activeStakeScaled)).gt(0) ||
hasReward) {
userFarms.set(userState.userState.farmState.toString(), userFarm);
}
else {
// skip as we are not accounting for empty userFarms
continue;
}
}
// add new userFarm state if non empty (has rewards or stake) and not already present
const refUserFarm = Object.fromEntries(userFarms)[userState.userState.farmState.toString()];
if (!refUserFarm) {
throw new Error("User farm state not loaded properly ");
}
const updatedUserFarm = { ...refUserFarm };
if (userState.userState.delegatee.toString() in
updatedUserFarm.activeStakeByDelegatee) {
console.error("Delegatee for user for farm already present. There should be only one delegatee for this user for this farm");
continue;
}
// active stake by delegatee
updatedUserFarm.activeStakeByDelegatee.set(userState.userState.delegatee.toString(), (0, utils_2.lamportsToCollDecimal)(new decimal_js_1.default((0, utils_2.scaleDownWads)(userState.userState.activeStakeScaled)), farmState.farmState.token.decimals.toNumber()));
// pendingDepositStake by delegatee
updatedUserFarm.pendingDepositStakeByDelegatee.set(userState.userState.delegatee.toString(), new decimal_js_1.default((0, utils_2.scaleDownWads)(userState.userState.pendingDepositStakeScaled)));
// pendingWithdrawalUnstake by delegatee
updatedUserFarm.pendingWithdrawalUnstakeByDelegatee.set(userState.userState.delegatee.toString(), new decimal_js_1.default((0, utils_2.scaleDownWads)(userState.userState.pendingWithdrawalUnstakeScaled)));
// cummulating rewards
for (let indexReward = 0; indexReward < farmState.farmState.rewardInfos.length; indexReward++) {
updatedUserFarm.pendingRewards[indexReward].rewardTokenMint =
farmState.farmState.rewardInfos[indexReward].token.mint;
updatedUserFarm.pendingRewards[indexReward].cumulatedPendingRewards =
updatedUserFarm.pendingRewards[indexReward].cumulatedPendingRewards.add(userPendingRewardAmounts[indexReward]);
updatedUserFarm.pendingRewards[indexReward].pendingRewardsByDelegatee.set(userState.userState.delegatee.toString(), userPendingRewardAmounts[indexReward]);
}
// set updated userFarm
userFarms.set(userState.userState.farmState.toString(), updatedUserFarm);
}
return userFarms;
}
async executeTransaction(ix, signer, extraSigners = []) {
const tx = new web3_js_1.Transaction();
let { blockhash } = await this._connection.getLatestBlockhash();
tx.recentBlockhash = blockhash;
tx.feePayer = signer.publicKey;
tx.add(...ix);
let sig = await (0, web3_js_1.sendAndConfirmTransaction)(this._connection, tx, [signer, ...extraSigners], { skipPreflight: true, commitment: "confirmed" });
return sig;
}
async createNewUserIx(user, farm) {
const userState = (0, utils_2.getUserStatePDA)(this._farmsProgramId, farm, user);
const ix = farmOperations.initializeUser(farm, user, userState);
return ix;
}
async createNewUser(user, farm) {
const ix = await this.createNewUserIx(user.publicKey, farm);
let sig = await this.executeTransaction([ix], user);
const userState = (0, utils_2.getUserStatePDA)(this._farmsProgramId, farm, user.publicKey);
if (process.env.DEBUG === "true") {
console.log("Initialize User: " + userState);
console.log("Refresh Farm txn: " + sig.toString());
}
return sig;
}
async stakeIx(user, farm, amountLamports, stakeTokenMint) {
const farmVault = (0, utils_2.getFarmVaultPDA)(this._farmsProgramId, farm, stakeTokenMint);
const userStatePk = await (0, utils_2.getUserStatePDA)(this._farmsProgramId, farm, user);
const userTokenAta = await (0, utils_2.getAssociatedTokenAddress)(user, stakeTokenMint);
const ix = farmOperations.stake(user, userStatePk, userTokenAta, farm, farmVault, stakeTokenMint, new anchor_1.BN(amountLamports.toString()));
return ix;
}
async stake(user, farm, amountLamports, stakeTokenMint) {
const ix = await this.stakeIx(user.publicKey, farm, amountLamports, stakeTokenMint);
let increaseComputeIx = (0, utils_2.createAddExtraComputeUnitsTransaction)(user.publicKey, 400000);
let sig = await this.executeTransaction([increaseComputeIx, ix], user);
if (process.env.DEBUG === "true") {
console.log("User " + " stake " + amountLamports);
console.log("Stake txn: " + sig.toString());
}
return sig;
}
async unstakeIx(user, farm, amountLamports) {
const userStatePk = (0, utils_2.getUserStatePDA)(this._farmsProgramId, farm, user);
const ix = farmOperations.unstake(user, userStatePk, farm, new anchor_1.BN(amountLamports));
return ix;
}
async unstake(user, farm, sharesAmount) {
const ix = await this.unstakeIx(user.publicKey, farm, sharesAmount);
let sig = await this.executeTransaction([ix], user);
if (process.env.DEBUG === "true") {
console.log("Unstake " + sharesAmount);
console.log("Unstake txn: " + sig.toString());
}
return sig;
}
async withdrawUnstakedDepositIx(user, userState, farmState, stakeTokenMint) {
const userTokenAta = await (0, utils_2.getAssociatedTokenAddress)(user, stakeTokenMint);
const farmVault = (0, utils_2.getFarmVaultPDA)(this._farmsProgramId, farmState, stakeTokenMint);
const farmVaultsAuthority = (0, utils_2.getFarmAuthorityPDA)(this._farmsProgramId, farmState);
const ix = farmOperations.withdrawUnstakedDeposit(user, userState, farmState, userTokenAta, farmVault, farmVaultsAuthority);
return ix;
}
async withdrawUnstakedDeposit(user, farmState, tokenMint, userState) {
const ix = await this.withdrawUnstakedDepositIx(user.publicKey, userState, farmState, tokenMint);
let sig = await this.executeTransaction([ix], user);
if (process.env.DEBUG === "true") {
console.log("User " + userState + " withdraw unstaked deposit ");
console.log("Withdraw Unstaked Deposit txn: " + sig.toString());
}
return sig;
}
async claimForUserForFarmRewardIx(user, farm, rewardMint, rewardIndex = -1) {
const userStatePks = await this.getUserStateKeyForUserForFarm(user, farm);
const farmState = await accounts_2.FarmState.fetch(this._connection, farm);
if (!farmState) {
throw new Error(`Farm not found ${farm.toString()}`);
}
const userRewardAta = await (0, utils_2.getAssociatedTokenAddress)(user, rewardMint);
const treasuryVault = (0, utils_2.getTreasuryVaultPDA)(this._farmsProgramId, farmState.globalConfig, rewardMint);
// find rewardIndex if not defined
if (rewardIndex === -1) {
for (let i = 0; farmState.rewardInfos.length; i++) {
if (farmState.rewardInfos[i].token.mint.toString() ==
rewardMint.toString()) {
rewardIndex = i;
break;
}
}
}
const ixns = [];
for (let userStateIndex = 0; userStateIndex < userStatePks.length; userStateIndex++) {
const ix = farmOperations.harvestReward(user, userStatePks[userStateIndex], userRewardAta, farmState.globalConfig, treasuryVault, farm, farmState.rewardInfos[rewardIndex].rewardsVault, farmState.farmVaultsAuthority, rewardIndex);
ixns.push(ix);
}
return ixns;
}
async claimForUserForFarmReward(user, farm, rewardMint, rewardIndex = -1) {
const ixns = await this.claimForUserForFarmRewardIx(user.publicKey, farm, rewardMint, rewardIndex);
let sig = await this.executeTransaction(ixns, user);
if (process.env.DEBUG === "true") {
console.log("Harvest reward " + rewardIndex);
console.log("HarvestReward txn: " + sig.toString());
}
return sig;
}
async claimForUserForFarmAllRewardsIx(user, farm) {
const farmState = await accounts_2.FarmState.fetch(this._connection, farm);
const userStatePks = await this.getUserStateKeyForUserForFarm(user, farm);
const ixs = new Array();
if (!farmState) {
throw new Error(`Farm not found ${farm.toString()}`);
}
for (let userStateIndex = 0; userStateIndex < userStatePks.length; userStateIndex++) {
for (let rewardIndex = 0; rewardIndex < farmState.numRewardTokens.toNumber(); rewardIndex++) {
const userRewardAta = await (0, utils_2.getAssociatedTokenAddress)(user, farmState.rewardInfos[rewardIndex].token.mint);
const treasuryVault = (0, utils_2.getTreasuryVaultPDA)(this._farmsProgramId, farmState.globalConfig, farmState.rewardInfos[rewardIndex].token.mint);
ixs.push(farmOperations.harvestReward(user, userStatePks[userStateIndex], userRewardAta, farmState.globalConfig, treasuryVault, farm, farmState.rewardInfos[rewardIndex].rewardsVault, farmState.farmVaultsAuthority, rewardIndex));
}
}
return ixs;
}
async claimForUserForFarmAllRewards(user, farm) {
const ixs = await this.claimForUserForFarmAllRewardsIx(user.publicKey, farm);
const sigs = new Array();
for (let i = 0; i < ixs.length; i++) {
sigs[i] = await this.executeTransaction([ixs[i]], user);
}
return sigs;
}
async transferOwnershipIx(user, userState, newUser) {
const ix = farmOperations.transferOwnership(user, userState, newUser);
return ix;
}
async transferOwnership(user, userState, newUser) {
const ix = await this.transferOwnershipIx(user.publicKey, userState, newUser);
let sig = await this.executeTransaction([ix], user);
if (process.env.DEBUG === "true") {
console.log("Transfer User " +
userState +
" ownership from " +
user.publicKey +
" to " +
newUser);
console.log("Transfer User Ownership txn: " + sig.toString());
}
return sig;
}
async transferOwnershipAllUserStatesIx(user, newUser) {
const userStates = await this.getAllUserStatesForUser(user);
const ixs = new Array();
for (let index = 0; index < userStates.length; index++) {
ixs[index] = farmOperations.transferOwnership(user, userStates[index].key, newUser);
}
return ixs;
}
async transferOwnershipAllUserStates(user, newUser) {
const ixs = await this.transferOwnershipAllUserStatesIx(user.publicKey, newUser);
const sigs = new Array();
for (let i = 0; i < ixs.length; i++) {
sigs[i] = await this.executeTransaction([ixs[i]], user);
}
return sigs;
}
async createFarmIx(admin, farm, globalConfig, stakeTokenMint) {
const farmVault = (0, utils_2.getFarmVaultPDA)(this._farmsProgramId, farm.publicKey, stakeTokenMint);
const farmVaultAuthority = (0, utils_2.getFarmAuthorityPDA)(this._farmsProgramId, farm.publicKey);
let ixs = [];
ixs.push(await (0, utils_2.createKeypairRentExemptIx)(this._provider.connection, admin, farm, utils_1.SIZE_FARM_STATE, this._farmsProgramId));
ixs.push(farmOperations.initializeFarm(globalConfig, admin, farm.publicKey, farmVault, farmVaultAuthority, stakeTokenMint));
return ixs;
}
async createFarm(admin, globalConfig, farm, mint) {
const ix = await this.createFarmIx(admin.publicKey, farm, globalConfig, mint);
let sig = await this.executeTransaction(ix, admin, [farm]);
if (process.env.DEBUG === "true") {
console.log("Initialize Farm: " + farm.toString());
console.log("Initialize Farm txn: " + sig.toString());
}
return sig;
}
async addRewardToFarmIx(admin, globalConfig, farm, mint) {
const globalConfigState = await accounts_2.GlobalConfig.fetch(this._connection, globalConfig);
if (!globalConfigState) {
throw new Error("Could not fetch global config");
}
const treasuryVault = (0, utils_2.getTreasuryVaultPDA)(this._farmsProgramId, globalConfig, mint);
const farmState = await accounts_2.FarmState.fetch(this._connection, farm);
if (!farmState) {
throw new Error(`Could not fetch farm state ${farm.toBase58()}`);
}
const rewardVault = (0, utils_2.getRewardVaultPDA)(this._farmsProgramId, farm, mint);
const ix = farmOperations.initializeReward(globalConfig, globalConfigState.treasuryVaultsAuthority, treasuryVault, admin, farm, rewardVault, farmState.farmVaultsAuthority, mint);
return ix;
}
async addRewardToFarm(admin, globalConfig, farm, mint) {
const ix = await this.addRewardToFarmIx(admin.publicKey, globalConfig, farm, mint);
let sig = await this.executeTransaction([ix], admin);
if (process.env.DEBUG === "true") {
console.log("Initialize Reward: " + mint);
console.log("Initialize Reward txn: " + sig.toString());
}
return sig;
}
async addRewardAmountToFarmIx(admin, farm, mint, amount) {
const farmState = await accounts_2.FarmState.fetch(this._connection, farm);
if (!farmState) {
throw new Error(`Could not fetch farm state ${farm.toBase58()}`);
}
let amountLamports = new anchor_1.BN((0, utils_2.collToLamportsDecimal)(amount, farmState.token.decimals.toNumber()).toString());
const adminRewardAta = await (0, utils_2.getAssociatedTokenAddress)(admin, mint);
let rewardIndex = -1;
for (let i = 0; farmState.rewardInfos.length; i++) {
if (farmState.rewardInfos[i].token.mint.toString() === mint.toString()) {
rewardIndex = i;
break;
}
}
const ix = farmOperations.addReward(admin, farm, farmState.rewardInfos[rewardIndex].rewardsVault, farmState.farmVaultsAuthority, adminRewardAta, mint, rewardIndex, amountLamports);
return ix;
}
async addRewardAmountToFarm(admin, farm, mint, amount) {
const ix = await this.addRewardAmountToFarmIx(admin.publicKey, farm, mint, amount);
let sig = await this.executeTransaction([ix], admin);
if (process.env.DEBUG === "true") {
console.log("Add Reward: " + mint + " amount: " + amount);
console.log("Add Reward txn: " + sig.toString());
}
return sig;
}
async updateRewardToFarmIx(admin, farm, mint, mode, value) {
const farmState = await accounts_2.FarmState.fetch(this._connection, farm);
let rewardIndex = -1;
if (!farmState) {
throw new Error(`Could not fetch farm state ${farm.toBase58()}`);
}
for (let i = 0; farmState.rewardInfos.length; i++) {
if (farmState.rewardInfos[i].token.mint.toString() === mint.toString()) {
rewardIndex = i;
break;
}
}
const ix = farmOperations.updateRewardConfig(admin, farm, rewardIndex, mode, value);
return ix;
}
async updateRewardToFarm(admin, farm, mint, mode, value) {
const ix = await this.updateRewardToFarmIx(admin.publicKey, farm, mint, mode, value);
let sig = await this.executeTransaction([ix], admin);
if (process.env.DEBUG === "true") {
console.log("Update Reward: " +
mint +
" mode: " +
mode.discriminator +
" value: " +
value);
console.log("Update Reward txn: " + sig.toString());
}
return sig;
}
async refreshFarmIx(farm) {
const ix = farmOperations.refreshFarm(farm);
return ix;
}
async refreshFarm(payer, farm) {
const ix = await this.refreshFarmIx(farm);
let sig = await this.executeTransaction([ix], payer);
if (process.env.DEBUG === "true") {
console.log("Refresh Farm: " + farm);
console.log("Refresh Farm txn: " + sig.toString());
}
return sig;
}
async refreshUserIx(userState, farmState) {
const ix = farmOperations.refreshUserState(userState, farmState);
return ix;
}
async refreshUser(payer, userState, farmState) {
const ix = await this.refreshUserIx(userState, farmState);
let sig = await this.executeTransaction([ix], payer);
if (process.env.DEBUG === "true") {
console.log("Refresh User: " + userState);
console.log("Refresh User txn: " + sig.toString());
}
return sig;
}
async createGlobalConfigIxs(admin, globalConfig) {
let ixs = [];
ixs.push(await (0, utils_2.createKeypairRentExemptIx)(this._provider.connection, admin, globalConfig, utils_1.SIZE_GLOBAL_CONFIG, this._farmsProgramId));
const treasuryVaultAuthority = (0, utils_2.getTreasuryAuthorityPDA)(this._farmsProgramId, globalConfig.publicKey);
ixs.push(farmOperations.initializeGlobalConfig(admin, globalConfig.publicKey, treasuryVaultAuthority));
return ixs;
}
async createGlobalConfig(admin, globalConfig) {
const ix = await this.createGlobalConfigIxs(admin.publicKey, globalConfig);
const sig = await this.executeTransaction(ix, admin, [globalConfig]);
if (process.env.DEBUG === "true") {
console.log("Initialize Global Config: " + globalConfig.toString());
console.log("Initialize Global Config txn: " + sig.toString());
}
return sig;
}
async updateGlobalConfigIx(admin, globalConfig, mode, flagValue, flagValueType) {
const ix = farmOperations.updateGlobalConfig(admin, globalConfig, mode, flagValue, flagValueType);
return ix;
}
async updateGlobalConfig(admin, globalConfig, mode, flagValue, flagValueType) {
const ix = await this.updateGlobalConfigIx(admin.publicKey, globalConfig, mode, flagValue, flagValueType);
const sig = await this.executeTransaction([ix], admin);
if (process.env.DEBUG === "true") {
console.log("Update Global Config: " +
globalConfig.toString() +
" mode: " +
mode.discriminator +
" value: " +
flagValue);
console.log("Update Global Config txn: " + sig.toString());
}
return sig;
}
async withdrawTreasuryIx(admin, globalConfig, rewardMint, amount, withdrawAta) {
const treasuryVault = (0, utils_2.getTreasuryVaultPDA)(this._farmsProgramId, globalConfig, rewardMint);
const treasuryVaultAuthority = (0, utils_2.getTreasuryAuthorityPDA)(this._farmsProgramId, globalConfig);
if (!withdrawAta) {
withdrawAta = await (0, utils_2.getAssociatedTokenAddress)(admin, rewardMint);
}
const ix = farmOperations.withdrawTreasury(admin, globalConfig, treasuryVault, treasuryVaultAuthority, withdrawAta, amount, rewardMint);
return ix;
}
async withdrawTreasury(admin, globalConfig, rewardMint, amount, withdrawAta) {
const ix = await this.withdrawTreasuryIx(admin.publicKey, globalConfig, rewardMint, amount, withdrawAta);
const sig = await this.executeTransaction([ix], admin);
if (process.env.DEBUG === "true") {
console.log("Admin " +
admin.publicKey +
" withdraw treasury of " +
rewardMint +
" an amount of " +
amount);
console.log("Withdraw treasury txn: " + sig.toString());
}
return sig;
}
}
exports.Farms = Farms;
async function getCurrentTimeUnit(conn, farm) {
const slot = await conn.getSlot();
const timestamp = await conn.getBlockTime(slot);
if (farm.timeUnit == index_1.TimeUnit.Seconds.discriminator) {
return new decimal_js_1.default(timestamp);
}
else {
return new decimal_js_1.default(slot);
}
}
exports.getCurrentTimeUnit = getCurrentTimeUnit;
async function getCurrentRps(conn, farm, rewardIndex) {
const currentTimeUnit = new decimal_js_1.default(await getCurrentTimeUnit(conn, farm));
return (0, utils_1.calculateCurrentRewardPerToken)(farm, rewardIndex, currentTimeUnit);
}
exports.getCurrentRps = getCurrentRps;
//# sourceMappingURL=Farms.js.map