@human-protocol/sdk 6.1.0 → 7.0.0

package/CHANGELOG.md

@@ -1,5 +1,26 @@
 # @human-protocol/sdk
 
+## 7.0.0
+
+### Major Changes
+
+- a7ab394: Updated KV Store utils in sdk to return empty string in case no value in subgraph instead of throwing and error
+- a7ab394: Updated escrow contracts and SDKs to fetch oracle fees from `KVStore` instead of passing fee values during escrow setup. `Escrow.setup(...)` and factory setup flows no longer accept fee arguments, escrow deployments now require a `KVStore` address, and fee validation is enforced on-chain from `KVStore` values, including per-oracle and total fee limits. Added upgrade-safe `EscrowFactory` support for storing and updating the `KVStore` address.
+
+  Updated TypeScript and Python SDK escrow setup APIs to match the new contract signatures by removing fee arguments from `setup(...)` and create-and-setup helpers. Existing config fee fields remain optional for backward compatibility but are ignored by setup calls.
+
+  Updated SDKs to use a dedicated HMT stats subgraph endpoint for HMT statistics methods and removed `totalAmountPaid` and `averageAmountPerWorker` from `IDailyPayment`.
+
+### Minor Changes
+
+- a31cfc8: Added typed subgraph errors (SubgraphRequestError, SubgraphBadIndexerError) and wrapped subgraph request failures with these classes
+
+### Patch Changes
+
+- c50fc7e: Split combined domain files into module folders with explicit files per responsibility.
+- Updated dependencies [a7ab394]
+  - @human-protocol/core@6.0.0
+
 ## 6.1.0
 
 ### Minor Changes

package/dist/constants.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAE7D,eAAO,MAAM,gBAAgB,cAAc,CAAC;AAE5C,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,oBAAY,UAAU;IACpB,EAAE,MAAM;IACR,OAAO,MAAM;IACb,WAAW,MAAM;IACjB,YAAY,MAAM;IAClB,gBAAgB,MAAM;IACtB,SAAS,MAAM;IACf,SAAS,MAAM;IACf,qBAAqB,MAAM;CAC5B;AAED,eAAO,MAAM,QAAQ,EAAE;KACpB,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,WAAW;CA2GnC,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAC;AAEF,eAAO,MAAM,IAAI;;;;;CAKhB,CAAC;AAEF,eAAO,MAAM,4BAA4B,KAAK,CAAC"}
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../src/constants.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,SAAS,CAAC;AAClC,OAAO,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAEtC,eAAO,MAAM,qBAAqB,0BAA0B,CAAC;AAE7D,eAAO,MAAM,gBAAgB,cAAc,CAAC;AAE5C,eAAO,MAAM,cAAc,OAAO,CAAC;AAEnC,eAAO,MAAM,YAAY,OAAO,CAAC;AAEjC,eAAO,MAAM,eAAe,QAAQ,CAAC;AAErC,oBAAY,UAAU;IACpB,EAAE,MAAM;IACR,OAAO,MAAM;IACb,WAAW,MAAM;IACjB,YAAY,MAAM;IAClB,gBAAgB,MAAM;IACtB,SAAS,MAAM;IACf,SAAS,MAAM;IACf,qBAAqB,MAAM;CAC5B;AAED,eAAO,MAAM,QAAQ,EAAE;KACpB,OAAO,IAAI,OAAO,CAAC,CAAC,EAAE,WAAW;CAmInC,CAAC;AAEF,eAAO,MAAM,WAAW;;;;;;;;;;;;;CAavB,CAAC;AAEF,eAAO,MAAM,IAAI;;;;;CAKhB,CAAC;AAEF,eAAO,MAAM,4BAA4B,KAAK,CAAC"}

package/dist/constants.js

