@kamino-finance/kliquidity-sdk 6.2.1 → 6.3.0

package/src/utils/utils.ts

@@ -0,0 +1,312 @@
+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,
+  DriftDirectionKind,
+  RebalanceAutodriftStep,
+  RebalanceAutodriftStepKind,
+  RebalanceType,
+  RebalanceTypeKind,
+  StakingRateSource,
+  StakingRateSourceKind,
+  StrategyConfigOptionKind,
+} from '../kamino-client/types';
+import {
+  UpdateStrategyConfigAccounts,
+  UpdateStrategyConfigArgs,
+  updateStrategyConfig,
+} from '../kamino-client/instructions';
+import { SqrtPriceMath } from '@raydium-io/raydium-sdk';
+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';
+
+export const DolarBasedMintingMethod = new Decimal(0);
+export const ProportionalMintingMethod = new Decimal(1);
+
+export const RebalanceParamOffset = new Decimal(256);
+
+export function sleep(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export const Dex = ['ORCA', 'RAYDIUM', 'METEORA'] as const;
+export type Dex = (typeof Dex)[number];
+
+export const ReferencePriceType = [PoolPriceReferenceType, TwapPriceReferenceType] as const;
+export type ReferencePriceType = (typeof ReferencePriceType)[number];
+
+export function dexToNumber(dex: Dex): number {
+  for (let i = 0; i < Dex.length; i++) {
+    if (Dex[i] === dex) {
+      return i;
+    }
+  }
+
+  throw new Error(`Unknown DEX ${dex}`);
+}
+
+export function numberToDex(num: number): Dex {
+  const dex = Dex[num];
+
+  if (!dex) {
+    throw new Error(`Unknown DEX ${num}`);
+  }
+  return dex;
+}
+
+export function numberToReferencePriceType(num: number): ReferencePriceType {
+  const referencePriceType = ReferencePriceType[num];
+  if (!referencePriceType) {
+    throw new Error(`Strategy has invalid reference price type set: ${num}`);
+  }
+  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);
+  return [...buffer];
+}
+
+export function buildStrategyRebalanceParams(
+  params: Array<Decimal>,
+  rebalance_type: RebalanceTypeKind,
+  tokenADecimals?: number,
+  tokenBDecimals?: number
+): number[] {
+  const buffer = Buffer.alloc(128);
+  if (rebalance_type.kind == RebalanceType.Manual.kind) {
+    // Manual has no params
+  } else if (rebalance_type.kind == RebalanceType.PricePercentage.kind) {
+    buffer.writeUint16LE(params[0].toNumber());
+    buffer.writeUint16LE(params[1].toNumber(), 2);
+  } else if (rebalance_type.kind == RebalanceType.PricePercentageWithReset.kind) {
+    buffer.writeUint16LE(params[0].toNumber());
+    buffer.writeUint16LE(params[1].toNumber(), 2);
+    buffer.writeUint16LE(params[2].toNumber(), 4);
+    buffer.writeUint16LE(params[3].toNumber(), 6);
+  } else if (rebalance_type.kind == RebalanceType.Drift.kind) {
+    buffer.writeInt32LE(params[0].toNumber());
+    buffer.writeInt32LE(params[1].toNumber(), 4);
+    buffer.writeInt32LE(params[2].toNumber(), 8);
+    writeBNUint64LE(buffer, new BN(params[3].toString()), 12);
+    buffer.writeUint8(params[4].toNumber(), 20);
+  } else if (rebalance_type.kind == RebalanceType.TakeProfit.kind) {
+    // TODO: fix this for meteora
+    const lowerPrice = SqrtPriceMath.priceToSqrtPriceX64(params[0], tokenADecimals!, tokenBDecimals!);
+    const upperPrice = SqrtPriceMath.priceToSqrtPriceX64(params[1], tokenADecimals!, tokenBDecimals!);
+    writeBN128LE(buffer, lowerPrice, 0);
+    writeBN128LE(buffer, upperPrice, 16);
+    buffer.writeUint8(params[2].toNumber(), 32);
+  } else if (rebalance_type.kind == RebalanceType.PeriodicRebalance.kind) {
+    writeBNUint64LE(buffer, new BN(params[0].toString()), 0);
+    buffer.writeUInt16LE(params[1].toNumber(), 8);
+    buffer.writeUInt16LE(params[2].toNumber(), 10);
+  } else if (rebalance_type.kind == RebalanceType.Expander.kind) {
+    buffer.writeUInt16LE(params[0].toNumber(), 0);
+    buffer.writeUInt16LE(params[1].toNumber(), 2);
+    buffer.writeUInt16LE(params[2].toNumber(), 4);
+    buffer.writeUInt16LE(params[3].toNumber(), 6);
+    buffer.writeUInt16LE(params[4].toNumber(), 8);
+    buffer.writeUInt16LE(params[5].toNumber(), 10);
+    buffer.writeUInt8(params[6].toNumber(), 12);
+  } else if (rebalance_type.kind == RebalanceType.Autodrift.kind) {
+    buffer.writeUInt32LE(params[0].toNumber(), 0);
+    buffer.writeInt32LE(params[1].toNumber(), 4);
+    buffer.writeInt32LE(params[2].toNumber(), 8);
+    buffer.writeUInt16LE(params[3].toNumber(), 12);
+    buffer.writeUInt8(params[4].toNumber(), 14);
+    buffer.writeUInt8(params[5].toNumber(), 15);
+    buffer.writeUInt8(params[6].toNumber(), 16);
+  } else {
+    throw 'Rebalance type not valid ' + rebalance_type;
+  }
+  return [...buffer];
+}
+
+export function doesStrategyHaveResetRange(rebalanceTypeNumber: number): boolean {
+  const rebalanceType = numberToRebalanceType(rebalanceTypeNumber);
+  return (
+    rebalanceType.kind == RebalanceType.PricePercentageWithReset.kind ||
+    rebalanceType.kind == RebalanceType.Expander.kind
+  );
+}
+
+export function numberToDriftDirection(value: number): DriftDirectionKind {
+  if (value == 0) {
+    return new DriftDirection.Increasing();
+  } else if (value == 1) {
+    return new DriftDirection.Decreasing();
+  } else {
+    throw new Error(`Invalid drift direction ${value.toString()}`);
+  }
+}
+
+export function numberToStakingRateSource(value: number): StakingRateSourceKind {
+  if (value == 0) {
+    return new StakingRateSource.Constant();
+  } else if (value == 1) {
+    return new StakingRateSource.Scope();
+  } else {
+    throw new Error(`Invalid staking rate source ${value.toString()}`);
+  }
+}
+
+export function numberToAutodriftStep(value: number): RebalanceAutodriftStepKind {
+  if (value == 0) {
+    return new RebalanceAutodriftStep.Uninitialized();
+  } else if (value == 1) {
+    return new RebalanceAutodriftStep.Autodrifting();
+  } else {
+    throw new Error(`Invalid autodrift step ${value.toString()}`);
+  }
+}
+
+export function numberToRebalanceType(rebalance_type: number): RebalanceTypeKind {
+  if (rebalance_type == 0) {
+    return new RebalanceType.Manual();
+  } else if (rebalance_type == 1) {
+    return new RebalanceType.PricePercentage();
+  } else if (rebalance_type == 2) {
+    return new RebalanceType.PricePercentageWithReset();
+  } else if (rebalance_type == 3) {
+    return new RebalanceType.Drift();
+  } else if (rebalance_type == 4) {
+    return new RebalanceType.TakeProfit();
+  } else if (rebalance_type == 5) {
+    return new RebalanceType.PeriodicRebalance();
+  } else if (rebalance_type == 6) {
+    return new RebalanceType.Expander();
+  } else if (rebalance_type == 7) {
+    return new RebalanceType.Autodrift();
+  } else {
+    throw new Error(`Invalid rebalance type ${rebalance_type.toString()}`);
+  }
+}
+
+export async function getUpdateStrategyConfigIx(
+  signer: PublicKey,
+  globalConfig: PublicKey,
+  strategy: PublicKey,
+  mode: StrategyConfigOptionKind,
+  amount: Decimal,
+  newAccount: PublicKey = PublicKey.default
+): Promise<TransactionInstruction> {
+  const args: UpdateStrategyConfigArgs = {
+    mode: mode.discriminator,
+    value: getStrategyConfigValue(amount),
+  };
+
+  const accounts: UpdateStrategyConfigAccounts = {
+    adminAuthority: signer,
+    newAccount,
+    globalConfig,
+    strategy,
+    systemProgram: SystemProgram.programId,
+  };
+
+  return updateStrategyConfig(args, accounts);
+}
+
+export function collToLamportsDecimal(amount: Decimal, decimals: number): Decimal {
+  const factor = new Decimal(10).pow(decimals);
+  return amount.mul(factor);
+}
+
+export function lamportsToNumberDecimal(amount: Decimal.Value, decimals: number): Decimal {
+  const factor = new Decimal(10).pow(decimals);
+  return new Decimal(amount).div(factor);
+}
+
+export function readBigUint128LE(buffer: Buffer, offset: number): bigint {
+  return buffer.readBigUInt64LE(offset) + (buffer.readBigUInt64LE(offset + 8) << BigInt(64));
+}
+
+export function readPriceOption(buffer: Buffer, offset: number): [number, Decimal] {
+  if (buffer.readUint8(offset) == 0) {
+    return [offset + 1, new Decimal(0)];
+  }
+  const value = buffer.readBigUInt64LE(offset + 1);
+  const exp = buffer.readBigUInt64LE(offset + 9);
+  return [offset + 17, new Decimal(value.toString()).div(new Decimal(10).pow(exp.toString()))];
+}
+
+function writeBNUint64LE(buffer: Buffer, value: BN, offset: number) {
+  const lower_half = value.maskn(64).toBuffer('le');
+  buffer.set(lower_half, offset);
+}
+
+function writeBN128LE(buffer: Buffer, value: BN, offset: number) {
+  const lower_half = value.maskn(64).toBuffer('le');
+  const upper_half = value.shrn(64).toBuffer('le');
+  buffer.set(lower_half, offset);
+  buffer.set(upper_half, offset + 8);
+}
+
+export function rebalanceFieldsDictToInfo(rebalanceFields: RebalanceFieldsDict): RebalanceFieldInfo[] {
+  const rebalanceFieldsInfo: RebalanceFieldInfo[] = [];
+  for (const key in rebalanceFields) {
+    const value = rebalanceFields[key];
+    rebalanceFieldsInfo.push({
+      label: key,
+      type: 'number',
+      value: value,
+      enabled: false,
+    });
+  }
+  return rebalanceFieldsInfo;
+}
+
+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 sqrtPriceX64ToPrice(sqrtPrice, decimalsA, decimalsB);
+  }
+  if (dex == 'RAYDIUM') {
+    return SqrtPriceMath.sqrtPriceX64ToPrice(sqrtPrice, decimalsA, decimalsB);
+  }
+  if (dex == 'METEORA') {
+    const price = new Decimal(sqrtPrice.toString());
+    return price.div(new Decimal(U64_MAX));
+  }
+  throw new Error(`Got invalid dex number ${dex}`);
+}
+
+// Zero is not a valid TWAP component as that indicates the SOL price
+export function stripTwapZeros(chain: number[]): number[] {
+  return chain.filter((component) => component > 0);
+}
+
+export function percentageToBPS(pct: number): number {
+  return pct * 100;
+}
+
+export function keyOrDefault(key: PublicKey, defaultKey: PublicKey): PublicKey {
+  if (key.equals(PublicKey.default)) {
+    return defaultKey;
+  }
+  return key;
+}

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,
+    })
+  }
+}

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

