diff --git a/test/fixtures/wpt/README.md b/test/fixtures/wpt/README.md
index a4ca98dc7ffa4f..a33692a1ca544c 100644
--- a/test/fixtures/wpt/README.md
+++ b/test/fixtures/wpt/README.md
@@ -32,7 +32,7 @@ Last update:
 - user-timing: https://github.com/web-platform-tests/wpt/tree/5ae85bf826/user-timing
 - wasm/jsapi: https://github.com/web-platform-tests/wpt/tree/cde25e7e3c/wasm/jsapi
 - wasm/webapi: https://github.com/web-platform-tests/wpt/tree/fd1b23eeaa/wasm/webapi
-- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/5e042cbc4e/WebCryptoAPI
+- WebCryptoAPI: https://github.com/web-platform-tests/wpt/tree/6e54abcb8b/WebCryptoAPI
 - webidl/ecmascript-binding/es-exceptions: https://github.com/web-platform-tests/wpt/tree/a370aad338/webidl/ecmascript-binding/es-exceptions
 - webmessaging/broadcastchannel: https://github.com/web-platform-tests/wpt/tree/e97fac4791/webmessaging/broadcastchannel
 
diff --git a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js
index ef6905e574c158..422a230bd16675 100644
--- a/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js
+++ b/test/fixtures/wpt/WebCryptoAPI/derive_bits_keys/cfrg_curves_bits.js
@@ -6,8 +6,6 @@ function define_tests() {
   // Verify the derive functions perform checks against the all-zero value results,
   // ensuring small-order points are rejected.
   // https://www.rfc-editor.org/rfc/rfc7748#section-6.1
-  // TODO: The spec states that the check must be done on use, but there is discussion about doing it on import.
-  // https://github.com/WICG/webcrypto-secure-curves/pull/13
   Object.keys(kSmallOrderPoint).forEach(function(algorithmName) {
       kSmallOrderPoint[algorithmName].forEach(function(test) {
           promise_test(async() => {
@@ -23,8 +21,8 @@ function define_tests() {
                                                  false, [])
                   derived = await subtle.deriveBits({name: algorithmName, public: publicKey}, privateKey, 8 * sizes[algorithmName]);
               } catch (err) {
-                  assert_false(privateKey === undefined, "Private key should be valid.");
-                  assert_false(publicKey === undefined, "Public key should be valid.");
+                  assert_true(privateKey !== undefined, "Private key should be valid.");
+                  assert_true(publicKey !== undefined, "Public key should be valid.");
                   assert_equals(err.name, "OperationError", "Should throw correct error, not " + err.name + ": " + err.message + ".");
               }
               assert_equals(derived, undefined, "Operation succeeded, but should not have.");
diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js
index d77a8808831176..4952df502d83ce 100644
--- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js
+++ b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa.js
@@ -1,363 +1,214 @@
 
 function run_test() {
-  setup({explicit_done: true});
-
   var subtle = self.crypto.subtle; // Change to test prefixed implementations
 
-  // When are all these tests really done? When all the promises they use have resolved.
-  var all_promises = [];
-
   // Source file [algorithm_name]_vectors.js provides the getTestVectors method
   // for the algorithm that drives these tests.
   var testVectors = getTestVectors();
 
-  // Test verification first, because signing tests rely on that working
   testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
-              var operation = subtle.verify(algorithm, vector.publicKey, vector.signature, vector.data)
-              .then(function(is_verified) {
-                  assert_true(is_verified, "Signature verified");
-              }, function(err) {
-                  assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
-              });
-
-              return operation;
-          }, vector.name + " verification");
-
-      }, function(err) {
-          // We need a failed test if the importVectorKey operation fails, so
-          // we know we never tested verification.
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " verification");
-      });
-
-      all_promises.push(promise);
-  });
+      var algorithm = {name: vector.algorithmName};
 
