How Synthetic Assets Are Minted and Burned On-Chain

core_concepts

Core Concepts for Synthetic Asset Protocols

Fundamental mechanisms that enable the creation and management of on-chain synthetic assets, detailing the roles of collateral, price feeds, and protocol governance.

Collateralization

Collateralization is the process of locking assets to back the value of minted synthetic tokens.

Users deposit assets like ETH or stablecoins into a smart contract vault.
The protocol enforces a minimum collateral ratio, often 150% or higher, to maintain solvency.
This over-collateralization protects the system from price volatility and ensures synthetic tokens are always redeemable.

Synthetic Asset (Synth)

A Synthetic Asset is an on-chain token that tracks the price of an external asset without holding the underlying.

Examples include sUSD (synthetic USD), sBTC (synthetic Bitcoin), or synthetic Tesla stock.
Synths are minted against collateral and can be traded, used in DeFi, or burned for redemption.
They provide on-chain exposure to real-world assets, commodities, or indices.

Price Feed Oracle

A Price Feed Oracle is a decentralized data source that provides real-time price data to the protocol.

It supplies the current market price of the tracked asset (e.g., BTC/USD) to the smart contracts.
Accurate oracles are critical for calculating collateral ratios and mint/burn values.
Protocols often use multiple oracles or a decentralized network like Chainlink to prevent manipulation.

Debt Pool & Global Debt

The Debt Pool represents the system's total outstanding liability, shared proportionally by all synth holders.

When a user mints a synth, they incur a share of the global debt denominated in a base currency like sUSD.
Debt shares fluctuate as synth prices change, affecting individual redemption values.
This mechanism distributes systemic risk and aligns incentives for maintaining protocol health.

Minting and Burning

Minting and Burning are the core functions for creating and destroying synthetic assets on-chain.

Minting issues new synths by locking collateral and adding to the user's debt share.
Burning destroys synths to unlock collateral, reducing the user's debt share.
These actions are governed by smart contracts that verify collateral ratios and oracle prices in real-time.

Liquidation

Liquidation is a protective mechanism triggered when a user's collateral ratio falls below the required minimum.

A liquidator can repay part of the under-collateralized debt in exchange for a discounted portion of the collateral.
This process removes risky positions, protecting the system's solvency.
It creates a market incentive for external actors to maintain the protocol's health.

The On-Chain Minting Process

The sequential, verifiable steps to create a synthetic asset by locking collateral in a smart contract.

Approve Collateral Spending

Authorize the smart contract to access the user's collateral tokens.

Detailed Instructions

Before depositing, the user must grant the synthetic asset protocol's core contract permission to transfer their collateral. This is a standard ERC-20 approve call, setting an allowance for the contract address. The required collateral amount is determined by the asset's collateralization ratio and the desired synthetic amount.

Sub-step 1: Call approve(spender, amount) on the collateral token contract (e.g., WETH, USDC).
Sub-step 2: Set spender to the protocol's Vault or SyntheticMint contract address.
Sub-step 3: Set amount to the calculated collateral needed, or use type(uint256).max for infinite approval.

solidity
// Example: Approving WETH for a Synthetix-like vault
IERC20(wethAddress).approve(vaultAddress, collateralAmount);

Tip: Always verify the contract address from the protocol's official documentation to avoid phishing.

Deposit Collateral and Mint

Lock collateral into the protocol and receive newly minted synthetic tokens.

Detailed Instructions

The user calls the minting function on the protocol's primary contract. This function performs a collateral transfer and synthetic token issuance in a single atomic transaction. The contract calculates the mintable amount based on the deposited collateral and the current price feed for the collateral asset. It then mints the synthetic asset (e.g., sUSD, sBTC) directly to the user's wallet.

Sub-step 1: Call mint(collateralAmount, synthAmount) on the protocol's minting contract.
Sub-step 2: The contract pulls the approved collateral from the user's wallet.
Sub-step 3: The contract verifies the user's collateralization ratio remains above the minimum (e.g., 150%).
Sub-step 4: Upon success, the synthetic token's totalSupply is increased and tokens are sent to the user.

solidity
// Example call to a mint function
ISynthMinter(minter).mint(collateralAmount, minSynthAmount);

Tip: Use a slippage parameter (minSynthAmount) to protect against price movements between transaction submission and confirmation.

Verify On-Chain State

Confirm the transaction succeeded and check the new debt position.

Detailed Instructions

After the transaction is confirmed, the user must verify the on-chain state changes. This involves checking the event logs for a successful Mint event and querying the contract for the user's updated debt balance and collateral locked. The protocol maintains a global debt ledger tracking each user's minted synthetic value.

Sub-step 1: Check the transaction receipt for a Transfer event from the null address (minting) to the user's address.
Sub-step 2: Query the synthetic token contract's balanceOf(userAddress).
Sub-step 3: Call the vault's collateral(address user) view function to confirm the deposit.
Sub-step 4: Call debtBalanceOf(userAddress, currencyKey) to see the user's issued debt.

