BitData

{{
  "language": "Solidity",
  "sources": {
    "contracts/BitData.sol": {
      "content": "// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

/*
BitData (BITDATA) — multifunctional ERC20 for decentralized data, staking, and ETF aggregation.
Features:
- Treasury & Liquidity management
- Staking and Reward system
- ETF creation and trading
- Webhook automation events
- Oracle price feed integration
*/

interface IERC20 {
    function transferFrom(address from, address to, uint256 amt) external returns (bool);
    function transfer(address to, uint256 amt) external returns (bool);
    function balanceOf(address who) external view returns (uint256);
    function approve(address spender, uint256 amount) external returns (bool);
}

interface IDEXRouter {
    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
}

contract BitData {
    string public constant name = "Bit Data";
    string public constant symbol = "BITDATA";
    uint8 public constant decimals = 18;

    uint256 public totalSupply;
    address public owner;
    address public treasury;

    mapping(address => uint256) public balanceOf;
    mapping(address => mapping(address => uint256)) public allowance;

    mapping(address => bool) public isWhitelistedApp;
    mapping(address => bool) public isRewardManager;
    mapping(address => bool) public isRestrictedProjectAccount;
    mapping(address => bool) public isMarketMaker;
    mapping(address => bool) public isExemptProjectAccount;

    mapping(address => uint256) public lockedBalance;
    mapping(address => uint256) public lockExpiry;

    bool public tradingEnabled = true;
    uint256 public liquidityReserve;
    uint256 private unlocked = 1;

    uint256 public launchBlock;
    uint256 public initialProtectionBlocks = 0;
    bool public transferDelayEnabled = false;
    mapping(address => uint256) public lastTransferBlock;
    uint256 public maxGasPriceDuringProtection = 0;

    mapping(address => bool) public flaggedAsBot;
    event AddressFlagged(address indexed acct, string reason);
    event AddressPenalized(address indexed acct, uint256 amount);

    uint256 public nextETFId;
    struct ETFInfo {
        string name;
        address creator;
        uint256 totalShares;
        uint256 createdAt;
    }
    mapping(uint256 => ETFInfo) public etfs;
    mapping(uint256 => address[]) public etfAssets;
    mapping(uint256 => mapping(address => uint256)) public etfAssetBalances;
    mapping(uint256 => mapping(address => uint256)) public etfAssetPricesInBITDATA;
    mapping(uint256 => mapping(address => bool)) public etfAssetRegistered;
    mapping(uint256 => mapping(address => uint256)) public etfSharesOf;

    address public oracleSigner;

    uint256 public totalStaked;
    mapping(address => uint256) public stakedBalance;
    mapping(address => uint256) public userRewardPerSharePaid;
    mapping(address => uint256) public rewards;
    uint256 public rewardPerShareStored;
    uint256 private constant REWARD_SCALE = 1e18;

    struct StoredData {
        address owner;
        uint256 paidWei;
        uint256 storedAt;
        string cid;
    }
    mapping(bytes32 => StoredData) public storedDataById;

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(address indexed ownerA, address indexed spender, uint256 value);
    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
    event TreasurySet(address indexed treasury);
    event LiquidityReserveUpdated(uint256 newReserve);
    event MarketBoost(address indexed executor, uint256 amount);
    event ExemptionSet(address indexed acct, bool exempt);
    event ETFCreated(uint256 indexed etfId, string name, address creator);
    event ETFAssetDeposited(uint256 indexed etfId, address token, uint256 amount);
    event ETFSharesMinted(uint256 indexed etfId, address to, uint256 shares);
    event ETFBought(uint256 indexed etfId, address buyer, uint256 bitdataAmount, uint256 sharesMinted);
    event ETFSold(uint256 indexed etfId, address seller, uint256 sharesBurned, uint256 bitdataReturned);
    event RewardDistributed(address indexed to, uint256 amount);
    event DataStored(bytes32 indexed id, string cid, address indexed owner, uint256 paidWei);
    event NodePaid(address indexed node, uint256 amountWei, string memo);
    event WebhookEvent(string indexed action, address indexed actor, uint256 value, string uri);

    modifier onlyOwner() {
        require(msg.sender == owner, "Not owner");
        _;
    }
    modifier lock() {
        require(unlocked == 1, "Reentrant");
        unlocked = 0;
        _;
        unlocked = 1;
    }
    modifier onlyOracleSigner() {
        require(msg.sender == oracleSigner, "not oracle signer");
        _;
    }
    modifier onlyRewardManagerOrOwner() {
        require(isRewardManager[msg.sender] || msg.sender == owner, "not reward mgr/owner");
        _;
    }

    constructor(address _treasury, address _oracleSigner) {
        require(_treasury != address(0), "treasury zero");
        owner = msg.sender;
        treasury = _treasury;
        oracleSigner = _oracleSigner;

        uint256 _supply = 1_000_000_000 * 10**uint256(decimals);
        totalSupply = _supply;
        balanceOf[_treasury] = _supply;

        isExemptProjectAccount[_treasury] = true;
        isExemptProjectAccount[msg.sender] = true;

        emit Transfer(address(0), _treasury, _supply);
        emit TreasurySet(_treasury);
    }

    function approve(address spender, uint256 value) external returns (bool) {
        allowance[msg.sender][spender] = value;
        emit Approval(msg.sender, spender, value);
        return true;
    }
    function transfer(address to, uint256 value) external returns (bool) {
        _transfer(msg.sender, to, value);
        return true;
    }
    function transferFrom(address from, address to, uint256 value) external returns (bool) {
        uint256 a = allowance[from][msg.sender];
        require(a >= value, "Allowance low");
        if (a != type(uint256).max) {
            allowance[from][msg.sender] = a - value;
            emit Approval(from, msg.sender, allowance[from][msg.sender]);
        }
        _transfer(from, to, value);
        return true;
    }

    function _transfer(address from, address to, uint256 amt) internal lock {
        require(to != address(0), "zero to");
        require(balanceOf[from] >= amt, "bal low");

        if (!(isExemptProjectAccount[from] || isExemptProjectAccount[to])) {
            require(tradingEnabled, "trading disabled");
            if (transferDelayEnabled) {
                require(lastTransferBlock[from] < block.number, "one tx per block");
                lastTransferBlock[from] = block.number;
            }
            if (launchBlock != 0 && block.number <= launchBlock + initialProtectionBlocks) {
                if (maxGasPriceDuringProtection > 0) {
                    require(tx.gasprice <= maxGasPriceDuringProtection * 1 gwei, "gas too high");
                }
            }
        }

        if (lockExpiry[from] > block.timestamp && !isExemptProjectAccount[from]) {
            require(balanceOf[from] - amt >= lockedBalance[from], "tokens locked");
        }

        balanceOf[from] -= amt;
        balanceOf[to] += amt;
        emit Transfer(from, to, amt);
        emit WebhookEvent("transfer", from, amt, "https://api.bitdata.example/webhook/transfer");
    }

    function _approve(address owner_, address spender, uint256 value) internal {
        allowance[owner_][spender] = value;
        emit Approval(owner_, spender, value);
    }

    function seedLiquidity(address router, uint256 tokenAmount)
        external
        payable
        onlyOwner
        lock
    {
        require(msg.value > 0, "need ETH");
        IDEXRouter dex = IDEXRouter(router);

        _approve(address(this), router, tokenAmount);

        dex.addLiquidityETH{value: msg.value}(
            address(this),
            tokenAmount,
            0,
            0,
            treasury,
            block.timestamp
        );

        emit WebhookEvent("seed_liquidity", msg.sender, tokenAmount, "https://api.bitdata.example/webhook/liquidity");
    }

    function setExemptProjectAccount(address acct, bool ok) external onlyOwner {
        isExemptProjectAccount[acct] = ok;
        emit ExemptionSet(acct, ok);
    }
    function openTrading() external onlyOwner {
        if (launchBlock == 0) launchBlock = block.number;
        tradingEnabled = true;
        emit WebhookEvent("open_trading", msg.sender, block.number, "https://api.bitdata.example/webhook/trading");
    }
    function closeTrading() external onlyOwner {
        tradingEnabled = false;
    }

}
"
    }
  },
  "settings": {
    "optimizer": {
      "enabled": true,
      "runs": 200
    },
    "outputSelection": {
      "*": {
        "*": [
          "evm.bytecode",
          "evm.deployedBytecode",
          "devdoc",
          "userdoc",
          "metadata",
          "abi"
        ]
      }
    },
    "remappings": []
  }
}}