@ar.io/sdk 3.12.0-beta.6 → 3.12.0-beta.7

package/lib/cjs/utils/hash.js

@@ -1,6 +1,9 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.hashBufferToB64Url = exports.hashReadableStreamToB64Url = exports.hashReadableToB64Url = void 0;
+exports.convertDataStreamToDataRoot = exports.hashDataStreamToB64Url = exports.readableStreamToAsyncIterable = exports.isReadableStream = exports.isAsyncIterable = void 0;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
  *
@@ -16,41 +19,90 @@ exports.hashBufferToB64Url = exports.hashReadableStreamToB64Url = exports.hashRe
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+const arweave_1 = __importDefault(require("arweave"));
+const merkle_js_1 = require("arweave/node/lib/merkle.js");
 const crypto_1 = require("crypto");
 const base64_js_1 = require("./base64.js");
-const hashReadableToB64Url = (stream, algorithm = 'sha256') => {
-    return new Promise((resolve, reject) => {
-        const hash = (0, crypto_1.createHash)(algorithm);
-        stream.on('data', (chunk) => hash.update(chunk));
-        stream.on('end', () => resolve((0, base64_js_1.toB64Url)(hash.digest())));
-        stream.on('error', (err) => reject(err));
-    });
+const isAsyncIterable = (x) => {
+    return x && typeof x[Symbol.asyncIterator] === 'function';
+};
+exports.isAsyncIterable = isAsyncIterable;
+const isReadableStream = (x) => {
+    return x && typeof x.getReader === 'function';
 };
-exports.hashReadableToB64Url = hashReadableToB64Url;
-const hashReadableStreamToB64Url = (stream, algorithm = 'sha256') => {
-    return new Promise((resolve, reject) => {
-        const hash = (0, crypto_1.createHash)(algorithm);
+exports.isReadableStream = isReadableStream;
+// convert ReadableStream to async iterable
+const readableStreamToAsyncIterable = (stream) => ({
+    async *[Symbol.asyncIterator]() {
         const reader = stream.getReader();
-        const read = async () => {
-            try {
+        try {
+            while (true) {
                 const { done, value } = await reader.read();
-                if (done) {
-                    resolve((0, base64_js_1.toB64Url)(hash.digest()));
-                }
-                else {
-                    hash.update(value);
-                    read();
-                }
+                if (done)
+                    break;
+                if (value !== undefined)
+                    yield value;
             }
-            catch (err) {
-                reject(err);
-            }
-        };
-        read().catch(reject);
-    });
+        }
+        finally {
+            reader.releaseLock();
+        }
+    },
+});
+exports.readableStreamToAsyncIterable = readableStreamToAsyncIterable;
+const hashDataStreamToB64Url = async (stream, algorithm = 'sha256') => {
+    const asyncIterable = (0, exports.isAsyncIterable)(stream)
+        ? stream
+        : (0, exports.readableStreamToAsyncIterable)(stream);
+    const hash = (0, crypto_1.createHash)(algorithm);
+    for await (const chunk of asyncIterable) {
+        hash.update(chunk);
+    }
+    return (0, base64_js_1.toB64Url)(hash.digest());
 };
-exports.hashReadableStreamToB64Url = hashReadableStreamToB64Url;
-const hashBufferToB64Url = (buffer, algorithm = 'sha256') => {
-    return (0, base64_js_1.toB64Url)((0, crypto_1.createHash)(algorithm).update(buffer).digest());
+exports.hashDataStreamToB64Url = hashDataStreamToB64Url;
+const convertDataStreamToDataRoot = async ({ dataStream, }) => {
+    const chunks = [];
+    let leftover = new Uint8Array(0);
+    let cursor = 0;
+    const asyncIterable = (0, exports.isAsyncIterable)(dataStream)
+        ? dataStream
+        : (0, exports.readableStreamToAsyncIterable)(dataStream);
+    for await (const data of asyncIterable) {
+        const inputChunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const combined = new Uint8Array(leftover.length + inputChunk.length);
+        combined.set(leftover, 0);
+        combined.set(inputChunk, leftover.length);
+        let startIndex = 0;
+        while (combined.length - startIndex >= merkle_js_1.MAX_CHUNK_SIZE) {
+            let chunkSize = merkle_js_1.MAX_CHUNK_SIZE;
+            const remainderAfterThis = combined.length - startIndex - merkle_js_1.MAX_CHUNK_SIZE;
+            if (remainderAfterThis > 0 && remainderAfterThis < merkle_js_1.MIN_CHUNK_SIZE) {
+                chunkSize = Math.ceil((combined.length - startIndex) / 2);
+            }
+            const chunkData = combined.slice(startIndex, startIndex + chunkSize);
+            const dataHash = await arweave_1.default.crypto.hash(chunkData);
+            chunks.push({
+                dataHash,
+                minByteRange: cursor,
+                maxByteRange: cursor + chunkSize,
+            });
+            cursor += chunkSize;
+            startIndex += chunkSize;
+        }
+        leftover = combined.slice(startIndex);
+    }
+    if (leftover.length > 0) {
+        // TODO: ensure a web friendly crypto hash function is used in web
+        const dataHash = await arweave_1.default.crypto.hash(leftover);
+        chunks.push({
+            dataHash,
+            minByteRange: cursor,
+            maxByteRange: cursor + leftover.length,
+        });
+    }
+    const leaves = await (0, merkle_js_1.generateLeaves)(chunks);
+    const root = await (0, merkle_js_1.buildLayers)(leaves);
+    return (0, base64_js_1.toB64Url)(Buffer.from(root.id));
 };
-exports.hashBufferToB64Url = hashBufferToB64Url;
+exports.convertDataStreamToDataRoot = convertDataStreamToDataRoot;

package/lib/cjs/version.js

@@ -17,4 +17,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.version = void 0;
 // AUTOMATICALLY GENERATED FILE - DO NOT TOUCH
-exports.version = '3.12.0-beta.6';
+exports.version = '3.12.0-beta.7';

package/lib/esm/common/wayfinder/verification/strategies/data-root-verifier.js

@@ -15,39 +15,16 @@
  */
 import Arweave from 'arweave';
 import { MAX_CHUNK_SIZE, MIN_CHUNK_SIZE, buildLayers, generateLeaves, } from 'arweave/node/lib/merkle.js';
-import { Readable } from 'node:stream';
 import { toB64Url } from '../../../../utils/base64.js';
-export async function convertBufferToDataRoot({ buffer, }) {
-    const chunks = [];
-    let cursor = 0;
-    let offset = 0;
-    while (offset < buffer.byteLength) {
-        let chunkSize = Math.min(MAX_CHUNK_SIZE, buffer.byteLength - offset);
-        const remainder = buffer.byteLength - offset - chunkSize;
-        if (remainder > 0 && remainder < MIN_CHUNK_SIZE) {
-            chunkSize = Math.ceil((buffer.byteLength - offset) / 2);
-        }
-        // subarray does not exist on web Buffer type
-        const slice = buffer.subarray(offset, offset + chunkSize);
-        const hash = await crypto.subtle.digest('SHA-256', slice);
-        const hashArray = new Uint8Array(hash);
-        chunks.push({
-            dataHash: hashArray,
-            minByteRange: cursor,
-            maxByteRange: cursor + chunkSize,
-        });
-        cursor += chunkSize;
-        offset += chunkSize;
-    }
-    const leaves = await generateLeaves(chunks);
-    const result = await buildLayers(leaves);
-    return Buffer.from(result.id).toString('base64url');
-}
-export const convertReadableToDataRoot = async ({ iterable, }) => {
+import { isAsyncIterable, readableStreamToAsyncIterable, } from '../../../../utils/hash.js';
+export const convertDataStreamToDataRoot = async ({ dataStream, }) => {
     const chunks = [];
     let leftover = new Uint8Array(0);
     let cursor = 0;
-    for await (const data of iterable) {
+    const asyncIterable = isAsyncIterable(dataStream)
+        ? dataStream
+        : readableStreamToAsyncIterable(dataStream);
+    for await (const data of asyncIterable) {
         const inputChunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
         const combined = new Uint8Array(leftover.length + inputChunk.length);
         combined.set(leftover, 0);
@@ -72,6 +49,7 @@ export const convertReadableToDataRoot = async ({ iterable, }) => {
         leftover = combined.slice(startIndex);
     }
     if (leftover.length > 0) {
+        // TODO: ensure a web friendly crypto hash function is used in web
         const dataHash = await Arweave.crypto.hash(leftover);
         chunks.push({
             dataHash,
@@ -89,20 +67,14 @@ export class DataRootVerificationStrategy {
         this.trustedDataRootProvider = trustedDataRootProvider;
     }
     async verifyData({ data, txId, }) {
-        const trustedDataRootPromise = this.trustedDataRootProvider.getDataRoot({
-            txId,
-        });
-        let computedDataRoot;
-        if (Buffer.isBuffer(data)) {
-            computedDataRoot = await convertBufferToDataRoot({ buffer: data });
-        }
-        else if (data instanceof Readable || data instanceof ReadableStream) {
-            computedDataRoot = await convertReadableToDataRoot({ iterable: data });
-        }
-        if (computedDataRoot === undefined) {
-            throw new Error('Data root could not be computed');
-        }
-        const trustedDataRoot = await trustedDataRootPromise;
+        const [computedDataRoot, trustedDataRoot] = await Promise.all([
+            convertDataStreamToDataRoot({
+                dataStream: data,
+            }),
+            this.trustedDataRootProvider.getDataRoot({
+                txId,
+            }),
+        ]);
         if (computedDataRoot !== trustedDataRoot) {
             throw new Error('Data root does not match', {
                 cause: { computedDataRoot, trustedDataRoot },

package/lib/esm/common/wayfinder/verification/strategies/hash-verifier.js

@@ -1,45 +1,22 @@
-/**
- * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-import { Readable } from 'node:stream';
-import { hashBufferToB64Url, hashReadableStreamToB64Url, hashReadableToB64Url, } from '../../../../utils/hash.js';
+import { hashDataStreamToB64Url } from '../../../../utils/hash.js';
 export class HashVerificationStrategy {
     trustedHashProvider;
     constructor({ trustedHashProvider, }) {
         this.trustedHashProvider = trustedHashProvider;
     }
     async verifyData({ data, txId, }) {
-        const hashPromise = this.trustedHashProvider.getHash({ txId });
-        let computedHash;
-        if (Buffer.isBuffer(data)) {
-            computedHash = hashBufferToB64Url(data);
-        }
-        else if (data instanceof Readable) {
-            computedHash = await hashReadableToB64Url(data);
-        }
-        else if (data instanceof ReadableStream) {
-            computedHash = await hashReadableStreamToB64Url(data);
-        }
+        // kick off the hash computation, but don't wait for it until we compute our own hash
+        const [computedHash, fetchedHash] = await Promise.all([
+            hashDataStreamToB64Url(data),
+            this.trustedHashProvider.getHash({ txId }),
+        ]);
         // await on the hash promise and compare to get a little concurrency when computing hashes over larger data
-        const { hash } = await hashPromise;
         if (computedHash === undefined) {
             throw new Error('Hash could not be computed');
         }
-        if (computedHash !== hash) {
+        if (computedHash !== fetchedHash.hash) {
             throw new Error('Hash does not match', {
-                cause: { computedHash, trustedHash: hash },
+                cause: { computedHash, trustedHash: fetchedHash },
             });
         }
     }