-  // Test verification with an altered buffer after call
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
+      // Test verification first, because signing tests rely on that working
+      promise_test(async() => {
+          let isVerified = false;
+          let key;
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
+              isVerified = await subtle.verify(algorithm, key, vector.signature, vector.data)
+          } catch (err) {
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
+          };
+          assert_true(isVerified, "Signature verified");
+      }, vector.name + " verification");
+
+      // Test verification with an altered buffer after call
+      promise_test(async() => {
+          let isVerified = false;
+          let key;
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
               var signature = copyBuffer(vector.signature);
-              var operation = subtle.verify(algorithm, vector.publicKey, signature, vector.data)
-              .then(function(is_verified) {
-                  assert_true(is_verified, "Signature verified");
-              }, function(err) {
-                  assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
-              });
-
-              signature[0] = 255 - signature[0];
-              return operation;
-          }, vector.name + " verification with altered signature after call");
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " verification with altered signature after call");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Check for successful verification even if data is altered after call.
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
+              [isVerified] = await Promise.all([
+                  subtle.verify(algorithm, key, signature, vector.data),
+                  signature[0] = 255 - signature[0]
+              ]);
+          } catch (err) {
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
+          };
+          assert_true(isVerified, "Signature verified");
+      }, vector.name + " verification with altered signature after call");
+
+      // Check for successful verification even if data is altered after call.
+      promise_test(async() => {
+          let isVerified = false;
+          let key;
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
               var data = copyBuffer(vector.data);
-              var operation = subtle.verify(algorithm, vector.publicKey, vector.signature, data)
-              .then(function(is_verified) {
-                  assert_true(is_verified, "Signature verified");
-              }, function(err) {
-                  assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
-              });
-
-              data[0] = 255 - data[0];
-              return operation;
-          }, vector.name + " with altered data after call");
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " with altered data after call");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Check for failures due to using privateKey to verify.
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
-              return subtle.verify(algorithm, vector.privateKey, vector.signature, vector.data)
-              .then(function(data) {
-                  assert_unreached("Should have thrown error for using privateKey to verify in " + vector.name + ": " + err.message + "'");
-              }, function(err) {
-                  assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'");
-              });
-          }, vector.name + " using privateKey to verify");
-
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " using privateKey to verify");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Check for failures due to using publicKey to sign.
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
-              return subtle.sign(algorithm, vector.publicKey, vector.data)
-              .then(function(signature) {
-                  assert_unreached("Should have thrown error for using publicKey to sign in " + vector.name + ": " + err.message + "'");
-              }, function(err) {
-                  assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'");
-              });
-          }, vector.name + " using publicKey to sign");
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " using publicKey to sign");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Check for failures due to no "verify" usage.
-  testVectors.forEach(function(originalVector) {
-      var vector = Object.assign({}, originalVector);
-
-      var promise = importVectorKeys(vector, [], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
-              return subtle.verify(algorithm, vector.publicKey, vector.signature, vector.data)
-              .then(function(data) {
-                  assert_unreached("Should have thrown error for no verify usage in " + vector.name + ": " + err.message + "'");
-              }, function(err) {
-                  assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'");
-              });
-          }, vector.name + " no verify usage");
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " no verify usage");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Check for successful signing and verification.
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
-          promise_test(function(test) {
-              return subtle.sign(algorithm, vector.privateKey, vector.data)
-              .then(function(signature) {
-                  assert_true(equalBuffers(signature, vector.signature), "Signing did not give the expected output");
-                  // Can we verify the signature?
-                  return subtle.verify(algorithm, vector.publicKey, signature, vector.data)
-                  .then(function(is_verified) {
-                      assert_true(is_verified, "Round trip verification works");
-                      return signature;
-                  }, function(err) {
-                      assert_unreached("verify error for test " + vector.name + ": " + err.message + "'");
-                  });
-              }, function(err) {
-                  assert_unreached("sign error for test " + vector.name + ": '" + err.message + "'");
-              });
-          }, vector.name + " round trip");
-
-      }, function(err) {
-          // We need a failed test if the importVectorKey operation fails, so
-          // we know we never tested signing or verifying
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " round trip");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Test signing with the wrong algorithm
-  testVectors.forEach(function(vector) {
-      // Want to get the key for the wrong algorithm
-      var promise = subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"])
-      .then(function(wrongKey) {
-          var algorithm = {name: vector.algorithmName};
-          return importVectorKeys(vector, ["verify"], ["sign"])
-          .then(function(vectors) {
-              promise_test(function(test) {
-                  var operation = subtle.sign(algorithm, wrongKey, vector.data)
-                  .then(function(signature) {
-                      assert_unreached("Signing should not have succeeded for " + vector.name);
-                  }, function(err) {
-                      assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'");
-                  });
-
-                  return operation;
-              }, vector.name + " signing with wrong algorithm name");
-
-          }, function(err) {
-              // We need a failed test if the importVectorKey operation fails, so
-              // we know we never tested verification.
-              promise_test(function(test) {
-                  assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-              }, "importVectorKeys step: " + vector.name + " signing with wrong algorithm name");
-          });
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("Generate wrong key for test " + vector.name + " failed: '" + err.message + "'");
-          }, "generate wrong key step: " + vector.name + " signing with wrong algorithm name");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Test verification with the wrong algorithm
-  testVectors.forEach(function(vector) {
-      // Want to get the key for the wrong algorithm
-      var promise = subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"])
-      .then(function(wrongKey) {
-          return importVectorKeys(vector, ["verify"], ["sign"])
-          .then(function(vectors) {
-              var algorithm = {name: vector.algorithmName};
-              promise_test(function(test) {
-                  var operation = subtle.verify(algorithm, wrongKey, vector.signature, vector.data)
-                  .then(function(signature) {
-                      assert_unreached("Verifying should not have succeeded for " + vector.name);
-                  }, function(err) {
-                      assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'");
-                  });
-
-                  return operation;
-              }, vector.name + " verifying with wrong algorithm name");
-
-          }, function(err) {
-              // We need a failed test if the importVectorKey operation fails, so
-              // we know we never tested verification.
-              promise_test(function(test) {
-                  assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-              }, "importVectorKeys step: " + vector.name + " verifying with wrong algorithm name");
-          });
-      }, function(err) {
-          promise_test(function(test) {
-              assert_unreached("Generate wrong key for test " + vector.name + " failed: '" + err.message + "'");
-          }, "generate wrong key step: " + vector.name + " verifying with wrong algorithm name");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Test verification fails with wrong signature
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
+              [isVerified] = await Promise.all([
+                  subtle.verify(algorithm, key, vector.signature, data),
+                  data[0] = 255 - data[0]
+              ]);
+          } catch (err) {
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
+          };
+          assert_true(isVerified, "Signature verified");
+      }, vector.name + " with altered data after call");
+
+      // Check for failures due to using privateKey to verify.
+      promise_test(async() => {
+          let isVerified = false;
+          let key;
+          try {
+              key = await subtle.importKey("pkcs8", vector.privateKeyBuffer, algorithm, false, ["sign"]);
+              isVerified = await subtle.verify(algorithm, key, vector.signature, vector.data)
+              assert_unreached("Should have thrown error for using privateKey to verify in " + vector.name);
+          } catch (err) {
+              if (err instanceof AssertionError)
+                  throw err;
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'");
+          };
+          assert_false(isVerified, "Signature verified");
+      }, vector.name + " using privateKey to verify");
+
+      // Check for failures due to using publicKey to sign.
+      promise_test(async() => {
+          let isVerified = false;
+          let key;
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
+              let signature = await subtle.sign(algorithm, key, vector.data);
+              assert_unreached("Should have thrown error for using publicKey to sign in " + vector.name);
+          } catch (err) {
+              if (err instanceof AssertionError)
+                  throw err;
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'");
+          };
+      }, vector.name + " using publicKey to sign");
+
+      // Check for failures due to no "verify" usage.
+      promise_test(async() => {
+          let isVerified = false;
+          let key;
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, []);
+              isVerified = await subtle.verify(algorithm, key, vector.signature, vector.data)
+              assert_unreached("Should have thrown error for no verify usage in " + vector.name);
+          } catch (err) {
+              if (err instanceof AssertionError)
+                  throw err;
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_equals(err.name, "InvalidAccessError", "Should throw InvalidAccessError instead of '" + err.message + "'");
+          };
+          assert_false(isVerified, "Signature verified");
+      }, vector.name + " no verify usage");
+
+      // Check for successful signing and verification.
+      var algorithm = {name: vector.algorithmName};
+      promise_test(async() => {
+          let isVerified = false;
+          let privateKey, publicKey;
+          let signature;
+          try {
+              privateKey = await subtle.importKey("pkcs8", vector.privateKeyBuffer, algorithm, false, ["sign"]);
+              publicKey = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
+              signature = await subtle.sign(algorithm, privateKey, vector.data);
+              isVerified = await subtle.verify(algorithm, publicKey, vector.signature, vector.data)
+          } catch (err) {
+              assert_false(publicKey === undefined || privateKey === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_false(signature === undefined, "sign error for test " + vector.name + ": '" + err.message + "'");
+              assert_unreached("verify error for test " + vector.name + ": " + err.message + "'");
+          };
+          assert_true(isVerified, "Round trip verification works");
+      }, vector.name + " round trip");
+
+      // Test signing with the wrong algorithm
+      var algorithm = {name: vector.algorithmName};
+      promise_test(async() => {
+          let wrongKey;
+          try {
+              wrongKey = await subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"])
+              let signature = await subtle.sign(algorithm, wrongKey, vector.data);
+              assert_unreached("Signing should not have succeeded for " + vector.name);
+          } catch (err) {
+              if (err instanceof AssertionError)
+                  throw err;
+              assert_false(wrongKey === undefined, "Generate wrong key for test " + vector.name + " failed: '" + err.message + "'");
+              assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'");
+          };
+      }, vector.name + " signing with wrong algorithm name");
+
+      // Test verification with the wrong algorithm
+      var algorithm = {name: vector.algorithmName};
+      promise_test(async() => {
+          let wrongKey;
+          try {
+              wrongKey = await subtle.generateKey({name: "HMAC", hash: "SHA-1"}, false, ["sign", "verify"])
+              let isVerified = await subtle.verify(algorithm, wrongKey, vector.signature, vector.data)
+              assert_unreached("Verifying should not have succeeded for " + vector.name);
+          } catch (err) {
+              if (err instanceof AssertionError)
+                  throw err;
+              assert_false(wrongKey === undefined, "Generate wrong key for test " + vector.name + " failed: '" + err.message + "'");
+              assert_equals(err.name, "InvalidAccessError", "Should have thrown InvalidAccessError instead of '" + err.message + "'");
+          };
+      }, vector.name + " verifying with wrong algorithm name");
+
+      // Test verification fails with wrong signature
+      var algorithm = {name: vector.algorithmName};
+      promise_test(async() => {
+          let key;
+          let isVerified = true;
           var signature = copyBuffer(vector.signature);
           signature[0] = 255 - signature[0];
-          promise_test(function(test) {
-              var operation = subtle.verify(algorithm, vector.publicKey, signature, vector.data)
-              .then(function(is_verified) {
-                  assert_false(is_verified, "Signature NOT verified");
-              }, function(err) {
-                  assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
-              });
-
-              return operation;
-          }, vector.name + " verification failure due to altered signature");
-
-      }, function(err) {
-          // We need a failed test if the importVectorKey operation fails, so
-          // we know we never tested verification.
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " verification failure due to altered signature");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Test verification fails with short (odd length) signature
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
+              isVerified = await subtle.verify(algorithm, key, signature, vector.data)
+          } catch (err) {
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
+          };
+          assert_false(isVerified, "Signature verified");
+      }, vector.name + " verification failure due to altered signature");
+
+      // Test verification fails with short (odd length) signature
+      promise_test(async() => {
+          let key;
+          let isVerified = true;
           var signature = vector.signature.slice(1); // Skip the first byte
-          promise_test(function(test) {
-              var operation = subtle.verify(algorithm, vector.publicKey, signature, vector.data)
-              .then(function(is_verified) {
-                  assert_false(is_verified, "Signature NOT verified");
-              }, function(err) {
-                  assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
-              });
-
-              return operation;
-          }, vector.name + " verification failure due to shortened signature");
-
-      }, function(err) {
-          // We need a failed test if the importVectorKey operation fails, so
-          // we know we never tested verification.
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " verification failure due to shortened signature");
-      });
-
-      all_promises.push(promise);
-  });
-
-  // Test verification fails with wrong data
-  testVectors.forEach(function(vector) {
-      var promise = importVectorKeys(vector, ["verify"], ["sign"])
-      .then(function(vectors) {
-          var algorithm = {name: vector.algorithmName};
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
+              isVerified = await subtle.verify(algorithm, key, signature, vector.data)
+          } catch (err) {
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
+          };
+          assert_false(isVerified, "Signature verified");
+      }, vector.name + " verification failure due to shortened signature");
+
+      // Test verification fails with wrong data
+      promise_test(async() => {
+          let key;
+          let isVerified = true;
           var data = copyBuffer(vector.data);
           data[0] = 255 - data[0];
-          promise_test(function(test) {
-              var operation = subtle.verify(algorithm, vector.publicKey, vector.signature, data)
-              .then(function(is_verified) {
-                  assert_false(is_verified, "Signature NOT verified");
-              }, function(err) {
-                  assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
-              });
-
-              return operation;
-          }, vector.name + " verification failure due to altered data");
-
-      }, function(err) {
-          // We need a failed test if the importVectorKey operation fails, so
-          // we know we never tested verification.
-          promise_test(function(test) {
-              assert_unreached("importVectorKeys failed for " + vector.name + ". Message: ''" + err.message + "''");
-          }, "importVectorKeys step: " + vector.name + " verification failure due to altered data");
-      });
-
-      all_promises.push(promise);
-  });
-
-
-  promise_test(function() {
-      return Promise.all(all_promises)
-          .then(function() {done();})
-          .catch(function() {done();})
-  }, "setup");
-
-  // Test that generated keys are valid for signing and verifying.
-  testVectors.forEach(function(vector) {
-      var algorithm = {name: vector.algorithmName};
+          try {
+              key = await subtle.importKey("spki", vector.publicKeyBuffer, algorithm, false, ["verify"]);
+              isVerified = await subtle.verify(algorithm, key, vector.signature, data)
+          } catch (err) {
+              assert_false(key === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+              assert_unreached("Verification should not throw error " + vector.name + ": " + err.message + "'");
+          };
+          assert_false(isVerified, "Signature verified");
+      }, vector.name + " verification failure due to altered data");
+
+      // Test that generated keys are valid for signing and verifying.
       promise_test(async() => {
           let key = await subtle.generateKey(algorithm, false, ["sign", "verify"]);
           let signature = await subtle.sign(algorithm, key.privateKey, vector.data);
@@ -366,41 +217,25 @@ function run_test() {
       }, "Sign and verify using generated " + vector.algorithmName + " keys.");
   });
 
