diff --git a/README.md b/README.md
index 15bb106b5..e70e1f775 100644
--- a/README.md
+++ b/README.md
@@ -1 +1,49 @@
 # javascript-lotto-precourse
+
+## 📜기능 정리
+
+### 로또 구입 입력 기능
+
+- [x] **구입 금액** 입력을 받는 기능 - `Console.readLineAsync()`
+- [x] 입력이 존재하는지 검사하는 기능
+- [x] 입력이 양의 정수인지 검사하는 기능
+- [x] 입력이 1000단위로 나누어 떨어지는지 검사하는 기능
+
+### 로또를 발행하는 기능
+
+- [x] 구입 금액을 1000으로 나누어 **로또 발행 수**를 계산하는 기능
+- [x] 로또 발행 수를 출력하는 기능 - `Console.print()`
+- [x] 1 ~ 45 이내의 중복되지 않는 6개의 숫자로 이루어진 **로또 번호 배열**을 생성하는 기능 - `MissionUtils.Random.pickUniqueNumbersInRange(1, 45, 6)`
+- [x] 생성한 로또 번호 배열 오름차 순으로 정렬하는 기능
+- [x] 발행 수만큼 로또 번호 배열 생성을 반복하는 기능
+- [x] 생성된 모든 로또 번호를 출력하는 기능 - `Console.print()`
+
+### 당첨 번호 입력 기능
+
+- [x] **당첨 번호** 입력을 받는 기능 - `Console.readLineAsync()`
+- [x] 입력이 있는지 검사하는 기능
+- [x] 쉼표(,)를 기준으로 입력을 분리(spliit)하는 기능
+- [x] 쉼표로 분리된 입력이 양의 정수인지 검사하는 기능
+- [x] 쉼표로 분리된 입력이 1 ~ 45 이내의 숫자인지 검사하는 기능
+- [x] 쉼표로 분리된 입력에 중복된 숫자가 있는지 검사하는 기능
+
+### 보너스 번호 입력 기능
+
+- [x] **보너스 번호** 입력을 받는 기능 - `Console.readLineAsync()`
+- [x] 입력이 있는지 검사하는 기능
+- [x] 입력이 양의 정수인지 검사하는 기능
+- [x] 입력이 1 ~ 45 이내의 숫자인지 검사하는 기능
+- [x] 입력이 당첨 번호와 중복되는지 검사하는 기능
+
+### 당첨 내역을 출력하는 기능
+
+- [x] “당첨 통계” 메세지를 출력하는 기능 - `Console.print()`
+- [x] 로또 번호 배열을 순회하며 일치하는 숫자를 찾아 당첨 정보를 생성하는 기능
+- [x] 발행 수만큼 당첨 정보 생성을 반복하는 기능
+- [x] 당첨 정보를 받아 당첨 내역을 출력하는 기능 - `Console.print()`
+
+### 총 수익률을 출력하는 기능
+
+- [x] 당첨 정보를 기반으로 수익률을 계산하는 기능
+- [x] 수익률을 소수점 둘째 자리에서 반올림 하는 기능
+- [x] 수익률 정보를 받아 총 수익률을 출력하는 기능 - `Console.print()`
diff --git a/__tests__/LottoMachineTest.js b/__tests__/LottoMachineTest.js
new file mode 100644
index 000000000..9e1713583
--- /dev/null
+++ b/__tests__/LottoMachineTest.js
@@ -0,0 +1,310 @@
+import {
+  validatePurchasePrice,
+  calcPurchaseCount,
+  createLottoNumbers,
+  validateWinningNumbers,
+  validateBonusNumber,
+  incrementCount,
+  calcWinningResult,
+  calcTotalYield,
+} from "../src/lottoMachine.js";
+import { MissionUtils } from "@woowacourse/mission-utils";
+import Lotto from "../src/Lotto.js";
+import { BONUS_PRIZE_INDEX, winningInfo } from "../src/const.js";
+
+describe("validatePurchasePrice 테스트", () => {
+  test("정상적인 구매 금액이면 숫자를 반환한다.", () => {
+    const result = validatePurchasePrice("1000");
+    expect(result).toBe(1000);
+  });
+
+  test("공백이 포함된 구매 금액이면 trim 후 검증한다.", () => {
+    const result = validatePurchasePrice("  2000  ");
+    expect(result).toBe(2000);
+  });
+
+  test("빈 문자열이면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePurchasePrice("");
+    }).toThrow("[ERROR]");
+  });
+
+  test("공백만 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePurchasePrice("   ");
+    }).toThrow("[ERROR]");
+  });
+
+  test("1000단위가 아니면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePurchasePrice("1500");
+    }).toThrow("[ERROR]");
+  });
+
+  test("숫자가 아니면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePurchasePrice("abc");
+    }).toThrow("[ERROR]");
+  });
+
+  test("양의 정수가 아니면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePurchasePrice("-1000");
+    }).toThrow("[ERROR]");
+  });
+});
+
+describe("calcPurchaseCount 테스트", () => {
+  test("1000원이면 1개를 반환한다.", () => {
+    const result = calcPurchaseCount(1000);
+    expect(result).toBe(1);
+  });
+
+  test("5000원이면 5개를 반환한다.", () => {
+    const result = calcPurchaseCount(5000);
+    expect(result).toBe(5);
+  });
+});
+
+describe("createLottoNumbers 테스트", () => {
+  beforeEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("구매 개수만큼 로또를 생성한다.", () => {
+    const mockNumbers = [1, 2, 3, 4, 5, 6];
+    MissionUtils.Random.pickUniqueNumbersInRange = jest
+      .fn()
+      .mockReturnValue(mockNumbers);
+
+    const result = createLottoNumbers(3);
+
+    expect(result).toHaveLength(3);
+    expect(MissionUtils.Random.pickUniqueNumbersInRange).toHaveBeenCalledTimes(
+      3
+    );
+  });
+
+  test("생성된 로또 번호는 정렬되어 있다.", () => {
+    const mockNumbers = [6, 1, 5, 2, 4, 3];
+    MissionUtils.Random.pickUniqueNumbersInRange = jest
+      .fn()
+      .mockReturnValue(mockNumbers);
+
+    const result = createLottoNumbers(1);
+
+    expect(result[0].numbers).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  test("생성된 로또는 Lotto 인스턴스이다.", () => {
+    const mockNumbers = [1, 2, 3, 4, 5, 6];
+    MissionUtils.Random.pickUniqueNumbersInRange = jest
+      .fn()
+      .mockReturnValue(mockNumbers);
+
+    const result = createLottoNumbers(1);
+
+    expect(result[0]).toBeInstanceOf(Lotto);
+  });
+});
+
+describe("validateWinningNumbers 테스트", () => {
+  test("정상적인 당첨 번호이면 배열을 반환한다.", () => {
+    const result = validateWinningNumbers("1,2,3,4,5,6");
+    expect(result).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  test("공백이 포함된 당첨 번호이면 trim 후 검증한다.", () => {
+    const result = validateWinningNumbers(" 1, 2, 3, 4, 5, 6 ");
+    expect(result).toEqual([1, 2, 3, 4, 5, 6]);
+  });
+
+  test("빈 문자열이면 예외가 발생한다.", () => {
+    expect(() => {
+      validateWinningNumbers("");
+    }).toThrow("[ERROR]");
+  });
+
+  test("6개가 아니면 예외가 발생한다.", () => {
+    expect(() => {
+      validateWinningNumbers("1,2,3,4,5");
+    }).toThrow("[ERROR]");
+  });
+
+  test("중복된 번호가 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateWinningNumbers("1,2,3,4,5,5");
+    }).toThrow("[ERROR]");
+  });
+
+  test("범위를 벗어난 번호가 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateWinningNumbers("1,2,3,4,5,46");
+    }).toThrow("[ERROR]");
+  });
+
+  test("숫자가 아닌 값이 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateWinningNumbers("1,2,3,4,5,abc");
+    }).toThrow("[ERROR]");
+  });
+
+  test("양의 정수가 아닌 값이 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateWinningNumbers("1,2,3,4,5,abc");
+    }).toThrow("[ERROR]");
+  });
+});
+
+describe("validateBonusNumber 테스트", () => {
+  const winningNumbers = [1, 2, 3, 4, 5, 6];
+
+  test("정상적인 보너스 번호이면 숫자를 반환한다.", () => {
+    const result = validateBonusNumber("7", winningNumbers);
+    expect(result).toBe(7);
+  });
+
+  test("공백이 포함된 보너스 번호이면 trim 후 검증한다.", () => {
+    const result = validateBonusNumber("  7  ", winningNumbers);
+    expect(result).toBe(7);
+  });
+
+  test("빈 문자열이면 예외가 발생한다.", () => {
+    expect(() => {
+      validateBonusNumber("", winningNumbers);
+    }).toThrow("[ERROR]");
+  });
+
+  test("당첨 번호와 중복되면 예외가 발생한다.", () => {
+    expect(() => {
+      validateBonusNumber("6", winningNumbers);
+    }).toThrow("[ERROR]");
+  });
+
+  test("범위를 벗어난 번호이면 예외가 발생한다.", () => {
+    expect(() => {
+      validateBonusNumber("46", winningNumbers);
+    }).toThrow("[ERROR]");
+  });
+
+  test("숫자가 아니면 예외가 발생한다.", () => {
+    expect(() => {
+      validateBonusNumber("abc", winningNumbers);
+    }).toThrow("[ERROR]");
+  });
+});
+
+describe("incrementCount 테스트", () => {
+  test("3개 일치이면 result[0]의 count가 증가한다.", () => {
+    const result = structuredClone(winningInfo);
+    incrementCount(result, 3, false);
+
+    expect(result[0].count).toBe(1);
+  });
+
+  test("4개 일치이면 result[1]의 count가 증가한다.", () => {
+    const result = structuredClone(winningInfo);
+    incrementCount(result, 4, false);
+
+    expect(result[1].count).toBe(1);
+  });
+
+  test("5개 일치이고 보너스 숫자가 일치하지 않으면 result[2]의 count가 증가한다.", () => {
+    const result = structuredClone(winningInfo);
+    incrementCount(result, 5, false);
+
+    expect(result[2].count).toBe(1);
+    expect(result[BONUS_PRIZE_INDEX].count).toBe(0);
+  });
+
+  test("5개 일치이고 보너스 숫자가 일치하면 result[3]의 count가 증가한다.", () => {
+    const result = structuredClone(winningInfo);
+    incrementCount(result, 5, true);
+
+    expect(result[2].count).toBe(0);
+    expect(result[BONUS_PRIZE_INDEX].count).toBe(1);
+  });
+
+  test("6개 일치이면 result[4]의 count가 증가한다.", () => {
+    const result = structuredClone(winningInfo);
+    incrementCount(result, 6, false);
+
+    expect(result[4].count).toBe(1);
+  });
+
+  test("2개 이하 일치이면 count가 증가하지 않는다.", () => {
+    const result = structuredClone(winningInfo);
+    incrementCount(result, 2, false);
+
+    result.forEach((item) => {
+      expect(item.count).toBe(0);
+    });
+  });
+});
+
+describe("calcWinningResult 테스트", () => {
+  test("당첨된 로또가 있으면 해당 등수 count가 증가한다.", () => {
+    const lottoArray = [
+      new Lotto([1, 2, 3, 4, 5, 6]),
+      new Lotto([1, 2, 3, 4, 5, 7]),
+      new Lotto([1, 2, 3, 4, 10, 11]),
+      new Lotto([1, 2, 3, 10, 11, 12]),
+    ];
+    const winningNumbers = [1, 2, 3, 4, 5, 6];
+    const bonusNumber = 7;
+
+    const result = calcWinningResult(lottoArray, winningNumbers, bonusNumber);
+
+    expect(result[0].count).toBe(1);
+    expect(result[1].count).toBe(1);
+    expect(result[2].count).toBe(0);
+    expect(result[BONUS_PRIZE_INDEX].count).toBe(1);
+    expect(result[4].count).toBe(1);
+  });
+});
+
+describe("calcTotalYield 테스트", () => {
+  test("당첨금이 없으면 수익률은 0.0%이다.", () => {
+    const result = structuredClone(winningInfo);
+    const purchasePrice = 1000;
+
+    const totalYield = calcTotalYield(result, purchasePrice);
+
+    expect(totalYield).toBe("0.0");
+  });
+
+  test("당첨금이 있으면 수익률을 계산한다.", () => {
+    const result = structuredClone(winningInfo);
+    result[0].count = 1;
+    result[1].count = 1;
+    const purchasePrice = 10000;
+
+    const totalYield = calcTotalYield(result, purchasePrice);
+
+    expect(totalYield).toBe("550.0");
+  });
+
+  test("수익률은 소수점 첫째 자리까지 반환한다.", () => {
+    const result = structuredClone(winningInfo);
+    result[0].count = 1;
+    const purchasePrice = 3000;
+
+    const totalYield = calcTotalYield(result, purchasePrice);
+
+    expect(totalYield).toBe("166.7");
+  });
+
+  test("모든 등수 당첨 시 수익률을 계산한다.", () => {
+    const result = structuredClone(winningInfo);
+    result[0].count = 1;
+    result[1].count = 1;
+    result[2].count = 1;
+    result[BONUS_PRIZE_INDEX].count = 1;
+    result[4].count = 1;
+    const purchasePrice = 10000;
+
+    const totalYield = calcTotalYield(result, purchasePrice);
+
+    expect(totalYield).toBe("20315550.0");
+  });
+});
diff --git a/__tests__/LottoTest.js b/__tests__/LottoTest.js
index 409aaf69b..feae83e7f 100644
--- a/__tests__/LottoTest.js
+++ b/__tests__/LottoTest.js
@@ -1,18 +1,100 @@
 import Lotto from "../src/Lotto";
 
 describe("로또 클래스 테스트", () => {
-  test("로또 번호의 개수가 6개가 넘어가면 예외가 발생한다.", () => {
-    expect(() => {
-      new Lotto([1, 2, 3, 4, 5, 6, 7]);
-    }).toThrow("[ERROR]");
+  describe("로또 번호 검증 테스트", () => {
+    test("로또 번호의 개수가 6개가 넘어가면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, 6, 7]);
+      }).toThrow("[ERROR]");
+    });
+
+    // TODO: 테스트가 통과하도록 프로덕션 코드 구현
+    test("로또 번호에 중복된 숫자가 있으면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, 5]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 0이 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([0, 1, 2, 3, 4, 5]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 음수가 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([-1, 1, 2, 3, 4, 5]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 45보다 큰 숫자가 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, 46]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 null이 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, null]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 undefined가 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, undefined]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 빈 문자열이 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, ""]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 문자열이 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, "abc"]);
+      }).toThrow("[ERROR]");
+    });
+
+    test("로또 번호에 소수가 포함되면 예외가 발생한다.", () => {
+      expect(() => {
+        new Lotto([1, 2, 3, 4, 5, 1.5]);
+      }).toThrow("[ERROR]");
+    });
   });
 
