@kamino-finance/klend-sdk 5.2.11 → 5.2.13

package/src/idl_codegen_kamino_vault/errors/custom.ts

@@ -21,7 +21,7 @@ export type CustomError =
   | TokenVaultIncorrect
   | SharesMintDecimalsIncorrect
   | SharesMintIncorrect
-  | InitialAccountintIncorrect
+  | InitialAccountingIncorrect
   | ReserveIsStale
   | NotEnoughLiquidityDisinvestedToSendToUser
   | BPSValueTooBig
@@ -37,503 +37,559 @@ export type CustomError =
   | SharesMintedAmountDoesNotMatch
   | AUMDecreasedAfterInvest
   | AUMBelowPendingFees
+  | DepositAmountsZeroShares
+  | WithdrawResultsInZeroShares
+  | CannotWithdrawZeroShares
+  | ManagementFeeGreaterThanMaxAllowed
 
 export class DepositAmountsZero extends Error {
-  static readonly code = 6000
-  readonly code = 6000
+  static readonly code = 7000
+  readonly code = 7000
   readonly name = "DepositAmountsZero"
   readonly msg = "DepositAmountsZero"
 
   constructor(readonly logs?: string[]) {
-    super("6000: DepositAmountsZero")
+    super("7000: DepositAmountsZero")
   }
 }
 
 export class SharesIssuedAmountDoesNotMatch extends Error {
-  static readonly code = 6001
-  readonly code = 6001
+  static readonly code = 7001
+  readonly code = 7001
   readonly name = "SharesIssuedAmountDoesNotMatch"
   readonly msg = "SharesIssuedAmountDoesNotMatch"
 
   constructor(readonly logs?: string[]) {
-    super("6001: SharesIssuedAmountDoesNotMatch")
+    super("7001: SharesIssuedAmountDoesNotMatch")
   }
 }
 
 export class MathOverflow extends Error {
-  static readonly code = 6002
-  readonly code = 6002
+  static readonly code = 7002
+  readonly code = 7002
   readonly name = "MathOverflow"
   readonly msg = "MathOverflow"
 
   constructor(readonly logs?: string[]) {
-    super("6002: MathOverflow")
+    super("7002: MathOverflow")
   }
 }
 
 export class IntegerOverflow extends Error {
-  static readonly code = 6003
-  readonly code = 6003
+  static readonly code = 7003
+  readonly code = 7003
   readonly name = "IntegerOverflow"
   readonly msg = "IntegerOverflow"
 
   constructor(readonly logs?: string[]) {
-    super("6003: IntegerOverflow")
+    super("7003: IntegerOverflow")
   }
 }
 
 export class WithdrawAmountBelowMinimum extends Error {
-  static readonly code = 6004
-  readonly code = 6004
+  static readonly code = 7004
+  readonly code = 7004
   readonly name = "WithdrawAmountBelowMinimum"
   readonly msg = "Withdrawn amount is below minimum"
 
   constructor(readonly logs?: string[]) {
-    super("6004: Withdrawn amount is below minimum")
+    super("7004: Withdrawn amount is below minimum")
   }
 }
 
 export class TooMuchLiquidityToWithdraw extends Error {
-  static readonly code = 6005
-  readonly code = 6005
+  static readonly code = 7005
+  readonly code = 7005
   readonly name = "TooMuchLiquidityToWithdraw"
   readonly msg = "TooMuchLiquidityToWithdraw"
 
   constructor(readonly logs?: string[]) {
-    super("6005: TooMuchLiquidityToWithdraw")
+    super("7005: TooMuchLiquidityToWithdraw")
   }
 }
 
 export class ReserveAlreadyExists extends Error {
-  static readonly code = 6006
-  readonly code = 6006
+  static readonly code = 7006
+  readonly code = 7006
   readonly name = "ReserveAlreadyExists"
   readonly msg = "ReserveAlreadyExists"
 
   constructor(readonly logs?: string[]) {
-    super("6006: ReserveAlreadyExists")
+    super("7006: ReserveAlreadyExists")
   }
 }
 
 export class ReserveNotPartOfAllocations extends Error {
-  static readonly code = 6007
-  readonly code = 6007
+  static readonly code = 7007
+  readonly code = 7007
   readonly name = "ReserveNotPartOfAllocations"
   readonly msg = "ReserveNotPartOfAllocations"
 
   constructor(readonly logs?: string[]) {
-    super("6007: ReserveNotPartOfAllocations")
+    super("7007: ReserveNotPartOfAllocations")
   }
 }
 
 export class CouldNotDeserializeAccountAsReserve extends Error {
-  static readonly code = 6008
-  readonly code = 6008
+  static readonly code = 7008
+  readonly code = 7008
   readonly name = "CouldNotDeserializeAccountAsReserve"
   readonly msg = "CouldNotDeserializeAccountAsReserve"
 
   constructor(readonly logs?: string[]) {
-    super("6008: CouldNotDeserializeAccountAsReserve")
+    super("7008: CouldNotDeserializeAccountAsReserve")
   }
 }
 
 export class ReserveNotProvidedInTheAccounts extends Error {
-  static readonly code = 6009
-  readonly code = 6009
+  static readonly code = 7009
+  readonly code = 7009
   readonly name = "ReserveNotProvidedInTheAccounts"
   readonly msg = "ReserveNotProvidedInTheAccounts"
 
   constructor(readonly logs?: string[]) {
-    super("6009: ReserveNotProvidedInTheAccounts")
+    super("7009: ReserveNotProvidedInTheAccounts")
   }
 }
 
 export class ReserveAccountAndKeyMismatch extends Error {
-  static readonly code = 6010
-  readonly code = 6010
+  static readonly code = 7010
+  readonly code = 7010
   readonly name = "ReserveAccountAndKeyMismatch"
   readonly msg = "ReserveAccountAndKeyMismatch"
 
   constructor(readonly logs?: string[]) {
-    super("6010: ReserveAccountAndKeyMismatch")
+    super("7010: ReserveAccountAndKeyMismatch")
   }
 }
 
 export class OutOfRangeOfReserveIndex extends Error {
-  static readonly code = 6011
-  readonly code = 6011
+  static readonly code = 7011
+  readonly code = 7011
   readonly name = "OutOfRangeOfReserveIndex"
   readonly msg = "OutOfRangeOfReserveIndex"
 
   constructor(readonly logs?: string[]) {
-    super("6011: OutOfRangeOfReserveIndex")
+    super("7011: OutOfRangeOfReserveIndex")
   }
 }
 
 export class CannotFindReserveInAllocations extends Error {
-  static readonly code = 6012
-  readonly code = 6012
+  static readonly code = 7012
+  readonly code = 7012
   readonly name = "CannotFindReserveInAllocations"
   readonly msg = "OutOfRangeOfReserveIndex"
 
   constructor(readonly logs?: string[]) {
-    super("6012: OutOfRangeOfReserveIndex")
+    super("7012: OutOfRangeOfReserveIndex")
   }
 }
 
 export class InvestAmountBelowMinimum extends Error {
-  static readonly code = 6013
-  readonly code = 6013
+  static readonly code = 7013
+  readonly code = 7013
   readonly name = "InvestAmountBelowMinimum"
   readonly msg = "Invested amount is below minimum"
 
   constructor(readonly logs?: string[]) {
-    super("6013: Invested amount is below minimum")
+    super("7013: Invested amount is below minimum")
   }
 }
 
 export class AdminAuthorityIncorrect extends Error {
-  static readonly code = 6014
-  readonly code = 6014
+  static readonly code = 7014
+  readonly code = 7014
   readonly name = "AdminAuthorityIncorrect"
   readonly msg = "AdminAuthorityIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6014: AdminAuthorityIncorrect")
