@super-protocol/swarm-contracts-sdk 0.0.1-beta.1

package/dist/mjs/crypto/nodejs/NativeCrypto.js

@@ -0,0 +1,152 @@
+import { createCipheriv, createDecipheriv, randomBytes, createHash, } from 'crypto';
+import { once } from 'events';
+import { Encoding } from '@super-protocol/dto-js';
+import { isCCM, isECB, isGCM, isOCB, isRC4 } from '../utils.js';
+/**
+ *
+ */
+class NativeCrypto {
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.keyLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getKeyLength(cipher) {
+        if (/256-xts/.test(cipher)) {
+            return 64;
+        }
+        if (/256|128-xts|chacha20/.test(cipher) && cipher !== 'aes-128-cbc-hmac-sha256') {
+            return 32;
+        }
+        if (/192|des-ede3|desx|des3$/.test(cipher) || cipher === 'id-smime-alg-cms3deswrap') {
+            return 24;
+        }
+        if (/128|des-ede/.test(cipher)) {
+            return 16;
+        }
+        if (/64|des/.test(cipher)) {
+            return 8;
+        }
+        if (/40/.test(cipher)) {
+            return 5;
+        }
+        return 16;
+    }
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.ivLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getIVLength(cipher) {
+        if (isCCM(cipher) || isGCM(cipher) || isOCB(cipher)) {
+            return 12;
+        }
+        if (/wrap-pad/.test(cipher)) {
+            return 4;
+        }
+        if (/wrap|cast|des|bf|blowfish|idea|rc2/.test(cipher)) {
+            return 8;
+        }
+        return 16;
+    }
+    static createKey(cipher) {
+        const length = this.getKeyLength(cipher);
+        return randomBytes(length);
+    }
+    static createIV(cipher) {
+        const length = this.getIVLength(cipher);
+        return randomBytes(length);
+    }
+    static createCipher(cipher, key, iv) {
+        if (isECB(cipher) || isRC4(cipher)) {
+            throw new Error(`Cipher "${cipher}" is not supported`);
+        }
+        if (isCCM(cipher) || isOCB(cipher)) {
+            const options = {
+                authTagLength: 16,
+            };
+            return createCipheriv(cipher, key, iv, options);
+        }
+        return createCipheriv(cipher, key, iv);
+    }
+    static createDecipher(cipher, key, iv, mac) {
+        const options = {};
+        if (isCCM(cipher) || isOCB(cipher)) {
+            options.authTagLength = 16;
+        }
+        const decipher = createDecipheriv(cipher, key, iv, options);
+        if (mac) {
+            decipher.setAuthTag(mac);
+        }
+        return decipher;
+    }
+    static encrypt(key, content, cipherName, outputEncoding = Encoding.base64, 
+    // TODO: replace BufferEncoding with Encoding
+    inputEncoding = 'binary') {
+        const iv = this.createIV(cipherName);
+        const result = {};
+        const cipher = this.createCipher(cipherName, key, iv);
+        result.ciphertext = cipher.update(content, inputEncoding, outputEncoding);
+        result.ciphertext += cipher.final(outputEncoding);
+        if (!isECB(cipherName) && !isRC4(cipherName)) {
+            result.iv = iv.toString(outputEncoding);
+        }
+        if (isCCM(cipherName) || isGCM(cipherName) || isOCB(cipherName)) {
+            result.mac = cipher.getAuthTag().toString(outputEncoding);
+        }
+        return result;
+    }
+    static async encryptStream(key, inputStream, outputStream, cipherName, encoding = Encoding.base64) {
+        const iv = this.createIV(cipherName);
+        const result = {};
+        const cipher = this.createCipher(cipherName, key, iv);
+        inputStream.pipe(cipher).pipe(outputStream);
+        await once(outputStream, 'finish');
+        result.iv = iv.toString(encoding);
+        if (isCCM(cipherName) || isGCM(cipherName) || isOCB(cipherName)) {
+            result.mac = cipher.getAuthTag().toString(encoding);
+        }
+        return result;
+    }
+    static decrypt(key, content, cipherName, params, inputEncoding = Encoding.base64, 
+    // TODO: replace BufferEncoding with Encoding
+    outputEncoding = 'binary') {
+        const decipher = this.createDecipher(cipherName, key, params.iv, params?.mac);
+        let decrypted = decipher.update(content, inputEncoding, outputEncoding);
+        decrypted += decipher.final(outputEncoding);
+        return decrypted;
+    }
+    static async decryptStream(key, inputStream, outputStream, cipherName, params) {
+        const decipher = this.createDecipher(cipherName, key, params.iv, params.mac);
+        inputStream.pipe(decipher).pipe(outputStream);
+        await once(outputStream, 'finish');
+    }
+    static createHashFromBuffer(data, algorithm, encoding = Encoding.base64) {
+        const hash = createHash(algorithm);
+        hash.update(data);
+        return {
+            algo: algorithm,
+            encoding,
+            hash: hash.digest(encoding),
+        };
+    }
+    static createHashFromStream(inputStream, algorithm, encoding = Encoding.base64) {
+        const hash = createHash(algorithm);
+        return new Promise((resolve) => {
+            hash.on('finish', () => {
+                resolve({
+                    algo: algorithm,
+                    encoding,
+                    hash: hash.digest(encoding),
+                });
+            });
+            inputStream.pipe(hash);
+        });
+    }
+}
+export default NativeCrypto;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/nodejs/RSA-Hybrid.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+import { Encryption, RSAHybridEncryption } from '@super-protocol/dto-js';
+import { KeyObject } from 'crypto';
+declare class RSAHybrid {
+    static getKeyFingerprint(key: KeyObject): string;
+    private static publicEncrypt;
+    private static privateDecrypt;
+    static encrypt(content: string, encryption: Encryption): RSAHybridEncryption;
+    static encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<RSAHybridEncryption>;
+    static decrypt(encryption: RSAHybridEncryption): string;
+    static decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: RSAHybridEncryption): Promise<void>;
+}
+export default RSAHybrid;

