@haven-fi/solauto-sdk 1.0.667 → 1.0.668

package/dist/marginfi-sdk/errors/marginfi.js

@@ -7,23 +7,24 @@
  * @see https://github.com/metaplex-foundation/kinobi
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.IllegalAccountAuthorityTransferError = exports.IllegalBalanceStateError = exports.IllegalFlagError = exports.IllegalFlashloanError = exports.AccountInFlashloanError = exports.AccountTempActiveBalanceLimitExceededError = exports.AccountDisabledError = exports.EmissionsUpdateErrorError = exports.CannotCloseOutstandingEmissionsError = exports.InvalidSwitchboardDecimalConversionError = exports.OracleNotSetupError = exports.EmissionsAlreadySetupError = exports.IsolatedAccountIllegalStateError = exports.InvalidPriceError = exports.BankLiabilityCapacityExceededError = exports.IllegalUtilizationRatioError = exports.InvalidOracleSetupError = exports.NoLiabilityFoundError = exports.NoAssetFoundError = exports.OperationRepayOnlyError = exports.OperationBorrowOnlyError = exports.OperationWithdrawOnlyError = exports.OperationDepositOnlyError = exports.BankAccoutNotFoundError = exports.BankReduceOnlyError = exports.BankPausedError = exports.StaleOracleError = exports.InvalidConfigError = exports.BalanceNotBadDebtError = exports.AccountNotBankruptError = exports.IllegalLiquidationError = exports.BankAlreadyExistsError = exports.LendingAccountBalanceSlotsFullError = exports.BadAccountHealthError = exports.InvalidBankAccountError = exports.MissingBankAccountError = exports.InvalidOracleAccountError = exports.MissingPythAccountError = exports.MissingPythOrBankAccountError = exports.InvalidTransferError = exports.BankAssetCapacityExceededError = exports.LendingAccountBalanceNotFoundError = exports.BankNotFoundError = exports.MathErrorError = void 0;
+exports.SwitchboardStalePriceError = exports.StakePoolValidationFailedError = exports.AssetTagMismatchError = exports.AddedStakedPoolManuallyError = exports.InvalidFeeAtaError = exports.T22MintRequiredError = exports.IllegalActionError = exports.UnauthorizedError = exports.IllegalAccountAuthorityTransferError = exports.IllegalBalanceStateError = exports.IllegalFlagError = exports.IllegalFlashloanError = exports.AccountInFlashloanError = exports.AccountTempActiveBalanceLimitExceededError = exports.AccountDisabledError = exports.EmissionsUpdateErrorError = exports.CannotCloseOutstandingEmissionsError = exports.InvalidSwitchboardDecimalConversionError = exports.OracleNotSetupError = exports.EmissionsAlreadySetupError = exports.IsolatedAccountIllegalStateError = exports.InvalidPriceError = exports.BankLiabilityCapacityExceededError = exports.IllegalUtilizationRatioError = exports.InvalidOracleSetupError = exports.NoLiabilityFoundError = exports.NoAssetFoundError = exports.OperationRepayOnlyError = exports.OperationBorrowOnlyError = exports.OperationWithdrawOnlyError = exports.OperationDepositOnlyError = exports.BankAccountNotFoundError = exports.BankReduceOnlyError = exports.BankPausedError = exports.InvalidConfigError = exports.BalanceNotBadDebtError = exports.AccountNotBankruptError = exports.ZeroLiquidationAmountError = exports.BankAlreadyExistsError = exports.LendingAccountBalanceSlotsFullError = exports.RiskEngineInitRejectedError = exports.InvalidBankAccountError = exports.MissingBankAccountError = exports.MissingPythAccountError = exports.MissingPythOrBankAccountError = exports.InvalidTransferError = exports.BankAssetCapacityExceededError = exports.LendingAccountBalanceNotFoundError = exports.BankNotFoundError = exports.InternalLogicErrorError = void 0;
+exports.ArenaSettingCannotChangeError = exports.ArenaBankLimitError = exports.WorseHealthPostLiquidationError = exports.TooSevereLiquidationError = exports.TooSeverePayoffError = exports.ExhaustedLiabilityError = exports.HealthyAccountError = exports.AssetsInLiabilityBankError = exports.NoLiabilitiesInLiabilityBankError = exports.OverliquidationAttemptError = exports.SameAssetAndLiabilityBanksError = exports.InvalidEmissionsDestinationAccountError = exports.MathErrorError = exports.SwitchboardInvalidAccountError = exports.PythPushInvalidAccountError = exports.SwitchboardWrongAccountOwnerError = exports.PythPushFeedIdNonHexCharacterError = exports.PythPushFeedIdMustBe32BytesError = exports.PythPushInsufficientVerificationLevelError = exports.PythPushMismatchedFeedIdError = exports.StakedPythPushWrongAccountOwnerError = exports.PythPushWrongAccountOwnerError = exports.WrongOracleAccountKeysError = exports.WrongNumberOfOracleAccountsError = exports.PythPushStalePriceError = void 0;
 exports.getMarginfiErrorFromCode = getMarginfiErrorFromCode;
 exports.getMarginfiErrorFromName = getMarginfiErrorFromName;
 const umi_1 = require("@metaplex-foundation/umi");
 const codeToErrorMap = new Map();
 const nameToErrorMap = new Map();
