diff --git a/package.json b/package.json
index cd5c54cc..edfad8b1 100644
--- a/package.json
+++ b/package.json
@@ -14,6 +14,7 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.12.5",
+    "@debionetwork/pinata-ipfs": "0.0.2",
     "@kiltprotocol/sdk-js": "^0.22.1",
     "@metamask/detect-provider": "^1.2.0",
     "@polkadot/api": "^6.5.2",
diff --git a/src/components/Dialog/ServiceDialog.vue b/src/components/Dialog/ServiceDialog.vue
index a775cf88..ffd0fa99 100644
--- a/src/components/Dialog/ServiceDialog.vue
+++ b/src/components/Dialog/ServiceDialog.vue
@@ -48,7 +48,7 @@
 
 <script>
 import Button from "@/components/Button";
-import { downloadDecryptedFromIPFS } from "@/lib/ipfs";
+import { downloadFile, decryptFile, downloadDocumentFile } from "@/lib/pinata-proxy"
 import { hexToU8a } from "@polkadot/util";
 import { mapState } from "vuex";
 
@@ -87,17 +87,14 @@ export default {
       this.$emit("close");
     },
     async downloadFile() {
-      const publicKey = hexToU8a(this.mnemonicData.publicKey);
-      const privateKey = hexToU8a(this.mnemonicData.privateKey);
-      const baseUrl = "https://ipfs.io/ipfs/";
-      const path = this.downloadPath.replace(baseUrl, "")
-      await downloadDecryptedFromIPFS(
-        path,
-        privateKey,
-        publicKey,
-        this.serviceId + ".pdf",
-        "application/pdf"
-      );
+      const type = "application/pdf"
+      const pair = {
+        publicKey: hexToU8a(this.mnemonicData.publicKey),
+        secretKey: hexToU8a(this.mnemonicData.privateKey)
+      }
+      const { data } = await downloadFile(this.downloadPath)
+      const decryptedFile = decryptFile(data, pair, type)
+      await downloadDocumentFile(decryptedFile, this.downloadPath.split("/").pop(), type)
     },
     onSubmit() {
       this.$router.push({ name: "request-test-checkout" });
diff --git a/src/lib/pinata-proxy.js b/src/lib/pinata-proxy.js
new file mode 100644
index 00000000..e07c928f
--- /dev/null
+++ b/src/lib/pinata-proxy.js
@@ -0,0 +1,86 @@
+import Kilt from "@kiltprotocol/sdk-js"
+import axios from "axios"
+import {
+  getIpfsMetaData as pinataIpfsGetIpfsMetadata,
+  uploadFile as pinataIpfsUploadFile,
+  downloadDocumentFileInBrowser,
+  downloadJson
+} from "@debionetwork/pinata-ipfs"
+
+const pinataJwtKey = process.env.VUE_APP_PINATA_JWT_KEY
+
+export const uploadFile = val => {
+  const options = {
+    pinataMetadata: {
+      name: val.title,
+      keyvalues: {
+        type: val.type,
+        date: +new Date()
+      }
+    },
+    pinataOptions: { cidVersion: 0 }
+  }
+
+  const CancelToken = axios.CancelToken
+  const source = CancelToken.source()
+
+  return pinataIpfsUploadFile(
+    options,
+    val.file,
+    pinataJwtKey,
+    source.token
+  )
+}
+
+export const getFileUrl = cid => {
+  return `https://ipfs.debio.network/ipfs/${cid}`
+}
+
+export const downloadFile = async (ipfsLink, withMetaData = false) => {
+  console.log("Downloading...")
+  const result = await downloadJson(
+    ipfsLink,
+    withMetaData,
+    pinataJwtKey
+  )
+  console.log("Success Downloaded!")
+
+  return result
+}
+
+export const getIpfsMetaData = async (cid) => {
+  const metaData = await pinataIpfsGetIpfsMetadata(
+    cid,
+    pinataJwtKey
+  )
+
+  return metaData
+}
+
+export const decryptFile = (obj, pair) => {
+  const box = Object.values(obj[0].data.box)
+  const nonce = Object.values(obj[0].data.nonce)
+  let decryptedFile
+
+  const toDecrypt = {
+    box: Uint8Array.from(box),
+    nonce: Uint8Array.from(nonce)
+  }
+
+  decryptedFile = Kilt.Utils.Crypto.decryptAsymmetric(toDecrypt, pair.publicKey, pair.secretKey)
+
+  if (!decryptedFile) console.log("Undefined File", decryptedFile)
+  else return decryptedFile
+}
+
+export const downloadDocumentFile = (data, fileName, type) => {
+  try {
+    downloadDocumentFileInBrowser(
+      data,
+      fileName,
+      type
+    )
+  } catch (error) {
+    console.error(error)
+  }
+}
diff --git a/src/views/Dashboard/Lab/Account/Certification.vue b/src/views/Dashboard/Lab/Account/Certification.vue
index a55d5d8e..8e79d1d9 100644
--- a/src/views/Dashboard/Lab/Account/Certification.vue
+++ b/src/views/Dashboard/Lab/Account/Certification.vue
@@ -159,7 +159,7 @@ import { createCertification, updateCertification, deleteCertification } from "@
 import serviceHandler from "@/mixins/serviceHandler"
 import Dialog from "@/components/Dialog"
 import Button from "@/components/Button"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 
 const englishAlphabet = val => (val && /^[A-Za-z0-9!@#$%^&*\\(\\)\-_=+:;"',.\\/? ]+$/.test(val)) || "This field can only contain English alphabet"
 
@@ -317,36 +317,43 @@ export default {
       await this.dispatch(deleteCertification, this.api, this.pair, cert.id)
       this.showDeletePrompt = false
     },
-    fileUploadEventListener(file) {
+    async fileUploadEventListener(file) {
       this.certSupportingDocumentsUrl = ""
-      if (!this.$refs.certificationForm.validate()) {
-        return
-      }
       if (file && file.name) {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
         this.isUploading = true
         this.isLoading = true
+        const dataFile = await this.setupFileReader(file)
 
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
+        })
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
+        const link = getFileUrl(result.IpfsHash)
 
-          context.certSupportingDocumentsUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server...
-          context.isUploading = false
-          context.isLoading = false
-        })
+        this.certSupportingDocumentsUrl = link
+        this.isUploading = false
+        this.isLoading = false
       }
+    },
+
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
     }
   }
 }
