IPatchworkProtocol

function claimScope(string calldata scopeName) external;

function transferScopeOwnership(string calldata scopeName, address newOwner) external;

function cancelScopeTransfer(string calldata scopeName) external;

function acceptScopeTransfer(string calldata scopeName) external;

function getScopeOwnerElect(string calldata scopeName) external view returns (address ownerElect);

function getScopeOwner(string calldata scopeName) external view returns (address owner);

function addOperator(string calldata scopeName, address op) external;

function removeOperator(string calldata scopeName, address op) external;

function setScopeRules(string calldata scopeName, bool allowUserPatch, bool allowUserAssign, bool requireWhitelist)
    external;

function addWhitelist(string calldata scopeName, address addr) external;

function removeWhitelist(string calldata scopeName, address addr) external;

function setMintConfiguration(address addr, MintConfig memory config) external;

function getMintConfiguration(address addr) external view returns (MintConfig memory config);

function setPatchFee(address addr, uint256 baseFee) external;

function getPatchFee(address addr) external view returns (uint256 baseFee);

function setAssignFee(address fragmentAddress, uint256 baseFee) external;

function getAssignFee(address fragmentAddress) external view returns (uint256 baseFee);

function addBanker(string memory scopeName, address addr) external;

function removeBanker(string memory scopeName, address addr) external;

function withdraw(string memory scopeName, uint256 amount) external;

function balanceOf(string memory scopeName) external view returns (uint256 balance);

function mint(address to, address mintable, bytes calldata data) external payable returns (uint256 tokenId);

function mintBatch(address to, address mintable, bytes calldata data, uint256 quantity)
    external
    payable
    returns (uint256[] memory tokenIds);

function proposeProtocolFeeConfig(FeeConfig memory config) external;

function commitProtocolFeeConfig() external;

function getProtocolFeeConfig() external view returns (FeeConfig memory config);

function proposeScopeFeeOverride(string memory scopeName, FeeConfigOverride memory config) external;

function commitScopeFeeOverride(string memory scopeName) external;

function getScopeFeeOverride(string memory scopeName) external view returns (FeeConfigOverride memory config);

function addProtocolBanker(address addr) external;

function removeProtocolBanker(address addr) external;

function withdrawFromProtocol(uint256 balance) external;

function balanceOfProtocol() external view returns (uint256 balance);

function patch(address owner, address originalAddress, uint256 originalTokenId, address patchAddress)
    external
    payable
    returns (uint256 tokenId);

function patchBurned(address originalAddress, uint256 originalTokenId, address patchAddress) external;

function patch1155(
    address to,
    address originalAddress,
    uint256 originalTokenId,
    address originalAccount,
    address patchAddress
) external payable returns (uint256 tokenId);

function patchBurned1155(
    address originalAddress,
    uint256 originalTokenId,
    address originalAccount,
    address patchAddress
) external;

function patchAccount(address owner, address originalAddress, address patchAddress)
    external
    payable
    returns (uint256 tokenId);

function patchBurnedAccount(address originalAddress, address patchAddress) external;

function assign(address fragment, uint256 fragmentTokenId, address target, uint256 targetTokenId) external payable;

function assign(
    address fragment,
    uint256 fragmentTokenId,
    address target,
    uint256 targetTokenId,
    uint256 targetMetadataId
) external payable;

function assignBatch(address[] calldata fragments, uint256[] calldata tokenIds, address target, uint256 targetTokenId)
    external
    payable;

function assignBatch(
    address[] calldata fragments,
    uint256[] calldata tokenIds,
    address target,
    uint256 targetTokenId,
    uint256 targetMetadataId
) external payable;

function unassignSingle(address fragment, uint256 fragmentTokenId) external;

function unassignSingle(address fragment, uint256 fragmentTokenId, uint256 targetMetadataId) external;

function unassignMulti(address fragment, uint256 fragmentTokenId, address target, uint256 targetTokenId) external;

function unassignMulti(
    address fragment,
    uint256 fragmentTokenId,
    address target,
    uint256 targetTokenId,
    uint256 targetMetadataId
) external;

function unassign(address fragment, uint256 fragmentTokenId, address target, uint256 targetTokenId) external;

function unassign(
    address fragment,
    uint256 fragmentTokenId,
    address target,
    uint256 targetTokenId,
    uint256 targetMetadataId
) external;

function applyTransfer(address from, address to, uint256 tokenId) external;

function updateOwnershipTree(address addr, uint256 tokenId) external;

function proposeAssignerDelegate(address addr) external;

function commitAssignerDelegate() external;

event Assign(
    address indexed owner,
    address fragmentAddress,
    uint256 fragmentTokenId,
    address indexed targetAddress,
    uint256 indexed targetTokenId,
    uint256 scopeFee,
    uint256 protocolFee
);

event Unassign(
    address indexed owner,
    address fragmentAddress,
    uint256 fragmentTokenId,
    address indexed targetAddress,
    uint256 indexed targetTokenId
);

event Patch(
    address indexed owner,
    address originalAddress,
    uint256 originalTokenId,
    address indexed patchAddress,
    uint256 indexed patchTokenId,
    uint256 scopeFee,
    uint256 protocolFee
);

event ERC1155Patch(
    address indexed owner,
    address originalAddress,
    uint256 originalTokenId,
    address originalAccount,
    address indexed patchAddress,
    uint256 indexed patchTokenId,
    uint256 scopeFee,
    uint256 protocolFee
);

