@ar.io/sdk 3.11.0-beta.1 → 3.11.1-alpha.1

package/lib/cjs/common/wayfinder/routing/strategies/ping.js

@@ -1,72 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FastestPingRoutingStrategy = void 0;
-class FastestPingRoutingStrategy {
-    timeoutMs;
-    probePath;
-    constructor({ timeoutMs = 500, probePath = '/ar-io/info', // TODO: limit to allowed /ar-io and arweave node endpoints
-     } = {}) {
-        this.timeoutMs = timeoutMs;
-        this.probePath = probePath;
-    }
-    async selectGateway({ gateways }) {
-        if (gateways.length === 0) {
-            throw new Error('No gateways provided');
-        }
-        try {
-            const results = await Promise.allSettled(gateways.map(async (gateway) => {
-                try {
-                    const startTime = Date.now();
-                    const response = await fetch(`${gateway.toString().replace(/\/$/, '')}${this.probePath}`, {
-                        method: 'HEAD',
-                        signal: AbortSignal.timeout(this.timeoutMs),
-                    });
-                    const endTime = Date.now();
-                    const durationMs = endTime - startTime;
-                    return {
-                        gateway,
-                        status: response.status,
-                        durationMs,
-                        error: null,
-                    };
-                }
-                catch (error) {
-                    // Handle network errors
-                    return {
-                        gateway,
-                        status: 'rejected',
-                        durationMs: Infinity,
-                        error,
-                    };
-                }
-            }));
-            // Process results
-            const processedResults = results.map((result, index) => {
-                if (result.status === 'fulfilled') {
-                    return result.value;
-                }
-                else {
-                    return {
-                        gateway: gateways[index],
-                        status: 'rejected',
-                        durationMs: Infinity,
-                        error: result.reason,
-                    };
-                }
-            });
-            // Filter healthy gateways and sort by latency
-            const healthyGateways = processedResults
-                .filter((result) => result.status === 200)
-                .sort((a, b) => a.durationMs - b.durationMs);
-            if (healthyGateways.length > 0) {
-                return healthyGateways[0].gateway;
-            }
-            throw new Error('No healthy gateways found');
-        }
-        catch (error) {
-            throw new Error('Failed to ping gateways: ' +
-                (error instanceof Error ? error.message : String(error)));
-        }
-    }
-}
-exports.FastestPingRoutingStrategy = FastestPingRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/ping.test.js

