/**
 * 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 {
  assertIsInstructionWithAccounts,
  containsBytes,
  fixEncoderSize,
  getBytesEncoder,
  type Address,
  type Instruction,
  type InstructionWithData,
  type ReadonlyUint8Array,
} from "@solana/kit";
import {
  parseAddKaminoRewardsInstruction,
  parseChangePoolInstruction,
  parseCheckExpectedVaultsBalancesInstruction,
  parseCloseProgramAccountInstruction,
  parseCloseStrategyInstruction,
  parseCollectFeesAndRewardsInstruction,
  parseDepositAndInvestInstruction,
  parseDepositInstruction,
  parseEmergencySwapInstruction,
  parseExecutiveWithdrawInstruction,
  parseFlashSwapUnevenVaultsEndInstruction,
  parseFlashSwapUnevenVaultsStartInstruction,
  parseInitializeCollateralInfoInstruction,
  parseInitializeGlobalConfigInstruction,
  parseInitializeKaminoRewardInstruction,
  parseInitializeSharesMetadataInstruction,
  parseInitializeStrategyInstruction,
  parseInsertCollateralInfoInstruction,
  parseInvestInstruction,
  parseOpenLiquidityPositionInstruction,
  parseOrcaSwapInstruction,
  parsePermisionlessWithdrawFromTreasuryInstruction,
  parseSignTermsInstruction,
  parseSingleTokenDepositAndInvestWithMinInstruction,
  parseSingleTokenDepositWithMinInstruction,
  parseSwapRewardsInstruction,
  parseSwapUnevenVaultsInstruction,
  parseUpdateCollateralInfoInstruction,
  parseUpdateGlobalConfigInstruction,
  parseUpdateRewardMappingInstruction,
  parseUpdateSharesMetadataInstruction,
  parseUpdateStrategyAdminInstruction,
  parseUpdateStrategyConfigInstruction,
  parseUpdateTreasuryFeeVaultInstruction,
  parseWithdrawFromTopupInstruction,
  parseWithdrawFromTreasuryInstruction,
  parseWithdrawInstruction,
  type ParsedAddKaminoRewardsInstruction,
  type ParsedChangePoolInstruction,
  type ParsedCheckExpectedVaultsBalancesInstruction,
  type ParsedCloseProgramAccountInstruction,
  type ParsedCloseStrategyInstruction,
  type ParsedCollectFeesAndRewardsInstruction,
  type ParsedDepositAndInvestInstruction,
  type ParsedDepositInstruction,
  type ParsedEmergencySwapInstruction,
  type ParsedExecutiveWithdrawInstruction,
  type ParsedFlashSwapUnevenVaultsEndInstruction,
  type ParsedFlashSwapUnevenVaultsStartInstruction,
  type ParsedInitializeCollateralInfoInstruction,
  type ParsedInitializeGlobalConfigInstruction,
  type ParsedInitializeKaminoRewardInstruction,
  type ParsedInitializeSharesMetadataInstruction,
  type ParsedInitializeStrategyInstruction,
  type ParsedInsertCollateralInfoInstruction,
  type ParsedInvestInstruction,
  type ParsedOpenLiquidityPositionInstruction,
  type ParsedOrcaSwapInstruction,
  type ParsedPermisionlessWithdrawFromTreasuryInstruction,
  type ParsedSignTermsInstruction,
  type ParsedSingleTokenDepositAndInvestWithMinInstruction,
  type ParsedSingleTokenDepositWithMinInstruction,
  type ParsedSwapRewardsInstruction,
  type ParsedSwapUnevenVaultsInstruction,
  type ParsedUpdateCollateralInfoInstruction,
  type ParsedUpdateGlobalConfigInstruction,
  type ParsedUpdateRewardMappingInstruction,
  type ParsedUpdateSharesMetadataInstruction,
  type ParsedUpdateStrategyAdminInstruction,
  type ParsedUpdateStrategyConfigInstruction,
  type ParsedUpdateTreasuryFeeVaultInstruction,
  type ParsedWithdrawFromTopupInstruction,
  type ParsedWithdrawFromTreasuryInstruction,
  type ParsedWithdrawInstruction,
} from "../instructions";

export const YVAULTS_PROGRAM_ADDRESS = "6LtLpnUFNByNXLyCoK9wA2MykKAmQNZKBdY8s47dehDc" as Address<"6LtLpnUFNByNXLyCoK9wA2MykKAmQNZKBdY8s47dehDc">;

export enum YvaultsAccount {
  Whirlpool,
  Position,
  PoolState,
  PersonalPositionState,
  ProtocolPositionState,
  WhirlpoolStrategy,
  GlobalConfig,
  CollateralInfos,
  ScopeChainAccount,
  TermsSignature,
}

export function identifyYvaultsAccount(
  account: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
): YvaultsAccount {
  const data = "data" in account ? account.data : account;
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([63, 149, 209, 12, 225, 128, 99, 9]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.Whirlpool;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([170, 188, 143, 228, 122, 64, 247, 208]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.Position;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([247, 237, 227, 245, 215, 195, 222, 70]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.PoolState;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([70, 111, 150, 126, 230, 15, 25, 117]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.PersonalPositionState;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([100, 226, 145, 99, 146, 218, 160, 106]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.ProtocolPositionState;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([190, 178, 231, 184, 49, 186, 103, 13]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.WhirlpoolStrategy;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([149, 8, 156, 202, 160, 252, 176, 217]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.GlobalConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([127, 210, 52, 226, 74, 169, 111, 9]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.CollateralInfos;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([180, 51, 138, 247, 240, 173, 119, 79]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.ScopeChainAccount;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([197, 173, 136, 91, 182, 49, 113, 19]),
      ),
      0,
    )
  ) {
    return YvaultsAccount.TermsSignature;
  }
  throw new Error(
    "The provided account could not be identified as a yvaults account.",
  );
}

export enum YvaultsInstruction {
  InitializeStrategy,
  InitializeKaminoReward,
  AddKaminoRewards,
  InitializeGlobalConfig,
  InitializeCollateralInfo,
  UpdateCollateralInfo,
  InsertCollateralInfo,
  InitializeSharesMetadata,
  UpdateSharesMetadata,
  UpdateGlobalConfig,
  UpdateTreasuryFeeVault,
  UpdateStrategyConfig,
  UpdateRewardMapping,
  OpenLiquidityPosition,
  CloseStrategy,
  Deposit,
  Invest,
  DepositAndInvest,
  Withdraw,
  ExecutiveWithdraw,
  CollectFeesAndRewards,
  SwapRewards,
  SwapUnevenVaults,
  CheckExpectedVaultsBalances,
  SingleTokenDepositAndInvestWithMin,
  SingleTokenDepositWithMin,
  FlashSwapUnevenVaultsStart,
  FlashSwapUnevenVaultsEnd,
  EmergencySwap,
  WithdrawFromTreasury,
  PermisionlessWithdrawFromTreasury,
  WithdrawFromTopup,
  ChangePool,
  CloseProgramAccount,
  OrcaSwap,
  SignTerms,
  UpdateStrategyAdmin,
}

export function identifyYvaultsInstruction(
  instruction: { data: ReadonlyUint8Array } | ReadonlyUint8Array,
): YvaultsInstruction {
  const data = "data" in instruction ? instruction.data : instruction;
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([208, 119, 144, 145, 178, 57, 105, 252]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.InitializeStrategy;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([203, 212, 8, 90, 91, 118, 111, 50]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.InitializeKaminoReward;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([174, 174, 142, 193, 47, 77, 235, 65]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.AddKaminoRewards;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([113, 216, 122, 131, 225, 209, 22, 55]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.InitializeGlobalConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([74, 61, 216, 76, 244, 91, 18, 119]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.InitializeCollateralInfo;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([76, 94, 131, 44, 137, 61, 161, 110]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateCollateralInfo;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([22, 97, 4, 78, 166, 188, 51, 190]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.InsertCollateralInfo;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([3, 15, 172, 114, 200, 0, 131, 32]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.InitializeSharesMetadata;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([155, 34, 122, 165, 245, 137, 147, 107]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateSharesMetadata;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([164, 84, 130, 189, 111, 58, 250, 200]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateGlobalConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([9, 241, 94, 91, 173, 74, 166, 119]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateTreasuryFeeVault;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([81, 217, 177, 65, 40, 227, 8, 165]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateStrategyConfig;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([203, 37, 37, 96, 23, 85, 233, 42]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateRewardMapping;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([204, 234, 204, 219, 6, 91, 96, 241]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.OpenLiquidityPosition;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([56, 247, 170, 246, 89, 221, 134, 200]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.CloseStrategy;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([242, 35, 198, 137, 82, 225, 242, 182]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.Deposit;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([13, 245, 180, 103, 254, 182, 121, 4]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.Invest;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([22, 157, 173, 6, 187, 25, 86, 109]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.DepositAndInvest;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([183, 18, 70, 156, 148, 109, 161, 34]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.Withdraw;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([159, 39, 110, 137, 100, 234, 204, 141]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.ExecutiveWithdraw;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([113, 18, 75, 8, 182, 31, 105, 186]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.CollectFeesAndRewards;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([92, 41, 172, 30, 190, 65, 174, 90]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.SwapRewards;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([143, 212, 101, 95, 105, 209, 184, 1]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.SwapUnevenVaults;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([75, 151, 187, 125, 50, 4, 11, 71]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.CheckExpectedVaultsBalances;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([118, 134, 143, 192, 188, 21, 131, 17]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.SingleTokenDepositAndInvestWithMin;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([250, 142, 102, 160, 72, 12, 83, 139]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.SingleTokenDepositWithMin;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([129, 111, 174, 12, 10, 60, 149, 193]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.FlashSwapUnevenVaultsStart;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([226, 2, 190, 101, 202, 132, 156, 20]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.FlashSwapUnevenVaultsEnd;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([73, 226, 248, 215, 5, 197, 211, 229]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.EmergencySwap;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([0, 164, 86, 76, 56, 72, 12, 170]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.WithdrawFromTreasury;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([167, 36, 32, 79, 97, 170, 183, 108]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.PermisionlessWithdrawFromTreasury;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([95, 227, 138, 220, 240, 95, 150, 113]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.WithdrawFromTopup;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([141, 221, 123, 235, 35, 9, 145, 201]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.ChangePool;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([245, 14, 192, 211, 99, 42, 170, 187]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.CloseProgramAccount;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([33, 94, 249, 97, 250, 254, 198, 93]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.OrcaSwap;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([226, 42, 174, 143, 144, 159, 139, 1]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.SignTerms;
  }
  if (
    containsBytes(
      data,
      fixEncoderSize(getBytesEncoder(), 8).encode(
        new Uint8Array([13, 227, 164, 236, 32, 39, 6, 255]),
      ),
      0,
    )
  ) {
    return YvaultsInstruction.UpdateStrategyAdmin;
  }
  throw new Error(
    "The provided instruction could not be identified as a yvaults instruction.",
  );
}

export type ParsedYvaultsInstruction<TProgram extends string = ""> =
  | ({
      instructionType: YvaultsInstruction.InitializeStrategy;
    } & ParsedInitializeStrategyInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.InitializeKaminoReward;
    } & ParsedInitializeKaminoRewardInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.AddKaminoRewards;
    } & ParsedAddKaminoRewardsInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.InitializeGlobalConfig;
    } & ParsedInitializeGlobalConfigInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.InitializeCollateralInfo;
    } & ParsedInitializeCollateralInfoInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateCollateralInfo;
    } & ParsedUpdateCollateralInfoInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.InsertCollateralInfo;
    } & ParsedInsertCollateralInfoInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.InitializeSharesMetadata;
    } & ParsedInitializeSharesMetadataInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateSharesMetadata;
    } & ParsedUpdateSharesMetadataInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateGlobalConfig;
    } & ParsedUpdateGlobalConfigInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateTreasuryFeeVault;
    } & ParsedUpdateTreasuryFeeVaultInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateStrategyConfig;
    } & ParsedUpdateStrategyConfigInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateRewardMapping;
    } & ParsedUpdateRewardMappingInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.OpenLiquidityPosition;
    } & ParsedOpenLiquidityPositionInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.CloseStrategy;
    } & ParsedCloseStrategyInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.Deposit;
    } & ParsedDepositInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.Invest;
    } & ParsedInvestInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.DepositAndInvest;
    } & ParsedDepositAndInvestInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.Withdraw;
    } & ParsedWithdrawInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.ExecutiveWithdraw;
    } & ParsedExecutiveWithdrawInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.CollectFeesAndRewards;
    } & ParsedCollectFeesAndRewardsInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.SwapRewards;
    } & ParsedSwapRewardsInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.SwapUnevenVaults;
    } & ParsedSwapUnevenVaultsInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.CheckExpectedVaultsBalances;
    } & ParsedCheckExpectedVaultsBalancesInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.SingleTokenDepositAndInvestWithMin;
    } & ParsedSingleTokenDepositAndInvestWithMinInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.SingleTokenDepositWithMin;
    } & ParsedSingleTokenDepositWithMinInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.FlashSwapUnevenVaultsStart;
    } & ParsedFlashSwapUnevenVaultsStartInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.FlashSwapUnevenVaultsEnd;
    } & ParsedFlashSwapUnevenVaultsEndInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.EmergencySwap;
    } & ParsedEmergencySwapInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.WithdrawFromTreasury;
    } & ParsedWithdrawFromTreasuryInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.PermisionlessWithdrawFromTreasury;
    } & ParsedPermisionlessWithdrawFromTreasuryInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.WithdrawFromTopup;
    } & ParsedWithdrawFromTopupInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.ChangePool;
    } & ParsedChangePoolInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.CloseProgramAccount;
    } & ParsedCloseProgramAccountInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.OrcaSwap;
    } & ParsedOrcaSwapInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.SignTerms;
    } & ParsedSignTermsInstruction<TProgram>)
  | ({
      instructionType: YvaultsInstruction.UpdateStrategyAdmin;
    } & ParsedUpdateStrategyAdminInstruction<TProgram>);

export function parseYvaultsInstruction<TProgram extends string>(
  instruction: Instruction<TProgram> & InstructionWithData<ReadonlyUint8Array>,
): ParsedYvaultsInstruction<TProgram> {
  const instructionType = identifyYvaultsInstruction(instruction);
  switch (instructionType) {
    case YvaultsInstruction.InitializeStrategy: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.InitializeStrategy,
        ...parseInitializeStrategyInstruction(instruction),
      };
    }
    case YvaultsInstruction.InitializeKaminoReward: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.InitializeKaminoReward,
        ...parseInitializeKaminoRewardInstruction(instruction),
      };
    }
    case YvaultsInstruction.AddKaminoRewards: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.AddKaminoRewards,
        ...parseAddKaminoRewardsInstruction(instruction),
      };
    }
    case YvaultsInstruction.InitializeGlobalConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.InitializeGlobalConfig,
        ...parseInitializeGlobalConfigInstruction(instruction),
      };
    }
    case YvaultsInstruction.InitializeCollateralInfo: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.InitializeCollateralInfo,
        ...parseInitializeCollateralInfoInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateCollateralInfo: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateCollateralInfo,
        ...parseUpdateCollateralInfoInstruction(instruction),
      };
    }
    case YvaultsInstruction.InsertCollateralInfo: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.InsertCollateralInfo,
        ...parseInsertCollateralInfoInstruction(instruction),
      };
    }
    case YvaultsInstruction.InitializeSharesMetadata: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.InitializeSharesMetadata,
        ...parseInitializeSharesMetadataInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateSharesMetadata: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateSharesMetadata,
        ...parseUpdateSharesMetadataInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateGlobalConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateGlobalConfig,
        ...parseUpdateGlobalConfigInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateTreasuryFeeVault: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateTreasuryFeeVault,
        ...parseUpdateTreasuryFeeVaultInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateStrategyConfig: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateStrategyConfig,
        ...parseUpdateStrategyConfigInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateRewardMapping: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateRewardMapping,
        ...parseUpdateRewardMappingInstruction(instruction),
      };
    }
    case YvaultsInstruction.OpenLiquidityPosition: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.OpenLiquidityPosition,
        ...parseOpenLiquidityPositionInstruction(instruction),
      };
    }
    case YvaultsInstruction.CloseStrategy: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.CloseStrategy,
        ...parseCloseStrategyInstruction(instruction),
      };
    }
    case YvaultsInstruction.Deposit: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.Deposit,
        ...parseDepositInstruction(instruction),
      };
    }
    case YvaultsInstruction.Invest: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.Invest,
        ...parseInvestInstruction(instruction),
      };
    }
    case YvaultsInstruction.DepositAndInvest: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.DepositAndInvest,
        ...parseDepositAndInvestInstruction(instruction),
      };
    }
    case YvaultsInstruction.Withdraw: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.Withdraw,
        ...parseWithdrawInstruction(instruction),
      };
    }
    case YvaultsInstruction.ExecutiveWithdraw: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.ExecutiveWithdraw,
        ...parseExecutiveWithdrawInstruction(instruction),
      };
    }
    case YvaultsInstruction.CollectFeesAndRewards: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.CollectFeesAndRewards,
        ...parseCollectFeesAndRewardsInstruction(instruction),
      };
    }
    case YvaultsInstruction.SwapRewards: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.SwapRewards,
        ...parseSwapRewardsInstruction(instruction),
      };
    }
    case YvaultsInstruction.SwapUnevenVaults: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.SwapUnevenVaults,
        ...parseSwapUnevenVaultsInstruction(instruction),
      };
    }
    case YvaultsInstruction.CheckExpectedVaultsBalances: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.CheckExpectedVaultsBalances,
        ...parseCheckExpectedVaultsBalancesInstruction(instruction),
      };
    }
    case YvaultsInstruction.SingleTokenDepositAndInvestWithMin: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.SingleTokenDepositAndInvestWithMin,
        ...parseSingleTokenDepositAndInvestWithMinInstruction(instruction),
      };
    }
    case YvaultsInstruction.SingleTokenDepositWithMin: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.SingleTokenDepositWithMin,
        ...parseSingleTokenDepositWithMinInstruction(instruction),
      };
    }
    case YvaultsInstruction.FlashSwapUnevenVaultsStart: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.FlashSwapUnevenVaultsStart,
        ...parseFlashSwapUnevenVaultsStartInstruction(instruction),
      };
    }
    case YvaultsInstruction.FlashSwapUnevenVaultsEnd: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.FlashSwapUnevenVaultsEnd,
        ...parseFlashSwapUnevenVaultsEndInstruction(instruction),
      };
    }
    case YvaultsInstruction.EmergencySwap: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.EmergencySwap,
        ...parseEmergencySwapInstruction(instruction),
      };
    }
    case YvaultsInstruction.WithdrawFromTreasury: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.WithdrawFromTreasury,
        ...parseWithdrawFromTreasuryInstruction(instruction),
      };
    }
    case YvaultsInstruction.PermisionlessWithdrawFromTreasury: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.PermisionlessWithdrawFromTreasury,
        ...parsePermisionlessWithdrawFromTreasuryInstruction(instruction),
      };
    }
    case YvaultsInstruction.WithdrawFromTopup: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.WithdrawFromTopup,
        ...parseWithdrawFromTopupInstruction(instruction),
      };
    }
    case YvaultsInstruction.ChangePool: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.ChangePool,
        ...parseChangePoolInstruction(instruction),
      };
    }
    case YvaultsInstruction.CloseProgramAccount: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.CloseProgramAccount,
        ...parseCloseProgramAccountInstruction(instruction),
      };
    }
    case YvaultsInstruction.OrcaSwap: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.OrcaSwap,
        ...parseOrcaSwapInstruction(instruction),
      };
    }
    case YvaultsInstruction.SignTerms: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.SignTerms,
        ...parseSignTermsInstruction(instruction),
      };
    }
    case YvaultsInstruction.UpdateStrategyAdmin: {
      assertIsInstructionWithAccounts(instruction);
      return {
        instructionType: YvaultsInstruction.UpdateStrategyAdmin,
        ...parseUpdateStrategyAdminInstruction(instruction),
      };
    }
    default:
      throw new Error(
        `Unrecognized instruction type: ${instructionType as string}`,
      );
  }
}