event AccountPatch(
    address indexed owner,
    address originalAddress,
    address indexed patchAddress,
    uint256 indexed patchTokenId,
    uint256 scopeFee,
    uint256 protocolFee
);

event ScopeClaim(string scopeName, address indexed owner);

event ScopeTransferElect(string scopeName, address indexed from, address indexed to);

event ScopeTransferCancel(string scopeName, address indexed from, address indexed to);

event ScopeTransfer(string scopeName, address indexed from, address indexed to);

event ScopeAddOperator(string scopeName, address indexed actor, address indexed operator);

event ScopeRemoveOperator(string scopeName, address indexed actor, address indexed operator);

event ScopeRuleChange(
    string scopeName, address indexed actor, bool allowUserPatch, bool allowUserAssign, bool requireWhitelist
);

event ScopeWhitelistAdd(string scopeName, address indexed actor, address indexed addr);

event ScopeWhitelistRemove(string scopeName, address indexed actor, address indexed addr);

event MintConfigure(string scopeName, address indexed actor, address indexed mintable, MintConfig config);

event ScopeBankerAdd(string scopeName, address indexed actor, address indexed banker);

event ScopeBankerRemove(string scopeName, address indexed actor, address indexed banker);

event ScopeWithdraw(string scopeName, address indexed actor, uint256 amount);

event ProtocolBankerAdd(address indexed actor, address indexed banker);

event ProtocolBankerRemove(address indexed actor, address indexed banker);

event ProtocolWithdraw(address indexed actor, uint256 amount);

event Mint(
    address indexed actor,
    string scopeName,
    address indexed to,
    address indexed mintable,
    bytes data,
    uint256 scopeFee,
    uint256 protocolFee
);

event MintBatch(
    address indexed actor,
    string scopeName,
    address indexed to,
    address indexed mintable,
    bytes data,
    uint256 quantity,
    uint256 scopeFee,
    uint256 protocolFee
);

event ProtocolFeeConfigPropose(FeeConfig config);

event ProtocolFeeConfigCommit(FeeConfig config);

event ScopeFeeOverridePropose(string scopeName, FeeConfigOverride config);

event ScopeFeeOverrideCommit(string scopeName, FeeConfigOverride config);

event PatchFeeChange(string scopeName, address indexed addr, uint256 fee);

event AssignFeeChange(string scopeName, address indexed addr, uint256 fee);

event AssignerDelegatePropose(address indexed addr);

event AssignerDelegateCommit(address indexed addr);

error NotAuthorized(address addr);

error ScopeExists(string scopeName);

error ScopeDoesNotExist(string scopeName);

error ScopeTransferNotAllowed(address to);

error Frozen(address addr, uint256 tokenId);

error Locked(address addr, uint256 tokenId);

error NotWhitelisted(string scopeName, address addr);

error AccountAlreadyPatched(address addr, address patchAddress);

error AlreadyPatched(address addr, uint256 tokenId, address patchAddress);

error ERC1155AlreadyPatched(address addr, uint256 tokenId, address account, address patchAddress);

error BadInputLengths();

error FragmentUnregistered(address addr);

error FragmentRedacted(address addr);

error FragmentAlreadyAssigned(address addr, uint256 tokenId);

error RefNotFound(address target, address fragment, uint256 tokenId);

error FragmentNotAssigned(address addr, uint256 tokenId);

error FragmentNotAssignedToTarget(address addr, uint256 tokenId, address targetAddress, uint256 targetTokenId);

error FragmentAlreadyRegistered(address addr);

error OutOfIDs();

error UnsupportedTokenId(uint256 tokenId);

error CannotLockSoulboundPatch(address addr);

error NotFrozen(address addr, uint256 tokenId);

error IncorrectNonce(address addr, uint256 tokenId, uint256 nonce);

error SelfAssignmentNotAllowed(address addr, uint256 tokenId);

error TransferNotAllowed(address addr, uint256 tokenId);

error TransferBlockedByAssignment(address addr, uint256 tokenId);

error MintNotAllowed(address addr);

error NotPatchworkAssignable(address addr);

error DataIntegrityError(address addr, uint256 tokenId, address addr2, uint256 tokenId2);

error InsufficientFunds();

error IncorrectFeeAmount();

error MintNotActive();

error FailedToSend();

error UnsupportedContract();

error UnsupportedOperation();

error NoProposedFeeSet();

error TimelockNotElapsed();

error InvalidFeeValue();

error NoDelegateProposed();

struct FeeConfig {
    uint256 mintBp;
    uint256 patchBp;
    uint256 assignBp;
}

struct FeeConfigOverride {
    uint256 mintBp;
    uint256 patchBp;
    uint256 assignBp;
    bool active;
}

struct ProposedFeeConfig {
    FeeConfig config;
    uint256 timestamp;
    bool active;
}

struct MintConfig {
    uint256 flatFee;
    bool active;
}

struct ProposedAssignerDelegate {
    uint256 timestamp;
    address addr;
}

struct Scope {
    address owner;
    address ownerElect;
    bool allowUserPatch;
    bool allowUserAssign;
    bool requireWhitelist;
    mapping(address => bool) operators;
    mapping(address => bool) whitelist;
    mapping(address => MintConfig) mintConfigurations;
    mapping(address => uint256) patchFees;
    mapping(address => uint256) assignFees;
    uint256 balance;
    mapping(address => bool) bankers;
}