Merge pull request #116 from lighthouse-web3/v0.3.6

V0.3.6

Author: ravish1729

README.md

@@ -1,4 +1,4 @@
-# Lighthouse <img src="https://img.shields.io/badge/BETA-v0.3.5-green"/>
+# Lighthouse <img src="https://img.shields.io/badge/BETA-v0.3.6-green"/>
 
 Lighthouse is a permanent decentralized file storage protocol that allows the ability to pay once and store forever. While traditionally, users need to repeatedly keep track and pay for their storage after every fixed amount of time, Lighthouse manages this for them and makes sure that user files are stored forever. The aim is to move users from a rent-based cost model where they are renting their own files on cloud storage to a permanent ownership model. It is built on top of IPFS, Filecoin, and Polygon. It uses the existing miner network and storage capacity of the filecoin network.
 

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "@lighthouse-web3/sdk",
-  "version": "0.3.5",
+  "version": "0.3.6",
   "description": "NPM package and CLI tool to interact with lighthouse protocol",
   "main": "./dist/Lighthouse/index.js",
   "types": "./dist/Lighthouse/index.d.ts",

package.json

@@ -72,7 +72,7 @@ Command.prototype.helpInformation = function (context: any) {
 }
 
 widgets.addHelpText('before', 'Welcome to lighthouse-web3')
-widgets.version('0.3.5')
+widgets.version('0.3.6')
 
 widgets
   .command('wallet')

src/Commands/index.ts

@@ -13,7 +13,7 @@ export default async <T extends boolean>(
   accessToken: string,
   multi: boolean,
   dealParameters: DealParameters | undefined,
-  uploadProgressCallback: (data: IUploadProgressCallback) => void
+  uploadProgressCallback?: (data: IUploadProgressCallback) => void
 ): Promise<{ data: UploadFileReturnType<T> }> => {
   try {
     const endpoint =
@@ -35,35 +35,30 @@ export default async <T extends boolean>(
         : 'null',
     })
 
-    const response = await retryFetch(endpoint, {
-      method: 'POST',
-      body: formData,
-      headers: headers,
-      timeout: 7200000,
-    })
+    const response = uploadProgressCallback
+      ? await retryFetch(endpoint, {
+          method: 'POST',
+          body: formData,
+          headers: headers,
+          timeout: 7200000,
+          onProgress: (progress) => {
+            uploadProgressCallback({
+              progress: progress,
+            })
+          },
+        })
+      : await retryFetch(endpoint, {
+          method: 'POST',
+          body: formData,
+          headers: headers,
+          timeout: 7200000,
+        })
 
     if (!response.ok) {
       throw new Error(`Request failed with status code ${response.status}`)
     }
 
-    const reader = response.body?.getReader()
-    const decoder = new TextDecoder()
-    let responseText = ''
-
-    if (reader) {
-      let totalBytes = 0
-      while (true) {
-        const { done, value } = await reader.read()
-        if (done) break
-        totalBytes += value?.length || 0
-        responseText += decoder.decode(value, { stream: true })
-        uploadProgressCallback({
-          progress: 1, // We can't accurately calculate progress without knowing the total size
-          total: totalBytes,
-          uploaded: totalBytes,
-        })
-      }
-    }
+    const responseText = await response.text()
 
     let data
     if (typeof responseText === 'string') {

src/Lighthouse/upload/files/browser.ts

@@ -41,10 +41,7 @@ async function uploadFiles(
         apiKey,
         true,
         dealParameters,
-        uploadProgressCallback ||
-          (() => {
-            return
-          })
+        uploadProgressCallback
       )
     }
   } else {
@@ -57,10 +54,7 @@ async function uploadFiles(
         apiKey,
         false,
         dealParameters,
-        uploadProgressCallback ||
-          (() => {
-            return
-          })
+        uploadProgressCallback
       )
     }
   }

src/Lighthouse/upload/files/index.ts

@@ -29,7 +29,7 @@ export default async (
   apiKey: string,
   publicKey: string,
   auth_token: string,
-  uploadProgressCallback: (data: IUploadProgressCallback) => void
+  uploadProgressCallback?: (data: IUploadProgressCallback) => void
 ): Promise<{ data: IFileUploadedResponse[] }> => {
   try {
     let keyMap = {} as any
@@ -73,40 +73,42 @@ export default async (
       )
     })
 
-    const controller = new AbortController()
-    const signal = controller.signal
-    const response = await retryFetch(endpoint, {
-      method: 'POST',
-      body: formData,
-      timeout: 7200000,
-      headers: {
-        Encryption: `${true}`,
-        Authorization: token,
-      },
-      signal,
-    })
+    const response = uploadProgressCallback
+      ? await retryFetch(endpoint, {
+          method: 'POST',
+          body: formData,
+          timeout: 7200000,
+          headers: {
+            Encryption: `${true}`,
+            Authorization: token,
+          },
+          onProgress: (progress) => {
+            uploadProgressCallback({
+              progress: progress,
+            })
+          },
+        })
+      : await retryFetch(endpoint, {
+          method: 'POST',
+          body: formData,
+          timeout: 7200000,
+          headers: {
+            Encryption: `${true}`,
+            Authorization: token,
+          },
+        })
     if (!response.ok) {
       throw new Error(`HTTP error! status: ${response.status}`)
     }
 
     const reader = response.body?.getReader()
