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

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

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const priority_js_1 = require("./priority.js");
+(0, node_test_1.describe)('PriorityRouter', () => {
+    const mockGateways = [
+        {
+            settings: {
+                fqdn: 'gateway1.net',
+                port: 443,
+                protocol: 'https',
+                allowDelegatedStaking: false,
+                delegateRewardShareRatio: 0.5,
+                allowedDelegates: [],
+                minDelegatedStake: 0,
+                autoStake: false,
+                properties: '',
+                label: '',
+                note: '',
+            },
+            gatewayAddress: 'addr1',
+            observerAddress: 'addr1',
+            totalDelegatedStake: 1000,
+            startTimestamp: 0,
+            endTimestamp: 0,
+            operatorStake: 100,
+            status: 'joined',
+            weights: {
+                normalizedCompositeWeight: 0.5,
+                stakeWeight: 0.5,
+                tenureWeight: 0.5,
+                gatewayPerformanceRatio: 0.5,
+                observerPerformanceRatio: 0.5,
+                compositeWeight: 0.5,
+                gatewayRewardRatioWeight: 0.5,
+                observerRewardRatioWeight: 0.5,
+            },
+            stats: {
+                passedConsecutiveEpochs: 10,
+                failedConsecutiveEpochs: 5,
+                totalEpochCount: 15,
+                passedEpochCount: 10,
+                failedEpochCount: 5,
+                observedEpochCount: 15,
+                prescribedEpochCount: 20,
+            },
+        },
+        {
+            settings: {
+                fqdn: 'gateway1.net',
+                port: 443,
+                protocol: 'https',
+                allowDelegatedStaking: false,
+                delegateRewardShareRatio: 0.5,
+                allowedDelegates: [],
+                minDelegatedStake: 0,
+                autoStake: false,
+                properties: '',
+                label: '',
+                note: '',
+            },
+            gatewayAddress: 'addr1',
+            observerAddress: 'addr1',
+            totalDelegatedStake: 2000,
+            startTimestamp: 0,
+            endTimestamp: 0,
+            operatorStake: 2000,
+            status: 'joined',
+            weights: {
+                normalizedCompositeWeight: 0.5,
+                stakeWeight: 0.5,
+                tenureWeight: 0.5,
+                gatewayPerformanceRatio: 0.5,
+                observerPerformanceRatio: 0.5,
+                compositeWeight: 0.5,
+                gatewayRewardRatioWeight: 0.5,
+                observerRewardRatioWeight: 0.5,
+            },
+            stats: {
+                passedConsecutiveEpochs: 10,
+                failedConsecutiveEpochs: 5,
+                totalEpochCount: 15,
+                passedEpochCount: 10,
+                failedEpochCount: 5,
+                observedEpochCount: 15,
+                prescribedEpochCount: 20,
+            },
+        },
+        {
+            settings: {
+                fqdn: 'gateway2.net',
+                port: 443,
+                protocol: 'https',
+                allowDelegatedStaking: false,
+                delegateRewardShareRatio: 0.5,
+                allowedDelegates: [],
+                minDelegatedStake: 0,
+                autoStake: false,
+                properties: '',
+                label: '',
+                note: '',
+            },
+            gatewayAddress: 'addr2',
+            observerAddress: 'addr2',
+            totalDelegatedStake: 0,
+            startTimestamp: 0,
+            endTimestamp: 0,
+            operatorStake: 0,
+            status: 'leaving',
+            weights: {
+                normalizedCompositeWeight: 0.5,
+                stakeWeight: 0.5,
+                tenureWeight: 0.5,
+                gatewayPerformanceRatio: 0.5,
+                observerPerformanceRatio: 0.5,
+                compositeWeight: 0.5,
+                gatewayRewardRatioWeight: 0.5,
+                observerRewardRatioWeight: 0.5,
+            },
+            stats: {
+                passedConsecutiveEpochs: 10,
+                failedConsecutiveEpochs: 5,
+                totalEpochCount: 15,
+                passedEpochCount: 10,
+                failedEpochCount: 5,
+                observedEpochCount: 15,
+                prescribedEpochCount: 20,
+            },
+        },
+    ];
+    const mockArIOClient = {
+        getGateways: async () => ({ items: mockGateways }),
+    };
+    (0, node_test_1.it)('should prioritize gateway with highest success rate when using successRate weight', async () => {
+        const router = new priority_js_1.PriorityGatewayRouter({
+            ario: mockArIOClient,
+            sortBy: 'operatorStake',
+            sortOrder: 'desc',
+            limit: 1,
+        });
+        const result = await router.getTargetGateway();
+        node_assert_1.strict.deepStrictEqual(result, new URL('http://gateway1.net'));
+    });
+    (0, node_test_1.it)('should prioritize gateway with lowest latency when using latency weight', async () => {
+        const router = new priority_js_1.PriorityGatewayRouter({
+            ario: mockArIOClient,
+            sortBy: 'operatorStake',
+            sortOrder: 'desc',
+            limit: 1,
+        });
+        const result = await router.getTargetGateway();
+        node_assert_1.strict.deepStrictEqual(result, new URL('http://gateway2.net'));
+    });
+});

