@kamino-finance/farms-sdk
Version:
339 lines • 15.8 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 () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__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.SIZE_FARM_STATE = exports.SIZE_GLOBAL_CONFIG = void 0;
exports.setUpProgram = setUpProgram;
exports.createGlobalAccountsWithAirdrop = createGlobalAccountsWithAirdrop;
exports.createGlobalAccounts = createGlobalAccounts;
exports.setUpGlobalConfigWithAirdrop = setUpGlobalConfigWithAirdrop;
exports.setUpGlobalConfig = setUpGlobalConfig;
exports.createUser = createUser;
exports.setUpUser = setUpUser;
exports.createFarmAccountsWithAirdrops = createFarmAccountsWithAirdrops;
exports.createFarmAccounts = createFarmAccounts;
exports.createDelegatedFarmAccounts = createDelegatedFarmAccounts;
exports.setUpFarmWithAirdrops = setUpFarmWithAirdrops;
exports.setUpFarm = setUpFarm;
exports.setUpFarmDelegated = setUpFarmDelegated;
exports.setUpFarmIx = setUpFarmIx;
exports.setupFarmsEnvironment = setupFarmsEnvironment;
const web3_js_1 = require("@solana/web3.js");
const anchor = __importStar(require("@coral-xyz/anchor"));
const utils_1 = require("./utils");
const decimal_js_1 = __importDefault(require("decimal.js"));
const utils_2 = require("./utils");
const accounts_1 = require("../rpc_client/accounts");
const Farms_1 = require("../Farms");
const types_1 = require("../rpc_client/types");
const sendTransactionsUtils_1 = require("./sendTransactionsUtils");
const spl_token_1 = require("@solana/spl-token");
const token_1 = require("./token");
exports.SIZE_GLOBAL_CONFIG = 2136;
exports.SIZE_FARM_STATE = 8336;
const MAINNET_BETA_CHAIN_ID = 101;
const LOCALNET_CHAIN_ID = 102;
function setUpProgram(args) {
// Cluster & admin
if (!args.clusterOverride) {
throw new Error("Cluster is required");
}
if (!args.adminFilePath) {
throw new Error("Admin is required");
}
const cluster = args.clusterOverride;
let chain;
if (cluster === "localnet") {
chain = {
name: "localnet",
endpoint: "http://127.0.0.1:8899",
chainID: LOCALNET_CHAIN_ID,
displayName: "Localnet",
};
}
else {
chain = {
name: "mainnet-beta",
endpoint: cluster,
wsEndpoint: cluster?.replace("https:", "wss:") + "/whirligig",
chainID: MAINNET_BETA_CHAIN_ID,
displayName: "Mainnet Beta (Triton)",
};
}
const client = new sendTransactionsUtils_1.Web3Client(chain);
const connection = client.sendConnection;
const payer = (0, utils_2.parseKeypairFile)(args.adminFilePath);
// @ts-ignore
const wallet = new anchor.Wallet(payer);
const provider = new anchor.AnchorProvider(connection, wallet, anchor.AnchorProvider.defaultOptions());
const initialOwner = payer;
anchor.setProvider(provider);
// Programs
const farmsProgramId = args.programOverride || (0, utils_1.getFarmsProgramId)(cluster);
return {
initialOwner,
provider,
programId: farmsProgramId,
cluster: cluster,
web3Client: client,
};
}
async function createGlobalAccountsWithAirdrop(env, owner = env.initialOwner, rewardTokens) {
const globalConfig = web3_js_1.Keypair.generate();
let rewardAtas = new Array();
let treasuryVaults = new Array();
for (let index = 0; index < rewardTokens.length; index++) {
rewardAtas.push(await (0, token_1.setupAta)(env.provider, rewardTokens[index], owner));
treasuryVaults.push(await (0, utils_1.getTreasuryVaultPDA)(env.programId, globalConfig.publicKey, rewardTokens[index]));
}
let treasuryVaultAuthority = await (0, utils_1.getTreasuryAuthorityPDA)(env.programId, globalConfig.publicKey);
const globalAccounts = {
globalAdmin: owner,
globalConfig,
treasuryVaults,
globalAdminRewardAtas: rewardAtas,
treasuryVaultAuthority,
};
return globalAccounts;
}
async function createGlobalAccounts(env, owner = env.initialOwner) {
let bufferSpaceZeroAccount = 0;
const globalConfig = await (0, utils_1.createGlobalConfigPublicKeyRentExempt)(env.provider, env.programId);
let rewardAtas = new Array();
let treasuryVaults = new Array();
let treasuryVaultAuthority = await (0, utils_1.getTreasuryAuthorityPDA)(env.programId, globalConfig.publicKey);
const globalAccounts = {
globalAdmin: owner,
globalConfig,
treasuryVaults,
globalAdminRewardAtas: rewardAtas,
treasuryVaultAuthority,
};
return globalAccounts;
}
async function setUpGlobalConfigWithAirdrop(env, owner = env.initialOwner, rewardTokens) {
const globalAccounts = await createGlobalAccountsWithAirdrop(env, owner, rewardTokens);
const farmClient = new Farms_1.Farms(env.provider.connection);
await farmClient.createGlobalConfig(globalAccounts.globalAdmin, globalAccounts.globalConfig, 0);
return globalAccounts;
}
async function setUpGlobalConfig(env, owner = env.initialOwner) {
const globalAccounts = await createGlobalAccounts(env, owner);
const farmClient = new Farms_1.Farms(env.provider.connection);
await farmClient.createGlobalConfig(globalAccounts.globalAdmin, globalAccounts.globalConfig, 0);
return globalAccounts;
}
async function createUser(env, farmAccounts, solAirdropAmount, tokenAirdropAmount, owner) {
if (!owner) {
owner = new anchor.web3.Keypair();
}
const userState = (0, utils_1.getUserStatePDA)(env.programId, farmAccounts.farmState.publicKey, owner.publicKey);
if (solAirdropAmount.gt(0)) {
await (0, utils_1.solAirdrop)(env.provider, owner.publicKey, solAirdropAmount);
await (0, utils_1.sleep)(1000);
}
let farmState = await accounts_1.FarmState.fetch(env.provider.connection, farmAccounts.farmState.publicKey);
if (!farmState) {
throw new Error("Farm state not found");
}
const tokenAta = await (0, token_1.setupAta)(env.provider, farmState.token.mint, owner);
let rewardAtas = new Array();
for (let index = 0; index < farmState.numRewardTokens.toNumber(); index++) {
rewardAtas.push(await (0, token_1.setupAta)(env.provider, farmState.rewardInfos[index].token.mint, owner));
}
await (0, utils_1.sleep)(2000);
if (tokenAirdropAmount.gt(0)) {
await (0, token_1.mintTo)(env.provider, farmState.token.mint, tokenAta, (0, utils_1.collToLamportsDecimal)(tokenAirdropAmount, farmState.token.decimals.toNumber()).toNumber());
}
const testingUser = {
owner,
userState: userState,
tokenAta,
rewardAtas,
};
return testingUser;
}
async function setUpUser(env, farmAccounts, rewardTokens, owner) {
if (!owner) {
owner = new anchor.web3.Keypair();
}
const solAirdropAmount = new decimal_js_1.default(5);
const tokenAirdropAmount = new decimal_js_1.default(2000000);
const userAccounts = await createUser(env, farmAccounts, solAirdropAmount, tokenAirdropAmount, owner);
const farmClient = new Farms_1.Farms(env.provider.connection);
await farmClient.createNewUser(userAccounts.owner, farmAccounts.farmState.publicKey, 0);
return userAccounts;
}
async function createFarmAccountsWithAirdrops(env, rewardTokens, tokenMint, solAirdropAmount, rewardAirdropAmounts, farmAdmin) {
if (!farmAdmin) {
farmAdmin = new anchor.web3.Keypair();
}
const farmState = web3_js_1.Keypair.generate();
if (solAirdropAmount.gt(0)) {
await (0, utils_1.solAirdrop)(env.provider, farmAdmin.publicKey, solAirdropAmount);
await (0, utils_1.sleep)(1000);
}
const farmVault = await (0, utils_1.getFarmVaultPDA)(env.programId, farmState.publicKey, tokenMint);
const farmVaultAuthority = await (0, utils_1.getFarmAuthorityPDA)(env.programId, farmState.publicKey);
let rewardVaults = new Array();
let adminRewardAtas = new Array();
for (let index = 0; index < rewardTokens.length; index++) {
rewardVaults.push(await (0, utils_1.getRewardVaultPDA)(env.programId, farmState.publicKey, rewardTokens[index]));
adminRewardAtas.push(await (0, token_1.setupAta)(env.provider, rewardTokens[index], farmAdmin));
}
await (0, utils_1.sleep)(2000);
for (let index = 0; index < rewardTokens.length; index++) {
let tokenDecimals = await (0, token_1.getMintDecimals)(env.provider.connection, rewardTokens[index]);
if (rewardAirdropAmounts[index].gt(0)) {
await (0, token_1.mintTo)(env.provider, rewardTokens[index], adminRewardAtas[index], (0, utils_1.collToLamportsDecimal)(rewardAirdropAmounts[index], tokenDecimals).toNumber());
}
}
let farmAccounts = {
farmAdmin: farmAdmin,
farmState: farmState,
tokenMint,
farmVault,
rewardVaults,
farmVaultAuthority,
rewardMints: rewardTokens,
adminRewardAtas,
};
return farmAccounts;
}
async function createFarmAccounts(farmsProgramId, rewardTokens, tokenMint, farmAdmin) {
const farmState = web3_js_1.Keypair.generate();
const farmVault = (0, utils_1.getFarmVaultPDA)(farmsProgramId, farmState.publicKey, tokenMint);
const farmVaultAuthority = (0, utils_1.getFarmAuthorityPDA)(farmsProgramId, farmState.publicKey);
let rewardVaults = new Array();
let adminRewardAtas = new Array();
let farmAccounts = {
farmAdmin: farmAdmin,
farmState: farmState,
tokenMint,
farmVault,
rewardVaults,
farmVaultAuthority,
rewardMints: rewardTokens,
adminRewardAtas,
};
return farmAccounts;
}
function createDelegatedFarmAccounts(env, rewardTokens, farmAdmin) {
const farmState = web3_js_1.Keypair.generate();
const farmVaultAuthority = (0, utils_1.getFarmAuthorityPDA)(env.programId, farmState.publicKey);
let rewardVaults = new Array();
let adminRewardAtas = new Array();
let farmAccounts = {
farmAdmin: farmAdmin,
farmState: farmState,
tokenMint: web3_js_1.PublicKey.default,
farmVault: web3_js_1.PublicKey.default,
rewardVaults,
farmVaultAuthority,
rewardMints: rewardTokens,
adminRewardAtas,
};
return farmAccounts;
}
async function setUpFarmWithAirdrops(env, globalAccounts, rewardTokens, farmAdmin, tokenMint) {
if (!farmAdmin) {
farmAdmin = new anchor.web3.Keypair();
}
const solAirdropAmount = new decimal_js_1.default(5);
let rewardAirdropAmounts = new Array(rewardTokens.length);
rewardAirdropAmounts.fill(new decimal_js_1.default(10000));
if (!tokenMint) {
tokenMint = await (0, token_1.createMint)(env.provider, env.initialOwner.publicKey);
}
const farmAccounts = await createFarmAccountsWithAirdrops(env, rewardTokens, tokenMint, solAirdropAmount, rewardAirdropAmounts);
const farmClient = new Farms_1.Farms(env.provider.connection);
await farmClient.createFarm(farmAccounts.farmAdmin, globalAccounts.globalConfig.publicKey, farmAccounts.farmState, tokenMint, "execute", 0);
return farmAccounts;
}
async function setUpFarm(env, globalConfig, tokenMint, farmAdmin, mode, priorityFeeMultiplier) {
let rewardTokens = new Array();
const farmAccounts = await createFarmAccounts(env.programId, rewardTokens, tokenMint, farmAdmin);
const farmClient = new Farms_1.Farms(env.provider.connection);
await farmClient.createFarm(farmAccounts.farmAdmin, globalConfig, farmAccounts.farmState, tokenMint, mode, priorityFeeMultiplier, env.web3Client);
return farmAccounts;
}
async function setUpFarmDelegated(env, globalConfig, farmAdmin, farmDelegate, mode, priorityFeeMultiplier) {
let rewardTokens = new Array();
const farmAccounts = createDelegatedFarmAccounts(env, rewardTokens, farmAdmin);
const farmClient = new Farms_1.Farms(env.provider.connection);
await farmClient.createFarmDelegated(farmAccounts.farmAdmin, globalConfig, farmAccounts.farmState, farmDelegate, mode, priorityFeeMultiplier);
return farmAccounts;
}
async function setUpFarmIx(connection, farmsProgramId, globalConfig, tokenMint, farmAdmin, mode, multisig) {
let rewardTokens = new Array();
const farmAccounts = await createFarmAccounts(farmsProgramId, rewardTokens, tokenMint, farmAdmin);
const farmClient = new Farms_1.Farms(connection);
return [
await farmClient.createFarmIx(mode === "multisig"
? new web3_js_1.PublicKey(multisig)
: farmAccounts.farmAdmin.publicKey, farmAccounts.farmState, globalConfig, tokenMint),
farmAccounts,
];
}
async function setupFarmsEnvironment(env, numRewardTokens, minClaimDurationSeconds = 60, rewardRps = 50) {
let rewardTokens = Array();
for (let i = 0; i < numRewardTokens; i++) {
rewardTokens.push(await (0, token_1.createMint)(env.provider, env.initialOwner.publicKey));
}
const globalAccounts = await setUpGlobalConfigWithAirdrop(env, env.initialOwner, rewardTokens);
const farmAccounts = await setUpFarmWithAirdrops(env, globalAccounts, rewardTokens);
const farmsClient = new Farms_1.Farms(env.provider.connection);
for (let i = 0; i < numRewardTokens; i++) {
await farmsClient.addRewardToFarm(farmAccounts.farmAdmin, globalAccounts.globalConfig.publicKey, farmAccounts.farmState.publicKey, rewardTokens[i], spl_token_1.TOKEN_PROGRAM_ID, "execute", 0);
}
for (let i = 0; i < numRewardTokens; i++) {
await farmsClient.addRewardAmountToFarm(farmAccounts.farmAdmin, farmAccounts.farmState.publicKey, rewardTokens[i], new decimal_js_1.default(100), "execute", 0);
}
for (let i = 0; i < numRewardTokens; i++) {
await farmsClient.updateFarmConfig(farmAccounts.farmAdmin, farmAccounts.farmState.publicKey, rewardTokens[i], new types_1.FarmConfigOption.UpdateRewardRps(), rewardRps, "execute", 0);
await farmsClient.updateFarmConfig(farmAccounts.farmAdmin, farmAccounts.farmState.publicKey, rewardTokens[i], new types_1.FarmConfigOption.UpdateRewardMinClaimDuration(), minClaimDurationSeconds, "execute", 0);
}
const userAccounts = await setUpUser(env, farmAccounts, rewardTokens);
return {
farmsClient,
farmAccounts,
globalAccounts,
userAccounts,
rewardTokens,
};
}
//# sourceMappingURL=setup.js.map