-
-  // A test vector has all needed fields for signing and verifying, EXCEPT that the
-  // key field may be null. This function replaces that null with the Correct
-  // CryptoKey object.
-  //
-  // Returns a Promise that yields an updated vector on success.
-  function importVectorKeys(vector, publicKeyUsages, privateKeyUsages) {
-      var publicPromise, privatePromise;
-
-      if (vector.publicKey !== null) {
-          publicPromise = new Promise(function(resolve, reject) {
-              resolve(vector);
-          });
-      } else {
-          publicPromise = subtle.importKey(vector.publicKeyFormat, vector.publicKeyBuffer, {name: vector.algorithmName}, false, publicKeyUsages)
-          .then(function(key) {
-              vector.publicKey = key;
-              return vector;
-          });        // Returns a copy of the sourceBuffer it is sent.
-      }
-
-      if (vector.privateKey !== null) {
-          privatePromise = new Promise(function(resolve, reject) {
-              resolve(vector);
-          });
-      } else {
-          privatePromise = subtle.importKey(vector.privateKeyFormat, vector.privateKeyBuffer, {name: vector.algorithmName}, false, privateKeyUsages)
-          .then(function(key) {
-              vector.privateKey = key;
-              return vector;
-          });
-      }
-
-      return Promise.all([publicPromise, privatePromise]);
-  }
+  // When verifying an Ed25519 or Ed448 signature, if the public key or the first half of the signature (R) is
+  // an invalid or small-order element, return false.
+  Object.keys(kSmallOrderTestCases).forEach(function (algorithmName) {
+      var algorithm = {name: algorithmName};
+      kSmallOrderTestCases[algorithmName].forEach(function(test) {
+          promise_test(async() => {
+              let isVerified = true;
+              let publicKey;
+              try {
+                  publicKey = await subtle.importKey("raw", test.keyData, algorithm, false, ["verify"])
+                  isVerified = await subtle.verify(algorithm, publicKey, test.signature, test.message);
+              } catch (err) {
+                  assert_false(publicKey === undefined, "importKey failed for " + vector.name + ". Message: ''" + err.message + "''");
+                  assert_unreached("The operation shouldn't fail, but it thown this error: " + err.name + ": " + err.message + ".");
+              }
+              assert_false(isVerified, "Signature verification result.");
+          }, algorithmName + " Verification checks with small-order key of order - Test " + test.id);
+      });
+  });
 
   // Returns a copy of the sourceBuffer it is sent.
   function copyBuffer(sourceBuffer) {
diff --git a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js
index 96ec2b01af96f2..ce80e0ea7e2626 100644
--- a/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js
+++ b/test/fixtures/wpt/WebCryptoAPI/sign_verify/eddsa_vectors.js
@@ -53,6 +53,145 @@ function getTestVectors() {
 
     vectors.push(vector);
   });
