ox/dist/core/internal/human-readable/errors.js

Ethereum Standard Library

import { BaseError } from '../../Errors.js';
export class InvalidAbiItemError extends BaseError {
    name = 'AbiItem.InvalidAbiItemError';
    constructor({ signature }) {
        super('Failed to parse ABI item.', {
            details: `parseAbiItem(${JSON.stringify(signature, null, 2)})`,
            docsPath: '/api/AbiItem/from',
        });
    }
}
export class UnknownTypeError extends BaseError {
    name = 'HumanReadableAbi.UnknownTypeError';
    constructor({ type }) {
        super('Unknown type.', {
            metaMessages: [
                `Type "${type}" is not a valid ABI type. Perhaps you forgot to include a struct signature?`,
            ],
        });
    }
}
export class UnknownSolidityTypeError extends BaseError {
    name = 'HumanReadableAbi.UnknownSolidityTypeError';
    constructor({ type }) {
        super('Unknown type.', {
            metaMessages: [`Type "${type}" is not a valid ABI type.`],
        });
    }
}
export class InvalidAbiParameterError extends BaseError {
    name = 'AbiParameter.InvalidAbiParameterError';
    constructor({ param }) {
        super('Failed to parse ABI parameter.', {
            details: `parseAbiParameter(${JSON.stringify(param, null, 2)})`,
            docsPath: '/api/AbiParameter/from',
        });
    }
}
export class InvalidAbiParametersError extends BaseError {
    name = 'AbiParameters.InvalidAbiParametersError';
    constructor({ params }) {
        super('Failed to parse ABI parameters.', {
            details: `parseAbiParameters(${JSON.stringify(params, null, 2)})`,
            docsPath: '/api/AbiParameters/from',
        });
    }
}
export class InvalidParameterError extends BaseError {
    name = 'HumanReadableAbi.InvalidParameterError';
    constructor({ param }) {
        super('Invalid ABI parameter.', {
            details: param,
        });
    }
}
export class SolidityProtectedKeywordError extends BaseError {
    name = 'HumanReadableAbi.SolidityProtectedKeywordError';
    constructor({ param, name }) {
        super('Invalid ABI parameter.', {
            details: param,
            metaMessages: [
                `"${name}" is a protected Solidity keyword. More info: https://docs.soliditylang.org/en/latest/cheatsheet.html`,
            ],
        });
    }
}
export class InvalidModifierError extends BaseError {
    name = 'HumanReadableAbi.InvalidModifierError';
    constructor({ param, type, modifier, }) {
        super('Invalid ABI parameter.', {
            details: param,
            metaMessages: [
                `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ''}.`,
            ],
        });
    }
}
export class InvalidFunctionModifierError extends BaseError {
    name = 'HumanReadableAbi.InvalidFunctionModifierError';
    constructor({ param, type, modifier, }) {
        super('Invalid ABI parameter.', {
            details: param,
            metaMessages: [
                `Modifier "${modifier}" not allowed${type ? ` in "${type}" type` : ''}.`,
                `Data location can only be specified for array, struct, or mapping types, but "${modifier}" was given.`,
            ],
        });
    }
}
export class InvalidAbiTypeParameterError extends BaseError {
    name = 'HumanReadableAbi.InvalidAbiTypeParameterError';
    constructor({ abiParameter, }) {
        super('Invalid ABI parameter.', {
            details: JSON.stringify(abiParameter, null, 2),
            metaMessages: ['ABI parameter type is invalid.'],
        });
    }
}
export class InvalidSignatureError extends BaseError {
    name = 'Abi.InvalidSignatureError';
    constructor({ signature, type, }) {
        super(`Invalid ${type} signature.`, {
            details: signature,
        });
    }
}
export class UnknownSignatureError extends BaseError {
    name = 'Abi.UnknownSignatureError';
    constructor({ signature }) {
        super('Unknown signature.', {
            details: signature,
        });
    }
}
export class InvalidStructSignatureError extends BaseError {
    name = 'Abi.InvalidStructSignatureError';
    constructor({ signature }) {
        super('Invalid struct signature.', {
            details: signature,
            metaMessages: ['No properties exist.'],
        });
    }
}
export class InvalidParenthesisError extends BaseError {
    name = 'HumanReadableAbi.InvalidParenthesisError';
    constructor({ current, depth }) {
        super('Unbalanced parentheses.', {
            metaMessages: [
                `"${current.trim()}" has too many ${depth > 0 ? 'opening' : 'closing'} parentheses.`,
            ],
            details: `Depth "${depth}"`,
        });
    }
}
export class CircularReferenceError extends BaseError {
    name = 'Abi.CircularReferenceError';
    constructor({ type }) {
        super('Circular reference detected.', {
            metaMessages: [`Struct "${type}" is a circular reference.`],
        });
    }
}
//# sourceMappingURL=errors.js.map