Does this seem over-engineered to anyone else?
Are all of these getters required?
/* Getters */
function getTraitValue(bytes32 traitKey, uint256 tokenId) external view returns (bytes32);
function getTraitValues(bytes32 traitKey, uint256[] calldata tokenIds) external view returns (bytes32[] memory);
function getTraitKeys() external view returns (bytes32[] memory);
function getTotalTraitKeys() external view returns (uint256);
function getTraitKeyAt(uint256 index) external view returns (bytes32);
function getTraitLabelsURI() external view returns (string memory);
This seems like a prohibitive amount of code to add for something that (could) ony be only one key and value.
Also why do we have trait keys, full trait keys, and trait labels? Are these all not the same thing? Then the trait keys are indexed so they have yet another way to call them. Why are there so many ways to address the trait names? This seems every confusing.
And then what is a trait URI? Is this meant to just describe the label again? If this is meant to store offchain data about keys, why is this necessary if the point of this to store data onchain?
My main criticism is why are there so many ways to tell us how the how to translate trait names into human readable form? Is that not the least most important thing? Isn’t what matters, just that there is in fact a unique key for each trait (which is accomplished by having an index in the trait key array) and then if we have any kind of human readable label the contract operator should be able to easily find a unique human readable label within bytes32 that should be a sufficient enough clue to properly label the key in a user interface.
Thanks for helping me to understand.