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

package/dist/mjs/contracts/typechain-types/hardhat-diamond-abi/HardhatDiamondABI.sol/App.js

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

package/dist/mjs/contracts/typechain-types/hardhat-diamond-abi/HardhatDiamondABI.sol/index.d.ts

@@ -0,0 +1 @@
+export type { App } from "./App.js";

package/dist/mjs/contracts/typechain-types/hardhat-diamond-abi/HardhatDiamondABI.sol/index.js

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

package/dist/mjs/contracts/typechain-types/hardhat-diamond-abi/index.d.ts

@@ -0,0 +1,2 @@
+import type * as hardhatDiamondAbiSol from "./HardhatDiamondABI.sol";
+export type { hardhatDiamondAbiSol };

package/dist/mjs/contracts/typechain-types/hardhat-diamond-abi/index.js

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

package/dist/mjs/contracts/typechain-types/index.d.ts

@@ -0,0 +1,5 @@
+import type * as hardhatDiamondAbi from "./hardhat-diamond-abi/index.js";
+export type { hardhatDiamondAbi };
+export * as factories from "./factories/index.js";
+export type { App } from "./hardhat-diamond-abi/HardhatDiamondABI.sol/App.js";
+export { App__factory } from "./factories/hardhat-diamond-abi/HardhatDiamondABI.sol/App__factory.js";

package/dist/mjs/contracts/typechain-types/index.js

@@ -0,0 +1,7 @@
+// @ts-nocheck
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+export * as factories from "./factories/index.js";
+export { App__factory } from "./factories/hardhat-diamond-abi/HardhatDiamondABI.sol/App__factory.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29udHJhY3RzL3R5cGVjaGFpbi10eXBlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjO0FBQ2QsK0NBQStDO0FBQy9DLG9CQUFvQjtBQUNwQixvQkFBb0I7QUFJcEIsT0FBTyxLQUFLLFNBQVMsTUFBTSxzQkFBc0IsQ0FBQztBQUVsRCxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0sdUVBQXVFLENBQUMifQ==

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

@@ -0,0 +1,70 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { CryptoAlgorithm, Encryption, Hash, EncryptionKey, type Serialized } from '@super-protocol/dto-js';
+import fs from 'fs';
+import { Readable } from 'stream';
+import { BinaryToTextEncoding, KeyObject } from 'crypto';
+import { HashAlgorithm } from '@super-protocol/dto-js';
+import { CryptoKeyType } from './types.js';
+declare class Crypto {
+    /**
+     * Used to encrypt data before sending it to blockchain
+     * @param content - string data to encrypt
+     * @param encryption - encryption info containing the algorithm and key
+     * @returns Encryption - object what contains encrypted data, key and spec to decryption
+     */
+    static encrypt<T = unknown>(content: Serialized<T>, encryption: Encryption): Encryption<Serialized<T>>;
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where the encrypted data will be saved
+     * @param encryption - encryption info containing the algorithm and key
+     * @returns Promise<Encryption> - encryption info
+     */
+    static encryptStream(inputStream: fs.ReadStream, outputStream: fs.WriteStream, encryption: Encryption): Promise<Encryption>;
+    /**
+     * Used to decrypt data from blockchain
+     * @param encryption - object what contains encrypted data, key and spec to decryption
+     * @returns decrypted data
+     */
+    static decrypt<S = unknown, T = Serialized<S>>(encryption: Encryption<T>): T;
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption - encryption info
+     */
+    static decryptStream(inputStream: fs.ReadStream, outputStream: fs.WriteStream, encryption: Encryption): Promise<void>;
+    /**
+     * Create hash from content
+     * @param content - buffer data to create hash from
+     * @param hashInfo - information about hash algorithm and encoding
+     * @returns Hash structure with hash itself hash algorithm and encoding
+     */
+    static createHash(content: Buffer, hashInfo: Omit<Hash, 'hash'>): Promise<Hash>;
+    /**
+     * Create hash from stream
+     * @param inputStream - readable stream
+     * @param hashInfo - information about hash algorithm and encoding
+     * @returns Hash structure with hash itself hash algorithm and encoding
+     */
+    static createHash(inputStream: Readable, hashInfo: Omit<Hash, 'hash'>): Promise<Hash>;
+    static getPublicKey(privateKey: EncryptionKey): EncryptionKey;
+    static generateKeys<T extends CryptoAlgorithm>(algo: T): Promise<CryptoKeyType<T>>;
+    static sign(params: {
+        data: Buffer | string;
+        privateKey: KeyObject;
+        outputFormat?: BinaryToTextEncoding;
+        algo?: HashAlgorithm;
+    }): string;
+    static verify(params: {
+        data: Buffer | string;
+        publicKey: KeyObject;
+        signatureFormat?: BinaryToTextEncoding;
+        algo?: HashAlgorithm;
+        signature: string;
+    }): boolean;
+}
+export default Crypto;

