@kamino-finance/klend-sdk 5.10.28-beta.1 → 5.10.28

package/dist/idl_codegen_unstaking_pool/types/index.js

@@ -1,39 +0,0 @@
-"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;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.PoolConfigField = void 0;
-const PoolConfigField = __importStar(require("./PoolConfigField"));
-exports.PoolConfigField = PoolConfigField;
-//# sourceMappingURL=index.js.map

package/dist/idl_codegen_unstaking_pool/types/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/idl_codegen_unstaking_pool/types/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,mEAAqD;AAE5C,0CAAe"}

package/src/classes/stakePool.ts

@@ -1,21 +0,0 @@
-import { Connection, PublicKey } from '@solana/web3.js/lib';
-import { maybeGetStakedPoolByMint } from './standardStakePool';
-import { StakePool as StandardStakePool } from '@solana/spl-stake-pool/dist/layouts';
-
-// Expand this type to represent all supported stake pool implementations
-export type GenericStakePool = StandardStakePool;
-export enum StakePoolType {
-  Standard,
-}
-
-export async function mapStakedSolMintToPool(
-  connection: Connection,
-  mint: PublicKey
-): Promise<[GenericStakePool, PublicKey, StakePoolType]> {
-  // We cannot know which pool the mint corresponds to, so we fetch them program by program
-  const maybeStandardPoolAndKey = await maybeGetStakedPoolByMint(connection, mint);
-  if (maybeStandardPoolAndKey) {
-    return [...maybeStandardPoolAndKey, StakePoolType.Standard];
-  }
-  throw new Error(`Cannot map mint ${mint} to staked sol pool`);
-}

package/src/classes/standardStakePool.ts