package/dist/mjs/crypto/nodejs/RSA-Hybrid.js

@@ -0,0 +1,89 @@
+import { Cipher, CryptoAlgorithm, } from '@super-protocol/dto-js';
+import { createPublicKey, createPrivateKey, createHash, constants as CryptoConstants, publicEncrypt, privateDecrypt, randomBytes, } from 'crypto';
+import NativeCrypto from './NativeCrypto.js';
+class RSAHybrid {
+    static getKeyFingerprint(key) {
+        const jsonKey = key.export({ format: 'jwk' });
+        const buffer = Buffer.concat([
+            Buffer.from('ssh-rsa'),
+            Buffer.from(jsonKey.e || ''),
+            Buffer.from(jsonKey.n || ''),
+        ]);
+        const hex = createHash('md5').update(buffer).digest('hex');
+        return hex.match(/.{2}/g).join(':');
+    }
+    static publicEncrypt(rsaKey, aesKey) {
+        const publicKey = createPublicKey({
+            key: rsaKey,
+            format: 'pem',
+        });
+        const encryptedKey = publicEncrypt({
+            key: publicKey,
+            padding: CryptoConstants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: 'sha256',
+        }, Buffer.from(aesKey));
+        const keyFingerprint = this.getKeyFingerprint(publicKey);
+        return {
+            [keyFingerprint]: encryptedKey.toString('base64'),
+        };
+    }
+    static privateDecrypt(rsaKey, keys) {
+        const privateKey = createPrivateKey({
+            key: rsaKey,
+            format: 'pem',
+        });
+        const keyFingerprint = this.getKeyFingerprint(privateKey);
+        const encryptedKey = keys[keyFingerprint];
+        const aesKey = privateDecrypt({
+            key: privateKey,
+            padding: CryptoConstants.RSA_PKCS1_OAEP_PADDING,
+            oaepHash: 'sha256',
+        }, Buffer.from(encryptedKey, 'base64'));
+        return aesKey;
+    }
+    static encrypt(content, encryption) {
+        const aesKey = randomBytes(32);
+        const keys = this.publicEncrypt(encryption.key, aesKey);
+        const encrypted = NativeCrypto.encrypt(aesKey, content, Cipher.AES_256_GCM, encryption.encoding);
+        return {
+            ...encrypted,
+            encoding: encryption.encoding,
+            algo: CryptoAlgorithm.RSAHybrid,
+            cipher: Cipher.RSA_OAEP_AES_GCM,
+            keys: JSON.stringify(keys),
+        };
+    }
+    static async encryptStream(inputStream, outputStream, encryption) {
+        const aesKey = randomBytes(32);
+        const keys = this.publicEncrypt(encryption.key, aesKey);
+        const encrypted = (await NativeCrypto.encryptStream(aesKey, inputStream, outputStream, Cipher.AES_256_GCM, encryption.encoding));
+        return {
+            ...encrypted,
+            encoding: encryption.encoding,
+            algo: CryptoAlgorithm.RSAHybrid,
+            cipher: Cipher.RSA_OAEP_AES_GCM,
+            keys: JSON.stringify(keys),
+        };
+    }
+    static decrypt(encryption) {
+        const iv = Buffer.from(encryption.iv, encryption.encoding);
+        const mac = Buffer.from(encryption.mac, encryption.encoding);
+        const aesKey = this.privateDecrypt(encryption.key, JSON.parse(encryption.keys));
+        const decrypted = NativeCrypto.decrypt(aesKey, encryption.ciphertext, Cipher.AES_256_GCM, {
+            iv,
+            mac,
+        }, encryption.encoding);
+        return decrypted;
+    }
+    static async decryptStream(inputStream, outputStream, encryption) {
+        const iv = Buffer.from(encryption.iv, encryption.encoding);
+        const mac = Buffer.from(encryption.mac, encryption.encoding);
+        const aesKey = this.privateDecrypt(encryption.key, JSON.parse(encryption.keys));
+        await NativeCrypto.decryptStream(aesKey, inputStream, outputStream, Cipher.AES_256_GCM, {
+            iv,
+            mac,
+        });
+    }
+}
+export default RSAHybrid;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/types.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { CryptoAlgorithm } from '@super-protocol/dto-js';
+import { KeyObject } from 'crypto';
+export type AsymmetricKeys = {
+    publicKey: KeyObject;
+    privateKey: KeyObject;
+};
+export type SymmetricKey = Buffer;
+export type CryptoKeyType<T extends CryptoAlgorithm> = T extends CryptoAlgorithm.ECIES ? AsymmetricKeys : T extends CryptoAlgorithm.AES ? SymmetricKey : never;

