Merge main

.gas-snapshot

@@ -3,6 +3,7 @@ BaseInvariantTest:invariantMirror721BalanceSum() (runs: 30, calls: 450, reverts:
 BaseInvariantTest:invariantMirrorAndBaseRemainImmutable() (runs: 30, calls: 450, reverts: 0)
 BaseInvariantTest:invariantTotalReflectionIsValid() (runs: 30, calls: 450, reverts: 0)
 BaseInvariantTest:invariantUserReflectionIsValid() (runs: 30, calls: 450, reverts: 0)
+<<<<<<< HEAD
 BenchTest:testMintAndTransferDN404_01() (gas: 208504)
 BenchTest:testMintAndTransferDN404_02() (gas: 214588)
 BenchTest:testMintAndTransferDN404_03() (gas: 220716)
@@ -80,9 +81,89 @@ DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256) (runs: 258, 
 DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256,uint256) (runs: 258, μ: 781, ~: 746)
 DN404CustomUnitTest:testUnitInvalidCheckTrick(uint256) (runs: 258, μ: 548, ~: 550)
 DN404CustomUnitTest:test__codesize() (gas: 28382)
+=======
+BenchTest:testMintAndTransferDN404_01() (gas: 208476)
+BenchTest:testMintAndTransferDN404_02() (gas: 214623)
+BenchTest:testMintAndTransferDN404_03() (gas: 220730)
+BenchTest:testMintAndTransferDN404_04() (gas: 226881)
+BenchTest:testMintAndTransferDN404_05() (gas: 254909)
+BenchTest:testMintAndTransferDN404_06() (gas: 261016)
+BenchTest:testMintAndTransferDN404_07() (gas: 267135)
+BenchTest:testMintAndTransferDN404_08() (gas: 273294)
+BenchTest:testMintAndTransferDN404_09() (gas: 345078)
+BenchTest:testMintAndTransferDN404_10() (gas: 351185)
+BenchTest:testMintAndTransferDN404_11() (gas: 357335)
+BenchTest:testMintAndTransferDN404_12() (gas: 363506)
+BenchTest:testMintAndTransferDN404_13() (gas: 391491)
+BenchTest:testMintAndTransferDN404_14() (gas: 397620)
+BenchTest:testMintAndTransferDN404_15() (gas: 403727)
+BenchTest:testMintAndTransferDN404_16() (gas: 409898)
+BenchTest:testMintAndTransferPandora_01() (gas: 190491)
+BenchTest:testMintAndTransferPandora_02() (gas: 306372)
+BenchTest:testMintAndTransferPandora_03() (gas: 422256)
+BenchTest:testMintAndTransferPandora_04() (gas: 538156)
+BenchTest:testMintAndTransferPandora_05() (gas: 654092)
+BenchTest:testMintAndTransferPandora_06() (gas: 769973)
+BenchTest:testMintAndTransferPandora_07() (gas: 885890)
+BenchTest:testMintAndTransferPandora_08() (gas: 1001773)
+BenchTest:testMintAndTransferPandora_09() (gas: 1117673)
+BenchTest:testMintAndTransferPandora_10() (gas: 1233556)
+BenchTest:testMintAndTransferPandora_11() (gas: 1349472)
+BenchTest:testMintAndTransferPandora_12() (gas: 1465408)
+BenchTest:testMintAndTransferPandora_13() (gas: 1581274)
+BenchTest:testMintAndTransferPandora_14() (gas: 1697190)
+BenchTest:testMintAndTransferPandora_15() (gas: 1813056)
+BenchTest:testMintAndTransferPandora_16() (gas: 1929009)
+BenchTest:testMintDN404_01() (gas: 123326)
+BenchTest:testMintDN404_02() (gas: 126415)
+BenchTest:testMintDN404_03() (gas: 129464)
+BenchTest:testMintDN404_04() (gas: 132601)
+BenchTest:testMintDN404_05() (gas: 157591)
+BenchTest:testMintDN404_06() (gas: 160618)
+BenchTest:testMintDN404_07() (gas: 163777)
+BenchTest:testMintDN404_08() (gas: 166824)
+BenchTest:testMintDN404_09() (gas: 213738)
+BenchTest:testMintDN404_10() (gas: 216810)
+BenchTest:testMintDN404_11() (gas: 219900)
+BenchTest:testMintDN404_12() (gas: 222993)
+BenchTest:testMintDN404_13() (gas: 247986)
+BenchTest:testMintDN404_14() (gas: 251056)
+BenchTest:testMintDN404_15() (gas: 254189)
+BenchTest:testMintDN404_16() (gas: 257260)
+BenchTest:testMintPandora_01() (gas: 133912)
+BenchTest:testMintPandora_02() (gas: 203416)
+BenchTest:testMintPandora_03() (gas: 272897)
+BenchTest:testMintPandora_04() (gas: 342371)
+BenchTest:testMintPandora_05() (gas: 411929)
+BenchTest:testMintPandora_06() (gas: 481455)
+BenchTest:testMintPandora_07() (gas: 550914)
+BenchTest:testMintPandora_08() (gas: 620441)
+BenchTest:testMintPandora_09() (gas: 689944)
+BenchTest:testMintPandora_10() (gas: 759449)
+BenchTest:testMintPandora_11() (gas: 828907)
+BenchTest:testMintPandora_12() (gas: 898435)
+BenchTest:testMintPandora_13() (gas: 967960)
+BenchTest:testMintPandora_14() (gas: 1037484)
+BenchTest:testMintPandora_15() (gas: 1106967)
+BenchTest:testMintPandora_16() (gas: 1176473)
+BenchTest:test__codesize() (gas: 26848)
+DN404CustomUnitTest:testInitializeCorrectUnitSuccess() (gas: 129962)
+DN404CustomUnitTest:testInitializeWithUnitTooLargeReverts() (gas: 33824)
+DN404CustomUnitTest:testInitializeWithZeroUnitReverts() (gas: 13897)
+DN404CustomUnitTest:testMint() (gas: 162923)
+DN404CustomUnitTest:testMintWithoutNFTs(uint256,uint256,uint256) (runs: 258, μ: 154560, ~: 163018)
+DN404CustomUnitTest:testNFTMint() (gas: 57526664)
+DN404CustomUnitTest:testNFTMintAndBurn(uint256,uint256,uint256) (runs: 258, μ: 205216, ~: 161918)
+DN404CustomUnitTest:testNFTMintViaTransfer(uint256,uint256,uint256) (runs: 258, μ: 216356, ~: 241612)
+DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256) (runs: 258, μ: 638, ~: 692)
+DN404CustomUnitTest:testTotalSupplyOverflowsTrick(uint256,uint256,uint256) (runs: 258, μ: 780, ~: 746)
+DN404CustomUnitTest:testUnitInvalidCheckTrick(uint256) (runs: 258, μ: 548, ~: 550)
+DN404CustomUnitTest:test__codesize() (gas: 28403)
+>>>>>>> main
 DN404MirrorTest:testBaseERC20() (gas: 114578)
