@kamino-finance/klend-sdk 5.10.25 → 5.10.26-beta.0

package/src/idl_codegen_unstaking_pool/errors/custom.ts

@@ -0,0 +1,288 @@
+export type CustomError =
+  | IntegerOverflow
+  | StakePoolError
+  | InvalidStakePoolAccounts
+  | StakePoolDeserializeError
+  | InvalidStakePoolProgram
+  | InvalidStakePoolSize
+  | InvalidStakeAccountProgram
+  | InvalidStakeAccountSize
+  | InvalidStakeAccountCandidate
+  | StakeAccountDeserializeError
+  | UnexpectedSolToDestake
+  | UnexpectedSolToCollect
+  | InvalidStakedSolProgram
+  | CannotDepositZeroStakedSol
+  | CannotMintZeroShares
+  | CannotBurnZeroShares
+  | CannotCollectZeroSol
+  | NotEnoughWsol
+  | NotEnoughSharesIssued
+  | NotEnoughStakedSolToDeposit;
+
+export class IntegerOverflow extends Error {
+  static readonly code = 6000;
+  readonly code = 6000;
+  readonly name = 'IntegerOverflow';
+  readonly msg = 'IntegerOverflow';
+
+  constructor(readonly logs?: string[]) {
+    super('6000: IntegerOverflow');
+  }
+}
+
+export class StakePoolError extends Error {
+  static readonly code = 6001;
+  readonly code = 6001;
+  readonly name = 'StakePoolError';
+  readonly msg = 'Stake pool specific error';
+
+  constructor(readonly logs?: string[]) {
+    super('6001: Stake pool specific error');
+  }
+}
+
+export class InvalidStakePoolAccounts extends Error {
+  static readonly code = 6002;
+  readonly code = 6002;
+  readonly name = 'InvalidStakePoolAccounts';
+  readonly msg = 'Passed stake pool accounts are not valid';
+
+  constructor(readonly logs?: string[]) {
+    super('6002: Passed stake pool accounts are not valid');
+  }
+}
+
+export class StakePoolDeserializeError extends Error {
+  static readonly code = 6003;
+  readonly code = 6003;
+  readonly name = 'StakePoolDeserializeError';
+  readonly msg = 'Stake pool deserialization error';
+
+  constructor(readonly logs?: string[]) {
+    super('6003: Stake pool deserialization error');
+  }
+}
+
+export class InvalidStakePoolProgram extends Error {
+  static readonly code = 6004;
+  readonly code = 6004;
+  readonly name = 'InvalidStakePoolProgram';
+  readonly msg = 'Stake pool invalid program';
+
+  constructor(readonly logs?: string[]) {
+    super('6004: Stake pool invalid program');
+  }
+}
+
+export class InvalidStakePoolSize extends Error {
+  static readonly code = 6005;
+  readonly code = 6005;
+  readonly name = 'InvalidStakePoolSize';
+  readonly msg = 'Stake pool invalid size';
+
+  constructor(readonly logs?: string[]) {
+    super('6005: Stake pool invalid size');
+  }
+}
+
+export class InvalidStakeAccountProgram extends Error {
+  static readonly code = 6006;
+  readonly code = 6006;
+  readonly name = 'InvalidStakeAccountProgram';
+  readonly msg = 'Stake account invalid program';
+
+  constructor(readonly logs?: string[]) {
+    super('6006: Stake account invalid program');
+  }
+}
+
+export class InvalidStakeAccountSize extends Error {
+  static readonly code = 6007;
+  readonly code = 6007;
+  readonly name = 'InvalidStakeAccountSize';
+  readonly msg = 'Stake account invalid size';
+
+  constructor(readonly logs?: string[]) {
+    super('6007: Stake account invalid size');
+  }
+}
+
+export class InvalidStakeAccountCandidate extends Error {
+  static readonly code = 6008;
+  readonly code = 6008;
+  readonly name = 'InvalidStakeAccountCandidate';
+  readonly msg = 'Stake account candidates should be uninitialized accounts';
+
+  constructor(readonly logs?: string[]) {
+    super('6008: Stake account candidates should be uninitialized accounts');
+  }
+}
+
+export class StakeAccountDeserializeError extends Error {
+  static readonly code = 6009;
+  readonly code = 6009;
+  readonly name = 'StakeAccountDeserializeError';
+  readonly msg = 'Stake account deserialization error';
+
+  constructor(readonly logs?: string[]) {
+    super('6009: Stake account deserialization error');
+  }
+}
+
+export class UnexpectedSolToDestake extends Error {
+  static readonly code = 6010;
+  readonly code = 6010;
+  readonly name = 'UnexpectedSolToDestake';
+  readonly msg = 'Simulation and actual cpi call have different results for withdrawing sol from stake pool';
+
+  constructor(readonly logs?: string[]) {
+    super('6010: Simulation and actual cpi call have different results for withdrawing sol from stake pool');
+  }
+}
+
+export class UnexpectedSolToCollect extends Error {
+  static readonly code = 6011;
+  readonly code = 6011;
+  readonly name = 'UnexpectedSolToCollect';
+  readonly msg = 'Simulation and actual cpi call have different results for collecting sol from stake account';
+
+  constructor(readonly logs?: string[]) {
+    super('6011: Simulation and actual cpi call have different results for collecting sol from stake account');
+  }
+}
+
+export class InvalidStakedSolProgram extends Error {
+  static readonly code = 6012;
+  readonly code = 6012;
+  readonly name = 'InvalidStakedSolProgram';
+  readonly msg = 'Staked sol program not support';
+
+  constructor(readonly logs?: string[]) {
+    super('6012: Staked sol program not support');
+  }
+}
+
+export class CannotDepositZeroStakedSol extends Error {
+  static readonly code = 6013;
+  readonly code = 6013;
+  readonly name = 'CannotDepositZeroStakedSol';
+  readonly msg = 'Cannot deposit 0 staked sol';
+
+  constructor(readonly logs?: string[]) {
+    super('6013: Cannot deposit 0 staked sol');
+  }
+}
+
+export class CannotMintZeroShares extends Error {
+  static readonly code = 6014;
+  readonly code = 6014;
+  readonly name = 'CannotMintZeroShares';
+  readonly msg = 'Cannot mint 0 shares';
+
+  constructor(readonly logs?: string[]) {
+    super('6014: Cannot mint 0 shares');
+  }
+}
+
+export class CannotBurnZeroShares extends Error {
+  static readonly code = 6015;
+  readonly code = 6015;
+  readonly name = 'CannotBurnZeroShares';
+  readonly msg = 'Cannot burn 0 shares';
+
+  constructor(readonly logs?: string[]) {
+    super('6015: Cannot burn 0 shares');
+  }
+}
+
+export class CannotCollectZeroSol extends Error {
+  static readonly code = 6016;
+  readonly code = 6016;
+  readonly name = 'CannotCollectZeroSol';
+  readonly msg = 'Cannot collect 0';
+
+  constructor(readonly logs?: string[]) {
+    super('6016: Cannot collect 0');
+  }
+}
+
+export class NotEnoughWsol extends Error {
+  static readonly code = 6017;
+  readonly code = 6017;
+  readonly name = 'NotEnoughWsol';
+  readonly msg = 'Not enough wsol in vault';
+
+  constructor(readonly logs?: string[]) {
+    super('6017: Not enough wsol in vault');
+  }
+}
+
+export class NotEnoughSharesIssued extends Error {
+  static readonly code = 6018;
+  readonly code = 6018;
+  readonly name = 'NotEnoughSharesIssued';
+  readonly msg = 'Not enough shares issued';
+
+  constructor(readonly logs?: string[]) {
+    super('6018: Not enough shares issued');
+  }
+}
+
+export class NotEnoughStakedSolToDeposit extends Error {
+  static readonly code = 6019;
+  readonly code = 6019;
+  readonly name = 'NotEnoughStakedSolToDeposit';
+  readonly msg = 'Not enough staked sol to deposit (must be at least equivalent to minimum pool delegation)';
+
+  constructor(readonly logs?: string[]) {
+    super('6019: Not enough staked sol to deposit (must be at least equivalent to minimum pool delegation)');
+  }
+}
+
+export function fromCode(code: number, logs?: string[]): CustomError | null {
+  switch (code) {
+    case 6000:
+      return new IntegerOverflow(logs);
+    case 6001:
+      return new StakePoolError(logs);
+    case 6002:
+      return new InvalidStakePoolAccounts(logs);
+    case 6003:
+      return new StakePoolDeserializeError(logs);
+    case 6004:
+      return new InvalidStakePoolProgram(logs);
+    case 6005:
+      return new InvalidStakePoolSize(logs);
+    case 6006:
+      return new InvalidStakeAccountProgram(logs);
+    case 6007:
+      return new InvalidStakeAccountSize(logs);
+    case 6008:
+      return new InvalidStakeAccountCandidate(logs);
+    case 6009:
+      return new StakeAccountDeserializeError(logs);
+    case 6010:
+      return new UnexpectedSolToDestake(logs);
+    case 6011:
+      return new UnexpectedSolToCollect(logs);
+    case 6012:
+      return new InvalidStakedSolProgram(logs);
+    case 6013:
+      return new CannotDepositZeroStakedSol(logs);
+    case 6014:
+      return new CannotMintZeroShares(logs);
+    case 6015:
+      return new CannotBurnZeroShares(logs);
+    case 6016:
+      return new CannotCollectZeroSol(logs);
+    case 6017:
+      return new NotEnoughWsol(logs);
+    case 6018:
+      return new NotEnoughSharesIssued(logs);
+    case 6019:
+      return new NotEnoughStakedSolToDeposit(logs);
+  }
+
+  return null;
+}