package/dist/mjs/crypto/Crypto.js

@@ -0,0 +1,132 @@
+import { CryptoAlgorithm, } from '@super-protocol/dto-js';
+import AES from './nodejs/AES.js';
+import ARIA from './nodejs/ARIA.js';
+import ECIES from './nodejs/ECIES.js';
+import RSAHybrid from './nodejs/RSA-Hybrid.js';
+import NativeCrypto from './nodejs/NativeCrypto.js';
+import crypto from 'crypto';
+import { HashAlgorithm } from '@super-protocol/dto-js';
+class Crypto {
+    /**
+     * Used to encrypt data before sending it to blockchain
+     * @param content - string data to encrypt
+     * @param encryption - encryption info containing the algorithm and key
+     * @returns Encryption - object what contains encrypted data, key and spec to decryption
+     */
+    static encrypt(content, encryption) {
+        switch (encryption.algo) {
+            case CryptoAlgorithm.AES:
+                return AES.encrypt(content, encryption);
+            case CryptoAlgorithm.ARIA:
+                return ARIA.encrypt(content, encryption);
+            case CryptoAlgorithm.ECIES:
+                return ECIES.encrypt(content, encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return RSAHybrid.encrypt(content, encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where the encrypted data will be saved
+     * @param encryption - encryption info containing the algorithm and key
+     * @returns Promise<Encryption> - encryption info
+     */
+    static async encryptStream(inputStream, outputStream, encryption) {
+        switch (encryption.algo) {
+            case CryptoAlgorithm.AES:
+                return await AES.encryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.ARIA:
+                return await ARIA.encryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return await RSAHybrid.encryptStream(inputStream, outputStream, encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    /**
+     * Used to decrypt data from blockchain
+     * @param encryption - object what contains encrypted data, key and spec to decryption
+     * @returns decrypted data
+     */
+    static decrypt(encryption) {
+        switch (encryption.algo) {
+            case CryptoAlgorithm.AES:
+                return AES.decrypt(encryption);
+            case CryptoAlgorithm.ARIA:
+                return ARIA.decrypt(encryption);
+            case CryptoAlgorithm.ECIES:
+                return ECIES.decrypt(encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return RSAHybrid.decrypt(encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption - encryption info
+     */
+    static async decryptStream(inputStream, outputStream, encryption) {
+        switch (encryption.algo) {
+            case CryptoAlgorithm.AES:
+                return await AES.decryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.ARIA:
+                return await ARIA.decryptStream(inputStream, outputStream, encryption);
+            case CryptoAlgorithm.RSAHybrid:
+                return await RSAHybrid.decryptStream(inputStream, outputStream, encryption);
+            default:
+                throw Error(`${encryption.algo} algorithm not supported`);
+        }
+    }
+    static async createHash(param1, hashInfo) {
+        const { algo, encoding } = hashInfo;
+        return Buffer.isBuffer(param1)
+            ? NativeCrypto.createHashFromBuffer(param1, algo, encoding)
+            : await NativeCrypto.createHashFromStream(param1, algo, encoding);
+    }
+    static getPublicKey(privateKey) {
+        switch (privateKey.algo) {
+            case CryptoAlgorithm.ECIES:
+                return ECIES.getPublicKeyEncryption(privateKey);
+            default:
+                throw Error(`${privateKey.algo} algorithm not supported`);
+        }
+    }
+    static async generateKeys(algo) {
+        switch (algo) {
+            case CryptoAlgorithm.ECIES:
+                return (await ECIES.generateKeys());
+            case CryptoAlgorithm.AES:
+                return AES.generateKeys();
+            default:
+                throw Error(`${algo} algorithm not supported`);
+        }
+    }
+    static sign(params) {
+        const { data, outputFormat = 'base64', algo = HashAlgorithm.SHA256 } = params;
+        if (!params.privateKey) {
+            throw new Error('sign failed, private key is not assigned');
+        }
+        const signer = crypto.createSign(algo);
+        signer.write(data);
+        signer.end();
+        return signer.sign(params.privateKey, outputFormat);
+    }
+    static verify(params) {
+        const { data, signature, signatureFormat = 'base64', algo = HashAlgorithm.SHA256 } = params;
+        if (!params.publicKey) {
+            throw new Error('verify failed, public key is not assigned');
+        }
+        const verifier = crypto.createVerify(algo);
+        verifier.write(data);
+        verifier.end();
+        return verifier.verify(params.publicKey, signature, signatureFormat);
+    }
+}
+export default Crypto;
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,4 @@
+import Crypto from './Crypto.js';
+export default Crypto;
+export * from './types.js';
+export * as cryptoUtils from './utils.js';

package/dist/mjs/crypto/index.js

@@ -0,0 +1,5 @@
+import Crypto from './Crypto.js';
+export default Crypto;
+export * from './types.js';
+export * as cryptoUtils from './utils.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvY3J5cHRvL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sTUFBTSxNQUFNLGFBQWEsQ0FBQztBQUNqQyxlQUFlLE1BQU0sQ0FBQztBQUN0QixjQUFjLFlBQVksQ0FBQztBQUMzQixPQUFPLEtBQUssV0FBVyxNQUFNLFlBQVksQ0FBQyJ9

package/dist/mjs/crypto/nodejs/AES.d.ts

@@ -0,0 +1,25 @@
+/// <reference types="node" />
+import { AESEncryption, Encryption } from '@super-protocol/dto-js';
+import { ReadStream, WriteStream } from 'fs';
+import { SymmetricKey } from '../types.js';
+declare class AES {
+    static encrypt(content: string, encryption: Encryption): AESEncryption;
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param encryption - encryption settings that include algorithm and key
+     * @returns Promise<AESEncryption> - encryption info
+     */
+    static encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<AESEncryption>;
+    static decrypt(encryption: AESEncryption): string;
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption - encryption info
+     */
+    static decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: AESEncryption): Promise<void>;
+    static generateKeys(): SymmetricKey;
+}
+export default AES;

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

@@ -0,0 +1,77 @@
+import { Cipher, CryptoAlgorithm, } from '@super-protocol/dto-js';
+import * as crypto from 'crypto';
+import NativeCrypto from './NativeCrypto.js';
+class AES {
+    static encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || Cipher.AES_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = NativeCrypto.encrypt(keyBuffer, content, encryption.cipher);
+        return {
+            algo: CryptoAlgorithm.AES,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param encryption - encryption settings that include algorithm and key
+     * @returns Promise<AESEncryption> - encryption info
+     */
+    static async encryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || Cipher.AES_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = await NativeCrypto.encryptStream(keyBuffer, inputStream, outputStream, encryption.cipher);
+        return {
+            algo: encryption.algo,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    static decrypt(encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        return NativeCrypto.decrypt(key, encryption.ciphertext, encryption.cipher, params, encryption.encoding);
+    }
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption - encryption info
+     */
+    static async decryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        await NativeCrypto.decryptStream(key, inputStream, outputStream, encryption.cipher, params);
+    }
+    static generateKeys() {
+        return crypto.randomBytes(32);
+    }
+}
+export default AES;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/nodejs/ARIA.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { ARIAEncryption, Encryption } from '@super-protocol/dto-js';
+import { ReadStream, WriteStream } from 'fs';
+declare class ARIA {
+    static encrypt(content: string, encryption: Encryption): ARIAEncryption;
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param encryption - encryption settings that include algorithm and key
+     * @returns Promise<ARIAEncryption> - encryption info
+     */
+    static encryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: Encryption): Promise<ARIAEncryption>;
+    static decrypt(encryption: ARIAEncryption): string;
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption - encryption info
+     */
+    static decryptStream(inputStream: ReadStream, outputStream: WriteStream, encryption: ARIAEncryption): Promise<void>;
+}
+export default ARIA;

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

@@ -0,0 +1,72 @@
+import { CryptoAlgorithm, Cipher, } from '@super-protocol/dto-js';
+import NativeCrypto from './NativeCrypto.js';
+class ARIA {
+    static encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || Cipher.ARIA_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = NativeCrypto.encrypt(keyBuffer, content, encryption.cipher);
+        return {
+            algo: CryptoAlgorithm.ARIA,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            ciphertext: encrypted.ciphertext,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    /**
+     * Encrypts data stream
+     * @param inputStream - path to file that will be encrypted
+     * @param outputStream - place where it will be saved
+     * @param encryption - encryption settings that include algorithm and key
+     * @returns Promise<ARIAEncryption> - encryption info
+     */
+    static async encryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        encryption.cipher = encryption.cipher || Cipher.ARIA_256_GCM;
+        const keyBuffer = Buffer.from(encryption.key, encryption.encoding);
+        const encrypted = await NativeCrypto.encryptStream(keyBuffer, inputStream, outputStream, encryption.cipher);
+        return {
+            algo: CryptoAlgorithm.ARIA,
+            encoding: encryption.encoding,
+            cipher: encryption.cipher,
+            iv: encrypted.iv,
+            mac: encrypted.mac,
+        };
+    }
+    static decrypt(encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        return NativeCrypto.decrypt(key, encryption.ciphertext, encryption.cipher, params, encryption.encoding);
+    }
+    /**
+     * Decrypts data stream
+     * @param inputStream - stream with data to decrypt
+     * @param outputStream - stream where the decrypted data will be written
+     * @param encryption - encryption info
+     */
+    static async decryptStream(inputStream, outputStream, encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const key = Buffer.from(encryption.key, encryption.encoding);
+        const params = {
+            iv: Buffer.from(encryption.iv, encryption.encoding),
+        };
+        if (encryption.mac) {
+            params.mac = Buffer.from(encryption.mac, encryption.encoding);
+        }
+        await NativeCrypto.decryptStream(key, inputStream, outputStream, encryption.cipher, params);
+    }
+}
+export default ARIA;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/nodejs/ECIES.d.ts

@@ -0,0 +1,10 @@
+import { ECIESEncryption, Encryption, EncryptionKey } from '@super-protocol/dto-js';
+import { AsymmetricKeys } from '../types.js';
+declare class ECIES {
+    static encrypt(content: string, encryption: Encryption): ECIESEncryption;
+    static decrypt(encryption: ECIESEncryption): string;
+    static getPublicFromPrivate(privateKey: Pick<EncryptionKey, 'key' | 'encoding'>): string;
+    static getPublicKeyEncryption: (encryption: EncryptionKey) => EncryptionKey;
+    static generateKeys(namedCurve?: string): Promise<AsymmetricKeys>;
+}
+export default ECIES;

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

@@ -0,0 +1,82 @@
+import { CryptoAlgorithm, Encoding, } from '@super-protocol/dto-js';
+import crypto, { generateKeyPair } from 'crypto';
+class ECIES {
+    static encrypt(content, encryption) {
+        if (!encryption.key)
+            throw Error('Encryption key is not provided');
+        const ecdh = crypto.createECDH('secp256k1');
+        ecdh.generateKeys();
+        const epk = ecdh.getPublicKey();
+        const pk = ecdh.computeSecret(Buffer.from(encryption.key, encryption.encoding));
+        const hash = crypto.createHash('sha512').update(pk).digest();
+        const cipherKey = hash.subarray(0, 32), macKey = hash.subarray(32);
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv('aes-256-cbc', cipherKey, iv);
+        let ct = cipher.update(content);
+        ct = Buffer.concat([ct, cipher.final()]);
+        const dataToMac = Buffer.concat([iv, epk, ct]);
+        const mac = crypto.createHmac('sha256', macKey).update(dataToMac).digest();
+        return {
+            iv: iv.toString(encryption.encoding),
+            ephemPublicKey: epk.toString(encryption.encoding),
+            mac: mac.toString(encryption.encoding),
+            encoding: encryption.encoding,
+            algo: CryptoAlgorithm.ECIES,
+            ciphertext: ct.toString(encryption.encoding),
+        };
+    }
+    static decrypt(encryption) {
+        if (!encryption.key)
+            throw Error('Decryption key is not provided');
+        const iv = Buffer.from(encryption.iv, encryption.encoding), epk = Buffer.from(encryption.ephemPublicKey, encryption.encoding), ct = Buffer.from(encryption.ciphertext, encryption.encoding), mac = Buffer.from(encryption.mac, encryption.encoding);
+        const ecdh = crypto.createECDH('secp256k1');
+        ecdh.setPrivateKey(Buffer.from(encryption.key, encryption.encoding));
+        const pk = ecdh.computeSecret(epk);
+        const hash = crypto.createHash('sha512').update(pk).digest();
+        const cipherKey = hash.subarray(0, 32), macKey = hash.subarray(32);
+        const m = crypto
+            .createHmac('sha256', macKey)
+            .update(Buffer.concat([iv, epk, ct]))
+            .digest();
+        if (m.compare(mac) !== 0 || mac.compare(m) !== 0) {
+            throw new Error('Corrupted Ecies body: unmatched authentication code');
+        }
+        const decipher = crypto.createDecipheriv('aes-256-cbc', cipherKey, iv);
+        const pt = decipher.update(ct);
+        const result = Buffer.concat([pt, decipher.final()]);
+        return result.toString('binary');
+    }
+    static getPublicFromPrivate(privateKey) {
+        const ecdh = crypto.createECDH('secp256k1');
+        ecdh.setPrivateKey(Buffer.from(privateKey.key, privateKey.encoding));
+        return ecdh.getPublicKey(privateKey.encoding);
+    }
+    static getPublicKeyEncryption = (encryption) => {
+        if (encryption.algo !== CryptoAlgorithm.ECIES) {
+            throw Error('Only ECIES result encryption is supported');
+        }
+        if (encryption.encoding !== Encoding.base64) {
+            throw new Error('Only base64 result encryption is supported');
+        }
+        if (!encryption.key) {
+            throw new Error('Encryption private key is not provided');
+        }
+        return {
+            algo: encryption.algo,
+            encoding: encryption.encoding,
+            key: this.getPublicFromPrivate(encryption),
+        };
+    };
+    static generateKeys(namedCurve = 'secp256k1') {
+        return new Promise((resolve, reject) => {
+            generateKeyPair('ec', { namedCurve }, (err, publicKey, privateKey) => {
+                if (err) {
+                    return reject(err);
+                }
+                resolve({ publicKey, privateKey });
+            });
+        });
+    }
+}
+export default ECIES;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/mjs/crypto/nodejs/NativeCrypto.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ReadStream, WriteStream } from 'fs';
+import { Cipher, Decipher } from 'crypto';
+import { Readable } from 'stream';
+import { Encoding, EncryptionWithMacIV, Hash, HashAlgorithm } from '@super-protocol/dto-js';
+/**
+ *
+ */
+declare class NativeCrypto {
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.keyLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getKeyLength(cipher: string): number;
+    /**
+     * Here would be better to check cipher type using
+     * ```
+     * getCipherInfo(cipher)!.ivLength
+     * ```
+     * but it doesn't work in browser
+     */
+    static getIVLength(cipher: string): number;
+    static createKey(cipher: string): Buffer;
+    static createIV(cipher: string): Buffer;
+    static createCipher(cipher: string, key: Buffer, iv: Buffer): Cipher;
+    static createDecipher(cipher: string, key: Buffer, iv: Buffer, mac?: Buffer): Decipher;
+    static encrypt(key: Buffer, content: string, cipherName: string, outputEncoding?: Encoding, inputEncoding?: BufferEncoding): Partial<EncryptionWithMacIV>;
+    static encryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: string, encoding?: Encoding): Promise<Partial<EncryptionWithMacIV>>;
+    static decrypt(key: Buffer, content: string, cipherName: string, params: {
+        iv: Buffer;
+        mac?: Buffer;
+    }, inputEncoding?: Encoding, outputEncoding?: BufferEncoding): string;
+    static decryptStream(key: Buffer, inputStream: ReadStream, outputStream: WriteStream, cipherName: string, params: {
+        iv: Buffer;
+        mac?: Buffer;
+    }): Promise<void>;
+    static createHashFromBuffer(data: Buffer, algorithm: HashAlgorithm, encoding?: Encoding): Hash;
+    static createHashFromStream(inputStream: Readable, algorithm: HashAlgorithm, encoding?: Encoding): Promise<Hash>;
+}
+export default NativeCrypto;