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

package/lib/cjs/common/wayfinder/wayfinder.test.js

@@ -11,8 +11,8 @@ const node_stream_1 = require("node:stream");
 const consumers_1 = require("node:stream/consumers");
 const node_test_1 = require("node:test");
 const logger_js_1 = require("../../common/logger.js");
-const random_js_1 = require("./routers/random.js");
-const static_js_1 = require("./routers/static.js");
+const random_js_1 = require("./routing/strategies/random.js");
+const static_js_1 = require("./routing/strategies/static.js");
 const wayfinder_js_1 = require("./wayfinder.js");
 // TODO: replace with locally running gateway
 const gatewayUrl = 'permagate.io';
@@ -21,15 +21,14 @@ const stubbedGatewaysProvider = {
 };
 logger_js_1.Logger.default.setLogLevel('none');
 (0, node_test_1.describe)('Wayfinder', () => {
-    node_test_1.describe.skip('http wrapper', () => {
+    (0, node_test_1.describe)('http wrapper', () => {
         (0, node_test_1.describe)('fetch', () => {
             let wayfinder;
             (0, node_test_1.before)(() => {
                 wayfinder = new wayfinder_js_1.Wayfinder({
                     httpClient: fetch,
-                    router: new random_js_1.RandomGatewayRouter({
-                        gatewaysProvider: stubbedGatewaysProvider,
-                    }),
+                    routingStrategy: new random_js_1.RandomRoutingStrategy(),
+                    gatewaysProvider: stubbedGatewaysProvider,
                 });
             });
             (0, node_test_1.it)('should fetch the data using the selected gateway', async () => {
@@ -54,9 +53,11 @@ logger_js_1.Logger.default.setLogLevel('none');
                 const [nativeFetch, response] = await Promise.all([
                     fetch(`https://${gatewayUrl}/`, {
                         method: 'HEAD',
+                        redirect: 'follow',
                     }),
                     wayfinder.request(`https://${gatewayUrl}/`, {
                         method: 'HEAD',
+                        redirect: 'follow',
                     }),
                 ]);
                 node_assert_1.default.strictEqual(response.status, 200);
@@ -64,10 +65,14 @@ logger_js_1.Logger.default.setLogLevel('none');
                 // TODO: ensure the headers are the same excluding unique headers
             });
             for (const api of ['/info', '/block/current']) {
-                (0, node_test_1.it)(`supports native arweave node apis ${api}`, async () => {
+                node_test_1.it.skip(`supports native arweave node apis ${api}`, async () => {
                     const [nativeFetch, response] = await Promise.all([
-                        fetch(`https://${gatewayUrl}${api}`),
-                        wayfinder.request(`ar://${api}`),
+                        fetch(`https://${gatewayUrl}${api}`, {
+                            redirect: 'follow',
+                        }),
+                        wayfinder.request(`ar://${api}`, {
+                            redirect: 'follow',
+                        }),
                     ]);
                     node_assert_1.default.strictEqual(response.status, 200);
                     node_assert_1.default.strictEqual(response.status, nativeFetch.status);
@@ -88,6 +93,7 @@ logger_js_1.Logger.default.setLogLevel('none');
             (0, node_test_1.it)('supports a post request to graphql', async () => {
                 const response = await wayfinder.request('ar:///graphql', {
                     method: 'POST',
+                    redirect: 'follow',
                     headers: {
                         'Content-Type': 'application/json',
                     },
@@ -121,10 +127,14 @@ logger_js_1.Logger.default.setLogLevel('none');
                 });
                 node_assert_1.default.strictEqual(response.status, 200);
             });
-            node_test_1.it.skip('returns the error from the target gateway if the route is not found', async () => {
+            (0, node_test_1.it)('returns the error from the target gateway if the route is not found', async () => {
                 const [nativeFetch, response] = await Promise.all([
-                    fetch(`https://${gatewayUrl}/ar-io/not-found`),
-                    wayfinder.request('ar:///not-found'),
+                    fetch(`https://${gatewayUrl}/ar-io/not-found`, {
+                        redirect: 'follow',
+                    }),
+                    wayfinder.request('ar:///ar-io/not-found', {
+                        redirect: 'follow',
+                    }),
                 ]);
                 node_assert_1.default.strictEqual(response.status, nativeFetch.status);
                 node_assert_1.default.strictEqual(response.statusText, nativeFetch.statusText);
@@ -135,17 +145,17 @@ logger_js_1.Logger.default.setLogLevel('none');
             (0, node_test_1.before)(() => {
                 wayfinder = new wayfinder_js_1.Wayfinder({
                     httpClient: axios_1.default,
-                    router: new random_js_1.RandomGatewayRouter({
-                        gatewaysProvider: stubbedGatewaysProvider,
-                    }),
+                    routingStrategy: new random_js_1.RandomRoutingStrategy(),
+                    gatewaysProvider: stubbedGatewaysProvider,
                 });
             });
             (0, node_test_1.it)('should fetch the data using axios default function against the target gateway', async () => {
                 const [nativeAxios, response] = await Promise.all([
                     (0, axios_1.default)(`https://ao.${gatewayUrl}`),
-                    wayfinder.request('ar://ao'),
+                    wayfinder.request('ar://ao', {
+                        maxRedirects: 5,
+                    }),
                 ]);
-                node_assert_1.default.strictEqual(response.status, 200);
                 node_assert_1.default.strictEqual(response.status, nativeAxios.status);
                 // assert the arns headers are the same
                 const arnsHeaders = Object.entries(response.headers)
@@ -159,7 +169,6 @@ logger_js_1.Logger.default.setLogLevel('none');
                     axios_1.default.get(`https://ao.${gatewayUrl}`),
                     wayfinder.request.get('ar://ao'),
                 ]);
-                node_assert_1.default.strictEqual(response.status, 200);
                 node_assert_1.default.strictEqual(response.status, nativeAxios.status);
                 // assert the arns headers are the same
                 const arnsHeaders = Object.entries(response.headers)
@@ -178,7 +187,7 @@ logger_js_1.Logger.default.setLogLevel('none');
                 // TODO: ensure the headers are the same excluding unique headers
             });
             for (const api of ['/info', '/block/current']) {
-                (0, node_test_1.it)(`supports native arweave node apis ${api}`, async () => {
+                node_test_1.it.skip(`supports native arweave node apis ${api}`, async () => {
                     const [nativeAxios, response] = await Promise.all([
                         (0, axios_1.default)(`https://${gatewayUrl}${api}`),
                         wayfinder.request(`ar://${api}`),
@@ -192,26 +201,24 @@ logger_js_1.Logger.default.setLogLevel('none');
                 (0, node_test_1.it)(`supports native ario node gateway apis ${api}`, async () => {
                     const [nativeAxios, response] = await Promise.all([
                         (0, axios_1.default)(`https://${gatewayUrl}${api}`),
-                        wayfinder.request(`ar:///${api}`),
+                        wayfinder.request(`ar://${api}`),
                     ]);
                     node_assert_1.default.strictEqual(response.status, 200);
                     node_assert_1.default.strictEqual(response.status, nativeAxios.status);
                     // TODO: ensure the headers are the same excluding unique headers
                 });
             }
-            node_test_1.it.skip('should return the error from the target gateway if the route is not found', async () => {
+            (0, node_test_1.it)('should return the error from the target gateway if the route is not found', async () => {
                 const axiosInstance = axios_1.default.create({
                     validateStatus: () => true, // don't throw so we can compare axios result with wrapped axios result
                 });
                 const wayfinder = new wayfinder_js_1.Wayfinder({
                     httpClient: axiosInstance,
-                    router: new random_js_1.RandomGatewayRouter({
-                        gatewaysProvider: stubbedGatewaysProvider,
-                    }),
+                    routingStrategy: new random_js_1.RandomRoutingStrategy(),
                 });
                 const [nativeAxios, response] = await Promise.all([
                     axiosInstance(`https://${gatewayUrl}/ar-io/not-found`),
-                    wayfinder.request('ar:///not-found'),
+                    wayfinder.request('ar:///ar-io/not-found'),
                 ]);
                 node_assert_1.default.strictEqual(response.status, nativeAxios.status);
             });
@@ -221,9 +228,8 @@ logger_js_1.Logger.default.setLogLevel('none');
             (0, node_test_1.before)(() => {
                 wayfinder = new wayfinder_js_1.Wayfinder({
                     httpClient: got_1.default,
-                    router: new random_js_1.RandomGatewayRouter({
-                        gatewaysProvider: stubbedGatewaysProvider,
-                    }),
+                    routingStrategy: new random_js_1.RandomRoutingStrategy(),
+                    gatewaysProvider: stubbedGatewaysProvider,
                 });
             });
             (0, node_test_1.it)('should fetch the data using the got default function against the target gateway', async () => {
@@ -231,13 +237,18 @@ logger_js_1.Logger.default.setLogLevel('none');
                     (0, got_1.default)(`https://ao.${gatewayUrl}`),
                     wayfinder.request('ar://ao'),
                 ]);
-                node_assert_1.default.strictEqual(response.statusCode, 200);
                 node_assert_1.default.strictEqual(response.statusCode, nativeGot.statusCode);
                 node_assert_1.default.deepStrictEqual(response.body, nativeGot.body);
             });
             (0, node_test_1.it)('should stream the data using got.stream against the selected target gateway', async () => {
-                const nativeBuffer = await (0, consumers_1.buffer)(await got_1.default.stream(`https://ao.${gatewayUrl}`, { decompress: false }));
-                const wayfinderBuffer = await (0, consumers_1.buffer)(await wayfinder.request.stream('ar://ao', { decompress: false }));
+                const nativeBuffer = await (0, consumers_1.buffer)(await got_1.default.stream(`https://ao.${gatewayUrl}`, {
+                    decompress: false,
+                    followRedirect: true,
+                }));
+                const wayfinderBuffer = await (0, consumers_1.buffer)(await wayfinder.request.stream('ar://ao', {
+                    decompress: false,
+                    followRedirect: true,
+                }));
                 node_assert_1.default.deepStrictEqual(wayfinderBuffer, nativeBuffer);
             });
         });
@@ -246,10 +257,10 @@ logger_js_1.Logger.default.setLogLevel('none');
         (0, node_test_1.it)('should emit events on the wayfinder event emitter', async () => {
             const wayfinder = new wayfinder_js_1.Wayfinder({
                 httpClient: fetch,
-                router: new static_js_1.StaticGatewayRouter({
+                routingStrategy: new static_js_1.StaticRoutingStrategy({
                     gateway: `http://${gatewayUrl}`,
                 }),
-                verifier: {
+                verificationStrategy: {
                     // @ts-expect-error
                     verifyData: async (params) => {
                         return;
@@ -263,8 +274,8 @@ logger_js_1.Logger.default.setLogLevel('none');
             wayfinder.emitter.on('verification-progress', (event) => {
                 events.push({ type: 'verification-progress', ...event });
             });
-            wayfinder.emitter.on('verification-passed', (event) => {
-                events.push({ type: 'verification-passed', ...event });
+            wayfinder.emitter.on('verification-succeeded', (event) => {
+                events.push({ type: 'verification-succeeded', ...event });
             });
             // request data and assert the event is emitted
             const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
@@ -273,7 +284,7 @@ logger_js_1.Logger.default.setLogLevel('none');
             // read the full response body to ensure the stream is fully consumed
             await response.text();
             node_assert_1.default.strictEqual(response.status, 200);
-            node_assert_1.default.ok(events.find((e) => e.type === 'verification-passed'), 'Should emit at least one verification-passed');
+            node_assert_1.default.ok(events.find((e) => e.type === 'verification-succeeded'), 'Should emit at least one verification-succeeded');
         });
         (0, node_test_1.it)('should execute callbacks provided to the wayfinder constructor', async () => {
             let verificationFailed = false;
@@ -281,7 +292,7 @@ logger_js_1.Logger.default.setLogLevel('none');
             let verificationPassed = false;
             const wayfinder = new wayfinder_js_1.Wayfinder({
                 httpClient: fetch,
-                router: new static_js_1.StaticGatewayRouter({
+                routingStrategy: new static_js_1.StaticRoutingStrategy({
                     gateway: `http://${gatewayUrl}`,
                 }),
                 events: {
@@ -295,6 +306,7 @@ logger_js_1.Logger.default.setLogLevel('none');
                         verificationPassed = true;
                     },
                 },
+                strict: true,
             });
             const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
                 redirect: 'follow',
@@ -304,196 +316,203 @@ logger_js_1.Logger.default.setLogLevel('none');
             node_assert_1.default.strictEqual(response.status, 200);
             node_assert_1.default.ok(verificationFailed === false, 'Should not emit verification-failed');
             node_assert_1.default.ok(verificationProgress, 'Should emit verification-progress');
-            node_assert_1.default.ok(verificationPassed, 'Should emit verification-passed');
+            node_assert_1.default.ok(verificationPassed, 'Should emit verification-succeeded');
         });
     });
-    node_test_1.describe.skip('tapAndVerifyRequest', () => {
+    (0, node_test_1.describe)('tapAndVerifyRequest', () => {
         (0, node_test_1.describe)('Readable', () => {
-            (0, node_test_1.it)('should duplicate the stream, verify the first and return the second if verification passes', async () => {
-                // create a simple readable
-                const chunks = [
-                    Buffer.from('foo'),
-                    Buffer.from('bar'),
-                    Buffer.from('baz'),
-                ];
-                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                // a stream that will emit chunks
-                const originalStream = node_stream_1.Readable.from(chunks);
-                let seen = Buffer.alloc(0);
-                const verifyData = async ({ data, 
-                // @ts-expect-error
-                txId, }) => {
-                    return new Promise((resolve, reject) => {
-                        data.on('data', (chunk) => {
-                            seen = Buffer.concat([seen, chunk]);
-                        });
-                        data.on('end', () => {
-                            // Should have seen exactly the full payload
-                            node_assert_1.default.strictEqual(seen.length, contentLength);
-                            resolve();
+            (0, node_test_1.describe)('strict mode enabled', () => {
+                (0, node_test_1.it)('should duplicate the stream, verify the first and return the second if verification passes', async () => {
+                    // create a simple readable
+                    const chunks = [
+                        Buffer.from('foo'),
+                        Buffer.from('bar'),
+                        Buffer.from('baz'),
+                    ];
+                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                    // a stream that will emit chunks
+                    const originalStream = node_stream_1.Readable.from(chunks);
+                    let seen = Buffer.alloc(0);
+                    const verifyData = async ({ data, 
+                    // @ts-expect-error
+                    txId, }) => {
+                        return new Promise((resolve, reject) => {
+                            data.on('data', (chunk) => {
+                                seen = Buffer.concat([seen, chunk]);
+                            });
+                            data.on('end', () => {
+                                // Should have seen exactly the full payload
+                                node_assert_1.default.strictEqual(seen.length, contentLength);
+                                resolve();
+                            });
+                            data.on('error', reject);
                         });
-                        data.on('error', reject);
+                    };
+                    const txId = 'test-tx-1';
+                    const emitter = new node_events_1.EventEmitter();
+                    const events = [];
+                    emitter.on('verification-progress', (e) => {
+                        events.push({ type: 'verification-progress', ...e });
                     });
-                };
-                const txId = 'test-tx-1';
-                const emitter = new node_events_1.EventEmitter();
-                const events = [];
-                emitter.on('verification-progress', (e) => {
-                    console.log('verification-progress', e);
-                    events.push({ type: 'verification-progress', ...e });
-                });
-                emitter.on('verification-passed', (e) => events.push({ type: 'verification-passed', ...e }));
-                // tap with verification
-                const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
-                    originalStream,
-                    contentLength,
-                    verifyData,
-                    txId,
-                    emitter,
-                });
-                // read the stream
-                const out = [];
-                for await (const chunk of tapped) {
-                    out.push(chunk);
-                }
-                // assert the stream is the same
-                node_assert_1.default.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
-                node_assert_1.default.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
-                node_assert_1.default.ok(events.find((e) => e.type === 'verification-passed' && e.txId === txId), 'Should emit at least one verification-passed');
-            });
-            (0, node_test_1.it)('should throw an error on the client stream if verification fails', async () => {
-                const chunks = [
-                    Buffer.from('foo'),
-                    Buffer.from('bar'),
-                    Buffer.from('baz'),
-                ];
-                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                // a stream that will emit chunks
-                const originalStream = node_stream_1.Readable.from(chunks);
-                const verifyData = async ({ 
-                // @ts-expect-error
-                data, txId, }) => {
-                    throw new Error('Verification failed for txId: ' + txId);
-                };
-                const txId = 'test-tx-1';
-                const emitter = new node_events_1.EventEmitter();
-                const events = [];
-                emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
-                emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
-                // tap with verification
-                const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
-                    originalStream,
-                    contentLength,
-                    verifyData,
-                    txId,
-                    emitter,
-                });
-                // read the stream
-                try {
+                    emitter.on('verification-succeeded', (e) => events.push({ type: 'verification-succeeded', ...e }));
+                    // tap with verification
+                    const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
+                        originalStream,
+                        contentLength,
+                        verifyData,
+                        txId,
+                        emitter,
+                        strict: true,
+                    });
+                    // read the stream
                     const out = [];
                     for await (const chunk of tapped) {
                         out.push(chunk);
                     }
-                }
-                catch (error) {
-                    node_assert_1.default.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
-                    // stream should be closed
-                    node_assert_1.default.ok(tapped.closed);
-                }
+                    // assert the stream is the same
+                    node_assert_1.default.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
+                    node_assert_1.default.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
+                    node_assert_1.default.ok(events.find((e) => e.type === 'verification-succeeded' && e.txId === txId), 'Should emit at least one verification-succeeded');
+                });
+                (0, node_test_1.it)('should throw an error on the client stream if verification fails', async () => {
+                    const chunks = [
+                        Buffer.from('foo'),
+                        Buffer.from('bar'),
+                        Buffer.from('baz'),
+                    ];
+                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                    // a stream that will emit chunks
+                    const originalStream = node_stream_1.Readable.from(chunks);
+                    const verifyData = async ({ 
+                    // @ts-expect-error
+                    data, txId, }) => {
+                        throw new Error('Verification failed for txId: ' + txId);
+                    };
+                    const txId = 'test-tx-1';
+                    const emitter = new node_events_1.EventEmitter();
+                    const events = [];
+                    emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
+                    emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
+                    // tap with verification (using strict mode)
+                    const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
+                        originalStream,
+                        contentLength,
+                        verifyData,
+                        txId,
+                        emitter,
+                        strict: true,
+                    });
+                    // read the stream
+                    try {
+                        const out = [];
+                        for await (const chunk of tapped) {
+                            out.push(chunk);
+                        }
+                    }
+                    catch (error) {
+                        node_assert_1.default.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
+                        // stream should be closed
+                        node_assert_1.default.ok(tapped.closed);
+                    }
+                });
             });
         });
         (0, node_test_1.describe)('ReadableStream', () => {
-            (0, node_test_1.it)('should duplicate the ReadableStream, verify the first and return the second if verification passes', async () => {
-                // create a simple readable
-                const chunks = [
-                    Buffer.from('foo'),
-                    Buffer.from('bar'),
-                    Buffer.from('baz'),
-                ];
-                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                // a stream that will emit chunks
-                const originalStream = ReadableStream.from(chunks);
-                let seen = Buffer.alloc(0);
-                const verifyData = async ({ data, 
-                // @ts-expect-error
-                txId, }) => {
-                    return new Promise(async (resolve, reject) => {
-                        const reader = data.getReader();
-                        while (true) {
-                            try {
-                                const { done, value } = await reader.read();
-                                if (done) {
-                                    resolve();
-                                    break;
+            (0, node_test_1.describe)('strict mode enabled', () => {
+                (0, node_test_1.it)('should duplicate the ReadableStream, verify the first and return the second if verification passes', async () => {
+                    // create a simple readable
+                    const chunks = [
+                        Buffer.from('foo'),
+                        Buffer.from('bar'),
+                        Buffer.from('baz'),
+                    ];
+                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                    // a stream that will emit chunks
+                    const originalStream = ReadableStream.from(chunks);
+                    let seen = Buffer.alloc(0);
+                    const verifyData = async ({ data, 
+                    // @ts-expect-error
+                    txId, }) => {
+                        return new Promise(async (resolve, reject) => {
+                            const reader = data.getReader();
+                            while (true) {
+                                try {
+                                    const { done, value } = await reader.read();
+                                    if (done) {
+                                        resolve();
+                                        break;
+                                    }
+                                    seen = Buffer.concat([seen, value]);
+                                }
+                                catch (error) {
+                                    reject(error);
                                 }
-                                seen = Buffer.concat([seen, value]);
-                            }
-                            catch (error) {
-                                reject(error);
                             }
-                        }
+                        });
+                    };
+                    const txId = 'test-tx-1';
+                    const emitter = new node_events_1.EventEmitter();
+                    const events = [];
+                    emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
+                    emitter.on('verification-succeeded', (e) => events.push({ type: 'verification-succeeded', ...e }));
+                    // tap with verification
+                    const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
+                        originalStream,
+                        contentLength,
+                        verifyData,
+                        txId,
+                        emitter,
+                        strict: true,
                     });
-                };
-                const txId = 'test-tx-1';
-                const emitter = new node_events_1.EventEmitter();
-                const events = [];
-                emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
-                emitter.on('verification-passed', (e) => events.push({ type: 'verification-passed', ...e }));
-                // tap with verification
-                const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
-                    originalStream,
-                    contentLength,
-                    verifyData,
-                    txId,
-                    emitter,
-                });
-                // read the stream
-                const out = [];
-                for await (const chunk of tapped) {
-                    out.push(chunk);
-                }
-                // assert the stream is the same
-                node_assert_1.default.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
-                node_assert_1.default.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
-                node_assert_1.default.ok(events.find((e) => e.type === 'verification-passed' && e.txId === txId), 'Should emit at least one verification-passed');
-            });
-            (0, node_test_1.it)('should throw an error on the client stream if verification fails', async () => {
-                const chunks = [
-                    Buffer.from('foo'),
-                    Buffer.from('bar'),
-                    Buffer.from('baz'),
-                ];
-                const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
-                // a stream that will emit chunks
-                const originalStream = ReadableStream.from(chunks);
-                const verifyData = async ({ 
-                // @ts-expect-error
-                data, txId, }) => {
-                    throw new Error('Verification failed for txId: ' + txId);
-                };
-                const txId = 'test-tx-1';
-                const emitter = new node_events_1.EventEmitter();
-                const events = [];
-                emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
-                emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
-                // tap with verification
-                const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
-                    originalStream,
-                    contentLength,
-                    verifyData,
-                    txId,
-                    emitter,
-                });
-                // read the stream
-                try {
+                    // read the stream
                     const out = [];
                     for await (const chunk of tapped) {
                         out.push(chunk);
                     }
-                }
-                catch (error) {
-                    node_assert_1.default.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
-                }
+                    // assert the stream is the same
+                    node_assert_1.default.strictEqual(Buffer.concat(out).toString(), Buffer.concat(chunks).toString(), 'The tapped stream should emit exactly the original data');
+                    node_assert_1.default.ok(events.find((e) => e.type === 'verification-progress'), 'Should emit at least one verification-progress');
+                    node_assert_1.default.ok(events.find((e) => e.type === 'verification-succeeded' && e.txId === txId), 'Should emit at least one verification-succeeded');
+                });
+                (0, node_test_1.it)('should throw an error on the client stream if verification fails', async () => {
+                    const chunks = [
+                        Buffer.from('foo'),
+                        Buffer.from('bar'),
+                        Buffer.from('baz'),
+                    ];
+                    const contentLength = chunks.reduce((sum, c) => sum + c.length, 0);
+                    // a stream that will emit chunks
+                    const originalStream = ReadableStream.from(chunks);
+                    const verifyData = async ({ 
+                    // @ts-expect-error
+                    data, txId, }) => {
+                        throw new Error('Verification failed for txId: ' + txId);
+                    };
+                    const txId = 'test-tx-1';
+                    const emitter = new node_events_1.EventEmitter();
+                    const events = [];
+                    emitter.on('verification-progress', (e) => events.push({ type: 'verification-progress', ...e }));
+                    emitter.on('verification-failed', (e) => events.push({ type: 'verification-failed', ...e }));
+                    // tap with verification (using strict mode)
+                    const tapped = (0, wayfinder_js_1.tapAndVerifyStream)({
+                        originalStream,
+                        contentLength,
+                        verifyData,
+                        txId,
+                        emitter,
+                        strict: true,
+                    });
+                    // read the stream
+                    try {
+                        const out = [];
+                        for await (const chunk of tapped) {
+                            out.push(chunk);
+                        }
+                    }
+                    catch (error) {
+                        node_assert_1.default.ok(events.find((e) => e.type === 'verification-failed' && e.txId === txId), 'Should emit at least one verification-failed');
+                    }
+                });
             });
         });
     });

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.11.0-alpha.9';
+exports.version = '3.11.0-beta.1';

package/lib/esm/cli/utils.js

@@ -117,7 +117,10 @@ function aoProcessFromOptions(options) {
 export function readARIOFromOptions(options) {
     setLoggerIfDebug(options);
     return ARIO.init({
-        process: aoProcessFromOptions(options),
+        process: aoProcessFromOptions({
+            cuUrl: 'https://cu.ardrive.io', // default to ardrive cu for ARIO process
+            ...options,
+        }),
         paymentUrl: options.paymentUrl,
     });
 }

package/lib/esm/common/contracts/ao-process.js

@@ -95,7 +95,8 @@ export class AOProcess {
                 tags,
                 processId: this.processId,
             });
-            throw new Error(`Process ${this.processId} does not support provided action.`);
+            throw new Error(result.message ||
+                `Process ${this.processId} did not return a valid response. Response: ${JSON.stringify(result)}`);
         }
         const messageData = result.Messages?.[0]?.Data;
         // return undefined if no data is returned