Supported Assets

DSwap supports a diverse range of synthetic assets as virtual positions tracked in smart contracts, enabling efficient exposure to global markets without token deployment costs.

Virtual Asset System

No ERC20 Tokens

Unlike traditional synthetic protocols, DSwap uses virtual asset tracking:

Position Tracking: Balances stored in smart contract mappings
No Token Deployment: Eliminates gas costs and complexity
Instant Addition: New assets can be added immediately
Efficient Operations: Direct position updates without token transfers

Asset Position Structure

// Virtual asset positions
mapping(address => mapping(bytes32 => uint256)) public userPositions;

struct AssetInfo {
    bytes32 assetId;        // Unique asset identifier
    string name;            // Full asset name
    string symbol;          // Trading symbol
    bytes32 priceId;        // Oracle price feed ID
    uint256 totalValue;     // Total USD value of positions
    bool active;            // Trading enabled/disabled
}

Asset Categories

Equities (Primary Focus)

Major publicly traded companies:

Symbol

Name

Market

Price Feed

Market Hours

xAAPL

Apple Inc.

NASDAQ

AAPL/USD

9:30-16:00 EST

xTSLA

Tesla Inc.

NASDAQ

TSLA/USD

9:30-16:00 EST

xMSFT

Microsoft Corp.

NASDAQ

MSFT/USD

9:30-16:00 EST

xAMZN

Amazon.com Inc.

NASDAQ

AMZN/USD

9:30-16:00 EST

xGOOGL

Alphabet Inc.

NASDAQ

GOOGL/USD

9:30-16:00 EST

Commodities

Physical assets and futures contracts:

Symbol

Name

Contract

Price Feed

Trading Hours

xGOLD

Gold Futures

XAU/USD

24/7

xSILVER

Silver Futures

XAG/USD

24/7

xOIL

Crude Oil Futures

CL/USD

24/7

xCOPPER

Copper Futures

HG/USD

24/7

Indices

Market indices and benchmarks:

Symbol

Name

Components

Price Feed

Calculation

xSP500

S&P 500 Index

500 stocks

SPX/USD

Market cap weighted

xNASDAQ

NASDAQ Composite

Tech-heavy

IXIC/USD

Market cap weighted

xDOW

Dow Jones Industrial

30 blue chips

DJI/USD

Price weighted

Crypto Synthetics

Synthetic versions of major cryptocurrencies:

Symbol

Name

Price Feed

Availability

xBTC

Synthetic Bitcoin

BTC/USD

24/7

xETH

Synthetic Ethereum

ETH/USD

24/7

Asset Properties

Universal Features

All synthetic assets share common properties:

Oracle-based pricing: Real-time price feeds
Virtual positions: No token contracts required
Instant settlement: Immediate position updates
Cross-asset swapping: Universal compatibility
Settlement locks: 1-minute cooldown after operations

Asset Information Queries

function getAssetInfo(bytes32 assetId) external view returns (AssetInfo memory) {
    return assetInfos[assetId];
}

function getAllAssets() external view returns (bytes32[] memory) {
    return assetIds;
}

function getUserPosition(address user, bytes32 assetId) external view returns (uint256) {
    return userPositions[user][assetId];
}

Asset Addition Process

Instant Asset Deployment

New assets can be added without token deployment:

function addAsset(
    bytes32 assetId,
    string memory name,
    string memory symbol,
    bytes32 priceId
) external onlyRole(ADMIN_ROLE) {
    require(assetInfos[assetId].assetId == bytes32(0), "Asset exists");
    
    assetInfos[assetId] = AssetInfo({
        assetId: assetId,
        name: name,
        symbol: symbol,
        priceId: priceId,
        totalValue: 0,
        active: true
    });
    
    assetIds.push(assetId);
    
    emit AssetAdded(assetId, name, symbol, priceId);
}

Asset Lifecycle Management

