"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.UnsupportedTokenError = exports.InvalidKey = exports.NotSupported = exports.NotImplementedError = exports.InvalidSignatureError = exports.InvalidParameterValueError = exports.InvalidTransactionError = exports.ExtendTransactionError = exports.UtilsError = exports.BuildTransactionError = exports.SigningError = exports.ParseTransactionError = exports.ExtendableError = void 0;
/**
 * This base class ensures that our stack trace is captured properly but also that we have classes of errors
 * that can be found in a switch.
 */
var ExtendableError = /** @class */ (function (_super) {
    __extends(ExtendableError, _super);
    function ExtendableError(message) {
        var _this = _super.call(this, message) || this;
        _this.name = _this.constructor.name;
        if (typeof Error.captureStackTrace === 'function') {
            Error.captureStackTrace(_this, _this.constructor);
        }
        else {
            _this.stack = new Error(message).stack;
        }
        return _this;
    }
    return ExtendableError;
}(Error));
exports.ExtendableError = ExtendableError;
var ParseTransactionError = /** @class */ (function (_super) {
    __extends(ParseTransactionError, _super);
    function ParseTransactionError(message) {
        return _super.call(this, message) || this;
    }
    return ParseTransactionError;
}(ExtendableError));
exports.ParseTransactionError = ParseTransactionError;
var SigningError = /** @class */ (function (_super) {
    __extends(SigningError, _super);
    function SigningError(message) {
        return _super.call(this, message) || this;
    }
    return SigningError;
}(ExtendableError));
exports.SigningError = SigningError;
var BuildTransactionError = /** @class */ (function (_super) {
    __extends(BuildTransactionError, _super);
    function BuildTransactionError(message) {
        return _super.call(this, message) || this;
    }
    return BuildTransactionError;
}(ExtendableError));
exports.BuildTransactionError = BuildTransactionError;
var UtilsError = /** @class */ (function (_super) {
    __extends(UtilsError, _super);
    function UtilsError(message) {
        return _super.call(this, message) || this;
    }
    return UtilsError;
}(ExtendableError));
exports.UtilsError = UtilsError;
var ExtendTransactionError = /** @class */ (function (_super) {
    __extends(ExtendTransactionError, _super);
    function ExtendTransactionError(message) {
        return _super.call(this, message) || this;
    }
    return ExtendTransactionError;
}(ExtendableError));
exports.ExtendTransactionError = ExtendTransactionError;
/**
 * Error for invalid transaction status
 */
var InvalidTransactionError = /** @class */ (function (_super) {
    __extends(InvalidTransactionError, _super);
    function InvalidTransactionError(message) {
        return _super.call(this, message) || this;
    }
    return InvalidTransactionError;
}(ExtendableError));
exports.InvalidTransactionError = InvalidTransactionError;
/**
 * Error for an invalid value for a contract method parameter
 */
var InvalidParameterValueError = /** @class */ (function (_super) {
    __extends(InvalidParameterValueError, _super);
    function InvalidParameterValueError(message) {
        return _super.call(this, message) || this;
    }
    return InvalidParameterValueError;
}(ExtendableError));
exports.InvalidParameterValueError = InvalidParameterValueError;
/**
 * Error produced by not truthy signature values
 */
var InvalidSignatureError = /** @class */ (function (_super) {
    __extends(InvalidSignatureError, _super);
    function InvalidSignatureError(message) {
        return _super.call(this, message) || this;
    }
    return InvalidSignatureError;
}(ExtendableError));
exports.InvalidSignatureError = InvalidSignatureError;
/**
 * Error for an method that needs to be implemented
 */
var NotImplementedError = /** @class */ (function (_super) {
    __extends(NotImplementedError, _super);
    function NotImplementedError(message) {
        return _super.call(this, message) || this;
    }
    return NotImplementedError;
}(ExtendableError));
exports.NotImplementedError = NotImplementedError;
/**
 * Error for not supported features
 */
var NotSupported = /** @class */ (function (_super) {
    __extends(NotSupported, _super);
    function NotSupported(message) {
        return _super.call(this, message) || this;
    }
    return NotSupported;
}(ExtendableError));
exports.NotSupported = NotSupported;
/**
 * Error for invalid seed, public, or private keys
 */
var InvalidKey = /** @class */ (function (_super) {
    __extends(InvalidKey, _super);
    function InvalidKey(message) {
        return _super.call(this, message) || this;
    }
    return InvalidKey;
}(ExtendableError));
exports.InvalidKey = InvalidKey;
/**
 * Error for invalid mint/token
 */
var UnsupportedTokenError = /** @class */ (function (_super) {
    __extends(UnsupportedTokenError, _super);
    function UnsupportedTokenError(message) {
        return _super.call(this, message) || this;
    }
    return UnsupportedTokenError;
}(ExtendableError));
exports.UnsupportedTokenError = UnsupportedTokenError;
//# sourceMappingURL=data:application/json;base64, 