@@ -1,156 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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.
- */
-const strict_1 = __importDefault(require("node:assert/strict"));
-const node_test_1 = require("node:test");
-const ping_js_1 = require("./ping.js");
-(0, node_test_1.describe)('FastestPingRoutingStrategy', () => {
-    // Original fetch function
-    const originalFetch = global.fetch;
-    // Mock response options for each gateway
-    const mockResponses = new Map();
-    (0, node_test_1.beforeEach)(() => {
-        // reset mock responses
-        mockResponses.clear();
-        // mock fetch to simulate network latency and response status
-        global.fetch = async (url) => {
-            const urlString = url.toString();
-            // find the matching gateway
-            let matchingGateway = '';
-            for (const gateway of mockResponses.keys()) {
-                if (urlString.startsWith(gateway)) {
-                    matchingGateway = gateway;
-                    break;
-                }
-            }
-            if (!matchingGateway) {
-                return Promise.reject(new Error(`No mock response for URL: ${urlString}`));
-            }
-            const { status, delayMs } = mockResponses.get(matchingGateway);
-            // simulate network delay
-            await new Promise((resolve) => setTimeout(resolve, delayMs));
-            return new Response(null, { status });
-        };
-        // mock AbortSignal.timeout
-        if (!AbortSignal.timeout) {
-            AbortSignal.timeout = (ms) => {
-                const controller = new AbortController();
-                setTimeout(() => controller.abort(), ms);
-                return controller.signal;
-            };
-        }
-    });
-    // restore original fetch after tests
-    (0, node_test_1.afterEach)(() => {
-        global.fetch = originalFetch;
-    });
-    (0, node_test_1.it)('selects the gateway with the lowest latency', async () => {
-        const gateways = [
-            new URL('https://slow.com'),
-            new URL('https://fast.com'),
-            new URL('https://medium.com'),
-        ];
-        // configure mock responses
-        mockResponses.set('https://slow.com', { status: 200, delayMs: 300 });
-        mockResponses.set('https://fast.com', { status: 200, delayMs: 50 });
-        mockResponses.set('https://medium.com', { status: 200, delayMs: 150 });
-        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
-        // select the gateway with the lowest latency
-        const selectedGateway = await strategy.selectGateway({
-            gateways,
-        });
-        strict_1.default.equal(selectedGateway.toString(), 'https://fast.com/', 'Should select the gateway with the lowest latency');
-    });
-    (0, node_test_1.it)('ignores gateways that return non-200 status codes', async () => {
-        const gateways = [
-            new URL('https://error.com'),
-            new URL('https://success.com'),
-            new URL('https://another-error.com'),
-        ];
-        // configure mock responses
-        mockResponses.set('https://error.com', { status: 404, delayMs: 50 });
-        mockResponses.set('https://success.com', { status: 200, delayMs: 100 });
-        mockResponses.set('https://another-error.com', {
-            status: 500,
-            delayMs: 75,
-        });
-        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
-        // select the gateway with the lowest latency
-        const selectedGateway = await strategy.selectGateway({
-            gateways,
-        });
-        strict_1.default.equal(selectedGateway.toString(), 'https://success.com/', 'Should select the gateway that returns a 200 status code');
-    });
-    (0, node_test_1.it)('throws an error when all gateways fail', async () => {
-        const gateways = [
-            new URL('https://error1.com'),
-            new URL('https://error2.com'),
-        ];
-        // configure mock responses
-        mockResponses.set('https://error1.com', { status: 404, delayMs: 50 });
-        mockResponses.set('https://error2.com', { status: 500, delayMs: 75 });
-        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
-        // select the gateway with the lowest latency
-        await strict_1.default.rejects(async () => await strategy.selectGateway({ gateways }), /No healthy gateways found/, 'Should throw an error when all gateways fail');
-    });
-    (0, node_test_1.it)('handles network errors gracefully', async () => {
-        const gateways = [
-            new URL('https://network-error.com'),
-            new URL('https://success.com'),
-        ];
-        // configure mock responses
-        mockResponses.set('https://success.com', { status: 200, delayMs: 100 });
-        // override fetch for the network error case
-        const originalFetchMock = global.fetch;
-        global.fetch = async (url) => {
-            if (url.toString().includes('network-error')) {
-                throw new Error('Network error');
-            }
-            return originalFetchMock(url);
-        };
-        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 500 });
-        // select the gateway with the lowest latency
-        const selectedGateway = await strategy.selectGateway({
-            gateways,
-        });
-        strict_1.default.equal(selectedGateway.toString(), 'https://success.com/', 'Should handle network errors and select the working gateway');
-    });
-    (0, node_test_1.it)('respects the timeout parameter', async () => {
-        const gateways = [
-            new URL('https://timeout.com'),
-            new URL('https://fast.com'),
-        ];
-        // configure mock responses
-        mockResponses.set('https://timeout.com', { status: 200, delayMs: 300 });
-        mockResponses.set('https://fast.com', { status: 200, delayMs: 50 });
-        // set a short timeout
-        const strategy = new ping_js_1.FastestPingRoutingStrategy({ timeoutMs: 100 });
-        const selectedGateway = await strategy.selectGateway({
-            gateways,
-        });
-        strict_1.default.equal(selectedGateway.toString(), 'https://fast.com/', 'Should respect the timeout and select only gateways that respond within the timeout');
-    });
-    (0, node_test_1.it)('throws an error when no gateways are provided', async () => {
-        const gateways = [];
-        const strategy = new ping_js_1.FastestPingRoutingStrategy();
-        // select the gateway with the lowest latency
-        await strict_1.default.rejects(async () => await strategy.selectGateway({ gateways }), /No gateways provided/, 'Should throw an error when no gateways are provided');
-    });
-});