-/** MathError: Math error */
-class MathErrorError extends umi_1.ProgramError {
+/** InternalLogicError: Internal Marginfi logic error */
+class InternalLogicErrorError extends umi_1.ProgramError {
     constructor(program, cause) {
-        super('Math error', program, cause);
-        this.name = 'MathError';
+        super('Internal Marginfi logic error', program, cause);
+        this.name = 'InternalLogicError';
         this.code = 0x1770; // 6000
     }
 }
-exports.MathErrorError = MathErrorError;
-codeToErrorMap.set(0x1770, MathErrorError);
-nameToErrorMap.set('MathError', MathErrorError);
+exports.InternalLogicErrorError = InternalLogicErrorError;
+codeToErrorMap.set(0x1770, InternalLogicErrorError);
+nameToErrorMap.set('InternalLogicError', InternalLogicErrorError);
 /** BankNotFound: Invalid bank index */
 class BankNotFoundError extends umi_1.ProgramError {
     constructor(program, cause) {
@@ -68,10 +69,10 @@ class InvalidTransferError extends umi_1.ProgramError {
 exports.InvalidTransferError = InvalidTransferError;
 codeToErrorMap.set(0x1774, InvalidTransferError);
 nameToErrorMap.set('InvalidTransfer', InvalidTransferError);
-/** MissingPythOrBankAccount: Missing Pyth or Bank account */
+/** MissingPythOrBankAccount: Missing Oracle, Bank, LST mint, or Sol Pool */
 class MissingPythOrBankAccountError extends umi_1.ProgramError {
     constructor(program, cause) {
-        super('Missing Pyth or Bank account', program, cause);
+        super('Missing Oracle, Bank, LST mint, or Sol Pool', program, cause);
         this.name = 'MissingPythOrBankAccount';
         this.code = 0x1775; // 6005
     }
@@ -90,413 +91,754 @@ class MissingPythAccountError extends umi_1.ProgramError {
 exports.MissingPythAccountError = MissingPythAccountError;
 codeToErrorMap.set(0x1776, MissingPythAccountError);
 nameToErrorMap.set('MissingPythAccount', MissingPythAccountError);
-/** InvalidOracleAccount: Invalid Pyth account */
-class InvalidOracleAccountError extends umi_1.ProgramError {
-    constructor(program, cause) {
-        super('Invalid Pyth account', program, cause);
-        this.name = 'InvalidOracleAccount';
-        this.code = 0x1777; // 6007
-    }
-}
-exports.InvalidOracleAccountError = InvalidOracleAccountError;
-codeToErrorMap.set(0x1777, InvalidOracleAccountError);
-nameToErrorMap.set('InvalidOracleAccount', InvalidOracleAccountError);
 /** MissingBankAccount: Missing Bank account */
 class MissingBankAccountError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Missing Bank account', program, cause);
         this.name = 'MissingBankAccount';
-        this.code = 0x1778; // 6008
+        this.code = 0x1777; // 6007
     }
 }
 exports.MissingBankAccountError = MissingBankAccountError;
-codeToErrorMap.set(0x1778, MissingBankAccountError);
+codeToErrorMap.set(0x1777, MissingBankAccountError);
 nameToErrorMap.set('MissingBankAccount', MissingBankAccountError);
 /** InvalidBankAccount: Invalid Bank account */
 class InvalidBankAccountError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Invalid Bank account', program, cause);
         this.name = 'InvalidBankAccount';
-        this.code = 0x1779; // 6009
+        this.code = 0x1778; // 6008
     }
 }
 exports.InvalidBankAccountError = InvalidBankAccountError;
-codeToErrorMap.set(0x1779, InvalidBankAccountError);
+codeToErrorMap.set(0x1778, InvalidBankAccountError);
 nameToErrorMap.set('InvalidBankAccount', InvalidBankAccountError);
-/** BadAccountHealth: Bad account health */
-class BadAccountHealthError extends umi_1.ProgramError {
+/** RiskEngineInitRejected: RiskEngine rejected due to either bad health or stale oracles */
+class RiskEngineInitRejectedError extends umi_1.ProgramError {
     constructor(program, cause) {
-        super('Bad account health', program, cause);
-        this.name = 'BadAccountHealth';
-        this.code = 0x177a; // 6010
+        super('RiskEngine rejected due to either bad health or stale oracles', program, cause);
+        this.name = 'RiskEngineInitRejected';
+        this.code = 0x1779; // 6009
     }
 }
-exports.BadAccountHealthError = BadAccountHealthError;
-codeToErrorMap.set(0x177a, BadAccountHealthError);
-nameToErrorMap.set('BadAccountHealth', BadAccountHealthError);
+exports.RiskEngineInitRejectedError = RiskEngineInitRejectedError;
+codeToErrorMap.set(0x1779, RiskEngineInitRejectedError);
+nameToErrorMap.set('RiskEngineInitRejected', RiskEngineInitRejectedError);
 /** LendingAccountBalanceSlotsFull: Lending account balance slots are full */
 class LendingAccountBalanceSlotsFullError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Lending account balance slots are full', program, cause);
         this.name = 'LendingAccountBalanceSlotsFull';
-        this.code = 0x177b; // 6011
+        this.code = 0x177a; // 6010
     }
 }
 exports.LendingAccountBalanceSlotsFullError = LendingAccountBalanceSlotsFullError;
-codeToErrorMap.set(0x177b, LendingAccountBalanceSlotsFullError);
+codeToErrorMap.set(0x177a, LendingAccountBalanceSlotsFullError);
 nameToErrorMap.set('LendingAccountBalanceSlotsFull', LendingAccountBalanceSlotsFullError);
 /** BankAlreadyExists: Bank already exists */
 class BankAlreadyExistsError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Bank already exists', program, cause);
         this.name = 'BankAlreadyExists';
-        this.code = 0x177c; // 6012
+        this.code = 0x177b; // 6011
     }
 }
 exports.BankAlreadyExistsError = BankAlreadyExistsError;
-codeToErrorMap.set(0x177c, BankAlreadyExistsError);
+codeToErrorMap.set(0x177b, BankAlreadyExistsError);
 nameToErrorMap.set('BankAlreadyExists', BankAlreadyExistsError);
-/** IllegalLiquidation: Illegal liquidation */
-class IllegalLiquidationError extends umi_1.ProgramError {
+/** ZeroLiquidationAmount: Amount to liquidate must be positive */
+class ZeroLiquidationAmountError extends umi_1.ProgramError {
     constructor(program, cause) {
-        super('Illegal liquidation', program, cause);
-        this.name = 'IllegalLiquidation';
-        this.code = 0x177d; // 6013
+        super('Amount to liquidate must be positive', program, cause);
+        this.name = 'ZeroLiquidationAmount';
+        this.code = 0x177c; // 6012
     }
 }
-exports.IllegalLiquidationError = IllegalLiquidationError;
-codeToErrorMap.set(0x177d, IllegalLiquidationError);
-nameToErrorMap.set('IllegalLiquidation', IllegalLiquidationError);
+exports.ZeroLiquidationAmountError = ZeroLiquidationAmountError;
+codeToErrorMap.set(0x177c, ZeroLiquidationAmountError);
+nameToErrorMap.set('ZeroLiquidationAmount', ZeroLiquidationAmountError);
 /** AccountNotBankrupt: Account is not bankrupt */
 class AccountNotBankruptError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Account is not bankrupt', program, cause);
         this.name = 'AccountNotBankrupt';
-        this.code = 0x177e; // 6014
+        this.code = 0x177d; // 6013
     }
 }
 exports.AccountNotBankruptError = AccountNotBankruptError;