package/src/idl_codegen_unstaking_pool/errors/index.ts

@@ -0,0 +1,49 @@
+import { PublicKey } from '@solana/web3.js';
+import { PROGRAM_ID } from '../programId';
+import * as anchor from './anchor';
+import * as custom from './custom';
+
+export function fromCode(code: number, logs?: string[]): custom.CustomError | anchor.AnchorError | null {
+  return code >= 6000 ? custom.fromCode(code, logs) : anchor.fromCode(code, logs);
+}
+
+function hasOwnProperty<X extends object, Y extends PropertyKey>(obj: X, prop: Y): obj is X & Record<Y, unknown> {
+  return Object.hasOwnProperty.call(obj, prop);
+}
+
+const errorRe = /Program (\w+) failed: custom program error: (\w+)/;
+
+export function fromTxError(
+  err: unknown,
+  programId: PublicKey = PROGRAM_ID
+): custom.CustomError | anchor.AnchorError | null {
+  if (typeof err !== 'object' || err === null || !hasOwnProperty(err, 'logs') || !Array.isArray(err.logs)) {
+    return null;
+  }
+
+  let firstMatch: RegExpExecArray | null = null;
+  for (const logLine of err.logs) {
+    firstMatch = errorRe.exec(logLine);
+    if (firstMatch !== null) {
+      break;
+    }
+  }
+
+  if (firstMatch === null) {
+    return null;
+  }
+
+  const [programIdRaw, codeRaw] = firstMatch.slice(1);
+  if (programIdRaw !== programId.toString()) {
+    return null;
+  }
+
+  let errorCode: number;
+  try {
+    errorCode = parseInt(codeRaw, 16);
+  } catch (parseErr) {
+    return null;
+  }
+
+  return fromCode(errorCode, err.logs);
+}