package/lib/cjs/common/wayfinder/routers/random.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RandomGatewayRouter = void 0;
+const random_js_1 = require("../../../utils/random.js");
+class RandomGatewayRouter {
+    name = 'random';
+    gatewaysProvider;
+    blocklist;
+    constructor({ gatewaysProvider, blocklist = [], }) {
+        this.gatewaysProvider = gatewaysProvider;
+        this.blocklist = blocklist;
+    }
+    async getTargetGateway() {
+        const allGateways = await this.gatewaysProvider.getGateways();
+        const gateways = allGateways.filter((g) => !this.blocklist.includes(g.hostname));
+        const targetGateway = gateways[(0, random_js_1.randomInt)(0, gateways.length)];
+        if (targetGateway === undefined) {
+            throw new Error('No target gateway found');
+        }
+        return targetGateway;
+    }
+}
+exports.RandomGatewayRouter = RandomGatewayRouter;

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const random_js_1 = require("./random.js");
+(0, node_test_1.describe)('RandomRouter', () => {
+    const mockGateways = [
+        new URL('https://gateway1.net'),
+        new URL('https://gateway2.net'),
+        new URL('https://gateway3.net'),
+    ];
+    const mockGatewaysProvider = {
+        getGateways: async () => mockGateways,
+    };
+    (0, node_test_1.it)('should only return joined gateways', async () => {
+        const router = new random_js_1.RandomGatewayRouter({
+            gatewaysProvider: mockGatewaysProvider,
+        });
+        // random gateway should be one of the mock gateways
+        for (let i = 0; i < 10; i++) {
+            const result = await router.getTargetGateway();
+            node_assert_1.strict.ok(mockGateways.includes(result));
+        }
+    });
+});

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

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleCacheRouter = void 0;
+class SimpleCacheRouter {
+    name;
+    lastUpdatedTimestamp;
+    ttlSeconds;
+    targetGateway;
+    router;
+    constructor({ router, ttlSeconds = 5 * 60, // 5 minutes
+     }) {
+        this.router = router;
+        this.ttlSeconds = ttlSeconds;
+    }
+    async getTargetGateway() {
+        if (this.targetGateway === undefined ||
+            this.lastUpdatedTimestamp + this.ttlSeconds * 1000 < Date.now()) {
+            this.targetGateway = await this.router.getTargetGateway();
+            this.lastUpdatedTimestamp = Date.now();
+        }
+        return this.targetGateway;
+    }
+}
+exports.SimpleCacheRouter = SimpleCacheRouter;
+// TODO: a router that accepts ario and a router, and adds read through promise cache to ario.getGateways to avoid calling the ARIO contract on every request