-codeToErrorMap.set(0x177e, AccountNotBankruptError);
+codeToErrorMap.set(0x177d, AccountNotBankruptError);
 nameToErrorMap.set('AccountNotBankrupt', AccountNotBankruptError);
 /** BalanceNotBadDebt: Account balance is not bad debt */
 class BalanceNotBadDebtError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Account balance is not bad debt', program, cause);
         this.name = 'BalanceNotBadDebt';
-        this.code = 0x177f; // 6015
+        this.code = 0x177e; // 6014
     }
 }
 exports.BalanceNotBadDebtError = BalanceNotBadDebtError;
-codeToErrorMap.set(0x177f, BalanceNotBadDebtError);
+codeToErrorMap.set(0x177e, BalanceNotBadDebtError);
 nameToErrorMap.set('BalanceNotBadDebt', BalanceNotBadDebtError);
 /** InvalidConfig: Invalid group config */
 class InvalidConfigError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Invalid group config', program, cause);
         this.name = 'InvalidConfig';
-        this.code = 0x1780; // 6016
+        this.code = 0x177f; // 6015
     }
 }
 exports.InvalidConfigError = InvalidConfigError;
-codeToErrorMap.set(0x1780, InvalidConfigError);
+codeToErrorMap.set(0x177f, InvalidConfigError);
 nameToErrorMap.set('InvalidConfig', InvalidConfigError);
-/** StaleOracle: Stale oracle data */
-class StaleOracleError extends umi_1.ProgramError {
-    constructor(program, cause) {
-        super('Stale oracle data', program, cause);
-        this.name = 'StaleOracle';
-        this.code = 0x1781; // 6017
-    }
-}
-exports.StaleOracleError = StaleOracleError;
-codeToErrorMap.set(0x1781, StaleOracleError);
-nameToErrorMap.set('StaleOracle', StaleOracleError);
 /** BankPaused: Bank paused */
 class BankPausedError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Bank paused', program, cause);
         this.name = 'BankPaused';
-        this.code = 0x1782; // 6018
+        this.code = 0x1780; // 6016
     }
 }
 exports.BankPausedError = BankPausedError;
-codeToErrorMap.set(0x1782, BankPausedError);
+codeToErrorMap.set(0x1780, BankPausedError);
 nameToErrorMap.set('BankPaused', BankPausedError);
 /** BankReduceOnly: Bank is ReduceOnly mode */
 class BankReduceOnlyError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Bank is ReduceOnly mode', program, cause);
         this.name = 'BankReduceOnly';
-        this.code = 0x1783; // 6019
+        this.code = 0x1781; // 6017
     }
 }
 exports.BankReduceOnlyError = BankReduceOnlyError;
-codeToErrorMap.set(0x1783, BankReduceOnlyError);
+codeToErrorMap.set(0x1781, BankReduceOnlyError);
 nameToErrorMap.set('BankReduceOnly', BankReduceOnlyError);
-/** BankAccoutNotFound: Bank is missing */
-class BankAccoutNotFoundError extends umi_1.ProgramError {
+/** BankAccountNotFound: Bank is missing */
+class BankAccountNotFoundError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Bank is missing', program, cause);
-        this.name = 'BankAccoutNotFound';
-        this.code = 0x1784; // 6020
+        this.name = 'BankAccountNotFound';
+        this.code = 0x1782; // 6018
     }
 }
-exports.BankAccoutNotFoundError = BankAccoutNotFoundError;
-codeToErrorMap.set(0x1784, BankAccoutNotFoundError);
-nameToErrorMap.set('BankAccoutNotFound', BankAccoutNotFoundError);
+exports.BankAccountNotFoundError = BankAccountNotFoundError;
+codeToErrorMap.set(0x1782, BankAccountNotFoundError);
+nameToErrorMap.set('BankAccountNotFound', BankAccountNotFoundError);
 /** OperationDepositOnly: Operation is deposit-only */
 class OperationDepositOnlyError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Operation is deposit-only', program, cause);
         this.name = 'OperationDepositOnly';
-        this.code = 0x1785; // 6021
+        this.code = 0x1783; // 6019
     }
 }
 exports.OperationDepositOnlyError = OperationDepositOnlyError;
-codeToErrorMap.set(0x1785, OperationDepositOnlyError);
+codeToErrorMap.set(0x1783, OperationDepositOnlyError);
 nameToErrorMap.set('OperationDepositOnly', OperationDepositOnlyError);
 /** OperationWithdrawOnly: Operation is withdraw-only */
 class OperationWithdrawOnlyError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Operation is withdraw-only', program, cause);
         this.name = 'OperationWithdrawOnly';
-        this.code = 0x1786; // 6022
+        this.code = 0x1784; // 6020
     }
 }
 exports.OperationWithdrawOnlyError = OperationWithdrawOnlyError;
-codeToErrorMap.set(0x1786, OperationWithdrawOnlyError);
+codeToErrorMap.set(0x1784, OperationWithdrawOnlyError);
 nameToErrorMap.set('OperationWithdrawOnly', OperationWithdrawOnlyError);
 /** OperationBorrowOnly: Operation is borrow-only */
 class OperationBorrowOnlyError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Operation is borrow-only', program, cause);
         this.name = 'OperationBorrowOnly';
-        this.code = 0x1787; // 6023
+        this.code = 0x1785; // 6021
     }
 }
 exports.OperationBorrowOnlyError = OperationBorrowOnlyError;
-codeToErrorMap.set(0x1787, OperationBorrowOnlyError);
+codeToErrorMap.set(0x1785, OperationBorrowOnlyError);
 nameToErrorMap.set('OperationBorrowOnly', OperationBorrowOnlyError);
 /** OperationRepayOnly: Operation is repay-only */
 class OperationRepayOnlyError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Operation is repay-only', program, cause);
         this.name = 'OperationRepayOnly';
