Repository: pcaversaccio/snekmate (language: python)

Issue:
🔁 Upgrade to Solidity Version `0.8.22`
- Official Release: https://github.com/ethereum/solidity/releases/tag/v0.8.22.
- We should use the feature that you can now access events from other contracts for our Foundry tests.


Discussion / hints:

Fix patch:
diff --git a/.gas-snapshot b/.gas-snapshot
index ee8e1864..a6091d04 100644
--- a/.gas-snapshot
+++ b/.gas-snapshot
@@ -7,9 +7,9 @@ AccessControlTest:testFuzzGrantRoleSuccess(address) (runs: 256, μ: 43797, ~: 43
 AccessControlTest:testFuzzRenounceRoleMultipleTimesSuccess(address) (runs: 256, μ: 44371, ~: 44356)
 AccessControlTest:testFuzzRenounceRoleNonMsgSender(address) (runs: 256, μ: 9556, ~: 9556)
 AccessControlTest:testFuzzRenounceRoleSuccess(address) (runs: 256, μ: 40866, ~: 40851)
-AccessControlTest:testFuzzRevokeRoleMultipleTimesSuccess(address) (runs: 256, μ: 40636, ~: 40620)
+AccessControlTest:testFuzzRevokeRoleMultipleTimesSuccess(address) (runs: 256, μ: 40635, ~: 40620)
 AccessControlTest:testFuzzRevokeRoleNonAdmin(address,address) (runs: 256, μ: 16498, ~: 16498)
-AccessControlTest:testFuzzRevokeRoleSuccess(address) (runs: 256, μ: 39480, ~: 39464)
+AccessControlTest:testFuzzRevokeRoleSuccess(address) (runs: 256, μ: 39479, ~: 39464)
 AccessControlTest:testFuzzSetRoleAdminPreviousAdminCallsGrantRole(address,address) (runs: 256, μ: 75747, ~: 75747)
 AccessControlTest:testFuzzSetRoleAdminPreviousAdminCallsRevokeRole(address,address) (runs: 256, μ: 101276, ~: 101276)
 AccessControlTest:testFuzzSetRoleAdminSuccess(address,address) (runs: 256, μ: 89648, ~: 89648)
@@ -41,81 +41,81 @@ Base64Test:testDecodeSingleCharacter() (gas: 153350)
 Base64Test:testDecodeWithDoublePadding() (gas: 225773)
 Base64Test:testDecodeWithNoPadding() (gas: 178995)
 Base64Test:testDecodeWithSinglePadding() (gas: 189251)
-Base64Test:testEncodeEmptyString() (gas: 9108)
-Base64Test:testEncodeSafeUrl() (gas: 83123)
-Base64Test:testEncodeSentence() (gas: 110379)
-Base64Test:testEncodeSingleCharacter() (gas: 65635)
-Base64Test:testEncodeWithDoublePadding() (gas: 71238)
-Base64Test:testEncodeWithNoPadding() (gas: 69969)
-Base64Test:testEncodeWithSinglePadding() (gas: 71341)
-BatchDistributorInvariants:invariantNoEtherBalance() (runs: 256, calls: 3840, reverts: 3825)
-BatchDistributorInvariants:invariantNoTokenBalance() (runs: 256, calls: 3840, reverts: 3825)
+Base64Test:testEncodeEmptyString() (gas: 9100)
+Base64Test:testEncodeSafeUrl() (gas: 83259)
+Base64Test:testEncodeSentence() (gas: 110695)
+Base64Test:testEncodeSingleCharacter() (gas: 65663)
+Base64Test:testEncodeWithDoublePadding() (gas: 71302)
+Base64Test:testEncodeWithNoPadding() (gas: 70033)
+Base64Test:testEncodeWithSinglePadding() (gas: 71405)
+BatchDistributorInvariants:invariantNoEtherBalance() (runs: 256, calls: 3840, reverts: 3827)
+BatchDistributorInvariants:invariantNoTokenBalance() (runs: 256, calls: 3840, reverts: 3827)
 BatchDistributorTest:testDistributeEtherMultipleAddressesSuccess() (gas: 151992)
 BatchDistributorTest:testDistributeEtherOneAddressSuccess() (gas: 78424)
 BatchDistributorTest:testDistributeEtherRevertWithInsufficientFunds() (gas: 82768)
 BatchDistributorTest:testDistributeEtherRevertWithNoFallbackFunctionForMsgSender() (gas: 158626)
 BatchDistributorTest:testDistributeEtherRevertWithNoFallbackFunctionForReceipt() (gas: 53879)
 BatchDistributorTest:testDistributeEtherSendsBackExcessiveEther() (gas: 187230)
-BatchDistributorTest:testDistributeTokenMultipleAddressesSuccess() (gas: 615999)
-BatchDistributorTest:testDistributeTokenOneAddressSuccess() (gas: 578324)
-BatchDistributorTest:testDistributeTokenRevertWithInsufficientAllowance() (gas: 574065)
-BatchDistributorTest:testDistributeTokenRevertWithInsufficientBalance() (gas: 574851)
-BatchDistributorTest:testFuzzDistributeEtherMultipleAddressesSuccess(((address,uint256)[]),uint256) (runs: 256, μ: 1780314, ~: 1661052)
-BatchDistributorTest:testFuzzDistributeTokenMultipleAddressesSuccess(((address,uint256)[]),address,uint256) (runs: 256, μ: 1322216, ~: 1285243)
-Create2AddressTest:testComputeAddress() (gas: 550238)
-Create2AddressTest:testComputeAddressSelf() (gas: 558561)
-Create2AddressTest:testFuzzComputeAddress(bytes32,address) (runs: 256, μ: 550833, ~: 550833)
-Create2AddressTest:testFuzzComputeAddressSelf(bytes32) (runs: 256, μ: 558582, ~: 558582)
+BatchDistributorTest:testDistributeTokenMultipleAddressesSuccess() (gas: 616202)
+BatchDistributorTest:testDistributeTokenOneAddressSuccess() (gas: 578527)
+BatchDistributorTest:testDistributeTokenRevertWithInsufficientAllowance() (gas: 574268)
+BatchDistributorTest:testDistributeTokenRevertWithInsufficientBalance() (gas: 575054)
+BatchDistributorTest:testFuzzDistributeEtherMultipleAddressesSuccess(((address,uint256)[]),uint256) (runs: 256, μ: 1841083, ~: 1807823)
+BatchDistributorTest:testFuzzDistributeTokenMultipleAddressesSuccess(((address,uint256)[]),address,uint256) (runs: 256, μ: 1345116, ~: 1329571)
+Create2AddressTest:testComputeAddress() (gas: 550599)
+Create2AddressTest:testComputeAddressSelf() (gas: 558922)
+Create2AddressTest:testFuzzComputeAddress(bytes32,address) (runs: 256, μ: 551194, ~: 551194)
+Create2AddressTest:testFuzzComputeAddressSelf(bytes32) (runs: 256, μ: 558943, ~: 558943)
 CreateAddressTest:testComputeAddressNonce0x00() (gas: 16180)
-CreateAddressTest:testComputeAddressNonce0x7f() (gas: 534711)
-CreateAddressTest:testComputeAddressNonceUint16() (gas: 534763)
-CreateAddressTest:testComputeAddressNonceUint24() (gas: 534858)
-CreateAddressTest:testComputeAddressNonceUint32() (gas: 534820)
-CreateAddressTest:testComputeAddressNonceUint40() (gas: 534892)
-CreateAddressTest:testComputeAddressNonceUint48() (gas: 534920)
-CreateAddressTest:testComputeAddressNonceUint56() (gas: 534948)
-CreateAddressTest:testComputeAddressNonceUint64() (gas: 535085)
-CreateAddressTest:testComputeAddressNonceUint8() (gas: 534803)
+CreateAddressTest:testComputeAddressNonce0x7f() (gas: 534914)
+CreateAddressTest:testComputeAddressNonceUint16() (gas: 534966)
+CreateAddressTest:testComputeAddressNonceUint24() (gas: 535061)
+CreateAddressTest:testComputeAddressNonceUint32() (gas: 535023)
+CreateAddressTest:testComputeAddressNonceUint40() (gas: 535095)
+CreateAddressTest:testComputeAddressNonceUint48() (gas: 535123)
+CreateAddressTest:testComputeAddressNonceUint56() (gas: 535151)
+CreateAddressTest:testComputeAddressNonceUint64() (gas: 535288)
+CreateAddressTest:testComputeAddressNonceUint8() (gas: 535006)
 CreateAddressTest:testComputeAddressRevertTooHighNonce() (gas: 10607)
-CreateAddressTest:testComputeAddressSelfNonce0x7f() (gas: 538593)
-CreateAddressTest:testComputeAddressSelfNonceUint16() (gas: 538814)
-CreateAddressTest:testComputeAddressSelfNonceUint24() (gas: 538843)
-CreateAddressTest:testComputeAddressSelfNonceUint32() (gas: 538939)
-CreateAddressTest:testComputeAddressSelfNonceUint40() (gas: 538968)
-CreateAddressTest:testComputeAddressSelfNonceUint48() (gas: 538996)
-CreateAddressTest:testComputeAddressSelfNonceUint56() (gas: 539025)
-CreateAddressTest:testComputeAddressSelfNonceUint64() (gas: 539142)
-CreateAddressTest:testComputeAddressSelfNonceUint8() (gas: 538748)
+CreateAddressTest:testComputeAddressSelfNonce0x7f() (gas: 538796)
+CreateAddressTest:testComputeAddressSelfNonceUint16() (gas: 539017)
+CreateAddressTest:testComputeAddressSelfNonceUint24() (gas: 539046)
+CreateAddressTest:testComputeAddressSelfNonceUint32() (gas: 539142)
+CreateAddressTest:testComputeAddressSelfNonceUint40() (gas: 539171)
+CreateAddressTest:testComputeAddressSelfNonceUint48() (gas: 539199)
+CreateAddressTest:testComputeAddressSelfNonceUint56() (gas: 539228)
+CreateAddressTest:testComputeAddressSelfNonceUint64() (gas: 539345)
+CreateAddressTest:testComputeAddressSelfNonceUint8() (gas: 538951)
 CreateAddressTest:testComputeAddressSelfRevertTooHighNonce() (gas: 8836)
-CreateAddressTest:testFuzzComputeAddressNonce0x7f(uint64,address) (runs: 256, μ: 538182, ~: 538346)
-CreateAddressTest:testFuzzComputeAddressNonceUint16(uint64,address) (runs: 256, μ: 537675, ~: 537811)
-CreateAddressTest:testFuzzComputeAddressNonceUint24(uint64,address) (runs: 256, μ: 537827, ~: 537937)
-CreateAddressTest:testFuzzComputeAddressNonceUint32(uint64,address) (runs: 256, μ: 537816, ~: 537944)
-CreateAddressTest:testFuzzComputeAddressNonceUint40(uint64,address) (runs: 256, μ: 537935, ~: 538036)
-CreateAddressTest:testFuzzComputeAddressNonceUint48(uint64,address) (runs: 256, μ: 537917, ~: 538020)
-CreateAddressTest:testFuzzComputeAddressNonceUint56(uint64,address) (runs: 256, μ: 537939, ~: 538049)
-CreateAddressTest:testFuzzComputeAddressNonceUint64(uint64,address) (runs: 256, μ: 537952, ~: 538153)
-CreateAddressTest:testFuzzComputeAddressNonceUint8(uint64,address) (runs: 256, μ: 537710, ~: 537811)
-CreateAddressTest:testFuzzComputeAddressRevertTooHighNonce(uint256,address) (runs: 256, μ: 13368, ~: 13340)
-CreateAddressTest:testFuzzComputeAddressSelfNonce0x7f(uint64) (runs: 256, μ: 544073, ~: 544185)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint16(uint64) (runs: 256, μ: 543306, ~: 543221)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint24(uint64) (runs: 256, μ: 543584, ~: 543675)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint32(uint64) (runs: 256, μ: 543672, ~: 543771)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint40(uint64) (runs: 256, μ: 543665, ~: 543755)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint48(uint64) (runs: 256, μ: 543718, ~: 543829)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint56(uint64) (runs: 256, μ: 543806, ~: 543899)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint64(uint64) (runs: 256, μ: 543865, ~: 544029)
-CreateAddressTest:testFuzzComputeAddressSelfNonceUint8(uint64) (runs: 256, μ: 543394, ~: 543466)
-CreateAddressTest:testFuzzComputeAddressSelfRevertTooHighNonce(uint256) (runs: 256, μ: 13194, ~: 13179)
+CreateAddressTest:testFuzzComputeAddressNonce0x7f(uint64,address) (runs: 256, μ: 538429, ~: 538549)
+CreateAddressTest:testFuzzComputeAddressNonceUint16(uint64,address) (runs: 256, μ: 537895, ~: 538163)
+CreateAddressTest:testFuzzComputeAddressNonceUint24(uint64,address) (runs: 256, μ: 538016, ~: 538140)
+CreateAddressTest:testFuzzComputeAddressNonceUint32(uint64,address) (runs: 256, μ: 538016, ~: 538147)
+CreateAddressTest:testFuzzComputeAddressNonceUint40(uint64,address) (runs: 256, μ: 538148, ~: 538239)
+CreateAddressTest:testFuzzComputeAddressNonceUint48(uint64,address) (runs: 256, μ: 538122, ~: 538223)
+CreateAddressTest:testFuzzComputeAddressNonceUint56(uint64,address) (runs: 256, μ: 538163, ~: 538252)
+CreateAddressTest:testFuzzComputeAddressNonceUint64(uint64,address) (runs: 256, μ: 538150, ~: 538356)
+CreateAddressTest:testFuzzComputeAddressNonceUint8(uint64,address) (runs: 256, μ: 537940, ~: 538014)
+CreateAddressTest:testFuzzComputeAddressRevertTooHighNonce(uint256,address) (runs: 256, μ: 13406, ~: 13340)
+CreateAddressTest:testFuzzComputeAddressSelfNonce0x7f(uint64) (runs: 256, μ: 544285, ~: 544388)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint16(uint64) (runs: 256, μ: 543501, ~: 543424)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint24(uint64) (runs: 256, μ: 543783, ~: 543878)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint32(uint64) (runs: 256, μ: 543842, ~: 543974)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint40(uint64) (runs: 256, μ: 543873, ~: 543958)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint48(uint64) (runs: 256, μ: 543915, ~: 544032)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint56(uint64) (runs: 256, μ: 544008, ~: 544102)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint64(uint64) (runs: 256, μ: 544057, ~: 544232)
+CreateAddressTest:testFuzzComputeAddressSelfNonceUint8(uint64) (runs: 256, μ: 543598, ~: 543669)
+CreateAddressTest:testFuzzComputeAddressSelfRevertTooHighNonce(uint256) (runs: 256, μ: 13210, ~: 13179)
 ECDSATest:testEthSignedMessageHash() (gas: 5846)
-ECDSATest:testFuzzEthSignedMessageHash(string) (runs: 256, μ: 6436, ~: 6438)
-ECDSATest:testFuzzRecoverWithInvalidSignature(bytes,string) (runs: 256, μ: 15163, ~: 15164)
-ECDSATest:testFuzzRecoverWithTooLongSignature(bytes,string) (runs: 256, μ: 14001, ~: 13999)
-ECDSATest:testFuzzRecoverWithValidSignature(string,string) (runs: 256, μ: 21767, ~: 21775)
-ECDSATest:testFuzzRecoverWithWrongMessage(string,string,bytes32) (runs: 256, μ: 21776, ~: 21788)
-ECDSATest:testFuzzToDataWithIntendedValidatorHash(address,bytes) (runs: 256, μ: 7304, ~: 7290)
+ECDSATest:testFuzzEthSignedMessageHash(string) (runs: 256, μ: 6432, ~: 6426)
+ECDSATest:testFuzzRecoverWithInvalidSignature(bytes,string) (runs: 256, μ: 15159, ~: 15161)
+ECDSATest:testFuzzRecoverWithTooLongSignature(bytes,string) (runs: 256, μ: 13993, ~: 13996)
+ECDSATest:testFuzzRecoverWithValidSignature(string,string) (runs: 256, μ: 21714, ~: 21775)
+ECDSATest:testFuzzRecoverWithWrongMessage(string,string,bytes32) (runs: 256, μ: 21717, ~: 21663)
+ECDSATest:testFuzzToDataWithIntendedValidatorHash(address,bytes) (runs: 256, μ: 7303, ~: 7290)
 ECDSATest:testFuzzToDataWithIntendedValidatorHashSelf(bytes) (runs: 256, μ: 9334, ~: 9318)
-ECDSATest:testFuzzToTypedDataHash(string,string) (runs: 256, μ: 7060, ~: 7063)
+ECDSATest:testFuzzToTypedDataHash(string,string) (runs: 256, μ: 7050, ~: 7051)
 ECDSATest:testRecoverWith0x00Value() (gas: 15622)
 ECDSATest:testRecoverWithArbitraryMessage() (gas: 20642)
 ECDSATest:testRecoverWithCorrectVersion() (gas: 21384)
@@ -132,14 +132,14 @@ ECDSATest:testToTypedDataHash() (gas: 5937)
 EIP712DomainSeparatorTest:testCachedDomainSeparatorV4() (gas: 7562)
 EIP712DomainSeparatorTest:testDomainSeparatorV4() (gas: 11305)
 EIP712DomainSeparatorTest:testEIP712Domain() (gas: 13629)
-EIP712DomainSeparatorTest:testFuzzDomainSeparatorV4(uint8) (runs: 256, μ: 11459, ~: 11480)
-EIP712DomainSeparatorTest:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19162, ~: 19122)
+EIP712DomainSeparatorTest:testFuzzDomainSeparatorV4(uint8) (runs: 256, μ: 11460, ~: 11480)
+EIP712DomainSeparatorTest:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19161, ~: 19122)
 EIP712DomainSeparatorTest:testFuzzHashTypedDataV4(address,address,uint256,uint256,uint64) (runs: 256, μ: 7698, ~: 7698)
 EIP712DomainSeparatorTest:testHashTypedDataV4() (gas: 13017)
-ERC1155Invariants:invariantOwner() (runs: 256, calls: 3840, reverts: 3479)
-ERC1155Test:testBalanceOfBatchCase1() (gas: 279227)
-ERC1155Test:testBalanceOfBatchCase2() (gas: 233797)
-ERC1155Test:testBalanceOfBatchCase3() (gas: 36108)
+ERC1155Invariants:invariantOwner() (runs: 256, calls: 3840, reverts: 3437)
+ERC1155Test:testBalanceOfBatchCase1() (gas: 278855)
+ERC1155Test:testBalanceOfBatchCase2() (gas: 233425)
+ERC1155Test:testBalanceOfBatchCase3() (gas: 35736)
 ERC1155Test:testBalanceOfBatchLengthsMismatch() (gas: 26717)
 ERC1155Test:testBalanceOfBatchZeroAddress() (gas: 17875)
 ERC1155Test:testBalanceOfCase1() (gas: 145672)
@@ -147,7 +147,7 @@ ERC1155Test:testBalanceOfCase2() (gas: 21510)
 ERC1155Test:testBalanceOfZeroAddress() (gas: 11061)
 ERC1155Test:testBurnAmountExceedsBalance() (gas: 129986)
 ERC1155Test:testBurnBatchAmountExceedsBalance() (gas: 197360)
-ERC1155Test:testBurnBatchByApprovedOperator() (gas: 248232)
+ERC1155Test:testBurnBatchByApprovedOperator() (gas: 248034)
 ERC1155Test:testBurnBatchByNotApprovedOperator() (gas: 31835)
 ERC1155Test:testBurnBatchFromZeroAddress() (gas: 25983)
 ERC1155Test:testBurnBatchLengthsMismatch() (gas: 41694)
@@ -163,83 +163,83 @@ ERC1155Test:testExistsAfterBatchMint() (gas: 143320)
 ERC1155Test:testExistsAfterSingleBurn() (gas: 137816)
 ERC1155Test:testExistsAfterSingleMint() (gas: 119400)
 ERC1155Test:testExistsBeforeMint() (gas: 7642)
-ERC1155Test:testFuzzBurnBatchSuccess(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 132328, ~: 132328)
-ERC1155Test:testFuzzBurnSuccess(address,address,uint256) (runs: 256, μ: 140124, ~: 140134)
+ERC1155Test:testFuzzBurnBatchSuccess(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 132323, ~: 132332)
+ERC1155Test:testFuzzBurnSuccess(address,address,uint256) (runs: 256, μ: 140134, ~: 140134)
 ERC1155Test:testFuzzRenounceOwnershipNonOwner(address) (runs: 256, μ: 13977, ~: 13977)