@@ -0,0 +1,169 @@
+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 PositionFields {
+  whirlpool: PublicKey
+  positionMint: PublicKey
+  liquidity: BN
+  tickLowerIndex: number
+  tickUpperIndex: number
+  feeGrowthCheckpointA: BN
+  feeOwedA: BN
+  feeGrowthCheckpointB: BN
+  feeOwedB: BN
+  rewardInfos: Array<types.PositionRewardInfoFields>
+}
+
+export interface PositionJSON {
+  whirlpool: string
+  positionMint: string
+  liquidity: string
+  tickLowerIndex: number
+  tickUpperIndex: number
+  feeGrowthCheckpointA: string
+  feeOwedA: string
+  feeGrowthCheckpointB: string
+  feeOwedB: string
+  rewardInfos: Array<types.PositionRewardInfoJSON>
+}
+
+export class Position {
+  readonly whirlpool: PublicKey
+  readonly positionMint: PublicKey
+  readonly liquidity: BN
+  readonly tickLowerIndex: number
+  readonly tickUpperIndex: number
+  readonly feeGrowthCheckpointA: BN
+  readonly feeOwedA: BN
+  readonly feeGrowthCheckpointB: BN
+  readonly feeOwedB: BN
+  readonly rewardInfos: Array<types.PositionRewardInfo>
+
+  static readonly discriminator = Buffer.from([
+    170, 188, 143, 228, 122, 64, 247, 208,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey("whirlpool"),
+    borsh.publicKey("positionMint"),
+    borsh.u128("liquidity"),
+    borsh.i32("tickLowerIndex"),
+    borsh.i32("tickUpperIndex"),
+    borsh.u128("feeGrowthCheckpointA"),
+    borsh.u64("feeOwedA"),
+    borsh.u128("feeGrowthCheckpointB"),
+    borsh.u64("feeOwedB"),
+    borsh.array(types.PositionRewardInfo.layout(), 3, "rewardInfos"),
+  ])
+
+  constructor(fields: PositionFields) {
+    this.whirlpool = fields.whirlpool
+    this.positionMint = fields.positionMint
+    this.liquidity = fields.liquidity
+    this.tickLowerIndex = fields.tickLowerIndex
+    this.tickUpperIndex = fields.tickUpperIndex
+    this.feeGrowthCheckpointA = fields.feeGrowthCheckpointA
+    this.feeOwedA = fields.feeOwedA
+    this.feeGrowthCheckpointB = fields.feeGrowthCheckpointB
+    this.feeOwedB = fields.feeOwedB
+    this.rewardInfos = fields.rewardInfos.map(
+      (item) => new types.PositionRewardInfo({ ...item })
+    )
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<Position | 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<Position | 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): Position {
+    if (!data.slice(0, 8).equals(Position.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = Position.layout.decode(data.slice(8))
+
+    return new Position({
+      whirlpool: dec.whirlpool,
+      positionMint: dec.positionMint,
+      liquidity: dec.liquidity,
+      tickLowerIndex: dec.tickLowerIndex,
+      tickUpperIndex: dec.tickUpperIndex,
+      feeGrowthCheckpointA: dec.feeGrowthCheckpointA,
+      feeOwedA: dec.feeOwedA,
+      feeGrowthCheckpointB: dec.feeGrowthCheckpointB,
+      feeOwedB: dec.feeOwedB,
+      rewardInfos: dec.rewardInfos.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.PositionRewardInfo.fromDecoded(item)
+      ),
+    })
+  }
+
+  toJSON(): PositionJSON {
+    return {
+      whirlpool: this.whirlpool.toString(),
+      positionMint: this.positionMint.toString(),
+      liquidity: this.liquidity.toString(),
+      tickLowerIndex: this.tickLowerIndex,
+      tickUpperIndex: this.tickUpperIndex,
+      feeGrowthCheckpointA: this.feeGrowthCheckpointA.toString(),
+      feeOwedA: this.feeOwedA.toString(),
+      feeGrowthCheckpointB: this.feeGrowthCheckpointB.toString(),
+      feeOwedB: this.feeOwedB.toString(),
+      rewardInfos: this.rewardInfos.map((item) => item.toJSON()),
+    }
+  }
+
+  static fromJSON(obj: PositionJSON): Position {
+    return new Position({
+      whirlpool: new PublicKey(obj.whirlpool),
+      positionMint: new PublicKey(obj.positionMint),
+      liquidity: new BN(obj.liquidity),
+      tickLowerIndex: obj.tickLowerIndex,
+      tickUpperIndex: obj.tickUpperIndex,
+      feeGrowthCheckpointA: new BN(obj.feeGrowthCheckpointA),
+      feeOwedA: new BN(obj.feeOwedA),
+      feeGrowthCheckpointB: new BN(obj.feeGrowthCheckpointB),
+      feeOwedB: new BN(obj.feeOwedB),
+      rewardInfos: obj.rewardInfos.map((item) =>
+        types.PositionRewardInfo.fromJSON(item)
+      ),
+    })
+  }
+}

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

@@ -0,0 +1,97 @@
+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 PositionBundleFields {
+  positionBundleMint: PublicKey
+  positionBitmap: Array<number>
+}
+
+export interface PositionBundleJSON {
+  positionBundleMint: string
+  positionBitmap: Array<number>
+}
+
+export class PositionBundle {
+  readonly positionBundleMint: PublicKey
+  readonly positionBitmap: Array<number>
+
+  static readonly discriminator = Buffer.from([
+    129, 169, 175, 65, 185, 95, 32, 100,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey("positionBundleMint"),
+    borsh.array(borsh.u8(), 32, "positionBitmap"),
+  ])
+
+  constructor(fields: PositionBundleFields) {
+    this.positionBundleMint = fields.positionBundleMint
+    this.positionBitmap = fields.positionBitmap
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PositionBundle | 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<PositionBundle | 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): PositionBundle {
+    if (!data.slice(0, 8).equals(PositionBundle.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PositionBundle.layout.decode(data.slice(8))
+
+    return new PositionBundle({
+      positionBundleMint: dec.positionBundleMint,
+      positionBitmap: dec.positionBitmap,
+    })
+  }
+
+  toJSON(): PositionBundleJSON {
+    return {
+      positionBundleMint: this.positionBundleMint.toString(),
+      positionBitmap: this.positionBitmap,
+    }
+  }
+
+  static fromJSON(obj: PositionBundleJSON): PositionBundle {
+    return new PositionBundle({
+      positionBundleMint: new PublicKey(obj.positionBundleMint),
+      positionBitmap: obj.positionBitmap,
+    })
+  }
+}