-        this.code = 0x1788; // 6024
+        this.code = 0x1786; // 6022
     }
 }
 exports.OperationRepayOnlyError = OperationRepayOnlyError;
-codeToErrorMap.set(0x1788, OperationRepayOnlyError);
+codeToErrorMap.set(0x1786, OperationRepayOnlyError);
 nameToErrorMap.set('OperationRepayOnly', OperationRepayOnlyError);
 /** NoAssetFound: No asset found */
 class NoAssetFoundError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('No asset found', program, cause);
         this.name = 'NoAssetFound';
-        this.code = 0x1789; // 6025
+        this.code = 0x1787; // 6023
     }
 }
 exports.NoAssetFoundError = NoAssetFoundError;
-codeToErrorMap.set(0x1789, NoAssetFoundError);
+codeToErrorMap.set(0x1787, NoAssetFoundError);
 nameToErrorMap.set('NoAssetFound', NoAssetFoundError);
 /** NoLiabilityFound: No liability found */
 class NoLiabilityFoundError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('No liability found', program, cause);
         this.name = 'NoLiabilityFound';
-        this.code = 0x178a; // 6026
+        this.code = 0x1788; // 6024
     }
 }
 exports.NoLiabilityFoundError = NoLiabilityFoundError;
-codeToErrorMap.set(0x178a, NoLiabilityFoundError);
+codeToErrorMap.set(0x1788, NoLiabilityFoundError);
 nameToErrorMap.set('NoLiabilityFound', NoLiabilityFoundError);
 /** InvalidOracleSetup: Invalid oracle setup */
 class InvalidOracleSetupError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Invalid oracle setup', program, cause);
         this.name = 'InvalidOracleSetup';
-        this.code = 0x178b; // 6027
+        this.code = 0x1789; // 6025
     }
 }
 exports.InvalidOracleSetupError = InvalidOracleSetupError;
-codeToErrorMap.set(0x178b, InvalidOracleSetupError);
+codeToErrorMap.set(0x1789, InvalidOracleSetupError);
 nameToErrorMap.set('InvalidOracleSetup', InvalidOracleSetupError);
 /** IllegalUtilizationRatio: Invalid bank utilization ratio */
 class IllegalUtilizationRatioError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Invalid bank utilization ratio', program, cause);
         this.name = 'IllegalUtilizationRatio';
-        this.code = 0x178c; // 6028
+        this.code = 0x178a; // 6026
     }
 }
 exports.IllegalUtilizationRatioError = IllegalUtilizationRatioError;
-codeToErrorMap.set(0x178c, IllegalUtilizationRatioError);
+codeToErrorMap.set(0x178a, IllegalUtilizationRatioError);
 nameToErrorMap.set('IllegalUtilizationRatio', IllegalUtilizationRatioError);
 /** BankLiabilityCapacityExceeded: Bank borrow cap exceeded */
 class BankLiabilityCapacityExceededError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Bank borrow cap exceeded', program, cause);
         this.name = 'BankLiabilityCapacityExceeded';
-        this.code = 0x178d; // 6029
+        this.code = 0x178b; // 6027
     }
 }
 exports.BankLiabilityCapacityExceededError = BankLiabilityCapacityExceededError;
-codeToErrorMap.set(0x178d, BankLiabilityCapacityExceededError);
+codeToErrorMap.set(0x178b, BankLiabilityCapacityExceededError);
 nameToErrorMap.set('BankLiabilityCapacityExceeded', BankLiabilityCapacityExceededError);
 /** InvalidPrice: Invalid Price */
 class InvalidPriceError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Invalid Price', program, cause);
         this.name = 'InvalidPrice';
-        this.code = 0x178e; // 6030
+        this.code = 0x178c; // 6028
     }
 }
 exports.InvalidPriceError = InvalidPriceError;
-codeToErrorMap.set(0x178e, InvalidPriceError);
+codeToErrorMap.set(0x178c, InvalidPriceError);
 nameToErrorMap.set('InvalidPrice', InvalidPriceError);
-/** IsolatedAccountIllegalState: Account can have only one liablity when account is under isolated risk */
+/** IsolatedAccountIllegalState: Account can have only one liability when account is under isolated risk */
 class IsolatedAccountIllegalStateError extends umi_1.ProgramError {
     constructor(program, cause) {
-        super('Account can have only one liablity when account is under isolated risk', program, cause);
+        super('Account can have only one liability when account is under isolated risk', program, cause);
         this.name = 'IsolatedAccountIllegalState';
-        this.code = 0x178f; // 6031
+        this.code = 0x178d; // 6029
     }
 }
 exports.IsolatedAccountIllegalStateError = IsolatedAccountIllegalStateError;
-codeToErrorMap.set(0x178f, IsolatedAccountIllegalStateError);
+codeToErrorMap.set(0x178d, IsolatedAccountIllegalStateError);
 nameToErrorMap.set('IsolatedAccountIllegalState', IsolatedAccountIllegalStateError);
 /** EmissionsAlreadySetup: Emissions already setup */
 class EmissionsAlreadySetupError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Emissions already setup', program, cause);
         this.name = 'EmissionsAlreadySetup';
-        this.code = 0x1790; // 6032
+        this.code = 0x178e; // 6030
     }
 }
 exports.EmissionsAlreadySetupError = EmissionsAlreadySetupError;
-codeToErrorMap.set(0x1790, EmissionsAlreadySetupError);
+codeToErrorMap.set(0x178e, EmissionsAlreadySetupError);
 nameToErrorMap.set('EmissionsAlreadySetup', EmissionsAlreadySetupError);
 /** OracleNotSetup: Oracle is not set */
 class OracleNotSetupError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Oracle is not set', program, cause);
         this.name = 'OracleNotSetup';
-        this.code = 0x1791; // 6033
+        this.code = 0x178f; // 6031
     }
 }
 exports.OracleNotSetupError = OracleNotSetupError;
-codeToErrorMap.set(0x1791, OracleNotSetupError);
+codeToErrorMap.set(0x178f, OracleNotSetupError);
 nameToErrorMap.set('OracleNotSetup', OracleNotSetupError);