solidity
// Example view calls to verify state
uint256 mySynthBalance = IERC20(synthAddress).balanceOf(msg.sender);
uint256 myCollateral = IVault(vaultAddress).collateral(msg.sender);

Tip: A healthy position maintains a collateralization ratio well above the liquidation threshold to avoid risk.

Monitor Oracle Prices and Health Factor

Track the value of collateral versus synthetic debt to maintain a safe position.

Detailed Instructions

Minting creates an open debt position. The user must monitor the price oracle feeds that determine the value of both the collateral and the synthetic asset. The protocol's health factor (Collateral Value / Debt Value) must stay above the liquidation ratio. If the collateral value falls or the synthetic debt value rises, the ratio decreases, risking liquidation.

Sub-step 1: Regularly query the protocol's oracle for the current price of your collateral (e.g., ETH/USD).
Sub-step 2: Query the price of the minted synthetic asset (often pegged to an asset like BTC).
Sub-step 3: Calculate the current collateralization ratio: (collateralAmount * collateralPrice) / (synthAmount * synthPrice).
Sub-step 4: Compare this ratio to the protocol's liquidationRatio (e.g., 150%).

javascript
// Pseudocode for checking health
const healthFactor = (collateralValueInUSD) / (debtValueInUSD);
const isSafe = healthFactor > LIQUIDATION_RATIO;

Tip: Consider setting up off-chain alerts for price movements that could bring your position near the liquidation threshold.

The On-Chain Burning and Redemption Process

Process overview

Initiate a Burn Request

User submits a transaction to destroy synthetic tokens and request underlying collateral.

Detailed Instructions

To initiate a burn, the user calls the burn or redeem function on the synthetic asset's smart contract, specifying the amount of synths to destroy. This transaction must be sent from an address holding a sufficient balance. The function typically requires the collateralization ratio to be met for the user's position before proceeding. The contract will lock the synthetic tokens and emit an event logging the burn request.

Sub-step 1: Connect your wallet to the protocol's front-end or interact directly with the contract.
Sub-step 2: Call the burn(uint256 amount) function, where amount is the quantity of synths in the smallest unit (e.g., wei).
Sub-step 3: Verify the transaction succeeds and a Burn event is emitted with your address and the amount.

solidity
// Example interaction with a synth contract
ISynth sUSD = ISynth(0x57Ab1ec28D129707052df4dF418D58a2D46d5f51);
sUSD.burn(1000000000000000000); // Burns 1 sUSD (18 decimals)

Tip: Always check the current protocol fee for burning, as it may be deducted from the returned collateral.

Verify Collateral Release Conditions

The protocol checks system health and user eligibility before releasing funds.

Detailed Instructions

Upon receiving the burn request, the protocol's core contract performs several on-chain checks. It first verifies the global system collateralization ratio is above the required minimum (e.g., 150%). It then ensures the user's debt from the debt ledger is accurately accounted for and that the synth supply can be safely reduced. A critical check is for any circuit breaker or trading suspension that would halt redemptions. The contract calculates the exact amount of underlying collateral (e.g., ETH, DAI) to return based on the current price from the oracle feed.

