@ar.io/sdk 3.12.2 → 3.13.0-beta.1

package/lib/cjs/cli/commands/arnsPurchaseCommands.js

@@ -12,6 +12,7 @@ async function buyRecordCLICommand(o) {
     const type = (0, utils_js_1.recordTypeFromOptions)(o);
     const years = (0, utils_js_1.positiveIntegerFromOptions)(o, 'years');
     const fundFrom = (0, utils_js_1.fundFromFromOptions)(o);
+    const referrer = (0, utils_js_1.referrerFromOptions)(o);
     const processId = o.processId;
     if (processId === undefined) {
         // TODO: Spawn ANT process, register it to ANT registry, get process ID
@@ -45,12 +46,14 @@ async function buyRecordCLICommand(o) {
         years,
         fundFrom: (0, utils_js_1.fundFromFromOptions)(o),
         paidBy: (0, utils_js_1.stringArrayFromOptions)(o, 'paidBy'),
+        referrer,
     }, (0, utils_js_1.customTagsFromOptions)(o));
 }
 async function upgradeRecordCLICommand(o) {
     const name = (0, utils_js_1.requiredStringFromOptions)(o, 'name');
     const { ario, signerAddress } = (0, utils_js_1.writeARIOFromOptions)(o);
     const fundFrom = (0, utils_js_1.fundFromFromOptions)(o);
+    const referrer = (0, utils_js_1.referrerFromOptions)(o);
     if (!o.skipConfirmation) {
         const existingRecord = await ario.getArNSRecord({
             name,
@@ -77,12 +80,14 @@ async function upgradeRecordCLICommand(o) {
         name,
         fundFrom,
         paidBy: (0, utils_js_1.stringArrayFromOptions)(o, 'paidBy'),
+        referrer,
     });
 }
 async function extendLeaseCLICommand(o) {
     const name = (0, utils_js_1.requiredStringFromOptions)(o, 'name');
     const years = (0, utils_js_1.requiredPositiveIntegerFromOptions)(o, 'years');
     const fundFrom = (0, utils_js_1.fundFromFromOptions)(o);
+    const referrer = (0, utils_js_1.referrerFromOptions)(o);
     const { ario, signerAddress } = (0, utils_js_1.writeARIOFromOptions)(o);
     if (!o.skipConfirmation) {
         const existingRecord = await ario.getArNSRecord({
@@ -111,12 +116,14 @@ async function extendLeaseCLICommand(o) {
         name,
         years,
         paidBy: (0, utils_js_1.stringArrayFromOptions)(o, 'paidBy'),
+        referrer,
     }, (0, utils_js_1.customTagsFromOptions)(o));
 }
 async function increaseUndernameLimitCLICommand(o) {
     const name = (0, utils_js_1.requiredStringFromOptions)(o, 'name');
     const increaseCount = (0, utils_js_1.requiredPositiveIntegerFromOptions)(o, 'increaseCount');
     const fundFrom = (0, utils_js_1.fundFromFromOptions)(o);
+    const referrer = (0, utils_js_1.referrerFromOptions)(o);
     const { ario, signerAddress } = (0, utils_js_1.writeARIOFromOptions)(o);
     if (!o.skipConfirmation) {
         const existingRecord = await ario.getArNSRecord({
@@ -142,11 +149,13 @@ async function increaseUndernameLimitCLICommand(o) {
         name,
         increaseCount,
         paidBy: (0, utils_js_1.stringArrayFromOptions)(o, 'paidBy'),
+        referrer,
     }, (0, utils_js_1.customTagsFromOptions)(o));
 }
 async function requestPrimaryNameCLICommand(o) {
     const { ario, signerAddress } = (0, utils_js_1.writeARIOFromOptions)(o);
     const fundFrom = (0, utils_js_1.fundFromFromOptions)(o);
+    const referrer = (0, utils_js_1.referrerFromOptions)(o);
     const name = (0, utils_js_1.requiredStringFromOptions)(o, 'name');
     if (!o.skipConfirmation) {
         // TODO: Assert name requested is not already owned?
@@ -167,5 +176,6 @@ async function requestPrimaryNameCLICommand(o) {
         name,
         fundFrom,
         paidBy: (0, utils_js_1.stringArrayFromOptions)(o, 'paidBy'),
+        referrer,
     }, (0, utils_js_1.customTagsFromOptions)(o));
 }

package/lib/cjs/cli/options.js

@@ -286,6 +286,10 @@ exports.optionMap = {
         description: 'Addresses to pay for the interaction',
         type: 'array',
     },
+    referrer: {
+        alias: '--referrer <referrer>',
+        description: 'The referrer for ArNS purchase tracking',
+    },
 };
 exports.walletOptions = [
     exports.optionMap.walletFile,
@@ -309,6 +313,7 @@ exports.arnsPurchaseOptions = [
     exports.optionMap.fundFrom,
     exports.optionMap.paidBy,
     exports.optionMap.paymentUrl,
+    exports.optionMap.referrer,
 ];
 exports.epochOptions = [exports.optionMap.epochIndex, exports.optionMap.timestamp];
 exports.addressAndVaultIdOptions = [exports.optionMap.address, exports.optionMap.vaultId];

package/lib/cjs/cli/utils.js

@@ -46,6 +46,7 @@ exports.requiredPositiveIntegerFromOptions = requiredPositiveIntegerFromOptions;
 exports.getANTStateFromOptions = getANTStateFromOptions;
 exports.getTokenCostParamsFromOptions = getTokenCostParamsFromOptions;
 exports.fundFromFromOptions = fundFromFromOptions;
+exports.referrerFromOptions = referrerFromOptions;
 exports.assertLockLengthInRange = assertLockLengthInRange;
 /**
  * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
@@ -507,6 +508,9 @@ function fundFromFromOptions(o) {
     }
     return o.fundFrom ?? 'balance';
 }
+function referrerFromOptions(o) {
+    return o.referrer;
+}
 function assertLockLengthInRange(lockLengthMs, assertMin = true) {
     const minLockLengthMs = 1209600000; // 14 days
     const maxLockLengthMs = 378432000000; // ~12 years

package/lib/cjs/common/index.js

@@ -38,3 +38,5 @@ __exportStar(require("./faucet.js"), exports);
 // ao
 __exportStar(require("./io.js"), exports);
 __exportStar(require("./contracts/ao-process.js"), exports);
+// wayfinder
+__exportStar(require("./wayfinder/index.js"), exports);

package/lib/cjs/common/io.js

@@ -986,6 +986,7 @@ class ARIOWriteable extends ARIOReadable {
             { name: 'Process-Id', value: params.processId },
             { name: 'Purchase-Type', value: params.type || 'lease' },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,
@@ -1016,6 +1017,7 @@ class ARIOWriteable extends ARIOReadable {
             { name: 'Action', value: 'Upgrade-Name' },
             { name: 'Name', value: params.name },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,
@@ -1049,6 +1051,7 @@ class ARIOWriteable extends ARIOReadable {
             { name: 'Name', value: params.name },
             { name: 'Years', value: params.years.toString() },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,
@@ -1073,6 +1076,7 @@ class ARIOWriteable extends ARIOReadable {
             { name: 'Name', value: params.name },
             { name: 'Quantity', value: params.increaseCount.toString() },
             { name: 'Fund-From', value: params.fundFrom },
+            { name: 'Referrer', value: params.referrer },
         ];
         return this.process.send({
             signer: this.signer,

package/lib/cjs/common/turbo.js

@@ -155,7 +155,7 @@ class TurboArNSPaymentProviderAuthenticated extends TurboArNSPaymentProviderUnau
         }
         this.signer = signer;
     }
-    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, paidBy = [], }) {
+    async initiateArNSPurchase({ intent, name, quantity, type, processId, years, paidBy = [], referrer, }) {
         // Signer check is implicitly handled by requiring it in the constructor
         const url = (0, url_js_1.urlWithSearchParams)({
             baseUrl: `${this.paymentUrl}/v1/arns/purchase/${intent}/${name}`,
@@ -165,6 +165,7 @@ class TurboArNSPaymentProviderAuthenticated extends TurboArNSPaymentProviderUnau
                 type,
                 years,
                 paidBy,
+                referrer,
             },
         });
         const headers = await signedRequestHeadersFromSigner({

package/lib/cjs/common/wayfinder/gateways/network.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkGatewaysProvider = void 0;
+const io_js_1 = require("../../io.js");
+class NetworkGatewaysProvider {
+    ario;
+    sortBy;
+    sortOrder;
+    limit;
+    filter;
+    constructor({ ario = io_js_1.ARIO.mainnet(), sortBy = 'operatorStake', sortOrder = 'desc', limit = 1000, filter = (g) => g.status === 'joined', }) {
+        this.ario = ario;
+        this.sortBy = sortBy;
+        this.sortOrder = sortOrder;
+        this.limit = limit;
+        this.filter = filter;
+    }
+    async getGateways() {
+        let cursor;
+        let attempts = 0;
+        const gateways = [];
+        do {
+            try {
+                const { items: newGateways = [], nextCursor } = await this.ario.getGateways({
+                    limit: 1000,
+                    cursor,
+                    sortBy: this.sortBy,
+                    sortOrder: this.sortOrder,
+                });
+                gateways.push(...newGateways);
+                cursor = nextCursor;
+                attempts = 0; // reset attempts if we get a new cursor
+            }
+            catch (error) {
+                console.error('Error fetching gateways', {
+                    cursor,
+                    attempts,
+                    error,
+                });
+                attempts++;
+            }
+        } while (cursor !== undefined && attempts < 3);
+        // filter out any gateways that are not joined
+        const filteredGateways = gateways.filter(this.filter).slice(0, this.limit);
+        return filteredGateways.map((g) => new URL(`${g.settings.protocol}://${g.settings.fqdn}:${g.settings.port}`));
+    }
+}
+exports.NetworkGatewaysProvider = NetworkGatewaysProvider;

package/lib/cjs/common/wayfinder/gateways/simple-cache.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCacheGatewaysProvider = void 0;
+const index_js_1 = require("../../../web/index.js");
+class SimpleCacheGatewaysProvider {
+    gatewaysProvider;
+    ttlSeconds;
+    lastUpdated;
+    gatewaysCache;
+    logger;
+    constructor({ gatewaysProvider, ttlSeconds = 60 * 60, // 1 hour
+    logger = index_js_1.Logger.default, }) {
+        this.gatewaysCache = [];
+        this.gatewaysProvider = gatewaysProvider;
+        this.ttlSeconds = ttlSeconds;
+        this.logger = logger;
+    }
+    async getGateways() {
+        const now = Date.now();
+        if (this.gatewaysCache.length === 0 ||
+            now - this.lastUpdated > this.ttlSeconds * 1000) {
+            try {
+                // preserve the cache if the fetch fails
+                const allGateways = await this.gatewaysProvider.getGateways();
+                this.gatewaysCache = allGateways;
+                this.lastUpdated = now;
+            }
+            catch (error) {
+                this.logger.error('Error fetching gateways', error);
+            }
+        }
+        return this.gatewaysCache;
+    }
+}
+exports.SimpleCacheGatewaysProvider = SimpleCacheGatewaysProvider;

package/lib/cjs/common/wayfinder/gateways/static.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticGatewaysProvider = void 0;
+class StaticGatewaysProvider {
+    gateways;
+    constructor({ gateways }) {
+        this.gateways = gateways.map((g) => new URL(g));
+    }
+    async getGateways() {
+        return this.gateways;
+    }
+}
+exports.StaticGatewaysProvider = StaticGatewaysProvider;

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

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.
+ */
+__exportStar(require("./wayfinder.js"), exports);
+// routing strategies
+__exportStar(require("./routing/strategies/random.js"), exports);
+__exportStar(require("./routing/strategies/static.js"), exports);
+__exportStar(require("./routing/strategies/ping.js"), exports);
+__exportStar(require("./routing/strategies/round-robin.js"), exports);
+__exportStar(require("./routing/strategies/preferred-with-fallback.js"), exports);
+// gateways providers
+__exportStar(require("./gateways/network.js"), exports);
+__exportStar(require("./gateways/simple-cache.js"), exports);
+__exportStar(require("./gateways/static.js"), exports);
+// trusted gateways
+__exportStar(require("./verification/trusted.js"), exports);
+// hash providers
+__exportStar(require("./verification/strategies/data-root-verifier.js"), exports);
+__exportStar(require("./verification/strategies/hash-verifier.js"), exports);
+// TODO: signature verification

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

@@ -0,0 +1,72 @@
+"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/preferred-with-fallback.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PreferredWithFallbackRoutingStrategy = void 0;
+const logger_js_1 = require("../../../logger.js");
+const ping_js_1 = require("./ping.js");
+class PreferredWithFallbackRoutingStrategy {
+    name = 'preferred-with-fallback';
+    preferredGateway;
+    fallbackStrategy;
+    logger;
+    constructor({ preferredGateway, fallbackStrategy = new ping_js_1.FastestPingRoutingStrategy(), logger = logger_js_1.Logger.default, }) {
+        try {
+            this.preferredGateway = new URL(preferredGateway);
+        }
+        catch (error) {
+            throw new Error(`Invalid URL provided for preferred gateway: ${preferredGateway}`);
+        }
+        this.fallbackStrategy = fallbackStrategy;
+        this.logger = logger;
+    }
+    async selectGateway({ gateways = [] }) {
+        this.logger.debug('Attempting to connect to preferred gateway', {
+            preferredGateway: this.preferredGateway.toString(),
+        });
+        try {
+            // Check if the preferred gateway is responsive
+            const response = await fetch(this.preferredGateway.toString(), {
+                method: 'HEAD',
+                signal: AbortSignal.timeout(1000),
+            });
+            if (response.ok) {
+                this.logger.debug('Successfully connected to preferred gateway', {
+                    preferredGateway: this.preferredGateway.toString(),
+                });
+                return this.preferredGateway;
+            }
+            throw new Error(`Preferred gateway responded with status: ${response.status}`);
+        }
+        catch (error) {
+            this.logger.warn('Failed to connect to preferred gateway, falling back to alternative strategy', {
+                preferredGateway: this.preferredGateway.toString(),
+                error: error instanceof Error ? error.message : String(error),
+                fallbackStrategy: this.fallbackStrategy.constructor.name,
+            });
+            // Fall back to the provided routing strategy
+            return this.fallbackStrategy.selectGateway({ gateways });
+        }
+    }
+}
+exports.PreferredWithFallbackRoutingStrategy = PreferredWithFallbackRoutingStrategy;

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

@@ -0,0 +1,13 @@
+"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/round-robin.js

@@ -0,0 +1,42 @@
+"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/static.js

@@ -0,0 +1,29 @@
+"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/verification/strategies/data-root-verifier.js

@@ -0,0 +1,110 @@
+"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.convertDataStreamToDataRoot = 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 arweave_1 = __importDefault(require("arweave"));
+const merkle_js_1 = require("arweave/node/lib/merkle.js");
+const base64_js_1 = require("../../../../utils/base64.js");
+const hash_js_1 = require("../../../../utils/hash.js");
+const convertDataStreamToDataRoot = async ({ dataStream, }) => {
+    const chunks = [];
+    let leftover = new Uint8Array(0);
+    let cursor = 0;
+    const asyncIterable = (0, hash_js_1.isAsyncIterable)(dataStream)
+        ? dataStream
+        : (0, hash_js_1.readableStreamToAsyncIterable)(dataStream);
+    for await (const data of asyncIterable) {
+        const inputChunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const combined = new Uint8Array(leftover.length + inputChunk.length);
+        combined.set(leftover, 0);
+        combined.set(inputChunk, leftover.length);
+        let startIndex = 0;
+        while (combined.length - startIndex >= merkle_js_1.MAX_CHUNK_SIZE) {
+            let chunkSize = merkle_js_1.MAX_CHUNK_SIZE;
+            const remainderAfterThis = combined.length - startIndex - merkle_js_1.MAX_CHUNK_SIZE;
+            if (remainderAfterThis > 0 && remainderAfterThis < merkle_js_1.MIN_CHUNK_SIZE) {
+                chunkSize = Math.ceil((combined.length - startIndex) / 2);
+            }
+            const chunkData = combined.slice(startIndex, startIndex + chunkSize);
+            const dataHash = await arweave_1.default.crypto.hash(chunkData);
+            chunks.push({
+                dataHash,
+                minByteRange: cursor,
+                maxByteRange: cursor + chunkSize,
+            });
+            cursor += chunkSize;
+            startIndex += chunkSize;
+        }
+        leftover = combined.slice(startIndex);
+    }
+    if (leftover.length > 0) {
+        // TODO: ensure a web friendly crypto hash function is used in web
+        const dataHash = await arweave_1.default.crypto.hash(leftover);
+        chunks.push({
+            dataHash,
+            minByteRange: cursor,
+            maxByteRange: cursor + leftover.length,
+        });
+    }
+    const leaves = await (0, merkle_js_1.generateLeaves)(chunks);
+    const root = await (0, merkle_js_1.buildLayers)(leaves);
+    return (0, base64_js_1.toB64Url)(Buffer.from(root.id));
+};
+exports.convertDataStreamToDataRoot = convertDataStreamToDataRoot;
+class DataRootVerificationStrategy {
+    trustedDataRootProvider;
+    constructor({ trustedDataRootProvider, }) {
+        this.trustedDataRootProvider = trustedDataRootProvider;
+    }
+    async verifyData({ data, txId, }) {
+        const [computedDataRoot, trustedDataRoot] = await Promise.all([
+            (0, exports.convertDataStreamToDataRoot)({
+                dataStream: data,
+            }),
+            this.trustedDataRootProvider.getDataRoot({
+                txId,
+            }),
+        ]);
+        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

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashVerificationStrategy = void 0;
+const hash_js_1 = require("../../../../utils/hash.js");
+class HashVerificationStrategy {
+    trustedHashProvider;
+    constructor({ trustedHashProvider, }) {
+        this.trustedHashProvider = trustedHashProvider;
+    }
+    async verifyData({ data, txId, }) {
+        // kick off the hash computation, but don't wait for it until we compute our own hash
+        const [computedHash, fetchedHash] = await Promise.all([
+            (0, hash_js_1.hashDataStreamToB64Url)(data),
+            this.trustedHashProvider.getHash({ txId }),
+        ]);
+        // await on the hash promise and compare to get a little concurrency when computing hashes over larger data
+        if (computedHash === undefined) {
+            throw new Error('Hash could not be computed');
+        }
+        if (computedHash !== fetchedHash.hash) {
+            throw new Error('Hash does not match', {
+                cause: { computedHash, trustedHash: fetchedHash },
+            });
+        }
+    }
+}
+exports.HashVerificationStrategy = HashVerificationStrategy;