package/lib/cjs/common/wayfinder/routers/simple-cache.test.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const simple_cache_js_1 = require("./simple-cache.js");
+(0, node_test_1.describe)('SimpleCacheRouter', () => {
+    (0, node_test_1.it)('should cache gateway for TTL period even if underlying gateway changes', async () => {
+        const gateway1 = new URL('https://gateway1.net');
+        const gateway2 = new URL('https://gateway2.net');
+        let currentGateway = gateway1;
+        const mockRouter = {
+            name: 'mock',
+            getTargetGateway: async () => currentGateway,
+        };
+        const router = new simple_cache_js_1.SimpleCacheRouter({
+            router: mockRouter,
+            ttlSeconds: 300, // 5 minutes
+        });
+        // Get initial gateway which should be cached
+        const initial = await router.getTargetGateway();
+        node_assert_1.strict.deepStrictEqual(initial, gateway1);
+        // Change the underlying gateway
+        currentGateway = gateway2;
+        // Should still return cached gateway1 for multiple calls
+        for (let i = 0; i < 5; i++) {
+            const result = await router.getTargetGateway();
+            node_assert_1.strict.deepStrictEqual(result, gateway1);
+        }
+        // Advance time past TTL
+        const originalNow = Date.now;
+        try {
+            Date.now = () => originalNow() + 300 * 1000 + 1;
+            // Should now return the new gateway2
+            const result = await router.getTargetGateway();
+            node_assert_1.strict.deepStrictEqual(result, gateway2);
+        }
+        finally {
+            Date.now = originalNow;
+        }
+    });
+});

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticGatewayRouter = void 0;
+class StaticGatewayRouter {
+    name = 'static';
+    gateway;
+    constructor({ gateway }) {
+        this.gateway = new URL(gateway);
+    }
+    async getTargetGateway() {
+        return this.gateway;
+    }
+}
+exports.StaticGatewayRouter = StaticGatewayRouter;

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

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = require("node:assert");
+const node_test_1 = require("node:test");
+const static_js_1 = require("./static.js");
+(0, node_test_1.describe)('StaticGatewayRouter', () => {
+    (0, node_test_1.it)('should return the provided gateway', async () => {
+        const router = new static_js_1.StaticGatewayRouter({
+            gateway: 'http://test-gateway.net',
+        });
+        const result = await router.getTargetGateway();
+        node_assert_1.strict.deepStrictEqual(result, new URL('http://test-gateway.net'));
+    });
+});

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

