///
export declare const PUBLIC_KEY_LENGTH = 32;
export declare const PRIVATE_KEY_LENGTH = 32;
export declare const SIGNATURE_LENGTH = 64;
export declare const ADDRESS_LENGTH = 26;
export declare const MAIN_NET_CHAIN_ID = 87;
export declare const TEST_NET_CHAIN_ID = 84;
export interface INonceSeed {
seed: TBytes;
nonce?: number;
}
export declare type AESMode = 'CBC' | 'CFB' | 'CTR' | 'OFB' | 'ECB' | 'GCM';
export declare type RSADigestAlgorithm = 'MD5' | 'SHA1' | 'SHA224' | 'SHA256' | 'SHA384' | 'SHA512' | 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512';
export declare type TRandomTypesMap = {
Array8: number[];
Array16: number[];
Array32: number[];
Buffer: Buffer;
Uint8Array: Uint8Array;
Uint16Array: Uint16Array;
Uint32Array: Uint32Array;
};
export declare type TBytes = Uint8Array;
export declare type TBase64 = string;
export declare type TBase58 = string;
export declare type TBase16 = string;
export declare type TChainId = string | number;
export declare type TBinaryIn = TBytes | TBase58 | number[];
export declare type TRawStringInDiscriminator = {
TRawStringIn: null;
};
export declare type TRawStringIn = TBytes | string | number[] | TRawStringInDiscriminator;
export declare type TBinaryOut = TBytes | TBase58;
export declare type TPublicKey = {
publicKey: T;
};
export declare type TPrivateKey = {
privateKey: T;
};
export declare type TKeyPair = TPublicKey & TPrivateKey;
export declare type TSeed = TRawStringIn | INonceSeed;
export declare type TRSAKeyPair = {
rsaPublic: TBytes;
rsaPrivate: TBytes;
};
export interface ISeedRelated {
seedWithNonce: (seed: TSeed, nonce: number) => INonceSeed;
keyPair: (seed: TSeed) => TKeyPair;
publicKey: (seedOrPrivateKey: TSeed | TPrivateKey) => TDesiredOut;
privateKey: (seed: TSeed) => TDesiredOut;
address: (seedOrPublicKey: TSeed | TPublicKey, chainId?: TChainId) => TDesiredOut;
signBytes: (seedOrPrivateKey: TSeed | TPrivateKey, bytes: TBinaryIn, random?: TBinaryIn) => TDesiredOut;
}
export interface ISeedEmbeded {
seedWithNonce: (nonce: number) => INonceSeed;
keyPair: () => TKeyPair;
publicKey: () => TDesiredOut;
privateKey: () => TDesiredOut;
address: (chainId?: TChainId) => TDesiredOut;
signBytes: (bytes: TBinaryIn, random?: TBinaryIn) => TDesiredOut;
}
export interface IWavesCrypto {
blake2b: (input: TBinaryIn) => TBytes;
keccak: (input: TBinaryIn) => TBytes;
sha256: (input: TBinaryIn) => TBytes;
base64Encode: (input: TBinaryIn) => TBase64;
base64Decode: (input: TBase64) => TBytes;
base58Encode: (input: TBinaryIn) => TBase58;
base58Decode: (input: TBase58) => TBytes;
base16Encode: (input: TBinaryIn) => TBase16;
base16Decode: (input: TBase16) => TBytes;
stringToBytes: (input: string, encoding?: 'utf8' | 'raw') => TBytes;
bytesToString: (input: TBinaryIn, encoding?: 'utf8' | 'raw') => string;
split: (binary: TBinaryIn, ...sizes: number[]) => TBytes[];
concat: (...binaries: TBinaryIn[]) => TBytes;
buildAddress: (publicKeyBytes: TBytes, chainId: TChainId) => TBytes;
random(count: number, type: T): TRandomTypesMap[T];
randomBytes: (size: number) => TBytes;
randomSeed: (wordsCount?: number) => string;
verifySignature: (publicKey: TBinaryIn, bytes: TBinaryIn, signature: TBinaryIn) => boolean;
verifyPublicKey: (publicKey: TBinaryIn) => boolean;
verifyAddress: (address: TBinaryIn, optional?: {
chainId?: TChainId;
publicKey?: TBinaryIn;
}) => boolean;
sharedKey: (privateKeyFrom: TBinaryIn, publicKeyTo: TBinaryIn, prefix: TRawStringIn) => TDesiredOut;
messageDecrypt: (sharedKey: TBinaryIn, encryptedMessage: TBinaryIn) => string;
messageEncrypt: (sharedKey: TBinaryIn, message: string) => TBytes;
aesEncrypt: (data: TBinaryIn, encryptionKey: TBinaryIn, mode?: AESMode, iv?: TBinaryIn) => TBytes;
aesDecrypt: (encryptedData: TBinaryIn, encryptionKey: TBinaryIn, mode?: AESMode, iv?: TBinaryIn) => TBytes;
encryptSeed: (seed: string, password: string, encryptionRounds?: number) => TBase64;
decryptSeed: (encryptedSeed: TBase64, password: string, encryptionRounds?: number) => string;
rsaKeyPair: (bits?: number, e?: number) => Promise;
rsaKeyPairSync: (bits?: number, e?: number) => TRSAKeyPair;
rsaSign: (rsaPrivateKey: TBytes, message: TBytes, digest?: RSADigestAlgorithm) => TBytes;
rsaVerify: (rsaPublicKey: TBytes, message: TBytes, signature: TBytes, digest?: RSADigestAlgorithm) => boolean;
merkleVerify: (rootHash: Uint8Array, merkleProof: Uint8Array, leafData: Uint8Array) => boolean;
}