@bsv/sdk 1.6.26 → 1.7.1

package/docs/reference/identity.md

@@ -130,8 +130,8 @@ IdentityClient lets you discover who others are, and let the world know who you
 export class IdentityClient {
     constructor(wallet?: WalletInterface, private readonly options = DEFAULT_IDENTITY_CLIENT_OPTIONS, private readonly originator?: OriginatorDomainNameStringUnder250Bytes) 
     async publiclyRevealAttributes(certificate: WalletCertificate, fieldsToReveal: CertificateFieldNameUnder50Bytes[]): Promise<BroadcastResponse | BroadcastFailure> 
-    async resolveByIdentityKey(args: DiscoverByIdentityKeyArgs): Promise<DisplayableIdentity[]> 
-    async resolveByAttributes(args: DiscoverByAttributesArgs): Promise<DisplayableIdentity[]> 
+    async resolveByIdentityKey(args: DiscoverByIdentityKeyArgs, overrideWithContacts = true): Promise<DisplayableIdentity[]> 
+    async resolveByAttributes(args: DiscoverByAttributesArgs, overrideWithContacts = true): Promise<DisplayableIdentity[]> 
     public async getContacts(identityKey?: PubKeyHex, forceRefresh = false): Promise<Contact[]> 
     public async saveContact(contact: DisplayableIdentity, metadata?: Record<string, any>): Promise<void> 
     public async removeContact(identityKey: PubKeyHex): Promise<void> 
@@ -228,7 +228,7 @@ Argument Details
 Resolves displayable identity certificates by specific identity attributes, issued by a trusted entity.
 
 ```ts
-async resolveByAttributes(args: DiscoverByAttributesArgs): Promise<DisplayableIdentity[]> 
+async resolveByAttributes(args: DiscoverByAttributesArgs, overrideWithContacts = true): Promise<DisplayableIdentity[]> 
 ```
 See also: [DiscoverByAttributesArgs](./wallet.md#interface-discoverbyattributesargs), [DisplayableIdentity](./identity.md#interface-displayableidentity)
 
@@ -240,13 +240,15 @@ Argument Details
 
 + **args**
   + Attributes and optional parameters used to discover certificates.
++ **overrideWithContacts**
+  + Whether to override the results with personal contacts if available.
 
 #### Method resolveByIdentityKey
 
 Resolves displayable identity certificates, issued to a given identity key by a trusted certifier.
 
 ```ts
-async resolveByIdentityKey(args: DiscoverByIdentityKeyArgs): Promise<DisplayableIdentity[]> 
+async resolveByIdentityKey(args: DiscoverByIdentityKeyArgs, overrideWithContacts = true): Promise<DisplayableIdentity[]> 
 ```
 See also: [DiscoverByIdentityKeyArgs](./wallet.md#interface-discoverbyidentitykeyargs), [DisplayableIdentity](./identity.md#interface-displayableidentity)
 
@@ -258,6 +260,8 @@ Argument Details
 
 + **args**
   + Arguments for requesting the discovery based on the identity key.
++ **overrideWithContacts**
+  + Whether to override the results with personal contacts if available.
 
 #### Method saveContact
 

package/docs/reference/storage.md

@@ -22,7 +22,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 export interface DownloadResult {
-    data: number[];
+    data: Uint8Array;
     mimeType: string | null;
 }
 ```
@@ -85,7 +85,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 export interface UploadableFile {
-    data: number[];
+    data: Uint8Array | number[];
     type: string;
 }
 ```
@@ -341,13 +341,20 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 ### Variable: getURLForFile
 
 ```ts
-getURLForFile = (file: number[]): string => {
-    const hash = sha256(file);
+getURLForFile = (file: Uint8Array | number[]): string => {
+    const data = file instanceof Uint8Array ? file : Uint8Array.from(file);
+    const hasher = new Hash.SHA256();
+    const chunkSize = 1024 * 1024;
+    for (let i = 0; i < data.length; i += chunkSize) {
+        const chunk = data.subarray(i, i + chunkSize);
+        hasher.update(Array.from(chunk));
+    }
+    const hash = hasher.digest();
     return getURLForHash(hash);
 }
 ```
 
-See also: [getURLForHash](./storage.md#variable-geturlforhash), [sha256](./primitives.md#variable-sha256)
+See also: [SHA256](./primitives.md#class-sha256), [getURLForHash](./storage.md#variable-geturlforhash)
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 

package/docs/tutorials/uhrp-storage.md

@@ -71,7 +71,7 @@ async function basicFileUpload() {
   // Create sample file
   const fileData = new TextEncoder().encode('Hello, UHRP storage!')
   const file = {
-    data: Array.from(fileData),
+    data: fileData,
     type: 'text/plain'
   }
   
@@ -116,7 +116,7 @@ async function basicFileDownload(uhrpUrl: string) {
     
     // Convert to string if text file
     if (result.mimeType?.startsWith('text/')) {
-      const content = new TextDecoder().decode(new Uint8Array(result.data))
+      const content = new TextDecoder().decode(result.data)
       console.log('Content:', content)
     }
     
@@ -172,7 +172,7 @@ class UHRPFileManager {
     tags: string[] = []
   ): Promise<FileMetadata> {
     const file = {
-      data: Array.from(fileData),
+      data: fileData,
       type: mimeType
     }
     
@@ -217,7 +217,7 @@ class UHRPFileManager {
       console.log('File downloaded:', uhrpUrl)
       
       return {
-        data: new Uint8Array(result.data),
+        data: result.data,
         metadata
       }
     } catch (error) {
@@ -371,7 +371,7 @@ class BatchFileOperations {
     const results = await Promise.allSettled(
       files.map(async (file) => {
         const fileObj = {
-          data: Array.from(file.data),
+          data: file.data,
           type: file.type
         }
         
@@ -422,7 +422,7 @@ class BatchFileOperations {
         return {
           success: true,
           url,
-          data: new Uint8Array(result.value.data)
+          data: result.value.data
         }
       } else {
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.6.26",
+  "version": "1.7.1",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/identity/IdentityClient.ts

@@ -116,11 +116,21 @@ export class IdentityClient {
   * Resolves displayable identity certificates, issued to a given identity key by a trusted certifier.
   *
   * @param {DiscoverByIdentityKeyArgs} args - Arguments for requesting the discovery based on the identity key.
+  * @param {boolean} [overrideWithContacts=true] - Whether to override the results with personal contacts if available.
   * @returns {Promise<DisplayableIdentity[]>} The promise resolves to displayable identities.
   */
   async resolveByIdentityKey (
-    args: DiscoverByIdentityKeyArgs
+    args: DiscoverByIdentityKeyArgs,
+    overrideWithContacts = true
   ): Promise<DisplayableIdentity[]> {
+    if (overrideWithContacts) {
+      // Override results with personal contacts if available
+      const contacts = await this.contactsManager.getContacts(args.identityKey)
+      if (contacts.length > 0) {
+        return contacts
+      }
+    }
+
     const { certificates } = await this.wallet.discoverByIdentityKey(args, this.originator)
     return certificates.map(cert => {
       return IdentityClient.parseIdentity(cert)
@@ -131,15 +141,31 @@ export class IdentityClient {
    * Resolves displayable identity certificates by specific identity attributes, issued by a trusted entity.
    *
    * @param {DiscoverByAttributesArgs} args - Attributes and optional parameters used to discover certificates.
+   * @param {boolean} [overrideWithContacts=true] - Whether to override the results with personal contacts if available.
    * @returns {Promise<DisplayableIdentity[]>} The promise resolves to displayable identities.
    */
   async resolveByAttributes (
-    args: DiscoverByAttributesArgs
+    args: DiscoverByAttributesArgs,
+    overrideWithContacts = true
   ): Promise<DisplayableIdentity[]> {
-    const { certificates } = await this.wallet.discoverByAttributes(args, this.originator)
-    return certificates.map(cert => {
-      return IdentityClient.parseIdentity(cert)
-    })
+    // Run both queries in parallel for better performance
+    const [contacts, certificatesResult] = await Promise.all([
+      overrideWithContacts ? this.contactsManager.getContacts() : Promise.resolve([]),
+      this.wallet.discoverByAttributes(args, this.originator)
+    ])
+
+    // Fast lookup by identityKey
+    const contactByKey = new Map<PubKeyHex, Contact>(
+      contacts.map(contact => [contact.identityKey, contact] as const)
+    )
+
+    // Guard if certificates might be absent
+    const certs = certificatesResult?.certificates ?? []
+
+    // Parse certificates and substitute with contacts where available
+    return certs.map(cert =>
+      contactByKey.get(cert.subject) ?? IdentityClient.parseIdentity(cert)
+    )
   }
 
   /**

package/src/identity/__tests/IdentityClient.test.ts

@@ -226,6 +226,43 @@ describe('IdentityClient', () => {
         badgeClickURL: 'https://socialcert.net'
       })
     })
+
+    it('should prioritize contacts over discovered identities for same identity key', async () => {
+      const contact = {
+        name: 'Alice Smith (Personal Contact)',
+        identityKey: 'alice-identity-key',
+        avatarURL: 'alice-avatar.png',
+        abbreviatedKey: 'alice-i...',
+        badgeIconURL: '',
+        badgeLabel: '',
+        badgeClickURL: ''
+      }
+
+      const discoveredCertificate = {
+        type: KNOWN_IDENTITY_TYPES.xCert,
+        subject: 'alice-identity-key',
+        decryptedFields: {
+          userName: 'Alice Public',
+          profilePhoto: 'public-photo.png'
+        },
+        certifierInfo: {
+          name: 'CertifierX',
+          iconUrl: 'certifier-icon.png'
+        }
+      }
+
+      // Mock ContactsManager to return contact for the specific identity key
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue([contact])
+      walletMock.discoverByIdentityKey = jest.fn().mockResolvedValue({ certificates: [discoveredCertificate] })
+
+      const identities = await identityClient.resolveByIdentityKey({ identityKey: 'alice-identity-key' })
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('Alice Smith (Personal Contact)') // Contact should be returned, not discovered identity
+      // Wallet method should not be called when contact is found
+      expect(walletMock.discoverByIdentityKey).not.toHaveBeenCalled()
+    })
   })
 
   it('should throw if createAction returns no tx', async () => {
@@ -256,34 +293,124 @@ describe('IdentityClient', () => {
   })
 
   describe('resolveByAttributes', () => {
-    it('should return parsed identities from discovered certificates', async () => {
+    beforeEach(() => {
+      // Mock both getContacts and discoverByAttributes
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [] })
+      identityClient.getContacts = jest.fn().mockResolvedValue([])
+    })
+
+    it('should return parsed identities from discovered certificates only', async () => {
       const dummyCertificate = {
         type: KNOWN_IDENTITY_TYPES.emailCert,
-        subject: 'emailSubject1234',
+        subject: 'alice-identity-key',
         decryptedFields: {
-          email: 'alice@example.com',
-          profilePhoto: 'ignored' // not used for email type
+          identityKey: 'alice-identity-key',
+          email: 'alice@example.com'
         },
         certifierInfo: {
-          name: 'EmailCertifier',
-          iconUrl: 'emailIconUrl'
+          name: 'Email Certifier',
+          iconUrl: 'certifier-icon.png',
+          publicKey: 'certifier-public-key',
+          website: 'https://certifier.example.com'
         }
       }
-      // Mock discoverByAttributes to return a certificate list.
+
       walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [dummyCertificate] })
 
       const identities = await identityClient.resolveByAttributes({ attributes: { email: 'alice@example.com' } })
-      expect(walletMock.discoverByAttributes).toHaveBeenCalledWith({ attributes: { email: 'alice@example.com' } }, undefined)
       expect(identities).toHaveLength(1)
-      expect(identities[0]).toEqual({
-        name: 'alice@example.com',
-        avatarURL: 'XUTZxep7BBghAJbSBwTjNfmcsDdRFs5EaGEgkESGSgjJVYgMEizu',
-        abbreviatedKey: 'emailSubje...',
-        identityKey: 'emailSubject1234',
-        badgeLabel: 'Email certified by EmailCertifier',
-        badgeIconURL: 'emailIconUrl',
-        badgeClickURL: 'https://socialcert.net'
-      })
+      expect(identities[0].name).toBe('alice@example.com')
+    })
+
+    it('should prioritize contacts over discovered identities for same identity key', async () => {
+      const contact = {
+        name: 'Alice Smith (Personal)',
+        identityKey: 'alice-identity-key',
+        avatarURL: 'alice-avatar.png',
+        abbreviatedKey: 'alice-i...',
+        badgeIconURL: '',
+        badgeLabel: '',
+        badgeClickURL: ''
+      }
+
+      const discoveredCertificate = {
+        type: KNOWN_IDENTITY_TYPES.emailCert,
+        subject: 'alice-identity-key',
+        decryptedFields: {
+          email: 'alice@example.com'
+        },
+        certifierInfo: {
+          name: 'Email Certifier',
+          iconUrl: 'certifier-icon.png',
+          publicKey: 'certifier-public-key',
+          website: 'https://certifier.example.com'
+        }
+      }
+
+      // Mock the ContactsManager's getContacts method instead of the IdentityClient method
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue([contact])
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [discoveredCertificate] })
+
+      const identities = await identityClient.resolveByAttributes({ attributes: { name: 'Alice' } })
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('Alice Smith (Personal)') // Contact should be returned, not discovered identity
+    })
+
+    it('should return empty array for empty search terms', async () => {
+      const contacts = [
+        {
+          name: 'Alice Smith',
+          identityKey: 'alice-key',
+          avatarURL: '', abbreviatedKey: 'alice-i...', badgeIconURL: '', badgeLabel: '', badgeClickURL: ''
+        }
+      ]
+
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue(contacts)
+
+      const identities = await identityClient.resolveByAttributes({ attributes: { name: '', email: '   ' } })
+
+      expect(identities).toHaveLength(0)
+    })
+
+    it('should return only discovered identities when overrideWithContacts is false', async () => {
+      const contacts = [
+        {
+          name: 'Alice Smith (Personal)',
+          identityKey: 'alice-key',
+          avatarURL: '', abbreviatedKey: 'alice-i...', badgeIconURL: '', badgeLabel: '', badgeClickURL: ''
+        }
+      ]
+
+      const discoveredCertificate = {
+        type: KNOWN_IDENTITY_TYPES.emailCert,
+        subject: 'alice-key', // Same key as contact but should not be filtered out
+        decryptedFields: {
+          email: 'alice@example.com'
+        },
+        certifierInfo: {
+          name: 'Email Certifier',
+          iconUrl: 'certifier-icon.png',
+          publicKey: 'certifier-public-key',
+          website: 'https://certifier.example.com'
+        }
+      }
+
+      const mockContactsManager = identityClient['contactsManager']
+      mockContactsManager.getContacts = jest.fn().mockResolvedValue(contacts)
+      walletMock.discoverByAttributes = jest.fn().mockResolvedValue({ certificates: [discoveredCertificate] })
+
+      // With overrideWithContacts = false, should ignore contacts entirely
+      const identities = await identityClient.resolveByAttributes(
+        { attributes: { name: 'Alice' } },
+        false
+      )
+
+      expect(identities).toHaveLength(1)
+      expect(identities[0].name).toBe('alice@example.com') // Should be discovered identity, not contact
+      expect(mockContactsManager.getContacts).not.toHaveBeenCalled() // Should not fetch contacts
     })
   })
 
@@ -434,14 +561,14 @@ describe('IdentityClient', () => {
           customInstructions: JSON.stringify({ keyID: 'existingKeyID' })
         }
 
-        ; (walletMock.listOutputs as jest.Mock).mockResolvedValueOnce({
-          outputs: [existingOutput],
-          BEEF: [1, 2, 3]
-        })
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValueOnce({
+            outputs: [existingOutput],
+            BEEF: [1, 2, 3]
+          })
 
-        ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
-          plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
-        })
+          ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
+            plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
+          })
 
         const updatedContact = { ...mockContact, name: 'Alice Updated' }
         await identityClient.saveContact(updatedContact)
@@ -489,14 +616,14 @@ describe('IdentityClient', () => {
           customInstructions: JSON.stringify({ keyID: 'mockKeyID' })
         }
 
-        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
-          outputs: [mockOutput],
-          BEEF: [1, 2, 3]
-        })
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+            outputs: [mockOutput],
+            BEEF: [1, 2, 3]
+          })
 
-        ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
-          plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
-        })
+          ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
+            plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
+          })
 
         const result = await identityClient.getContacts()
 
@@ -523,11 +650,11 @@ describe('IdentityClient', () => {
         })
         await identityClient.saveContact(mockContact)
 
-        // Mock empty result for force refresh
-        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
-          outputs: [],
-          BEEF: []
-        })
+          // Mock empty result for force refresh
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+            outputs: [],
+            BEEF: []
+          })
 
         const result = await identityClient.getContacts(undefined, true)
 
@@ -542,7 +669,7 @@ describe('IdentityClient', () => {
           BEEF: []
         })
         await identityClient.saveContact(mockContact)
-        
+
         const otherContact = { ...mockContact, identityKey: 'different-key', name: 'Bob' }
         await identityClient.saveContact(otherContact)
 
@@ -575,7 +702,7 @@ describe('IdentityClient', () => {
           BEEF: []
         })
         await identityClient.saveContact(mockContact)
-        
+
         const otherContact = { ...mockContact, identityKey: 'other-key', name: 'Bob' }
         await identityClient.saveContact(otherContact)
 
@@ -585,14 +712,14 @@ describe('IdentityClient', () => {
           customInstructions: JSON.stringify({ keyID: 'mockKeyID' })
         }
 
-        ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
-          outputs: [mockOutput],
-          BEEF: [1, 2, 3]
-        })
+          ; (walletMock.listOutputs as jest.Mock).mockResolvedValue({
+            outputs: [mockOutput],
+            BEEF: [1, 2, 3]
+          })
 
-        ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
-          plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
-        })
+          ; (walletMock.decrypt as jest.Mock).mockResolvedValue({
+            plaintext: new TextEncoder().encode(JSON.stringify(mockContact))
+          })
 
         await identityClient.removeContact(mockContact.identityKey)
 

package/src/storage/StorageDownloader.ts

@@ -9,7 +9,7 @@ export interface DownloaderConfig {
 }
 
 export interface DownloadResult {
-  data: number[]
+  data: Uint8Array
   mimeType: string | null
 }
 
@@ -58,6 +58,7 @@ export class StorageDownloader {
       throw new Error('Invalid parameter UHRP url')
     }
     const hash = StorageUtils.getHashFromURL(uhrpUrl)
+    const expected = Utils.toHex(hash)
     const downloadURLs = await this.resolve(uhrpUrl)
 
     if (!Array.isArray(downloadURLs) || downloadURLs.length === 0) {
@@ -70,22 +71,37 @@ export class StorageDownloader {
         const result = await fetch(downloadURLs[i], { method: 'GET' })
 
         // If the request fails, continue to the next url
-        if (!result.ok || result.status >= 400) {
+        if (!result.ok || result.status >= 400 || result.body == null) {
           continue
         }
-        const body = await result.arrayBuffer()
-
-        // The body is loaded into a number array
-        const content: number[] = [...new Uint8Array(body)]
-        const contentHash = Hash.sha256(content)
-        for (let i = 0; i < contentHash.length; ++i) {
-          if (contentHash[i] !== hash[i]) {
-            throw new Error('Value of content does not match hash of the url given')
-          }
+
+        const reader = result.body.getReader()
+        const hashStream = new Hash.SHA256()
+        const chunks: Uint8Array[] = []
+        let totalLength = 0
+
+        while (true) {
+          const { done, value } = await reader.read()
+          if (done) break
+          hashStream.update(Array.from(value))
+          chunks.push(value)
+          totalLength += value.length
+        }
+
+        const digest = Utils.toHex(hashStream.digest())
+        if (digest !== expected) {
+          throw new Error('Data integrity error: value of content does not match hash of the url given')
+        }
+
+        const data = new Uint8Array(totalLength)
+        let offset = 0
+        for (const chunk of chunks) {
+          data.set(chunk, offset)
+          offset += chunk.length
         }
 
         return {
-          data: content,
+          data,
           mimeType: result.headers.get('Content-Type')
         }
       } catch (error) {

package/src/storage/StorageUploader.ts

@@ -8,7 +8,7 @@ export interface UploaderConfig {
 }
 
 export interface UploadableFile {
-  data: number[]
+  data: Uint8Array | number[]
   type: string
 }
 
@@ -108,7 +108,7 @@ export class StorageUploader {
     file: UploadableFile,
     requiredHeaders: Record<string, string>
   ): Promise<UploadFileResult> {
-    const body = Uint8Array.from(file.data)
+    const body = file.data instanceof Uint8Array ? file.data : Uint8Array.from(file.data)
 
     const response = await fetch(uploadURL, {
       method: 'PUT',
@@ -122,7 +122,7 @@ export class StorageUploader {
       throw new Error(`File upload failed: HTTP ${response.status}`)
     }
 
-    const uhrpURL = await StorageUtils.getURLForFile(file.data)
+    const uhrpURL = StorageUtils.getURLForFile(body)
     return {
       published: true,
       uhrpURL
@@ -148,10 +148,11 @@ export class StorageUploader {
     retentionPeriod: number
   }): Promise<UploadFileResult> {
     const { file, retentionPeriod } = params
-    const fileSize = file.data.length
+    const data = file.data instanceof Uint8Array ? file.data : Uint8Array.from(file.data)
+    const fileSize = data.byteLength
 
     const { uploadURL, requiredHeaders } = await this.getUploadInfo(fileSize, retentionPeriod)
-    return await this.uploadFile(uploadURL, file, requiredHeaders)
+    return await this.uploadFile(uploadURL, { data, type: file.type }, requiredHeaders)
   }
 
   /**

package/src/storage/StorageUtils.ts

@@ -1,5 +1,5 @@
-import { sha256 } from '../primitives/Hash.js'
 import { toHex, fromBase58Check, toBase58Check, toArray } from '../primitives/utils.js'
+import { Hash } from '../primitives/index.js'
 
 /**
  * Takes a UHRP URL and removes any prefixes.
@@ -26,11 +26,19 @@ export const getURLForHash = (hash: number[]): string => {
 
 /**
  * Generates a UHRP URL for a given file.
- * @param {number[] | string} file - File content as number array or string.
+ * Uses a streaming hash to avoid excessive memory usage with large files.
+ * @param {Uint8Array | number[]} file - File content as a typed array or number array.
  * @returns {string} - Base58Check encoded URL.
  */
-export const getURLForFile = (file: number[]): string => {
-  const hash = sha256(file)
+export const getURLForFile = (file: Uint8Array | number[]): string => {
+  const data = file instanceof Uint8Array ? file : Uint8Array.from(file)
+  const hasher = new Hash.SHA256()
+  const chunkSize = 1024 * 1024
+  for (let i = 0; i < data.length; i += chunkSize) {
+    const chunk = data.subarray(i, i + chunkSize)
+    hasher.update(Array.from(chunk))
+  }
+  const hash = hasher.digest()
   return getURLForHash(hash)
 }