@algorandfoundation/algokit-utils 10.0.0-alpha.39 → 10.0.0-alpha.40

package/algorand-client-transaction-creator.d.ts

@@ -568,7 +568,6 @@ declare class AlgorandClientTransactionCreator {
    * @returns The application ABI method create transaction
    */
   appCreateMethodCall: (params: {
-    appId?: 0 | undefined;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -580,6 +579,7 @@ declare class AlgorandClientTransactionCreator {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId?: 0 | undefined;
     onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.UpdateApplication | OnApplicationComplete.DeleteApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;
@@ -649,7 +649,6 @@ declare class AlgorandClientTransactionCreator {
    * @returns The application ABI method update transaction
    */
   appUpdateMethodCall: (params: {
-    appId: bigint;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -661,6 +660,7 @@ declare class AlgorandClientTransactionCreator {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId: bigint;
     onComplete?: OnApplicationComplete.UpdateApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;
@@ -721,7 +721,6 @@ declare class AlgorandClientTransactionCreator {
    * @returns The application ABI method delete transaction
    */
   appDeleteMethodCall: (params: {
-    appId: bigint;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -733,6 +732,7 @@ declare class AlgorandClientTransactionCreator {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId: bigint;
     onComplete?: OnApplicationComplete.DeleteApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;
@@ -791,7 +791,6 @@ declare class AlgorandClientTransactionCreator {
    * @returns The application ABI method call transaction
    */
   appCallMethodCall: (params: {
-    appId: bigint;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -803,6 +802,7 @@ declare class AlgorandClientTransactionCreator {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId: bigint;
     onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;

package/algorand-client-transaction-sender.d.ts

@@ -746,7 +746,6 @@ declare class AlgorandClientTransactionSender {
    * @returns The result of the application ABI method create transaction and the transaction that was sent
    */
   appCreateMethodCall: (params: {
-    appId?: 0 | undefined;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -758,6 +757,7 @@ declare class AlgorandClientTransactionSender {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId?: 0 | undefined;
     onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.UpdateApplication | OnApplicationComplete.DeleteApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;
@@ -834,7 +834,6 @@ declare class AlgorandClientTransactionSender {
    * @returns The result of the application ABI method update transaction and the transaction that was sent
    */
   appUpdateMethodCall: (params: {
-    appId: bigint;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -846,6 +845,7 @@ declare class AlgorandClientTransactionSender {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId: bigint;
     onComplete?: OnApplicationComplete.UpdateApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;
@@ -913,7 +913,6 @@ declare class AlgorandClientTransactionSender {
    * @returns The result of the application ABI method delete transaction and the transaction that was sent
    */
   appDeleteMethodCall: (params: {
-    appId: bigint;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -925,6 +924,7 @@ declare class AlgorandClientTransactionSender {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId: bigint;
     onComplete?: OnApplicationComplete.DeleteApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;
@@ -990,7 +990,6 @@ declare class AlgorandClientTransactionSender {
    * @returns The result of the application ABI method call transaction and the transaction that was sent
    */
   appCallMethodCall: (params: {
-    appId: bigint;
     sender: SendingAddress;
     signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
     rekeyTo?: ReadableAddress | undefined;
@@ -1002,6 +1001,7 @@ declare class AlgorandClientTransactionSender {
     validityWindow?: number | bigint | undefined;
     firstValidRound?: bigint | undefined;
     lastValidRound?: bigint | undefined;
+    appId: bigint;
     onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
     accountReferences?: ReadableAddress[] | undefined;
     appReferences?: bigint[] | undefined;

package/app-client.d.ts

@@ -458,7 +458,7 @@ declare class AppClient {
       signer: AddressWithTransactionSigner | TransactionSigner | undefined;
       method: ABIMethod;
       onComplete: OnApplicationComplete.UpdateApplication;
-      args: (Transaction | TransactionWithSigner | Promise<Transaction> | ABIValue | AppMethodCall<{
+      args: (Transaction | ABIValue | TransactionWithSigner | AppMethodCall<{
         sender: SendingAddress;
         signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
         rekeyTo?: ReadableAddress | undefined;
@@ -511,7 +511,7 @@ declare class AppClient {
         rejectVersion?: number | undefined;
         approvalProgram: string | Uint8Array;
         clearStateProgram: string | Uint8Array;
-      }> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+      }> | AppMethodCall<AppMethodCallParams> | Promise<Transaction> | undefined)[] | undefined;
     }>;
     /**
      * Return params for an opt-in ABI call
@@ -519,7 +519,6 @@ declare class AppClient {
      * @returns The parameters which can be used to create an opt-in ABI method call
      */
     optIn: (params: AppClientMethodCallParams) => Promise<{
-      appId: bigint;
       sender: SendingAddress;
       signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
       rekeyTo?: ReadableAddress | undefined;
@@ -531,6 +530,7 @@ declare class AppClient {
       validityWindow?: number | bigint | undefined;
       firstValidRound?: bigint | undefined;
       lastValidRound?: bigint | undefined;
+      appId: bigint;
       onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
       accountReferences?: ReadableAddress[] | undefined;
       appReferences?: bigint[] | undefined;
@@ -547,7 +547,6 @@ declare class AppClient {
      * @returns The parameters which can be used to create a delete ABI method call
      */
     delete: (params: AppClientMethodCallParams) => Promise<{
-      appId: bigint;
       sender: SendingAddress;
       signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
       rekeyTo?: ReadableAddress | undefined;
@@ -559,6 +558,7 @@ declare class AppClient {
       validityWindow?: number | bigint | undefined;
       firstValidRound?: bigint | undefined;
       lastValidRound?: bigint | undefined;
+      appId: bigint;
       onComplete?: OnApplicationComplete.DeleteApplication | undefined;
       accountReferences?: ReadableAddress[] | undefined;
       appReferences?: bigint[] | undefined;
@@ -574,7 +574,6 @@ declare class AppClient {
      * @returns The parameters which can be used to create a close out ABI method call
      */
     closeOut: (params: AppClientMethodCallParams) => Promise<{
-      appId: bigint;
       sender: SendingAddress;
       signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
       rekeyTo?: ReadableAddress | undefined;
@@ -586,6 +585,7 @@ declare class AppClient {
       validityWindow?: number | bigint | undefined;
       firstValidRound?: bigint | undefined;
       lastValidRound?: bigint | undefined;
+      appId: bigint;
       onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
       accountReferences?: ReadableAddress[] | undefined;
       appReferences?: bigint[] | undefined;
@@ -601,7 +601,6 @@ declare class AppClient {
      * @returns The parameters which can be used to create an ABI method call
      */
     call: (params: AppClientMethodCallParams & CallOnComplete) => Promise<{
-      appId: bigint;
       sender: SendingAddress;
       signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
       rekeyTo?: ReadableAddress | undefined;
@@ -613,6 +612,7 @@ declare class AppClient {
       validityWindow?: number | bigint | undefined;
       firstValidRound?: bigint | undefined;
       lastValidRound?: bigint | undefined;
+      appId: bigint;
       onComplete?: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.DeleteApplication | undefined;
       accountReferences?: ReadableAddress[] | undefined;
       appReferences?: bigint[] | undefined;
@@ -709,8 +709,8 @@ declare class AppClient {
     update: (params: AppClientMethodCallParams & AppClientCompilationParams & SendParams) => Promise<{
       compiledApproval?: CompiledTeal | undefined;
       compiledClear?: CompiledTeal | undefined;
-      transactions: Transaction[];
       confirmations: PendingTransactionResponse[];
+      transactions: Transaction[];
       groupId: string | undefined;
       txIds: string[];
       returns?: ABIReturn[] | undefined;

package/app-factory.d.ts

@@ -211,7 +211,7 @@ declare class AppFactory {
       sender: Address;
       signer: AddressWithTransactionSigner | TransactionSigner | undefined;
       method: ABIMethod;
-      args: (Transaction | TransactionWithSigner | Promise<Transaction> | ABIValue | AppMethodCall<{
+      args: (Transaction | ABIValue | TransactionWithSigner | AppMethodCall<{
         sender: SendingAddress;
         signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
         rekeyTo?: ReadableAddress | undefined;
@@ -264,7 +264,7 @@ declare class AppFactory {
         rejectVersion?: number | undefined;
         approvalProgram: string | Uint8Array;
         clearStateProgram: string | Uint8Array;
-      }> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+      }> | AppMethodCall<AppMethodCallParams> | Promise<Transaction> | undefined)[] | undefined;
       onComplete: OnApplicationComplete.NoOp | OnApplicationComplete.OptIn | OnApplicationComplete.CloseOut | OnApplicationComplete.UpdateApplication | OnApplicationComplete.DeleteApplication;
     }>;
     /** Return params for a deployment update ABI call */
@@ -293,7 +293,7 @@ declare class AppFactory {
       sender: Address;
       signer: AddressWithTransactionSigner | TransactionSigner | undefined;
       method: ABIMethod;
-      args: (Transaction | TransactionWithSigner | Promise<Transaction> | ABIValue | AppMethodCall<{
+      args: (Transaction | ABIValue | TransactionWithSigner | AppMethodCall<{
         sender: SendingAddress;
         signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
         rekeyTo?: ReadableAddress | undefined;
@@ -346,7 +346,7 @@ declare class AppFactory {
         rejectVersion?: number | undefined;
         approvalProgram: string | Uint8Array;
         clearStateProgram: string | Uint8Array;
-      }> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+      }> | AppMethodCall<AppMethodCallParams> | Promise<Transaction> | undefined)[] | undefined;
       onComplete: OnApplicationComplete.UpdateApplication;
     };
     /** Return params for a deployment delete ABI call */
@@ -375,7 +375,7 @@ declare class AppFactory {
       sender: Address;
       signer: AddressWithTransactionSigner | TransactionSigner | undefined;
       method: ABIMethod;
-      args: (Transaction | TransactionWithSigner | Promise<Transaction> | ABIValue | AppMethodCall<{
+      args: (Transaction | ABIValue | TransactionWithSigner | AppMethodCall<{
         sender: SendingAddress;
         signer?: (TransactionSigner | AddressWithTransactionSigner) | undefined;
         rekeyTo?: ReadableAddress | undefined;
@@ -428,7 +428,7 @@ declare class AppFactory {
         rejectVersion?: number | undefined;
         approvalProgram: string | Uint8Array;
         clearStateProgram: string | Uint8Array;
-      }> | AppMethodCall<AppMethodCallParams> | undefined)[] | undefined;
+      }> | AppMethodCall<AppMethodCallParams> | Promise<Transaction> | undefined)[] | undefined;
       onComplete: OnApplicationComplete.DeleteApplication;
     };
     bare: {
@@ -653,9 +653,9 @@ declare class AppFactory {
       compiledApproval?: CompiledTeal | undefined;
       compiledClear?: CompiledTeal | undefined;
       operationPerformed: "create";
-      version: string;
       updatable?: boolean | undefined;
       deletable?: boolean | undefined;
+      version: string;
       createdRound: bigint;
       updatedRound: bigint;
       createdMetadata: AppDeployMetadata;
@@ -699,9 +699,9 @@ declare class AppFactory {
       compiledApproval?: CompiledTeal | undefined;
       compiledClear?: CompiledTeal | undefined;
       operationPerformed: "replace";
-      version: string;
       updatable?: boolean | undefined;
       deletable?: boolean | undefined;
+      version: string;
       createdRound: bigint;
       updatedRound: bigint;
       createdMetadata: AppDeployMetadata;

package/crypto/index.d.ts

@@ -1,4 +1,5 @@
-import { Ed25519Generator, RawEd25519Signer, RawEd25519Verifier, ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier } from "../packages/crypto/src/ed25519.js";
+import { Ed25519Generator, Ed25519SigningKey, RawEd25519Signer, RawEd25519Verifier, WrappedEd25519Seed, ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier } from "../packages/crypto/src/ed25519.js";
+import { BIP44Path, HdAccountGenerator, HdWalletGenerator, WrappedHdExtendedPrivateKey, peikertXHdWalletGenerator } from "../packages/crypto/src/hd.js";
 import { hash } from "../packages/crypto/src/hash.js";
-import { BIP44Path, HdAccountGenerator, HdWalletGenerator, RawHdWalletSigner, peikertXHdAccountGenerator, peikertXHdWalletGenerator } from "../packages/crypto/src/hd.js";
-export { BIP44Path, Ed25519Generator, HdAccountGenerator, HdWalletGenerator, RawEd25519Signer, RawEd25519Verifier, RawHdWalletSigner, ed25519Generator, ed25519Verifier, hash, nobleEd25519Generator, nobleEd25519Verifier, peikertXHdAccountGenerator, peikertXHdWalletGenerator };
+import { WrappedEd25519Secret, ed25519SigningKeyFromWrappedSecret, nobleEd25519SigningKeyFromWrappedSecret } from "../packages/crypto/src/index.js";
+export { BIP44Path, Ed25519Generator, Ed25519SigningKey, HdAccountGenerator, HdWalletGenerator, RawEd25519Signer, RawEd25519Verifier, WrappedEd25519Secret, WrappedEd25519Seed, WrappedHdExtendedPrivateKey, ed25519Generator, ed25519SigningKeyFromWrappedSecret, ed25519Verifier, hash, nobleEd25519Generator, nobleEd25519SigningKeyFromWrappedSecret, nobleEd25519Verifier, peikertXHdWalletGenerator };

package/crypto/index.js

@@ -2,11 +2,13 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const require_ed25519 = require('../packages/crypto/src/ed25519.js');
 const require_hash = require('../packages/crypto/src/hash.js');
 const require_hd = require('../packages/crypto/src/hd.js');
+const require_index = require('../packages/crypto/src/index.js');
 
 exports.ed25519Generator = require_ed25519.ed25519Generator;
+exports.ed25519SigningKeyFromWrappedSecret = require_index.ed25519SigningKeyFromWrappedSecret;
 exports.ed25519Verifier = require_ed25519.ed25519Verifier;
 exports.hash = require_hash.hash;
 exports.nobleEd25519Generator = require_ed25519.nobleEd25519Generator;
+exports.nobleEd25519SigningKeyFromWrappedSecret = require_index.nobleEd25519SigningKeyFromWrappedSecret;
 exports.nobleEd25519Verifier = require_ed25519.nobleEd25519Verifier;
-exports.peikertXHdAccountGenerator = require_hd.peikertXHdAccountGenerator;
 exports.peikertXHdWalletGenerator = require_hd.peikertXHdWalletGenerator;

package/crypto/index.mjs

@@ -1,5 +1,6 @@
 import { ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier } from "../packages/crypto/src/ed25519.mjs";
 import { hash } from "../packages/crypto/src/hash.mjs";
-import { peikertXHdAccountGenerator, peikertXHdWalletGenerator } from "../packages/crypto/src/hd.mjs";
+import { peikertXHdWalletGenerator } from "../packages/crypto/src/hd.mjs";
+import { ed25519SigningKeyFromWrappedSecret, nobleEd25519SigningKeyFromWrappedSecret } from "../packages/crypto/src/index.mjs";
 
-export { ed25519Generator, ed25519Verifier, hash, nobleEd25519Generator, nobleEd25519Verifier, peikertXHdAccountGenerator, peikertXHdWalletGenerator };
+export { ed25519Generator, ed25519SigningKeyFromWrappedSecret, ed25519Verifier, hash, nobleEd25519Generator, nobleEd25519SigningKeyFromWrappedSecret, nobleEd25519Verifier, peikertXHdWalletGenerator };

package/package.json

@@ -6,7 +6,7 @@
     "**"
   ],
   "name": "@algorandfoundation/algokit-utils",
-  "version": "10.0.0-alpha.39",
+  "version": "10.0.0-alpha.40",
   "private": false,
   "description": "A set of core Algorand utilities written in TypeScript and released via npm that make it easier to build solutions on Algorand.",
   "author": "Algorand Foundation",

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

@@ -38,6 +38,23 @@ declare const nobleEd25519Generator: Ed25519Generator;
  * @returns An object containing the ed25519 public key, secret key, and a raw signer function.
  */
 declare const ed25519Generator: Ed25519Generator;
+type Ed25519SigningKey = {
+  ed25519Pubkey: Uint8Array;
+  rawEd25519Signer: RawEd25519Signer;
+};
+/**
+ * Represents a 32-byte Ed25519 seed that can be unwrapped for short-lived use and then re-wrapped.
+ */
+type WrappedEd25519Seed = {
+  /**
+   * Unwraps and returns the 32-byte Ed25519 seed.
+   */
+  unwrapEd25519Seed: () => Promise<Uint8Array>;
+  /**
+   * Re-wraps the Ed25519 seed after use.
+   */
+  wrapEd25519Seed: () => Promise<void>;
+};
 //#endregion
-export { Ed25519Generator, RawEd25519Signer, RawEd25519Verifier, ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier };
+export { Ed25519Generator, Ed25519SigningKey, RawEd25519Signer, RawEd25519Verifier, WrappedEd25519Seed, ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier };
 //# sourceMappingURL=ed25519.d.ts.map

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

@@ -1 +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"],"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"}
+{"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.map

@@ -1 +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"],"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"}
+{"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/hd.d.ts

@@ -2,18 +2,39 @@ import { RawEd25519Signer } from "./ed25519.js";
 
 //#region packages/crypto/src/hd.d.ts
 type BIP44Path = [number, number, number, number, number];
-type RawHdWalletSigner = (bytesToSign: Uint8Array, bip44Path: BIP44Path) => Promise<Uint8Array>;
 type HdWalletGenerator = (seed?: Uint8Array) => Promise<{
   hdRootKey: Uint8Array;
-  rawHdSigner: RawHdWalletSigner;
+  accountGenerator: HdAccountGenerator;
 }>;
-type HdAccountGenerator = (rootKey: Uint8Array, account: number, index: number) => Promise<{
+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;
-declare const peikertXHdAccountGenerator: HdAccountGenerator;
+/**
+ * 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, RawHdWalletSigner, peikertXHdAccountGenerator, peikertXHdWalletGenerator };
+export { BIP44Path, HdAccountGenerator, HdWalletGenerator, WrappedHdExtendedPrivateKey, peikertXHdWalletGenerator };
 //# sourceMappingURL=hd.d.ts.map

package/packages/crypto/src/hd.js

@@ -2,51 +2,36 @@ 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 verifyPath = (bip44Path) => {
-	if (bip44Path.length !== 5) throw new Error("BIP44 path must have exactly 5 elements");
-	if (bip44Path[0] !== (0, _algorandfoundation_xhd_wallet_api.harden)(44)) throw new Error("BIP44 path must start with 44'");
-	if (bip44Path[1] !== (0, _algorandfoundation_xhd_wallet_api.harden)(283)) throw new Error("BIP44 path must have hardened coin type 283' for Algorand");
-};
-const getPathComponents = (bip44Path) => {
-	return {
-		account: bip44Path[2],
-		index: bip44Path[4]
-	};
-};
 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 rawHdSigner = async (bytesToSign, bip44Path) => {
-		verifyPath(bip44Path);
-		const { account, index } = getPathComponents(bip44Path);
-		return xhd.signAlgoTransaction(rootKey, _algorandfoundation_xhd_wallet_api.KeyContext.Address, account, index, bytesToSign, _algorandfoundation_xhd_wallet_api.BIP32DerivationType.Peikert);
-	};
-	return {
-		hdRootKey: rootKey,
-		rawHdSigner
-	};
-};
-const peikertXHdAccountGenerator = async (rootKey, 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);
-	};
-	return {
-		ed25519Pubkey,
-		rawEd25519Signer,
-		bip44Path: [
+	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.peikertXHdAccountGenerator = peikertXHdAccountGenerator;
 exports.peikertXHdWalletGenerator = peikertXHdWalletGenerator;
 //# sourceMappingURL=hd.js.map

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

@@ -1 +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'\n\nexport type BIP44Path = [number, number, number, number, number]\n\nexport type RawHdWalletSigner = (bytesToSign: Uint8Array, bip44Path: BIP44Path) => Promise<Uint8Array>\n\nexport type HdWalletGenerator = (seed?: Uint8Array) => Promise<{\n  hdRootKey: Uint8Array\n  rawHdSigner: RawHdWalletSigner\n}>\n\nexport type HdAccountGenerator = (\n  rootKey: Uint8Array,\n  account: number,\n  index: number,\n) => Promise<{\n  ed25519Pubkey: Uint8Array\n  bip44Path: BIP44Path\n  rawEd25519Signer: RawEd25519Signer\n}>\n\nconst verifyPath = (bip44Path: BIP44Path) => {\n  if (bip44Path.length !== 5) {\n    throw new Error('BIP44 path must have exactly 5 elements')\n  }\n  if (bip44Path[0] !== harden(44)) {\n    throw new Error(\"BIP44 path must start with 44'\")\n  }\n  if (bip44Path[1] !== harden(283)) {\n    throw new Error(\"BIP44 path must have hardened coin type 283' for Algorand\")\n  }\n}\n\nconst getPathComponents = (bip44Path: BIP44Path) => {\n  const account = bip44Path[2]\n  const index = bip44Path[4]\n  return { account, index }\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 rawHdSigner: RawHdWalletSigner = async (bytesToSign: Uint8Array, bip44Path: BIP44Path): Promise<Uint8Array> => {\n    verifyPath(bip44Path)\n    const { account, index } = getPathComponents(bip44Path)\n\n    return xhd.signAlgoTransaction(rootKey, KeyContext.Address, account, index, bytesToSign, BIP32DerivationType.Peikert)\n  }\n\n  return { hdRootKey: rootKey, rawHdSigner }\n}\n\nexport const peikertXHdAccountGenerator: HdAccountGenerator = async (rootKey: Uint8Array, 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  return { ed25519Pubkey, rawEd25519Signer, bip44Path }\n}\n"],"mappings":";;;;AAsBA,MAAM,cAAc,cAAyB;AAC3C,KAAI,UAAU,WAAW,EACvB,OAAM,IAAI,MAAM,0CAA0C;AAE5D,KAAI,UAAU,sDAAc,GAAG,CAC7B,OAAM,IAAI,MAAM,iCAAiC;AAEnD,KAAI,UAAU,sDAAc,IAAI,CAC9B,OAAM,IAAI,MAAM,4DAA4D;;AAIhF,MAAM,qBAAqB,cAAyB;AAGlD,QAAO;EAAE,SAFO,UAAU;EAER,OADJ,UAAU;EACC;;AAG3B,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,cAAiC,OAAO,aAAyB,cAA8C;AACnH,aAAW,UAAU;EACrB,MAAM,EAAE,SAAS,UAAU,kBAAkB,UAAU;AAEvD,SAAO,IAAI,oBAAoB,SAASC,8CAAW,SAAS,SAAS,OAAO,aAAaC,uDAAoB,QAAQ;;AAGvH,QAAO;EAAE,WAAW;EAAS;EAAa;;AAG5C,MAAa,6BAAiD,OAAO,SAAqB,SAAiB,UAAkB;CAC3H,MAAM,gBAAgB,MAAM,IAAI,OAAO,SAASD,8CAAW,SAAS,SAAS,OAAOC,uDAAoB,QAAQ;CAEhH,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,SAAO,IAAI,oBAAoB,SAASD,8CAAW,SAAS,SAAS,OAAO,aAAaC,uDAAoB,QAAQ;;AAKvH,QAAO;EAAE;EAAe;EAAkB,WAFb;kDAAQ,GAAG;kDAAS,IAAI;kDAAS,QAAQ;GAAE;GAAG;GAAM;EAE5B"}
+{"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

@@ -1,50 +1,36 @@
 import { BIP32DerivationType, KeyContext, XHDWalletAPI, fromSeed, harden } from "@algorandfoundation/xhd-wallet-api";
 
 //#region packages/crypto/src/hd.ts
-const verifyPath = (bip44Path) => {
-	if (bip44Path.length !== 5) throw new Error("BIP44 path must have exactly 5 elements");
-	if (bip44Path[0] !== harden(44)) throw new Error("BIP44 path must start with 44'");
-	if (bip44Path[1] !== harden(283)) throw new Error("BIP44 path must have hardened coin type 283' for Algorand");
-};
-const getPathComponents = (bip44Path) => {
-	return {
-		account: bip44Path[2],
-		index: bip44Path[4]
-	};
-};
 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 rawHdSigner = async (bytesToSign, bip44Path) => {
-		verifyPath(bip44Path);
-		const { account, index } = getPathComponents(bip44Path);
-		return xhd.signAlgoTransaction(rootKey, KeyContext.Address, account, index, bytesToSign, BIP32DerivationType.Peikert);
-	};
-	return {
-		hdRootKey: rootKey,
-		rawHdSigner
-	};
-};
-const peikertXHdAccountGenerator = async (rootKey, 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);
-	};
-	return {
-		ed25519Pubkey,
-		rawEd25519Signer,
-		bip44Path: [
+	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 { peikertXHdAccountGenerator, peikertXHdWalletGenerator };
+export { peikertXHdWalletGenerator };
 //# sourceMappingURL=hd.mjs.map

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

@@ -1 +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'\n\nexport type BIP44Path = [number, number, number, number, number]\n\nexport type RawHdWalletSigner = (bytesToSign: Uint8Array, bip44Path: BIP44Path) => Promise<Uint8Array>\n\nexport type HdWalletGenerator = (seed?: Uint8Array) => Promise<{\n  hdRootKey: Uint8Array\n  rawHdSigner: RawHdWalletSigner\n}>\n\nexport type HdAccountGenerator = (\n  rootKey: Uint8Array,\n  account: number,\n  index: number,\n) => Promise<{\n  ed25519Pubkey: Uint8Array\n  bip44Path: BIP44Path\n  rawEd25519Signer: RawEd25519Signer\n}>\n\nconst verifyPath = (bip44Path: BIP44Path) => {\n  if (bip44Path.length !== 5) {\n    throw new Error('BIP44 path must have exactly 5 elements')\n  }\n  if (bip44Path[0] !== harden(44)) {\n    throw new Error(\"BIP44 path must start with 44'\")\n  }\n  if (bip44Path[1] !== harden(283)) {\n    throw new Error(\"BIP44 path must have hardened coin type 283' for Algorand\")\n  }\n}\n\nconst getPathComponents = (bip44Path: BIP44Path) => {\n  const account = bip44Path[2]\n  const index = bip44Path[4]\n  return { account, index }\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 rawHdSigner: RawHdWalletSigner = async (bytesToSign: Uint8Array, bip44Path: BIP44Path): Promise<Uint8Array> => {\n    verifyPath(bip44Path)\n    const { account, index } = getPathComponents(bip44Path)\n\n    return xhd.signAlgoTransaction(rootKey, KeyContext.Address, account, index, bytesToSign, BIP32DerivationType.Peikert)\n  }\n\n  return { hdRootKey: rootKey, rawHdSigner }\n}\n\nexport const peikertXHdAccountGenerator: HdAccountGenerator = async (rootKey: Uint8Array, 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  return { ed25519Pubkey, rawEd25519Signer, bip44Path }\n}\n"],"mappings":";;;AAsBA,MAAM,cAAc,cAAyB;AAC3C,KAAI,UAAU,WAAW,EACvB,OAAM,IAAI,MAAM,0CAA0C;AAE5D,KAAI,UAAU,OAAO,OAAO,GAAG,CAC7B,OAAM,IAAI,MAAM,iCAAiC;AAEnD,KAAI,UAAU,OAAO,OAAO,IAAI,CAC9B,OAAM,IAAI,MAAM,4DAA4D;;AAIhF,MAAM,qBAAqB,cAAyB;AAGlD,QAAO;EAAE,SAFO,UAAU;EAER,OADJ,UAAU;EACC;;AAG3B,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,cAAiC,OAAO,aAAyB,cAA8C;AACnH,aAAW,UAAU;EACrB,MAAM,EAAE,SAAS,UAAU,kBAAkB,UAAU;AAEvD,SAAO,IAAI,oBAAoB,SAAS,WAAW,SAAS,SAAS,OAAO,aAAa,oBAAoB,QAAQ;;AAGvH,QAAO;EAAE,WAAW;EAAS;EAAa;;AAG5C,MAAa,6BAAiD,OAAO,SAAqB,SAAiB,UAAkB;CAC3H,MAAM,gBAAgB,MAAM,IAAI,OAAO,SAAS,WAAW,SAAS,SAAS,OAAO,oBAAoB,QAAQ;CAEhH,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,SAAO,IAAI,oBAAoB,SAAS,WAAW,SAAS,SAAS,OAAO,aAAa,oBAAoB,QAAQ;;AAKvH,QAAO;EAAE;EAAe;EAAkB,WAFb;GAAC,OAAO,GAAG;GAAE,OAAO,IAAI;GAAE,OAAO,QAAQ;GAAE;GAAG;GAAM;EAE5B"}
+{"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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"}

package/packages/crypto/src/index.mjs

@@ -0,0 +1,138 @@
+import { bytesToNumberLE, numberToBytesLE } from "../../../node_modules/@noble/curves/utils.mjs";
+import { mod } from "../../../node_modules/@noble/curves/abstract/modular.mjs";
+import { ed25519 } from "../../../node_modules/@noble/curves/ed25519.mjs";
+import { ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier } from "./ed25519.mjs";
+import { hash } from "./hash.mjs";
+import { peikertXHdWalletGenerator } from "./hd.mjs";
+import { sha512 } from "@noble/hashes/sha2.js";
+import * as ed from "@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 = bytesToNumberLE(extendedSecretKey.slice(0, 32));
+	const kR = extendedSecretKey.slice(32, 64);
+	const publicKey = rawPubkey(extendedSecretKey);
+	const r = mod(bytesToNumberLE(sha512(new Uint8Array([...kR, ...data]))), ed25519.Point.Fn.ORDER);
+	const R = ed25519.Point.BASE.multiply(r);
+	const S = mod(r + mod(bytesToNumberLE(sha512(new Uint8Array([
+		...R.toBytes(),
+		...publicKey,
+		...data
+	]))), ed25519.Point.Fn.ORDER) * scalar, ed25519.Point.Fn.ORDER);
+	return new Uint8Array([...R.toBytes(), ...numberToBytesLE(S, 32)]);
+}
+function rawPubkey(extendedSecretKey) {
+	const reducedScalar = mod(bytesToNumberLE(extendedSecretKey.slice(0, 32)) & (1n << 255n) - 1n, ed25519.Point.Fn.ORDER);
+	return 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 ed.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 ed.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
+export { ed25519SigningKeyFromWrappedSecret, nobleEd25519SigningKeyFromWrappedSecret };
+//# sourceMappingURL=index.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"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":";;;;;;;;;;AAcA,MAAM,sBAAsB;AAC5B,MAAM,sCAAsC;AAE5C,MAAM,6BAA6B,QAAoB,eAAyD;CAC9G,IAAI;AACJ,SAAQ,YAAR;EACE,KAAK;AACH,oBAAiB;AACjB;EACF,KAAK;AACH,oBAAiB;AACjB;EACF,QACE,OAAM,IAAI,MAAM,wBAAwB,aAAa;;AAGzD,KAAI,OAAO,WAAW,eACpB,OAAM,IAAI,MAAM,sBAAsB,WAAW,SAAS,eAAe,cAAc,OAAO,OAAO,GAAG;;AAI5G,MAAM,yBAAyB,gBAAyB,WAAoB,kBAAiC;AAC3G,OAAM,IAAI,eACR,CAAC,gBAAgB,UAAU,EAC3B,GAAG,cAAc,8EAClB;;AAGH,SAAS,QAAQ,mBAA+B,MAA8B;CAC5E,MAAM,SAAS,gBAAgB,kBAAkB,MAAM,GAAG,GAAG,CAAC;CAE9D,MAAM,KAAK,kBAAkB,MAAM,IAAI,GAAG;CAG1C,MAAM,YAAY,UAAU,kBAAkB;CAI9C,MAAM,IAAI,IAAI,gBADA,OAAO,IAAI,WAAW,CAAC,GAAG,IAAI,GAAG,KAAK,CAAC,CAAC,CAClB,EAAE,QAAQ,MAAM,GAAG,MAAM;CAG7D,MAAM,IAAI,QAAQ,MAAM,KAAK,SAAS,EAAE;CAOxC,MAAM,IAAI,IAAI,IAHJ,IAAI,gBADA,OAAO,IAAI,WAAW;EAAC,GAAG,EAAE,SAAS;EAAE,GAAG;EAAW,GAAG;EAAK,CAAC,CAAC,CACzC,EAAE,QAAQ,MAAM,GAAG,MAAM,GAGvC,QAAQ,QAAQ,MAAM,GAAG,MAAM;AAErD,QAAO,IAAI,WAAW,CAAC,GAAG,EAAE,SAAS,EAAE,GAAG,gBAAgB,GAAG,GAAG,CAAC,CAAC;;AAGpE,SAAS,UAAU,mBAA2C;CAG5D,MAAM,gBAAgB,IAFP,gBAAgB,kBAAkB,MAAM,GAAG,GAAG,CAAC,IACvB,MAAM,QAAQ,IACN,QAAQ,MAAM,GAAG,MAAM;AAItE,QADkB,QAAQ,MAAM,KAAK,SAAS,cAAc,CAC3C,SAAS;;;;;;;;;;AAW5B,MAAa,0CAA0C,OAAO,eAAiE;CAC7H,IAAI;AACJ,KAAI,qBAAqB,WACvB,gBAAe,WAAW;UACjB,8BAA8B,WACvC,gBAAe,WAAW;KAE1B,OAAM,IAAI,MAAM,sDAAsD;CAGxE,MAAM,SAAS,OAAO,gBAAiD;EACrE,IAAI,SAAiC;EACrC,IAAI,YAAoC;EACxC,IAAI;EACJ,IAAI;AACJ,MAAI;AACF,OAAI,uBAAuB,YAAY;AACrC,aAAS,MAAM,WAAW,mBAAmB;AAC7C,8BAA0B,QAAQ,eAAe;AACjD,gBAAY,MAAM,GAAG,UAAU,aAAa,OAAO;cAC1C,gCAAgC,YAAY;AACrD,aAAS,MAAM,WAAW,4BAA4B;AACtD,8BAA0B,QAAQ,kBAAkB;AACpD,gBAAY,QAAQ,OAAO,MAAM,GAAG,GAAG,EAAE,YAAY;SAErD,OAAM,IAAI,MAAM,wDAAwD;WAEnE,OAAO;AACd,kBAAe;YACP;AACR,OAAI;AACF,UAAM,cAAc;YACb,OAAO;AACd,gBAAY;aACJ;AACR,YAAQ,KAAK,EAAE;;;AAInB,MAAI,iBAAiB,UAAa,cAAc,OAC9C,uBAAsB,cAAc,WAAW,UAAU;AAG3D,MAAI,iBAAiB,OACnB,OAAM;AAGR,MAAI,cAAc,OAChB,OAAM;AAGR,MAAI,cAAc,OAChB,OAAM,IAAI,MAAM,gDAAgD;AAGlE,SAAO;;CAGT,IAAI,SAAiC;CACrC,IAAI;CACJ,IAAI;CACJ,IAAI,SAAiC;AACrC,KAAI;AACF,MAAI,uBAAuB,YAAY;AACrC,YAAS,MAAM,WAAW,mBAAmB;AAC7C,6BAA0B,QAAQ,eAAe;AACjD,YAAS,MAAM,GAAG,kBAAkB,OAAO;aAClC,gCAAgC,YAAY;AACrD,YAAS,MAAM,WAAW,4BAA4B;AACtD,6BAA0B,QAAQ,kBAAkB;AACpD,YAAS,UAAU,OAAO,MAAM,GAAG,GAAG,CAAC;QAEvC,OAAM,IAAI,MAAM,wDAAwD;UAEnE,OAAO;AACd,gBAAc;WACN;AACR,MAAI;AACF,SAAM,cAAc;WACb,OAAO;AACd,eAAY;YACJ;AACR,WAAQ,KAAK,EAAE;;;AAInB,KAAI,gBAAgB,UAAa,cAAc,OAC7C,uBAAsB,aAAa,WAAW,8BAA8B;AAG9E,KAAI,gBAAgB,OAClB,OAAM;AAGR,KAAI,cAAc,OAChB,OAAM;AAGR,KAAI,WAAW,OACb,OAAM,IAAI,MAAM,oEAAoE;AAGtF,QAAO;EACL,eAAe;EACf,kBAAkB;EACnB;;;;;;;;;;;AAYH,MAAa,qCAAqC"}