// Add new asset (governance-controlled)
const addNewAsset = async (assetDetails) => {
  const proposal = {
    title: `Add ${assetDetails.name} Synthetic Asset`,
    description: `Add ${assetDetails.symbol} for trading`,
    targets: [DSWAP_ADDRESS],
    values: [0],
    calldatas: [
      dswap.interface.encodeFunctionData("addAsset", [
        keccak256(assetDetails.symbol),
        assetDetails.name,
        assetDetails.symbol,
        assetDetails.priceId
      ])
    ]
  }
  
  return await governance.propose(proposal)
}

Asset Queries and Analytics

Position Tracking

// Get user's synthetic asset positions
const getUserPositions = async (userAddress) => {
  const allAssets = await dswap.getAllAssets()
  const positions = []
  
  for (const assetId of allAssets) {
    const balance = await dswap.getUserPosition(userAddress, assetId)
    if (balance > 0) {
      const assetInfo = await dswap.getAssetInfo(assetId)
      const price = await oracle.getPrice(assetInfo.priceId)
      
      positions.push({
        assetId,
        symbol: assetInfo.symbol,
        balance: formatEther(balance),
        value: (Number(balance) * Number(price)) / 1e26, // Convert to USD
        price: Number(price) / 1e8
      })
    }
  }
  
  return positions
}

Asset Analytics

const getAssetAnalytics = async (assetId) => {
  const assetInfo = await dswap.getAssetInfo(assetId)
  const totalValue = assetInfo.totalValue
  const holders = await getAssetHolders(assetId)
  const volume = await getAssetVolume(assetId, '24h')
  
  return {
    symbol: assetInfo.symbol,
    totalValue: formatEther(totalValue),
    holders: holders.length,
    volume24h: formatEther(volume),
    marketShare: (Number(totalValue) / await getTotalSyntheticValue()) * 100
  }
}

Market Data Integration

Real-Time Price Feeds

const AssetPriceWidget = ({ assetId }) => {
  const { data: priceData } = useQuery(
    ['assetPrice', assetId],
    () => oracle.getPriceData(assetId),
    { refetchInterval: 30000 }
  )
  
  const price = priceData ? Number(priceData.price) / 1e8 : 0
  const change24h = calculatePriceChange(priceData, '24h')
  
  return (
    <div className="price-widget">
      <div className="current-price">${price.toFixed(2)}</div>
      <div className={`price-change ${change24h >= 0 ? 'positive' : 'negative'}`}>
        {change24h >= 0 ? '+' : ''}{change24h.toFixed(2)}%
      </div>
      <div className="last-update">
        Updated: {formatTime(priceData?.timestamp)}
      </div>
    </div>
  )
}

Market Hours Display

const MarketStatus = ({ assetId }) => {
  const { data: marketHours } = useQuery(
    ['marketHours', assetId],
    () => getMarketHours(assetId)
  )
  
  const isOpen = marketHours?.isOpen
  const nextEvent = isOpen ? marketHours.closeTime : marketHours.openTime
  
  return (
    <div className={`market-status ${isOpen ? 'open' : 'closed'}`}>
      <div className="status-indicator">
        {isOpen ? '🟢 Market Open' : '🔴 Market Closed'}
      </div>
      <div className="next-event">
        {isOpen ? 'Closes' : 'Opens'} at {formatTime(nextEvent)}
      </div>
    </div>
  )
}

Asset Risk Parameters

Risk Classification

const assetRiskProfiles = {
  equities: {
    volatility: 'medium-high',
    liquidity: 'high',
    marketHours: 'limited',
    oracleRisk: 'low'
  },
  commodities: {
    volatility: 'high',
    liquidity: 'medium',
    marketHours: '24/7',
    oracleRisk: 'medium'
  },
  indices: {
    volatility: 'medium',
    liquidity: 'high',
    marketHours: 'limited',
    oracleRisk: 'low'
  },
  crypto: {
    volatility: 'very-high',
    liquidity: 'high',
    marketHours: '24/7',
    oracleRisk: 'low'
  }
}

