3land_sdk 1.0.2 → 1.0.3

package/src/types/errors/anchor.ts

@@ -52,722 +52,725 @@ export type AnchorError =
   | AccountReallocExceedsLimit
   | AccountDuplicateReallocs
   | DeclaredProgramIdMismatch
-  | Deprecated
+  | Deprecated;
 
 export class InstructionMissing extends Error {
-  static readonly code = 100
-  readonly code = 100
-  readonly name = "InstructionMissing"
-  readonly msg = "8 byte instruction identifier not provided"
+  static readonly code = 100;
+  readonly code = 100;
+  override readonly name = "InstructionMissing";
+  readonly msg = "8 byte instruction identifier not provided";
 
   constructor(readonly logs?: string[]) {
-    super("100: 8 byte instruction identifier not provided")
+    super("100: 8 byte instruction identifier not provided");
   }
 }
 
 export class InstructionFallbackNotFound extends Error {
-  static readonly code = 101
-  readonly code = 101
-  readonly name = "InstructionFallbackNotFound"
-  readonly msg = "Fallback functions are not supported"
+  static readonly code = 101;
+  readonly code = 101;
+  override readonly name = "InstructionFallbackNotFound";
+  readonly msg = "Fallback functions are not supported";
 
   constructor(readonly logs?: string[]) {
-    super("101: Fallback functions are not supported")
+    super("101: Fallback functions are not supported");
   }
 }
 
 export class InstructionDidNotDeserialize extends Error {
-  static readonly code = 102
-  readonly code = 102
-  readonly name = "InstructionDidNotDeserialize"
-  readonly msg = "The program could not deserialize the given instruction"
+  static readonly code = 102;
+  readonly code = 102;
+  override readonly name = "InstructionDidNotDeserialize";
+  readonly msg = "The program could not deserialize the given instruction";
 
   constructor(readonly logs?: string[]) {
-    super("102: The program could not deserialize the given instruction")
+    super("102: The program could not deserialize the given instruction");
   }
 }
 
 export class InstructionDidNotSerialize extends Error {
-  static readonly code = 103
-  readonly code = 103
-  readonly name = "InstructionDidNotSerialize"
-  readonly msg = "The program could not serialize the given instruction"
+  static readonly code = 103;
+  readonly code = 103;
+  override readonly name = "InstructionDidNotSerialize";
+  readonly msg = "The program could not serialize the given instruction";
 
   constructor(readonly logs?: string[]) {
-    super("103: The program could not serialize the given instruction")
+    super("103: The program could not serialize the given instruction");
   }
 }
 
 export class IdlInstructionStub extends Error {
-  static readonly code = 1000
-  readonly code = 1000
-  readonly name = "IdlInstructionStub"
-  readonly msg = "The program was compiled without idl instructions"
+  static readonly code = 1000;
+  readonly code = 1000;
+  override readonly name = "IdlInstructionStub";
+  readonly msg = "The program was compiled without idl instructions";
 
   constructor(readonly logs?: string[]) {
-    super("1000: The program was compiled without idl instructions")
+    super("1000: The program was compiled without idl instructions");
   }
 }
 
 export class IdlInstructionInvalidProgram extends Error {
-  static readonly code = 1001
-  readonly code = 1001
-  readonly name = "IdlInstructionInvalidProgram"
+  static readonly code = 1001;
+  readonly code = 1001;
+  override readonly name = "IdlInstructionInvalidProgram";
   readonly msg =
-    "The transaction was given an invalid program for the IDL instruction"
+    "The transaction was given an invalid program for the IDL instruction";
 
   constructor(readonly logs?: string[]) {
     super(
       "1001: The transaction was given an invalid program for the IDL instruction"
-    )
+    );
   }
 }
 
 export class ConstraintMut extends Error {
-  static readonly code = 2000
-  readonly code = 2000
-  readonly name = "ConstraintMut"
-  readonly msg = "A mut constraint was violated"
+  static readonly code = 2000;
+  readonly code = 2000;
+  override readonly name = "ConstraintMut";
+  readonly msg = "A mut constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2000: A mut constraint was violated")
+    super("2000: A mut constraint was violated");
   }
 }
 
 export class ConstraintHasOne extends Error {
-  static readonly code = 2001
-  readonly code = 2001
-  readonly name = "ConstraintHasOne"
-  readonly msg = "A has one constraint was violated"
+  static readonly code = 2001;
+  readonly code = 2001;
+  override readonly name = "ConstraintHasOne";
+  readonly msg = "A has one constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2001: A has one constraint was violated")
+    super("2001: A has one constraint was violated");
   }
 }
 
 export class ConstraintSigner extends Error {
-  static readonly code = 2002
-  readonly code = 2002
-  readonly name = "ConstraintSigner"
-  readonly msg = "A signer constraint was violated"
+  static readonly code = 2002;
+  readonly code = 2002;
+  override readonly name = "ConstraintSigner";
+  readonly msg = "A signer constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2002: A signer constraint was violated")
+    super("2002: A signer constraint was violated");
   }
 }
 
 export class ConstraintRaw extends Error {
-  static readonly code = 2003
-  readonly code = 2003
-  readonly name = "ConstraintRaw"
-  readonly msg = "A raw constraint was violated"
+  static readonly code = 2003;
+  readonly code = 2003;
+  override readonly name = "ConstraintRaw";
+  readonly msg = "A raw constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2003: A raw constraint was violated")
+    super("2003: A raw constraint was violated");
   }
 }
 
 export class ConstraintOwner extends Error {
-  static readonly code = 2004
-  readonly code = 2004
-  readonly name = "ConstraintOwner"
-  readonly msg = "An owner constraint was violated"
+  static readonly code = 2004;
+  readonly code = 2004;
+  override readonly name = "ConstraintOwner";
+  readonly msg = "An owner constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2004: An owner constraint was violated")
+    super("2004: An owner constraint was violated");
   }
 }
 
 export class ConstraintRentExempt extends Error {
-  static readonly code = 2005
-  readonly code = 2005
-  readonly name = "ConstraintRentExempt"
-  readonly msg = "A rent exemption constraint was violated"
+  static readonly code = 2005;
+  readonly code = 2005;
+  override readonly name = "ConstraintRentExempt";
+  readonly msg = "A rent exemption constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2005: A rent exemption constraint was violated")
+    super("2005: A rent exemption constraint was violated");
   }
 }
 
 export class ConstraintSeeds extends Error {
-  static readonly code = 2006
-  readonly code = 2006
-  readonly name = "ConstraintSeeds"
-  readonly msg = "A seeds constraint was violated"
+  static readonly code = 2006;
+  readonly code = 2006;
+  override readonly name = "ConstraintSeeds";
+  readonly msg = "A seeds constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2006: A seeds constraint was violated")
+    super("2006: A seeds constraint was violated");
   }
 }
 
 export class ConstraintExecutable extends Error {
-  static readonly code = 2007
-  readonly code = 2007
-  readonly name = "ConstraintExecutable"
-  readonly msg = "An executable constraint was violated"
+  static readonly code = 2007;
+  readonly code = 2007;
+  override readonly name = "ConstraintExecutable";
+  readonly msg = "An executable constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2007: An executable constraint was violated")
+    super("2007: An executable constraint was violated");
   }
 }
 
 export class ConstraintState extends Error {
-  static readonly code = 2008
-  readonly code = 2008
-  readonly name = "ConstraintState"
-  readonly msg = "Deprecated Error, feel free to replace with something else"
+  static readonly code = 2008;
+  readonly code = 2008;
+  override readonly name = "ConstraintState";
+  readonly msg = "Deprecated Error, feel free to replace with something else";
 
   constructor(readonly logs?: string[]) {
-    super("2008: Deprecated Error, feel free to replace with something else")
+    super("2008: Deprecated Error, feel free to replace with something else");
   }
 }
 
 export class ConstraintAssociated extends Error {
-  static readonly code = 2009
-  readonly code = 2009
-  readonly name = "ConstraintAssociated"
-  readonly msg = "An associated constraint was violated"
+  static readonly code = 2009;
+  readonly code = 2009;
+  override readonly name = "ConstraintAssociated";
+  readonly msg = "An associated constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2009: An associated constraint was violated")
+    super("2009: An associated constraint was violated");
   }
 }
 
 export class ConstraintAssociatedInit extends Error {
-  static readonly code = 2010
-  readonly code = 2010
-  readonly name = "ConstraintAssociatedInit"
-  readonly msg = "An associated init constraint was violated"
+  static readonly code = 2010;
+  readonly code = 2010;
+  override readonly name = "ConstraintAssociatedInit";
+  readonly msg = "An associated init constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2010: An associated init constraint was violated")
+    super("2010: An associated init constraint was violated");
   }
 }
 
 export class ConstraintClose extends Error {
-  static readonly code = 2011
-  readonly code = 2011
-  readonly name = "ConstraintClose"
-  readonly msg = "A close constraint was violated"
+  static readonly code = 2011;
+  readonly code = 2011;
+  override readonly name = "ConstraintClose";
+  readonly msg = "A close constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2011: A close constraint was violated")
+    super("2011: A close constraint was violated");
   }
 }
 
 export class ConstraintAddress extends Error {
-  static readonly code = 2012
-  readonly code = 2012
-  readonly name = "ConstraintAddress"
-  readonly msg = "An address constraint was violated"
+  static readonly code = 2012;
+  readonly code = 2012;
+  override readonly name = "ConstraintAddress";
+  readonly msg = "An address constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2012: An address constraint was violated")
+    super("2012: An address constraint was violated");
   }
 }
 
 export class ConstraintZero extends Error {
-  static readonly code = 2013
-  readonly code = 2013
-  readonly name = "ConstraintZero"
-  readonly msg = "Expected zero account discriminant"
+  static readonly code = 2013;
+  readonly code = 2013;
+  override readonly name = "ConstraintZero";
+  readonly msg = "Expected zero account discriminant";
 
   constructor(readonly logs?: string[]) {
-    super("2013: Expected zero account discriminant")
+    super("2013: Expected zero account discriminant");
   }
 }
 
 export class ConstraintTokenMint extends Error {
-  static readonly code = 2014
-  readonly code = 2014
-  readonly name = "ConstraintTokenMint"
-  readonly msg = "A token mint constraint was violated"
+  static readonly code = 2014;
+  readonly code = 2014;
+  override readonly name = "ConstraintTokenMint";
+  readonly msg = "A token mint constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2014: A token mint constraint was violated")
+    super("2014: A token mint constraint was violated");
   }
 }
 
 export class ConstraintTokenOwner extends Error {
-  static readonly code = 2015
-  readonly code = 2015
-  readonly name = "ConstraintTokenOwner"
-  readonly msg = "A token owner constraint was violated"
+  static readonly code = 2015;
+  readonly code = 2015;
+  override readonly name = "ConstraintTokenOwner";
+  readonly msg = "A token owner constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2015: A token owner constraint was violated")
+    super("2015: A token owner constraint was violated");
   }
 }
 
 export class ConstraintMintMintAuthority extends Error {
-  static readonly code = 2016
-  readonly code = 2016
-  readonly name = "ConstraintMintMintAuthority"
-  readonly msg = "A mint mint authority constraint was violated"
+  static readonly code = 2016;
+  readonly code = 2016;
+  override readonly name = "ConstraintMintMintAuthority";
+  readonly msg = "A mint mint authority constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2016: A mint mint authority constraint was violated")
+    super("2016: A mint mint authority constraint was violated");
   }
 }
 
 export class ConstraintMintFreezeAuthority extends Error {
-  static readonly code = 2017
-  readonly code = 2017
-  readonly name = "ConstraintMintFreezeAuthority"
-  readonly msg = "A mint freeze authority constraint was violated"
+  static readonly code = 2017;
+  readonly code = 2017;
+  override readonly name = "ConstraintMintFreezeAuthority";
+  readonly msg = "A mint freeze authority constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2017: A mint freeze authority constraint was violated")
+    super("2017: A mint freeze authority constraint was violated");
   }
 }
 
 export class ConstraintMintDecimals extends Error {
-  static readonly code = 2018
-  readonly code = 2018
-  readonly name = "ConstraintMintDecimals"
-  readonly msg = "A mint decimals constraint was violated"
+  static readonly code = 2018;
+  readonly code = 2018;
+  override readonly name = "ConstraintMintDecimals";
+  readonly msg = "A mint decimals constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2018: A mint decimals constraint was violated")
+    super("2018: A mint decimals constraint was violated");
   }
 }
 
 export class ConstraintSpace extends Error {
-  static readonly code = 2019
-  readonly code = 2019
-  readonly name = "ConstraintSpace"
-  readonly msg = "A space constraint was violated"
+  static readonly code = 2019;
+  readonly code = 2019;
+  override readonly name = "ConstraintSpace";
+  readonly msg = "A space constraint was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2019: A space constraint was violated")
+    super("2019: A space constraint was violated");
   }
 }
 
 export class ConstraintAccountIsNone extends Error {
-  static readonly code = 2020
-  readonly code = 2020
-  readonly name = "ConstraintAccountIsNone"
-  readonly msg = "A required account for the constraint is None"
+  static readonly code = 2020;
+  readonly code = 2020;
+  override readonly name = "ConstraintAccountIsNone";
+  readonly msg = "A required account for the constraint is None";
 
   constructor(readonly logs?: string[]) {
-    super("2020: A required account for the constraint is None")
+    super("2020: A required account for the constraint is None");
   }
 }
 
 export class RequireViolated extends Error {
-  static readonly code = 2500
-  readonly code = 2500
-  readonly name = "RequireViolated"
-  readonly msg = "A require expression was violated"
+  static readonly code = 2500;
+  readonly code = 2500;
+  override readonly name = "RequireViolated";
+  readonly msg = "A require expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2500: A require expression was violated")
+    super("2500: A require expression was violated");
   }
 }
 
 export class RequireEqViolated extends Error {
-  static readonly code = 2501
-  readonly code = 2501
-  readonly name = "RequireEqViolated"
-  readonly msg = "A require_eq expression was violated"
+  static readonly code = 2501;
+  readonly code = 2501;
+  override readonly name = "RequireEqViolated";
+  readonly msg = "A require_eq expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2501: A require_eq expression was violated")
+    super("2501: A require_eq expression was violated");
   }
 }
 
 export class RequireKeysEqViolated extends Error {
-  static readonly code = 2502
-  readonly code = 2502
-  readonly name = "RequireKeysEqViolated"
-  readonly msg = "A require_keys_eq expression was violated"
+  static readonly code = 2502;
+  readonly code = 2502;
+  override readonly name = "RequireKeysEqViolated";
+  readonly msg = "A require_keys_eq expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2502: A require_keys_eq expression was violated")
+    super("2502: A require_keys_eq expression was violated");
   }
 }
 
 export class RequireNeqViolated extends Error {
-  static readonly code = 2503
-  readonly code = 2503
-  readonly name = "RequireNeqViolated"
-  readonly msg = "A require_neq expression was violated"
+  static readonly code = 2503;
+  readonly code = 2503;
+  override readonly name = "RequireNeqViolated";
+  readonly msg = "A require_neq expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2503: A require_neq expression was violated")
+    super("2503: A require_neq expression was violated");
   }
 }
 
 export class RequireKeysNeqViolated extends Error {
-  static readonly code = 2504
-  readonly code = 2504
-  readonly name = "RequireKeysNeqViolated"
-  readonly msg = "A require_keys_neq expression was violated"
+  static readonly code = 2504;
+  readonly code = 2504;
+  override readonly name = "RequireKeysNeqViolated";
+  readonly msg = "A require_keys_neq expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2504: A require_keys_neq expression was violated")
+    super("2504: A require_keys_neq expression was violated");
   }
 }
 
 export class RequireGtViolated extends Error {
-  static readonly code = 2505
-  readonly code = 2505
-  readonly name = "RequireGtViolated"
-  readonly msg = "A require_gt expression was violated"
+  static readonly code = 2505;
+  readonly code = 2505;
+  override readonly name = "RequireGtViolated";
+  readonly msg = "A require_gt expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2505: A require_gt expression was violated")
+    super("2505: A require_gt expression was violated");
   }
 }
 
 export class RequireGteViolated extends Error {
-  static readonly code = 2506
-  readonly code = 2506
-  readonly name = "RequireGteViolated"
-  readonly msg = "A require_gte expression was violated"
+  static readonly code = 2506;
+  readonly code = 2506;
+  override readonly name = "RequireGteViolated";
+  readonly msg = "A require_gte expression was violated";
 
   constructor(readonly logs?: string[]) {
-    super("2506: A require_gte expression was violated")
+    super("2506: A require_gte expression was violated");
   }
 }
 
 export class AccountDiscriminatorAlreadySet extends Error {
-  static readonly code = 3000
-  readonly code = 3000
-  readonly name = "AccountDiscriminatorAlreadySet"
-  readonly msg = "The account discriminator was already set on this account"
+  static readonly code = 3000;
+  readonly code = 3000;
+  override readonly name = "AccountDiscriminatorAlreadySet";
+  readonly msg = "The account discriminator was already set on this account";
 
   constructor(readonly logs?: string[]) {
-    super("3000: The account discriminator was already set on this account")
+    super("3000: The account discriminator was already set on this account");
   }
 }
 
 export class AccountDiscriminatorNotFound extends Error {
-  static readonly code = 3001
-  readonly code = 3001
-  readonly name = "AccountDiscriminatorNotFound"
-  readonly msg = "No 8 byte discriminator was found on the account"
+  static readonly code = 3001;
+  readonly code = 3001;
+  override readonly name = "AccountDiscriminatorNotFound";
+  readonly msg = "No 8 byte discriminator was found on the account";
 
   constructor(readonly logs?: string[]) {
-    super("3001: No 8 byte discriminator was found on the account")
+    super("3001: No 8 byte discriminator was found on the account");
   }
 }
 
 export class AccountDiscriminatorMismatch extends Error {
-  static readonly code = 3002
-  readonly code = 3002
-  readonly name = "AccountDiscriminatorMismatch"
-  readonly msg = "8 byte discriminator did not match what was expected"
+  static readonly code = 3002;
+  readonly code = 3002;
+  override readonly name = "AccountDiscriminatorMismatch";
+  readonly msg = "8 byte discriminator did not match what was expected";
 
   constructor(readonly logs?: string[]) {
-    super("3002: 8 byte discriminator did not match what was expected")
+    super("3002: 8 byte discriminator did not match what was expected");
   }
 }
 
 export class AccountDidNotDeserialize extends Error {
-  static readonly code = 3003
-  readonly code = 3003
-  readonly name = "AccountDidNotDeserialize"
-  readonly msg = "Failed to deserialize the account"
+  static readonly code = 3003;
+  readonly code = 3003;
+  override readonly name = "AccountDidNotDeserialize";
+  readonly msg = "Failed to deserialize the account";
 
   constructor(readonly logs?: string[]) {
-    super("3003: Failed to deserialize the account")
+    super("3003: Failed to deserialize the account");
   }
 }
 
 export class AccountDidNotSerialize extends Error {
-  static readonly code = 3004
-  readonly code = 3004
-  readonly name = "AccountDidNotSerialize"
-  readonly msg = "Failed to serialize the account"
+  static readonly code = 3004;
+  readonly code = 3004;
+  override readonly name = "AccountDidNotSerialize";
+  readonly msg = "Failed to serialize the account";
 
   constructor(readonly logs?: string[]) {
-    super("3004: Failed to serialize the account")
+    super("3004: Failed to serialize the account");
   }
 }
 
 export class AccountNotEnoughKeys extends Error {
-  static readonly code = 3005
-  readonly code = 3005
-  readonly name = "AccountNotEnoughKeys"
-  readonly msg = "Not enough account keys given to the instruction"
+  static readonly code = 3005;
+  readonly code = 3005;
+  override readonly name = "AccountNotEnoughKeys";
+  readonly msg = "Not enough account keys given to the instruction";
 
   constructor(readonly logs?: string[]) {
-    super("3005: Not enough account keys given to the instruction")
+    super("3005: Not enough account keys given to the instruction");
   }
 }
 
 export class AccountNotMutable extends Error {
-  static readonly code = 3006
-  readonly code = 3006
-  readonly name = "AccountNotMutable"
-  readonly msg = "The given account is not mutable"
+  static readonly code = 3006;
+  readonly code = 3006;
+  override readonly name = "AccountNotMutable";
+  readonly msg = "The given account is not mutable";
 
   constructor(readonly logs?: string[]) {
-    super("3006: The given account is not mutable")
+    super("3006: The given account is not mutable");
   }
 }
 
 export class AccountOwnedByWrongProgram extends Error {
-  static readonly code = 3007
-  readonly code = 3007
-  readonly name = "AccountOwnedByWrongProgram"
+  static readonly code = 3007;
+  readonly code = 3007;
+  override readonly name = "AccountOwnedByWrongProgram";
   readonly msg =
-    "The given account is owned by a different program than expected"
+    "The given account is owned by a different program than expected";
 
   constructor(readonly logs?: string[]) {
     super(
       "3007: The given account is owned by a different program than expected"
-    )
+    );
   }
 }
 
 export class InvalidProgramId extends Error {
-  static readonly code = 3008
-  readonly code = 3008
-  readonly name = "InvalidProgramId"
-  readonly msg = "Program ID was not as expected"
+  static readonly code = 3008;
+  readonly code = 3008;
+  override readonly name = "InvalidProgramId";
+  readonly msg = "Program ID was not as expected";
 
   constructor(readonly logs?: string[]) {
-    super("3008: Program ID was not as expected")
+    super("3008: Program ID was not as expected");
   }
 }
 
 export class InvalidProgramExecutable extends Error {
-  static readonly code = 3009
-  readonly code = 3009
-  readonly name = "InvalidProgramExecutable"
-  readonly msg = "Program account is not executable"
+  static readonly code = 3009;
+  readonly code = 3009;
+  override readonly name = "InvalidProgramExecutable";
+  readonly msg = "Program account is not executable";
 
   constructor(readonly logs?: string[]) {
-    super("3009: Program account is not executable")
+    super("3009: Program account is not executable");
   }
 }
 
 export class AccountNotSigner extends Error {
-  static readonly code = 3010
-  readonly code = 3010
-  readonly name = "AccountNotSigner"
-  readonly msg = "The given account did not sign"
+  static readonly code = 3010;
+  readonly code = 3010;
+  override readonly name = "AccountNotSigner";
+  readonly msg = "The given account did not sign";
 
   constructor(readonly logs?: string[]) {
-    super("3010: The given account did not sign")
+    super("3010: The given account did not sign");
   }
 }
 
 export class AccountNotSystemOwned extends Error {
-  static readonly code = 3011
-  readonly code = 3011
-  readonly name = "AccountNotSystemOwned"
-  readonly msg = "The given account is not owned by the system program"
+  static readonly code = 3011;
+  readonly code = 3011;
+  override readonly name = "AccountNotSystemOwned";
+  readonly msg = "The given account is not owned by the system program";
 
   constructor(readonly logs?: string[]) {
-    super("3011: The given account is not owned by the system program")
+    super("3011: The given account is not owned by the system program");
   }
 }
 
 export class AccountNotInitialized extends Error {
-  static readonly code = 3012
-  readonly code = 3012
-  readonly name = "AccountNotInitialized"
-  readonly msg = "The program expected this account to be already initialized"
+  static readonly code = 3012;
+  readonly code = 3012;
+  override readonly name = "AccountNotInitialized";
+  readonly msg = "The program expected this account to be already initialized";
 
   constructor(readonly logs?: string[]) {
-    super("3012: The program expected this account to be already initialized")
+    super("3012: The program expected this account to be already initialized");
   }
 }
 
 export class AccountNotProgramData extends Error {
-  static readonly code = 3013
-  readonly code = 3013
-  readonly name = "AccountNotProgramData"
-  readonly msg = "The given account is not a program data account"
+  static readonly code = 3013;
+  readonly code = 3013;
+  override readonly name = "AccountNotProgramData";
+  readonly msg = "The given account is not a program data account";
 
   constructor(readonly logs?: string[]) {
-    super("3013: The given account is not a program data account")
+    super("3013: The given account is not a program data account");
   }
 }
 
 export class AccountNotAssociatedTokenAccount extends Error {
-  static readonly code = 3014
-  readonly code = 3014
-  readonly name = "AccountNotAssociatedTokenAccount"
-  readonly msg = "The given account is not the associated token account"
+  static readonly code = 3014;
+  readonly code = 3014;
+  override readonly name = "AccountNotAssociatedTokenAccount";
+  readonly msg = "The given account is not the associated token account";
 
   constructor(readonly logs?: string[]) {
-    super("3014: The given account is not the associated token account")
+    super("3014: The given account is not the associated token account");
   }
 }
 
 export class AccountSysvarMismatch extends Error {
-  static readonly code = 3015
-  readonly code = 3015
-  readonly name = "AccountSysvarMismatch"
-  readonly msg = "The given public key does not match the required sysvar"
+  static readonly code = 3015;
+  readonly code = 3015;
+  override readonly name = "AccountSysvarMismatch";
+  readonly msg = "The given public key does not match the required sysvar";
 
   constructor(readonly logs?: string[]) {
-    super("3015: The given public key does not match the required sysvar")
+    super("3015: The given public key does not match the required sysvar");
   }
 }
 
 export class AccountReallocExceedsLimit extends Error {
-  static readonly code = 3016
-  readonly code = 3016
-  readonly name = "AccountReallocExceedsLimit"
+  static readonly code = 3016;
+  readonly code = 3016;
+  override readonly name = "AccountReallocExceedsLimit";
   readonly msg =
-    "The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit"
+    "The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit";
 
   constructor(readonly logs?: string[]) {
     super(
       "3016: The account reallocation exceeds the MAX_PERMITTED_DATA_INCREASE limit"
-    )
+    );
   }
 }
 
 export class AccountDuplicateReallocs extends Error {
-  static readonly code = 3017
-  readonly code = 3017
-  readonly name = "AccountDuplicateReallocs"
-  readonly msg = "The account was duplicated for more than one reallocation"
+  static readonly code = 3017;
+  readonly code = 3017;
+  override readonly name = "AccountDuplicateReallocs";
+  readonly msg = "The account was duplicated for more than one reallocation";
 
   constructor(readonly logs?: string[]) {
-    super("3017: The account was duplicated for more than one reallocation")
+    super("3017: The account was duplicated for more than one reallocation");
   }
 }
 
 export class DeclaredProgramIdMismatch extends Error {
-  static readonly code = 4100
-  readonly code = 4100
-  readonly name = "DeclaredProgramIdMismatch"
-  readonly msg = "The declared program id does not match the actual program id"
+  static readonly code = 4100;
+  readonly code = 4100;
+  override readonly name = "DeclaredProgramIdMismatch";
+  readonly msg = "The declared program id does not match the actual program id";
 
   constructor(readonly logs?: string[]) {
-    super("4100: The declared program id does not match the actual program id")
+    super("4100: The declared program id does not match the actual program id");
   }
 }
 
 export class Deprecated extends Error {
-  static readonly code = 5000
-  readonly code = 5000
-  readonly name = "Deprecated"
-  readonly msg = "The API being used is deprecated and should no longer be used"
+  static readonly code = 5000;
+  readonly code = 5000;
+  override readonly name = "Deprecated";
+  readonly msg =
+    "The API being used is deprecated and should no longer be used";
 
   constructor(readonly logs?: string[]) {
-    super("5000: The API being used is deprecated and should no longer be used")
+    super(
+      "5000: The API being used is deprecated and should no longer be used"
+    );
   }
 }
 
 export function fromCode(code: number, logs?: string[]): AnchorError | null {
   switch (code) {
     case 100:
-      return new InstructionMissing(logs)
+      return new InstructionMissing(logs);
     case 101:
-      return new InstructionFallbackNotFound(logs)
+      return new InstructionFallbackNotFound(logs);
     case 102:
-      return new InstructionDidNotDeserialize(logs)
+      return new InstructionDidNotDeserialize(logs);
     case 103:
-      return new InstructionDidNotSerialize(logs)
+      return new InstructionDidNotSerialize(logs);
     case 1000:
-      return new IdlInstructionStub(logs)
+      return new IdlInstructionStub(logs);
     case 1001:
-      return new IdlInstructionInvalidProgram(logs)
+      return new IdlInstructionInvalidProgram(logs);
     case 2000:
-      return new ConstraintMut(logs)
+      return new ConstraintMut(logs);
     case 2001:
-      return new ConstraintHasOne(logs)
+      return new ConstraintHasOne(logs);
     case 2002:
-      return new ConstraintSigner(logs)
+      return new ConstraintSigner(logs);
     case 2003:
-      return new ConstraintRaw(logs)
+      return new ConstraintRaw(logs);
     case 2004:
-      return new ConstraintOwner(logs)
+      return new ConstraintOwner(logs);
     case 2005:
-      return new ConstraintRentExempt(logs)
+      return new ConstraintRentExempt(logs);
     case 2006:
-      return new ConstraintSeeds(logs)
+      return new ConstraintSeeds(logs);
     case 2007:
-      return new ConstraintExecutable(logs)
+      return new ConstraintExecutable(logs);
     case 2008:
-      return new ConstraintState(logs)
+      return new ConstraintState(logs);
     case 2009:
-      return new ConstraintAssociated(logs)
+      return new ConstraintAssociated(logs);
     case 2010:
-      return new ConstraintAssociatedInit(logs)
+      return new ConstraintAssociatedInit(logs);
     case 2011:
-      return new ConstraintClose(logs)
+      return new ConstraintClose(logs);
     case 2012:
-      return new ConstraintAddress(logs)
+      return new ConstraintAddress(logs);
     case 2013:
-      return new ConstraintZero(logs)
+      return new ConstraintZero(logs);
     case 2014:
-      return new ConstraintTokenMint(logs)
+      return new ConstraintTokenMint(logs);
     case 2015:
-      return new ConstraintTokenOwner(logs)
+      return new ConstraintTokenOwner(logs);
     case 2016:
-      return new ConstraintMintMintAuthority(logs)
+      return new ConstraintMintMintAuthority(logs);
     case 2017:
-      return new ConstraintMintFreezeAuthority(logs)
+      return new ConstraintMintFreezeAuthority(logs);
     case 2018:
-      return new ConstraintMintDecimals(logs)
+      return new ConstraintMintDecimals(logs);
     case 2019:
-      return new ConstraintSpace(logs)
+      return new ConstraintSpace(logs);
     case 2020:
-      return new ConstraintAccountIsNone(logs)
+      return new ConstraintAccountIsNone(logs);
     case 2500:
-      return new RequireViolated(logs)
+      return new RequireViolated(logs);
     case 2501:
-      return new RequireEqViolated(logs)
+      return new RequireEqViolated(logs);
     case 2502:
-      return new RequireKeysEqViolated(logs)
+      return new RequireKeysEqViolated(logs);
     case 2503:
-      return new RequireNeqViolated(logs)
+      return new RequireNeqViolated(logs);
     case 2504:
-      return new RequireKeysNeqViolated(logs)
+      return new RequireKeysNeqViolated(logs);
     case 2505:
-      return new RequireGtViolated(logs)
+      return new RequireGtViolated(logs);
     case 2506:
-      return new RequireGteViolated(logs)
+      return new RequireGteViolated(logs);
     case 3000:
-      return new AccountDiscriminatorAlreadySet(logs)
+      return new AccountDiscriminatorAlreadySet(logs);
     case 3001:
-      return new AccountDiscriminatorNotFound(logs)
+      return new AccountDiscriminatorNotFound(logs);
     case 3002:
-      return new AccountDiscriminatorMismatch(logs)
+      return new AccountDiscriminatorMismatch(logs);
     case 3003:
-      return new AccountDidNotDeserialize(logs)
+      return new AccountDidNotDeserialize(logs);
     case 3004:
-      return new AccountDidNotSerialize(logs)
+      return new AccountDidNotSerialize(logs);
     case 3005:
-      return new AccountNotEnoughKeys(logs)
+      return new AccountNotEnoughKeys(logs);
     case 3006:
-      return new AccountNotMutable(logs)
+      return new AccountNotMutable(logs);
     case 3007:
-      return new AccountOwnedByWrongProgram(logs)
+      return new AccountOwnedByWrongProgram(logs);
     case 3008:
-      return new InvalidProgramId(logs)
+      return new InvalidProgramId(logs);
     case 3009:
-      return new InvalidProgramExecutable(logs)
+      return new InvalidProgramExecutable(logs);
     case 3010:
-      return new AccountNotSigner(logs)
+      return new AccountNotSigner(logs);
     case 3011:
-      return new AccountNotSystemOwned(logs)
+      return new AccountNotSystemOwned(logs);
     case 3012:
-      return new AccountNotInitialized(logs)
+      return new AccountNotInitialized(logs);
     case 3013:
-      return new AccountNotProgramData(logs)
+      return new AccountNotProgramData(logs);
     case 3014:
-      return new AccountNotAssociatedTokenAccount(logs)
+      return new AccountNotAssociatedTokenAccount(logs);
     case 3015:
-      return new AccountSysvarMismatch(logs)
+      return new AccountSysvarMismatch(logs);
     case 3016:
-      return new AccountReallocExceedsLimit(logs)
+      return new AccountReallocExceedsLimit(logs);
     case 3017:
-      return new AccountDuplicateReallocs(logs)
+      return new AccountDuplicateReallocs(logs);
     case 4100:
-      return new DeclaredProgramIdMismatch(logs)
+      return new DeclaredProgramIdMismatch(logs);
     case 5000:
-      return new Deprecated(logs)
+      return new Deprecated(logs);
   }
 
-  return null
+  return null;
 }