+    super("7014: AdminAuthorityIncorrect")
   }
 }
 
 export class BaseVaultAuthorityIncorrect extends Error {
-  static readonly code = 6015
-  readonly code = 6015
+  static readonly code = 7015
+  readonly code = 7015
   readonly name = "BaseVaultAuthorityIncorrect"
   readonly msg = "BaseVaultAuthorityIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6015: BaseVaultAuthorityIncorrect")
+    super("7015: BaseVaultAuthorityIncorrect")
   }
 }
 
 export class BaseVaultAuthorityBumpIncorrect extends Error {
-  static readonly code = 6016
-  readonly code = 6016
+  static readonly code = 7016
+  readonly code = 7016
   readonly name = "BaseVaultAuthorityBumpIncorrect"
   readonly msg = "BaseVaultAuthorityBumpIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6016: BaseVaultAuthorityBumpIncorrect")
+    super("7016: BaseVaultAuthorityBumpIncorrect")
   }
 }
 
 export class TokenMintIncorrect extends Error {
-  static readonly code = 6017
-  readonly code = 6017
+  static readonly code = 7017
+  readonly code = 7017
   readonly name = "TokenMintIncorrect"
   readonly msg = "TokenMintIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6017: TokenMintIncorrect")
+    super("7017: TokenMintIncorrect")
   }
 }
 
 export class TokenMintDecimalsIncorrect extends Error {
-  static readonly code = 6018
-  readonly code = 6018
+  static readonly code = 7018
+  readonly code = 7018
   readonly name = "TokenMintDecimalsIncorrect"
   readonly msg = "TokenMintDecimalsIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6018: TokenMintDecimalsIncorrect")