-/** InvalidSwitchboardDecimalConversion: Invalid swithcboard decimal conversion */
+/** InvalidSwitchboardDecimalConversion: Invalid switchboard decimal conversion */
 class InvalidSwitchboardDecimalConversionError extends umi_1.ProgramError {
     constructor(program, cause) {
-        super('Invalid swithcboard decimal conversion', program, cause);
+        super('Invalid switchboard decimal conversion', program, cause);
         this.name = 'InvalidSwitchboardDecimalConversion';
-        this.code = 0x1792; // 6034
+        this.code = 0x1790; // 6032
     }
 }
 exports.InvalidSwitchboardDecimalConversionError = InvalidSwitchboardDecimalConversionError;
-codeToErrorMap.set(0x1792, InvalidSwitchboardDecimalConversionError);
+codeToErrorMap.set(0x1790, InvalidSwitchboardDecimalConversionError);
 nameToErrorMap.set('InvalidSwitchboardDecimalConversion', InvalidSwitchboardDecimalConversionError);
 /** CannotCloseOutstandingEmissions: Cannot close balance because of outstanding emissions */
 class CannotCloseOutstandingEmissionsError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Cannot close balance because of outstanding emissions', program, cause);
         this.name = 'CannotCloseOutstandingEmissions';
-        this.code = 0x1793; // 6035
+        this.code = 0x1791; // 6033
     }
 }
 exports.CannotCloseOutstandingEmissionsError = CannotCloseOutstandingEmissionsError;
-codeToErrorMap.set(0x1793, CannotCloseOutstandingEmissionsError);
+codeToErrorMap.set(0x1791, CannotCloseOutstandingEmissionsError);
 nameToErrorMap.set('CannotCloseOutstandingEmissions', CannotCloseOutstandingEmissionsError);
 /** EmissionsUpdateError: Update emissions error */
 class EmissionsUpdateErrorError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Update emissions error', program, cause);
         this.name = 'EmissionsUpdateError';
-        this.code = 0x1794; // 6036
+        this.code = 0x1792; // 6034
     }
 }
 exports.EmissionsUpdateErrorError = EmissionsUpdateErrorError;
-codeToErrorMap.set(0x1794, EmissionsUpdateErrorError);
+codeToErrorMap.set(0x1792, EmissionsUpdateErrorError);
 nameToErrorMap.set('EmissionsUpdateError', EmissionsUpdateErrorError);
 /** AccountDisabled: Account disabled */
 class AccountDisabledError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Account disabled', program, cause);
         this.name = 'AccountDisabled';
-        this.code = 0x1795; // 6037
+        this.code = 0x1793; // 6035
     }
 }
 exports.AccountDisabledError = AccountDisabledError;
-codeToErrorMap.set(0x1795, AccountDisabledError);
+codeToErrorMap.set(0x1793, AccountDisabledError);
 nameToErrorMap.set('AccountDisabled', AccountDisabledError);
 /** AccountTempActiveBalanceLimitExceeded: Account can't temporarily open 3 balances, please close a balance first */
 class AccountTempActiveBalanceLimitExceededError extends umi_1.ProgramError {
     constructor(program, cause) {
         super("Account can't temporarily open 3 balances, please close a balance first", program, cause);
         this.name = 'AccountTempActiveBalanceLimitExceeded';
-        this.code = 0x1796; // 6038
+        this.code = 0x1794; // 6036
     }
 }
 exports.AccountTempActiveBalanceLimitExceededError = AccountTempActiveBalanceLimitExceededError;
-codeToErrorMap.set(0x1796, AccountTempActiveBalanceLimitExceededError);
+codeToErrorMap.set(0x1794, AccountTempActiveBalanceLimitExceededError);
 nameToErrorMap.set('AccountTempActiveBalanceLimitExceeded', AccountTempActiveBalanceLimitExceededError);
 /** AccountInFlashloan: Illegal action during flashloan */
 class AccountInFlashloanError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Illegal action during flashloan', program, cause);
         this.name = 'AccountInFlashloan';
-        this.code = 0x1797; // 6039
+        this.code = 0x1795; // 6037
     }
 }
 exports.AccountInFlashloanError = AccountInFlashloanError;
-codeToErrorMap.set(0x1797, AccountInFlashloanError);
+codeToErrorMap.set(0x1795, AccountInFlashloanError);
 nameToErrorMap.set('AccountInFlashloan', AccountInFlashloanError);
 /** IllegalFlashloan: Illegal flashloan */
 class IllegalFlashloanError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Illegal flashloan', program, cause);
         this.name = 'IllegalFlashloan';
-        this.code = 0x1798; // 6040
+        this.code = 0x1796; // 6038
     }
 }
 exports.IllegalFlashloanError = IllegalFlashloanError;
-codeToErrorMap.set(0x1798, IllegalFlashloanError);
+codeToErrorMap.set(0x1796, IllegalFlashloanError);
 nameToErrorMap.set('IllegalFlashloan', IllegalFlashloanError);
 /** IllegalFlag: Illegal flag */
 class IllegalFlagError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Illegal flag', program, cause);
         this.name = 'IllegalFlag';
-        this.code = 0x1799; // 6041
+        this.code = 0x1797; // 6039
     }
 }
 exports.IllegalFlagError = IllegalFlagError;
-codeToErrorMap.set(0x1799, IllegalFlagError);
+codeToErrorMap.set(0x1797, IllegalFlagError);
 nameToErrorMap.set('IllegalFlag', IllegalFlagError);
 /** IllegalBalanceState: Illegal balance state */
 class IllegalBalanceStateError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Illegal balance state', program, cause);
         this.name = 'IllegalBalanceState';
-        this.code = 0x179a; // 6042
+        this.code = 0x1798; // 6040
     }
 }
 exports.IllegalBalanceStateError = IllegalBalanceStateError;
-codeToErrorMap.set(0x179a, IllegalBalanceStateError);
+codeToErrorMap.set(0x1798, IllegalBalanceStateError);
 nameToErrorMap.set('IllegalBalanceState', IllegalBalanceStateError);
 /** IllegalAccountAuthorityTransfer: Illegal account authority transfer */
 class IllegalAccountAuthorityTransferError extends umi_1.ProgramError {
     constructor(program, cause) {
         super('Illegal account authority transfer', program, cause);
         this.name = 'IllegalAccountAuthorityTransfer';
-        this.code = 0x179b; // 6043
+        this.code = 0x1799; // 6041
     }
 }
 exports.IllegalAccountAuthorityTransferError = IllegalAccountAuthorityTransferError;
