feat: restore operator WIP — PMM JSON sync entrypoint, dotenv RPC trim + secrets, pool env alignment

- 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

test/bridge/trustless/EnhancedSwapRouter.t.sol

@@ -12,9 +12,58 @@ contract MockERC20 is ERC20 {
     }
 }
 
+contract MockLiquidityProvider {
+    mapping(address => mapping(address => bool)) public supported;
+    mapping(address => mapping(address => uint256)) public quotes;
+
+    function setSupport(address tokenIn, address tokenOut, bool isSupported) external {
+        supported[tokenIn][tokenOut] = isSupported;
+    }
+
+    function setQuote(address tokenIn, address tokenOut, uint256 amountOut) external {
+        quotes[tokenIn][tokenOut] = amountOut;
+    }
+
+    function getQuote(
+        address tokenIn,
+        address tokenOut,
+        uint256
+    ) external view returns (uint256 amountOut, uint256 slippageBps) {
+        if (!supported[tokenIn][tokenOut]) {
+            return (0, 10000);
+        }
+        return (quotes[tokenIn][tokenOut], 30);
+    }
+
+    function executeSwap(
+        address tokenIn,
+        address tokenOut,
+        uint256 amountIn,
+        uint256
+    ) external returns (uint256 amountOut) {
+        require(supported[tokenIn][tokenOut], "unsupported");
+        amountOut = quotes[tokenIn][tokenOut];
+        ERC20(tokenIn).transferFrom(msg.sender, address(this), amountIn);
+        ERC20(tokenOut).transfer(msg.sender, amountOut);
+    }
+
+    function supportsTokenPair(address tokenIn, address tokenOut) external view returns (bool) {
+        return supported[tokenIn][tokenOut];
+    }
+
+    function providerName() external pure returns (string memory) {
+        return "Mock";
+    }
+
+    function estimateGas(address, address, uint256) external pure returns (uint256) {
+        return 150000;
+    }
+}
+
 contract EnhancedSwapRouterTest is Test {
     EnhancedSwapRouter public router;
     LiquidityPoolETH public liquidityPool;
+    MockLiquidityProvider public liquidityProvider;
     
     MockERC20 public weth;
     MockERC20 public usdt;
@@ -39,6 +88,7 @@ contract EnhancedSwapRouterTest is Test {
         usdt = new MockERC20("Tether USD", "USDT");
         usdc = new MockERC20("USD Coin", "USDC");
         dai = new MockERC20("Dai Stablecoin", "DAI");
+        liquidityProvider = new MockLiquidityProvider();
 
         // Deploy liquidity pool
         liquidityPool = new LiquidityPoolETH(address(weth), 5, 11000);
@@ -133,8 +183,43 @@ contract EnhancedSwapRouterTest is Test {
     function testSwapTokenToTokenRevertsWhenPoolNotSet() public {
         vm.prank(user);
         weth.approve(address(router), 1 ether);
-        vm.expectRevert("EnhancedSwapRouter: Dodoex pool not configured");
+        vm.expectRevert(EnhancedSwapRouter.DodoRouteNotConfigured.selector);
+        router.swapTokenToToken(address(weth), address(usdt), 1 ether, 0);
+    }
+
+    function testSetDodoLiquidityProvider() public {
+        vm.prank(deployer);
+        router.setDodoLiquidityProvider(address(liquidityProvider));
+        assertEq(router.dodoLiquidityProvider(), address(liquidityProvider));
+    }
+
+    function testGetQuotesUsesDodoLiquidityProviderWhenRouteSupported() public {
+        vm.startPrank(deployer);
+        router.setDodoLiquidityProvider(address(liquidityProvider));
+        router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.UniswapV3, false);
+        router.setProviderEnabled(EnhancedSwapRouter.SwapProvider.Balancer, false);
+        vm.stopPrank();
+
+        liquidityProvider.setSupport(address(weth), address(usdt), true);
+        liquidityProvider.setQuote(address(weth), address(usdt), 1234);
+
+        (EnhancedSwapRouter.SwapProvider[] memory providers, uint256[] memory amounts) =
+            router.getQuotes(address(usdt), 1 ether);
+
+        assertEq(providers.length, 1);
+        assertEq(uint256(providers[0]), uint256(EnhancedSwapRouter.SwapProvider.Dodoex));
+        assertEq(amounts[0], 1234);
+    }
+
+    function testSwapTokenToTokenRevertsWhenProviderRouteMissing() public {
+        address mockPool = address(0xDD00);
+        vm.startPrank(deployer);
+        router.setDodoPoolAddress(address(weth), address(usdt), mockPool);
+        router.setDodoLiquidityProvider(address(liquidityProvider));
+        vm.stopPrank();
+
+        vm.prank(user);
+        vm.expectRevert(EnhancedSwapRouter.DodoRouteNotConfigured.selector);
         router.swapTokenToToken(address(weth), address(usdt), 1 ether, 0);
     }
 }
-

test/dex/DODOPMMIntegration.t.sol

@@ -11,6 +11,24 @@ contract MockERC20 is ERC20 {
     }
 }
 
