AgentSkillsCN

resupply-architecture

当用户询问“补给架构”“补给协议概览”“ResupplyRegistry”“核心合约”“operator 模式”“补给系统设计”，或需要了解补给协议各组件之间的连接方式时，可调用此技能。

SKILL.md
--- frontmatter
name: resupply-architecture
description: This skill should be used when the user asks about "Resupply architecture", "Resupply protocol overview", "ResupplyRegistry", "Core contract", "operator pattern", "Resupply system design", or needs to understand how the Resupply protocol components connect together.

Resupply Protocol Architecture

Resupply is a CDP-based (Collateralized Debt Position) stablecoin lending protocol enabling users to borrow reUSD stablecoins against ERC4626 vault tokens as collateral. The protocol integrates with Curve Lend, Frax Lend, Convex, and Yearn for yield-bearing collateral support.

Core Components

Core Contract (/src/dao/Core.sol)

The central authority contract managing system-wide configuration:

solidity
// Key state variables
address public feeReceiver;           // Protocol fee recipient
uint256 public epochLength;           // Default: 1 week (604800 seconds)
uint256 public startTime;             // Protocol start timestamp

// Operator management
mapping(address operator => bool isEnabled) public operatorPermissions;
mapping(address operator => IAuthHook hook) public authHooks;

Key functions:

  • •execute(address target, bytes calldata data) - Execute calls through Core with operator permissions
  • •setOperatorPermissions(address operator, bool enabled) - Enable/disable operators
  • •setAuthHook(address operator, IAuthHook hook) - Set pre/post execution hooks

ResupplyRegistry (/src/protocol/ResupplyRegistry.sol)

Single source of truth for all protocol addresses and deployed pairs:

solidity
// Registry mappings
address[] public pairs;                          // All deployed lending pairs
mapping(address => bool) public isPair;          // Pair validation
mapping(bytes32 => address) public coreHandlers; // Named component lookup

// Core handler keys
bytes32 constant PAIR_DEPLOYER = keccak256("PAIR_DEPLOYER");
bytes32 constant LIQUIDATION_HANDLER = keccak256("LIQUIDATION_HANDLER");
bytes32 constant REDEMPTION_HANDLER = keccak256("REDEMPTION_HANDLER");
bytes32 constant REWARD_HANDLER = keccak256("REWARD_HANDLER");
bytes32 constant INSURANCE_POOL = keccak256("INSURANCE_POOL");

Registry access pattern:

solidity
address deployer = registry.coreHandlers(PAIR_DEPLOYER);
address[] memory allPairs = registry.getAllPairs();
bool valid = registry.isPair(pairAddress);

Operator Pattern

Operators are authorized contracts that can execute privileged actions through Core:

OperatorPurpose
GuardianEmergency pause, access control
TreasuryManagerTreasury fund management
BorrowLimitControllerDynamic borrow limit adjustments
PairAdderAdding new lending pairs
EmissionsControllerGovernance token emissions

Auth Hook Pattern:

solidity
interface IAuthHook {
    function canCall(address caller, address target, bytes4 selector) external view returns (bool);
    function preHook(address caller, address target, bytes calldata data) external;
    function postHook(address caller, address target, bytes calldata data, bytes calldata result) external;
}

Token Architecture

reUSD Stablecoin (/src/protocol/Stablecoin.sol)

The protocol's native stablecoin with controlled minting:

solidity
// LayerZero OFT for cross-chain support
contract Stablecoin is OFT {
    address public minter;  // Only minter can mint/burn

    function mint(address account, uint256 amount) external;
    function burn(address account, uint256 amount) external;
}

RSUP Governance Token (/src/dao/GovToken.sol)

Governance token for protocol voting and staking rewards:

solidity
contract GovToken is OFT {
    address public minter;
    uint256 public maxMintable;  // Capped supply
}

Precision Constants

All contracts use consistent precision values:

solidity
uint256 constant LTV_PRECISION = 1e5;        // Loan-to-value ratios (95% = 95_000)
uint256 constant EXCHANGE_PRECISION = 1e18;  // Exchange rates
uint256 constant RATE_PRECISION = 1e18;      // Interest rates per second
uint256 constant PAIR_DECIMALS = 1e18;       // Token decimals assumption

Epoch System

The protocol operates on weekly epochs for reward distribution and governance:

solidity
uint256 constant EPOCH_LENGTH = 604800;  // 1 week in seconds

function getEpoch() public view returns (uint256) {
    return (block.timestamp - startTime) / epochLength;
}

Integration Points

Resupply integrates with external protocols through pair deployers:

  • •Curve Lend: CurveLendMinterFactory, CurveLendOperator
  • •Frax Lend: Frax lending pair configurations
  • •Convex: CRV/CVX reward routing
  • •LayerZero: Cross-chain token bridging (OFT standard)

Additional Resources

For a complete list of all protocol contracts with paths, see references/contracts.md.