Dynamic Risk Adjustments

// Adjust parameters based on market conditions
function updateAssetRiskParameters(bytes32 assetId) external onlyKeeper {
    uint256 volatility = calculateVolatility(assetId);
    uint256 liquidity = assessLiquidity(assetId);
    
    if (volatility > HIGH_VOLATILITY_THRESHOLD) {
        // Increase fees during high volatility
        assetFeeMultipliers[assetId] = 150; // 1.5x
    }
    
    if (liquidity < LOW_LIQUIDITY_THRESHOLD) {
        // Reduce position limits for illiquid assets
        maxPositionSizes[assetId] = maxPositionSizes[assetId] * 50 / 100;
    }
}

Integration Examples

Asset Selection Interface

const AssetSelector = ({ onSelect, category }) => {
  const { data: assets } = useQuery(
    ['assets', category],
    () => getAssetsByCategory(category)
  )
  
  return (
    <div className="asset-grid">
      {assets?.map(asset => (
        <AssetCard
          key={asset.assetId}
          asset={asset}
          onClick={() => onSelect(asset)}
        />
      ))}
    </div>
  )
}

const AssetCard = ({ asset, onClick }) => {
  const { data: price } = useAssetPrice(asset.assetId)
  const { data: volume } = useAssetVolume(asset.assetId)
  
  return (
    <div className="asset-card" onClick={onClick}>
      <div className="asset-header">
        <span className="symbol">{asset.symbol}</span>
        <span className="price">${price?.toFixed(2)}</span>
      </div>
      <div className="asset-details">
        <div className="name">{asset.name}</div>
        <div className="volume">24h Volume: ${volume?.toLocaleString()}</div>
      </div>
    </div>
  )
}

Portfolio Overview

const SyntheticPortfolio = ({ userAddress }) => {
  const { data: positions } = useQuery(
    ['userPositions', userAddress],
    () => getUserPositions(userAddress)
  )
  
  const totalValue = positions?.reduce((sum, pos) => sum + pos.value, 0) || 0
  
  return (
    <div className="synthetic-portfolio">
      <div className="portfolio-header">
        <h3>Synthetic Assets Portfolio</h3>
        <div className="total-value">${totalValue.toLocaleString()}</div>
      </div>
      
      <div className="position-list">
        {positions?.map(position => (
          <div key={position.assetId} className="position-item">
            <div className="asset-info">
              <span className="symbol">{position.symbol}</span>
              <span className="balance">{position.balance}</span>
            </div>
            <div className="value-info">
              <span className="price">${position.price.toFixed(2)}</span>
              <span className="value">${position.value.toLocaleString()}</span>
            </div>
          </div>
        ))}
      </div>
    </div>
  )
}

Future Asset Expansion

Planned Additions

Assets under consideration for future deployment:

More Equities: xNVDA, xMETA, xNFLX, xDIS
International Equities: xNIKKEI, xFTSE, xDAX
Additional Commodities: xNATGAS, xCORN, xSOY
Crypto Indices: xDEFI, xNFT, xMEME
Forex Pairs: xEUR, xGBP, xJPY

Community Asset Proposals

// Propose new synthetic asset
const proposeNewAsset = async (assetDetails) => {
  const proposal = {
    title: `Add ${assetDetails.name} Synthetic Asset`,
    description: `
      Asset: ${assetDetails.name} (${assetDetails.symbol})
      Oracle: ${assetDetails.oracleProvider}
      Market Cap: $${assetDetails.marketCap.toLocaleString()}
      Liquidity: $${assetDetails.dailyVolume.toLocaleString()} daily
      Rationale: ${assetDetails.rationale}
    `,
    targets: [DSWAP_ADDRESS],
    values: [0],
    calldatas: [
      dswap.interface.encodeFunctionData("addAsset", [
        keccak256(assetDetails.symbol),
        assetDetails.name,
        assetDetails.symbol,
        assetDetails.priceId
      ])
    ]
  }
  
  return await governance.propose(proposal)
}

