/**
 * This code was AUTOGENERATED using the Codama library.
 * Please DO NOT EDIT THIS FILE, instead use visitors
 * to add features, then rerun Codama to update it.
 *
 * @see https://github.com/codama-idl/codama
 */

import type {
  Address,
  ClientWithRpc,
  ClientWithTransactionPlanning,
  ClientWithTransactionSending,
  GetAccountInfoApi,
  GetMultipleAccountsApi,
  Instruction,
  InstructionWithData,
  ReadonlyUint8Array,
} from "@solana/kit";
import type {
  SelfFetchFunctions,
  SelfPlanAndSendFunctions,
} from "@solana/program-client-core";
import type {
  FeeTier,
  FeeTierArgs,
  LockConfig,
  LockConfigArgs,
  Position,
  PositionArgs,
  PositionBundle,
  PositionBundleArgs,
  TickArray,
  TickArrayArgs,
  TokenBadge,
  TokenBadgeArgs,
  Whirlpool,
  WhirlpoolArgs,
  WhirlpoolsConfig,
  WhirlpoolsConfigArgs,
  WhirlpoolsConfigExtension,
  WhirlpoolsConfigExtensionArgs,
} from "../accounts/index.js";
import type {
  CloseBundledPositionInput,
  ClosePositionInput,
  ClosePositionWithTokenExtensionsInput,
  CollectFeesInput,
  CollectFeesV2Input,
  CollectProtocolFeesInput,
  CollectProtocolFeesV2Input,
  CollectRewardInput,
  CollectRewardV2Input,
  DecreaseLiquidityInput,
  DecreaseLiquidityV2Input,
  DeletePositionBundleInput,
  DeleteTokenBadgeInput,
  IncreaseLiquidityInput,
  IncreaseLiquidityV2Input,
  InitializeConfigExtensionInput,
  InitializeConfigInput,
  InitializeFeeTierInput,
  InitializePoolInput,
  InitializePoolV2Input,
  InitializePositionBundleInput,
  InitializePositionBundleWithMetadataInput,
  InitializeRewardInput,
  InitializeRewardV2Input,
  InitializeTickArrayInput,
  InitializeTokenBadgeInput,
  LockPositionInput,
  OpenBundledPositionInput,
  OpenPositionInput,
  OpenPositionWithMetadataInput,
  OpenPositionWithTokenExtensionsInput,
  ParsedCloseBundledPositionInstruction,
  ParsedClosePositionInstruction,
  ParsedClosePositionWithTokenExtensionsInstruction,
  ParsedCollectFeesInstruction,
  ParsedCollectFeesV2Instruction,
  ParsedCollectProtocolFeesInstruction,
  ParsedCollectProtocolFeesV2Instruction,
  ParsedCollectRewardInstruction,
  ParsedCollectRewardV2Instruction,
  ParsedDecreaseLiquidityInstruction,
  ParsedDecreaseLiquidityV2Instruction,
  ParsedDeletePositionBundleInstruction,
  ParsedDeleteTokenBadgeInstruction,
  ParsedIncreaseLiquidityInstruction,
  ParsedIncreaseLiquidityV2Instruction,
  ParsedInitializeConfigExtensionInstruction,
  ParsedInitializeConfigInstruction,
  ParsedInitializeFeeTierInstruction,
  ParsedInitializePoolInstruction,
  ParsedInitializePoolV2Instruction,
  ParsedInitializePositionBundleInstruction,
  ParsedInitializePositionBundleWithMetadataInstruction,
  ParsedInitializeRewardInstruction,
  ParsedInitializeRewardV2Instruction,
  ParsedInitializeTickArrayInstruction,
  ParsedInitializeTokenBadgeInstruction,
  ParsedLockPositionInstruction,
  ParsedOpenBundledPositionInstruction,
  ParsedOpenPositionInstruction,
  ParsedOpenPositionWithMetadataInstruction,
  ParsedOpenPositionWithTokenExtensionsInstruction,
  ParsedSetCollectProtocolFeesAuthorityInstruction,
  ParsedSetConfigExtensionAuthorityInstruction,
  ParsedSetDefaultFeeRateInstruction,
  ParsedSetDefaultProtocolFeeRateInstruction,
  ParsedSetFeeAuthorityInstruction,
  ParsedSetFeeRateInstruction,
  ParsedSetProtocolFeeRateInstruction,
  ParsedSetRewardAuthorityBySuperAuthorityInstruction,
  ParsedSetRewardAuthorityInstruction,
  ParsedSetRewardEmissionsInstruction,
  ParsedSetRewardEmissionsSuperAuthorityInstruction,
  ParsedSetRewardEmissionsV2Instruction,
  ParsedSetTokenBadgeAuthorityInstruction,
  ParsedSwapInstruction,
  ParsedSwapV2Instruction,
  ParsedTwoHopSwapInstruction,
  ParsedTwoHopSwapV2Instruction,
  ParsedUpdateFeesAndRewardsInstruction,
  SetCollectProtocolFeesAuthorityInput,
  SetConfigExtensionAuthorityInput,
  SetDefaultFeeRateInput,
  SetDefaultProtocolFeeRateInput,
  SetFeeAuthorityInput,
  SetFeeRateInput,
  SetProtocolFeeRateInput,
  SetRewardAuthorityBySuperAuthorityInput,
  SetRewardAuthorityInput,
  SetRewardEmissionsInput,
  SetRewardEmissionsSuperAuthorityInput,
  SetRewardEmissionsV2Input,
  SetTokenBadgeAuthorityInput,
  SwapInput,
  SwapV2Input,
  TwoHopSwapInput,
  TwoHopSwapV2Input,
  UpdateFeesAndRewardsInput,
} from "../instructions/index.js";
import {
  assertIsInstructionWithAccounts,
  containsBytes,
  extendClient,
  fixEncoderSize,
  getBytesEncoder,
  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
  SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
  SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
  SolanaError,
} from "@solana/kit";
import {
  addSelfFetchFunctions,
  addSelfPlanAndSendFunctions,
} from "@solana/program-client-core";
import {
  getFeeTierCodec,
  getLockConfigCodec,
  getPositionBundleCodec,
  getPositionCodec,
  getTickArrayCodec,
  getTokenBadgeCodec,
  getWhirlpoolCodec,
  getWhirlpoolsConfigCodec,
  getWhirlpoolsConfigExtensionCodec,
} from "../accounts/index.js";
import {
  getCloseBundledPositionInstruction,
  getClosePositionInstruction,
  getClosePositionWithTokenExtensionsInstruction,
  getCollectFeesInstruction,
  getCollectFeesV2Instruction,
  getCollectProtocolFeesInstruction,
  getCollectProtocolFeesV2Instruction,
  getCollectRewardInstruction,
  getCollectRewardV2Instruction,
  getDecreaseLiquidityInstruction,
  getDecreaseLiquidityV2Instruction,
  getDeletePositionBundleInstruction,
  getDeleteTokenBadgeInstruction,
  getIncreaseLiquidityInstruction,
  getIncreaseLiquidityV2Instruction,
  getInitializeConfigExtensionInstruction,
  getInitializeConfigInstruction,
  getInitializeFeeTierInstruction,
  getInitializePoolInstruction,
  getInitializePoolV2Instruction,
  getInitializePositionBundleInstruction,
  getInitializePositionBundleWithMetadataInstruction,
  getInitializeRewardInstruction,
  getInitializeRewardV2Instruction,
  getInitializeTickArrayInstruction,
  getInitializeTokenBadgeInstruction,
  getLockPositionInstruction,
  getOpenBundledPositionInstruction,
  getOpenPositionInstruction,
  getOpenPositionWithMetadataInstruction,
  getOpenPositionWithTokenExtensionsInstruction,
  getSetCollectProtocolFeesAuthorityInstruction,
  getSetConfigExtensionAuthorityInstruction,
  getSetDefaultFeeRateInstruction,
  getSetDefaultProtocolFeeRateInstruction,
  getSetFeeAuthorityInstruction,
  getSetFeeRateInstruction,
  getSetProtocolFeeRateInstruction,
  getSetRewardAuthorityBySuperAuthorityInstruction,
  getSetRewardAuthorityInstruction,
  getSetRewardEmissionsInstruction,
  getSetRewardEmissionsSuperAuthorityInstruction,
  getSetRewardEmissionsV2Instruction,
  getSetTokenBadgeAuthorityInstruction,
  getSwapInstruction,
  getSwapV2Instruction,
  getTwoHopSwapInstruction,
  getTwoHopSwapV2Instruction,
  getUpdateFeesAndRewardsInstruction,
  parseCloseBundledPositionInstruction,
  parseClosePositionInstruction,
  parseClosePositionWithTokenExtensionsInstruction,
  parseCollectFeesInstruction,
  parseCollectFeesV2Instruction,
  parseCollectProtocolFeesInstruction,
  parseCollectProtocolFeesV2Instruction,
  parseCollectRewardInstruction,
  parseCollectRewardV2Instruction,
  parseDecreaseLiquidityInstruction,
  parseDecreaseLiquidityV2Instruction,
  parseDeletePositionBundleInstruction,
  parseDeleteTokenBadgeInstruction,
  parseIncreaseLiquidityInstruction,
  parseIncreaseLiquidityV2Instruction,
  parseInitializeConfigExtensionInstruction,
  parseInitializeConfigInstruction,
  parseInitializeFeeTierInstruction,
  parseInitializePoolInstruction,
  parseInitializePoolV2Instruction,
  parseInitializePositionBundleInstruction,
  parseInitializePositionBundleWithMetadataInstruction,
  parseInitializeRewardInstruction,
  parseInitializeRewardV2Instruction,
  parseInitializeTickArrayInstruction,
  parseInitializeTokenBadgeInstruction,
  parseLockPositionInstruction,
  parseOpenBundledPositionInstruction,
  parseOpenPositionInstruction,
  parseOpenPositionWithMetadataInstruction,
  parseOpenPositionWithTokenExtensionsInstruction,
  parseSetCollectProtocolFeesAuthorityInstruction,
  parseSetConfigExtensionAuthorityInstruction,
  parseSetDefaultFeeRateInstruction,
  parseSetDefaultProtocolFeeRateInstruction,
  parseSetFeeAuthorityInstruction,
  parseSetFeeRateInstruction,
  parseSetProtocolFeeRateInstruction,
  parseSetRewardAuthorityBySuperAuthorityInstruction,
  parseSetRewardAuthorityInstruction,
  parseSetRewardEmissionsInstruction,
  parseSetRewardEmissionsSuperAuthorityInstruction,
  parseSetRewardEmissionsV2Instruction,
  parseSetTokenBadgeAuthorityInstruction,
  parseSwapInstruction,
  parseSwapV2Instruction,
  parseTwoHopSwapInstruction,
  parseTwoHopSwapV2Instruction,
  parseUpdateFeesAndRewardsInstruction,
} from "../instructions/index.js";

