@algorandfoundation/algokit-utils 10.0.0-alpha.4 → 10.0.0-alpha.41

package/packages/crypto/src/ed25519.js

@@ -0,0 +1,59 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+let _noble_ed25519 = require("@noble/ed25519");
+_noble_ed25519 = require_runtime.__toESM(_noble_ed25519);
+
+//#region packages/crypto/src/ed25519.ts
+/**
+* Verifies an ed25519 signature using the @noble/ed25519 implementation.
+*
+* @param message - The original message that was signed.
+* @param signature - The ed25519 signature to verify.
+* @returns A promise that resolves to true if the signature is valid, false otherwise.
+*/
+const nobleEd25519Verifier = async (signature, message, pubkey) => {
+	return _noble_ed25519.verifyAsync(signature, message, pubkey);
+};
+/**
+* Verifies an ed25519 signature using the default ed25519 implementation (currently @noble/ed25519).
+* The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Verifier`.
+*
+* @param message - The original message that was signed.
+* @param signature - The ed25519 signature to verify.
+* @returns A promise that resolves to true if the signature is valid, false otherwise.
+*/
+const ed25519Verifier = nobleEd25519Verifier;
+_noble_ed25519.hashes.sha512 = (msg) => (0, _noble_hashes_sha2_js.sha512)(msg);
+/**
+* Generates an ed25519 keypair and a raw signer function using the @noble/ed25519 implementation.
+*
+* @param seed - Optional seed for key generation. If not provided, a random seed will be used.
+* @returns An object containing the ed25519 public key, secret key, and a raw signer function.
+*/
+const nobleEd25519Generator = (seed) => {
+	const ed25519SecretKey = _noble_ed25519.utils.randomSecretKey(seed);
+	const ed25519Pubkey = _noble_ed25519.getPublicKey(ed25519SecretKey);
+	const rawEd25519Signer = async (bytesToSign) => {
+		return _noble_ed25519.signAsync(bytesToSign, ed25519SecretKey);
+	};
+	return {
+		ed25519Pubkey,
+		ed25519SecretKey,
+		rawEd25519Signer
+	};
+};
+/**
+* Generates an ed25519 keypair and a raw signer function using the default ed25519 implementation (currently @noble/ed25519).
+* The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Generator`.
+*
+* @param seed - Optional seed for key generation. If not provided, a random seed will be used.
+* @returns An object containing the ed25519 public key, secret key, and a raw signer function.
+*/
+const ed25519Generator = nobleEd25519Generator;
+
+//#endregion
+exports.ed25519Generator = ed25519Generator;
+exports.ed25519Verifier = ed25519Verifier;
+exports.nobleEd25519Generator = nobleEd25519Generator;
+exports.nobleEd25519Verifier = nobleEd25519Verifier;
+//# sourceMappingURL=ed25519.js.map

package/packages/crypto/src/ed25519.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519.js","names":["ed"],"sources":["../../../../packages/crypto/src/ed25519.ts"],"sourcesContent":["import * as ed from '@noble/ed25519'\nimport { sha512 } from '@noble/hashes/sha2.js'\n\nexport type RawEd25519Verifier = (signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array) => Promise<boolean>\nexport type RawEd25519Signer = (bytesToSign: Uint8Array) => Promise<Uint8Array>\nexport type Ed25519Generator = (seed?: Uint8Array) => {\n  ed25519Pubkey: Uint8Array\n  ed25519SecretKey: Uint8Array\n  rawEd25519Signer: RawEd25519Signer\n}\n\n/**\n * Verifies an ed25519 signature using the @noble/ed25519 implementation.\n *\n * @param message - The original message that was signed.\n * @param signature - The ed25519 signature to verify.\n * @returns A promise that resolves to true if the signature is valid, false otherwise.\n */\nexport const nobleEd25519Verifier: RawEd25519Verifier = async (\n  signature: Uint8Array,\n  message: Uint8Array,\n  pubkey: Uint8Array,\n): Promise<boolean> => {\n  return ed.verifyAsync(signature, message, pubkey)\n}\n\n/**\n * Verifies an ed25519 signature using the default ed25519 implementation (currently @noble/ed25519).\n * The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Verifier`.\n *\n * @param message - The original message that was signed.\n * @param signature - The ed25519 signature to verify.\n * @returns A promise that resolves to true if the signature is valid, false otherwise.\n */\nexport const ed25519Verifier: RawEd25519Verifier = nobleEd25519Verifier\n\ned.hashes.sha512 = (msg: ed.Bytes) => sha512(msg)\n\n/**\n * Generates an ed25519 keypair and a raw signer function using the @noble/ed25519 implementation.\n *\n * @param seed - Optional seed for key generation. If not provided, a random seed will be used.\n * @returns An object containing the ed25519 public key, secret key, and a raw signer function.\n */\nexport const nobleEd25519Generator: Ed25519Generator = (seed?: Uint8Array) => {\n  const ed25519SecretKey = ed.utils.randomSecretKey(seed)\n  const ed25519Pubkey = ed.getPublicKey(ed25519SecretKey)\n\n  const rawEd25519Signer: RawEd25519Signer = async (bytesToSign: Uint8Array): Promise<Uint8Array> => {\n    return ed.signAsync(bytesToSign, ed25519SecretKey)\n  }\n\n  return { ed25519Pubkey, ed25519SecretKey, rawEd25519Signer }\n}\n\n/**\n * Generates an ed25519 keypair and a raw signer function using the default ed25519 implementation (currently @noble/ed25519).\n * The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Generator`.\n *\n * @param seed - Optional seed for key generation. If not provided, a random seed will be used.\n * @returns An object containing the ed25519 public key, secret key, and a raw signer function.\n */\nexport const ed25519Generator: Ed25519Generator = nobleEd25519Generator\n\nexport type Ed25519SigningKey = {\n  ed25519Pubkey: Uint8Array\n  rawEd25519Signer: RawEd25519Signer\n}\n\n/**\n * Represents a 32-byte Ed25519 seed that can be unwrapped for short-lived use and then re-wrapped.\n */\nexport type WrappedEd25519Seed = {\n  /**\n   * Unwraps and returns the 32-byte Ed25519 seed.\n   */\n  unwrapEd25519Seed: () => Promise<Uint8Array>\n  /**\n   * Re-wraps the Ed25519 seed after use.\n   */\n  wrapEd25519Seed: () => Promise<void>\n}\n"],"mappings":";;;;;;;;;;;;;AAkBA,MAAa,uBAA2C,OACtD,WACA,SACA,WACqB;AACrB,QAAOA,eAAG,YAAY,WAAW,SAAS,OAAO;;;;;;;;;;AAWnD,MAAa,kBAAsC;AAEnD,eAAG,OAAO,UAAU,0CAAyB,IAAI;;;;;;;AAQjD,MAAa,yBAA2C,SAAsB;CAC5E,MAAM,mBAAmBA,eAAG,MAAM,gBAAgB,KAAK;CACvD,MAAM,gBAAgBA,eAAG,aAAa,iBAAiB;CAEvD,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,SAAOA,eAAG,UAAU,aAAa,iBAAiB;;AAGpD,QAAO;EAAE;EAAe;EAAkB;EAAkB;;;;;;;;;AAU9D,MAAa,mBAAqC"}

