@ar.io/sdk 3.10.2 → 3.11.0-alpha.10

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

@@ -0,0 +1,500 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const axios_1 = __importDefault(require("axios"));
+const got_1 = __importDefault(require("got"));
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_events_1 = require("node:events");
+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 wayfinder_js_1 = require("./wayfinder.js");
+// TODO: replace with locally running gateway
+const gatewayUrl = 'permagate.io';
+const stubbedGatewaysProvider = {
+    getGateways: async () => [new URL(`http://${gatewayUrl}`)],
+};
+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)('fetch', () => {
+            let wayfinder;
+            (0, node_test_1.before)(() => {
+                wayfinder = new wayfinder_js_1.Wayfinder({
+                    httpClient: fetch,
+                    router: new random_js_1.RandomGatewayRouter({
+                        gatewaysProvider: stubbedGatewaysProvider,
+                    }),
+                });
+            });
+            (0, node_test_1.it)('should fetch the data using the selected gateway', async () => {
+                const nativeFetch = await fetch(`https://ao.${gatewayUrl}`);
+                const response = await wayfinder.request('ar://ao');
+                node_assert_1.default.strictEqual(response.status, 200);
+                node_assert_1.default.strictEqual(response.status, nativeFetch.status);
+                // assert the arns headers are the same
+                const arnsHeaders = Array.from(response.headers.entries()).filter(([key]) => key.startsWith('x-arns-'));
+                const nativeFetchHeaders = Array.from(nativeFetch.headers.entries()).filter(([key]) => key.startsWith('x-arns-'));
+                node_assert_1.default.deepStrictEqual(arnsHeaders, nativeFetchHeaders);
+            });
+            (0, node_test_1.it)('should fetch a tx id using the selected gateway', async () => {
+                const nativeFetch = await fetch(`https://${gatewayUrl}/KKmRbIfrc7wiLcG0zvY1etlO0NBx1926dSCksxCIN3A`, 
+                // follow redirects
+                { redirect: 'follow' });
+                const response = await wayfinder.request('ar://KKmRbIfrc7wiLcG0zvY1etlO0NBx1926dSCksxCIN3A', { redirect: 'follow' });
+                node_assert_1.default.strictEqual(response.status, 200);
+                node_assert_1.default.strictEqual(response.status, nativeFetch.status);
+            });
+            (0, node_test_1.it)('should route a non-ar:// url as a normal fetch', async () => {
+                const [nativeFetch, response] = await Promise.all([
+                    fetch(`https://${gatewayUrl}/`, {
+                        method: 'HEAD',
+                    }),
+                    wayfinder.request(`https://${gatewayUrl}/`, {
+                        method: 'HEAD',
+                    }),
+                ]);
+                node_assert_1.default.strictEqual(response.status, 200);
+                node_assert_1.default.strictEqual(response.status, nativeFetch.status);
+                // 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 () => {
+                    const [nativeFetch, response] = await Promise.all([
+                        fetch(`https://${gatewayUrl}${api}`),
+                        wayfinder.request(`ar://${api}`),
+                    ]);
+                    node_assert_1.default.strictEqual(response.status, 200);
+                    node_assert_1.default.strictEqual(response.status, nativeFetch.status);
+                    // TODO: ensure the headers are the same excluding unique headers
+                });
+            }
+            for (const api of ['/ar-io/info']) {
+                (0, node_test_1.it)(`supports native ario node gateway apis ${api}`, async () => {
+                    const [nativeFetch, response] = await Promise.all([
+                        fetch(`https://${gatewayUrl}${api}`),
+                        wayfinder.request(`ar:///${api}`),
+                    ]);
+                    node_assert_1.default.strictEqual(response.status, 200);
+                    node_assert_1.default.strictEqual(response.status, nativeFetch.status);
+                    // TODO: ensure the headers are the same excluding unique headers
+                });
+            }
+            (0, node_test_1.it)('supports a post request to graphql', async () => {
+                const response = await wayfinder.request('ar:///graphql', {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                    },
+                    body: JSON.stringify({
+                        query: `
+                query {
+                  transactions(
+                    ids: ["xf958qhCNGfDme1FtoiD6DtMfDENDbtxZpjOM_1tsMM"]
+                  ) {
+                    edges {
+                      cursor
+                      node {
+                        id
+                        tags {
+                          name
+                          value
+                        }
+                        block {
+                          height
+                          timestamp
+                        }
+                      }
+                    }
+                    pageInfo {
+                      hasNextPage
+                    }
+                  }
+                }
+            `,
+                    }),
+                });
+                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 () => {
+                const [nativeFetch, response] = await Promise.all([
+                    fetch(`https://${gatewayUrl}/ar-io/not-found`),
+                    wayfinder.request('ar:///not-found'),
+                ]);
+                node_assert_1.default.strictEqual(response.status, nativeFetch.status);
+                node_assert_1.default.strictEqual(response.statusText, nativeFetch.statusText);
+            });
+        });
+        (0, node_test_1.describe)('axios', () => {
+            let wayfinder;
+            (0, node_test_1.before)(() => {
+                wayfinder = new wayfinder_js_1.Wayfinder({
+                    httpClient: axios_1.default,
+                    router: new random_js_1.RandomGatewayRouter({
+                        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'),
+                ]);
+                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)
+                    .sort()
+                    .filter(([key]) => key.startsWith('x-arns-'));
+                const nativeAxiosHeaders = Object.entries(nativeAxios.headers).filter(([key]) => key.startsWith('x-arns-'));
+                node_assert_1.default.deepStrictEqual(arnsHeaders.sort(), nativeAxiosHeaders.sort());
+            });
+            (0, node_test_1.it)('should fetch the data using the axios.get method against the target gateway', async () => {
+                const [nativeAxios, response] = await Promise.all([
+                    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)
+                    .sort()
+                    .filter(([key]) => key.startsWith('x-arns-'));
+                const nativeAxiosHeaders = Object.entries(nativeAxios.headers).filter(([key]) => key.startsWith('x-arns-'));
+                node_assert_1.default.deepStrictEqual(arnsHeaders.sort(), nativeAxiosHeaders.sort());
+            });
+            (0, node_test_1.it)('should route a non-ar:// url as a normal axios request', async () => {
+                const [nativeAxios, response] = await Promise.all([
+                    (0, axios_1.default)(`https://${gatewayUrl}/`),
+                    wayfinder.request(`https://${gatewayUrl}/`),
+                ]);
+                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
+            });
+            for (const api of ['/info', '/block/current']) {
+                (0, node_test_1.it)(`supports native arweave node apis ${api}`, async () => {
+                    const [nativeAxios, response] = await Promise.all([
+                        (0, axios_1.default)(`https://${gatewayUrl}${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
+                });
+            }
+            for (const api of ['/ar-io/info', '/ar-io/__gateway_metrics']) {
+                (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}`),
+                    ]);
+                    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 () => {
+                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,
+                    }),
+                });
+                const [nativeAxios, response] = await Promise.all([
+                    axiosInstance(`https://${gatewayUrl}/ar-io/not-found`),
+                    wayfinder.request('ar:///not-found'),
+                ]);
+                node_assert_1.default.strictEqual(response.status, nativeAxios.status);
+            });
+        });
+        (0, node_test_1.describe)('got', () => {
+            let wayfinder;
+            (0, node_test_1.before)(() => {
+                wayfinder = new wayfinder_js_1.Wayfinder({
+                    httpClient: got_1.default,
+                    router: new random_js_1.RandomGatewayRouter({
+                        gatewaysProvider: stubbedGatewaysProvider,
+                    }),
+                });
+            });
+            (0, node_test_1.it)('should fetch the data using the got default function against the target gateway', async () => {
+                const [nativeGot, response] = await Promise.all([
+                    (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 }));
+                node_assert_1.default.deepStrictEqual(wayfinderBuffer, nativeBuffer);
+            });
+        });
+    });
+    (0, node_test_1.describe)('events', () => {
+        (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({
+                    gateway: `http://${gatewayUrl}`,
+                }),
+                verifier: {
+                    // @ts-expect-error
+                    verifyData: async (params) => {
+                        return;
+                    },
+                },
+            });
+            const events = [];
+            wayfinder.emitter.on('verification-failed', (event) => {
+                events.push({ type: 'verification-failed', ...event });
+            });
+            wayfinder.emitter.on('verification-progress', (event) => {
+                events.push({ type: 'verification-progress', ...event });
+            });
+            wayfinder.emitter.on('verification-passed', (event) => {
+                events.push({ type: 'verification-passed', ...event });
+            });
+            // request data and assert the event is emitted
+            const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
+                redirect: 'follow',
+            });
+            // 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');
+        });
+        (0, node_test_1.it)('should execute callbacks provided to the wayfinder constructor', async () => {
+            let verificationFailed = false;
+            let verificationProgress = false;
+            let verificationPassed = false;
+            const wayfinder = new wayfinder_js_1.Wayfinder({
+                httpClient: fetch,
+                router: new static_js_1.StaticGatewayRouter({
+                    gateway: `http://${gatewayUrl}`,
+                }),
+                events: {
+                    onVerificationFailed: () => {
+                        verificationFailed = true;
+                    },
+                    onVerificationProgress: () => {
+                        verificationProgress = true;
+                    },
+                    onVerificationPassed: () => {
+                        verificationPassed = true;
+                    },
+                },
+            });
+            const response = await wayfinder.request('ar://c7wkwt6TKgcWJUfgvpJ5q5qi4DIZyJ1_TqhjXgURh0U', {
+                redirect: 'follow',
+            });
+            // 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(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_test_1.describe.skip('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();
+                        });
+                        data.on('error', reject);
+                    });
+                };
+                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 {
+                    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;
+                                }
+                                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-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 {
+                    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/types/ant.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AntInfoSchema = exports.AntHandlersSchema = exports.AntHandlerNames = exports.AntWriteHandlers = exports.AntReadHandlers = exports.AntStateSchema = exports.AntBalancesSchema = exports.AntControllersSchema = exports.AntRecordsSchema = exports.AntRecordSchema = exports.AntKeywordsSchema = exports.AntDescriptionSchema = exports.IntegerStringSchema = exports.AOAddressSchema = exports.ArweaveTxIdSchema = void 0;
+exports.AntInfoSchema = exports.AntHandlersSchema = exports.AntHandlerNames = exports.AntWriteHandlers = exports.AntReadHandlers = exports.SpawnANTStateSchema = exports.AntStateSchema = exports.AntBalancesSchema = exports.AntControllersSchema = exports.AntRecordsSchema = exports.AntRecordSchema = exports.AntKeywordsSchema = exports.AntDescriptionSchema = exports.IntegerStringSchema = exports.AOAddressSchema = exports.ArweaveTxIdSchema = void 0;
 exports.isAoANTState = isAoANTState;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
@@ -81,6 +81,17 @@ exports.AntStateSchema = zod_1.z.object({
         .boolean()
         .describe('Flag indicating whether the ANT has been initialized.'),
 });
+exports.SpawnANTStateSchema = zod_1.z.object({
+    name: zod_1.z.string().describe('The name of the ANT.'),
+    ticker: zod_1.z.string().describe('The ticker symbol for the ANT.'),
+    description: zod_1.z.string().describe('The description for the ANT.'),
+    keywords: exports.AntKeywordsSchema.describe('The keywords for the ANT.'),
+    owner: exports.AOAddressSchema.describe('The Owners address.'),
+    controllers: exports.AntControllersSchema.describe('Controllers of the ANT who have administrative privileges.'),
+    records: exports.AntRecordsSchema.describe('Records associated with the ANT.'),
+    balances: exports.AntBalancesSchema.describe('Balance details for each address holding the ANT.'),
+    logo: exports.ArweaveTxIdSchema.describe('Transaction ID of the ANT logo.'),
+});
 exports.AntReadHandlers = [
     'balance',
     'balances',

package/lib/cjs/types/index.js

@@ -35,3 +35,4 @@ __exportStar(require("./common.js"), exports);
 __exportStar(require("./faucet.js"), exports);
 __exportStar(require("./io.js"), exports);
 __exportStar(require("./token.js"), exports);
+__exportStar(require("./wayfinder.js"), exports);

package/lib/cjs/types/io.js

@@ -31,7 +31,7 @@ const isValidIntent = (intent) => {
     return exports.validIntents.indexOf(intent) !== -1;
 };
 exports.isValidIntent = isValidIntent;
-exports.fundFromOptions = ['balance', 'stakes', 'any'];
+exports.fundFromOptions = ['balance', 'stakes', 'any', 'turbo'];
 const isValidFundFrom = (fundFrom) => {
     return exports.fundFromOptions.indexOf(fundFrom) !== -1;
 };

package/lib/cjs/types/wayfinder.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// TODO: add an offset provider that returns offsets for data items so we can use them to verify the signatures of a data item within a bundle

package/lib/cjs/utils/ao.js

@@ -30,8 +30,13 @@ const zod_1 = require("zod");
 const arweave_js_1 = require("../common/arweave.js");
 const index_js_1 = require("../common/index.js");
 const constants_js_1 = require("../constants.js");
+const ant_js_1 = require("../types/ant.js");
+const schema_js_1 = require("./schema.js");
 async function spawnANT({ signer, module = constants_js_1.AOS_MODULE_ID, ao = (0, aoconnect_1.connect)(), scheduler = constants_js_1.DEFAULT_SCHEDULER_ID, state, antRegistryId = constants_js_1.ANT_REGISTRY_ID, logger = index_js_1.Logger.default, authority = constants_js_1.AO_AUTHORITY, }) {
     // TODO: use On-Boot data handler for bootstrapping state instead of initialize-state
+    if (state) {
+        (0, schema_js_1.parseSchemaResult)(ant_js_1.SpawnANTStateSchema, state);
+    }
     const processId = await ao.spawn({
         module,
         scheduler,
@@ -49,6 +54,43 @@ async function spawnANT({ signer, module = constants_js_1.AOS_MODULE_ID, ao = (0
             },
         ],
     });
+    let bootRes;
+    let attempts = 0;
+    while (attempts < 5 && bootRes === undefined) {
+        try {
+            bootRes = await ao.result({
+                process: processId,
+                message: processId,
+            });
+            break;
+        }
+        catch (error) {
+            logger.debug('Retrying ANT boot result fetch', {
+                processId,
+                module,
+                scheduler,
+                attempts,
+                error,
+            });
+            attempts++;
+            await new Promise((resolve) => setTimeout(resolve, 1000 * attempts ** 2));
+        }
+    }
+    if (bootRes === undefined ||
+        bootRes.Messages.find((m) => m.Tags.find((t) => t.value === 'Invalid-Boot-Notice'))) {
+        if (bootRes === undefined) {
+            throw new Error('Failed to get boot result');
+        }
+        const bootError = errorMessageFromOutput(bootRes);
+        logger.error('ANT failed to boot correctly', {
+            processId,
+            module,
+            scheduler,
+            bootRes,
+            bootError,
+        });
+        throw new Error(`ANT failed to boot correctly: ${bootError}`);
+    }
     logger.debug(`Spawned ANT`, {
         processId,
         module,

package/lib/cjs/utils/hash.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashBufferToB64Url = exports.hashReadableStreamToB64Url = exports.hashReadableToB64Url = 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 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));
+    });
+};
+exports.hashReadableToB64Url = hashReadableToB64Url;
+const hashReadableStreamToB64Url = (stream, algorithm = 'sha256') => {
+    return new Promise((resolve, reject) => {
+        const hash = (0, crypto_1.createHash)(algorithm);
+        const reader = stream.getReader();
+        const read = async () => {
+            try {
+                const { done, value } = await reader.read();
+                if (done) {
+                    resolve((0, base64_js_1.toB64Url)(hash.digest()));
+                }
+                else {
+                    hash.update(value);
+                    read();
+                }
+            }
+            catch (err) {
+                reject(err);
+            }
+        };
+        read().catch(reject);
+    });
+};
+exports.hashReadableStreamToB64Url = hashReadableStreamToB64Url;
+const hashBufferToB64Url = (buffer, algorithm = 'sha256') => {
+    return (0, base64_js_1.toB64Url)((0, crypto_1.createHash)(algorithm).update(buffer).digest());
+};
+exports.hashBufferToB64Url = hashBufferToB64Url;