package/src/idl_codegen_unstaking_pool/instructions/burn.ts

@@ -0,0 +1,60 @@
+import { TransactionInstruction, PublicKey, AccountMeta } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from '../programId';
+
+export interface BurnArgs {
+  sharesToBurn: BN;
+}
+
+export interface BurnAccounts {
+  user: PublicKey;
+  userWsolToken: PublicKey;
+  userUnstakingSolToken: PublicKey;
+  wsolVault: PublicKey;
+  wsolMint: PublicKey;
+  poolState: PublicKey;
+  unstakingSolMint: PublicKey;
+  basePoolAuthority: PublicKey;
+  systemProgram: PublicKey;
+  unstakingSolTokenProgram: PublicKey;
+  wsolTokenProgram: PublicKey;
+}
+
+export const layout = borsh.struct([borsh.u64('sharesToBurn')]);
+
+export function burn(args: BurnArgs, accounts: BurnAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.user, isSigner: true, isWritable: false },
+    { pubkey: accounts.userWsolToken, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.userUnstakingSolToken,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.wsolVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.wsolMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.poolState, isSigner: false, isWritable: true },
+    { pubkey: accounts.unstakingSolMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.basePoolAuthority, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.unstakingSolTokenProgram,
+      isSigner: false,
+      isWritable: false,
+    },
+    { pubkey: accounts.wsolTokenProgram, isSigner: false, isWritable: false },
+  ];
+  const identifier = Buffer.from([116, 110, 29, 56, 107, 219, 42, 93]);
+  const buffer = Buffer.alloc(1000);
+  const len = layout.encode(
+    {
+      sharesToBurn: args.sharesToBurn,
+    },
+    buffer
+  );
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_unstaking_pool/instructions/collect.ts