package/packages/crypto/src/ed25519.mjs

@@ -0,0 +1,54 @@
+import { sha512 } from "@noble/hashes/sha2.js";
+import * as ed from "@noble/ed25519";
+
+//#region packages/crypto/src/ed25519.ts
+/**
+* Verifies an ed25519 signature using the @noble/ed25519 implementation.
+*
+* @param message - The original message that was signed.
+* @param signature - The ed25519 signature to verify.
+* @returns A promise that resolves to true if the signature is valid, false otherwise.
+*/
+const nobleEd25519Verifier = async (signature, message, pubkey) => {
+	return ed.verifyAsync(signature, message, pubkey);
+};
+/**
+* Verifies an ed25519 signature using the default ed25519 implementation (currently @noble/ed25519).
+* The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Verifier`.
+*
+* @param message - The original message that was signed.
+* @param signature - The ed25519 signature to verify.
+* @returns A promise that resolves to true if the signature is valid, false otherwise.
+*/
+const ed25519Verifier = nobleEd25519Verifier;
+ed.hashes.sha512 = (msg) => sha512(msg);
+/**
+* Generates an ed25519 keypair and a raw signer function using the @noble/ed25519 implementation.
+*
+* @param seed - Optional seed for key generation. If not provided, a random seed will be used.
+* @returns An object containing the ed25519 public key, secret key, and a raw signer function.
+*/
+const nobleEd25519Generator = (seed) => {
+	const ed25519SecretKey = ed.utils.randomSecretKey(seed);
+	const ed25519Pubkey = ed.getPublicKey(ed25519SecretKey);
+	const rawEd25519Signer = async (bytesToSign) => {
+		return ed.signAsync(bytesToSign, ed25519SecretKey);
+	};
+	return {
+		ed25519Pubkey,
+		ed25519SecretKey,
+		rawEd25519Signer
+	};
+};
+/**
+* Generates an ed25519 keypair and a raw signer function using the default ed25519 implementation (currently @noble/ed25519).
+* The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Generator`.
+*
+* @param seed - Optional seed for key generation. If not provided, a random seed will be used.
+* @returns An object containing the ed25519 public key, secret key, and a raw signer function.
+*/
+const ed25519Generator = nobleEd25519Generator;
+
+//#endregion
+export { ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier };
+//# sourceMappingURL=ed25519.mjs.map

package/packages/crypto/src/ed25519.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ed25519.mjs","names":[],"sources":["../../../../packages/crypto/src/ed25519.ts"],"sourcesContent":["import * as ed from '@noble/ed25519'\nimport { sha512 } from '@noble/hashes/sha2.js'\n\nexport type RawEd25519Verifier = (signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array) => Promise<boolean>\nexport type RawEd25519Signer = (bytesToSign: Uint8Array) => Promise<Uint8Array>\nexport type Ed25519Generator = (seed?: Uint8Array) => {\n  ed25519Pubkey: Uint8Array\n  ed25519SecretKey: Uint8Array\n  rawEd25519Signer: RawEd25519Signer\n}\n\n/**\n * Verifies an ed25519 signature using the @noble/ed25519 implementation.\n *\n * @param message - The original message that was signed.\n * @param signature - The ed25519 signature to verify.\n * @returns A promise that resolves to true if the signature is valid, false otherwise.\n */\nexport const nobleEd25519Verifier: RawEd25519Verifier = async (\n  signature: Uint8Array,\n  message: Uint8Array,\n  pubkey: Uint8Array,\n): Promise<boolean> => {\n  return ed.verifyAsync(signature, message, pubkey)\n}\n\n/**\n * Verifies an ed25519 signature using the default ed25519 implementation (currently @noble/ed25519).\n * The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Verifier`.\n *\n * @param message - The original message that was signed.\n * @param signature - The ed25519 signature to verify.\n * @returns A promise that resolves to true if the signature is valid, false otherwise.\n */\nexport const ed25519Verifier: RawEd25519Verifier = nobleEd25519Verifier\n\ned.hashes.sha512 = (msg: ed.Bytes) => sha512(msg)\n\n/**\n * Generates an ed25519 keypair and a raw signer function using the @noble/ed25519 implementation.\n *\n * @param seed - Optional seed for key generation. If not provided, a random seed will be used.\n * @returns An object containing the ed25519 public key, secret key, and a raw signer function.\n */\nexport const nobleEd25519Generator: Ed25519Generator = (seed?: Uint8Array) => {\n  const ed25519SecretKey = ed.utils.randomSecretKey(seed)\n  const ed25519Pubkey = ed.getPublicKey(ed25519SecretKey)\n\n  const rawEd25519Signer: RawEd25519Signer = async (bytesToSign: Uint8Array): Promise<Uint8Array> => {\n    return ed.signAsync(bytesToSign, ed25519SecretKey)\n  }\n\n  return { ed25519Pubkey, ed25519SecretKey, rawEd25519Signer }\n}\n\n/**\n * Generates an ed25519 keypair and a raw signer function using the default ed25519 implementation (currently @noble/ed25519).\n * The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519Generator`.\n *\n * @param seed - Optional seed for key generation. If not provided, a random seed will be used.\n * @returns An object containing the ed25519 public key, secret key, and a raw signer function.\n */\nexport const ed25519Generator: Ed25519Generator = nobleEd25519Generator\n\nexport type Ed25519SigningKey = {\n  ed25519Pubkey: Uint8Array\n  rawEd25519Signer: RawEd25519Signer\n}\n\n/**\n * Represents a 32-byte Ed25519 seed that can be unwrapped for short-lived use and then re-wrapped.\n */\nexport type WrappedEd25519Seed = {\n  /**\n   * Unwraps and returns the 32-byte Ed25519 seed.\n   */\n  unwrapEd25519Seed: () => Promise<Uint8Array>\n  /**\n   * Re-wraps the Ed25519 seed after use.\n   */\n  wrapEd25519Seed: () => Promise<void>\n}\n"],"mappings":";;;;;;;;;;;AAkBA,MAAa,uBAA2C,OACtD,WACA,SACA,WACqB;AACrB,QAAO,GAAG,YAAY,WAAW,SAAS,OAAO;;;;;;;;;;AAWnD,MAAa,kBAAsC;AAEnD,GAAG,OAAO,UAAU,QAAkB,OAAO,IAAI;;;;;;;AAQjD,MAAa,yBAA2C,SAAsB;CAC5E,MAAM,mBAAmB,GAAG,MAAM,gBAAgB,KAAK;CACvD,MAAM,gBAAgB,GAAG,aAAa,iBAAiB;CAEvD,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,SAAO,GAAG,UAAU,aAAa,iBAAiB;;AAGpD,QAAO;EAAE;EAAe;EAAkB;EAAkB;;;;;;;;;AAU9D,MAAa,mBAAqC"}

package/packages/crypto/src/hash.d.ts

@@ -0,0 +1,8 @@
+//#region packages/crypto/src/hash.d.ts
+/**
+ * Computes an Algorand-compatible SHA-512/256 hash.
+ */
+declare function hash(bytes: Uint8Array): Uint8Array;
+//#endregion
+export { hash };
+//# sourceMappingURL=hash.d.ts.map

package/packages/crypto/src/hash.js

@@ -0,0 +1,15 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_constants = require('../../common/src/constants.js');
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+
+//#region packages/crypto/src/hash.ts
+/**
+* Computes an Algorand-compatible SHA-512/256 hash.
+*/
+function hash(bytes) {
+	return (0, _noble_hashes_sha2_js.sha512_256)(bytes).slice(0, require_constants.HASH_BYTES_LENGTH);
+}
+
+//#endregion
+exports.hash = hash;
+//# sourceMappingURL=hash.js.map

package/packages/crypto/src/hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","names":["HASH_BYTES_LENGTH"],"sources":["../../../../packages/crypto/src/hash.ts"],"sourcesContent":["import { sha512_256 } from '@noble/hashes/sha2.js'\nimport { HASH_BYTES_LENGTH } from '@algorandfoundation/algokit-common'\n\n/**\n * Computes an Algorand-compatible SHA-512/256 hash.\n */\nexport function hash(bytes: Uint8Array): Uint8Array {\n  return sha512_256(bytes).slice(0, HASH_BYTES_LENGTH)\n}\n"],"mappings":";;;;;;;;AAMA,SAAgB,KAAK,OAA+B;AAClD,8CAAkB,MAAM,CAAC,MAAM,GAAGA,oCAAkB"}

package/packages/crypto/src/hash.mjs

@@ -0,0 +1,14 @@
+import { HASH_BYTES_LENGTH } from "../../common/src/constants.mjs";
+import { sha512_256 } from "@noble/hashes/sha2.js";
+
+//#region packages/crypto/src/hash.ts
+/**
+* Computes an Algorand-compatible SHA-512/256 hash.
+*/
+function hash(bytes) {
+	return sha512_256(bytes).slice(0, HASH_BYTES_LENGTH);
+}
+
+//#endregion
+export { hash };
+//# sourceMappingURL=hash.mjs.map

package/packages/crypto/src/hash.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hash.mjs","names":[],"sources":["../../../../packages/crypto/src/hash.ts"],"sourcesContent":["import { sha512_256 } from '@noble/hashes/sha2.js'\nimport { HASH_BYTES_LENGTH } from '@algorandfoundation/algokit-common'\n\n/**\n * Computes an Algorand-compatible SHA-512/256 hash.\n */\nexport function hash(bytes: Uint8Array): Uint8Array {\n  return sha512_256(bytes).slice(0, HASH_BYTES_LENGTH)\n}\n"],"mappings":";;;;;;;AAMA,SAAgB,KAAK,OAA+B;AAClD,QAAO,WAAW,MAAM,CAAC,MAAM,GAAG,kBAAkB"}

package/packages/crypto/src/hd.d.ts

@@ -0,0 +1,40 @@
+import { RawEd25519Signer } from "./ed25519.js";
+
+//#region packages/crypto/src/hd.d.ts
+type BIP44Path = [number, number, number, number, number];
+type HdWalletGenerator = (seed?: Uint8Array) => Promise<{
+  hdRootKey: Uint8Array;
+  accountGenerator: HdAccountGenerator;
+}>;
+type HdAccountGenerator = (account: number, index: number) => Promise<{
+  /** The ed25519 public key corresponding to the generated account and index. */
+  ed25519Pubkey: Uint8Array;
+  /** The extended ed25519 private key (96 bytes for scalar + prefix + chain code) corresponding to the generated account and index. */
+  extendedPrivateKey: Uint8Array;
+  /** The BIP44 path used to derive the key for the generated account and index. */
+  bip44Path: BIP44Path;
+  /** A signer function that can sign bytes using the ed25519 secret key corresponding to the generated account and index. */
+  rawEd25519Signer: RawEd25519Signer;
+}>;
+declare const peikertXHdWalletGenerator: HdWalletGenerator;
+/**
+ * Represents a 96-byte `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code` secret that can be unwrapped
+ * for short-lived use and then re-wrapped.
+ *
+ * It should be noted that the `chain_code` is NOT used for signing. It can, however, be used for key derivation.
+ * If your secret is only used for signing, it is recommended to only store the first 64 bytes in the secret store
+ * and then pad the secret to 96 bytes in the unwrap function
+ */
+type WrappedHdExtendedPrivateKey = {
+  /**
+   * Unwraps and returns the 96-byte HD `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code`.
+   */
+  unwrapHdExtendedPrivateKey: () => Promise<Uint8Array>;
+  /**
+   * Re-wraps the `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code` after use.
+   */
+  wrapHdExtendedPrivateKey: () => Promise<void>;
+};
+//#endregion
+export { BIP44Path, HdAccountGenerator, HdWalletGenerator, WrappedHdExtendedPrivateKey, peikertXHdWalletGenerator };
+//# sourceMappingURL=hd.d.ts.map