package/dist/mjs/crypto/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL3R5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIifQ==

package/dist/mjs/crypto/utils.d.ts

@@ -0,0 +1,15 @@
+import { DirHash, FileInfo } from '@super-protocol/dto-js';
+/**
+ * Here would be better to check cipher type using
+ * ```
+ * getCipherInfo(cipher)!.mode === 'mode'
+ * ```
+ * but it doesn't work in browser
+ */
+export declare const isCCM: (cipher: string) => boolean;
+export declare const isGCM: (cipher: string) => boolean;
+export declare const isOCB: (cipher: string) => boolean;
+export declare const isECB: (cipher: string) => boolean;
+export declare const isRC4: (cipher: string) => boolean;
+export declare const isAuthTagRequired: (cipherName: string) => boolean;
+export declare const getDirHashFileContents: (files: Record<string, FileInfo>) => Promise<DirHash>;

package/dist/mjs/crypto/utils.js

@@ -0,0 +1,81 @@
+import { Encoding, HashAlgorithm } from '@super-protocol/dto-js';
+import Crypto from './Crypto.js';
+/**
+ * Here would be better to check cipher type using
+ * ```
+ * getCipherInfo(cipher)!.mode === 'mode'
+ * ```
+ * but it doesn't work in browser
+ */
+export const isCCM = (cipher) => /ccm/i.test(cipher) || cipher === 'chacha20-poly1305';
+export const isGCM = (cipher) => /gcm/i.test(cipher);
+export const isOCB = (cipher) => /ocb/i.test(cipher);
+export const isECB = (cipher) => /ecb/i.test(cipher) || cipher === 'des-ede' || cipher === 'des-ede3';
+export const isRC4 = (cipher) => /^rc4/i.test(cipher);
+export const isAuthTagRequired = (cipherName) => {
+    return isCCM(cipherName) || isGCM(cipherName) || isOCB(cipherName);
+};
+export const getDirHashFileContents = async (files) => {
+    const sortedFiles = Object.entries(files).map(([path, info]) => {
+        if (path.length === 0) {
+            throw new Error('Filename cannot be empty');
+        }
+        const subResult = {
+            filename: path,
+            encoding: typeof info.hash === 'string' ? Encoding.hex : info.hash.encoding,
+            size: info.size,
+            is_prefix: info.is_prefix,
+        };
+        if (typeof info.hash === 'string') {
+            const match = info.hash.match(/^([^:]+):(.+)$/);
+            if (match?.length !== 3) {
+                throw new Error(`Invalid hash format for filename ${path}: ${info.hash}`);
+            }
+            return {
+                ...subResult,
+                algo: match[1],
+                hash: match[2],
+                encodedHash: info.hash,
+            };
+        }
+        const hashHex = Buffer.from(info.hash.hash, info.hash.encoding).toString(Encoding.hex);
+        return {
+            ...subResult,
+            algo: info.hash.algo,
+            hash: info.hash.hash,
+            encodedHash: `${info.hash.algo}:${hashHex}`,
+        };
+    });
+    let buffer = Buffer.alloc(0);
+    let totalSize = 0;
+    sortedFiles.sort((a, b) => preparedValue(a).localeCompare(preparedValue(b)));
+    sortedFiles.forEach((info) => {
+        buffer = Buffer.concat([
+            buffer,
+            Buffer.from(info.filename, 'utf-8'),
+            Buffer.from(info.hash, info.encoding),
+        ]);
+        totalSize += info.size;
+    });
+    const rootHash = await Crypto.createHash(buffer, {
+        algo: HashAlgorithm.SHA256,
+        encoding: Encoding.hex,
+    });
+    return {
+        entries: Object.fromEntries(sortedFiles.map((info) => {
+            return [
+                info.filename,
+                {
+                    hash: info.encodedHash,
+                    size: info.size,
+                    is_prefix: info.is_prefix || false,
+                },
+            ];
+        })),
+        hash: `${rootHash.algo}:${rootHash.hash}`,
+        size: totalSize,
+        version: 1,
+    };
+};
+const preparedValue = (value) => `${value.hash}:${value.filename}`;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/utils.spec.d.ts

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

