diff --git a/eth2/utils/hashing/.cargo/config b/eth2/utils/hashing/.cargo/config
new file mode 100644
index 000000000..4ec2f3b86
--- /dev/null
+++ b/eth2/utils/hashing/.cargo/config
@@ -0,0 +1,2 @@
+[target.wasm32-unknown-unknown]
+runner = 'wasm-bindgen-test-runner'
diff --git a/eth2/utils/hashing/Cargo.toml b/eth2/utils/hashing/Cargo.toml
index 78dd70e43..506b84a6b 100644
--- a/eth2/utils/hashing/Cargo.toml
+++ b/eth2/utils/hashing/Cargo.toml
@@ -4,5 +4,14 @@ version = "0.1.0"
 authors = ["Paul Hauner <paul@paulhauner.com>"]
 edition = "2018"
 
-[dependencies]
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 ring = "0.14.6"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+sha2 = "0.8.0"
+
+[dev-dependencies]
+rustc-hex = "2.0.1"
+
+[target.'cfg(target_arch = "wasm32")'.dev-dependencies]
+wasm-bindgen-test = "0.2.47"
diff --git a/eth2/utils/hashing/src/lib.rs b/eth2/utils/hashing/src/lib.rs
index a9e286c39..7214c7421 100644
--- a/eth2/utils/hashing/src/lib.rs
+++ b/eth2/utils/hashing/src/lib.rs
@@ -1,7 +1,17 @@
+#[cfg(not(target_arch = "wasm32"))]
 use ring::digest::{digest, SHA256};
 
+#[cfg(target_arch = "wasm32")]
+use sha2::{Digest, Sha256};
+
 pub fn hash(input: &[u8]) -> Vec<u8> {
-    digest(&SHA256, input).as_ref().into()
+    #[cfg(not(target_arch = "wasm32"))]
+    let h = digest(&SHA256, input).as_ref().into();
+
+    #[cfg(target_arch = "wasm32")]
+    let h = Sha256::digest(input).as_ref().into();
+
+    h
 }
 
 /// Get merkle root of some hashed values - the input leaf nodes is expected to already be hashed
@@ -37,19 +47,24 @@ pub fn merkle_root(values: &[Vec<u8>]) -> Option<Vec<u8>> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ring::test;
+    use rustc_hex::FromHex;
 
-    #[test]
+    #[cfg(target_arch = "wasm32")]
+    use wasm_bindgen_test::*;
+
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_hashing() {
         let input: Vec<u8> = b"hello world".as_ref().into();
 
         let output = hash(input.as_ref());
         let expected_hex = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
-        let expected: Vec<u8> = test::from_hex(expected_hex).unwrap();
+        let expected: Vec<u8> = expected_hex.from_hex().unwrap();
         assert_eq!(expected, output);
     }
 
-    #[test]
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_merkle_root() {
         // hash the leaf nodes
         let mut input = vec![
@@ -79,13 +94,17 @@ mod tests {
 
         assert_eq!(&expected[..], output.unwrap().as_slice());
     }
-    #[test]
+
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_empty_input_merkle_root() {
         let input = vec![];
         let output = merkle_root(&input[..]);
         assert_eq!(None, output);
     }
-    #[test]
+
+    #[cfg_attr(not(target_arch = "wasm32"), test)]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn test_odd_leaf_merkle_root() {
         let input = vec![
             hash("a".as_bytes()),
diff --git a/eth2/utils/ssz/src/decode/impls.rs b/eth2/utils/ssz/src/decode/impls.rs
index 0965ee3e5..75dd5d444 100644
--- a/eth2/utils/ssz/src/decode/impls.rs
+++ b/eth2/utils/ssz/src/decode/impls.rs
@@ -34,6 +34,11 @@ impl_decodable_for_uint!(u8, 8);
 impl_decodable_for_uint!(u16, 16);
 impl_decodable_for_uint!(u32, 32);
 impl_decodable_for_uint!(u64, 64);
+
+#[cfg(target_pointer_width = "32")]
+impl_decodable_for_uint!(usize, 32);
+
+#[cfg(target_pointer_width = "64")]
 impl_decodable_for_uint!(usize, 64);
 
 impl Decode for bool {
diff --git a/eth2/utils/ssz/src/encode/impls.rs b/eth2/utils/ssz/src/encode/impls.rs
index 04492a1f2..e0e2d9dbc 100644
--- a/eth2/utils/ssz/src/encode/impls.rs
+++ b/eth2/utils/ssz/src/encode/impls.rs
@@ -24,6 +24,11 @@ impl_encodable_for_uint!(u8, 8);
 impl_encodable_for_uint!(u16, 16);
 impl_encodable_for_uint!(u32, 32);
 impl_encodable_for_uint!(u64, 64);
+
+#[cfg(target_pointer_width = "32")]
+impl_encodable_for_uint!(usize, 32);
+
+#[cfg(target_pointer_width = "64")]
 impl_encodable_for_uint!(usize, 64);
 
 /// The SSZ "union" type.
diff --git a/eth2/utils/ssz/src/lib.rs b/eth2/utils/ssz/src/lib.rs
index fceebcc44..51dd16523 100644
--- a/eth2/utils/ssz/src/lib.rs
+++ b/eth2/utils/ssz/src/lib.rs
@@ -46,7 +46,10 @@ pub use encode::{Encode, SszEncoder};
 /// The number of bytes used to represent an offset.
 pub const BYTES_PER_LENGTH_OFFSET: usize = 4;
 /// The maximum value that can be represented using `BYTES_PER_LENGTH_OFFSET`.
-pub const MAX_LENGTH_VALUE: usize = (1 << (BYTES_PER_LENGTH_OFFSET * 8)) - 1;
+#[cfg(target_pointer_width = "32")]
+pub const MAX_LENGTH_VALUE: usize = (std::u32::MAX >> 8 * (4 - BYTES_PER_LENGTH_OFFSET)) as usize;
+#[cfg(target_pointer_width = "64")]
+pub const MAX_LENGTH_VALUE: usize = (std::u64::MAX >> 8 * (8 - BYTES_PER_LENGTH_OFFSET)) as usize;
 
 /// Convenience function to SSZ encode an object supporting ssz::Encode.
 ///