@@ -0,0 +1,139 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataRootVerifier = exports.convertReadableToDataRoot = void 0;
+exports.convertBufferToDataRoot = convertBufferToDataRoot;
+/**
+ * Copyright (C) 2022-2024 Permanent Data Solutions, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+const arweave_1 = __importDefault(require("arweave"));
+const merkle_js_1 = require("arweave/node/lib/merkle.js");
+const node_stream_1 = require("node:stream");
+const base64_js_1 = require("../../../utils/base64.js");
+async function convertBufferToDataRoot({ buffer, }) {
+    const chunks = [];
+    let cursor = 0;
+    let offset = 0;
+    while (offset < buffer.byteLength) {
+        let chunkSize = Math.min(merkle_js_1.MAX_CHUNK_SIZE, buffer.byteLength - offset);
+        const remainder = buffer.byteLength - offset - chunkSize;
+        if (remainder > 0 && remainder < merkle_js_1.MIN_CHUNK_SIZE) {
+            chunkSize = Math.ceil((buffer.byteLength - offset) / 2);
+        }
+        // subarray does not exist on web Buffer type
+        const slice = buffer.subarray(offset, offset + chunkSize);
+        const hash = await crypto.subtle.digest('SHA-256', slice);
+        const hashArray = new Uint8Array(hash);
+        chunks.push({
+            dataHash: hashArray,
+            minByteRange: cursor,
+            maxByteRange: cursor + chunkSize,
+        });
+        cursor += chunkSize;
+        offset += chunkSize;
+    }
+    const leaves = await (0, merkle_js_1.generateLeaves)(chunks);
+    const result = await (0, merkle_js_1.buildLayers)(leaves);
+    return Buffer.from(result.id).toString('base64url');
+}
+const convertReadableToDataRoot = async ({ iterable, }) => {
+    const chunks = [];
+    let leftover = new Uint8Array(0);
+    let cursor = 0;
+    for await (const data of iterable) {
+        const inputChunk = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        const combined = new Uint8Array(leftover.length + inputChunk.length);
+        combined.set(leftover, 0);
+        combined.set(inputChunk, leftover.length);
+        let startIndex = 0;
+        while (combined.length - startIndex >= merkle_js_1.MAX_CHUNK_SIZE) {
+            let chunkSize = merkle_js_1.MAX_CHUNK_SIZE;
+            const remainderAfterThis = combined.length - startIndex - merkle_js_1.MAX_CHUNK_SIZE;
+            if (remainderAfterThis > 0 && remainderAfterThis < merkle_js_1.MIN_CHUNK_SIZE) {
+                chunkSize = Math.ceil((combined.length - startIndex) / 2);
+            }
+            const chunkData = combined.slice(startIndex, startIndex + chunkSize);
+            const dataHash = await arweave_1.default.crypto.hash(chunkData);
+            chunks.push({
+                dataHash,
+                minByteRange: cursor,
+                maxByteRange: cursor + chunkSize,
+            });
+            cursor += chunkSize;
+            startIndex += chunkSize;
+        }
+        leftover = combined.slice(startIndex);
+    }
+    if (leftover.length > 0) {
+        const dataHash = await arweave_1.default.crypto.hash(leftover);
+        chunks.push({
+            dataHash,
+            minByteRange: cursor,
+            maxByteRange: cursor + leftover.length,
+        });
+    }
+    const leaves = await (0, merkle_js_1.generateLeaves)(chunks);
+    const root = await (0, merkle_js_1.buildLayers)(leaves);
+    return (0, base64_js_1.toB64Url)(Buffer.from(root.id));
+};
+exports.convertReadableToDataRoot = convertReadableToDataRoot;
+class DataRootVerifier {
+    trustedDataRootProvider;
+    constructor({ trustedDataRootProvider, }) {
+        this.trustedDataRootProvider = trustedDataRootProvider;
+    }
+    async verifyData({ data, txId, }) {
+        const trustedDataRootPromise = this.trustedDataRootProvider.getDataRoot({
+            txId,
+        });
+        let computedDataRoot;
+        if (Buffer.isBuffer(data)) {
+            computedDataRoot = await convertBufferToDataRoot({ buffer: data });
+        }
+        else if (data instanceof node_stream_1.Readable || data instanceof ReadableStream) {
+            computedDataRoot = await (0, exports.convertReadableToDataRoot)({ iterable: data });
+        }
+        if (computedDataRoot === undefined) {
+            throw new Error('Data root could not be computed');
+        }
+        const trustedDataRoot = await trustedDataRootPromise;
+        if (computedDataRoot !== trustedDataRoot) {
+            throw new Error('Data root does not match', {
+                cause: { computedDataRoot, trustedDataRoot },
+            });
+        }
+    }
+}
+exports.DataRootVerifier = DataRootVerifier;
+// 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/hash-verifier.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HashVerifier = 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 node_stream_1 = require("node:stream");
+const hash_js_1 = require("../../../utils/hash.js");
+class HashVerifier {
+    trustedHashProvider;
+    constructor({ trustedHashProvider, }) {
+        this.trustedHashProvider = trustedHashProvider;
+    }
+    async verifyData({ data, txId, }) {
+        const hashPromise = this.trustedHashProvider.getHash({ txId });
+        let computedHash;
+        if (Buffer.isBuffer(data)) {
+            computedHash = (0, hash_js_1.hashBufferToB64Url)(data);
+        }
+        else if (data instanceof node_stream_1.Readable) {
+            computedHash = await (0, hash_js_1.hashReadableToB64Url)(data);
+        }
+        else if (data instanceof ReadableStream) {
+            computedHash = await (0, hash_js_1.hashReadableStreamToB64Url)(data);
+        }
+        // await on the hash promise and compare to get a little concurrency when computing hashes over larger data
+        const { hash } = await hashPromise;
+        if (computedHash === undefined) {
+            throw new Error('Hash could not be computed');
+        }
+        if (computedHash !== hash) {
+            throw new Error('Hash does not match', {
+                cause: { computedHash, trustedHash: hash },
+            });
+        }
+    }
+}
+exports.HashVerifier = HashVerifier;