// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/proxy/utils/UUPSUpgradeable.sol";

contract NexisToken is ERC20Upgradeable, AccessControlUpgradeable, UUPSUpgradeable {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");

    uint256 public constant MAX_SUPPLY = 1_000_000_000 * 1e18; // 1 billion

    /// @notice Initialize the token contract
    function initialize() public initializer {
        __ERC20_init("Nexis", "NZT");
        __AccessControl_init();
        __UUPSUpgradeable_init();

        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        _grantRole(MINTER_ROLE, msg.sender);
    }

    /// @notice Mint new tokens (only MintManager)
    /// @param to Recipient address
    /// @param amount Amount to mint
    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {
        require(totalSupply() + amount <= MAX_SUPPLY, "Exceeds max supply");
        _mint(to, amount);
    }

    /// @notice Burn tokens from sender
    /// @param amount Amount to burn
    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    /// @notice Burn tokens from specific address (requires approval)
    /// @param from Address to burn from
    /// @param amount Amount to burn
    function burnFrom(address from, uint256 amount) external {
        _spendAllowance(from, msg.sender, amount);
        _burn(from, amount);
    }

    /// @notice Get circulating supply (excluding treasury and vesting)
    function circulatingSupply() external view returns (uint256) {
        uint256 total = totalSupply();
        uint256 treasuryBalance = balanceOf(address(treasury));
        uint256 vestingBalance = balanceOf(address(vesting));
        return total - treasuryBalance - vestingBalance;
    }

    /// @notice Authorize contract upgrades (governance only)
    function _authorizeUpgrade(address newImplementation)
        internal
        override
        onlyRole(DEFAULT_ADMIN_ROLE)
    {}
}

const nztContract = new ethers.Contract(nztAddress, nztAbi, provider);

// Get token details
const name = await nztContract.name(); // "Nexis"
const symbol = await nztContract.symbol(); // "NZT"
const decimals = await nztContract.decimals(); // 18
const totalSupply = await nztContract.totalSupply();
const maxSupply = await nztContract.MAX_SUPPLY();

// Get balance
const balance = await nztContract.balanceOf(userAddress);
console.log(`Balance: ${ethers.formatEther(balance)} NZT`);

// Get allowance
const allowance = await nztContract.allowance(ownerAddress, spenderAddress);
console.log(`Allowance: ${ethers.formatEther(allowance)} NZT`);

// Get circulating supply
const circulating = await nztContract.circulatingSupply();
console.log(`Circulating: ${ethers.formatEther(circulating)} NZT`);

const nztContract = new ethers.Contract(nztAddress, nztAbi, signer);

// Transfer tokens
const transferTx = await nztContract.transfer(
  recipientAddress,
  ethers.parseEther("100") // 100 NZT
);
await transferTx.wait();

// Approve spending
const approveTx = await nztContract.approve(
  spenderAddress,
  ethers.parseEther("1000") // 1000 NZT
);
await approveTx.wait();

// Transfer from (requires approval)
const transferFromTx = await nztContract.transferFrom(
  fromAddress,
  toAddress,
  ethers.parseEther("50")
);
await transferFromTx.wait();

// Burn tokens
const burnTx = await nztContract.burn(ethers.parseEther("10"));
await burnTx.wait();

contract NexisGovernance {
    INexisToken public nztToken;

    struct Proposal {
        uint256 id;
        address proposer;
        string description;
        uint256 forVotes;
        uint256 againstVotes;
        uint256 startBlock;
        uint256 endBlock;
        bool executed;
        mapping(address => bool) hasVoted;
    }

    uint256 public constant PROPOSAL_THRESHOLD = 100_000 * 1e18; // 100k NZT
    uint256 public constant QUORUM = 5; // 5% of circulating supply
    uint256 public constant VOTING_PERIOD = 50_400; // ~7 days (2s blocks)

    /// @notice Create a new proposal
    function propose(
        string memory description,
        address[] memory targets,
        bytes[] memory calldatas
    ) external returns (uint256) {
        require(
            nztToken.balanceOf(msg.sender) >= PROPOSAL_THRESHOLD,
            "Insufficient NZT to propose"
        );

        uint256 proposalId = proposalCount++;
        Proposal storage p = proposals[proposalId];
        p.id = proposalId;
        p.proposer = msg.sender;
        p.description = description;
        p.startBlock = block.number;
        p.endBlock = block.number + VOTING_PERIOD;

        emit ProposalCreated(proposalId, msg.sender, description);
        return proposalId;
    }

    /// @notice Cast a vote on a proposal
    function castVote(uint256 proposalId, bool support) external {
        Proposal storage p = proposals[proposalId];
        require(block.number >= p.startBlock, "Voting not started");
        require(block.number <= p.endBlock, "Voting ended");
        require(!p.hasVoted[msg.sender], "Already voted");

        uint256 votes = nztToken.balanceOf(msg.sender);
        require(votes > 0, "No voting power");

        if (support) {
            p.forVotes += votes;
        } else {
            p.againstVotes += votes;
        }

        p.hasVoted[msg.sender] = true;
        emit VoteCast(msg.sender, proposalId, support, votes);
    }

    /// @notice Execute a passed proposal
    function execute(uint256 proposalId) external {
        Proposal storage p = proposals[proposalId];
        require(block.number > p.endBlock, "Voting ongoing");
        require(!p.executed, "Already executed");

        uint256 totalVotes = p.forVotes + p.againstVotes;
        uint256 quorumVotes = (nztToken.circulatingSupply() * QUORUM) / 100;

        require(totalVotes >= quorumVotes, "Quorum not reached");
        require(p.forVotes > p.againstVotes, "Proposal failed");

        p.executed = true;
        // Execute proposal actions...

        emit ProposalExecuted(proposalId);
    }
}