package/lib/cjs/common/wayfinder/routing/strategies/random.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RandomRoutingStrategy = void 0;
-const random_js_1 = require("../../../../utils/random.js");
-class RandomRoutingStrategy {
-    async selectGateway({ gateways }) {
-        if (gateways.length === 0) {
-            throw new Error('No gateways available');
-        }
-        return gateways[(0, random_js_1.randomInt)(0, gateways.length)];
-    }
-}
-exports.RandomRoutingStrategy = RandomRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/random.test.js

@@ -1,68 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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.
- */
-const strict_1 = __importDefault(require("node:assert/strict"));
-const node_test_1 = require("node:test");
-const random_js_1 = require("./random.js");
-(0, node_test_1.describe)('RandomRoutingStrategy', () => {
-    (0, node_test_1.it)('selects a gateway from the provided list', async () => {
-        // Arrange
-        const gateways = [
-            new URL('https://example1.com'),
-            new URL('https://example2.com'),
-            new URL('https://example3.com'),
-        ];
-        const strategy = new random_js_1.RandomRoutingStrategy();
-        const selectedGateway = await strategy.selectGateway({ gateways });
-        strict_1.default.ok(gateways.includes(selectedGateway), 'The selected gateway should be one of the gateways provided');
-    });
-    (0, node_test_1.it)('throws error when no gateways are provided', async () => {
-        const gateways = [];
-        const strategy = new random_js_1.RandomRoutingStrategy();
-        await strict_1.default.rejects(async () => await strategy.selectGateway({ gateways }), /No gateways available/, 'Should throw an error when no gateways are provided');
-    });
-    (0, node_test_1.it)('should distribute gateway selection somewhat randomly', async () => {
-        const gateways = [
-            new URL('https://example1.com'),
-            new URL('https://example2.com'),
-            new URL('https://example3.com'),
-            new URL('https://example4.com'),
-            new URL('https://example5.com'),
-        ];
-        const strategy = new random_js_1.RandomRoutingStrategy();
-        const selections = new Map();
-        // select gateways multiple times
-        const iterations = 100;
-        for (let i = 0; i < iterations; i++) {
-            const gateway = await strategy.selectGateway({ gateways });
-            const key = gateway.toString();
-            selections.set(key, (selections.get(key) || 0) + 1);
-        }
-        // each gateway should be selected at least once
-        for (const gateway of gateways) {
-            const key = gateway.toString();
-            strict_1.default.ok(selections.has(key), `Gateway ${key} should be selected at least once`);
-        }
-        // no gateway should be selected more than 50% of the time
-        for (const [key, count] of selections.entries()) {
-            strict_1.default.ok(count < iterations * 0.5, `Gateway ${key} was selected ${count} times, which is more than 50% of iterations`);
-        }
-    });
-});

package/lib/cjs/common/wayfinder/routing/strategies/round-robin.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.RoundRobinRoutingStrategy = void 0;
-/**
- * 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.
- */
-const logger_js_1 = require("../../../../common/logger.js");
-class RoundRobinRoutingStrategy {
-    gateways;
-    currentIndex;
-    logger;
-    constructor({ gateways, logger = logger_js_1.Logger.default, }) {
-        this.gateways = gateways;
-        this.currentIndex = 0;
-        this.logger = logger;
-    }
-    // provided gateways are ignored
-    async selectGateway({ gateways = [], } = {}) {
-        if (gateways.length > 0) {
-            this.logger.warn('RoundRobinRoutingStrategy does not accept provided gateways. Ignoring provided gateways...', {
-                providedGateways: gateways.length,
-                internalGateways: this.gateways,
-            });
-        }
-        const gateway = this.gateways[this.currentIndex];
-        this.currentIndex = (this.currentIndex + 1) % this.gateways.length;
-        return gateway;
-    }
-}
-exports.RoundRobinRoutingStrategy = RoundRobinRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/round-robin.test.js