package/packages/crypto/src/hd.js

@@ -0,0 +1,37 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+let _algorandfoundation_xhd_wallet_api = require("@algorandfoundation/xhd-wallet-api");
+
+//#region packages/crypto/src/hd.ts
+const xhd = new _algorandfoundation_xhd_wallet_api.XHDWalletAPI();
+const peikertXHdWalletGenerator = async (seed) => {
+	const seedArray = seed ?? new Uint8Array(32);
+	if (seed === void 0) crypto.getRandomValues(seedArray);
+	const rootKey = (0, _algorandfoundation_xhd_wallet_api.fromSeed)(Buffer.from(seedArray));
+	const accountGenerator = async (account, index) => {
+		const ed25519Pubkey = await xhd.keyGen(rootKey, _algorandfoundation_xhd_wallet_api.KeyContext.Address, account, index, _algorandfoundation_xhd_wallet_api.BIP32DerivationType.Peikert);
+		const rawEd25519Signer = async (bytesToSign) => {
+			return xhd.signAlgoTransaction(rootKey, _algorandfoundation_xhd_wallet_api.KeyContext.Address, account, index, bytesToSign, _algorandfoundation_xhd_wallet_api.BIP32DerivationType.Peikert);
+		};
+		const bip44Path = [
+			(0, _algorandfoundation_xhd_wallet_api.harden)(44),
+			(0, _algorandfoundation_xhd_wallet_api.harden)(283),
+			(0, _algorandfoundation_xhd_wallet_api.harden)(account),
+			0,
+			index
+		];
+		return {
+			ed25519Pubkey,
+			rawEd25519Signer,
+			bip44Path,
+			extendedPrivateKey: await xhd.deriveKey(rootKey, bip44Path, true, _algorandfoundation_xhd_wallet_api.BIP32DerivationType.Peikert)
+		};
+	};
+	return {
+		hdRootKey: rootKey,
+		accountGenerator
+	};
+};
+
+//#endregion
+exports.peikertXHdWalletGenerator = peikertXHdWalletGenerator;
+//# sourceMappingURL=hd.js.map

package/packages/crypto/src/hd.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"hd.js","names":["XHDWalletAPI","KeyContext","BIP32DerivationType"],"sources":["../../../../packages/crypto/src/hd.ts"],"sourcesContent":["import { BIP32DerivationType, fromSeed, KeyContext, XHDWalletAPI, harden } from '@algorandfoundation/xhd-wallet-api'\nimport { RawEd25519Signer } from './ed25519'\nexport type BIP44Path = [number, number, number, number, number]\n\nexport type HdWalletGenerator = (seed?: Uint8Array) => Promise<{\n  hdRootKey: Uint8Array\n  accountGenerator: HdAccountGenerator\n}>\n\nexport type HdAccountGenerator = (\n  account: number,\n  index: number,\n) => Promise<{\n  /** The ed25519 public key corresponding to the generated account and index. */\n  ed25519Pubkey: Uint8Array\n  /** The extended ed25519 private key (96 bytes for scalar + prefix + chain code) corresponding to the generated account and index. */\n  extendedPrivateKey: Uint8Array\n  /** The BIP44 path used to derive the key for the generated account and index. */\n  bip44Path: BIP44Path\n  /** A signer function that can sign bytes using the ed25519 secret key corresponding to the generated account and index. */\n  rawEd25519Signer: RawEd25519Signer\n}>\n\nconst xhd = new XHDWalletAPI()\n\nexport const peikertXHdWalletGenerator: HdWalletGenerator = async (seed?: Uint8Array) => {\n  const seedArray = seed ?? new Uint8Array(32)\n  if (seed === undefined) {\n    crypto.getRandomValues(seedArray)\n  }\n\n  const rootKey = fromSeed(Buffer.from(seedArray))\n\n  const accountGenerator: HdAccountGenerator = async (account: number, index: number) => {\n    const ed25519Pubkey = await xhd.keyGen(rootKey, KeyContext.Address, account, index, BIP32DerivationType.Peikert)\n\n    const rawEd25519Signer: RawEd25519Signer = async (bytesToSign: Uint8Array): Promise<Uint8Array> => {\n      return xhd.signAlgoTransaction(rootKey, KeyContext.Address, account, index, bytesToSign, BIP32DerivationType.Peikert)\n    }\n\n    const bip44Path: BIP44Path = [harden(44), harden(283), harden(account), 0, index]\n\n    const xPrv = await xhd.deriveKey(rootKey, bip44Path, true, BIP32DerivationType.Peikert)\n\n    return { ed25519Pubkey, rawEd25519Signer, bip44Path, extendedPrivateKey: xPrv }\n  }\n\n  return { hdRootKey: rootKey, accountGenerator }\n}\n\n/**\n * Represents a 96-byte `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code` secret that can be unwrapped\n * for short-lived use and then re-wrapped.\n *\n * It should be noted that the `chain_code` is NOT used for signing. It can, however, be used for key derivation.\n * If your secret is only used for signing, it is recommended to only store the first 64 bytes in the secret store\n * and then pad the secret to 96 bytes in the unwrap function\n */\nexport type WrappedHdExtendedPrivateKey = {\n  /**\n   * Unwraps and returns the 96-byte HD `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code`.\n   */\n  unwrapHdExtendedPrivateKey: () => Promise<Uint8Array>\n  /**\n   * Re-wraps the `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code` after use.\n   */\n  wrapHdExtendedPrivateKey: () => Promise<void>\n}\n"],"mappings":";;;;AAuBA,MAAM,MAAM,IAAIA,iDAAc;AAE9B,MAAa,4BAA+C,OAAO,SAAsB;CACvF,MAAM,YAAY,QAAQ,IAAI,WAAW,GAAG;AAC5C,KAAI,SAAS,OACX,QAAO,gBAAgB,UAAU;CAGnC,MAAM,2DAAmB,OAAO,KAAK,UAAU,CAAC;CAEhD,MAAM,mBAAuC,OAAO,SAAiB,UAAkB;EACrF,MAAM,gBAAgB,MAAM,IAAI,OAAO,SAASC,8CAAW,SAAS,SAAS,OAAOC,uDAAoB,QAAQ;EAEhH,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,UAAO,IAAI,oBAAoB,SAASD,8CAAW,SAAS,SAAS,OAAO,aAAaC,uDAAoB,QAAQ;;EAGvH,MAAM,YAAuB;kDAAQ,GAAG;kDAAS,IAAI;kDAAS,QAAQ;GAAE;GAAG;GAAM;AAIjF,SAAO;GAAE;GAAe;GAAkB;GAAW,oBAFxC,MAAM,IAAI,UAAU,SAAS,WAAW,MAAMA,uDAAoB,QAAQ;GAER;;AAGjF,QAAO;EAAE,WAAW;EAAS;EAAkB"}