@@ -0,0 +1,43 @@
+import { TransactionInstruction, PublicKey, AccountMeta } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from '../programId';
+
+export interface CollectAccounts {
+  payer: PublicKey;
+  stakeAccount: PublicKey;
+  poolState: PublicKey;
+  basePoolAuthority: PublicKey;
+  wsolVault: PublicKey;
+  wsolMint: PublicKey;
+  tokenProgram: PublicKey;
+  systemProgram: PublicKey;
+  clockProgramId: PublicKey;
+  stakeProgramId: PublicKey;
+  stakeHistoryProgramId: PublicKey;
+}
+
+export function collect(accounts: CollectAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.payer, isSigner: true, isWritable: true },
+    { pubkey: accounts.stakeAccount, isSigner: false, isWritable: true },
+    { pubkey: accounts.poolState, isSigner: false, isWritable: true },
+    { pubkey: accounts.basePoolAuthority, isSigner: false, isWritable: true },
+    { pubkey: accounts.wsolVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.wsolMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.clockProgramId, isSigner: false, isWritable: false },
+    { pubkey: accounts.stakeProgramId, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.stakeHistoryProgramId,
+      isSigner: false,
+      isWritable: false,
+    },
+  ];
+  const identifier = Buffer.from([208, 47, 194, 155, 17, 98, 82, 236]);
+  const data = identifier;
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_unstaking_pool/instructions/index.ts

@@ -0,0 +1,10 @@
+export { initializePool } from './initializePool';
+export type { InitializePoolAccounts } from './initializePool';
+export { mint } from './mint';
+export type { MintArgs, MintAccounts } from './mint';
+export { collect } from './collect';
+export type { CollectAccounts } from './collect';
+export { burn } from './burn';
+export type { BurnArgs, BurnAccounts } from './burn';
+export { updatePoolConfig } from './updatePoolConfig';
+export type { UpdatePoolConfigArgs, UpdatePoolConfigAccounts } from './updatePoolConfig';

package/src/idl_codegen_unstaking_pool/instructions/initializePool.ts