export const WHIRLPOOL_PROGRAM_ADDRESS =
  "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc" as Address<"whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc">;

export enum WhirlpoolAccount {
  WhirlpoolsConfig = 0,
  WhirlpoolsConfigExtension = 1,
  FeeTier = 2,
  LockConfig = 3,
  Position = 4,
  PositionBundle = 5,
  TickArray = 6,
  TokenBadge = 7,
  Whirlpool = 8,
}

export function identifyWhirlpoolAccount(
  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
): WhirlpoolAccount {
  const data = "data" in account ? account.data : account;
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([157, 20, 49, 224, 217, 87, 193, 254]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.WhirlpoolsConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([2, 99, 215, 163, 240, 26, 153, 58]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.WhirlpoolsConfigExtension;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([56, 75, 159, 76, 142, 68, 190, 105]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.FeeTier;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([106, 47, 238, 159, 124, 12, 160, 192]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.LockConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([170, 188, 143, 228, 122, 64, 247, 208]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.Position;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([129, 169, 175, 65, 185, 95, 32, 100]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.PositionBundle;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([69, 97, 189, 190, 110, 7, 66, 187]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.TickArray;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([116, 219, 204, 229, 249, 116, 255, 150]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.TokenBadge;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([63, 149, 209, 12, 225, 128, 99, 9]),
      ),
      0,
    )
  ) {
    return WhirlpoolAccount.Whirlpool;
  }
  throw new SolanaError(
    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_ACCOUNT,
    { accountData: data, programName: "whirlpool" },
  );
}

export enum WhirlpoolInstruction {
  InitializeConfig = 0,
  InitializePool = 1,
  InitializeTickArray = 2,
  InitializeFeeTier = 3,
  InitializeReward = 4,
  SetRewardEmissions = 5,
  OpenPosition = 6,
  OpenPositionWithMetadata = 7,
  IncreaseLiquidity = 8,
  DecreaseLiquidity = 9,
  UpdateFeesAndRewards = 10,
  CollectFees = 11,
  CollectReward = 12,
  CollectProtocolFees = 13,
  Swap = 14,
  ClosePosition = 15,
  SetDefaultFeeRate = 16,
  SetDefaultProtocolFeeRate = 17,
  SetFeeRate = 18,
  SetProtocolFeeRate = 19,
  SetFeeAuthority = 20,
  SetCollectProtocolFeesAuthority = 21,
  SetRewardAuthority = 22,
  SetRewardAuthorityBySuperAuthority = 23,
  SetRewardEmissionsSuperAuthority = 24,
  TwoHopSwap = 25,
  InitializePositionBundle = 26,
  InitializePositionBundleWithMetadata = 27,
  DeletePositionBundle = 28,
  OpenBundledPosition = 29,
  CloseBundledPosition = 30,
  OpenPositionWithTokenExtensions = 31,
  ClosePositionWithTokenExtensions = 32,
  LockPosition = 33,
  CollectFeesV2 = 34,
  CollectProtocolFeesV2 = 35,
  CollectRewardV2 = 36,
  DecreaseLiquidityV2 = 37,
  IncreaseLiquidityV2 = 38,
  InitializePoolV2 = 39,
  InitializeRewardV2 = 40,
  SetRewardEmissionsV2 = 41,
  SwapV2 = 42,
  TwoHopSwapV2 = 43,
  InitializeConfigExtension = 44,
  SetConfigExtensionAuthority = 45,
  SetTokenBadgeAuthority = 46,
  InitializeTokenBadge = 47,
  DeleteTokenBadge = 48,
}

export function identifyWhirlpoolInstruction(
  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
): WhirlpoolInstruction {
  const data = "data" in instruction ? instruction.data : instruction;
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([208, 127, 21, 1, 194, 190, 196, 70]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([95, 180, 10, 172, 84, 174, 232, 40]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializePool;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([11, 188, 193, 214, 141, 91, 149, 184]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeTickArray;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([183, 74, 156, 160, 112, 2, 42, 30]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeFeeTier;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([95, 135, 192, 196, 242, 129, 230, 68]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeReward;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([13, 197, 86, 168, 109, 176, 27, 244]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetRewardEmissions;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([135, 128, 47, 77, 15, 152, 240, 49]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.OpenPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([242, 29, 134, 48, 58, 110, 14, 60]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.OpenPositionWithMetadata;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([46, 156, 243, 118, 13, 205, 251, 178]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.IncreaseLiquidity;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([160, 38, 208, 111, 104, 91, 44, 1]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.DecreaseLiquidity;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([154, 230, 250, 13, 236, 209, 75, 223]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.UpdateFeesAndRewards;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([164, 152, 207, 99, 30, 186, 19, 182]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CollectFees;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([70, 5, 132, 87, 86, 235, 177, 34]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CollectReward;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([22, 67, 23, 98, 150, 178, 70, 220]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CollectProtocolFees;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([248, 198, 158, 145, 225, 117, 135, 200]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.Swap;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([123, 134, 81, 0, 49, 68, 98, 98]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.ClosePosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([118, 215, 214, 157, 182, 229, 208, 228]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetDefaultFeeRate;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([107, 205, 249, 226, 151, 35, 86, 0]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetDefaultProtocolFeeRate;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([53, 243, 137, 65, 8, 140, 158, 6]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetFeeRate;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([95, 7, 4, 50, 154, 79, 156, 131]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetProtocolFeeRate;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([31, 1, 50, 87, 237, 101, 97, 132]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetFeeAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([34, 150, 93, 244, 139, 225, 233, 67]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetCollectProtocolFeesAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([34, 39, 183, 252, 83, 28, 85, 127]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetRewardAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([240, 154, 201, 198, 148, 93, 56, 25]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetRewardAuthorityBySuperAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([207, 5, 200, 209, 122, 56, 82, 183]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetRewardEmissionsSuperAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([195, 96, 237, 108, 68, 162, 219, 230]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.TwoHopSwap;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([117, 45, 241, 149, 24, 18, 194, 65]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializePositionBundle;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([93, 124, 16, 179, 249, 131, 115, 245]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializePositionBundleWithMetadata;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([100, 25, 99, 2, 217, 239, 124, 173]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.DeletePositionBundle;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([169, 113, 126, 171, 213, 172, 212, 49]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.OpenBundledPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([41, 36, 216, 245, 27, 85, 103, 67]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CloseBundledPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([212, 47, 95, 92, 114, 102, 131, 250]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.OpenPositionWithTokenExtensions;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([1, 182, 135, 59, 155, 25, 99, 223]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.ClosePositionWithTokenExtensions;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([227, 62, 2, 252, 247, 10, 171, 185]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.LockPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([207, 117, 95, 191, 229, 180, 226, 15]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CollectFeesV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([103, 128, 222, 134, 114, 200, 22, 200]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CollectProtocolFeesV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([177, 107, 37, 180, 160, 19, 49, 209]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.CollectRewardV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([58, 127, 188, 62, 79, 82, 196, 96]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.DecreaseLiquidityV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([133, 29, 89, 223, 69, 238, 176, 10]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.IncreaseLiquidityV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([207, 45, 87, 242, 27, 63, 204, 67]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializePoolV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([91, 1, 77, 50, 235, 229, 133, 49]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeRewardV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([114, 228, 72, 32, 193, 48, 160, 102]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetRewardEmissionsV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([43, 4, 237, 11, 26, 201, 30, 98]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SwapV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([186, 143, 209, 29, 254, 2, 194, 117]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.TwoHopSwapV2;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([55, 9, 53, 9, 114, 57, 209, 52]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeConfigExtension;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([44, 94, 241, 116, 24, 188, 60, 143]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetConfigExtensionAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([207, 202, 4, 32, 205, 79, 13, 178]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.SetTokenBadgeAuthority;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([253, 77, 205, 95, 27, 224, 89, 223]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.InitializeTokenBadge;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([53, 146, 68, 8, 18, 117, 17, 185]),
      ),
      0,
    )
  ) {
    return WhirlpoolInstruction.DeleteTokenBadge;
  }
  throw new SolanaError(
    SOLANA_ERROR__PROGRAM_CLIENTS__FAILED_TO_IDENTIFY_INSTRUCTION,
    { instructionData: data, programName: "whirlpool" },
  );
}

export type ParsedWhirlpoolInstruction<
  TProgram extends string = "whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc",
> =
  | ({
      instructionType: WhirlpoolInstruction.InitializeConfig;
    } & ParsedInitializeConfigInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializePool;
    } & ParsedInitializePoolInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializeTickArray;
    } & ParsedInitializeTickArrayInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializeFeeTier;
    } & ParsedInitializeFeeTierInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializeReward;
    } & ParsedInitializeRewardInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetRewardEmissions;
    } & ParsedSetRewardEmissionsInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.OpenPosition;
    } & ParsedOpenPositionInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.OpenPositionWithMetadata;
    } & ParsedOpenPositionWithMetadataInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.IncreaseLiquidity;
    } & ParsedIncreaseLiquidityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.DecreaseLiquidity;
    } & ParsedDecreaseLiquidityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.UpdateFeesAndRewards;
    } & ParsedUpdateFeesAndRewardsInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CollectFees;
    } & ParsedCollectFeesInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CollectReward;
    } & ParsedCollectRewardInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CollectProtocolFees;
    } & ParsedCollectProtocolFeesInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.Swap;
    } & ParsedSwapInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.ClosePosition;
    } & ParsedClosePositionInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetDefaultFeeRate;
    } & ParsedSetDefaultFeeRateInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetDefaultProtocolFeeRate;
    } & ParsedSetDefaultProtocolFeeRateInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetFeeRate;
    } & ParsedSetFeeRateInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetProtocolFeeRate;
    } & ParsedSetProtocolFeeRateInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetFeeAuthority;
    } & ParsedSetFeeAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetCollectProtocolFeesAuthority;
    } & ParsedSetCollectProtocolFeesAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetRewardAuthority;
    } & ParsedSetRewardAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetRewardAuthorityBySuperAuthority;
    } & ParsedSetRewardAuthorityBySuperAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetRewardEmissionsSuperAuthority;
    } & ParsedSetRewardEmissionsSuperAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.TwoHopSwap;
    } & ParsedTwoHopSwapInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializePositionBundle;
    } & ParsedInitializePositionBundleInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializePositionBundleWithMetadata;
    } & ParsedInitializePositionBundleWithMetadataInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.DeletePositionBundle;
    } & ParsedDeletePositionBundleInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.OpenBundledPosition;
    } & ParsedOpenBundledPositionInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CloseBundledPosition;
    } & ParsedCloseBundledPositionInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.OpenPositionWithTokenExtensions;
    } & ParsedOpenPositionWithTokenExtensionsInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.ClosePositionWithTokenExtensions;
    } & ParsedClosePositionWithTokenExtensionsInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.LockPosition;
    } & ParsedLockPositionInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CollectFeesV2;
    } & ParsedCollectFeesV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CollectProtocolFeesV2;
    } & ParsedCollectProtocolFeesV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.CollectRewardV2;
    } & ParsedCollectRewardV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.DecreaseLiquidityV2;
    } & ParsedDecreaseLiquidityV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.IncreaseLiquidityV2;
    } & ParsedIncreaseLiquidityV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializePoolV2;
    } & ParsedInitializePoolV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializeRewardV2;
    } & ParsedInitializeRewardV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetRewardEmissionsV2;
    } & ParsedSetRewardEmissionsV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SwapV2;
    } & ParsedSwapV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.TwoHopSwapV2;
    } & ParsedTwoHopSwapV2Instruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializeConfigExtension;
    } & ParsedInitializeConfigExtensionInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetConfigExtensionAuthority;
    } & ParsedSetConfigExtensionAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.SetTokenBadgeAuthority;
    } & ParsedSetTokenBadgeAuthorityInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.InitializeTokenBadge;
    } & ParsedInitializeTokenBadgeInstruction<TProgram>)
  | ({
      instructionType: WhirlpoolInstruction.DeleteTokenBadge;
    } & ParsedDeleteTokenBadgeInstruction<TProgram>);

export function parseWhirlpoolInstruction<TProgram extends string>(
  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
): ParsedWhirlpoolInstruction<TProgram> {
  const instructionType = identifyWhirlpoolInstruction(instruction);
  switch (instructionType) {
    case WhirlpoolInstruction.InitializeConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeConfig,
        ...parseInitializeConfigInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializePool: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializePool,
        ...parseInitializePoolInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializeTickArray: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeTickArray,
        ...parseInitializeTickArrayInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializeFeeTier: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeFeeTier,
        ...parseInitializeFeeTierInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializeReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeReward,
        ...parseInitializeRewardInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetRewardEmissions: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetRewardEmissions,
        ...parseSetRewardEmissionsInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.OpenPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.OpenPosition,
        ...parseOpenPositionInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.OpenPositionWithMetadata: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.OpenPositionWithMetadata,
        ...parseOpenPositionWithMetadataInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.IncreaseLiquidity: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.IncreaseLiquidity,
        ...parseIncreaseLiquidityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.DecreaseLiquidity: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.DecreaseLiquidity,
        ...parseDecreaseLiquidityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.UpdateFeesAndRewards: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.UpdateFeesAndRewards,
        ...parseUpdateFeesAndRewardsInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.CollectFees: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CollectFees,
        ...parseCollectFeesInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.CollectReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CollectReward,
        ...parseCollectRewardInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.CollectProtocolFees: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CollectProtocolFees,
        ...parseCollectProtocolFeesInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.Swap: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.Swap,
        ...parseSwapInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.ClosePosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.ClosePosition,
        ...parseClosePositionInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetDefaultFeeRate: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetDefaultFeeRate,
        ...parseSetDefaultFeeRateInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetDefaultProtocolFeeRate: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetDefaultProtocolFeeRate,
        ...parseSetDefaultProtocolFeeRateInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetFeeRate: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetFeeRate,
        ...parseSetFeeRateInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetProtocolFeeRate: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetProtocolFeeRate,
        ...parseSetProtocolFeeRateInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetFeeAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetFeeAuthority,
        ...parseSetFeeAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetCollectProtocolFeesAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetCollectProtocolFeesAuthority,
        ...parseSetCollectProtocolFeesAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetRewardAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetRewardAuthority,
        ...parseSetRewardAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetRewardAuthorityBySuperAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType:
          WhirlpoolInstruction.SetRewardAuthorityBySuperAuthority,
        ...parseSetRewardAuthorityBySuperAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetRewardEmissionsSuperAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetRewardEmissionsSuperAuthority,
        ...parseSetRewardEmissionsSuperAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.TwoHopSwap: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.TwoHopSwap,
        ...parseTwoHopSwapInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializePositionBundle: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializePositionBundle,
        ...parseInitializePositionBundleInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializePositionBundleWithMetadata: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType:
          WhirlpoolInstruction.InitializePositionBundleWithMetadata,
        ...parseInitializePositionBundleWithMetadataInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.DeletePositionBundle: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.DeletePositionBundle,
        ...parseDeletePositionBundleInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.OpenBundledPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.OpenBundledPosition,
        ...parseOpenBundledPositionInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.CloseBundledPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CloseBundledPosition,
        ...parseCloseBundledPositionInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.OpenPositionWithTokenExtensions: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.OpenPositionWithTokenExtensions,
        ...parseOpenPositionWithTokenExtensionsInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.ClosePositionWithTokenExtensions: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.ClosePositionWithTokenExtensions,
        ...parseClosePositionWithTokenExtensionsInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.LockPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.LockPosition,
        ...parseLockPositionInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.CollectFeesV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CollectFeesV2,
        ...parseCollectFeesV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.CollectProtocolFeesV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CollectProtocolFeesV2,
        ...parseCollectProtocolFeesV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.CollectRewardV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.CollectRewardV2,
        ...parseCollectRewardV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.DecreaseLiquidityV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.DecreaseLiquidityV2,
        ...parseDecreaseLiquidityV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.IncreaseLiquidityV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.IncreaseLiquidityV2,
        ...parseIncreaseLiquidityV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializePoolV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializePoolV2,
        ...parseInitializePoolV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializeRewardV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeRewardV2,
        ...parseInitializeRewardV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetRewardEmissionsV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetRewardEmissionsV2,
        ...parseSetRewardEmissionsV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.SwapV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SwapV2,
        ...parseSwapV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.TwoHopSwapV2: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.TwoHopSwapV2,
        ...parseTwoHopSwapV2Instruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializeConfigExtension: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeConfigExtension,
        ...parseInitializeConfigExtensionInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetConfigExtensionAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetConfigExtensionAuthority,
        ...parseSetConfigExtensionAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.SetTokenBadgeAuthority: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.SetTokenBadgeAuthority,
        ...parseSetTokenBadgeAuthorityInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.InitializeTokenBadge: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.InitializeTokenBadge,
        ...parseInitializeTokenBadgeInstruction(instruction),
      };
    }
    case WhirlpoolInstruction.DeleteTokenBadge: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: WhirlpoolInstruction.DeleteTokenBadge,
        ...parseDeleteTokenBadgeInstruction(instruction),
      };
    }
    default:
      throw new SolanaError(
        SOLANA_ERROR__PROGRAM_CLIENTS__UNRECOGNIZED_INSTRUCTION_TYPE,
        {
          instructionType: instructionType as string,
          programName: "whirlpool",
        },
      );
  }
}

