diff --git a/sea.js b/sea.js
index 969bc43d..0a931a6a 100644
--- a/sea.js
+++ b/sea.js
@@ -64,11 +64,6 @@
           (_, i) => String.fromCharCode(this[ i + start])
         ).join('')
       }
-
-      function btoa(b) {
-        return new Buffer(b).toString('base64');
-    };
- 
       if (enc === 'base64') {
         return btoa(this)
       }
@@ -96,9 +91,6 @@
         }
         const input = arguments[0]
         let buf
-        function atob(a) {
-          return new Buffer(a, 'base64').toString('binary');
-      };
         if (typeof input === 'string') {
           const enc = arguments[1] || 'utf8'
           if (enc === 'hex') {
@@ -182,7 +174,7 @@
         random: (len) => Buffer.from(crypto.randomBytes(len))
       });
       //try{
-        const { Crypto: WebCrypto } = USE('@peculiar/webcrypto', 1);
+        const WebCrypto = USE('node-webcrypto-ossl', 1);
         api.ossl = api.subtle = new WebCrypto({directory: 'ossl'}).subtle // ECDH
       //}catch(e){
         //console.log("node-webcrypto-ossl is optionally needed for ECDH, please install if needed.");
@@ -312,6 +304,7 @@
 
     //SEA.pair = async (data, proof, cb) => { try {
     SEA.pair = SEA.pair || (async (cb, opt) => { try {
+
       var ecdhSubtle = shim.ossl || shim.subtle;
       // First: ECDSA keys for signing/verifying...
       var sa = await shim.subtle.generateKey(S.ecdsa.pair, true, [ 'sign', 'verify' ])
diff --git a/sea/array.js b/sea/array.js
index 91c9a931..fecdde5d 100644
--- a/sea/array.js
+++ b/sea/array.js
@@ -1,29 +1,24 @@
-// This is Array extended to have .toString(['utf8'|'hex'|'base64'])
-function SeaArray() {}
-Object.assign(SeaArray, { from: Array.from });
-SeaArray.prototype = Object.create(Array.prototype);
-SeaArray.prototype.toString = function(enc, start, end) {
-  enc = enc || "utf8";
-  start = start || 0;
-  const length = this.length;
-  if (enc === "hex") {
-    const buf = new Uint8Array(this);
-    return [...Array(((end && end + 1) || length) - start).keys()]
-      .map(i => buf[i + start].toString(16).padStart(2, "0"))
-      .join("");
-  }
-  if (enc === "utf8") {
-    return Array.from({ length: (end || length) - start }, (_, i) =>
-      String.fromCharCode(this[i + start])
-    ).join("");
-  }
 
-  function btoa(b) {
-    return new Buffer(b).toString("base64");
-  }
-
-  if (enc === "base64") {
-    return btoa(this);
-  }
-};
-module.exports = SeaArray;
+    // This is Array extended to have .toString(['utf8'|'hex'|'base64'])
+    function SeaArray() {}
+    Object.assign(SeaArray, { from: Array.from })
+    SeaArray.prototype = Object.create(Array.prototype)
+    SeaArray.prototype.toString = function(enc, start, end) { enc = enc || 'utf8'; start = start || 0;
+      const length = this.length
+      if (enc === 'hex') {
+        const buf = new Uint8Array(this)
+        return [ ...Array(((end && (end + 1)) || length) - start).keys()]
+        .map((i) => buf[ i + start ].toString(16).padStart(2, '0')).join('')
+      }
+      if (enc === 'utf8') {
+        return Array.from(
+          { length: (end || length) - start },
+          (_, i) => String.fromCharCode(this[ i + start])
+        ).join('')
+      }
+      if (enc === 'base64') {
+        return btoa(this)
+      }
+    }
+    module.exports = SeaArray;
+  
\ No newline at end of file
diff --git a/sea/buffer.js b/sea/buffer.js
index bcba634c..1854bd1c 100644
--- a/sea/buffer.js
+++ b/sea/buffer.js
@@ -1,95 +1,78 @@
-// This is Buffer implementation used in SEA. Functionality is mostly
-// compatible with NodeJS 'safe-buffer' and is used for encoding conversions
-// between binary and 'hex' | 'utf8' | 'base64'
-// See documentation and validation for safe implementation in:
-// https://github.com/feross/safe-buffer#update
-var SeaArray = require("./array");
-function SafeBuffer(...props) {
-  console.warn("new SafeBuffer() is depreciated, please use SafeBuffer.from()");
-  return SafeBuffer.from(...props);
-}
-SafeBuffer.prototype = Object.create(Array.prototype);
-Object.assign(SafeBuffer, {
-  // (data, enc) where typeof data === 'string' then enc === 'utf8'|'hex'|'base64'
-  from() {
-    if (!Object.keys(arguments).length) {
-      throw new TypeError(
-        "First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object."
-      );
-    }
-    const input = arguments[0];
-    let buf;
-    function atob(a) {
-      return new Buffer(a, "base64").toString("binary");
-    }
-    if (typeof input === "string") {
-      const enc = arguments[1] || "utf8";
-      if (enc === "hex") {
-        const bytes = input
-          .match(/([\da-fA-F]{2})/g)
-          .map(byte => parseInt(byte, 16));
-        if (!bytes || !bytes.length) {
-          throw new TypeError("Invalid first argument for type 'hex'.");
-        }
-        buf = SeaArray.from(bytes);
-      } else if (enc === "utf8") {
-        const length = input.length;
-        const words = new Uint16Array(length);
-        Array.from(
-          { length: length },
-          (_, i) => (words[i] = input.charCodeAt(i))
-        );
-        buf = SeaArray.from(words);
-      } else if (enc === "base64") {
-        const dec = atob(input);
-        const length = dec.length;
-        const bytes = new Uint8Array(length);
-        Array.from(
-          { length: length },
-          (_, i) => (bytes[i] = dec.charCodeAt(i))
-        );
-        buf = SeaArray.from(bytes);
-      } else if (enc === "binary") {
-        buf = SeaArray.from(input);
-      } else {
-        console.info("SafeBuffer.from unknown encoding: " + enc);
-      }
-      return buf;
-    }
-    const byteLength = input.byteLength; // what is going on here? FOR MARTTI
-    const length = input.byteLength ? input.byteLength : input.length;
-    if (length) {
-      let buf;
-      if (input instanceof ArrayBuffer) {
-        buf = new Uint8Array(input);
-      }
-      return SeaArray.from(buf || input);
-    }
-  },
-  // This is 'safe-buffer.alloc' sans encoding support
-  alloc(length, fill = 0 /*, enc*/) {
-    return SeaArray.from(
-      new Uint8Array(Array.from({ length: length }, () => fill))
-    );
-  },
-  // This is normal UNSAFE 'buffer.alloc' or 'new Buffer(length)' - don't use!
-  allocUnsafe(length) {
-    return SeaArray.from(new Uint8Array(Array.from({ length: length })));
-  },
-  // This puts together array of array like members
-  concat(arr) {
-    // octet array
-    if (!Array.isArray(arr)) {
-      throw new TypeError(
-        "First argument must be Array containing ArrayBuffer or Uint8Array instances."
-      );
-    }
-    return SeaArray.from(
-      arr.reduce((ret, item) => ret.concat(Array.from(item)), [])
-    );
-  }
-});
-SafeBuffer.prototype.from = SafeBuffer.from;
-SafeBuffer.prototype.toString = SeaArray.prototype.toString;
 
-module.exports = SafeBuffer;
+    // This is Buffer implementation used in SEA. Functionality is mostly
+    // compatible with NodeJS 'safe-buffer' and is used for encoding conversions
+    // between binary and 'hex' | 'utf8' | 'base64'
+    // See documentation and validation for safe implementation in:
+    // https://github.com/feross/safe-buffer#update
+    var SeaArray = require('./array');
+    function SafeBuffer(...props) {
+      console.warn('new SafeBuffer() is depreciated, please use SafeBuffer.from()')
+      return SafeBuffer.from(...props)
+    }
+    SafeBuffer.prototype = Object.create(Array.prototype)
+    Object.assign(SafeBuffer, {
+      // (data, enc) where typeof data === 'string' then enc === 'utf8'|'hex'|'base64'
+      from() {
+        if (!Object.keys(arguments).length) {
+          throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')
+        }
+        const input = arguments[0]
+        let buf
+        if (typeof input === 'string') {
+          const enc = arguments[1] || 'utf8'
+          if (enc === 'hex') {
+            const bytes = input.match(/([\da-fA-F]{2})/g)
+            .map((byte) => parseInt(byte, 16))
+            if (!bytes || !bytes.length) {
+              throw new TypeError('Invalid first argument for type \'hex\'.')
+            }
+            buf = SeaArray.from(bytes)
+          } else if (enc === 'utf8') {
+            const length = input.length
+            const words = new Uint16Array(length)
+            Array.from({ length: length }, (_, i) => words[i] = input.charCodeAt(i))
+            buf = SeaArray.from(words)
+          } else if (enc === 'base64') {
+            const dec = atob(input)
+            const length = dec.length
+            const bytes = new Uint8Array(length)
+            Array.from({ length: length }, (_, i) => bytes[i] = dec.charCodeAt(i))
+            buf = SeaArray.from(bytes)
+          } else if (enc === 'binary') {
+            buf = SeaArray.from(input)
+          } else {
+            console.info('SafeBuffer.from unknown encoding: '+enc)
+          }
+          return buf
+        }
+        const byteLength = input.byteLength // what is going on here? FOR MARTTI
+        const length = input.byteLength ? input.byteLength : input.length
+        if (length) {
+          let buf
+          if (input instanceof ArrayBuffer) {
+            buf = new Uint8Array(input)
+          }
+          return SeaArray.from(buf || input)
+        }
+      },
+      // This is 'safe-buffer.alloc' sans encoding support
+      alloc(length, fill = 0 /*, enc*/ ) {
+        return SeaArray.from(new Uint8Array(Array.from({ length: length }, () => fill)))
+      },
+      // This is normal UNSAFE 'buffer.alloc' or 'new Buffer(length)' - don't use!
+      allocUnsafe(length) {
+        return SeaArray.from(new Uint8Array(Array.from({ length : length })))
+      },
+      // This puts together array of array like members
+      concat(arr) { // octet array
+        if (!Array.isArray(arr)) {
+          throw new TypeError('First argument must be Array containing ArrayBuffer or Uint8Array instances.')
+        }
+        return SeaArray.from(arr.reduce((ret, item) => ret.concat(Array.from(item)), []))
+      }
+    })
+    SafeBuffer.prototype.from = SafeBuffer.from
+    SafeBuffer.prototype.toString = SeaArray.prototype.toString
+
+    module.exports = SafeBuffer;
+  
\ No newline at end of file
diff --git a/sea/shim.js b/sea/shim.js
index 930fef9e..b6026e8c 100644
--- a/sea/shim.js
+++ b/sea/shim.js
@@ -1,39 +1,36 @@
-const SEA = require("./root");
-const Buffer = require("./buffer");
-const api = { Buffer: Buffer };
-var o = {};
 
-if (SEA.window) {
-  api.crypto = window.crypto || window.msCrypto;
-  api.subtle = (api.crypto || o).subtle || (api.crypto || o).webkitSubtle;
-  api.TextEncoder = window.TextEncoder;
-  api.TextDecoder = window.TextDecoder;
-  api.random = len =>
-    Buffer.from(api.crypto.getRandomValues(new Uint8Array(Buffer.alloc(len))));
-}
-if (!api.crypto) {
-  try {
-    var crypto = require("crypto", 1);
-    const { TextEncoder, TextDecoder } = require("text-encoding", 1);
-    Object.assign(api, {
-      crypto,
-      //subtle,
-      TextEncoder,
-      TextDecoder,
-      random: len => Buffer.from(crypto.randomBytes(len))
-    });
-    //try{
-    const { Crypto: WebCrypto } = require("@peculiar/webcrypto", 1);
-    api.ossl = api.subtle = new WebCrypto({ directory: "ossl" }).subtle; // ECDH
-    //}catch(e){
-    //console.log("node-webcrypto-ossl is optionally needed for ECDH, please install if needed.");
-    //}
-  } catch (e) {
-    console.log(
-      "node-webcrypto-ossl and text-encoding may not be included by default, please add it to your package.json!"
-    );
-    OSSL_WEBCRYPTO_OR_TEXT_ENCODING_NOT_INSTALLED;
-  }
-}
+    const SEA = require('./root')
+    const Buffer = require('./buffer')
+    const api = {Buffer: Buffer}
+    var o = {};
 
-module.exports = api;
+    if(SEA.window){
+      api.crypto = window.crypto || window.msCrypto;
+      api.subtle = (api.crypto||o).subtle || (api.crypto||o).webkitSubtle;
+      api.TextEncoder = window.TextEncoder;
+      api.TextDecoder = window.TextDecoder;
+      api.random = (len) => Buffer.from(api.crypto.getRandomValues(new Uint8Array(Buffer.alloc(len))))
+    }
+    if(!api.crypto){try{
+      var crypto = require('crypto', 1);
+      const { TextEncoder, TextDecoder } = require('text-encoding', 1)
+      Object.assign(api, {
+        crypto,
+        //subtle,
+        TextEncoder,
+        TextDecoder,
+        random: (len) => Buffer.from(crypto.randomBytes(len))
+      });
+      //try{
+        const WebCrypto = require('node-webcrypto-ossl', 1);
+        api.ossl = api.subtle = new WebCrypto({directory: 'ossl'}).subtle // ECDH
+      //}catch(e){
+        //console.log("node-webcrypto-ossl is optionally needed for ECDH, please install if needed.");
+      //}
+    }catch(e){
+      console.log("node-webcrypto-ossl and text-encoding may not be included by default, please add it to your package.json!");
+      OSSL_WEBCRYPTO_OR_TEXT_ENCODING_NOT_INSTALLED;
+    }}
+
+    module.exports = api
+  
\ No newline at end of file