-ERC1155Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 48431, ~: 48416)
-ERC1155Test:testFuzzSafeBatchTransferFromByApprovedOperator(address,address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 225334, ~: 225315)
-ERC1155Test:testFuzzSafeBatchTransferFromEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 190443, ~: 190428)
-ERC1155Test:testFuzzSafeBatchTransferFromNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 564088, ~: 564088)
-ERC1155Test:testFuzzSafeBatchTransferFromWithData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 564656, ~: 564245)
-ERC1155Test:testFuzzSafeMintBatchEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 152354, ~: 152346)
-ERC1155Test:testFuzzSafeMintBatchNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 519875, ~: 519875)
+ERC1155Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 48433, ~: 48416)
+ERC1155Test:testFuzzSafeBatchTransferFromByApprovedOperator(address,address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 225220, ~: 225191)
+ERC1155Test:testFuzzSafeBatchTransferFromEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 190337, ~: 190304)
+ERC1155Test:testFuzzSafeBatchTransferFromNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 564164, ~: 564164)
+ERC1155Test:testFuzzSafeBatchTransferFromWithData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 564753, ~: 564321)
+ERC1155Test:testFuzzSafeMintBatchEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 152234, ~: 152222)
+ERC1155Test:testFuzzSafeMintBatchNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 519951, ~: 519951)
 ERC1155Test:testFuzzSafeMintBatchNonMinter(address) (runs: 256, μ: 40926, ~: 40926)
-ERC1155Test:testFuzzSafeMintBatchWithData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 520204, ~: 519990)
-ERC1155Test:testFuzzSafeMintEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 151277, ~: 151259)
-ERC1155Test:testFuzzSafeMintNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 519918, ~: 519918)
+ERC1155Test:testFuzzSafeMintBatchWithData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 520282, ~: 520066)
+ERC1155Test:testFuzzSafeMintEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 151284, ~: 151259)
+ERC1155Test:testFuzzSafeMintNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 520118, ~: 520118)
 ERC1155Test:testFuzzSafeMintNonMinter(address) (runs: 256, μ: 33132, ~: 33132)
-ERC1155Test:testFuzzSafeMintWithData(address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 521253, ~: 520809)
-ERC1155Test:testFuzzSafeTransferFromByApprovedOperator(address,address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 204218, ~: 204191)
-ERC1155Test:testFuzzSafeTransferFromEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 169414, ~: 169391)
-ERC1155Test:testFuzzSafeTransferFromNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 606183, ~: 606183)
-ERC1155Test:testFuzzSafeTransferFromWithData(address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 608258, ~: 607445)
-ERC1155Test:testFuzzSetApprovalForAllRevoke(address,address) (runs: 256, μ: 31052, ~: 31024)
+ERC1155Test:testFuzzSafeMintWithData(address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 521421, ~: 521009)
+ERC1155Test:testFuzzSafeTransferFromByApprovedOperator(address,address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 204229, ~: 204191)
+ERC1155Test:testFuzzSafeTransferFromEOAReceiver(address,address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 169433, ~: 169391)
+ERC1155Test:testFuzzSafeTransferFromNoData(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 606373, ~: 606383)
+ERC1155Test:testFuzzSafeTransferFromWithData(address,uint256,uint256,uint256,uint256,bytes) (runs: 256, μ: 608355, ~: 607645)
+ERC1155Test:testFuzzSetApprovalForAllRevoke(address,address) (runs: 256, μ: 31053, ~: 31022)
 ERC1155Test:testFuzzSetApprovalForAllSuccess(address,address) (runs: 256, μ: 44181, ~: 44181)
-ERC1155Test:testFuzzSetMinterNonOwner(address,string) (runs: 256, μ: 15831, ~: 15845)
-ERC1155Test:testFuzzSetMinterSuccess(string) (runs: 256, μ: 33208, ~: 33204)
+ERC1155Test:testFuzzSetMinterNonOwner(address,string) (runs: 256, μ: 15772, ~: 15699)
+ERC1155Test:testFuzzSetMinterSuccess(string) (runs: 256, μ: 33178, ~: 33178)
 ERC1155Test:testFuzzSetUriNonMinter(address) (runs: 256, μ: 14452, ~: 14452)
-ERC1155Test:testFuzzTotalSupplyAfterBatchBurn(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 126368, ~: 126368)
-ERC1155Test:testFuzzTotalSupplyAfterBatchMint(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 140984, ~: 140922)
-ERC1155Test:testFuzzTotalSupplyAfterSingleBurn(address,uint256,bytes) (runs: 256, μ: 138026, ~: 138007)
-ERC1155Test:testFuzzTotalSupplyAfterSingleMint(uint256,uint256,bytes) (runs: 256, μ: 94451, ~: 119839)
+ERC1155Test:testFuzzTotalSupplyAfterBatchBurn(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 126363, ~: 126372)
+ERC1155Test:testFuzzTotalSupplyAfterBatchMint(address,uint256,uint256,uint256,uint256) (runs: 256, μ: 140992, ~: 141055)
+ERC1155Test:testFuzzTotalSupplyAfterSingleBurn(address,uint256,bytes) (runs: 256, μ: 138027, ~: 138007)
+ERC1155Test:testFuzzTotalSupplyAfterSingleMint(uint256,uint256,bytes) (runs: 256, μ: 90720, ~: 119810)
 ERC1155Test:testFuzzTransferOwnershipNonOwner(address,address) (runs: 256, μ: 14086, ~: 14086)
-ERC1155Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 73957, ~: 73930)
+ERC1155Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 73958, ~: 73928)
 ERC1155Test:testHasOwner() (gas: 9714)
 ERC1155Test:testInitialSetup() (gas: 2810217)
 ERC1155Test:testRenounceOwnershipNonOwner() (gas: 10918)
 ERC1155Test:testRenounceOwnershipSuccess() (gas: 22164)
-ERC1155Test:testSafeBatchTransferFromByApprovedOperator() (gas: 337974)
+ERC1155Test:testSafeBatchTransferFromByApprovedOperator() (gas: 337726)
 ERC1155Test:testSafeBatchTransferFromByNotApprovedOperator() (gas: 261065)
-ERC1155Test:testSafeBatchTransferFromEOAReceiver() (gas: 295876)
+ERC1155Test:testSafeBatchTransferFromEOAReceiver() (gas: 295678)
 ERC1155Test:testSafeBatchTransferFromInsufficientBalance() (gas: 267882)
 ERC1155Test:testSafeBatchTransferFromLengthsMismatch() (gas: 64116)
-ERC1155Test:testSafeBatchTransferFromNoData() (gas: 671374)
+ERC1155Test:testSafeBatchTransferFromNoData() (gas: 671326)
 ERC1155Test:testSafeBatchTransferFromReceiverFunctionNotImplemented() (gas: 281004)
-ERC1155Test:testSafeBatchTransferFromReceiverInvalidReturnIdentifier() (gas: 649008)
-ERC1155Test:testSafeBatchTransferFromReceiverReverts() (gas: 642368)
-ERC1155Test:testSafeBatchTransferFromReceiverRevertsOnlySingle() (gas: 671437)
+ERC1155Test:testSafeBatchTransferFromReceiverInvalidReturnIdentifier() (gas: 649208)
+ERC1155Test:testSafeBatchTransferFromReceiverReverts() (gas: 642568)
+ERC1155Test:testSafeBatchTransferFromReceiverRevertsOnlySingle() (gas: 671389)
 ERC1155Test:testSafeBatchTransferFromToZeroAddress() (gas: 257762)
-ERC1155Test:testSafeBatchTransferFromWithData() (gas: 673143)
-ERC1155Test:testSafeMintBatchEOAReceiver() (gas: 246826)
+ERC1155Test:testSafeBatchTransferFromWithData() (gas: 673095)
+ERC1155Test:testSafeMintBatchEOAReceiver() (gas: 246578)
 ERC1155Test:testSafeMintBatchLengthsMismatch() (gas: 66509)
-ERC1155Test:testSafeMintBatchNoData() (gas: 615833)
+ERC1155Test:testSafeMintBatchNoData() (gas: 615785)
 ERC1155Test:testSafeMintBatchNonMinter() (gas: 39827)
 ERC1155Test:testSafeMintBatchOverflow() (gas: 265271)
 ERC1155Test:testSafeMintBatchReceiverFunctionNotImplemented() (gas: 226880)
-ERC1155Test:testSafeMintBatchReceiverInvalidReturnIdentifier() (gas: 598991)
-ERC1155Test:testSafeMintBatchReceiverReverts() (gas: 592327)
-ERC1155Test:testSafeMintBatchReceiverRevertsOnlySingle() (gas: 615810)
+ERC1155Test:testSafeMintBatchReceiverInvalidReturnIdentifier() (gas: 599191)
+ERC1155Test:testSafeMintBatchReceiverReverts() (gas: 592527)
+ERC1155Test:testSafeMintBatchReceiverRevertsOnlySingle() (gas: 615762)
 ERC1155Test:testSafeMintBatchToZeroAddress() (gas: 40903)
-ERC1155Test:testSafeMintBatchWithData() (gas: 616683)
+ERC1155Test:testSafeMintBatchWithData() (gas: 616635)
 ERC1155Test:testSafeMintEOAReceiver() (gas: 148476)
-ERC1155Test:testSafeMintNoData() (gas: 516488)
+ERC1155Test:testSafeMintNoData() (gas: 516688)
 ERC1155Test:testSafeMintNonMinter() (gas: 32079)
 ERC1155Test:testSafeMintOverflow() (gas: 92104)
 ERC1155Test:testSafeMintReceiverFunctionNotImplemented() (gas: 136351)
-ERC1155Test:testSafeMintReceiverInvalidReturnIdentifier() (gas: 507951)
-ERC1155Test:testSafeMintReceiverReverts() (gas: 501710)
+ERC1155Test:testSafeMintReceiverInvalidReturnIdentifier() (gas: 508151)
+ERC1155Test:testSafeMintReceiverReverts() (gas: 501910)
 ERC1155Test:testSafeMintToZeroAddress() (gas: 33064)
-ERC1155Test:testSafeMintWithData() (gas: 518289)
+ERC1155Test:testSafeMintWithData() (gas: 518489)
 ERC1155Test:testSafeTransferFromByApprovedOperator() (gas: 204688)
 ERC1155Test:testSafeTransferFromByNotApprovedOperator() (gas: 150979)
 ERC1155Test:testSafeTransferFromEOAReceiver() (gas: 168649)
 ERC1155Test:testSafeTransferFromInsufficientBalance() (gas: 89880)
-ERC1155Test:testSafeTransferFromNoData() (gas: 603964)
+ERC1155Test:testSafeTransferFromNoData() (gas: 604164)
 ERC1155Test:testSafeTransferFromReceiverFunctionNotImplemented() (gas: 206194)
-ERC1155Test:testSafeTransferFromReceiverInvalidReturnIdentifier() (gas: 577832)
-ERC1155Test:testSafeTransferFromReceiverReverts() (gas: 571548)
+ERC1155Test:testSafeTransferFromReceiverInvalidReturnIdentifier() (gas: 578032)
+ERC1155Test:testSafeTransferFromReceiverReverts() (gas: 571748)
 ERC1155Test:testSafeTransferFromToZeroAddress() (gas: 87488)
-ERC1155Test:testSafeTransferFromWithData() (gas: 607393)
+ERC1155Test:testSafeTransferFromWithData() (gas: 607593)
 ERC1155Test:testSetApprovalForAllRevoke() (gas: 33276)
 ERC1155Test:testSetApprovalForAllSuccess() (gas: 46899)
 ERC1155Test:testSetApprovalForAllToSelf() (gas: 11116)
@@ -266,8 +266,8 @@ ERC1155Test:testUriBaseAndTokenUriNotSet() (gas: 2768301)
 ERC1155Test:testUriBaseAndTokenUriSet() (gas: 65517)
 ERC1155Test:testUriNoBaseURI() (gas: 2818373)
 ERC1155Test:testUriNoTokenUri() (gas: 17407)
-ERC20Invariants:invariantOwner() (runs: 256, calls: 3840, reverts: 3384)
-ERC20Invariants:invariantTotalSupply() (runs: 256, calls: 3840, reverts: 3384)
+ERC20Invariants:invariantOwner() (runs: 256, calls: 3840, reverts: 3391)
+ERC20Invariants:invariantTotalSupply() (runs: 256, calls: 3840, reverts: 3391)
 ERC20Test:testApproveExceedingBalanceCase1() (gas: 40223)
 ERC20Test:testApproveExceedingBalanceCase2() (gas: 46478)
 ERC20Test:testApproveFromZeroAddress() (gas: 13220)
@@ -288,28 +288,28 @@ ERC20Test:testBurnSuccessCase1() (gas: 25055)
 ERC20Test:testBurnSuccessCase2() (gas: 30620)
 ERC20Test:testCachedDomainSeparator() (gas: 7699)
 ERC20Test:testDomainSeparator() (gas: 11449)
-ERC20Test:testEIP712Domain() (gas: 13738)
-ERC20Test:testFuzzApproveSuccess(address,uint256) (runs: 256, μ: 39581, ~: 40437)
-ERC20Test:testFuzzBurnFromInsufficientAllowance(address,uint256,uint8) (runs: 256, μ: 178989, ~: 179181)
-ERC20Test:testFuzzBurnFromSuccess(address,uint256) (runs: 256, μ: 287698, ~: 288311)
+ERC20Test:testEIP712Domain() (gas: 13739)
+ERC20Test:testFuzzApproveSuccess(address,uint256) (runs: 256, μ: 39193, ~: 40437)
+ERC20Test:testFuzzBurnFromInsufficientAllowance(address,uint256,uint8) (runs: 256, μ: 175588, ~: 175650)
+ERC20Test:testFuzzBurnFromSuccess(address,uint256) (runs: 256, μ: 280436, ~: 281683)
 ERC20Test:testFuzzBurnInvalidAmount(address,uint256) (runs: 256, μ: 16454, ~: 16454)
-ERC20Test:testFuzzBurnSuccessCase(uint256) (runs: 256, μ: 263334, ~: 263127)
-ERC20Test:testFuzzDomainSeparator(uint8) (runs: 256, μ: 11663, ~: 11685)
-ERC20Test:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19446, ~: 19408)
-ERC20Test:testFuzzMintNonMinter(string,uint256) (runs: 256, μ: 13210, ~: 13228)
-ERC20Test:testFuzzMintSuccess(string,uint256) (runs: 256, μ: 54590, ~: 55667)
-ERC20Test:testFuzzPermitInvalid(string,string,uint16) (runs: 256, μ: 45388, ~: 45417)
-ERC20Test:testFuzzPermitSuccess(string,string,uint16) (runs: 256, μ: 70408, ~: 70441)
+ERC20Test:testFuzzBurnSuccessCase(uint256) (runs: 256, μ: 256360, ~: 256160)
+ERC20Test:testFuzzDomainSeparator(uint8) (runs: 256, μ: 11664, ~: 11685)
+ERC20Test:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19448, ~: 19409)
+ERC20Test:testFuzzMintNonMinter(string,uint256) (runs: 256, μ: 13152, ~: 13080)
+ERC20Test:testFuzzMintSuccess(string,uint256) (runs: 256, μ: 54709, ~: 55666)
+ERC20Test:testFuzzPermitInvalid(string,string,uint16) (runs: 256, μ: 45279, ~: 45277)
+ERC20Test:testFuzzPermitSuccess(string,string,uint16) (runs: 256, μ: 70299, ~: 70295)
 ERC20Test:testFuzzRenounceOwnershipNonOwner(address) (runs: 256, μ: 13979, ~: 13979)
-ERC20Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 48360, ~: 48345)
-ERC20Test:testFuzzSetMinterNonOwner(address,string) (runs: 256, μ: 15830, ~: 15850)
-ERC20Test:testFuzzSetMinterSuccess(string) (runs: 256, μ: 33226, ~: 33222)
-ERC20Test:testFuzzTransferFromInsufficientAllowance(address,address,uint256,uint8) (runs: 256, μ: 177313, ~: 177662)
-ERC20Test:testFuzzTransferFromSuccess(address,address,uint256) (runs: 256, μ: 205098, ~: 206053)
+ERC20Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 48361, ~: 48345)
+ERC20Test:testFuzzSetMinterNonOwner(address,string) (runs: 256, μ: 15777, ~: 15704)
+ERC20Test:testFuzzSetMinterSuccess(string) (runs: 256, μ: 33196, ~: 33196)
+ERC20Test:testFuzzTransferFromInsufficientAllowance(address,address,uint256,uint8) (runs: 256, μ: 173785, ~: 174131)
+ERC20Test:testFuzzTransferFromSuccess(address,address,uint256) (runs: 256, μ: 200696, ~: 202522)
 ERC20Test:testFuzzTransferInvalidAmount(address,address,uint256) (runs: 256, μ: 16849, ~: 16849)
 ERC20Test:testFuzzTransferOwnershipNonOwner(address,address) (runs: 256, μ: 14068, ~: 14068)
-ERC20Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 73902, ~: 73876)
-ERC20Test:testFuzzTransferSuccess(address,uint256) (runs: 256, μ: 176718, ~: 177401)
+ERC20Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 73902, ~: 73874)
+ERC20Test:testFuzzTransferSuccess(address,uint256) (runs: 256, μ: 172877, ~: 173866)
 ERC20Test:testHasOwner() (gas: 9758)
 ERC20Test:testInitialSetup() (gas: 1467701)
 ERC20Test:testMintNonMinter() (gas: 12639)
@@ -349,18 +349,18 @@ ERC2981Test:testDeleteDefaultRoyaltyNonOwner() (gas: 10537)
 ERC2981Test:testFuzzDeleteDefaultRoyaltyNonOwner(address) (runs: 256, μ: 13271, ~: 13271)
 ERC2981Test:testFuzzRenounceOwnershipNonOwner(address) (runs: 256, μ: 13972, ~: 13972)
 ERC2981Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 24598, ~: 24598)
-ERC2981Test:testFuzzResetTokenRoyalty(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 93196, ~: 95485)
+ERC2981Test:testFuzzResetTokenRoyalty(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 94010, ~: 95480)
 ERC2981Test:testFuzzResetTokenRoyaltyNonOwner(address) (runs: 256, μ: 13246, ~: 13246)
-ERC2981Test:testFuzzRoyaltyInfoDefaultRoyalty(address,uint256,uint256,uint96,uint256) (runs: 256, μ: 78555, ~: 80155)
-ERC2981Test:testFuzzRoyaltyInfoDeleteDefaultRoyalty(address,uint256,uint256,uint96,uint256) (runs: 256, μ: 62442, ~: 63329)
-ERC2981Test:testFuzzRoyaltyInfoSetTokenRoyalty(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 118930, ~: 122002)
-ERC2981Test:testFuzzRoyaltyInfoSetTokenRoyaltyUpdate(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 161954, ~: 166503)
-ERC2981Test:testFuzzRoyaltyInfoUpdateDefaultRoyalty(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 84055, ~: 85650)
+ERC2981Test:testFuzzRoyaltyInfoDefaultRoyalty(address,uint256,uint256,uint96,uint256) (runs: 256, μ: 79204, ~: 80155)
+ERC2981Test:testFuzzRoyaltyInfoDeleteDefaultRoyalty(address,uint256,uint256,uint96,uint256) (runs: 256, μ: 62367, ~: 63356)
+ERC2981Test:testFuzzRoyaltyInfoSetTokenRoyalty(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 120325, ~: 122002)
+ERC2981Test:testFuzzRoyaltyInfoSetTokenRoyaltyUpdate(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 164049, ~: 166503)
+ERC2981Test:testFuzzRoyaltyInfoUpdateDefaultRoyalty(address,address,uint256,uint256,uint96,uint256) (runs: 256, μ: 84914, ~: 85650)
 ERC2981Test:testFuzzSetDefaultRoyaltyNonOwner(address) (runs: 256, μ: 15525, ~: 15525)
-ERC2981Test:testFuzzSetDefaultRoyaltyTooHighFeeNumerator(uint96) (runs: 256, μ: 21820, ~: 21611)
+ERC2981Test:testFuzzSetDefaultRoyaltyTooHighFeeNumerator(uint96) (runs: 256, μ: 21844, ~: 21611)
 ERC2981Test:testFuzzSetTokenRoyaltyInvalidReceiver(address) (runs: 256, μ: 18626, ~: 18626)
 ERC2981Test:testFuzzSetTokenRoyaltyNonOwner(address) (runs: 256, μ: 15565, ~: 15565)
-ERC2981Test:testFuzzSetTokenRoyaltyTooHighFeeNumerator(uint96) (runs: 256, μ: 21861, ~: 21652)
+ERC2981Test:testFuzzSetTokenRoyaltyTooHighFeeNumerator(uint96) (runs: 256, μ: 21885, ~: 21652)
 ERC2981Test:testFuzzTransferOwnershipNonOwner(address,address) (runs: 256, μ: 14039, ~: 14039)
 ERC2981Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 29577, ~: 29577)
 ERC2981Test:testHasOwner() (gas: 9688)
@@ -388,8 +388,8 @@ ERC2981Test:testSupportsInterfaceSuccessGasCost() (gas: 6345)
 ERC2981Test:testTransferOwnershipNonOwner() (gas: 12649)
 ERC2981Test:testTransferOwnershipSuccess() (gas: 22091)
 ERC2981Test:testTransferOwnershipToZeroAddress() (gas: 15557)
-ERC4626VaultInvariants:invariantTotalAssets() (runs: 256, calls: 3840, reverts: 3287)
-ERC4626VaultInvariants:invariantTotalSupply() (runs: 256, calls: 3840, reverts: 3287)
+ERC4626VaultInvariants:invariantTotalAssets() (runs: 256, calls: 3840, reverts: 3243)
+ERC4626VaultInvariants:invariantTotalSupply() (runs: 256, calls: 3840, reverts: 3243)
 ERC4626VaultTest:testCachedDomainSeparator() (gas: 7676)
 ERC4626VaultTest:testDepositInsufficientAllowance() (gas: 82425)
 ERC4626VaultTest:testDepositWithNoApproval() (gas: 24740)