-    const contentLength = +response.headers.get('Content-Length')!
-    let receivedLength = 0
     let chunks = []
     while (true) {
       const { done, value } = await reader!.read()
       if (done) {
         break
       }
       chunks.push(value)
-      receivedLength += value.length
-      uploadProgressCallback({
-        progress: contentLength
-          ? Math.round(receivedLength / contentLength)
-          : 0,
-        total: contentLength || 0,
-        uploaded: receivedLength,
-      })
     }
 
     let responseData = new TextDecoder('utf-8').decode(

src/Lighthouse/uploadEncrypted/encrypt/file/browser.ts

@@ -2,6 +2,7 @@ import { ethers } from 'ethers'
 
 interface FetchOptions extends RequestInit {
   timeout?: number
+  onProgress?: (progress: number) => void
 }
 
 const isCID = (cid: string) => {
@@ -41,17 +42,85 @@ async function fetchWithTimeout(
   resource: string,
   options: FetchOptions
 ): Promise<Response> {
-  const { timeout = 8000, ...rest } = options
+  const { timeout = 8000, onProgress, ...rest } = options
 
   const controller = new AbortController()
   const id = setTimeout(() => controller.abort(), timeout)
+
   try {
-    const response = await fetch(resource, {
-      ...rest,
-      signal: controller.signal,
-    })
-    clearTimeout(id)
-    return response
+    if (onProgress && rest.body instanceof FormData) {
+      return new Promise<Response>((resolve, reject) => {
+        const xhr = new XMLHttpRequest()
+        xhr.open(rest.method || 'GET', resource)
+
+        if (rest.headers) {
+          if (rest.headers instanceof Headers) {
+            rest.headers.forEach((value, key) => {
+              xhr.setRequestHeader(key, value)
+            })
+          } else if (typeof rest.headers === 'object') {
+            for (const [key, value] of Object.entries(rest.headers)) {
+              xhr.setRequestHeader(key, value as string)
+            }
+          }
+        }
+
+        xhr.timeout = timeout
+        xhr.onload = () => {
+          const headers = new Headers()
+          xhr
+            .getAllResponseHeaders()
+            .trim()
+            .split(/[\r\n]+/)
+            .forEach((line) => {
+              const parts = line.split(': ')
+              const header = parts.shift()
+              const value = parts.join(': ')
+              if (header) headers.set(header, value)
+            })
+
+          resolve(
+            new Response(xhr.response, {
+              status: xhr.status,
+              statusText: xhr.statusText,
+              headers: headers,
+            })
+          )
+        }
+        xhr.onerror = () => reject(new Error('Network error'))
+        xhr.ontimeout = () => reject(new Error('Request timed out'))
+        xhr.upload.onprogress = (event: ProgressEvent) => {
+          if (event.lengthComputable) {
+            onProgress(event.loaded / event.total)
+          }
+        }
+
+        // Handle different body types
+        if (rest.body instanceof FormData) {
+          xhr.send(rest.body)
+        } else if (rest.body instanceof ReadableStream) {
+          // Convert ReadableStream to Blob and then send
+          new Response(rest.body).blob().then((blob) => xhr.send(blob))
+        } else if (
+          typeof rest.body === 'string' ||
+          rest.body instanceof Blob ||
+          rest.body instanceof ArrayBuffer
+        ) {
+          xhr.send(rest.body)
+        } else if (rest.body == null) {
+          xhr.send()
+        } else {
+          reject(new Error('Unsupported body type'))
+        }
+      })
+    } else {
+      const response = await fetch(resource, {
+        ...rest,
+        signal: controller.signal,
+      })
+      clearTimeout(id)
+      return response
+    }
   } catch (error) {
     clearTimeout(id)
     throw error

src/Lighthouse/utils/util.ts

@@ -1,7 +1,5 @@
 export interface IUploadProgressCallback {
   progress: number
-  total: number
-  uploaded: number
 }
 
 export interface IFileUploadedResponse {

src/types.ts

@@ -2,13 +2,11 @@
   "compilerOptions": {
     "outDir": "dist",
     "target": "es2022",
-    "lib": [
-      "es2019"
-    ],
+    "lib": ["es2019", "es6", "dom"],
     "module": "commonjs",
     "sourceMap": false,
     "strict": true,
-    "esModuleInterop": true,  
+    "esModuleInterop": true,
     "skipLibCheck": true,
     "forceConsistentCasingInFileNames": true,
     "experimentalDecorators": true,
@@ -19,5 +17,11 @@
     "resolveJsonModule": true
   },
   "include": ["src"],
-  "exclude": ["node_modules", "**/*.spec.ts","**/*.test.ts",".vscode",".d.ts"]
+  "exclude": [
+    "node_modules",
+    "**/*.spec.ts",
+    "**/*.test.ts",
+    ".vscode",
+    ".d.ts"
+  ]
 }