package/packages/crypto/src/hd.mjs

@@ -0,0 +1,36 @@
+import { BIP32DerivationType, KeyContext, XHDWalletAPI, fromSeed, harden } from "@algorandfoundation/xhd-wallet-api";
+
+//#region packages/crypto/src/hd.ts
+const xhd = new XHDWalletAPI();
+const peikertXHdWalletGenerator = async (seed) => {
+	const seedArray = seed ?? new Uint8Array(32);
+	if (seed === void 0) crypto.getRandomValues(seedArray);
+	const rootKey = fromSeed(Buffer.from(seedArray));
+	const accountGenerator = async (account, index) => {
+		const ed25519Pubkey = await xhd.keyGen(rootKey, KeyContext.Address, account, index, BIP32DerivationType.Peikert);
+		const rawEd25519Signer = async (bytesToSign) => {
+			return xhd.signAlgoTransaction(rootKey, KeyContext.Address, account, index, bytesToSign, BIP32DerivationType.Peikert);
+		};
+		const bip44Path = [
+			harden(44),
+			harden(283),
+			harden(account),
+			0,
+			index
+		];
+		return {
+			ed25519Pubkey,
+			rawEd25519Signer,
+			bip44Path,
+			extendedPrivateKey: await xhd.deriveKey(rootKey, bip44Path, true, BIP32DerivationType.Peikert)
+		};
+	};
+	return {
+		hdRootKey: rootKey,
+		accountGenerator
+	};
+};
+
+//#endregion
+export { peikertXHdWalletGenerator };
+//# sourceMappingURL=hd.mjs.map

package/packages/crypto/src/hd.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"hd.mjs","names":[],"sources":["../../../../packages/crypto/src/hd.ts"],"sourcesContent":["import { BIP32DerivationType, fromSeed, KeyContext, XHDWalletAPI, harden } from '@algorandfoundation/xhd-wallet-api'\nimport { RawEd25519Signer } from './ed25519'\nexport type BIP44Path = [number, number, number, number, number]\n\nexport type HdWalletGenerator = (seed?: Uint8Array) => Promise<{\n  hdRootKey: Uint8Array\n  accountGenerator: HdAccountGenerator\n}>\n\nexport type HdAccountGenerator = (\n  account: number,\n  index: number,\n) => Promise<{\n  /** The ed25519 public key corresponding to the generated account and index. */\n  ed25519Pubkey: Uint8Array\n  /** The extended ed25519 private key (96 bytes for scalar + prefix + chain code) corresponding to the generated account and index. */\n  extendedPrivateKey: Uint8Array\n  /** The BIP44 path used to derive the key for the generated account and index. */\n  bip44Path: BIP44Path\n  /** A signer function that can sign bytes using the ed25519 secret key corresponding to the generated account and index. */\n  rawEd25519Signer: RawEd25519Signer\n}>\n\nconst xhd = new XHDWalletAPI()\n\nexport const peikertXHdWalletGenerator: HdWalletGenerator = async (seed?: Uint8Array) => {\n  const seedArray = seed ?? new Uint8Array(32)\n  if (seed === undefined) {\n    crypto.getRandomValues(seedArray)\n  }\n\n  const rootKey = fromSeed(Buffer.from(seedArray))\n\n  const accountGenerator: HdAccountGenerator = async (account: number, index: number) => {\n    const ed25519Pubkey = await xhd.keyGen(rootKey, KeyContext.Address, account, index, BIP32DerivationType.Peikert)\n\n    const rawEd25519Signer: RawEd25519Signer = async (bytesToSign: Uint8Array): Promise<Uint8Array> => {\n      return xhd.signAlgoTransaction(rootKey, KeyContext.Address, account, index, bytesToSign, BIP32DerivationType.Peikert)\n    }\n\n    const bip44Path: BIP44Path = [harden(44), harden(283), harden(account), 0, index]\n\n    const xPrv = await xhd.deriveKey(rootKey, bip44Path, true, BIP32DerivationType.Peikert)\n\n    return { ed25519Pubkey, rawEd25519Signer, bip44Path, extendedPrivateKey: xPrv }\n  }\n\n  return { hdRootKey: rootKey, accountGenerator }\n}\n\n/**\n * Represents a 96-byte `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code` secret that can be unwrapped\n * for short-lived use and then re-wrapped.\n *\n * It should be noted that the `chain_code` is NOT used for signing. It can, however, be used for key derivation.\n * If your secret is only used for signing, it is recommended to only store the first 64 bytes in the secret store\n * and then pad the secret to 96 bytes in the unwrap function\n */\nexport type WrappedHdExtendedPrivateKey = {\n  /**\n   * Unwraps and returns the 96-byte HD `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code`.\n   */\n  unwrapHdExtendedPrivateKey: () => Promise<Uint8Array>\n  /**\n   * Re-wraps the `scalar (aka LHS or zL) || prefix (aka RHS or zR) || chain_code` after use.\n   */\n  wrapHdExtendedPrivateKey: () => Promise<void>\n}\n"],"mappings":";;;AAuBA,MAAM,MAAM,IAAI,cAAc;AAE9B,MAAa,4BAA+C,OAAO,SAAsB;CACvF,MAAM,YAAY,QAAQ,IAAI,WAAW,GAAG;AAC5C,KAAI,SAAS,OACX,QAAO,gBAAgB,UAAU;CAGnC,MAAM,UAAU,SAAS,OAAO,KAAK,UAAU,CAAC;CAEhD,MAAM,mBAAuC,OAAO,SAAiB,UAAkB;EACrF,MAAM,gBAAgB,MAAM,IAAI,OAAO,SAAS,WAAW,SAAS,SAAS,OAAO,oBAAoB,QAAQ;EAEhH,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,UAAO,IAAI,oBAAoB,SAAS,WAAW,SAAS,SAAS,OAAO,aAAa,oBAAoB,QAAQ;;EAGvH,MAAM,YAAuB;GAAC,OAAO,GAAG;GAAE,OAAO,IAAI;GAAE,OAAO,QAAQ;GAAE;GAAG;GAAM;AAIjF,SAAO;GAAE;GAAe;GAAkB;GAAW,oBAFxC,MAAM,IAAI,UAAU,SAAS,WAAW,MAAM,oBAAoB,QAAQ;GAER;;AAGjF,QAAO;EAAE,WAAW;EAAS;EAAkB"}