-DN404MirrorTest:testFnSelectorNotRecognized() (gas: 7032)
+DN404MirrorTest:testFnSelectorNotRecognized() (gas: 7054)
 DN404MirrorTest:testLinkMirrorContract() (gas: 45864)
+<<<<<<< HEAD
 DN404MirrorTest:testLogDirectTransfers() (gas: 1606798)
 DN404MirrorTest:testLogTransfer() (gas: 120655)
 DN404MirrorTest:testNameAndSymbol(string,string) (runs: 258, μ: 207574, ~: 208087)
@@ -102,11 +183,33 @@ DN404OnlyERC20Test:testApprove(address,uint256) (runs: 258, μ: 30119, ~: 31354)
 DN404OnlyERC20Test:testBurn() (gas: 51486)
 DN404OnlyERC20Test:testBurn(address,uint256,uint256) (runs: 258, μ: 52571, ~: 52687)
 DN404OnlyERC20Test:testBurnInsufficientBalanceReverts(address,uint256,uint256) (runs: 258, μ: 45709, ~: 45780)
+=======
+DN404MirrorTest:testLogDirectTransfers() (gas: 378669)
+DN404MirrorTest:testLogTransfer() (gas: 120655)
+DN404MirrorTest:testNameAndSymbol(string,string) (runs: 258, μ: 207619, ~: 208132)
+DN404MirrorTest:testNotLinked() (gas: 12767)
+DN404MirrorTest:testPullOwner() (gas: 112613)
+DN404MirrorTest:testPullOwnerWithOwnable() (gas: 3289068)
+DN404MirrorTest:testSafeTransferFrom(uint32) (runs: 258, μ: 465845, ~: 465839)
+DN404MirrorTest:testSetAndGetApprovalForAll() (gas: 325298)
+DN404MirrorTest:testSetAndGetApproved() (gas: 322563)
+DN404MirrorTest:testSupportsInterface() (gas: 7544)
+DN404MirrorTest:testTokenURI(string,uint256) (runs: 258, μ: 158123, ~: 135858)
+DN404MirrorTest:testTransferFrom(uint32) (runs: 258, μ: 366833, ~: 366826)
+DN404MirrorTest:testTransferFromMixed(uint256) (runs: 258, μ: 664101, ~: 599437)
+DN404MirrorTest:test__codesize() (gas: 57305)
+DN404OnlyERC20Test:testApprove() (gas: 35803)
+DN404OnlyERC20Test:testApprove(address,uint256) (runs: 258, μ: 30505, ~: 31354)
+DN404OnlyERC20Test:testBurn() (gas: 51486)
+DN404OnlyERC20Test:testBurn(address,uint256,uint256) (runs: 258, μ: 52397, ~: 52687)
+DN404OnlyERC20Test:testBurnInsufficientBalanceReverts(address,uint256,uint256) (runs: 258, μ: 45653, ~: 45780)
+>>>>>>> main
 DN404OnlyERC20Test:testInfiniteApproveTransferFrom() (gas: 104368)
 DN404OnlyERC20Test:testMaxSupplyTrick(uint256) (runs: 258, μ: 541, ~: 541)
 DN404OnlyERC20Test:testMetadata() (gas: 10044)
 DN404OnlyERC20Test:testMint() (gas: 47556)
 DN404OnlyERC20Test:testMintOverMaxLimitReverts() (gas: 43535)