-
   return vectors;
 }
+
+// https://eprint.iacr.org/2020/1244.pdf#table.caption.3
+var kSmallOrderPoints = [
+    // Canonical serializations
+    [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // #0 - Order 1
+    [0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // #1 - Order 2
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80], // #2 - Order 4
+    [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00], // #3 - Order 4
+    [0xC7, 0x17, 0x6A, 0x70, 0x3D, 0x4D, 0xD8, 0x4F, 0xBA, 0x3C, 0x0B, 0x76, 0x0D, 0x10, 0x67, 0x0F, 0x2A, 0x20, 0x53, 0xFA, 0x2C, 0x39, 0xCC, 0xC6, 0x4E, 0xC7, 0xFD, 0x77, 0x92, 0xAC, 0x03, 0x7A], // #4 - Order 8
+    [0xC7, 0x17, 0x6A, 0x70, 0x3D, 0x4D, 0xD8, 0x4F, 0xBA, 0x3C, 0x0B, 0x76, 0x0D, 0x10, 0x67, 0x0F, 0x2A, 0x20, 0x53, 0xFA, 0x2C, 0x39, 0xCC, 0xC6, 0x4E, 0xC7, 0xFD, 0x77, 0x92, 0xAC, 0x03, 0xFA], // #5 - Order 8
+    [0x26, 0xE8, 0x95, 0x8F, 0xC2, 0xB2, 0x27, 0xB0, 0x45, 0xC3, 0xF4, 0x89, 0xF2, 0xEF, 0x98, 0xF0, 0xD5, 0xDF, 0xAC, 0x05, 0xD3, 0xC6, 0x33, 0x39, 0xB1, 0x38, 0x02, 0x88, 0x6D, 0x53, 0xFC, 0x05], // #6 - Order 8
+    [0x26, 0xE8, 0x95, 0x8F, 0xC2, 0xB2, 0x27, 0xB0, 0x45, 0xC3, 0xF4, 0x89, 0xF2, 0xEF, 0x98, 0xF0, 0xD5, 0xDF, 0xAC, 0x05, 0xD3, 0xC6, 0x33, 0x39, 0xB1, 0x38, 0x02, 0x88, 0x6D, 0x53, 0xFC, 0x85], // #7 - Order 8
+
+    // Non-canonical serializatons
+    [0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80], // #8  - Order 1
+    [0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // #9  - Order 2
+    [0xEE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // #10 - Order 1
+    [0xEE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // #11 - Order 1
+    [0xED, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF], // #12 - Order 4
+    [0xED, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // #13 - Order 4
+];
+
+
+var pubKeys = [
+    [0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0xfa], // kSmallOrderPoints #5
+    [0xf7, 0xba, 0xde, 0xc5, 0xb8, 0xab, 0xea, 0xf6, 0x99, 0x58, 0x39, 0x92, 0x21, 0x9b, 0x7b, 0x22, 0x3f, 0x1d, 0xf3, 0xfb, 0xbe, 0xa9, 0x19, 0x84, 0x4e, 0x3f, 0x7c, 0x55, 0x4a, 0x43, 0xdd, 0x43], // highest 32 bytes of case "1" signature
+    [0xcd, 0xb2, 0x67, 0xce, 0x40, 0xc5, 0xcd, 0x45, 0x30, 0x6f, 0xa5, 0xd2, 0xf2, 0x97, 0x31, 0x45, 0x93, 0x87, 0xdb, 0xf9, 0xeb, 0x93, 0x3b, 0x7b, 0xd5, 0xae, 0xd9, 0xa7, 0x65, 0xb8, 0x8d, 0x4d],
+    [0x44, 0x2a, 0xad, 0x9f, 0x08, 0x9a, 0xd9, 0xe1, 0x46, 0x47, 0xb1, 0xef, 0x90, 0x99, 0xa1, 0xff, 0x47, 0x98, 0xd7, 0x85, 0x89, 0xe6, 0x6f, 0x28, 0xec, 0xa6, 0x9c, 0x11, 0xf5, 0x82, 0xa6, 0x23],
+    [0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff], // kSmallOrderPoints #9
+    [0xEC, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F], // kSmallOrderPoints #1
+]
+
+// https://eprint.iacr.org/2020/1244.pdf
+// signature = (R, S); public key A, h = SHA512(R||A||M )
+// 8(SB) = 8R + 8(hA) => (1)
+// SB = R + hA => (2)
+var kSmallOrderTestCases = {
+    "Ed25519": [
+        {
+            id: "0", // S = 0 | A's order = small | R's order = small | (1) = pass | (2) = pass
+            message : Uint8Array.from([0x8c, 0x93, 0x25, 0x5d, 0x71, 0xdc, 0xab, 0x10, 0xe8, 0xf3, 0x79, 0xc2, 0x62, 0x00, 0xf3, 0xc7, 0xbd, 0x5f, 0x09, 0xd9, 0xbc, 0x30, 0x68, 0xd3, 0xef, 0x4e, 0xde, 0xb4, 0x85, 0x30, 0x22, 0xb6]),
+            keyData : Uint8Array.from(pubKeys[0]),
+            signature : Uint8Array.from([0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0x7a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00]),
+            verified: false,  // small-order signature's R fail in the verification.
+        },
+        {
+            id: "1", // 0 < S < L | A's order = small | R's order = mixed | (1) = pass | (2) = pass
+            message : Uint8Array.from([0x9b, 0xd9, 0xf4, 0x4f, 0x4d, 0xcc, 0x75, 0xbd, 0x53, 0x1b, 0x56, 0xb2, 0xcd, 0x28, 0x0b, 0x0b, 0xb3, 0x8f, 0xc1, 0xcd, 0x6d, 0x12, 0x30, 0xe1, 0x48, 0x61, 0xd8, 0x61, 0xde, 0x09, 0x2e, 0x79]),
+            keyData : Uint8Array.from(pubKeys[0]),
+            signature : Uint8Array.from([0xf7, 0xba, 0xde, 0xc5, 0xb8, 0xab, 0xea, 0xf6, 0x99, 0x58, 0x39, 0x92, 0x21, 0x9b, 0x7b, 0x22, 0x3f, 0x1d, 0xf3, 0xfb, 0xbe, 0xa9, 0x19, 0x84, 0x4e, 0x3f, 0x7c, 0x55, 0x4a, 0x43, 0xdd, 0x43, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]),
+            verified: false, // small-order key's data fail in the verification.
+        },
+        {
+            id: "2", // 0 < S < L | A's order = mixed | R's order = small | (1) = pass | (2) = pass
+            message : Uint8Array.from([0xae, 0xbf, 0x3f, 0x26, 0x01, 0xa0, 0xc8, 0xc5, 0xd3, 0x9c, 0xc7, 0xd8, 0x91, 0x16, 0x42, 0xf7, 0x40, 0xb7, 0x81, 0x68, 0x21, 0x8d, 0xa8, 0x47, 0x17, 0x72, 0xb3, 0x5f, 0x9d, 0x35, 0xb9, 0xab]),
+            keyData : Uint8Array.from(pubKeys[1]),
+            signature : Uint8Array.from([0xc7, 0x17, 0x6a, 0x70, 0x3d, 0x4d, 0xd8, 0x4f, 0xba, 0x3c, 0x0b, 0x76, 0x0d, 0x10, 0x67, 0x0f, 0x2a, 0x20, 0x53, 0xfa, 0x2c, 0x39, 0xcc, 0xc6, 0x4e, 0xc7, 0xfd, 0x77, 0x92, 0xac, 0x03, 0xfa, 0x8c, 0x4b, 0xd4, 0x5a, 0xec, 0xac, 0xa5, 0xb2, 0x4f, 0xb9, 0x7b, 0xc1, 0x0a, 0xc2, 0x7a, 0xc8, 0x75, 0x1a, 0x7d, 0xfe, 0x1b, 0xaf, 0xf8, 0xb9, 0x53, 0xec, 0x9f, 0x58, 0x33, 0xca, 0x26, 0x0e]),
+            verified: false,  // small-order signature's R fail in the verification.
+        },
+        {
+            id: "3", // 0 < S < L | A's order = mixed | R's order = mixed | (1) = pass | (2) = pass
+            message : Uint8Array.from([0x9b, 0xd9, 0xf4, 0x4f, 0x4d, 0xcc, 0x75, 0xbd, 0x53, 0x1b, 0x56, 0xb2, 0xcd, 0x28, 0x0b, 0x0b, 0xb3, 0x8f, 0xc1, 0xcd, 0x6d, 0x12, 0x30, 0xe1, 0x48, 0x61, 0xd8, 0x61, 0xde, 0x09, 0x2e, 0x79]),
+            keyData : Uint8Array.from(pubKeys[2]),
+            signature : Uint8Array.from([0x90, 0x46, 0xa6, 0x47, 0x50, 0x44, 0x49, 0x38, 0xde, 0x19, 0xf2, 0x27, 0xbb, 0x80, 0x48, 0x5e, 0x92, 0xb8, 0x3f, 0xdb, 0x4b, 0x65, 0x06, 0xc1, 0x60, 0x48, 0x4c, 0x01, 0x6c, 0xc1, 0x85, 0x2f, 0x87, 0x90, 0x9e, 0x14, 0x42, 0x8a, 0x7a, 0x1d, 0x62, 0xe9, 0xf2, 0x2f, 0x3d, 0x3a, 0xd7, 0x80, 0x2d, 0xb0, 0x2e, 0xb2, 0xe6, 0x88, 0xb6, 0xc5, 0x2f, 0xcd, 0x66, 0x48, 0xa9, 0x8b, 0xd0, 0x09]),
+            verified: true, // mixed-order points are not checked.
+        },
+        {
+            id: "4", // 0 < S < L | A's order = mixed | R's order = mixed | (1) = pass | (2) = fail
+            message : Uint8Array.from([0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40, 0x11, 0xea, 0xcc, 0xd5, 0x5b, 0x53, 0xf5, 0x6c]),
+            keyData : Uint8Array.from(pubKeys[2]),
+            signature : Uint8Array.from([0x16, 0x0a, 0x1c, 0xb0, 0xdc, 0x9c, 0x02, 0x58, 0xcd, 0x0a, 0x7d, 0x23, 0xe9, 0x4d, 0x8f, 0xa8, 0x78, 0xbc, 0xb1, 0x92, 0x5f, 0x2c, 0x64, 0x24, 0x6b, 0x2d, 0xee, 0x17, 0x96, 0xbe, 0xd5, 0x12, 0x5e, 0xc6, 0xbc, 0x98, 0x2a, 0x26, 0x9b, 0x72, 0x3e, 0x06, 0x68, 0xe5, 0x40, 0x91, 0x1a, 0x9a, 0x6a, 0x58, 0x92, 0x1d, 0x69, 0x25, 0xe4, 0x34, 0xab, 0x10, 0xaa, 0x79, 0x40, 0x55, 0x1a, 0x09]),
+            verified: false, // expect a cofactorless verification algorithm.
+        },
+        {
+            id: "5", // 0 < S < L | A's order = mixed | R's order = L | (1) = pass | (2) = fail
+            message : Uint8Array.from([0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40, 0x11, 0xea, 0xcc, 0xd5, 0x5b, 0x53, 0xf5, 0x6c]),
+            keyData : Uint8Array.from(pubKeys[2]),
+            signature : Uint8Array.from([0x21, 0x12, 0x2a, 0x84, 0xe0, 0xb5, 0xfc, 0xa4, 0x05, 0x2f, 0x5b, 0x12, 0x35, 0xc8, 0x0a, 0x53, 0x78, 0x78, 0xb3, 0x8f, 0x31, 0x42, 0x35, 0x6b, 0x2c, 0x23, 0x84, 0xeb, 0xad, 0x46, 0x68, 0xb7, 0xe4, 0x0b, 0xc8, 0x36, 0xda, 0xc0, 0xf7, 0x10, 0x76, 0xf9, 0xab, 0xe3, 0xa5, 0x3f, 0x9c, 0x03, 0xc1, 0xce, 0xee, 0xdd, 0xb6, 0x58, 0xd0, 0x03, 0x04, 0x94, 0xac, 0xe5, 0x86, 0x68, 0x74, 0x05]),
+            verified: false, // expect a cofactorless verification algorithm.
+        },
+        {
+            id: "6", // S > L | A's order = L | R's order = L | (1) = pass | (2) = pass
+            message : Uint8Array.from([0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41, 0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40]),
+            keyData : Uint8Array.from(pubKeys[3]),
+            signature : Uint8Array.from([0xe9, 0x6f, 0x66, 0xbe, 0x97, 0x6d, 0x82, 0xe6, 0x01, 0x50, 0xba, 0xec, 0xff, 0x99, 0x06, 0x68, 0x4a, 0xeb, 0xb1, 0xef, 0x18, 0x1f, 0x67, 0xa7, 0x18, 0x9a, 0xc7, 0x8e, 0xa2, 0x3b, 0x6c, 0x0e, 0x54, 0x7f, 0x76, 0x90, 0xa0, 0xe2, 0xdd, 0xcd, 0x04, 0xd8, 0x7d, 0xbc, 0x34, 0x90, 0xdc, 0x19, 0xb3, 0xb3, 0x05, 0x2f, 0x7f, 0xf0, 0x53, 0x8c, 0xb6, 0x8a, 0xfb, 0x36, 0x9b, 0xa3, 0xa5, 0x14]),
+            verified: false, // S out of bounds
+        },
+        {
+            id: "7", // S >> L | A's order = L | R's order = L | (1) = pass | (2) = pass
+            message : Uint8Array.from([0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41, 0xe4, 0x7d, 0x62, 0xc6, 0x3f, 0x83, 0x0d, 0xc7, 0xa6, 0x85, 0x1a, 0x0b, 0x1f, 0x33, 0xae, 0x4b, 0xb2, 0xf5, 0x07, 0xfb, 0x6c, 0xff, 0xec, 0x40]),
+            keyData : Uint8Array.from(pubKeys[3]),
+            signature : Uint8Array.from([0x8c, 0xe5, 0xb9, 0x6c, 0x8f, 0x26, 0xd0, 0xab, 0x6c, 0x47, 0x95, 0x8c, 0x9e, 0x68, 0xb9, 0x37, 0x10, 0x4c, 0xd3, 0x6e, 0x13, 0xc3, 0x35, 0x66, 0xac, 0xd2, 0xfe, 0x8d, 0x38, 0xaa, 0x19, 0x42, 0x7e, 0x71, 0xf9, 0x8a, 0x47, 0x34, 0xe7, 0x4f, 0x2f, 0x13, 0xf0, 0x6f, 0x97, 0xc2, 0x0d, 0x58, 0xcc, 0x3f, 0x54, 0xb8, 0xbd, 0x0d, 0x27, 0x2f, 0x42, 0xb6, 0x95, 0xdd, 0x7e, 0x89, 0xa8, 0xc2, 0x02]),
+            verified: false, // S out of bounds
+        },
+        {
+            id: "8", // 0 < S < L | A's order = mixed | R's order = small (non-canonical) | (1) = ? | (2) = ? Implementations that reduce A before hashing will accept #8 and accept #9, and viceversa
+            message : Uint8Array.from([0x9b, 0xed, 0xc2, 0x67, 0x42, 0x37, 0x25, 0xd4, 0x73, 0x88, 0x86, 0x31, 0xeb, 0xf4, 0x59, 0x88, 0xba, 0xd3, 0xdb, 0x83, 0x85, 0x1e, 0xe8, 0x5c, 0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41]),
+            keyData : Uint8Array.from(pubKeys[1]),
+            signature : Uint8Array.from([0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x03, 0xbe, 0x96, 0x78, 0xac, 0x10, 0x2e, 0xdc, 0xd9, 0x2b, 0x02, 0x10, 0xbb, 0x34, 0xd7, 0x42, 0x8d, 0x12, 0xff, 0xc5, 0xdf, 0x5f, 0x37, 0xe3, 0x59, 0x94, 0x12, 0x66, 0xa4, 0xe3, 0x5f, 0x0f]),
+            verified: false, // non-canonical point should fail in the verificaton (RFC8032)
+        },
+        {
+            id: "9", // 0 < S < L | A's order = mixed | R's order = small (non-canonical) | (1) = ? | (2) = ?
+            message : Uint8Array.from([0x9b, 0xed, 0xc2, 0x67, 0x42, 0x37, 0x25, 0xd4, 0x73, 0x88, 0x86, 0x31, 0xeb, 0xf4, 0x59, 0x88, 0xba, 0xd3, 0xdb, 0x83, 0x85, 0x1e, 0xe8, 0x5c, 0x85, 0xe2, 0x41, 0xa0, 0x7d, 0x14, 0x8b, 0x41]),
+            keyData : Uint8Array.from(pubKeys[1]),
+            signature : Uint8Array.from([0xec, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xca, 0x8c, 0x5b, 0x64, 0xcd, 0x20, 0x89, 0x82, 0xaa, 0x38, 0xd4, 0x93, 0x66, 0x21, 0xa4, 0x77, 0x5a, 0xa2, 0x33, 0xaa, 0x05, 0x05, 0x71, 0x1d, 0x8f, 0xdc, 0xfd, 0xaa, 0x94, 0x3d, 0x49, 0x08]),
+            verified: false, // non-canonical point should fail in the verificaton (RFC8032)
+        },
+        {
+            id: "10", // 0 < S < L | A's order = small (non-canonical) | R's order = mixed | (1) = ? | (2) = ? Implementations that reduce A before hashing will accept #10 and accept #11, and viceversa
+            message : Uint8Array.from([0xe9, 0x6b, 0x70, 0x21, 0xeb, 0x39, 0xc1, 0xa1, 0x63, 0xb6, 0xda, 0x4e, 0x30, 0x93, 0xdc, 0xd3, 0xf2, 0x13, 0x87, 0xda, 0x4c, 0xc4, 0x57, 0x2b, 0xe5, 0x88, 0xfa, 0xfa, 0xe2, 0x3c, 0x15, 0x5b]),
+            keyData : Uint8Array.from(pubKeys[4]),
+            signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]),
+            verified: false, // non-canonical point should fail in the verificaton (RFC8032)
+        },
+        {
+            id: "11", // 0 < S < L | A's order = small (non-canonical) | R's order = mixed | (1) = ? | (2) = ? Implementations that reduce A before hashing will accept #10 and accept #11, and viceversa
+            message : Uint8Array.from([0x39, 0xa5, 0x91, 0xf5, 0x32, 0x1b, 0xbe, 0x07, 0xfd, 0x5a, 0x23, 0xdc, 0x2f, 0x39, 0xd0, 0x25, 0xd7, 0x45, 0x26, 0x61, 0x57, 0x46, 0x72, 0x7c, 0xee, 0xfd, 0x6e, 0x82, 0xae, 0x65, 0xc0, 0x6f]),
+            keyData : Uint8Array.from(pubKeys[4]),
+            signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]),
+            verified: false, // non-canonical point should fail in the verificaton (RFC8032)
+        },
+        // https://eprint.iacr.org/2020/1244.pdf#section.A.2
+        // cases breaking non-repudiation
+        {
+            id: "12", // 0 < S < L | A's order = small | R's order = mixed | (1) = ? | (2) = ?
+            message : Uint8Array.from([0x53, 0x65, 0x6e, 0x64, 0x20, 0x31, 0x30, 0x30, 0x20, 0x55, 0x53, 0x44, 0x20, 0x74, 0x6f, 0x20, 0x41, 0x6c, 0x69, 0x63, 0x65]),
+            keyData : Uint8Array.from(pubKeys[5]),
+            signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]),
+            verified: false,
+        },
+        {
+            id: "13", // 0 < S < L | A's order = small | R's order = mixed | (1) = ? | (2) = ?
+            message : Uint8Array.from([0x53, 0x65, 0x6e, 0x64, 0x20, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x20, 0x55, 0x53, 0x44, 0x20, 0x74, 0x6f, 0x20, 0x41, 0x6c, 0x69, 0x63, 0x65]),
+            keyData : Uint8Array.from(pubKeys[5]),
+            signature : Uint8Array.from([0xa9, 0xd5, 0x52, 0x60, 0xf7, 0x65, 0x26, 0x1e, 0xb9, 0xb8, 0x4e, 0x10, 0x6f, 0x66, 0x5e, 0x00, 0xb8, 0x67, 0x28, 0x7a, 0x76, 0x19, 0x90, 0xd7, 0x13, 0x59, 0x63, 0xee, 0x0a, 0x7d, 0x59, 0xdc, 0xa5, 0xbb, 0x70, 0x47, 0x86, 0xbe, 0x79, 0xfc, 0x47, 0x6f, 0x91, 0xd3, 0xf3, 0xf8, 0x9b, 0x03, 0x98, 0x4d, 0x80, 0x68, 0xdc, 0xf1, 0xbb, 0x7d, 0xfc, 0x66, 0x37, 0xb4, 0x54, 0x50, 0xac, 0x04]),
+            verified: false,
+        }
+    ]
+};
diff --git a/test/fixtures/wpt/versions.json b/test/fixtures/wpt/versions.json
index a7c655125b5c22..e68babe79c2c3c 100644
--- a/test/fixtures/wpt/versions.json
+++ b/test/fixtures/wpt/versions.json
@@ -88,7 +88,7 @@
     "path": "wasm/webapi"
   },
   "WebCryptoAPI": {
-    "commit": "5e042cbc4ecab7b2279a5fd411c6daa24ca886c6",
+    "commit": "6e54abcb8bac416c9fe4ed4488870fb1f859130d",
     "path": "WebCryptoAPI"
   },
   "webidl/ecmascript-binding/es-exceptions": {
diff --git a/test/wpt/status/WebCryptoAPI.json b/test/wpt/status/WebCryptoAPI.json
index 9f9ba93240be25..941de354fe2dbd 100644
--- a/test/wpt/status/WebCryptoAPI.json
+++ b/test/wpt/status/WebCryptoAPI.json
@@ -4,5 +4,19 @@
   },
   "historical.any.js": {
     "skip": "Not relevant in Node.js context"
+  },
+  "sign_verify/eddsa.https.any.js": {
+    "fail": {
+      "note": "see https://github.com/web-platform-tests/wpt/pull/43751",
+      "expected": [
+        "Ed25519 Verification checks with small-order key of order - Test 0",
+        "Ed25519 Verification checks with small-order key of order - Test 1",
+        "Ed25519 Verification checks with small-order key of order - Test 2",
+        "Ed25519 Verification checks with small-order key of order - Test 3",
+        "Ed25519 Verification checks with small-order key of order - Test 11",
+        "Ed25519 Verification checks with small-order key of order - Test 12",
+        "Ed25519 Verification checks with small-order key of order - Test 13"
+      ]
+    }
   }
 }