-codeToErrorMap.set(0x179b, IllegalAccountAuthorityTransferError);
+codeToErrorMap.set(0x1799, IllegalAccountAuthorityTransferError);
 nameToErrorMap.set('IllegalAccountAuthorityTransfer', IllegalAccountAuthorityTransferError);
+/** Unauthorized: Unauthorized */
+class UnauthorizedError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Unauthorized', program, cause);
+        this.name = 'Unauthorized';
+        this.code = 0x179a; // 6042
+    }
+}
+exports.UnauthorizedError = UnauthorizedError;
+codeToErrorMap.set(0x179a, UnauthorizedError);
+nameToErrorMap.set('Unauthorized', UnauthorizedError);
+/** IllegalAction: Invalid account authority */
+class IllegalActionError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Invalid account authority', program, cause);
+        this.name = 'IllegalAction';
+        this.code = 0x179b; // 6043
+    }
+}
+exports.IllegalActionError = IllegalActionError;
+codeToErrorMap.set(0x179b, IllegalActionError);
+nameToErrorMap.set('IllegalAction', IllegalActionError);
+/** T22MintRequired: Token22 Banks require mint account as first remaining account */
+class T22MintRequiredError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Token22 Banks require mint account as first remaining account', program, cause);
+        this.name = 'T22MintRequired';
+        this.code = 0x179c; // 6044
+    }
+}
+exports.T22MintRequiredError = T22MintRequiredError;
+codeToErrorMap.set(0x179c, T22MintRequiredError);
+nameToErrorMap.set('T22MintRequired', T22MintRequiredError);
+/** InvalidFeeAta: Invalid ATA for global fee account */
+class InvalidFeeAtaError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Invalid ATA for global fee account', program, cause);
+        this.name = 'InvalidFeeAta';
+        this.code = 0x179d; // 6045
+    }
+}
+exports.InvalidFeeAtaError = InvalidFeeAtaError;
+codeToErrorMap.set(0x179d, InvalidFeeAtaError);
+nameToErrorMap.set('InvalidFeeAta', InvalidFeeAtaError);
+/** AddedStakedPoolManually: Use add pool permissionless instead */
+class AddedStakedPoolManuallyError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Use add pool permissionless instead', program, cause);
+        this.name = 'AddedStakedPoolManually';
+        this.code = 0x179e; // 6046
+    }
+}
+exports.AddedStakedPoolManuallyError = AddedStakedPoolManuallyError;
+codeToErrorMap.set(0x179e, AddedStakedPoolManuallyError);
+nameToErrorMap.set('AddedStakedPoolManually', AddedStakedPoolManuallyError);
+/** AssetTagMismatch: Staked SOL accounts can only deposit staked assets and borrow SOL */
+class AssetTagMismatchError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Staked SOL accounts can only deposit staked assets and borrow SOL', program, cause);
+        this.name = 'AssetTagMismatch';
+        this.code = 0x179f; // 6047
+    }
+}
+exports.AssetTagMismatchError = AssetTagMismatchError;
+codeToErrorMap.set(0x179f, AssetTagMismatchError);
+nameToErrorMap.set('AssetTagMismatch', AssetTagMismatchError);
+/** StakePoolValidationFailed: Stake pool validation failed: check the stake pool, mint, or sol pool */
+class StakePoolValidationFailedError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Stake pool validation failed: check the stake pool, mint, or sol pool', program, cause);
+        this.name = 'StakePoolValidationFailed';
+        this.code = 0x17a0; // 6048
+    }
+}
+exports.StakePoolValidationFailedError = StakePoolValidationFailedError;
+codeToErrorMap.set(0x17a0, StakePoolValidationFailedError);
+nameToErrorMap.set('StakePoolValidationFailed', StakePoolValidationFailedError);
+/** SwitchboardStalePrice: Switchboard oracle: stale price */
+class SwitchboardStalePriceError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Switchboard oracle: stale price', program, cause);
+        this.name = 'SwitchboardStalePrice';
+        this.code = 0x17a1; // 6049
+    }
+}
+exports.SwitchboardStalePriceError = SwitchboardStalePriceError;
+codeToErrorMap.set(0x17a1, SwitchboardStalePriceError);
+nameToErrorMap.set('SwitchboardStalePrice', SwitchboardStalePriceError);
+/** PythPushStalePrice: Pyth Push oracle: stale price */
+class PythPushStalePriceError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: stale price', program, cause);
+        this.name = 'PythPushStalePrice';
+        this.code = 0x17a2; // 6050
+    }
+}
+exports.PythPushStalePriceError = PythPushStalePriceError;
+codeToErrorMap.set(0x17a2, PythPushStalePriceError);
+nameToErrorMap.set('PythPushStalePrice', PythPushStalePriceError);
+/** WrongNumberOfOracleAccounts: Oracle error: wrong number of accounts */
+class WrongNumberOfOracleAccountsError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Oracle error: wrong number of accounts', program, cause);
+        this.name = 'WrongNumberOfOracleAccounts';
+        this.code = 0x17a3; // 6051
+    }
+}
+exports.WrongNumberOfOracleAccountsError = WrongNumberOfOracleAccountsError;
+codeToErrorMap.set(0x17a3, WrongNumberOfOracleAccountsError);
+nameToErrorMap.set('WrongNumberOfOracleAccounts', WrongNumberOfOracleAccountsError);
+/** WrongOracleAccountKeys: Oracle error: wrong account keys */
+class WrongOracleAccountKeysError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Oracle error: wrong account keys', program, cause);
+        this.name = 'WrongOracleAccountKeys';
+        this.code = 0x17a4; // 6052
+    }
+}
+exports.WrongOracleAccountKeysError = WrongOracleAccountKeysError;
+codeToErrorMap.set(0x17a4, WrongOracleAccountKeysError);
+nameToErrorMap.set('WrongOracleAccountKeys', WrongOracleAccountKeysError);
+/** PythPushWrongAccountOwner: Pyth Push oracle: wrong account owner */
+class PythPushWrongAccountOwnerError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: wrong account owner', program, cause);
+        this.name = 'PythPushWrongAccountOwner';
+        this.code = 0x17a5; // 6053
+    }
+}
+exports.PythPushWrongAccountOwnerError = PythPushWrongAccountOwnerError;
+codeToErrorMap.set(0x17a5, PythPushWrongAccountOwnerError);
+nameToErrorMap.set('PythPushWrongAccountOwner', PythPushWrongAccountOwnerError);
+/** StakedPythPushWrongAccountOwner: Staked Pyth Push oracle: wrong account owner */
+class StakedPythPushWrongAccountOwnerError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Staked Pyth Push oracle: wrong account owner', program, cause);
+        this.name = 'StakedPythPushWrongAccountOwner';
+        this.code = 0x17a6; // 6054
+    }
+}
+exports.StakedPythPushWrongAccountOwnerError = StakedPythPushWrongAccountOwnerError;
+codeToErrorMap.set(0x17a6, StakedPythPushWrongAccountOwnerError);
+nameToErrorMap.set('StakedPythPushWrongAccountOwner', StakedPythPushWrongAccountOwnerError);
+/** PythPushMismatchedFeedId: Pyth Push oracle: mismatched feed id */
+class PythPushMismatchedFeedIdError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: mismatched feed id', program, cause);
+        this.name = 'PythPushMismatchedFeedId';
+        this.code = 0x17a7; // 6055
+    }
+}
+exports.PythPushMismatchedFeedIdError = PythPushMismatchedFeedIdError;
+codeToErrorMap.set(0x17a7, PythPushMismatchedFeedIdError);
+nameToErrorMap.set('PythPushMismatchedFeedId', PythPushMismatchedFeedIdError);
+/** PythPushInsufficientVerificationLevel: Pyth Push oracle: insufficient verification level */
+class PythPushInsufficientVerificationLevelError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: insufficient verification level', program, cause);
+        this.name = 'PythPushInsufficientVerificationLevel';
+        this.code = 0x17a8; // 6056
+    }
+}
+exports.PythPushInsufficientVerificationLevelError = PythPushInsufficientVerificationLevelError;
+codeToErrorMap.set(0x17a8, PythPushInsufficientVerificationLevelError);
+nameToErrorMap.set('PythPushInsufficientVerificationLevel', PythPushInsufficientVerificationLevelError);
+/** PythPushFeedIdMustBe32Bytes: Pyth Push oracle: feed id must be 32 Bytes */
+class PythPushFeedIdMustBe32BytesError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: feed id must be 32 Bytes', program, cause);
+        this.name = 'PythPushFeedIdMustBe32Bytes';
+        this.code = 0x17a9; // 6057
+    }
+}
+exports.PythPushFeedIdMustBe32BytesError = PythPushFeedIdMustBe32BytesError;
+codeToErrorMap.set(0x17a9, PythPushFeedIdMustBe32BytesError);
+nameToErrorMap.set('PythPushFeedIdMustBe32Bytes', PythPushFeedIdMustBe32BytesError);
+/** PythPushFeedIdNonHexCharacter: Pyth Push oracle: feed id contains non-hex characters */
+class PythPushFeedIdNonHexCharacterError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: feed id contains non-hex characters', program, cause);
+        this.name = 'PythPushFeedIdNonHexCharacter';
+        this.code = 0x17aa; // 6058
+    }
+}
+exports.PythPushFeedIdNonHexCharacterError = PythPushFeedIdNonHexCharacterError;
+codeToErrorMap.set(0x17aa, PythPushFeedIdNonHexCharacterError);
+nameToErrorMap.set('PythPushFeedIdNonHexCharacter', PythPushFeedIdNonHexCharacterError);
+/** SwitchboardWrongAccountOwner: Switchboard oracle: wrong account owner */
+class SwitchboardWrongAccountOwnerError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Switchboard oracle: wrong account owner', program, cause);
+        this.name = 'SwitchboardWrongAccountOwner';
+        this.code = 0x17ab; // 6059
+    }
+}
+exports.SwitchboardWrongAccountOwnerError = SwitchboardWrongAccountOwnerError;
+codeToErrorMap.set(0x17ab, SwitchboardWrongAccountOwnerError);
+nameToErrorMap.set('SwitchboardWrongAccountOwner', SwitchboardWrongAccountOwnerError);
+/** PythPushInvalidAccount: Pyth Push oracle: invalid account */
+class PythPushInvalidAccountError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Pyth Push oracle: invalid account', program, cause);
+        this.name = 'PythPushInvalidAccount';
+        this.code = 0x17ac; // 6060
+    }
+}
+exports.PythPushInvalidAccountError = PythPushInvalidAccountError;
+codeToErrorMap.set(0x17ac, PythPushInvalidAccountError);
+nameToErrorMap.set('PythPushInvalidAccount', PythPushInvalidAccountError);
+/** SwitchboardInvalidAccount: Switchboard oracle: invalid account */
+class SwitchboardInvalidAccountError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Switchboard oracle: invalid account', program, cause);
+        this.name = 'SwitchboardInvalidAccount';
+        this.code = 0x17ad; // 6061
+    }
+}
+exports.SwitchboardInvalidAccountError = SwitchboardInvalidAccountError;
+codeToErrorMap.set(0x17ad, SwitchboardInvalidAccountError);
+nameToErrorMap.set('SwitchboardInvalidAccount', SwitchboardInvalidAccountError);
+/** MathError: Math error */
+class MathErrorError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Math error', program, cause);
+        this.name = 'MathError';
+        this.code = 0x17ae; // 6062
+    }
+}
+exports.MathErrorError = MathErrorError;
+codeToErrorMap.set(0x17ae, MathErrorError);
+nameToErrorMap.set('MathError', MathErrorError);
+/** InvalidEmissionsDestinationAccount: Invalid emissions destination account */
+class InvalidEmissionsDestinationAccountError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Invalid emissions destination account', program, cause);
+        this.name = 'InvalidEmissionsDestinationAccount';
+        this.code = 0x17af; // 6063
+    }
+}
+exports.InvalidEmissionsDestinationAccountError = InvalidEmissionsDestinationAccountError;
+codeToErrorMap.set(0x17af, InvalidEmissionsDestinationAccountError);
+nameToErrorMap.set('InvalidEmissionsDestinationAccount', InvalidEmissionsDestinationAccountError);
+/** SameAssetAndLiabilityBanks: Asset and liability bank cannot be the same */
+class SameAssetAndLiabilityBanksError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Asset and liability bank cannot be the same', program, cause);
+        this.name = 'SameAssetAndLiabilityBanks';
+        this.code = 0x17b0; // 6064
+    }
+}
+exports.SameAssetAndLiabilityBanksError = SameAssetAndLiabilityBanksError;
+codeToErrorMap.set(0x17b0, SameAssetAndLiabilityBanksError);
+nameToErrorMap.set('SameAssetAndLiabilityBanks', SameAssetAndLiabilityBanksError);
+/** OverliquidationAttempt: Trying to withdraw more assets than available */
+class OverliquidationAttemptError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Trying to withdraw more assets than available', program, cause);
+        this.name = 'OverliquidationAttempt';
+        this.code = 0x17b1; // 6065
+    }
+}
+exports.OverliquidationAttemptError = OverliquidationAttemptError;
+codeToErrorMap.set(0x17b1, OverliquidationAttemptError);
+nameToErrorMap.set('OverliquidationAttempt', OverliquidationAttemptError);
+/** NoLiabilitiesInLiabilityBank: Liability bank has no liabilities */
+class NoLiabilitiesInLiabilityBankError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Liability bank has no liabilities', program, cause);
+        this.name = 'NoLiabilitiesInLiabilityBank';
+        this.code = 0x17b2; // 6066
+    }
+}
+exports.NoLiabilitiesInLiabilityBankError = NoLiabilitiesInLiabilityBankError;
+codeToErrorMap.set(0x17b2, NoLiabilitiesInLiabilityBankError);
+nameToErrorMap.set('NoLiabilitiesInLiabilityBank', NoLiabilitiesInLiabilityBankError);
+/** AssetsInLiabilityBank: Liability bank has assets */
+class AssetsInLiabilityBankError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Liability bank has assets', program, cause);
+        this.name = 'AssetsInLiabilityBank';
+        this.code = 0x17b3; // 6067
+    }
+}
+exports.AssetsInLiabilityBankError = AssetsInLiabilityBankError;
+codeToErrorMap.set(0x17b3, AssetsInLiabilityBankError);
+nameToErrorMap.set('AssetsInLiabilityBank', AssetsInLiabilityBankError);
+/** HealthyAccount: Account is healthy and cannot be liquidated */
+class HealthyAccountError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Account is healthy and cannot be liquidated', program, cause);
+        this.name = 'HealthyAccount';
+        this.code = 0x17b4; // 6068
+    }
+}
+exports.HealthyAccountError = HealthyAccountError;
+codeToErrorMap.set(0x17b4, HealthyAccountError);
+nameToErrorMap.set('HealthyAccount', HealthyAccountError);
+/** ExhaustedLiability: Liability payoff too severe, exhausted liability */
+class ExhaustedLiabilityError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Liability payoff too severe, exhausted liability', program, cause);
+        this.name = 'ExhaustedLiability';
+        this.code = 0x17b5; // 6069
+    }
+}
+exports.ExhaustedLiabilityError = ExhaustedLiabilityError;
+codeToErrorMap.set(0x17b5, ExhaustedLiabilityError);
+nameToErrorMap.set('ExhaustedLiability', ExhaustedLiabilityError);
+/** TooSeverePayoff: Liability payoff too severe, liability balance has assets */
+class TooSeverePayoffError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Liability payoff too severe, liability balance has assets', program, cause);
+        this.name = 'TooSeverePayoff';
+        this.code = 0x17b6; // 6070
+    }
+}
+exports.TooSeverePayoffError = TooSeverePayoffError;
+codeToErrorMap.set(0x17b6, TooSeverePayoffError);
+nameToErrorMap.set('TooSeverePayoff', TooSeverePayoffError);
+/** TooSevereLiquidation: Liquidation too severe, account above maintenance requirement */
+class TooSevereLiquidationError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Liquidation too severe, account above maintenance requirement', program, cause);
+        this.name = 'TooSevereLiquidation';
+        this.code = 0x17b7; // 6071
+    }
+}
+exports.TooSevereLiquidationError = TooSevereLiquidationError;
+codeToErrorMap.set(0x17b7, TooSevereLiquidationError);
+nameToErrorMap.set('TooSevereLiquidation', TooSevereLiquidationError);
+/** WorseHealthPostLiquidation: Liquidation would worsen account health */
+class WorseHealthPostLiquidationError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Liquidation would worsen account health', program, cause);
+        this.name = 'WorseHealthPostLiquidation';
+        this.code = 0x17b8; // 6072
+    }
+}
+exports.WorseHealthPostLiquidationError = WorseHealthPostLiquidationError;
+codeToErrorMap.set(0x17b8, WorseHealthPostLiquidationError);
+nameToErrorMap.set('WorseHealthPostLiquidation', WorseHealthPostLiquidationError);
+/** ArenaBankLimit: Arena groups can only support two banks */
+class ArenaBankLimitError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Arena groups can only support two banks', program, cause);
+        this.name = 'ArenaBankLimit';
+        this.code = 0x17b9; // 6073
+    }
+}
+exports.ArenaBankLimitError = ArenaBankLimitError;
+codeToErrorMap.set(0x17b9, ArenaBankLimitError);
+nameToErrorMap.set('ArenaBankLimit', ArenaBankLimitError);
+/** ArenaSettingCannotChange: Arena groups cannot return to non-arena status */
+class ArenaSettingCannotChangeError extends umi_1.ProgramError {
+    constructor(program, cause) {
+        super('Arena groups cannot return to non-arena status', program, cause);
+        this.name = 'ArenaSettingCannotChange';
+        this.code = 0x17ba; // 6074
+    }
+}
+exports.ArenaSettingCannotChangeError = ArenaSettingCannotChangeError;
+codeToErrorMap.set(0x17ba, ArenaSettingCannotChangeError);
+nameToErrorMap.set('ArenaSettingCannotChange', ArenaSettingCannotChangeError);
 /**
  * Attempts to resolve a custom program error from the provided error code.
  * @category Errors