+<<<<<<< HEAD
 DN404OnlyERC20Test:testMintz(address,uint256) (runs: 258, μ: 48044, ~: 47978)
 DN404OnlyERC20Test:testTransfer() (gas: 77086)
 DN404OnlyERC20Test:testTransfer(address,uint256) (runs: 258, μ: 77436, ~: 77543)
@@ -196,15 +299,71 @@ MintTests:test_WhenRecipientIsAddress0(uint256) (runs: 258, μ: 686507, ~: 64463
 MintTests:test_WhenRecipientsBalanceDifferenceIsNotUpTo1e18(uint256) (runs: 258, μ: 1034804, ~: 696763)
 MintTests:test_WhenRecipientsBalanceDifferenceIsUpTo1e18OrAbove(uint256) (runs: 258, μ: 790552, ~: 703210)
 MintTests:test__codesize() (gas: 26720)
+=======
+DN404OnlyERC20Test:testMintz(address,uint256) (runs: 258, μ: 47922, ~: 47978)
+DN404OnlyERC20Test:testTransfer() (gas: 77086)
+DN404OnlyERC20Test:testTransfer(address,uint256) (runs: 258, μ: 77498, ~: 77543)
+DN404OnlyERC20Test:testTransferFrom() (gas: 86826)
+DN404OnlyERC20Test:testTransferFrom(address,address,address,uint256,uint256) (runs: 258, μ: 107891, ~: 109795)
+DN404OnlyERC20Test:testTransferFromInsufficientAllowanceReverts() (gas: 70261)
+DN404OnlyERC20Test:testTransferFromInsufficientAllowanceReverts(address,uint256,uint256) (runs: 258, μ: 70448, ~: 71362)
+DN404OnlyERC20Test:testTransferFromInsufficientBalanceReverts() (gas: 76697)
+DN404OnlyERC20Test:testTransferFromInsufficientBalanceReverts(address,uint256,uint256) (runs: 258, μ: 77869, ~: 77818)
+DN404OnlyERC20Test:testTransferInsufficientBalanceReverts() (gas: 68196)
+DN404OnlyERC20Test:testTransferInsufficientBalanceReverts(address,uint256,uint256) (runs: 258, μ: 69238, ~: 69283)
+DN404OnlyERC20Test:test__codesize() (gas: 30290)
+DN404Test:testBatchNFTLog() (gas: 291443)
+DN404Test:testBurnOnTransfer(uint32,address) (runs: 258, μ: 269823, ~: 269823)
+DN404Test:testFnSelectorNotRecognized() (gas: 6996)
+DN404Test:testInitialize(uint32,address) (runs: 258, μ: 112767, ~: 116271)
+DN404Test:testMintAndBurn() (gas: 328471)
+DN404Test:testMintAndBurn2() (gas: 275156)
+DN404Test:testMintNext() (gas: 627787)
+DN404Test:testMintNextMixed(uint256) (runs: 258, μ: 636571, ~: 558426)
+DN404Test:testMintOnTransfer(uint32,address) (runs: 258, μ: 287429, ~: 287429)
+DN404Test:testMixed(uint256) (runs: 258, μ: 833902, ~: 630141)
+DN404Test:testNameAndSymbol(string,string) (runs: 258, μ: 207292, ~: 207805)
+DN404Test:testNumAliasesOverflowReverts() (gas: 57310)
+DN404Test:testOwnedIds() (gas: 350398)
+DN404Test:testOwnedIds(uint256) (runs: 258, μ: 273238, ~: 281130)
+DN404Test:testPermit2() (gas: 437997)
+DN404Test:testRegisterAndResolveAlias(address,address) (runs: 258, μ: 126452, ~: 126549)
+DN404Test:testSetAndGetAux(address,uint88) (runs: 258, μ: 21988, ~: 22360)
+DN404Test:testSetAndGetOperatorApprovals(address,address,bool) (runs: 258, μ: 130828, ~: 140316)
+DN404Test:testSetAndGetSkipNFT() (gas: 716729)
+DN404Test:testTokenURI(string,uint256) (runs: 258, μ: 158011, ~: 135746)
+DN404Test:testTransferWithMirrorEvent() (gas: 396680)
+DN404Test:testTransfersAndBurns() (gas: 461487)
+DN404Test:testWrapAround(uint32,uint256) (runs: 258, μ: 348228, ~: 343378)
+DN404Test:test__codesize() (gas: 57075)
+MappingsTest:testAddressPairMapSetAndGet(address[2],address[2],uint256,uint256) (runs: 258, μ: 45433, ~: 47053)
+MappingsTest:testBitmapSetAndGet(uint256) (runs: 258, μ: 463246, ~: 422073)
+MappingsTest:testBitmapSetAndGet(uint256,uint256,bool,bool) (runs: 258, μ: 25664, ~: 26361)
+MappingsTest:testFindFirstUnset() (gas: 79815)
+MappingsTest:testFindFirstUnset(uint256) (runs: 258, μ: 303430, ~: 221863)
+MappingsTest:testRestrictNFTId(uint256) (runs: 258, μ: 340, ~: 340)
+MappingsTest:testSetOwnerAliasAndOwnedIndex(uint256,uint32,uint32) (runs: 258, μ: 23331, ~: 23516)
+MappingsTest:testStorageSlotsNoCollision(uint256,uint256,uint256,uint256) (runs: 258, μ: 26806, ~: 26675)
+MappingsTest:testUint32MapSetAndGet(uint256) (runs: 258, μ: 1375364, ~: 1571823)
+MappingsTest:testUint32MapSetAndGet(uint256,uint256,uint32,uint32) (runs: 258, μ: 42568, ~: 46244)
+MappingsTest:testWrapNFTIdWithOverflowCheck(uint256,uint256,uint256) (runs: 258, μ: 827, ~: 852)
+MappingsTest:test__codesize() (gas: 7995)
+MintTests:test_WhenAmountIsGreaterThan_MAX_SUPPLYOrMintMakesNFTTotalSupplyExceed_MAX_SUPPLY(uint256) (runs: 258, μ: 64536, ~: 64684)
+MintTests:test_WhenRecipientAddressHasSkipNFTEnabled(uint256) (runs: 258, μ: 85845, ~: 85832)
+MintTests:test_WhenRecipientIsAddress0(uint256) (runs: 258, μ: 31084, ~: 31147)
+MintTests:test_WhenRecipientsBalanceDifferenceIsNotUpTo1e18(uint256) (runs: 258, μ: 82844, ~: 82909)
+MintTests:test_WhenRecipientsBalanceDifferenceIsUpTo1e18OrAbove(uint256) (runs: 258, μ: 89352, ~: 89426)
+MintTests:test__codesize() (gas: 26725)
+>>>>>>> main
 NFTMintDN404Test:testAllowlistMint() (gas: 257449)
 NFTMintDN404Test:testMint() (gas: 231750)
 NFTMintDN404Test:testTotalSupplyReached() (gas: 629566900)
-NFTMintDN404Test:test__codesize() (gas: 26501)
+NFTMintDN404Test:test__codesize() (gas: 26522)
 SimpleDN404Test:testMint() (gas: 47571)
 SimpleDN404Test:testName() (gas: 9674)
 SimpleDN404Test:testSetBaseURI() (gas: 47011)
 SimpleDN404Test:testSymbol() (gas: 9672)
 SimpleDN404Test:testWithdraw() (gas: 18277)
-SimpleDN404Test:test__codesize() (gas: 20220)
+SimpleDN404Test:test__codesize() (gas: 20241)
 SoladyTest:test__codesize() (gas: 1102)
 TestPlus:test__codesize() (gas: 406)

.github/workflows/ci.yml

@@ -1,7 +1,13 @@
 name: ci
 
 on:
+  pull_request:
+    branches: [main]
+    paths:
+      - '**.sol'
+      - '**.yml'
   push:
+    branches: [main]
     paths:
       - '**.sol'
       - '**.yml'

src/DN404.sol

@@ -779,6 +779,29 @@ abstract contract DN404 {
         }
     }
 
