diff --git a/src/adagrams.js b/src/adagrams.js
index 7ec5afc7..cb786076 100644
--- a/src/adagrams.js
+++ b/src/adagrams.js
@@ -1,15 +1,229 @@
 export const drawLetters = () => {
-  // Implement this method for wave 1
+  const letterPool = [
+    "A",
+    "A",
+    "A",
+    "A",
+    "A",
+    "A",
+    "A",
+    "A",
+    "A",
+    "B",
+    "B",
+    "C",
+    "C",
+    "D",
+    "D",
+    "D",
+    "D",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "E",
+    "F",
+    "F",
+    "G",
+    "G",
+    "G",
+    "H",
+    "H",
+    "I",
+    "I",
+    "I",
+    "I",
+    "I",
+    "I",
+    "I",
+    "I",
+    "I",
+    "J",
+    "K",
+    "L",
+    "L",
+    "L",
+    "L",
+    "M",
+    "M",
+    "N",
+    "N",
+    "N",
+    "N",
+    "N",
+    "N",
+    "O",
+    "O",
+    "O",
+    "O",
+    "O",
+    "O",
+    "O",
+    "O",
+    "P",
+    "P",
+    "Q",
+    "R",
+    "R",
+    "R",
+    "R",
+    "R",
+    "R",
+    "S",
+    "S",
+    "S",
+    "S",
+    "T",
+    "T",
+    "T",
+    "T",
+    "T",
+    "T",
+    "U",
+    "U",
+    "U",
+    "U",
+    "V",
+    "V",
+    "W",
+    "W",
+    "X",
+    "Y",
+    "Y",
+    "Z",
+  ];
+
+  const shuffledLetterPool = letterPool.sort(() => Math.random() - 0.5);
+
+  let hand = shuffledLetterPool.slice(0, 10);
+
+  return hand;
 };
 
 export const usesAvailableLetters = (input, lettersInHand) => {
-  // Implement this method for wave 2
+  let loop_count = 0;
+  for (let letter of input) {
+    for (let handLetter of lettersInHand) {
+      if (letter.toUpperCase() == handLetter.toUpperCase()) {
+        loop_count++;
+        const index = lettersInHand.indexOf(handLetter);
+        if (index > -1) {
+          lettersInHand.splice(index, 1);
+        }
+      }
+    }
+  }
+  if (loop_count === input.length) {
+    return true;
+  } else {
+    return false;
+  }
 };
 
 export const scoreWord = (word) => {
-  // Implement this method for wave 3
+  let score = 0;
+
+  if (word.length > 6 && word.length < 11) {
+    score += 8;
+  }
+
+  for (let letterCaseSensitive of word) {
+    const letter = letterCaseSensitive.toUpperCase();
+    if (
+      letter === "A" ||
+      letter === "E" ||
+      letter === "I" ||
+      letter === "O" ||
+      letter === "U" ||
+      letter === "L" ||
+      letter === "N" ||
+      letter === "R" ||
+      letter === "S" ||
+      letter === "T"
+    ) {
+      score += 1;
+    } else if (letter === "D" || letter === "G") {
+      score += 2;
+    } else if (
+      letter === "B" ||
+      letter === "C" ||
+      letter === "M" ||
+      letter === "P"
+    ) {
+      score += 3;
+    } else if (
+      letter === "F" ||
+      letter === "H" ||
+      letter === "V" ||
+      letter === "W" ||
+      letter === "Y"
+    ) {
+      score += 4;
+    } else if (letter === "K") {
+      score += 5;
+    } else if (letter === "J" || letter === "X") {
+      score += 8;
+    } else if (letter === "Q" || letter === "Z") {
+      score += 10;
+    }
+  }
+
+  return score;
 };
 
+console.log(scoreWord("A"));
+
 export const highestScoreFrom = (words) => {
-  // Implement this method for wave 4
+  let wordsAndScores = {};
+
+  for (let word of words) {
+    const key = word;
+    const value = scoreWord(word);
+
+    wordsAndScores[key] = value;
+  }
+
+  let potentialWinners = [];
+  const vals = Object.values(wordsAndScores);
+  const max = Math.max(...vals);
+  for (let word in wordsAndScores) {
+    if (wordsAndScores[word] === max) {
+      potentialWinners.push(word);
+    }
+  }
+
+  let tenLetteredWinners = [];
+  let shortestWinners = [];
+  if (potentialWinners.length === 1) {
+    return { word: potentialWinners[0], score: scoreWord(potentialWinners[0]) };
+  } else {
+    for (let word of potentialWinners) {
+      if (word.length === 10) {
+        tenLetteredWinners.push(word);
+      } else {
+        var min = Math.min(...words.map((o) => o.length));
+        if (word.length === min) {
+          shortestWinners.push(word);
+        }
+      }
+    }
+  }
+  if (tenLetteredWinners.length === 1 || tenLetteredWinners.length > 1) {
+    return {
+      word: tenLetteredWinners[0],
+      score: scoreWord(tenLetteredWinners[0]),
+    };
+  } else if (tenLetteredWinners.length === 0 && shortestWinners.length === 1) {
+    return {
+      word: shortestWinners[0], 
+      score: scoreWord(shortestWinners[0]) 
+    };
+  }
 };
diff --git a/test/adagrams.test.js b/test/adagrams.test.js
index 1a0dc94e..af3e3e1c 100644
--- a/test/adagrams.test.js
+++ b/test/adagrams.test.js
@@ -120,7 +120,9 @@ describe("Adagrams", () => {
     });
 
     it("returns a score of 0 if given an empty input", () => {
-      throw "Complete test";
+      expectScores({
+        " " : 0
+      });
     });
 
     it("adds an extra 8 points if word is 7 or more characters long", () => {
@@ -133,7 +135,7 @@ describe("Adagrams", () => {
     });
   });
 
-  describe.skip("highestScoreFrom", () => {
+  describe("highestScoreFrom", () => {
     it("returns a hash that contains the word and score of best word in an array", () => {
       const words = ["X", "XX", "XXX", "XXXX"];
       const correct = { word: "XXXX", score: scoreWord("XXXX") };
@@ -145,7 +147,7 @@ describe("Adagrams", () => {
       const words = ["XXX", "XXXX", "X", "XX"];
       const correct = { word: "XXXX", score: scoreWord("XXXX") };
 
-      throw "Complete test by adding an assertion";
+      expect(highestScoreFrom(words)).toEqual(correct);
     });
 
     describe("in case of tied score", () => {