Deploying Wrappers

Learn how to deploy asset wrappers for integrating new asset types with Flux Protocol.

Deploying a Wrapper

For Standard ERC20 Tokens

Most ERC20 tokens can use the standard wrapper:

// Deploy ERC20 wrapper for USDT
IAssetFactory factory = IAssetFactory(ASSET_FACTORY_ADDRESS);

address usdtWrapper = factory.deployERC20Wrapper(
    USDT_ADDRESS,          // Underlying token
    ORACLE_ADDRESS,        // Price oracle
    "Wrapped USDT",        // Wrapper name
    "wUSDT"                // Wrapper symbol
);

For LP Tokens

Deploy LP wrapper for Uniswap V2/V3 positions:

// Deploy Uniswap V2 LP wrapper
address lpWrapper = factory.deployUniswapV2Wrapper(
    UNI_V2_PAIR_ADDRESS,  // LP token address
    ORACLE_REGISTRY,       // Oracle for pricing
    "Wrapped UNI-V2",
    "wUNI-V2"
);

For Yield-Bearing Tokens

Deploy wrappers for assets that accrue value:

// Deploy wrapper for Aave aTokens
address aTokenWrapper = factory.deployAaveWrapper(
    aUSDC_ADDRESS,         // aToken address
    ORACLE_ADDRESS,
    "Wrapped aUSDC",
    "waUSDC"
);

---

Wrapper Factory

The wrapper factory simplifies deployment:

interface IAssetFactory {
    function deployERC20Wrapper(
        address underlying,
        address oracle,
        string memory name,
        string memory symbol
    ) external returns (address wrapper);

    function deployUniswapV2Wrapper(...) external returns (address);
    function deployUniswapV3Wrapper(...) external returns (address);
    function deployAaveWrapper(...) external returns (address);
    function deployCompoundWrapper(...) external returns (address);
}

---

Verification

After deployment, verify the wrapper:

function verifyWrapper(address wrapper) public view {
    IAsset w = IAsset(wrapper);

    // 1. Check underlying
    address underlying = w.underlyingAsset();
    require(underlying != address(0), "Invalid underlying");

    // 2. Check oracle
    address oracle = w.oracle();
    require(oracle != address(0), "No oracle");

    // 3. Test deposit/withdraw
    // ... test with small amount
}

---

Adding to Strategy

After deploying, add wrapper to strategy's allowed assets:

// If using mutable strategy
IMutableStrategy(strategy).addAllowedAsset(wrapperAddress);

// Or deploy new strategy with wrapper included
IAsset[] memory allowedAssets = new IAsset[](3);
allowedAssets[0] = IAsset(EXISTING_WRAPPER_1);
allowedAssets[1] = IAsset(EXISTING_WRAPPER_2);
allowedAssets[2] = IAsset(NEW_WRAPPER);

address newStrategy = strategyFactory.createStrategy(
    allowedAssets,
    // ... other params
);

---

Best Practices

1. Verify oracle - Ensure reliable price feed

2. Test thoroughly - Test deposit/withdraw flows

3. Check decimals - Handle decimal conversions correctly

4. Audit custom wrappers - Get security review

5. Document clearly - Explain wrapper behavior

---

Example: Custom Wrapper

contract CustomAssetWrapper is IAsset {
    address public override underlyingAsset;
    address public oracle;

    function getValue(uint256 amount)
        external
        view
        override
        returns (uint256)
    {
        // Get price from oracle
        uint256 price = IOracle(oracle).getPrice(underlyingAsset);

        // Calculate value
        return amount * price / 1e18;
    }

    function deposit(uint256 amount)
        external
        override
        returns (uint256)
    {
        // Transfer underlying from user
        IERC20(underlyingAsset).transferFrom(msg.sender, address(this), amount);

        // Mint wrapper tokens
        _mint(msg.sender, amount);

        return amount;
    }

    function withdraw(uint256 amount)
        external
        override
        returns (uint256)
    {
        // Burn wrapper tokens
        _burn(msg.sender, amount);

        // Return underlying to user
        IERC20(underlyingAsset).transfer(msg.sender, amount);

        return amount;
    }
}

---

Related Documentation

• Custom Wrapper Development - Build custom wrappers

• Asset Wrappers Concept - Understanding wrappers

• Oracle Integration - Setting up oracles