@@ -1,78 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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.
- */
-const strict_1 = __importDefault(require("node:assert/strict"));
-const node_test_1 = require("node:test");
-const logger_js_1 = require("../../../../common/logger.js");
-const round_robin_js_1 = require("./round-robin.js");
-logger_js_1.Logger.default.setLogLevel('none');
-(0, node_test_1.describe)('RoundRobinRoutingStrategy', () => {
-    (0, node_test_1.it)('selects gateways in order and cycles back to the beginning', async () => {
-        const gateways = [
-            new URL('https://example1.com'),
-            new URL('https://example2.com'),
-            new URL('https://example3.com'),
-        ];
-        const strategy = new round_robin_js_1.RoundRobinRoutingStrategy({ gateways });
-        const selection1 = await strategy.selectGateway();
-        strict_1.default.equal(selection1.toString(), gateways[0].toString(), 'Should select the first gateway first');
-        const selection2 = await strategy.selectGateway();
-        strict_1.default.equal(selection2.toString(), gateways[1].toString(), 'Should select the second gateway second');
-        const selection3 = await strategy.selectGateway();
-        strict_1.default.equal(selection3.toString(), gateways[2].toString(), 'Should select the third gateway third');
-        // should cycle back to the first gateway
-        const selection4 = await strategy.selectGateway();
-        strict_1.default.equal(selection4.toString(), gateways[0].toString(), 'Should cycle back to the first gateway');
-    });
-    (0, node_test_1.it)('uses the internal list even when a different list is provided', async () => {
-        const initialGateways = [
-            new URL('https://example1.com'),
-            new URL('https://example2.com'),
-        ];
-        const newGateways = [
-            new URL('https://example3.com'),
-            new URL('https://example4.com'),
-        ];
-        const strategy = new round_robin_js_1.RoundRobinRoutingStrategy({
-            gateways: initialGateways,
-        });
-        const selection1 = await strategy.selectGateway({
-            gateways: newGateways,
-        });
-        strict_1.default.equal(selection1.toString(), initialGateways[0].toString(), 'Should use the internal list even when a different list is provided');
-        const selection2 = await strategy.selectGateway({
-            // @ts-ignore
-            gateways: newGateways,
-        });
-        strict_1.default.equal(selection2.toString(), initialGateways[1].toString(), 'Should use the internal list even when a different list is provided');
-    });
-    (0, node_test_1.it)('handles a single gateway by returning it repeatedly', async () => {
-        const gateways = [new URL('https://example1.com')];
-        const strategy = new round_robin_js_1.RoundRobinRoutingStrategy({ gateways });
-        const selection1 = await strategy.selectGateway({
-            gateways: [new URL('https://example2.com')],
-        });
-        strict_1.default.equal(selection1.toString(), gateways[0].toString(), 'Should return the single gateway');
-        const selection2 = await strategy.selectGateway({
-            gateways: [new URL('https://example2.com')],
-        });
-        strict_1.default.equal(selection2.toString(), gateways[0].toString(), 'Should return the single gateway again');
-    });
-});

package/lib/cjs/common/wayfinder/routing/strategies/static.js

@@ -1,29 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StaticRoutingStrategy = void 0;
-const logger_js_1 = require("../../../logger.js");
-class StaticRoutingStrategy {
-    name = 'static';
-    gateway;
-    logger;
-    constructor({ gateway, logger = logger_js_1.Logger.default, }) {
-        try {
-            this.gateway = new URL(gateway);
-        }
-        catch (error) {
-            throw new Error(`Invalid URL provided for static gateway: ${gateway}`);
-        }
-        this.logger = logger;
-    }
-    // provided gateways are ignored
-    async selectGateway({ gateways = [], } = {}) {
-        if (gateways.length > 0) {
-            this.logger.warn('StaticRoutingStrategy does not accept provided gateways. Ignoring provided gateways...', {
-                providedGateways: gateways.length,
-                internalGateway: this.gateway,
-            });
-        }
-        return this.gateway;
-    }
-}
-exports.StaticRoutingStrategy = StaticRoutingStrategy;

package/lib/cjs/common/wayfinder/routing/strategies/static.test.js