+    /// @dev Transfers token `id` from `from` to `to`.
+    /// Also emits an ERC721 {Transfer} event on the `mirrorERC721`.
+    ///
+    /// Requirements:
+    ///
+    /// - Call must originate from the mirror contract.
+    /// - Token `id` must exist.
+    /// - `from` must be the owner of the token.
+    /// - `to` cannot be the zero address.
+    ///   `msgSender` must be the owner of the token, or be approved to manage the token.
+    ///
+    /// Emits a {Transfer} event.
+    function _initiateTransferFromNFT(address from, address to, uint256 id, address msgSender)
+        internal
+        virtual
+    {
+        _transferFromNFT(from, to, id, msgSender);
+        // Emit ERC721 {Transfer} event.
+        _DNDirectLogs memory directLogs = _directLogsMalloc(1, from, to);
+        _directLogsAppend(directLogs, id);
+        _directLogsSend(directLogs, _getDN404Storage().mirrorERC721);
+    }
+
     /// @dev Transfers token `id` from `from` to `to`.
     ///
     /// Requirements:
@@ -1280,11 +1303,15 @@ abstract contract DN404 {
             }
             if negBits {
                 // Find-first-set routine.
+                // From: https://github.com/vectorized/solady/blob/main/src/utils/LibBit.sol
                 let b := and(negBits, add(not(negBits), 1)) // Isolate the least significant bit.
-                let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, b))
-                r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
-                r := or(r, shl(5, lt(0xffffffff, shr(r, b))))
-                // For the remaining 32 bits, use a De Bruijn lookup.
+                // For the upper 3 bits of the result, use a De Bruijn-like lookup.
+                // Credit to adhusson: https://blog.adhusson.com/cheap-find-first-set-evm/
+                // forgefmt: disable-next-item
+                let r := shl(5, shr(252, shl(shl(2, shr(250, mul(b,
+                    0x2aaaaaaaba69a69a6db6db6db2cb2cb2ce739ce73def7bdeffffffff))),
+                    0x1412563212c14164235266736f7425221143267a45243675267677)))
+                // For the lower 5 bits of the result, use a De Bruijn lookup.
                 // forgefmt: disable-next-item
                 r := or(r, byte(and(div(0xd76453e0, shr(r, b)), 0x1f),
                     0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))

test/DN404.t.sol

@@ -7,6 +7,14 @@ import {DN404Mirror} from "../src/DN404Mirror.sol";
 import {LibClone} from "solady/utils/LibClone.sol";
 import {LibSort} from "solady/utils/LibSort.sol";
 
+library DN404MirrorTransferEmitter {
+    event Transfer(address indexed from, address indexed to, uint256 indexed id);
+
+    function emitTransfer(address from, address to, uint256 id) internal {
+        emit Transfer(from, to, id);
+    }
+}
+
 contract DN404Test is SoladyTest {
     uint256 private constant _WAD = 1000000000000000000;
 
@@ -276,6 +284,24 @@ contract DN404Test is SoladyTest {
         uint256 numOwned;
     }
 
+    function testTransferWithMirrorEvent() public {
+        address initialSupplyOwner = address(1111);
+        address alice = address(111);
+        address bob = address(222);
+
+        dn.initializeDN404(10 * _WAD, initialSupplyOwner, address(mirror));
+
+        vm.prank(initialSupplyOwner);
+        dn.transfer(alice, 10 * _WAD);
+
+        vm.expectEmit(true, true, true, true, address(mirror));
+        DN404MirrorTransferEmitter.emitTransfer(alice, bob, 3);
+        vm.prank(alice);
+        dn.initiateTransferFromNFT(alice, bob, 3);
+
+        assertEq(mirror.ownerAt(3), bob);
+    }
+
     function testMixed(uint256) public {
         dn.setUseExistsLookup(_random() % 2 == 0);
 

test/Mappings.t.sol

@@ -152,11 +152,15 @@ contract MappingsTest is SoladyTest {
             }
             if negBits {
                 // Find-first-set routine.
+                // From: https://github.com/vectorized/solady/blob/main/src/utils/LibBit.sol
                 let b := and(negBits, add(not(negBits), 1)) // Isolate the least significant bit.
-                let r := shl(7, lt(0xffffffffffffffffffffffffffffffff, b))
-                r := or(r, shl(6, lt(0xffffffffffffffff, shr(r, b))))
-                r := or(r, shl(5, lt(0xffffffff, shr(r, b))))
-                // For the remaining 32 bits, use a De Bruijn lookup.
+                // For the upper 3 bits of the result, use a De Bruijn-like lookup.
+                // Credit to adhusson: https://blog.adhusson.com/cheap-find-first-set-evm/
+                // forgefmt: disable-next-item
+                let r := shl(5, shr(252, shl(shl(2, shr(250, mul(b,
+                    0x2aaaaaaaba69a69a6db6db6db2cb2cb2ce739ce73def7bdeffffffff))),
+                    0x1412563212c14164235266736f7425221143267a45243675267677)))
+                // For the lower 5 bits of the result, use a De Bruijn lookup.
                 // forgefmt: disable-next-item
                 r := or(r, byte(and(div(0xd76453e0, shr(r, b)), 0x1f),
                     0x001f0d1e100c1d070f090b19131c1706010e11080a1a141802121b1503160405))

test/utils/mocks/MockDN404.sol

@@ -165,6 +165,10 @@ contract MockDN404 is DN404, MockBrutalizer {
         DN404._transferFromNFT(_brutalized(from), _brutalized(to), id, _brutalized(msgSender));
     }
 
+    function initiateTransferFromNFT(address from, address to, uint256 id) external {
+        _initiateTransferFromNFT(from, to, id, msg.sender);
+    }
+
     function _afterNFTTransfer(address from, address to, uint256 id) internal virtual override {
         /// @solidity memory-safe-assembly
         assembly {