@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/libs/modules/key-derivation/networks/ada/ada-base-key-derivation.js

@@ -0,0 +1,39 @@
+import { P as PrivateKey } from '../../../../../cardano_serialization_lib-CUQYtJ2C.js';
+import { getNode } from './libs/helpers/get-node.helper.js';
+import { getRootKey } from './libs/helpers/get-root-key.helper.js';
+import { getNodeRawKeys } from './libs/helpers/get-node-raw-keys.helper.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+
+class AdaBaseKeyDerivation {
+  mnemonic;
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  deriveFromMnemonic(parameters) {
+    const entropy = this.mnemonic.getEntropy();
+    const rootKey = getRootKey(entropy);
+    const enterpriseNode = getNode(rootKey, parameters.enterpriseDerivationPath);
+    const rewardNode = getNode(rootKey, parameters.rewardDerivationPath);
+    const { privateKey: enterprisePrivateKey, publicKey: enterprisePublicKey } = getNodeRawKeys(enterpriseNode);
+    const { privateKey: rewardPrivateKey, publicKey: rewardPublicKey } = getNodeRawKeys(rewardNode);
+    return {
+      enterprisePrivateKey: enterprisePrivateKey.to_hex(),
+      enterprisePublicKey: enterprisePublicKey.to_hex(),
+      rewardPrivateKey: rewardPrivateKey.to_hex(),
+      rewardPublicKey: rewardPublicKey.to_hex()
+    };
+  }
+  importByPrivateKey(parameters) {
+    const rawEnterprisePublicKey = PrivateKey.from_hex(parameters.enterprisePrivateKey).to_public();
+    const rawRewardPublicKey = PrivateKey.from_hex(parameters.rewardPrivateKey).to_public();
+    return {
+      enterprisePrivateKey: parameters.enterprisePrivateKey,
+      enterprisePublicKey: rawEnterprisePublicKey.to_hex(),
+      rewardPrivateKey: parameters.rewardPrivateKey,
+      rewardPublicKey: rawRewardPublicKey.to_hex()
+    };
+  }
+}
+
+export { AdaBaseKeyDerivation };

package/build/browser/libs/modules/key-derivation/networks/ada/ada-common-key-derivation.d.ts

@@ -0,0 +1,11 @@
+import { ImportByPrivateKeyParameters, AbstractKeyDerivation, DeriveFromMnemonicParameters } from '../../libs/types/index.js';
+import { GetDerivationTypeUnion, KeyPair } from '../../../../types/types.js';
+import { Mnemonic } from '../../../mnemonic/index.js';
+declare class AdaCommonKeyDerivation implements AbstractKeyDerivation<GetDerivationTypeUnion<"adaEnterprise" | "adaReward">> {
+    private readonly mnemonic;
+    constructor(mnemonic: Mnemonic);
+    deriveFromMnemonic({ derivationPath, }: DeriveFromMnemonicParameters<GetDerivationTypeUnion<"adaEnterprise" | "adaReward">>): KeyPair<GetDerivationTypeUnion<"adaEnterprise" | "adaReward">>;
+    importByPrivateKey({ privateKey, }: ImportByPrivateKeyParameters<GetDerivationTypeUnion<"adaEnterprise" | "adaReward">>): KeyPair<GetDerivationTypeUnion<"adaEnterprise" | "adaReward">> | never;
+}
+export { AdaCommonKeyDerivation };
+//# sourceMappingURL=ada-common-key-derivation.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/ada-common-key-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-common-key-derivation.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/key-derivation/networks/ada/ada-common-key-derivation.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,4BAA4B,EAC5B,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,mDAAmD,CAAC;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AAEjE,cAAM,sBAAuB,YAAW,qBAAqB,CAC3D,sBAAsB,CAAC,eAAe,GAAG,WAAW,CAAC,CACtD;IACC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;gBAEjB,QAAQ,EAAE,QAAQ;IAI9B,kBAAkB,CAAC,EACxB,cAAc,GACf,EAAE,4BAA4B,CAAC,sBAAsB,CAAC,eAAe,GAAG,WAAW,CAAC,CAAC,GAAG,OAAO,CAC9F,sBAAsB,CAAC,eAAe,GAAG,WAAW,CAAC,CACtD;IAaM,kBAAkB,CAAC,EACxB,UAAU,GACX,EAAE,4BAA4B,CAAC,sBAAsB,CAAC,eAAe,GAAG,WAAW,CAAC,CAAC,GAClF,OAAO,CAAC,sBAAsB,CAAC,eAAe,GAAG,WAAW,CAAC,CAAC,GAC9D,KAAK;CAQV;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/ada-common-key-derivation.js

@@ -0,0 +1,37 @@
+import { P as PrivateKey } from '../../../../../cardano_serialization_lib-CUQYtJ2C.js';
+import { getNode } from './libs/helpers/get-node.helper.js';
+import { getRootKey } from './libs/helpers/get-root-key.helper.js';
+import { getNodeRawKeys } from './libs/helpers/get-node-raw-keys.helper.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+import '../../../../../index-CjeBPB5t.js';
+
+class AdaCommonKeyDerivation {
+  mnemonic;
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  deriveFromMnemonic({
+    derivationPath
+  }) {
+    const entropy = this.mnemonic.getEntropy();
+    const rootKey = getRootKey(entropy);
+    const node = getNode(rootKey, derivationPath);
+    const { privateKey, publicKey } = getNodeRawKeys(node);
+    return {
+      privateKey: privateKey.to_hex(),
+      publicKey: publicKey.to_hex()
+    };
+  }
+  importByPrivateKey({
+    privateKey
+  }) {
+    const rawPublicKey = PrivateKey.from_hex(privateKey).to_public();
+    return {
+      privateKey,
+      publicKey: rawPublicKey.to_hex()
+    };
+  }
+}
+
+export { AdaCommonKeyDerivation };

