From 2609eb3e34418b1b46369dd4c12222be2f0b822d Mon Sep 17 00:00:00 2001
From: Kieran O'Neill <hello@kieranoneill.com>
Date: Sun, 25 Feb 2024 18:12:20 +0200
Subject: [PATCH 1/3] feat: add verify modal to allow to input your merkle root

---
 app/components/Navigation/Navigation.tsx      |   7 -
 app/components/UploadCompleteModal/index.ts   |   1 +
 .../VerifyFileProofModal.tsx                  | 189 ++++++++++++++++++
 app/components/VerifyFileProofModal/index.ts  |   1 +
 .../VerifyFileProofModal/types/IProps.ts      |   9 +
 .../VerifyFileProofModal/types/index.ts       |   1 +
 app/constants/Routes.ts                       |   1 -
 app/files/page.tsx                            |  70 +++++--
 app/upload/page.tsx                           |   2 +-
 app/verify/page.tsx                           |  32 ---
 10 files changed, 250 insertions(+), 63 deletions(-)
 create mode 100644 app/components/UploadCompleteModal/index.ts
 create mode 100644 app/components/VerifyFileProofModal/VerifyFileProofModal.tsx
 create mode 100644 app/components/VerifyFileProofModal/index.ts
 create mode 100644 app/components/VerifyFileProofModal/types/IProps.ts
 create mode 100644 app/components/VerifyFileProofModal/types/index.ts
 delete mode 100644 app/verify/page.tsx