@@ -1,40 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-/**
- * 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.
- */
-const strict_1 = __importDefault(require("node:assert/strict"));
-const node_test_1 = require("node:test");
-const static_js_1 = require("./static.js");
-(0, node_test_1.describe)('StaticRoutingStrategy', () => {
-    (0, node_test_1.it)('returns the configured gateway regardless of the gateways parameter', async () => {
-        const staticGateway = 'https://static-example.com/';
-        const strategy = new static_js_1.StaticRoutingStrategy({
-            gateway: staticGateway,
-        });
-        const result1 = await strategy.selectGateway();
-        const result2 = await strategy.selectGateway();
-        const result3 = await strategy.selectGateway();
-        strict_1.default.equal(result1.toString(), staticGateway, 'Should return the static gateway');
-        strict_1.default.equal(result2.toString(), staticGateway, 'Should return the static gateway');
-        strict_1.default.equal(result3.toString(), staticGateway, 'Should return the static gateway even when no gateways are provided');
-    });
-    (0, node_test_1.it)('throws an error when an invalid URL is provided', () => {
-        strict_1.default.throws(() => new static_js_1.StaticRoutingStrategy({ gateway: 'not-a-valid-url' }), /Invalid URL provided for static gateway/, 'Should throw an error when an invalid URL is provided');
-    });
-});

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

@@ -1,139 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataRootVerificationStrategy = exports.convertReadableToDataRoot = void 0;
-exports.convertBufferToDataRoot = convertBufferToDataRoot;
-/**
- * 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.
- */
-const arweave_1 = __importDefault(require("arweave"));
-const merkle_js_1 = require("arweave/node/lib/merkle.js");
-const node_stream_1 = require("node:stream");
-const base64_js_1 = require("../../../../utils/base64.js");
-async function convertBufferToDataRoot({ buffer, }) {
-    const chunks = [];
-    let cursor = 0;
-    let offset = 0;
-    while (offset < buffer.byteLength) {
-        let chunkSize = Math.min(merkle_js_1.MAX_CHUNK_SIZE, buffer.byteLength - offset);
-        const remainder = buffer.byteLength - offset - chunkSize;
-        if (remainder > 0 && remainder < merkle_js_1.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 (0, merkle_js_1.generateLeaves)(chunks);
-    const result = await (0, merkle_js_1.buildLayers)(leaves);
-    return Buffer.from(result.id).toString('base64url');
-}
-const convertReadableToDataRoot = async ({ iterable, }) => {
-    const chunks = [];
-    let leftover = new Uint8Array(0);
-    let cursor = 0;
-    for await (const data of iterable) {
-        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) {
-        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.convertReadableToDataRoot = convertReadableToDataRoot;
-class DataRootVerificationStrategy {
-    trustedDataRootProvider;
-    constructor({ trustedDataRootProvider, }) {
-        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 node_stream_1.Readable || data instanceof ReadableStream) {
-            computedDataRoot = await (0, exports.convertReadableToDataRoot)({ iterable: data });
-        }
-        if (computedDataRoot === undefined) {
-            throw new Error('Data root could not be computed');
-        }
-        const trustedDataRoot = await trustedDataRootPromise;
-        if (computedDataRoot !== trustedDataRoot) {
-            throw new Error('Data root does not match', {
-                cause: { computedDataRoot, trustedDataRoot },
-            });
-        }
-    }
-}
-exports.DataRootVerificationStrategy = DataRootVerificationStrategy;
-// some data item options
-// compute and verify data root, use offsets from server and verify the signature that the data item at the offset matches the signature
-// does not give you assurance of valid bundle, but gives verification that the data item itself is valid
-// reading from offsets is the only way for the client to compute and verify the signature
-/**
- * - when you get a signature of a data item, you can only verify the owner
- * - you still need to verify it's going back to the bundle, unpack it, and verify the data item exists at the offset
- * - you need to the location of the chunks for the data item, and prove it's in the chunk and then prove the data root of the bundle, then you have fully verified the data verifier
- * - how to prove the data item is on arweave - verify the merkle hash that the chunks for the data item, fit within the expected tree of the parent bundle
- *
- * Composite verifier - you'll want to be very efficient with streams
- * - hash verifier
- * - parent chunks verifier --> for any range of data within a single transaction, tell me that it's correct
- * - signature verifier
- * - offset verifier
- * - data item verifier
- */
-// introduce a composite verifier that determines where/how to lookup the hash