+    super("7018: TokenMintDecimalsIncorrect")
   }
 }
 
 export class TokenVaultIncorrect extends Error {
-  static readonly code = 6019
-  readonly code = 6019
+  static readonly code = 7019
+  readonly code = 7019
   readonly name = "TokenVaultIncorrect"
   readonly msg = "TokenVaultIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6019: TokenVaultIncorrect")
+    super("7019: TokenVaultIncorrect")
   }
 }
 
 export class SharesMintDecimalsIncorrect extends Error {
-  static readonly code = 6020
-  readonly code = 6020
+  static readonly code = 7020
+  readonly code = 7020
   readonly name = "SharesMintDecimalsIncorrect"
   readonly msg = "SharesMintDecimalsIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6020: SharesMintDecimalsIncorrect")
+    super("7020: SharesMintDecimalsIncorrect")
   }
 }
 
 export class SharesMintIncorrect extends Error {
-  static readonly code = 6021
-  readonly code = 6021
+  static readonly code = 7021
+  readonly code = 7021
   readonly name = "SharesMintIncorrect"
   readonly msg = "SharesMintIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6021: SharesMintIncorrect")
+    super("7021: SharesMintIncorrect")
   }
 }
 
-export class InitialAccountintIncorrect extends Error {
-  static readonly code = 6022
-  readonly code = 6022
-  readonly name = "InitialAccountintIncorrect"
-  readonly msg = "InitialAccountintIncorrect"
+export class InitialAccountingIncorrect extends Error {
+  static readonly code = 7022
+  readonly code = 7022
+  readonly name = "InitialAccountingIncorrect"
+  readonly msg = "InitialAccountingIncorrect"
 
   constructor(readonly logs?: string[]) {
-    super("6022: InitialAccountintIncorrect")
+    super("7022: InitialAccountingIncorrect")
   }
 }
 
 export class ReserveIsStale extends Error {
-  static readonly code = 6023
-  readonly code = 6023
+  static readonly code = 7023
+  readonly code = 7023
   readonly name = "ReserveIsStale"
   readonly msg = "Reserve is stale and must be refreshed before any operation"
 
   constructor(readonly logs?: string[]) {
-    super("6023: Reserve is stale and must be refreshed before any operation")
+    super("7023: Reserve is stale and must be refreshed before any operation")
   }
 }
 
 export class NotEnoughLiquidityDisinvestedToSendToUser extends Error {
-  static readonly code = 6024
-  readonly code = 6024
+  static readonly code = 7024
+  readonly code = 7024
   readonly name = "NotEnoughLiquidityDisinvestedToSendToUser"
   readonly msg = "Not enough liquidity disinvested to send to user"
 
   constructor(readonly logs?: string[]) {
-    super("6024: Not enough liquidity disinvested to send to user")
+    super("7024: Not enough liquidity disinvested to send to user")
   }
 }
 
 export class BPSValueTooBig extends Error {
-  static readonly code = 6025
-  readonly code = 6025
+  static readonly code = 7025
+  readonly code = 7025
   readonly name = "BPSValueTooBig"
   readonly msg = "BPS value is greater than 10000"
 
   constructor(readonly logs?: string[]) {
-    super("6025: BPS value is greater than 10000")
+    super("7025: BPS value is greater than 10000")
   }
 }
 
 export class DepositAmountBelowMinimum extends Error {
-  static readonly code = 6026
-  readonly code = 6026
+  static readonly code = 7026
+  readonly code = 7026
   readonly name = "DepositAmountBelowMinimum"
   readonly msg = "Deposited amount is below minimum"
 
   constructor(readonly logs?: string[]) {
-    super("6026: Deposited amount is below minimum")
+    super("7026: Deposited amount is below minimum")
   }
 }
 
 export class ReserveSpaceExhausted extends Error {
-  static readonly code = 6027
-  readonly code = 6027
+  static readonly code = 7027
+  readonly code = 7027
   readonly name = "ReserveSpaceExhausted"
   readonly msg = "Vault have no space for new reserves"
 
   constructor(readonly logs?: string[]) {
-    super("6027: Vault have no space for new reserves")
+    super("7027: Vault have no space for new reserves")
   }
 }
 
 export class CannotWithdrawFromEmptyVault extends Error {
-  static readonly code = 6028
-  readonly code = 6028
+  static readonly code = 7028
+  readonly code = 7028
   readonly name = "CannotWithdrawFromEmptyVault"
   readonly msg = "Cannot withdraw from empty vault"
 
   constructor(readonly logs?: string[]) {
-    super("6028: Cannot withdraw from empty vault")
+    super("7028: Cannot withdraw from empty vault")
   }
 }
 
 export class TokensDepositedAmountDoesNotMatch extends Error {
-  static readonly code = 6029
-  readonly code = 6029
+  static readonly code = 7029
+  readonly code = 7029
   readonly name = "TokensDepositedAmountDoesNotMatch"
   readonly msg = "TokensDepositedAmountDoesNotMatch"
 
   constructor(readonly logs?: string[]) {
-    super("6029: TokensDepositedAmountDoesNotMatch")
+    super("7029: TokensDepositedAmountDoesNotMatch")
   }
 }
 
 export class AmountToWithdrawDoesNotMatch extends Error {
-  static readonly code = 6030
-  readonly code = 6030
+  static readonly code = 7030
+  readonly code = 7030
   readonly name = "AmountToWithdrawDoesNotMatch"
   readonly msg = "Amount to withdraw does not match"
 
   constructor(readonly logs?: string[]) {
-    super("6030: Amount to withdraw does not match")
+    super("7030: Amount to withdraw does not match")
   }
 }
 
 export class LiquidityToWithdrawDoesNotMatch extends Error {
-  static readonly code = 6031
-  readonly code = 6031
+  static readonly code = 7031
+  readonly code = 7031
   readonly name = "LiquidityToWithdrawDoesNotMatch"
   readonly msg = "Liquidity to withdraw does not match"
 
   constructor(readonly logs?: string[]) {
-    super("6031: Liquidity to withdraw does not match")
+    super("7031: Liquidity to withdraw does not match")
   }
 }
 
 export class UserReceivedAmountDoesNotMatch extends Error {
-  static readonly code = 6032
-  readonly code = 6032
+  static readonly code = 7032
+  readonly code = 7032
   readonly name = "UserReceivedAmountDoesNotMatch"
   readonly msg = "User received amount does not match"
 
   constructor(readonly logs?: string[]) {
-    super("6032: User received amount does not match")
+    super("7032: User received amount does not match")
   }
 }
 
 export class SharesBurnedAmountDoesNotMatch extends Error {
-  static readonly code = 6033
-  readonly code = 6033
+  static readonly code = 7033
+  readonly code = 7033
   readonly name = "SharesBurnedAmountDoesNotMatch"
   readonly msg = "Shares burned amount does not match"
 
   constructor(readonly logs?: string[]) {
-    super("6033: Shares burned amount does not match")
+    super("7033: Shares burned amount does not match")
   }
 }
 
 export class DisinvestedLiquidityAmountDoesNotMatch extends Error {
-  static readonly code = 6034
-  readonly code = 6034
+  static readonly code = 7034
+  readonly code = 7034
   readonly name = "DisinvestedLiquidityAmountDoesNotMatch"
   readonly msg = "Disinvested liquidity amount does not match"
 
   constructor(readonly logs?: string[]) {
-    super("6034: Disinvested liquidity amount does not match")
+    super("7034: Disinvested liquidity amount does not match")
   }
 }
 
 export class SharesMintedAmountDoesNotMatch extends Error {
-  static readonly code = 6035
-  readonly code = 6035
+  static readonly code = 7035
+  readonly code = 7035
   readonly name = "SharesMintedAmountDoesNotMatch"
   readonly msg = "SharesMintedAmountDoesNotMatch"
 
   constructor(readonly logs?: string[]) {
-    super("6035: SharesMintedAmountDoesNotMatch")
+    super("7035: SharesMintedAmountDoesNotMatch")
   }
 }
 
 export class AUMDecreasedAfterInvest extends Error {
-  static readonly code = 6036
-  readonly code = 6036
+  static readonly code = 7036
+  readonly code = 7036
   readonly name = "AUMDecreasedAfterInvest"
   readonly msg = "AUM decreased after invest"
 
   constructor(readonly logs?: string[]) {
-    super("6036: AUM decreased after invest")
+    super("7036: AUM decreased after invest")
   }
 }
 
 export class AUMBelowPendingFees extends Error {
-  static readonly code = 6037
-  readonly code = 6037
+  static readonly code = 7037
+  readonly code = 7037
   readonly name = "AUMBelowPendingFees"
   readonly msg = "AUM is below pending fees"
 
   constructor(readonly logs?: string[]) {
-    super("6037: AUM is below pending fees")
+    super("7037: AUM is below pending fees")
+  }
+}
+
+export class DepositAmountsZeroShares extends Error {
+  static readonly code = 7038
+  readonly code = 7038
+  readonly name = "DepositAmountsZeroShares"
+  readonly msg = "Deposit amount results in 0 shares"
+
+  constructor(readonly logs?: string[]) {
+    super("7038: Deposit amount results in 0 shares")
+  }
+}
+
+export class WithdrawResultsInZeroShares extends Error {
+  static readonly code = 7039
+  readonly code = 7039
+  readonly name = "WithdrawResultsInZeroShares"
+  readonly msg = "Withdraw amount results in 0 shares"
+
+  constructor(readonly logs?: string[]) {
+    super("7039: Withdraw amount results in 0 shares")
+  }
+}
+
+export class CannotWithdrawZeroShares extends Error {
+  static readonly code = 7040
+  readonly code = 7040
+  readonly name = "CannotWithdrawZeroShares"
+  readonly msg = "Cannot withdraw zero shares"
+
+  constructor(readonly logs?: string[]) {
+    super("7040: Cannot withdraw zero shares")
+  }
+}
+
+export class ManagementFeeGreaterThanMaxAllowed extends Error {
+  static readonly code = 7041
+  readonly code = 7041
+  readonly name = "ManagementFeeGreaterThanMaxAllowed"
+  readonly msg = "Management fee is greater than maximum allowed"
+
+  constructor(readonly logs?: string[]) {
+    super("7041: Management fee is greater than maximum allowed")
   }
 }
 
 export function fromCode(code: number, logs?: string[]): CustomError | null {
   switch (code) {
-    case 6000:
+    case 7000:
       return new DepositAmountsZero(logs)
-    case 6001:
+    case 7001:
       return new SharesIssuedAmountDoesNotMatch(logs)
-    case 6002:
+    case 7002:
       return new MathOverflow(logs)
-    case 6003:
+    case 7003:
       return new IntegerOverflow(logs)
-    case 6004:
+    case 7004:
       return new WithdrawAmountBelowMinimum(logs)
-    case 6005:
+    case 7005:
       return new TooMuchLiquidityToWithdraw(logs)
-    case 6006:
+    case 7006:
       return new ReserveAlreadyExists(logs)
-    case 6007:
+    case 7007:
       return new ReserveNotPartOfAllocations(logs)
-    case 6008:
+    case 7008:
       return new CouldNotDeserializeAccountAsReserve(logs)
-    case 6009:
+    case 7009:
       return new ReserveNotProvidedInTheAccounts(logs)
-    case 6010:
+    case 7010:
       return new ReserveAccountAndKeyMismatch(logs)
-    case 6011:
+    case 7011:
       return new OutOfRangeOfReserveIndex(logs)
-    case 6012:
+    case 7012:
       return new CannotFindReserveInAllocations(logs)
-    case 6013:
+    case 7013:
       return new InvestAmountBelowMinimum(logs)
-    case 6014:
+    case 7014:
       return new AdminAuthorityIncorrect(logs)
-    case 6015:
+    case 7015:
       return new BaseVaultAuthorityIncorrect(logs)
-    case 6016:
+    case 7016:
       return new BaseVaultAuthorityBumpIncorrect(logs)
-    case 6017:
+    case 7017:
       return new TokenMintIncorrect(logs)
-    case 6018:
+    case 7018:
       return new TokenMintDecimalsIncorrect(logs)
-    case 6019:
+    case 7019:
       return new TokenVaultIncorrect(logs)
-    case 6020:
+    case 7020:
       return new SharesMintDecimalsIncorrect(logs)
-    case 6021:
+    case 7021:
       return new SharesMintIncorrect(logs)
-    case 6022:
-      return new InitialAccountintIncorrect(logs)
-    case 6023:
+    case 7022:
+      return new InitialAccountingIncorrect(logs)
+    case 7023:
       return new ReserveIsStale(logs)
-    case 6024:
+    case 7024:
       return new NotEnoughLiquidityDisinvestedToSendToUser(logs)
-    case 6025:
+    case 7025:
       return new BPSValueTooBig(logs)
-    case 6026:
+    case 7026:
       return new DepositAmountBelowMinimum(logs)
-    case 6027:
+    case 7027:
       return new ReserveSpaceExhausted(logs)
-    case 6028:
+    case 7028:
       return new CannotWithdrawFromEmptyVault(logs)
-    case 6029:
+    case 7029:
       return new TokensDepositedAmountDoesNotMatch(logs)
-    case 6030:
+    case 7030:
       return new AmountToWithdrawDoesNotMatch(logs)
-    case 6031:
+    case 7031:
       return new LiquidityToWithdrawDoesNotMatch(logs)
-    case 6032:
+    case 7032:
       return new UserReceivedAmountDoesNotMatch(logs)
-    case 6033:
+    case 7033:
       return new SharesBurnedAmountDoesNotMatch(logs)
-    case 6034:
+    case 7034:
       return new DisinvestedLiquidityAmountDoesNotMatch(logs)
-    case 6035:
+    case 7035:
       return new SharesMintedAmountDoesNotMatch(logs)
-    case 6036:
+    case 7036:
       return new AUMDecreasedAfterInvest(logs)
-    case 6037:
+    case 7037:
       return new AUMBelowPendingFees(logs)
+    case 7038:
+      return new DepositAmountsZeroShares(logs)
+    case 7039:
+      return new WithdrawResultsInZeroShares(logs)
+    case 7040:
+      return new CannotWithdrawZeroShares(logs)
+    case 7041:
+      return new ManagementFeeGreaterThanMaxAllowed(logs)
   }
 
   return null