@kamino-finance/klend-sdk 5.10.27 → 5.10.28-beta.0

package/src/classes/unstakingPool.ts

@@ -0,0 +1,565 @@
+import {
+  AccountMeta,
+  AddressLookupTableProgram,
+  Connection,
+  GetProgramAccountsResponse,
+  Keypair,
+  PublicKey,
+  SystemProgram,
+  SYSVAR_CLOCK_PUBKEY,
+  SYSVAR_INSTRUCTIONS_PUBKEY,
+  SYSVAR_RENT_PUBKEY,
+  TransactionInstruction,
+} from '@solana/web3.js';
+import {
+  initializePool,
+  InitializePoolAccounts,
+  updatePoolConfig,
+  UpdatePoolConfigAccounts,
+  UpdatePoolConfigArgs,
+  collect,
+  CollectAccounts,
+  burn,
+  BurnAccounts,
+  BurnArgs,
+  mint,
+  MintAccounts,
+  MintArgs,
+} from '../idl_codegen_unstaking_pool/instructions';
+import { ASSOCIATED_TOKEN_PROGRAM_ID, NATIVE_MINT, TOKEN_2022_PROGRAM_ID, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { getAssociatedTokenAddress, WRAPPED_SOL_MINT } from '../lib';
+import { PoolState } from '../idl_codegen_unstaking_pool/accounts';
+import { PublicKeySet } from '../utils';
+import bs58 from 'bs58';
+import { getProgramAccounts } from '../utils/rpc';
+import { InitPoolIxs, MintIxs, SyncVaultLUTIxs, UpdatePoolConfigIxs } from './types';
+import { PoolConfigField, PoolConfigFieldKind } from '../idl_codegen_unstaking_pool/types';
+import BN from 'bn.js';
+import { STAKE_POOL_PROGRAM_ID } from '@solana/spl-stake-pool';
+import { mapStakedSolMintToPool, StakePoolType } from './stakePool';
+import { getStandardPoolMintRemainingAccounts, StakeAccount } from './standardStakePool';
+export const unstakingPoolId = new PublicKey('USo1uB8RsRuM8y8e8vbL3mwR22EzSTLyZqaJPoZvn3a');
+export const unstakingPoolStagingId = new PublicKey('STuRAYCqtoJ15dASjaypTtgqDB7h7fLgiNBuWt17ZG5');
+export const STAKE_PROGRAM_ID = new PublicKey('Stake11111111111111111111111111111111111111');
+export const CLOCK_PROGRAM_ID = new PublicKey('SysvarC1ock11111111111111111111111111111111');
+const STAKE_HISTORY_PROGRAM_ID = new PublicKey('SysvarStakeHistory1111111111111111111111111');
+
+const BASE_POOL_AUTHORITY_SEED = 'authority';
+const UNSTAKING_SOL_MINT_SEED = 'unstaking_sol_mint';
+
+/**
+ * KaminoPoolClient is a class that provides a high-level interface to interact with the Kamino Pool program.
+ */
+export class UnstakingPoolClient {
+  private readonly _connection: Connection;
+  private readonly _unstakingPoolProgramId: PublicKey;
+
+  constructor(connection: Connection, unstakingPoolprogramId?: PublicKey) {
+    this._connection = connection;
+    this._unstakingPoolProgramId = unstakingPoolprogramId ? unstakingPoolprogramId : unstakingPoolId;
+  }
+
+  getConnection() {
+    return this._connection;
+  }
+
+  getProgramID() {
+    return this._unstakingPoolProgramId;
+  }
+
+  /**
+   * This method will create a pool with a given config. The config can be changed later on, but it is recommended to set it up correctly from the start
+   * @param poolConfig - the config object used to create a pool
+   * @returns pool - keypair, should be used to sign the transaction which creates the pool account
+   * @returns pool: the keypair of the pool, used to sign the initialization transaction; initPoolIxs: a struct with ixs to initialize the pool and its lookup table + populateLUTIxs, a list to populate the lookup table which has to be executed in a separate transaction
+   */
+  async createPoolIxs(poolConfig: UnstakingPoolConfig): Promise<{ pool: Keypair; initPoolIxs: InitPoolIxs }> {
+    const poolState = Keypair.generate();
+    const size = PoolState.layout.span + 8;
+
+    const createPoolIx = SystemProgram.createAccount({
+      fromPubkey: poolConfig.admin,
+      newAccountPubkey: poolState.publicKey,
+      lamports: await this._connection.getMinimumBalanceForRentExemption(size),
+      space: size,
+      programId: this._unstakingPoolProgramId,
+    });
+
+    const unstakingSolMint = PublicKey.findProgramAddressSync(
+      [Buffer.from(UNSTAKING_SOL_MINT_SEED), poolState.publicKey.toBytes()],
+      this._unstakingPoolProgramId
+    )[0];
+
+    const basePoolAuthority = PublicKey.findProgramAddressSync(
+      [Buffer.from(BASE_POOL_AUTHORITY_SEED), poolState.publicKey.toBytes()],
+      this._unstakingPoolProgramId
+    )[0];
+
+    const wsolVault = getAssociatedTokenAddress(WRAPPED_SOL_MINT, basePoolAuthority);
+
+    const initPoolAccounts: InitializePoolAccounts = {
+      admin: poolConfig.admin,
+      poolState: poolState.publicKey,
+      basePoolAuthority,
+      systemProgram: SystemProgram.programId,
+      rent: SYSVAR_RENT_PUBKEY,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      associatedTokenProgram: ASSOCIATED_TOKEN_PROGRAM_ID,
+      unstakingSolMint,
+      wsolMint: WRAPPED_SOL_MINT,
+      wsolVault,
+    };
+    const initPoolIx = initializePool(initPoolAccounts, this._unstakingPoolProgramId);
+
+    // create and set up the pool lookup table
+    const slot = await this._connection.getSlot();
+    const [createLUTIx, lut] = this.getInitLookupTableIx(poolConfig.admin, slot);
+
+    const allAccountsToBeInserted = [
+      poolState.publicKey,
+      basePoolAuthority,
+      wsolVault,
+      unstakingSolMint,
+      poolConfig.admin,
+      NATIVE_MINT,
+      this._unstakingPoolProgramId,
+      SystemProgram.programId,
+      SYSVAR_RENT_PUBKEY,
+      TOKEN_PROGRAM_ID,
+      TOKEN_2022_PROGRAM_ID,
+      SYSVAR_INSTRUCTIONS_PUBKEY,
+      SYSVAR_CLOCK_PUBKEY,
+      STAKE_PROGRAM_ID,
+      STAKE_POOL_PROGRAM_ID,
+    ];
+    const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(poolConfig.admin, lut, allAccountsToBeInserted, []);
+    const { updatePoolConfigIx: updateLUTIx } = await this.updatePoolConfigIxs(
+      poolState.publicKey,
+      poolConfig.admin,
+      new PoolConfigField.LookupTable(),
+      lut.toString()
+    );
+    const ixns = [createPoolIx, initPoolIx, createLUTIx, ...insertIntoLUTIxs, updateLUTIx];
+
+    if (poolConfig.actionAuthority) {
+      const { updatePoolConfigIx: updateActionAuthorityIx } = await this.updatePoolConfigIxs(
+        poolState.publicKey,
+        poolConfig.admin,
+        new PoolConfigField.ActionAuthority(),
+        poolConfig.actionAuthority.toString()
+      );
+      ixns.push(updateActionAuthorityIx);
+    }
+
+    return { pool: poolState, initPoolIxs: { initPoolIxs: ixns, populateLUTIxs: [] } };
+  }
+
+  /**
+   * Update pool configuration such as admin authority (or fees/minimum depositable in the future)
+   * @param poolState - the pool to update and set the LUT for if needed or only the pool pubkey if updating LUT is not needed
+   * @param admin - admin of the specified pool
+   * @param mode - what field to update for pool
+   * @param value - new value that is converted .toString()
+   * @returns a struct that contains a list of ix to update the pool config + a list of ixs to insert all new accounts in the LUT
+   */
+  async updatePoolConfigIxs(
+    poolState: UnstakingPool | PublicKey,
+    admin: PublicKey,
+    mode: PoolConfigFieldKind,
+    value: string
+  ): Promise<UpdatePoolConfigIxs> {
+    const updatePoolConfigAccounts: UpdatePoolConfigAccounts = {
+      admin,
+      poolState: poolState instanceof UnstakingPool ? poolState.address : poolState,
+    };
+    const args: UpdatePoolConfigArgs = {
+      entry: mode,
+      data: Buffer.from([0]),
+    };
+
+    if (isNaN(+value)) {
+      const data = new PublicKey(value);
+      args.data = data.toBuffer();
+    } else {
+      const buffer = Buffer.alloc(8);
+      buffer.writeBigUInt64LE(BigInt(value.toString()));
+      args.data = buffer;
+    }
+
+    const updatePoolConfigIx = updatePoolConfig(args, updatePoolConfigAccounts, this._unstakingPoolProgramId);
+
+    const updateLUTIxs: TransactionInstruction[] = [];
+
+    if (poolState instanceof UnstakingPool && poolState.state) {
+      if (mode.kind === new PoolConfigField.ActionAuthority().kind) {
+        const newPubkey = new PublicKey(value);
+        const insertIntoLutIxs = await this.insertIntoLookupTableIxs(
+          poolState.state.actionAuthority,
+          poolState.state.poolLookupTable,
+          [newPubkey]
+        );
+        updateLUTIxs.push(...insertIntoLutIxs);
+      }
+    }
+
+    return { updatePoolConfigIx, updateLUTIxs };
+  }
+
+  /**
+   * Collect a stake account SOL if the needed epoch was reached
+   * @param poolState - the pool to collect SOL into
+   * @param payer - payer for the operation (ix is permissionless)
+   * @param stakeAccount - stake account that was deactivated this epoch and has base pool authority as owner
+   * @returns collect instruction
+   */
+  async collectIx(
+    poolState: UnstakingPool,
+    payer: PublicKey,
+    stakeAccount: PublicKey
+  ): Promise<TransactionInstruction> {
+    const pool = await poolState.getState(this.getConnection());
+    const accounts: CollectAccounts = {
+      poolState: poolState.address,
+      payer,
+      stakeAccount,
+      basePoolAuthority: pool.basePoolAuthority,
+      wsolVault: pool.wsolVault,
+      wsolMint: NATIVE_MINT,
+      tokenProgram: TOKEN_PROGRAM_ID,
+      systemProgram: SystemProgram.programId,
+      clockProgramId: SYSVAR_CLOCK_PUBKEY,
+      stakeProgramId: STAKE_PROGRAM_ID,
+      stakeHistoryProgramId: STAKE_HISTORY_PROGRAM_ID,
+    };
+    return collect(accounts, this._unstakingPoolProgramId);
+  }
+
+  /**
+   * Burn a number of shares (USOL) in exchange for SOL
+   * @param poolState - the pool to burn USOL from
+   * @param user - user that burns (ix is not gated by action authority)
+   * @param sharesToBurn - number of shares that are equivalent 1:1 with SOL
+   * @returns burn instruction
+   */
+  async burnIx(poolState: UnstakingPool, user: PublicKey, sharesToBurn: BN): Promise<TransactionInstruction> {
+    const pool = await poolState.getState(this.getConnection());
+    const accounts: BurnAccounts = {
+      poolState: poolState.address,
+      basePoolAuthority: pool.basePoolAuthority,
+      wsolVault: pool.wsolVault,
+      wsolMint: NATIVE_MINT,
+      systemProgram: SystemProgram.programId,
+      user,
+      userWsolToken: getAssociatedTokenAddress(NATIVE_MINT, user),
+      userUnstakingSolToken: getAssociatedTokenAddress(pool.unstakingSolMint, user),
+      unstakingSolMint: pool.unstakingSolMint,
+      unstakingSolTokenProgram: TOKEN_PROGRAM_ID,
+      wsolTokenProgram: TOKEN_PROGRAM_ID,
+    };
+    const args: BurnArgs = {
+      sharesToBurn,
+    };
+    return burn(args, accounts, this._unstakingPoolProgramId);
+  }
+
+  /**
+   * Mints a number of unstaking sol (USOL) in exchange for staked SOL
+   * NOTE: this ix is permissioned by action authority
+   * @param poolState - the pool to mint USOL from
+   * @param user - user that mints
+   * @param stakedSolMint - staked sol mint
+   * @param stakedSolToDeposit - staked sol to convert to USOL (at the pool ratio)
+   * @returns burn instruction
+   */
+  async mintIx(
+    poolState: UnstakingPool,
+    user: PublicKey,
+    stakedSolMint: PublicKey,
+    stakedSolToDeposit: BN
+  ): Promise<MintIxs> {
+    const pool = await poolState.getState(this.getConnection());
+    const [stakedSolPool, stakedSolPoolPk, stakePoolType] = await mapStakedSolMintToPool(
+      this.getConnection(),
+      stakedSolMint
+    );
+    const accounts: MintAccounts = {
+      poolState: poolState.address,
+      basePoolAuthority: pool.basePoolAuthority,
+      systemProgram: SystemProgram.programId,
+      unstakingSolMint: pool.unstakingSolMint,
+      unstakingSolTokenProgram: TOKEN_PROGRAM_ID,
+      user,
+      actionAuthority: pool.actionAuthority,
+      userStakedSolToken: getAssociatedTokenAddress(stakedSolMint, user),
+      userUnstakingSolToken: getAssociatedTokenAddress(pool.unstakingSolMint, user),
+      stakedSolMint,
+      stakedSolTokenProgram: stakedSolPool.tokenProgramId,
+    };
+    const args: MintArgs = {
+      stakedSolToDeposit,
+    };
+    const txn = mint(args, accounts, this._unstakingPoolProgramId);
+    let remainingAccounts: AccountMeta[] = [];
+    let remainingSigners: Keypair[] = [];
+    switch (stakePoolType) {
+      case StakePoolType.Standard:
+        [remainingAccounts, remainingSigners] = await getStandardPoolMintRemainingAccounts(
+          this.getConnection(),
+          stakedSolPool,
+          stakedSolPoolPk,
+          stakedSolToDeposit
+        );
+    }
+    txn.keys = txn.keys.concat(remainingAccounts);
+    return { mintIx: txn, additionalSigners: remainingSigners };
+  }
+
+  /**
+   * Sync a pool for lookup table; create and set the LUT for the pool if needed and fill it with all the needed accounts
+   * @param pool the pool to sync and set the LUT for if needed
+   * @param poolReserves optional; the state of the reserves in the pool allocation
+   * @returns a struct that contains a list of ix to create the LUT and assign it to the pool if needed + a list of ixs to insert all the accounts in the LUT
+   */
+  async syncPoolLookupTable(pool: UnstakingPool): Promise<SyncVaultLUTIxs> {
+    const poolState = await pool.getState(this._connection);
+    const allAccountsToBeInserted = [
+      pool.address,
+      poolState.basePoolAuthority,
+      poolState.wsolVault,
+      poolState.unstakingSolMint,
+      poolState.actionAuthority,
+      poolState.admin,
+      this._unstakingPoolProgramId,
+      SystemProgram.programId,
+      SYSVAR_RENT_PUBKEY,
+      TOKEN_PROGRAM_ID,
+      TOKEN_2022_PROGRAM_ID,
+      SYSVAR_INSTRUCTIONS_PUBKEY,
+      SYSVAR_CLOCK_PUBKEY,
+      STAKE_PROGRAM_ID,
+      STAKE_POOL_PROGRAM_ID,
+    ];
+
+    const setupLUTIfNeededIxs: TransactionInstruction[] = [];
+    let lut = poolState.poolLookupTable;
+    if (lut.equals(PublicKey.default)) {
+      const recentSlot = await this._connection.getSlot();
+      const [ixn, address] = this.getInitLookupTableIx(poolState.admin, recentSlot);
+      setupLUTIfNeededIxs.push(ixn);
+      lut = address;
+
+      // set the new LUT for the pool
+      const updatePoolConfigIxs = await this.updatePoolConfigIxs(
+        pool,
+        pool.address,
+        new PoolConfigField.LookupTable(),
+        lut.toString()
+      );
+      setupLUTIfNeededIxs.push(updatePoolConfigIxs.updatePoolConfigIx);
+    }
+
+    const ixns: TransactionInstruction[] = [];
+    let overridenExistentAccounts: PublicKey[] | undefined = undefined;
+    if (poolState.poolLookupTable.equals(PublicKey.default)) {
+      overridenExistentAccounts = [];
+    }
+    ixns.push(
+      ...(await this.insertIntoLookupTableIxs(poolState.admin, lut, allAccountsToBeInserted, overridenExistentAccounts))
+    );
+
+    return {
+      setupLUTIfNeededIxs,
+      syncLUTIxs: ixns,
+    };
+  }
+
+  getInitLookupTableIx(payer: PublicKey, slot: number): [TransactionInstruction, PublicKey] {
+    const [ixn, address] = AddressLookupTableProgram.createLookupTable({
+      authority: payer,
+      payer,
+      recentSlot: slot,
+    });
+
+    return [ixn, address];
+  }
+
+  async insertIntoLookupTableIxs(
+    payer: PublicKey,
+    lookupTable: PublicKey,
+    keys: PublicKey[],
+    accountsInLUT?: PublicKey[]
+  ): Promise<TransactionInstruction[]> {
+    let lutContents = accountsInLUT;
+    if (!accountsInLUT) {
+      lutContents = await this.getAccountsInLUT(lookupTable);
+    } else {
+      lutContents = accountsInLUT;
+    }
+
+    const missingAccounts = keys.filter((key) => !lutContents!.includes(key) && !key.equals(PublicKey.default));
+    // deduplicate missing accounts and remove default accounts and convert it back to an array
+    const missingAccountsList = new PublicKeySet(missingAccounts).toArray();
+
+    const chunkSize = 20;
+    const ixns: TransactionInstruction[] = [];
+
+    for (let i = 0; i < missingAccountsList.length; i += chunkSize) {
+      const chunk = missingAccountsList.slice(i, i + chunkSize);
+      const ixn = AddressLookupTableProgram.extendLookupTable({
+        lookupTable,
+        authority: payer,
+        payer,
+        addresses: chunk,
+      });
+      ixns.push(ixn);
+    }
+
+    return ixns;
+  }
+
+  /**
+   *
+   * @param connection
+   * @param lookupTable
+   * @returns
+   */
+  async getAccountsInLUT(lookupTable: PublicKey): Promise<PublicKey[]> {
+    const lutState = await this._connection.getAddressLookupTable(lookupTable);
+    if (!lutState || !lutState.value) {
+      throw new Error(`Lookup table ${lookupTable.toString()} not found`);
+    }
+
+    return lutState.value.state.addresses;
+  }
+
+  deactivateLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+    const ixn = AddressLookupTableProgram.deactivateLookupTable({
+      authority: payer,
+      lookupTable: lookupTable,
+    });
+
+    return ixn;
+  }
+
+  /// this require the LUT to be deactivated at least 500 blocks before
+  closeLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+    const ixn = AddressLookupTableProgram.closeLookupTable({
+      authority: payer,
+      recipient: payer,
+      lookupTable: lookupTable,
+    });
+
+    return ixn;
+  }
+
+  /**
+   * Get all pools
+   * @returns an array of all pools
+   */
+  async getAllPools(): Promise<UnstakingPool[]> {
+    const filters = [
+      {
+        dataSize: PoolState.layout.span + 8,
+      },
+      {
+        memcmp: {
+          offset: 0,
+          bytes: bs58.encode(PoolState.discriminator),
+        },
+      },
+    ];
+
+    const unstakingPools: GetProgramAccountsResponse = await getProgramAccounts(
+      this._connection,
+      this._unstakingPoolProgramId,
+      PoolState.layout.span + 8,
+      {
+        commitment: this._connection.commitment ?? 'processed',
+        filters,
+      }
+    );
+
+    return unstakingPools.map((unstakingPool) => {
+      if (unstakingPool.account === null) {
+        throw new Error(`unstakingPool with pubkey ${unstakingPool.pubkey.toString()} does not exist`);
+      }
+
+      const unstakingPoolAccount = PoolState.decode(unstakingPool.account.data);
+      if (!unstakingPoolAccount) {
+        throw Error(`unstakingPool with pubkey ${unstakingPool.pubkey.toString()} could not be decoded`);
+      }
+
+      return new UnstakingPool(unstakingPool.pubkey, unstakingPoolAccount, this._unstakingPoolProgramId);
+    });
+  }
+} // UnstakingPoolClient
+
+export class UnstakingPool {
+  readonly address: PublicKey;
+  state: PoolState | undefined | null;
+  programId: PublicKey;
+
+  constructor(poolAddress: PublicKey, state?: PoolState, programId: PublicKey = unstakingPoolId) {
+    this.address = poolAddress;
+    this.state = state;
+    this.programId = programId;
+  }
+
+  async getState(connection: Connection): Promise<PoolState> {
+    if (!this.state) {
+      const res = await PoolState.fetch(connection, this.address, this.programId);
+      if (!res) {
+        throw new Error(`Invalid pool ${this.address.toString()}`);
+      }
+      this.state = res;
+      return res;
+    } else {
+      return this.state;
+    }
+  }
+
+  async reloadState(connection: Connection): Promise<PoolState> {
+    this.state = await PoolState.fetch(connection, this.address, this.programId);
+    if (!this.state) {
+      throw new Error(`Could not fetch pool ${this.address.toString()}`);
+    }
+    return this.state;
+  }
+
+  async getStakeAccountsForPool(connection: Connection): Promise<Array<[StakeAccount, PublicKey]>> {
+    if (!this.state) {
+      throw new Error('Need to have pool state to fetch stake accounts');
+    }
+    // Filter only accounts that have withdraw authority the base pool authority
+    //                           and are delegating
+    const results = await connection.getParsedProgramAccounts(STAKE_PROGRAM_ID, {
+      filters: [
+        { memcmp: { offset: 0, bytes: bs58.encode([2]) } },
+        { memcmp: { offset: 44, bytes: this.state.basePoolAuthority.toBase58() } },
+      ],
+    });
+    return results
+      .filter(result => 'parsed' in result.account.data)
+      .map(result => {
+	if(!('parsed' in result.account.data)) {
+	  throw new Error('Already filtered above for these, this error should not happen!');
+	}
+        return [result.account.data.parsed, result.pubkey];
+      })
+  }
+}
+
+/**
+ * Used to initialize a Kamino Pool
+ */
+export class UnstakingPoolConfig {
+  /** The admin of the pool */
+  readonly admin: PublicKey;
+  /** Pubkey that can mint new tokens */
+  readonly actionAuthority: PublicKey | null;
+
+  constructor(args: { admin: PublicKey; actionAuthority: PublicKey | null }) {
+    this.admin = args.admin;
+    this.actionAuthority = args.actionAuthority;
+  }
+}