@kamino-finance/kliquidity-sdk 6.2.2 → 6.3.1

package/src/raydium_client/accounts/PoolState.ts

@@ -0,0 +1,385 @@
+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 PoolStateFields {
+  bump: Array<number>
+  ammConfig: PublicKey
+  owner: PublicKey
+  tokenMint0: PublicKey
+  tokenMint1: PublicKey
+  tokenVault0: PublicKey
+  tokenVault1: PublicKey
+  observationKey: PublicKey
+  mintDecimals0: number
+  mintDecimals1: number
+  tickSpacing: number
+  liquidity: BN
+  sqrtPriceX64: BN
+  tickCurrent: number
+  observationIndex: number
+  observationUpdateDuration: number
+  feeGrowthGlobal0X64: BN
+  feeGrowthGlobal1X64: BN
+  protocolFeesToken0: BN
+  protocolFeesToken1: BN
+  swapInAmountToken0: BN
+  swapOutAmountToken1: BN
+  swapInAmountToken1: BN
+  swapOutAmountToken0: BN
+  status: number
+  padding: Array<number>
+  rewardInfos: Array<types.RewardInfoFields>
+  tickArrayBitmap: Array<BN>
+  totalFeesToken0: BN
+  totalFeesClaimedToken0: BN
+  totalFeesToken1: BN
+  totalFeesClaimedToken1: BN
+  fundFeesToken0: BN
+  fundFeesToken1: BN
+  openTime: BN
+  padding1: Array<BN>
+  padding2: Array<BN>
+}
+
+export interface PoolStateJSON {
+  bump: Array<number>
+  ammConfig: string
+  owner: string
+  tokenMint0: string
+  tokenMint1: string
+  tokenVault0: string
+  tokenVault1: string
+  observationKey: string
+  mintDecimals0: number
+  mintDecimals1: number
+  tickSpacing: number
+  liquidity: string
+  sqrtPriceX64: string
+  tickCurrent: number
+  observationIndex: number
+  observationUpdateDuration: number
+  feeGrowthGlobal0X64: string
+  feeGrowthGlobal1X64: string
+  protocolFeesToken0: string
+  protocolFeesToken1: string
+  swapInAmountToken0: string
+  swapOutAmountToken1: string
+  swapInAmountToken1: string
+  swapOutAmountToken0: string
+  status: number
+  padding: Array<number>
+  rewardInfos: Array<types.RewardInfoJSON>
+  tickArrayBitmap: Array<string>
+  totalFeesToken0: string
+  totalFeesClaimedToken0: string
+  totalFeesToken1: string
+  totalFeesClaimedToken1: string
+  fundFeesToken0: string
+  fundFeesToken1: string
+  openTime: string
+  padding1: Array<string>
+  padding2: Array<string>
+}
+
+export class PoolState {
+  readonly bump: Array<number>
+  readonly ammConfig: PublicKey
+  readonly owner: PublicKey
+  readonly tokenMint0: PublicKey
+  readonly tokenMint1: PublicKey
+  readonly tokenVault0: PublicKey
+  readonly tokenVault1: PublicKey
+  readonly observationKey: PublicKey
+  readonly mintDecimals0: number
+  readonly mintDecimals1: number
+  readonly tickSpacing: number
+  readonly liquidity: BN
+  readonly sqrtPriceX64: BN
+  readonly tickCurrent: number
+  readonly observationIndex: number
+  readonly observationUpdateDuration: number
+  readonly feeGrowthGlobal0X64: BN
+  readonly feeGrowthGlobal1X64: BN
+  readonly protocolFeesToken0: BN
+  readonly protocolFeesToken1: BN
+  readonly swapInAmountToken0: BN
+  readonly swapOutAmountToken1: BN
+  readonly swapInAmountToken1: BN
+  readonly swapOutAmountToken0: BN
+  readonly status: number
+  readonly padding: Array<number>
+  readonly rewardInfos: Array<types.RewardInfo>
+  readonly tickArrayBitmap: Array<BN>
+  readonly totalFeesToken0: BN
+  readonly totalFeesClaimedToken0: BN
+  readonly totalFeesToken1: BN
+  readonly totalFeesClaimedToken1: BN
+  readonly fundFeesToken0: BN
+  readonly fundFeesToken1: BN
+  readonly openTime: BN
+  readonly padding1: Array<BN>
+  readonly padding2: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    247, 237, 227, 245, 215, 195, 222, 70,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.array(borsh.u8(), 1, "bump"),
+    borsh.publicKey("ammConfig"),
+    borsh.publicKey("owner"),
+    borsh.publicKey("tokenMint0"),
+    borsh.publicKey("tokenMint1"),
+    borsh.publicKey("tokenVault0"),
+    borsh.publicKey("tokenVault1"),
+    borsh.publicKey("observationKey"),
+    borsh.u8("mintDecimals0"),
+    borsh.u8("mintDecimals1"),
+    borsh.u16("tickSpacing"),
+    borsh.u128("liquidity"),
+    borsh.u128("sqrtPriceX64"),
+    borsh.i32("tickCurrent"),
+    borsh.u16("observationIndex"),
+    borsh.u16("observationUpdateDuration"),
+    borsh.u128("feeGrowthGlobal0X64"),
+    borsh.u128("feeGrowthGlobal1X64"),
+    borsh.u64("protocolFeesToken0"),
+    borsh.u64("protocolFeesToken1"),
+    borsh.u128("swapInAmountToken0"),
+    borsh.u128("swapOutAmountToken1"),
+    borsh.u128("swapInAmountToken1"),
+    borsh.u128("swapOutAmountToken0"),
+    borsh.u8("status"),
+    borsh.array(borsh.u8(), 7, "padding"),
+    borsh.array(types.RewardInfo.layout(), 3, "rewardInfos"),
+    borsh.array(borsh.u64(), 16, "tickArrayBitmap"),
+    borsh.u64("totalFeesToken0"),
+    borsh.u64("totalFeesClaimedToken0"),
+    borsh.u64("totalFeesToken1"),
+    borsh.u64("totalFeesClaimedToken1"),
+    borsh.u64("fundFeesToken0"),
+    borsh.u64("fundFeesToken1"),
+    borsh.u64("openTime"),
+    borsh.array(borsh.u64(), 25, "padding1"),
+    borsh.array(borsh.u64(), 32, "padding2"),
+  ])
+
+  constructor(fields: PoolStateFields) {
+    this.bump = fields.bump
+    this.ammConfig = fields.ammConfig
+    this.owner = fields.owner
+    this.tokenMint0 = fields.tokenMint0
+    this.tokenMint1 = fields.tokenMint1
+    this.tokenVault0 = fields.tokenVault0
+    this.tokenVault1 = fields.tokenVault1
+    this.observationKey = fields.observationKey
+    this.mintDecimals0 = fields.mintDecimals0
+    this.mintDecimals1 = fields.mintDecimals1
+    this.tickSpacing = fields.tickSpacing
+    this.liquidity = fields.liquidity
+    this.sqrtPriceX64 = fields.sqrtPriceX64
+    this.tickCurrent = fields.tickCurrent
+    this.observationIndex = fields.observationIndex
+    this.observationUpdateDuration = fields.observationUpdateDuration
+    this.feeGrowthGlobal0X64 = fields.feeGrowthGlobal0X64
+    this.feeGrowthGlobal1X64 = fields.feeGrowthGlobal1X64
+    this.protocolFeesToken0 = fields.protocolFeesToken0
+    this.protocolFeesToken1 = fields.protocolFeesToken1
+    this.swapInAmountToken0 = fields.swapInAmountToken0
+    this.swapOutAmountToken1 = fields.swapOutAmountToken1
+    this.swapInAmountToken1 = fields.swapInAmountToken1
+    this.swapOutAmountToken0 = fields.swapOutAmountToken0
+    this.status = fields.status
+    this.padding = fields.padding
+    this.rewardInfos = fields.rewardInfos.map(
+      (item) => new types.RewardInfo({ ...item })
+    )
+    this.tickArrayBitmap = fields.tickArrayBitmap
+    this.totalFeesToken0 = fields.totalFeesToken0
+    this.totalFeesClaimedToken0 = fields.totalFeesClaimedToken0
+    this.totalFeesToken1 = fields.totalFeesToken1
+    this.totalFeesClaimedToken1 = fields.totalFeesClaimedToken1
+    this.fundFeesToken0 = fields.fundFeesToken0
+    this.fundFeesToken1 = fields.fundFeesToken1
+    this.openTime = fields.openTime
+    this.padding1 = fields.padding1
+    this.padding2 = fields.padding2
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<PoolState | 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<PoolState | 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): PoolState {
+    if (!data.slice(0, 8).equals(PoolState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = PoolState.layout.decode(data.slice(8))
+
+    return new PoolState({
+      bump: dec.bump,
+      ammConfig: dec.ammConfig,
+      owner: dec.owner,
+      tokenMint0: dec.tokenMint0,
+      tokenMint1: dec.tokenMint1,
+      tokenVault0: dec.tokenVault0,
+      tokenVault1: dec.tokenVault1,
+      observationKey: dec.observationKey,
+      mintDecimals0: dec.mintDecimals0,
+      mintDecimals1: dec.mintDecimals1,
+      tickSpacing: dec.tickSpacing,
+      liquidity: dec.liquidity,
+      sqrtPriceX64: dec.sqrtPriceX64,
+      tickCurrent: dec.tickCurrent,
+      observationIndex: dec.observationIndex,
+      observationUpdateDuration: dec.observationUpdateDuration,
+      feeGrowthGlobal0X64: dec.feeGrowthGlobal0X64,
+      feeGrowthGlobal1X64: dec.feeGrowthGlobal1X64,
+      protocolFeesToken0: dec.protocolFeesToken0,
+      protocolFeesToken1: dec.protocolFeesToken1,
+      swapInAmountToken0: dec.swapInAmountToken0,
+      swapOutAmountToken1: dec.swapOutAmountToken1,
+      swapInAmountToken1: dec.swapInAmountToken1,
+      swapOutAmountToken0: dec.swapOutAmountToken0,
+      status: dec.status,
+      padding: dec.padding,
+      rewardInfos: dec.rewardInfos.map(
+        (
+          item: any /* eslint-disable-line @typescript-eslint/no-explicit-any */
+        ) => types.RewardInfo.fromDecoded(item)
+      ),
+      tickArrayBitmap: dec.tickArrayBitmap,
+      totalFeesToken0: dec.totalFeesToken0,
+      totalFeesClaimedToken0: dec.totalFeesClaimedToken0,
+      totalFeesToken1: dec.totalFeesToken1,
+      totalFeesClaimedToken1: dec.totalFeesClaimedToken1,
+      fundFeesToken0: dec.fundFeesToken0,
+      fundFeesToken1: dec.fundFeesToken1,
+      openTime: dec.openTime,
+      padding1: dec.padding1,
+      padding2: dec.padding2,
+    })
+  }
+
+  toJSON(): PoolStateJSON {
+    return {
+      bump: this.bump,
+      ammConfig: this.ammConfig.toString(),
+      owner: this.owner.toString(),
+      tokenMint0: this.tokenMint0.toString(),
+      tokenMint1: this.tokenMint1.toString(),
+      tokenVault0: this.tokenVault0.toString(),
+      tokenVault1: this.tokenVault1.toString(),
+      observationKey: this.observationKey.toString(),
+      mintDecimals0: this.mintDecimals0,
+      mintDecimals1: this.mintDecimals1,
+      tickSpacing: this.tickSpacing,
+      liquidity: this.liquidity.toString(),
+      sqrtPriceX64: this.sqrtPriceX64.toString(),
+      tickCurrent: this.tickCurrent,
+      observationIndex: this.observationIndex,
+      observationUpdateDuration: this.observationUpdateDuration,
+      feeGrowthGlobal0X64: this.feeGrowthGlobal0X64.toString(),
+      feeGrowthGlobal1X64: this.feeGrowthGlobal1X64.toString(),
+      protocolFeesToken0: this.protocolFeesToken0.toString(),
+      protocolFeesToken1: this.protocolFeesToken1.toString(),
+      swapInAmountToken0: this.swapInAmountToken0.toString(),
+      swapOutAmountToken1: this.swapOutAmountToken1.toString(),
+      swapInAmountToken1: this.swapInAmountToken1.toString(),
+      swapOutAmountToken0: this.swapOutAmountToken0.toString(),
+      status: this.status,
+      padding: this.padding,
+      rewardInfos: this.rewardInfos.map((item) => item.toJSON()),
+      tickArrayBitmap: this.tickArrayBitmap.map((item) => item.toString()),
+      totalFeesToken0: this.totalFeesToken0.toString(),
+      totalFeesClaimedToken0: this.totalFeesClaimedToken0.toString(),
+      totalFeesToken1: this.totalFeesToken1.toString(),
+      totalFeesClaimedToken1: this.totalFeesClaimedToken1.toString(),
+      fundFeesToken0: this.fundFeesToken0.toString(),
+      fundFeesToken1: this.fundFeesToken1.toString(),
+      openTime: this.openTime.toString(),
+      padding1: this.padding1.map((item) => item.toString()),
+      padding2: this.padding2.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: PoolStateJSON): PoolState {
+    return new PoolState({
+      bump: obj.bump,
+      ammConfig: new PublicKey(obj.ammConfig),
+      owner: new PublicKey(obj.owner),
+      tokenMint0: new PublicKey(obj.tokenMint0),
+      tokenMint1: new PublicKey(obj.tokenMint1),
+      tokenVault0: new PublicKey(obj.tokenVault0),
+      tokenVault1: new PublicKey(obj.tokenVault1),
+      observationKey: new PublicKey(obj.observationKey),
+      mintDecimals0: obj.mintDecimals0,
+      mintDecimals1: obj.mintDecimals1,
+      tickSpacing: obj.tickSpacing,
+      liquidity: new BN(obj.liquidity),
+      sqrtPriceX64: new BN(obj.sqrtPriceX64),
+      tickCurrent: obj.tickCurrent,
+      observationIndex: obj.observationIndex,
+      observationUpdateDuration: obj.observationUpdateDuration,
+      feeGrowthGlobal0X64: new BN(obj.feeGrowthGlobal0X64),
+      feeGrowthGlobal1X64: new BN(obj.feeGrowthGlobal1X64),
+      protocolFeesToken0: new BN(obj.protocolFeesToken0),
+      protocolFeesToken1: new BN(obj.protocolFeesToken1),
+      swapInAmountToken0: new BN(obj.swapInAmountToken0),
+      swapOutAmountToken1: new BN(obj.swapOutAmountToken1),
+      swapInAmountToken1: new BN(obj.swapInAmountToken1),
+      swapOutAmountToken0: new BN(obj.swapOutAmountToken0),
+      status: obj.status,
+      padding: obj.padding,
+      rewardInfos: obj.rewardInfos.map((item) =>
+        types.RewardInfo.fromJSON(item)
+      ),
+      tickArrayBitmap: obj.tickArrayBitmap.map((item) => new BN(item)),
+      totalFeesToken0: new BN(obj.totalFeesToken0),
+      totalFeesClaimedToken0: new BN(obj.totalFeesClaimedToken0),
+      totalFeesToken1: new BN(obj.totalFeesToken1),
+      totalFeesClaimedToken1: new BN(obj.totalFeesClaimedToken1),
+      fundFeesToken0: new BN(obj.fundFeesToken0),
+      fundFeesToken1: new BN(obj.fundFeesToken1),
+      openTime: new BN(obj.openTime),
+      padding1: obj.padding1.map((item) => new BN(item)),
+      padding2: obj.padding2.map((item) => new BN(item)),
+    })
+  }
+}

package/src/raydium_client/accounts/ProtocolPositionState.ts

@@ -0,0 +1,171 @@
+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 ProtocolPositionStateFields {
+  bump: number
+  poolId: PublicKey
+  tickLowerIndex: number
+  tickUpperIndex: number
+  liquidity: BN
+  feeGrowthInside0LastX64: BN
+  feeGrowthInside1LastX64: BN
+  tokenFeesOwed0: BN
+  tokenFeesOwed1: BN
+  rewardGrowthInside: Array<BN>
+  padding: Array<BN>
+}
+
+export interface ProtocolPositionStateJSON {
+  bump: number
+  poolId: string
+  tickLowerIndex: number
+  tickUpperIndex: number
+  liquidity: string
+  feeGrowthInside0LastX64: string
+  feeGrowthInside1LastX64: string
+  tokenFeesOwed0: string
+  tokenFeesOwed1: string
+  rewardGrowthInside: Array<string>
+  padding: Array<string>
+}
+
+export class ProtocolPositionState {
+  readonly bump: number
+  readonly poolId: PublicKey
+  readonly tickLowerIndex: number
+  readonly tickUpperIndex: number
+  readonly liquidity: BN
+  readonly feeGrowthInside0LastX64: BN
+  readonly feeGrowthInside1LastX64: BN
+  readonly tokenFeesOwed0: BN
+  readonly tokenFeesOwed1: BN
+  readonly rewardGrowthInside: Array<BN>
+  readonly padding: Array<BN>
+
+  static readonly discriminator = Buffer.from([
+    100, 226, 145, 99, 146, 218, 160, 106,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.u8("bump"),
+    borsh.publicKey("poolId"),
+    borsh.i32("tickLowerIndex"),
+    borsh.i32("tickUpperIndex"),
+    borsh.u128("liquidity"),
+    borsh.u128("feeGrowthInside0LastX64"),
+    borsh.u128("feeGrowthInside1LastX64"),
+    borsh.u64("tokenFeesOwed0"),
+    borsh.u64("tokenFeesOwed1"),
+    borsh.array(borsh.u128(), 3, "rewardGrowthInside"),
+    borsh.array(borsh.u64(), 8, "padding"),
+  ])
+
+  constructor(fields: ProtocolPositionStateFields) {
+    this.bump = fields.bump
+    this.poolId = fields.poolId
+    this.tickLowerIndex = fields.tickLowerIndex
+    this.tickUpperIndex = fields.tickUpperIndex
+    this.liquidity = fields.liquidity
+    this.feeGrowthInside0LastX64 = fields.feeGrowthInside0LastX64
+    this.feeGrowthInside1LastX64 = fields.feeGrowthInside1LastX64
+    this.tokenFeesOwed0 = fields.tokenFeesOwed0
+    this.tokenFeesOwed1 = fields.tokenFeesOwed1
+    this.rewardGrowthInside = fields.rewardGrowthInside
+    this.padding = fields.padding
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<ProtocolPositionState | 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<ProtocolPositionState | 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): ProtocolPositionState {
+    if (!data.slice(0, 8).equals(ProtocolPositionState.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = ProtocolPositionState.layout.decode(data.slice(8))
+
+    return new ProtocolPositionState({
+      bump: dec.bump,
+      poolId: dec.poolId,
+      tickLowerIndex: dec.tickLowerIndex,
+      tickUpperIndex: dec.tickUpperIndex,
+      liquidity: dec.liquidity,
+      feeGrowthInside0LastX64: dec.feeGrowthInside0LastX64,
+      feeGrowthInside1LastX64: dec.feeGrowthInside1LastX64,
+      tokenFeesOwed0: dec.tokenFeesOwed0,
+      tokenFeesOwed1: dec.tokenFeesOwed1,
+      rewardGrowthInside: dec.rewardGrowthInside,
+      padding: dec.padding,
+    })
+  }
+
+  toJSON(): ProtocolPositionStateJSON {
+    return {
+      bump: this.bump,
+      poolId: this.poolId.toString(),
+      tickLowerIndex: this.tickLowerIndex,
+      tickUpperIndex: this.tickUpperIndex,
+      liquidity: this.liquidity.toString(),
+      feeGrowthInside0LastX64: this.feeGrowthInside0LastX64.toString(),
+      feeGrowthInside1LastX64: this.feeGrowthInside1LastX64.toString(),
+      tokenFeesOwed0: this.tokenFeesOwed0.toString(),
+      tokenFeesOwed1: this.tokenFeesOwed1.toString(),
+      rewardGrowthInside: this.rewardGrowthInside.map((item) =>
+        item.toString()
+      ),
+      padding: this.padding.map((item) => item.toString()),
+    }
+  }
+
+  static fromJSON(obj: ProtocolPositionStateJSON): ProtocolPositionState {
+    return new ProtocolPositionState({
+      bump: obj.bump,
+      poolId: new PublicKey(obj.poolId),
+      tickLowerIndex: obj.tickLowerIndex,
+      tickUpperIndex: obj.tickUpperIndex,
+      liquidity: new BN(obj.liquidity),
+      feeGrowthInside0LastX64: new BN(obj.feeGrowthInside0LastX64),
+      feeGrowthInside1LastX64: new BN(obj.feeGrowthInside1LastX64),
+      tokenFeesOwed0: new BN(obj.tokenFeesOwed0),
+      tokenFeesOwed1: new BN(obj.tokenFeesOwed1),
+      rewardGrowthInside: obj.rewardGrowthInside.map((item) => new BN(item)),
+      padding: obj.padding.map((item) => new BN(item)),
+    })
+  }
+}

package/src/raydium_client/accounts/TickArrayBitmapExtension.ts

@@ -0,0 +1,113 @@
+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 TickArrayBitmapExtensionFields {
+  poolId: PublicKey
+  positiveTickArrayBitmap: Array<Array<BN>>
+  negativeTickArrayBitmap: Array<Array<BN>>
+}
+
+export interface TickArrayBitmapExtensionJSON {
+  poolId: string
+  positiveTickArrayBitmap: Array<Array<string>>
+  negativeTickArrayBitmap: Array<Array<string>>
+}
+
+export class TickArrayBitmapExtension {
+  readonly poolId: PublicKey
+  readonly positiveTickArrayBitmap: Array<Array<BN>>
+  readonly negativeTickArrayBitmap: Array<Array<BN>>
+
+  static readonly discriminator = Buffer.from([
+    60, 150, 36, 219, 97, 128, 139, 153,
+  ])
+
+  static readonly layout = borsh.struct([
+    borsh.publicKey("poolId"),
+    borsh.array(borsh.array(borsh.u64(), 8), 14, "positiveTickArrayBitmap"),
+    borsh.array(borsh.array(borsh.u64(), 8), 14, "negativeTickArrayBitmap"),
+  ])
+
+  constructor(fields: TickArrayBitmapExtensionFields) {
+    this.poolId = fields.poolId
+    this.positiveTickArrayBitmap = fields.positiveTickArrayBitmap
+    this.negativeTickArrayBitmap = fields.negativeTickArrayBitmap
+  }
+
+  static async fetch(
+    c: Connection,
+    address: PublicKey,
+    programId: PublicKey = PROGRAM_ID
+  ): Promise<TickArrayBitmapExtension | 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<TickArrayBitmapExtension | 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): TickArrayBitmapExtension {
+    if (!data.slice(0, 8).equals(TickArrayBitmapExtension.discriminator)) {
+      throw new Error("invalid account discriminator")
+    }
+
+    const dec = TickArrayBitmapExtension.layout.decode(data.slice(8))
+
+    return new TickArrayBitmapExtension({
+      poolId: dec.poolId,
+      positiveTickArrayBitmap: dec.positiveTickArrayBitmap,
+      negativeTickArrayBitmap: dec.negativeTickArrayBitmap,
+    })
+  }
+
+  toJSON(): TickArrayBitmapExtensionJSON {
+    return {
+      poolId: this.poolId.toString(),
+      positiveTickArrayBitmap: this.positiveTickArrayBitmap.map((item) =>
+        item.map((item) => item.toString())
+      ),
+      negativeTickArrayBitmap: this.negativeTickArrayBitmap.map((item) =>
+        item.map((item) => item.toString())
+      ),
+    }
+  }
+
+  static fromJSON(obj: TickArrayBitmapExtensionJSON): TickArrayBitmapExtension {
+    return new TickArrayBitmapExtension({
+      poolId: new PublicKey(obj.poolId),
+      positiveTickArrayBitmap: obj.positiveTickArrayBitmap.map((item) =>
+        item.map((item) => new BN(item))
+      ),
+      negativeTickArrayBitmap: obj.negativeTickArrayBitmap.map((item) =>
+        item.map((item) => new BN(item))
+      ),
+    })
+  }
+}