LONDON by POB - Mint at 15.59 GWEI

$LONDON Token-nomics

A social currency backed by the lasting impact of minting, gas price manipulation, and EIP 1559

Abstract

$LONDON is an ERC20 where the amount of tokens minted is directly tied to gas price via a bonding curve (See Figure 1). The bonding curve doesn't reward gas bidding wars; users had to coordinate in new ways to optimize their $LONDON returns.

$LONDON is the native governance token of the 💷LondonDAO.

Users were able to mint up to the London hardfork since EIP 1559 radically changed the fee market mechanics.

$LONDON is a fair launch project, there is no starting supply.

$LONDON was minted via the bonding curve below. Max output @ 15.59 gwei.

X: 15.59 gwei

Y: 1559 $LONDON

$LONDON Stats

$LONDON Stats

Value

Current gas price in gwei

Lowest gas price used in gwei

# of mints at 15.59 gwei

Total supply

Utility

$LONDON is primarily a governance token for the 💷LondonDAO.

One of the 💷LondonDAO main directives is to develop a community of $LONDON holders and create exclusive NFT drops, and experiment with new token mechanics.

Such experiments and NFT drops will be exclusive to $LONDON holders.

The first of such NFT drops was the LONDON Gift, a generative art memento to memoralize the London hardfork, only redeemable with $LONDON.

Background

$LONDON is a highly experimental project designed to show the fragility/robustness of the ETH fee markets. It is a celebration and critique of our relationship with miners and core developers. After the London hardfork, 💷LondonDAO will continue the spirit of the project in the form of funding new NFT token mechanics and experiment with new crypto-experiences.

Gas price is how we get our say in this crypto-future.

Can we use gas price and its mechanics to say something we never have before? How can we manipulate gas markets in ways never before?

With the stars aligning, the London hardfork + EIP 1559 provides a perfect 'meme' for this project. EIP 1559 fundamentally changes gas price mechanics, so what better thing to create a project about gas prices around? We also wanted the project to 'expire' to not needlessly clog the mempool with transactions, the hardfork became the perfect 'epxiry' date.

This is why the bonding curve (a bell curve) is centered at precisely 15.59 gwei in homage to EIP 1559 and your maximum returns is 1559 $LONDON. As people mint closer and closer to 15.59 gwei and even get it exactly, people in the future will know of the measurable impact of $LONDON without knowing about the project.

$LONDON is a social token. It is backed by our ability to manipulate the gas market. It is backed by the number of 15.59 GWEI transactions happening during this span of time. It is backed by the rallying cries and commentary on crypto-twitter. It is backed by you. By using gas price as not just a means to an end, but also a form of communication, $LONDON minters will demonstrate where our relationship truly lies with gas fee mechanics.

Appendix: Contract Code

Minter Contract


// PARAMETERS 
// blockNumberUpTo: 12965000
// a: 6000000000
// b: 1
// c: 15590000000
// d: 1559

contract BellCurveParametersStorage {
    
    uint256 immutable public a;
    uint256 immutable public b;
    uint256 immutable public c;
    uint256 immutable public d;

    uint256 constant SIG_DIGITS = 3;

    constructor(uint256 _a, uint256 _b, uint256 _c, uint256 _d) {
      a = _a;
      b = _b;
      c = _c;
      d = _d;
    }

    function bellCurve(uint256 x) internal view returns (uint256 y) {
      uint256 decimals = 10 ** SIG_DIGITS;
      // since it is all uints, we will use a ternary to keep it positive 
      uint256 xDiffC = x > c ? (x - c) : (c - x);
      // this complex set of math gets us a bell curve with the ouput in SIG_DIGITS worth of decimals
      return (10 ** (18 - SIG_DIGITS)) * ((d * decimals * decimals) / (decimals + (((xDiffC * decimals) / a))**(2 * b) / decimals));
    }
}

contract GasPriceBasedMinter is BellCurveParametersStorage, Context, Ownable {
    ERC20Mintable public erc20;

    uint256 immutable public blockNumberUpTo;
    bytes32 constant ZERO_HASH = keccak256(0x00);

    constructor(uint256 _blockNumberUpTo, uint256 _a, uint256 _b, uint256 _c, uint256 _d) BellCurveParametersStorage(_a, _b, _c, _d) {
      blockNumberUpTo = _blockNumberUpTo;
    }

    function setErc20(address _erc20) public onlyOwner {
      erc20 = ERC20Mintable(_erc20);
    }

    function mintableTokenAtGasPrice(uint256 gasPrice)
      public
      view
      returns (uint256 amount)
    {
      amount = bellCurve(gasPrice);
    }

    fallback() external payable {
      require(block.number < blockNumberUpTo, "CAN'T $MINT ANYMORE");
      require(keccak256(msg.data) == ZERO_HASH, "CAN'T $MINT FROM MACHINE");
      require(msg.value == 0, "DON'T DONATE");
      uint256 amount = mintableTokenAtGasPrice(tx.gasprice);
      // mint amount to _msgSender
      erc20.mint(_msgSender(), amount);
    }
}

ERC20 Contract


// Standard ERC20 Contract for $LONDON
interface IERC20 {
    function totalSupply() external view returns (uint256);

    function balanceOf(address account) external view returns (uint256);

    function transfer(address recipient, uint256 amount) external returns (bool);

    function allowance(address owner, address spender) external view returns (uint256);

    function approve(address spender, uint256 amount) external returns (bool);

    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);

    event Approval(address indexed owner, address indexed spender, uint256 value);
}

Omne quod movetur ab alio movetur