-  // TODO: 테스트가 통과하도록 프로덕션 코드 구현
-  test("로또 번호에 중복된 숫자가 있으면 예외가 발생한다.", () => {
-    expect(() => {
-      new Lotto([1, 2, 3, 4, 5, 5]);
-    }).toThrow("[ERROR]");
+  describe("numbers getter 테스트", () => {
+    test("numbers getter가 로또 번호를 반환한다.", () => {
+      const numbers = [1, 15, 25, 35, 40, 45];
+      const lotto = new Lotto(numbers);
+      expect(lotto.numbers).toEqual(numbers);
+    });
   });
 
-  // TODO: 추가 기능 구현에 따른 테스트 코드 작성
+  describe("getMatchCount 테스트", () => {
+    test("당첨 번호와 일치하는 개수를 반환한다.", () => {
+      const lotto = new Lotto([1, 2, 3, 4, 5, 6]);
+      const winningNumbers = [1, 2, 3, 7, 8, 9];
+      expect(lotto.getMatchCount(winningNumbers)).toBe(3);
+    });
+
+    test("일치하는 번호가 없으면 0을 반환한다.", () => {
+      const lotto = new Lotto([1, 2, 3, 4, 5, 6]);
+      const winningNumbers = [7, 8, 9, 10, 11, 12];
+      expect(lotto.getMatchCount(winningNumbers)).toBe(0);
+    });
+  });
+
+  describe("getHasBonus 테스트", () => {
+    test("보너스 번호가 포함되어 있으면 true를 반환한다.", () => {
+      const lotto = new Lotto([1, 2, 3, 4, 5, 6]);
+      expect(lotto.getHasBonus(6)).toBe(true);
+    });
+
+    test("보너스 번호가 포함되어 있지 않으면 false를 반환한다.", () => {
+      const lotto = new Lotto([1, 2, 3, 4, 5, 6]);
+      expect(lotto.getHasBonus(7)).toBe(false);
+    });
+  });
 });
