@autonomys/auto-dag-data 0.8.2

package/LICENSE

@@ -0,0 +1,18 @@
+MIT License
+
+Copyright (c) 2024 Autonomys Network (autonomys.xyz)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+1. **Attribution**: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+2. **No Warranty**: THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+
+3. **Limitation of Liability**: IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---

package/README.md

@@ -0,0 +1,167 @@
+# Auto DAG Data
+
+![Autonomys Banner](https://github.com/autonomys/auto-sdk/blob/main/.github/images/autonomys-banner.webp)
+
+[![Latest Github release](https://img.shields.io/github/v/tag/autonomys/auto-sdk.svg)](https://github.com/autonomys/auto-sdk/tags)
+[![Build status of the main branch on Linux/OSX](https://img.shields.io/github/actions/workflow/status/autonomys/auto-sdk/build.yaml?branch=main&label=Linux%2FOSX%20build)](https://github.com/autonomys/auto-sdk/actions/workflows/build.yaml)
+[![npm version](https://badge.fury.io/js/@autonomys%2Fauto-dag-data.svg)](https://badge.fury.io/js/@autonomys/auto-dag-data)
+
+## Overview
+
+The **Autonomys Auto DAG Data SDK** (`@autonomys/auto-dag-data`) provides utilities for creating and managing IPLD DAGs (InterPlanetary Linked Data Directed Acyclic Graphs) for files and folders. It facilitates chunking large files, handling metadata, and creating folder structures suitable for distributed storage systems like IPFS.
+
+## Features
+
+- **File Chunking and DAG Creation**: Efficiently split large files into smaller chunks and create IPLD DAGs.
+- **Folder Structure Creation**: Generate IPLD DAGs for directory structures.
+- **Metadata Handling**: Add and manage metadata for files and folders.
+- **CID Management**: Utilities for working with Content Identifiers (CIDs).
+- **TypeScript Support**: Fully typed for enhanced developer experience.
+
+## Installation
+
+You can install Auto-DAG-Data using npm or yarn:
+
+```bash
+npm install @autonomys/auto-dag-data
+```
+
+or
+
+```bash
+yarn add @autonomys/auto-dag-data
+```
+
+## Usage
+
+### Creating an IPLD DAG from a File
+
+To create an IPLD DAG from a file, you can use the `createFileIPLDDag` function:
+
+```typescript
+import { createFileIPLDDag } from '@autonomys/auto-dag-data'
+import fs from 'fs'
+
+const fileBuffer = fs.readFileSync('path/to/your/file.txt')
+
+const dag = createFileIPLDDag(fileBuffer, 'file.txt')
+```
+
+### Creating an IPLD DAG from a Folder
+
+To create an IPLD DAG from a folder, you can use the `createFolderIPLDDag` function:
+
+```typescript
+import { createFolderIPLDDag } from '@autonomys/auto-dag-data'
+import { CID } from 'multiformats'
+
+// Example child CIDs and folder information
+const childCIDs: CID[] = [
+  /* array of CIDs */
+]
+const folderName = 'my-folder'
+const folderSize = 1024 // size in bytes
+
+const folderDag = createFolderIPLDDag(childCIDs, folderName, folderSize)
+```
+
+### Working with CIDs
+
+You can use functions from the `cid` module to work with CIDs:
+
+```typescript
+import { cidOfNode, cidToString, stringToCid } from '@autonomys/auto-dag-data'
+
+// Create a CID from a node
+const cid = cidOfNode(dag.head)
+
+// Convert the CID to a string
+const cidString = cidToString(cid)
+
+// Parse a string back into a CID
+const parsedCID = stringToCid(cidString)
+```
+
+### Encoding and Decoding Nodes
+
+You can encode and decode IPLD nodes:
+
+```typescript
+import { encodeNode, decodeNode } from '@autonomys/auto-dag-data'
+
+// Encode a node
+const encodedNode = encodeNode(dag.head)
+
+// Decode a node
+const decodedNode = decodeNode(encodedNode)
+```
+
+### Handling Metadata
+
+To add metadata to a node, you can create a metadata node:
+
+```typescript
+import { createMetadataNode } from '@autonomys/auto-dag-data'
+
+const metadata = {
+  name: 'My File',
+  description: 'This is a sample file',
+  // ... other metadata fields
+}
+
+const metadataNode = createMetadataNode(metadata)
+```
+
+### Example: Creating a File DAG and Converting to CID
+
+```typescript
+import { createFileIPLDDag, cidOfNode, cidToString } from '@autonomys/auto-dag-data'
+import fs from 'fs'
+
+const fileBuffer = fs.readFileSync('path/to/your/file.txt')
+
+const dag = createFileIPLDDag(fileBuffer, 'file.txt')
+
+const cid = cidOfNode(dag.headCID)
+const cidString = cidToString(cid)
+
+console.log(`CID of the file DAG: ${cidString}`)
+```
+
+### Example: Converting Metadata To DAG
+
+```typescript
+import {
+  createMetadataIPLDDag,
+  cidOfNode,
+  cidToString,
+  type OffchainMetadata,
+} from '@autonomys/auto-dag-data'
+import fs from 'fs'
+
+const metadata: OffchainMetadata = fs.readFileSync('path/to/your/metadata.json')
+
+const dag = createMetadataIPLDDag(metadata)
+
+const cid = cidOfNode(dag.headCID)
+const cidString = cidToString(cid)
+
+console.log(`CID of the metadata DAG: ${cidString}`)
+```
+
+## License
+
+This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
+
+## Additional Resources
+
+- **Autonomys Academy**: Learn more at [Autonomys Academy](https://academy.autonomys.xyz).
+- **Auto-Utils Package**: Utility functions used alongside `auto-dag-data` can be found in [`@autonomys/auto-utils`](../Auto-Utils/README.md).
+
+## Contact
+
+If you have any questions or need support, feel free to reach out:
+
+- **GitHub Issues**: [GitHub Issues Page](https://github.com/autonomys/auto-sdk/issues)
+
+We appreciate your feedback and contributions!

package/dist/cid/index.d.ts

@@ -0,0 +1,9 @@
+import { CID } from 'multiformats/cid';
+import { PBNode } from '../ipld/utils.js';
+export declare const BLAKE3_CODE = 31;
+export declare const cidOfNode: (node: PBNode) => CID<unknown, 85, 31, 1>;
+export declare const cidToString: (cid: CID) => string;
+export declare const stringToCid: (str: string) => CID<unknown, number, number, import("multiformats/cid").Version>;
+export declare const cidFromBlakeHash: (hash: Buffer) => CID<unknown, 85, 31, 1>;
+export declare const blake3HashFromCid: (cid: CID) => Uint8Array;
+//# sourceMappingURL=index.d.ts.map

package/dist/cid/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cid/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAGtC,OAAO,EAAc,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAErD,eAAO,MAAM,WAAW,KAAO,CAAA;AAE/B,eAAO,MAAM,SAAS,SAAU,MAAM,4BAErC,CAAA;AAED,eAAO,MAAM,WAAW,QAAS,GAAG,WAEnC,CAAA;AAED,eAAO,MAAM,WAAW,QAAS,MAAM,qEAEtC,CAAA;AAED,eAAO,MAAM,gBAAgB,SAAU,MAAM,4BAE5C,CAAA;AAED,eAAO,MAAM,iBAAiB,QAAS,GAAG,eAAyB,CAAA"}

package/dist/cid/index.js

@@ -0,0 +1,20 @@
+import { hash } from 'blake3';
+import * as base32 from 'multiformats/bases/base32';
+import { CID } from 'multiformats/cid';
+import * as raw from 'multiformats/codecs/raw';
+import { create } from 'multiformats/hashes/digest';
+import { encodeNode } from '../ipld/utils.js';
+export const BLAKE3_CODE = 0x1f;
+export const cidOfNode = (node) => {
+    return cidFromBlakeHash(hash(encodeNode(node)));
+};
+export const cidToString = (cid) => {
+    return cid.toString(base32.base32);
+};
+export const stringToCid = (str) => {
+    return CID.parse(str, base32.base32);
+};
+export const cidFromBlakeHash = (hash) => {
+    return CID.create(1, raw.code, create(BLAKE3_CODE, hash));
+};
+export const blake3HashFromCid = (cid) => cid.multihash.digest;

package/dist/compression/index.d.ts

@@ -0,0 +1,7 @@
+import type { AwaitIterable } from 'interface-store';
+import type { PickPartial } from '../utils/types.js';
+import { CompressionOptions } from './types.js';
+export declare const COMPRESSION_CHUNK_SIZE: number;
+export declare function compressFile(file: AwaitIterable<Buffer>, { level, chunkSize, algorithm, }: PickPartial<CompressionOptions, 'algorithm'>): AsyncIterable<Buffer>;
+export declare function decompressFile(compressedFile: AwaitIterable<Buffer>, { chunkSize, algorithm, level, }: PickPartial<CompressionOptions, 'algorithm'>): AsyncIterable<Buffer>;
+//# sourceMappingURL=index.d.ts.map

package/dist/compression/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAGpD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAA;AAE/C,eAAO,MAAM,sBAAsB,QAAc,CAAA;AAEjD,wBAAuB,YAAY,CACjC,IAAI,EAAE,aAAa,CAAC,MAAM,CAAC,EAC3B,EACE,KAAS,EACT,SAAkC,EAClC,SAAS,GACV,EAAE,WAAW,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,MAAM,CAAC,CA6BvB;AAED,wBAAuB,cAAc,CACnC,cAAc,EAAE,aAAa,CAAC,MAAM,CAAC,EACrC,EACE,SAAkC,EAClC,SAAqC,EACrC,KAAS,GACV,EAAE,WAAW,CAAC,kBAAkB,EAAE,WAAW,CAAC,GAC9C,aAAa,CAAC,MAAM,CAAC,CA6BvB"}

package/dist/compression/index.js

@@ -0,0 +1,106 @@
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { Unzlib, Zlib } from 'fflate';
+import { CompressionAlgorithm } from '../metadata/index.js';
+import { asyncByChunk } from '../utils/async.js';
+export const COMPRESSION_CHUNK_SIZE = 1024 * 1024;
+export function compressFile(file_1, _a) {
+    return __asyncGenerator(this, arguments, function* compressFile_1(file, { level = 9, chunkSize = COMPRESSION_CHUNK_SIZE, algorithm, }) {
+        var _b, e_1, _c, _d;
+        if (algorithm !== CompressionAlgorithm.ZLIB) {
+            throw new Error('Unsupported compression algorithm');
+        }
+        if (level < 0 || level > 9) {
+            throw new Error('Invalid compression level');
+        }
+        if (chunkSize <= 0) {
+            throw new Error('Invalid chunk size');
+        }
+        const zlib = new Zlib({ level });
+        const compressedChunks = [];
+        zlib.ondata = (chunk) => {
+            compressedChunks.push(Buffer.from(chunk));
+        };
+        try {
+            for (var _e = true, _f = __asyncValues(asyncByChunk(file, chunkSize)), _g; _g = yield __await(_f.next()), _b = _g.done, !_b; _e = true) {
+                _d = _g.value;
+                _e = false;
+                const chunk = _d;
+                zlib.push(chunk, false);
+                while (compressedChunks.length > 0) {
+                    yield yield __await(compressedChunks.shift());
+                }
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        zlib.push(new Uint8Array(), true);
+        while (compressedChunks.length > 0) {
+            yield yield __await(compressedChunks.shift());
+        }
+    });
+}
+export function decompressFile(compressedFile_1, _a) {
+    return __asyncGenerator(this, arguments, function* decompressFile_1(compressedFile, { chunkSize = COMPRESSION_CHUNK_SIZE, algorithm = CompressionAlgorithm.ZLIB, level = 9, }) {
+        var _b, e_2, _c, _d;
+        if (algorithm !== CompressionAlgorithm.ZLIB) {
+            throw new Error('Unsupported compression algorithm');
+        }
+        if (chunkSize <= 0) {
+            throw new Error('Invalid chunk size');
+        }
+        if (level < 0 || level > 9) {
+            throw new Error('Invalid compression level');
+        }
+        const unzlib = new Unzlib();
+        const decompressedChunks = [];
+        unzlib.ondata = (chunk) => {
+            decompressedChunks.push(Buffer.from(chunk));
+        };
+        try {
+            for (var _e = true, _f = __asyncValues(asyncByChunk(compressedFile, chunkSize)), _g; _g = yield __await(_f.next()), _b = _g.done, !_b; _e = true) {
+                _d = _g.value;
+                _e = false;
+                const chunk = _d;
+                unzlib.push(chunk, false);
+                while (decompressedChunks.length > 0) {
+                    yield yield __await(decompressedChunks.shift());
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        unzlib.push(new Uint8Array(), true);
+        while (decompressedChunks.length > 0) {
+            yield yield __await(decompressedChunks.shift());
+        }
+    });
+}

package/dist/compression/types.d.ts

@@ -0,0 +1,9 @@
+import { CompressionAlgorithm } from '../metadata/index.js';
+export type CompressionLevel = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export type ZLibOptions = {
+    algorithm: CompressionAlgorithm.ZLIB;
+    level: CompressionLevel;
+    chunkSize: number;
+};
+export type CompressionOptions = ZLibOptions;
+//# sourceMappingURL=types.d.ts.map

package/dist/compression/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/compression/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAE3D,MAAM,MAAM,gBAAgB,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAA;AAEpE,MAAM,MAAM,WAAW,GAAG;IACxB,SAAS,EAAE,oBAAoB,CAAC,IAAI,CAAA;IACpC,KAAK,EAAE,gBAAgB,CAAA;IACvB,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG,WAAW,CAAA"}

package/dist/compression/types.js

@@ -0,0 +1 @@
+export {};

package/dist/encryption/index.d.ts

@@ -0,0 +1,8 @@
+import { EncryptionOptions } from '../metadata/index.js';
+import type { PickPartial } from '../utils/types.js';
+import { PasswordGenerationOptions } from './types.js';
+export declare const ENCRYPTING_CHUNK_SIZE: number;
+export declare const getKeyFromPassword: ({ password, salt }: PasswordGenerationOptions) => Promise<CryptoKey>;
+export declare const encryptFile: (file: AsyncIterable<Buffer>, password: string, { chunkSize, algorithm }: PickPartial<EncryptionOptions, "algorithm">) => AsyncIterable<Buffer>;
+export declare const decryptFile: (file: AsyncIterable<Buffer>, password: string, { chunkSize, algorithm }: PickPartial<EncryptionOptions, "algorithm">) => AsyncIterable<Buffer>;
+//# sourceMappingURL=index.d.ts.map

package/dist/encryption/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/encryption/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAuB,iBAAiB,EAAE,MAAM,sBAAsB,CAAA;AAE7E,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AACpD,OAAO,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAA;AAItD,eAAO,MAAM,qBAAqB,QAAc,CAAA;AAMhD,eAAO,MAAM,kBAAkB,uBAA8B,yBAAyB,uBAyBrF,CAAA;AAED,eAAO,MAAM,WAAW,SAChB,aAAa,CAAC,MAAM,CAAC,YACjB,MAAM,4BACkC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAC5F,aAAa,CAAC,MAAM,CAetB,CAAA;AAED,eAAO,MAAM,WAAW,SAChB,aAAa,CAAC,MAAM,CAAC,YACjB,MAAM,4BACiC,WAAW,CAAC,iBAAiB,EAAE,WAAW,CAAC,KAC3F,aAAa,CAAC,MAAM,CA+BtB,CAAA"}

package/dist/encryption/index.js

@@ -0,0 +1,121 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { Crypto } from '@peculiar/webcrypto';
+import { randomBytes } from 'crypto';
+import { EncryptionAlgorithm } from '../metadata/index.js';
+import { asyncByChunk } from '../utils/async.js';
+const crypto = new Crypto();
+export const ENCRYPTING_CHUNK_SIZE = 1024 * 1024;
+const IV_SIZE = 16;
+const TAG_SIZE = 16;
+const ENCRYPTED_CHUNK_SIZE = ENCRYPTING_CHUNK_SIZE + IV_SIZE + TAG_SIZE;
+const SALT_SIZE = 32;
+export const getKeyFromPassword = (_a) => __awaiter(void 0, [_a], void 0, function* ({ password, salt }) {
+    const encoder = new TextEncoder();
+    const saltHash = typeof salt === 'string' ? yield crypto.subtle.digest('SHA-256', encoder.encode(salt)) : salt;
+    const keyMaterial = yield crypto.subtle.importKey('raw', encoder.encode(password), 'PBKDF2', false, ['deriveBits', 'deriveKey']);
+    return crypto.subtle.deriveKey({
+        name: 'PBKDF2',
+        salt: saltHash,
+        iterations: 100000,
+        hash: 'SHA-256',
+    }, keyMaterial, { name: 'AES-GCM', length: 256 }, false, ['encrypt', 'decrypt']);
+});
+export const encryptFile = function (file_1, password_1, _a) {
+    return __asyncGenerator(this, arguments, function* (file, password, { chunkSize = ENCRYPTING_CHUNK_SIZE, algorithm }) {
+        var _b, e_1, _c, _d;
+        if (algorithm !== EncryptionAlgorithm.AES_256_GCM) {
+            throw new Error('Unsupported encryption algorithm');
+        }
+        const salt = randomBytes(SALT_SIZE);
+        const key = yield __await(getKeyFromPassword({ password, salt }));
+        yield yield __await(salt);
+        try {
+            for (var _e = true, _f = __asyncValues(asyncByChunk(file, chunkSize)), _g; _g = yield __await(_f.next()), _b = _g.done, !_b; _e = true) {
+                _d = _g.value;
+                _e = false;
+                const chunk = _d;
+                const iv = crypto.getRandomValues(new Uint8Array(IV_SIZE));
+                const encrypted = yield __await(crypto.subtle.encrypt({ name: 'AES-GCM', iv }, key, chunk));
+                yield yield __await(Buffer.concat([Buffer.from(iv), Buffer.from(encrypted)]));
+            }
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (!_e && !_b && (_c = _f.return)) yield __await(_c.call(_f));
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+    });
+};
+export const decryptFile = function (file_1, password_1, _a) {
+    return __asyncGenerator(this, arguments, function* (file, password, { chunkSize = ENCRYPTED_CHUNK_SIZE, algorithm }) {
+        var _b, e_2, _c, _d;
+        if (algorithm !== EncryptionAlgorithm.AES_256_GCM) {
+            throw new Error('Unsupported encryption algorithm');
+        }
+        let key = undefined;
+        let chunks = Buffer.alloc(0);
+        try {
+            for (var _e = true, file_2 = __asyncValues(file), file_2_1; file_2_1 = yield __await(file_2.next()), _b = file_2_1.done, !_b; _e = true) {
+                _d = file_2_1.value;
+                _e = false;
+                const chunk = _d;
+                chunks = Buffer.concat([chunks, chunk]);
+                if (chunks.length >= SALT_SIZE && !key) {
+                    const salt = chunks.subarray(0, 32);
+                    key = yield __await(getKeyFromPassword({ password, salt }));
+                    chunks = chunks.subarray(SALT_SIZE);
+                }
+                while (key && chunks.length >= chunkSize) {
+                    const iv = chunks.subarray(0, IV_SIZE);
+                    const encryptedChunk = chunk.subarray(IV_SIZE, chunkSize);
+                    const decrypted = yield __await(crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, encryptedChunk));
+                    chunks = chunks.subarray(chunkSize);
+                    yield yield __await(Buffer.from(decrypted));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (!_e && !_b && (_c = file_2.return)) yield __await(_c.call(file_2));
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        if (key && chunks.length > 0) {
+            const iv = chunks.subarray(0, IV_SIZE);
+            const encryptedChunk = chunks.subarray(IV_SIZE, chunkSize);
+            const decrypted = yield __await(crypto.subtle.decrypt({ name: 'AES-GCM', iv }, key, encryptedChunk));
+            yield yield __await(Buffer.from(decrypted));
+        }
+    });
+};

package/dist/encryption/types.d.ts

@@ -0,0 +1,5 @@
+export type PasswordGenerationOptions = {
+    password: string;
+    salt: string | Uint8Array;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/encryption/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/encryption/types.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,yBAAyB,GAAG;IACtC,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,GAAG,UAAU,CAAA;CAC1B,CAAA"}

package/dist/encryption/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export * from './cid/index.js';
+export * from './compression/index.js';
+export * from './encryption/index.js';
+export * from './ipld/index.js';
+export * from './metadata/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAA;AAC9B,cAAc,wBAAwB,CAAA;AACtC,cAAc,uBAAuB,CAAA;AACrC,cAAc,iBAAiB,CAAA;AAC/B,cAAc,qBAAqB,CAAA"}

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from './cid/index.js';
+export * from './compression/index.js';
+export * from './encryption/index.js';
+export * from './ipld/index.js';
+export * from './metadata/index.js';

package/dist/ipld/blockstore/base.d.ts

@@ -0,0 +1,9 @@
+import { BaseBlockstore } from 'blockstore-core';
+import type { Pair } from 'interface-blockstore';
+import { AbortOptions, AwaitIterable } from 'interface-store';
+import { MetadataType } from '../../metadata/index.js';
+export interface IPLDBlockstore extends BaseBlockstore {
+    getFilteredMany(nodeType: MetadataType, options?: AbortOptions): AwaitIterable<Pair['cid']>;
+    getSize(cid: Pair['cid']): Promise<number>;
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/ipld/blockstore/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/ipld/blockstore/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAChD,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAA;AAEtD,MAAM,WAAW,cAAe,SAAQ,cAAc;IACpD,eAAe,CAAC,QAAQ,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAA;IAC3F,OAAO,CAAC,GAAG,EAAE,IAAI,CAAC,KAAK,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;CAC3C"}

package/dist/ipld/blockstore/base.js

@@ -0,0 +1 @@
+export {};

package/dist/ipld/blockstore/index.d.ts

@@ -0,0 +1,3 @@
+export * from './base.js';
+export * from './memory.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/ipld/blockstore/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ipld/blockstore/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAA;AACzB,cAAc,aAAa,CAAA"}

package/dist/ipld/blockstore/index.js

@@ -0,0 +1,2 @@
+export * from './base.js';
+export * from './memory.js';

package/dist/ipld/blockstore/memory.d.ts

@@ -0,0 +1,13 @@
+import { MemoryBlockstore } from 'blockstore-core';
+import { Pair } from 'interface-blockstore';
+import { AbortOptions, AwaitIterable } from 'interface-store';
+import { CID, Version } from 'multiformats';
+import { MetadataType } from '../../metadata/index.js';
+import { IPLDBlockstore } from './base.js';
+export declare class MemoryIPLDBlockstore extends MemoryBlockstore implements IPLDBlockstore {
+    private readonly nodeByType;
+    getFilteredMany(nodeType: MetadataType, options?: AbortOptions): AwaitIterable<Pair['cid']>;
+    put(key: CID<unknown, number, number, Version>, val: Uint8Array): Promise<CID<unknown, number, number, Version>>;
+    getSize(cid: CID): Promise<number>;
+}
+//# sourceMappingURL=memory.d.ts.map

package/dist/ipld/blockstore/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/ipld/blockstore/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAA;AAClD,OAAO,EAAE,IAAI,EAAE,MAAM,sBAAsB,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAA;AAC7D,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AAC3C,OAAO,EAAoC,YAAY,EAAE,MAAM,yBAAyB,CAAA;AACxF,OAAO,EAAE,cAAc,EAAE,MAAM,WAAW,CAAA;AAE1C,qBAAa,oBAAqB,SAAQ,gBAAiB,YAAW,cAAc;IAClF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAiC;IACrD,eAAe,CACpB,QAAQ,EAAE,YAAY,EACtB,OAAO,CAAC,EAAE,YAAY,GACrB,aAAa,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IAMvB,GAAG,CACP,GAAG,EAAE,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAC1C,GAAG,EAAE,UAAU,GACd,OAAO,CAAC,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;IAM3C,OAAO,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;CAKzC"}

package/dist/ipld/blockstore/memory.js

@@ -0,0 +1,57 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+import { MemoryBlockstore } from 'blockstore-core';
+import { decodeIPLDNodeData } from '../../metadata/index.js';
+export class MemoryIPLDBlockstore extends MemoryBlockstore {
+    constructor() {
+        super(...arguments);
+        this.nodeByType = new Map();
+    }
+    getFilteredMany(nodeType, options) {
+        return __asyncGenerator(this, arguments, function* getFilteredMany_1() {
+            var _a;
+            for (const cid of (_a = this.nodeByType.get(nodeType)) !== null && _a !== void 0 ? _a : []) {
+                yield yield __await(cid);
+            }
+        });
+    }
+    put(key, val) {
+        const _super = Object.create(null, {
+            put: { get: () => super.put }
+        });
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const data = decodeIPLDNodeData(val);
+            this.nodeByType.set(data.type, [...((_a = this.nodeByType.get(data.type)) !== null && _a !== void 0 ? _a : []), key]);
+            return _super.put.call(this, key, val);
+        });
+    }
+    getSize(cid) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const bytes = yield this.get(cid);
+            const data = decodeIPLDNodeData(bytes);
+            return (_a = data.size) !== null && _a !== void 0 ? _a : 0;
+        });
+    }
+}

package/dist/ipld/builders.d.ts

@@ -0,0 +1,12 @@
+import { CID } from 'multiformats/cid';
+import { FileUploadOptions } from '../metadata/index.js';
+import { PBNode } from './index.js';
+export interface Builders {
+    inlink: (links: CID[], size: number, linkDepth: number, chunkSize: number) => PBNode;
+    chunk: (data: Buffer) => PBNode;
+    root: (links: CID[], size: number, linkDepth: number, name?: string, maxNodeSize?: number, fileUploadOptions?: FileUploadOptions) => PBNode;
+    single: (data: Buffer, filename?: string, fileUploadOptions?: FileUploadOptions) => PBNode;
+}
+export declare const metadataBuilders: Builders;
+export declare const fileBuilders: Builders;
+//# sourceMappingURL=builders.d.ts.map