diff --git a/src/adagrams.js b/src/adagrams.js
index ebc2839c..268192e2 100644
--- a/src/adagrams.js
+++ b/src/adagrams.js
@@ -1,15 +1,168 @@
+const letterPool = {
+  A: 9,
+  B: 2,
+  C: 2,
+  D: 4,
+  E: 12,
+  F: 2,
+  G: 3,
+  H: 2,
+  I: 9,
+  J: 1,
+  K: 1,
+  L: 4,
+  M: 2,
+  N: 6,
+  O: 8,
+  P: 2,
+  Q: 1,
+  R: 6,
+  S: 4,
+  T: 6,
+  U: 4,
+  V: 2,
+  W: 2,
+  X: 1,
+  Y: 2,
+  Z: 1,
+};
+
 export const drawLetters = () => {
   // Implement this method for wave 1
+  // Return a randomized list of ten letters
+  let allLetters = [];
+  let tenLetters = [];
+  // if (letterPool.length === 0) {break};
+  // console.log("letterPool: ", letterPool);
+  for (const [key, value] of Object.entries(letterPool)) {
+    // console.log("key:", key);
+    for (let n = 0; n < value; n++) {
+      allLetters.push(key);
+      // console.log("key:", key);
+    }
+  }
+  // console.log("allLetters:", allLetters);
+  let indexie = [];
+  // let n = 0;
+  while (indexie.length < 10) {
+    // n++;
+    let i = Math.floor(Math.random() * allLetters.length);
+    // console.log("i: ", i);
+    if (indexie.includes(i)) {
+      continue;
+    } else {
+      indexie.push(i);
+    }
+  }
+  indexie.forEach((k) => {
+    return tenLetters.push(allLetters[k]);
+  });
+  // console.log("indexie:", indexie);
+  // console.log("tenLetters:", tenLetters);
+  return tenLetters;
 };
 
 export const usesAvailableLetters = (input, lettersInHand) => {
   // Implement this method for wave 2
+  // input is a string of letters.
+  // lettersInHand is an array of letters.
+  // this seems a bit long. Maybe I can use another method to count letter in ...
+  // or maybe I can make another function to do this.
+  const lettersArray = lettersInHand;
+  for (let letter of input) {
+    let inputCount = 0;
+    let handCount = 0;
+    for (let i = 0; i < input.length; i++) {
+      if (input[i] === letter) {
+        inputCount++;
+      }
+    }
+    for (let i = 0; i < lettersInHand.length; i++) {
+      if (lettersInHand[i] === letter) {
+        handCount++;
+      }
+    }
+    if (!lettersInHand.includes(letter) || inputCount > handCount) {
+      return false;
+    }
+  }
+  return true;
 };
 
 export const scoreWord = (word) => {
   // Implement this method for wave 3
+  const scoreChart = {
+    A: 1,
+    E: 1,
+    I: 1,
+    O: 1,
+    U: 1,
+    L: 1,
+    N: 1,
+    R: 1,
+    S: 1,
+    T: 1,
+    D: 2,
+    G: 2,
+    B: 3,
+    C: 3,
+    M: 3,
+    P: 3,
+    F: 4,
+    H: 4,
+    V: 4,
+    W: 4,
+    Y: 4,
+    K: 5,
+    J: 8,
+    X: 8,
+    Q: 10,
+    Z: 10,
+  };
+  let score = 0;
+  if (word.length > 0 && typeof word === "string") {
+    const wordUppercase = word.toUpperCase();
+    for (let i = 0; i < wordUppercase.length; i++) {
+      score += scoreChart[wordUppercase[i]];
+    }
+    if (word.length > 6) {
+      score += 8;
+    }
+  }
+  return score;
+};
+
+export const getIndexTieBreak = (highestScoringWords) => {
+  // Break ties from highestScoreFrom
+  let highestIndex = 0;
+  for (let i = 0; i < highestScoringWords.length; i++) {
+    if (highestScoringWords[i].length === 10) {
+      return i;
+    } else if (
+      highestScoringWords[i].length < highestScoringWords[highestIndex].length
+    ) {
+      highestIndex = i;
+    }
+  }
+  return highestIndex;
 };
 
 export const highestScoreFrom = (words) => {
   // Implement this method for wave 1
+  let highestScoringWords = [];
+  let highScore = 0;
+  let highScoreIndex = 0;
+  for (let word of words) {
+    let score = scoreWord(word);
+    if (score > highScore) {
+      highestScoringWords = [word];
+      highScore = score;
+    } else if (score === highScore) {
+      highestScoringWords.push(word);
+    }
+  }
+  if (highestScoringWords.length > 1) {
+    highScoreIndex = getIndexTieBreak(highestScoringWords);
+  }
+  return { word: highestScoringWords[highScoreIndex], score: highScore };
 };
diff --git a/test/adagrams.test.js b/test/adagrams.test.js
index 1a0dc94e..f3c52f3f 100644
--- a/test/adagrams.test.js
+++ b/test/adagrams.test.js
@@ -2,6 +2,7 @@ import {
   drawLetters,
   usesAvailableLetters,
   scoreWord,
+  getIndexTieBreak,
   highestScoreFrom,
 } from "adagrams";
 
@@ -120,7 +121,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 +136,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 +148,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", () => {