package/build/browser/libs/modules/key-derivation/networks/ada/ada-exodus-key-derivation.d.ts

@@ -0,0 +1,24 @@
+import { ImportByPrivateKeyParameters, AbstractKeyDerivation, DeriveFromMnemonicParameters } from '../../libs/types/index.js';
+import { GetDerivationTypeUnion, KeyPair } from '../../../../types/types.js';
+import { Mnemonic } from '../../../mnemonic/index.js';
+import { Secp256k1Curve } from '../../../curves/curves.js';
+declare class AdaExodusKeyDerivation implements AbstractKeyDerivation<GetDerivationTypeUnion<"adaExodus">> {
+    private readonly mnemonic;
+    private readonly secp256k1Curve;
+    constructor(mnemonic: Mnemonic, secp256k1Curve: Secp256k1Curve);
+    deriveFromMnemonic({ derivationPath, }: DeriveFromMnemonicParameters<GetDerivationTypeUnion<"adaExodus">>): KeyPair<GetDerivationTypeUnion<"adaExodus">>;
+    importByPrivateKey({ privateKey, }: ImportByPrivateKeyParameters<GetDerivationTypeUnion<"adaExodus">>): KeyPair<GetDerivationTypeUnion<"adaExodus">> | never;
+    private clampEd25519SecretKey;
+    /**
+     * Byron legacy master seed (CIP-3 behavior).
+     * HMAC-SHA512:
+     *   key = 32-byte secp child
+     *   msg = "Root Seed Chain " + counter (counter starts at 1)
+     * Split: I = iL || iR
+     * Validity check: clamp(SHA512(iL)[0..31]) and ensure bit 5 of last byte is 0.
+     * If invalid → increment counter and retry.
+     */
+    private deriveByronSecretKey;
+}
+export { AdaExodusKeyDerivation };
+//# sourceMappingURL=ada-exodus-key-derivation.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/ada-exodus-key-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-exodus-key-derivation.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/key-derivation/networks/ada/ada-exodus-key-derivation.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EACV,4BAA4B,EAC5B,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,mDAAmD,CAAC;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAC7E,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAmBtE,cAAM,sBAAuB,YAAW,qBAAqB,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC;IAChG,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;IACpC,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;gBAE7B,QAAQ,EAAE,QAAQ,EAAE,cAAc,EAAE,cAAc;IAK9D,kBAAkB,CAAC,EACxB,cAAc,GACf,EAAE,4BAA4B,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,GAAG,OAAO,CAC5E,sBAAsB,CAAC,WAAW,CAAC,CACpC;IAiBM,kBAAkB,CAAC,EACxB,UAAU,GACX,EAAE,4BAA4B,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,GAChE,OAAO,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,GAC5C,KAAK;IAST,OAAO,CAAC,qBAAqB;IAS7B;;;;;;;;OAQG;IACH,OAAO,CAAC,oBAAoB;CAgC7B;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/ada-exodus-key-derivation.js