Sub-step 1: The contract queries the latest price from the designated oracle (e.g., Chainlink's latestAnswer()).
Sub-step 2: It calculates the user's share of the collateral pool using the debt ledger's inverse entry rate.
Sub-step 3: It confirms the calculated collateral withdrawal will not push the system below the liquidation ratio.

solidity
// Pseudocode for collateral calculation
uint256 collateralValue = synthAmount * oraclePrice;
uint256 userShare = (collateralValue * inverseDebtEntryRate) / PRECISION;
uint256 fee = (userShare * burnFeeRate) / PRECISION;
uint256 collateralToReturn = userShare - fee;

Tip: Redemptions may be delayed during periods of extreme volatility or oracle downtime.

Settle and Transfer Collateral

The protocol settles the debt and transfers the underlying asset to the user.

Detailed Instructions

After verification, the contract executes the settlement. It permanently destroys the synthetic tokens by reducing the total supply in the synth contract and updates the global debt ledger to reflect the removed debt. The corresponding amount of collateral is transferred from the protocol's collateral vault (e.g., CollateralManager contract) to the user's wallet. For multi-collateral systems, the contract determines the specific asset(s) to send based on the user's original collateral mix or a predefined redemption basket. A settlement event is emitted, providing a transparent record of the transaction.

Sub-step 1: The synth contract's _totalSupply state variable is decremented.
Sub-step 2: The debtLedger is appended with a new entry to adjust for the burned debt.
Sub-step 3: The transfer function is called on the collateral token contract (e.g., DAI.transfer(user, amount)).

solidity
// Example of state updates during settlement
_totalSupply = _totalSupply.sub(amount);
debtLedger.push(
    debtLedger[debtLedger.length - 1].multiplyDecimalRoundPrecise(inverseRate)
);
IERC20(collateral).safeTransfer(msg.sender, collateralToReturn);

Tip: The gas cost for this step varies significantly based on network congestion and the complexity of the collateral settlement logic.

Confirm Final State and Receipt

User verifies the transaction completion and updated balances.

Detailed Instructions

The user must confirm the transaction's success and the final state changes on-chain. This involves checking that the synthetic token balance in their wallet has decreased by the exact burned amount and that the expected quantity of collateral has been received. Users should verify the transaction receipt for relevant events like Burned and Transfer. It is also prudent to check the protocol's debt tracker or interface to confirm the user's debt position has been eliminated. For large redemptions, monitoring the protocol's health metrics post-transaction ensures systemic stability was maintained.

Sub-step 1: Query your wallet balance for the synthetic asset using balanceOf(yourAddress).
Sub-step 2: Query your wallet balance for the received collateral asset.
Sub-step 3: Decode the transaction logs to find the Burned(address indexed account, uint256 value) event.
Sub-step 4: Check the protocol's stats page to see the updated total synth supply and collateralization ratio.

javascript
// Using ethers.js to check balances and events post-transaction
const synthBalance = await synthContract.balanceOf(userAddress);
const collateralBalance = await daiContract.balanceOf(userAddress);
const receipt = await provider.getTransactionReceipt(txHash);
const eventFragment = synthContract.interface.getEvent('Burned');
const log = receipt.logs.find(l => l.topics[0] === eventFragment.topicHash);

Tip: Keep a record of the transaction hash and block number for auditing and dispute resolution.

Comparison of Minting Mechanisms Across Protocols

A technical comparison of collateralization, fees, and operational parameters for synthetic asset issuance.

Minting Parameter	Synthetix (sUSD)	MakerDAO (Dai)	Abracadabra (MIM)	Liquity (LUSD)
Primary Collateral Type	SNX (Staked)	ETH, wBTC, RWA	Interest-bearing tokens (yvUSDC, xSUSHI)	ETH only
Minimum Collateral Ratio (CR)	400%	110% (ETH), 150%+ (others)	Varies by cauldron (~110-200%)	110%
Minting Fee	0.3% exchange fee on synth trades	Stability Fee (variable, e.g., 3-8% APY)	Borrowing fee (0.5% typically)	0.5-5% variable borrowing fee + 200 LUSD min.
Mint/Burn Settlement	Chainlink oracles, instant on L2	Oracle delay (~1 hour for liquidation)	Instant, based on underlying vault value	Instant, via Trove management
Liquidation Mechanism	C-Ratio staking enforcement	Liquidator auctions (keeper network)	Liquidation via 'BentoBox' vaults	Stability Pool + Redemptions
Governance Token Role	SNX stakers earn fees & inflation	MKR holders vote on risk & fees	SPELL holders govern cauldron parameters	LQTY stakers earn fee revenue
Primary Use Case	Synthetic forex & commodities	Decentralized stablecoin for DeFi	Leveraged yield farming	Gas-efficient ETH-backed stablecoin

Protocol Mechanics by Audience

Understanding the Process

Synthetic assets are on-chain tokens that track the price of real-world assets like stocks or commodities, without holding the underlying asset. Minting creates them; burning destroys them to reclaim collateral.

How Minting Works

Collateral Deposit: You lock a crypto asset like ETH as collateral in a protocol like Synthetix. This is required to back the value of the synthetic you create.
Debt Issuance: The protocol issues you a synthetic token, such as sUSD (synthetic USD), and records a corresponding debt in the system. Your debt ratio is based on the total value of your collateral.
Price Feed Reliance: The value of your synthetic is maintained by decentralized oracles like Chainlink, which provide real-time price data to the smart contracts.

Example: Creating Synthetic USD

To mint 100 sUSD, you might need to deposit $150 worth of ETH as over-collateralization. The protocol's smart contract locks your ETH and mints the sUSD to your wallet. You can then trade this sUSD for other synthetic assets within the ecosystem.

Technical Implementation FAQ

The oracle price feed is a critical component for determining collateral value and minting limits. Most protocols use a decentralized network like Chainlink, which aggregates price data from multiple off-chain sources. The smart contract queries a specific price feed adapter, receiving a signed price and timestamp. This data is validated on-chain before use. For example, a synthetic USD (sUSD) contract might pull the ETH/USD price, which is updated every block and has a deviation threshold of 0.5%. The contract will reject stale data, typically older than 1 hour, to prevent manipulation.

Further Technical Resources

Synthetix Protocol Documentation

Details the on-chain minting and burning mechanics for synthetic assets using overcollateralized debt pools, SNX staking, and system-wide debt accounting.

Visit resource

MakerDAO Protocol Docs

Explains how DAI is minted and burned through collateralized debt positions, liquidation flows, and system parameters enforced by smart contracts.

Visit resource

UMA Protocol Documentation

Covers optimistic oracle-based synthetic asset design, token minting, redemption, and dispute resolution without continuous price feeds.

Visit resource

Chainlink Data Feeds Documentation

Describes decentralized price oracles frequently used to secure mint and burn logic for synthetic asset protocols.

Visit resource

Synthetix Smart Contracts Repository

Source code for the core contracts governing synthetic asset issuance, burning, collateralization ratios, and debt tracking.

Visit resource