Optimize Clones assembly

[Vectorized]

Changes:

• Deployments use the scratch space.
• Optimize predictDeterministicAddress to use lesser operations, while maintaining the same memory expansion costs.

Gas Before:

·------------------------------------------------------------|---------------------------|-------------|-----------------------------·
|                    Solc version: 0.8.13                    ·  Optimizer enabled: true  ·  Runs: 200  ·  Block limit: 10000000 gas  │
·····························································|···························|·············|······························
|  Methods                                                                                                                           │
···············|·············································|·············|·············|·············|···············|··············
|  Contract    ·  Method                                     ·  Min        ·  Max        ·  Avg        ·  # calls      ·  usd (avg)  │
···············|·············································|·············|·············|·············|···············|··············
|  ClonesMock  ·  clone(address,bytes)                       ·      90724  ·      97783  ·      93136  ·           12  ·          -  │
···············|·············································|·············|·············|·············|···············|··············
|  ClonesMock  ·  cloneDeterministic(address,bytes32,bytes)  ·      65269  ·      98378  ·      89662  ·           14  ·          -  │
···············|·············································|·············|·············|·············|···············|··············
|  Deployments                                               ·                                         ·  % of limit   ·             │
·····························································|·············|·············|·············|···············|··············
|  ClonesMock                                                ·          -  ·          -  ·     435385  ·        4.4 %  ·          -  │
·····························································|·············|·············|·············|···············|··············
|  DummyImplementation                                       ·          -  ·          -  ·     398946  ·          4 %  ·          -  │
·------------------------------------------------------------|-------------|-------------|-------------|---------------|-------------·

Gas After:

·------------------------------------------------------------|---------------------------|-------------|-----------------------------·
|                    Solc version: 0.8.13                    ·  Optimizer enabled: true  ·  Runs: 200  ·  Block limit: 10000000 gas  │
·····························································|···························|·············|······························
|  Methods                                                                                                                           │
···············|·············································|·············|·············|·············|···············|··············
|  Contract    ·  Method                                     ·  Min        ·  Max        ·  Avg        ·  # calls      ·  usd (avg)  │
···············|·············································|·············|·············|·············|···············|··············
|  ClonesMock  ·  clone(address,bytes)                       ·      90707  ·      97766  ·      93119  ·           12  ·          -  │
···············|·············································|·············|·············|·············|···············|··············
|  ClonesMock  ·  cloneDeterministic(address,bytes32,bytes)  ·      65237  ·      98361  ·      89645  ·           14  ·          -  │
···············|·············································|·············|·············|·············|···············|··············
|  Deployments                                               ·                                         ·  % of limit   ·             │
·····························································|·············|·············|·············|···············|··············
|  ClonesMock                                                ·          -  ·          -  ·     432690  ·        4.3 %  ·          -  │
·····························································|·············|·············|·············|···············|··············
|  DummyImplementation                                       ·          -  ·          -  ·     398946  ·          4 %  ·          -  │
·------------------------------------------------------------|-------------|-------------|-------------|---------------|-------------·

PR Checklist

• Tests
• Documentation
• Changelog entry

[frangio]

Can you quantify the improvement to the clone functions from using the scratch space?

The suggested method for predictDeterministicAddress is being discussed in #3600 (comment). I don't think this is something we want to merge. It's a use of memory outside the rules for memory safety as described in the Solidity documentation.

[Vectorized]

@frangio Ok, understand.

Changed the implementation of predictDeterministicAddress to use free memory instead.

Saves a tiny bit of gas during deployment, and makes the deployer bytecode a little smaller.

[frangio]

For the record, I looked at defining a helper like below that we could reuse in all places. Unfortunately Solidity doesn't inline the call so I don't think it's worth it.

    function _getInitCode(address implementation) internal pure returns (bytes32 w0, bytes32 w1) {
        /// @solidity memory-safe-assembly
        assembly {
            w0 := or(0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000, shr(0xe8, shl(0x60, implementation)))
            // Packs the remaining 17 bytes of `implementation` with the bytecode after the address.
            w1 := or(shl(0x78, implementation), 0x5af43d82803e903d91602b57fd5bf3)
        }
    }

[frangio]

LGTM

[Vectorized]

Resolved the CHANGELOG.md conflict.

[frangio]

For reference here's the memory layout in predictDeterministicAddress. Rows are written onto memory from top to bottom.

0                               1                               2                               3                               4                               5                               6                               7                               8                               9
0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 8 9 a b c d e f 0 1 2 3 4 5 6 7 
                                                                                                                ~~~~~~~~~~~~~~~~~~~~~~~~dddddddddddddddddddddddddddddddddddddddd
                                                                        000000000000000000000000000000005af43d82803e903d91602b57fd5bf3ff
                                        ~~~~~~~~~~~~~~~~~~~~~~~~iiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiiii
0000000000000000000000003d602d80600a3d3981f3363d3d373d3d3d363d73
                                                                                                                                                                                ssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssssss
                                                                                                                                                                                                                                                hhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh

                        [                                                                                                            ][                                                                                                                                                                        ]

[Vectorized]

Brb, i’m outside right now.

[LuKks]

@Vectorized Any hints on how to create the equivalent of predictDeterministicAddress but on JavaScript? For example, having all the data needed pre-loaded locally (deployer addr, implementation addr, contract bytecode, etc) to later being able to calculate addresses on pure JS?

I tried a lot but nothing seems to result in the correct address, maybe the optimizations and using the proxy prefix + suffix bytes makes it not straightforward to replicate it on JavaScript?

References:
https://stackoverflow.com/questions/71573083/im-trying-to-implement-openzeppelins-minimal-proxy-clone-contract-on-tron-bloc/71581522#71581522
https://github.com/thegostep/solidity-create2-deployer

Thank you in advance! :)

[Amxx]

@Vectorized Any hints on how to create the equivalent of predictDeterministicAddress but on JavaScript? For example, having all the data needed pre-loaded locally (deployer addr, implementation addr, contract bytecode, etc) to later being able to calculate addresses on pure JS?

I tried a lot but nothing seems to result in the correct address, maybe the optimizations and using the proxy prefix + suffix bytes makes it not straightforward to replicate it on JavaScript?

References: https://stackoverflow.com/questions/71573083/im-trying-to-implement-openzeppelins-minimal-proxy-clone-contract-on-tron-bloc/71581522#71581522 https://github.com/thegostep/solidity-create2-deployer

Thank you in advance! :)

Here

[LuKks]

@Amxx Thanks, I ended up doing a tiny JS library to solve the issue so I don't have to deal with it again! Haha
https://github.com/LuKks/predict-deterministic-address

So that allowed me to finish this other one:
https://github.com/LuKks/wallet-accounts (wallet with sub-accounts as a smart contract)