The Alberta Buck - Ethereum Implementation (DRAFT v0.1)

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";

contract BuckCredit is ERC721Enumerable {

    enum DepreciationType {
        NONE,              // Non-depreciating (land, gold, crypto)
        LINEAR,            // Constant annual reduction
        DECLINING_BALANCE  // Percentage of remaining value per year
    }

    struct CreditParams {
        // Immutable (set at creation)
        address insurer;            // Vendor who can update this credit
        uint8   assetClass;         // Asset classification (immutable)
        uint48  createdAt;          // Creation timestamp

        // Insurer-mutable (reappraisal, schedule changes)
        uint256 faceValue;          // Maximum insured value (18 decimals)
        uint256 depreciationFloor;  // Minimum value after depreciation

        DepreciationType depType;   // Depreciation model
        uint32  depRate;            // Annual rate in basis points (10000 = 100%)
        uint48  depStartAt;         // When depreciation begins

        uint32  premiumRate;        // Annual premium: basis points of activated value
        uint48  lastUpdated;        // Timestamp of last insurer update

        // Client-mutable (activation)
        uint256 activatedValue;     // Currently activated portion (<= faceValue)
        uint48  lastActivatedAt;    // Timestamp of last activation
    }

    mapping(uint256 => CreditParams) public credits;
    uint256 private _nextTokenId;

    // --- Events ---
    event CreditCreated(uint256 indexed tokenId, address indexed insurer,
                        address indexed owner, uint256 faceValue);
    event CreditUpdated(uint256 indexed tokenId, address indexed insurer,
                        uint256 newFaceValue, uint32 newDepRate, uint32 newPremiumRate);
    event CreditActivated(uint256 indexed tokenId, address indexed owner,
                          uint256 additionalValue, uint256 totalActivated);
}

    /// @notice Current depreciated value of the activated portion of this credit.
    /// @dev Pure computation from on-chain state -- no oracle needed.
    function currentValue(uint256 tokenId) public view returns (uint256) {
        CreditParams storage c = credits[tokenId];
        if (c.activatedValue == 0) return 0;

        uint256 depreciatedFace = _depreciate(
            c.faceValue, c.depType, c.depRate,
            c.depreciationFloor, c.depStartAt
        );

        // Activated portion depreciates proportionally
        return depreciatedFace * c.activatedValue / c.faceValue;
    }

    function _depreciate(
        uint256 faceValue,
        DepreciationType depType,
        uint32 depRate,        // basis points per year
        uint256 floor,
        uint48 startAt
    ) internal view returns (uint256) {
        if (depType == DepreciationType.NONE || block.timestamp <= startAt) {
            return faceValue;
        }

        uint256 elapsed = block.timestamp - startAt;
        uint256 depreciable = faceValue - floor; // portion subject to depreciation

        if (depType == DepreciationType.LINEAR) {
            // loss = depreciable * rate * elapsed / (365.25 days * 10000)
            uint256 loss = depreciable * depRate * elapsed / (365.25 days * 10000);
            if (loss >= depreciable) return floor;
            return faceValue - loss;
        }

        if (depType == DepreciationType.DECLINING_BALANCE) {
            // value = floor + depreciable * (1 - rate/10000) ^ years
            // Use continuous approximation: exp(-rate * elapsed / (10000 * 365.25 days))
            // Implemented via fixed-point exp approximation (see _expNeg below)
            uint256 exponent = uint256(depRate) * elapsed / (365.25 days);
            // exponent is in basis-point-years; convert to 18-decimal fixed point
            // exponent_fp = exponent * 1e18 / 10000 = exponent * 1e14
            uint256 expFp = exponent * 1e14;
            uint256 factor = _expNeg(expFp); // returns 1e18 * exp(-expFp/1e18)
            return floor + depreciable * factor / 1e18;
        }

        return faceValue; // fallback
    }

    /// @dev Fixed-point exp(-x) for x in 18-decimal format.
    ///      Uses 6th-order Taylor series, accurate to <0.01% for x < 3.0 (ie. <300% total depreciation).
    ///      For production, use PRBMath.exp() or ABDKMath64x64.
    function _expNeg(uint256 x) internal pure returns (uint256) {
        // exp(-x) ~ 1 - x + x^2/2 - x^3/6 + x^4/24 - x^5/120 + x^6/720
        uint256 UNIT = 1e18;
        if (x > 10 * UNIT) return 0; // effectively fully depreciated

        uint256 x2 = x * x / UNIT;
        uint256 x3 = x2 * x / UNIT;
        uint256 x4 = x3 * x / UNIT;
        uint256 x5 = x4 * x / UNIT;
        uint256 x6 = x5 * x / UNIT;

        // Positive terms: 1 + x^2/2 + x^4/24 + x^6/720
        uint256 pos = UNIT + x2 / 2 + x4 / 24 + x6 / 720;
        // Negative terms: x + x^3/6 + x^5/120
        uint256 neg = x + x3 / 6 + x5 / 120;

        if (neg >= pos) return 0;
        return pos - neg;
    }

    /// @notice Client activates additional credit, up to the current face value.
    /// @param tokenId  The BUCK_CREDIT NFT to activate
    /// @param amount   Additional value to activate (18 decimals)
    /// @dev Caller must be the token owner.
    ///      Premium for the newly activated amount is collected by BUCK.mint(),
    ///      not here -- activation just increases the limit.
    function activate(uint256 tokenId, uint256 amount) external {
        require(ownerOf(tokenId) == msg.sender, "Not credit owner");
        CreditParams storage c = credits[tokenId];
        require(c.activatedValue + amount <= c.faceValue,
                "Exceeds face value");

        c.activatedValue += amount;
        c.lastActivatedAt = uint48(block.timestamp);

        emit CreditActivated(tokenId, msg.sender, amount, c.activatedValue);
    }

    /// @notice Aggregate current value of all credits owned by an account.
    /// @dev Called by BUCK.mint() to compute the credit limit.
    function totalCurrentValue(address account) external view returns (uint256) {
        uint256 total = 0;
        uint256 count = balanceOf(account);
        for (uint256 i = 0; i < count; i++) {
            total += currentValue(tokenOfOwnerByIndex(account, i));
        }
        return total;
    }

    /// @notice Insurer updates credit parameters (reappraisal, schedule change).
    /// @dev Only callable by the credit's designated insurer.
    ///      Cannot change assetClass or insurer address.
    function updateCredit(
        uint256 tokenId,
        uint256 newFaceValue,
        uint256 newDepreciationFloor,
        DepreciationType newDepType,
        uint32 newDepRate,
        uint48 newDepStartAt,
        uint32 newPremiumRate
    ) external {
        CreditParams storage c = credits[tokenId];
        require(msg.sender == c.insurer, "Not insurer");

        // If face value decreases below activated, cap activated
        if (newFaceValue < c.activatedValue) {
            c.activatedValue = newFaceValue;
        }

        c.faceValue = newFaceValue;
        c.depreciationFloor = newDepreciationFloor;
        c.depType = newDepType;
        c.depRate = newDepRate;
        c.depStartAt = newDepStartAt;
        c.premiumRate = newPremiumRate;
        c.lastUpdated = uint48(block.timestamp);

        emit CreditUpdated(tokenId, msg.sender,
                           newFaceValue, newDepRate, newPremiumRate);
    }

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.20;