@@ -1,358 +0,0 @@
-import { STAKE_POOL_PROGRAM_ID, ValidatorList, ValidatorListLayout } from '@solana/spl-stake-pool';
-import { StakePool, StakePoolLayout } from '@solana/spl-stake-pool';
-import { AccountMeta, Connection, Keypair, PublicKey } from '@solana/web3.js';
-import { CLOCK_PROGRAM_ID, STAKE_PROGRAM_ID } from './unstakingPool';
-import BN from 'bn.js';
-import assert from 'assert';
-import { enums, Infer, nullable, number, type } from 'superstruct';
-
-export const TRANSIENT_STAKE_SEED_PREFIX = Buffer.from('transient');
-export const STAKE_ACCOUNT_RENT_EXEMPTION = 2_282_880;
-const MINIMUM_ACTIVE_STAKE = 1_000_000;
-// This represents the minimum each validator stake account must have and cannot be withdrawn
-const TRANSIENT_STAKE_ACCOUNT_RENT_EXEMPTION = STAKE_ACCOUNT_RENT_EXEMPTION + MINIMUM_ACTIVE_STAKE;
-
-export async function getStandardPoolState(address: PublicKey, connection: Connection): Promise<StakePool> {
-  const accountInfo = await connection.getAccountInfo(address);
-  if (!accountInfo) {
-    throw new Error(`Cannot fetch standard stake pool account ${address.toString()}`);
-  }
-  return StakePoolLayout.decode(accountInfo.data);
-}
-
-export async function getValidatorList(address: PublicKey, connection: Connection): Promise<ValidatorList> {
-  const accountInfo = await connection.getAccountInfo(address);
-  if (!accountInfo) {
-    throw new Error(`Cannot fetch standard stake pool account ${address.toString()}`);
-  }
-  return ValidatorListLayout.decode(accountInfo.data);
-}
-
-export async function maybeGetStakedPoolByMint(
-  connection: Connection,
-  mint: PublicKey
-): Promise<[StakePool, PublicKey] | undefined> {
-  const results = await connection.getProgramAccounts(STAKE_POOL_PROGRAM_ID, {
-    filters: [{ memcmp: { offset: 162, bytes: mint.toBase58() } }],
-  });
-  // There should be only 1 stake pool for mint
-  if (results.length === 0) {
-    return undefined;
-  }
-  if (results.length === 1) {
-    return [StakePoolLayout.decode(results[0].account.data), results[0].pubkey];
-  }
-  throw new Error(`Got ${results.length} stake pools for mint ${mint.toString()} and not sure which one is correct.`);
-}
-
-export async function getStandardPoolMintRemainingAccounts(
-  connection: Connection,
-  stakedSolPool: StakePool,
-  stakedSolPoolPk: PublicKey,
-  stakedSolToDeposit: BN
-): Promise<[Array<AccountMeta>, Array<Keypair>]> {
-  const withdrawAuthority = await findWithdrawAuthorityProgramAddress(STAKE_POOL_PROGRAM_ID, stakedSolPoolPk);
-  const remainingAccounts = [
-    { pubkey: stakedSolPoolPk, isSigner: false, isWritable: true },
-    { pubkey: stakedSolPool.validatorList, isSigner: false, isWritable: true },
-    { pubkey: withdrawAuthority, isSigner: false, isWritable: true },
-    { pubkey: stakedSolPool.managerFeeAccount, isSigner: false, isWritable: true },
-    { pubkey: CLOCK_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: STAKE_PROGRAM_ID, isSigner: false, isWritable: false },
-    { pubkey: STAKE_POOL_PROGRAM_ID, isSigner: false, isWritable: false },
-  ];
-  const withdrawCandidates = await getWithdrawCandidates(
-    connection,
-    stakedSolPool,
-    stakedSolPoolPk,
-    stakedSolToDeposit
-  );
-  // Each withdraw candidate should also create a new keypair for the stake account
-  const withdrawCandidatesTo: Keypair[] = [];
-  for (const withdrawCandidateFrom of withdrawCandidates) {
-    remainingAccounts.push({ pubkey: withdrawCandidateFrom, isSigner: false, isWritable: true });
-    const withdrawCandidateTo = Keypair.generate();
-    remainingAccounts.push({ pubkey: withdrawCandidateTo.publicKey, isSigner: true, isWritable: true });
-    withdrawCandidatesTo.push(withdrawCandidateTo);
-  }
-  return [remainingAccounts, withdrawCandidatesTo];
-}
-
-async function getAllWithdrawCandidatesSorted(
-  connection: Connection,
-  stakedSolPool: StakePool,
-  stakedSolPoolPk: PublicKey
-): Promise<Array<{ isPreferred: boolean; balance: number; pk: PublicKey }>> {
-  const activeValidators: { isPreferred: boolean; balance: number; pk: PublicKey }[] = [];
-  const transientValidators: { isPreferred: boolean; balance: number; pk: PublicKey }[] = [];
-  const validatorList = await getValidatorList(stakedSolPool.validatorList, connection);
-  const accountsToFetch: PublicKey[] = [];
-  // Add all accounts to be fetched to an array so that we can use getMultipleAccounts
-  for (const validator of validatorList.validators) {
-    const stakeAccount = await findStakeProgramAddress(
-      STAKE_POOL_PROGRAM_ID,
-      validator.voteAccountAddress,
-      stakedSolPoolPk,
-      validator.transientSeedSuffixStart.toNumber()
-    );
-    const transientAccount = await findTransientStakeProgramAddress(
-      STAKE_POOL_PROGRAM_ID,
-      validator.voteAccountAddress,
-      stakedSolPoolPk,
-      validator.transientSeedSuffixEnd
-    );
-    accountsToFetch.push(stakeAccount);
-    accountsToFetch.push(transientAccount);
-  }
-  let accountsBalances: Array<number> = [];
-  // TODO: if this is still too slow we can also start all getMultipleAccounts in parallel and do Promise.all
-  for (let i = 0; i < accountsToFetch.length; i += 100) {
-    const accountInfos = await connection.getMultipleAccountsInfo(accountsToFetch.slice(i, i + 100));
-    accountsBalances = accountsBalances.concat(
-      accountInfos.map((accountInfo) => (accountInfo ? accountInfo.lamports : 0))
-    );
-  }
-  assert(accountsBalances.length === accountsToFetch.length);
-  let i = 0;
-  for (const validator of validatorList.validators) {
-    const isPreferred = stakedSolPool.preferredWithdrawValidatorVoteAddress
-      ? validator.voteAccountAddress.equals(stakedSolPool.preferredWithdrawValidatorVoteAddress)
-      : false;
-    const stakeAccount = accountsToFetch[i];
-    const stakeAccountBalance = accountsBalances[i] - TRANSIENT_STAKE_ACCOUNT_RENT_EXEMPTION;
-    if (stakeAccountBalance > 0) {
-      activeValidators.push({ isPreferred, balance: stakeAccountBalance, pk: stakeAccount });
-    }
-    const transientAccount = accountsToFetch[i + 1];
-    const transientAccountBalance = accountsBalances[i + 1] - TRANSIENT_STAKE_ACCOUNT_RENT_EXEMPTION;
-    if (transientAccountBalance > 0) {
-      transientValidators.push({ isPreferred, balance: transientAccountBalance, pk: transientAccount });
-    }
-    i += 2;
-  }
-  // Sorting descending based on balance, but preferred validators should always be used first
-  activeValidators.sort((a, b) => {
-    if (a.isPreferred) {
-      return -1;
-    }
-    if (b.isPreferred) {
-      return 1;
-    }
-    return b.balance - a.balance;
-  });
-  transientValidators.sort((a, b) => {
-    if (a.isPreferred) {
-      return -1;
-    }
-    if (b.isPreferred) {
-      return 1;
-    }
-    return b.balance - a.balance;
-  });
-  const allCandidates = activeValidators.concat(transientValidators);
-
-  // Add reserve stake account at the end as that should be used only if no validators have enough stake
-  const reserveStakeBalance = (await connection.getBalance(stakedSolPool.reserveStake)) - STAKE_ACCOUNT_RENT_EXEMPTION;
-  if (reserveStakeBalance > 0) {
-    allCandidates.push({
-      isPreferred: false,
-      balance: reserveStakeBalance,
-      pk: stakedSolPool.reserveStake,
-    });
-  }
-  return allCandidates;
-}
-
-export async function getWithdrawCandidates(
-  connection: Connection,
-  stakedSolPool: StakePool,
-  stakedSolPoolPk: PublicKey,
-  stakedSolToDeposit: BN
-): Promise<Array<PublicKey>> {
-  const allCandidates = await getAllWithdrawCandidatesSorted(connection, stakedSolPool, stakedSolPoolPk);
-
-  let stakedSolRemaining = stakedSolToDeposit;
-  let solToWithdraw = new BN(0);
-  const withdrawCandidates: Array<PublicKey> = [];
-
-  // Try to withdraw all of the SOL from validators' active/transient accounts
-  for (const candidate of allCandidates) {
-    if (stakedSolRemaining.isZero()) {
-      break;
-    }
-
-    // See how much the validator balance is worth in staked sol
-    // but limit to amount of needed stake sol
-    let stakedSolAmountToWithdraw = BN.min(
-      stakedSolRemaining,
-      solToStakePoolTokensWithInverseFee(stakedSolPool, new BN(candidate.balance))
-    );
-    // Convert it back to staked sol so we get the real amount
-    let actualSolAmount = calcLamportsWithdrawAmount(stakedSolPool, stakedSolAmountToWithdraw);
-
-    const remainingSolAmount = calcLamportsWithdrawAmount(
-      stakedSolPool,
-      stakedSolRemaining.sub(stakedSolAmountToWithdraw)
-    );
-
-    // If the current validator uses up all of the remaining staked sol except some minimum that we need
-    // in order to split_stake, then leave at least the minimum required to be consumed by another validator
-    if (!remainingSolAmount.isZero() && remainingSolAmount < new BN(MINIMUM_ACTIVE_STAKE)) {
-      stakedSolAmountToWithdraw = stakedSolAmountToWithdraw.sub(
-        solToStakePoolTokensWithInverseFee(stakedSolPool, new BN(MINIMUM_ACTIVE_STAKE))
-      );
-      actualSolAmount = calcLamportsWithdrawAmount(stakedSolPool, stakedSolAmountToWithdraw);
-    }
-
-    if (actualSolAmount < new BN(MINIMUM_ACTIVE_STAKE) && !candidate.pk.equals(stakedSolPool.reserveStake)) {
-      // Skip if the amount to withdraw is less than the minimum required for a valid stake
-      continue;
-    }
-
-    // Update stake_pool so simulation stays true to what happens on chain
-    stakedSolRemaining = stakedSolRemaining.sub(stakedSolAmountToWithdraw);
-    solToWithdraw = solToWithdraw.add(actualSolAmount);
-    stakedSolPool.totalLamports = stakedSolPool.totalLamports.sub(actualSolAmount);
-    stakedSolPool.poolTokenSupply = stakedSolPool.poolTokenSupply.sub(
-      stakePoolTokensMinusFee(stakedSolPool, stakedSolAmountToWithdraw)
-    );
-    withdrawCandidates.push(candidate.pk);
-  }
-
-  return withdrawCandidates;
-}
-
-function calcPoolTokensStakeWithdrawalFee(stakedSolPool: StakePool, stakedSolAmountToWithdraw: BN): BN {
-  const denominator = stakedSolPool.stakeWithdrawalFee.denominator;
-  if (denominator.isZero()) {
-    return new BN(0);
-  }
-  const numerator = stakedSolAmountToWithdraw.mul(stakedSolPool.stakeWithdrawalFee.numerator);
-  const poolTokens = numerator.add(denominator).sub(new BN(1)).div(denominator);
-  return poolTokens;
-}
-
-function stakePoolTokensMinusFee(stakedSolPool: StakePool, stakedSolAmountToWithdraw: BN): BN {
-  const stakedSolFee = calcPoolTokensStakeWithdrawalFee(stakedSolPool, stakedSolAmountToWithdraw);
-  return stakedSolAmountToWithdraw.sub(stakedSolFee);
-}
-
-function solToStakePoolTokensWithInverseFee(stakedSolPool: StakePool, sol: BN): BN {
-  let poolTokens = calcPoolTokensForDeposit(stakedSolPool, sol);
-  if (!stakedSolPool.stakeWithdrawalFee.numerator.isZero()) {
-    const numerator = poolTokens.mul(stakedSolPool.stakeWithdrawalFee.denominator);
-    const denominator = stakedSolPool.stakeWithdrawalFee.denominator.sub(stakedSolPool.stakeWithdrawalFee.numerator);
-    if (denominator.isZero()) {
-      // If the pool has 100% fee for some reason just fail it, we cannot compute the inverse
-      throw new Error('Pool fee cannot be 100%');
-    }
-    poolTokens = numerator.div(denominator);
-  }
-  return poolTokens;
-}
-
-// Below functions/types are not exported from spl-stake-pool
-
-/**
- * Generates the withdraw authority program address for the stake pool
- */
-export async function findWithdrawAuthorityProgramAddress(programId: PublicKey, stakePoolAddress: PublicKey) {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [stakePoolAddress.toBuffer(), Buffer.from('withdraw')],
-    programId
-  );
-  return publicKey;
-}
-
-export async function findStakeProgramAddress(
-  programId: PublicKey,
-  voteAccountAddress: PublicKey,
-  stakedSolPoolPk: PublicKey,
-  seed: number
-): Promise<PublicKey> {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [
-      voteAccountAddress.toBuffer(),
-      stakedSolPoolPk.toBuffer(),
-      seed ? new BN(seed).toArrayLike(Buffer, 'le', 4) : Buffer.alloc(0),
-    ],
-    programId
-  );
-  return publicKey;
-}
-
-export async function findTransientStakeProgramAddress(
-  programId: PublicKey,
-  voteAccountAddress: PublicKey,
-  stakePoolAddress: PublicKey,
-  seed: BN
-) {
-  const [publicKey] = await PublicKey.findProgramAddress(
-    [
-      TRANSIENT_STAKE_SEED_PREFIX,
-      voteAccountAddress.toBuffer(),
-      stakePoolAddress.toBuffer(),
-      seed.toArrayLike(Buffer, 'le', 8),
-    ],
-    programId
-  );
-  return publicKey;
-}
-
-function calcPoolTokensForDeposit(stakePool: StakePool, stakeLamports: BN): BN {
-  if (stakePool.poolTokenSupply.isZero() || stakePool.totalLamports.isZero()) {
-    return stakeLamports;
-  }
-  const numerator = stakeLamports.mul(stakePool.poolTokenSupply);
-  return numerator.div(stakePool.totalLamports);
-}
-
-export function calcLamportsWithdrawAmount(stakePool: StakePool, poolTokens: BN): BN {
-  const numerator = poolTokens.mul(stakePool.totalLamports);
-  const denominator = stakePool.poolTokenSupply;
-  if (numerator.lt(denominator)) {
-    return new BN(0);
-  }
-  return numerator.div(denominator);
-}
-
-export declare const BigNumFromString: import('superstruct').Struct<BN, null>;
-export declare const PublicKeyFromString: import('superstruct').Struct<PublicKey, null>;
-export const StakeAccountType = enums(['uninitialized', 'initialized', 'delegated', 'rewardsPool']);
-
-export type StakeMeta = Infer<typeof StakeMeta>;
-export const StakeMeta = type({
-  rentExemptReserve: BigNumFromString,
-  authorized: type({
-    staker: PublicKeyFromString,
-    withdrawer: PublicKeyFromString,
-  }),
-  lockup: type({
-    unixTimestamp: number(),
-    epoch: number(),
-    custodian: PublicKeyFromString,
-  }),
-});
-
-type StakeAccountInfo = Infer<typeof StakeAccountInfo>;
-const StakeAccountInfo = type({
-  meta: StakeMeta,
-  stake: nullable(
-    type({
-      delegation: type({
-        voter: PublicKeyFromString,
-        stake: BigNumFromString,
-        activationEpoch: BigNumFromString,
-        deactivationEpoch: BigNumFromString,
-        warmupCooldownRate: number(),
-      }),
-      creditsObserved: number(),
-    })
-  ),
-});
-
-export type StakeAccount = Infer<typeof StakeAccount>;
-export const StakeAccount = type({
-  type: StakeAccountType,
-  info: StakeAccountInfo,
-});