@@ -400,12 +400,12 @@ ERC4626VaultTest:testEmptyVaultDeposit() (gas: 556789)
 ERC4626VaultTest:testEmptyVaultMint() (gas: 557600)
 ERC4626VaultTest:testEmptyVaultRedeem() (gas: 191988)
 ERC4626VaultTest:testEmptyVaultwithdraw() (gas: 204833)
-ERC4626VaultTest:testFail_redeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 556559, ~: 559013)
-ERC4626VaultTest:testFail_withdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 558305, ~: 560854)
-ERC4626VaultTest:testFuzzDomainSeparator(uint8) (runs: 256, μ: 11555, ~: 11577)
+ERC4626VaultTest:testFail_redeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 555267, ~: 558733)
+ERC4626VaultTest:testFail_withdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 557151, ~: 560574)
+ERC4626VaultTest:testFuzzDomainSeparator(uint8) (runs: 256, μ: 11557, ~: 11577)
 ERC4626VaultTest:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19367, ~: 19328)
-ERC4626VaultTest:testFuzzPermitInvalid(string,string,uint16) (runs: 256, μ: 45318, ~: 45349)
-ERC4626VaultTest:testFuzzPermitSuccess(string,string,uint16) (runs: 256, μ: 70305, ~: 70336)
+ERC4626VaultTest:testFuzzPermitInvalid(string,string,uint16) (runs: 256, μ: 45211, ~: 45209)
+ERC4626VaultTest:testFuzzPermitSuccess(string,string,uint16) (runs: 256, μ: 70194, ~: 70190)
 ERC4626VaultTest:testInitialSetup() (gas: 5784605)
 ERC4626VaultTest:testMintWithNoApproval() (gas: 24769)
 ERC4626VaultTest:testMintZero() (gas: 37196)
@@ -424,32 +424,32 @@ ERC4626VaultTest:testVaultInteractionsForSomeoneElse() (gas: 221714)
 ERC4626VaultTest:testWithdrawInsufficientAllowance() (gas: 122543)
 ERC4626VaultTest:testWithdrawInsufficientAssets() (gas: 117830)
 ERC4626VaultTest:testWithdrawWithNoAssets() (gas: 21327)
