ElasticSwap contest - p4st13r4's results

Handle

p4st13r4

Vulnerability details

Impact

sqrt and diff methods can be optimized in the following way:

• sqrt: use solmate implementation
• diff: use an unchecked block to compute absolute value of the difference. This can be done because checks for the numbers ordering are made in the function body.

Proof of Concept

Gas usage snapshot is done using output from yarn test.

Actual implementation:

|  Contract                ·  Method                      ·  Min        ·  Max        ·  Avg           ·  # calls      ·  usd (avg)  │
···························|······························|·············|·············|················|···············|··············
|  Exchange                ·  addLiquidity                ·      93816  ·     240603  ·        197649  ·           68  ·          -  │
···························|······························|·············|·············|················|···············|··············
|  Exchange                ·  removeLiquidity             ·      51385  ·     174717  ·         95831  ·           37  ·          -  │

When recommended changes are implemented:

|  Contract                ·  Method                      ·  Min        ·  Max        ·  Avg           ·  # calls      ·  usd (avg)  │
···························|······························|·············|·············|················|···············|··············
|  Exchange                ·  addLiquidity                ·      83765  ·     232479  ·        192144  ·           68  ·          -  │
···························|······························|·············|·············|················|···············|··············
|  Exchange                ·  removeLiquidity             ·      50087  ·     161885  ·         88396  ·           37  ·          -  │
···························|······························|·············|·············|················|···············|··············

Tools Used

Repo tests

Recommended Mitigation Steps

Change sqrt and diff implementation:

    function diff(uint256 a, uint256 b) public pure returns (uint256) {
        unchecked {
            if (a >= b) {
                return a - b;
            }
            return b - a;
        }
    }

    // https://github.com/Rari-Capital/solmate/blob/main/src/utils/FixedPointMathLib.sol#L150 
    function sqrt(uint256 x) internal pure returns (uint256 z) {
        assembly {
            // Start off with z at 1.
            z := 1

            // Used below to help find a nearby power of 2.
            let y := x

            // Find the lowest power of 2 that is at least sqrt(x).
            if iszero(lt(y, 0x100000000000000000000000000000000)) {
                y := shr(128, y) // Like dividing by 2 ** 128.
                z := shl(64, z)
            }
            if iszero(lt(y, 0x10000000000000000)) {
                y := shr(64, y) // Like dividing by 2 ** 64.
                z := shl(32, z)
            }
            if iszero(lt(y, 0x100000000)) {
                y := shr(32, y) // Like dividing by 2 ** 32.
                z := shl(16, z)
            }
            if iszero(lt(y, 0x10000)) {
                y := shr(16, y) // Like dividing by 2 ** 16.
                z := shl(8, z)
            }
            if iszero(lt(y, 0x100)) {
                y := shr(8, y) // Like dividing by 2 ** 8.
                z := shl(4, z)
            }
            if iszero(lt(y, 0x10)) {
                y := shr(4, y) // Like dividing by 2 ** 4.
                z := shl(2, z)
            }
            if iszero(lt(y, 0x8)) {
                // Equivalent to 2 ** z.
                z := shl(1, z)
            }

            // Shifting right by 1 is like dividing by 2.
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))
            z := shr(1, add(z, div(x, z)))

            // Compute a rounded down version of z.
            let zRoundDown := div(x, z)

            // If zRoundDown is smaller, use it.
            if lt(zRoundDown, z) {
                z := zRoundDown
            }
        }
    }