@aptos-labs/ts-sdk 1.12.1 → 1.13.0-zeta.0

package/src/api/transaction.ts

@@ -33,11 +33,12 @@ import {
   InputGenerateTransactionOptions,
   InputGenerateTransactionPayloadData,
 } from "../transactions";
-import { AccountAddressInput, Account, PrivateKey } from "../core";
+import { AccountAddressInput, PrivateKey } from "../core";
 import { Build } from "./transactionSubmission/build";
 import { Simulate } from "./transactionSubmission/simulate";
 import { Submit } from "./transactionSubmission/submit";
 import { TransactionManagement } from "./transactionSubmission/management";
+import { Account } from "../account/Account";
 import { SimpleTransaction } from "../transactions/instances/simpleTransaction";
 
 export class Transaction {
@@ -63,6 +64,9 @@ export class Transaction {
    * Queries on-chain transactions. This function will not return pending
    * transactions. For that, use `getTransactionsByHash`.
    *
+   * @example
+   * const transactions = await aptos.getTransactions()
+   *
    * @param args.options.offset The number transaction to start with
    * @param args.options.limit Number of results to return
    *
@@ -78,6 +82,9 @@ export class Transaction {
   /**
    * Queries on-chain transaction by version. This function will not return pending transactions.
    *
+   * @example
+   * const transaction = await aptos.getTransactions({ledgerVersion:1})
+   *
    * @param args.ledgerVersion - Transaction version is an unsigned 64-bit number.
    * @returns On-chain transaction. Only on-chain transactions have versions, so this
    * function cannot be used to query pending transactions.
@@ -91,6 +98,10 @@ export class Transaction {
 
   /**
    * Queries on-chain transaction by transaction hash. This function will return pending transactions.
+   *
+   * @example
+   * const transaction = await aptos.getTransactionByHash({transactionHash:"0x123"})
+   *
    * @param args.transactionHash - Transaction hash should be hex-encoded bytes string with 0x prefix.
    * @returns Transaction from mempool (pending) or on-chain (committed) transaction
    */
@@ -110,6 +121,9 @@ export class Transaction {
    * 2. Apply hash algorithm SHA3-256 to the hash message bytes.
    * 3. Hex-encode the hash bytes with 0x prefix.
    *
+   * @example
+   * const isPendingTransaction = await aptos.isPendingTransaction({transactionHash:"0x123"})
+   *
    * @param args.transactionHash A hash of transaction
    * @returns `true` if transaction is in pending state and `false` otherwise
    */
@@ -135,6 +149,8 @@ export class Transaction {
    * 4. Transaction does not move past the pending state within `args.options.timeoutSecs` seconds.
    *    - The function will throw a WaitForTransactionError
    *
+   * @example
+   * const transaction = await aptos.waitForTransaction({transactionHash:"0x123"})
    *
    * @param args.transactionHash The hash of a transaction previously submitted to the blockchain.
    * @param args.options.timeoutSecs Timeout in seconds. Defaults to 20 seconds.
@@ -158,14 +174,9 @@ export class Transaction {
    * For more information {@link https://api.mainnet.aptoslabs.com/v1/spec#/operations/estimate_gas_price}
    *
    * @returns Object holding the outputs of the estimate gas API
+   *
    * @example
-   * ```
-   * {
-   *  gas_estimate: number;
-   *  deprioritized_gas_estimate?: number;
-   *  prioritized_gas_estimate?: number;
-   * }
-   * ```
+   * const gasPrice = await aptos.waitForTransaction()
    */
   async getGasPriceEstimation(): Promise<GasEstimation> {
     return getGasPriceEstimation({
@@ -178,6 +189,11 @@ export class Transaction {
    *
    * This allows a user to sign a transaction using their own preferred signing method, and
    * then submit it to the network.
+   *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const message = await aptos.getSigningMessage({transaction})
+   *
    * @param args.transaction A raw transaction for signing elsewhere
    */
   // eslint-disable-next-line class-methods-use-this
@@ -192,6 +208,13 @@ export class Transaction {
    * `aptos move compile --save-metadata ...`,
    * For more info {@link https://aptos.dev/tutorials/your-first-dapp/#step-4-publish-a-move-module}
    *
+   * @example
+   * const transaction = await aptos.publishPackageTransaction({
+   *  account: alice,
+   *  metadataBytes,
+   *  moduleBytecode: [byteCode],
+   * })
+   *
    * @param args.account The publisher account
    * @param args.metadataBytes The package metadata bytes
    * @param args.moduleBytecode An array of the bytecode of each module in the package in compiler output order
@@ -212,6 +235,13 @@ export class Transaction {
    * the account.
    * Note: Only legacy Ed25519 scheme is supported for now.
    * More info: {@link https://aptos.dev/guides/account-management/key-rotation/}
+   *
+   * @example
+   * const response = await aptos.rotateAuthKey({
+   *  fromAccount: alice,
+   *  toNewPrivateKey: new ED25519PublicKey("0x123"),
+   * })
+   *
    * @param args.fromAccount The account to rotate the auth key for
    * @param args.toNewPrivateKey The new private key to rotate to
    *
@@ -224,6 +254,13 @@ export class Transaction {
   /**
    * Sign a transaction that can later be submitted to chain
    *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const transaction = await aptos.transaction.sign({
+   *  signer: alice,
+   *  transaction
+   * })
+   *
    * @param args.signer The signer account
    * @param args.transaction A raw transaction to sign on
    *
@@ -239,6 +276,13 @@ export class Transaction {
   /**
    * Sign a transaction as a fee payer that can later be submitted to chain
    *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const transaction = await aptos.transaction.signAsFeePayer({
+   *  signer: alice,
+   *  transaction
+   * })
+   *
    * @param args.signer The fee payer signer account
    * @param args.transaction A raw transaction to sign on
    *
@@ -301,13 +345,13 @@ export class Transaction {
    *
    * @param args.signer The signer account to sign the transaction
    * @param args.transaction An instance of a RawTransaction, plus optional secondary/fee payer addresses
-   * ```
-   * {
-   *  rawTransaction: RawTransaction,
-   *  secondarySignerAddresses? : Array<AccountAddress>,
-   *  feePayerAddress?: AccountAddress
-   * }
-   * ```
+   *
+   * @example
+   * const transaction = await aptos.transaction.build.simple({...})
+   * const transaction = await aptos.signAndSubmitTransaction({
+   *  signer: alice,
+   *  transaction
+   * })
    *
    * @return PendingTransactionResponse
    */

package/src/api/transactionSubmission/management.ts

@@ -2,7 +2,7 @@ import EventEmitter from "eventemitter3";
 import { TransactionWorkerEvents, TransactionWorker, TransactionWorkerEventsEnum } from "../../transactions/management";
 import { InputGenerateTransactionPayloadData, InputGenerateTransactionOptions } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";
-import { Account } from "../../core";
+import { Account } from "../../account";
 
 export class TransactionManagement extends EventEmitter<TransactionWorkerEvents> {
   account!: Account;

package/src/api/transactionSubmission/sign.ts

@@ -1,7 +1,7 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import { Account } from "../../core";
+import { Account } from "../../account";
 import { signTransaction } from "../../internal/transactionSubmission";
 import { AccountAuthenticator, AnyRawTransaction } from "../../transactions";
 import { AptosConfig } from "../aptosConfig";

package/src/bcs/serializer.ts

@@ -316,6 +316,24 @@ export class Serializer {
       item.serialize(this);
     });
   }
+
+  serializeOption<T extends Serializable>(value?: T): void {
+    if (value === undefined) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      value.serialize(this);
+    }
+  }
+
+  serializeOptionStr(value?: string): void {
+    if (value === undefined) {
+      this.serializeU32AsUleb128(0);
+    } else {
+      this.serializeU32AsUleb128(1);
+      this.serializeStr(value);
+    }
+  }
 }
 
 export function ensureBoolean(value: unknown): asserts value is boolean {

package/src/client/core.ts

@@ -26,11 +26,12 @@ const errors: Record<number, string> = {
  * returns the response.
  */
 export async function request<Req, Res>(options: ClientRequest<Req>, client: Client): Promise<ClientResponse<Res>> {
-  const { url, method, body, contentType, params, overrides } = options;
+  const { url, method, body, contentType, params, overrides, originMethod } = options;
   const headers: Record<string, string | AnyNumber | boolean | undefined> = {
     ...overrides?.HEADERS,
     "x-aptos-client": `aptos-typescript-sdk/${VERSION}`,
     "content-type": contentType ?? MimeType.JSON,
+    "x-aptos-typescript-sdk-origin-method": originMethod,
   };
 
   if (overrides?.AUTH_TOKEN) {
@@ -105,6 +106,14 @@ export async function aptosRequest<Req extends {}, Res extends {}>(
     return result;
   }
 
+  if (result.status >= 500) {
+    throw new AptosApiError(options, result, `${response.data}`);
+  }
+
+  if (aptosConfig.isPepperServiceRequest(url)) {
+    throw new AptosApiError(options, result, `${response.data}`);
+  }
+
   let errorMessage: string;
 
   if (result && result.data && "message" in result.data && "error_code" in result.data) {

package/src/client/get.ts

@@ -89,6 +89,12 @@ export async function getAptosFullNode<Req extends {}, Res extends {}>(
   });
 }
 
+export async function getAptosPepperService<Req extends {}, Res extends {}>(
+  options: GetAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
+  return get<Req, Res>({ ...options, type: AptosApiType.PEPPER });
+}
+
 /// This function is a helper for paginating using a function wrapping an API
 export async function paginateWithCursor<Req extends Record<string, any>, Res extends Array<{}>>(
   options: GetAptosRequestOptions,

package/src/client/post.ts

@@ -135,3 +135,16 @@ export async function postAptosFaucet<Req extends {}, Res extends {}>(
     },
   });
 }
+
+
+export async function postAptosPepperService<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
+  return post<Req, Res>({ ...options, type: AptosApiType.PEPPER });
+}
+
+export async function postAptosProvingService<Req extends {}, Res extends {}>(
+  options: PostAptosRequestOptions,
+): Promise<AptosResponse<Req, Res>> {
+  return post<Req, Res>({ ...options, type: AptosApiType.PROVER });
+}

package/src/core/crypto/ed25519.ts

@@ -1,18 +1,30 @@
 // Copyright © Aptos Foundation
 // SPDX-License-Identifier: Apache-2.0
 
-import nacl from "tweetnacl";
+import { ed25519 } from "@noble/curves/ed25519";
 import { Deserializer } from "../../bcs/deserializer";
 import { Serializable, Serializer } from "../../bcs/serializer";
 import { AuthenticationKey } from "../authenticationKey";
 import { Hex } from "../hex";
 import { HexInput, SigningScheme as AuthenticationKeyScheme } from "../../types";
-import { CKDPriv, deriveKey, HARDENED_OFFSET, isValidHardenedPath, mnemonicToSeed, splitPath } from "./hdKey";
+import {
+  isValidHardenedPath,
+  fromDerivationPath as fromDerivationPathInner,
+  mnemonicToSeed,
+} from "./hdKey";
 import { PrivateKey } from "./privateKey";
 import { AccountPublicKey, VerifySignatureArgs } from "./publicKey";
 import { Signature } from "./signature";
 import { convertSigningMessage } from "./utils";
 
+/**
+ * L is the value that greater than or equal to will produce a non-canonical signature, and must be rejected
+ */
+const L: number[] = [
+  0xed, 0xd3, 0xf5, 0x5c, 0x1a, 0x63, 0x12, 0x58, 0xd6, 0x9c, 0xf7, 0xa2, 0xde, 0xf9, 0xde, 0x14, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10,
+];
+
 /**
  * Represents the public key of an Ed25519 key pair.
  *
@@ -65,7 +77,12 @@ export class Ed25519PublicKey extends AccountPublicKey {
     const messageBytes = Hex.fromHexInput(messageToVerify).toUint8Array();
     const signatureBytes = signature.toUint8Array();
     const publicKeyBytes = this.key.toUint8Array();
-    return nacl.sign.detached.verify(messageBytes, signatureBytes, publicKeyBytes);
+    // Also verify malleability
+    if (!signature.isCanonicalSignature()) {
+      return false;
+    }
+
+    return ed25519.verify(signatureBytes, messageBytes, publicKeyBytes);
   }
 
   authKey(): AuthenticationKey {
@@ -126,7 +143,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * The Ed25519 signing key
    * @private
    */
-  private readonly signingKeyPair: nacl.SignKeyPair;
+  private readonly signingKey: Hex;
 
   // region Constructors
 
@@ -144,7 +161,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
     }
 
     // Create keyPair from Private key in Uint8Array format
-    this.signingKeyPair = nacl.sign.keyPair.fromSeed(privateKeyHex.toUint8Array().slice(0, Ed25519PrivateKey.LENGTH));
+    this.signingKey = privateKeyHex;
   }
 
   /**
@@ -153,8 +170,8 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * @returns Ed25519PrivateKey
    */
   static generate(): Ed25519PrivateKey {
-    const keyPair = nacl.sign.keyPair();
-    return new Ed25519PrivateKey(keyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH));
+    const keyPair = ed25519.utils.randomPrivateKey();
+    return new Ed25519PrivateKey(keyPair);
   }
 
   /**
@@ -172,29 +189,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
     if (!isValidHardenedPath(path)) {
       throw new Error(`Invalid derivation path ${path}`);
     }
-    return Ed25519PrivateKey.fromDerivationPathInner(path, mnemonicToSeed(mnemonics));
-  }
-
-  /**
-   * 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(path: string, seed: Uint8Array, offset = HARDENED_OFFSET): Ed25519PrivateKey {
-    const { key, chainCode } = deriveKey(Ed25519PrivateKey.SLIP_0010_SEED, seed);
-
-    const segments = splitPath(path).map((el) => parseInt(el, 10));
-
-    // Derive the child key based on the path
-    const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
-      key,
-      chainCode,
-    });
-    return new Ed25519PrivateKey(privateKey);
+    return new Ed25519PrivateKey(fromDerivationPathInner(path, Ed25519PrivateKey.SLIP_0010_SEED, mnemonicToSeed(mnemonics)));
   }
 
   // endregion
@@ -207,7 +202,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * @returns Ed25519PublicKey
    */
   publicKey(): Ed25519PublicKey {
-    const bytes = this.signingKeyPair.publicKey;
+    const bytes = ed25519.getPublicKey(this.signingKey.toUint8Array());
     return new Ed25519PublicKey(bytes);
   }
 
@@ -220,7 +215,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
   sign(message: HexInput): Ed25519Signature {
     const messageToSign = convertSigningMessage(message);
     const messageBytes = Hex.fromHexInput(messageToSign).toUint8Array();
-    const signatureBytes = nacl.sign.detached(messageBytes, this.signingKeyPair.secretKey);
+    const signatureBytes = ed25519.sign(messageBytes, this.signingKey.toUint8Array());
     return new Ed25519Signature(signatureBytes);
   }
 
@@ -230,7 +225,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * @returns Uint8Array representation of the private key
    */
   toUint8Array(): Uint8Array {
-    return this.signingKeyPair.secretKey.slice(0, Ed25519PrivateKey.LENGTH);
+    return this.signingKey.toUint8Array();
   }
 
   /**
@@ -239,7 +234,7 @@ export class Ed25519PrivateKey extends Serializable implements PrivateKey {
    * @returns string representation of the private key
    */
   toString(): string {
-    return Hex.fromHexInput(this.toUint8Array()).toString();
+    return this.signingKey.toString();
   }
 
   // endregion
@@ -312,5 +307,26 @@ export class Ed25519Signature extends Signature {
     return new Ed25519Signature(bytes);
   }
 
+  /**
+   * Checks if an ED25519 signature is non-canonical.
+   *
+   * Comes from Aptos Core
+   * https://github.com/aptos-labs/aptos-core/blob/main/crates/aptos-crypto/src/ed25519/ed25519_sigs.rs#L47-L85
+   */
+  isCanonicalSignature(): boolean {
+    const s = this.toUint8Array().slice(32);
+
+    for (let i = s.length - 1; i >= 0; i -= 1) {
+      if (s[i] < L[i]) {
+        return true;
+      }
+      if (s[i] > L[i]) {
+        return false;
+      }
+    }
+    // As this stage S == L which implies a non-canonical S.
+    return false;
+  }
+
   // endregion
 }

package/src/core/crypto/ephemeral.ts

@@ -0,0 +1,147 @@
+import { Serializer, Deserializer } from "../../bcs";
+import { EphemeralPublicKeyVariant, EphemeralSignatureVariant, HexInput } from "../../types";
+import { PublicKey } from "./publicKey";
+import { Signature } from "./signature";
+import { Ed25519PublicKey, Ed25519Signature } from "./ed25519";
+import { Hex } from "../hex";
+
+/**
+ * Represents ephemeral keys and signatures for Aptos Keyless accounts.
+ *
+ * TODO
+ */
+export class EphemeralPublicKey extends PublicKey {
+  /**
+   * Reference to the inner public key
+   */
+  public readonly publicKey: PublicKey;
+
+  constructor(publicKey: PublicKey) {
+    super();
+    const publicKeyType = publicKey.constructor.name;
+    switch (publicKeyType) {
+      case Ed25519PublicKey.name:
+        this.publicKey = publicKey;
+        break;
+      default:
+        throw new Error(`Unsupported key for EphemeralPublicKey - ${publicKeyType}`);
+    }
+  }
+
+  /**
+   * Get the public key in bytes (Uint8Array).
+   *
+   * @returns Uint8Array representation of the public key
+   */
+  toUint8Array(): Uint8Array {
+    return this.bcsToBytes();
+  }
+
+  /**
+   * Get the public key as a hex string with the 0x prefix.
+   *
+   * @returns string representation of the public key
+   */
+  toString(): string {
+    return this.bcsToHex().toString()
+  }
+
+  /**
+   * 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: EphemeralSignature }): boolean {
+    const { message, signature } = args;
+    return this.publicKey.verifySignature({ message, signature });
+  }
+
+  serialize(serializer: Serializer): void {
+    if (this.publicKey instanceof Ed25519PublicKey) {
+      serializer.serializeU32AsUleb128(EphemeralPublicKeyVariant.Ed25519);
+      this.publicKey.serialize(serializer);
+    } else {
+      throw new Error("Unknown public key type");
+    }
+  }
+
+  static deserialize(deserializer: Deserializer): EphemeralPublicKey {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case EphemeralPublicKeyVariant.Ed25519:
+        return new EphemeralPublicKey(Ed25519PublicKey.deserialize(deserializer));
+      default:
+        throw new Error(`Unknown variant index for EphemeralPublicKey: ${index}`);
+    }
+  }
+
+  static isPublicKey(publicKey: PublicKey): publicKey is EphemeralPublicKey {
+    return publicKey instanceof EphemeralPublicKey;
+  }
+
+  isEd25519(): this is Ed25519PublicKey {
+    return this.publicKey instanceof Ed25519PublicKey;
+  }
+}
+
+
+export class EphemeralSignature extends Signature {
+  public readonly signature: Signature;
+
+  constructor(signature: Signature) {
+    super();
+    const signatureType = signature.constructor.name;
+    switch (signatureType) {
+      case Ed25519Signature.name:
+        this.signature = signature;
+        break;
+      default:
+        throw new Error(`Unsupported signature for EphemeralSignature - ${signatureType}`);
+    }
+  }
+
+  /**
+   * Get the public key in bytes (Uint8Array).
+   *
+   * @returns Uint8Array representation of the public key
+   */
+  toUint8Array(): Uint8Array {
+    return this.signature.toUint8Array();
+  }
+
+  /**
+   * Get the public key as a hex string with the 0x prefix.
+   *
+   * @returns string representation of the public key
+   */
+  toString(): string {
+    return this.signature.toString();
+  }
+
+  static fromHex(hexInput: HexInput): EphemeralSignature {
+    const data = Hex.fromHexInput(hexInput);
+    const deserializer = new Deserializer(data.toUint8Array());
+    return EphemeralSignature.deserialize(deserializer);
+  }
+
+  serialize(serializer: Serializer): void {
+    if (this.signature instanceof Ed25519Signature) {
+      serializer.serializeU32AsUleb128(EphemeralSignatureVariant.Ed25519);
+      this.signature.serialize(serializer);
+    } else {
+      throw new Error("Unknown signature type");
+    }
+  }
+
+  static deserialize(deserializer: Deserializer): EphemeralSignature {
+    const index = deserializer.deserializeUleb128AsU32();
+    switch (index) {
+      case EphemeralSignatureVariant.Ed25519:
+        return new EphemeralSignature(Ed25519Signature.deserialize(deserializer));
+      default:
+        throw new Error(`Unknown variant index for EphemeralSignature: ${index}`);
+    }
+  }
+}

package/src/core/crypto/hdKey.ts

@@ -4,6 +4,7 @@
 import { hmac } from "@noble/hashes/hmac";
 import { sha512 } from "@noble/hashes/sha512";
 import * as bip39 from "@scure/bip39";
+import { HexInput } from "../../types";
 
 export type DerivedKeys = {
   key: Uint8Array;
@@ -15,6 +16,7 @@ export type DerivedKeys = {
  */
 export const APTOS_HARDENED_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+'\/[0-9]+'?$/;
 export const APTOS_BIP44_REGEX = /^m\/44'\/637'\/[0-9]+'\/[0-9]+\/[0-9]+$/;
+export const APTOS_BIP44_DEFAULT_DERIVATION_PATH = "m/44'/637'/0'/0'/0'";
 
 /**
  * A list of supported key types and associated seeds
@@ -91,6 +93,35 @@ const removeApostrophes = (val: string): string => val.replace("'", "");
  */
 export const splitPath = (path: string): Array<string> => path.split("/").slice(1).map(removeApostrophes);
 
+/**
+ * @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
+ */
+export function fromDerivationPath(
+  path: string,
+  hashSeed: HexInput,
+  seed: Uint8Array,
+  offset = HARDENED_OFFSET,
+): Uint8Array {
+  if (offset === HARDENED_OFFSET && !isValidHardenedPath(path)) {
+    throw new Error(`Invalid hardened derivation path ${path}`);
+  } else if (offset !== HARDENED_OFFSET && !isValidBIP44Path(path)) {
+    throw new Error(`Invalid derivation path ${path}`);
+  }
+  const { key, chainCode } = deriveKey(hashSeed, seed);
+
+  const segments = splitPath(path).map((el) => parseInt(el, 10));
+
+  // Derive the child key based on the path
+  const { key: privateKey } = segments.reduce((parentKeys, segment) => CKDPriv(parentKeys, segment + offset), {
+    key,
+    chainCode,
+  });
+  return privateKey;
+}
+
 /**
  * Normalizes the mnemonic by removing extra whitespace and making it lowercase
  * @param mnemonic the mnemonic seed phrase

package/src/core/crypto/index.ts

@@ -5,6 +5,8 @@ export * from "./ed25519";
 export * from "./hdKey";
 export * from "./multiEd25519";
 export * from "./multiKey";
+export * from "./ephemeral";
+export * from "./keyless";
 export * from "./privateKey";
 export * from "./publicKey";
 export * from "./secp256k1";