diff --git a/app/components/Navigation/Navigation.tsx b/app/components/Navigation/Navigation.tsx
index 67ac770..2329c69 100644
--- a/app/components/Navigation/Navigation.tsx
+++ b/app/components/Navigation/Navigation.tsx
@@ -15,7 +15,6 @@ import {
 import { useRouter } from 'next/navigation';
 import React, { FC } from 'react';
 import {
-  IoCheckmarkCircleOutline,
   IoChevronBackOutline,
   IoCloudUploadOutline,
   IoListOutline,
@@ -31,7 +30,6 @@ import {
   FILES_ROUTE,
   INDEX_ROUTE,
   UPLOAD_ROUTE,
-  VERIFY_ROUTE,
 } from '@app/constants';
 
 // hooks
@@ -60,11 +58,6 @@ const Navigation: FC<IProps> = ({ isOpen, onClose }) => {
       label: 'Files',
       route: FILES_ROUTE,
     },
-    {
-      icon: IoCheckmarkCircleOutline,
-      label: 'Verify',
-      route: VERIFY_ROUTE,
-    },
   ];
   // handlers
   const handleOnClose = () => onClose();
diff --git a/app/components/UploadCompleteModal/index.ts b/app/components/UploadCompleteModal/index.ts
new file mode 100644
index 0000000..b291cea
--- /dev/null
+++ b/app/components/UploadCompleteModal/index.ts
@@ -0,0 +1 @@
+export { default } from './UploadCompleteModal';
diff --git a/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx b/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx
new file mode 100644
index 0000000..2df881e
--- /dev/null
+++ b/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx
@@ -0,0 +1,189 @@
+import {
+  Button,
+  Code,
+  Heading,
+  HStack,
+  Icon,
+  Modal,
+  ModalBody,
+  ModalContent,
+  ModalFooter,
+  ModalHeader,
+  ModalOverlay,
+  Skeleton,
+  Spacer,
+  Text,
+  Textarea,
+  VStack,
+} from '@chakra-ui/react';
+import React, { ChangeEvent, FC, useState } from 'react';
+import {
+  IoCheckmarkCircleOutline,
+  IoCloseCircleOutline,
+} from 'react-icons/io5';
+
+// constants
+import { DEFAULT_GAP } from '@app/constants';
+
+// hooks
+import useDefaultTextColor from '@app/hooks/useDefaultTextColor';
+import useLogger from '@app/hooks/useLogger';
+import usePrimaryColorScheme from '@app/hooks/usePrimaryColorScheme';
+import useSubTextColor from '@app/hooks/useSubTextColor';
+
+// types
+import type { ILogger } from '@app/types';
+import type { IProps } from './types';
+
+// utils
+
+const VerifyFileProofModal: FC<IProps> = ({ file, onClose }) => {
+  // hooks
+  const defaultTextColor: string = useDefaultTextColor();
+  const logger: ILogger = useLogger();
+  const primaryColorScheme: string = usePrimaryColorScheme();
+  const subTextColor: string = useSubTextColor();
+  // state
+  const [rootValue, setRootValue] = useState<string | null>(null);
+  const [verified, setVerified] = useState<boolean>(false);
+  // handlers
+  const handleOnClose = () => onClose();
+  const handleRootValueChange = (event: ChangeEvent<HTMLTextAreaElement>) =>
+    setRootValue(event.target.value.length > 0 ? event.target.value : null);
+
+  return (
+    <Modal closeOnOverlayClick={false} isOpen={!!file} onClose={onClose}>
+      <ModalOverlay />
+
+      <ModalContent>
+        <ModalHeader>
+          <Heading color={defaultTextColor} size="md" textAlign="center">
+            {`Verify File Proof`}
+          </Heading>
+        </ModalHeader>
+
+        <ModalBody>
+          <VStack spacing={DEFAULT_GAP} w="full">
+            {/*description*/}
+            <Text color={defaultTextColor} textAlign="left" w="full">
+              {`Here is the Merkle proof for the file.`}
+            </Text>
+
+            {/*file name*/}
+            <HStack
+              alignItems="center"
+              justifyContent="space-between"
+              spacing={2}
+              w="full"
+            >
+              <Text color={defaultTextColor} fontSize="sm" textAlign="left">
+                {`Name:`}
+              </Text>
+
+              <Spacer />
+
+              <Text color={subTextColor} fontSize="sm" textAlign="right">
+                {file ? file.name : '-'}
+              </Text>
+            </HStack>
+
+            {/*hash*/}
+            <HStack
+              alignItems="center"
+              justifyContent="space-between"
+              spacing={2}
+              w="full"
+            >
+              <Text color={defaultTextColor} fontSize="sm" textAlign="left">
+                {`Hash:`}
+              </Text>
+
+              <Spacer />
+
+              <Code
+                fontSize="sm"
+                textAlign="left"
+                w="full"
+                wordBreak="break-word"
+              >
+                {file ? file.hash : '-'}
+              </Code>
+            </HStack>
+
+            {/*proof*/}
+            <Code fontSize="sm" textAlign="left" w="full">
+              {file ? JSON.stringify(file.proof) : '-'}
+            </Code>
+
+            <Text color={defaultTextColor} textAlign="left" w="full">
+              {`Enter the Merkle Root and see of the proof is verifiable:`}
+            </Text>
+
+            {/*root value input*/}
+            <Textarea
+              onChange={handleRootValueChange}
+              value={rootValue || ''}
+            />
+
+            {/*verified status*/}
+            <HStack
+              alignItems="center"
+              justifyContent="center"
+              minH={50}
+              spacing={2}
+              w="full"
+            >
+              {rootValue ? (
+                verified ? (
+                  <>
+                    <Icon
+                      as={IoCheckmarkCircleOutline}
+                      color="green.500"
+                      h={6}
+                      w={6}
+                    />
+
+                    <Text
+                      color="green.500"
+                      textAlign="left"
+                    >{`Proof Valid`}</Text>
+                  </>
+                ) : (
+                  <>
+                    <Icon
+                      as={IoCloseCircleOutline}
+                      color="red.500"
+                      h={6}
+                      w={6}
+                    />
+
+                    <Text
+                      color="red.500"
+                      textAlign="left"
+                    >{`Proof Invalid`}</Text>
+                  </>
+                )
+              ) : null}
+            </HStack>
+          </VStack>
+        </ModalBody>
+
+        <ModalFooter>
+          <HStack justifyContent="flex-end" spacing={2} w="full">
+            <Button
+              colorScheme={primaryColorScheme}
+              onClick={handleOnClose}
+              variant="solid"
+            >
+              {`Cancel`}
+            </Button>
+          </HStack>
+        </ModalFooter>
+      </ModalContent>
+    </Modal>
+  );
+};
+
+VerifyFileProofModal.displayName = 'VerifyFileProofModal';
+
+export default VerifyFileProofModal;
diff --git a/app/components/VerifyFileProofModal/index.ts b/app/components/VerifyFileProofModal/index.ts
new file mode 100644
index 0000000..479adf1
--- /dev/null
+++ b/app/components/VerifyFileProofModal/index.ts
@@ -0,0 +1 @@
+export { default } from './VerifyFileProofModal';
diff --git a/app/components/VerifyFileProofModal/types/IProps.ts b/app/components/VerifyFileProofModal/types/IProps.ts
new file mode 100644
index 0000000..15ff878
--- /dev/null
+++ b/app/components/VerifyFileProofModal/types/IProps.ts
@@ -0,0 +1,9 @@
+// types
+import type { IFileResponse } from '@app/types';
+
+interface IProps {
+  file: IFileResponse | null;
+  onClose: () => void;
+}
+
+export default IProps;
diff --git a/app/components/VerifyFileProofModal/types/index.ts b/app/components/VerifyFileProofModal/types/index.ts
new file mode 100644
index 0000000..f404dee
--- /dev/null
+++ b/app/components/VerifyFileProofModal/types/index.ts
@@ -0,0 +1 @@
+export type { default as IProps } from './IProps';
diff --git a/app/constants/Routes.ts b/app/constants/Routes.ts
index 71548dd..164ccfe 100644
--- a/app/constants/Routes.ts
+++ b/app/constants/Routes.ts
@@ -1,4 +1,3 @@
 export const FILES_ROUTE: string = '/files';
 export const INDEX_ROUTE: string = '/';
 export const UPLOAD_ROUTE: string = '/upload';
-export const VERIFY_ROUTE: string = '/verify';
diff --git a/app/files/page.tsx b/app/files/page.tsx
index 833cea3..4eef9b4 100644
--- a/app/files/page.tsx
+++ b/app/files/page.tsx
@@ -17,11 +17,12 @@ import {
   VStack,
 } from '@chakra-ui/react';
 import { NextPage } from 'next';
-import React from 'react';
-import { IoDownloadOutline } from 'react-icons/io5';
+import React, { useState } from 'react';
+import { IoCheckmarkDoneOutline, IoDownloadOutline } from 'react-icons/io5';
 
 // components
 import CopyIconButton from '@app/components/CopyIconButton';
+import VerifyFileProofModal from '@app/components/VerifyFileProofModal';
 
 // constants
 import { DEFAULT_GAP } from '@app/constants';
@@ -44,9 +45,14 @@ const FilesPage: NextPage = () => {
   const defaultTextColor: string = useDefaultTextColor();
   const subTextColor: string = useSubTextColor();
   const { files, loading } = useFiles();
+  // state
+  const [fileToVerify, setFileToVerify] = useState<IFileResponse | null>(null);
   // handlers
   const handleDownloadProofClick = (file: IFileResponse) => () =>
     downloadJSONFile(file.hash, file.proof);
+  const handleVerifyFileProofClick = (file: IFileResponse) => () =>
+    setFileToVerify(file);
+  const handleVerifyFileProofModalClose = () => setFileToVerify(null);
   // renders
   const renderContent = () => {
     let fileKeys: string[];
@@ -125,6 +131,19 @@ const FilesPage: NextPage = () => {
                           variant="ghost"
                         />
                       </Tooltip>
+
+                      {/*verify proof*/}
+                      <Tooltip label={`Verify Proof`}>
+                        <IconButton
+                          _hover={{ bg: buttonHoverBackgroundColor }}
+                          aria-label="Verify proof"
+                          color={defaultTextColor}
+                          icon={<IoCheckmarkDoneOutline />}
+                          onClick={handleVerifyFileProofClick(file)}
+                          size="md"
+                          variant="ghost"
+                        />
+                      </Tooltip>
                     </HStack>
                   ))}
                 </AccordionPanel>
@@ -146,33 +165,40 @@ const FilesPage: NextPage = () => {
   };
 
   return (
-    <VStack
-      alignItems="center"
-      justifyContent="flex-start"
-      flexGrow={1}
-      spacing={DEFAULT_GAP}
-      w="full"
-    >
-      {/*heading*/}
-      <Heading color={defaultTextColor} size="lg" textAlign="center" w="full">
-        {`Files`}
-      </Heading>
-
-      {/*description*/}
-      <Text color={defaultTextColor} size="md" textAlign="center" w="full">
-        {`Below is a list of files, grouped by their merkle tree roots. You can download a file's proof and use the root you received to verify the file's integrity.`}
-      </Text>
+    <>
+      <VerifyFileProofModal
+        file={fileToVerify}
+        onClose={handleVerifyFileProofModalClose}
+      />
 
       <VStack
         alignItems="center"
+        justifyContent="flex-start"
         flexGrow={1}
-        justify="flex-start"
-        spacing={DEFAULT_GAP - 2}
+        spacing={DEFAULT_GAP}
         w="full"
       >
-        {renderContent()}
+        {/*heading*/}
+        <Heading color={defaultTextColor} size="lg" textAlign="center" w="full">
+          {`Files`}
+        </Heading>
+
+        {/*description*/}
+        <Text color={defaultTextColor} size="md" textAlign="center" w="full">
+          {`Below is a list of files, grouped by their merkle tree roots. You can download a file's proof and use the root you received to verify the file's integrity.`}
+        </Text>
+
+        <VStack
+          alignItems="center"
+          flexGrow={1}
+          justify="flex-start"
+          spacing={DEFAULT_GAP - 2}
+          w="full"
+        >
+          {renderContent()}
+        </VStack>
       </VStack>
-    </VStack>
+    </>
   );
 };
 
