@hubbleprotocol/farms-sdk
Version:
339 lines • 16.7 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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
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.setUpFarmWithAirdrops = setUpFarmWithAirdrops;
exports.setUpFarm = setUpFarm;
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 market_1 = require("@project-serum/serum/lib/market");
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");
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 === null || cluster === void 0 ? void 0 : 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);
const program = new anchor.Program(utils_2.FarmsIdl, farmsProgramId);
return {
initialOwner,
provider,
program,
cluster: cluster,
web3Client: client,
};
}
function createGlobalAccountsWithAirdrop(env_1) {
return __awaiter(this, arguments, void 0, function* (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(yield (0, utils_1.setupAta)(env.provider, rewardTokens[index], owner));
treasuryVaults.push(yield (0, utils_1.getTreasuryVaultPDA)(env.program.programId, globalConfig.publicKey, rewardTokens[index]));
}
let treasuryVaultAuthority = yield (0, utils_1.getTreasuryAuthorityPDA)(env.program.programId, globalConfig.publicKey);
const globalAccounts = {
globalAdmin: owner,
globalConfig,
treasuryVaults,
globalAdminRewardAtas: rewardAtas,
treasuryVaultAuthority,
};
return globalAccounts;
});
}
function createGlobalAccounts(env_1) {
return __awaiter(this, arguments, void 0, function* (env, owner = env.initialOwner) {
let bufferSpaceZeroAccount = 0;
const globalConfig = yield (0, utils_1.createGlobalConfigPublicKeyRentExempt)(env.provider, env.program.programId);
let rewardAtas = new Array();
let treasuryVaults = new Array();
let treasuryVaultAuthority = yield (0, utils_1.getTreasuryAuthorityPDA)(env.program.programId, globalConfig.publicKey);
const globalAccounts = {
globalAdmin: owner,
globalConfig,
treasuryVaults,
globalAdminRewardAtas: rewardAtas,
treasuryVaultAuthority,
};
return globalAccounts;
});
}
function setUpGlobalConfigWithAirdrop(env_1) {
return __awaiter(this, arguments, void 0, function* (env, owner = env.initialOwner, rewardTokens) {
const globalAccounts = yield createGlobalAccountsWithAirdrop(env, owner, rewardTokens);
const farmClient = new Farms_1.Farms(env.provider.connection);
yield farmClient.createGlobalConfig(globalAccounts.globalAdmin, globalAccounts.globalConfig, 0);
return globalAccounts;
});
}
function setUpGlobalConfig(env_1) {
return __awaiter(this, arguments, void 0, function* (env, owner = env.initialOwner) {
const globalAccounts = yield createGlobalAccounts(env, owner);
const farmClient = new Farms_1.Farms(env.provider.connection);
yield farmClient.createGlobalConfig(globalAccounts.globalAdmin, globalAccounts.globalConfig, 0);
return globalAccounts;
});
}
function createUser(env, farmAccounts, solAirdropAmount, tokenAirdropAmount, rewardAirdropAmounts, owner) {
return __awaiter(this, void 0, void 0, function* () {
if (!owner) {
owner = new anchor.web3.Keypair();
}
const userState = yield (0, utils_1.getUserStatePDA)(env.program.programId, farmAccounts.farmState.publicKey, owner.publicKey);
if (solAirdropAmount.gt(0)) {
yield (0, utils_1.solAirdrop)(env.provider, owner.publicKey, solAirdropAmount);
yield (0, utils_1.sleep)(1000);
}
let farmState = yield accounts_1.FarmState.fetch(env.provider.connection, farmAccounts.farmState.publicKey);
if (!farmState) {
throw new Error("Farm state not found");
}
const tokenAta = yield (0, utils_1.setupAta)(env.provider, farmState.token.mint, owner);
let rewardAtas = new Array();
for (let index = 0; index < farmState.numRewardTokens.toNumber(); index++) {
rewardAtas.push(yield (0, utils_1.setupAta)(env.provider, farmState.rewardInfos[index].token.mint, owner));
}
yield (0, utils_1.sleep)(2000);
if (tokenAirdropAmount.gt(0)) {
yield (0, utils_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;
});
}
function setUpUser(env, farmAccounts, rewardTokens, owner) {
return __awaiter(this, void 0, void 0, function* () {
if (!owner) {
owner = new anchor.web3.Keypair();
}
const solAirdropAmount = new decimal_js_1.default(5);
const tokenAirdropAmount = new decimal_js_1.default(2000000);
let rewardAirdropAmounts = new Array(rewardTokens.length);
rewardAirdropAmounts.fill(new decimal_js_1.default(20000000));
const userAccounts = yield createUser(env, farmAccounts, solAirdropAmount, tokenAirdropAmount, rewardAirdropAmounts, owner);
const farmClient = new Farms_1.Farms(env.provider.connection);
yield farmClient.createNewUser(userAccounts.owner, farmAccounts.farmState.publicKey, 0);
return userAccounts;
});
}
function createFarmAccountsWithAirdrops(env, rewardTokens, tokenMint, solAirdropAmount, rewardAirdropAmounts, farmAdmin) {
return __awaiter(this, void 0, void 0, function* () {
if (!farmAdmin) {
farmAdmin = new anchor.web3.Keypair();
}
const farmState = web3_js_1.Keypair.generate();
if (solAirdropAmount.gt(0)) {
yield (0, utils_1.solAirdrop)(env.provider, farmAdmin.publicKey, solAirdropAmount);
yield (0, utils_1.sleep)(1000);
}
const farmVault = yield (0, utils_1.getFarmVaultPDA)(env.program.programId, farmState.publicKey, tokenMint);
const farmVaultAuthority = yield (0, utils_1.getFarmAuthorityPDA)(env.program.programId, farmState.publicKey);
let rewardVaults = new Array();
let adminRewardAtas = new Array();
for (let index = 0; index < rewardTokens.length; index++) {
rewardVaults.push(yield (0, utils_1.getRewardVaultPDA)(env.program.programId, farmState.publicKey, rewardTokens[index]));
adminRewardAtas.push(yield (0, utils_1.setupAta)(env.provider, rewardTokens[index], farmAdmin));
}
yield (0, utils_1.sleep)(2000);
for (let index = 0; index < rewardTokens.length; index++) {
let tokenDecimals = yield (0, market_1.getMintDecimals)(env.provider.connection, rewardTokens[index]);
if (rewardAirdropAmounts[index].gt(0)) {
yield (0, utils_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;
});
}
function createFarmAccounts(env, rewardTokens, tokenMint, farmAdmin) {
return __awaiter(this, void 0, void 0, function* () {
const farmState = web3_js_1.Keypair.generate();
const farmVault = yield (0, utils_1.getFarmVaultPDA)(env.program.programId, farmState.publicKey, tokenMint);
const farmVaultAuthority = yield (0, utils_1.getFarmAuthorityPDA)(env.program.programId, 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 setUpFarmWithAirdrops(env, globalAccounts, rewardTokens, farmAdmin, tokenMint) {
return __awaiter(this, void 0, void 0, function* () {
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 = yield (0, utils_1.createMint)(env.provider, env.initialOwner.publicKey);
}
const farmAccounts = yield createFarmAccountsWithAirdrops(env, rewardTokens, tokenMint, solAirdropAmount, rewardAirdropAmounts);
const farmClient = new Farms_1.Farms(env.provider.connection);
yield farmClient.createFarm(farmAccounts.farmAdmin, globalAccounts.globalConfig.publicKey, farmAccounts.farmState, tokenMint, "execute", 0);
return farmAccounts;
});
}
function setUpFarm(env, globalConfig, tokenMint, farmAdmin, mode, priorityFeeMultiplier) {
return __awaiter(this, void 0, void 0, function* () {
let rewardTokens = new Array();
const farmAccounts = yield createFarmAccounts(env, rewardTokens, tokenMint, farmAdmin);
const farmClient = new Farms_1.Farms(env.provider.connection);
yield farmClient.createFarm(farmAccounts.farmAdmin, globalConfig, farmAccounts.farmState, tokenMint, mode, priorityFeeMultiplier, env.web3Client);
return farmAccounts;
});
}
function setUpFarmIx(env, globalConfig, tokenMint, farmAdmin, mode) {
return __awaiter(this, void 0, void 0, function* () {
let rewardTokens = new Array();
const farmAccounts = yield createFarmAccounts(env, rewardTokens, tokenMint, farmAdmin);
const farmClient = new Farms_1.Farms(env.provider.connection);
return [
yield farmClient.createFarmIx(mode === "multisig"
? new web3_js_1.PublicKey(process.env.MULTISIG)
: farmAccounts.farmAdmin.publicKey, farmAccounts.farmState, globalConfig, tokenMint),
farmAccounts,
];
});
}
function setupFarmsEnvironment(env_1, numRewardTokens_1) {
return __awaiter(this, arguments, void 0, function* (env, numRewardTokens, minClaimDurationSeconds = 60, rewardRps = 50) {
let rewardTokens = Array();
for (let i = 0; i < numRewardTokens; i++) {
rewardTokens.push(yield (0, utils_1.createMint)(env.provider, env.initialOwner.publicKey));
}
const globalAccounts = yield setUpGlobalConfigWithAirdrop(env, env.initialOwner, rewardTokens);
const farmAccounts = yield setUpFarmWithAirdrops(env, globalAccounts, rewardTokens);
const farmsClient = new Farms_1.Farms(env.provider.connection);
for (let i = 0; i < numRewardTokens; i++) {
yield 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++) {
yield farmsClient.addRewardAmountToFarm(farmAccounts.farmAdmin, farmAccounts.farmState.publicKey, rewardTokens[i], new decimal_js_1.default(100), "execute", 0);
}
for (let i = 0; i < numRewardTokens; i++) {
yield farmsClient.updateFarmConfig(farmAccounts.farmAdmin, farmAccounts.farmState.publicKey, rewardTokens[i], new types_1.FarmConfigOption.UpdateRewardRps(), rewardRps, "execute", 0);
yield farmsClient.updateFarmConfig(farmAccounts.farmAdmin, farmAccounts.farmState.publicKey, rewardTokens[i], new types_1.FarmConfigOption.UpdateRewardMinClaimDuration(), minClaimDurationSeconds, "execute", 0);
}
const userAccounts = yield setUpUser(env, farmAccounts, rewardTokens);
return {
farmsClient,
farmAccounts,
globalAccounts,
userAccounts,
rewardTokens,
};
});
}
//# sourceMappingURL=setup.js.map