diff --git a/Cargo.toml b/Cargo.toml
index 047dc2e..258dc34 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,8 +29,8 @@
 iovec    = "0.1.0"
 
 [target.'cfg(target_os = "fuchsia")'.dependencies]
-magenta = "0.1.0"
-magenta-sys = "0.1.0"
+magenta = "0.2.0"
+magenta-sys = "0.2.0"
 
 [target.'cfg(unix)'.dependencies]
 libc   = "0.2.19"
diff --git a/src/sys/fuchsia/eventedfd.rs b/src/sys/fuchsia/eventedfd.rs
index 33e5930..e337666 100644
--- a/src/sys/fuchsia/eventedfd.rs
+++ b/src/sys/fuchsia/eventedfd.rs
@@ -1,7 +1,7 @@
 use {io, poll, Evented, Ready, Poll, PollOpt, Token};
 use libc;
 use magenta;
-use magenta::HandleBase;
+use magenta::AsHandleRef;
 use sys::fuchsia::{DontDrop, poll_opts_to_wait_async, sys};
 use std::mem;
 use std::os::unix::io::RawFd;
@@ -56,10 +56,11 @@
                 let _res =
                     registration
                         .handle.inner_ref()
-                        .wait_async(port,
-                                    registration.token.0 as u64,
-                                    rereg_signals,
-                                    rereg_opts);
+                        .wait_async_handle(
+                            port,
+                            registration.token.0 as u64,
+                            rereg_signals,
+                            rereg_opts);
             }
         }
     }
diff --git a/src/sys/fuchsia/handles.rs b/src/sys/fuchsia/handles.rs
index fc70c15..ee24566 100644
--- a/src/sys/fuchsia/handles.rs
+++ b/src/sys/fuchsia/handles.rs
@@ -1,44 +1,36 @@
 use {io, poll, Evented, Ready, Poll, PollOpt, Token};
-use magenta::HandleBase;
+use magenta_sys::mx_handle_t;
 use std::sync::Mutex;
 
 /// Wrapper for registering a `HandleBase` type with mio.
 #[derive(Debug)]