export interface WhirlpoolPlugin {
  accounts: WhirlpoolPluginAccounts;
  instructions: WhirlpoolPluginInstructions;
}

export interface WhirlpoolPluginAccounts {
  whirlpoolsConfig: ReturnType<typeof getWhirlpoolsConfigCodec> &
    SelfFetchFunctions<WhirlpoolsConfigArgs, WhirlpoolsConfig>;
  whirlpoolsConfigExtension: ReturnType<
    typeof getWhirlpoolsConfigExtensionCodec
  > &
    SelfFetchFunctions<
      WhirlpoolsConfigExtensionArgs,
      WhirlpoolsConfigExtension
    >;
  feeTier: ReturnType<typeof getFeeTierCodec> &
    SelfFetchFunctions<FeeTierArgs, FeeTier>;
  lockConfig: ReturnType<typeof getLockConfigCodec> &
    SelfFetchFunctions<LockConfigArgs, LockConfig>;
  position: ReturnType<typeof getPositionCodec> &
    SelfFetchFunctions<PositionArgs, Position>;
  positionBundle: ReturnType<typeof getPositionBundleCodec> &
    SelfFetchFunctions<PositionBundleArgs, PositionBundle>;
  tickArray: ReturnType<typeof getTickArrayCodec> &
    SelfFetchFunctions<TickArrayArgs, TickArray>;
  tokenBadge: ReturnType<typeof getTokenBadgeCodec> &
    SelfFetchFunctions<TokenBadgeArgs, TokenBadge>;
  whirlpool: ReturnType<typeof getWhirlpoolCodec> &
    SelfFetchFunctions<WhirlpoolArgs, Whirlpool>;
}