+contract MockDodoPool {
+    address public immutable baseToken;
+    address public immutable quoteToken;
+
+    constructor(address baseToken_, address quoteToken_) {
+        baseToken = baseToken_;
+        quoteToken = quoteToken_;
+    }
+
+    function _BASE_TOKEN_() external view returns (address) {
+        return baseToken;
+    }
+
+    function _QUOTE_TOKEN_() external view returns (address) {
+        return quoteToken;
+    }
+}
+
 contract DODOPMMIntegrationTest is Test {
     DODOPMMIntegration public integration;
     address public dvm = address(0xdEaD);
@@ -90,4 +108,66 @@ contract DODOPMMIntegrationTest is Test {
             true
         );
     }
+
+    function testImportExistingPoolRecordsMappings() public {
+        address baseToken = address(officialUSDT);
+        address quoteToken = address(compliantUSDC);
+        MockDodoPool pool = new MockDodoPool(baseToken, quoteToken);
+
+        vm.prank(admin);
+        integration.importExistingPool(
+            address(pool),
+            baseToken,
+            quoteToken,
+            3,
+            1e18,
+            0.5e18,
+            false
+        );
+
+        assertEq(integration.pools(baseToken, quoteToken), address(pool));
+        assertEq(integration.pools(quoteToken, baseToken), address(pool));
+        assertTrue(integration.isRegisteredPool(address(pool)));
+
+        DODOPMMIntegration.PoolConfig memory config = integration.getPoolConfig(address(pool));
+        assertEq(config.baseToken, baseToken);
+        assertEq(config.quoteToken, quoteToken);
+    }
+
+    function testImportExistingPoolAcceptsReverseHintAndNormalizes() public {
+        address baseToken = address(officialUSDT);
+        address quoteToken = address(compliantUSDC);
+        MockDodoPool pool = new MockDodoPool(baseToken, quoteToken);
+
+        vm.prank(admin);
+        integration.importExistingPool(
+            address(pool),
+            quoteToken,
+            baseToken,
+            3,
+            1e18,
+            0.5e18,
+            false
+        );
+
+        DODOPMMIntegration.PoolConfig memory config = integration.getPoolConfig(address(pool));
+        assertEq(config.baseToken, baseToken);
+        assertEq(config.quoteToken, quoteToken);
+    }
+
+    function testImportExistingPoolRevertsOnMismatch() public {
+        MockDodoPool pool = new MockDodoPool(address(officialUSDT), address(compliantUSDC));
+
+        vm.prank(admin);
+        vm.expectRevert("DODOPMMIntegration: pool token mismatch");
+        integration.importExistingPool(
+            address(pool),
+            address(officialUSDT),
+            address(compliantUSDT),
+            3,
+            1e18,
+            0.5e18,
+            false
+        );
+    }
 }