@aptos-labs/ts-sdk 0.0.3 → 0.0.5

package/dist/esm/core/crypto/ed25519.d.ts

@@ -0,0 +1,173 @@
+import { PublicKey, PrivateKey, Signature } from './asymmetricCrypto.js';
+import { Deserializer } from '../../bcs/deserializer.js';
+import { Serializer } from '../../bcs/serializer.js';
+import { HexInput } from '../../types/index.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../hex.js';
+import '../common.js';
+
+/**
+ * Represents the public key of an Ed25519 key pair.
+ *
+ * Since [AIP-55](https://github.com/aptos-foundation/AIPs/pull/263) Aptos supports
+ * `Legacy` and `Unified` authentication keys.
+ *
+ * Ed25519 scheme is represented in the SDK as `Legacy authentication key` and also
+ * as `AnyPublicKey` that represents any `Unified authentication key`
+ */
+declare class Ed25519PublicKey extends PublicKey {
+    /**
+     * Length of an Ed25519 public key
+     */
+    static readonly LENGTH: number;
+    /**
+     * Bytes of the public key
+     * @private
+     */
+    private readonly key;
+    /**
+     * Create a new PublicKey instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(hexInput: HexInput);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    /**
+     * Verifies a signed data with a public key
+     * @param args.message a signed message
+     * @param args.signature the signature of the message
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: Ed25519Signature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Ed25519PublicKey;
+    static load(deserializer: Deserializer): Ed25519PublicKey;
+}
+/**
+ * Represents the private key of an Ed25519 key pair.
+ */
+declare class Ed25519PrivateKey extends PrivateKey {
+    /**
+     * Length of an Ed25519 private key
+     */
+    static readonly LENGTH: number;
+    /**
+     * The Ed25519 key seed to use for BIP-32 compatibility
+     * See more {@link https://github.com/satoshilabs/slips/blob/master/slip-0010.md}
+     */
+    static readonly SLIP_0010_SEED = "ed25519 seed";
+    /**
+     * The Ed25519 signing key
+     * @private
+     */
+    private readonly signingKeyPair;
+    /**
+     * Create a new PrivateKey instance from a Uint8Array or String.
+     *
+     * @param hexInput HexInput (string or Uint8Array)
+     */
+    constructor(hexInput: HexInput);
+    /**
+     * Get the private key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the private key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the private key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the private key
+     */
+    toString(): string;
+    /**
+     * Sign the given message with the private key.
+     *
+     * @param message in HexInput format
+     * @returns Signature
+     */
+    sign(message: HexInput): Ed25519Signature;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Ed25519PrivateKey;
+    /**
+     * Generate a new random private key.
+     *
+     * @returns Ed25519PrivateKey
+     */
+    static generate(): Ed25519PrivateKey;
+    /**
+     * Derive the Ed25519PublicKey for this private key.
+     *
+     * @returns Ed25519PublicKey
+     */
+    publicKey(): Ed25519PublicKey;
+    /**
+     * Derives a private key from a mnemonic seed phrase.
+     *
+     * To derive multiple keys from the same phrase, change the path
+     *
+     * IMPORTANT: Ed25519 supports hardened derivation only (since it lacks a key homomorphism,
+     * so non-hardened derivation cannot work)
+     *
+     * @param path the BIP44 path
+     * @param mnemonics the mnemonic seed phrase
+     */
+    static fromDerivationPath(path: string, mnemonics: string): Ed25519PrivateKey;
+    /**
+     * A private inner function so we can separate from the main fromDerivationPath() method
+     * to add tests to verify we create the keys correctly.
+     *
+     * @param path the BIP44 path
+     * @param seed the seed phrase created by the mnemonics
+     * @param offset the offset used for key derivation, defaults to 0x80000000
+     * @returns
+     */
+    private static fromDerivationPathInner;
+}
+/**
+ * A signature of a message signed using an Ed25519 private key
+ */
+declare class Ed25519Signature extends Signature {
+    /**
+     * Length of an Ed25519 signature
+     */
+    static readonly LENGTH = 64;
+    /**
+     * The signature bytes
+     * @private
+     */
+    private readonly data;
+    constructor(hexInput: HexInput);
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Ed25519Signature;
+    static load(deserializer: Deserializer): Ed25519Signature;
+}
+
+export { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature };

package/dist/esm/core/crypto/ed25519.mjs

@@ -0,0 +1,2 @@
+import{a,b,c}from"../../chunk-BIUGRAMO.mjs";import"../../chunk-E72CFUU4.mjs";import"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-LU6VS7PJ.mjs";import"../../chunk-V6AAQLLJ.mjs";import"../../chunk-7AQXAH6Q.mjs";import"../../chunk-PDLUCVJB.mjs";import"../../chunk-BC2NOUYT.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.mjs";export{b as Ed25519PrivateKey,a as Ed25519PublicKey,c as Ed25519Signature};
+//# sourceMappingURL=ed25519.mjs.map

package/dist/esm/core/crypto/ed25519.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/hdKey.d.ts

@@ -0,0 +1,65 @@
+declare type DerivedKeys = {
+    key: Uint8Array;
+    chainCode: Uint8Array;
+};
+/**
+ * Aptos derive path is 637
+ */
+declare const APTOS_HARDENED_REGEX: RegExp;
+declare const APTOS_BIP44_REGEX: RegExp;
+/**
+ * A list of supported key types and associated seeds
+ */
+declare enum KeyType {
+    ED25519 = "ed25519 seed"
+}
+declare const HARDENED_OFFSET = 2147483648;
+/**
+ * Aptos derive path is 637
+ *
+ * Parse and validate a path that is compliant to BIP-44 in form m/44'/637'/{account_index}'/{change_index}/{address_index}
+ * for Secp256k1
+ *
+ * Note that for secp256k1, last two components must be non-hardened.
+ *
+ * @param path path string (e.g. `m/44'/637'/0'/0/0`).
+ */
+declare function isValidBIP44Path(path: string): boolean;
+/**
+ * Aptos derive path is 637
+ *
+ * Parse and validate a path that is compliant to SLIP-0010 and BIP-44
+ * in form m/44'/637'/{account_index}'/{change_index}'/{address_index}'.
+ * See SLIP-0010 {@link https://github.com/satoshilabs/slips/blob/master/slip-0044.md}
+ * See BIP-44 {@link https://github.com/bitcoin/bips/blob/master/bip-0044.mediawiki}
+ *
+ * Note that for Ed25519, all components must be hardened.
+ * This is because non-hardened [PK] derivation would not work due to Ed25519's lack of a key homomorphism.
+ * Specifically, you cannot derive the PK associated with derivation path a/b/c given the PK of a/b.
+ * This is because the PK in Ed25519 is, more or less, computed as 𝑔𝐻(𝑠𝑘),
+ * with the hash function breaking the homomorphism.
+ *
+ * @param path path string (e.g. `m/44'/637'/0'/0'/0'`).
+ */
+declare function isValidHardenedPath(path: string): boolean;
+declare const deriveKey: (hashSeed: Uint8Array | string, data: Uint8Array | string) => DerivedKeys;
+/**
+ * Derive a child key from the private key
+ * @param key
+ * @param chainCode
+ * @param index
+ * @constructor
+ */
+declare const CKDPriv: ({ key, chainCode }: DerivedKeys, index: number) => DerivedKeys;
+/**
+ * Splits derive path into segments
+ * @param path
+ */
+declare const splitPath: (path: string) => Array<string>;
+/**
+ * Normalizes the mnemonic by removing extra whitespace and making it lowercase
+ * @param mnemonic the mnemonic seed phrase
+ */
+declare const mnemonicToSeed: (mnemonic: string) => Uint8Array;
+
+export { APTOS_BIP44_REGEX, APTOS_HARDENED_REGEX, CKDPriv, DerivedKeys, HARDENED_OFFSET, KeyType, deriveKey, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, splitPath };

package/dist/esm/core/crypto/hdKey.mjs

@@ -0,0 +1,2 @@
+import{a,b,c,d,e,f,g,h,i,j}from"../../chunk-LR65XHSF.mjs";import"../../chunk-XNFEUXDS.mjs";export{b as APTOS_BIP44_REGEX,a as APTOS_HARDENED_REGEX,h as CKDPriv,d as HARDENED_OFFSET,c as KeyType,g as deriveKey,e as isValidBIP44Path,f as isValidHardenedPath,j as mnemonicToSeed,i as splitPath};
+//# sourceMappingURL=hdKey.mjs.map

package/dist/esm/core/crypto/hdKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/index.d.ts

@@ -0,0 +1,17 @@
+export { PrivateKey, PublicKey, Signature } from './asymmetricCrypto.js';
+export { Ed25519PrivateKey, Ed25519PublicKey, Ed25519Signature } from './ed25519.js';
+export { MultiEd25519PublicKey, MultiEd25519Signature } from './multiEd25519.js';
+export { Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature } from './secp256k1.js';
+export { MultiKey } from './multiKey.js';
+export { APTOS_BIP44_REGEX, APTOS_HARDENED_REGEX, CKDPriv, DerivedKeys, HARDENED_OFFSET, KeyType, deriveKey, isValidBIP44Path, isValidHardenedPath, mnemonicToSeed, splitPath } from './hdKey.js';
+import '../../types/index.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../../bcs/serializer.js';
+import '../hex.js';
+import '../common.js';
+import '../../bcs/deserializer.js';
+import './anyPublicKey.js';
+import './anySignature.js';

package/dist/esm/core/crypto/index.mjs

@@ -0,0 +1,2 @@
+import"../../chunk-TCTZCPQ6.mjs";import{a as q,b as r}from"../../chunk-FNB6CFQR.mjs";import{a as v}from"../../chunk-CZZJAR3B.mjs";import"../../chunk-UVGCVCNG.mjs";import{a as n,b as o,c as p}from"../../chunk-BIUGRAMO.mjs";import{a as s,b as t,c as u}from"../../chunk-YS2OX7AB.mjs";import{a,b,c}from"../../chunk-E72CFUU4.mjs";import{a as d,b as e,c as f,d as g,e as h,f as i,g as j,h as k,i as l,j as m}from"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-LU6VS7PJ.mjs";import"../../chunk-V6AAQLLJ.mjs";import"../../chunk-7AQXAH6Q.mjs";import"../../chunk-PDLUCVJB.mjs";import"../../chunk-BC2NOUYT.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.mjs";export{e as APTOS_BIP44_REGEX,d as APTOS_HARDENED_REGEX,k as CKDPriv,o as Ed25519PrivateKey,n as Ed25519PublicKey,p as Ed25519Signature,g as HARDENED_OFFSET,f as KeyType,q as MultiEd25519PublicKey,r as MultiEd25519Signature,v as MultiKey,b as PrivateKey,a as PublicKey,t as Secp256k1PrivateKey,s as Secp256k1PublicKey,u as Secp256k1Signature,c as Signature,j as deriveKey,h as isValidBIP44Path,i as isValidHardenedPath,m as mnemonicToSeed,l as splitPath};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/core/crypto/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/multiEd25519.d.ts

@@ -0,0 +1,126 @@
+import { PublicKey, Signature } from './asymmetricCrypto.js';
+import { Deserializer } from '../../bcs/deserializer.js';
+import { Serializer } from '../../bcs/serializer.js';
+import { Ed25519PublicKey, Ed25519Signature } from './ed25519.js';
+import { HexInput } from '../../types/index.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../hex.js';
+import '../common.js';
+
+/**
+ * Represents the public key of a K-of-N Ed25519 multi-sig transaction.
+ */
+declare class MultiEd25519PublicKey extends PublicKey {
+    /**
+     * Maximum number of public keys supported
+     */
+    static readonly MAX_KEYS = 32;
+    /**
+     * Minimum number of public keys needed
+     */
+    static readonly MIN_KEYS = 2;
+    /**
+     * Minimum threshold for the number of valid signatures required
+     */
+    static readonly MIN_THRESHOLD = 1;
+    /**
+     * List of Ed25519 public keys for this MultiEd25519PublicKey
+     */
+    readonly publicKeys: Ed25519PublicKey[];
+    /**
+     * The minimum number of valid signatures required, for the number of public keys specified
+     */
+    readonly threshold: number;
+    /**
+     * Public key for a K-of-N multi-sig transaction. A K-of-N multi-sig transaction means that for such a
+     * transaction to be executed, at least K out of the N authorized signers have signed the transaction
+     * and passed the check conducted by the chain.
+     *
+     * @see {@link
+     * https://aptos.dev/integration/creating-a-signed-transaction/ | Creating a Signed Transaction}
+     *
+     * @param args.publicKeys A list of public keys
+     * @param args.threshold At least "threshold" signatures must be valid
+     */
+    constructor(args: {
+        publicKeys: Ed25519PublicKey[];
+        threshold: number;
+    });
+    /**
+     * Converts a PublicKeys into Uint8Array (bytes) with: bytes = p1_bytes | ... | pn_bytes | threshold
+     */
+    toUint8Array(): Uint8Array;
+    toString(): string;
+    verifySignature(args: {
+        message: HexInput;
+        signature: MultiEd25519Signature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiEd25519PublicKey;
+}
+/**
+ * Represents the signature of a K-of-N Ed25519 multi-sig transaction.
+ */
+declare class MultiEd25519Signature extends Signature {
+    /**
+     * Maximum number of Ed25519 signatures supported
+     */
+    static MAX_SIGNATURES_SUPPORTED: number;
+    /**
+     * Number of bytes in the bitmap representing who signed the transaction (32-bits)
+     */
+    static BITMAP_LEN: number;
+    /**
+     * The list of underlying Ed25519 signatures
+     */
+    readonly signatures: Ed25519Signature[];
+    /**
+     * 32-bit Bitmap representing who signed the transaction
+     *
+     * This is represented where each public key can be masked to determine whether the message was signed by that key.
+     */
+    readonly bitmap: Uint8Array;
+    /**
+     * Signature for a K-of-N multi-sig transaction.
+     *
+     * @see {@link
+     * https://aptos.dev/integration/creating-a-signed-transaction/#multisignature-transactions | Creating a Signed Transaction}
+     *
+     * @param args.signatures A list of signatures
+     * @param args.bitmap 4 bytes, at most 32 signatures are supported. If Nth bit value is `1`, the Nth
+     * signature should be provided in `signatures`. Bits are read from left to right
+     */
+    constructor(args: {
+        signatures: Ed25519Signature[];
+        bitmap: Uint8Array;
+    });
+    /**
+     * Converts a MultiSignature into Uint8Array (bytes) with `bytes = s1_bytes | ... | sn_bytes | bitmap`
+     */
+    toUint8Array(): Uint8Array;
+    toString(): string;
+    /**
+     * Helper method to create a bitmap out of the specified bit positions
+     * @param args.bits The bitmap positions that should be set. A position starts at index 0.
+     * Valid position should range between 0 and 31.
+     * @example
+     * Here's an example of valid `bits`
+     * ```
+     * [0, 2, 31]
+     * ```
+     * `[0, 2, 31]` means the 1st, 3rd and 32nd bits should be set in the bitmap.
+     * The result bitmap should be 0b1010000000000000000000000000001
+     *
+     * @returns bitmap that is 32bit long
+     */
+    static createBitmap(args: {
+        bits: number[];
+    }): Uint8Array;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiEd25519Signature;
+}
+
+export { MultiEd25519PublicKey, MultiEd25519Signature };

package/dist/esm/core/crypto/multiEd25519.mjs

@@ -0,0 +1,2 @@
+import{a,b}from"../../chunk-FNB6CFQR.mjs";import"../../chunk-BIUGRAMO.mjs";import"../../chunk-E72CFUU4.mjs";import"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-LU6VS7PJ.mjs";import"../../chunk-V6AAQLLJ.mjs";import"../../chunk-7AQXAH6Q.mjs";import"../../chunk-PDLUCVJB.mjs";import"../../chunk-BC2NOUYT.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.mjs";export{a as MultiEd25519PublicKey,b as MultiEd25519Signature};
+//# sourceMappingURL=multiEd25519.mjs.map

package/dist/esm/core/crypto/multiEd25519.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/multiKey.d.ts

@@ -0,0 +1,52 @@
+import { HexInput } from '../../types/index.js';
+import { Deserializer } from '../../bcs/deserializer.js';
+import { Serializer } from '../../bcs/serializer.js';
+import { AnyPublicKey } from './anyPublicKey.js';
+import { AnySignature } from './anySignature.js';
+import { PublicKey } from './asymmetricCrypto.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../hex.js';
+import '../common.js';
+
+declare class MultiKey extends PublicKey {
+    /**
+     * List of any public keys
+     */
+    readonly publicKeys: AnyPublicKey[];
+    /**
+     * The minimum number of valid signatures required, for the number of public keys specified
+     */
+    readonly signaturesRequired: number;
+    constructor(args: {
+        publicKeys: PublicKey[];
+        signaturesRequired: number;
+    });
+    toUint8Array(): Uint8Array;
+    /**
+     * Create a bitmap that holds the mapping from the original public keys
+     * to the signatures passed in
+     *
+     * @param args.bits array of the index mapping to the matching public keys
+     * @returns Uint8array bit map
+     */
+    createBitmap(args: {
+        bits: number[];
+    }): Uint8Array;
+    /**
+     * Hex string representation the multi key bytes
+     *
+     * @returns string
+     */
+    toString(): string;
+    verifySignature(args: {
+        message: HexInput;
+        signature: AnySignature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): MultiKey;
+}
+
+export { MultiKey };

package/dist/esm/core/crypto/multiKey.mjs

@@ -0,0 +1,2 @@
+import{a}from"../../chunk-CZZJAR3B.mjs";import"../../chunk-UVGCVCNG.mjs";import"../../chunk-BIUGRAMO.mjs";import"../../chunk-YS2OX7AB.mjs";import"../../chunk-E72CFUU4.mjs";import"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-LU6VS7PJ.mjs";import"../../chunk-V6AAQLLJ.mjs";import"../../chunk-7AQXAH6Q.mjs";import"../../chunk-PDLUCVJB.mjs";import"../../chunk-BC2NOUYT.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.mjs";export{a as MultiKey};
+//# sourceMappingURL=multiKey.mjs.map

package/dist/esm/core/crypto/multiKey.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/esm/core/crypto/secp256k1.d.ts

@@ -0,0 +1,161 @@
+import { PublicKey, PrivateKey, Signature } from './asymmetricCrypto.js';
+import { Deserializer } from '../../bcs/deserializer.js';
+import { Serializer } from '../../bcs/serializer.js';
+import { HexInput } from '../../types/index.js';
+import '../../utils/apiEndpoints.js';
+import '../../types/indexer.js';
+import '../../types/generated/operations.js';
+import '../../types/generated/types.js';
+import '../hex.js';
+import '../common.js';
+
+/**
+ * Represents the Secp256k1 ecdsa public key
+ *
+ * Secp256k1 authentication key is represented in the SDK as `AnyPublicKey`.
+ */
+declare class Secp256k1PublicKey extends PublicKey {
+    static readonly LENGTH: number;
+    private readonly key;
+    /**
+     * Create a new PublicKey instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(hexInput: HexInput);
+    /**
+     * Get the public key in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the public key
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the public key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the public key
+     */
+    toString(): string;
+    /**
+     * Verifies a signed data with a public key
+     *
+     * @param args.message message
+     * @param args.signature The signature
+     * @returns true if the signature is valid
+     */
+    verifySignature(args: {
+        message: HexInput;
+        signature: Secp256k1Signature;
+    }): boolean;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Secp256k1PublicKey;
+    static load(deserializer: Deserializer): Secp256k1PublicKey;
+}
+/**
+ * A Secp256k1 ecdsa private key
+ */
+declare class Secp256k1PrivateKey extends PrivateKey {
+    /**
+     * Length of Secp256k1 ecdsa private key
+     */
+    static readonly LENGTH: number;
+    /**
+     * The private key bytes
+     * @private
+     */
+    private readonly key;
+    /**
+     * Create a new PrivateKey instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(hexInput: HexInput);
+    /**
+     * Get the private key in bytes (Uint8Array).
+     *
+     * @returns
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the private key as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the private key
+     */
+    toString(): string;
+    /**
+     * Sign the given message with the private key.
+     *
+     * @param message in HexInput format
+     * @returns Signature
+     */
+    sign(message: HexInput): Secp256k1Signature;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Secp256k1PrivateKey;
+    /**
+     * Generate a new random private key.
+     *
+     * @returns Secp256k1PrivateKey
+     */
+    static generate(): Secp256k1PrivateKey;
+    /**
+     * Derive the Secp256k1PublicKey from this private key.
+     *
+     * @returns Secp256k1PublicKey
+     */
+    publicKey(): Secp256k1PublicKey;
+    /**
+     * Derives a private key from a mnemonic seed phrase.
+     *
+     * @param path the BIP44 path
+     * @param mnemonics the mnemonic seed phrase
+     *
+     * @returns The generated key
+     */
+    static fromDerivationPath(path: string, mnemonics: string): Secp256k1PrivateKey;
+    /**
+     * A private inner function so we can separate from the main fromDerivationPath() method
+     * to add tests to verify we create the keys correctly.
+     *
+     * @param path the BIP44 path
+     * @param seed the seed phrase created by the mnemonics
+     *
+     * @returns The generated key
+     */
+    private static fromDerivationPathInner;
+}
+/**
+ * A signature of a message signed using an Secp256k1 ecdsa private key
+ */
+declare class Secp256k1Signature extends Signature {
+    /**
+     * Secp256k1 ecdsa signatures are 256-bit.
+     */
+    static readonly LENGTH = 64;
+    /**
+     * The signature bytes
+     * @private
+     */
+    private readonly data;
+    /**
+     * Create a new Signature instance from a Uint8Array or String.
+     *
+     * @param hexInput A HexInput (string or Uint8Array)
+     */
+    constructor(hexInput: HexInput);
+    /**
+     * Get the signature in bytes (Uint8Array).
+     *
+     * @returns Uint8Array representation of the signature
+     */
+    toUint8Array(): Uint8Array;
+    /**
+     * Get the signature as a hex string with the 0x prefix.
+     *
+     * @returns string representation of the signature
+     */
+    toString(): string;
+    serialize(serializer: Serializer): void;
+    static deserialize(deserializer: Deserializer): Secp256k1Signature;
+    static load(deserializer: Deserializer): Secp256k1Signature;
+}
+
+export { Secp256k1PrivateKey, Secp256k1PublicKey, Secp256k1Signature };

package/dist/esm/core/crypto/secp256k1.mjs

@@ -0,0 +1,2 @@
+import{a,b,c}from"../../chunk-YS2OX7AB.mjs";import"../../chunk-E72CFUU4.mjs";import"../../chunk-LR65XHSF.mjs";import"../../chunk-FZY4PMEE.mjs";import"../../chunk-LU6VS7PJ.mjs";import"../../chunk-V6AAQLLJ.mjs";import"../../chunk-7AQXAH6Q.mjs";import"../../chunk-PDLUCVJB.mjs";import"../../chunk-BC2NOUYT.mjs";import"../../chunk-27P7PELS.mjs";import"../../chunk-IZHPCZE3.mjs";import"../../chunk-FBPNHF54.mjs";import"../../chunk-DNDWTM7A.mjs";import"../../chunk-GUT3G5CG.mjs";import"../../chunk-4WPQQPUF.mjs";import"../../chunk-XNFEUXDS.mjs";export{b as Secp256k1PrivateKey,a as Secp256k1PublicKey,c as Secp256k1Signature};
+//# sourceMappingURL=secp256k1.mjs.map

package/dist/esm/core/crypto/secp256k1.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}