package/packages/crypto/src/index.d.ts

@@ -0,0 +1,28 @@
+import { Ed25519Generator, Ed25519SigningKey, RawEd25519Signer, RawEd25519Verifier, WrappedEd25519Seed, ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier } from "./ed25519.js";
+import { BIP44Path, HdAccountGenerator, HdWalletGenerator, WrappedHdExtendedPrivateKey, peikertXHdWalletGenerator } from "./hd.js";
+import { hash } from "./hash.js";
+
+//#region packages/crypto/src/index.d.ts
+type WrappedEd25519Secret = WrappedEd25519Seed | WrappedHdExtendedPrivateKey;
+/**
+ * Creates an Ed25519 signing key from a wrapped secret using the @noble/ed25519 implementation.
+ *
+ * NOTE: This function will zero out the unwrapped secret after the wrap function is called.
+ *
+ * @param wrapUnwrap - The wrapped secret provider that unwraps and re-wraps the Ed25519 secret.
+ * @returns A promise that resolves to an Ed25519 signing key containing the public key and raw signer.
+ */
+declare const nobleEd25519SigningKeyFromWrappedSecret: (wrapUnwrap: WrappedEd25519Secret) => Promise<Ed25519SigningKey>;
+/**
+ * Creates an ed25519 signing key from a wrapped secret using the default ed25519 implementation (currently @noble/ed25519).
+ * The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519SigningKeyFromWrappedSecret`.
+ *
+ * NOTE: This function will zero out the unwrapped secret after the wrap function is called.
+ *
+ * @param wrapUnwrap - The wrapped secret provider that unwraps and re-wraps the ed25519 secret.
+ * @returns A promise that resolves to an ed25519 signing key with public key and raw signer.
+ */
+declare const ed25519SigningKeyFromWrappedSecret: (wrapUnwrap: WrappedEd25519Secret) => Promise<Ed25519SigningKey>;
+//#endregion
+export { WrappedEd25519Secret, ed25519SigningKeyFromWrappedSecret, nobleEd25519SigningKeyFromWrappedSecret };
+//# sourceMappingURL=index.d.ts.map

package/packages/crypto/src/index.js