diff --git a/app/upload/page.tsx b/app/upload/page.tsx
index 3ee7188..e94999e 100644
--- a/app/upload/page.tsx
+++ b/app/upload/page.tsx
@@ -24,7 +24,7 @@ import React, { ChangeEvent, MutableRefObject, useRef, useState } from 'react';
 import { IoCloudUploadOutline, IoDocumentsOutline } from 'react-icons/io5';
 
 // components
-import UploadCompleteModal from '@app/components/UploadCompleteModal/UploadCompleteModal';
+import UploadCompleteModal from '@app/components/UploadCompleteModal';
 
 // constants
 import { DEFAULT_GAP, FILES_PATH, UPLOAD_PATH } from '@app/constants';
diff --git a/app/verify/page.tsx b/app/verify/page.tsx
deleted file mode 100644
index 3da65e9..0000000
--- a/app/verify/page.tsx
+++ /dev/null
@@ -1,32 +0,0 @@
-'use client';
-import { Heading, VStack } from '@chakra-ui/react';
-import { NextPage } from 'next';
-import React from 'react';
-
-// constants
-import { DEFAULT_GAP } from '@app/constants';
-
-// hooks
-import useDefaultTextColor from '@app/hooks/useDefaultTextColor';
-
-const VerifyPage: NextPage = () => {
-  // hooks
-  const defaultTextColor: string = useDefaultTextColor();
-
-  return (
-    <VStack
-      alignItems="center"
-      justifyContent="flex-start"
-      flexGrow={1}
-      spacing={DEFAULT_GAP}
-      w="full"
-    >
-      {/*heading*/}
-      <Heading color={defaultTextColor} size="lg" textAlign="center" w="full">
-        {`Verify`}
-      </Heading>
-    </VStack>
-  );
-};
-
-export default VerifyPage;

From 6f4ca79f2d02ed3efed999554b2ac93c988445d6 Mon Sep 17 00:00:00 2001
From: Kieran O'Neill <hello@kieranoneill.com>
Date: Sun, 25 Feb 2024 19:42:17 +0200
Subject: [PATCH 2/3] feat: add modal to verify merkle proof

---
 .../VerifyFileProofModal.tsx                  |  41 ++-
 app/files/page.tsx                            |   2 +-
 app/utils/sha256/index.ts                     |   1 +
 app/utils/sha256/sha256.ts                    |  15 ++
 app/utils/verifyMerkleProof/index.ts          |   1 +
 .../verifyMerkleProof/verifyMerkleProof.ts    |  50 ++++
 internal/merkletree/merkletree.go             |   4 +-
 internal/routes/files.go                      | 239 +++++++++---------
 internal/utils/filedirectory.go               |   5 +
 9 files changed, 218 insertions(+), 140 deletions(-)
 create mode 100644 app/utils/sha256/index.ts
 create mode 100644 app/utils/sha256/sha256.ts
 create mode 100644 app/utils/verifyMerkleProof/index.ts
 create mode 100644 app/utils/verifyMerkleProof/verifyMerkleProof.ts

diff --git a/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx b/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx
index 2df881e..befa0d9 100644
--- a/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx
+++ b/app/components/VerifyFileProofModal/VerifyFileProofModal.tsx
@@ -10,13 +10,12 @@ import {
   ModalFooter,
   ModalHeader,
   ModalOverlay,
-  Skeleton,
   Spacer,
   Text,
   Textarea,
   VStack,
 } from '@chakra-ui/react';
