@kamino-finance/klend-sdk 7.3.3 → 7.3.5-beta.0

package/dist/errors.js

@@ -0,0 +1,2520 @@
+import { __export } from './chunk-PR4QN5HX.js';
+
+// src/@codegen/klend/errors/anchor.ts
+var anchor_exports = {};
+__export(anchor_exports, {
+  AccountDidNotDeserialize: () => AccountDidNotDeserialize,
+  AccountDidNotSerialize: () => AccountDidNotSerialize,
+  AccountDiscriminatorAlreadySet: () => AccountDiscriminatorAlreadySet,
+  AccountDiscriminatorMismatch: () => AccountDiscriminatorMismatch,
+  AccountDiscriminatorNotFound: () => AccountDiscriminatorNotFound,
+  AccountDuplicateReallocs: () => AccountDuplicateReallocs,
+  AccountNotAssociatedTokenAccount: () => AccountNotAssociatedTokenAccount,
+  AccountNotEnoughKeys: () => AccountNotEnoughKeys,
+  AccountNotInitialized: () => AccountNotInitialized,
+  AccountNotMutable: () => AccountNotMutable,
+  AccountNotProgramData: () => AccountNotProgramData,
+  AccountNotSigner: () => AccountNotSigner,
+  AccountNotSystemOwned: () => AccountNotSystemOwned,
+  AccountOwnedByWrongProgram: () => AccountOwnedByWrongProgram,
+  AccountReallocExceedsLimit: () => AccountReallocExceedsLimit,
+  AccountSysvarMismatch: () => AccountSysvarMismatch,
+  ConstraintAccountIsNone: () => ConstraintAccountIsNone,
+  ConstraintAddress: () => ConstraintAddress,
+  ConstraintAssociated: () => ConstraintAssociated,
+  ConstraintAssociatedInit: () => ConstraintAssociatedInit,
+  ConstraintClose: () => ConstraintClose,
+  ConstraintExecutable: () => ConstraintExecutable,
+  ConstraintHasOne: () => ConstraintHasOne,
+  ConstraintMintDecimals: () => ConstraintMintDecimals,
+  ConstraintMintFreezeAuthority: () => ConstraintMintFreezeAuthority,
+  ConstraintMintMintAuthority: () => ConstraintMintMintAuthority,
+  ConstraintMut: () => ConstraintMut,
+  ConstraintOwner: () => ConstraintOwner,
+  ConstraintRaw: () => ConstraintRaw,
+  ConstraintRentExempt: () => ConstraintRentExempt,
+  ConstraintSeeds: () => ConstraintSeeds,
+  ConstraintSigner: () => ConstraintSigner,
+  ConstraintSpace: () => ConstraintSpace,
+  ConstraintState: () => ConstraintState,
+  ConstraintTokenMint: () => ConstraintTokenMint,
+  ConstraintTokenOwner: () => ConstraintTokenOwner,
+  ConstraintZero: () => ConstraintZero,
+  DeclaredProgramIdMismatch: () => DeclaredProgramIdMismatch,
+  Deprecated: () => Deprecated,
+  IdlInstructionInvalidProgram: () => IdlInstructionInvalidProgram,
+  IdlInstructionStub: () => IdlInstructionStub,
+  InstructionDidNotDeserialize: () => InstructionDidNotDeserialize,
+  InstructionDidNotSerialize: () => InstructionDidNotSerialize,
+  InstructionFallbackNotFound: () => InstructionFallbackNotFound,
+  InstructionMissing: () => InstructionMissing,
+  InvalidProgramExecutable: () => InvalidProgramExecutable,
+  InvalidProgramId: () => InvalidProgramId,
+  RequireEqViolated: () => RequireEqViolated,
+  RequireGtViolated: () => RequireGtViolated,
+  RequireGteViolated: () => RequireGteViolated,
+  RequireKeysEqViolated: () => RequireKeysEqViolated,
+  RequireKeysNeqViolated: () => RequireKeysNeqViolated,
+  RequireNeqViolated: () => RequireNeqViolated,
+  RequireViolated: () => RequireViolated,
+  fromCode: () => fromCode
+});
+var InstructionMissing = class extends Error {
+  constructor(logs) {
+    super("100: 8 byte instruction identifier not provided");
+    this.logs = logs;
+  }
+  static code = 100;
+  code = 100;
+  name = "InstructionMissing";
+  msg = "8 byte instruction identifier not provided";
+};
+var InstructionFallbackNotFound = class extends Error {
+  constructor(logs) {
+    super("101: Fallback functions are not supported");
+    this.logs = logs;
+  }
+  static code = 101;
+  code = 101;
+  name = "InstructionFallbackNotFound";
+  msg = "Fallback functions are not supported";
+};
+var InstructionDidNotDeserialize = class extends Error {
+  constructor(logs) {
+    super("102: The program could not deserialize the given instruction");
+    this.logs = logs;
+  }
+  static code = 102;
+  code = 102;
+  name = "InstructionDidNotDeserialize";
+  msg = "The program could not deserialize the given instruction";
+};
+var InstructionDidNotSerialize = class extends Error {
+  constructor(logs) {
+    super("103: The program could not serialize the given instruction");
+    this.logs = logs;
+  }
+  static code = 103;
+  code = 103;
+  name = "InstructionDidNotSerialize";
+  msg = "The program could not serialize the given instruction";
+};
+var IdlInstructionStub = class extends Error {
+  constructor(logs) {
+    super("1000: The program was compiled without idl instructions");
+    this.logs = logs;
+  }
+  static code = 1e3;
+  code = 1e3;
+  name = "IdlInstructionStub";
+  msg = "The program was compiled without idl instructions";
+};
+var IdlInstructionInvalidProgram = class extends Error {
+  constructor(logs) {
+    super(
+      "1001: The transaction was given an invalid program for the IDL instruction"
+    );
+    this.logs = logs;
+  }
+  static code = 1001;
+  code = 1001;
+  name = "IdlInstructionInvalidProgram";
+  msg = "The transaction was given an invalid program for the IDL instruction";
+};
+var ConstraintMut = class extends Error {
+  constructor(logs) {
+    super("2000: A mut constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2e3;
+  code = 2e3;
+  name = "ConstraintMut";
+  msg = "A mut constraint was violated";
+};
+var ConstraintHasOne = class extends Error {
+  constructor(logs) {
+    super("2001: A has one constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2001;
+  code = 2001;
+  name = "ConstraintHasOne";
+  msg = "A has one constraint was violated";
+};
+var ConstraintSigner = class extends Error {
+  constructor(logs) {
+    super("2002: A signer constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2002;
+  code = 2002;
+  name = "ConstraintSigner";
+  msg = "A signer constraint was violated";
+};
+var ConstraintRaw = class extends Error {
+  constructor(logs) {
+    super("2003: A raw constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2003;
+  code = 2003;
+  name = "ConstraintRaw";
+  msg = "A raw constraint was violated";
+};
+var ConstraintOwner = class extends Error {
+  constructor(logs) {
+    super("2004: An owner constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2004;
+  code = 2004;
+  name = "ConstraintOwner";
+  msg = "An owner constraint was violated";
+};
+var ConstraintRentExempt = class extends Error {
+  constructor(logs) {
+    super("2005: A rent exemption constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2005;
+  code = 2005;
+  name = "ConstraintRentExempt";
+  msg = "A rent exemption constraint was violated";
+};
+var ConstraintSeeds = class extends Error {
+  constructor(logs) {
+    super("2006: A seeds constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2006;
+  code = 2006;
+  name = "ConstraintSeeds";
+  msg = "A seeds constraint was violated";
+};
+var ConstraintExecutable = class extends Error {
+  constructor(logs) {
+    super("2007: An executable constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2007;
+  code = 2007;
+  name = "ConstraintExecutable";
+  msg = "An executable constraint was violated";
+};
+var ConstraintState = class extends Error {
+  constructor(logs) {
+    super("2008: Deprecated Error, feel free to replace with something else");
+    this.logs = logs;
+  }
+  static code = 2008;
+  code = 2008;
+  name = "ConstraintState";
+  msg = "Deprecated Error, feel free to replace with something else";
+};
+var ConstraintAssociated = class extends Error {
+  constructor(logs) {
+    super("2009: An associated constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2009;
+  code = 2009;
+  name = "ConstraintAssociated";
+  msg = "An associated constraint was violated";
+};
+var ConstraintAssociatedInit = class extends Error {
+  constructor(logs) {
+    super("2010: An associated init constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2010;
+  code = 2010;
+  name = "ConstraintAssociatedInit";
+  msg = "An associated init constraint was violated";
+};
+var ConstraintClose = class extends Error {
+  constructor(logs) {
+    super("2011: A close constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2011;
+  code = 2011;
+  name = "ConstraintClose";
+  msg = "A close constraint was violated";
+};
+var ConstraintAddress = class extends Error {
+  constructor(logs) {
+    super("2012: An address constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2012;
+  code = 2012;
+  name = "ConstraintAddress";
+  msg = "An address constraint was violated";
+};
+var ConstraintZero = class extends Error {
+  constructor(logs) {
+    super("2013: Expected zero account discriminant");
+    this.logs = logs;
+  }
+  static code = 2013;
+  code = 2013;
+  name = "ConstraintZero";
+  msg = "Expected zero account discriminant";
+};
+var ConstraintTokenMint = class extends Error {
+  constructor(logs) {
+    super("2014: A token mint constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2014;
+  code = 2014;
+  name = "ConstraintTokenMint";
+  msg = "A token mint constraint was violated";
+};
+var ConstraintTokenOwner = class extends Error {
+  constructor(logs) {
+    super("2015: A token owner constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2015;
+  code = 2015;
+  name = "ConstraintTokenOwner";
+  msg = "A token owner constraint was violated";
+};
+var ConstraintMintMintAuthority = class extends Error {
+  constructor(logs) {
+    super("2016: A mint mint authority constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2016;
+  code = 2016;
+  name = "ConstraintMintMintAuthority";
+  msg = "A mint mint authority constraint was violated";
+};
+var ConstraintMintFreezeAuthority = class extends Error {
+  constructor(logs) {
+    super("2017: A mint freeze authority constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2017;
+  code = 2017;
+  name = "ConstraintMintFreezeAuthority";
+  msg = "A mint freeze authority constraint was violated";
+};
+var ConstraintMintDecimals = class extends Error {
+  constructor(logs) {
+    super("2018: A mint decimals constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2018;
+  code = 2018;
+  name = "ConstraintMintDecimals";
+  msg = "A mint decimals constraint was violated";
+};
+var ConstraintSpace = class extends Error {
+  constructor(logs) {
+    super("2019: A space constraint was violated");
+    this.logs = logs;
+  }
+  static code = 2019;
+  code = 2019;
+  name = "ConstraintSpace";
+  msg = "A space constraint was violated";
+};
+var ConstraintAccountIsNone = class extends Error {
+  constructor(logs) {
+    super("2020: A required account for the constraint is None");
+    this.logs = logs;
+  }
+  static code = 2020;
+  code = 2020;
+  name = "ConstraintAccountIsNone";
+  msg = "A required account for the constraint is None";
+};
+var RequireViolated = class extends Error {
+  constructor(logs) {
+    super("2500: A require expression was violated");
+    this.logs = logs;
+  }
+  static code = 2500;
+  code = 2500;
+  name = "RequireViolated";
+  msg = "A require expression was violated";
+};
+var RequireEqViolated = class extends Error {
+  constructor(logs) {
+    super("2501: A require_eq expression was violated");
+    this.logs = logs;
+  }
+  static code = 2501;
+  code = 2501;
+  name = "RequireEqViolated";
+  msg = "A require_eq expression was violated";
+};
+var RequireKeysEqViolated = class extends Error {
+  constructor(logs) {
+    super("2502: A require_keys_eq expression was violated");
+    this.logs = logs;
+  }
+  static code = 2502;
+  code = 2502;
+  name = "RequireKeysEqViolated";
+  msg = "A require_keys_eq expression was violated";
+};
+var RequireNeqViolated = class extends Error {
+  constructor(logs) {
+    super("2503: A require_neq expression was violated");
+    this.logs = logs;
+  }
+  static code = 2503;
+  code = 2503;
+  name = "RequireNeqViolated";
+  msg = "A require_neq expression was violated";
+};
+var RequireKeysNeqViolated = class extends Error {
+  constructor(logs) {
+    super("2504: A require_keys_neq expression was violated");
+    this.logs = logs;
+  }
+  static code = 2504;
+  code = 2504;
+  name = "RequireKeysNeqViolated";
+  msg = "A require_keys_neq expression was violated";
+};
+var RequireGtViolated = class extends Error {
+  constructor(logs) {
+    super("2505: A require_gt expression was violated");
+    this.logs = logs;
+  }
+  static code = 2505;
+  code = 2505;
+  name = "RequireGtViolated";
+  msg = "A require_gt expression was violated";
+};
+var RequireGteViolated = class extends Error {
+  constructor(logs) {
+    super("2506: A require_gte expression was violated");
+    this.logs = logs;
+  }
+  static code = 2506;
+  code = 2506;
+  name = "RequireGteViolated";
+  msg = "A require_gte expression was violated";
+};
+var AccountDiscriminatorAlreadySet = class extends Error {
+  constructor(logs) {
+    super("3000: The account discriminator was already set on this account");
+    this.logs = logs;
+  }
+  static code = 3e3;
+  code = 3e3;
+  name = "AccountDiscriminatorAlreadySet";
+  msg = "The account discriminator was already set on this account";
+};
+var AccountDiscriminatorNotFound = class extends Error {
+  constructor(logs) {
+    super("3001: No 8 byte discriminator was found on the account");
+    this.logs = logs;
+  }
+  static code = 3001;
+  code = 3001;
+  name = "AccountDiscriminatorNotFound";
+  msg = "No 8 byte discriminator was found on the account";
+};
+var AccountDiscriminatorMismatch = class extends Error {
+  constructor(logs) {
+    super("3002: 8 byte discriminator did not match what was expected");
+    this.logs = logs;
+  }
+  static code = 3002;
+  code = 3002;
+  name = "AccountDiscriminatorMismatch";
+  msg = "8 byte discriminator did not match what was expected";
+};
+var AccountDidNotDeserialize = class extends Error {
+  constructor(logs) {
+    super("3003: Failed to deserialize the account");
+    this.logs = logs;
+  }
+  static code = 3003;
+  code = 3003;
+  name = "AccountDidNotDeserialize";
+  msg = "Failed to deserialize the account";
+};
+var AccountDidNotSerialize = class extends Error {
+  constructor(logs) {
+    super("3004: Failed to serialize the account");
+    this.logs = logs;
+  }
+  static code = 3004;
+  code = 3004;
+  name = "AccountDidNotSerialize";
+  msg = "Failed to serialize the account";
+};
+var AccountNotEnoughKeys = class extends Error {
+  constructor(logs) {
+    super("3005: Not enough account keys given to the instruction");
+    this.logs = logs;
+  }
+  static code = 3005;
+  code = 3005;
+  name = "AccountNotEnoughKeys";
+  msg = "Not enough account keys given to the instruction";
+};
+var AccountNotMutable = class extends Error {
+  constructor(logs) {
+    super("3006: The given account is not mutable");
+    this.logs = logs;
+  }
+  static code = 3006;
+  code = 3006;
+  name = "AccountNotMutable";
+  msg = "The given account is not mutable";
+};
+var AccountOwnedByWrongProgram = class extends Error {
+  constructor(logs) {
+    super(
+      "3007: The given account is owned by a different program than expected"
+    );
+    this.logs = logs;
+  }
+  static code = 3007;
+  code = 3007;
+  name = "AccountOwnedByWrongProgram";
+  msg = "The given account is owned by a different program than expected";
+};
+var InvalidProgramId = class extends Error {
+  constructor(logs) {
+    super("3008: Program ID was not as expected");
+    this.logs = logs;
+  }
+  static code = 3008;
+  code = 3008;
+  name = "InvalidProgramId";
+  msg = "Program ID was not as expected";
+};
+var InvalidProgramExecutable = class extends Error {
+  constructor(logs) {
+    super("3009: Program account is not executable");
+    this.logs = logs;
+  }
+  static code = 3009;
+  code = 3009;
+  name = "InvalidProgramExecutable";
+  msg = "Program account is not executable";
+};
+var AccountNotSigner = class extends Error {
+  constructor(logs) {
+    super("3010: The given account did not sign");
+    this.logs = logs;
+  }
+  static code = 3010;
+  code = 3010;
+  name = "AccountNotSigner";
+  msg = "The given account did not sign";
+};
+var AccountNotSystemOwned = class extends Error {
+  constructor(logs) {
+    super("3011: The given account is not owned by the system program");
+    this.logs = logs;
+  }
+  static code = 3011;
+  code = 3011;
+  name = "AccountNotSystemOwned";
+  msg = "The given account is not owned by the system program";
+};
+var AccountNotInitialized = class extends Error {
+  constructor(logs) {
+    super("3012: The program expected this account to be already initialized");
+    this.logs = logs;
+  }
+  static code = 3012;
+  code = 3012;
+  name = "AccountNotInitialized";
+  msg = "The program expected this account to be already initialized";
+};
+var AccountNotProgramData = class extends Error {
+  constructor(logs) {
+    super("3013: The given account is not a program data account");
+    this.logs = logs;
+  }
+  static code = 3013;
+  code = 3013;
+  name = "AccountNotProgramData";
+  msg = "The given account is not a program data account";
+};
+var AccountNotAssociatedTokenAccount = class extends Error {
+  constructor(logs) {
+    super("3014: The given account is not the associated token account");
+    this.logs = logs;
+  }
+  static code = 3014;
+  code = 3014;
+  name = "AccountNotAssociatedTokenAccount";
+  msg = "The given account is not the associated token account";
+};
+var AccountSysvarMismatch = class extends Error {
+  constructor(logs) {
+    super("3015: The given public key does not match the required sysvar");
+    this.logs = logs;
+  }
+  static code = 3015;
+  code = 3015;
+  name = "AccountSysvarMismatch";
+  msg = "The given public key does not match the required sysvar";
+};
+var AccountReallocExceedsLimit = class extends Error {
+  constructor(logs) {
+    super(
+      "3016: The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit"
+    );
+    this.logs = logs;
+  }
+  static code = 3016;
+  code = 3016;
+  name = "AccountReallocExceedsLimit";
+  msg = "The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit";
+};
+var AccountDuplicateReallocs = class extends Error {
+  constructor(logs) {
+    super("3017: The account was duplicated for more than one reallocation");
+    this.logs = logs;
+  }
+  static code = 3017;
+  code = 3017;
+  name = "AccountDuplicateReallocs";
+  msg = "The account was duplicated for more than one reallocation";
+};
+var DeclaredProgramIdMismatch = class extends Error {
+  constructor(logs) {
+    super("4100: The declared program id does not match the actual program id");
+    this.logs = logs;
+  }
+  static code = 4100;
+  code = 4100;
+  name = "DeclaredProgramIdMismatch";
+  msg = "The declared program id does not match the actual program id";
+};
+var Deprecated = class extends Error {
+  constructor(logs) {
+    super("5000: The API being used is deprecated and should no longer be used");
+    this.logs = logs;
+  }
+  static code = 5e3;
+  code = 5e3;
+  name = "Deprecated";
+  msg = "The API being used is deprecated and should no longer be used";
+};
+function fromCode(code, logs) {
+  switch (code) {
+    case 100:
+      return new InstructionMissing(logs);
+    case 101:
+      return new InstructionFallbackNotFound(logs);
+    case 102:
+      return new InstructionDidNotDeserialize(logs);
+    case 103:
+      return new InstructionDidNotSerialize(logs);
+    case 1e3:
+      return new IdlInstructionStub(logs);
+    case 1001:
+      return new IdlInstructionInvalidProgram(logs);
+    case 2e3:
+      return new ConstraintMut(logs);
+    case 2001:
+      return new ConstraintHasOne(logs);
+    case 2002:
+      return new ConstraintSigner(logs);
+    case 2003:
+      return new ConstraintRaw(logs);
+    case 2004:
+      return new ConstraintOwner(logs);
+    case 2005:
+      return new ConstraintRentExempt(logs);
+    case 2006:
+      return new ConstraintSeeds(logs);
+    case 2007:
+      return new ConstraintExecutable(logs);
+    case 2008:
+      return new ConstraintState(logs);
+    case 2009:
+      return new ConstraintAssociated(logs);
+    case 2010:
+      return new ConstraintAssociatedInit(logs);
+    case 2011:
+      return new ConstraintClose(logs);
+    case 2012:
+      return new ConstraintAddress(logs);
+    case 2013:
+      return new ConstraintZero(logs);
+    case 2014:
+      return new ConstraintTokenMint(logs);
+    case 2015:
+      return new ConstraintTokenOwner(logs);
+    case 2016:
+      return new ConstraintMintMintAuthority(logs);
+    case 2017:
+      return new ConstraintMintFreezeAuthority(logs);
+    case 2018:
+      return new ConstraintMintDecimals(logs);
+    case 2019:
+      return new ConstraintSpace(logs);
+    case 2020:
+      return new ConstraintAccountIsNone(logs);
+    case 2500:
+      return new RequireViolated(logs);
+    case 2501:
+      return new RequireEqViolated(logs);
+    case 2502:
+      return new RequireKeysEqViolated(logs);
+    case 2503:
+      return new RequireNeqViolated(logs);
+    case 2504:
+      return new RequireKeysNeqViolated(logs);
+    case 2505:
+      return new RequireGtViolated(logs);
+    case 2506:
+      return new RequireGteViolated(logs);
+    case 3e3:
+      return new AccountDiscriminatorAlreadySet(logs);
+    case 3001:
+      return new AccountDiscriminatorNotFound(logs);
+    case 3002:
+      return new AccountDiscriminatorMismatch(logs);
+    case 3003:
+      return new AccountDidNotDeserialize(logs);
+    case 3004:
+      return new AccountDidNotSerialize(logs);
+    case 3005:
+      return new AccountNotEnoughKeys(logs);
+    case 3006:
+      return new AccountNotMutable(logs);
+    case 3007:
+      return new AccountOwnedByWrongProgram(logs);
+    case 3008:
+      return new InvalidProgramId(logs);
+    case 3009:
+      return new InvalidProgramExecutable(logs);
+    case 3010:
+      return new AccountNotSigner(logs);
+    case 3011:
+      return new AccountNotSystemOwned(logs);
+    case 3012:
+      return new AccountNotInitialized(logs);
+    case 3013:
+      return new AccountNotProgramData(logs);
+    case 3014:
+      return new AccountNotAssociatedTokenAccount(logs);
+    case 3015:
+      return new AccountSysvarMismatch(logs);
+    case 3016:
+      return new AccountReallocExceedsLimit(logs);
+    case 3017:
+      return new AccountDuplicateReallocs(logs);
+    case 4100:
+      return new DeclaredProgramIdMismatch(logs);
+    case 5e3:
+      return new Deprecated(logs);
+  }
+  return null;
+}
+
+// src/@codegen/klend/errors/custom.ts
+var custom_exports = {};
+__export(custom_exports, {
+  BorrowLimitExceeded: () => BorrowLimitExceeded,
+  BorrowTooLarge: () => BorrowTooLarge,
+  BorrowTooSmall: () => BorrowTooSmall,
+  BorrowingAboveUtilizationRateDisabled: () => BorrowingAboveUtilizationRateDisabled,
+  BorrowingDisabled: () => BorrowingDisabled,
+  BorrowingDisabledOutsideElevationGroup: () => BorrowingDisabledOutsideElevationGroup,
+  CTokenUsageBlocked: () => CTokenUsageBlocked,
+  CannotCalculateReferralAmountDueToSlotsMismatch: () => CannotCalculateReferralAmountDueToSlotsMismatch,
+  CannotSocializeObligationWithCollateral: () => CannotSocializeObligationWithCollateral,
+  CollateralNonLiquidatable: () => CollateralNonLiquidatable,
+  CouldNotDeserializeScope: () => CouldNotDeserializeScope,
+  CpiDisabled: () => CpiDisabled,
+  DepositDisabledOutsideElevationGroup: () => DepositDisabledOutsideElevationGroup,
+  DepositLimitExceeded: () => DepositLimitExceeded,
+  DeprecatedInvalidObligationId: () => DeprecatedInvalidObligationId,
+  ElevationGroupAlreadyActivated: () => ElevationGroupAlreadyActivated,
+  ElevationGroupBorrowLimitExceeded: () => ElevationGroupBorrowLimitExceeded,
+  ElevationGroupDebtReserveAsCollateral: () => ElevationGroupDebtReserveAsCollateral,
+  ElevationGroupHasAnotherDebtReserve: () => ElevationGroupHasAnotherDebtReserve,
+  ElevationGroupMaxCollateralReserveZero: () => ElevationGroupMaxCollateralReserveZero,
+  ElevationGroupNewLoansDisabled: () => ElevationGroupNewLoansDisabled,
+  ElevationGroupWithoutDebtReserve: () => ElevationGroupWithoutDebtReserve,
+  FarmAccountsMissing: () => FarmAccountsMissing,
+  FlashBorrowCpi: () => FlashBorrowCpi,
+  FlashLoansDisabled: () => FlashLoansDisabled,
+  FlashRepayCpi: () => FlashRepayCpi,
+  GlobalEmergencyMode: () => GlobalEmergencyMode,
+  InconsistentElevationGroup: () => InconsistentElevationGroup,
+  IncorrectInstructionInPosition: () => IncorrectInstructionInPosition,
+  InitialAdminDepositExecuted: () => InitialAdminDepositExecuted,
+  InsufficientLiquidity: () => InsufficientLiquidity,
+  InsufficientProtocolFeesToRedeem: () => InsufficientProtocolFeesToRedeem,
+  InsufficientReferralFeesToRedeem: () => InsufficientReferralFeesToRedeem,
+  InsufficientRepayAmount: () => InsufficientRepayAmount,
+  IntegerOverflow: () => IntegerOverflow,
+  InvalidAccountInput: () => InvalidAccountInput,
+  InvalidAccountOwner: () => InvalidAccountOwner,
+  InvalidAmount: () => InvalidAmount,
+  InvalidBorrowRateCurvePoint: () => InvalidBorrowRateCurvePoint,
+  InvalidConfig: () => InvalidConfig,
+  InvalidElevationGroup: () => InvalidElevationGroup,
+  InvalidElevationGroupConfig: () => InvalidElevationGroupConfig,
+  InvalidFlag: () => InvalidFlag,
+  InvalidFlashRepay: () => InvalidFlashRepay,
+  InvalidMarketAuthority: () => InvalidMarketAuthority,
+  InvalidMarketOwner: () => InvalidMarketOwner,
+  InvalidObligationCollateral: () => InvalidObligationCollateral,
+  InvalidObligationLiquidity: () => InvalidObligationLiquidity,
+  InvalidObligationOwner: () => InvalidObligationOwner,
+  InvalidObligationSeedsValue: () => InvalidObligationSeedsValue,
+  InvalidOracleConfig: () => InvalidOracleConfig,
+  InvalidOrderConfiguration: () => InvalidOrderConfiguration,
+  InvalidPythPriceAccount: () => InvalidPythPriceAccount,
+  InvalidScopePriceAccount: () => InvalidScopePriceAccount,
+  InvalidSigner: () => InvalidSigner,
+  InvalidSwitchboardAccount: () => InvalidSwitchboardAccount,
+  InvalidTokenAccount: () => InvalidTokenAccount,
+  InvalidTwapConfig: () => InvalidTwapConfig,
+  InvalidTwapPrice: () => InvalidTwapPrice,
+  InvalidUtilizationRate: () => InvalidUtilizationRate,
+  IsolatedAssetTierViolation: () => IsolatedAssetTierViolation,
+  LastTimestampGreaterThanCurrent: () => LastTimestampGreaterThanCurrent,
+  LendingMarketsMustMatch: () => LendingMarketsMustMatch,
+  LiabilitiesBiggerThanAssets: () => LiabilitiesBiggerThanAssets,
+  LiquidationBorrowFactorPriority: () => LiquidationBorrowFactorPriority,
+  LiquidationLowestLiquidationLtvPriority: () => LiquidationLowestLiquidationLtvPriority,
+  LiquidationRewardTooSmall: () => LiquidationRewardTooSmall,
+  LiquidationTooSmall: () => LiquidationTooSmall,
+  LowestLtvAssetsPriority: () => LowestLtvAssetsPriority,
+  MathOverflow: () => MathOverflow,
+  MaximumWithdrawValueZero: () => MaximumWithdrawValueZero,
+  MultipleFlashBorrows: () => MultipleFlashBorrows,
+  NegativeInterestRate: () => NegativeInterestRate,
+  NetValueRemainingTooSmall: () => NetValueRemainingTooSmall,
+  NoFarmForReserve: () => NoFarmForReserve,
+  NoFlashRepayFound: () => NoFlashRepayFound,
+  NoPriceFound: () => NoPriceFound,
+  NoUpgradeAuthority: () => NoUpgradeAuthority,
+  ObligationBorrowsEmpty: () => ObligationBorrowsEmpty,
+  ObligationBorrowsZero: () => ObligationBorrowsZero,
+  ObligationCollateralEmpty: () => ObligationCollateralEmpty,
+  ObligationCollateralExceedsElevationGroupLimit: () => ObligationCollateralExceedsElevationGroupLimit,
+  ObligationCollateralLtvZero: () => ObligationCollateralLtvZero,
+  ObligationCurrentlyMarkedForDeleveraging: () => ObligationCurrentlyMarkedForDeleveraging,
+  ObligationDepositsEmpty: () => ObligationDepositsEmpty,
+  ObligationDepositsZero: () => ObligationDepositsZero,
+  ObligationElevationGroupMultipleDebtReserve: () => ObligationElevationGroupMultipleDebtReserve,
+  ObligationEmpty: () => ObligationEmpty,
+  ObligationHealthy: () => ObligationHealthy,
+  ObligationInObsoleteReserve: () => ObligationInObsoleteReserve,
+  ObligationLiquidityEmpty: () => ObligationLiquidityEmpty,
+  ObligationOwnersMustMatch: () => ObligationOwnersMustMatch,
+  ObligationReserveLimit: () => ObligationReserveLimit,
+  ObligationStale: () => ObligationStale,
+  ObligationsMustMatch: () => ObligationsMustMatch,
+  OperationNotPermittedMarketImmutable: () => OperationNotPermittedMarketImmutable,
+  OperationNotPermittedWithCurrentObligationOrders: () => OperationNotPermittedWithCurrentObligationOrders,
+  OrderConfigurationNotSupportedByObligation: () => OrderConfigurationNotSupportedByObligation,
+  OrderCreationDisabled: () => OrderCreationDisabled,
+  OrderIndexOutOfBounds: () => OrderIndexOutOfBounds,
+  PriceConfidenceTooWide: () => PriceConfidenceTooWide,
+  PriceIsBiggerThanHeuristic: () => PriceIsBiggerThanHeuristic,
+  PriceIsLowerThanHeuristic: () => PriceIsLowerThanHeuristic,
+  PriceIsZero: () => PriceIsZero,
+  PriceNotValid: () => PriceNotValid,
+  PriceTooDivergentFromTwap: () => PriceTooDivergentFromTwap,
+  PriceTooOld: () => PriceTooOld,
+  ReferrerAccountMintMissmatch: () => ReferrerAccountMintMissmatch,
+  ReferrerAccountMissing: () => ReferrerAccountMissing,
+  ReferrerAccountNotInitialized: () => ReferrerAccountNotInitialized,
+  ReferrerAccountReferrerMissmatch: () => ReferrerAccountReferrerMissmatch,
+  ReferrerAccountWrongAddress: () => ReferrerAccountWrongAddress,
+  ReferrerStateOwnerMismatch: () => ReferrerStateOwnerMismatch,
+  RepayTooSmall: () => RepayTooSmall,
+  RepayTooSmallForFullLiquidation: () => RepayTooSmallForFullLiquidation,
+  ReserveAccountingMismatch: () => ReserveAccountingMismatch,
+  ReserveDeprecated: () => ReserveDeprecated,
+  ReserveHasNotReceivedInitialDeposit: () => ReserveHasNotReceivedInitialDeposit,
+  ReserveObsolete: () => ReserveObsolete,
+  ReserveStale: () => ReserveStale,
+  ReserveTokenBalanceMismatch: () => ReserveTokenBalanceMismatch,
+  ReserveVaultBalanceMismatch: () => ReserveVaultBalanceMismatch,
+  ShortUrlNotAsciiAlphanumeric: () => ShortUrlNotAsciiAlphanumeric,
+  SwitchboardV2Error: () => SwitchboardV2Error,
+  UnhealthyElevationGroupLtv: () => UnhealthyElevationGroupLtv,
+  UnsupportedTokenExtension: () => UnsupportedTokenExtension,
+  UserMetadataOwnerAlreadySet: () => UserMetadataOwnerAlreadySet,
+  WithdrawTooLarge: () => WithdrawTooLarge,
+  WithdrawTooSmall: () => WithdrawTooSmall,
+  WithdrawalCapReached: () => WithdrawalCapReached,
+  WorseLtvBlocked: () => WorseLtvBlocked,
+  WorseLtvThanUnhealthyLtv: () => WorseLtvThanUnhealthyLtv,
+  ZeroMaxLtvAssetsInDeposits: () => ZeroMaxLtvAssetsInDeposits,
+  fromCode: () => fromCode2
+});
+var InvalidMarketAuthority = class extends Error {
+  constructor(logs) {
+    super("6000: Market authority is invalid");
+    this.logs = logs;
+  }
+  static code = 6e3;
+  code = 6e3;
+  name = "InvalidMarketAuthority";
+  msg = "Market authority is invalid";
+};
+var InvalidMarketOwner = class extends Error {
+  constructor(logs) {
+    super("6001: Market owner is invalid");
+    this.logs = logs;
+  }
+  static code = 6001;
+  code = 6001;
+  name = "InvalidMarketOwner";
+  msg = "Market owner is invalid";
+};
+var InvalidAccountOwner = class extends Error {
+  constructor(logs) {
+    super("6002: Input account owner is not the program address");
+    this.logs = logs;
+  }
+  static code = 6002;
+  code = 6002;
+  name = "InvalidAccountOwner";
+  msg = "Input account owner is not the program address";
+};
+var InvalidAmount = class extends Error {
+  constructor(logs) {
+    super("6003: Input amount is invalid");
+    this.logs = logs;
+  }
+  static code = 6003;
+  code = 6003;
+  name = "InvalidAmount";
+  msg = "Input amount is invalid";
+};
+var InvalidConfig = class extends Error {
+  constructor(logs) {
+    super("6004: Input config value is invalid");
+    this.logs = logs;
+  }
+  static code = 6004;
+  code = 6004;
+  name = "InvalidConfig";
+  msg = "Input config value is invalid";
+};
+var InvalidSigner = class extends Error {
+  constructor(logs) {
+    super("6005: Signer is not allowed to perform this action");
+    this.logs = logs;
+  }
+  static code = 6005;
+  code = 6005;
+  name = "InvalidSigner";
+  msg = "Signer is not allowed to perform this action";
+};
+var InvalidAccountInput = class extends Error {
+  constructor(logs) {
+    super("6006: Invalid account input");
+    this.logs = logs;
+  }
+  static code = 6006;
+  code = 6006;
+  name = "InvalidAccountInput";
+  msg = "Invalid account input";
+};
+var MathOverflow = class extends Error {
+  constructor(logs) {
+    super("6007: Math operation overflow");
+    this.logs = logs;
+  }
+  static code = 6007;
+  code = 6007;
+  name = "MathOverflow";
+  msg = "Math operation overflow";
+};
+var InsufficientLiquidity = class extends Error {
+  constructor(logs) {
+    super("6008: Insufficient liquidity available");
+    this.logs = logs;
+  }
+  static code = 6008;
+  code = 6008;
+  name = "InsufficientLiquidity";
+  msg = "Insufficient liquidity available";
+};
+var ReserveStale = class extends Error {
+  constructor(logs) {
+    super("6009: Reserve state needs to be refreshed");
+    this.logs = logs;
+  }
+  static code = 6009;
+  code = 6009;
+  name = "ReserveStale";
+  msg = "Reserve state needs to be refreshed";
+};
+var WithdrawTooSmall = class extends Error {
+  constructor(logs) {
+    super("6010: Withdraw amount too small");
+    this.logs = logs;
+  }
+  static code = 6010;
+  code = 6010;
+  name = "WithdrawTooSmall";
+  msg = "Withdraw amount too small";
+};
+var WithdrawTooLarge = class extends Error {
+  constructor(logs) {
+    super("6011: Withdraw amount too large");
+    this.logs = logs;
+  }
+  static code = 6011;
+  code = 6011;
+  name = "WithdrawTooLarge";
+  msg = "Withdraw amount too large";
+};
+var BorrowTooSmall = class extends Error {
+  constructor(logs) {
+    super("6012: Borrow amount too small to receive liquidity after fees");
+    this.logs = logs;
+  }
+  static code = 6012;
+  code = 6012;
+  name = "BorrowTooSmall";
+  msg = "Borrow amount too small to receive liquidity after fees";
+};
+var BorrowTooLarge = class extends Error {
+  constructor(logs) {
+    super("6013: Borrow amount too large for deposited collateral");
+    this.logs = logs;
+  }
+  static code = 6013;
+  code = 6013;
+  name = "BorrowTooLarge";
+  msg = "Borrow amount too large for deposited collateral";
+};
+var RepayTooSmall = class extends Error {
+  constructor(logs) {
+    super("6014: Repay amount too small to transfer liquidity");
+    this.logs = logs;
+  }
+  static code = 6014;
+  code = 6014;
+  name = "RepayTooSmall";
+  msg = "Repay amount too small to transfer liquidity";
+};
+var LiquidationTooSmall = class extends Error {
+  constructor(logs) {
+    super("6015: Liquidation amount too small to receive collateral");
+    this.logs = logs;
+  }
+  static code = 6015;
+  code = 6015;
+  name = "LiquidationTooSmall";
+  msg = "Liquidation amount too small to receive collateral";
+};
+var ObligationHealthy = class extends Error {
+  constructor(logs) {
+    super("6016: Cannot liquidate healthy obligations");
+    this.logs = logs;
+  }
+  static code = 6016;
+  code = 6016;
+  name = "ObligationHealthy";
+  msg = "Cannot liquidate healthy obligations";
+};
+var ObligationStale = class extends Error {
+  constructor(logs) {
+    super("6017: Obligation state needs to be refreshed");
+    this.logs = logs;
+  }
+  static code = 6017;
+  code = 6017;
+  name = "ObligationStale";
+  msg = "Obligation state needs to be refreshed";
+};
+var ObligationReserveLimit = class extends Error {
+  constructor(logs) {
+    super("6018: Obligation reserve limit exceeded");
+    this.logs = logs;
+  }
+  static code = 6018;
+  code = 6018;
+  name = "ObligationReserveLimit";
+  msg = "Obligation reserve limit exceeded";
+};
+var InvalidObligationOwner = class extends Error {
+  constructor(logs) {
+    super("6019: Obligation owner is invalid");
+    this.logs = logs;
+  }
+  static code = 6019;
+  code = 6019;
+  name = "InvalidObligationOwner";
+  msg = "Obligation owner is invalid";
+};
+var ObligationDepositsEmpty = class extends Error {
+  constructor(logs) {
+    super("6020: Obligation deposits are empty");
+    this.logs = logs;
+  }
+  static code = 6020;
+  code = 6020;
+  name = "ObligationDepositsEmpty";
+  msg = "Obligation deposits are empty";
+};
+var ObligationBorrowsEmpty = class extends Error {
+  constructor(logs) {
+    super("6021: Obligation borrows are empty");
+    this.logs = logs;
+  }
+  static code = 6021;
+  code = 6021;
+  name = "ObligationBorrowsEmpty";
+  msg = "Obligation borrows are empty";
+};
+var ObligationDepositsZero = class extends Error {
+  constructor(logs) {
+    super("6022: Obligation deposits have zero value");
+    this.logs = logs;
+  }
+  static code = 6022;
+  code = 6022;
+  name = "ObligationDepositsZero";
+  msg = "Obligation deposits have zero value";
+};
+var ObligationBorrowsZero = class extends Error {
+  constructor(logs) {
+    super("6023: Obligation borrows have zero value");
+    this.logs = logs;
+  }
+  static code = 6023;
+  code = 6023;
+  name = "ObligationBorrowsZero";
+  msg = "Obligation borrows have zero value";
+};
+var InvalidObligationCollateral = class extends Error {
+  constructor(logs) {
+    super("6024: Invalid obligation collateral");
+    this.logs = logs;
+  }
+  static code = 6024;
+  code = 6024;
+  name = "InvalidObligationCollateral";
+  msg = "Invalid obligation collateral";
+};
+var InvalidObligationLiquidity = class extends Error {
+  constructor(logs) {
+    super("6025: Invalid obligation liquidity");
+    this.logs = logs;
+  }
+  static code = 6025;
+  code = 6025;
+  name = "InvalidObligationLiquidity";
+  msg = "Invalid obligation liquidity";
+};
+var ObligationCollateralEmpty = class extends Error {
+  constructor(logs) {
+    super("6026: Obligation collateral is empty");
+    this.logs = logs;
+  }
+  static code = 6026;
+  code = 6026;
+  name = "ObligationCollateralEmpty";
+  msg = "Obligation collateral is empty";
+};
+var ObligationLiquidityEmpty = class extends Error {
+  constructor(logs) {
+    super("6027: Obligation liquidity is empty");
+    this.logs = logs;
+  }
+  static code = 6027;
+  code = 6027;
+  name = "ObligationLiquidityEmpty";
+  msg = "Obligation liquidity is empty";
+};
+var NegativeInterestRate = class extends Error {
+  constructor(logs) {
+    super("6028: Interest rate is negative");
+    this.logs = logs;
+  }
+  static code = 6028;
+  code = 6028;
+  name = "NegativeInterestRate";
+  msg = "Interest rate is negative";
+};
+var InvalidOracleConfig = class extends Error {
+  constructor(logs) {
+    super("6029: Input oracle config is invalid");
+    this.logs = logs;
+  }
+  static code = 6029;
+  code = 6029;
+  name = "InvalidOracleConfig";
+  msg = "Input oracle config is invalid";
+};
+var InsufficientProtocolFeesToRedeem = class extends Error {
+  constructor(logs) {
+    super("6030: Insufficient protocol fees to claim or no liquidity available");
+    this.logs = logs;
+  }
+  static code = 6030;
+  code = 6030;
+  name = "InsufficientProtocolFeesToRedeem";
+  msg = "Insufficient protocol fees to claim or no liquidity available";
+};
+var FlashBorrowCpi = class extends Error {
+  constructor(logs) {
+    super("6031: No cpi flash borrows allowed");
+    this.logs = logs;
+  }
+  static code = 6031;
+  code = 6031;
+  name = "FlashBorrowCpi";
+  msg = "No cpi flash borrows allowed";
+};
+var NoFlashRepayFound = class extends Error {
+  constructor(logs) {
+    super("6032: No corresponding repay found for flash borrow");
+    this.logs = logs;
+  }
+  static code = 6032;
+  code = 6032;
+  name = "NoFlashRepayFound";
+  msg = "No corresponding repay found for flash borrow";
+};
+var InvalidFlashRepay = class extends Error {
+  constructor(logs) {
+    super("6033: Invalid repay found");
+    this.logs = logs;
+  }
+  static code = 6033;
+  code = 6033;
+  name = "InvalidFlashRepay";
+  msg = "Invalid repay found";
+};
+var FlashRepayCpi = class extends Error {
+  constructor(logs) {
+    super("6034: No cpi flash repays allowed");
+    this.logs = logs;
+  }
+  static code = 6034;
+  code = 6034;
+  name = "FlashRepayCpi";
+  msg = "No cpi flash repays allowed";
+};
+var MultipleFlashBorrows = class extends Error {
+  constructor(logs) {
+    super("6035: Multiple flash borrows not allowed in the same transaction");
+    this.logs = logs;
+  }
+  static code = 6035;
+  code = 6035;
+  name = "MultipleFlashBorrows";
+  msg = "Multiple flash borrows not allowed in the same transaction";
+};
+var FlashLoansDisabled = class extends Error {
+  constructor(logs) {
+    super("6036: Flash loans are disabled for this reserve");
+    this.logs = logs;
+  }
+  static code = 6036;
+  code = 6036;
+  name = "FlashLoansDisabled";
+  msg = "Flash loans are disabled for this reserve";
+};
+var SwitchboardV2Error = class extends Error {
+  constructor(logs) {
+    super("6037: Switchboard error");
+    this.logs = logs;
+  }
+  static code = 6037;
+  code = 6037;
+  name = "SwitchboardV2Error";
+  msg = "Switchboard error";
+};
+var CouldNotDeserializeScope = class extends Error {
+  constructor(logs) {
+    super("6038: Cannot deserialize the scope price account");
+    this.logs = logs;
+  }
+  static code = 6038;
+  code = 6038;
+  name = "CouldNotDeserializeScope";
+  msg = "Cannot deserialize the scope price account";
+};
+var PriceTooOld = class extends Error {
+  constructor(logs) {
+    super("6039: Price too old");
+    this.logs = logs;
+  }
+  static code = 6039;
+  code = 6039;
+  name = "PriceTooOld";
+  msg = "Price too old";
+};
+var PriceTooDivergentFromTwap = class extends Error {
+  constructor(logs) {
+    super("6040: Price too divergent from twap");
+    this.logs = logs;
+  }
+  static code = 6040;
+  code = 6040;
+  name = "PriceTooDivergentFromTwap";
+  msg = "Price too divergent from twap";
+};
+var InvalidTwapPrice = class extends Error {
+  constructor(logs) {
+    super("6041: Invalid twap price");
+    this.logs = logs;
+  }
+  static code = 6041;
+  code = 6041;
+  name = "InvalidTwapPrice";
+  msg = "Invalid twap price";
+};
+var GlobalEmergencyMode = class extends Error {
+  constructor(logs) {
+    super("6042: Emergency mode is enabled");
+    this.logs = logs;
+  }
+  static code = 6042;
+  code = 6042;
+  name = "GlobalEmergencyMode";
+  msg = "Emergency mode is enabled";
+};
+var InvalidFlag = class extends Error {
+  constructor(logs) {
+    super("6043: Invalid lending market config");
+    this.logs = logs;
+  }
+  static code = 6043;
+  code = 6043;
+  name = "InvalidFlag";
+  msg = "Invalid lending market config";
+};
+var PriceNotValid = class extends Error {
+  constructor(logs) {
+    super("6044: Price is not valid");
+    this.logs = logs;
+  }
+  static code = 6044;
+  code = 6044;
+  name = "PriceNotValid";
+  msg = "Price is not valid";
+};
+var PriceIsBiggerThanHeuristic = class extends Error {
+  constructor(logs) {
+    super("6045: Price is bigger than allowed by heuristic");
+    this.logs = logs;
+  }
+  static code = 6045;
+  code = 6045;
+  name = "PriceIsBiggerThanHeuristic";
+  msg = "Price is bigger than allowed by heuristic";
+};
+var PriceIsLowerThanHeuristic = class extends Error {
+  constructor(logs) {
+    super("6046: Price lower than allowed by heuristic");
+    this.logs = logs;
+  }
+  static code = 6046;
+  code = 6046;
+  name = "PriceIsLowerThanHeuristic";
+  msg = "Price lower than allowed by heuristic";
+};
+var PriceIsZero = class extends Error {
+  constructor(logs) {
+    super("6047: Price is zero");
+    this.logs = logs;
+  }
+  static code = 6047;
+  code = 6047;
+  name = "PriceIsZero";
+  msg = "Price is zero";
+};
+var PriceConfidenceTooWide = class extends Error {
+  constructor(logs) {
+    super("6048: Price confidence too wide");
+    this.logs = logs;
+  }
+  static code = 6048;
+  code = 6048;
+  name = "PriceConfidenceTooWide";
+  msg = "Price confidence too wide";
+};
+var IntegerOverflow = class extends Error {
+  constructor(logs) {
+    super("6049: Conversion between integers failed");
+    this.logs = logs;
+  }
+  static code = 6049;
+  code = 6049;
+  name = "IntegerOverflow";
+  msg = "Conversion between integers failed";
+};
+var NoFarmForReserve = class extends Error {
+  constructor(logs) {
+    super("6050: This reserve does not have a farm");
+    this.logs = logs;
+  }
+  static code = 6050;
+  code = 6050;
+  name = "NoFarmForReserve";
+  msg = "This reserve does not have a farm";
+};
+var IncorrectInstructionInPosition = class extends Error {
+  constructor(logs) {
+    super("6051: Wrong instruction at expected position");
+    this.logs = logs;
+  }
+  static code = 6051;
+  code = 6051;
+  name = "IncorrectInstructionInPosition";
+  msg = "Wrong instruction at expected position";
+};
+var NoPriceFound = class extends Error {
+  constructor(logs) {
+    super("6052: No price found");
+    this.logs = logs;
+  }
+  static code = 6052;
+  code = 6052;
+  name = "NoPriceFound";
+  msg = "No price found";
+};
+var InvalidTwapConfig = class extends Error {
+  constructor(logs) {
+    super(
+      "6053: Invalid Twap configuration: Twap is enabled but one of the enabled price doesn't have a twap"
+    );
+    this.logs = logs;
+  }
+  static code = 6053;
+  code = 6053;
+  name = "InvalidTwapConfig";
+  msg = "Invalid Twap configuration: Twap is enabled but one of the enabled price doesn't have a twap";
+};
+var InvalidPythPriceAccount = class extends Error {
+  constructor(logs) {
+    super("6054: Pyth price account does not match configuration");
+    this.logs = logs;
+  }
+  static code = 6054;
+  code = 6054;
+  name = "InvalidPythPriceAccount";
+  msg = "Pyth price account does not match configuration";
+};
+var InvalidSwitchboardAccount = class extends Error {
+  constructor(logs) {
+    super("6055: Switchboard account(s) do not match configuration");
+    this.logs = logs;
+  }
+  static code = 6055;
+  code = 6055;
+  name = "InvalidSwitchboardAccount";
+  msg = "Switchboard account(s) do not match configuration";
+};
+var InvalidScopePriceAccount = class extends Error {
+  constructor(logs) {
+    super("6056: Scope price account does not match configuration");
+    this.logs = logs;
+  }
+  static code = 6056;
+  code = 6056;
+  name = "InvalidScopePriceAccount";
+  msg = "Scope price account does not match configuration";
+};
+var ObligationCollateralLtvZero = class extends Error {
+  constructor(logs) {
+    super(
+      "6057: The obligation has one collateral with an LTV set to 0. Withdraw it before withdrawing other collaterals"
+    );
+    this.logs = logs;
+  }
+  static code = 6057;
+  code = 6057;
+  name = "ObligationCollateralLtvZero";
+  msg = "The obligation has one collateral with an LTV set to 0. Withdraw it before withdrawing other collaterals";
+};
+var InvalidObligationSeedsValue = class extends Error {
+  constructor(logs) {
+    super(
+      "6058: Seeds must be default pubkeys for tag 0, and mint addresses for tag 1 or 2"
+    );
+    this.logs = logs;
+  }
+  static code = 6058;
+  code = 6058;
+  name = "InvalidObligationSeedsValue";
+  msg = "Seeds must be default pubkeys for tag 0, and mint addresses for tag 1 or 2";
+};
+var DeprecatedInvalidObligationId = class extends Error {
+  constructor(logs) {
+    super("6059: [DEPRECATED] Obligation id must be 0");
+    this.logs = logs;
+  }
+  static code = 6059;
+  code = 6059;
+  name = "DeprecatedInvalidObligationId";
+  msg = "[DEPRECATED] Obligation id must be 0";
+};
+var InvalidBorrowRateCurvePoint = class extends Error {
+  constructor(logs) {
+    super("6060: Invalid borrow rate curve point");
+    this.logs = logs;
+  }
+  static code = 6060;
+  code = 6060;
+  name = "InvalidBorrowRateCurvePoint";
+  msg = "Invalid borrow rate curve point";
+};
+var InvalidUtilizationRate = class extends Error {
+  constructor(logs) {
+    super("6061: Invalid utilization rate");
+    this.logs = logs;
+  }
+  static code = 6061;
+  code = 6061;
+  name = "InvalidUtilizationRate";
+  msg = "Invalid utilization rate";
+};
+var CannotSocializeObligationWithCollateral = class extends Error {
+  constructor(logs) {
+    super(
+      "6062: Obligation hasn't been fully liquidated and debt cannot be socialized."
+    );
+    this.logs = logs;
+  }
+  static code = 6062;
+  code = 6062;
+  name = "CannotSocializeObligationWithCollateral";
+  msg = "Obligation hasn't been fully liquidated and debt cannot be socialized.";
+};
+var ObligationEmpty = class extends Error {
+  constructor(logs) {
+    super("6063: Obligation has no borrows or deposits.");
+    this.logs = logs;
+  }
+  static code = 6063;
+  code = 6063;
+  name = "ObligationEmpty";
+  msg = "Obligation has no borrows or deposits.";
+};
+var WithdrawalCapReached = class extends Error {
+  constructor(logs) {
+    super("6064: Withdrawal cap is reached");
+    this.logs = logs;
+  }
+  static code = 6064;
+  code = 6064;
+  name = "WithdrawalCapReached";
+  msg = "Withdrawal cap is reached";
+};
+var LastTimestampGreaterThanCurrent = class extends Error {
+  constructor(logs) {
+    super(
+      "6065: The last interval start timestamp is greater than the current timestamp"
+    );
+    this.logs = logs;
+  }
+  static code = 6065;
+  code = 6065;
+  name = "LastTimestampGreaterThanCurrent";
+  msg = "The last interval start timestamp is greater than the current timestamp";
+};
+var LiquidationRewardTooSmall = class extends Error {
+  constructor(logs) {
+    super(
+      "6066: The reward amount is less than the minimum acceptable received liquidity"
+    );
+    this.logs = logs;
+  }
+  static code = 6066;
+  code = 6066;
+  name = "LiquidationRewardTooSmall";
+  msg = "The reward amount is less than the minimum acceptable received liquidity";
+};
+var IsolatedAssetTierViolation = class extends Error {
+  constructor(logs) {
+    super("6067: Isolated Asset Tier Violation");
+    this.logs = logs;
+  }
+  static code = 6067;
+  code = 6067;
+  name = "IsolatedAssetTierViolation";
+  msg = "Isolated Asset Tier Violation";
+};
+var InconsistentElevationGroup = class extends Error {
+  constructor(logs) {
+    super(
+      "6068: The obligation's elevation group and the reserve's are not the same"
+    );
+    this.logs = logs;
+  }
+  static code = 6068;
+  code = 6068;
+  name = "InconsistentElevationGroup";
+  msg = "The obligation's elevation group and the reserve's are not the same";
+};
+var InvalidElevationGroup = class extends Error {
+  constructor(logs) {
+    super(
+      "6069: The elevation group chosen for the reserve does not exist in the lending market"
+    );
+    this.logs = logs;
+  }
+  static code = 6069;
+  code = 6069;
+  name = "InvalidElevationGroup";
+  msg = "The elevation group chosen for the reserve does not exist in the lending market";
+};
+var InvalidElevationGroupConfig = class extends Error {
+  constructor(logs) {
+    super("6070: The elevation group updated has wrong parameters set");
+    this.logs = logs;
+  }
+  static code = 6070;
+  code = 6070;
+  name = "InvalidElevationGroupConfig";
+  msg = "The elevation group updated has wrong parameters set";
+};
+var UnhealthyElevationGroupLtv = class extends Error {
+  constructor(logs) {
+    super(
+      "6071: The current obligation must have most or all its debt repaid before changing the elevation group"
+    );
+    this.logs = logs;
+  }
+  static code = 6071;
+  code = 6071;
+  name = "UnhealthyElevationGroupLtv";
+  msg = "The current obligation must have most or all its debt repaid before changing the elevation group";
+};
+var ElevationGroupNewLoansDisabled = class extends Error {
+  constructor(logs) {
+    super(
+      "6072: Elevation group does not accept any new loans or any new borrows/withdrawals"
+    );
+    this.logs = logs;
+  }
+  static code = 6072;
+  code = 6072;
+  name = "ElevationGroupNewLoansDisabled";
+  msg = "Elevation group does not accept any new loans or any new borrows/withdrawals";
+};
+var ReserveDeprecated = class extends Error {
+  constructor(logs) {
+    super("6073: Reserve was deprecated, no longer usable");
+    this.logs = logs;
+  }
+  static code = 6073;
+  code = 6073;
+  name = "ReserveDeprecated";
+  msg = "Reserve was deprecated, no longer usable";
+};
+var ReferrerAccountNotInitialized = class extends Error {
+  constructor(logs) {
+    super("6074: Referrer account not initialized");
+    this.logs = logs;
+  }
+  static code = 6074;
+  code = 6074;
+  name = "ReferrerAccountNotInitialized";
+  msg = "Referrer account not initialized";
+};
+var ReferrerAccountMintMissmatch = class extends Error {
+  constructor(logs) {
+    super(
+      "6075: Referrer account mint does not match the operation reserve mint"
+    );
+    this.logs = logs;
+  }
+  static code = 6075;
+  code = 6075;
+  name = "ReferrerAccountMintMissmatch";
+  msg = "Referrer account mint does not match the operation reserve mint";
+};
+var ReferrerAccountWrongAddress = class extends Error {
+  constructor(logs) {
+    super("6076: Referrer account address is not a valid program address");
+    this.logs = logs;
+  }
+  static code = 6076;
+  code = 6076;
+  name = "ReferrerAccountWrongAddress";
+  msg = "Referrer account address is not a valid program address";
+};
+var ReferrerAccountReferrerMissmatch = class extends Error {
+  constructor(logs) {
+    super("6077: Referrer account referrer does not match the owner referrer");
+    this.logs = logs;
+  }
+  static code = 6077;
+  code = 6077;
+  name = "ReferrerAccountReferrerMissmatch";
+  msg = "Referrer account referrer does not match the owner referrer";
+};
+var ReferrerAccountMissing = class extends Error {
+  constructor(logs) {
+    super("6078: Referrer account missing for obligation with referrer");
+    this.logs = logs;
+  }
+  static code = 6078;
+  code = 6078;
+  name = "ReferrerAccountMissing";
+  msg = "Referrer account missing for obligation with referrer";
+};
+var InsufficientReferralFeesToRedeem = class extends Error {
+  constructor(logs) {
+    super("6079: Insufficient referral fees to claim or no liquidity available");
+    this.logs = logs;
+  }
+  static code = 6079;
+  code = 6079;
+  name = "InsufficientReferralFeesToRedeem";
+  msg = "Insufficient referral fees to claim or no liquidity available";
+};
+var CpiDisabled = class extends Error {
+  constructor(logs) {
+    super("6080: CPI disabled for this instruction");
+    this.logs = logs;
+  }
+  static code = 6080;
+  code = 6080;
+  name = "CpiDisabled";
+  msg = "CPI disabled for this instruction";
+};
+var ShortUrlNotAsciiAlphanumeric = class extends Error {
+  constructor(logs) {
+    super("6081: Referrer short_url is not ascii alphanumeric");
+    this.logs = logs;
+  }
+  static code = 6081;
+  code = 6081;
+  name = "ShortUrlNotAsciiAlphanumeric";
+  msg = "Referrer short_url is not ascii alphanumeric";
+};
+var ReserveObsolete = class extends Error {
+  constructor(logs) {
+    super("6082: Reserve is marked as obsolete");
+    this.logs = logs;
+  }
+  static code = 6082;
+  code = 6082;
+  name = "ReserveObsolete";
+  msg = "Reserve is marked as obsolete";
+};
+var ElevationGroupAlreadyActivated = class extends Error {
+  constructor(logs) {
+    super("6083: Obligation already part of the same elevation group");
+    this.logs = logs;
+  }
+  static code = 6083;
+  code = 6083;
+  name = "ElevationGroupAlreadyActivated";
+  msg = "Obligation already part of the same elevation group";
+};
+var ObligationInObsoleteReserve = class extends Error {
+  constructor(logs) {
+    super("6084: Obligation has a deposit or borrow in an obsolete reserve");
+    this.logs = logs;
+  }
+  static code = 6084;
+  code = 6084;
+  name = "ObligationInObsoleteReserve";
+  msg = "Obligation has a deposit or borrow in an obsolete reserve";
+};
+var ReferrerStateOwnerMismatch = class extends Error {
+  constructor(logs) {
+    super("6085: Referrer state owner does not match the given signer");
+    this.logs = logs;
+  }
+  static code = 6085;
+  code = 6085;
+  name = "ReferrerStateOwnerMismatch";
+  msg = "Referrer state owner does not match the given signer";
+};
+var UserMetadataOwnerAlreadySet = class extends Error {
+  constructor(logs) {
+    super("6086: User metadata owner is already set");
+    this.logs = logs;
+  }
+  static code = 6086;
+  code = 6086;
+  name = "UserMetadataOwnerAlreadySet";
+  msg = "User metadata owner is already set";
+};
+var CollateralNonLiquidatable = class extends Error {
+  constructor(logs) {
+    super("6087: This collateral cannot be liquidated (LTV set to 0)");
+    this.logs = logs;
+  }
+  static code = 6087;
+  code = 6087;
+  name = "CollateralNonLiquidatable";
+  msg = "This collateral cannot be liquidated (LTV set to 0)";
+};
+var BorrowingDisabled = class extends Error {
+  constructor(logs) {
+    super("6088: Borrowing is disabled");
+    this.logs = logs;
+  }
+  static code = 6088;
+  code = 6088;
+  name = "BorrowingDisabled";
+  msg = "Borrowing is disabled";
+};
+var BorrowLimitExceeded = class extends Error {
+  constructor(logs) {
+    super("6089: Cannot borrow above borrow limit");
+    this.logs = logs;
+  }
+  static code = 6089;
+  code = 6089;
+  name = "BorrowLimitExceeded";
+  msg = "Cannot borrow above borrow limit";
+};
+var DepositLimitExceeded = class extends Error {
+  constructor(logs) {
+    super("6090: Cannot deposit above deposit limit");
+    this.logs = logs;
+  }
+  static code = 6090;
+  code = 6090;
+  name = "DepositLimitExceeded";
+  msg = "Cannot deposit above deposit limit";
+};
+var BorrowingDisabledOutsideElevationGroup = class extends Error {
+  constructor(logs) {
+    super(
+      "6091: Reserve does not accept any new borrows outside elevation group"
+    );
+    this.logs = logs;
+  }
+  static code = 6091;
+  code = 6091;
+  name = "BorrowingDisabledOutsideElevationGroup";
+  msg = "Reserve does not accept any new borrows outside elevation group";
+};
+var NetValueRemainingTooSmall = class extends Error {
+  constructor(logs) {
+    super("6092: Net value remaining too small");
+    this.logs = logs;
+  }
+  static code = 6092;
+  code = 6092;
+  name = "NetValueRemainingTooSmall";
+  msg = "Net value remaining too small";
+};
+var WorseLtvBlocked = class extends Error {
+  constructor(logs) {
+    super("6093: Cannot get the obligation in a worse position");
+    this.logs = logs;
+  }
+  static code = 6093;
+  code = 6093;
+  name = "WorseLtvBlocked";
+  msg = "Cannot get the obligation in a worse position";
+};
+var LiabilitiesBiggerThanAssets = class extends Error {
+  constructor(logs) {
+    super("6094: Cannot have more liabilities than assets in a position");
+    this.logs = logs;
+  }
+  static code = 6094;
+  code = 6094;
+  name = "LiabilitiesBiggerThanAssets";
+  msg = "Cannot have more liabilities than assets in a position";
+};
+var ReserveTokenBalanceMismatch = class extends Error {
+  constructor(logs) {
+    super("6095: Reserve state and token account cannot drift");
+    this.logs = logs;
+  }
+  static code = 6095;
+  code = 6095;
+  name = "ReserveTokenBalanceMismatch";
+  msg = "Reserve state and token account cannot drift";
+};
+var ReserveVaultBalanceMismatch = class extends Error {
+  constructor(logs) {
+    super("6096: Reserve token account has been unexpectedly modified");
+    this.logs = logs;
+  }
+  static code = 6096;
+  code = 6096;
+  name = "ReserveVaultBalanceMismatch";
+  msg = "Reserve token account has been unexpectedly modified";
+};
+var ReserveAccountingMismatch = class extends Error {
+  constructor(logs) {
+    super(
+      "6097: Reserve internal state accounting has been unexpectedly modified"
+    );
+    this.logs = logs;
+  }
+  static code = 6097;
+  code = 6097;
+  name = "ReserveAccountingMismatch";
+  msg = "Reserve internal state accounting has been unexpectedly modified";
+};
+var BorrowingAboveUtilizationRateDisabled = class extends Error {
+  constructor(logs) {
+    super("6098: Borrowing above set utilization rate is disabled");
+    this.logs = logs;
+  }
+  static code = 6098;
+  code = 6098;
+  name = "BorrowingAboveUtilizationRateDisabled";
+  msg = "Borrowing above set utilization rate is disabled";
+};
+var LiquidationBorrowFactorPriority = class extends Error {
+  constructor(logs) {
+    super(
+      "6099: Liquidation must prioritize the debt with the highest borrow factor"
+    );
+    this.logs = logs;
+  }
+  static code = 6099;
+  code = 6099;
+  name = "LiquidationBorrowFactorPriority";
+  msg = "Liquidation must prioritize the debt with the highest borrow factor";
+};
+var LiquidationLowestLiquidationLtvPriority = class extends Error {
+  constructor(logs) {
+    super(
+      "6100: Liquidation must prioritize the collateral with the lowest liquidation LTV"
+    );
+    this.logs = logs;
+  }
+  static code = 6100;
+  code = 6100;
+  name = "LiquidationLowestLiquidationLtvPriority";
+  msg = "Liquidation must prioritize the collateral with the lowest liquidation LTV";
+};
+var ElevationGroupBorrowLimitExceeded = class extends Error {
+  constructor(logs) {
+    super("6101: Elevation group borrow limit exceeded");
+    this.logs = logs;
+  }
+  static code = 6101;
+  code = 6101;
+  name = "ElevationGroupBorrowLimitExceeded";
+  msg = "Elevation group borrow limit exceeded";
+};
+var ElevationGroupWithoutDebtReserve = class extends Error {
+  constructor(logs) {
+    super("6102: The elevation group does not have a debt reserve defined");
+    this.logs = logs;
+  }
+  static code = 6102;
+  code = 6102;
+  name = "ElevationGroupWithoutDebtReserve";
+  msg = "The elevation group does not have a debt reserve defined";
+};
+var ElevationGroupMaxCollateralReserveZero = class extends Error {
+  constructor(logs) {
+    super("6103: The elevation group does not allow any collateral reserves");
+    this.logs = logs;
+  }
+  static code = 6103;
+  code = 6103;
+  name = "ElevationGroupMaxCollateralReserveZero";
+  msg = "The elevation group does not allow any collateral reserves";
+};
+var ElevationGroupHasAnotherDebtReserve = class extends Error {
+  constructor(logs) {
+    super(
+      "6104: In elevation group attempt to borrow from a reserve that is not the debt reserve"
+    );
+    this.logs = logs;
+  }
+  static code = 6104;
+  code = 6104;
+  name = "ElevationGroupHasAnotherDebtReserve";
+  msg = "In elevation group attempt to borrow from a reserve that is not the debt reserve";
+};
+var ElevationGroupDebtReserveAsCollateral = class extends Error {
+  constructor(logs) {
+    super(
+      "6105: The elevation group's debt reserve cannot be used as a collateral reserve"
+    );
+    this.logs = logs;
+  }
+  static code = 6105;
+  code = 6105;
+  name = "ElevationGroupDebtReserveAsCollateral";
+  msg = "The elevation group's debt reserve cannot be used as a collateral reserve";
+};
+var ObligationCollateralExceedsElevationGroupLimit = class extends Error {
+  constructor(logs) {
+    super(
+      "6106: Obligation have more collateral than the maximum allowed by the elevation group"
+    );
+    this.logs = logs;
+  }
+  static code = 6106;
+  code = 6106;
+  name = "ObligationCollateralExceedsElevationGroupLimit";
+  msg = "Obligation have more collateral than the maximum allowed by the elevation group";
+};
+var ObligationElevationGroupMultipleDebtReserve = class extends Error {
+  constructor(logs) {
+    super(
+      "6107: Obligation is an elevation group but have more than one debt reserve"
+    );
+    this.logs = logs;
+  }
+  static code = 6107;
+  code = 6107;
+  name = "ObligationElevationGroupMultipleDebtReserve";
+  msg = "Obligation is an elevation group but have more than one debt reserve";
+};
+var UnsupportedTokenExtension = class extends Error {
+  constructor(logs) {
+    super("6108: Mint has a token (2022) extension that is not supported");
+    this.logs = logs;
+  }
+  static code = 6108;
+  code = 6108;
+  name = "UnsupportedTokenExtension";
+  msg = "Mint has a token (2022) extension that is not supported";
+};
+var InvalidTokenAccount = class extends Error {
+  constructor(logs) {
+    super("6109: Can't have an spl token mint with a t22 account");
+    this.logs = logs;
+  }
+  static code = 6109;
+  code = 6109;
+  name = "InvalidTokenAccount";
+  msg = "Can't have an spl token mint with a t22 account";
+};
+var DepositDisabledOutsideElevationGroup = class extends Error {
+  constructor(logs) {
+    super("6110: Can't deposit into this reserve outside elevation group");
+    this.logs = logs;
+  }
+  static code = 6110;
+  code = 6110;
+  name = "DepositDisabledOutsideElevationGroup";
+  msg = "Can't deposit into this reserve outside elevation group";
+};
+var CannotCalculateReferralAmountDueToSlotsMismatch = class extends Error {
+  constructor(logs) {
+    super("6111: Cannot calculate referral amount due to slots mismatch");
+    this.logs = logs;
+  }
+  static code = 6111;
+  code = 6111;
+  name = "CannotCalculateReferralAmountDueToSlotsMismatch";
+  msg = "Cannot calculate referral amount due to slots mismatch";
+};
+var ObligationOwnersMustMatch = class extends Error {
+  constructor(logs) {
+    super("6112: Obligation owners must match");
+    this.logs = logs;
+  }
+  static code = 6112;
+  code = 6112;
+  name = "ObligationOwnersMustMatch";
+  msg = "Obligation owners must match";
+};
+var ObligationsMustMatch = class extends Error {
+  constructor(logs) {
+    super("6113: Obligations must match");
+    this.logs = logs;
+  }
+  static code = 6113;
+  code = 6113;
+  name = "ObligationsMustMatch";
+  msg = "Obligations must match";
+};
+var LendingMarketsMustMatch = class extends Error {
+  constructor(logs) {
+    super("6114: Lending markets must match");
+    this.logs = logs;
+  }
+  static code = 6114;
+  code = 6114;
+  name = "LendingMarketsMustMatch";
+  msg = "Lending markets must match";
+};
+var ObligationCurrentlyMarkedForDeleveraging = class extends Error {
+  constructor(logs) {
+    super("6115: Obligation is already marked for deleveraging");
+    this.logs = logs;
+  }
+  static code = 6115;
+  code = 6115;
+  name = "ObligationCurrentlyMarkedForDeleveraging";
+  msg = "Obligation is already marked for deleveraging";
+};
+var MaximumWithdrawValueZero = class extends Error {
+  constructor(logs) {
+    super(
+      "6116: Maximum withdrawable value of this collateral is zero, LTV needs improved"
+    );
+    this.logs = logs;
+  }
+  static code = 6116;
+  code = 6116;
+  name = "MaximumWithdrawValueZero";
+  msg = "Maximum withdrawable value of this collateral is zero, LTV needs improved";
+};
+var ZeroMaxLtvAssetsInDeposits = class extends Error {
+  constructor(logs) {
+    super(
+      "6117: No max LTV 0 assets allowed in deposits for repay and withdraw"
+    );
+    this.logs = logs;
+  }
+  static code = 6117;
+  code = 6117;
+  name = "ZeroMaxLtvAssetsInDeposits";
+  msg = "No max LTV 0 assets allowed in deposits for repay and withdraw";
+};
+var LowestLtvAssetsPriority = class extends Error {
+  constructor(logs) {
+    super(
+      "6118: Withdrawing must prioritize the collateral with the lowest reserve max-LTV"
+    );
+    this.logs = logs;
+  }
+  static code = 6118;
+  code = 6118;
+  name = "LowestLtvAssetsPriority";
+  msg = "Withdrawing must prioritize the collateral with the lowest reserve max-LTV";
+};
+var WorseLtvThanUnhealthyLtv = class extends Error {
+  constructor(logs) {
+    super("6119: Cannot get the obligation liquidatable");
+    this.logs = logs;
+  }
+  static code = 6119;
+  code = 6119;
+  name = "WorseLtvThanUnhealthyLtv";
+  msg = "Cannot get the obligation liquidatable";
+};
+var FarmAccountsMissing = class extends Error {
+  constructor(logs) {
+    super("6120: Farm accounts to refresh are missing");
+    this.logs = logs;
+  }
+  static code = 6120;
+  code = 6120;
+  name = "FarmAccountsMissing";
+  msg = "Farm accounts to refresh are missing";
+};
+var RepayTooSmallForFullLiquidation = class extends Error {
+  constructor(logs) {
+    super(
+      "6121: Repay amount is too small to satisfy the mandatory full liquidation"
+    );
+    this.logs = logs;
+  }
+  static code = 6121;
+  code = 6121;
+  name = "RepayTooSmallForFullLiquidation";
+  msg = "Repay amount is too small to satisfy the mandatory full liquidation";
+};
+var InsufficientRepayAmount = class extends Error {
+  constructor(logs) {
+    super(
+      "6122: Liquidator provided repay amount lower than required by liquidation rules"
+    );
+    this.logs = logs;
+  }
+  static code = 6122;
+  code = 6122;
+  name = "InsufficientRepayAmount";
+  msg = "Liquidator provided repay amount lower than required by liquidation rules";
+};
+var OrderIndexOutOfBounds = class extends Error {
+  constructor(logs) {
+    super("6123: Obligation order of the given index cannot exist");
+    this.logs = logs;
+  }
+  static code = 6123;
+  code = 6123;
+  name = "OrderIndexOutOfBounds";
+  msg = "Obligation order of the given index cannot exist";
+};
+var InvalidOrderConfiguration = class extends Error {
+  constructor(logs) {
+    super("6124: Given order configuration has wrong parameters");
+    this.logs = logs;
+  }
+  static code = 6124;
+  code = 6124;
+  name = "InvalidOrderConfiguration";
+  msg = "Given order configuration has wrong parameters";
+};
+var OrderConfigurationNotSupportedByObligation = class extends Error {
+  constructor(logs) {
+    super(
+      "6125: Given order configuration cannot be used with the current state of the obligation"
+    );
+    this.logs = logs;
+  }
+  static code = 6125;
+  code = 6125;
+  name = "OrderConfigurationNotSupportedByObligation";
+  msg = "Given order configuration cannot be used with the current state of the obligation";
+};
+var OperationNotPermittedWithCurrentObligationOrders = class extends Error {
+  constructor(logs) {
+    super(
+      "6126: Single debt, single collateral obligation orders have to be cancelled before changing the deposit/borrow count"
+    );
+    this.logs = logs;
+  }
+  static code = 6126;
+  code = 6126;
+  name = "OperationNotPermittedWithCurrentObligationOrders";
+  msg = "Single debt, single collateral obligation orders have to be cancelled before changing the deposit/borrow count";
+};
+var OperationNotPermittedMarketImmutable = class extends Error {
+  constructor(logs) {
+    super("6127: Cannot update lending market because it is set as immutable");
+    this.logs = logs;
+  }
+  static code = 6127;
+  code = 6127;
+  name = "OperationNotPermittedMarketImmutable";
+  msg = "Cannot update lending market because it is set as immutable";
+};
+var OrderCreationDisabled = class extends Error {
+  constructor(logs) {
+    super("6128: Creation of new orders is disabled");
+    this.logs = logs;
+  }
+  static code = 6128;
+  code = 6128;
+  name = "OrderCreationDisabled";
+  msg = "Creation of new orders is disabled";
+};
+var NoUpgradeAuthority = class extends Error {
+  constructor(logs) {
+    super(
+      "6129: Cannot initialize global config because there is no upgrade authority to the program"
+    );
+    this.logs = logs;
+  }
+  static code = 6129;
+  code = 6129;
+  name = "NoUpgradeAuthority";
+  msg = "Cannot initialize global config because there is no upgrade authority to the program";
+};
+var InitialAdminDepositExecuted = class extends Error {
+  constructor(logs) {
+    super("6130: Initial admin deposit in reserve already executed");
+    this.logs = logs;
+  }
+  static code = 6130;
+  code = 6130;
+  name = "InitialAdminDepositExecuted";
+  msg = "Initial admin deposit in reserve already executed";
+};
+var ReserveHasNotReceivedInitialDeposit = class extends Error {
+  constructor(logs) {
+    super(
+      "6131: Reserve has not received the initial deposit, cannot update config"
+    );
+    this.logs = logs;
+  }
+  static code = 6131;
+  code = 6131;
+  name = "ReserveHasNotReceivedInitialDeposit";
+  msg = "Reserve has not received the initial deposit, cannot update config";
+};
+var CTokenUsageBlocked = class extends Error {
+  constructor(logs) {
+    super("6132: CToken minting/redeeming is blocked for this reserve");
+    this.logs = logs;
+  }
+  static code = 6132;
+  code = 6132;
+  name = "CTokenUsageBlocked";
+  msg = "CToken minting/redeeming is blocked for this reserve";
+};
+function fromCode2(code, logs) {
+  switch (code) {
+    case 6e3:
+      return new InvalidMarketAuthority(logs);
+    case 6001:
+      return new InvalidMarketOwner(logs);
+    case 6002:
+      return new InvalidAccountOwner(logs);
+    case 6003:
+      return new InvalidAmount(logs);
+    case 6004:
+      return new InvalidConfig(logs);
+    case 6005:
+      return new InvalidSigner(logs);
+    case 6006:
+      return new InvalidAccountInput(logs);
+    case 6007:
+      return new MathOverflow(logs);
+    case 6008:
+      return new InsufficientLiquidity(logs);
+    case 6009:
+      return new ReserveStale(logs);
+    case 6010:
+      return new WithdrawTooSmall(logs);
+    case 6011:
+      return new WithdrawTooLarge(logs);
+    case 6012:
+      return new BorrowTooSmall(logs);
+    case 6013:
+      return new BorrowTooLarge(logs);
+    case 6014:
+      return new RepayTooSmall(logs);
+    case 6015:
+      return new LiquidationTooSmall(logs);
+    case 6016:
+      return new ObligationHealthy(logs);
+    case 6017:
+      return new ObligationStale(logs);
+    case 6018:
+      return new ObligationReserveLimit(logs);
+    case 6019:
+      return new InvalidObligationOwner(logs);
+    case 6020:
+      return new ObligationDepositsEmpty(logs);
+    case 6021:
+      return new ObligationBorrowsEmpty(logs);
+    case 6022:
+      return new ObligationDepositsZero(logs);
+    case 6023:
+      return new ObligationBorrowsZero(logs);
+    case 6024:
+      return new InvalidObligationCollateral(logs);
+    case 6025:
+      return new InvalidObligationLiquidity(logs);
+    case 6026:
+      return new ObligationCollateralEmpty(logs);
+    case 6027:
+      return new ObligationLiquidityEmpty(logs);
+    case 6028:
+      return new NegativeInterestRate(logs);
+    case 6029:
+      return new InvalidOracleConfig(logs);
+    case 6030:
+      return new InsufficientProtocolFeesToRedeem(logs);
+    case 6031:
+      return new FlashBorrowCpi(logs);
+    case 6032:
+      return new NoFlashRepayFound(logs);
+    case 6033:
+      return new InvalidFlashRepay(logs);
+    case 6034:
+      return new FlashRepayCpi(logs);
+    case 6035:
+      return new MultipleFlashBorrows(logs);
+    case 6036:
+      return new FlashLoansDisabled(logs);
+    case 6037:
+      return new SwitchboardV2Error(logs);
+    case 6038:
+      return new CouldNotDeserializeScope(logs);
+    case 6039:
+      return new PriceTooOld(logs);
+    case 6040:
+      return new PriceTooDivergentFromTwap(logs);
+    case 6041:
+      return new InvalidTwapPrice(logs);
+    case 6042:
+      return new GlobalEmergencyMode(logs);
+    case 6043:
+      return new InvalidFlag(logs);
+    case 6044:
+      return new PriceNotValid(logs);
+    case 6045:
+      return new PriceIsBiggerThanHeuristic(logs);
+    case 6046:
+      return new PriceIsLowerThanHeuristic(logs);
+    case 6047:
+      return new PriceIsZero(logs);
+    case 6048:
+      return new PriceConfidenceTooWide(logs);
+    case 6049:
+      return new IntegerOverflow(logs);
+    case 6050:
+      return new NoFarmForReserve(logs);
+    case 6051:
+      return new IncorrectInstructionInPosition(logs);
+    case 6052:
+      return new NoPriceFound(logs);
+    case 6053:
+      return new InvalidTwapConfig(logs);
+    case 6054:
+      return new InvalidPythPriceAccount(logs);
+    case 6055:
+      return new InvalidSwitchboardAccount(logs);
+    case 6056:
+      return new InvalidScopePriceAccount(logs);
+    case 6057:
+      return new ObligationCollateralLtvZero(logs);
+    case 6058:
+      return new InvalidObligationSeedsValue(logs);
+    case 6059:
+      return new DeprecatedInvalidObligationId(logs);
+    case 6060:
+      return new InvalidBorrowRateCurvePoint(logs);
+    case 6061:
+      return new InvalidUtilizationRate(logs);
+    case 6062:
+      return new CannotSocializeObligationWithCollateral(logs);
+    case 6063:
+      return new ObligationEmpty(logs);
+    case 6064:
+      return new WithdrawalCapReached(logs);
+    case 6065:
+      return new LastTimestampGreaterThanCurrent(logs);
+    case 6066:
+      return new LiquidationRewardTooSmall(logs);
+    case 6067:
+      return new IsolatedAssetTierViolation(logs);
+    case 6068:
+      return new InconsistentElevationGroup(logs);
+    case 6069:
+      return new InvalidElevationGroup(logs);
+    case 6070:
+      return new InvalidElevationGroupConfig(logs);
+    case 6071:
+      return new UnhealthyElevationGroupLtv(logs);
+    case 6072:
+      return new ElevationGroupNewLoansDisabled(logs);
+    case 6073:
+      return new ReserveDeprecated(logs);
+    case 6074:
+      return new ReferrerAccountNotInitialized(logs);
+    case 6075:
+      return new ReferrerAccountMintMissmatch(logs);
+    case 6076:
+      return new ReferrerAccountWrongAddress(logs);
+    case 6077:
+      return new ReferrerAccountReferrerMissmatch(logs);
+    case 6078:
+      return new ReferrerAccountMissing(logs);
+    case 6079:
+      return new InsufficientReferralFeesToRedeem(logs);
+    case 6080:
+      return new CpiDisabled(logs);
+    case 6081:
+      return new ShortUrlNotAsciiAlphanumeric(logs);
+    case 6082:
+      return new ReserveObsolete(logs);
+    case 6083:
+      return new ElevationGroupAlreadyActivated(logs);
+    case 6084:
+      return new ObligationInObsoleteReserve(logs);
+    case 6085:
+      return new ReferrerStateOwnerMismatch(logs);
+    case 6086:
+      return new UserMetadataOwnerAlreadySet(logs);
+    case 6087:
+      return new CollateralNonLiquidatable(logs);
+    case 6088:
+      return new BorrowingDisabled(logs);
+    case 6089:
+      return new BorrowLimitExceeded(logs);
+    case 6090:
+      return new DepositLimitExceeded(logs);
+    case 6091:
+      return new BorrowingDisabledOutsideElevationGroup(logs);
+    case 6092:
+      return new NetValueRemainingTooSmall(logs);
+    case 6093:
+      return new WorseLtvBlocked(logs);
+    case 6094:
+      return new LiabilitiesBiggerThanAssets(logs);
+    case 6095:
+      return new ReserveTokenBalanceMismatch(logs);
+    case 6096:
+      return new ReserveVaultBalanceMismatch(logs);
+    case 6097:
+      return new ReserveAccountingMismatch(logs);
+    case 6098:
+      return new BorrowingAboveUtilizationRateDisabled(logs);
+    case 6099:
+      return new LiquidationBorrowFactorPriority(logs);
+    case 6100:
+      return new LiquidationLowestLiquidationLtvPriority(logs);
+    case 6101:
+      return new ElevationGroupBorrowLimitExceeded(logs);
+    case 6102:
+      return new ElevationGroupWithoutDebtReserve(logs);
+    case 6103:
+      return new ElevationGroupMaxCollateralReserveZero(logs);
+    case 6104:
+      return new ElevationGroupHasAnotherDebtReserve(logs);
+    case 6105:
+      return new ElevationGroupDebtReserveAsCollateral(logs);
+    case 6106:
+      return new ObligationCollateralExceedsElevationGroupLimit(logs);
+    case 6107:
+      return new ObligationElevationGroupMultipleDebtReserve(logs);
+    case 6108:
+      return new UnsupportedTokenExtension(logs);
+    case 6109:
+      return new InvalidTokenAccount(logs);
+    case 6110:
+      return new DepositDisabledOutsideElevationGroup(logs);
+    case 6111:
+      return new CannotCalculateReferralAmountDueToSlotsMismatch(logs);
+    case 6112:
+      return new ObligationOwnersMustMatch(logs);
+    case 6113:
+      return new ObligationsMustMatch(logs);
+    case 6114:
+      return new LendingMarketsMustMatch(logs);
+    case 6115:
+      return new ObligationCurrentlyMarkedForDeleveraging(logs);
+    case 6116:
+      return new MaximumWithdrawValueZero(logs);
+    case 6117:
+      return new ZeroMaxLtvAssetsInDeposits(logs);
+    case 6118:
+      return new LowestLtvAssetsPriority(logs);
+    case 6119:
+      return new WorseLtvThanUnhealthyLtv(logs);
+    case 6120:
+      return new FarmAccountsMissing(logs);
+    case 6121:
+      return new RepayTooSmallForFullLiquidation(logs);
+    case 6122:
+      return new InsufficientRepayAmount(logs);
+    case 6123:
+      return new OrderIndexOutOfBounds(logs);
+    case 6124:
+      return new InvalidOrderConfiguration(logs);
+    case 6125:
+      return new OrderConfigurationNotSupportedByObligation(logs);
+    case 6126:
+      return new OperationNotPermittedWithCurrentObligationOrders(logs);
+    case 6127:
+      return new OperationNotPermittedMarketImmutable(logs);
+    case 6128:
+      return new OrderCreationDisabled(logs);
+    case 6129:
+      return new NoUpgradeAuthority(logs);
+    case 6130:
+      return new InitialAdminDepositExecuted(logs);
+    case 6131:
+      return new ReserveHasNotReceivedInitialDeposit(logs);
+    case 6132:
+      return new CTokenUsageBlocked(logs);
+  }
+  return null;
+}
+
+export { anchor_exports as anchor, custom_exports as custom };
+//# sourceMappingURL=errors.js.map
+//# sourceMappingURL=errors.js.map