export interface WhirlpoolPluginInstructions {
  initializeConfig: (
    input: InitializeConfigInput,
  ) => ReturnType<typeof getInitializeConfigInstruction> &
    SelfPlanAndSendFunctions;
  initializePool: (
    input: InitializePoolInput,
  ) => ReturnType<typeof getInitializePoolInstruction> &
    SelfPlanAndSendFunctions;
  initializeTickArray: (
    input: InitializeTickArrayInput,
  ) => ReturnType<typeof getInitializeTickArrayInstruction> &
    SelfPlanAndSendFunctions;
  initializeFeeTier: (
    input: InitializeFeeTierInput,
  ) => ReturnType<typeof getInitializeFeeTierInstruction> &
    SelfPlanAndSendFunctions;
  initializeReward: (
    input: InitializeRewardInput,
  ) => ReturnType<typeof getInitializeRewardInstruction> &
    SelfPlanAndSendFunctions;
  setRewardEmissions: (
    input: SetRewardEmissionsInput,
  ) => ReturnType<typeof getSetRewardEmissionsInstruction> &
    SelfPlanAndSendFunctions;
  openPosition: (
    input: OpenPositionInput,
  ) => ReturnType<typeof getOpenPositionInstruction> & SelfPlanAndSendFunctions;
  openPositionWithMetadata: (
    input: OpenPositionWithMetadataInput,
  ) => ReturnType<typeof getOpenPositionWithMetadataInstruction> &
    SelfPlanAndSendFunctions;
  increaseLiquidity: (
    input: IncreaseLiquidityInput,
  ) => ReturnType<typeof getIncreaseLiquidityInstruction> &
    SelfPlanAndSendFunctions;
  decreaseLiquidity: (
    input: DecreaseLiquidityInput,
  ) => ReturnType<typeof getDecreaseLiquidityInstruction> &
    SelfPlanAndSendFunctions;
  updateFeesAndRewards: (
    input: UpdateFeesAndRewardsInput,
  ) => ReturnType<typeof getUpdateFeesAndRewardsInstruction> &
    SelfPlanAndSendFunctions;
  collectFees: (
    input: CollectFeesInput,
  ) => ReturnType<typeof getCollectFeesInstruction> & SelfPlanAndSendFunctions;
  collectReward: (
    input: CollectRewardInput,
  ) => ReturnType<typeof getCollectRewardInstruction> &
    SelfPlanAndSendFunctions;
  collectProtocolFees: (
    input: CollectProtocolFeesInput,
  ) => ReturnType<typeof getCollectProtocolFeesInstruction> &
    SelfPlanAndSendFunctions;
  swap: (
    input: SwapInput,
  ) => ReturnType<typeof getSwapInstruction> & SelfPlanAndSendFunctions;
  closePosition: (
    input: ClosePositionInput,
  ) => ReturnType<typeof getClosePositionInstruction> &
    SelfPlanAndSendFunctions;
  setDefaultFeeRate: (
    input: SetDefaultFeeRateInput,
  ) => ReturnType<typeof getSetDefaultFeeRateInstruction> &
    SelfPlanAndSendFunctions;
  setDefaultProtocolFeeRate: (
    input: SetDefaultProtocolFeeRateInput,
  ) => ReturnType<typeof getSetDefaultProtocolFeeRateInstruction> &
    SelfPlanAndSendFunctions;
  setFeeRate: (
    input: SetFeeRateInput,
  ) => ReturnType<typeof getSetFeeRateInstruction> & SelfPlanAndSendFunctions;
  setProtocolFeeRate: (
    input: SetProtocolFeeRateInput,
  ) => ReturnType<typeof getSetProtocolFeeRateInstruction> &
    SelfPlanAndSendFunctions;
  setFeeAuthority: (
    input: SetFeeAuthorityInput,
  ) => ReturnType<typeof getSetFeeAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  setCollectProtocolFeesAuthority: (
    input: SetCollectProtocolFeesAuthorityInput,
  ) => ReturnType<typeof getSetCollectProtocolFeesAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  setRewardAuthority: (
    input: SetRewardAuthorityInput,
  ) => ReturnType<typeof getSetRewardAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  setRewardAuthorityBySuperAuthority: (
    input: SetRewardAuthorityBySuperAuthorityInput,
  ) => ReturnType<typeof getSetRewardAuthorityBySuperAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  setRewardEmissionsSuperAuthority: (
    input: SetRewardEmissionsSuperAuthorityInput,
  ) => ReturnType<typeof getSetRewardEmissionsSuperAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  twoHopSwap: (
    input: TwoHopSwapInput,
  ) => ReturnType<typeof getTwoHopSwapInstruction> & SelfPlanAndSendFunctions;
  initializePositionBundle: (
    input: InitializePositionBundleInput,
  ) => ReturnType<typeof getInitializePositionBundleInstruction> &
    SelfPlanAndSendFunctions;
  initializePositionBundleWithMetadata: (
    input: InitializePositionBundleWithMetadataInput,
  ) => ReturnType<typeof getInitializePositionBundleWithMetadataInstruction> &
    SelfPlanAndSendFunctions;
  deletePositionBundle: (
    input: DeletePositionBundleInput,
  ) => ReturnType<typeof getDeletePositionBundleInstruction> &
    SelfPlanAndSendFunctions;
  openBundledPosition: (
    input: OpenBundledPositionInput,
  ) => ReturnType<typeof getOpenBundledPositionInstruction> &
    SelfPlanAndSendFunctions;
  closeBundledPosition: (
    input: CloseBundledPositionInput,
  ) => ReturnType<typeof getCloseBundledPositionInstruction> &
    SelfPlanAndSendFunctions;
  openPositionWithTokenExtensions: (
    input: OpenPositionWithTokenExtensionsInput,
  ) => ReturnType<typeof getOpenPositionWithTokenExtensionsInstruction> &
    SelfPlanAndSendFunctions;
  closePositionWithTokenExtensions: (
    input: ClosePositionWithTokenExtensionsInput,
  ) => ReturnType<typeof getClosePositionWithTokenExtensionsInstruction> &
    SelfPlanAndSendFunctions;
  lockPosition: (
    input: LockPositionInput,
  ) => ReturnType<typeof getLockPositionInstruction> & SelfPlanAndSendFunctions;
  collectFeesV2: (
    input: CollectFeesV2Input,
  ) => ReturnType<typeof getCollectFeesV2Instruction> &
    SelfPlanAndSendFunctions;
  collectProtocolFeesV2: (
    input: CollectProtocolFeesV2Input,
  ) => ReturnType<typeof getCollectProtocolFeesV2Instruction> &
    SelfPlanAndSendFunctions;
  collectRewardV2: (
    input: CollectRewardV2Input,
  ) => ReturnType<typeof getCollectRewardV2Instruction> &
    SelfPlanAndSendFunctions;
  decreaseLiquidityV2: (
    input: DecreaseLiquidityV2Input,
  ) => ReturnType<typeof getDecreaseLiquidityV2Instruction> &
    SelfPlanAndSendFunctions;
  increaseLiquidityV2: (
    input: IncreaseLiquidityV2Input,
  ) => ReturnType<typeof getIncreaseLiquidityV2Instruction> &
    SelfPlanAndSendFunctions;
  initializePoolV2: (
    input: InitializePoolV2Input,
  ) => ReturnType<typeof getInitializePoolV2Instruction> &
    SelfPlanAndSendFunctions;
  initializeRewardV2: (
    input: InitializeRewardV2Input,
  ) => ReturnType<typeof getInitializeRewardV2Instruction> &
    SelfPlanAndSendFunctions;
  setRewardEmissionsV2: (
    input: SetRewardEmissionsV2Input,
  ) => ReturnType<typeof getSetRewardEmissionsV2Instruction> &
    SelfPlanAndSendFunctions;
  swapV2: (
    input: SwapV2Input,
  ) => ReturnType<typeof getSwapV2Instruction> & SelfPlanAndSendFunctions;
  twoHopSwapV2: (
    input: TwoHopSwapV2Input,
  ) => ReturnType<typeof getTwoHopSwapV2Instruction> & SelfPlanAndSendFunctions;
  initializeConfigExtension: (
    input: InitializeConfigExtensionInput,
  ) => ReturnType<typeof getInitializeConfigExtensionInstruction> &
    SelfPlanAndSendFunctions;
  setConfigExtensionAuthority: (
    input: SetConfigExtensionAuthorityInput,
  ) => ReturnType<typeof getSetConfigExtensionAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  setTokenBadgeAuthority: (
    input: SetTokenBadgeAuthorityInput,
  ) => ReturnType<typeof getSetTokenBadgeAuthorityInstruction> &
    SelfPlanAndSendFunctions;
  initializeTokenBadge: (
    input: InitializeTokenBadgeInput,
  ) => ReturnType<typeof getInitializeTokenBadgeInstruction> &
    SelfPlanAndSendFunctions;
  deleteTokenBadge: (
    input: DeleteTokenBadgeInput,
  ) => ReturnType<typeof getDeleteTokenBadgeInstruction> &
    SelfPlanAndSendFunctions;
}

