Smart Contracts Reference

RedCarpetHQ is powered by battle-tested smart contracts. This reference provides technical details for developers and advanced users.

Contract Architecture

Global Contracts (Single Instance)

Registry

Address: [Deployed Address]

Key Functions:

Stores:

Campaign

Address: [Deployed Address]

Key Functions:

Events:

Market

Address: [Deployed Address]

Key Functions:

Offer Types:

Events:

FeeDistributor

Address: [Deployed Address]

Distribution:

Key Functions:

Events:

Contest

Address: [Deployed Address]

Constants:

Key Functions:

Events:

RiskOracle

Address: [Deployed Address]

Risk Tiers:

Key Functions:

Assessment Factors:

HybridPriceOracle

Address: [Deployed Address]

Key Functions:

Update Mechanism:

DividendDistributor

Address: [Deployed Address]

Key Functions:

Events:

Per-Token Contracts

UnifiedVault (ERC4626)

Deployment: One per graduated token

ERC4626 Functions:

Lending Functions:

State Variables:

Events:

MinimumERC20 (Campaign Token)

Deployment: One per campaign

Standard ERC20:

Additional Features:

Events:

Contract Interactions

Campaign Creation Flow

``
User → Campaign.createCampaign()
↓
Campaign → Clones.clone(tokenImplementation)
↓
Campaign → MinimumERC20.initialize()
↓
Campaign → Registry.registerCampaign()
↓
Event: CampaignCreated
`

`
User → USDC.approve(Campaign, amount)
↓
User → Campaign.purchaseTokens(token, amount)
↓
Campaign → USDC.transferFrom(user, Campaign, amount)
↓
Campaign → MinimumERC20.mint(user, tokens)
↓
Event: TokensPurchased
`

`
Creator → Campaign.finalizeCampaign(token)
↓
Campaign → Check: raised >= floor
↓
Campaign → USDC.transfer(fundsRecipient, raised)
↓
Campaign → MinimumERC20.lockSupply()
↓
Campaign → Registry.setGraduated(token)
↓
Campaign → LendingManager.deployVault(token)
↓
Event: CampaignEnded, SupplyLocked
`

`
Seller → Token.approve(Market, amount)
↓
Seller → Market.createOffer(SELL, token, amount, price)
↓
Market → Token.transferFrom(seller, Market, amount)
↓
Event: OfferCreated
↓
Buyer → USDC.approve(Market, cost)
↓
Buyer → Market.fillOffer(offerId, amount)
↓
Market → USDC.transferFrom(buyer, Market, cost)
↓
Market → Calculate fee (2.5%)
↓
Market → FeeDistributor.distributeFees(token, fee)
↓
Market → Token.transfer(buyer, amount)
↓
Market → USDC.transfer(seller, cost - fee)
↓
Market → HybridPriceOracle.updatePrice(token, price, volume)
↓
Market → Contest.recordVolume(token, buyer, volume)
↓
Events: OfferFilled, TradeExecuted
`

`
Lender → USDC.approve(Vault, amount)
↓
Lender → Vault.deposit(amount, lender)
↓
Vault → USDC.transferFrom(lender, Vault, amount)
↓
Vault → Split: 80% lending, 20% stability
↓
Vault → Mint shares to lender
↓
Event: Deposit
↓
Borrower → Token.approve(Vault, collateral)
↓
Borrower → Vault.depositCollateral(collateral)
↓
Vault → Token.transferFrom(borrower, Vault, collateral)
↓
Event: CollateralDeposited
↓
Borrower → Vault.borrow(amount)
↓
Vault → Check: collateral sufficient
↓
Vault → Accrue interest
↓
Vault → USDC.transfer(borrower, amount)
↓
Vault → Update totalBorrows
↓
Event: Borrowed
`

`
Liquidator → Vault.liquidate(borrower)
↓
Vault → Check: collateral ratio < threshold
↓
Vault → Calculate debt + bonus
↓
Vault → Stability pool repays debt
↓
Vault → Seize collateral
↓
Vault → Distribute collateral to stability depositors
↓
Vault → Create sell offer on Market (auto-sell)
↓
Event: Liquidated
`

`
Producer → USDC.approve(DividendDistributor, amount)
↓
Producer → DividendDistributor.createDividendRound(token, amount)
↓
DividendDistributor → USDC.transferFrom(producer, contract, amount)
↓
Event: DividendRoundCreated
↓
Producer → Token.snapshot()
↓
Event: Snapshot
↓
Producer → DividendDistributor.activateRound(token, roundId)
↓
Event: DividendRoundActivated
↓
Holder → DividendDistributor.claimDividend(token, roundId)
↓
DividendDistributor → Calculate share
↓
DividendDistributor → USDC.transfer(holder, share)
↓
Event: DividendClaimed
`

All state-changing functions use ReentrancyGuard:
`solidity
modifier nonReentrant() {
require(_status != _ENTERED, "ReentrancyGuard: reentrant call");
_status = _ENTERED;
_;
_status = _NOT_ENTERED;
}
`

Critical contracts can be paused:
`solidity
function pause() external onlyOwner {
_pause();
}

function unpause() external onlyOwner {
_unpause();
}
`

All token transfers use OpenZeppelin's SafeERC20:
`solidity
using SafeERC20 for IERC20;

IERC20(token).safeTransfer(recipient, amount);
IERC20(token).safeTransferFrom(sender, recipient, amount);
`

Solidity 0.8.20 has built-in overflow checks:
`solidity
pragma solidity 0.8.20;
// Automatic overflow/underflow protection
`

Integrator Commission (uiFeeFactor)

Packed Structs:
`solidity
struct Offer {
uint256 offerId;
address token;
address paymentToken;
uint8 offerType; // Packed with status
uint8 status; // Same slot
// ... more fields
}
`

Immutable Variables:
`solidity
IERC20 public immutable collateralToken;
Registry public immutable registry;
`

Multiple Claims:
`solidity
function claimMultipleDividends(
address[] calldata tokens,
uint256[] calldata roundIds
) external;
`

`javascript
const Web3 = require('web3');
const web3 = new Web3(RPC_URL); // Use platform-provided RPC

const campaignABI = [ / ABI from platform API / ];
const campaign = new web3.eth.Contract(campaignABI, CAMPAIGN_ADDRESS);
`

`javascript
const { ethers } = require('ethers');
const provider = new ethers.JsonRpcProvider(RPC_URL); // Use platform-provided RPC

const campaignABI = [ / ABI from platform API / ];
const campaign = new ethers.Contract(CAMPAIGN_ADDRESS, campaignABI, provider);
``

Upgradability

Non-Upgradable Contracts

All core contracts are immutable (not upgradable):

Why?

Registry Updates

Registry can update:

Does NOT affect:

Next Steps: