Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.13;

import { Harberger, Perwei } from "./Harberger.sol";
import { ReentrancyGuard } from "./ReentrancyGuard.sol";

address constant admin = 0xee324c588ceF1BF1c1360883E4318834af66366d;
address constant treasury = 0x1337E2624ffEC537087c6774e9A18031CFEAf0a9;

// NOTE: The tax rate is 1/2629742 per second. The denominator (2629743) is
// seconds in a month. 
// 1 month (avg. 30.44 days) = 2_629_743
// We subtract a second to have an even number.
// Practically, it means that a self-assessed key worth 1
// ether will accumulate a tax obligation of 1 ether/month.
uint256 constant numerator    = 1;
uint256 constant denominator  = 2629742;
// TODO: Add a function that allows to shut down this contract gracefully in
// case of an update, by e.g. allowing an admit to call a function that sends
// the leftover collateral to the lastController.
contract Ad is ReentrancyGuard {
  error ErrValue();
  error ErrUnauthorized();
  error ErrCall();

  string public title;
  string public href;

  address public controller;
  uint256 public collateral;
  uint256 public timestamp;

  // NOTE: We leave this ragequit function in for now as it allows an
  // administrator to shut down the contract when a new version is deployed, or
  // to slash a malicous ad publisher.
  function ragequit() external {
    if (msg.sender != admin) {
      revert ErrUnauthorized();
    }

    admin.call{value: address(this).balance}("");
  }

  function price() public view returns (uint256 nextPrice, uint256 taxes) {
    return Harberger.getNextPrice(
      Perwei(numerator, denominator),
      block.timestamp - timestamp,
      collateral
    );
  }

  function set(
    string calldata _title,
    string calldata _href
  ) nonReentrant external payable {
    if (controller == address(0)) {
      title = _title;
      href = _href;
      controller = msg.sender;
      collateral = msg.value;
      timestamp = block.timestamp;
    } else {
      (uint256 nextPrice, uint256 taxes) = price();
      if (msg.value < nextPrice + 1) {
        revert ErrValue();
      }

      address lastController = controller;
      title = _title;
      href = _href;
      controller = msg.sender;
      collateral = msg.value - nextPrice;
      timestamp = block.timestamp;

      (bool treasurySuccess,) = treasury.call{value: taxes}("");
      if (!treasurySuccess) {
        revert ErrCall();
      }
      // NOTE: We send the last controller double the amount of the current
      // price because one times the price is just their remaining collateral,
      // and another times the price is the buyer's transfer fee paid to take
      // possession over the ad during acquisition. The buyer's remaining
      // collateral (and hence the new price of the ad) is the message's value
      // minus the transfer fee.
      //
      // As this was a vulnerability in prior iterations of this contract, we
      // should also talk about what happens in the case that the buyer sends
      // so little in msg.value that it's roughly equal to the current price of
      // the ad.
      // In this case, the transfer fee (which is equal to the ad's current
      // price) is sent to the last controller, and the remainder = msg.value -
      // nextPrice is put up as the new collateral and hence is the new price.
      // And since this price is very low, the buyer takes on the risk of
      // having their ad being sold at a discount.
      lastController.call{value: nextPrice * 2}("");
      // NOTE2: We're not checking the success of this call because it could
      // lead to the last controller intentionally failing the call, hence
      // making the ad contract stuck.
    }
  }
}

/// SPDX-License-Identifier: AGPL-3.0
pragma solidity ^0.8.6;

import {FixedPointMathLib} from "./FixedPointMathLib.sol";

/* Introduction of "Perwei" struct:

  To ensure accounting precision, financial and scientific applications make
  use of a so called "parts-per" notation and so it turns out that: "One part
  per hundred is generally represented by the percent sign (%)" [1].

  But with Solidity and Ethereum having a precision of up to 18 decimal points
  but no native fixed point math arithmetic functions, we have to be careful
  when e.g. calculating fractions of a value.

  E.g. in cases where we want to calculate the tax of a property that's worth
  only 1000 Wei (= 0.000000000000001 Ether) using naive percentages leads to
  inaccuracies when dealing with Solidity's division operator. Hence, libraries
  like solmate and others have come up with "parts-per"-ready implementations
  where values are scaled up. The `Perwei` struct here represents a structure
  of numerator and denominator that allows precise calculations of up to 18
  decimals in the results, e.g. Perwei(1, 1e18).

  References:
  - 1:
https://en.wikipedia.org/w/index.php?title=Parts-per_notation&oldid=1068959843

*/
struct Perwei {
    uint256 numerator;
    uint256 denominator;
}

