@kamino-finance/kliquidity-sdk 8.4.6 → 8.4.7-beta.0

package/src/utils/transactions.ts

@@ -1,64 +1,66 @@
 import {
-  Address,
-  GetAccountInfoApi,
-  GetTokenAccountBalanceApi,
-  Instruction,
-  Rpc,
-  TransactionSigner,
-} from '@solana/kit';
+  AccountInfo,
+  ComputeBudgetProgram,
+  Connection,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js';
 import Decimal from 'decimal.js';
-import { DECIMALS_SOL, createAssociatedTokenAccountInstruction, getAssociatedTokenAddress } from './tokenUtils';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  DECIMALS_SOL,
+  createAssociatedTokenAccountInstruction,
+  getAssociatedTokenAddress,
+} from './tokenUtils';
+import { createCloseAccountInstruction, NATIVE_MINT, TOKEN_PROGRAM_ID } from '@solana/spl-token';
 import { collToLamportsDecimal } from './utils';
 import { CreateAta } from './types';
-import { DEFAULT_PUBLIC_KEY, WRAPPED_SOL_MINT } from '../constants/pubkeys';
-import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
-import {
-  COMPUTE_BUDGET_PROGRAM_ADDRESS,
-  getSetComputeUnitLimitInstruction,
-  getSetComputeUnitPriceInstruction,
-} from '@solana-program/compute-budget';
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-  fetchMaybeToken,
-  getCloseAccountInstruction,
-  getSyncNativeInstruction,
-} from '@solana-program/token-2022';
-import { getTransferSolInstruction } from '@solana-program/system';
 
 export const MAX_ACCOUNTS_PER_TRANSACTION = 64;
 