@@ -0,0 +1,41 @@
+import { TransactionInstruction, PublicKey, AccountMeta } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from '../programId';
+
+export interface InitializePoolAccounts {
+  admin: PublicKey;
+  poolState: PublicKey;
+  unstakingSolMint: PublicKey;
+  wsolMint: PublicKey;
+  basePoolAuthority: PublicKey;
+  wsolVault: PublicKey;
+  systemProgram: PublicKey;
+  rent: PublicKey;
+  tokenProgram: PublicKey;
+  associatedTokenProgram: PublicKey;
+}
+
+export function initializePool(accounts: InitializePoolAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.admin, isSigner: true, isWritable: true },
+    { pubkey: accounts.poolState, isSigner: false, isWritable: true },
+    { pubkey: accounts.unstakingSolMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.wsolMint, isSigner: false, isWritable: false },
+    { pubkey: accounts.basePoolAuthority, isSigner: false, isWritable: false },
+    { pubkey: accounts.wsolVault, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    { pubkey: accounts.rent, isSigner: false, isWritable: false },
+    { pubkey: accounts.tokenProgram, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.associatedTokenProgram,
+      isSigner: false,
+      isWritable: false,
+    },
+  ];
+  const identifier = Buffer.from([95, 180, 10, 172, 84, 174, 232, 40]);
+  const data = identifier;
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_unstaking_pool/instructions/mint.ts

@@ -0,0 +1,64 @@
+import { TransactionInstruction, PublicKey, AccountMeta } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from '../programId';
+
+export interface MintArgs {
+  stakedSolToDeposit: BN;
+}
+
+export interface MintAccounts {
+  user: PublicKey;
+  actionAuthority: PublicKey;
+  userStakedSolToken: PublicKey;
+  userUnstakingSolToken: PublicKey;
+  stakedSolMint: PublicKey;
+  poolState: PublicKey;
+  unstakingSolMint: PublicKey;
+  basePoolAuthority: PublicKey;
+  systemProgram: PublicKey;
+  unstakingSolTokenProgram: PublicKey;
+  stakedSolTokenProgram: PublicKey;
+}
+
+export const layout = borsh.struct([borsh.u64('stakedSolToDeposit')]);
+
+export function mint(args: MintArgs, accounts: MintAccounts, programId: PublicKey = PROGRAM_ID) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.user, isSigner: true, isWritable: true },
+    { pubkey: accounts.actionAuthority, isSigner: true, isWritable: false },
+    { pubkey: accounts.userStakedSolToken, isSigner: false, isWritable: true },
+    {
+      pubkey: accounts.userUnstakingSolToken,
+      isSigner: false,
+      isWritable: true,
+    },
+    { pubkey: accounts.stakedSolMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.poolState, isSigner: false, isWritable: true },
+    { pubkey: accounts.unstakingSolMint, isSigner: false, isWritable: true },
+    { pubkey: accounts.basePoolAuthority, isSigner: false, isWritable: true },
+    { pubkey: accounts.systemProgram, isSigner: false, isWritable: false },
+    {
+      pubkey: accounts.unstakingSolTokenProgram,
+      isSigner: false,
+      isWritable: false,
+    },
+    {
+      pubkey: accounts.stakedSolTokenProgram,
+      isSigner: false,
+      isWritable: false,
+    },
+  ];
+  const identifier = Buffer.from([51, 57, 225, 47, 182, 146, 137, 166]);
+  const buffer = Buffer.alloc(1000);
+  const len = layout.encode(
+    {
+      stakedSolToDeposit: args.stakedSolToDeposit,
+    },
+    buffer
+  );
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_unstaking_pool/instructions/updatePoolConfig.ts