-import React, { ChangeEvent, FC, useState } from 'react';
+import React, { ChangeEvent, FC, useEffect, useState } from 'react';
 import {
   IoCheckmarkCircleOutline,
   IoCloseCircleOutline,
@@ -27,29 +26,48 @@ import { DEFAULT_GAP } from '@app/constants';
 
 // hooks
 import useDefaultTextColor from '@app/hooks/useDefaultTextColor';
-import useLogger from '@app/hooks/useLogger';
 import usePrimaryColorScheme from '@app/hooks/usePrimaryColorScheme';
 import useSubTextColor from '@app/hooks/useSubTextColor';
 
 // types
-import type { ILogger } from '@app/types';
 import type { IProps } from './types';
 
 // utils
+import verifyMerkleProof from '@app/utils/verifyMerkleProof';
 
 const VerifyFileProofModal: FC<IProps> = ({ file, onClose }) => {
   // hooks
   const defaultTextColor: string = useDefaultTextColor();
-  const logger: ILogger = useLogger();
   const primaryColorScheme: string = usePrimaryColorScheme();
   const subTextColor: string = useSubTextColor();
   // state
-  const [rootValue, setRootValue] = useState<string | null>(null);
+  const [rootValue, setRootValue] = useState<string>('');
   const [verified, setVerified] = useState<boolean>(false);
+  // reset
+  const reset = () => {
+    setRootValue('');
+    setVerified(false);
+  };
   // handlers
-  const handleOnClose = () => onClose();
-  const handleRootValueChange = (event: ChangeEvent<HTMLTextAreaElement>) =>
-    setRootValue(event.target.value.length > 0 ? event.target.value : null);
+  const handleOnClose = () => {
+    reset();
+    onClose();
+  };
+  const handleRootValueChange = async (
+    event: ChangeEvent<HTMLTextAreaElement>
+  ) => setRootValue(event.target.value);
+
+  useEffect(() => {
+    (async () => {
+      let isValidRoot: boolean = verified;
+
+      if (file) {
+        isValidRoot = await verifyMerkleProof(rootValue, file.proof);
+      }
+
+      setVerified(isValidRoot);
+    })();
+  }, [rootValue]);
 
   return (
     <Modal closeOnOverlayClick={false} isOpen={!!file} onClose={onClose}>
@@ -120,10 +138,7 @@ const VerifyFileProofModal: FC<IProps> = ({ file, onClose }) => {
             </Text>
 
             {/*root value input*/}
-            <Textarea
-              onChange={handleRootValueChange}
-              value={rootValue || ''}
-            />
+            <Textarea onChange={handleRootValueChange} value={rootValue} />
 
             {/*verified status*/}
             <HStack
diff --git a/app/files/page.tsx b/app/files/page.tsx
index 4eef9b4..418be15 100644
--- a/app/files/page.tsx
+++ b/app/files/page.tsx
@@ -68,7 +68,7 @@ const FilesPage: NextPage = () => {
 
       if (fileKeys.length > 0) {
         return (
-          <Accordion allowMultiple={true} allowToggle={true} w="full">
+          <Accordion allowMultiple={true} w="full">
             {fileKeys.map((key, fileKeyIndex) => (
               <AccordionItem key={`files-page-${key}-${fileKeyIndex}`}>
                 {/*accordian button*/}
diff --git a/app/utils/sha256/index.ts b/app/utils/sha256/index.ts
new file mode 100644
index 0000000..f401424
--- /dev/null
+++ b/app/utils/sha256/index.ts
@@ -0,0 +1 @@
+export { default } from './sha256';
diff --git a/app/utils/sha256/sha256.ts b/app/utils/sha256/sha256.ts
new file mode 100644
index 0000000..5119684
--- /dev/null
+++ b/app/utils/sha256/sha256.ts
@@ -0,0 +1,15 @@
+/**
+ * Convenience function that hashes a string using the SHA-256 algorithm and returns as a hexadecimal encoded string.
+ * @param {string} input - string to hash.
+ * @returns {string} the input hashed using SHA-256 and encoded in hexadecimal.
+ */
+export default async function sha256(input: string): Promise<string> {
+  const hashBuffer: ArrayBuffer = await crypto.subtle.digest(
+    'SHA-256',
+    new TextEncoder().encode(input)
+  );
+
+  return Array.from(new Uint8Array(hashBuffer)) // convert buffer to bytes
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join(''); // convert bytes to hex string
+}
diff --git a/app/utils/verifyMerkleProof/index.ts b/app/utils/verifyMerkleProof/index.ts
new file mode 100644
index 0000000..a609b6d
--- /dev/null
+++ b/app/utils/verifyMerkleProof/index.ts
@@ -0,0 +1 @@
+export { default } from './verifyMerkleProof';
diff --git a/app/utils/verifyMerkleProof/verifyMerkleProof.ts b/app/utils/verifyMerkleProof/verifyMerkleProof.ts
new file mode 100644
index 0000000..338e3c8
--- /dev/null
+++ b/app/utils/verifyMerkleProof/verifyMerkleProof.ts
@@ -0,0 +1,50 @@
+// enums
+import { LeafPositionEnum } from '@app/enums';
+
+// types
+import type { IFileProofItem } from '@app/types';
+
+// utils
+import sha256 from '@app/utils/sha256';
+
+/**
+ * Verifies that a supplied Merkle root is valid for a Merkle proof.
+ * @param {string} root - the root to check against the Merkle proof.
+ * @param {IFileProofItem[]} proof - the Merkle proof.
+ * @returns {Promise<boolean>} true, if the Merkle root supplied and the calculated Merkle root from the Merkle proof
+ * match, false otherwise.
+ */
+export default async function verifyMerkleProof(
+  root: string,
+  proof: IFileProofItem[]
+): Promise<boolean> {
+  let leafHash: string | null = null;
+  let value: IFileProofItem;
+
+  // if the merkle tree proof is empty, the root is not in there :P
+  if (proof.length <= 0) {
+    return false;
+  }
+
+  for (let i: number = 0; i < proof.length; i++) {
+    value = proof[i];
+
+    // if we are at the first element just use the first hash
+    if (i === 0) {
+      leafHash = value.hash;
+
+      continue;
+    }
+
+    // if the next leaf is a left leaf, create the parent with the right leaf
+    if (value.position === LeafPositionEnum.Left) {
+      leafHash = await sha256(`${value.hash}${leafHash}`);
+      continue;
+    }
+
+    // if the next leaf is a right leaf, create the parent with the left leaf
+    leafHash = await sha256(`${leafHash}${value.hash}`);
+  }
+
+  return leafHash === root;
+}
diff --git a/internal/merkletree/merkletree.go b/internal/merkletree/merkletree.go
index e053aa9..442e916 100644
--- a/internal/merkletree/merkletree.go
+++ b/internal/merkletree/merkletree.go
@@ -174,13 +174,13 @@ func VerifyMerkleTreeProof(root string, proof []*types.MerkleTreeProofItem) bool
 			continue
 		}
 
-		// if the next leaf is a left leaf, create the parent
+		// if the next leaf is a left leaf, create the parent with the right leaf
 		if value.Position == constants.Left {
 			leafHash = createHashPair(value.Hash, leafHash)
 			continue
 		}
 
-		// if the next leaf is a right leaf, create the parent
+		// if the next leaf is a right leaf, create the parent with the left leaf
 		leafHash = createHashPair(leafHash, value.Hash)
 	}
 
diff --git a/internal/routes/files.go b/internal/routes/files.go
index be73aa5..43c7aef 100644
--- a/internal/routes/files.go
+++ b/internal/routes/files.go
@@ -1,160 +1,151 @@
 package routes
 
 import (
-	"aether/internal/constants"
-	"aether/internal/errors"
-	"aether/internal/merkletree"
-	"aether/internal/types"
-	"aether/internal/utils"
-	"fmt"
-	"github.com/labstack/echo/v4"
-	"net/http"
-	"sort"
+  "aether/internal/constants"
+  "aether/internal/errors"
+  "aether/internal/merkletree"
+  "aether/internal/types"
+  "aether/internal/utils"
+  "fmt"
+  "github.com/labstack/echo/v4"
+  "net/http"
 )
 
 func NewGetFilesRoute() echo.HandlerFunc {
-	return func(c echo.Context) error {
-		var filesResponse map[string][]*types.FileResponse
-		var hashes []string
-		var readError *errors.ReadError
-
-		fileDirectories, err := utils.GetAllFileDirectories()
-		if err != nil {
-			readError = errors.NewReadError("failed to get file directories", err)
-
-			fmt.Println(readError)
-
-			return c.JSON(http.StatusInternalServerError, readError)
-		}
-
-		filesResponse = map[string][]*types.FileResponse{}
-
-		// add the merkle proofs to the file directories
-		for key, fileDirectory := range fileDirectories {
-			hashes = utils.ExtractHashesFromFileDirectory(fileDirectory)
-			sort.Slice(hashes, func(i int, j int) bool {
-				return hashes[i] < hashes[j]
-			})
-
-			for _, value := range fileDirectory {
-				filesResponse[key] = append(filesResponse[key], &types.FileResponse{
-					Hash:  value.Hash,
-					Name:  value.Name,
-					Proof: merkletree.GenerateMerkleTreeProof(value.Hash, hashes),
-				})
-			}
-		}
-
-		return c.JSON(http.StatusOK, filesResponse)
-	}
+  return func(c echo.Context) error {
+    var filesResponse map[string][]*types.FileResponse
+    var hashes []string
+    var readError *errors.ReadError
+
+    fileDirectories, err := utils.GetAllFileDirectories()
+    if err != nil {
+      readError = errors.NewReadError("failed to get file directories", err)
+
+      fmt.Println(readError)
+
+      return c.JSON(http.StatusInternalServerError, readError)
+    }
+
+    filesResponse = map[string][]*types.FileResponse{}
+
+    // add the merkle proofs to the file directories
+    for key, fileDirectory := range fileDirectories {
+      hashes = utils.ExtractHashesFromFileDirectory(fileDirectory)
+      
+      for _, value := range fileDirectory {
+        filesResponse[key] = append(filesResponse[key], &types.FileResponse{
+          Hash:  value.Hash,
+          Name:  value.Name,
+          Proof: merkletree.GenerateMerkleTreeProof(value.Hash, hashes),
+        })
+      }
+    }
+
+    return c.JSON(http.StatusOK, filesResponse)
+  }
 }
 
 func NewPostFilesUploadRoute() echo.HandlerFunc {
-	return func(c echo.Context) error {
-		var fileDirectory []*types.FileDirectoryItem
-		var files []*types.FileReadData
-		var readError *errors.ReadError
-		var writeError *errors.WriteError
+  return func(c echo.Context) error {
+    var fileDirectory []*types.FileDirectoryItem
+    var files []*types.FileReadData
+    var readError *errors.ReadError
+    var writeError *errors.WriteError
 
-		form, err := c.MultipartForm()
-		if err != nil {
-			fmt.Println(err)
+    form, err := c.MultipartForm()
+    if err != nil {
+      fmt.Println(err)
 
-			return c.JSON(http.StatusInternalServerError, err)
-		}
+      return c.JSON(http.StatusInternalServerError, err)
+    }
 
-		formFiles := form.File["file"]
+    formFiles := form.File["file"]
 
-		// iterate through each file, hash it and copy it to the .files/<subDirName> directory
-		for _, fileHeader := range formFiles {
-			// read file
-			uploadFile, err := fileHeader.Open()
-			if err != nil {
-				readError = errors.NewReadError(fmt.Sprintf("failed to read file %s", fileHeader.Filename), err)
+    // iterate through each file, hash it and copy it to the .files/<subDirName> directory
+    for _, fileHeader := range formFiles {
+      // read file
+      uploadFile, err := fileHeader.Open()
+      if err != nil {
+        readError = errors.NewReadError(fmt.Sprintf("failed to read file %s", fileHeader.Filename), err)
 
-				fmt.Println(readError)
+        fmt.Println(readError)
 
-				return c.JSON(http.StatusInternalServerError, readError)
-			}
-			defer uploadFile.Close()
+        return c.JSON(http.StatusInternalServerError, readError)
+      }
+      defer uploadFile.Close()
 
-			// get a hash of the file
-			fileHash, err := utils.HashFile(uploadFile, fileHeader.Filename)
-			if err != nil {
-				hashError := errors.NewHashError(fmt.Sprintf("unable to hash file %s", fileHeader.Filename), err)
+      // get a hash of the file
+      fileHash, err := utils.HashFile(uploadFile, fileHeader.Filename)
+      if err != nil {
+        hashError := errors.NewHashError(fmt.Sprintf("unable to hash file %s", fileHeader.Filename), err)
 
-				fmt.Println(hashError)
+        fmt.Println(hashError)
 
-				return c.JSON(http.StatusInternalServerError, hashError)
-			}
+        return c.JSON(http.StatusInternalServerError, hashError)
+      }
 
-			fmt.Println(fmt.Sprintf("file %s has a hash of %s", fileHeader.Filename, fileHash))
+      fmt.Println(fmt.Sprintf("file %s has a hash of %s", fileHeader.Filename, fileHash))
 
-			// add files so they can be written to storage when we have the merkle root
-			files = append(files, &types.FileReadData{
-				File: uploadFile,
-				Name: fileHeader.Filename,
-			})
+      // add files so they can be written to storage when we have the merkle root
+      files = append(files, &types.FileReadData{
+        File: uploadFile,
+        Name: fileHeader.Filename,
+      })
 
-			// add to the directory
-			fileDirectory = append(fileDirectory, &types.FileDirectoryItem{
-				Hash: fileHash,
-				Name: fileHeader.Filename,
-			})
-		}
+      // add to the directory
+      fileDirectory = append(fileDirectory, &types.FileDirectoryItem{
+        Hash: fileHash,
+        Name: fileHeader.Filename,
+      })
+    }
 
-		// sort the files by hash
-		sort.Slice(fileDirectory, func(i int, j int) bool {
-			return fileDirectory[i].Hash < fileDirectory[j].Hash
-		})
+    // create a merkle root
+    merkleRoot := merkletree.GenerateMerkleTreeRoot(utils.ExtractHashesFromFileDirectory(fileDirectory))
 
-		// create a merkle root
-		merkleRoot := merkletree.GenerateMerkleTreeRoot(utils.ExtractHashesFromFileDirectory(fileDirectory))
+    fmt.Println(fmt.Sprintf("created merkle root %s", merkleRoot))
 
-		fmt.Println(fmt.Sprintf("created merkle root %s", merkleRoot))
+    // if we have an empty merkle root, no files were uploaded
+    if merkleRoot == "" {
+      fmt.Println("empty merkle root there was no files added to directory")
 
-		// if we have an empty merkle root, no files were uploaded
-		if merkleRoot == "" {
-			fmt.Println("empty merkle root there was no files added to directory")
+      return c.NoContent(http.StatusBadRequest)
+    }
 
-			return c.NoContent(http.StatusBadRequest)
-		}
+    // create a subdirectory to store the files using the merkle root hash as the directory name
+    dirName := fmt.Sprintf("%s/%s", constants.RootFileDirectory, merkleRoot)
+    err = utils.CreateDir(dirName)
+    if err != nil {
+      writeError = errors.NewWriteError(fmt.Sprintf("failed create the %s directory", dirName), err)
 
-		// create a subdirectory to store the files using the merkle root hash as the directory name
-		dirName := fmt.Sprintf("%s/%s", constants.RootFileDirectory, merkleRoot)
-		err = utils.CreateDir(dirName)
-		if err != nil {
-			writeError = errors.NewWriteError(fmt.Sprintf("failed create the %s directory", dirName), err)
+      fmt.Println(writeError)
 
-			fmt.Println(writeError)
+      return c.JSON(http.StatusInternalServerError, writeError)
+    }
 
-			return c.JSON(http.StatusInternalServerError, writeError)
-		}
+    // add the files to the directory
+    err = utils.SaveFilesToDir(dirName, files)
+    if err != nil {
+      writeError = errors.NewWriteError(fmt.Sprintf("failed write files to %s", dirName), err)
 
-		// add the files to the directory
-		err = utils.SaveFilesToDir(dirName, files)
-		if err != nil {
-			writeError = errors.NewWriteError(fmt.Sprintf("failed write files to %s", dirName), err)
+      fmt.Println(writeError)
 
-			fmt.Println(writeError)
+      return c.JSON(http.StatusInternalServerError, writeError)
+    }
 
-			return c.JSON(http.StatusInternalServerError, writeError)
-		}
+    fmt.Println(fmt.Sprintf("added files to directory %s", dirName))
 
-		fmt.Println(fmt.Sprintf("added files to directory %s", dirName))
+    // create a file directory json in the directory
+    err = utils.WriteFileDirectoryJSONToStorage(dirName, fileDirectory)
+    if err != nil {
+      fmt.Println(fmt.Sprintf("failed to create file directory json at %s", dirName))
+    }
 
-		// create a file directory json in the directory
-		err = utils.WriteFileDirectoryJSONToStorage(dirName, fileDirectory)
-		if err != nil {
-			fmt.Println(fmt.Sprintf("failed to create file directory json at %s", dirName))
-		}
+    fmt.Println(fmt.Sprintf("created file directory json at %s, with %d entries", dirName, len(fileDirectory)))
 
-		fmt.Println(fmt.Sprintf("created file directory json at %s, with %d entries", dirName, len(fileDirectory)))
-
-		// finally return the merkle root and the directory
-		return c.JSON(http.StatusOK, types.FilesUploadResponse{
-			Directory: fileDirectory,
-			Root:      merkleRoot,
-		})
-	}
+    // finally return the merkle root and the directory
+    return c.JSON(http.StatusOK, types.FilesUploadResponse{
+      Directory: fileDirectory,
+      Root:      merkleRoot,
+    })
+  }
 }
diff --git a/internal/utils/filedirectory.go b/internal/utils/filedirectory.go
index a6a4043..826490a 100644
--- a/internal/utils/filedirectory.go
+++ b/internal/utils/filedirectory.go
@@ -6,8 +6,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
+	"sort"
 )
 
+// ExtractHashesFromFileDirectory Extracts all the file hashes from the directory and sorts them alphabetically.
 func ExtractHashesFromFileDirectory(fileDirectory []*types.FileDirectoryItem) []string {
 	hashes := make([]string, len(fileDirectory))
 
@@ -15,6 +17,9 @@ func ExtractHashesFromFileDirectory(fileDirectory []*types.FileDirectoryItem) []
 		hashes[i] = fileDirectory[i].Hash
 	}
 
+	// sort the hashes alphabetically
+	sort.Strings(hashes)
+
 	return hashes
 }
 

From 10e6be01768a6344d893ac752118be34c39ba938 Mon Sep 17 00:00:00 2001
From: Kieran O'Neill <hello@kieranoneill.com>
Date: Sun, 25 Feb 2024 20:19:41 +0200
Subject: [PATCH 3/3] refactor: use a renaming of directory method and clean up
 if there are errors

---
 internal/routes/files.go       | 284 ++++++++++++++++++++-------------
 internal/types/filereaddata.go |   8 -
 internal/utils/storage.go      |  35 ++--
 3 files changed, 185 insertions(+), 142 deletions(-)
 delete mode 100644 internal/types/filereaddata.go

diff --git a/internal/routes/files.go b/internal/routes/files.go
index 43c7aef..c8cf690 100644
--- a/internal/routes/files.go
+++ b/internal/routes/files.go
@@ -1,151 +1,205 @@
 package routes
 
 import (
-  "aether/internal/constants"
-  "aether/internal/errors"
-  "aether/internal/merkletree"
-  "aether/internal/types"
-  "aether/internal/utils"
-  "fmt"
-  "github.com/labstack/echo/v4"
-  "net/http"
+	"aether/internal/constants"
+	"aether/internal/errors"
+	"aether/internal/merkletree"
+	"aether/internal/types"
+	"aether/internal/utils"
+	"fmt"
+	"github.com/labstack/echo/v4"
+	"io"
+	"net/http"
+	"os"
 )
 
 func NewGetFilesRoute() echo.HandlerFunc {
-  return func(c echo.Context) error {
-    var filesResponse map[string][]*types.FileResponse
-    var hashes []string
-    var readError *errors.ReadError
-
-    fileDirectories, err := utils.GetAllFileDirectories()
-    if err != nil {
-      readError = errors.NewReadError("failed to get file directories", err)
-
-      fmt.Println(readError)
-
-      return c.JSON(http.StatusInternalServerError, readError)
-    }
-
-    filesResponse = map[string][]*types.FileResponse{}
-
-    // add the merkle proofs to the file directories
-    for key, fileDirectory := range fileDirectories {
-      hashes = utils.ExtractHashesFromFileDirectory(fileDirectory)
-      
-      for _, value := range fileDirectory {
-        filesResponse[key] = append(filesResponse[key], &types.FileResponse{
-          Hash:  value.Hash,
-          Name:  value.Name,
-          Proof: merkletree.GenerateMerkleTreeProof(value.Hash, hashes),
-        })
-      }
-    }
-
-    return c.JSON(http.StatusOK, filesResponse)
-  }
+	return func(c echo.Context) error {
+		var filesResponse map[string][]*types.FileResponse
+		var hashes []string
+		var readError *errors.ReadError
+
+		fileDirectories, err := utils.GetAllFileDirectories()
+		if err != nil {
+			readError = errors.NewReadError("failed to get file directories", err)
+
+			fmt.Println(readError)
+
+			return c.JSON(http.StatusInternalServerError, readError)
+		}
+
+		filesResponse = map[string][]*types.FileResponse{}
+
+		// add the merkle proofs to the file directories
+		for key, fileDirectory := range fileDirectories {
+			hashes = utils.ExtractHashesFromFileDirectory(fileDirectory)
+
+			for _, value := range fileDirectory {
+				filesResponse[key] = append(filesResponse[key], &types.FileResponse{
+					Hash:  value.Hash,
+					Name:  value.Name,
+					Proof: merkletree.GenerateMerkleTreeProof(value.Hash, hashes),
+				})
+			}
+		}
+
+		return c.JSON(http.StatusOK, filesResponse)
+	}
 }
 
 func NewPostFilesUploadRoute() echo.HandlerFunc {
-  return func(c echo.Context) error {
-    var fileDirectory []*types.FileDirectoryItem
-    var files []*types.FileReadData
-    var readError *errors.ReadError
-    var writeError *errors.WriteError
+	return func(c echo.Context) error {
+		var fileDirectory []*types.FileDirectoryItem
+		var readError *errors.ReadError
+		var writeError *errors.WriteError
+
+		form, err := c.MultipartForm()
+		if err != nil {
+			fmt.Println(err)
+
+			return c.JSON(http.StatusInternalServerError, err)
+		}
+
+		formFiles := form.File["file"]
+
+		// create a directory name with a random hash
+		subDirName, err := utils.CreateRandomSha256Hash()
+		if err != nil {
+			hashError := errors.NewHashError("failed to create hash", err)
+
+			fmt.Println(hashError)
+
+			return c.JSON(http.StatusInternalServerError, hashError)
+		}
+
+		dirName := fmt.Sprintf("%s/%s", constants.RootFileDirectory, subDirName)
+
+		// create the new directory
+		err = utils.CreateDir(dirName)
+		if err != nil {
+			writeError = errors.NewWriteError(fmt.Sprintf("failed create the %s directory", dirName), err)
+
+			fmt.Println(writeError)
+
+			return c.JSON(http.StatusInternalServerError, writeError)
+		}
+
+		// iterate through each file, hash it and copy it to the .files/<dirName> directory
+		for _, fileHeader := range formFiles {
+			// read file
+			uploadFile, err := fileHeader.Open()
+			if err != nil {
+				readError = errors.NewReadError(fmt.Sprintf("failed to read file %s", fileHeader.Filename), err)
+
+				fmt.Println(readError)
+
+				return c.JSON(http.StatusInternalServerError, readError)
+			}
+			defer uploadFile.Close()
+
+			// get a hash of the file
+			fileHash, err := utils.HashFile(uploadFile, fileHeader.Filename)
+			if err != nil {
+				hashError := errors.NewHashError(fmt.Sprintf("unable to hash file %s", fileHeader.Filename), err)
+
+				fmt.Println(hashError)
+
+				return c.JSON(http.StatusInternalServerError, hashError)
+			}
+
+			fmt.Println(fmt.Sprintf("file %s has a hash of %s", fileHeader.Filename, fileHash))
 
-    form, err := c.MultipartForm()
-    if err != nil {
-      fmt.Println(err)
+			// add to the directory
+			fileDirectory = append(fileDirectory, &types.FileDirectoryItem{
+				Hash: fileHash,
+				Name: fileHeader.Filename,
+			})
 
-      return c.JSON(http.StatusInternalServerError, err)
-    }
+			// create the file
+			destFile, err := os.Create(fmt.Sprintf("%s/%s", dirName, fileHeader.Filename))
+			if err != nil {
+				writeError = errors.NewWriteError(fmt.Sprintf("failed to create file %s/%s", dirName, fileHeader.Filename), err)
 
-    formFiles := form.File["file"]
+				fmt.Println(writeError)
 
-    // iterate through each file, hash it and copy it to the .files/<subDirName> directory
-    for _, fileHeader := range formFiles {
-      // read file
-      uploadFile, err := fileHeader.Open()
-      if err != nil {
-        readError = errors.NewReadError(fmt.Sprintf("failed to read file %s", fileHeader.Filename), err)
+				return c.JSON(http.StatusInternalServerError, writeError)
+			}
+			defer destFile.Close()
 
-        fmt.Println(readError)
+			// copy the contents of the uploaded file
+			_, err = io.Copy(destFile, uploadFile)
+			if err != nil {
+				writeError = errors.NewWriteError(fmt.Sprintf("failed to write file %s/%s", dirName, fileHeader.Filename), err)
 
-        return c.JSON(http.StatusInternalServerError, readError)
-      }
-      defer uploadFile.Close()
+				fmt.Println(writeError)
 
-      // get a hash of the file
-      fileHash, err := utils.HashFile(uploadFile, fileHeader.Filename)
-      if err != nil {
-        hashError := errors.NewHashError(fmt.Sprintf("unable to hash file %s", fileHeader.Filename), err)
+				return c.JSON(http.StatusInternalServerError, writeError)
+			}
+		}
 
-        fmt.Println(hashError)
+		fmt.Println(fmt.Sprintf("added files to directory %s", dirName))
 
-        return c.JSON(http.StatusInternalServerError, hashError)
-      }
+		// create a merkle root
+		merkleRoot := merkletree.GenerateMerkleTreeRoot(utils.ExtractHashesFromFileDirectory(fileDirectory))
 
-      fmt.Println(fmt.Sprintf("file %s has a hash of %s", fileHeader.Filename, fileHash))
+		fmt.Println(fmt.Sprintf("created merkle root %s", merkleRoot))
 
-      // add files so they can be written to storage when we have the merkle root
-      files = append(files, &types.FileReadData{
-        File: uploadFile,
-        Name: fileHeader.Filename,
-      })
+		// if we have an empty merkle root, remove the new directory
+		if merkleRoot == "" {
+			// clean up
+			utils.RemoveDir(dirName)
 
-      // add to the directory
-      fileDirectory = append(fileDirectory, &types.FileDirectoryItem{
-        Hash: fileHash,
-        Name: fileHeader.Filename,
-      })
-    }
+			fmt.Println("empty merkle root")
 
-    // create a merkle root
-    merkleRoot := merkletree.GenerateMerkleTreeRoot(utils.ExtractHashesFromFileDirectory(fileDirectory))
+			return c.NoContent(http.StatusBadRequest)
+		}
 
-    fmt.Println(fmt.Sprintf("created merkle root %s", merkleRoot))
+		merkleRootDirName := fmt.Sprintf("%s/%s", constants.RootFileDirectory, merkleRoot)
 
-    // if we have an empty merkle root, no files were uploaded
-    if merkleRoot == "" {
-      fmt.Println("empty merkle root there was no files added to directory")
+		// check if the merkle root directory exists
+		if utils.DoesDirExist(merkleRootDirName) {
+			// remove the newly created directory, we don't need it
+			utils.RemoveDir(dirName)
 
-      return c.NoContent(http.StatusBadRequest)
-    }
+			// return the previous directory details
+			return c.JSON(http.StatusOK, types.FilesUploadResponse{
+				Directory: fileDirectory,
+				Root:      merkleRoot,
+			})
+		}
 
-    // create a subdirectory to store the files using the merkle root hash as the directory name
-    dirName := fmt.Sprintf("%s/%s", constants.RootFileDirectory, merkleRoot)
-    err = utils.CreateDir(dirName)
-    if err != nil {
-      writeError = errors.NewWriteError(fmt.Sprintf("failed create the %s directory", dirName), err)
+		// create a file directory json in the directory
+		err = utils.WriteFileDirectoryJSONToStorage(dirName, fileDirectory)
+		if err != nil {
+			// clean up
+			utils.RemoveDir(dirName)
 
-      fmt.Println(writeError)
+			writeError = errors.NewWriteError(fmt.Sprintf("failed to create file directory json at %s", dirName), err)
 
-      return c.JSON(http.StatusInternalServerError, writeError)
-    }
+			fmt.Println(writeError)
 
-    // add the files to the directory
-    err = utils.SaveFilesToDir(dirName, files)
-    if err != nil {
-      writeError = errors.NewWriteError(fmt.Sprintf("failed write files to %s", dirName), err)
+			return c.JSON(http.StatusInternalServerError, writeError)
+		}
 
-      fmt.Println(writeError)
+		fmt.Println(fmt.Sprintf("created file directory json at %s, with %d entries", dirName, len(fileDirectory)))
 
-      return c.JSON(http.StatusInternalServerError, writeError)
-    }
+		// rename the directory to the merkle root
+		err = os.Rename(dirName, merkleRootDirName)
+		if err != nil {
+			// clean up
+			utils.RemoveDir(dirName)
 
-    fmt.Println(fmt.Sprintf("added files to directory %s", dirName))
+			writeError = errors.NewWriteError(fmt.Sprintf("failed to rename directory %s to %s", dirName, merkleRootDirName), err)
 
-    // create a file directory json in the directory
-    err = utils.WriteFileDirectoryJSONToStorage(dirName, fileDirectory)
-    if err != nil {
-      fmt.Println(fmt.Sprintf("failed to create file directory json at %s", dirName))
-    }
+			fmt.Println(writeError)
 
-    fmt.Println(fmt.Sprintf("created file directory json at %s, with %d entries", dirName, len(fileDirectory)))
+			return c.JSON(http.StatusInternalServerError, writeError)
+		}
 
-    // finally return the merkle root and the directory
-    return c.JSON(http.StatusOK, types.FilesUploadResponse{
-      Directory: fileDirectory,
-      Root:      merkleRoot,
-    })
-  }
+		// finally return the merkle root and the directory
+		return c.JSON(http.StatusOK, types.FilesUploadResponse{
+			Directory: fileDirectory,
+			Root:      merkleRoot,
+		})
+	}
 }
diff --git a/internal/types/filereaddata.go b/internal/types/filereaddata.go
deleted file mode 100644
index 9a86855..0000000
--- a/internal/types/filereaddata.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package types
-
-import "io"
-
-type FileReadData struct {
-	File io.Reader
-	Name string
-}
diff --git a/internal/utils/storage.go b/internal/utils/storage.go
index 5da683f..a4387e7 100644
--- a/internal/utils/storage.go
+++ b/internal/utils/storage.go
@@ -1,29 +1,10 @@
 package utils
 
 import (
-	"aether/internal/types"
 	"fmt"
-	"io"
 	"os"
 )
 
-func SaveFilesToDir(dirName string, files []*types.FileReadData) error {
-	for _, file := range files {
-		destFile, err := os.Create(fmt.Sprintf("%s/%s", dirName, file.Name))
-		if err != nil {
-			return err
-		}
-		defer destFile.Close()
-
-		_, err = io.Copy(destFile, file.File)
-		if err != nil {
-			return err
-		}
-	}
-
-	return nil
-}
-
 // CreateDir Creates a directory folder to storage if it doesn't exist
 func CreateDir(dirName string) error {
 	_, err := os.Stat(dirName)
@@ -40,3 +21,19 @@ func CreateDir(dirName string) error {
 
 	return nil
 }
+
+func DoesDirExist(dirName string) bool {
+	_, err := os.Stat(dirName)
+	if os.IsNotExist(err) {
+		return false
+	}
+
+	return true
+}
+
+func RemoveDir(dirName string) {
+	err := os.RemoveAll(dirName)
+	if err != nil {
+		fmt.Println(fmt.Sprintf("failed to remove directory %s", dirName))
+	}
+}