@@ -0,0 +1,102 @@
+import { B as Buffer } from '../../../../../index-CjeBPB5t.js';
+import { P as PrivateKey } from '../../../../../cardano_serialization_lib-CUQYtJ2C.js';
+import { c as cryptoBrowserifyExports } from '../../../../../index-B2kUtIg3.js';
+import { KeyDerivationError } from '../../libs/exceptions/key-derivation-error.exception.js';
+import { ExceptionMessage } from './libs/enums/exception-message.enum.js';
+import '../../../../../bip32-CTos7K79.js';
+import '../../../../../ecc-CVvMF8il.js';
+import '../../../../../index-Bsx2kz1h.js';
+import { Ed25519SecretKeyBytePosition } from '../../../curves/ed25519-curve/libs/enums/ed25519-secret-key-byte-position.enum.js';
+import { getSecp256k1NodeFromMnemonic } from '../../libs/helpers/get-secp256k1-node-from-mnemonic.helper.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+
+const Ed25519ClampMask = {
+  LOW: 248,
+  // 248
+  HIGH_CLEAR: 127,
+  // 127
+  HIGH_SET: 64
+  // 64
+};
+const Ed25519SecretKeyByteIndex = {
+  FIRST: 0,
+  LAST: 31
+};
+const SHA512_ALGORITHM = "sha512";
+const BYRON_HMAC_MESSAGE_PREFIX = "Root Seed Chain ";
+const HMAC512_LENGTH = 64;
+const INVALID_SCALAR_BIT_MASK = 32;
+class AdaExodusKeyDerivation {
+  mnemonic;
+  secp256k1Curve;
+  constructor(mnemonic, secp256k1Curve) {
+    this.mnemonic = mnemonic;
+    this.secp256k1Curve = secp256k1Curve;
+  }
+  deriveFromMnemonic({
+    derivationPath
+  }) {
+    const node = getSecp256k1NodeFromMnemonic({
+      derivationPath,
+      mnemonic: this.mnemonic,
+      secp256k1Curve: this.secp256k1Curve
+    });
+    const secretKey = this.deriveByronSecretKey(node.privateKey);
+    const rawPrivateKey = PrivateKey.from_normal_bytes(Buffer.from(secretKey));
+    const rawPublicKey = rawPrivateKey.to_public();
+    return {
+      privateKey: rawPrivateKey.to_hex(),
+      publicKey: rawPublicKey.to_hex()
+    };
+  }
+  importByPrivateKey({
+    privateKey
+  }) {
+    const rawPublicKey = PrivateKey.from_hex(privateKey).to_public();
+    return {
+      privateKey,
+      publicKey: rawPublicKey.to_hex()
+    };
+  }
+  clampEd25519SecretKey(secretKeyBuffer) {
+    const clampedSecretKey = Buffer.from(secretKeyBuffer);
+    clampedSecretKey[Ed25519SecretKeyByteIndex.FIRST] &= Ed25519ClampMask.LOW;
+    clampedSecretKey[Ed25519SecretKeyByteIndex.LAST] &= Ed25519ClampMask.HIGH_CLEAR;
+    clampedSecretKey[Ed25519SecretKeyByteIndex.LAST] |= Ed25519ClampMask.HIGH_SET;
+    return clampedSecretKey;
+  }
+  /**
+   * Byron legacy master seed (CIP-3 behavior).
+   * HMAC-SHA512:
+   *   key = 32-byte secp child
+   *   msg = "Root Seed Chain " + counter (counter starts at 1)
+   * Split: I = iL || iR
+   * Validity check: clamp(SHA512(iL)[0..31]) and ensure bit 5 of last byte is 0.
+   * If invalid → increment counter and retry.
+   */
+  deriveByronSecretKey(bip32Seed) {
+    const hmacKey = Buffer.from(bip32Seed);
+    let counter = 1;
+    while (true) {
+      const message = Buffer.from(`${BYRON_HMAC_MESSAGE_PREFIX}${counter}`, "utf8");
+      const I = cryptoBrowserifyExports.createHmac(SHA512_ALGORITHM, hmacKey).update(message).digest();
+      if (I.length !== HMAC512_LENGTH) {
+        throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+      }
+      const secretKey = I.subarray(
+        Ed25519SecretKeyBytePosition.START,
+        Ed25519SecretKeyBytePosition.END
+      );
+      const hashed = cryptoBrowserifyExports.createHash(SHA512_ALGORITHM).update(secretKey).digest().subarray(Ed25519SecretKeyBytePosition.START, Ed25519SecretKeyBytePosition.END);
+      const candidate = this.clampEd25519SecretKey(hashed);
+      const lastByte = candidate.at(Ed25519SecretKeyByteIndex.LAST);
+      if (lastByte && (lastByte & INVALID_SCALAR_BIT_MASK) === 0) {
+        return Buffer.from(secretKey);
+      }
+      counter += 1;
+    }
+  }
+}
+
+export { AdaExodusKeyDerivation };

package/build/browser/libs/modules/key-derivation/networks/ada/ada-ledger-key-derivation.d.ts

@@ -0,0 +1,14 @@
+import { ImportByPrivateKeyParameters, AbstractKeyDerivation, DeriveFromMnemonicParameters } from '../../libs/types/index.js';
+import { KeyPair } from '../../../../types/types.js';
+import { Mnemonic } from '../../../mnemonic/mnemonic.js';
+declare class AdaLedgerKeyDerivation implements AbstractKeyDerivation<"adaLedger"> {
+    private readonly mnemonic;
+    constructor(mnemonic: Mnemonic);
+    deriveFromMnemonic(parameters: DeriveFromMnemonicParameters<"adaLedger">): KeyPair<"adaLedger">;
+    importByPrivateKey(parameters: ImportByPrivateKeyParameters<"adaLedger">): KeyPair<"adaLedger">;
+    private deriveRootNodeFromSeed;
+    private deriveNodeFromSeed;
+    private derivePrivateChildNode;
+}
+export { AdaLedgerKeyDerivation };
+//# sourceMappingURL=ada-ledger-key-derivation.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/ada-ledger-key-derivation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada-ledger-key-derivation.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/key-derivation/networks/ada/ada-ledger-key-derivation.ts"],"names":[],"mappings":"AAyCA,OAAO,KAAK,EACV,4BAA4B,EAC5B,qBAAqB,EACrB,4BAA4B,EAC7B,MAAM,mDAAmD,CAAC;AAC3D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,KAAK,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAGpE,cAAM,sBAAuB,YAAW,qBAAqB,CAAC,WAAW,CAAC;IACxE,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAW;gBAEjB,QAAQ,EAAE,QAAQ;IAI9B,kBAAkB,CACvB,UAAU,EAAE,4BAA4B,CAAC,WAAW,CAAC,GACpD,OAAO,CAAC,WAAW,CAAC;IAuChB,kBAAkB,CACvB,UAAU,EAAE,4BAA4B,CAAC,WAAW,CAAC,GACpD,OAAO,CAAC,WAAW,CAAC;IAevB,OAAO,CAAC,sBAAsB;IAiF9B,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,sBAAsB;CAuG/B;AAED,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/ada-ledger-key-derivation.js