-export const getComputeBudgetAndPriorityFeeIxns = (units: number, priorityFeeLamports?: Decimal): Instruction[] => {
-  const ixns: Instruction[] = [];
+export const decodeSerializedTransaction = (tx: string | undefined) => {
+  if (!tx) {
+    return undefined;
+  }
+  return Transaction.from(Buffer.from(tx, 'base64'));
+};
 
-  ixns.push(getSetComputeUnitLimitInstruction({ units }));
+export const getComputeBudgetAndPriorityFeeIxns = (
+  units: number,
+  priorityFeeLamports?: Decimal
+): TransactionInstruction[] => {
+  const ixns: TransactionInstruction[] = [];
+  ixns.push(ComputeBudgetProgram.setComputeUnitLimit({ units }));
 
   if (priorityFeeLamports && priorityFeeLamports.gt(0)) {
     const unitPrice = priorityFeeLamports.mul(10 ** 6).div(units);
-    ixns.push(getSetComputeUnitPriceInstruction({ microLamports: BigInt(unitPrice.floor().toString()) }));
+    ixns.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: BigInt(unitPrice.floor().toString()) }));
   }
 
   return ixns;
 };
 
 export const createAtaIfMissingIx = async (
-  connection: Rpc<GetAccountInfoApi>,
-  mint: Address,
-  owner: TransactionSigner,
-  programId: Address
-): Promise<Instruction | undefined> => {
-  const ata = await getAssociatedTokenAddress(mint, owner.address, programId);
+  connection: Connection,
+  mint: PublicKey,
+  owner: PublicKey,
+  programId: PublicKey
+): Promise<TransactionInstruction | undefined> => {
+  const ata = await getAssociatedTokenAddress(mint, owner, true, programId);
   const doesAtaExist = Boolean(await checkIfAccountExists(connection, ata));
   const createIxn = !doesAtaExist
-    ? createAssociatedTokenAccountInstruction(owner, ata, owner.address, mint, programId)
+    ? createAssociatedTokenAccountInstruction(owner, ata, owner, mint, programId)
     : undefined;
   return createIxn;
 };
 
 export const getAtasWithCreateIxnsIfMissing = async (
-  connection: Rpc<any>,
-  mints: [Address, Address][],
-  owner: TransactionSigner
-): Promise<Instruction[]> => {
+  connection: Connection,
+  mints: [PublicKey, PublicKey][],
+  owner: PublicKey
+): Promise<TransactionInstruction[]> => {
   const requests = mints.map(async ([mint, tokenProgram]) => {
     const createAtaIx = await createAtaIfMissingIx(connection, mint, owner, tokenProgram);
     if (createAtaIx) {
@@ -68,36 +70,34 @@ export const getAtasWithCreateIxnsIfMissing = async (
   });
   const result = (await Promise.all(requests.filter((x) => x !== undefined))).filter(
     (ix) => ix !== undefined
-  ) as Instruction[];
+  ) as TransactionInstruction[];
 
   return result;
 };
 
 export const createWsolAtaIfMissing = async (
-  rpc: Rpc<GetAccountInfoApi & GetTokenAccountBalanceApi>,
+  connection: Connection,
   amount: Decimal,
-  owner: TransactionSigner,
+  owner: PublicKey,
   method: 'deposit' | 'withdraw' = 'deposit'
 ): Promise<CreateAta> => {
-  const createIxns: Instruction[] = [];
-  const closeIxns: Instruction[] = [];
+  const createIxns: TransactionInstruction[] = [];
+  const closeIxns: TransactionInstruction[] = [];
 
-  const wsolAta: Address = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address);
+  const wsolAta: PublicKey = await getAssociatedTokenAddress(NATIVE_MINT, owner, true, TOKEN_PROGRAM_ID);
 
   const solDeposit = amount.toNumber();
-  const wsolAtaTokenAccount = await fetchMaybeToken(rpc, wsolAta);
+  const wsolAtaAccountInfo: AccountInfo<Buffer> | null = await connection.getAccountInfo(wsolAta);
 
   // This checks if we need to create it
-  if (!wsolAtaTokenAccount.exists) {
-    createIxns.push(
-      createAssociatedTokenAccountInstruction(owner, wsolAta, owner.address, WRAPPED_SOL_MINT, TOKEN_PROGRAM_ADDRESS)
-    );
+  if (isWsolInfoInvalid(wsolAtaAccountInfo)) {
+    createIxns.push(createAssociatedTokenAccountInstruction(owner, wsolAta, owner, NATIVE_MINT, TOKEN_PROGRAM_ID));
   }
 
   let uiAmount = 0;
   try {
-    if (wsolAtaTokenAccount.exists) {
-      const tokenBalance = await findAtaBalance(rpc, wsolAta);
+    if (wsolAtaAccountInfo != null) {
+      const tokenBalance = await findAtaBalance(connection, wsolAta);
       uiAmount = tokenBalance === null ? 0 : tokenBalance;
     }
   } catch (err) {
@@ -106,35 +106,36 @@ export const createWsolAtaIfMissing = async (
 
   if (solDeposit !== null && solDeposit > uiAmount && method === 'deposit') {
     createIxns.push(
-      getTransferSolInstruction({
-        amount: BigInt(
+      SystemProgram.transfer({
+        fromPubkey: owner,
+        toPubkey: wsolAta,
+        lamports: BigInt(
           collToLamportsDecimal(new Decimal(solDeposit - uiAmount), DECIMALS_SOL)
             .floor()
             .toString()
         ),
-        source: owner,
-        destination: wsolAta,
       })
     );
   }
 
   if (createIxns.length > 0) {
     createIxns.push(
-      getSyncNativeInstruction(
-        {
-          account: wsolAta,
-        },
-        { programAddress: TOKEN_PROGRAM_ADDRESS }
-      )
+      // Sync Native instruction. @solana/spl-token will release it soon. Here use the raw instruction temporally.
+      new TransactionInstruction({
+        keys: [
+          {
+            pubkey: wsolAta,
+            isSigner: false,
+            isWritable: true,
+          },
+        ],
+        data: Buffer.from(new Uint8Array([17])),
+        programId: TOKEN_PROGRAM_ID,
+      })
     );
   }
 
-  closeIxns.push(
-    getCloseAccountInstruction(
-      { account: wsolAta, owner: owner, destination: owner.address, multiSigners: [] },
-      { programAddress: TOKEN_PROGRAM_ADDRESS }
-    )
-  );
+  closeIxns.push(createCloseAccountInstruction(wsolAta, owner, owner, [], TOKEN_PROGRAM_ID));
 
   return {
     ata: wsolAta,
@@ -148,40 +149,35 @@ export const isWsolInfoInvalid = (wsolAtaAccountInfo: any): boolean => {
     wsolAtaAccountInfo === null ||
     (wsolAtaAccountInfo !== null &&
       wsolAtaAccountInfo.data.length === 0 &&
-      wsolAtaAccountInfo.owner === DEFAULT_PUBLIC_KEY);
+      wsolAtaAccountInfo.owner.toString() === '11111111111111111111111111111111');
 
   return res;
 };
 
-export async function checkIfAccountExists(connection: Rpc<GetAccountInfoApi>, account: Address): Promise<boolean> {
-  return (await connection.getAccountInfo(account, { encoding: 'base64' }).send()).value != null;
+export async function checkIfAccountExists(connection: Connection, account: PublicKey): Promise<boolean> {
+  return (await connection.getAccountInfo(account)) != null;
 }
 
-export function removeBudgetAndAtaIxns(ixns: Instruction[], mints: Address[]): Instruction[] {
+export function removeBudgetAndAtaIxns(ixns: TransactionInstruction[], mints: PublicKey[]): TransactionInstruction[] {
   return ixns.filter((ixn) => {
-    const { programAddress, accounts } = ixn;
+    const { programId, keys } = ixn;
 
-    if (programAddress === COMPUTE_BUDGET_PROGRAM_ADDRESS) {
+    if (programId.equals(ComputeBudgetProgram.programId)) {
       return false;
     }
 
-    if (programAddress === ASSOCIATED_TOKEN_PROGRAM_ADDRESS) {
-      if (!accounts || accounts.length < 2) {
-        return true;
-      }
-      const mint = accounts[3];
-      return !mints.includes(mint.address);
+    if (programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mint = keys[3];
+
+      return !mints.includes(mint.pubkey);
     }
 
     return true;
   });
 }
 
-export const findAtaBalance = async (
-  connection: Rpc<GetTokenAccountBalanceApi>,
-  ata: Address
-): Promise<number | null> => {
-  const res = await connection.getTokenAccountBalance(ata).send();
+export const findAtaBalance = async (connection: Connection, ata: PublicKey): Promise<number | null> => {
+  const res = await connection.getTokenAccountBalance(ata);
   if (res && res.value) {
     return res.value.uiAmount;
   }

package/src/utils/types.ts

@@ -1,12 +1,10 @@
-import { BN } from '@coral-xyz/anchor';
-
-import { address, Address, Instruction, TransactionMessage, TransactionSigner } from '@solana/kit';
-import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
+import { PublicKey, TransactionInstruction, TransactionMessage } from '@solana/web3.js';
+import { WhirlpoolStrategy } from '../kamino-client/accounts';
 import { Dex, collToLamportsDecimal } from './utils';
 import Decimal from 'decimal.js';
-import { RebalanceTypeKind } from '../@codegen/kliquidity/types';
+import { RebalanceTypeKind } from '../kamino-client/types';
 
-export const RAYDIUM_DEVNET_PROGRAM_ID = address('devi51mZmdwUJGU9hjN27vEz64Gps7uUefqxg27EAtH');
+export const RAYDIUM_DEVNET_PROGRAM_ID = new PublicKey('devi51mZmdwUJGU9hjN27vEz64Gps7uUefqxg27EAtH');
 
 export type StrategyType = 'NON_PEGGED' | 'PEGGED' | 'STABLE';
 export type StrategyCreationStatus = 'IGNORED' | 'SHADOW' | 'LIVE' | 'DEPRECATED' | 'STAGING';
@@ -15,7 +13,7 @@ export type StrategiesFilters = {
   strategyType?: StrategyType;
   strategyCreationStatus?: StrategyCreationStatus;
   isCommunity?: boolean;
-  owner?: Address;
+  owner?: PublicKey;
 };
 
 export function strategyTypeToBase58(strategyType: StrategyType): string {
@@ -110,9 +108,9 @@ export function getStrategyCreationStatusFromStrategy(strategy: WhirlpoolStrateg
 
 export interface GenericPoolInfo {
   dex: Dex;
-  address: Address;
-  tokenMintA: Address;
-  tokenMintB: Address;
+  address: PublicKey;
+  tokenMintA: PublicKey;
+  tokenMintB: PublicKey;
   price: Decimal;
   feeRate: Decimal;
   volumeOnLast7d: Decimal | undefined;
@@ -127,8 +125,8 @@ export interface GenericPositionRangeInfo {
 }
 
 export interface VaultParameters {
-  tokenMintA: Address;
-  tokenMintB: Address;
+  tokenMintA: PublicKey;
+  tokenMintB: PublicKey;
   dex: Dex;
   feeTier: Decimal;
   rebalancingParameters: RebalanceFieldInfo[];
@@ -209,12 +207,12 @@ export interface TokensBalances {
 export interface SwapperIxBuilder {
   (
     input: DepositAmountsForSwap,
-    tokenAMint: Address,
-    tokenBMint: Address,
-    owner: TransactionSigner,
+    tokenAMint: PublicKey,
+    tokenBMint: PublicKey,
+    owner: PublicKey,
     slippage: Decimal,
-    allKeys: Address[]
-  ): Promise<[Instruction[], Address[]]>;
+    allKeys: PublicKey[]
+  ): Promise<[TransactionInstruction[], PublicKey[]]>;
 }
 
 export interface ProfiledFunctionExecution {
@@ -226,19 +224,19 @@ export function noopProfiledFunctionExecution(promise: Promise<any>): Promise<an
 }
 
 export interface CreateAta {
-  ata: Address;
-  createIxns: Instruction[];
-  closeIxns: Instruction[];
+  ata: PublicKey;
+  createIxns: TransactionInstruction[];
+  closeIxns: TransactionInstruction[];
 }
 
 export interface DeserializedVersionedTransaction {
   txMessage: TransactionMessage[];
-  lookupTablesAddresses: Address[];
+  lookupTablesAddresses: PublicKey[];
 }
 
 export interface InstructionsWithLookupTables {
-  instructions: Instruction[];
-  lookupTablesAddresses: Address[];
+  instructions: TransactionInstruction[];
+  lookupTablesAddresses: PublicKey[];
 }
 
 export interface PerformanceFees {
@@ -269,51 +267,46 @@ export interface InputRebalanceFieldInfo {
 }
 
 export interface InitStrategyIxs {
-  initStrategyIx: Instruction;
-  updateStrategyParamsIxs: Instruction[];
-  updateRebalanceParamsIx: Instruction;
-  openPositionIxs: Instruction[];
+  initStrategyIx: TransactionInstruction;
+  updateStrategyParamsIxs: TransactionInstruction[];
+  updateRebalanceParamsIx: TransactionInstruction;
+  openPositionIxs: TransactionInstruction[];
 }
 
 export interface WithdrawShares {
-  prerequisiteIxs: Instruction[];
-  withdrawIx: Instruction;
-  closeSharesAtaIx?: Instruction;
+  prerequisiteIxs: TransactionInstruction[];
+  withdrawIx: TransactionInstruction;
+  closeSharesAtaIx?: TransactionInstruction;
 }
 
 export interface MetadataProgramAddressesOrca {
-  position: Address;
+  position: PublicKey;
   positionBump: number;
-  positionMetadata: Address;
+  positionMetadata: PublicKey;
   positionMetadataBump: number;
 }
 
 export interface MetadataProgramAddressesRaydium {
-  position: Address;
+  position: PublicKey;
   positionBump: number;
-  protocolPosition: Address;
+  protocolPosition: PublicKey;
   protocolPositionBump: number;
-  positionMetadata: Address;
+  positionMetadata: PublicKey;
   positionMetadataBump: number;
 }
 
 export interface LowerAndUpperTickPubkeys {
-  lowerTick: Address;
+  lowerTick: PublicKey;
   lowerTickBump: number;
-  upperTick: Address;
+  upperTick: PublicKey;
   upperTickBump: number;
 }
 export interface WithdrawAllAndCloseIxns {
-  withdrawIxns: Instruction[];
-  closeIxn: Instruction;
+  withdrawIxns: TransactionInstruction[];
+  closeIxn: TransactionInstruction;
 }
 
 export interface InitPoolTickIfNeeded {
-  tick: Address;
-  initTickIx: Instruction | undefined;
+  tick: PublicKey;
+  initTickIx: TransactionInstruction | undefined;
 }
-
-export type Percentage = {
-  numerator: BN;
-  denominator: BN;
-};

package/src/utils/utils.ts

@@ -1,4 +1,7 @@
-import { Address, Instruction, isSome, Option, TransactionSigner } from '@solana/kit';
+import { PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { WhirlpoolStrategy } from '../kamino-client/accounts';
+import { WHIRLPOOL_PROGRAM_ID } from '../whirlpools-client/programId';
+import { PROGRAM_ID as RAYDIUM_PROGRAM_ID } from '../raydium_client/programId';
 import Decimal from 'decimal.js';
 import {
   DriftDirection,
@@ -10,26 +13,27 @@ import {
   StakingRateSource,
   StakingRateSourceKind,
   StrategyConfigOptionKind,
-} from '../@codegen/kliquidity/types';
+} from '../kamino-client/types';
 import {
   UpdateStrategyConfigAccounts,
   UpdateStrategyConfigArgs,
   updateStrategyConfig,
-} from '../@codegen/kliquidity/instructions';
+} from '../kamino-client/instructions';
 import { RebalanceFieldInfo, RebalanceFieldsDict } from './types';
 import BN from 'bn.js';
 import { PoolPriceReferenceType, TwapPriceReferenceType } from './priceReferenceTypes';
+import { sqrtPriceX64ToPrice } from '@orca-so/whirlpool-sdk';
+import { METEORA_PROGRAM_ID } from '../meteora_client/programId';
 import { U64_MAX } from '../constants/numericalValues';
 import { SqrtPriceMath } from '@raydium-io/raydium-sdk-v2/lib/raydium/clmm/utils/math';
-import { DEFAULT_PUBLIC_KEY } from '../constants/pubkeys';
-import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
-import { sqrtPriceToPrice as orcaSqrtPriceToPrice } from '@orca-so/whirlpools-core';
 
-export const DollarBasedMintingMethod = new Decimal(0);
+export const DolarBasedMintingMethod = new Decimal(0);
 export const ProportionalMintingMethod = new Decimal(1);
 
 export const RebalanceParamOffset = new Decimal(256);
 
+export const ZERO_BN = new BN(0);
+
 export function sleep(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -67,6 +71,18 @@ export function numberToReferencePriceType(num: number): ReferencePriceType {
   return referencePriceType;
 }
 
+export function getDexProgramId(strategyState: WhirlpoolStrategy): PublicKey {
+  if (strategyState.strategyDex.toNumber() == dexToNumber('ORCA')) {
+    return WHIRLPOOL_PROGRAM_ID;
+  } else if (strategyState.strategyDex.toNumber() == dexToNumber('RAYDIUM')) {
+    return RAYDIUM_PROGRAM_ID;
+  } else if (strategyState.strategyDex.toNumber() == dexToNumber('METEORA')) {
+    return METEORA_PROGRAM_ID;
+  } else {
+    throw Error(`Invalid DEX ${strategyState.strategyDex.toString()}`);
+  }
+}
+
 export function getStrategyConfigValue(value: Decimal): number[] {
   const buffer = Buffer.alloc(128);
   writeBNUint64LE(buffer, new BN(value.toString()), 0);
@@ -190,14 +206,13 @@ export function numberToRebalanceType(rebalance_type: number): RebalanceTypeKind
 }
 
 export async function getUpdateStrategyConfigIx(
-  signer: TransactionSigner,
-  globalConfig: Address,
-  strategy: Address,
+  signer: PublicKey,
+  globalConfig: PublicKey,
+  strategy: PublicKey,
   mode: StrategyConfigOptionKind,
   amount: Decimal,
-  programId: Address,
-  newAccount: Address = DEFAULT_PUBLIC_KEY
-): Promise<Instruction> {
+  newAccount: PublicKey = PublicKey.default
+): Promise<TransactionInstruction> {
   const args: UpdateStrategyConfigArgs = {
     mode: mode.discriminator,
     value: getStrategyConfigValue(amount),
@@ -208,10 +223,10 @@ export async function getUpdateStrategyConfigIx(
     newAccount,
     globalConfig,
     strategy,
-    systemProgram: SYSTEM_PROGRAM_ADDRESS,
+    systemProgram: SystemProgram.programId,
   };
 
-  return updateStrategyConfig(args, accounts, programId);
+  return updateStrategyConfig(args, accounts);
 }
 
 export function collToLamportsDecimal(amount: Decimal, decimals: number): Decimal {
@@ -263,14 +278,14 @@ export function rebalanceFieldsDictToInfo(rebalanceFields: RebalanceFieldsDict):
   return rebalanceFieldsInfo;
 }
 
-export function isVaultInitialized(vault: Address, decimals: BN): boolean {
-  return vault !== DEFAULT_PUBLIC_KEY && decimals.toNumber() > 0;
+export function isVaultInitialized(vault: PublicKey, decimals: BN): boolean {
+  return !vault.equals(PublicKey.default) && decimals.toNumber() > 0;
 }
 
 export function sqrtPriceToPrice(sqrtPrice: BN, dexNo: number, decimalsA: number, decimalsB: number): Decimal {
   const dex = numberToDex(dexNo);
   if (dex == 'ORCA') {
-    return new Decimal(orcaSqrtPriceToPrice(BigInt(sqrtPrice.toString()), decimalsA, decimalsB));
+    return sqrtPriceX64ToPrice(sqrtPrice, decimalsA, decimalsB);
   }
   if (dex == 'RAYDIUM') {
     return SqrtPriceMath.sqrtPriceX64ToPrice(sqrtPrice, decimalsA, decimalsB);
@@ -291,24 +306,9 @@ export function percentageToBPS(pct: number): number {
   return pct * 100;
 }
 
-export function keyOrDefault(key: Address, defaultKey: Address): Address {
-  if (key === DEFAULT_PUBLIC_KEY) {
+export function keyOrDefault(key: PublicKey, defaultKey: PublicKey): PublicKey {
+  if (key.equals(PublicKey.default)) {
     return defaultKey;
   }
   return key;
 }
-
-// Extract value from Option if Some, otherwise return null
-export function optionGetValue<T>(option: Option<T>): T | null {
-  return isSome(option) ? (option as any).value : null;
-}
-
-// Extract value from Option if Some, otherwise return undefined
-export function optionGetValueOrUndefined<T>(option: Option<T>): T | undefined {
-  return isSome(option) ? (option as any).value : undefined;
-}
-
-// Extract value from Option if Some, otherwise return provided default
-export function optionGetValueOrDefault<T>(option: Option<T>, defaultValue: T): T {
-  return isSome(option) ? (option as any).value : defaultValue;
-}

package/src/whirlpools-client/accounts/FeeTier.ts

@@ -0,0 +1,105 @@
+import { PublicKey, Connection } from "@solana/web3.js"
+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 FeeTierFields {
+  whirlpoolsConfig: PublicKey
+  tickSpacing: number
+  defaultFeeRate: number
+}
+
+export interface FeeTierJSON {
+  whirlpoolsConfig: string
+  tickSpacing: number
+  defaultFeeRate: number
+}
+
+export class FeeTier {
+  readonly whirlpoolsConfig: PublicKey
+  readonly tickSpacing: number
+  readonly defaultFeeRate: number
+
+  static readonly discriminator = Buffer.from([
+    56, 75, 159, 76, 142, 68, 190, 105,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey("whirlpoolsConfig"),
+    borsh.u16("tickSpacing"),
+    borsh.u16("defaultFeeRate"),
+  ])
+
+  constructor(fields: FeeTierFields) {
+    this.whirlpoolsConfig = fields.whirlpoolsConfig
+    this.tickSpacing = fields.tickSpacing
+    this.defaultFeeRate = fields.defaultFeeRate
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<FeeTier | null> {
+    const info = await c.getAccountInfo(address)
+
+    if (info === null) {
+      return null
+    }
+    if (!info.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program")
+    }
+
+    return this.decode(info.data)
+  }
+
+  static async fetchMultiple(
+    c: Connection,
+    addresses: PublicKey[],
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Array<FeeTier | null>> {
+    const infos = await c.getMultipleAccountsInfo(addresses)
+
+    return infos.map((info) => {
+      if (info === null) {
+        return null
+      }
+      if (!info.owner.equals(programId)) {
+        throw new Error("account doesn't belong to this program")
+      }
+
+      return this.decode(info.data)
+    })
+  }
+
+  static decode(data: Buffer): FeeTier {
+    if (!data.slice(0, 8).equals(FeeTier.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = FeeTier.layout.decode(data.slice(8))
+
+    return new FeeTier({
+      whirlpoolsConfig: dec.whirlpoolsConfig,
+      tickSpacing: dec.tickSpacing,
+      defaultFeeRate: dec.defaultFeeRate,
+    })
+  }
+
+  toJSON(): FeeTierJSON {
+    return {
+      whirlpoolsConfig: this.whirlpoolsConfig.toString(),
+      tickSpacing: this.tickSpacing,
+      defaultFeeRate: this.defaultFeeRate,
+    }
+  }
+
+  static fromJSON(obj: FeeTierJSON): FeeTier {
+    return new FeeTier({
+      whirlpoolsConfig: new PublicKey(obj.whirlpoolsConfig),
+      tickSpacing: obj.tickSpacing,
+      defaultFeeRate: obj.defaultFeeRate,
+    })
+  }
+}