@@ -0,0 +1,141 @@
+const require_runtime = require('../../../_virtual/_rolldown/runtime.js');
+const require_utils = require('../../../node_modules/@noble/curves/utils.js');
+const require_modular = require('../../../node_modules/@noble/curves/abstract/modular.js');
+const require_ed25519 = require('../../../node_modules/@noble/curves/ed25519.js');
+const require_ed25519$1 = require('./ed25519.js');
+const require_hash = require('./hash.js');
+const require_hd = require('./hd.js');
+let _noble_hashes_sha2_js = require("@noble/hashes/sha2.js");
+let _noble_ed25519 = require("@noble/ed25519");
+_noble_ed25519 = require_runtime.__toESM(_noble_ed25519);
+
+//#region packages/crypto/src/index.ts
+const ED25519_SEED_LENGTH = 32;
+const ED25519_EXTENDED_PRIVATE_KEY_LENGTH = 96;
+const assertEd25519SecretLength = (secret, secretType) => {
+	let expectedLength;
+	switch (secretType) {
+		case "ed25519 seed":
+			expectedLength = ED25519_SEED_LENGTH;
+			break;
+		case "HD extended key":
+			expectedLength = ED25519_EXTENDED_PRIVATE_KEY_LENGTH;
+			break;
+		default: throw new Error(`Unknown secret type: ${secretType}`);
+	}
+	if (secret.length !== expectedLength) throw new Error(`Expected unwrapped ${secretType} to be ${expectedLength} bytes, got ${secret.length}.`);
+};
+const throwWrapUnwrapErrors = (operationError, wrapError, operationName) => {
+	throw new AggregateError([operationError, wrapError], `${operationName} failed and failed to re-wrap Ed25519 secret. Check both errors for details.`);
+};
+function rawSign(extendedSecretKey, data) {
+	const scalar = require_utils.bytesToNumberLE(extendedSecretKey.slice(0, 32));
+	const kR = extendedSecretKey.slice(32, 64);
+	const publicKey = rawPubkey(extendedSecretKey);
+	const r = require_modular.mod(require_utils.bytesToNumberLE((0, _noble_hashes_sha2_js.sha512)(new Uint8Array([...kR, ...data]))), require_ed25519.ed25519.Point.Fn.ORDER);
+	const R = require_ed25519.ed25519.Point.BASE.multiply(r);
+	const S = require_modular.mod(r + require_modular.mod(require_utils.bytesToNumberLE((0, _noble_hashes_sha2_js.sha512)(new Uint8Array([
+		...R.toBytes(),
+		...publicKey,
+		...data
+	]))), require_ed25519.ed25519.Point.Fn.ORDER) * scalar, require_ed25519.ed25519.Point.Fn.ORDER);
+	return new Uint8Array([...R.toBytes(), ...require_utils.numberToBytesLE(S, 32)]);
+}
+function rawPubkey(extendedSecretKey) {
+	const reducedScalar = require_modular.mod(require_utils.bytesToNumberLE(extendedSecretKey.slice(0, 32)) & (1n << 255n) - 1n, require_ed25519.ed25519.Point.Fn.ORDER);
+	return require_ed25519.ed25519.Point.BASE.multiply(reducedScalar).toBytes();
+}
+/**
+* Creates an Ed25519 signing key from a wrapped secret using the @noble/ed25519 implementation.
+*
+* NOTE: This function will zero out the unwrapped secret after the wrap function is called.
+*
+* @param wrapUnwrap - The wrapped secret provider that unwraps and re-wraps the Ed25519 secret.
+* @returns A promise that resolves to an Ed25519 signing key containing the public key and raw signer.
+*/
+const nobleEd25519SigningKeyFromWrappedSecret = async (wrapUnwrap) => {
+	let wrapFunction;
+	if ("wrapEd25519Seed" in wrapUnwrap) wrapFunction = wrapUnwrap.wrapEd25519Seed;
+	else if ("wrapHdExtendedPrivateKey" in wrapUnwrap) wrapFunction = wrapUnwrap.wrapHdExtendedPrivateKey;
+	else throw new Error("Invalid WrappedEd25519Secret: missing wrap function");
+	const signer = async (bytesToSign) => {
+		let secret = void 0;
+		let signature = void 0;
+		let signingError;
+		let wrapError;
+		try {
+			if ("unwrapEd25519Seed" in wrapUnwrap) {
+				secret = await wrapUnwrap.unwrapEd25519Seed();
+				assertEd25519SecretLength(secret, "ed25519 seed");
+				signature = await _noble_ed25519.signAsync(bytesToSign, secret);
+			} else if ("unwrapHdExtendedPrivateKey" in wrapUnwrap) {
+				secret = await wrapUnwrap.unwrapHdExtendedPrivateKey();
+				assertEd25519SecretLength(secret, "HD extended key");
+				signature = rawSign(secret.slice(0, 64), bytesToSign);
+			} else throw new Error("Invalid WrappedEd25519Secret: missing unwrap function");
+		} catch (error) {
+			signingError = error;
+		} finally {
+			try {
+				await wrapFunction();
+			} catch (error) {
+				wrapError = error;
+			} finally {
+				secret?.fill(0);
+			}
+		}
+		if (signingError !== void 0 && wrapError !== void 0) throwWrapUnwrapErrors(signingError, wrapError, "Signing");
+		if (signingError !== void 0) throw signingError;
+		if (wrapError !== void 0) throw wrapError;
+		if (signature === void 0) throw new Error("Signing failed unexpectedly without an error.");
+		return signature;
+	};
+	let pubkey = void 0;
+	let pubkeyError;
+	let wrapError;
+	let secret = void 0;
+	try {
+		if ("unwrapEd25519Seed" in wrapUnwrap) {
+			secret = await wrapUnwrap.unwrapEd25519Seed();
+			assertEd25519SecretLength(secret, "ed25519 seed");
+			pubkey = await _noble_ed25519.getPublicKeyAsync(secret);
+		} else if ("unwrapHdExtendedPrivateKey" in wrapUnwrap) {
+			secret = await wrapUnwrap.unwrapHdExtendedPrivateKey();
+			assertEd25519SecretLength(secret, "HD extended key");
+			pubkey = rawPubkey(secret.slice(0, 64));
+		} else throw new Error("Invalid WrappedEd25519Secret: missing unwrap function");
+	} catch (error) {
+		pubkeyError = error;
+	} finally {
+		try {
+			await wrapFunction();
+		} catch (error) {
+			wrapError = error;
+		} finally {
+			secret?.fill(0);
+		}
+	}
+	if (pubkeyError !== void 0 && wrapError !== void 0) throwWrapUnwrapErrors(pubkeyError, wrapError, "Deriving Ed25519 public key");
+	if (pubkeyError !== void 0) throw pubkeyError;
+	if (wrapError !== void 0) throw wrapError;
+	if (pubkey === void 0) throw new Error("Deriving Ed25519 public key failed unexpectedly without an error.");
+	return {
+		ed25519Pubkey: pubkey,
+		rawEd25519Signer: signer
+	};
+};
+/**
+* Creates an ed25519 signing key from a wrapped secret using the default ed25519 implementation (currently @noble/ed25519).
+* The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519SigningKeyFromWrappedSecret`.
+*
+* NOTE: This function will zero out the unwrapped secret after the wrap function is called.
+*
+* @param wrapUnwrap - The wrapped secret provider that unwraps and re-wraps the ed25519 secret.
+* @returns A promise that resolves to an ed25519 signing key with public key and raw signer.
+*/
+const ed25519SigningKeyFromWrappedSecret = nobleEd25519SigningKeyFromWrappedSecret;
+
+//#endregion
+exports.ed25519SigningKeyFromWrappedSecret = ed25519SigningKeyFromWrappedSecret;
+exports.nobleEd25519SigningKeyFromWrappedSecret = nobleEd25519SigningKeyFromWrappedSecret;
+//# sourceMappingURL=index.js.map