@@ -0,0 +1,219 @@
+import { P as PrivateKey } from '../../../../../cardano_serialization_lib-CUQYtJ2C.js';
+import { u as utf8ToBytes, c as concatBytes } from '../../../../../utils-BDj4oeIm.js';
+import { getDerivationPathNumericValues } from './libs/helpers/get-derivation-path-numeric-values.helper.js';
+import { HARDENED_RANGE_OFFSET } from '../../../../constants/index.js';
+import '../../../../../index-CjeBPB5t.js';
+import { multiplyEd25519BasePointByScalar } from './libs/helpers/multiply-ed25519-base-point-by-scalar.util.js';
+import { encodeEd25519PointToBytes } from './libs/helpers/encode-ed25519-point-to-bytes.helper.js';
+import { getAdaLedgerExtendedPrivateKeyFromNode } from './libs/helpers/get-ada-ledger-extended-private-key-from-node.helper.js';
+import { ExceptionMessage } from './libs/enums/exception-message.enum.js';
+import { LedgerDerivationHmacPrefix } from './libs/enums/ledger-derivation-hmac-prefix.enum.js';
+import { Ed25519PrivateKeyClamp } from './libs/enums/ed25519-private-key-clamp.enum.js';
+import { ED25519_PUBLIC_KEY_LENGTH_BYTES, LEDGER_CHAIN_CODE_LENGTH_BYTES, ED25519_KEY_PART_LENGTH_BYTES, ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES, ED25519_RESEED_LOOP_THIRD_HIGHEST_BIT_MASK, LEDGER_CHILD_Z_LEFT_LENGTH_BYTES, LEDGER_CHILD_Z_SKIP_LENGTH_BYTES, ED25519_SUBGROUP_ORDER, ED25519_CHILD_LEFT_KEY_MULTIPLIER, ED25519_SEED_KEY_TEXT, LEDGER_ROOT_CHAIN_CODE_PREFIX_BYTE, UINT256_MODULUS } from './libs/constants/constants.js';
+import { hmacSha256 } from './libs/utils/hmac-sha256.util.js';
+import { hmacSha512 } from './libs/utils/hmac-sha512.util.js';
+import { toUint32LittleEndianBytes } from './libs/utils/to-uint32-little-endian-bytes.util.js';
+import { clearBits } from './libs/utils/clear-bits.util.js';
+import { setBits } from './libs/utils/set-bits.util.js';
+import { bytesToBigIntLittleEndian } from './libs/utils/bytes-to-big-int-little-endian.util.js';
+import { areUint8ArraysEqual } from './libs/utils/are-uint8-arrays-equal.util.js';
+import { bigIntToBytesLittleEndian } from './libs/utils/big-int-to-bytes-little-endian.helper.js';
+import { KeyDerivationError } from '../../libs/exceptions/key-derivation-error.exception.js';
+import '../../../../../constructor-parameters.type-KUUHqGZo.js';
+import '../../../mnemonic/libs/enums/exception-message.enum.js';
+
+class AdaLedgerKeyDerivation {
+  mnemonic;
+  constructor(mnemonic) {
+    this.mnemonic = mnemonic;
+  }
+  deriveFromMnemonic(parameters) {
+    const seed = this.mnemonic.getSeed();
+    const enterpriseNode = this.deriveNodeFromSeed(parameters.enterpriseDerivationPath, seed);
+    const rewardNode = this.deriveNodeFromSeed(parameters.rewardDerivationPath, seed);
+    const enterprisePrivateKey = getAdaLedgerExtendedPrivateKeyFromNode(enterpriseNode);
+    const rewardPrivateKey = getAdaLedgerExtendedPrivateKeyFromNode(rewardNode);
+    const enterprisePublicKey = enterprisePrivateKey.to_public();
+    const rewardPublicKey = rewardPrivateKey.to_public();
+    const derivedEnterprisePubBytes = enterprisePublicKey.as_bytes();
+    const derivedRewardPubBytes = rewardPublicKey.as_bytes();
+    if (derivedEnterprisePubBytes.length !== ED25519_PUBLIC_KEY_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_FORMAT_BYTES);
+    }
+    if (derivedRewardPubBytes.length !== ED25519_PUBLIC_KEY_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_FORMAT_BYTES);
+    }
+    if (!areUint8ArraysEqual(derivedEnterprisePubBytes, enterpriseNode.publicKeyBytes)) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_FORMAT_BYTES);
+    }
+    if (!areUint8ArraysEqual(derivedRewardPubBytes, rewardNode.publicKeyBytes)) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_FORMAT_BYTES);
+    }
+    return {
+      enterprisePrivateKey: enterprisePrivateKey.to_hex(),
+      enterprisePublicKey: enterprisePublicKey.to_hex(),
+      rewardPrivateKey: rewardPrivateKey.to_hex(),
+      rewardPublicKey: rewardPublicKey.to_hex()
+    };
+  }
+  importByPrivateKey(parameters) {
+    const enterprisePrivateKey = PrivateKey.from_hex(parameters.enterprisePrivateKey);
+    const rewardPrivateKey = PrivateKey.from_hex(parameters.rewardPrivateKey);
+    const enterprisePublicKey = enterprisePrivateKey.to_public();
+    const rewardPublicKey = rewardPrivateKey.to_public();
+    return {
+      enterprisePrivateKey: enterprisePrivateKey.to_hex(),
+      enterprisePublicKey: enterprisePublicKey.to_hex(),
+      rewardPrivateKey: rewardPrivateKey.to_hex(),
+      rewardPublicKey: rewardPublicKey.to_hex()
+    };
+  }
+  deriveRootNodeFromSeed(seedBytes) {
+    const seedKeyBytes = utf8ToBytes(ED25519_SEED_KEY_TEXT);
+    const rootChainCodeBytes = hmacSha256(
+      seedKeyBytes,
+      concatBytes(new Uint8Array([LEDGER_ROOT_CHAIN_CODE_PREFIX_BYTE]), seedBytes)
+    );
+    if (rootChainCodeBytes.length !== LEDGER_CHAIN_CODE_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    let intermediateHmacOutputBytes = hmacSha512(seedKeyBytes, seedBytes);
+    let leftPrivateKeyBytes = intermediateHmacOutputBytes.slice(0, ED25519_KEY_PART_LENGTH_BYTES);
+    let rightPrivateKeyBytes = intermediateHmacOutputBytes.slice(
+      ED25519_KEY_PART_LENGTH_BYTES,
+      ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES
+    );
+    if (leftPrivateKeyBytes.length !== ED25519_KEY_PART_LENGTH_BYTES || rightPrivateKeyBytes.length !== ED25519_KEY_PART_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    if (leftPrivateKeyBytes[31] === void 0) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    while ((leftPrivateKeyBytes[31] & ED25519_RESEED_LOOP_THIRD_HIGHEST_BIT_MASK) !== 0) {
+      seedBytes = intermediateHmacOutputBytes;
+      intermediateHmacOutputBytes = hmacSha512(seedKeyBytes, seedBytes);
+      leftPrivateKeyBytes = intermediateHmacOutputBytes.slice(0, ED25519_KEY_PART_LENGTH_BYTES);
+      rightPrivateKeyBytes = intermediateHmacOutputBytes.slice(
+        ED25519_KEY_PART_LENGTH_BYTES,
+        ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES
+      );
+    }
+    const clampedLeftPrivateKeyBytes = leftPrivateKeyBytes.slice();
+    if (clampedLeftPrivateKeyBytes[0] === void 0 || clampedLeftPrivateKeyBytes[31] === void 0) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    clampedLeftPrivateKeyBytes[0] = clearBits(
+      clampedLeftPrivateKeyBytes[0],
+      Ed25519PrivateKeyClamp.LOW_3_BITS_MASK
+    );
+    clampedLeftPrivateKeyBytes[31] = clearBits(
+      clampedLeftPrivateKeyBytes[31],
+      Ed25519PrivateKeyClamp.CLEAR_HIGHEST_BIT_MASK
+    );
+    clampedLeftPrivateKeyBytes[31] = setBits(
+      clampedLeftPrivateKeyBytes[31],
+      Ed25519PrivateKeyClamp.SET_SECOND_HIGHEST_BIT_MASK
+    );
+    const leftPrivateKeyScalar = bytesToBigIntLittleEndian(clampedLeftPrivateKeyBytes);
+    const rootPublicPoint = multiplyEd25519BasePointByScalar(leftPrivateKeyScalar);
+    const rootPublicKeyBytes = encodeEd25519PointToBytes(rootPublicPoint);
+    if (rootPublicKeyBytes.length !== ED25519_PUBLIC_KEY_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    return {
+      leftPrivateKeyBytes: clampedLeftPrivateKeyBytes,
+      rightPrivateKeyBytes,
+      publicKeyBytes: rootPublicKeyBytes,
+      chainCodeBytes: rootChainCodeBytes
+    };
+  }
+  deriveNodeFromSeed(derivationPath, seedBytes) {
+    let currentNode = this.deriveRootNodeFromSeed(seedBytes);
+    const derivationPathNumericValues = getDerivationPathNumericValues(derivationPath);
+    for (const derivationPathNumericValue of derivationPathNumericValues) {
+      currentNode = this.derivePrivateChildNode(currentNode, derivationPathNumericValue);
+    }
+    return currentNode;
+  }
+  derivePrivateChildNode(parentNode, childDerivationPathValue) {
+    const { leftPrivateKeyBytes, rightPrivateKeyBytes, publicKeyBytes, chainCodeBytes } = parentNode;
+    const childIndexBytes = toUint32LittleEndianBytes(childDerivationPathValue);
+    const isHardenedDerivation = childDerivationPathValue >= HARDENED_RANGE_OFFSET;
+    let hmacZOutputBytes;
+    let childChainCodeBytes;
+    if (!isHardenedDerivation) {
+      hmacZOutputBytes = hmacSha512(
+        chainCodeBytes,
+        concatBytes(
+          new Uint8Array([LedgerDerivationHmacPrefix.NON_HARDENED_Z]),
+          publicKeyBytes,
+          childIndexBytes
+        )
+      );
+      childChainCodeBytes = hmacSha512(
+        chainCodeBytes,
+        concatBytes(
+          new Uint8Array([LedgerDerivationHmacPrefix.NON_HARDENED_CHAIN_CODE]),
+          publicKeyBytes,
+          childIndexBytes
+        )
+      ).slice(32);
+    } else {
+      const concatenatedPrivateKeyBytes = concatBytes(leftPrivateKeyBytes, rightPrivateKeyBytes);
+      hmacZOutputBytes = hmacSha512(
+        chainCodeBytes,
+        concatBytes(
+          new Uint8Array([LedgerDerivationHmacPrefix.HARDENED_Z]),
+          concatenatedPrivateKeyBytes,
+          childIndexBytes
+        )
+      );
+      childChainCodeBytes = hmacSha512(
+        chainCodeBytes,
+        concatBytes(
+          new Uint8Array([LedgerDerivationHmacPrefix.HARDENED_CHAIN_CODE]),
+          concatenatedPrivateKeyBytes,
+          childIndexBytes
+        )
+      ).slice(32);
+    }
+    if (childChainCodeBytes.length !== LEDGER_CHAIN_CODE_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    const zLeftBytes = hmacZOutputBytes.slice(0, LEDGER_CHILD_Z_LEFT_LENGTH_BYTES);
+    const zRightBytes = hmacZOutputBytes.slice(
+      LEDGER_CHILD_Z_LEFT_LENGTH_BYTES + LEDGER_CHILD_Z_SKIP_LENGTH_BYTES
+    );
+    const zLeftValue = bytesToBigIntLittleEndian(zLeftBytes);
+    const parentLeftPrivateKeyValue = bytesToBigIntLittleEndian(leftPrivateKeyBytes);
+    const childLeftPrivateKeyValue = zLeftValue * ED25519_CHILD_LEFT_KEY_MULTIPLIER + parentLeftPrivateKeyValue;
+    if (childLeftPrivateKeyValue % ED25519_SUBGROUP_ORDER === 0n) {
+      throw new KeyDerivationError(ExceptionMessage.INVALID_DERIVED_ED25519_SCALAR);
+    }
+    const zRightValue = bytesToBigIntLittleEndian(zRightBytes);
+    const parentRightPrivateKeyValue = bytesToBigIntLittleEndian(rightPrivateKeyBytes);
+    const childRightPrivateKeyValue = (zRightValue + parentRightPrivateKeyValue) % UINT256_MODULUS;
+    const childLeftPrivateKeyBytes = bigIntToBytesLittleEndian(
+      childLeftPrivateKeyValue,
+      ED25519_KEY_PART_LENGTH_BYTES
+    );
+    const childRightPrivateKeyBytes = bigIntToBytesLittleEndian(
+      childRightPrivateKeyValue,
+      ED25519_KEY_PART_LENGTH_BYTES
+    );
+    const childLeftPrivateKeyScalar = bytesToBigIntLittleEndian(childLeftPrivateKeyBytes);
+    const childPublicPoint = multiplyEd25519BasePointByScalar(childLeftPrivateKeyScalar);
+    const childPublicKeyBytes = encodeEd25519PointToBytes(childPublicPoint);
+    if (childPublicKeyBytes.length !== ED25519_PUBLIC_KEY_LENGTH_BYTES) {
+      throw new KeyDerivationError(ExceptionMessage.FAILED_TO_CREATE_HMAC512_HASH);
+    }
+    return {
+      leftPrivateKeyBytes: childLeftPrivateKeyBytes,
+      rightPrivateKeyBytes: childRightPrivateKeyBytes,
+      publicKeyBytes: childPublicKeyBytes,
+      chainCodeBytes: childChainCodeBytes
+    };
+  }
+}
+
+export { AdaLedgerKeyDerivation };

package/build/browser/libs/modules/key-derivation/networks/ada/ada.d.ts

@@ -0,0 +1,5 @@
+export { AdaBaseKeyDerivation } from './ada-base-key-derivation.js';
+export { AdaCommonKeyDerivation } from './ada-common-key-derivation.js';
+export { AdaExodusKeyDerivation } from './ada-exodus-key-derivation.js';
+export { AdaLedgerKeyDerivation } from './ada-ledger-key-derivation.js';
+//# sourceMappingURL=ada.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/ada.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ada.d.ts","sourceRoot":"","sources":["../../../../../../../src/libs/modules/key-derivation/networks/ada/ada.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,gCAAgC,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/ada.js

@@ -0,0 +1,4 @@
+export { AdaBaseKeyDerivation } from './ada-base-key-derivation.js';
+export { AdaCommonKeyDerivation } from './ada-common-key-derivation.js';
+export { AdaExodusKeyDerivation } from './ada-exodus-key-derivation.js';
+export { AdaLedgerKeyDerivation } from './ada-ledger-key-derivation.js';

package/build/browser/libs/modules/key-derivation/networks/ada/libs/constants/constants.d.ts

@@ -0,0 +1,15 @@
+declare const ED25519_SEED_KEY_TEXT = "ed25519 seed";
+declare const BITS_PER_BYTE = 8n;
+declare const ED25519_KEY_PART_LENGTH_BYTES = 32;
+declare const ED25519_PUBLIC_KEY_LENGTH_BYTES = 32;
+declare const ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES: number;
+declare const LEDGER_CHAIN_CODE_LENGTH_BYTES = 32;
+declare const ED25519_CHILD_LEFT_KEY_MULTIPLIER = 8n;
+declare const UINT256_MODULUS: bigint;
+declare const ED25519_SUBGROUP_ORDER: bigint;
+declare const LEDGER_ROOT_CHAIN_CODE_PREFIX_BYTE = 1;
+declare const ED25519_RESEED_LOOP_THIRD_HIGHEST_BIT_MASK = 32;
+declare const LEDGER_CHILD_Z_LEFT_LENGTH_BYTES = 28;
+declare const LEDGER_CHILD_Z_SKIP_LENGTH_BYTES = 4;
+export { ED25519_SEED_KEY_TEXT, BITS_PER_BYTE, ED25519_KEY_PART_LENGTH_BYTES, ED25519_PUBLIC_KEY_LENGTH_BYTES, ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES, LEDGER_CHAIN_CODE_LENGTH_BYTES, ED25519_CHILD_LEFT_KEY_MULTIPLIER, UINT256_MODULUS, ED25519_SUBGROUP_ORDER, LEDGER_ROOT_CHAIN_CODE_PREFIX_BYTE, ED25519_RESEED_LOOP_THIRD_HIGHEST_BIT_MASK, LEDGER_CHILD_Z_LEFT_LENGTH_BYTES, LEDGER_CHILD_Z_SKIP_LENGTH_BYTES, };
+//# sourceMappingURL=constants.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/libs/constants/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/ada/libs/constants/constants.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,qBAAqB,iBAAiB,CAAC;AAE7C,QAAA,MAAM,aAAa,KAAK,CAAC;AAEzB,QAAA,MAAM,6BAA6B,KAAK,CAAC;AACzC,QAAA,MAAM,+BAA+B,KAAK,CAAC;AAC3C,QAAA,MAAM,yCAAyC,QAAoC,CAAC;AACpF,QAAA,MAAM,8BAA8B,KAAK,CAAC;AAE1C,QAAA,MAAM,iCAAiC,KAAK,CAAC;AAC7C,QAAA,MAAM,eAAe,QAAa,CAAC;AAEnC,QAAA,MAAM,sBAAsB,QAAyD,CAAC;AAEtF,QAAA,MAAM,kCAAkC,IAAO,CAAC;AAEhD,QAAA,MAAM,0CAA0C,KAAc,CAAC;AAE/D,QAAA,MAAM,gCAAgC,KAAK,CAAC;AAC5C,QAAA,MAAM,gCAAgC,IAAI,CAAC;AAE3C,OAAO,EACL,qBAAqB,EACrB,aAAa,EACb,6BAA6B,EAC7B,+BAA+B,EAC/B,yCAAyC,EACzC,8BAA8B,EAC9B,iCAAiC,EACjC,eAAe,EACf,sBAAsB,EACtB,kCAAkC,EAClC,0CAA0C,EAC1C,gCAAgC,EAChC,gCAAgC,GACjC,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/libs/constants/constants.js

@@ -0,0 +1,15 @@
+const ED25519_SEED_KEY_TEXT = "ed25519 seed";
+const BITS_PER_BYTE = 8n;
+const ED25519_KEY_PART_LENGTH_BYTES = 32;
+const ED25519_PUBLIC_KEY_LENGTH_BYTES = 32;
+const ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES = ED25519_KEY_PART_LENGTH_BYTES * 2;
+const LEDGER_CHAIN_CODE_LENGTH_BYTES = 32;
+const ED25519_CHILD_LEFT_KEY_MULTIPLIER = 8n;
+const UINT256_MODULUS = 1n << 256n;
+const ED25519_SUBGROUP_ORDER = (1n << 252n) + 27742317777372353535851937790883648493n;
+const LEDGER_ROOT_CHAIN_CODE_PREFIX_BYTE = 1;
+const ED25519_RESEED_LOOP_THIRD_HIGHEST_BIT_MASK = 32;
+const LEDGER_CHILD_Z_LEFT_LENGTH_BYTES = 28;
+const LEDGER_CHILD_Z_SKIP_LENGTH_BYTES = 4;
+
+export { BITS_PER_BYTE, ED25519_CHILD_LEFT_KEY_MULTIPLIER, ED25519_EXTENDED_PRIVATE_KEY_LENGTH_BYTES, ED25519_KEY_PART_LENGTH_BYTES, ED25519_PUBLIC_KEY_LENGTH_BYTES, ED25519_RESEED_LOOP_THIRD_HIGHEST_BIT_MASK, ED25519_SEED_KEY_TEXT, ED25519_SUBGROUP_ORDER, LEDGER_CHAIN_CODE_LENGTH_BYTES, LEDGER_CHILD_Z_LEFT_LENGTH_BYTES, LEDGER_CHILD_Z_SKIP_LENGTH_BYTES, LEDGER_ROOT_CHAIN_CODE_PREFIX_BYTE, UINT256_MODULUS };

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/ed25519-private-key-clamp.enum.d.ts

@@ -0,0 +1,7 @@
+declare const Ed25519PrivateKeyClamp: {
+    readonly LOW_3_BITS_MASK: 7;
+    readonly CLEAR_HIGHEST_BIT_MASK: 128;
+    readonly SET_SECOND_HIGHEST_BIT_MASK: 64;
+};
+export { Ed25519PrivateKeyClamp };
+//# sourceMappingURL=ed25519-private-key-clamp.enum.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/ed25519-private-key-clamp.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519-private-key-clamp.enum.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/ada/libs/enums/ed25519-private-key-clamp.enum.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,sBAAsB;;;;CAIlB,CAAC;AAEX,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/ed25519-private-key-clamp.enum.js

@@ -0,0 +1,7 @@
+const Ed25519PrivateKeyClamp = {
+  LOW_3_BITS_MASK: 7,
+  CLEAR_HIGHEST_BIT_MASK: 128,
+  SET_SECOND_HIGHEST_BIT_MASK: 64
+};
+
+export { Ed25519PrivateKeyClamp };

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/enums.d.ts

@@ -0,0 +1,4 @@
+export { ExceptionMessage } from './exception-message.enum.js';
+export { LedgerDerivationHmacPrefix } from './ledger-derivation-hmac-prefix.enum.js';
+export { Ed25519PrivateKeyClamp } from './ed25519-private-key-clamp.enum.js';
+//# sourceMappingURL=enums.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/ada/libs/enums/enums.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAC/D,OAAO,EAAE,0BAA0B,EAAE,MAAM,yCAAyC,CAAC;AACrF,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/enums.js

@@ -0,0 +1,3 @@
+export { ExceptionMessage } from './exception-message.enum.js';
+export { LedgerDerivationHmacPrefix } from './ledger-derivation-hmac-prefix.enum.js';
+export { Ed25519PrivateKeyClamp } from './ed25519-private-key-clamp.enum.js';

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/exception-message.enum.d.ts

@@ -0,0 +1,7 @@
+declare const ExceptionMessage: {
+    readonly FAILED_TO_CREATE_HMAC512_HASH: "Failed to create HMAC-SHA512 hash";
+    readonly FAILED_TO_FORMAT_BYTES: "Failed to format bytes";
+    readonly INVALID_DERIVED_ED25519_SCALAR: "Invalid derived Ed25519 scalar";
+};
+export { ExceptionMessage };
+//# sourceMappingURL=exception-message.enum.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/exception-message.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exception-message.enum.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/ada/libs/enums/exception-message.enum.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,gBAAgB;;;;CAIZ,CAAC;AAEX,OAAO,EAAE,gBAAgB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/exception-message.enum.js

@@ -0,0 +1,7 @@
+const ExceptionMessage = {
+  FAILED_TO_CREATE_HMAC512_HASH: "Failed to create HMAC-SHA512 hash",
+  FAILED_TO_FORMAT_BYTES: "Failed to format bytes",
+  INVALID_DERIVED_ED25519_SCALAR: "Invalid derived Ed25519 scalar"
+};
+
+export { ExceptionMessage };

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/ledger-derivation-hmac-prefix.enum.d.ts

@@ -0,0 +1,8 @@
+declare const LedgerDerivationHmacPrefix: {
+    readonly HARDENED_Z: 0;
+    readonly HARDENED_CHAIN_CODE: 1;
+    readonly NON_HARDENED_Z: 2;
+    readonly NON_HARDENED_CHAIN_CODE: 3;
+};
+export { LedgerDerivationHmacPrefix };
+//# sourceMappingURL=ledger-derivation-hmac-prefix.enum.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/ledger-derivation-hmac-prefix.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ledger-derivation-hmac-prefix.enum.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/ada/libs/enums/ledger-derivation-hmac-prefix.enum.ts"],"names":[],"mappings":"AAAA,QAAA,MAAM,0BAA0B;;;;;CAKtB,CAAC;AAEX,OAAO,EAAE,0BAA0B,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/libs/enums/ledger-derivation-hmac-prefix.enum.js

@@ -0,0 +1,8 @@
+const LedgerDerivationHmacPrefix = {
+  HARDENED_Z: 0,
+  HARDENED_CHAIN_CODE: 1,
+  NON_HARDENED_Z: 2,
+  NON_HARDENED_CHAIN_CODE: 3
+};
+
+export { LedgerDerivationHmacPrefix };

package/build/browser/libs/modules/key-derivation/networks/ada/libs/helpers/encode-ed25519-point-to-bytes.helper.d.ts

@@ -0,0 +1,4 @@
+import { EdwardsPoint } from '@noble/curves/abstract/edwards.js';
+declare function encodeEd25519PointToBytes(point: EdwardsPoint): Uint8Array;
+export { encodeEd25519PointToBytes };
+//# sourceMappingURL=encode-ed25519-point-to-bytes.helper.d.ts.map

package/build/browser/libs/modules/key-derivation/networks/ada/libs/helpers/encode-ed25519-point-to-bytes.helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-ed25519-point-to-bytes.helper.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/libs/modules/key-derivation/networks/ada/libs/helpers/encode-ed25519-point-to-bytes.helper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAGtE,iBAAS,yBAAyB,CAAC,KAAK,EAAE,YAAY,GAAG,UAAU,CAUlE;AAED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}

package/build/browser/libs/modules/key-derivation/networks/ada/libs/helpers/encode-ed25519-point-to-bytes.helper.js

@@ -0,0 +1,13 @@
+import { h as hexToBytes } from '../../../../../../../utils-BDj4oeIm.js';
+
+function encodeEd25519PointToBytes(point) {
+  if (typeof point.toBytes === "function") {
+    return point.toBytes();
+  }
+  if (typeof point.toHex === "function") {
+    return hexToBytes(point.toHex());
+  }
+  throw new Error("Point encoding method not found");
+}
+
+export { encodeEd25519PointToBytes };