# 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.
---
# Agent Instructions: Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.
Perform an HTTP GET request on the current page URL with the `ask` query parameter:
```
GET https://docs.godex.ai/getting-started/godao-platforms-token/how-to-proceed.md?ask=
```
The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.
Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.