export type WhirlpoolPluginRequirements = ClientWithRpc<
  GetAccountInfoApi & GetMultipleAccountsApi
> &
  ClientWithTransactionPlanning &
  ClientWithTransactionSending;

export function whirlpoolProgram() {
  return <T extends WhirlpoolPluginRequirements>(
    client: T,
  ): Omit<T, "whirlpool"> & { whirlpool: WhirlpoolPlugin } => {
    return extendClient(client, {
      whirlpool: <WhirlpoolPlugin>{
        accounts: {
          whirlpoolsConfig: addSelfFetchFunctions(
            client,
            getWhirlpoolsConfigCodec(),
          ),
          whirlpoolsConfigExtension: addSelfFetchFunctions(
            client,
            getWhirlpoolsConfigExtensionCodec(),
          ),
          feeTier: addSelfFetchFunctions(client, getFeeTierCodec()),
          lockConfig: addSelfFetchFunctions(client, getLockConfigCodec()),
          position: addSelfFetchFunctions(client, getPositionCodec()),
          positionBundle: addSelfFetchFunctions(
            client,
            getPositionBundleCodec(),
          ),
          tickArray: addSelfFetchFunctions(client, getTickArrayCodec()),
          tokenBadge: addSelfFetchFunctions(client, getTokenBadgeCodec()),
          whirlpool: addSelfFetchFunctions(client, getWhirlpoolCodec()),
        },
        instructions: {
          initializeConfig: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeConfigInstruction(input),
            ),
          initializePool: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializePoolInstruction(input),
            ),
          initializeTickArray: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeTickArrayInstruction(input),
            ),
          initializeFeeTier: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeFeeTierInstruction(input),
            ),
          initializeReward: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeRewardInstruction(input),
            ),
          setRewardEmissions: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetRewardEmissionsInstruction(input),
            ),
          openPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getOpenPositionInstruction(input),
            ),
          openPositionWithMetadata: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getOpenPositionWithMetadataInstruction(input),
            ),
          increaseLiquidity: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getIncreaseLiquidityInstruction(input),
            ),
          decreaseLiquidity: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getDecreaseLiquidityInstruction(input),
            ),
          updateFeesAndRewards: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getUpdateFeesAndRewardsInstruction(input),
            ),
          collectFees: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCollectFeesInstruction(input),
            ),
          collectReward: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCollectRewardInstruction(input),
            ),
          collectProtocolFees: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCollectProtocolFeesInstruction(input),
            ),
          swap: (input) =>
            addSelfPlanAndSendFunctions(client, getSwapInstruction(input)),
          closePosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClosePositionInstruction(input),
            ),
          setDefaultFeeRate: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetDefaultFeeRateInstruction(input),
            ),
          setDefaultProtocolFeeRate: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetDefaultProtocolFeeRateInstruction(input),
            ),
          setFeeRate: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetFeeRateInstruction(input),
            ),
          setProtocolFeeRate: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetProtocolFeeRateInstruction(input),
            ),
          setFeeAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetFeeAuthorityInstruction(input),
            ),
          setCollectProtocolFeesAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetCollectProtocolFeesAuthorityInstruction(input),
            ),
          setRewardAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetRewardAuthorityInstruction(input),
            ),
          setRewardAuthorityBySuperAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetRewardAuthorityBySuperAuthorityInstruction(input),
            ),
          setRewardEmissionsSuperAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetRewardEmissionsSuperAuthorityInstruction(input),
            ),
          twoHopSwap: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getTwoHopSwapInstruction(input),
            ),
          initializePositionBundle: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializePositionBundleInstruction(input),
            ),
          initializePositionBundleWithMetadata: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializePositionBundleWithMetadataInstruction(input),
            ),
          deletePositionBundle: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getDeletePositionBundleInstruction(input),
            ),
          openBundledPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getOpenBundledPositionInstruction(input),
            ),
          closeBundledPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCloseBundledPositionInstruction(input),
            ),
          openPositionWithTokenExtensions: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getOpenPositionWithTokenExtensionsInstruction(input),
            ),
          closePositionWithTokenExtensions: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getClosePositionWithTokenExtensionsInstruction(input),
            ),
          lockPosition: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getLockPositionInstruction(input),
            ),
          collectFeesV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCollectFeesV2Instruction(input),
            ),
          collectProtocolFeesV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCollectProtocolFeesV2Instruction(input),
            ),
          collectRewardV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getCollectRewardV2Instruction(input),
            ),
          decreaseLiquidityV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getDecreaseLiquidityV2Instruction(input),
            ),
          increaseLiquidityV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getIncreaseLiquidityV2Instruction(input),
            ),
          initializePoolV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializePoolV2Instruction(input),
            ),
          initializeRewardV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeRewardV2Instruction(input),
            ),
          setRewardEmissionsV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetRewardEmissionsV2Instruction(input),
            ),
          swapV2: (input) =>
            addSelfPlanAndSendFunctions(client, getSwapV2Instruction(input)),
          twoHopSwapV2: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getTwoHopSwapV2Instruction(input),
            ),
          initializeConfigExtension: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeConfigExtensionInstruction(input),
            ),
          setConfigExtensionAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetConfigExtensionAuthorityInstruction(input),
            ),
          setTokenBadgeAuthority: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getSetTokenBadgeAuthorityInstruction(input),
            ),
          initializeTokenBadge: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getInitializeTokenBadgeInstruction(input),
            ),
          deleteTokenBadge: (input) =>
            addSelfPlanAndSendFunctions(
              client,
              getDeleteTokenBadgeInstruction(input),
            ),
        },
      },
    });
  };
}