package/dist/mjs/crypto/utils.spec.js

@@ -0,0 +1,219 @@
+import { getDirHashFileContents } from './utils.js';
+import { Encoding, HashAlgorithm } from '@super-protocol/dto-js';
+describe('getDirHashFileContents', () => {
+    it('should correctly process mixed hash formats and return expected structure', async () => {
+        const input = {
+            'readme.md': {
+                hash: 'sha256:9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08',
+                size: 1,
+                is_prefix: false,
+            },
+            'test1.gguf': {
+                hash: 'sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                size: 2,
+                is_prefix: false,
+            },
+            'test2.gguf': {
+                hash: {
+                    algo: HashAlgorithm.SHA256,
+                    hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                    encoding: Encoding.hex,
+                },
+                size: 4,
+            },
+            'test3.gguf': {
+                hash: {
+                    algo: HashAlgorithm.SHA256,
+                    hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                    encoding: Encoding.hex,
+                },
+                size: 3,
+            },
+        };
+        const expectedOutput = {
+            entries: {
+                'readme.md': {
+                    hash: input['readme.md'].hash,
+                    size: input['readme.md'].size,
+                    is_prefix: false,
+                },
+                'test1.gguf': {
+                    hash: input['test1.gguf'].hash,
+                    size: input['test1.gguf'].size,
+                    is_prefix: false,
+                },
+                'test2.gguf': {
+                    hash: `${input['test2.gguf'].hash.algo}:${input['test2.gguf'].hash.hash}`,
+                    size: input['test2.gguf'].size,
+                    is_prefix: false,
+                },
+                'test3.gguf': {
+                    hash: `${input['test3.gguf'].hash.algo}:${input['test3.gguf'].hash.hash}`,
+                    size: input['test3.gguf'].size,
+                    is_prefix: false,
+                },
+            },
+            hash: 'sha256:c28c1da5dcdfd82a6f05c9faa813fea7a7664d44c7721123e24507655f32d2c4',
+            version: 1,
+            size: Object.values(input).reduce((acc, cur) => {
+                return acc + cur.size;
+            }, 0),
+        };
+        const result = await getDirHashFileContents(input);
+        expect(result).toEqual(expectedOutput);
+        expect(Object.keys(result.entries).length).toBe(4);
+        Object.values(result.entries).forEach((item) => {
+            expect(item.hash).toMatch(/^sha256:[a-f0-9]{64}$/);
+            expect(item.size).toBeGreaterThanOrEqual(0);
+            expect(item.is_prefix).toBeDefined();
+        });
+        const sortedHashes = Object.values(result.entries).sort();
+        expect(Object.values(result.entries)).toEqual(sortedHashes);
+    });
+    it('use .dirhashes as input which was getting after execution ./spctl files upload command', async () => {
+        const inputRaw = {
+            hash: 'sha256:e11c89b85cce479c7aa1d54f033416b05ae260aef8759fa63f7a08888cacda5e',
+            size: 315747,
+            entries: {
+                'stg-95-text-gen-webui.configuration.json': {
+                    hash: 'sha256:72e4cc706580e622422cbaf6e5cfe186501d6fe1667c5dc901dac862f7824ed7',
+                    size: 47326,
+                    is_prefix: false,
+                },
+                'input-model-test.json': {
+                    hash: 'sha256:173e589350533bf41548487594c593b03e747280ca11b98f3d2ab6ac4cecc9cc',
+                    size: 4263,
+                    is_prefix: false,
+                },
+                'stg-96-comfy-ui.configuration.json': {
+                    hash: 'sha256:69398bf33df2e7884ad605e0d02a827ef47e3b73d75bd145318714b0437b9200',
+                    size: 13052,
+                    is_prefix: false,
+                },
+                'testnet-57-solution-comfyui.configuration.json': {
+                    hash: 'sha256:8a3504f6d19a5ce7db351f142532d7828a90b8c2c74b4734128641b387a6b72d',
+                    size: 10797,
+                    is_prefix: false,
+                },
+                'input-model-test2.json': {
+                    hash: 'sha256:bc622b87205f0ed76a6d2133a163d4e0b6a7768ba14370fc569a1da40f90b9ec',
+                    size: 4468,
+                    is_prefix: false,
+                },
+                'testnet-57-solution-comfyui-origin.configuration.json': {
+                    hash: 'sha256:1ef8bc1d5704e62ab0af29348713f3a5031238f2ce4208df842a4231979901c1',
+                    size: 10796,
+                    is_prefix: false,
+                },
+                'input-model-test4.json': {
+                    hash: 'sha256:d3d738eb08571430e7013a05c3b71b827663edd611a76a20dba1428d47d71c4b',
+                    size: 4639,
+                    is_prefix: false,
+                },
+                'input-test.json': {
+                    hash: 'sha256:6382aeeedc6009a0ffdeba8ad4d7c26327cdf2526804604906b3df79a324e79d',
+                    size: 4246,
+                    is_prefix: false,
+                },
+                'stg-53-solution.configuration.json': {
+                    hash: 'sha256:f62c975536328c55135ccc6713ea20dae41c08adc6acb75dda8a757ccd9caeaa',
+                    size: 1056,
+                    is_prefix: false,
+                },
+                'input-model-test3.json': {
+                    hash: 'sha256:579864e52b017bebb6f9a5669ab01d3adcf569f82cc4fdcfddcf92a3224ede44',
+                    size: 4470,
+                    is_prefix: false,
+                },
+                'stg-95-text-gen-webui-origin.configuration.json': {
+                    hash: 'sha256:8ec037c664c3f54bcd97caa35147a3c6437ad2170dcf270b1fc1d1f6eb087d8a',
+                    size: 47023,
+                    is_prefix: false,
+                },
+                'testnet-56-solution-origin-tgwui.configuration.json': {
+                    hash: 'sha256:65d925a45dba7b7ab80fb98229c21658b880902872fcf4c000d732a9df40875c',
+                    size: 47016,
+                    is_prefix: false,
+                },
+                'testnet-73-solution-tgwui-cpu.configuration.json': {
+                    hash: 'sha256:d4ff54980b745663d8d7cc80bdba25fd0bb8bc39d2d3f6861de3b33a7577bdf8',
+                    size: 47319,
+                    is_prefix: false,
+                },
+                'testnet-72-solution-comfyui-cpu.configuration.json': {
+                    hash: 'sha256:ec4a67e487474b4842f8dd1d43226344e8a447e0ab4de0299c08eff089722e79',
+                    size: 10689,
+                    is_prefix: false,
+                },
+                'stg-96-comfy-ui-origin.configuration.json': {
+                    hash: 'sha256:3a4ad890d48b25d4a6afd9ebb7de6255a49c90313b50b2d4fc7325046b696307',
+                    size: 11268,
+                    is_prefix: false,
+                },
+                'testnet-56-solution-tgwui.configuration.json': {
+                    hash: 'sha256:d4ff54980b745663d8d7cc80bdba25fd0bb8bc39d2d3f6861de3b33a7577bdf8',
+                    size: 47319,
+                    is_prefix: false,
+                },
+            },
+            version: 1,
+        };
+        const result = await getDirHashFileContents(inputRaw.entries);
+        expect(result).toEqual(inputRaw);
+    });
+    it('should throw error for invalid hash format', async () => {
+        const invalidInput = {
+            'readme.md': {
+                hash: 'invalid hash format',
+                size: 1,
+            },
+        };
+        await expect(getDirHashFileContents(invalidInput)).rejects.toThrow(`Invalid hash format for filename ${Object.keys(invalidInput)[0]}: ${Object.values(invalidInput)[0].hash}`);
+    });
+    it('should generate expected dirhash with base64 encoding', async () => {
+        const result = await getDirHashFileContents({
+            'Cotype-Nano.Q2_K.gguf': {
+                hash: {
+                    algo: HashAlgorithm.SHA256,
+                    hash: 'B0eyXuCY2B1cxGCgCDj1LScRxDD3gZX9GFCsB+4rQ1M=',
+                    encoding: Encoding.base64,
+                },
+                size: 676304384,
+            },
+        });
+        expect(result).toEqual({
+            hash: 'sha256:9f1ef46bd93481b8c8f7197ab8bf8db129d7675c3f5c1e7acae8cee915f6bf07',
+            size: 676304384,
+            entries: {
+                'Cotype-Nano.Q2_K.gguf': {
+                    hash: 'sha256:0747b25ee098d81d5cc460a00838f52d2711c430f78195fd1850ac07ee2b4353',
+                    size: 676304384,
+                    is_prefix: false,
+                },
+            },
+            version: 1,
+        });
+    });
+    it('should consider is_prefix flag if it is passed', async () => {
+        const result = await getDirHashFileContents({
+            folder: {
+                hash: 'sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                size: 1,
+                is_prefix: true,
+            },
+        });
+        expect(result).toEqual({
+            hash: 'sha256:240dcd016ecf6156c888533e70b988656f3df000f614bb669f5a991baa45e166',
+            size: 1,
+            entries: {
+                folder: {
+                    hash: 'sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855',
+                    size: 1,
+                    is_prefix: true,
+                },
+            },
+            version: 1,
+        });
+    });
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/errors/base.error.d.ts

@@ -0,0 +1,3 @@
+export declare class BaseError extends Error {
+    constructor(error: unknown);
+}

package/dist/mjs/errors/base.error.js

@@ -0,0 +1,15 @@
+import { getErrorMessage } from './utils.js';
+export class BaseError extends Error {
+    constructor(error) {
+        const message = getErrorMessage(error);
+        super(message);
+        Object.setPrototypeOf(this, new.target.prototype);
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        else {
+            throw new Error('captureStackTrace does not exist');
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYmFzZS5lcnJvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3NyYy9lcnJvcnMvYmFzZS5lcnJvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0sWUFBWSxDQUFDO0FBRTdDLE1BQU0sT0FBTyxTQUFVLFNBQVEsS0FBSztJQUNsQyxZQUFZLEtBQWM7UUFDeEIsTUFBTSxPQUFPLEdBQUcsZUFBZSxDQUFDLEtBQUssQ0FBQyxDQUFDO1FBQ3ZDLEtBQUssQ0FBQyxPQUFPLENBQUMsQ0FBQztRQUNmLE1BQU0sQ0FBQyxjQUFjLENBQUMsSUFBSSxFQUFFLEdBQUcsQ0FBQyxNQUFNLENBQUMsU0FBUyxDQUFDLENBQUM7UUFDbEQsSUFBSSxLQUFLLENBQUMsaUJBQWlCLEVBQUUsQ0FBQztZQUM1QixLQUFLLENBQUMsaUJBQWlCLENBQUMsSUFBSSxFQUFFLElBQUksQ0FBQyxXQUFXLENBQUMsQ0FBQztRQUNsRCxDQUFDO2FBQU0sQ0FBQztZQUNOLE1BQU0sSUFBSSxLQUFLLENBQUMsa0NBQWtDLENBQUMsQ0FBQztRQUN0RCxDQUFDO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist/mjs/errors/index.d.ts

@@ -0,0 +1,3 @@
+export { BaseError } from './base.error.js';
+export { NotFoundError } from './not-found.error.js';
+export { InsufficientFundsError, InsufficientFundsDetails } from './insufficient-funds.error.js';