# Install Nexis CLI
npm install -g @nexis/cli

# Request testnet NZT
nexis faucet request --address YOUR_ADDRESS

# Output: Sent 1000 NZT to YOUR_ADDRESS
# Transaction: 0xabc123...

const nexisBridge = new ethers.Contract(bridgeAddress, bridgeAbi, signer);

// Deposit NZT from Base L2 to Nexis L3
const depositTx = await nexisBridge.depositERC20(
  NZT_L2_ADDRESS,
  NZT_L3_ADDRESS,
  ethers.parseEther("100"),
  200_000, // L3 gas limit
  "0x" // Extra data
);
await depositTx.wait();

// Withdrawal from L3 to L2 (7-day delay)
const withdrawTx = await nexisBridge.withdrawERC20(
  NZT_L3_ADDRESS,
  ethers.parseEther("50"),
  0, // Min gas limit
  "0x"
);
await withdrawTx.wait();

// After 7-day challenge period, finalize on L2
const finalizeTx = await nexisBridge.finalizeWithdrawal(withdrawalHash);
await finalizeTx.wait();

// Total minted supply
const totalSupply = await nztContract.totalSupply();

// Circulating supply (excludes treasury, vesting, burned)
const circulatingSupply = await nztContract.circulatingSupply();

// Burned supply
const burnedSupply = await nztContract.balanceOf(
  '0x000000000000000000000000000000000000dEaD'
);

// Treasury balance
const treasurySupply = await nztContract.balanceOf(treasuryAddress);

// Staked supply
const stakedSupply = await stakingContract.totalStaked();

// Calculate percentages
const totalMinted = parseFloat(ethers.formatEther(totalSupply));
const circulating = parseFloat(ethers.formatEther(circulatingSupply));
const burned = parseFloat(ethers.formatEther(burnedSupply));
const staked = parseFloat(ethers.formatEther(stakedSupply));

console.log(`Total Supply: ${totalMinted.toLocaleString()} NZT`);
console.log(`Circulating: ${circulating.toLocaleString()} NZT (${(circulating/totalMinted*100).toFixed(2)}%)`);
console.log(`Burned: ${burned.toLocaleString()} NZT (${(burned/totalMinted*100).toFixed(2)}%)`);
console.log(`Staked: ${staked.toLocaleString()} NZT (${(staked/circulating*100).toFixed(2)}% of circulating)`);

import { Pool } from '@uniswap/v3-sdk';
import { Token } from '@uniswap/sdk-core';

const NZT = new Token(8453, NZT_ADDRESS, 18, 'NZT', 'Nexis');
const USDC = new Token(8453, USDC_ADDRESS, 6, 'USDC', 'USD Coin');

// Get pool data
const poolContract = new ethers.Contract(poolAddress, poolAbi, provider);
const slot0 = await poolContract.slot0();
const liquidity = await poolContract.liquidity();

// Calculate price from sqrtPriceX96
const sqrtPriceX96 = slot0.sqrtPriceX96;
const price = (sqrtPriceX96 / (2**96)) ** 2;

// Adjust for decimals
const nztPrice = price * (10 ** (USDC.decimals - NZT.decimals));
console.log(`NZT Price: $${nztPrice.toFixed(4)} USDC`);

import { NexisSDK } from '@nexis/sdk';

const sdk = new NexisSDK({
  network: 'testnet', // or 'mainnet'
  privateKey: process.env.PRIVATE_KEY
});

// Get NZT balance
const balance = await sdk.token.getBalance(address);
console.log(`Balance: ${balance} NZT`);

// Transfer NZT
const tx = await sdk.token.transfer(recipientAddress, amount);
console.log(`Tx hash: ${tx.hash}`);

// Stake NZT
const stakeTx = await sdk.staking.stake(amount);
console.log(`Staked ${amount} NZT`);

// Vote on proposal
const voteTx = await sdk.governance.vote(proposalId, true);
console.log(`Voted on proposal ${proposalId}`);