How to proceed

1. Data Table: Outline what data each part of the system will rely on.

2. Wireframes: Describe main screens/flows for the user portal (in text for review, can be turned into diagrams).

3. Technical Details: Components, data flow, and logic of the platform.

4. Draft Smart Contract Architecture: Specify major contracts, key functions/events, and relationships.

Key Data Involved

Data	Description	Usage
User Address	Ethereum wallet address of user	Identifies user across contracts
Debt Amount	Amount lost in original protocol	Determines vgd to mint
vgd (Vested GD) Balance	User’s unvested (locked) and vesting GD tokens	Vesting and claimable state
GD Balance	Claimable/redeemed GD token balance	For staking, trading, governance
Vesting Schedule Per User	Vesting start, duration, claimed amount	Unlock tracking
Treasury Holdings	Assets (e.g., DAI, ETH) backing GD	Calculating backing, transparency
Staked GD	User’s staked GD for rebasing	Staking rewards, APY calculation
GD Price & Backing Per Token	Dynamic value per protocol status	User dashboard, oracle feeds
Bonding Info	Discount, input asset, vesting periods	Protocol expansion mechanism

2. Wireframes (Textual Flow)

A. Dashboard/Home

• Wallet Connect button

• Overview cards:

  • Total original debt

  • vgd (Vested GD): locked, unlock schedule, claimable

  • GD: claimable, staked

  • Staking APY

  • Backing per GD (protocol reserves per token)

• CTA: “Claim GD” if available

B. Debt/Vesting Page

• Table:

  • Debt ID | Amount | Vested GD | Unlock Progress | Next Vesting Claim | Claim Button

• Vesting schedule graph (linear or custom unlock curve)

• FAQ about vesting and redemption terms

C. Staking Page

• GD Staked: Amount, APY, Rewards earned

• “Stake More” & “Unstake” actions

• Historical staking rewards table

D. Bonding Page (if using bonding mechanism)

• List available bonds: Asset type (e.g., ETH, DAI), Discount Rate, Duration

• Bond input amount, receive GD estimate

• Bond progress/claim schedule

E. Treasury Page

• Assets held

• Backing per GD stats

• Explorer for all protocol holdings & audit logs

F. Governance (Optional)

• Proposals

• Vote delegation

3. Technical Details/Components

Smart Contracts

• VGDVesting: Manages vgd minting, vesting schedule, user claims

• GDToken: ERC20, rebasing (staking/interests), mint/burn control

• Staking: Lock GD, distribute rebase rewards/APY

• Bonding: Accept asset/discounts for locked GD minting, accrue to treasury

• Treasury: Holds reserves, verifies GD backing, manages outflows

• Governance (Optionally): Handles parameter changes

• Oracle (Externalized): Tracks market price of reserves

Frontend

• React/NextJS UI

  • Web3 wallet connect

  • Dashboard with vesting, staking, bonding modules

  • Real-time treasury dashboard (subgraph/api for contracts)

  • Claim and stake flows, modals for actions

Backend/Indexing

• The Graph or custom indexer for events: debt conversions, vesting, staking, treasury movements.

4. Smart Contract Architecture (Solidity Outline)

Here’s a simplified starter code layout for your system:

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

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

// --- GD Token --- contract GDToken is ERC20, Ownable { address public stakingContract; address public vestingContract; address public treasury; bool public rebasingEnabled;

constructor() ERC20("GD Token", "GD") {}

function mint(address to, uint256 amount) external onlyOwner {
    _mint(to, amount);
}
function burn(address from, uint256 amount) external onlyOwner {
    _burn(from, amount);
}
function setContracts(address _staking, address _vesting, address _treasury) external onlyOwner {
    stakingContract = _staking;
    vestingContract = _vesting;
    treasury = _treasury;
}
// Rebase logic (optional, for APY)
function rebase(uint256 reward) external onlyOwner {
    if (rebasingEnabled) {
        _mint(stakingContract, reward);
    }
}

}

// --- vgd (Vested GD) Vesting --- contract VGDVesting is Ownable { GDToken public gd; struct Vesting { uint256 total; uint256 claimed; uint256 start; uint256 duration; } mapping(address => Vesting) public vests;

event Vested(address indexed user, uint256 total, uint256 start, uint256 duration);event Claimed(address indexed user, uint256 amount);constructor(GDToken _gd) {    gd = _gd;}function setVesting(address user, uint256 amount, uint256 duration) external onlyOwner {    require(vests[user].total == 0, "Already set");    vests[user] = Vesting(amount, 0, block.timestamp, duration);    emit Vested(user, amount, block.timestamp, duration);}function claim() external {    Vesting storage v = vests[msg.sender];    require(v.total > 0, "No vesting");    uint256 vested = vestedAmount(msg.sender);    uint256 unclaimed = vested - v.claimed;    require(unclaimed > 0, "Nothing to claim");    v.claimed += unclaimed;    gd.mint(msg.sender, unclaimed);    emit Claimed(msg.sender, unclaimed);}function vestedAmount(address user) public view returns (uint256) {    Vesting memory v = vests[user];    if (block.timestamp <= v.start) return 0;    uint256 elapsed = block.timestamp - v.start;    if (elapsed >= v.duration) return v.total;    return (v.total * elapsed) / v.duration;}

}

// --- Staking Contract --- contract GDStaking is Ownable { GDToken public gd; mapping(address => uint256) public staked; uint256 public rewardRate; // ...rewards & rebase logic...

text

event Staked(address indexed user, uint256 amount);event Unstaked(address indexed user, uint256 amount);// APY/rewards omitted for brevityconstructor(GDToken _gd) {    gd = _gd;}function stake(uint256 amount) external {    gd.transferFrom(msg.sender, address(this), amount);    staked[msg.sender] += amount;    emit Staked(msg.sender, amount);}function unstake(uint256 amount) external {    require(staked[msg.sender] >= amount, "Insufficient");    staked[msg.sender] -= amount;    gd.transfer(msg.sender, amount);    emit Unstaked(msg.sender, amount);}

}

// --- Treasury (Simplified) --- contract GDTreasury is Ownable { mapping(address => uint256) public reserves; event ReserveAdded(address token, uint256 amount);

text

function addReserve(address token, uint256 amount) external onlyOwner {    reserves[token] += amount;    // IMPORTANT: Add transfer-in logic (receive tokens)    emit ReserveAdded(token, amount);}// Backing per GD, policy management etc. can be added.

}

// --- Bonding (Discount for Depositing Asset, Simplified) --- contract GDBonding is Ownable { GDTreasury public treasury; GDToken public gd; // bond params, issue/claim, vesting logic // Omitted for brevity }

This architecture gives you:

• Mintable GD with owner/DAO governance;

• Vesting contract for vgd → GD redemption with schedules and claims;

• Staking contract for rebase rewards (add reward logic as needed);

• Treasury for protocol reserves/backing;

• (Optional) Bonding logic for reserves expansion.