-ERC4626VaultTest:test_RT_deposit_redeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 471961, ~: 476819)
-ERC4626VaultTest:test_RT_deposit_withdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 475339, ~: 478584)
-ERC4626VaultTest:test_RT_mint_redeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 473219, ~: 477074)
-ERC4626VaultTest:test_RT_mint_withdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 474765, ~: 478503)
-ERC4626VaultTest:test_RT_redeem_deposit((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 473322, ~: 477054)
-ERC4626VaultTest:test_RT_redeem_mint((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 473671, ~: 477266)
-ERC4626VaultTest:test_RT_withdraw_deposit((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 474985, ~: 478675)
-ERC4626VaultTest:test_RT_withdraw_mint((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 475125, ~: 479028)
-ERC4626VaultTest:test_asset((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423570, ~: 427926)
-ERC4626VaultTest:test_convertToAssets((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 430186, ~: 432725)
-ERC4626VaultTest:test_convertToShares((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 429075, ~: 432608)
-ERC4626VaultTest:test_deposit((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 470557, ~: 472955)
-ERC4626VaultTest:test_maxDeposit((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423583, ~: 427939)
-ERC4626VaultTest:test_maxMint((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423608, ~: 427964)
-ERC4626VaultTest:test_maxRedeem((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423723, ~: 428078)
-ERC4626VaultTest:test_maxWithdraw((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 425256, ~: 429594)
-ERC4626VaultTest:test_mint((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 471159, ~: 473431)
-ERC4626VaultTest:test_previewDeposit((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 464685, ~: 469176)
-ERC4626VaultTest:test_previewMint((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 465886, ~: 469620)
-ERC4626VaultTest:test_previewRedeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 467821, ~: 471173)
-ERC4626VaultTest:test_previewWithdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 470824, ~: 472793)
-ERC4626VaultTest:test_redeem((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 473319, ~: 475686)
-ERC4626VaultTest:test_totalAssets((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 424174, ~: 428528)
-ERC4626VaultTest:test_withdraw((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 475521, ~: 476893)
-ERC721Invariants:invariantOwner() (runs: 256, calls: 3840, reverts: 3501)
-ERC721Invariants:invariantTotalSupply() (runs: 256, calls: 3840, reverts: 3501)
+ERC4626VaultTest:test_RT_deposit_redeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 473911, ~: 476508)
+ERC4626VaultTest:test_RT_deposit_withdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 475953, ~: 478397)
+ERC4626VaultTest:test_RT_mint_redeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 475106, ~: 476716)
+ERC4626VaultTest:test_RT_mint_withdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 477101, ~: 478648)
+ERC4626VaultTest:test_RT_redeem_deposit((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 473890, ~: 476603)
+ERC4626VaultTest:test_RT_redeem_mint((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 474355, ~: 477170)
+ERC4626VaultTest:test_RT_withdraw_deposit((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 475542, ~: 478469)
+ERC4626VaultTest:test_RT_withdraw_mint((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 476818, ~: 479012)
+ERC4626VaultTest:test_asset((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423304, ~: 427693)
+ERC4626VaultTest:test_convertToAssets((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 429214, ~: 432864)
+ERC4626VaultTest:test_convertToShares((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 428602, ~: 432600)
+ERC4626VaultTest:test_deposit((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 469338, ~: 472753)
+ERC4626VaultTest:test_maxDeposit((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423317, ~: 427705)
+ERC4626VaultTest:test_maxMint((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423342, ~: 427730)
+ERC4626VaultTest:test_maxRedeem((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423456, ~: 427845)
+ERC4626VaultTest:test_maxWithdraw((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 424997, ~: 429456)
+ERC4626VaultTest:test_mint((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 470021, ~: 473011)
+ERC4626VaultTest:test_previewDeposit((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 466416, ~: 469052)
+ERC4626VaultTest:test_previewMint((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 468029, ~: 469716)
+ERC4626VaultTest:test_previewRedeem((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 468559, ~: 471074)
+ERC4626VaultTest:test_previewWithdraw((address[4],uint256[4],uint256[4],int256),uint256) (runs: 256, μ: 471004, ~: 472277)
+ERC4626VaultTest:test_redeem((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 472566, ~: 475359)
+ERC4626VaultTest:test_totalAssets((address[4],uint256[4],uint256[4],int256)) (runs: 256, μ: 423906, ~: 428294)
+ERC4626VaultTest:test_withdraw((address[4],uint256[4],uint256[4],int256),uint256,uint256) (runs: 256, μ: 474016, ~: 476378)
+ERC721Invariants:invariantOwner() (runs: 256, calls: 3840, reverts: 3469)
+ERC721Invariants:invariantTotalSupply() (runs: 256, calls: 3840, reverts: 3469)
 ERC721Test:testApproveClearingApprovalWithNoPriorApproval() (gas: 177294)
 ERC721Test:testApproveClearingApprovalWithPriorApproval() (gas: 185988)
 ERC721Test:testApproveFromApprovedAddress() (gas: 199707)
@@ -470,30 +470,30 @@ ERC721Test:testCachedDomainSeparator() (gas: 7699)
 ERC721Test:testDomainSeparator() (gas: 11450)
 ERC721Test:testEIP712Domain() (gas: 13877)
 ERC721Test:testFuzzApproveClearingApprovalWithNoPriorApproval(address,address) (runs: 256, μ: 196799, ~: 196799)
-ERC721Test:testFuzzApproveClearingApprovalWithPriorApproval(address,address) (runs: 256, μ: 184062, ~: 184072)
+ERC721Test:testFuzzApproveClearingApprovalWithPriorApproval(address,address) (runs: 256, μ: 184072, ~: 184072)
 ERC721Test:testFuzzApproveFromNonOwner(address) (runs: 256, μ: 172895, ~: 172895)
 ERC721Test:testFuzzApproveFromOperatorAddress(address,address,address) (runs: 256, μ: 222958, ~: 222958)
 ERC721Test:testFuzzApproveWithNoPriorApproval(address,address) (runs: 256, μ: 196754, ~: 196754)
 ERC721Test:testFuzzApproveWithPriorApproval(address,address) (runs: 256, μ: 203884, ~: 203884)
-ERC721Test:testFuzzBurnSuccess(address) (runs: 256, μ: 305614, ~: 305600)
-ERC721Test:testFuzzDomainSeparator(uint8) (runs: 256, μ: 11643, ~: 11663)
-ERC721Test:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19578, ~: 19542)
+ERC721Test:testFuzzBurnSuccess(address) (runs: 256, μ: 305616, ~: 305600)
+ERC721Test:testFuzzDomainSeparator(uint8) (runs: 256, μ: 11641, ~: 11663)
+ERC721Test:testFuzzEIP712Domain(bytes1,uint8,bytes32,uint256[]) (runs: 256, μ: 19581, ~: 19542)
 ERC721Test:testFuzzGetApprovedApprovedTokenId(address,address) (runs: 256, μ: 194385, ~: 194385)
-ERC721Test:testFuzzPermitInvalid(string,string,uint16) (runs: 256, μ: 201779, ~: 201808)
-ERC721Test:testFuzzPermitSuccess(string,string,uint16) (runs: 256, μ: 227244, ~: 227279)
+ERC721Test:testFuzzPermitInvalid(string,string,uint16) (runs: 256, μ: 201667, ~: 201665)
+ERC721Test:testFuzzPermitSuccess(string,string,uint16) (runs: 256, μ: 227137, ~: 227133)
 ERC721Test:testFuzzRenounceOwnershipNonOwner(address) (runs: 256, μ: 13938, ~: 13938)
-ERC721Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 48379, ~: 48364)
+ERC721Test:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 48380, ~: 48364)
 ERC721Test:testFuzzSafeMintNonMinter(address) (runs: 256, μ: 15894, ~: 15894)
-ERC721Test:testFuzzSafeMintSuccess(address[]) (runs: 256, μ: 21195241, ~: 20542690)
-ERC721Test:testFuzzSafeTransferFromWithData(address,address,address,bytes) (runs: 256, μ: 1428634, ~: 1429724)
+ERC721Test:testFuzzSafeMintSuccess(address[]) (runs: 256, μ: 20692774, ~: 20004472)
+ERC721Test:testFuzzSafeTransferFromWithData(address,address,address,bytes) (runs: 256, μ: 1429056, ~: 1429893)
 ERC721Test:testFuzzSetApprovalForAllSuccess(address,address) (runs: 256, μ: 188481, ~: 188481)
-ERC721Test:testFuzzSetMinterNonOwner(address,string) (runs: 256, μ: 15879, ~: 15895)
-ERC721Test:testFuzzSetMinterSuccess(string) (runs: 256, μ: 33247, ~: 33240)
-ERC721Test:testFuzzTokenByIndex(address,string[]) (runs: 256, μ: 24430305, ~: 25067709)
-ERC721Test:testFuzzTotalSupply(address,string[]) (runs: 256, μ: 24291533, ~: 24925886)
-ERC721Test:testFuzzTransferFrom(address,address,address) (runs: 256, μ: 560099, ~: 560080)
+ERC721Test:testFuzzSetMinterNonOwner(address,string) (runs: 256, μ: 15822, ~: 15749)
+ERC721Test:testFuzzSetMinterSuccess(string) (runs: 256, μ: 33217, ~: 33216)
+ERC721Test:testFuzzTokenByIndex(address,string[]) (runs: 256, μ: 21215507, ~: 21172166)
+ERC721Test:testFuzzTotalSupply(address,string[]) (runs: 256, μ: 21087302, ~: 21043655)
+ERC721Test:testFuzzTransferFrom(address,address,address) (runs: 256, μ: 560103, ~: 560080)
 ERC721Test:testFuzzTransferOwnershipNonOwner(address,address) (runs: 256, μ: 14090, ~: 14090)
-ERC721Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 73921, ~: 73894)
+ERC721Test:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 73919, ~: 73892)
 ERC721Test:testGetApprovedApprovedTokenId() (gas: 194287)
 ERC721Test:testGetApprovedInvalidTokenId() (gas: 11097)
 ERC721Test:testGetApprovedNotApprovedTokenId() (gas: 170525)
@@ -511,22 +511,22 @@ ERC721Test:testRenounceOwnershipNonOwner() (gas: 10944)
 ERC721Test:testRenounceOwnershipSuccess() (gas: 22143)
 ERC721Test:testSafeMintNonMinter() (gas: 13225)
 ERC721Test:testSafeMintOverflow() (gas: 15488)
-ERC721Test:testSafeMintReceiverContract() (gas: 388074)
+ERC721Test:testSafeMintReceiverContract() (gas: 388274)
 ERC721Test:testSafeMintReceiverContractFunctionNotImplemented() (gas: 116165)
-ERC721Test:testSafeMintReceiverContractInvalidReturnIdentifier() (gas: 340201)
-ERC721Test:testSafeMintReceiverContractRevertsWithMessage() (gas: 337495)
-ERC721Test:testSafeMintReceiverContractRevertsWithPanic() (gas: 337738)
-ERC721Test:testSafeMintReceiverContractRevertsWithoutMessage() (gas: 337125)
+ERC721Test:testSafeMintReceiverContractInvalidReturnIdentifier() (gas: 340401)
+ERC721Test:testSafeMintReceiverContractRevertsWithMessage() (gas: 337695)
+ERC721Test:testSafeMintReceiverContractRevertsWithPanic() (gas: 337938)
+ERC721Test:testSafeMintReceiverContractRevertsWithoutMessage() (gas: 337325)
 ERC721Test:testSafeMintSuccess() (gas: 524242)
 ERC721Test:testSafeMintToZeroAddress() (gas: 38430)
 ERC721Test:testSafeMintTokenAlreadyMinted() (gas: 363393)
-ERC721Test:testSafeTransferFromNoData() (gas: 1429232)
+ERC721Test:testSafeTransferFromNoData() (gas: 1429392)
 ERC721Test:testSafeTransferFromReceiverFunctionNotImplemented() (gas: 181184)
-ERC721Test:testSafeTransferFromReceiverInvalidReturnIdentifier() (gas: 405251)
-ERC721Test:testSafeTransferFromReceiverRevertsWithMessage() (gas: 402525)
-ERC721Test:testSafeTransferFromReceiverRevertsWithPanic() (gas: 402791)
-ERC721Test:testSafeTransferFromReceiverRevertsWithoutMessage() (gas: 402155)
-ERC721Test:testSafeTransferFromWithData() (gas: 1194512)
+ERC721Test:testSafeTransferFromReceiverInvalidReturnIdentifier() (gas: 405451)
+ERC721Test:testSafeTransferFromReceiverRevertsWithMessage() (gas: 402725)
+ERC721Test:testSafeTransferFromReceiverRevertsWithPanic() (gas: 402991)
+ERC721Test:testSafeTransferFromReceiverRevertsWithoutMessage() (gas: 402355)
+ERC721Test:testSafeTransferFromWithData() (gas: 1194672)
 ERC721Test:testSetApprovalForAllOperatorIsOwner() (gas: 167663)
 ERC721Test:testSetApprovalForAllSuccessCase1() (gas: 195887)
 ERC721Test:testSetApprovalForAllSuccessCase2() (gas: 188412)
@@ -556,19 +556,19 @@ ERC721Test:testTransferOwnershipToZeroAddress() (gas: 15608)
 MathTest:testCbrtRoundDown() (gas: 41439)
 MathTest:testCbrtRoundUp() (gas: 42219)
 MathTest:testCeilDiv() (gas: 12525)
-MathTest:testFuzzCbrt(uint256,bool) (runs: 256, μ: 19323, ~: 19011)
+MathTest:testFuzzCbrt(uint256,bool) (runs: 256, μ: 19461, ~: 19248)
 MathTest:testFuzzCeilDiv(uint256,uint256) (runs: 256, μ: 8984, ~: 9001)
 MathTest:testFuzzInt256Average(int256,int256) (runs: 256, μ: 5572, ~: 5572)
 MathTest:testFuzzIsNegative(int256) (runs: 256, μ: 5646, ~: 5646)
-MathTest:testFuzzLog10(uint256,bool) (runs: 256, μ: 7063, ~: 7284)
-MathTest:testFuzzLog2(uint256,bool) (runs: 256, μ: 6940, ~: 7087)
-MathTest:testFuzzLog256(uint256,bool) (runs: 256, μ: 6981, ~: 7226)
-MathTest:testFuzzMulDiv(uint256,uint256,uint256) (runs: 256, μ: 12933, ~: 12671)
-MathTest:testFuzzMulDivDomain(uint256,uint256,uint256) (runs: 256, μ: 10507, ~: 10592)
+MathTest:testFuzzLog10(uint256,bool) (runs: 256, μ: 6969, ~: 6961)
+MathTest:testFuzzLog2(uint256,bool) (runs: 256, μ: 6847, ~: 6823)
+MathTest:testFuzzLog256(uint256,bool) (runs: 256, μ: 6869, ~: 6840)
+MathTest:testFuzzMulDiv(uint256,uint256,uint256) (runs: 256, μ: 12919, ~: 12671)
+MathTest:testFuzzMulDivDomain(uint256,uint256,uint256) (runs: 256, μ: 10509, ~: 10592)
 MathTest:testFuzzUint256Average(uint256,uint256) (runs: 256, μ: 5785, ~: 5785)
-MathTest:testFuzzWadCbrt(uint256) (runs: 256, μ: 19006, ~: 18703)
+MathTest:testFuzzWadCbrt(uint256) (runs: 256, μ: 18999, ~: 18667)
 MathTest:testFuzzWadExp(int256) (runs: 256, μ: 15199, ~: 15267)
-MathTest:testFuzzWadLn(int256) (runs: 256, μ: 16738, ~: 16533)
+MathTest:testFuzzWadLn(int256) (runs: 256, μ: 16714, ~: 16511)
 MathTest:testInt256Average() (gas: 11898)
 MathTest:testIsNegative() (gas: 10280)
 MathTest:testLog10RoundDown() (gas: 17707)
@@ -589,9 +589,9 @@ MathTest:testWadExp() (gas: 23617)
 MathTest:testWadExpOverflow() (gas: 11149)
 MathTest:testWadLn() (gas: 24196)
 MathTest:testWadLnNegativeValues() (gas: 11130)
-MerkleProofVerificationTest:testFuzzMultiProofVerifySingleLeaf(bytes32[],uint256) (runs: 256, μ: 1649976158, ~: 1649972549)
-MerkleProofVerificationTest:testFuzzVerify(bytes32[],uint256) (runs: 256, μ: 135974870, ~: 135971337)
-MerkleProofVerificationTest:testFuzzVerifyMultiProofMultipleLeaves(bool,bool,bool) (runs: 256, μ: 412472402, ~: 412472337)
+MerkleProofVerificationTest:testFuzzMultiProofVerifySingleLeaf(bytes32[],uint256) (runs: 256, μ: 1649976158, ~: 1649972664)
+MerkleProofVerificationTest:testFuzzVerify(bytes32[],uint256) (runs: 256, μ: 135974870, ~: 135971452)
+MerkleProofVerificationTest:testFuzzVerifyMultiProofMultipleLeaves(bool,bool,bool) (runs: 256, μ: 412472467, ~: 412472462)
 MerkleProofVerificationTest:testInvalidMerkleMultiProof() (gas: 412478415)
 MerkleProofVerificationTest:testInvalidMerkleProof() (gas: 33970390)
 MerkleProofVerificationTest:testInvalidMerkleProofLength() (gas: 33972548)
@@ -615,10 +615,10 @@ Ownable2StepInvariants:invariantPendingOwner() (runs: 256, calls: 3840, reverts:
 Ownable2StepTest:testAcceptOwnershipNonPendingOwner() (gas: 46604)
 Ownable2StepTest:testAcceptOwnershipSuccess() (gas: 39404)
 Ownable2StepTest:testFuzzAcceptOwnershipNonPendingOwner(address) (runs: 256, μ: 45814, ~: 45814)
-Ownable2StepTest:testFuzzAcceptOwnershipSuccess(address,address) (runs: 256, μ: 65110, ~: 65086)
-Ownable2StepTest:testFuzzPendingOwnerResetAfterRenounceOwnership(address) (runs: 256, μ: 38750, ~: 38735)
+Ownable2StepTest:testFuzzAcceptOwnershipSuccess(address,address) (runs: 256, μ: 65112, ~: 65084)
+Ownable2StepTest:testFuzzPendingOwnerResetAfterRenounceOwnership(address) (runs: 256, μ: 38752, ~: 38735)
 Ownable2StepTest:testFuzzRenounceOwnershipNonOwner(address) (runs: 256, μ: 13954, ~: 13954)
-Ownable2StepTest:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 43683, ~: 43668)
+Ownable2StepTest:testFuzzRenounceOwnershipSuccess(address) (runs: 256, μ: 43685, ~: 43668)
 Ownable2StepTest:testFuzzTransferOwnershipNonOwner(address,address) (runs: 256, μ: 14106, ~: 14106)
 Ownable2StepTest:testFuzzTransferOwnershipSuccess(address,address) (runs: 256, μ: 50453, ~: 50453)
 Ownable2StepTest:testHasOwner() (gas: 9668)
@@ -641,7 +641,7 @@ OwnableTest:testTransferOwnershipNonOwner() (gas: 12559)
 OwnableTest:testTransferOwnershipSuccess() (gas: 22022)
 OwnableTest:testTransferOwnershipToZeroAddress() (gas: 15511)
 SignatureCheckerTest:testEIP1271NoIsValidSignatureFunction() (gas: 22878)
-SignatureCheckerTest:testEIP1271WithInvalidSignature(bytes,string) (runs: 256, μ: 23436, ~: 23429)
+SignatureCheckerTest:testEIP1271WithInvalidSignature(bytes,string) (runs: 256, μ: 23432, ~: 23429)
 SignatureCheckerTest:testEIP1271WithInvalidSignature1() (gas: 33840)
 SignatureCheckerTest:testEIP1271WithInvalidSignature2() (gas: 29807)
 SignatureCheckerTest:testEIP1271WithInvalidSigner() (gas: 33940)
@@ -652,8 +652,8 @@ SignatureCheckerTest:testEOAWithInvalidSignature2() (gas: 21022)
 SignatureCheckerTest:testEOAWithInvalidSigner() (gas: 20447)
 SignatureCheckerTest:testEOAWithTooHighSValue() (gas: 18068)
 SignatureCheckerTest:testEOAWithValidSignature() (gas: 19572)
-SignatureCheckerTest:testFuzzEIP1271WithInvalidSigner(string,string) (runs: 256, μ: 35890, ~: 35896)
-SignatureCheckerTest:testFuzzEIP1271WithValidSignature(string) (runs: 256, μ: 34432, ~: 34434)
-SignatureCheckerTest:testFuzzEOAWithInvalidSignature(bytes,string) (runs: 256, μ: 16841, ~: 16836)
-SignatureCheckerTest:testFuzzEOAWithInvalidSigner(string,string) (runs: 256, μ: 21524, ~: 21527)
-SignatureCheckerTest:testFuzzEOAWithValidSignature(string,string) (runs: 256, μ: 20665, ~: 20668)
\ No newline at end of file
+SignatureCheckerTest:testFuzzEIP1271WithInvalidSigner(string,string) (runs: 256, μ: 35830, ~: 35896)
+SignatureCheckerTest:testFuzzEIP1271WithValidSignature(string) (runs: 256, μ: 34428, ~: 34422)
+SignatureCheckerTest:testFuzzEOAWithInvalidSignature(bytes,string) (runs: 256, μ: 16837, ~: 16836)
+SignatureCheckerTest:testFuzzEOAWithInvalidSigner(string,string) (runs: 256, μ: 21466, ~: 21527)
+SignatureCheckerTest:testFuzzEOAWithValidSignature(string,string) (runs: 256, μ: 20607, ~: 20668)
\ No newline at end of file
diff --git a/.github/workflows/checks.yml b/.github/workflows/checks.yml
index 248409cc..aad956fc 100644
--- a/.github/workflows/checks.yml
+++ b/.github/workflows/checks.yml
@@ -15,7 +15,7 @@ jobs:
           - ubuntu-latest
         architecture:
           - x64
-        python-version:
+        python_version:
           - 3.11
         node_version:
           - 18
@@ -51,7 +51,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ matrix.python_version }}
           architecture: ${{ matrix.architecture }}
 
       - name: Check formatting with Black
@@ -83,7 +83,7 @@ jobs:
       matrix:
         os:
           - ubuntu-latest
-        ruby-version:
+        ruby_version:
           - 3.2
 
     steps:
@@ -93,7 +93,7 @@ jobs:
       - name: Set up Ruby
         uses: ruby/setup-ruby@v1
         with:
-          ruby-version: ${{ matrix.ruby-version }}
+          ruby-version: ${{ matrix.ruby_version }}
           bundler-cache: true
 
       - name: Install awesome_bot
diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml
index 2d230dcc..82cd1d7e 100644
--- a/.github/workflows/publish-pypi.yml
+++ b/.github/workflows/publish-pypi.yml
@@ -19,7 +19,7 @@ jobs:
           - ubuntu-latest
         architecture:
           - x64
-        python-version:
+        python_version:
           - 3.11
 
     steps:
@@ -29,7 +29,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ matrix.python_version }}
           architecture: ${{ matrix.architecture }}
 
       - name: Install pypa/build
diff --git a/foundry.toml b/foundry.toml
index 466e20c9..26ec3a95 100644
--- a/foundry.toml
+++ b/foundry.toml
@@ -13,6 +13,7 @@ invariant = { runs = 256 }                                  # the number of runs
 ffi = true                                                  # whether to enable foreign function interface (ffi) cheatcodes or not
 verbosity = 3                                               # the verbosity of tests
 fs_permissions = [{ access = "read-write", path = "./"}]    # set read-write access to project root
+solc_version = '0.8.22'                                     # override for the solc version
 evm_version = 'shanghai'                                    # set the EVM target version
 
 ## default overrides for the CI runs
diff --git a/lib/create-util b/lib/create-util
index a72e3635..700e40d4 160000
--- a/lib/create-util
+++ b/lib/create-util
@@ -1,1 +1,1 @@
-Subproject commit a72e36353e8c8b6fdb80d7553c16291dab303304
+Subproject commit 700e40d4a0708d70f8545887d28187e8244b1081
diff --git a/lib/forge-std b/lib/forge-std
index 6d27cc06..267acd30 160000
--- a/lib/forge-std
+++ b/lib/forge-std
@@ -1,1 +1,1 @@
-Subproject commit 6d27cc06fb2668965cbbc533d6ac3385c91a19a3
+Subproject commit 267acd30a625086b3f16e1a28cfe0c5097fa46b8
diff --git a/lib/solady b/lib/solady
index fe918e7d..5a08b367 160000
--- a/lib/solady
+++ b/lib/solady
@@ -1,1 +1,1 @@
-Subproject commit fe918e7d7b560dee66e657f49ef75645ec10f2e4
+Subproject commit 5a08b36780139180057d488ab410999dbd37190b
diff --git a/lib/utils/VyperDeployer.sol b/lib/utils/VyperDeployer.sol
index 36ee4e6f..5f1ce434 100644
--- a/lib/utils/VyperDeployer.sol
+++ b/lib/utils/VyperDeployer.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Create} from "create-util/Create.sol";
 
diff --git a/package.json b/package.json
index d9bc02ff..b8d41d49 100644
--- a/package.json
+++ b/package.json
@@ -39,7 +39,7 @@
     "@openzeppelin/merkle-tree": "^1.0.5",
     "eslint": "^8.52.0",
     "eslint-config-prettier": "^9.0.0",
-    "ethers": "^6.8.0",
+    "ethers": "^6.8.1",
     "keccak256": "^1.0.6",
     "merkletreejs": "^0.3.11",
     "prettier": "^3.0.3",
diff --git a/yarn.lock b/yarn.lock
index e4fd1cb3..c96cc821 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -874,10 +874,10 @@ ethereum-cryptography@^2.0.0, ethereum-cryptography@^2.1.2:
     "@scure/bip32" "1.3.1"
     "@scure/bip39" "1.2.1"
 
-ethers@^6.8.0:
-  version "6.8.0"
-  resolved "https://registry.yarnpkg.com/ethers/-/ethers-6.8.0.tgz#0a26f57e96fd697cefcfcef464e0c325689d1daf"
-  integrity sha512-zrFbmQRlraM+cU5mE4CZTLBurZTs2gdp2ld0nG/f3ecBK+x6lZ69KSxBqZ4NjclxwfTxl5LeNufcBbMsTdY53Q==
+ethers@^6.8.1:
+  version "6.8.1"
+  resolved "https://registry.yarnpkg.com/ethers/-/ethers-6.8.1.tgz#ee2a1a39b5f62a13678f90ccd879175391d0a2b4"
+  integrity sha512-iEKm6zox5h1lDn6scuRWdIdFJUCGg3+/aQWu0F4K0GVyEZiktFkqrJbRjTn1FlYEPz7RKA707D6g5Kdk6j7Ljg==
   dependencies:
     "@adraffy/ens-normalize" "1.10.0"
     "@noble/curves" "1.2.0"


Test patch:
diff --git a/.github/workflows/publish-test-pypi.yml b/.github/workflows/publish-test-pypi.yml
index 53a3820c..dd273be3 100644
--- a/.github/workflows/publish-test-pypi.yml
+++ b/.github/workflows/publish-test-pypi.yml
@@ -16,7 +16,7 @@ jobs:
           - ubuntu-latest
         architecture:
           - x64
-        python-version:
+        python_version:
           - 3.11
 
     steps:
@@ -26,7 +26,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ matrix.python_version }}
           architecture: ${{ matrix.architecture }}
 
       - name: Install pypa/build
diff --git a/.github/workflows/test-contracts.yml b/.github/workflows/test-contracts.yml
index fc428339..3c9bace6 100644
--- a/.github/workflows/test-contracts.yml
+++ b/.github/workflows/test-contracts.yml
@@ -15,7 +15,7 @@ jobs:
           - ubuntu-latest
         architecture:
           - x64
-        python-version:
+        python_version:
           - 3.11
         node_version:
           - 18
@@ -29,7 +29,7 @@ jobs:
       - name: Setup Python
         uses: actions/setup-python@v4
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ matrix.python_version }}
           architecture: ${{ matrix.architecture }}
 
       - name: Install Vyper
@@ -41,7 +41,7 @@ jobs:
       - name: Setup Ape
         uses: ApeWorX/github-action@v2
         with:
-          python-version: ${{ matrix.python-version }}
+          python-version: ${{ matrix.python_version }}
 
       - name: Check Ape compilation
         run: ape compile
diff --git a/test/auth/AccessControl.t.sol b/test/auth/AccessControl.t.sol
index 654e2917..c344add7 100644
--- a/test/auth/AccessControl.t.sol
+++ b/test/auth/AccessControl.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
@@ -21,24 +21,6 @@ contract AccessControlTest is Test {
 
     address private deployer = address(vyperDeployer);
 
-    event RoleAdminChanged(
-        bytes32 indexed role,
-        bytes32 indexed previousAdminRole,
-        bytes32 indexed newAdminRole
-    );
-
-    event RoleGranted(
-        bytes32 indexed role,
-        address indexed account,
-        address indexed sender
-    );
-
-    event RoleRevoked(
-        bytes32 indexed role,
-        address indexed account,
-        address indexed sender
-    );
-
     function setUp() public {
         accessControl = IAccessControlExtended(
             vyperDeployer.deployContract("src/auth/", "AccessControl")
@@ -66,11 +48,11 @@ contract AccessControlTest is Test {
         );
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(DEFAULT_ADMIN_ROLE, deployer, deployer);
+        emit IAccessControl.RoleGranted(DEFAULT_ADMIN_ROLE, deployer, deployer);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, deployer, deployer);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, deployer, deployer);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_2, deployer, deployer);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_2, deployer, deployer);
         accessControlInitialEvent = IAccessControlExtended(
             vyperDeployer.deployContract("src/auth/", "AccessControl")
         );
@@ -144,7 +126,7 @@ contract AccessControlTest is Test {
         address account = makeAddr("account");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -155,7 +137,7 @@ contract AccessControlTest is Test {
         address account = makeAddr("account");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(DEFAULT_ADMIN_ROLE, account, admin);
+        emit IAccessControl.RoleGranted(DEFAULT_ADMIN_ROLE, account, admin);
         accessControl.grantRole(DEFAULT_ADMIN_ROLE, account);
         assertTrue(accessControl.hasRole(DEFAULT_ADMIN_ROLE, account));
         vm.stopPrank();
@@ -166,7 +148,7 @@ contract AccessControlTest is Test {
         address account = makeAddr("account");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
@@ -192,12 +174,12 @@ contract AccessControlTest is Test {
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
         accessControl.revokeRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -208,12 +190,12 @@ contract AccessControlTest is Test {
         address account = makeAddr("account");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
         accessControl.revokeRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
@@ -230,7 +212,7 @@ contract AccessControlTest is Test {
         vm.startPrank(admin);
         assertTrue(accessControl.hasRole(DEFAULT_ADMIN_ROLE, admin));
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(DEFAULT_ADMIN_ROLE, admin, admin);
+        emit IAccessControl.RoleRevoked(DEFAULT_ADMIN_ROLE, admin, admin);
         accessControl.revokeRole(DEFAULT_ADMIN_ROLE, admin);
         assertTrue(!accessControl.hasRole(DEFAULT_ADMIN_ROLE, admin));
 
@@ -249,7 +231,7 @@ contract AccessControlTest is Test {
         address account = makeAddr("account");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -260,7 +242,7 @@ contract AccessControlTest is Test {
         assertTrue(!accessControl.hasRole(DEFAULT_ADMIN_ROLE, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, account);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, account);
         accessControl.renounceRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -271,7 +253,7 @@ contract AccessControlTest is Test {
         address account = makeAddr("account");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -282,7 +264,7 @@ contract AccessControlTest is Test {
         assertTrue(!accessControl.hasRole(DEFAULT_ADMIN_ROLE, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, account);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, account);
         accessControl.renounceRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
@@ -299,7 +281,7 @@ contract AccessControlTest is Test {
         vm.startPrank(admin);
         assertTrue(accessControl.hasRole(DEFAULT_ADMIN_ROLE, admin));
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(DEFAULT_ADMIN_ROLE, admin, admin);
+        emit IAccessControl.RoleRevoked(DEFAULT_ADMIN_ROLE, admin, admin);
         accessControl.renounceRole(DEFAULT_ADMIN_ROLE, admin);
         assertTrue(!accessControl.hasRole(DEFAULT_ADMIN_ROLE, admin));
 
@@ -322,7 +304,7 @@ contract AccessControlTest is Test {
         bytes32 otherAdminRole = keccak256("OTHER_ADMIN_ROLE");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleAdminChanged(
+        emit IAccessControl.RoleAdminChanged(
             ADDITIONAL_ROLE_1,
             DEFAULT_ADMIN_ROLE,
             otherAdminRole
@@ -330,7 +312,7 @@ contract AccessControlTest is Test {
         accessControl.set_role_admin(ADDITIONAL_ROLE_1, otherAdminRole);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(otherAdminRole, otherAdmin, admin);
+        emit IAccessControl.RoleGranted(otherAdminRole, otherAdmin, admin);
         accessControl.grantRole(otherAdminRole, otherAdmin);
         assertTrue(accessControl.hasRole(otherAdminRole, otherAdmin));
         vm.stopPrank();
@@ -338,12 +320,12 @@ contract AccessControlTest is Test {
         vm.startPrank(otherAdmin);
         assertEq(accessControl.getRoleAdmin(ADDITIONAL_ROLE_1), otherAdminRole);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, otherAdmin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, otherAdmin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, otherAdmin);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, otherAdmin);
         accessControl.revokeRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -356,7 +338,7 @@ contract AccessControlTest is Test {
         bytes32 otherAdminRole = keccak256("OTHER_ADMIN_ROLE");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleAdminChanged(
+        emit IAccessControl.RoleAdminChanged(
             ADDITIONAL_ROLE_1,
             DEFAULT_ADMIN_ROLE,
             otherAdminRole
@@ -364,7 +346,7 @@ contract AccessControlTest is Test {
         accessControl.set_role_admin(ADDITIONAL_ROLE_1, otherAdminRole);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(otherAdminRole, otherAdmin, admin);
+        emit IAccessControl.RoleGranted(otherAdminRole, otherAdmin, admin);
         accessControl.grantRole(otherAdminRole, otherAdmin);
         assertTrue(accessControl.hasRole(otherAdminRole, otherAdmin));
 
@@ -382,7 +364,7 @@ contract AccessControlTest is Test {
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleAdminChanged(
+        emit IAccessControl.RoleAdminChanged(
             ADDITIONAL_ROLE_1,
             DEFAULT_ADMIN_ROLE,
             otherAdminRole
@@ -390,7 +372,7 @@ contract AccessControlTest is Test {
         accessControl.set_role_admin(ADDITIONAL_ROLE_1, otherAdminRole);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(otherAdminRole, otherAdmin, admin);
+        emit IAccessControl.RoleGranted(otherAdminRole, otherAdmin, admin);
         accessControl.grantRole(otherAdminRole, otherAdmin);
         assertTrue(accessControl.hasRole(otherAdminRole, otherAdmin));
 
@@ -404,7 +386,7 @@ contract AccessControlTest is Test {
         address admin = deployer;
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -415,7 +397,7 @@ contract AccessControlTest is Test {
         address admin = deployer;
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(DEFAULT_ADMIN_ROLE, account, admin);
+        emit IAccessControl.RoleGranted(DEFAULT_ADMIN_ROLE, account, admin);
         accessControl.grantRole(DEFAULT_ADMIN_ROLE, account);
         assertTrue(accessControl.hasRole(DEFAULT_ADMIN_ROLE, account));
         vm.stopPrank();
@@ -426,7 +408,7 @@ contract AccessControlTest is Test {
         address admin = deployer;
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
@@ -457,12 +439,12 @@ contract AccessControlTest is Test {
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
         accessControl.revokeRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -473,12 +455,12 @@ contract AccessControlTest is Test {
         address admin = deployer;
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, admin);
         accessControl.revokeRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
@@ -505,7 +487,7 @@ contract AccessControlTest is Test {
         address admin = deployer;
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -516,7 +498,7 @@ contract AccessControlTest is Test {
         assertTrue(!accessControl.hasRole(DEFAULT_ADMIN_ROLE, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, account);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, account);
         accessControl.renounceRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -527,7 +509,7 @@ contract AccessControlTest is Test {
         address admin = deployer;
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, admin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, admin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -538,7 +520,7 @@ contract AccessControlTest is Test {
         assertTrue(!accessControl.hasRole(DEFAULT_ADMIN_ROLE, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, account);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, account);
         accessControl.renounceRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
@@ -567,7 +549,7 @@ contract AccessControlTest is Test {
         bytes32 otherAdminRole = keccak256("OTHER_ADMIN_ROLE");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleAdminChanged(
+        emit IAccessControl.RoleAdminChanged(
             ADDITIONAL_ROLE_1,
             DEFAULT_ADMIN_ROLE,
             otherAdminRole
@@ -575,7 +557,7 @@ contract AccessControlTest is Test {
         accessControl.set_role_admin(ADDITIONAL_ROLE_1, otherAdminRole);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(otherAdminRole, otherAdmin, admin);
+        emit IAccessControl.RoleGranted(otherAdminRole, otherAdmin, admin);
         accessControl.grantRole(otherAdminRole, otherAdmin);
         assertTrue(accessControl.hasRole(otherAdminRole, otherAdmin));
         vm.stopPrank();
@@ -583,12 +565,12 @@ contract AccessControlTest is Test {
         vm.startPrank(otherAdmin);
         assertEq(accessControl.getRoleAdmin(ADDITIONAL_ROLE_1), otherAdminRole);
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(ADDITIONAL_ROLE_1, account, otherAdmin);
+        emit IAccessControl.RoleGranted(ADDITIONAL_ROLE_1, account, otherAdmin);
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
         assertTrue(accessControl.hasRole(ADDITIONAL_ROLE_1, account));
 
         vm.expectEmit(true, true, true, false);
-        emit RoleRevoked(ADDITIONAL_ROLE_1, account, otherAdmin);
+        emit IAccessControl.RoleRevoked(ADDITIONAL_ROLE_1, account, otherAdmin);
         accessControl.revokeRole(ADDITIONAL_ROLE_1, account);
         assertTrue(!accessControl.hasRole(ADDITIONAL_ROLE_1, account));
         vm.stopPrank();
@@ -603,7 +585,7 @@ contract AccessControlTest is Test {
         bytes32 otherAdminRole = keccak256("OTHER_ADMIN_ROLE");
         vm.startPrank(admin);
         vm.expectEmit(true, true, true, false);
-        emit RoleAdminChanged(
+        emit IAccessControl.RoleAdminChanged(
             ADDITIONAL_ROLE_1,
             DEFAULT_ADMIN_ROLE,
             otherAdminRole
@@ -611,7 +593,7 @@ contract AccessControlTest is Test {
         accessControl.set_role_admin(ADDITIONAL_ROLE_1, otherAdminRole);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(otherAdminRole, otherAdmin, admin);
+        emit IAccessControl.RoleGranted(otherAdminRole, otherAdmin, admin);
         accessControl.grantRole(otherAdminRole, otherAdmin);
         assertTrue(accessControl.hasRole(otherAdminRole, otherAdmin));
 
@@ -631,7 +613,7 @@ contract AccessControlTest is Test {
         accessControl.grantRole(ADDITIONAL_ROLE_1, account);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleAdminChanged(
+        emit IAccessControl.RoleAdminChanged(
             ADDITIONAL_ROLE_1,
             DEFAULT_ADMIN_ROLE,
             otherAdminRole
@@ -639,7 +621,7 @@ contract AccessControlTest is Test {
         accessControl.set_role_admin(ADDITIONAL_ROLE_1, otherAdminRole);
 
         vm.expectEmit(true, true, true, false);
-        emit RoleGranted(otherAdminRole, otherAdmin, admin);
+        emit IAccessControl.RoleGranted(otherAdminRole, otherAdmin, admin);
         accessControl.grantRole(otherAdminRole, otherAdmin);
         assertTrue(accessControl.hasRole(otherAdminRole, otherAdmin));
 
diff --git a/test/auth/Ownable.t.sol b/test/auth/Ownable.t.sol
index 82b573c2..dd8e5d47 100644
--- a/test/auth/Ownable.t.sol
+++ b/test/auth/Ownable.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
@@ -15,11 +15,6 @@ contract OwnableTest is Test {
     address private deployer = address(vyperDeployer);
     address private zeroAddress = address(0);
 
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
     function setUp() public {
         ownable = IOwnable(
             vyperDeployer.deployContract("src/auth/", "Ownable")
@@ -30,7 +25,7 @@ contract OwnableTest is Test {
         assertEq(ownable.owner(), deployer);
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(zeroAddress, deployer);
+        emit IOwnable.OwnershipTransferred(zeroAddress, deployer);
         ownableInitialEvent = IOwnable(
             vyperDeployer.deployContract("src/auth/", "Ownable")
         );
@@ -46,7 +41,7 @@ contract OwnableTest is Test {
         address newOwner = makeAddr("newOwner");
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IOwnable.OwnershipTransferred(oldOwner, newOwner);
         ownable.transfer_ownership(newOwner);
         assertEq(ownable.owner(), newOwner);
         vm.stopPrank();
@@ -68,7 +63,7 @@ contract OwnableTest is Test {
         address newOwner = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IOwnable.OwnershipTransferred(oldOwner, newOwner);
         ownable.renounce_ownership();
         assertEq(ownable.owner(), newOwner);
         vm.stopPrank();
@@ -87,14 +82,14 @@ contract OwnableTest is Test {
         address oldOwner = deployer;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner1);
+        emit IOwnable.OwnershipTransferred(oldOwner, newOwner1);
         ownable.transfer_ownership(newOwner1);
         assertEq(ownable.owner(), newOwner1);
         vm.stopPrank();
 
         vm.startPrank(newOwner1);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IOwnable.OwnershipTransferred(newOwner1, newOwner2);
         ownable.transfer_ownership(newOwner2);
         assertEq(ownable.owner(), newOwner2);
         vm.stopPrank();
@@ -116,14 +111,14 @@ contract OwnableTest is Test {
         address renounceAddress = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IOwnable.OwnershipTransferred(oldOwner, newOwner);
         ownable.transfer_ownership(newOwner);
         assertEq(ownable.owner(), newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner, renounceAddress);
+        emit IOwnable.OwnershipTransferred(newOwner, renounceAddress);
         ownable.renounce_ownership();
         assertEq(ownable.owner(), renounceAddress);
         vm.stopPrank();
diff --git a/test/auth/Ownable2Step.t.sol b/test/auth/Ownable2Step.t.sol
index 368df9e7..9293f002 100644
--- a/test/auth/Ownable2Step.t.sol
+++ b/test/auth/Ownable2Step.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
@@ -15,16 +15,6 @@ contract Ownable2StepTest is Test {
     address private deployer = address(vyperDeployer);
     address private zeroAddress = address(0);
 
-    event OwnershipTransferStarted(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
     function setUp() public {
         ownable2Step = IOwnable2Step(
             vyperDeployer.deployContract("src/auth/", "Ownable2Step")
@@ -36,7 +26,7 @@ contract Ownable2StepTest is Test {
         assertEq(ownable2Step.pending_owner(), zeroAddress);
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(zeroAddress, deployer);
+        emit IOwnable2Step.OwnershipTransferred(zeroAddress, deployer);
         ownable2StepInitialEvent = IOwnable2Step(
             vyperDeployer.deployContract("src/auth/", "Ownable2Step")
         );
@@ -54,7 +44,7 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
@@ -72,14 +62,14 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferred(oldOwner, newOwner);
         ownable2Step.accept_ownership();
         assertEq(ownable2Step.owner(), newOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
@@ -92,7 +82,7 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
@@ -107,7 +97,7 @@ contract Ownable2StepTest is Test {
         address newOwner = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferred(oldOwner, newOwner);
         ownable2Step.renounce_ownership();
         assertEq(ownable2Step.owner(), newOwner);
         vm.stopPrank();
@@ -124,7 +114,7 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
@@ -149,13 +139,13 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner1);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner1);
         ownable2Step.transfer_ownership(newOwner1);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner1);
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner2);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner2);
         ownable2Step.transfer_ownership(newOwner2);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner2);
@@ -181,27 +171,27 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner1);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner1);
         ownable2Step.transfer_ownership(newOwner1);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner1);
         vm.stopPrank();
 
         vm.startPrank(newOwner1);
-        emit OwnershipTransferred(oldOwner, newOwner1);
+        emit IOwnable2Step.OwnershipTransferred(oldOwner, newOwner1);
         ownable2Step.accept_ownership();
         assertEq(ownable2Step.owner(), newOwner1);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(newOwner1, newOwner2);
+        emit IOwnable2Step.OwnershipTransferStarted(newOwner1, newOwner2);
         ownable2Step.transfer_ownership(newOwner2);
         assertEq(ownable2Step.owner(), newOwner1);
         assertEq(ownable2Step.pending_owner(), newOwner2);
         vm.stopPrank();
 
         vm.startPrank(newOwner2);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IOwnable2Step.OwnershipTransferred(newOwner1, newOwner2);
         ownable2Step.accept_ownership();
         assertEq(ownable2Step.owner(), newOwner2);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
@@ -214,7 +204,7 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
@@ -231,14 +221,14 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferred(oldOwner, newOwner);
         ownable2Step.accept_ownership();
         assertEq(ownable2Step.owner(), newOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
@@ -246,7 +236,7 @@ contract Ownable2StepTest is Test {
 
         vm.startPrank(newOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner, renounceAddress);
+        emit IOwnable2Step.OwnershipTransferred(newOwner, renounceAddress);
         ownable2Step.renounce_ownership();
         assertEq(ownable2Step.owner(), renounceAddress);
         vm.stopPrank();
@@ -267,7 +257,7 @@ contract Ownable2StepTest is Test {
         vm.startPrank(oldOwner);
         assertEq(ownable2Step.pending_owner(), zeroAddress);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferStarted(oldOwner, newOwner);
+        emit IOwnable2Step.OwnershipTransferStarted(oldOwner, newOwner);
         ownable2Step.transfer_ownership(newOwner);
         assertEq(ownable2Step.owner(), oldOwner);
         assertEq(ownable2Step.pending_owner(), newOwner);
diff --git a/test/auth/interfaces/IAccessControlExtended.sol b/test/auth/interfaces/IAccessControlExtended.sol
index 8066a8c1..82455b38 100644
--- a/test/auth/interfaces/IAccessControlExtended.sol
+++ b/test/auth/interfaces/IAccessControlExtended.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC165} from "openzeppelin/utils/introspection/IERC165.sol";
 import {IAccessControl} from "openzeppelin/access/IAccessControl.sol";
diff --git a/test/auth/interfaces/IOwnable.sol b/test/auth/interfaces/IOwnable.sol
index e965e36e..fd9ab8d8 100644
--- a/test/auth/interfaces/IOwnable.sol
+++ b/test/auth/interfaces/IOwnable.sol
@@ -1,7 +1,12 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IOwnable {
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
     function owner() external view returns (address);
 
     function transfer_ownership(address newOwner) external;
diff --git a/test/auth/interfaces/IOwnable2Step.sol b/test/auth/interfaces/IOwnable2Step.sol
index b7c68c48..248206b9 100644
--- a/test/auth/interfaces/IOwnable2Step.sol
+++ b/test/auth/interfaces/IOwnable2Step.sol
@@ -1,7 +1,17 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IOwnable2Step {
+    event OwnershipTransferStarted(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
     function owner() external view returns (address);
 
     function pending_owner() external view returns (address);
diff --git a/test/extensions/ERC2981.t.sol b/test/extensions/ERC2981.t.sol
index 47d7dd33..a835c7b1 100644
--- a/test/extensions/ERC2981.t.sol
+++ b/test/extensions/ERC2981.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
@@ -20,11 +20,6 @@ contract ERC2981Test is Test {
     address private deployer = address(vyperDeployer);
     address private zeroAddress = address(0);
 
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
     function setUp() public {
         ERC2981Extended = IERC2981Extended(
             vyperDeployer.deployContract("src/extensions/", "ERC2981")
@@ -43,7 +38,7 @@ contract ERC2981Test is Test {
         assertEq(royaltyAmount, 0);
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(zeroAddress, deployer);
+        emit IERC2981Extended.OwnershipTransferred(zeroAddress, deployer);
         ERC2981ExtendedInitialEvent = IERC2981Extended(
             vyperDeployer.deployContract("src/extensions/", "ERC2981")
         );
@@ -369,7 +364,7 @@ contract ERC2981Test is Test {
         address newOwner = makeAddr("newOwner");
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC2981Extended.OwnershipTransferred(oldOwner, newOwner);
         ERC2981Extended.transfer_ownership(newOwner);
         assertEq(ERC2981Extended.owner(), newOwner);
         vm.stopPrank();
@@ -391,7 +386,7 @@ contract ERC2981Test is Test {
         address newOwner = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC2981Extended.OwnershipTransferred(oldOwner, newOwner);
         ERC2981Extended.renounce_ownership();
         assertEq(ERC2981Extended.owner(), newOwner);
         vm.stopPrank();
@@ -719,14 +714,14 @@ contract ERC2981Test is Test {
         address oldOwner = deployer;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner1);
+        emit IERC2981Extended.OwnershipTransferred(oldOwner, newOwner1);
         ERC2981Extended.transfer_ownership(newOwner1);
         assertEq(ERC2981Extended.owner(), newOwner1);
         vm.stopPrank();
 
         vm.startPrank(newOwner1);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC2981Extended.OwnershipTransferred(newOwner1, newOwner2);
         ERC2981Extended.transfer_ownership(newOwner2);
         assertEq(ERC2981Extended.owner(), newOwner2);
         vm.stopPrank();
@@ -748,14 +743,14 @@ contract ERC2981Test is Test {
         address renounceAddress = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC2981Extended.OwnershipTransferred(oldOwner, newOwner);
         ERC2981Extended.transfer_ownership(newOwner);
         assertEq(ERC2981Extended.owner(), newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner, renounceAddress);
+        emit IERC2981Extended.OwnershipTransferred(newOwner, renounceAddress);
         ERC2981Extended.renounce_ownership();
         assertEq(ERC2981Extended.owner(), renounceAddress);
         vm.stopPrank();
diff --git a/test/extensions/ERC4626.t.sol b/test/extensions/ERC4626.t.sol
index 4c30e0cc..fb8587d2 100644
--- a/test/extensions/ERC4626.t.sol
+++ b/test/extensions/ERC4626.t.sol
@@ -1,11 +1,13 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {ERC4626Test} from "erc4626-tests/ERC4626.test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
 
+import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
 import {IERC20Errors} from "openzeppelin/interfaces/draft-IERC6093.sol";
+import {IERC4626} from "openzeppelin/interfaces/IERC4626.sol";
 
 import {ERC20Mock} from "../utils/mocks/ERC20Mock.sol";
 import {ERC20ExcessDecimalsMock} from "./mocks/ERC20ExcessDecimalsMock.sol";
@@ -59,31 +61,9 @@ contract ERC4626VaultTest is ERC4626Test {
     address private ERC4626ExtendedDecimalsOffset0Addr;
     address private ERC4626ExtendedDecimalsOffset6Addr;
     address private ERC4626ExtendedDecimalsOffset12Addr;
-    address private ERC4626ExtendedDecimalsOffset18Addr;
     /* solhint-enable var-name-mixedcase */
-
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint256 value
-    );
-
-    event Deposit(
-        address indexed sender,
-        address indexed owner,
-        uint256 assets,
-        uint256 shares
-    );
-
-    event Withdraw(
-        address indexed sender,
-        address indexed receiver,
-        address indexed owner,
-        uint256 assets,
-        uint256 shares
-    );
+    // solhint-disable-next-line var-name-mixedcase
+    address private ERC4626ExtendedDecimalsOffset18Addr;
 
     function setUp() public override {
         bytes memory argsDecimalsOffset0 = abi.encode(
@@ -374,7 +354,11 @@ contract ERC4626VaultTest is ERC4626Test {
         );
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset0Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset0Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -382,7 +366,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(zeroAddress, receiver, shares);
+        emit IERC20.Transfer(zeroAddress, receiver, shares);
         vm.expectEmit(
             true,
             true,
@@ -390,11 +374,15 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Deposit(holder, receiver, assets, shares);
+        emit IERC4626.Deposit(holder, receiver, assets, shares);
         ERC4626ExtendedDecimalsOffset0.deposit(assets, receiver);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset6Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset6Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -402,7 +390,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Transfer(zeroAddress, receiver, shares * 10 ** 6);
+        emit IERC20.Transfer(zeroAddress, receiver, shares * 10 ** 6);
         vm.expectEmit(
             true,
             true,
@@ -410,11 +398,15 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Deposit(holder, receiver, assets, shares * 10 ** 6);
+        emit IERC4626.Deposit(holder, receiver, assets, shares * 10 ** 6);
         ERC4626ExtendedDecimalsOffset6.deposit(assets, receiver);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset12Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset12Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -422,7 +414,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Transfer(zeroAddress, receiver, shares * 10 ** 12);
+        emit IERC20.Transfer(zeroAddress, receiver, shares * 10 ** 12);
         vm.expectEmit(
             true,
             true,
@@ -430,11 +422,15 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Deposit(holder, receiver, assets, shares * 10 ** 12);
+        emit IERC4626.Deposit(holder, receiver, assets, shares * 10 ** 12);
         ERC4626ExtendedDecimalsOffset12.deposit(assets, receiver);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset18Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset18Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -442,7 +438,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Transfer(zeroAddress, receiver, shares * 10 ** 18);
+        emit IERC20.Transfer(zeroAddress, receiver, shares * 10 ** 18);
         vm.expectEmit(
             true,
             true,
@@ -450,7 +446,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Deposit(holder, receiver, assets, shares * 10 ** 18);
+        emit IERC4626.Deposit(holder, receiver, assets, shares * 10 ** 18);
         ERC4626ExtendedDecimalsOffset18.deposit(assets, receiver);
 
         assertEq(underlying.balanceOf(holder), type(uint16).max - 4);
@@ -556,7 +552,11 @@ contract ERC4626VaultTest is ERC4626Test {
         );
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset0Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset0Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -564,7 +564,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(zeroAddress, receiver, shares);
+        emit IERC20.Transfer(zeroAddress, receiver, shares);
         vm.expectEmit(
             true,
             true,
@@ -572,11 +572,15 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Deposit(holder, receiver, assets, shares);
+        emit IERC4626.Deposit(holder, receiver, assets, shares);
         ERC4626ExtendedDecimalsOffset0.mint(shares, receiver);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset6Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset6Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -584,7 +588,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Transfer(zeroAddress, receiver, shares * 10 ** 6);
+        emit IERC20.Transfer(zeroAddress, receiver, shares * 10 ** 6);
         vm.expectEmit(
             true,
             true,
@@ -592,11 +596,15 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Deposit(holder, receiver, assets, shares * 10 ** 6);
+        emit IERC4626.Deposit(holder, receiver, assets, shares * 10 ** 6);
         ERC4626ExtendedDecimalsOffset6.mint(shares * 10 ** 6, receiver);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset12Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset12Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -604,7 +612,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Transfer(zeroAddress, receiver, shares * 10 ** 12);
+        emit IERC20.Transfer(zeroAddress, receiver, shares * 10 ** 12);
         vm.expectEmit(
             true,
             true,
@@ -612,11 +620,15 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Deposit(holder, receiver, assets, shares * 10 ** 12);
+        emit IERC4626.Deposit(holder, receiver, assets, shares * 10 ** 12);
         ERC4626ExtendedDecimalsOffset12.mint(shares * 10 ** 12, receiver);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(holder, ERC4626ExtendedDecimalsOffset18Addr, assets);
+        emit IERC20.Transfer(
+            holder,
+            ERC4626ExtendedDecimalsOffset18Addr,
+            assets
+        );
         vm.expectEmit(
             true,
             true,
@@ -624,7 +636,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Transfer(zeroAddress, receiver, shares * 10 ** 18);
+        emit IERC20.Transfer(zeroAddress, receiver, shares * 10 ** 18);
         vm.expectEmit(
             true,
             true,
@@ -632,7 +644,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Deposit(holder, receiver, assets, shares * 10 ** 18);
+        emit IERC4626.Deposit(holder, receiver, assets, shares * 10 ** 18);
         ERC4626ExtendedDecimalsOffset18.mint(shares * 10 ** 18, receiver);
 
         assertEq(underlying.balanceOf(holder), type(uint16).max - 4);
@@ -703,9 +715,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset0Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset0Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -713,7 +725,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset0.withdraw(0, receiver, holder);
 
         vm.expectEmit(
@@ -723,9 +735,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset6Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset6Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -733,7 +745,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset6.withdraw(0, receiver, holder);
 
         vm.expectEmit(
@@ -743,9 +755,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset12Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset12Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -753,7 +765,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset12.withdraw(0, receiver, holder);
 
         vm.expectEmit(
@@ -763,9 +775,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset18Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset18Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -773,7 +785,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset18.withdraw(0, receiver, holder);
 
         assertEq(underlying.balanceOf(holder), 0);
@@ -826,9 +838,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset0Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset0Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -836,7 +848,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset0.redeem(0, receiver, holder);
 
         vm.expectEmit(
@@ -846,9 +858,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset6Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset6Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -856,7 +868,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset6Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset6.redeem(0, receiver, holder);
 
         vm.expectEmit(
@@ -866,9 +878,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset12Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset12Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -876,7 +888,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset12Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset12.redeem(0, receiver, holder);
 
         vm.expectEmit(
@@ -886,9 +898,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Transfer(holder, zeroAddress, 0);
+        emit IERC20.Transfer(holder, zeroAddress, 0);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset18Addr, receiver, 0);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset18Addr, receiver, 0);
         vm.expectEmit(
             true,
             true,
@@ -896,7 +908,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset18Addr
         );
-        emit Withdraw(holder, receiver, holder, 0, 0);
+        emit IERC4626.Withdraw(holder, receiver, holder, 0, 0);
         ERC4626ExtendedDecimalsOffset18.redeem(0, receiver, holder);
 
         assertEq(underlying.balanceOf(holder), 0);
@@ -941,7 +953,7 @@ contract ERC4626VaultTest is ERC4626Test {
         uint256 alicePreDepositBalance = underlying.balanceOf(alice);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(alice, ERC4626ExtendedDecimalsOffset0Addr, assets);
+        emit IERC20.Transfer(alice, ERC4626ExtendedDecimalsOffset0Addr, assets);
         vm.expectEmit(
             true,
             true,
@@ -949,7 +961,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(zeroAddress, alice, assets);
+        emit IERC20.Transfer(zeroAddress, alice, assets);
         vm.expectEmit(
             true,
             true,
@@ -957,7 +969,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Deposit(alice, alice, assets, assets);
+        emit IERC4626.Deposit(alice, alice, assets, assets);
         uint256 aliceShareAmount = ERC4626ExtendedDecimalsOffset0.deposit(
             assets,
             alice
@@ -996,9 +1008,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(alice, zeroAddress, assets);
+        emit IERC20.Transfer(alice, zeroAddress, assets);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset0Addr, alice, assets);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset0Addr, alice, assets);
         vm.expectEmit(
             true,
             true,
@@ -1006,7 +1018,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Withdraw(alice, alice, alice, assets, assets);
+        emit IERC4626.Withdraw(alice, alice, alice, assets, assets);
         ERC4626ExtendedDecimalsOffset0.withdraw(assets, alice, alice);
 
         assertEq(ERC4626ExtendedDecimalsOffset0.totalAssets(), 0);
@@ -1038,7 +1050,7 @@ contract ERC4626VaultTest is ERC4626Test {
         uint256 alicePreDepositBalance = underlying.balanceOf(alice);
 
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(alice, ERC4626ExtendedDecimalsOffset0Addr, shares);
+        emit IERC20.Transfer(alice, ERC4626ExtendedDecimalsOffset0Addr, shares);
         vm.expectEmit(
             true,
             true,
@@ -1046,7 +1058,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(zeroAddress, alice, shares);
+        emit IERC20.Transfer(zeroAddress, alice, shares);
         vm.expectEmit(
             true,
             true,
@@ -1054,7 +1066,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Deposit(alice, alice, shares, shares);
+        emit IERC4626.Deposit(alice, alice, shares, shares);
         uint256 aliceAssetAmount = ERC4626ExtendedDecimalsOffset0.mint(
             shares,
             alice
@@ -1093,9 +1105,9 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Transfer(alice, zeroAddress, shares);
+        emit IERC20.Transfer(alice, zeroAddress, shares);
         vm.expectEmit(true, true, false, true, underlyingAddr);
-        emit Transfer(ERC4626ExtendedDecimalsOffset0Addr, alice, shares);
+        emit IERC20.Transfer(ERC4626ExtendedDecimalsOffset0Addr, alice, shares);
         vm.expectEmit(
             true,
             true,
@@ -1103,7 +1115,7 @@ contract ERC4626VaultTest is ERC4626Test {
             true,
             ERC4626ExtendedDecimalsOffset0Addr
         );
-        emit Withdraw(alice, alice, alice, shares, shares);
+        emit IERC4626.Withdraw(alice, alice, alice, shares, shares);
         ERC4626ExtendedDecimalsOffset0.redeem(shares, alice, alice);
 
         assertEq(ERC4626ExtendedDecimalsOffset0.totalAssets(), 0);
@@ -1608,7 +1620,7 @@ contract ERC4626VaultTest is ERC4626Test {
             )
         );
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         ERC4626ExtendedDecimalsOffset0.permit(
             owner,
             spender,
@@ -1654,7 +1666,7 @@ contract ERC4626VaultTest is ERC4626Test {
             )
         );
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         ERC4626ExtendedDecimalsOffset0.permit(
             owner,
             spender,
@@ -1927,7 +1939,7 @@ contract ERC4626VaultTest is ERC4626Test {
             )
         );
         vm.expectEmit(true, true, false, true);
-        emit Approval(ownerAddr, spenderAddr, amount);
+        emit IERC20.Approval(ownerAddr, spenderAddr, amount);
         ERC4626ExtendedDecimalsOffset0.permit(
             ownerAddr,
             spenderAddr,
diff --git a/test/extensions/interfaces/IERC2981Extended.sol b/test/extensions/interfaces/IERC2981Extended.sol
index dc080f97..d0c570e9 100644
--- a/test/extensions/interfaces/IERC2981Extended.sol
+++ b/test/extensions/interfaces/IERC2981Extended.sol
@@ -1,9 +1,14 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC2981} from "openzeppelin/interfaces/IERC2981.sol";
 
 interface IERC2981Extended is IERC2981 {
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
     function set_default_royalty(
         address receiver,
         uint96 feeNumerator
diff --git a/test/extensions/interfaces/IERC4626Extended.sol b/test/extensions/interfaces/IERC4626Extended.sol
index 21f2e410..b649bed7 100644
--- a/test/extensions/interfaces/IERC4626Extended.sol
+++ b/test/extensions/interfaces/IERC4626Extended.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC20Metadata} from "openzeppelin/token/ERC20/extensions/IERC20Metadata.sol";
 import {IERC20Permit} from "openzeppelin/token/ERC20/extensions/IERC20Permit.sol";
diff --git a/test/extensions/mocks/ERC20ExcessDecimalsMock.sol b/test/extensions/mocks/ERC20ExcessDecimalsMock.sol
index 26351909..d59ce148 100644
--- a/test/extensions/mocks/ERC20ExcessDecimalsMock.sol
+++ b/test/extensions/mocks/ERC20ExcessDecimalsMock.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 /**
  * @title ERC20ExcessDecimalsMock
diff --git a/test/tokens/ERC1155.t.sol b/test/tokens/ERC1155.t.sol
index 379a37f5..41465821 100644
--- a/test/tokens/ERC1155.t.sol
+++ b/test/tokens/ERC1155.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
@@ -28,53 +28,6 @@ contract ERC1155Test is Test {
     address private deployer = address(vyperDeployer);
     address private zeroAddress = address(0);
 
-    event TransferSingle(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256 id,
-        uint256 amount
-    );
-
-    event TransferBatch(
-        address indexed operator,
-        address indexed from,
-        address indexed to,
-        uint256[] ids,
-        uint256[] amounts
-    );
-
-    event ApprovalForAll(
-        address indexed owner,
-        address indexed operator,
-        bool approved
-    );
-
-    event URI(string value, uint256 indexed id);
-
-    event Received(
-        address indexed operator,
-        address indexed from,
-        uint256 id,
-        uint256 amount,
-        bytes data
-    );
-
-    event BatchReceived(
-        address indexed operator,
-        address indexed from,
-        uint256[] ids,
-        uint256[] amounts,
-        bytes data
-    );
-
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
-    event RoleMinterChanged(address indexed minter, bool status);
-
     function setUp() public {
         bytes memory args = abi.encode(_BASE_URI);
         ERC1155Extended = IERC1155Extended(
@@ -95,9 +48,9 @@ contract ERC1155Test is Test {
         );
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(zeroAddress, deployer);
+        emit IERC1155Extended.OwnershipTransferred(zeroAddress, deployer);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(deployer, true);
+        emit IERC1155Extended.RoleMinterChanged(deployer, true);
         bytes memory args = abi.encode(_BASE_URI);
         ERC1155ExtendedInitialEvent = IERC1155Extended(
             vyperDeployer.deployContract("src/tokens/", "ERC1155", args)
@@ -322,12 +275,12 @@ contract ERC1155Test is Test {
         assertTrue(!ERC1155Extended.isApprovedForAll(owner, operator));
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC1155Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC1155Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -340,12 +293,12 @@ contract ERC1155Test is Test {
         assertTrue(!ERC1155Extended.isApprovedForAll(owner, operator));
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC1155Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, !approved);
+        emit IERC1155.ApprovalForAll(owner, operator, !approved);
         ERC1155Extended.setApprovalForAll(operator, !approved);
         assertTrue(!ERC1155Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -373,7 +326,7 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(owner, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(owner, owner, receiver, id1, amount1);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -399,13 +352,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(operator, owner, receiver, id1, amount1);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -465,9 +418,9 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(owner, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(owner, owner, receiver, id1, amount1);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(owner, owner, id1, amount1, data);
+        emit ERC1155ReceiverMock.Received(owner, owner, id1, amount1, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -479,15 +432,15 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(operator, owner, receiver, id2, amount2);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(operator, owner, id2, amount2, data);
+        emit ERC1155ReceiverMock.Received(operator, owner, id2, amount2, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id2, amount2, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), 0);
@@ -525,9 +478,9 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(owner, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(owner, owner, receiver, id1, amount1);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(owner, owner, id1, amount1, data);
+        emit ERC1155ReceiverMock.Received(owner, owner, id1, amount1, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -539,15 +492,15 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(operator, owner, receiver, id2, amount2);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(operator, owner, id2, amount2, data);
+        emit ERC1155ReceiverMock.Received(operator, owner, id2, amount2, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id2, amount2, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), 0);
@@ -592,7 +545,7 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
@@ -638,7 +591,7 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
@@ -669,7 +622,7 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
@@ -737,7 +690,7 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -776,13 +729,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(operator, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(operator, owner, receiver, ids, amounts);
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -867,9 +820,15 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         vm.expectEmit(true, true, false, true, receiver);
-        emit BatchReceived(owner, owner, ids, amounts, data);
+        emit ERC1155ReceiverMock.BatchReceived(
+            owner,
+            owner,
+            ids,
+            amounts,
+            data
+        );
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -918,9 +877,15 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         vm.expectEmit(true, true, false, true, receiver);
-        emit BatchReceived(owner, owner, ids, amounts, data);
+        emit ERC1155ReceiverMock.BatchReceived(
+            owner,
+            owner,
+            ids,
+            amounts,
+            data
+        );
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -1088,9 +1053,15 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         vm.expectEmit(true, true, false, true, receiver);
-        emit BatchReceived(owner, owner, ids, amounts, data);
+        emit ERC1155ReceiverMock.BatchReceived(
+            owner,
+            owner,
+            ids,
+            amounts,
+            data
+        );
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -1257,7 +1228,7 @@ contract ERC1155Test is Test {
         uint256 id = 1;
         vm.prank(deployer);
         vm.expectEmit(true, false, false, true);
-        emit URI(string.concat(_BASE_URI, uri), id);
+        emit IERC1155.URI(string.concat(_BASE_URI, uri), id);
         ERC1155Extended.set_uri(id, uri);
         assertEq(ERC1155Extended.uri(id), string.concat(_BASE_URI, uri));
     }
@@ -1267,7 +1238,10 @@ contract ERC1155Test is Test {
         uint256 id = 1;
         vm.prank(deployer);
         vm.expectEmit(true, false, false, true);
-        emit URI(string.concat(_BASE_URI, Strings.toString(uint256(id))), id);
+        emit IERC1155.URI(
+            string.concat(_BASE_URI, Strings.toString(uint256(id))),
+            id
+        );
         ERC1155Extended.set_uri(id, uri);
         assertEq(
             ERC1155Extended.uri(id),
@@ -1455,7 +1429,7 @@ contract ERC1155Test is Test {
 
         vm.startPrank(firstOwner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(
+        emit IERC1155.TransferSingle(
             firstOwner,
             firstOwner,
             zeroAddress,
@@ -1486,13 +1460,19 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, zeroAddress, id1, burnAmount);
+        emit IERC1155.TransferSingle(
+            operator,
+            owner,
+            zeroAddress,
+            id1,
+            burnAmount
+        );
         ERC1155Extended.burn(owner, id1, burnAmount);
         assertEq(ERC1155Extended.total_supply(id1), amount1 - burnAmount);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -1577,7 +1557,7 @@ contract ERC1155Test is Test {
         vm.startPrank(owner);
         --amounts[2];
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, zeroAddress, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, zeroAddress, ids, amounts);
         ERC1155Extended.burn_batch(owner, ids, amounts);
         assertEq(ERC1155Extended.total_supply(ids[0]), 0);
         assertEq(ERC1155Extended.total_supply(ids[1]), 0);
@@ -1613,14 +1593,14 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         --amounts[2];
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(operator, owner, zeroAddress, ids, amounts);
+        emit IERC1155.TransferBatch(operator, owner, zeroAddress, ids, amounts);
         ERC1155Extended.burn_batch(owner, ids, amounts);
         assertEq(ERC1155Extended.total_supply(ids[0]), 0);
         assertEq(ERC1155Extended.total_supply(ids[1]), 0);
@@ -1757,11 +1737,23 @@ contract ERC1155Test is Test {
         bytes memory data = new bytes(0);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id1,
+            amount1
+        );
         ERC1155Extended.safe_mint(receiver, id1, amount1, data);
 
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id2,
+            amount2
+        );
         ERC1155Extended.safe_mint(receiver, id2, amount2, data);
         assertEq(ERC1155Extended.total_supply(id1), amount1);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -1791,11 +1783,23 @@ contract ERC1155Test is Test {
         bytes memory data = new bytes(0);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id1,
+            amount1
+        );
         ERC1155Extended.safe_mint(receiver, id1, amount1, data);
 
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id2,
+            amount2
+        );
         ERC1155Extended.safe_mint(receiver, id2, amount2, data);
         assertEq(ERC1155Extended.total_supply(id1), amount1);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -1825,11 +1829,23 @@ contract ERC1155Test is Test {
         bytes memory data = new bytes(42);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id1,
+            amount1
+        );
         ERC1155Extended.safe_mint(receiver, id1, amount1, data);
 
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id2,
+            amount2
+        );
         ERC1155Extended.safe_mint(receiver, id2, amount2, data);
         assertEq(ERC1155Extended.total_supply(id1), amount1);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -1950,7 +1966,13 @@ contract ERC1155Test is Test {
         bytes memory data = new bytes(0);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id, amount);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id,
+            amount
+        );
         ERC1155Extended.safe_mint(receiver, id, amount, data);
 
         vm.expectRevert();
@@ -1975,7 +1997,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -2013,7 +2041,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -2051,7 +2085,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -2175,7 +2215,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -2272,7 +2318,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
 
         vm.expectRevert();
@@ -2285,12 +2337,12 @@ contract ERC1155Test is Test {
         address minter = makeAddr("minter");
         vm.startPrank(owner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minter, true);
+        emit IERC1155Extended.RoleMinterChanged(minter, true);
         ERC1155Extended.set_minter(minter, true);
         assertTrue(ERC1155Extended.is_minter(minter));
 
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minter, false);
+        emit IERC1155Extended.RoleMinterChanged(minter, false);
         ERC1155Extended.set_minter(minter, false);
         assertTrue(!ERC1155Extended.is_minter(minter));
         vm.stopPrank();
@@ -2322,11 +2374,11 @@ contract ERC1155Test is Test {
         address newOwner = makeAddr("newOwner");
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC1155Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC1155Extended.OwnershipTransferred(oldOwner, newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, true);
+        emit IERC1155Extended.RoleMinterChanged(newOwner, true);
         ERC1155Extended.transfer_ownership(newOwner);
         assertEq(ERC1155Extended.owner(), newOwner);
         assertTrue(!ERC1155Extended.is_minter(oldOwner));
@@ -2350,9 +2402,9 @@ contract ERC1155Test is Test {
         address newOwner = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC1155Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC1155Extended.OwnershipTransferred(oldOwner, newOwner);
         ERC1155Extended.renounce_ownership();
         assertEq(ERC1155Extended.owner(), newOwner);
         assertTrue(!ERC1155Extended.is_minter(oldOwner));
@@ -2373,12 +2425,12 @@ contract ERC1155Test is Test {
         assertTrue(!ERC1155Extended.isApprovedForAll(owner, operator));
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC1155Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC1155Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -2393,12 +2445,12 @@ contract ERC1155Test is Test {
         assertTrue(!ERC1155Extended.isApprovedForAll(owner, operator));
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC1155Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, !approved);
+        emit IERC1155.ApprovalForAll(owner, operator, !approved);
         ERC1155Extended.setApprovalForAll(operator, !approved);
         assertTrue(!ERC1155Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -2428,7 +2480,7 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(owner, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(owner, owner, receiver, id1, amount1);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -2466,13 +2518,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(operator, owner, receiver, id1, amount1);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -2519,9 +2571,9 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(owner, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(owner, owner, receiver, id1, amount1);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(owner, owner, id1, amount1, data);
+        emit ERC1155ReceiverMock.Received(owner, owner, id1, amount1, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -2534,15 +2586,15 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(operator, owner, receiver, id2, amount2);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(operator, owner, id2, amount2, data);
+        emit ERC1155ReceiverMock.Received(operator, owner, id2, amount2, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id2, amount2, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), 0);
@@ -2589,9 +2641,9 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(owner, owner, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(owner, owner, receiver, id1, amount1);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(owner, owner, id1, amount1, data);
+        emit ERC1155ReceiverMock.Received(owner, owner, id1, amount1, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id1, amount1, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), amount2);
@@ -2604,15 +2656,15 @@ contract ERC1155Test is Test {
         bool approved = true;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(operator, owner, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(operator, owner, receiver, id2, amount2);
         vm.expectEmit(true, true, false, true, receiver);
-        emit Received(operator, owner, id2, amount2, data);
+        emit ERC1155ReceiverMock.Received(operator, owner, id2, amount2, data);
         ERC1155Extended.safeTransferFrom(owner, receiver, id2, amount2, data);
         assertEq(ERC1155Extended.balanceOf(owner, id1), 0);
         assertEq(ERC1155Extended.balanceOf(owner, id2), 0);
@@ -2653,7 +2705,7 @@ contract ERC1155Test is Test {
         vm.stopPrank();
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -2704,13 +2756,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC1155.ApprovalForAll(owner, operator, approved);
         ERC1155Extended.setApprovalForAll(operator, approved);
         vm.stopPrank();
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(operator, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(operator, owner, receiver, ids, amounts);
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -2769,9 +2821,15 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         vm.expectEmit(true, true, false, true, receiver);
-        emit BatchReceived(owner, owner, ids, amounts, data);
+        emit ERC1155ReceiverMock.BatchReceived(
+            owner,
+            owner,
+            ids,
+            amounts,
+            data
+        );
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -2833,9 +2891,15 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, receiver, ids, amounts);
         vm.expectEmit(true, true, false, true, receiver);
-        emit BatchReceived(owner, owner, ids, amounts, data);
+        emit ERC1155ReceiverMock.BatchReceived(
+            owner,
+            owner,
+            ids,
+            amounts,
+            data
+        );
         ERC1155Extended.safeBatchTransferFrom(
             owner,
             receiver,
@@ -2989,7 +3053,7 @@ contract ERC1155Test is Test {
 
         vm.startPrank(firstOwner);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(
+        emit IERC1155.TransferSingle(
             firstOwner,
             firstOwner,
             zeroAddress,
@@ -3032,7 +3096,7 @@ contract ERC1155Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(owner, owner, zeroAddress, ids, amounts);
+        emit IERC1155.TransferBatch(owner, owner, zeroAddress, ids, amounts);
         ERC1155Extended.burn_batch(owner, ids, amounts);
         assertEq(ERC1155Extended.total_supply(ids[0]), 0);
         assertEq(ERC1155Extended.total_supply(ids[1]), 0);
@@ -3060,11 +3124,23 @@ contract ERC1155Test is Test {
         vm.assume(id1 != id2 && amount1 > 0 && amount2 > 0);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id1,
+            amount1
+        );
         ERC1155Extended.safe_mint(receiver, id1, amount1, data);
 
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id2,
+            amount2
+        );
         ERC1155Extended.safe_mint(receiver, id2, amount2, data);
         assertEq(ERC1155Extended.total_supply(id1), amount1);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -3103,11 +3179,23 @@ contract ERC1155Test is Test {
         bytes memory data = new bytes(0);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id1,
+            amount1
+        );
         ERC1155Extended.safe_mint(receiver, id1, amount1, data);
 
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id2,
+            amount2
+        );
         ERC1155Extended.safe_mint(receiver, id2, amount2, data);
         assertEq(ERC1155Extended.total_supply(id1), amount1);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -3146,11 +3234,23 @@ contract ERC1155Test is Test {
         address receiver = address(erc1155ReceiverMock);
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id1, amount1);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id1,
+            amount1
+        );
 
         ERC1155Extended.safe_mint(receiver, id1, amount1, data);
         vm.expectEmit(true, true, true, true);
-        emit TransferSingle(deployer, zeroAddress, receiver, id2, amount2);
+        emit IERC1155.TransferSingle(
+            deployer,
+            zeroAddress,
+            receiver,
+            id2,
+            amount2
+        );
         ERC1155Extended.safe_mint(receiver, id2, amount2, data);
         assertEq(ERC1155Extended.total_supply(id1), amount1);
         assertEq(ERC1155Extended.total_supply(id2), amount2);
@@ -3203,7 +3303,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -3250,7 +3356,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -3301,7 +3413,13 @@ contract ERC1155Test is Test {
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, true);
-        emit TransferBatch(deployer, zeroAddress, receiver, ids, amounts);
+        emit IERC1155.TransferBatch(
+            deployer,
+            zeroAddress,
+            receiver,
+            ids,
+            amounts
+        );
         ERC1155Extended.safe_mint_batch(receiver, ids, amounts, data);
         for (uint256 i; i < ids.length; ++i) {
             assertEq(ERC1155Extended.total_supply(ids[i]), amounts[i]);
@@ -3336,12 +3454,12 @@ contract ERC1155Test is Test {
         address minterAddr = makeAddr(minter);
         vm.startPrank(owner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minterAddr, true);
+        emit IERC1155Extended.RoleMinterChanged(minterAddr, true);
         ERC1155Extended.set_minter(minterAddr, true);
         assertTrue(ERC1155Extended.is_minter(minterAddr));
 
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minterAddr, false);
+        emit IERC1155Extended.RoleMinterChanged(minterAddr, false);
         ERC1155Extended.set_minter(minterAddr, false);
         assertTrue(!ERC1155Extended.is_minter(minterAddr));
         vm.stopPrank();
@@ -3369,11 +3487,11 @@ contract ERC1155Test is Test {
         address oldOwner = deployer;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC1155Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner1);
+        emit IERC1155Extended.OwnershipTransferred(oldOwner, newOwner1);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner1, true);
+        emit IERC1155Extended.RoleMinterChanged(newOwner1, true);
         ERC1155Extended.transfer_ownership(newOwner1);
         assertEq(ERC1155Extended.owner(), newOwner1);
         assertTrue(!ERC1155Extended.is_minter(oldOwner));
@@ -3382,12 +3500,12 @@ contract ERC1155Test is Test {
 
         vm.startPrank(newOwner1);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner1, false);
+        emit IERC1155Extended.RoleMinterChanged(newOwner1, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC1155Extended.OwnershipTransferred(newOwner1, newOwner2);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner2, true);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC1155Extended.RoleMinterChanged(newOwner2, true);
+        emit IERC1155Extended.OwnershipTransferred(newOwner1, newOwner2);
         ERC1155Extended.transfer_ownership(newOwner2);
         assertEq(ERC1155Extended.owner(), newOwner2);
         assertTrue(!ERC1155Extended.is_minter(newOwner1));
@@ -3411,19 +3529,19 @@ contract ERC1155Test is Test {
         address renounceAddress = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC1155Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC1155Extended.OwnershipTransferred(oldOwner, newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, true);
+        emit IERC1155Extended.RoleMinterChanged(newOwner, true);
         ERC1155Extended.transfer_ownership(newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, false);
+        emit IERC1155Extended.RoleMinterChanged(newOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner, renounceAddress);
+        emit IERC1155Extended.OwnershipTransferred(newOwner, renounceAddress);
         ERC1155Extended.renounce_ownership();
         assertEq(ERC1155Extended.owner(), renounceAddress);
         vm.stopPrank();
diff --git a/test/tokens/ERC20.t.sol b/test/tokens/ERC20.t.sol
index 957f1e3e..d7042822 100644
--- a/test/tokens/ERC20.t.sol
+++ b/test/tokens/ERC20.t.sol
@@ -1,9 +1,11 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
 
+import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
+
 import {IERC20Extended} from "./interfaces/IERC20Extended.sol";
 
 contract ERC20Test is Test {
@@ -39,21 +41,6 @@ contract ERC20Test is Test {
     // solhint-disable-next-line var-name-mixedcase
     address private ERC20ExtendedAddr;
 
-    event Transfer(address indexed from, address indexed to, uint256 value);
-
-    event Approval(
-        address indexed owner,
-        address indexed spender,
-        uint256 value
-    );
-
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
-    event RoleMinterChanged(address indexed minter, bool status);
-
     function setUp() public {
         bytes memory args = abi.encode(
             _NAME,
@@ -91,11 +78,15 @@ contract ERC20Test is Test {
         assertTrue(ERC20Extended.is_minter(deployer));
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(zeroAddress, deployer);
+        emit IERC20Extended.OwnershipTransferred(zeroAddress, deployer);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(deployer, true);
+        emit IERC20Extended.RoleMinterChanged(deployer, true);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(zeroAddress, deployer, _INITIAL_SUPPLY * multiplier);
+        emit IERC20.Transfer(
+            zeroAddress,
+            deployer,
+            _INITIAL_SUPPLY * multiplier
+        );
         bytes memory args = abi.encode(
             _NAME,
             _SYMBOL,
@@ -141,7 +132,7 @@ contract ERC20Test is Test {
         uint256 amount = ERC20Extended.balanceOf(owner);
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, to, amount);
+        emit IERC20.Transfer(owner, to, amount);
         bool returnValue = ERC20Extended.transfer(to, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.balanceOf(owner), 0);
@@ -162,7 +153,7 @@ contract ERC20Test is Test {
         uint256 amount = 0;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, to, amount);
+        emit IERC20.Transfer(owner, to, amount);
         bool returnValue = ERC20Extended.transfer(to, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.balanceOf(owner), balance);
@@ -194,7 +185,7 @@ contract ERC20Test is Test {
         uint256 amount = ERC20Extended.balanceOf(owner);
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         bool returnValue = ERC20Extended.approve(spender, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.allowance(owner, spender), amount);
@@ -208,13 +199,13 @@ contract ERC20Test is Test {
         uint256 secondAmount = ERC20Extended.balanceOf(owner);
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, firstAmount);
+        emit IERC20.Approval(owner, spender, firstAmount);
         bool returnValue1 = ERC20Extended.approve(spender, firstAmount);
         assertEq(ERC20Extended.allowance(owner, spender), firstAmount);
         assertTrue(returnValue1);
 
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, secondAmount);
+        emit IERC20.Approval(owner, spender, secondAmount);
         bool returnValue2 = ERC20Extended.approve(spender, secondAmount);
         assertTrue(returnValue2);
         assertEq(ERC20Extended.allowance(owner, spender), secondAmount);
@@ -227,7 +218,7 @@ contract ERC20Test is Test {
         uint256 amount = type(uint128).max;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         bool returnValue = ERC20Extended.approve(spender, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.allowance(owner, spender), amount);
@@ -241,13 +232,13 @@ contract ERC20Test is Test {
         uint256 secondAmount = type(uint128).max;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, firstAmount);
+        emit IERC20.Approval(owner, spender, firstAmount);
         bool returnValue1 = ERC20Extended.approve(spender, firstAmount);
         assertEq(ERC20Extended.allowance(owner, spender), firstAmount);
         assertTrue(returnValue1);
 
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, secondAmount);
+        emit IERC20.Approval(owner, spender, secondAmount);
         bool returnValue2 = ERC20Extended.approve(spender, secondAmount);
         assertTrue(returnValue2);
         assertEq(ERC20Extended.allowance(owner, spender), secondAmount);
@@ -277,13 +268,13 @@ contract ERC20Test is Test {
         ERC20Extended.approve(spender, amount);
         vm.startPrank(spender);
         vm.expectEmit(true, true, false, true);
-        emit Approval(
+        emit IERC20.Approval(
             owner,
             spender,
             ERC20Extended.allowance(owner, spender) - amount
         );
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, to, amount);
+        emit IERC20.Transfer(owner, to, amount);
         bool returnValue = ERC20Extended.transferFrom(owner, to, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.balanceOf(owner), 0);
@@ -334,7 +325,7 @@ contract ERC20Test is Test {
         ERC20Extended.approve(spender, type(uint256).max);
         vm.startPrank(spender);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, to, amount);
+        emit IERC20.Transfer(owner, to, amount);
 
         bool returnValue = ERC20Extended.transferFrom(owner, to, amount);
         assertTrue(returnValue);
@@ -368,7 +359,7 @@ contract ERC20Test is Test {
         uint256 amount = 0;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn(amount);
         assertEq(ERC20Extended.balanceOf(owner), balance - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -382,7 +373,7 @@ contract ERC20Test is Test {
         uint256 amount = 100;
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn(amount);
         assertEq(ERC20Extended.balanceOf(owner), balance - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -414,14 +405,14 @@ contract ERC20Test is Test {
         ERC20Extended.approve(spender, amount);
         vm.startPrank(spender);
         vm.expectEmit(true, true, false, true);
-        emit Approval(
+        emit IERC20.Approval(
             owner,
             spender,
             ERC20Extended.allowance(owner, spender) - amount
         );
 
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn_from(owner, amount);
         assertEq(ERC20Extended.balanceOf(owner), balance - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -439,14 +430,14 @@ contract ERC20Test is Test {
         ERC20Extended.approve(spender, balance);
         vm.startPrank(spender);
         vm.expectEmit(true, true, false, true);
-        emit Approval(
+        emit IERC20.Approval(
             owner,
             spender,
             ERC20Extended.allowance(owner, spender) - amount
         );
 
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn_from(owner, amount);
         assertEq(ERC20Extended.balanceOf(owner), balance - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -498,7 +489,7 @@ contract ERC20Test is Test {
 
         vm.startPrank(spender);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn_from(owner, amount);
         assertEq(ERC20Extended.balanceOf(owner), balance - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -519,7 +510,7 @@ contract ERC20Test is Test {
         uint256 multiplier = 10 ** uint256(ERC20Extended.decimals());
         vm.startPrank(minter);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(zeroAddress, owner, amount);
+        emit IERC20.Transfer(zeroAddress, owner, amount);
         ERC20Extended.mint(owner, amount);
         assertEq(ERC20Extended.balanceOf(owner), amount);
         assertEq(
@@ -551,12 +542,12 @@ contract ERC20Test is Test {
         address minter = makeAddr("minter");
         vm.startPrank(owner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minter, true);
+        emit IERC20Extended.RoleMinterChanged(minter, true);
         ERC20Extended.set_minter(minter, true);
         assertTrue(ERC20Extended.is_minter(minter));
 
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minter, false);
+        emit IERC20Extended.RoleMinterChanged(minter, false);
         ERC20Extended.set_minter(minter, false);
         assertTrue(!ERC20Extended.is_minter(minter));
         vm.stopPrank();
@@ -607,7 +598,7 @@ contract ERC20Test is Test {
             )
         );
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         ERC20Extended.permit(owner, spender, amount, deadline, v, r, s);
         assertEq(ERC20Extended.allowance(owner, spender), amount);
         assertEq(ERC20Extended.nonces(owner), 1);
@@ -641,7 +632,7 @@ contract ERC20Test is Test {
             )
         );
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         ERC20Extended.permit(owner, spender, amount, deadline, v, r, s);
         vm.expectRevert(bytes("ERC20Permit: invalid signature"));
         ERC20Extended.permit(owner, spender, amount, deadline, v, r, s);
@@ -836,11 +827,11 @@ contract ERC20Test is Test {
         address newOwner = makeAddr("newOwner");
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC20Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC20Extended.OwnershipTransferred(oldOwner, newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, true);
+        emit IERC20Extended.RoleMinterChanged(newOwner, true);
         ERC20Extended.transfer_ownership(newOwner);
         assertEq(ERC20Extended.owner(), newOwner);
         assertTrue(!ERC20Extended.is_minter(oldOwner));
@@ -864,9 +855,9 @@ contract ERC20Test is Test {
         address newOwner = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC20Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC20Extended.OwnershipTransferred(oldOwner, newOwner);
         ERC20Extended.renounce_ownership();
         assertEq(ERC20Extended.owner(), newOwner);
         assertTrue(!ERC20Extended.is_minter(oldOwner));
@@ -884,7 +875,7 @@ contract ERC20Test is Test {
         uint256 give = type(uint256).max;
         deal(ERC20ExtendedAddr, from, give);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(from, to, amount);
+        emit IERC20.Transfer(from, to, amount);
         bool returnValue = ERC20Extended.transfer(to, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.balanceOf(from), give - amount);
@@ -911,7 +902,7 @@ contract ERC20Test is Test {
         vm.assume(spender != zeroAddress);
         address owner = self;
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, amount);
+        emit IERC20.Approval(owner, spender, amount);
         bool returnValue = ERC20Extended.approve(spender, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.allowance(owner, spender), amount);
@@ -938,9 +929,9 @@ contract ERC20Test is Test {
         vm.stopPrank();
 
         vm.expectEmit(true, true, false, true);
-        emit Approval(owner, spender, 0);
+        emit IERC20.Approval(owner, spender, 0);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, to, amount);
+        emit IERC20.Transfer(owner, to, amount);
         bool returnValue = ERC20Extended.transferFrom(owner, to, amount);
         assertTrue(returnValue);
         assertEq(ERC20Extended.balanceOf(owner), give - amount);
@@ -975,7 +966,7 @@ contract ERC20Test is Test {
         uint256 totalSupply = ERC20Extended.totalSupply();
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn(amount);
         assertEq(ERC20Extended.balanceOf(owner), give - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -1001,7 +992,7 @@ contract ERC20Test is Test {
         vm.stopPrank();
 
         vm.expectEmit(true, true, false, true);
-        emit Transfer(owner, zeroAddress, amount);
+        emit IERC20.Transfer(owner, zeroAddress, amount);
         ERC20Extended.burn_from(owner, amount);
         assertEq(ERC20Extended.balanceOf(owner), give - amount);
         assertEq(ERC20Extended.totalSupply(), totalSupply - amount);
@@ -1033,7 +1024,7 @@ contract ERC20Test is Test {
         uint256 multiplier = 10 ** uint256(ERC20Extended.decimals());
         vm.startPrank(minter);
         vm.expectEmit(true, true, false, true);
-        emit Transfer(zeroAddress, ownerAddr, amount);
+        emit IERC20.Transfer(zeroAddress, ownerAddr, amount);
         ERC20Extended.mint(ownerAddr, amount);
         assertEq(ERC20Extended.balanceOf(ownerAddr), amount);
         assertEq(
@@ -1056,12 +1047,12 @@ contract ERC20Test is Test {
         address minterAddr = makeAddr(minter);
         vm.startPrank(owner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minterAddr, true);
+        emit IERC20Extended.RoleMinterChanged(minterAddr, true);
         ERC20Extended.set_minter(minterAddr, true);
         assertTrue(ERC20Extended.is_minter(minterAddr));
 
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minterAddr, false);
+        emit IERC20Extended.RoleMinterChanged(minterAddr, false);
         ERC20Extended.set_minter(minterAddr, false);
         assertTrue(!ERC20Extended.is_minter(minterAddr));
         vm.stopPrank();
@@ -1108,7 +1099,7 @@ contract ERC20Test is Test {
             )
         );
         vm.expectEmit(true, true, false, true);
-        emit Approval(ownerAddr, spenderAddr, amount);
+        emit IERC20.Approval(ownerAddr, spenderAddr, amount);
         ERC20Extended.permit(ownerAddr, spenderAddr, amount, deadline, v, r, s);
         assertEq(ERC20Extended.allowance(ownerAddr, spenderAddr), amount);
         assertEq(ERC20Extended.nonces(ownerAddr), 1);
@@ -1224,11 +1215,11 @@ contract ERC20Test is Test {
         address oldOwner = deployer;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC20Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner1);
+        emit IERC20Extended.OwnershipTransferred(oldOwner, newOwner1);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner1, true);
+        emit IERC20Extended.RoleMinterChanged(newOwner1, true);
         ERC20Extended.transfer_ownership(newOwner1);
         assertEq(ERC20Extended.owner(), newOwner1);
         assertTrue(!ERC20Extended.is_minter(oldOwner));
@@ -1237,12 +1228,12 @@ contract ERC20Test is Test {
 
         vm.startPrank(newOwner1);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner1, false);
+        emit IERC20Extended.RoleMinterChanged(newOwner1, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC20Extended.OwnershipTransferred(newOwner1, newOwner2);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner2, true);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC20Extended.RoleMinterChanged(newOwner2, true);
+        emit IERC20Extended.OwnershipTransferred(newOwner1, newOwner2);
         ERC20Extended.transfer_ownership(newOwner2);
         assertEq(ERC20Extended.owner(), newOwner2);
         assertTrue(!ERC20Extended.is_minter(newOwner1));
@@ -1266,19 +1257,19 @@ contract ERC20Test is Test {
         address renounceAddress = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC20Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC20Extended.OwnershipTransferred(oldOwner, newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, true);
+        emit IERC20Extended.RoleMinterChanged(newOwner, true);
         ERC20Extended.transfer_ownership(newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, false);
+        emit IERC20Extended.RoleMinterChanged(newOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner, renounceAddress);
+        emit IERC20Extended.OwnershipTransferred(newOwner, renounceAddress);
         ERC20Extended.renounce_ownership();
         assertEq(ERC20Extended.owner(), renounceAddress);
         vm.stopPrank();
diff --git a/test/tokens/ERC721.t.sol b/test/tokens/ERC721.t.sol
index 3a86b011..a113e93c 100644
--- a/test/tokens/ERC721.t.sol
+++ b/test/tokens/ERC721.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {stdError} from "forge-std/StdError.sol";
@@ -10,6 +10,7 @@ import {IERC721} from "openzeppelin/token/ERC721/IERC721.sol";
 import {IERC721Receiver} from "openzeppelin/token/ERC721/IERC721Receiver.sol";
 import {IERC721Metadata} from "openzeppelin/token/ERC721/extensions/IERC721Metadata.sol";
 import {IERC721Enumerable} from "openzeppelin/token/ERC721/extensions/IERC721Enumerable.sol";
+import {IERC4906} from "openzeppelin/interfaces/IERC4906.sol";
 import {IERC4494} from "./interfaces/IERC4494.sol";
 
 import {Address} from "openzeppelin/utils/Address.sol";
@@ -50,35 +51,6 @@ contract ERC721Test is Test {
     // solhint-disable-next-line var-name-mixedcase
     address private ERC721ExtendedAddr;
 
-    event Transfer(
-        address indexed from,
-        address indexed to,
-        uint256 indexed tokenId
-    );
-
-    event Received(address operator, address from, uint256 tokenId, bytes data);
-
-    event Approval(
-        address indexed owner,
-        address indexed approved,
-        uint256 indexed tokenId
-    );
-
-    event ApprovalForAll(
-        address indexed owner,
-        address indexed operator,
-        bool approved
-    );
-
-    event OwnershipTransferred(
-        address indexed previousOwner,
-        address indexed newOwner
-    );
-
-    event MetadataUpdate(uint256 tokenId);
-
-    event RoleMinterChanged(address indexed minter, bool status);
-
     /**
      * @dev An `internal` function that validates a successful transfer call.
      * @param owner The 20-byte owner address.
@@ -252,7 +224,7 @@ contract ERC721Test is Test {
         uint256 snapshot = vm.snapshot();
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, receiver, tokenId);
+        emit IERC721.Transfer(owner, receiver, tokenId);
         if (!withData) {
             Address.functionCall(
                 ERC721ExtendedAddr,
@@ -282,7 +254,7 @@ contract ERC721Test is Test {
         snapshot = vm.snapshot();
         vm.startPrank(approved);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, receiver, tokenId);
+        emit IERC721.Transfer(owner, receiver, tokenId);
         if (!withData) {
             Address.functionCall(
                 ERC721ExtendedAddr,
@@ -312,7 +284,7 @@ contract ERC721Test is Test {
         snapshot = vm.snapshot();
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, receiver, tokenId);
+        emit IERC721.Transfer(owner, receiver, tokenId);
         if (!withData) {
             Address.functionCall(
                 ERC721ExtendedAddr,
@@ -345,7 +317,7 @@ contract ERC721Test is Test {
         vm.stopPrank();
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, receiver, tokenId);
+        emit IERC721.Transfer(owner, receiver, tokenId);
         if (!withData) {
             Address.functionCall(
                 ERC721ExtendedAddr,
@@ -375,7 +347,7 @@ contract ERC721Test is Test {
         snapshot = vm.snapshot();
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, owner, tokenId);
+        emit IERC721.Transfer(owner, owner, tokenId);
         if (!withData) {
             Address.functionCall(
                 ERC721ExtendedAddr,
@@ -465,7 +437,7 @@ contract ERC721Test is Test {
         snapshot = vm.snapshot();
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, true, receiver);
-        emit Received(owner, owner, tokenId, data);
+        emit ERC721ReceiverMock.Received(owner, owner, tokenId, data);
         Address.functionCall(
             ERC721ExtendedAddr,
             abi.encodeWithSignature(
@@ -483,7 +455,7 @@ contract ERC721Test is Test {
         snapshot = vm.snapshot();
         vm.startPrank(approved);
         vm.expectEmit(true, true, true, true, receiver);
-        emit Received(approved, owner, tokenId, data);
+        emit ERC721ReceiverMock.Received(approved, owner, tokenId, data);
         Address.functionCall(
             ERC721ExtendedAddr,
             abi.encodeWithSignature(
@@ -544,9 +516,9 @@ contract ERC721Test is Test {
         assertTrue(ERC721Extended.is_minter(deployer));
 
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(zeroAddress, deployer);
+        emit IERC721Extended.OwnershipTransferred(zeroAddress, deployer);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(deployer, true);
+        emit IERC721Extended.RoleMinterChanged(deployer, true);
         bytes memory args = abi.encode(
             _NAME,
             _SYMBOL,
@@ -844,7 +816,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -862,12 +834,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender1, tokenId);
+        emit IERC721.Approval(owner, spender1, tokenId);
         ERC721Extended.approve(spender1, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender1);
 
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender2, tokenId);
+        emit IERC721.Approval(owner, spender2, tokenId);
         ERC721Extended.approve(spender2, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender2);
         vm.stopPrank();
@@ -885,12 +857,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender1, tokenId);
+        emit IERC721.Approval(owner, spender1, tokenId);
         ERC721Extended.approve(spender1, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender1);
 
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender2, tokenId);
+        emit IERC721.Approval(owner, spender2, tokenId);
         ERC721Extended.approve(spender2, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender2);
         vm.stopPrank();
@@ -907,7 +879,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -924,12 +896,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
 
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -947,12 +919,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender1, tokenId);
+        emit IERC721.Approval(owner, spender1, tokenId);
         ERC721Extended.approve(spender1, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender1);
 
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender2, tokenId);
+        emit IERC721.Approval(owner, spender2, tokenId);
         ERC721Extended.approve(spender2, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender2);
         vm.stopPrank();
@@ -1029,7 +1001,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -1060,7 +1032,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC721.ApprovalForAll(owner, operator, approved);
         ERC721Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC721Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -1077,17 +1049,17 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, !approved);
+        emit IERC721.ApprovalForAll(owner, operator, !approved);
         ERC721Extended.setApprovalForAll(operator, !approved);
         assertTrue(!ERC721Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC721.ApprovalForAll(owner, operator, approved);
         ERC721Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC721Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, !approved);
+        emit IERC721.ApprovalForAll(owner, operator, !approved);
         ERC721Extended.setApprovalForAll(operator, !approved);
         assertTrue(!ERC721Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -1104,12 +1076,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC721.ApprovalForAll(owner, operator, approved);
         ERC721Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC721Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC721.ApprovalForAll(owner, operator, approved);
         ERC721Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC721Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -1375,7 +1347,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, zeroAddress, tokenId);
+        emit IERC721.Transfer(owner, zeroAddress, tokenId);
         ERC721Extended.burn(tokenId);
         vm.expectRevert(bytes("ERC721: invalid token ID"));
         ERC721Extended.burn(tokenId);
@@ -1407,13 +1379,13 @@ contract ERC721Test is Test {
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, zeroAddress, tokenId);
+        emit IERC721.Transfer(owner, zeroAddress, tokenId);
         ERC721Extended.burn(tokenId);
         vm.stopPrank();
 
         vm.startPrank(other);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, zeroAddress, tokenId + 1);
+        emit IERC721.Transfer(owner, zeroAddress, tokenId + 1);
         ERC721Extended.burn(tokenId + 1);
         vm.stopPrank();
 
@@ -1439,33 +1411,33 @@ contract ERC721Test is Test {
         uint256 tokenId = 0;
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(zeroAddress, owner, tokenId);
+        emit IERC721.Transfer(zeroAddress, owner, tokenId);
         vm.expectEmit(false, false, false, true);
-        emit MetadataUpdate(tokenId);
+        emit IERC4906.MetadataUpdate(tokenId);
         ERC721Extended.safe_mint(owner, uri1);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(zeroAddress, owner, tokenId + 1);
+        emit IERC721.Transfer(zeroAddress, owner, tokenId + 1);
         vm.expectEmit(false, false, false, true);
-        emit MetadataUpdate(tokenId + 1);
+        emit IERC4906.MetadataUpdate(tokenId + 1);
         ERC721Extended.safe_mint(owner, uri2);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(zeroAddress, owner, tokenId + 2);
+        emit IERC721.Transfer(zeroAddress, owner, tokenId + 2);
         vm.expectEmit(false, false, false, true);
-        emit MetadataUpdate(tokenId + 2);
+        emit IERC4906.MetadataUpdate(tokenId + 2);
         ERC721Extended.safe_mint(owner, uri3);
         vm.stopPrank();
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, zeroAddress, tokenId + 2);
+        emit IERC721.Transfer(owner, zeroAddress, tokenId + 2);
         ERC721Extended.burn(tokenId + 2);
         vm.stopPrank();
 
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(zeroAddress, owner, tokenId + 3);
+        emit IERC721.Transfer(zeroAddress, owner, tokenId + 3);
         vm.expectEmit(false, false, false, true);
-        emit MetadataUpdate(tokenId + 3);
+        emit IERC4906.MetadataUpdate(tokenId + 3);
         ERC721Extended.safe_mint(owner, "");
         vm.stopPrank();
         assertEq(ERC721Extended.balanceOf(owner), 3);
@@ -1482,14 +1454,14 @@ contract ERC721Test is Test {
         uint256 tokenId = 0;
         vm.startPrank(deployer);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(zeroAddress, owner, tokenId);
+        emit IERC721.Transfer(zeroAddress, owner, tokenId);
         vm.expectEmit(false, false, false, true);
-        emit MetadataUpdate(tokenId);
+        emit IERC4906.MetadataUpdate(tokenId);
         ERC721Extended.safe_mint(owner, uri1);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(zeroAddress, owner, tokenId + 1);
+        emit IERC721.Transfer(zeroAddress, owner, tokenId + 1);
         vm.expectEmit(false, false, false, true);
-        emit MetadataUpdate(tokenId + 1);
+        emit IERC4906.MetadataUpdate(tokenId + 1);
         ERC721Extended.safe_mint(owner, uri2);
 
         /**
@@ -1619,12 +1591,12 @@ contract ERC721Test is Test {
         address minter = makeAddr("minter");
         vm.startPrank(owner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minter, true);
+        emit IERC721Extended.RoleMinterChanged(minter, true);
         ERC721Extended.set_minter(minter, true);
         assertTrue(ERC721Extended.is_minter(minter));
 
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minter, false);
+        emit IERC721Extended.RoleMinterChanged(minter, false);
         ERC721Extended.set_minter(minter, false);
         assertTrue(!ERC721Extended.is_minter(minter));
         vm.stopPrank();
@@ -1679,7 +1651,7 @@ contract ERC721Test is Test {
             )
         );
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.permit(spender, tokenId, deadline, v, r, s);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         assertEq(ERC721Extended.nonces(tokenId), 1);
@@ -1717,7 +1689,7 @@ contract ERC721Test is Test {
             )
         );
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.permit(spender, tokenId, deadline, v, r, s);
         vm.expectRevert(bytes("ERC721Permit: invalid signature"));
         ERC721Extended.permit(spender, tokenId, deadline, v, r, s);
@@ -1928,11 +1900,11 @@ contract ERC721Test is Test {
         address newOwner = makeAddr("newOwner");
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC721Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC721Extended.OwnershipTransferred(oldOwner, newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, true);
+        emit IERC721Extended.RoleMinterChanged(newOwner, true);
         ERC721Extended.transfer_ownership(newOwner);
         assertEq(ERC721Extended.owner(), newOwner);
         assertTrue(!ERC721Extended.is_minter(oldOwner));
@@ -1956,9 +1928,9 @@ contract ERC721Test is Test {
         address newOwner = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC721Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC721Extended.OwnershipTransferred(oldOwner, newOwner);
         ERC721Extended.renounce_ownership();
         assertEq(ERC721Extended.owner(), newOwner);
         assertTrue(!ERC721Extended.is_minter(oldOwner));
@@ -2086,7 +2058,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -2109,12 +2081,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender1, tokenId);
+        emit IERC721.Approval(owner, spender1, tokenId);
         ERC721Extended.approve(spender1, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender1);
 
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender2, tokenId);
+        emit IERC721.Approval(owner, spender2, tokenId);
         ERC721Extended.approve(spender2, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender2);
         vm.stopPrank();
@@ -2136,7 +2108,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -2158,12 +2130,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
 
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -2217,7 +2189,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(operator);
         vm.expectEmit(true, true, true, false);
-        emit Approval(owner, spender, tokenId);
+        emit IERC721.Approval(owner, spender, tokenId);
         ERC721Extended.approve(spender, tokenId);
         assertEq(ERC721Extended.getApproved(tokenId), spender);
         vm.stopPrank();
@@ -2239,17 +2211,17 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, !approved);
+        emit IERC721.ApprovalForAll(owner, operator, !approved);
         ERC721Extended.setApprovalForAll(operator, !approved);
         assertTrue(!ERC721Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, approved);
+        emit IERC721.ApprovalForAll(owner, operator, approved);
         ERC721Extended.setApprovalForAll(operator, approved);
         assertTrue(ERC721Extended.isApprovedForAll(owner, operator));
 
         vm.expectEmit(true, true, false, true);
-        emit ApprovalForAll(owner, operator, !approved);
+        emit IERC721.ApprovalForAll(owner, operator, !approved);
         ERC721Extended.setApprovalForAll(operator, !approved);
         assertTrue(!ERC721Extended.isApprovedForAll(owner, operator));
         vm.stopPrank();
@@ -2307,7 +2279,7 @@ contract ERC721Test is Test {
 
         vm.startPrank(owner);
         vm.expectEmit(true, true, true, false);
-        emit Transfer(owner, zeroAddress, tokenId);
+        emit IERC721.Transfer(owner, zeroAddress, tokenId);
         ERC721Extended.burn(tokenId);
         vm.expectRevert(bytes("ERC721: invalid token ID"));
         ERC721Extended.burn(tokenId);
@@ -2326,9 +2298,9 @@ contract ERC721Test is Test {
         vm.startPrank(deployer);
         for (uint256 i; i < owners.length; ++i) {
             vm.expectEmit(true, true, true, false);
-            emit Transfer(zeroAddress, owners[i], i);
+            emit IERC721.Transfer(zeroAddress, owners[i], i);
             vm.expectEmit(false, false, false, true);
-            emit MetadataUpdate(i);
+            emit IERC4906.MetadataUpdate(i);
             ERC721Extended.safe_mint(owners[i], uri);
             assertGe(ERC721Extended.balanceOf(owners[i]), 1);
         }
@@ -2347,12 +2319,12 @@ contract ERC721Test is Test {
         address minterAddr = makeAddr(minter);
         vm.startPrank(owner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minterAddr, true);
+        emit IERC721Extended.RoleMinterChanged(minterAddr, true);
         ERC721Extended.set_minter(minterAddr, true);
         assertTrue(ERC721Extended.is_minter(minterAddr));
 
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(minterAddr, false);
+        emit IERC721Extended.RoleMinterChanged(minterAddr, false);
         ERC721Extended.set_minter(minterAddr, false);
         assertTrue(!ERC721Extended.is_minter(minterAddr));
         vm.stopPrank();
@@ -2403,7 +2375,7 @@ contract ERC721Test is Test {
             )
         );
         vm.expectEmit(true, true, true, false);
-        emit Approval(ownerAddr, spenderAddr, tokenId);
+        emit IERC721.Approval(ownerAddr, spenderAddr, tokenId);
         ERC721Extended.permit(spenderAddr, tokenId, deadline, v, r, s);
         assertEq(ERC721Extended.getApproved(tokenId), spenderAddr);
         assertEq(ERC721Extended.nonces(tokenId), 1);
@@ -2523,11 +2495,11 @@ contract ERC721Test is Test {
         address oldOwner = deployer;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC721Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner1);
+        emit IERC721Extended.OwnershipTransferred(oldOwner, newOwner1);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner1, true);
+        emit IERC721Extended.RoleMinterChanged(newOwner1, true);
         ERC721Extended.transfer_ownership(newOwner1);
         assertEq(ERC721Extended.owner(), newOwner1);
         assertTrue(!ERC721Extended.is_minter(oldOwner));
@@ -2536,12 +2508,12 @@ contract ERC721Test is Test {
 
         vm.startPrank(newOwner1);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner1, false);
+        emit IERC721Extended.RoleMinterChanged(newOwner1, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC721Extended.OwnershipTransferred(newOwner1, newOwner2);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner2, true);
-        emit OwnershipTransferred(newOwner1, newOwner2);
+        emit IERC721Extended.RoleMinterChanged(newOwner2, true);
+        emit IERC721Extended.OwnershipTransferred(newOwner1, newOwner2);
         ERC721Extended.transfer_ownership(newOwner2);
         assertEq(ERC721Extended.owner(), newOwner2);
         assertTrue(!ERC721Extended.is_minter(newOwner1));
@@ -2565,19 +2537,19 @@ contract ERC721Test is Test {
         address renounceAddress = zeroAddress;
         vm.startPrank(oldOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(oldOwner, false);
+        emit IERC721Extended.RoleMinterChanged(oldOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(oldOwner, newOwner);
+        emit IERC721Extended.OwnershipTransferred(oldOwner, newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, true);
+        emit IERC721Extended.RoleMinterChanged(newOwner, true);
         ERC721Extended.transfer_ownership(newOwner);
         vm.stopPrank();
 
         vm.startPrank(newOwner);
         vm.expectEmit(true, false, false, true);
-        emit RoleMinterChanged(newOwner, false);
+        emit IERC721Extended.RoleMinterChanged(newOwner, false);
         vm.expectEmit(true, true, false, false);
-        emit OwnershipTransferred(newOwner, renounceAddress);
+        emit IERC721Extended.OwnershipTransferred(newOwner, renounceAddress);
         ERC721Extended.renounce_ownership();
         assertEq(ERC721Extended.owner(), renounceAddress);
         vm.stopPrank();
diff --git a/test/tokens/interfaces/IERC1155Extended.sol b/test/tokens/interfaces/IERC1155Extended.sol
index 5caefbe7..1c180994 100644
--- a/test/tokens/interfaces/IERC1155Extended.sol
+++ b/test/tokens/interfaces/IERC1155Extended.sol
@@ -1,9 +1,16 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC1155MetadataURI} from "openzeppelin/token/ERC1155/extensions/IERC1155MetadataURI.sol";
 
 interface IERC1155Extended is IERC1155MetadataURI {
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+    event RoleMinterChanged(address indexed minter, bool status);
+
     function set_uri(uint256 id, string calldata tokenUri) external;
 
     function exists(uint256 id) external view returns (bool);
diff --git a/test/tokens/interfaces/IERC20Extended.sol b/test/tokens/interfaces/IERC20Extended.sol
index b8ba9560..fd1e75c2 100644
--- a/test/tokens/interfaces/IERC20Extended.sol
+++ b/test/tokens/interfaces/IERC20Extended.sol
@@ -1,11 +1,18 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC20Metadata} from "openzeppelin/token/ERC20/extensions/IERC20Metadata.sol";
 import {IERC20Permit} from "openzeppelin/token/ERC20/extensions/IERC20Permit.sol";
 import {IERC5267} from "openzeppelin/interfaces/IERC5267.sol";
 
 interface IERC20Extended is IERC20Metadata, IERC20Permit, IERC5267 {
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+    event RoleMinterChanged(address indexed minter, bool status);
+
     function burn(uint256 amount) external;
 
     function burn_from(address owner, uint256 amount) external;
diff --git a/test/tokens/interfaces/IERC4494.sol b/test/tokens/interfaces/IERC4494.sol
index 5e387782..ec80df07 100644
--- a/test/tokens/interfaces/IERC4494.sol
+++ b/test/tokens/interfaces/IERC4494.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC165} from "openzeppelin/utils/introspection/IERC165.sol";
 
diff --git a/test/tokens/interfaces/IERC721Extended.sol b/test/tokens/interfaces/IERC721Extended.sol
index a5fe9409..f8112b39 100644
--- a/test/tokens/interfaces/IERC721Extended.sol
+++ b/test/tokens/interfaces/IERC721Extended.sol
@@ -1,17 +1,26 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC721Metadata} from "openzeppelin/token/ERC721/extensions/IERC721Metadata.sol";
 import {IERC721Enumerable} from "openzeppelin/token/ERC721/extensions/IERC721Enumerable.sol";
 import {IERC5267} from "openzeppelin/interfaces/IERC5267.sol";
+import {IERC4906} from "openzeppelin/interfaces/IERC4906.sol";
 import {IERC4494} from "./IERC4494.sol";
 
 interface IERC721Extended is
     IERC721Metadata,
     IERC721Enumerable,
     IERC4494,
-    IERC5267
+    IERC5267,
+    IERC4906
 {
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+    event RoleMinterChanged(address indexed minter, bool status);
+
     function burn(uint256 tokenId) external;
 
     function is_minter(address minter) external view returns (bool);
diff --git a/test/tokens/mocks/ERC1155ReceiverMock.sol b/test/tokens/mocks/ERC1155ReceiverMock.sol
index 937408a3..c659e060 100644
--- a/test/tokens/mocks/ERC1155ReceiverMock.sol
+++ b/test/tokens/mocks/ERC1155ReceiverMock.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {ERC165} from "openzeppelin/utils/introspection/ERC165.sol";
 import {IERC1155Receiver} from "openzeppelin/token/ERC1155/IERC1155Receiver.sol";
diff --git a/test/tokens/mocks/ERC721ReceiverMock.sol b/test/tokens/mocks/ERC721ReceiverMock.sol
index df50620d..4cbf199c 100644
--- a/test/tokens/mocks/ERC721ReceiverMock.sol
+++ b/test/tokens/mocks/ERC721ReceiverMock.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC721Receiver} from "openzeppelin/token/ERC721/IERC721Receiver.sol";
 
diff --git a/test/utils/Base64.t.sol b/test/utils/Base64.t.sol
index 94769fd5..e6d87255 100644
--- a/test/utils/Base64.t.sol
+++ b/test/utils/Base64.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {PRBTest} from "prb/test/PRBTest.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/BatchDistributor.t.sol b/test/utils/BatchDistributor.t.sol
index 386d7ce7..85920a2b 100644
--- a/test/utils/BatchDistributor.t.sol
+++ b/test/utils/BatchDistributor.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/Create2Address.t.sol b/test/utils/Create2Address.t.sol
index deed47d1..593d83fc 100644
--- a/test/utils/Create2Address.t.sol
+++ b/test/utils/Create2Address.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/CreateAddress.t.sol b/test/utils/CreateAddress.t.sol
index d94bc419..e98cbb15 100644
--- a/test/utils/CreateAddress.t.sol
+++ b/test/utils/CreateAddress.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/ECDSA.t.sol b/test/utils/ECDSA.t.sol
index c7e740f3..69ec801a 100644
--- a/test/utils/ECDSA.t.sol
+++ b/test/utils/ECDSA.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/EIP712DomainSeparator.t.sol b/test/utils/EIP712DomainSeparator.t.sol
index d04d6b95..9443a00f 100644
--- a/test/utils/EIP712DomainSeparator.t.sol
+++ b/test/utils/EIP712DomainSeparator.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/Math.t.sol b/test/utils/Math.t.sol
index a9dd2955..50c3f448 100644
--- a/test/utils/Math.t.sol
+++ b/test/utils/Math.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/MerkleProofVerification.t.sol b/test/utils/MerkleProofVerification.t.sol
index d9937e08..2e8aba89 100644
--- a/test/utils/MerkleProofVerification.t.sol
+++ b/test/utils/MerkleProofVerification.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/Multicall.t.sol b/test/utils/Multicall.t.sol
index 36d7f97a..49c8677a 100644
--- a/test/utils/Multicall.t.sol
+++ b/test/utils/Multicall.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/SignatureChecker.t.sol b/test/utils/SignatureChecker.t.sol
index 75d867a9..164fd6f3 100644
--- a/test/utils/SignatureChecker.t.sol
+++ b/test/utils/SignatureChecker.t.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Test} from "forge-std/Test.sol";
 import {VyperDeployer} from "utils/VyperDeployer.sol";
diff --git a/test/utils/interfaces/IBase64.sol b/test/utils/interfaces/IBase64.sol
index e6e8c06b..9234e147 100644
--- a/test/utils/interfaces/IBase64.sol
+++ b/test/utils/interfaces/IBase64.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IBase64 {
     function encode(
diff --git a/test/utils/interfaces/IBatchDistributor.sol b/test/utils/interfaces/IBatchDistributor.sol
index 7da0f349..c3e955ac 100644
--- a/test/utils/interfaces/IBatchDistributor.sol
+++ b/test/utils/interfaces/IBatchDistributor.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC20} from "openzeppelin/token/ERC20/IERC20.sol";
 
diff --git a/test/utils/interfaces/ICreate2Address.sol b/test/utils/interfaces/ICreate2Address.sol
index 4ee19fca..6d88333c 100644
--- a/test/utils/interfaces/ICreate2Address.sol
+++ b/test/utils/interfaces/ICreate2Address.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface ICreate2Address {
     function compute_address_self(
diff --git a/test/utils/interfaces/ICreateAddress.sol b/test/utils/interfaces/ICreateAddress.sol
index 6996301f..d5fb5e5f 100644
--- a/test/utils/interfaces/ICreateAddress.sol
+++ b/test/utils/interfaces/ICreateAddress.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface ICreateAddress {
     function compute_address_rlp_self(
diff --git a/test/utils/interfaces/IECDSA.sol b/test/utils/interfaces/IECDSA.sol
index 9556a836..a978b1d8 100644
--- a/test/utils/interfaces/IECDSA.sol
+++ b/test/utils/interfaces/IECDSA.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IECDSA {
     function recover_sig(
diff --git a/test/utils/interfaces/IEIP712DomainSeparator.sol b/test/utils/interfaces/IEIP712DomainSeparator.sol
index 8a6940f8..04494b9d 100644
--- a/test/utils/interfaces/IEIP712DomainSeparator.sol
+++ b/test/utils/interfaces/IEIP712DomainSeparator.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC5267} from "openzeppelin/interfaces/IERC5267.sol";
 
diff --git a/test/utils/interfaces/IMath.sol b/test/utils/interfaces/IMath.sol
index 601aae66..33f41e12 100644
--- a/test/utils/interfaces/IMath.sol
+++ b/test/utils/interfaces/IMath.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IMath {
     function uint256_average(
diff --git a/test/utils/interfaces/IMerkleProofVerification.sol b/test/utils/interfaces/IMerkleProofVerification.sol
index faa9c3bd..645d31d1 100644
--- a/test/utils/interfaces/IMerkleProofVerification.sol
+++ b/test/utils/interfaces/IMerkleProofVerification.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IMerkleProofVerification {
     function verify(
diff --git a/test/utils/interfaces/IMulticall.sol b/test/utils/interfaces/IMulticall.sol
index 4151c69c..a9f8b3e9 100644
--- a/test/utils/interfaces/IMulticall.sol
+++ b/test/utils/interfaces/IMulticall.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface IMulticall {
     struct Batch {
diff --git a/test/utils/interfaces/ISignatureChecker.sol b/test/utils/interfaces/ISignatureChecker.sol
index dca12dfd..33bb99bc 100644
--- a/test/utils/interfaces/ISignatureChecker.sol
+++ b/test/utils/interfaces/ISignatureChecker.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: WTFPL
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 interface ISignatureChecker {
     function is_valid_signature_now(
diff --git a/test/utils/mocks/Create2Impl.sol b/test/utils/mocks/Create2Impl.sol
index 62fc25ba..335d807b 100644
--- a/test/utils/mocks/Create2Impl.sol
+++ b/test/utils/mocks/Create2Impl.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Create2} from "openzeppelin/utils/Create2.sol";
 
diff --git a/test/utils/mocks/ERC1271MaliciousMock.sol b/test/utils/mocks/ERC1271MaliciousMock.sol
index 707d4f04..a606712f 100644
--- a/test/utils/mocks/ERC1271MaliciousMock.sol
+++ b/test/utils/mocks/ERC1271MaliciousMock.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {IERC1271} from "openzeppelin/interfaces/IERC1271.sol";
 
diff --git a/test/utils/mocks/ERC1271WalletMock.sol b/test/utils/mocks/ERC1271WalletMock.sol
index 1278486d..7d728c0c 100644
--- a/test/utils/mocks/ERC1271WalletMock.sol
+++ b/test/utils/mocks/ERC1271WalletMock.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {Ownable} from "openzeppelin/access/Ownable.sol";
 import {IERC1271} from "openzeppelin/interfaces/IERC1271.sol";
diff --git a/test/utils/mocks/ERC20Mock.sol b/test/utils/mocks/ERC20Mock.sol
index 9a1919f2..deb3a6fa 100644
--- a/test/utils/mocks/ERC20Mock.sol
+++ b/test/utils/mocks/ERC20Mock.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 import {ERC20} from "openzeppelin/token/ERC20/ERC20.sol";
 
diff --git a/test/utils/mocks/EtherReceiver.sol b/test/utils/mocks/EtherReceiver.sol
index 5ec61be5..82733fc7 100644
--- a/test/utils/mocks/EtherReceiver.sol
+++ b/test/utils/mocks/EtherReceiver.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 /**
  * @title EtherReceiver
diff --git a/test/utils/mocks/MockCallee.sol b/test/utils/mocks/MockCallee.sol
index 92789480..8ec75120 100644
--- a/test/utils/mocks/MockCallee.sol
+++ b/test/utils/mocks/MockCallee.sol
@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.21;
+pragma solidity ^0.8.22;
 
 /**
  * @dev Error that occurs when a method reverts.