Asset Management

Activation/Deactivation

function setAssetStatus(bytes32 assetId, bool active) external onlyRole(ADMIN_ROLE) {
    require(assetInfos[assetId].assetId != bytes32(0), "Asset not found");
    assetInfos[assetId].active = active;
    
    emit AssetStatusUpdated(assetId, active);
}

Asset Metrics Tracking

const trackAssetMetrics = async (assetId) => {
  const metrics = {
    totalPositions: await getTotalPositions(assetId),
    uniqueHolders: await getUniqueHolders(assetId),
    averagePosition: await getAveragePositionSize(assetId),
    dailyVolume: await getDailyVolume(assetId),
    priceVolatility: await calculateVolatility(assetId, '30d')
  }
  
  return metrics
}

Oracle Integration

Price Feed Requirements

Each asset requires reliable oracle integration:

Primary Feed: Chainlink or Pyth price feed
Backup Feed: Secondary oracle for redundancy
Update Frequency: Minimum update frequency requirements
Deviation Limits: Maximum allowed price deviations

Oracle Configuration

struct OracleConfig {
    bytes32 primaryFeed;    // Primary oracle feed ID
    bytes32 backupFeed;     // Backup oracle feed ID
    uint256 maxAge;         // Maximum price age in seconds
    uint256 maxDeviation;   // Maximum price deviation (basis points)
    bool requiresBoth;      // Require both oracles to agree
}

mapping(bytes32 => OracleConfig) public oracleConfigs;

Asset Lifecycle

Addition Process

Community Proposal: Governance proposal for new asset
Technical Review: Oracle availability and reliability assessment
Risk Assessment: Volatility and liquidity analysis
Governance Vote: Community approval required
Oracle Integration: Price feed setup and testing
Activation: Asset becomes available for trading

Deprecation Process

Assets may be deprecated due to:

Oracle Issues: Unreliable or discontinued price feeds
Low Usage: Insufficient trading volume or interest
Regulatory Concerns: Legal or compliance issues
Technical Problems: Smart contract or integration issues

Asset Status Management

const manageAssetStatus = async (assetId, newStatus, reason) => {
  // Only governance can change asset status
  const proposal = {
    title: `${newStatus ? 'Activate' : 'Deactivate'} ${assetId}`,
    description: `Reason: ${reason}`,
    targets: [DSWAP_ADDRESS],
    values: [0],
    calldatas: [
      dswap.interface.encodeFunctionData("setAssetStatus", [assetId, newStatus])
    ]
  }
  
  return await governance.propose(proposal)
}

Integration Examples

Asset Discovery

const useAssetDiscovery = (searchTerm, category) => {
  return useQuery({
    queryKey: ['assetDiscovery', searchTerm, category],
    queryFn: async () => {
      const allAssets = await dswap.getAllAssets()
      const assetDetails = await Promise.all(
        allAssets.map(id => dswap.getAssetInfo(id))
      )
      
      return assetDetails
        .filter(asset => asset.active)
        .filter(asset => !category || getAssetCategory(asset) === category)
        .filter(asset => !searchTerm || 
          asset.name.toLowerCase().includes(searchTerm.toLowerCase()) ||
          asset.symbol.toLowerCase().includes(searchTerm.toLowerCase())
        )
    }
  })
}

Asset Performance Tracking

const AssetPerformanceTracker = ({ assetId, timeframe }) => {
  const { data: performance } = useQuery(
    ['assetPerformance', assetId, timeframe],
    () => getAssetPerformance(assetId, timeframe)
  )
  
  return (
    <div className="performance-tracker">
      <div className="performance-metrics">
        <div>Price Change: {performance?.priceChange?.toFixed(2)}%</div>
        <div>Volume: ${performance?.volume?.toLocaleString()}</div>
        <div>Volatility: {performance?.volatility?.toFixed(2)}%</div>
        <div>Holders: {performance?.holders}</div>
      </div>
      
      <div className="performance-chart">
        <PriceChart data={performance?.priceHistory} />
      </div>
    </div>
  )
}