diff --git a/__tests__/ValidateTest.js b/__tests__/ValidateTest.js
new file mode 100644
index 000000000..a9cd49311
--- /dev/null
+++ b/__tests__/ValidateTest.js
@@ -0,0 +1,143 @@
+import {
+  validateEmptyInput,
+  validatePositiveNumber,
+  validateThousandUnit,
+  validateLottoNumberRange,
+  validateNumbersLength,
+  validateDuplicateNumbers,
+} from "../src/validate.js";
+import { FIELD_NAMES } from "../src/const.js";
+
+describe("validateEmptyInput 테스트", () => {
+  test("빈 문자열이면 예외가 발생한다.", () => {
+    expect(() => {
+      validateEmptyInput("", FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+
+  test("null이면 예외가 발생한다.", () => {
+    expect(() => {
+      validateEmptyInput(null, FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+
+  test("undefined이면 예외가 발생한다.", () => {
+    expect(() => {
+      validateEmptyInput(undefined, FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+});
+
+describe("validatePositiveNumber 테스트", () => {
+  test("문자열이면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePositiveNumber("abc", FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+
+  test("소수이면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePositiveNumber(1000.5, FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+
+  test("0이면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePositiveNumber(0, FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+
+  test("음수이면 예외가 발생한다.", () => {
+    expect(() => {
+      validatePositiveNumber(-1000, FIELD_NAMES.PURCHASE_PRICE);
+    }).toThrow("[ERROR]");
+  });
+
+  test("양의 정수이면 정수를 반환한다.", () => {
+    const result = validatePositiveNumber("1000", FIELD_NAMES.PURCHASE_PRICE);
+    expect(result).toBe(1000);
+  });
+});
+
+describe("validateThousandUnit 테스트", () => {
+  test("1000으로 나누어떨어지지 않으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateThousandUnit(1500);
+    }).toThrow(`[ERROR]`);
+  });
+
+  test("1000단위이면 예외가 발생하지 않는다.", () => {
+    expect(() => {
+      validateThousandUnit(1000);
+    }).not.toThrow();
+  });
+});
+
+describe("validateLottoNumberRange 테스트", () => {
+  test("1보다 작으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateLottoNumberRange(0, FIELD_NAMES.LOTTO_NUMBERS);
+    }).toThrow("[ERROR]");
+  });
+
+  test("45보다 크면 예외가 발생한다.", () => {
+    expect(() => {
+      validateLottoNumberRange(46, FIELD_NAMES.LOTTO_NUMBERS);
+    }).toThrow("[ERROR]");
+  });
+
+  test("1~45 사이의 숫자이면 예외가 발생하지 않는다.", () => {
+    expect(() => {
+      validateLottoNumberRange(25, FIELD_NAMES.LOTTO_NUMBERS);
+    }).not.toThrow();
+  });
+});
+
+describe("validateNumbersLength 테스트", () => {
+  test("6개가 아니면 예외가 발생한다.", () => {
+    expect(() => {
+      validateNumbersLength([1, 2, 3, 4, 5], FIELD_NAMES.LOTTO_NUMBERS);
+    }).toThrow("[ERROR]");
+  });
+
+  test("6개보다 많으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateNumbersLength([1, 2, 3, 4, 5, 6, 7], FIELD_NAMES.LOTTO_NUMBERS);
+    }).toThrow("[ERROR]");
+  });
+
+  test("6개이면 예외가 발생하지 않는다.", () => {
+    expect(() => {
+      validateNumbersLength([1, 2, 3, 4, 5, 6], FIELD_NAMES.LOTTO_NUMBERS);
+    }).not.toThrow();
+  });
+});
+
+describe("validateDuplicateNumbers 테스트", () => {
+  test("중복된 숫자가 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateDuplicateNumbers([1, 2, 3, 4, 5, 5], FIELD_NAMES.LOTTO_NUMBERS);
+    }).toThrow("[ERROR]");
+  });
+
+  test("중복된 숫자가 여러 개 있으면 예외가 발생한다.", () => {
+    expect(() => {
+      validateDuplicateNumbers([1, 1, 2, 2, 3, 3], FIELD_NAMES.LOTTO_NUMBERS);
+    }).toThrow("[ERROR]");
+  });
+
+  test("중복된 숫자가 없으면 예외가 발생하지 않는다.", () => {
+    expect(() => {
+      validateDuplicateNumbers([1, 2, 3, 4, 5, 6], FIELD_NAMES.LOTTO_NUMBERS);
+    }).not.toThrow();
+  });
+
+  test("모든 숫자가 중복되지 않으면 예외가 발생하지 않는다.", () => {
+    expect(() => {
+      validateDuplicateNumbers(
+        [1, 15, 25, 35, 40, 45],
+        FIELD_NAMES.LOTTO_NUMBERS
+      );
+    }).not.toThrow();
+  });
+});
diff --git a/src/App.js b/src/App.js
index 091aa0a5d..45960a12a 100644
--- a/src/App.js
+++ b/src/App.js
@@ -1,5 +1,14 @@
+import { startLottoMachine } from "./lottoMachine.js";
+import { Console } from "@woowacourse/mission-utils";
+
 class App {
-  async run() {}
+  async run() {
+    try {
+      await startLottoMachine();
+    } catch (error) {
+      Console.print(error.message);
+    }
+  }
 }
 
 export default App;
diff --git a/src/Lotto.js b/src/Lotto.js
index cb0b1527e..a36b247b4 100644
--- a/src/Lotto.js
+++ b/src/Lotto.js
@@ -1,5 +1,13 @@
+import {
+  validateDuplicateNumbers,
+  validateEmptyInput,
+  validateLottoNumberRange,
+  validateNumbersLength,
+  validatePositiveNumber,
+} from "./validate.js";
+
 class Lotto {
-  #numbers;
+  #numbers; // 로또 번호
 
   constructor(numbers) {
     this.#validate(numbers);
@@ -7,12 +15,27 @@ class Lotto {
   }
 
   #validate(numbers) {
-    if (numbers.length !== 6) {
-      throw new Error("[ERROR] 로또 번호는 6개여야 합니다.");
-    }
+    const validateField = "로또 번호";
+    validateNumbersLength(numbers, validateField);
+    validateDuplicateNumbers(numbers, validateField);
+    numbers.forEach((num) => {
+      validateEmptyInput(num, validateField);
+      validatePositiveNumber(num, validateField);
+      validateLottoNumberRange(num, validateField);
+    });
+  }
+
+  get numbers() {
+    return this.#numbers;
   }
 
-  // TODO: 추가 기능 구현
+  getMatchCount(winningNumbers) {
+    return this.#numbers.filter((num) => winningNumbers.includes(num)).length;
+  }
+
+  getHasBonus(bonusNumber) {
+    return this.#numbers.includes(bonusNumber);
+  }
 }
 
 export default Lotto;
diff --git a/src/const.js b/src/const.js
new file mode 100644
index 000000000..ef36eb81e
--- /dev/null
+++ b/src/const.js
@@ -0,0 +1,40 @@
+export const ERROR_HEADER = "[ERROR]";
+
+export const PURCHASE_UNIT = 1000;
+
+export const FIELD_NAMES = {
+  PURCHASE_PRICE: "구입금액",
+  WINNING_NUMBERS: "당첨 번호",
+  BONUS_NUMBERS: "보너스 번호",
+  LOTTO_NUMBERS: "로또 번호",
+};
+
+export const winningInfo = [
+  {
+    match: 3,
+    prizeMoney: 5000,
+    count: 0,
+  },
+  {
+    match: 4,
+    prizeMoney: 50000,
+    count: 0,
+  },
+  {
+    match: 5,
+    prizeMoney: 1500000,
+    count: 0,
+  },
+  {
+    match: 5,
+    prizeMoney: 30000000,
+    count: 0,
+  },
+  {
+    match: 6,
+    prizeMoney: 2000000000,
+    count: 0,
+  },
+];
+
+export const BONUS_PRIZE_INDEX = 3;
diff --git a/src/lottoMachine.js b/src/lottoMachine.js
new file mode 100644
index 000000000..aa173fe7b
--- /dev/null
+++ b/src/lottoMachine.js
@@ -0,0 +1,172 @@
+import { Console, MissionUtils } from "@woowacourse/mission-utils";
+import Lotto from "./Lotto.js";
+import {
+  validateDuplicateNumbers,
+  validateEmptyInput,
+  validateLottoNumberRange,
+  validateNumbersLength,
+  validatePositiveNumber,
+  validateThousandUnit,
+} from "./validate.js";
+import {
+  BONUS_PRIZE_INDEX,
+  FIELD_NAMES,
+  PURCHASE_UNIT,
+  winningInfo,
+} from "./const.js";
+
+export const validatePurchasePrice = (rawInput) => {
+  const input = rawInput.trim();
+  validateEmptyInput(input, FIELD_NAMES.PURCHASE_PRICE);
+  const numberInput = validatePositiveNumber(input, FIELD_NAMES.PURCHASE_PRICE);
+  validateThousandUnit(numberInput);
+
+  return numberInput;
+};
+
+const inputPurchasePrice = async () => {
+  const rawInput = await Console.readLineAsync(
+    `\n${FIELD_NAMES.PURCHASE_PRICE}을 입력해 주세요.\n`
+  );
+  return validatePurchasePrice(rawInput);
+};
+
+export const calcPurchaseCount = (price) => {
+  const purchaseNum = Number(price) / PURCHASE_UNIT;
+  return purchaseNum;
+};
+
+export const createLottoNumbers = (purchaseNum) => {
+  const lottoArray = [];
+
+  for (let i = 1; i <= purchaseNum; i++) {
+    const lottoNumbers = MissionUtils.Random.pickUniqueNumbersInRange(1, 45, 6);
+    const sortedLottoNumbers = lottoNumbers.sort(
+      (first, second) => first - second
+    );
+    lottoArray.push(new Lotto(sortedLottoNumbers));
+  }
+
+  return lottoArray;
+};
+
+const printLottoArray = (lottoArray) => {
+  lottoArray.forEach((lotto) => {
+    Console.print(`[${lotto.numbers.join(", ")}]`);
+  });
+};
+
+export const validateWinningNumbers = (rawInput) => {
+  const splitArray = rawInput.trim().split(",");
+  const numberArray = splitArray.map((input) => {
+    validateEmptyInput(input, FIELD_NAMES.WINNING_NUMBERS);
+    const numberInput = validatePositiveNumber(
+      input,
+      FIELD_NAMES.WINNING_NUMBERS
+    );
+    validateLottoNumberRange(numberInput, FIELD_NAMES.WINNING_NUMBERS);
+    return numberInput;
+  });
+  validateNumbersLength(numberArray, FIELD_NAMES.WINNING_NUMBERS);
+  validateDuplicateNumbers(numberArray, FIELD_NAMES.WINNING_NUMBERS);
+  return numberArray;
+};
+
+const inputWinningNumbers = async () => {
+  const rawInput = await Console.readLineAsync(
+    `\n${FIELD_NAMES.WINNING_NUMBERS}를 입력해 주세요.\n`
+  );
+  return validateWinningNumbers(rawInput);
+};
+
+export const validateBonusNumber = (rawInput, winningNumbers) => {
+  const input = rawInput.trim();
+  validateEmptyInput(input, FIELD_NAMES.BONUS_NUMBERS);
+  const numberInput = validatePositiveNumber(input, FIELD_NAMES.BONUS_NUMBERS);
+  validateLottoNumberRange(numberInput);
+  validateDuplicateNumbers(
+    [...winningNumbers, numberInput],
+    FIELD_NAMES.BONUS_NUMBERS
+  );
+
+  return numberInput;
+};
+
+const inputBonusNumber = async (winningNumbers) => {
+  const rawInput = await Console.readLineAsync(
+    `\n${FIELD_NAMES.BONUS_NUMBERS}를 입력해 주세요.\n`
+  );
+  return validateBonusNumber(rawInput, winningNumbers);
+};
+
+export const incrementCount = (result, matchCount, hasBonus) => {
+  if (matchCount < 3) {
+    return;
+  }
+  if (matchCount === 5 && hasBonus) {
+    result[BONUS_PRIZE_INDEX].count += 1;
+    return;
+  }
+
+  const target = result.find((item) => item.match === matchCount);
+  if (!target) {
+    return;
+  }
+  target.count += 1;
+};
+
+export const calcWinningResult = (lottoArray, winningNumbers, bonusNumber) => {
+  const result = structuredClone(winningInfo);
+
+  lottoArray.forEach((lotto) => {
+    const matchCount = lotto.getMatchCount(winningNumbers);
+    const hasBonus = lotto.getHasBonus(bonusNumber);
+
+    incrementCount(result, matchCount, hasBonus);
+  });
+
+  return result;
+};
+
+const setWinningResultMessage = (item, index) => {
+  const formattedPrice = item.prizeMoney.toLocaleString();
+  if (index === BONUS_PRIZE_INDEX) {
+    Console.print(
+      `${item.match}개 일치, 보너스 볼 일치 (${formattedPrice}원) - ${item.count}개`
+    );
+  } else {
+    Console.print(
+      `${item.match}개 일치 (${formattedPrice}원) - ${item.count}개`
+    );
+  }
+};
+
+const printWinningResult = (result) => {
+  result.forEach((item, index) => {
+    setWinningResultMessage(item, index);
+  });
+};
+
+export const calcTotalYield = (result, purchasePrice) => {
+  let totalPrice = 0;
+  result.forEach((item) => {
+    totalPrice += item.count * item.prizeMoney;
+  });
+  const totalYield = (totalPrice / purchasePrice) * 100;
+  return totalYield.toFixed(1);
+};
+
+export const startLottoMachine = async () => {
+  const purchasePrice = await inputPurchasePrice();
+  const purchaseCount = calcPurchaseCount(purchasePrice);
+  Console.print(`\n${purchaseCount}개를 구매했습니다.`);
+  const lottoArray = createLottoNumbers(purchaseCount);
+  printLottoArray(lottoArray);
+  const winningNumbers = await inputWinningNumbers();
+  const bonusNumber = await inputBonusNumber(winningNumbers);
+  Console.print("\n당첨 통계\n---");
+  const result = calcWinningResult(lottoArray, winningNumbers, bonusNumber);
+  printWinningResult(result);
+  const totalYield = calcTotalYield(result, purchasePrice);
+  Console.print(`총 수익률은 ${totalYield}%입니다.`);
+};
diff --git a/src/validate.js b/src/validate.js
new file mode 100644
index 000000000..8ebcd219e
--- /dev/null
+++ b/src/validate.js
@@ -0,0 +1,55 @@
+import { ERROR_HEADER, PURCHASE_UNIT } from "./const.js";
+
+export const validateEmptyInput = (input, field) => {
+  if (!input || input === "") {
+    throw new Error(`${ERROR_HEADER} ${field}의 값이 존재하지 않습니다.`);
+  }
+};
+
+export const validatePositiveNumber = (input, field) => {
+  const numInput = Number(input);
+
+  if (Number.isNaN(numInput)) {
+    throw new Error(`${ERROR_HEADER} ${field}의 값은 숫자여야 합니다.`);
+  }
+  if (!Number.isInteger(numInput)) {
+    throw new Error(`${ERROR_HEADER} ${field}의 값은  정수여야 합니다.`);
+  }
+  if (numInput <= 0) {
+    throw new Error(
+      `${ERROR_HEADER} ${field}의 값은  1이상의 양의 정수여야 합니다.`
+    );
+  }
+  return numInput;
+};
+
+export const validateThousandUnit = (input) => {
+  if (Number(input) % PURCHASE_UNIT !== 0) {
+    throw new Error(
+      `${ERROR_HEADER} 구입 금액의 입력값은 ${PURCHASE_UNIT}단위 숫자로 입력해 주세요.`
+    );
+  }
+};
+
+export const validateLottoNumberRange = (input, field) => {
+  const numInput = Number(input);
+  const isLottoNumberRange = numInput >= 1 && numInput <= 45;
+  if (!isLottoNumberRange) {
+    throw new Error(
+      `${ERROR_HEADER} ${field}의 값은  1 ~ 45 이내의 숫자여야 합니다.`
+    );
+  }
+};
+
+export const validateNumbersLength = (numbers, field) => {
+  if (numbers.length !== 6) {
+    throw new Error(`${ERROR_HEADER} ${field}는 6개여야 합니다.`);
+  }
+};
+
+export const validateDuplicateNumbers = (numbers, field) => {
+  const uniqueNumbers = new Set(numbers);
+  if (uniqueNumbers.size !== numbers.length) {
+    throw new Error(`${ERROR_HEADER} ${field}에 중복된 숫자가 있습니다.`);
+  }
+};