2a4753eb2d
- Resolve stash: merge load_deployment_env path with secure-secrets and CR/LF RPC strip - create-pmm-full-mesh-chain138.sh delegates to sync-chain138-pmm-pools-from-json.sh - env.additions.example: canonical PMM pool defaults (cUSDT/USDT per crosscheck) - Include Chain138 scripts, official mirror deploy scaffolding, and prior staged changes Made-with: Cursor
260 lines
12 KiB
Solidity
260 lines
12 KiB
Solidity
// SPDX-License-Identifier: MIT
|
|
pragma solidity ^0.8.19;
|
|
|
|
import {Script, console} from "forge-std/Script.sol";
|
|
import "../../../contracts/bridge/trustless/EnhancedSwapRouter.sol";
|
|
|
|
/**
|
|
* @title DeployEnhancedSwapRouter
|
|
* @notice Deployment script for EnhancedSwapRouter with multi-protocol support
|
|
* @dev Deploys EnhancedSwapRouter with Uniswap V3, Curve, Dodoex, Balancer, and 1inch
|
|
*/
|
|
contract DeployEnhancedSwapRouter is Script {
|
|
address constant PLACEHOLDER = 0x000000000000000000000000000000000000dEaD;
|
|
|
|
// Ethereum Mainnet addresses
|
|
address constant UNISWAP_V3_ROUTER = 0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45;
|
|
address constant CURVE_3POOL = 0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7;
|
|
address constant DODOEX_ROUTER = 0xa356867fDCEa8e71AEaF87805808803806231FdC;
|
|
address constant BALANCER_VAULT = 0xBA12222222228d8Ba445958a75a0704d566BF2C8;
|
|
address constant ONEINCH_ROUTER = 0x1111111254EEB25477B68fb85Ed929f73A960582;
|
|
address constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
|
|
address constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
|
|
address constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
|
|
address constant DAI = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
|
|
|
|
// Chain 138 canonical token addresses
|
|
address constant CHAIN138_WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
|
|
address constant CHAIN138_USDT = 0x004b63A7B5b0E06f6bB6adb4a5F9f590BF3182D1;
|
|
address constant CHAIN138_USDC = 0x71D6687F38b93CCad569Fa6352c876eea967201b;
|
|
address constant CHAIN138_DAI_PLACEHOLDER = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
|
|
|
|
// Chain 138 live DODO pool map (2026-03-26)
|
|
address constant CHAIN138_cUSDT = 0x93E66202A11B1772E55407B32B44e5Cd8eda7f22;
|
|
address constant CHAIN138_cUSDC = 0xf22258f57794CC8E06237084b353Ab30fFfa640b;
|
|
address constant CHAIN138_cEURT = 0xdf4b71c61E5912712C1Bdd451416B9aC26949d72;
|
|
address constant CHAIN138_cXAUC = 0x290E52a8819A4fbD0714E517225429aA2B70EC6b;
|
|
address constant CHAIN138_POOL_CUSDTCUSDC = 0xff8d3b8fDF7B112759F076B69f4271D4209C0849;
|
|
address constant CHAIN138_POOL_CUSDTUSDT = 0x6fc60DEDc92a2047062294488539992710b99D71;
|
|
address constant CHAIN138_POOL_CUSDCUSDC = 0x0309178Ae30302D83C76d6DD402a684ef3160eeC;
|
|
address constant CHAIN138_POOL_CUSDT_XAU_PUBLIC = 0x1AA55E2001E5651349aFf5a63FD7a7ae44f0f1b0;
|
|
address constant CHAIN138_POOL_CUSDC_XAU_PUBLIC = 0xEa9AC6357CaCB42a83b9082B870610363b177CbA;
|
|
address constant CHAIN138_POOL_CEURT_XAU_PUBLIC = 0xba99bc1eAac164569d5aca96c806934dDaf970CF;
|
|
|
|
function run() external {
|
|
uint256 deployerPrivateKey = vm.envUint("PRIVATE_KEY");
|
|
address deployer = vm.addr(deployerPrivateKey);
|
|
uint256 chainId = block.chainid;
|
|
bool isMainnet = chainId == 1;
|
|
bool isChain138 = chainId == 138;
|
|
|
|
require(isMainnet || isChain138, "DeployEnhancedSwapRouter: supported chains are Ethereum Mainnet and Chain 138");
|
|
|
|
(
|
|
address uniswapV3Router,
|
|
address curve3Pool,
|
|
address dodoexRouter,
|
|
address balancerVault,
|
|
address oneInchRouter,
|
|
address weth,
|
|
address usdt,
|
|
address usdc,
|
|
address dai
|
|
) = _resolveAddresses(chainId);
|
|
|
|
console.log("=== EnhancedSwapRouter Deployment ===");
|
|
console.log("Deployer:", deployer);
|
|
console.log("Chain ID:", chainId);
|
|
if (isChain138) {
|
|
console.log("Mode: Chain 138 env-driven deployment");
|
|
console.log("Note: live DODO pools are stable/stable and stable/XAU.");
|
|
console.log("Note: WETH->stable routing remains optional until real WETH routes are configured.");
|
|
}
|
|
|
|
vm.startBroadcast(deployerPrivateKey);
|
|
|
|
console.log("\n--- Deploying EnhancedSwapRouter ---");
|
|
console.log("Uniswap V3 Router:", uniswapV3Router);
|
|
console.log("Curve 3Pool:", curve3Pool);
|
|
console.log("Dodoex Router:", dodoexRouter);
|
|
console.log("Balancer Vault:", balancerVault);
|
|
console.log("1inch Router:", oneInchRouter);
|
|
console.log("WETH:", weth);
|
|
console.log("USDT:", usdt);
|
|
console.log("USDC:", usdc);
|
|
console.log("DAI:", dai);
|
|
|
|
EnhancedSwapRouter router = new EnhancedSwapRouter(
|
|
uniswapV3Router,
|
|
curve3Pool,
|
|
dodoexRouter,
|
|
balancerVault,
|
|
oneInchRouter,
|
|
weth,
|
|
usdt,
|
|
usdc,
|
|
dai
|
|
);
|
|
|
|
console.log("\nEnhancedSwapRouter deployed at:", address(router));
|
|
|
|
// Grant ROUTING_MANAGER_ROLE to deployer so setRoutingConfig can be called
|
|
router.grantRole(router.ROUTING_MANAGER_ROLE(), deployer);
|
|
|
|
// Configure default routing
|
|
_configureDefaultRouting(router);
|
|
|
|
if (isChain138) {
|
|
_configureChain138InitialState(router, uniswapV3Router, curve3Pool, dodoexRouter, balancerVault, oneInchRouter);
|
|
}
|
|
|
|
vm.stopBroadcast();
|
|
|
|
console.log("\n=== Deployment Summary ===");
|
|
console.log("EnhancedSwapRouter:", address(router));
|
|
console.log("\n=== Export to .env ===");
|
|
console.log("export ENHANCED_SWAP_ROUTER=", vm.toString(address(router)));
|
|
if (isChain138) {
|
|
console.log("export ENHANCED_SWAP_ROUTER_CHAIN138=", vm.toString(address(router)));
|
|
console.log("export ENHANCED_SWAP_ROUTER_ADDRESS=", vm.toString(address(router)));
|
|
}
|
|
}
|
|
|
|
function _configureDefaultRouting(EnhancedSwapRouter router) internal {
|
|
console.log("\n--- Configuring Default Routing ---");
|
|
|
|
// Small swaps (< $10k): Uniswap V3, Dodoex
|
|
EnhancedSwapRouter.SwapProvider[] memory smallProviders = new EnhancedSwapRouter.SwapProvider[](2);
|
|
smallProviders[0] = EnhancedSwapRouter.SwapProvider.UniswapV3;
|
|
smallProviders[1] = EnhancedSwapRouter.SwapProvider.Dodoex;
|
|
router.setRoutingConfig(0, smallProviders);
|
|
console.log("Small swap routing configured");
|
|
|
|
// Medium swaps ($10k-$100k): Dodoex, Balancer, Uniswap V3
|
|
EnhancedSwapRouter.SwapProvider[] memory mediumProviders = new EnhancedSwapRouter.SwapProvider[](3);
|
|
mediumProviders[0] = EnhancedSwapRouter.SwapProvider.Dodoex;
|
|
mediumProviders[1] = EnhancedSwapRouter.SwapProvider.Balancer;
|
|
mediumProviders[2] = EnhancedSwapRouter.SwapProvider.UniswapV3;
|
|
router.setRoutingConfig(1, mediumProviders);
|
|
console.log("Medium swap routing configured");
|
|
|
|
// Large swaps (> $100k): Dodoex, Curve, Balancer
|
|
EnhancedSwapRouter.SwapProvider[] memory largeProviders = new EnhancedSwapRouter.SwapProvider[](3);
|
|
largeProviders[0] = EnhancedSwapRouter.SwapProvider.Dodoex;
|
|
largeProviders[1] = EnhancedSwapRouter.SwapProvider.Curve;
|
|
largeProviders[2] = EnhancedSwapRouter.SwapProvider.Balancer;
|
|
router.setRoutingConfig(2, largeProviders);
|
|
console.log("Large swap routing configured");
|
|
|
|
// Note: Balancer pool IDs need to be configured separately
|
|
// after identifying the actual pool addresses
|
|
console.log("\nWARNING: Remember to configure Balancer pool IDs after deployment");
|
|
}
|
|
|
|
function _configureChain138InitialState(
|
|
EnhancedSwapRouter router,
|
|
address uniswapV3Router,
|
|
address curve3Pool,
|
|
address dodoexRouter,
|
|
address balancerVault,
|
|
address oneInchRouter
|
|
) internal {
|
|
console.log("\n--- Chain 138 Initial Configuration ---");
|
|
address dodoPmmProvider = vm.envOr("DODO_PMM_PROVIDER_ADDRESS", address(0));
|
|
if (dodoPmmProvider == address(0)) {
|
|
dodoPmmProvider = vm.envOr("DODO_PMM_PROVIDER", address(0));
|
|
}
|
|
|
|
_registerPair(router, CHAIN138_cUSDT, CHAIN138_cUSDC, CHAIN138_POOL_CUSDTCUSDC);
|
|
_registerPair(router, CHAIN138_cUSDT, CHAIN138_USDT, CHAIN138_POOL_CUSDTUSDT);
|
|
_registerPair(router, CHAIN138_cUSDC, CHAIN138_USDC, CHAIN138_POOL_CUSDCUSDC);
|
|
_registerPair(router, CHAIN138_cUSDT, CHAIN138_cXAUC, CHAIN138_POOL_CUSDT_XAU_PUBLIC);
|
|
_registerPair(router, CHAIN138_cUSDC, CHAIN138_cXAUC, CHAIN138_POOL_CUSDC_XAU_PUBLIC);
|
|
_registerPair(router, CHAIN138_cEURT, CHAIN138_cXAUC, CHAIN138_POOL_CEURT_XAU_PUBLIC);
|
|
|
|
if (dodoPmmProvider != address(0)) {
|
|
router.setDodoLiquidityProvider(dodoPmmProvider);
|
|
console.log("Configured DODO PMM provider:", dodoPmmProvider);
|
|
}
|
|
|
|
// Disable providers that are definitely not usable until explicitly configured on Chain 138.
|
|
if (curve3Pool == PLACEHOLDER) {
|
|
router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.Curve, false);
|
|
console.log("Disabled Curve provider (placeholder address)");
|
|
}
|
|
if (balancerVault == PLACEHOLDER) {
|
|
router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.Balancer, false);
|
|
console.log("Disabled Balancer provider (placeholder address)");
|
|
}
|
|
if (oneInchRouter == PLACEHOLDER) {
|
|
router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.OneInch, false);
|
|
console.log("Disabled 1inch provider (placeholder address)");
|
|
}
|
|
if (uniswapV3Router == PLACEHOLDER) {
|
|
router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.UniswapV3, false);
|
|
console.log("Disabled Uniswap V3 provider (placeholder address)");
|
|
}
|
|
if (dodoexRouter == PLACEHOLDER && dodoPmmProvider == address(0)) {
|
|
router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.Dodoex, false);
|
|
console.log("Disabled Dodoex provider (no router and no PMM provider configured)");
|
|
} else {
|
|
console.log("Dodo pool mappings registered for current live Chain 138 pairs.");
|
|
}
|
|
|
|
console.log("WARNING: swapToStablecoin() still needs real WETH->stable routes to be useful on Chain 138.");
|
|
console.log("WARNING: current Chain 138 DODO initialization is primarily for token-to-token pair mappings via swapTokenToToken().");
|
|
}
|
|
|
|
function _registerPair(
|
|
EnhancedSwapRouter router,
|
|
address tokenA,
|
|
address tokenB,
|
|
address pool
|
|
) internal {
|
|
router.setDodoPoolAddress(tokenA, tokenB, pool);
|
|
router.setDodoPoolAddress(tokenB, tokenA, pool);
|
|
console.log("Registered DODO pool:", pool);
|
|
}
|
|
|
|
function _resolveAddresses(
|
|
uint256 chainId
|
|
)
|
|
internal
|
|
returns (
|
|
address uniswapV3Router,
|
|
address curve3Pool,
|
|
address dodoexRouter,
|
|
address balancerVault,
|
|
address oneInchRouter,
|
|
address weth,
|
|
address usdt,
|
|
address usdc,
|
|
address dai
|
|
)
|
|
{
|
|
if (chainId == 1) {
|
|
uniswapV3Router = vm.envOr("UNISWAP_V3_ROUTER", UNISWAP_V3_ROUTER);
|
|
curve3Pool = vm.envOr("CURVE_3POOL", CURVE_3POOL);
|
|
dodoexRouter = vm.envOr("DODOEX_ROUTER", DODOEX_ROUTER);
|
|
balancerVault = vm.envOr("BALANCER_VAULT", BALANCER_VAULT);
|
|
oneInchRouter = vm.envOr("ONEINCH_ROUTER", ONEINCH_ROUTER);
|
|
weth = vm.envOr("WETH", WETH);
|
|
usdt = vm.envOr("USDT", USDT);
|
|
usdc = vm.envOr("USDC", USDC);
|
|
dai = vm.envOr("DAI", DAI);
|
|
return (uniswapV3Router, curve3Pool, dodoexRouter, balancerVault, oneInchRouter, weth, usdt, usdc, dai);
|
|
}
|
|
|
|
// Chain 138: use canonical token defaults and env-driven protocol addresses.
|
|
uniswapV3Router = vm.envOr("UNISWAP_V3_ROUTER", PLACEHOLDER);
|
|
curve3Pool = vm.envOr("CURVE_3POOL", PLACEHOLDER);
|
|
dodoexRouter = vm.envOr("DODOEX_ROUTER", PLACEHOLDER);
|
|
balancerVault = vm.envOr("BALANCER_VAULT", PLACEHOLDER);
|
|
oneInchRouter = vm.envOr("ONEINCH_ROUTER", PLACEHOLDER);
|
|
weth = vm.envOr("WETH", CHAIN138_WETH);
|
|
usdt = vm.envOr("OFFICIAL_USDT_ADDRESS", CHAIN138_USDT);
|
|
usdc = vm.envOr("OFFICIAL_USDC_ADDRESS", CHAIN138_USDC);
|
|
dai = vm.envOr("DAI", CHAIN138_DAI_PLACEHOLDER);
|
|
}
|
|
}
|