package/packages/crypto/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["bytesToNumberLE","mod","ed25519","numberToBytesLE","ed"],"sources":["../../../../packages/crypto/src/index.ts"],"sourcesContent":["import { Ed25519SigningKey, WrappedEd25519Seed } from './ed25519'\nimport * as ed from '@noble/ed25519'\nimport { WrappedHdExtendedPrivateKey } from './hd'\nimport { ed25519 } from '@noble/curves/ed25519.js'\nimport { sha512 } from '@noble/hashes/sha2.js'\nimport { bytesToNumberLE, numberToBytesLE } from '@noble/curves/utils.js'\nimport { mod } from '@noble/curves/abstract/modular.js'\n\nexport * from './ed25519'\nexport * from './hash'\nexport * from './hd'\n\nexport type WrappedEd25519Secret = WrappedEd25519Seed | WrappedHdExtendedPrivateKey\n\nconst ED25519_SEED_LENGTH = 32\nconst ED25519_EXTENDED_PRIVATE_KEY_LENGTH = 96\n\nconst assertEd25519SecretLength = (secret: Uint8Array, secretType: 'ed25519 seed' | 'HD extended key'): void => {\n  let expectedLength: number\n  switch (secretType) {\n    case 'ed25519 seed':\n      expectedLength = ED25519_SEED_LENGTH\n      break\n    case 'HD extended key':\n      expectedLength = ED25519_EXTENDED_PRIVATE_KEY_LENGTH\n      break\n    default:\n      throw new Error(`Unknown secret type: ${secretType}`)\n  }\n\n  if (secret.length !== expectedLength) {\n    throw new Error(`Expected unwrapped ${secretType} to be ${expectedLength} bytes, got ${secret.length}.`)\n  }\n}\n\nconst throwWrapUnwrapErrors = (operationError: unknown, wrapError: unknown, operationName: string): never => {\n  throw new AggregateError(\n    [operationError, wrapError],\n    `${operationName} failed and failed to re-wrap Ed25519 secret. Check both errors for details.`,\n  )\n}\n\nfunction rawSign(extendedSecretKey: Uint8Array, data: Uint8Array): Uint8Array {\n  const scalar = bytesToNumberLE(extendedSecretKey.slice(0, 32))\n\n  const kR = extendedSecretKey.slice(32, 64)\n\n  // (1): pubKey = scalar * G\n  const publicKey = rawPubkey(extendedSecretKey)\n\n  // (2): h = hash(kR || msg) mod q\n  const rHash = sha512(new Uint8Array([...kR, ...data]))\n  const r = mod(bytesToNumberLE(rHash), ed25519.Point.Fn.ORDER)\n\n  // (4): R = r * G\n  const R = ed25519.Point.BASE.multiply(r)\n\n  // h = hash(R || pubKey || msg) mod q\n  const hHash = sha512(new Uint8Array([...R.toBytes(), ...publicKey, ...data]))\n  const h = mod(bytesToNumberLE(hHash), ed25519.Point.Fn.ORDER)\n\n  // (5): S = (r + h * k) mod q\n  const S = mod(r + h * scalar, ed25519.Point.Fn.ORDER)\n\n  return new Uint8Array([...R.toBytes(), ...numberToBytesLE(S, 32)])\n}\n\nfunction rawPubkey(extendedSecretKey: Uint8Array): Uint8Array {\n  const scalar = bytesToNumberLE(extendedSecretKey.slice(0, 32))\n  const clearedTopBitScalar = scalar & ((1n << 255n) - 1n)\n  const reducedScalar = mod(clearedTopBitScalar, ed25519.Point.Fn.ORDER)\n\n  // pubKey = scalar * G\n  const publicKey = ed25519.Point.BASE.multiply(reducedScalar)\n  return publicKey.toBytes()\n}\n\n/**\n * Creates an Ed25519 signing key from a wrapped secret using the @noble/ed25519 implementation.\n *\n * NOTE: This function will zero out the unwrapped secret after the wrap function is called.\n *\n * @param wrapUnwrap - The wrapped secret provider that unwraps and re-wraps the Ed25519 secret.\n * @returns A promise that resolves to an Ed25519 signing key containing the public key and raw signer.\n */\nexport const nobleEd25519SigningKeyFromWrappedSecret = async (wrapUnwrap: WrappedEd25519Secret): Promise<Ed25519SigningKey> => {\n  let wrapFunction: () => Promise<void>\n  if ('wrapEd25519Seed' in wrapUnwrap) {\n    wrapFunction = wrapUnwrap.wrapEd25519Seed\n  } else if ('wrapHdExtendedPrivateKey' in wrapUnwrap) {\n    wrapFunction = wrapUnwrap.wrapHdExtendedPrivateKey\n  } else {\n    throw new Error('Invalid WrappedEd25519Secret: missing wrap function')\n  }\n\n  const signer = async (bytesToSign: Uint8Array): Promise<Uint8Array> => {\n    let secret: Uint8Array | undefined = undefined\n    let signature: Uint8Array | undefined = undefined\n    let signingError: unknown\n    let wrapError: unknown\n    try {\n      if ('unwrapEd25519Seed' in wrapUnwrap) {\n        secret = await wrapUnwrap.unwrapEd25519Seed()\n        assertEd25519SecretLength(secret, 'ed25519 seed')\n        signature = await ed.signAsync(bytesToSign, secret)\n      } else if ('unwrapHdExtendedPrivateKey' in wrapUnwrap) {\n        secret = await wrapUnwrap.unwrapHdExtendedPrivateKey()\n        assertEd25519SecretLength(secret, 'HD extended key')\n        signature = rawSign(secret.slice(0, 64), bytesToSign)\n      } else {\n        throw new Error('Invalid WrappedEd25519Secret: missing unwrap function')\n      }\n    } catch (error) {\n      signingError = error\n    } finally {\n      try {\n        await wrapFunction()\n      } catch (error) {\n        wrapError = error\n      } finally {\n        secret?.fill(0)\n      }\n    }\n\n    if (signingError !== undefined && wrapError !== undefined) {\n      throwWrapUnwrapErrors(signingError, wrapError, 'Signing')\n    }\n\n    if (signingError !== undefined) {\n      throw signingError\n    }\n\n    if (wrapError !== undefined) {\n      throw wrapError\n    }\n\n    if (signature === undefined) {\n      throw new Error('Signing failed unexpectedly without an error.')\n    }\n\n    return signature\n  }\n\n  let pubkey: Uint8Array | undefined = undefined\n  let pubkeyError: unknown\n  let wrapError: unknown\n  let secret: Uint8Array | undefined = undefined\n  try {\n    if ('unwrapEd25519Seed' in wrapUnwrap) {\n      secret = await wrapUnwrap.unwrapEd25519Seed()\n      assertEd25519SecretLength(secret, 'ed25519 seed')\n      pubkey = await ed.getPublicKeyAsync(secret)\n    } else if ('unwrapHdExtendedPrivateKey' in wrapUnwrap) {\n      secret = await wrapUnwrap.unwrapHdExtendedPrivateKey()\n      assertEd25519SecretLength(secret, 'HD extended key')\n      pubkey = rawPubkey(secret.slice(0, 64))\n    } else {\n      throw new Error('Invalid WrappedEd25519Secret: missing unwrap function')\n    }\n  } catch (error) {\n    pubkeyError = error\n  } finally {\n    try {\n      await wrapFunction()\n    } catch (error) {\n      wrapError = error\n    } finally {\n      secret?.fill(0)\n    }\n  }\n\n  if (pubkeyError !== undefined && wrapError !== undefined) {\n    throwWrapUnwrapErrors(pubkeyError, wrapError, 'Deriving Ed25519 public key')\n  }\n\n  if (pubkeyError !== undefined) {\n    throw pubkeyError\n  }\n\n  if (wrapError !== undefined) {\n    throw wrapError\n  }\n\n  if (pubkey === undefined) {\n    throw new Error('Deriving Ed25519 public key failed unexpectedly without an error.')\n  }\n\n  return {\n    ed25519Pubkey: pubkey,\n    rawEd25519Signer: signer,\n  }\n}\n\n/**\n * Creates an ed25519 signing key from a wrapped secret using the default ed25519 implementation (currently @noble/ed25519).\n * The implementation may change in the future. To explicitly use the @noble/ed25519 implementation, use `nobleEd25519SigningKeyFromWrappedSecret`.\n *\n * NOTE: This function will zero out the unwrapped secret after the wrap function is called.\n *\n * @param wrapUnwrap - The wrapped secret provider that unwraps and re-wraps the ed25519 secret.\n * @returns A promise that resolves to an ed25519 signing key with public key and raw signer.\n */\nexport const ed25519SigningKeyFromWrappedSecret = nobleEd25519SigningKeyFromWrappedSecret\n"],"mappings":"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"}