0x6b175474e89094c44da98b954eedeac495271d0f

deployer: unknown relevance score: 10 status: identified bytecode: 7904 bytes

DECOMPILED SOLIDITY (Heimdall) 

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @title            Decompiled Contract
/// @author           Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version   heimdall-rs v0.9.2
///
/// @notice           This contract was decompiled using the heimdall-rs decompiler.
///                     It was generated directly by tracing the EVM opcodes from this contract.
///                     As a result, it may not compile or even be valid solidity code.
///                     Despite this, it should be obvious what each function does. Overall
///                     logic should have been preserved throughout decompiling.
///
/// @custom:github    You can find the open-source decompiler here:
///                       https://heimdall.rs

contract DecompiledContract {
    uint256 public constant decimals = 18;
    bytes public constant version = 0xBytes([49]);
    uint256 public constant PERMIT_TYPEHASH = 105916522785188513640362517802612480037966763957092682311465172263008277174987;
    string public constant name = "Dai Stablecoin";
    string public constant symbol = "DAI";
    
    mapping(bytes32 => bytes32) storage_map_a;
    uint256 public totalSupply;
    mapping(bytes32 => bytes32) storage_map_e;
    uint256 public fopwCDKKK;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event Approval(address, address, uint256);
    event Transfer(address, address, uint256);
    event Event_9c52a7f1();
    event Event_65fae35e();
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   approve(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approve(address arg0, uint256 arg1) public payable returns (bool) {
        var_a = address(arg0);
        storage_map_a[var_a] = arg1;
        emit Approval(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0xb753a98c
    /// @custom:signature   push(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function push(address arg0, uint256 arg1) public payable {
        address var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-balance");
        require(address(msg.sender) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(!(storage_map_a[var_a] + arg1) < storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-allowance");
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        if (address(msg.sender) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0xbf353dbb
    /// @custom:signature   wards(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function wards(address arg0) public view returns (uint256) {
        address var_b = address(arg0);
        return storage_map_c[var_b];
    }
    
    /// @custom:selector    0x8fcbaf0c
    /// @custom:signature   Unresolved_8fcbaf0c(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bool arg5, uint256 arg6, uint256 arg7) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    /// @param              arg7 ["uint256", "bytes32", "int256"]
    function Unresolved_8fcbaf0c(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bool arg5, uint256 arg6, uint256 arg7) public payable {
        uint256 var_h = 0x20 + (0x20 + (0x20 + (0x20 + (0x20 + (0x20 + (0x20 + var_h))))));
        require(!(address(arg0)) == 0);
        var_h = 0x20 + var_h;
        address var_s = ecrecover(keccak256(var_l), bytes1(arg5), arg6, arg7);
        require(var_t);
        require(address(arg0) == (address(var_s)), "Dai/invalid-permit");
        require(arg3 == 0, "Dai/invalid-nonce");
        require(!(block.timestamp > arg3), "Dai/invalid-nonce");
        address var_x = address(arg0);
        storage_map_e[var_x] = 0x01 + storage_map_e[var_x];
        require(arg2 == storage_map_e[var_x], "Dai/invalid-nonce");
        require(arg4, "Dai/permit-expired");
        var_x = address(arg1);
        storage_map_e[var_x] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        emit Approval(address(arg0), address(arg1), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_x = address(arg1);
        storage_map_e[var_x] = 0;
        emit Approval(address(arg0), address(arg1), 0);
        require(arg3 == 0, "Dai/permit-expired");
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public payable returns (bool) {
        address var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-balance");
        require(address(msg.sender) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(!(storage_map_a[var_a] + arg1) < storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        return 0x01;
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-allowance");
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        if (address(msg.sender) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0x65fae35e
    /// @custom:signature   Unresolved_65fae35e(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_65fae35e(address arg0, uint256 arg1) public payable {
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0x01, "Dai/not-authorized");
        var_a = address(arg0);
        storage_map_a[var_a] = 0x01;
        uint256 var_c = memory.length + 0x0120;
        emit Event_65fae35e(msg.sender, arg0, arg1, 0x20, 0xe0);
    }
    
    /// @custom:selector    0xbb35783b
    /// @custom:signature   move(address arg0, address arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function move(address arg0, address arg1, uint256 arg2) public payable {
        address var_a = address(arg0);
        require(!(storage_map_a[var_a] < arg2), "Dai/insufficient-balance");
        require(address(arg0) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = address(arg0);
        require(!(storage_map_a[var_a] - arg2) > storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        require(!(storage_map_a[var_a] + arg2) < storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = storage_map_a[var_a] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg2), "Dai/insufficient-allowance");
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg2) > storage_map_a[var_a]);
        if (address(arg0) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0x7ecebe00
    /// @custom:signature   nonces(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function nonces(address arg0) public view returns (uint256) {
        address var_b = address(arg0);
        return storage_map_c[var_b];
    }
    
    /// @custom:selector    0x40c10f19
    /// @custom:signature   mint(address arg0, uint256 arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint(address arg0, uint256 arg1) public view {
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0x01);
        var_a = address(arg0);
        require(!(storage_map_a[var_a] + arg1) < storage_map_a[var_a]);
    }
    
    /// @custom:selector    0x9dc29fac
    /// @custom:signature   burn(address arg0, uint256 arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function burn(address arg0, uint256 arg1) public view {
        address var_a = address(arg0);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-balance");
        require(address(arg0) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = address(arg0);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-allowance");
        if (address(arg0) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   balanceOf(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function balanceOf(address arg0) public view returns (uint256) {
        address var_b = address(arg0);
        return storage_map_c[var_b];
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   transferFrom(address arg0, address arg1, uint256 arg2) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function transferFrom(address arg0, address arg1, uint256 arg2) public payable returns (bool) {
        address var_a = address(arg0);
        require(!(storage_map_a[var_a] < arg2), "Dai/insufficient-balance");
        require(address(arg0) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = address(arg0);
        require(!(storage_map_a[var_a] - arg2) > storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        require(!(storage_map_a[var_a] + arg2) < storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = storage_map_a[var_a] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        return 0x01;
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg2), "Dai/insufficient-allowance");
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg2) > storage_map_a[var_a]);
        if (address(arg0) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   allowance(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function allowance(address arg0, address arg1) public view returns (uint256) {
        address var_b = address(arg0);
        var_b = address(arg1);
        return storage_map_c[var_b];
    }
    
    /// @custom:selector    0x9c52a7f1
    /// @custom:signature   Unresolved_9c52a7f1(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_9c52a7f1(address arg0, uint256 arg1) public payable {
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0x01, "Dai/not-authorized");
        var_a = address(arg0);
        storage_map_a[var_a] = 0;
        uint256 var_c = memory.length + 0x0120;
        emit Event_9c52a7f1(msg.sender, arg0, arg1, 0x20, 0xe0);
    }
    
    /// @custom:selector    0xf2d5d56b
    /// @custom:signature   pull(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function pull(address arg0, uint256 arg1) public payable {
        address var_a = address(arg0);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-balance");
        require(address(arg0) == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = address(arg0);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] + arg1) < storage_map_a[var_a]);
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(arg0), address(msg.sender), arg1);
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] < arg1), "Dai/insufficient-allowance");
        var_a = address(msg.sender);
        require(!(storage_map_a[var_a] - arg1) > storage_map_a[var_a]);
        if (address(arg0) == (address(msg.sender))) {
        }
    }
}

ABI

[
  {
    "type": "function",
    "name": "PERMIT_TYPEHASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_65fae35e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_8fcbaf0c",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "bool"
      },
      {
        "name": "arg6",
        "type": "uint256"
      },
      {
        "name": "arg7",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_9c52a7f1",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "allowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "burn",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "fopwCDKKK",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "move",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "name",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "nonces",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pull",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "push",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "symbol",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "transferFrom",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "version",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "wards",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "event",
    "name": "Approval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_65fae35e00000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_9c52a7f100000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (0)

(none -- all recognized)
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)