3land_sdk 1.0.0 → 1.0.2

package/dist/types/errors/anchor.js

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

package/dist/types/errors/index.d.ts

@@ -0,0 +1,4 @@
+import { PublicKey } from "@solana/web3.js";
+import * as anchor from "./anchor";
+export declare function fromCode(code: number, logs?: string[]): anchor.AnchorError | null;
+export declare function fromTxError(err: unknown, programId?: PublicKey): anchor.AnchorError | null;

package/dist/types/errors/index.js

@@ -0,0 +1,39 @@
+import { PROGRAM_ID } from "../programId";
+import * as anchor from "./anchor";
+export function fromCode(code, logs) {
+    return anchor.fromCode(code, logs);
+}
+function hasOwnProperty(obj, prop) {
+    return Object.hasOwnProperty.call(obj, prop);
+}
+const errorRe = /Program (\w+) failed: custom program error: (\w+)/;
+export function fromTxError(err, programId = PROGRAM_ID) {
+    if (typeof err !== "object" ||
+        err === null ||
+        !hasOwnProperty(err, "logs") ||
+        !Array.isArray(err.logs)) {
+        return null;
+    }
+    let firstMatch = null;
+    for (const logLine of err.logs) {
+        firstMatch = errorRe.exec(logLine);
+        if (firstMatch !== null) {
+            break;
+        }
+    }
+    if (firstMatch === null) {
+        return null;
+    }
+    const [programIdRaw, codeRaw] = firstMatch.slice(1);
+    if (programIdRaw !== programId.toString()) {
+        return null;
+    }
+    let errorCode;
+    try {
+        errorCode = parseInt(codeRaw, 16);
+    }
+    catch (parseErr) {
+        return null;
+    }
+    return fromCode(errorCode, err.logs);
+}