Risk Considerations

Asset-Specific Risks

Equity Assets:

Market hours limitations
Earnings and news impact
Sector correlation risks
Regulatory changes

Commodity Assets:

High volatility
Supply/demand shocks
Geopolitical impacts
Storage and delivery complexities

Index Assets:

Component stock impacts
Rebalancing effects
Market-wide movements
Calculation methodology changes

Crypto Assets:

Extreme volatility
Regulatory uncertainty
Technical risks
Market manipulation

Risk Mitigation

Diversification: Spread exposure across asset categories
Position Limits: Respect maximum position sizes
Oracle Monitoring: Track price feed health and accuracy
Market Awareness: Understand asset-specific market dynamics

Future Developments

Planned Features

More Asset Categories: REITs, bonds, currencies
Enhanced Analytics: Advanced charting and analysis tools
Social Trading: Copy trading and strategy sharing
Mobile Optimization: Native mobile app integration

Community Involvement

Propose new assets through governance
Participate in asset risk assessments
Provide feedback on asset performance
Help educate users about different asset classes

PreviousAsset Swapping NextPricing Model

Last updated 1 month ago

Good evening

hashtagVirtual Asset System

hashtagNo ERC20 Tokens

hashtagAsset Position Structure

hashtagAsset Categories

hashtagEquities (Primary Focus)

hashtagCommodities

hashtagIndices

hashtagCrypto Synthetics

hashtagAsset Properties

hashtagUniversal Features

hashtagAsset Information Queries

hashtagAsset Addition Process

hashtagInstant Asset Deployment

hashtagAsset Lifecycle Management

hashtagAsset Queries and Analytics

hashtagPosition Tracking

hashtagAsset Analytics

hashtagMarket Data Integration

hashtagReal-Time Price Feeds

hashtagMarket Hours Display

hashtagAsset Risk Parameters

hashtagRisk Classification

hashtagDynamic Risk Adjustments

hashtagIntegration Examples

hashtagAsset Selection Interface

hashtagPortfolio Overview

hashtagFuture Asset Expansion

hashtagPlanned Additions

hashtagCommunity Asset Proposals

hashtagAsset Management

hashtagActivation/Deactivation

hashtagAsset Metrics Tracking

hashtagOracle Integration

hashtagPrice Feed Requirements

hashtagOracle Configuration

hashtagAsset Lifecycle

hashtagAddition Process

hashtagDeprecation Process

hashtagAsset Status Management

hashtagIntegration Examples

hashtagAsset Discovery

hashtagAsset Performance Tracking

hashtagRisk Considerations

hashtagAsset-Specific Risks

hashtagRisk Mitigation

hashtagFuture Developments

hashtagPlanned Features

hashtagCommunity Involvement

Virtual Asset System

No ERC20 Tokens

Asset Position Structure

Asset Categories

Equities (Primary Focus)

Commodities

Indices

Crypto Synthetics

Asset Properties

Universal Features

Asset Information Queries

Asset Addition Process

Instant Asset Deployment

Asset Lifecycle Management

Asset Queries and Analytics

Position Tracking

Asset Analytics

Market Data Integration

Real-Time Price Feeds

Market Hours Display

Asset Risk Parameters

Risk Classification

Dynamic Risk Adjustments

Integration Examples

Asset Selection Interface

Portfolio Overview

Future Asset Expansion

Planned Additions

Community Asset Proposals

Asset Management

Activation/Deactivation

Asset Metrics Tracking

Oracle Integration

Price Feed Requirements

Oracle Configuration

Asset Lifecycle

Addition Process

Deprecation Process

Asset Status Management

Integration Examples

Asset Discovery

Asset Performance Tracking

Risk Considerations

Asset-Specific Risks

Risk Mitigation

Future Developments

Planned Features

Community Involvement