@@ -0,0 +1,40 @@
+import { TransactionInstruction, PublicKey, AccountMeta } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import { PROGRAM_ID } from '../programId';
+
+export interface UpdatePoolConfigArgs {
+  entry: types.PoolConfigFieldKind;
+  data: Uint8Array;
+}
+
+export interface UpdatePoolConfigAccounts {
+  admin: PublicKey;
+  poolState: PublicKey;
+}
+
+export const layout = borsh.struct([types.PoolConfigField.layout('entry'), borsh.vecU8('data')]);
+
+export function updatePoolConfig(
+  args: UpdatePoolConfigArgs,
+  accounts: UpdatePoolConfigAccounts,
+  programId: PublicKey = PROGRAM_ID
+) {
+  const keys: Array<AccountMeta> = [
+    { pubkey: accounts.admin, isSigner: true, isWritable: false },
+    { pubkey: accounts.poolState, isSigner: false, isWritable: true },
+  ];
+  const identifier = Buffer.from([68, 236, 203, 122, 179, 62, 234, 252]);
+  const buffer = Buffer.alloc(1000);
+  const len = layout.encode(
+    {
+      entry: args.entry.toEncodable(),
+      data: Buffer.from(args.data.buffer, args.data.byteOffset, args.data.length),
+    },
+    buffer
+  );
+  const data = Buffer.concat([identifier, buffer]).slice(0, 8 + len);
+  const ix = new TransactionInstruction({ keys, programId, data });
+  return ix;
+}

package/src/idl_codegen_unstaking_pool/programId.ts

@@ -0,0 +1,7 @@
+import { PublicKey } from '@solana/web3.js';
+
+// Program ID passed with the cli --program-id flag when running the code generator. Do not edit, it will get overwritten.
+export const PROGRAM_ID_CLI = new PublicKey('USo1uB8RsRuM8y8e8vbL3mwR22EzSTLyZqaJPoZvn3a');
+
+// This constant will not get overwritten on subsequent code generations and it's safe to modify it's value.
+export const PROGRAM_ID: PublicKey = PROGRAM_ID_CLI;

package/src/idl_codegen_unstaking_pool/types/PoolConfigField.ts

@@ -0,0 +1,85 @@
+import { PublicKey } from '@solana/web3.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import BN from 'bn.js'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as types from '../types'; // eslint-disable-line @typescript-eslint/no-unused-vars
+import * as borsh from '@coral-xyz/borsh';
+
+export interface ActionAuthorityJSON {
+  kind: 'ActionAuthority';
+}
+
+export class ActionAuthority {
+  static readonly discriminator = 0;
+  static readonly kind = 'ActionAuthority';
+  readonly discriminator = 0;
+  readonly kind = 'ActionAuthority';
+
+  toJSON(): ActionAuthorityJSON {
+    return {
+      kind: 'ActionAuthority',
+    };
+  }
+
+  toEncodable() {
+    return {
+      ActionAuthority: {},
+    };
+  }
+}
+
+export interface LookupTableJSON {
+  kind: 'LookupTable';
+}
+
+export class LookupTable {
+  static readonly discriminator = 1;
+  static readonly kind = 'LookupTable';
+  readonly discriminator = 1;
+  readonly kind = 'LookupTable';
+
+  toJSON(): LookupTableJSON {
+    return {
+      kind: 'LookupTable',
+    };
+  }
+
+  toEncodable() {
+    return {
+      LookupTable: {},
+    };
+  }
+}
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export function fromDecoded(obj: any): types.PoolConfigFieldKind {
+  if (typeof obj !== 'object') {
+    throw new Error('Invalid enum object');
+  }
+
+  if ('ActionAuthority' in obj) {
+    return new ActionAuthority();
+  }
+  if ('LookupTable' in obj) {
+    return new LookupTable();
+  }
+
+  throw new Error('Invalid enum object');
+}
+
+export function fromJSON(obj: types.PoolConfigFieldJSON): types.PoolConfigFieldKind {
+  switch (obj.kind) {
+    case 'ActionAuthority': {
+      return new ActionAuthority();
+    }
+    case 'LookupTable': {
+      return new LookupTable();
+    }
+  }
+}
+
+export function layout(property?: string) {
+  const ret = borsh.rustEnum([borsh.struct([], 'ActionAuthority'), borsh.struct([], 'LookupTable')]);
+  if (property !== undefined) {
+    return ret.replicate(property);
+  }
+  return ret;
+}