@ssv-labs/ssv-sdk 0.0.5 → 0.1.0

package/dist/libs/operator/methods.d.ts

@@ -7,7 +7,7 @@ type WithdrawArgs = SmartFnWriteOptions<{
     amount: bigint;
 }>;
 export declare const withdraw: (config: ConfigReturnType, { args: { operatorId, amount }, ...writeOptions }: WithdrawArgs) => Promise<{
-    hash: `0x${string}`;
+    hash: import('viem').Hash;
     wait: () => Promise<import('viem').TransactionReceipt & {
         events: ({
             eventName: "AdminChanged";
@@ -287,7 +287,7 @@ type RegisterOperatorArgs = SmartFnWriteOptions<{
     publicKey: string;
 }>;
 export declare const registerOperator: (config: ConfigReturnType, { args: { isPrivate, yearlyFee, publicKey }, ...writeOptions }: RegisterOperatorArgs) => Promise<{
-    hash: `0x${string}`;
+    hash: import('viem').Hash;
     wait: () => Promise<import('viem').TransactionReceipt & {
         events: ({
             eventName: "AdminChanged";
@@ -566,7 +566,7 @@ type SetOperatorWhitelistsArgs = SmartFnWriteOptions<{
     contractAddress: Address;
 }>;
 export declare const setOperatorWhitelists: (config: ConfigReturnType, { args: { operatorIds, contractAddress }, ...writeOptions }: SetOperatorWhitelistsArgs) => Promise<{
-    hash: `0x${string}`;
+    hash: import('viem').Hash;
     wait: () => Promise<import('viem').TransactionReceipt & {
         events: ({
             eventName: "AdminChanged";

package/dist/libs/ssv-keys/BLS/index.d.ts

@@ -0,0 +1,2 @@
+import { default as bls } from 'bls-eth-wasm';
+export default bls;

package/dist/libs/ssv-keys/Encryption/Encryption.d.ts

@@ -0,0 +1,7 @@
+import { IEncryptShare, IShares } from '../interfaces';
+export default class Encryption {
+    private readonly operatorPublicKeys;
+    private readonly shares;
+    constructor(operatorPublicKeys: string[], shares: IShares[]);
+    encrypt(): IEncryptShare[];
+}

package/dist/libs/ssv-keys/Encryption/__test__/RsaKeys.d.ts

@@ -0,0 +1,3 @@
+declare const publicKeys: string[];
+declare const privateKeys: string[];
+export { privateKeys, publicKeys, };

package/dist/libs/ssv-keys/Encryption/utils.d.ts

@@ -0,0 +1,55 @@
+import * as forge from 'node-forge';
+/**
+ * Node-forge implementation of JSEncrypt-like functionality
+ * Designed to match JSEncrypt's behavior exactly, including permissive key validation
+ */
+export declare class ForgeEncrypt {
+    private publicKey;
+    private privateKey;
+    constructor();
+    /**
+     * Set the public key (equivalent to JSEncrypt.setPublicKey)
+     * Matches JSEncrypt's permissive behavior - doesn't throw on invalid keys
+     */
+    setPublicKey(publicKeyPem: string): void;
+    /**
+     * Set the private key (equivalent to JSEncrypt.setPrivateKey)
+     * Matches JSEncrypt's permissive behavior - doesn't throw on invalid keys
+     */
+    setPrivateKey(privateKeyPem: string): void;
+    /**
+     * Encrypt data with public key (equivalent to JSEncrypt.encrypt)
+     * Returns base64 encoded encrypted data or false if encryption fails
+     */
+    encrypt(data: string): string | false;
+    /**
+     * Decrypt data with private key (equivalent to JSEncrypt.decrypt)
+     * Expects base64 encoded encrypted data, returns false if decryption fails
+     */
+    decrypt(encryptedData: string): string | false;
+    /**
+     * Get the public key in PEM format
+     */
+    getPublicKey(): string;
+    /**
+     * Get the private key in PEM format
+     */
+    getPrivateKey(): string;
+}
+/**
+ * Validate RSA public key using node-forge (equivalent to JSEncrypt validation)
+ * Note: This function is more strict than JSEncrypt for external validation
+ */
+export declare function validateRsaPublicKey(publicKeyPem: string): boolean;
+/**
+ * Generate a new RSA key pair (for testing purposes)
+ */
+export declare function generateRsaKeyPair(keySize?: number): {
+    publicKey: string;
+    privateKey: string;
+};
+/**
+ * Convert PEM key to node-forge key object
+ */
+export declare function pemToPublicKey(pem: string): forge.pki.rsa.PublicKey;
+export declare function pemToPrivateKey(pem: string): forge.pki.rsa.PrivateKey;

package/dist/libs/ssv-keys/EthereumKeyStore/EthereumKeyStore.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Decrypt private key from key store data
+ * Supports key store versions: v1, v3, v4
+ *
+ * Example of usage (Node env):
+ *
+ *  const keyStoreFilePath = path.join(process.cwd(), 'validator_keys', 'keystore.json');
+ *  const keyStoreString: string = fs.readFileSync(keyStoreFilePath).toString();
+ *  const keyStoreData = JSON.parse(keyStoreString);
+ *  const keyStore = new EthereumKeyStore(keyStoreData);
+ *  const password = 'testtest';
+ *  console.log('Private Key:', await keyStore.getPrivateKey(password));
+ */
+declare class EthereumKeyStore {
+    private readonly keyStoreData;
+    private privateKey;
+    constructor(keyStoreData: any);
+    getPrivateKey(password?: string): Promise<string>;
+    private fromV3;
+    private fromCustomV4;
+    private runCipherBuffer;
+}
+export default EthereumKeyStore;

package/dist/libs/ssv-keys/EthereumKeyStore/index.d.ts

@@ -0,0 +1 @@
+export { default } from './EthereumKeyStore';

package/dist/libs/ssv-keys/KeyShares/KeyShares.d.ts

@@ -0,0 +1,32 @@
+import { KeySharesItem } from './KeySharesItem';
+/**
+ * Represents a collection of KeyShares items with functionality for serialization,
+ * deserialization, and validation.
+ */
+export declare class KeyShares {
+    private shares;
+    constructor(shares?: KeySharesItem[]);
+    /**
+     * Add a single KeyShares item to the collection.
+     * @param keySharesItem The KeyShares item to add.
+     */
+    add(keySharesItem: KeySharesItem): void;
+    list(): KeySharesItem[];
+    /**
+     * Validate the KeyShares instance using class-validator.
+     * @returns The validation result.
+     */
+    validate(): any;
+    /**
+     * Converts the KeyShares instance to a JSON string.
+     * @returns The JSON string representation of the KeyShares instance.
+     */
+    toJson(): string;
+    /**
+     * Initialize the KeyShares instance from JSON or object data.
+     * @param content The JSON string or object to initialize from.
+     * @returns The KeyShares instance.
+     * @throws Error if the version is incompatible or the shares array is invalid.
+     */
+    static fromJson(content: string | any): Promise<KeyShares>;
+}

package/dist/libs/ssv-keys/KeyShares/KeySharesData/KeySharesData.d.ts

@@ -0,0 +1,21 @@
+import { IKeySharesData, IKeySharesPartialData } from '../../interfaces';
+import { OperatorData } from './OperatorData';
+export declare class KeySharesData implements IKeySharesData {
+    ownerNonce?: number | null;
+    ownerAddress?: string | null;
+    publicKey?: string | null;
+    operators?: OperatorData[] | null;
+    update(data: IKeySharesPartialData): void;
+    /**
+     * Do all possible validations.
+     */
+    validate(): Promise<any>;
+    /**
+     * Get the list of operators IDs.
+     */
+    get operatorIds(): number[];
+    /**
+     * Get the list of operators public keys.
+     */
+    get operatorPublicKeys(): string[];
+}

package/dist/libs/ssv-keys/KeyShares/KeySharesData/KeySharesPayload.d.ts

@@ -0,0 +1,32 @@
+import { IKeySharesPartialPayload, IKeySharesPayload } from '../../interfaces';
+/**
+ * Key Shares Payload
+ */
+export declare class KeySharesPayload implements IKeySharesPayload {
+    sharesData: string;
+    publicKey: string;
+    operatorIds: number[];
+    /**
+     * Converts arrays of public and private keys to a single hexadecimal string.
+     * @param publicKeys Array of public keys.
+     * @param privateKeys Array of private keys.
+     * @returns Hexadecimal string representation of keys.
+     */
+    private _sharesToBytes;
+    /**
+     * Updates the payload with new data and validates it.
+     * @param data Partial key shares payload to update.
+     */
+    update(data: IKeySharesPartialPayload): void;
+    /**
+     * Validates the current state of the instance.
+     * @returns {void | ValidationError[]} Validation errors if any, otherwise undefined.
+     */
+    validate(): any;
+    /**
+     * Builds the payload from the given data.
+     * @param data Data to build the payload.
+     * @returns {KeySharesPayload} The current instance for chaining.
+     */
+    build(data: any): KeySharesPayload;
+}

package/dist/libs/ssv-keys/KeyShares/KeySharesData/OperatorData.d.ts

@@ -0,0 +1,10 @@
+import { IOperator, IOperatorData } from '../../interfaces';
+export declare class OperatorData implements IOperatorData {
+    id: number;
+    operatorKey: string;
+    constructor(data: IOperator);
+    /**
+     * Validate operator id and public key
+     */
+    validate(): void;
+}

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/encrypted-key.d.ts

@@ -0,0 +1,6 @@
+import { ValidatorConstraintInterface, ValidationOptions } from 'class-validator';
+export declare class EncryptedKeyValidatorConstraint implements ValidatorConstraintInterface {
+    validate(value: any): boolean;
+    defaultMessage(): string;
+}
+export declare function EncryptedKeyValidator(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/index.d.ts

@@ -0,0 +1,6 @@
+export { OpeatorsListValidator } from './operator-unique';
+export { PublicKeyValidator } from './public-key';
+export { OwnerAddressValidator } from './owner-address';
+export { OwnerNonceValidator } from './owner-nonce';
+export { MatchLengthValidator } from './match';
+export { OperatorPublicKeyValidatorConstraint } from './operator-public-key';

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/match.d.ts

@@ -0,0 +1,6 @@
+import { ValidatorConstraintInterface, ValidationOptions, ValidationArguments } from 'class-validator';
+export declare class MatchLengthValidatorConstraint implements ValidatorConstraintInterface {
+    validate(value: any, args: ValidationArguments): boolean;
+    defaultMessage(): string;
+}
+export declare function MatchLengthValidator(property: string, validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/operator-public-key.d.ts

@@ -0,0 +1,6 @@
+import { ValidationOptions, ValidatorConstraintInterface } from 'class-validator';
+export declare class OperatorPublicKeyValidatorConstraint implements ValidatorConstraintInterface {
+    validate(value: string): boolean;
+    defaultMessage(): string;
+}
+export declare function OperatorPublicKeyValidator(validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/operator-unique.d.ts

@@ -0,0 +1,6 @@
+import { ValidatorConstraintInterface, ValidationOptions } from 'class-validator';
+export declare class OpeatorsListValidatorConstraint implements ValidatorConstraintInterface {
+    validate(operatorsList: any): boolean;
+    defaultMessage(): string;
+}
+export declare function OpeatorsListValidator(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/owner-address.d.ts

@@ -0,0 +1,6 @@
+import { ValidatorConstraintInterface, ValidationOptions } from 'class-validator';
+export declare class OwnerAddressValidatorConstraint implements ValidatorConstraintInterface {
+    validate(value: any): boolean;
+    defaultMessage(): string;
+}
+export declare function OwnerAddressValidator(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/owner-nonce.d.ts

@@ -0,0 +1,6 @@
+import { ValidatorConstraintInterface, ValidationOptions } from 'class-validator';
+export declare class OwnerNonceValidatorConstraint implements ValidatorConstraintInterface {
+    validate(value: any): boolean;
+    defaultMessage(): string;
+}
+export declare function OwnerNonceValidator(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesData/validators/public-key.d.ts

@@ -0,0 +1,6 @@
+import { ValidatorConstraintInterface, ValidationOptions } from 'class-validator';
+export declare class PublicKeyValidatorConstraint implements ValidatorConstraintInterface {
+    validate(value: any): Promise<boolean>;
+    defaultMessage(): string;
+}
+export declare function PublicKeyValidator(validationOptions?: ValidationOptions): (object: any, propertyName: string) => void;

package/dist/libs/ssv-keys/KeyShares/KeySharesItem.d.ts

@@ -0,0 +1,60 @@
+import { IEncryptShare, IKeySharesPartialData, IOperator } from '../interfaces';
+import { KeySharesData } from './KeySharesData/KeySharesData';
+import { SSVKeysException } from '../exceptions/base';
+import { KeySharesPayload } from './KeySharesData/KeySharesPayload';
+export interface IKeySharesPayloadData {
+    publicKey: string;
+    operators: IOperator[];
+    encryptedShares: IEncryptShare[];
+}
+export interface IKeySharesToSignatureData {
+    ownerAddress: string;
+    ownerNonce: number;
+    privateKey: string;
+}
+export interface IKeySharesFromSignatureData {
+    ownerAddress: string;
+    ownerNonce: number;
+    publicKey: string;
+}
+/**
+ * Key shares file data interface.
+ */
+export declare class KeySharesItem {
+    data: KeySharesData;
+    payload: KeySharesPayload;
+    error: SSVKeysException | undefined;
+    constructor();
+    /**
+     * Build payload from operators list, encrypted shares and validator public key
+     */
+    buildPayload(metaData: IKeySharesPayloadData, toSignatureData: IKeySharesToSignatureData): Promise<any>;
+    validateSingleShares(shares: string, fromSignatureData: IKeySharesFromSignatureData): Promise<void>;
+    /**
+     * Build shares from bytes string and operators list length
+     * @param bytes
+     * @param operatorCount
+     */
+    buildSharesFromBytes(bytes: string, operatorCount: number): {
+        sharesPublicKeys: string[];
+        encryptedKeys: string[];
+    };
+    /**
+     * Updates the current instance with partial data and payload, and validates.
+     */
+    update(data: IKeySharesPartialData): void;
+    /**
+     * Validate everything
+     */
+    validate(): void;
+    /**
+     * Stringify key shares to be ready for saving in file.
+     */
+    toJson(): string;
+    private splitArray;
+    /**
+     * Initialise from JSON or object data.
+     */
+    static fromJson(content: string | unknown): Promise<KeySharesItem>;
+}
+export type IKeySharesItem = InstanceType<typeof KeySharesItem>;

package/dist/libs/ssv-keys/SSVKeys.d.ts

@@ -0,0 +1,66 @@
+import { IOperator, IShares, ISharesKeyPairs, IEncryptShare } from './interfaces';
+export interface ExtractedKeys {
+    privateKey: string;
+    publicKey: string;
+}
+interface ISharesValidation {
+    shares: string;
+    operatorsCount: number;
+    validatorPublicKey: string;
+    isAccountExists: boolean;
+    ownerAddress: string;
+    ownerNonce: number;
+    blockNumber: number;
+}
+/**
+ * SSVKeys class provides high-level methods to easily work with entire flow:
+ *  - getting private key from keystore file using password
+ *  - creating shares threshold
+ *  - creating final shares
+ *  - building final payload which is ready to be used in web3 transaction
+ */
+export declare class SSVKeys {
+    protected threshold: ISharesKeyPairs | undefined;
+    /**
+     * Extract private key from keystore data using keystore password.
+     * Generally can be used in browsers when the keystore data has been provided by browser.
+     * @param data
+     * @param password
+     */
+    extractKeys(data: string, password: string): Promise<ExtractedKeys>;
+    /**
+     * Build threshold using private key and list of operators.
+     * @param privateKey
+     * @param operators
+     */
+    createThreshold(privateKey: string, operators: IOperator[]): Promise<ISharesKeyPairs>;
+    /**
+     * Encrypt operators shares using operators list (id, publicKey).
+     * @param operators
+     * @param shares
+     */
+    encryptShares(operators: IOperator[], shares: IShares[]): Promise<IEncryptShare[]>;
+    /**
+     * Build shares from private key, operators list
+     * @param privateKey
+     * @param operators
+     */
+    buildShares(privateKey: string, operators: IOperator[]): Promise<IEncryptShare[]>;
+    /**
+     * Getting threshold if it has been created before.
+     */
+    getThreshold(): ISharesKeyPairs | undefined;
+    validateSharesPostRegistration({ shares, operatorsCount, validatorPublicKey, isAccountExists, ownerAddress, ownerNonce, blockNumber }: ISharesValidation): Promise<{
+        isValid: boolean;
+        isSharesValid: boolean;
+        sharesPublicKeys: string[] | undefined;
+        encryptedKeys: string[] | undefined;
+        memo: {
+            message: string;
+            error: string;
+            data: string;
+            blockNumber: number;
+        }[];
+    }>;
+}
+export {};

package/dist/libs/ssv-keys/Threshold/Threshold.d.ts

@@ -0,0 +1,28 @@
+import { SSVKeysException } from '../exceptions/base';
+import { ISharesKeyPairs } from '../interfaces';
+export declare class ThresholdInvalidOperatorsLengthError extends SSVKeysException {
+    operators: number[];
+    constructor(operators: number[], message: string);
+}
+export declare class ThresholdInvalidOperatorIdError extends SSVKeysException {
+    operator: any;
+    constructor(operator: any, message: string);
+}
+/**
+ * Building threshold for list of operator IDs
+ */
+declare class Threshold {
+    protected publicKey: any;
+    protected privateKey: any;
+    protected shares: Array<any>;
+    static get DEFAULT_THRESHOLD_NUMBER(): number;
+    /**
+     * Receives list of operators IDs.
+     *  len(operator IDs) := 3 * F + 1
+     *
+     * If F calculated from this formula is not integer number - it will raise exception.
+     * Generate keys and return promise
+     */
+    create(privateKeyString: string, operatorIds: number[]): Promise<ISharesKeyPairs>;
+}
+export default Threshold;

package/dist/libs/ssv-keys/Threshold/__test__/helper/share_signatures.d.ts

@@ -0,0 +1,7 @@
+export interface Shares {
+    privateKey: any;
+    publicKey: any;
+    signatures: any[];
+    ids: any[];
+}
+export declare const sharesSignatures: (_privateKey: string, operators: number[], message: string, isThreshold: boolean) => Promise<Shares>;

package/dist/libs/ssv-keys/Threshold/index.d.ts

@@ -0,0 +1 @@
+export { default as Threshold } from './Threshold';

package/dist/libs/ssv-keys/exceptions/base.d.ts

@@ -0,0 +1,4 @@
+export declare class SSVKeysException extends Error {
+    trace: any;
+    constructor(message: string);
+}

package/dist/libs/ssv-keys/exceptions/bls.d.ts

@@ -0,0 +1,9 @@
+import { SSVKeysException } from './base';
+export declare class BLSDeserializeError extends SSVKeysException {
+    publicKey: string;
+    constructor(publicKey: string, message: string);
+}
+export declare class SingleSharesSignatureInvalid extends SSVKeysException {
+    data: string;
+    constructor(data: string, message: string);
+}

package/dist/libs/ssv-keys/exceptions/index.d.ts

@@ -0,0 +1,2 @@
+export { OperatorPublicKeyError, OperatorsCountsMismatchError } from './operator';
+export { SSVKeysException } from './base';

package/dist/libs/ssv-keys/exceptions/keyshares.d.ts

@@ -0,0 +1,5 @@
+import { SSVKeysException } from './base';
+export declare class KeySharesAbiDecodeError extends SSVKeysException {
+    data: any;
+    constructor(data: any, message: string);
+}

package/dist/libs/ssv-keys/exceptions/keystore.d.ts

@@ -0,0 +1,27 @@
+import { SSVKeysException } from './base';
+export declare class KeyStoreDataFormatError extends SSVKeysException {
+    data: any;
+    constructor(data: any, message: string);
+}
+export declare class KeyStoreInvalidError extends SSVKeysException {
+    data: any;
+    constructor(data: any, message: string);
+}
+export declare class KeyStorePasswordError extends SSVKeysException {
+    constructor(message: string);
+}
+export declare class EthereumWalletError extends SSVKeysException {
+    constructor(message: string);
+}
+export declare class PrivateKeyFormatError extends SSVKeysException {
+    data: any;
+    constructor(data: any, message: string);
+}
+export declare class OwnerAddressFormatError extends SSVKeysException {
+    data: any;
+    constructor(data: any, message: string);
+}
+export declare class OwnerNonceFormatError extends SSVKeysException {
+    data: any;
+    constructor(data: any, message: string);
+}

package/dist/libs/ssv-keys/exceptions/operator.d.ts

@@ -0,0 +1,22 @@
+import { SSVKeysException } from './base';
+import { IOperatorData } from '../interfaces';
+export declare class DuplicatedOperatorIdError extends SSVKeysException {
+    operator: IOperatorData;
+    constructor(operator: IOperatorData, message: string);
+}
+export declare class DuplicatedOperatorPublicKeyError extends SSVKeysException {
+    operator: IOperatorData;
+    constructor(operator: IOperatorData, message: string);
+}
+export declare class OperatorsCountsMismatchError extends SSVKeysException {
+    listOne: any[] | null | undefined;
+    listTwo: any[] | null | undefined;
+    constructor(propertyListOne: any[] | null | undefined, propertyListTwo: any[] | null | undefined, message: string);
+}
+export declare class OperatorPublicKeyError extends SSVKeysException {
+    operator: any;
+    constructor(operator: {
+        rsa: string;
+        base64: string | boolean;
+    }, message: string);
+}

package/dist/libs/ssv-keys/helpers/operator.helper.d.ts

@@ -0,0 +1,7 @@
+import { IOperator } from '../interfaces/IOperator.ts';
+import { OperatorData } from '../KeyShares/KeySharesData/OperatorData';
+/**
+ * Sort operators input.
+ * @param operators list
+ */
+export declare const operatorSortedList: (operators: IOperator[]) => OperatorData[];

package/dist/libs/ssv-keys/helpers/web3.helper.d.ts

@@ -0,0 +1,36 @@
+/**
+ * This function transforms an array of hexadecimal strings into a single Node.js Buffer.
+ * It employs viem.toBytes to convert each hex string into a Uint8Array, flattens them into a single array, and converts that to a Buffer.
+ *
+ * @param {string[]} hexArr - An array of hexadecimal strings. Each string can represent bytes of arbitrary length. *
+ * @returns {Buffer} - A Node.js Buffer that concatenates the bytes represented by the hexadecimal strings in the input array.
+ *
+ */
+declare const hexArrayToBytes: (hexArr: string[]) => Buffer;
+/**
+ * Asynchronously creates a BLS signature for given data using a private key.
+ *
+ * @param {string} dataToSign - The data to be signed.
+ * @param {string} privateKeyHex - Hexadecimal representation of the private key.
+ * @returns {Promise<string>} - A promise that resolves to the BLS signature in hexadecimal format.
+ *
+ * The function initializes the BLS library if needed, deserializes the private key from a hexadecimal string,
+ * computes the Keccak-256 hash of the data, signs the hashed data using the deserialized private key,
+ * and returns the signature in hexadecimal format, prefixed with '0x'.
+ */
+declare const buildSignature: (dataToSign: string, privateKeyHex: string) => Promise<string>;
+/**
+ * Asynchronously validates a BLS signature for given signed data.
+ *
+ * @param {string} signedData - Data that has been signed.
+ * @param {string} signatureHex - Hexadecimal representation of the BLS signature.
+ * @param {string} publicKey - Hexadecimal representation of the public key.
+ * @throws {SingleSharesSignatureInvalid} - Throws an error if the signature is invalid.
+ * @returns {Promise<void>} - Resolves when the signature is successfully verified.
+ *
+ * The function initializes the BLS library if needed, deserializes the public key and signature from hexadecimal strings,
+ * computes the Keccak-256 hash of the signed data, and verifies the signature using the deserialized public key.
+ */
+declare const validateSignature: (signedData: string, signatureHex: string, publicKey: string) => Promise<void>;
+export declare const privateToPublicKey: (privateKey: string) => Promise<string>;
+export { hexArrayToBytes, buildSignature, validateSignature };

package/dist/libs/ssv-keys/index.d.ts

@@ -0,0 +1,4 @@
+export { SSVKeys } from './SSVKeys';
+export { KeySharesItem } from './KeyShares/KeySharesItem';
+export { KeyShares } from './KeyShares/KeyShares';
+export { SSVKeysException, OperatorPublicKeyError, OperatorsCountsMismatchError } from './exceptions';

package/dist/libs/ssv-keys/interfaces/IEncryptShare.d.ts

@@ -0,0 +1,5 @@
+export interface IEncryptShare {
+    operatorPublicKey: string;
+    privateKey: string;
+    publicKey: string;
+}

package/dist/libs/ssv-keys/interfaces/IKeySharesData.d.ts

@@ -0,0 +1,18 @@
+import { IOperator } from './IOperator.ts';
+import { IOperatorData } from './IOperatorData.ts';
+export interface IKeySharesData {
+    ownerNonce?: number | null;
+    ownerAddress?: string | null;
+    publicKey?: string | null;
+    operators?: IOperatorData[] | null;
+    update(data: IKeySharesPartialData): void;
+    validate(): void;
+    get operatorIds(): number[];
+    get operatorPublicKeys(): string[];
+}
+export interface IKeySharesPartialData {
+    ownerNonce?: number | null;
+    ownerAddress?: string | null;
+    publicKey?: string | null;
+    operators?: IOperator[] | null;
+}

package/dist/libs/ssv-keys/interfaces/IKeySharesPayload.d.ts

@@ -0,0 +1,13 @@
+export interface IKeySharesPayload {
+    sharesData: string;
+    publicKey: string;
+    operatorIds: number[];
+    update(data: any): any;
+    validate(): void;
+    build(data: any): any;
+}
+export interface IKeySharesPartialPayload {
+    sharesData: string;
+    publicKey: string;
+    operatorIds: number[];
+}

package/dist/libs/ssv-keys/interfaces/IOperator.d.ts

@@ -0,0 +1,4 @@
+export interface IOperator {
+    id: number;
+    operatorKey: string;
+}

package/dist/libs/ssv-keys/interfaces/IOperatorData.d.ts

@@ -0,0 +1,5 @@
+export interface IOperatorData {
+    id: number | undefined;
+    operatorKey: string | undefined;
+    validate(): void;
+}