import "@openzeppelin/contracts/token/ERC20/ERC20.sol";

contract Buck is ERC20 {

    BuckCredit public immutable buckCredit;
    BuckKController public immutable buckK;
    address public immutable insurancePool;

    uint256 constant PRECISION = 1e18;

    // Per-account stored credit limit (monotonically increases per mint)
    mapping(address => uint256) public storedLimit;

    event Minted(address indexed account, uint256 amount, uint256 premium,
                 uint256 creditValue, uint256 buckKValue, uint256 newLimit);

    constructor(address _buckCredit, address _buckK, address _insurancePool)
        ERC20("Alberta Buck", "BUCK")
    {
        buckCredit = BuckCredit(_buckCredit);
        buckK = BuckKController(_buckK);
        insurancePool = _insurancePool;
    }

    /// @notice Mint BUCKs against the caller's aggregated BUCK_CREDIT value.
    /// @param amount  Desired BUCK amount to mint (18 decimals).
    function mint(uint256 amount) external {
        // 1. Aggregate all BUCK_CREDITs in the caller's account
        uint256 totalCreditValue = buckCredit.totalCurrentValue(msg.sender);

        // 2. Get current BUCK_K stabilization factor
        uint256 currentBuckK = buckK.compute();

        // 3. Compute maximum credit limit
        uint256 maxLimit = totalCreditValue * currentBuckK / PRECISION;

        // 4. Only increase the stored limit (never decrease via mint)
        if (maxLimit > storedLimit[msg.sender]) {
            storedLimit[msg.sender] = maxLimit;
        }

        // 5. Check that mint doesn't exceed limit
        uint256 currentBalance = balanceOf(msg.sender);
        require(currentBalance + amount <= storedLimit[msg.sender],
                "Exceeds credit limit");

        // 6. Compute default insurance premium
        uint256 premium = _computePremium(
            msg.sender, amount, storedLimit[msg.sender]
        );

        // 7. Mint: net amount to client, premium to insurance pool
        _mint(msg.sender, amount - premium);
        if (premium > 0) {
            _mint(insurancePool, premium);
        }

        emit Minted(msg.sender, amount, premium,
                     totalCreditValue, currentBuckK, storedLimit[msg.sender]);
    }

    /// @notice Burn BUCKs to reduce outstanding balance (repayment).
    /// @dev Reduces balance, freeing credit capacity for future minting.
    function burn(uint256 amount) external {
        _burn(msg.sender, amount);
    }

    /// @dev Premium as a fraction of the minted amount, scaling with utilization.
    ///      Uses a quadratic curve: premium_rate = baseRate + (utilization^2) * scaleRate
    ///      At 0% utilization: ~0.5% premium
    ///      At 50% utilization: ~1.75% premium
    ///      At 90% utilization: ~4.55% premium
    ///      At 100% utilization: impossible (can't mint past limit)
    uint256 constant BASE_RATE  = 50;    // 0.50% base (in basis points)
    uint256 constant SCALE_RATE = 450;   // 4.50% additional at 100% utilization
    uint256 constant BP = 10000;

    function _computePremium(
        address account,
        uint256 mintAmount,
        uint256 limit
    ) internal view returns (uint256) {
        if (limit == 0) return 0;

        // Utilization after this mint
        uint256 newBalance = balanceOf(account) + mintAmount;
        uint256 utilization = newBalance * PRECISION / limit; // 0 to 1e18

        // premium_rate = BASE_RATE + utilization^2 * SCALE_RATE / 1e18
        uint256 utilSq = utilization * utilization / PRECISION;
        uint256 rate = BASE_RATE + utilSq * SCALE_RATE / PRECISION;

        return mintAmount * rate / BP;
    }
}

// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity ^0.8.20;

import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";

contract BuckKController {

    // --- PID Gains (governance-set, 18-decimal fixed point) ---
    int256 public Kp;
    int256 public Ki;
    int256 public Kd;

    // --- PID State (updated on compute() when dT has elapsed) ---
    int256 public P;          // Proportional error
    int256 public I;          // Integral accumulator
    int256 public D;          // Derivative
    uint256 public lastUpdate; // Timestamp of last PID state update

    // --- Output ---
    uint256 public buckK;     // Current BUCK_K output (18-decimal, 1e18 = 1.0)
    uint256 public dT;        // Minimum seconds between PID state updates

    // --- Output Limits (anti-windup) ---
    uint256 public buckKMin;  // Floor (e.g., 0.5e18 = 50% of neutral)
    uint256 public buckKMax;  // Ceiling (e.g., 2.0e18 = 200% of neutral)

    // --- Oracle Configuration ---
    address public buckUsdcPool;    // Uniswap V3 BUCK/USDC pool
    uint32  public twapInterval;    // TWAP window in seconds (e.g., 1800 = 30min)

    // Commodity basket: Chainlink price feeds + weights
    struct BasketComponent {
        AggregatorV3Interface feed;  // Chainlink price feed
        uint256 weight;              // Weight in basket (18 decimals, sum = 1e18)
        uint8   feedDecimals;        // Decimals of the Chainlink feed
    }
    BasketComponent[] public basket;

    int256 constant UNIT = 1e18;
    address public governance;

    event BuckKUpdated(uint256 newBuckK, int256 error, int256 P, int256 I, int256 D);
    event GainsUpdated(int256 Kp, int256 Ki, int256 Kd);

    constructor(
        int256 _Kp, int256 _Ki, int256 _Kd,
        uint256 _dT,
        uint256 _buckKMin, uint256 _buckKMax,
        address _buckUsdcPool, uint32 _twapInterval,
        address _governance
    ) {
        Kp = _Kp; Ki = _Ki; Kd = _Kd;
        dT = _dT;
        buckKMin = _buckKMin;
        buckKMax = _buckKMax;
        buckUsdcPool = _buckUsdcPool;
        twapInterval = _twapInterval;
        governance = _governance;
        buckK = uint256(UNIT); // Start at 1.0 (neutral)
        lastUpdate = block.timestamp;
    }

    /// @notice Compute and return the current BUCK_K value.
    /// @dev If dT has elapsed since last update, performs a full PID cycle
    ///      (reads oracles, updates P/I/D state, stores new buckK).
    ///      Otherwise returns the cached buckK value.
    ///      Called by BUCK.mint() -- the minter pays gas for any PID update.
    function compute() external returns (uint256) {
        if (block.timestamp - lastUpdate < dT) {
            return buckK;
        }

        // --- Read oracles ---
        int256 basketCost = _getBasketCost();   // Setpoint: USDC cost of basket
        int256 buckPrice  = _getBuckPrice();     // PV: BUCK market price in USDC

        // --- PID computation ---
        int256 dt = int256(block.timestamp - lastUpdate);
        int256 error = basketCost - buckPrice;   // Positive = BUCK undervalued

        int256 newP = error;
        int256 newI = I + error * dt / UNIT;     // Scaled integral
        int256 newD = dt > 0
            ? (error - P) * UNIT / dt            // Rate of change
            : int256(0);

        int256 rawOutput = UNIT                   // Start at 1.0 (neutral)
            + newP * Kp / UNIT
            + newI * Ki / UNIT
            + newD * Kd / UNIT;

        // --- Anti-windup clamping ---
        uint256 newBuckK;
        if (rawOutput < int256(buckKMin)) {
            newBuckK = buckKMin;
            // Only update integral if it would push output away from saturation
            if (newI > I) I = newI;
        } else if (rawOutput > int256(buckKMax)) {
            newBuckK = buckKMax;
            if (newI < I) I = newI;
        } else {
            newBuckK = uint256(rawOutput);
            I = newI;
        }

        P = newP;
        D = newD;
        buckK = newBuckK;
        lastUpdate = block.timestamp;

        emit BuckKUpdated(newBuckK, error, P, I, D);
        return newBuckK;
    }

    /// @notice Current BUCK_K without updating state (view-only).
    function currentBuckK() external view returns (uint256) {
        return buckK;
    }

    // --- Oracle Helpers ---

    /// @dev Sum of weighted commodity prices from Chainlink feeds, in USDC (18 decimals).
    function _getBasketCost() internal view returns (int256) {
        int256 total = 0;
        for (uint i = 0; i < basket.length; i++) {
            BasketComponent storage comp = basket[i];
            (, int256 price,,,) = comp.feed.latestRoundData();
            // Normalize to 18 decimals
            int256 normalized = price * int256(10 ** (18 - comp.feedDecimals));
            total += normalized * int256(comp.weight) / UNIT;
        }
        return total;
    }

    /// @dev BUCK/USDC price from Uniswap V3 TWAP oracle (18 decimals).
    ///      Uses the pool's observe() function for manipulation resistance.
    function _getBuckPrice() internal view returns (int256) {
        // Uniswap V3 TWAP implementation:
        // 1. Call pool.observe([twapInterval, 0])
        // 2. Compute tick = (tickCumulatives[1] - tickCumulatives[0]) / twapInterval
        // 3. Convert tick to price: price = 1.0001^tick * 10^(token1Decimals - token0Decimals)
        //
        // Omitted here for brevity -- production would use Uniswap's OracleLibrary.
        // See: https://docs.uniswap.org/contracts/v3/guides/providing-liquidity/get-a-price
        revert("_getBuckPrice: implement with OracleLibrary");
    }

    // --- Governance ---

    function setGains(int256 _Kp, int256 _Ki, int256 _Kd) external {
        require(msg.sender == governance, "Not governance");
        Kp = _Kp; Ki = _Ki; Kd = _Kd;
        emit GainsUpdated(_Kp, _Ki, _Kd);
    }

    function setDT(uint256 _dT) external {
        require(msg.sender == governance, "Not governance");
        dT = _dT;
    }

    function addBasketComponent(address feed, uint256 weight, uint8 decimals) external {
        require(msg.sender == governance, "Not governance");
        basket.push(BasketComponent({
            feed: AggregatorV3Interface(feed),
            weight: weight,
            feedDecimals: decimals
        }));
    }
}