diff --git a/src/views/Dashboard/Lab/Account/index.vue b/src/views/Dashboard/Lab/Account/index.vue
index 7a5afe20..6b8659c7 100644
--- a/src/views/Dashboard/Lab/Account/index.vue
+++ b/src/views/Dashboard/Lab/Account/index.vue
@@ -160,7 +160,7 @@ import { getLocations, getStates, getCities } from "@/lib/api"
 import Kilt from "@kiltprotocol/sdk-js"
 import { u8aToHex } from "@polkadot/util"
 import Certification from "./Certification"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 import serviceHandler from "@/lib/metamask/mixins/serviceHandler"
 
 const englishAlphabet = val => (val && /^[A-Za-z0-9!@#$%^&*\\(\\)\-_=+:;"',.\\/? ]+$/.test(val)) || "This field can only contain English alphabet"
@@ -373,7 +373,7 @@ export default {
       }
     },
     
-    fileUploadEventListener(file) {
+    async fileUploadEventListener(file) {
       this.imageUrl = ""
       if (!this.$refs.form.validate()) {
         return
@@ -385,23 +385,19 @@ export default {
         this.isUploading = true
         this.isLoading = true
 
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.imageUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server...
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+
+        this.imageUrl = link
+        this.isUploading = false
+        this.isLoading = false
       }
       else {
         this.files = []
@@ -409,6 +405,21 @@ export default {
       }
     },
 
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
+    },
+
     checkVerify() {
       if (this.verificationStatus == "Verified") {
         return this.isVerify = true
diff --git a/src/views/Dashboard/Lab/Registration/Certification.vue b/src/views/Dashboard/Lab/Registration/Certification.vue
index a48c36b6..71786e7c 100644
--- a/src/views/Dashboard/Lab/Registration/Certification.vue
+++ b/src/views/Dashboard/Lab/Registration/Certification.vue
@@ -149,7 +149,7 @@ import { createCertification, updateCertification, deleteCertification } from "@
 import serviceHandler from "@/mixins/serviceHandler"
 import Dialog from "@/components/Dialog"
 import Button from "@/components/Button"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 
 const englishAlphabet = val => (val && /^[A-Za-z0-9!@#$%^&*\\(\\)\-_=+:;"',.\\/? ]+$/.test(val)) || "This field can only contain English alphabet"
 
@@ -325,11 +325,8 @@ export default {
       this.confirmDeleteDialog = false
     },
 
-    fileUploadEventListener(file) {
+    async fileUploadEventListener(file) {
       this.certSupportingDocumentsUrl = ""
-      if (!this.$refs.certificationForm.validate()) {
-        return
-      }
       if (file && file.name) {
         if (file.name.lastIndexOf(".") <= 0) {
           return
@@ -337,26 +334,36 @@ export default {
         this.isUploading = true
         this.isLoading = true
 
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.certSupportingDocumentsUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server...
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+
+        this.certSupportingDocumentsUrl = link
+        this.isUploading = false
+        this.isLoading = false
       }
-    }
+    },
 
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
+    }
   }
 }
 </script>
diff --git a/src/views/Dashboard/Lab/Registration/Services/index.vue b/src/views/Dashboard/Lab/Registration/Services/index.vue
index 2b8f9f6a..86399ced 100644
--- a/src/views/Dashboard/Lab/Registration/Services/index.vue
+++ b/src/views/Dashboard/Lab/Registration/Services/index.vue
@@ -217,7 +217,7 @@
 
 <script>
 import { mapState } from "vuex"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 import { createService, updateService } from "@/lib/polkadotProvider/command/services"
 import { getCategories } from "@/lib/api"
 import List from "./List"
@@ -562,7 +562,7 @@ export default {
       )
     },
 
-    imageUploadEventListener(file) {
+    async imageUploadEventListener(file) {
       if(!file || file.length === 0) {
         return
       }
@@ -573,27 +573,23 @@ export default {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.imageUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server... (convert img to file path)
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+
+        this.imageUrl = link
+        this.isUploading = false
+        this.isLoading = false
       }
     },
 
-    fileUploadEventListener(file) {
+    async fileUploadEventListener(file) {
       if (!file || file.size >= 2000000 || file.length === 0) {
         return
       }
@@ -604,24 +600,37 @@ export default {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          context.testResultSampleUrl = `https://ipfs.io/ipfs/${uploaded.ipfsPath[0].data.path}` // this is an image file that can be sent to server... (convert img to file path)
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+
+        this.testResultSampleUrl = link
+        this.isUploading = false
+        this.isLoading = false
       }
     },
 
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
+    },
+
     selectPicture() {
       this.$refs.fileInput.$refs.input.click()
     }
diff --git a/src/views/Dashboard/Lab/Registration/index.vue b/src/views/Dashboard/Lab/Registration/index.vue
index 885671a9..183a3ef1 100644
--- a/src/views/Dashboard/Lab/Registration/index.vue
+++ b/src/views/Dashboard/Lab/Registration/index.vue
@@ -124,7 +124,6 @@
                   prepend-icon="mdi-image"
                   outlined
                   v-model="files"
-                  @change="fileUploadEventListener"
                   :rules="fileInputRules"
                   :disabled="isLabAccountExist"
                   show-size
@@ -169,7 +168,7 @@
 <script>
 import { mapState, mapGetters } from "vuex"
 import { registerLab } from "@/lib/polkadotProvider/command/labs"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 import Certification from "./Certification"
 import Stepper from "./Stepper"
 import { getLocations, getStates, getCities } from "@/lib/api"
@@ -209,7 +208,7 @@ export default {
     phoneNumber: "",
     website: "",
     imageUrl: "",
-    files: [],
+    files: null,
     isLoading: false,
     isUploading: false,
     stepperItems: [
@@ -386,6 +385,7 @@ export default {
         const cred = Kilt.Identity.buildFromMnemonic(this.mnemonicData.toString(CryptoJS.enc.Utf8))
         const boxPublicKey = u8aToHex(cred.boxKeyPair.publicKey)
 
+        await this.fileUploadEventListener(this.files)
         await registerLab(
           this.api,
           this.pair,
@@ -430,7 +430,7 @@ export default {
       }
     },
 
-    fileUploadEventListener(file) {
+    async fileUploadEventListener(file) {
       if (file && file.name) {
         if (file.name.lastIndexOf(".") <= 0) {
           return
@@ -438,32 +438,43 @@ export default {
         this.isUploading = true
         this.isLoading = true
 
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.imageUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server...
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+
+        this.imageUrl = link
+        this.isUploading = false
+        this.isLoading = false
       }
       else {
-        this.files = []
+        this.files = null
         this.imageUrl = ""
       }
     },
 
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
+    },
+
     validating() {
-      if (this.labName == "" || this.email == "" || this.imageUrl == "" || this.address == "" || this.country == "" || this.city == "" || this.state == "") {
+      if (this.labName == "" || this.email == "" || this.address == "" || this.country == "" || this.city == "" || this.state == "") {
         this.$refs.labForm.validate()
         return false
       }
diff --git a/src/views/Dashboard/Lab/Services/Add.vue b/src/views/Dashboard/Lab/Services/Add.vue
index e11c8913..a0b25a19 100644
--- a/src/views/Dashboard/Lab/Services/Add.vue
+++ b/src/views/Dashboard/Lab/Services/Add.vue
@@ -215,7 +215,7 @@
 
 <script>
 import { mapState } from "vuex"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 import { createService, claimRequestService } from "@/lib/polkadotProvider/command/services"
 import { queryLabsById } from "@/lib/polkadotProvider/query/labs";
 import { getProvideRequestService, getCategories } from "@/lib/api";
@@ -487,35 +487,43 @@ export default {
       }
     },
 
-    imageUploadEventListener(file) {
+    async imageUploadEventListener(file) {
       this.isLoading = true
       this.imageUrl = ""
       if (file) {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.imageUrl = `https://ipfs.io/ipfs/${computeLink}`
-          context.isUploading = false
-          context.isLoading = false
-          context.isUploading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+        this.imageUrl = link
+        this.isLoading = false
       }
     },
 
-    fileUploadEventListener(file) {
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
+    },
+
+    async fileUploadEventListener(file) {
       if (!file || file.size >= 2000000) {
         return
       }
@@ -525,24 +533,17 @@ export default {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.testResultSampleUrl = `https://ipfs.io/ipfs/${computeLink}`
-          context.isUploading = false
-          context.isLoading = false
-          context.isUploading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+        this.testResultSampleUrl = link
+        this.isLoading = false
       }
     },
 
diff --git a/src/views/Dashboard/Lab/Services/Detail.vue b/src/views/Dashboard/Lab/Services/Detail.vue
index 936ff0ae..6e08c315 100644
--- a/src/views/Dashboard/Lab/Services/Detail.vue
+++ b/src/views/Dashboard/Lab/Services/Detail.vue
@@ -194,7 +194,7 @@
 
 <script>
 import { mapGetters, mapState } from "vuex"
-import { upload } from "@/lib/ipfs"
+import { uploadFile, getFileUrl } from "@/lib/pinata-proxy"
 import { getCategories } from "@/lib/api"
 import { queryServicesById } from "@/lib/polkadotProvider/query/services";
 import { fromEther } from "@/lib/balance-format"
@@ -386,7 +386,7 @@ export default {
       )
     },
 
-    imageUploadEventListener(file) {
+    async imageUploadEventListener(file) {
       this.isUploading = true
       this.isLoading = true
       this.imageUrl = ""
@@ -394,27 +394,37 @@ export default {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.imageUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server... (convert img to file path)
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+        this.imageUrl = link // this is an image file that can be sent to server... (convert img to file path)
+        this.isUploading = false
+        this.isLoading = false
       }
     },
 
-    fileUploadEventListener(file) {
+    setupFileReader(value) {
+      return new Promise((resolve, reject) => {
+        const file = value
+        const fr = new FileReader()
+
+        fr.onload = async function () {
+          resolve(value)
+        }
+
+        fr.onerror = reject
+
+        fr.readAsArrayBuffer(file)
+      })
+    },
+
+    async fileUploadEventListener(file) {
       if (!file || file.size >= 2000000) {
         return
       }
@@ -425,23 +435,19 @@ export default {
         if (file.name.lastIndexOf(".") <= 0) {
           return
         }
-        const fr = new FileReader()
-        fr.readAsArrayBuffer(file)
+        const dataFile = await this.setupFileReader(file)
 
-        const context = this
-        fr.addEventListener("load", async () => {
-          // Upload
-          const uploaded = await upload({
-            fileChunk: fr.result,
-            fileType: file.type,
-            fileName: file.name
-          })
-          const computeLink = `${uploaded.ipfsPath[0].data.ipfsFilePath}/${uploaded.fileName}`
-
-          context.testResultSampleUrl = `https://ipfs.io/ipfs/${computeLink}` // this is an image file that can be sent to server... (convert img to file path)
-          context.isUploading = false
-          context.isLoading = false
+        const result = await uploadFile({
+          title: dataFile.name,
+          type: dataFile.type,
+          file: dataFile
         })
+
+        const link = getFileUrl(result.IpfsHash)
+
+        this.testResultSampleUrl = link // this is an image file that can be sent to server... (convert img to file path)
+        this.isUploading = false
+        this.isLoading = false
       }
     },
 
diff --git a/src/views/Dashboard/Lab/Services/index.vue b/src/views/Dashboard/Lab/Services/index.vue
index 13674df5..1a3460be 100644
--- a/src/views/Dashboard/Lab/Services/index.vue
+++ b/src/views/Dashboard/Lab/Services/index.vue
@@ -154,12 +154,12 @@ export default {
     serviceCount: 0
   }),
   computed:{
-   ...mapGetters({
-      api: 'substrate/getAPI',
-      pair: 'substrate/wallet',
-      web3: 'metamask/getWeb3',
-      labAccount: 'substrate/labAccount',
-   }),
+    ...mapGetters({
+      api: "substrate/getAPI",
+      pair: "substrate/wallet",
+      web3: "metamask/getWeb3",
+      labAccount: "substrate/labAccount"
+    }),
 
     ...mapState({
       lastEventData: (state) => state.substrate.lastEventData
@@ -170,18 +170,18 @@ export default {
     lastEventData(val) {
       if (val === null) return
       if (val.method === "ServiceDeleted") {
-         this.isLoading = false
-         this.showDialog = false
-         this.getServices()
-         this.checkServiceCount()
+        this.isLoading = false
+        this.showDialog = false
+        this.getServices()
+        this.checkServiceCount()
       }
     }
   },
 
-   async created() {
-      await this.getServices()
-      await this.checkServiceCount()
-   },
+  async created() {
+    await this.getServices()
+    await this.checkServiceCount()
+  },
 
   methods:{
     async getServices() {
@@ -228,15 +228,15 @@ export default {
     },
 
     confirmDeleteService(item) {
-       this.idItemDeleted = item.id
-       this.showDialog = true
+      this.idItemDeleted = item.id
+      this.showDialog = true
     },
 
     async checkServiceCount() {
       this.serviceCount = this.labAccount.services.length
-       if (this.serviceCount <= 1) {
-          this.activeButton = false
-       }
+      if (this.serviceCount <= 1) {
+        this.activeButton = false
+      }
     }
   }
 }