@@ -27,10 +27,12 @@ exports.NETWORKS = {
         hmtAddress: '0xd1ba9BAC957322D6e8c07a160a3A8dA11A0d2867',
         stakingAddress: '0xEf6Da3aB52c33925Be3F84038193a7e1331F51E6',
         kvstoreAddress: '0xB6d36B1CDaD50302BCB3DB43bAb0D349458e1b8D',
-        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/ethereum/version/latest',
-        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmNhLQEfBJQ46fngBh4YCttk8kNkveFy5uvAeUmyAdX1kD',
+        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/human-ethereum/version/latest',
+        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmQZ3yL1FzydDwaB56ozgTiBESciTNFsMLyTBfHXzNd1gg',
         oldSubgraphUrl: '',
         oldFactoryAddress: '',
+        hmtSubgraphUrl: 'https://api.studio.thegraph.com/query/74256/hmt-stats-ethereum/version/latest',
+        hmtSubgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmdcTW7XhgULq5yJZGA65mjTwQogdyzLJaZ69ttDJz5JeE',
     },
     [enums_1.ChainId.SEPOLIA]: {
         chainId: enums_1.ChainId.SEPOLIA,
@@ -40,10 +42,12 @@ exports.NETWORKS = {
         hmtAddress: '0x792abbcC99c01dbDec49c9fa9A828a186Da45C33',
         stakingAddress: '0x2163e3A40032Af1C359ac731deaB48258b317890',
         kvstoreAddress: '0xCc0AF0635aa19fE799B6aFDBe28fcFAeA7f00a60',
-        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/sepolia/version/latest',
-        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmQghdr7hxqrjFde8DN15TzfrJLCfwvzmUH9RzWwH1mKzk',
+        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/human-sepolia/version/latest',
+        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmQEbyGSf8VG9pdskowsK6C977wkcyJSxw9q6EDctKEkUw',
         oldSubgraphUrl: '',
         oldFactoryAddress: '',
+        hmtSubgraphUrl: 'https://api.studio.thegraph.com/query/74256/hmt-stats-sepolia/version/latest',
+        hmtSubgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmYkPnYxbZ5ZTtKz7PTyxh6x5sK2H6yzx6vXDCrErpa9gB',
     },
     [enums_1.ChainId.BSC_MAINNET]: {
         chainId: enums_1.ChainId.BSC_MAINNET,
@@ -53,10 +57,12 @@ exports.NETWORKS = {
         hmtAddress: '0x711Fd6ab6d65A98904522d4e3586F492B989c527',
         stakingAddress: '0xE24e5C08E28331D24758b69A5E9f383D2bDD1c98',
         kvstoreAddress: '0x21A0C4CED7aE447fCf87D9FE3A29FA9B3AB20Ff1',
-        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/bsc/version/latest',
-        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmTioC9Z1HzKSCnEKL3BP9iHqbgZt1ceLU2VE4Mv6sxNkd',
+        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/human-bsc/version/latest',
+        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmV3nZUM51NGt7F8RpZP9GxKPpKox3F24iJ8H1ekPb6ha4',
         oldSubgraphUrl: 'https://api.thegraph.com/subgraphs/name/humanprotocol/bsc',
         oldFactoryAddress: '0xc88bC422cAAb2ac8812de03176402dbcA09533f4',
+        hmtSubgraphUrl: 'https://api.studio.thegraph.com/query/74256/hmt-stats-bsc/version/latest',
+        hmtSubgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmUnHgNShyv45S2dQ21W9jLvRA8xWT6XfeuP25fXJoNoEa',
     },
     [enums_1.ChainId.BSC_TESTNET]: {
         chainId: enums_1.ChainId.BSC_TESTNET,
@@ -66,10 +72,12 @@ exports.NETWORKS = {
         hmtAddress: '0xE3D74BBFa45B4bCa69FF28891fBE392f4B4d4e4d',
         stakingAddress: '0xD6D347ba6987519B4e42EcED43dF98eFf5465a23',
         kvstoreAddress: '0x32e27177BA6Ea91cf28dfd91a0Da9822A4b74EcF',
-        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/bsc-testnet/version/latest',
-        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmPyUYRjAvzDdeenXMGHcCRD2v4qwZbKMEkVkY3Jq6VLwn',
+        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/human-bsc-testnet/version/latest',
+        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmdQJog9vMghK2o39U9YJL8vpU9VZnkJa7jGg7wnsod7qV',
         oldSubgraphUrl: 'https://api.thegraph.com/subgraphs/name/humanprotocol/bsctest',
         oldFactoryAddress: '0xaae6a2646c1f88763e62e0cd08ad050ea66ac46f',
+        hmtSubgraphUrl: 'https://api.studio.thegraph.com/query/74256/hmt-stats-bsc-testnet/version/latest',
+        hmtSubgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmPMRbrXKp7a1i5x27dzBHbomxqKYDg5eU3djv1DXB5heq',
     },
     [enums_1.ChainId.POLYGON]: {
         chainId: enums_1.ChainId.POLYGON,
@@ -79,10 +87,12 @@ exports.NETWORKS = {
         hmtAddress: '0xc748B2A084F8eFc47E086ccdDD9b7e67aEb571BF',
         stakingAddress: '0x01D115E9E8bF0C58318793624CC662a030D07F1D',
         kvstoreAddress: '0xbcB28672F826a50B03EE91B28145EAbddA73B2eD',
-        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/polygon/version/latest',
-        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmQNkWNE5FPtqbtSkdtR6AEBJz9N7WDz1X7pfvQqYAcUZJ',
+        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/human-polygon/version/latest',
+        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmSu7B48kgGgMgXaD6Yb4fXjbnsJNmobKAU9qZgescZXid',
         oldSubgraphUrl: 'https://api.thegraph.com/subgraphs/name/humanprotocol/polygon',
         oldFactoryAddress: '0x45eBc3eAE6DA485097054ae10BA1A0f8e8c7f794',
+        hmtSubgraphUrl: 'https://api.studio.thegraph.com/query/74256/hmt-stats-polygon/version/latest',
+        hmtSubgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmcTTTq2reYDBP5j5P2eToc5FmYbJ5ZSMhPaRB6NLriNjR',
     },
     [enums_1.ChainId.POLYGON_AMOY]: {
         chainId: enums_1.ChainId.POLYGON_AMOY,
@@ -92,19 +102,21 @@ exports.NETWORKS = {
         hmtAddress: '0x792abbcC99c01dbDec49c9fa9A828a186Da45C33',
         stakingAddress: '0xffE496683F842a923110415b7278ded3F265f2C5',
         kvstoreAddress: '0x724AeFC243EdacCA27EAB86D3ec5a76Af4436Fc7',
-        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/amoy/version/latest',
-        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmcLwLMw3UzCSbNbjegrpNu6PB3kAd67xquuyaVWvc5Q7Q',
+        subgraphUrl: 'https://api.studio.thegraph.com/query/74256/human-amoy/version/latest',
+        subgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmRx5WSi7o9FtENWnE5eEz8Dr7kYUazk4TNPRt65UZkKkB',
         oldSubgraphUrl: '',
         oldFactoryAddress: '',
+        hmtSubgraphUrl: 'https://api.studio.thegraph.com/query/74256/hmt-stats-amoy/version/latest',
+        hmtSubgraphUrlApiKey: 'https://gateway.thegraph.com/api/deployments/id/QmZze6UWMJna8dQ183TVounSfGwc9C36RgQCGWhFzgrW3y',
     },
     [enums_1.ChainId.LOCALHOST]: {
         chainId: enums_1.ChainId.LOCALHOST,
         title: 'Localhost',
         scanUrl: '',
-        factoryAddress: '0xCf7Ed3AccA5a467e9e704C703E8D87F634fB0Fc9',
+        factoryAddress: '0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9',
         hmtAddress: '0x5FbDB2315678afecb367f032d93F642f64180aa3',
         stakingAddress: '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512',
-        kvstoreAddress: '0xDc64a140Aa3E981100a9becA4E685f962f0cF6C9',
+        kvstoreAddress: '0x9fE46736679d2D9a65F0992F2272dE9f3c7fa6e0',
         subgraphUrl: 'http://localhost:8000/subgraphs/name/humanprotocol/localhost',
         subgraphUrlApiKey: '',
         oldSubgraphUrl: '',

package/dist/encryption/encryption.d.ts

@@ -0,0 +1,84 @@
+import * as openpgp from 'openpgp';
+import { MessageDataType } from './types';
+/**
+ * Class for signing and decrypting messages.
+ *
+ * The algorithm includes the implementation of the [PGP encryption algorithm](https://github.com/openpgpjs/openpgpjs) multi-public key encryption on typescript, and uses the vanilla [ed25519](https://en.wikipedia.org/wiki/EdDSA#Ed25519) implementation Schnorr signature for signatures and [curve25519](https://en.wikipedia.org/wiki/Curve25519) for encryption. [Learn more](https://wiki.polkadot.network/docs/learn-cryptography).
+ *
+ * To get an instance of this class, initialization is recommended using the static [`build`](/ts/classes/Encryption/#build) method.
+ */
+export declare class Encryption {
+    private privateKey;
+    /**
+     * Constructor for the Encryption class.
+     *
+     * @param privateKey - The private key.
+     */
+    constructor(privateKey: openpgp.PrivateKey);
+    /**
+     * Builds an Encryption instance by decrypting the private key from an encrypted private key and passphrase.
+     *
+     * @param privateKeyArmored - The encrypted private key in armored format.
+     * @param passphrase - The passphrase for the private key (optional).
+     * @returns The Encryption instance.
+     *
+     * @example
+     * ```ts
+     * import { Encryption } from '@human-protocol/sdk';
+     *
+     * const privateKey = 'Armored_priv_key';
+     * const passphrase = 'example_passphrase';
+     * const encryption = await Encryption.build(privateKey, passphrase);
+     * ```
+     */
+    static build(privateKeyArmored: string, passphrase?: string): Promise<Encryption>;
+    /**
+     * This function signs and encrypts a message using the private key used to initialize the client and the specified public keys.
+     *
+     * @param message - Message to sign and encrypt.
+     * @param publicKeys - Array of public keys to use for encryption.
+     * @returns Message signed and encrypted.
+     *
+     * @example
+     * ```ts
+     * const publicKey1 = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+     * const publicKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+     *
+     * const publicKeys = [publicKey1, publicKey2];
+     * const resultMessage = await encryption.signAndEncrypt('message', publicKeys);
+     * console.log('Encrypted message:', resultMessage);
+     * ```
+     */
+    signAndEncrypt(message: MessageDataType, publicKeys: string[]): Promise<string>;
+    /**
+     * This function decrypts messages using the private key. In addition, the public key can be added for signature verification.
+     *
+     * @param message - Message to decrypt.
+     * @param publicKey - Public key used to verify signature if needed (optional).
+     * @returns Message decrypted.
+     * @throws Error If signature could not be verified when public key is provided
+     *
+     * @example
+     * ```ts
+     * const publicKey = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+     *
+     * const resultMessage = await encryption.decrypt('message', publicKey);
+     * console.log('Decrypted message:', resultMessage);
+     * ```
+     */
+    decrypt(message: string, publicKey?: string): Promise<Uint8Array>;
+    /**
+     * This function signs a message using the private key used to initialize the client.
+     *
+     * @param message - Message to sign.
+     * @returns Message signed.
+     *
+     * @example
+     * ```ts
+     * const resultMessage = await encryption.sign('message');
+     * console.log('Signed message:', resultMessage);
+     * ```
+     */
+    sign(message: string): Promise<string>;
+}
+//# sourceMappingURL=encryption.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryption.d.ts","sourceRoot":"","sources":["../../src/encryption/encryption.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,SAAS,CAAC;AACnC,OAAO,EAAyB,eAAe,EAAE,MAAM,SAAS,CAAC;AAEjE;;;;;;GAMG;AACH,qBAAa,UAAU;IACrB,OAAO,CAAC,UAAU,CAAqB;IAEvC;;;;OAIG;gBACS,UAAU,EAAE,OAAO,CAAC,UAAU;IAI1C;;;;;;;;;;;;;;;OAeG;WACiB,KAAK,CACvB,iBAAiB,EAAE,MAAM,EACzB,UAAU,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC;IAkBtB;;;;;;;;;;;;;;;;OAgBG;IACU,cAAc,CACzB,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,MAAM,CAAC;IAkBlB;;;;;;;;;;;;;;;OAeG;IACU,OAAO,CAClB,OAAO,EAAE,MAAM,EACf,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,UAAU,CAAC;IAoCtB;;;;;;;;;;;OAWG;IACU,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;CAYpD"}

package/dist/{encryption.js → encryption/encryption.js}

@@ -33,14 +33,9 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EncryptionUtils = exports.Encryption = void 0;
+exports.Encryption = void 0;
 const openpgp = __importStar(require("openpgp"));
-function makeMessageDataBinary(message) {
-    if (typeof message === 'string') {
-        return Buffer.from(message);
-    }
-    return message;
-}
+const types_1 = require("./types");
 /**
  * Class for signing and decrypting messages.
  *
@@ -106,7 +101,7 @@ class Encryption {
     async signAndEncrypt(message, publicKeys) {
         const pgpPublicKeys = await Promise.all(publicKeys.map((armoredKey) => openpgp.readKey({ armoredKey })));
         const pgpMessage = await openpgp.createMessage({
-            binary: makeMessageDataBinary(message),
+            binary: (0, types_1.makeMessageDataBinary)(message),
         });
         const encrypted = await openpgp.encrypt({
             message: pgpMessage,
@@ -187,156 +182,3 @@ class Encryption {
     }
 }
 exports.Encryption = Encryption;
-/**
- * Utility class for encryption-related operations.
- */
-class EncryptionUtils {
-    /**
-     * This function verifies the signature of a signed message using the public key.
-     *
-     * @param message - Message to verify.
-     * @param publicKey - Public key to verify that the message was signed by a specific source.
-     * @returns True if verified. False if not verified.
-     *
-     * @example
-     * ```ts
-     * import { EncryptionUtils } from '@human-protocol/sdk';
-     *
-     * const publicKey = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
-     * const result = await EncryptionUtils.verify('message', publicKey);
-     * console.log('Verification result:', result);
-     * ```
-     */
-    static async verify(message, publicKey) {
-        const pgpPublicKey = await openpgp.readKey({ armoredKey: publicKey });
-        const signedMessage = await openpgp.readCleartextMessage({
-            cleartextMessage: message,
-        });
-        const verificationResult = await signedMessage.verify([pgpPublicKey]);
-        const { verified } = verificationResult[0];
-        try {
-            return await verified;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * This function gets signed data from a signed message.
-     *
-     * @param message - Message.
-     * @returns Signed data.
-     * @throws Error If data could not be extracted from the message
-     *
-     * @example
-     * ```ts
-     * import { EncryptionUtils } from '@human-protocol/sdk';
-     *
-     * const signedData = await EncryptionUtils.getSignedData('message');
-     * console.log('Signed data:', signedData);
-     * ```
-     */
-    static async getSignedData(message) {
-        const signedMessage = await openpgp.readCleartextMessage({
-            cleartextMessage: message,
-        });
-        try {
-            return signedMessage.getText();
-        }
-        catch (e) {
-            throw new Error('Could not get data: ' + e.message);
-        }
-    }
-    /**
-     * This function generates a key pair for encryption and decryption.
-     *
-     * @param name - Name for the key pair.
-     * @param email - Email for the key pair.
-     * @param passphrase - Passphrase to encrypt the private key (optional, defaults to empty string).
-     * @returns Key pair generated.
-     *
-     * @example
-     * ```ts
-     * import { EncryptionUtils } from '@human-protocol/sdk';
-     *
-     * const name = 'YOUR_NAME';
-     * const email = 'YOUR_EMAIL';
-     * const passphrase = 'YOUR_PASSPHRASE';
-     * const keyPair = await EncryptionUtils.generateKeyPair(name, email, passphrase);
-     * console.log('Public key:', keyPair.publicKey);
-     * ```
-     */
-    static async generateKeyPair(name, email, passphrase = '') {
-        const { privateKey, publicKey, revocationCertificate } = await openpgp.generateKey({
-            type: 'ecc',
-            curve: 'ed25519Legacy',
-            userIDs: [{ name: name, email: email }],
-            passphrase: passphrase,
-            format: 'armored',
-        });
-        return {
-            passphrase: passphrase,
-            privateKey,
-            publicKey,
-            revocationCertificate,
-        };
-    }
-    /**
-     * This function encrypts a message using the specified public keys.
-     *
-     * @param message - Message to encrypt.
-     * @param publicKeys - Array of public keys to use for encryption.
-     * @returns Message encrypted.
-     *
-     * @example
-     * ```ts
-     * import { EncryptionUtils } from '@human-protocol/sdk';
-     *
-     * const publicKey1 = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
-     * const publicKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
-     * const publicKeys = [publicKey1, publicKey2];
-     * const encryptedMessage = await EncryptionUtils.encrypt('message', publicKeys);
-     * console.log('Encrypted message:', encryptedMessage);
-     * ```
-     */
-    static async encrypt(message, publicKeys) {
-        const pgpPublicKeys = await Promise.all(publicKeys.map((armoredKey) => openpgp.readKey({ armoredKey })));
-        const pgpMessage = await openpgp.createMessage({
-            binary: makeMessageDataBinary(message),
-        });
-        const encrypted = await openpgp.encrypt({
-            message: pgpMessage,
-            encryptionKeys: pgpPublicKeys,
-            format: 'armored',
-        });
-        return encrypted;
-    }
-    /**
-     * Verifies if a message appears to be encrypted with OpenPGP.
-     *
-     * @param message - Message to verify.
-     * @returns `true` if the message appears to be encrypted, `false` if not.
-     *
-     * @example
-     * ```ts
-     * import { EncryptionUtils } from '@human-protocol/sdk';
-     *
-     * const message = '-----BEGIN PGP MESSAGE-----...';
-     * const isEncrypted = EncryptionUtils.isEncrypted(message);
-     *
-     * if (isEncrypted) {
-     *   console.log('The message is encrypted with OpenPGP.');
-     * } else {
-     *   console.log('The message is not encrypted with OpenPGP.');
-     * }
-     * ```
-     */
-    static isEncrypted(message) {
-        const startMarker = '-----BEGIN PGP MESSAGE-----';
-        const endMarker = '-----END PGP MESSAGE-----';
-        const hasStartMarker = message.includes(startMarker);
-        const hasEndMarker = message.includes(endMarker);
-        return hasStartMarker && hasEndMarker;
-    }
-}
-exports.EncryptionUtils = EncryptionUtils;

package/dist/encryption/encryption_utils.d.ts

@@ -0,0 +1,101 @@
+import { IKeyPair } from '../interfaces';
+import { MessageDataType } from './types';
+/**
+ * Utility class for encryption-related operations.
+ */
+export declare class EncryptionUtils {
+    /**
+     * This function verifies the signature of a signed message using the public key.
+     *
+     * @param message - Message to verify.
+     * @param publicKey - Public key to verify that the message was signed by a specific source.
+     * @returns True if verified. False if not verified.
+     *
+     * @example
+     * ```ts
+     * import { EncryptionUtils } from '@human-protocol/sdk';
+     *
+     * const publicKey = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+     * const result = await EncryptionUtils.verify('message', publicKey);
+     * console.log('Verification result:', result);
+     * ```
+     */
+    static verify(message: string, publicKey: string): Promise<boolean>;
+    /**
+     * This function gets signed data from a signed message.
+     *
+     * @param message - Message.
+     * @returns Signed data.
+     * @throws Error If data could not be extracted from the message
+     *
+     * @example
+     * ```ts
+     * import { EncryptionUtils } from '@human-protocol/sdk';
+     *
+     * const signedData = await EncryptionUtils.getSignedData('message');
+     * console.log('Signed data:', signedData);
+     * ```
+     */
+    static getSignedData(message: string): Promise<string>;
+    /**
+     * This function generates a key pair for encryption and decryption.
+     *
+     * @param name - Name for the key pair.
+     * @param email - Email for the key pair.
+     * @param passphrase - Passphrase to encrypt the private key (optional, defaults to empty string).
+     * @returns Key pair generated.
+     *
+     * @example
+     * ```ts
+     * import { EncryptionUtils } from '@human-protocol/sdk';
+     *
+     * const name = 'YOUR_NAME';
+     * const email = 'YOUR_EMAIL';
+     * const passphrase = 'YOUR_PASSPHRASE';
+     * const keyPair = await EncryptionUtils.generateKeyPair(name, email, passphrase);
+     * console.log('Public key:', keyPair.publicKey);
+     * ```
+     */
+    static generateKeyPair(name: string, email: string, passphrase?: string): Promise<IKeyPair>;
+    /**
+     * This function encrypts a message using the specified public keys.
+     *
+     * @param message - Message to encrypt.
+     * @param publicKeys - Array of public keys to use for encryption.
+     * @returns Message encrypted.
+     *
+     * @example
+     * ```ts
+     * import { EncryptionUtils } from '@human-protocol/sdk';
+     *
+     * const publicKey1 = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+     * const publicKey2 = '-----BEGIN PGP PUBLIC KEY BLOCK-----...';
+     * const publicKeys = [publicKey1, publicKey2];
+     * const encryptedMessage = await EncryptionUtils.encrypt('message', publicKeys);
+     * console.log('Encrypted message:', encryptedMessage);
+     * ```
+     */
+    static encrypt(message: MessageDataType, publicKeys: string[]): Promise<string>;
+    /**
+     * Verifies if a message appears to be encrypted with OpenPGP.
+     *
+     * @param message - Message to verify.
+     * @returns `true` if the message appears to be encrypted, `false` if not.
+     *
+     * @example
+     * ```ts
+     * import { EncryptionUtils } from '@human-protocol/sdk';
+     *
+     * const message = '-----BEGIN PGP MESSAGE-----...';
+     * const isEncrypted = EncryptionUtils.isEncrypted(message);
+     *
+     * if (isEncrypted) {
+     *   console.log('The message is encrypted with OpenPGP.');
+     * } else {
+     *   console.log('The message is not encrypted with OpenPGP.');
+     * }
+     * ```
+     */
+    static isEncrypted(message: string): boolean;
+}
+//# sourceMappingURL=encryption_utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"encryption_utils.d.ts","sourceRoot":"","sources":["../../src/encryption/encryption_utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACzC,OAAO,EAAyB,eAAe,EAAE,MAAM,SAAS,CAAC;AAEjE;;GAEG;AACH,qBAAa,eAAe;IAC1B;;;;;;;;;;;;;;;OAeG;WACiB,MAAM,CACxB,OAAO,EAAE,MAAM,EACf,SAAS,EAAE,MAAM,GAChB,OAAO,CAAC,OAAO,CAAC;IAgBnB;;;;;;;;;;;;;;OAcG;WACiB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAYnE;;;;;;;;;;;;;;;;;;OAkBG;WACiB,eAAe,CACjC,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,UAAU,SAAK,GACd,OAAO,CAAC,QAAQ,CAAC;IAkBpB;;;;;;;;;;;;;;;;;OAiBG;WACiB,OAAO,CACzB,OAAO,EAAE,eAAe,EACxB,UAAU,EAAE,MAAM,EAAE,GACnB,OAAO,CAAC,MAAM,CAAC;IAiBlB;;;;;;;;;;;;;;;;;;;OAmBG;WACW,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;CASpD"}