-pub struct EventedHandle<T> where T: HandleBase {
+pub struct EventedHandle {
     /// The handle to be registered.
-    handle: T,
+    handle: mx_handle_t,
 
     /// The current `Token` with which the handle is registered with mio.
     token: Mutex<Option<Token>>,
 }
 
-impl<T> EventedHandle<T> where T: HandleBase {
+impl EventedHandle {
     /// Create a new `EventedHandle` which can be registered with mio
     /// in order to receive event notifications.
-    pub fn new(handle: T) -> Self {
+    ///
+    /// The underlying handle must not be 
+    pub unsafe fn new(handle: mx_handle_t) -> Self {
         EventedHandle {
             handle: handle,
             token: Mutex::new(None),
         }
     }
 
-    /// Get a reference to the underlying `HandleBase`.
-    pub fn get_ref(&self) -> &T {
-        &self.handle
-    }
-
-    /// Get a mutable reference to the underlying `HandleBase`.
-    pub fn get_mut(&mut self) -> &mut T {
-        &mut self.handle
-    }
-
-    /// Convert back into the inner `HandleBase`.
-    pub fn into_inner(self) -> T {
+    /// Get the underlying handle being registered.
+    pub fn get_handle(&self) -> mx_handle_t {
         self.handle
     }
 }
 
-impl<T> Evented for EventedHandle<T> where T: HandleBase {
+impl Evented for EventedHandle {
     fn register(&self,
                 poll: &Poll,
                 token: Token,
@@ -47,7 +39,7 @@
     {
         let mut this_token = self.token.lock().unwrap();
         {
-            poll::selector(poll).register_handle(&self.handle, token, interest, opts)?;
+            poll::selector(poll).register_handle(self.handle, token, interest, opts)?;
             *this_token = Some(token);
         }
         Ok(())
@@ -61,9 +53,9 @@
     {
         let mut this_token = self.token.lock().unwrap();
         {
-            poll::selector(poll).deregister_handle(&self.handle, token)?;
+            poll::selector(poll).deregister_handle(self.handle, token)?;
             *this_token = None;
-            poll::selector(poll).register_handle(&self.handle, token, interest, opts)?;
+            poll::selector(poll).register_handle(self.handle, token, interest, opts)?;
             *this_token = Some(token);
         }
         Ok(())
@@ -77,7 +69,7 @@
                 "Attempted to deregister an unregistered handle."))
         };
         {
-            poll::selector(poll).deregister_handle(&self.handle, token)?;
+            poll::selector(poll).deregister_handle(self.handle, token)?;
             *this_token = None;
         }
         Ok(())
diff --git a/src/sys/fuchsia/selector.rs b/src/sys/fuchsia/selector.rs
index d0a8707..293d576 100644
--- a/src/sys/fuchsia/selector.rs
+++ b/src/sys/fuchsia/selector.rs
@@ -9,7 +9,8 @@
     FuchsiaReady,
 };
 use magenta;
-use magenta::HandleBase;
+use magenta::AsHandleRef;
+use magenta_sys::mx_handle_t;
 use std::collections::hash_map;
 use std::fmt;
 use std::mem;
@@ -255,7 +256,7 @@
 
         let wait_async_opts = poll_opts_to_wait_async(poll_opts);
 
-        let wait_res = handle.wait_async(&self.port, token.0 as u64, signals, wait_async_opts)
+        let wait_res = handle.wait_async_handle(&self.port, token.0 as u64, signals, wait_async_opts)
             .map_err(status_to_io_err);
 
         if wait_res.is_err() {
@@ -280,31 +281,41 @@
             })
     }
 
-    pub fn register_handle<H>(&self,
-                              handle: &H,
-                              token: Token,
-                              interests: Ready,
-                              poll_opts: PollOpt) -> io::Result<()>
-        where H: magenta::HandleBase
+    pub fn register_handle(&self,
+                           handle: mx_handle_t,
+                           token: Token,
+                           interests: Ready,
+                           poll_opts: PollOpt) -> io::Result<()>
     {
         if poll_opts.is_level() && !poll_opts.is_oneshot() {
             return Err(io::Error::new(io::ErrorKind::InvalidInput,
                       "Repeated level-triggered events are not supported on Fuchsia handles."));
         }
 
-        handle.wait_async(&self.port,
-                          key_from_token_and_type(token, RegType::Handle)?,
-                          FuchsiaReady::from(interests).into_mx_signals(),
-                          poll_opts_to_wait_async(poll_opts))
-              .map_err(status_to_io_err)
+        let temp_handle = unsafe { magenta::Handle::from_raw(handle) };
+
+        let res = temp_handle.wait_async_handle(
+                    &self.port,
+                    key_from_token_and_type(token, RegType::Handle)?,
+                    FuchsiaReady::from(interests).into_mx_signals(),
+                    poll_opts_to_wait_async(poll_opts))
+              .map_err(status_to_io_err);
+
+        mem::forget(temp_handle);
+
+        res
     }
 
 
-    pub fn deregister_handle<H>(&self, handle: &H, token: Token) -> io::Result<()>
-        where H: magenta::HandleBase
+    pub fn deregister_handle(&self, handle: mx_handle_t, token: Token) -> io::Result<()>
     {
-        self.port.cancel(handle, key_from_token_and_type(token, RegType::Handle)?)
-                 .map_err(status_to_io_err)
+        let temp_handle = unsafe { magenta::Handle::from_raw(handle) };
+        let res = self.port.cancel(&temp_handle, key_from_token_and_type(token, RegType::Handle)?)
+                 .map_err(status_to_io_err);
+
+        mem::forget(temp_handle);
+
+        res
     }
 }
 
diff --git a/test/test_fuchsia_handles.rs b/test/test_fuchsia_handles.rs
index 26fd974..589471f 100644
--- a/test/test_fuchsia_handles.rs
+++ b/test/test_fuchsia_handles.rs
@@ -1,6 +1,6 @@
 use mio::*;
 use mio::fuchsia::EventedHandle;
-use magenta;
+use magenta::{self, AsHandleRef};
 use std::time::Duration;
 
 const MS: u64 = 1_000;
@@ -12,7 +12,7 @@
     let event_buffer = &mut event_buffer;
 
     let (channel0, channel1) = magenta::Channel::create(magenta::ChannelOpts::Normal).unwrap();
-    let channel1_evented = EventedHandle::new(channel1);
+    let channel1_evented = unsafe { EventedHandle::new(channel1.raw_handle()) };
 
     poll.register(&channel1_evented, Token(1), Ready::readable(), PollOpt::edge()).unwrap();