// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;

import "../../utils/introspection/IERC165.sol";

/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721
     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must
     * understand this adds an external call which potentially creates a reentrancy vulnerability.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.21;

interface IMintWithAssets {
    function mintWithAssets(address to, uint64[] memory assetIds) external;

    function nestMintWithAssets(
        address parentContract,
        uint256 destinationId,
        uint64[] memory assetIds
    ) external;
}

// SPDX-License-Identifier: Apache-2.0
pragma solidity ^0.8.21;

import "@openzeppelin/contracts/token/ERC721/IERC721.sol";
import "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import "@rmrk-team/evm-contracts/contracts/RMRK/access/Ownable.sol";
import "./interfaces/IMintWithAssets.sol";

error AlreadyMigrated();
error ItemNeverConfigured();
error ItemPreviouslyConfigured();
error MigrationNotAvailable();
error NothingToMigrate();
error NotMapper();

contract Migrator is Ownable, IERC721Receiver {
    event KanariaMigrated(uint256 indexed kanariaId, address indexed owner);

    event ItemMigrated(
        uint256 indexed kanariaId,
        address indexed owner,
        address contractAddress,
        uint64[] itemsAssetIds
    );

    event EvmToSubstrateAddressSet(
        address indexed evmAddress,
        string indexed substrateAddress
    );

    event EvmToSubstrateAddressReset(
        address indexed evmAddress,
        string indexed substrateAddress
    );

    struct ItemWithAssets {
        address contractAddress;
        uint64[] assetIds;
    }

    struct ItemWithAssetsAndId {
        address contractAddress;
        uint64[] assetIds;
        uint256 itemId;
    }

    struct ItemInputConfig {
        address owner;
        ItemWithAssetsAndId[] itemsWithAssets;
    }

    struct KanariaMigrationConfig {
        uint256 kanariaId;
        address owner;
        ItemWithAssets[] items;
    }

    mapping(uint256 kanariaId => uint256 migrated) // 1 = true, 0 = false
        private _kanariaMigrationState;
    mapping(uint256 kanariaId => address owner) private _kanariaOwners;
    mapping(uint256 kanariaId => ItemWithAssets[] items)
        private _kanariaItemsWithAssets;
    mapping(address owner => ItemWithAssetsAndId[])
        private _unnestedItemsMigrationConfig;
    mapping(uint256 itemId => uint256 configured) // 1 = true, 0 = false
        private _unnestedItemsConfiguredIds;

    address private _kanaria;
    address private _kanariaHolder;

    address private _mapper;
    mapping(address evm => string substrate) private _evmToSubstrate;
    mapping(string substrate => address evm) private _substrateToEvm;

    constructor(address kanaria) {
        _kanaria = kanaria;
    }

    function onERC721Received(
        address,
        address,
        uint256,
        bytes calldata
    ) external pure override returns (bytes4) {
        return this.onERC721Received.selector;
    }

    function configureKanariaMigrations(
        KanariaMigrationConfig[] calldata kanariaMigrationConfigs
    ) public onlyOwnerOrContributor {
        uint256 length = kanariaMigrationConfigs.length;

        for (uint256 i; i < length; ) {
            KanariaMigrationConfig memory config = kanariaMigrationConfigs[i];
            uint256 kanariaId = config.kanariaId;
            if (_kanariaMigrationState[kanariaId] == 1)
                revert AlreadyMigrated();

            _kanariaOwners[kanariaId] = config.owner;
            ItemWithAssets[] memory items = config.items;
            delete _kanariaItemsWithAssets[kanariaId];

            uint256 itemsLength = items.length;
            for (uint256 j; j < itemsLength; ) {
                _kanariaItemsWithAssets[kanariaId].push(items[j]);
                unchecked {
                    ++j;
                }
            }

            unchecked {
                ++i;
            }
        }
    }

    function configureItemMigrations(
        ItemInputConfig[] calldata itemsConfig
    ) public onlyOwnerOrContributor {
        uint256 length = itemsConfig.length;

        for (uint256 i; i < length; ) {
            ItemWithAssetsAndId[] memory items = itemsConfig[i].itemsWithAssets;
            address owner = itemsConfig[i].owner;

            for (uint256 j; j < items.length; ) {
                ItemWithAssetsAndId memory item = items[j];
                uint256 itemId = item.itemId;
                if (_unnestedItemsConfiguredIds[itemId] == 1)
                    revert ItemPreviouslyConfigured();
                _unnestedItemsConfiguredIds[itemId] = 1;
                _unnestedItemsMigrationConfig[owner].push(item);
                unchecked {
                    ++j;
                }
            }
            unchecked {
                ++i;
            }
        }
    }

    function updateItemConfiguration(
        address owner,
        uint256 itemId,
        address contractAddress,
        uint64[] memory assetIds
    ) public onlyOwnerOrContributor {
        if (_unnestedItemsConfiguredIds[itemId] == 0)
            revert ItemNeverConfigured();
        uint256 length = _unnestedItemsMigrationConfig[owner].length;
        bool found;

        for (uint256 i; i < length; ) {
            if (_unnestedItemsMigrationConfig[owner][i].itemId == itemId) {
                found = true;
                _unnestedItemsMigrationConfig[owner][i] = ItemWithAssetsAndId({
                    contractAddress: contractAddress,
                    assetIds: assetIds,
                    itemId: itemId
                });
                break;
            }
            unchecked {
                ++i;
            }
        }
        if (!found) revert AlreadyMigrated();
    }

    function getConfigForKanarias(
        uint256[] memory kanariaIds
    ) public view returns (KanariaMigrationConfig[] memory) {
        KanariaMigrationConfig[] memory configs = new KanariaMigrationConfig[](
            kanariaIds.length
        );
        for (uint256 i; i < kanariaIds.length; ) {
            configs[i] = KanariaMigrationConfig({
                kanariaId: kanariaIds[i],
                owner: _kanariaOwners[kanariaIds[i]],
                items: _kanariaItemsWithAssets[kanariaIds[i]]
            });
            unchecked {
                ++i;
            }
        }
        return configs;
    }

    function getMigratedStateForKanarias(
        uint256[] memory kanariaIds
    ) public view returns (bool[] memory) {
        bool[] memory states = new bool[](kanariaIds.length);
        for (uint256 i; i < kanariaIds.length; ) {
            states[i] = _kanariaMigrationState[kanariaIds[i]] == 1;
            unchecked {
                ++i;
            }
        }
        return states;
    }

    function getConfigForItems(
        address[] memory owners
    ) public view returns (ItemWithAssetsAndId[][] memory configs) {
        uint256 length = owners.length;
        configs = new ItemWithAssetsAndId[][](length);
        for (uint256 i; i < length; ) {
            configs[i] = _unnestedItemsMigrationConfig[owners[i]];
            unchecked {
                ++i;
            }
        }
        return configs;
    }

    function getTotalItemsToMigrateForOwners(
        address[] memory owners
    ) public view returns (uint256[] memory total) {
        uint256 length = owners.length;
        total = new uint256[](length);
        for (uint256 i; i < length; ) {
            total[i] = _unnestedItemsMigrationConfig[owners[i]].length;
            unchecked {
                ++i;
            }
        }
    }

    function migrateKanarias(uint256[] calldata kanariaIds) public {
        for (uint256 i; i < kanariaIds.length; ) {
            _migrateKanaria(kanariaIds[i]);
            unchecked {
                ++i;
            }
        }
    }

    function _migrateKanaria(uint256 kanariaId) private {
        address owner = _kanariaOwners[kanariaId];
        ItemWithAssets[] memory items = _kanariaItemsWithAssets[kanariaId];

        if (owner == address(0)) revert MigrationNotAvailable();
        if (_kanariaMigrationState[kanariaId] == 1) revert AlreadyMigrated();
        _kanariaMigrationState[kanariaId] = 1;

        // Items
        for (uint256 i; i < items.length; ) {
            ItemWithAssets memory item = items[i];
            IMintWithAssets(item.contractAddress).nestMintWithAssets(
                _kanaria,
                kanariaId,
                item.assetIds
            );
            emit ItemMigrated(
                kanariaId,
                owner,
                item.contractAddress,
                item.assetIds
            );
            unchecked {
                ++i;
            }
        }

        // Kanaria
        IERC721(_kanaria).transferFrom(_kanariaHolder, owner, kanariaId);
        emit KanariaMigrated(kanariaId, owner);
    }

    function migrateItems(address owner, uint256 amount) public {
        uint256 length = _unnestedItemsMigrationConfig[owner].length;
        if (length == 0) revert NothingToMigrate();
        amount = amount > length ? length : amount;

        for (uint256 i; i < amount; ) {
            uint256 lastIndex = length - i - 1;
            ItemWithAssetsAndId memory item = _unnestedItemsMigrationConfig[
                owner
            ][lastIndex];
            _unnestedItemsMigrationConfig[owner].pop();
            IMintWithAssets(item.contractAddress).mintWithAssets(
                owner,
                item.assetIds
            );
            emit ItemMigrated(0, owner, item.contractAddress, item.assetIds);
            unchecked {
                ++i;
            }
        }
    }

    function getKanariaAddress() public view returns (address) {
        return _kanaria;
    }

    function getKanariaHolderAddress() public view returns (address) {
        return _kanariaHolder;
    }

    function setKanariaHolderAddress(
        address kanariaHolder
    ) external onlyOwnerOrContributor {
        _kanariaHolder = kanariaHolder;
    }

    function getMapperAddress() public view returns (address) {
        return _mapper;
    }

    function setMapperAddress(address mapper) external onlyOwnerOrContributor {
        _mapper = mapper;
    }

    function setSubstrateAddress(
        address evm,
        string memory substrateAddress
    ) external {
        if (msg.sender != _mapper) revert NotMapper();
        _evmToSubstrate[evm] = substrateAddress;
        _substrateToEvm[substrateAddress] = evm;
        emit EvmToSubstrateAddressSet(evm, substrateAddress);
    }

    function resetSubstrateAddress(
        address evm,
        string memory substrateAddress
    ) external {
        if (msg.sender != _mapper) revert NotMapper();
        delete _evmToSubstrate[evm];
        delete _substrateToEvm[substrateAddress];
        emit EvmToSubstrateAddressReset(evm, substrateAddress);
    }

    function batchGetSubstrateAddresses(
        address[] memory evmAddress
    ) public view returns (string[] memory substrateAddresses) {
        substrateAddresses = new string[](evmAddress.length);
        for (uint256 i; i < evmAddress.length; ) {
            substrateAddresses[i] = _evmToSubstrate[evmAddress[i]];
            unchecked {
                ++i;
            }
        }
    }

    function batchGetEvmAddresses(
        string[] memory substrateAddress
    ) public view returns (address[] memory evmAddresses) {
        evmAddresses = new address[](substrateAddress.length);
        for (uint256 i; i < substrateAddress.length; ) {
            evmAddresses[i] = _substrateToEvm[substrateAddress[i]];
            unchecked {
                ++i;
            }
        }
    }
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.21;

import "@openzeppelin/contracts/utils/Context.sol";
import "../library/RMRKErrors.sol";

/**
 * @title Ownable
 * @author RMRK team
 * @notice A minimal ownable smart contractf or owner and contributors.
 * @dev This smart contract is based on "openzeppelin's access/Ownable.sol".
 */
contract Ownable is Context {
    address private _owner;
    mapping(address => uint256) private _contributors;

    /**
     * @notice Used to anounce the transfer of ownership.
     * @param previousOwner Address of the account that transferred their ownership role
     * @param newOwner Address of the account receiving the ownership role
     */
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    /**
     * @notice Event that signifies that an address was granted contributor role or that the permission has been
     *  revoked.
     * @dev This can only be triggered by a current owner, so there is no need to include that information in the event.
     * @param contributor Address of the account that had contributor role status updated
     * @param isContributor A boolean value signifying whether the role has been granted (`true`) or revoked (`false`)
     */
    event ContributorUpdate(address indexed contributor, bool isContributor);

    /**
     * @dev Reverts if called by any account other than the owner or an approved contributor.
     */
    modifier onlyOwnerOrContributor() {
        _onlyOwnerOrContributor();
        _;
    }

    /**
     * @dev Reverts if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _onlyOwner();
        _;
    }

    /**
     * @dev Initializes the contract by setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @notice Returns the address of the current owner.
     * @return Address of the current owner
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @notice Leaves the contract without owner. Functions using the `onlyOwner` modifier will be disabled.
     * @dev Can only be called by the current owner.
     * @dev Renouncing ownership will leave the contract without an owner, thereby removing any functionality that is
     *  only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @notice Transfers ownership of the contract to a new owner.
     * @dev Can only be called by the current owner.
     * @param newOwner Address of the new owner's account
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) revert RMRKNewOwnerIsZeroAddress();
        _transferOwnership(newOwner);
    }

    /**
     * @notice Transfers ownership of the contract to a new owner.
     * @dev Internal function without access restriction.
     * @dev Emits ***OwnershipTransferred*** event.
     * @param newOwner Address of the new owner's account
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @notice Adds or removes a contributor to the smart contract.
     * @dev Can only be called by the owner.
     * @dev Emits ***ContributorUpdate*** event.
     * @param contributor Address of the contributor's account
     * @param grantRole A boolean value signifying whether the contributor role is being granted (`true`) or revoked
     *  (`false`)
     */
    function manageContributor(
        address contributor,
        bool grantRole
    ) external onlyOwner {
        if (contributor == address(0)) revert RMRKNewContributorIsZeroAddress();
        grantRole
            ? _contributors[contributor] = 1
            : _contributors[contributor] = 0;
        emit ContributorUpdate(contributor, grantRole);
    }

    /**
     * @notice Used to check if the address is one of the contributors.
     * @param contributor Address of the contributor whose status we are checking
     * @return Boolean value indicating whether the address is a contributor or not
     */
    function isContributor(address contributor) public view returns (bool) {
        return _contributors[contributor] == 1;
    }

    /**
     * @notice Used to verify that the caller is either the owner or a contributor.
     * @dev If the caller is not the owner or a contributor, the execution will be reverted.
     */
    function _onlyOwnerOrContributor() private view {
        if (owner() != _msgSender() && !isContributor(_msgSender()))
            revert RMRKNotOwnerOrContributor();
    }

    /**
     * @notice Used to verify that the caller is the owner.
     * @dev If the caller is not the owner, the execution will be reverted.
     */
    function _onlyOwner() private view {
        if (owner() != _msgSender()) revert RMRKNotOwner();
    }
}

// SPDX-License-Identifier: Apache-2.0

pragma solidity ^0.8.21;

/// @title RMRKErrors
/// @author RMRK team
/// @notice A collection of errors used in the RMRK suite
/// @dev Errors are kept in a centralised file in order to provide a central point of reference and to avoid error
///  naming collisions due to inheritance

/// Attempting to grant the token to 0x0 address
error ERC721AddressZeroIsNotaValidOwner();
/// Attempting to grant approval to the current owner of the token
error ERC721ApprovalToCurrentOwner();
/// Attempting to grant approval when not being owner or approved for all should not be permitted
error ERC721ApproveCallerIsNotOwnerNorApprovedForAll();
/// Attempting to get approvals for a token owned by 0x0 (considered non-existent)
error ERC721ApprovedQueryForNonexistentToken();
/// Attempting to grant approval to self
error ERC721ApproveToCaller();
/// Attempting to use an invalid token ID
error ERC721InvalidTokenId();
/// Attempting to mint to 0x0 address
error ERC721MintToTheZeroAddress();
/// Attempting to manage a token without being its owner or approved by the owner
error ERC721NotApprovedOrOwner();
/// Attempting to mint an already minted token
error ERC721TokenAlreadyMinted();
/// Attempting to transfer the token from an address that is not the owner
error ERC721TransferFromIncorrectOwner();
/// Attempting to safe transfer to an address that is unable to receive the token
error ERC721TransferToNonReceiverImplementer();
/// Attempting to transfer the token to a 0x0 address
error ERC721TransferToTheZeroAddress();
/// Attempting to grant approval of assets to their current owner
error RMRKApprovalForAssetsToCurrentOwner();
/// Attempting to grant approval of assets without being the caller or approved for all
error RMRKApproveForAssetsCallerIsNotOwnerNorApprovedForAll();
/// Attempting to incorrectly configue a Catalog item
error RMRKBadConfig();
/// Attempting to set the priorities with an array of length that doesn't match the length of active assets array
error RMRKBadPriorityListLength();
/// Attempting to add an asset entry with `Part`s, without setting the `Catalog` address
error RMRKCatalogRequiredForParts();
/// Attempting to transfer a soulbound (non-transferrable) token
error RMRKCannotTransferSoulbound();
/// Attempting to accept a child that has already been accepted
error RMRKChildAlreadyExists();
/// Attempting to interact with a child, using index that is higher than the number of children
error RMRKChildIndexOutOfRange();
/// Attempting to find the index of a child token on a parent which does not own it.
error RMRKChildNotFoundInParent();
/// Attempting to pass collaborator address array and collaborator permission array of different lengths
error RMRKCollaboratorArraysNotEqualLength();
/// Attempting to register a collection that is already registered
error RMRKCollectionAlreadyRegistered();
/// Attempting to manage or interact with colleciton that is not registered
error RMRKCollectionNotRegistered();
/// Attempting to equip a `Part` with a child not approved by the Catalog
error RMRKEquippableEquipNotAllowedByCatalog();
/// Attempting to pass an epired ECDSA deadline
error RMRKExpiredDeadline();
/// Attempting to use ID 0, which is not supported
/// @dev The ID 0 in RMRK suite is reserved for empty values. Guarding against its use ensures the expected operation
error RMRKIdZeroForbidden();
/// Attempting to interact with an asset, using index greater than number of assets
error RMRKIndexOutOfRange();
/// Attempting to reclaim a child that can't be reclaimed
error RMRKInvalidChildReclaim();
/// Attempting to use and invalid ECDSA signature
error RMRKInvalidSignature();
/// Attempting to interact with an end-user account when the contract account is expected
error RMRKIsNotContract();
/// Attempting to interact with a contract that had its operation locked
error RMRKLocked();
/// Attempting to add a pending child after the number of pending children has reached the limit (default limit is 128)
error RMRKMaxPendingChildrenReached();
/// Attempting to add a pending asset after the number of pending assets has reached the limit (default limit is
///  128)
error RMRKMaxPendingAssetsReached();
/// Attempting to burn a total number of recursive children higher than maximum set
/// @param childContract Address of the collection smart contract in which the maximum number of recursive burns was reached
/// @param childId ID of the child token at which the maximum number of recursive burns was reached
error RMRKMaxRecursiveBurnsReached(address childContract, uint256 childId);
/// Attempting to mint a number of tokens that would cause the total supply to be greater than maximum supply
error RMRKMintOverMax();
/// Attempting to mint a nested token to a smart contract that doesn't support nesting
error RMRKMintToNonRMRKNestableImplementer();
/// Attempting to mint zero tokens
error RMRKMintZero();
/// Attempting to pass complementary arrays of different lengths
error RMRKMismachedArrayLength();
/// Attempting to transfer a child before it is unequipped
error RMRKMustUnequipFirst();
/// Attempting to nest a child over the nestable limit (current limit is 100 levels of nesting)
error RMRKNestableTooDeep();
/// Attempting to nest the token to own descendant, which would create a loop and leave the looped tokens in limbo
error RMRKNestableTransferToDescendant();
/// Attempting to nest the token to a smart contract that doesn't support nesting
error RMRKNestableTransferToNonRMRKNestableImplementer();
/// Attempting to nest the token into itself
error RMRKNestableTransferToSelf();
/// Attempting to interact with an asset that can not be found
error RMRKNoAssetMatchingId();
/// Attempting to manage an asset without owning it or having been granted permission by the owner to do so
error RMRKNotApprovedForAssetsOrOwner();
/// Attempting to interact with a token without being its owner or having been granted permission by the
///  owner to do so
/// @dev When a token is nested, only the direct owner (NFT parent) can mange it. In that case, approved addresses are
///  not allowed to manage it, in order to ensure the expected behaviour
error RMRKNotApprovedOrDirectOwner();
/// Attempting to manage a collection without being the collection's collaborator
error RMRKNotCollectionCollaborator();
/// Attemting to manage a collection without being the collection's issuer
error RMRKNotCollectionIssuer();
/// Attempting to manage a collection without being the collection's issuer or collaborator
error RMRKNotCollectionIssuerOrCollaborator();
/// Attempting to compose an asset wihtout having an associated Catalog
error RMRKNotComposableAsset();
/// Attempting to unequip an item that isn't equipped
error RMRKNotEquipped();
/// Attempting to interact with a management function without being the smart contract's owner
error RMRKNotOwner();
/// Attempting to interact with a function without being the owner or contributor of the collection
error RMRKNotOwnerOrContributor();
/// Attempting to manage a collection without being the specific address
error RMRKNotSpecificAddress();
/// Attempting to manage a token without being its owner
error RMRKNotTokenOwner();
/// Attempting to transfer the ownership to the 0x0 address
error RMRKNewOwnerIsZeroAddress();
/// Attempting to assign a 0x0 address as a contributor
error RMRKNewContributorIsZeroAddress();
/// Attemtping to use `Ownable` interface without implementing it
error RMRKOwnableNotImplemented();
/// Attempting an operation requiring the token being nested, while it is not
error RMRKParentIsNotNFT();
/// Attempting to add a `Part` with an ID that is already used
error RMRKPartAlreadyExists();
/// Attempting to use a `Part` that doesn't exist
error RMRKPartDoesNotExist();
/// Attempting to use a `Part` that is `Fixed` when `Slot` kind of `Part` should be used
error RMRKPartIsNotSlot();
/// Attempting to interact with a pending child using an index greater than the size of pending array
error RMRKPendingChildIndexOutOfRange();
/// Attempting to add an asset using an ID that has already been used
error RMRKAssetAlreadyExists();
/// Attempting to equip an item into a slot that already has an item equipped
error RMRKSlotAlreadyUsed();
/// Attempting to equip an item into a `Slot` that the target asset does not implement
error RMRKTargetAssetCannotReceiveSlot();
/// Attempting to equip a child into a `Slot` and parent that the child's collection doesn't support
error RMRKTokenCannotBeEquippedWithAssetIntoSlot();
/// Attempting to compose a NFT of a token without active assets
error RMRKTokenDoesNotHaveAsset();
/// Attempting to determine the asset with the top priority on a token without assets
error RMRKTokenHasNoAssets();
/// Attempting to accept or transfer a child which does not match the one at the specified index
error RMRKUnexpectedChildId();
/// Attempting to reject all pending assets but more assets than expected are pending
error RMRKUnexpectedNumberOfAssets();
/// Attempting to reject all pending children but children assets than expected are pending
error RMRKUnexpectedNumberOfChildren();
/// Attempting to accept or reject an asset which does not match the one at the specified index
error RMRKUnexpectedAssetId();
/// Attempting an operation expecting a parent to the token which is not the actual one
error RMRKUnexpectedParent();
/// Attempting not to pass an empty array of equippable addresses when adding or setting the equippable addresses
error RMRKZeroLengthIdsPassed();
/// Attempting to set the royalties to a value higher than 100% (10000 in basis points)
error RMRKRoyaltiesTooHigh();
/// Attempting to do a bulk operation on a token that is not owned by the caller
error RMRKCanOnlyDoBulkOperationsOnOwnedTokens();
/// Attempting to do a bulk operation with multiple tokens at a time
error RMRKCanOnlyDoBulkOperationsWithOneTokenAtATime();
/// Attempting to pay with native token with a value different than expected
error RMRKWrongValueSent();

{
  "compilationTarget": {
    "contracts/Migrator.sol": "Migrator"
  },
  "evmVersion": "london",
  "libraries": {},
  "metadata": {
    "bytecodeHash": "ipfs"
  },
  "optimizer": {
    "enabled": true,
    "runs": 1000
  },
  "remappings": []
}