library Harberger {
    function getNextPrice(
        Perwei memory perwei,
        uint256 secondsDelta,
        uint256 collateral
    ) internal pure returns (uint256, uint256) {
        uint256 taxes = taxPerSecond(perwei, secondsDelta, collateral);

        if (collateral < taxes) {
            return (0, collateral);
        } else {
            return (collateral - taxes, taxes);
        }
    }

    function taxPerSecond(
        Perwei memory perwei,
        uint256 secondsDelta,
        uint256 collateral
    ) internal pure returns (uint256) {
        return
            FixedPointMathLib.fdiv(
                collateral * secondsDelta * perwei.numerator,
                perwei.denominator * FixedPointMathLib.WAD,
                FixedPointMathLib.WAD
            );
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// SPDX-License-Identifier: AGPL-3.0-only
pragma solidity >=0.8.0;

/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solmate (https://github.com/Rari-Capital/solmate/blob/main/src/utils/FixedPointMathLib.sol)
library FixedPointMathLib {
    /*///////////////////////////////////////////////////////////////
                            COMMON BASE UNITS
    //////////////////////////////////////////////////////////////*/

    uint256 internal constant YAD = 1e8;
    uint256 internal constant WAD = 1e18;
    uint256 internal constant RAY = 1e27;
    uint256 internal constant RAD = 1e45;

    /*///////////////////////////////////////////////////////////////
                         FIXED POINT OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function fmul(
        uint256 x,
        uint256 y,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * y in z for now.
            z := mul(x, y)

            // Equivalent to require(x == 0 || (x * y) / x == y)
            if iszero(or(iszero(x), eq(div(z, x), y))) {
                revert(0, 0)
            }

            // If baseUnit is zero this will return zero instead of reverting.
            z := div(z, baseUnit)
        }
    }

    function fdiv(
        uint256 x,
        uint256 y,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            // Store x * baseUnit in z for now.
            z := mul(x, baseUnit)

            // Equivalent to require(y != 0 && (x == 0 || (x * baseUnit) / x == baseUnit))
            if iszero(and(iszero(iszero(y)), or(iszero(x), eq(div(z, x), baseUnit)))) {
                revert(0, 0)
            }

            // We ensure y is not zero above, so there is never division by zero here.
            z := div(z, y)
        }
    }

    function fpow(
        uint256 x,
        uint256 n,
        uint256 baseUnit
    ) internal pure returns (uint256 z) {
        assembly {
            switch x
            case 0 {
                switch n
                case 0 {
                    // 0 ** 0 = 1
                    z := baseUnit
                }
                default {
                    // 0 ** n = 0
                    z := 0
                }
            }
            default {
                switch mod(n, 2)
                case 0 {
                    // If n is even, store baseUnit in z for now.
                    z := baseUnit
                }
                default {
                    // If n is odd, store x in z for now.
                    z := x
                }

                // Shifting right by 1 is like dividing by 2.
                let half := shr(1, baseUnit)

                for {
                    // Shift n right by 1 before looping to halve it.
                    n := shr(1, n)
                } n {
                    // Shift n right by 1 each iteration to halve it.
                    n := shr(1, n)
                } {
                    // Revert immediately if x ** 2 would overflow.
                    // Equivalent to iszero(eq(div(xx, x), x)) here.
                    if shr(128, x) {
                        revert(0, 0)
                    }

                    // Store x squared.
                    let xx := mul(x, x)

                    // Round to the nearest number.
                    let xxRound := add(xx, half)

                    // Revert if xx + half overflowed.
                    if lt(xxRound, xx) {
                        revert(0, 0)
                    }

                    // Set x to scaled xxRound.
                    x := div(xxRound, baseUnit)

                    // If n is even:
                    if mod(n, 2) {
                        // Compute z * x.
                        let zx := mul(z, x)

                        // If z * x overflowed:
                        if iszero(eq(div(zx, x), z)) {
                            // Revert if x is non-zero.
                            if iszero(iszero(x)) {
                                revert(0, 0)
                            }
                        }

                        // Round to the nearest number.
                        let zxRound := add(zx, half)

                        // Revert if zx + half overflowed.
                        if lt(zxRound, zx) {
                            revert(0, 0)
                        }

                        // Return properly scaled zxRound.
                        z := div(zxRound, baseUnit)
                    }
                }
            }
        }
    }

    /*///////////////////////////////////////////////////////////////
                        GENERAL NUMBER UTILITIES
    //////////////////////////////////////////////////////////////*/

    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
            }
        }
    }
}

{
  "remappings": [
    "forge-std/=lib/forge-std/src/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs"
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "devdoc",
        "userdoc",
        "metadata",
        "abi"
      ]
    }
  },
  "evmVersion": "london",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"ErrCall","type":"error"},{"inputs":[],"name":"ErrUnauthorized","type":"error"},{"inputs":[],"name":"ErrValue","type":"error"},{"inputs":[],"name":"collateral","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"href","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"nextPrice","type":"uint256"},{"internalType":"uint256","name":"taxes","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ragequit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_title","type":"string"},{"internalType":"string","name":"_href","type":"string"}],"name":"set","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"timestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"title","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"}]

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