@algorandfoundation/algokit-utils 10.0.0-alpha.8 → 10.0.0-beta.1

package/packages/common/src/sourcemap.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"sourcemap.mjs","names":[],"sources":["../../../../packages/common/src/sourcemap.ts"],"sourcesContent":["// @ts-expect-error - vlq doesn't have proper type exports\nimport * as vlq from 'vlq'\n\n/**\n * Represents a location in a source file.\n */\nexport interface SourceLocation {\n  line: number\n  column: number\n  sourceIndex: number\n  nameIndex?: number\n}\n\n/**\n * Represents the location of a specific PC in a source line.\n */\nexport interface PcLineLocation {\n  pc: number\n  column: number\n  nameIndex?: number\n}\n\n/**\n * Contains a mapping from TEAL program PC to source file location.\n */\nexport class ProgramSourceMap {\n  public readonly version: number\n  /**\n   * A list of original sources used by the \"mappings\" entry.\n   */\n  public readonly sources: string[]\n  /**\n   * A list of symbol names used by the \"mappings\" entry.\n   */\n  public readonly names: string[]\n  /**\n   * A string with the encoded mapping data.\n   */\n  public readonly mappings: string\n\n  private pcToLocation: Map<number, SourceLocation>\n\n  // Key is `${sourceIndex}:${line}`\n  private sourceAndLineToPc: Map<string, PcLineLocation[]>\n\n  constructor({ version, sources, names, mappings }: { version: number; sources: string[]; names: string[]; mappings: string }) {\n    this.version = version\n    this.sources = sources\n    this.names = names\n    this.mappings = mappings\n\n    if (this.version !== 3) throw new Error(`Only version 3 is supported, got ${this.version}`)\n\n    if (this.mappings === undefined) throw new Error('mapping undefined, cannot build source map without `mapping`')\n\n    const pcList = this.mappings.split(';').map(vlq.decode)\n\n    this.pcToLocation = new Map()\n    this.sourceAndLineToPc = new Map()\n\n    const lastLocation = {\n      line: 0,\n      column: 0,\n      sourceIndex: 0,\n      nameIndex: 0,\n    } satisfies SourceLocation\n    for (const [pc, data] of pcList.entries()) {\n      const dataArray = data as number[]\n      if (dataArray.length < 4) continue\n\n      const nameDelta = dataArray.length > 4 ? dataArray[4] : undefined\n      const [, sourceDelta, lineDelta, columnDelta] = dataArray\n\n      lastLocation.sourceIndex += sourceDelta\n      lastLocation.line += lineDelta\n      lastLocation.column += columnDelta\n      if (typeof nameDelta !== 'undefined') {\n        lastLocation.nameIndex += nameDelta\n      }\n\n      const sourceAndLineKey = `${lastLocation.sourceIndex}:${lastLocation.line}`\n      let pcsForSourceAndLine = this.sourceAndLineToPc.get(sourceAndLineKey)\n      if (pcsForSourceAndLine === undefined) {\n        pcsForSourceAndLine = []\n        this.sourceAndLineToPc.set(sourceAndLineKey, pcsForSourceAndLine)\n      }\n\n      const pcInLine: PcLineLocation = {\n        pc,\n        column: lastLocation.column,\n      }\n      const pcLocation: SourceLocation = {\n        line: lastLocation.line,\n        column: lastLocation.column,\n        sourceIndex: lastLocation.sourceIndex,\n      }\n      if (typeof nameDelta !== 'undefined') {\n        pcInLine.nameIndex = lastLocation.nameIndex\n        pcLocation.nameIndex = lastLocation.nameIndex\n      }\n\n      pcsForSourceAndLine.push(pcInLine)\n      this.pcToLocation.set(pc, pcLocation)\n    }\n  }\n\n  getPcs(): number[] {\n    return Array.from(this.pcToLocation.keys())\n  }\n\n  getLocationForPc(pc: number): SourceLocation | undefined {\n    return this.pcToLocation.get(pc)\n  }\n\n  getPcsOnSourceLine(sourceIndex: number, line: number): PcLineLocation[] {\n    const pcs = this.sourceAndLineToPc.get(`${sourceIndex}:${line}`)\n    if (pcs === undefined) return []\n    return pcs\n  }\n}\n"],"mappings":";;;;;AAyBA,IAAa,mBAAb,MAA8B;CAC5B;;;;CAIA;;;;CAIA;;;;CAIA;CAEA;CAGA;CAEA,YAAY,EAAE,SAAS,SAAS,OAAO,YAAuF;AAC5H,OAAK,UAAU;AACf,OAAK,UAAU;AACf,OAAK,QAAQ;AACb,OAAK,WAAW;AAEhB,MAAI,KAAK,YAAY,EAAG,OAAM,IAAI,MAAM,oCAAoC,KAAK,UAAU;AAE3F,MAAI,KAAK,aAAa,KAAA,EAAW,OAAM,IAAI,MAAM,+DAA+D;EAEhH,MAAM,SAAS,KAAK,SAAS,MAAM,IAAI,CAAC,IAAI,IAAI,OAAO;AAEvD,OAAK,+BAAe,IAAI,KAAK;AAC7B,OAAK,oCAAoB,IAAI,KAAK;EAElC,MAAM,eAAe;GACnB,MAAM;GACN,QAAQ;GACR,aAAa;GACb,WAAW;GACZ;AACD,OAAK,MAAM,CAAC,IAAI,SAAS,OAAO,SAAS,EAAE;GACzC,MAAM,YAAY;AAClB,OAAI,UAAU,SAAS,EAAG;GAE1B,MAAM,YAAY,UAAU,SAAS,IAAI,UAAU,KAAK,KAAA;GACxD,MAAM,GAAG,aAAa,WAAW,eAAe;AAEhD,gBAAa,eAAe;AAC5B,gBAAa,QAAQ;AACrB,gBAAa,UAAU;AACvB,OAAI,OAAO,cAAc,YACvB,cAAa,aAAa;GAG5B,MAAM,mBAAmB,GAAG,aAAa,YAAY,GAAG,aAAa;GACrE,IAAI,sBAAsB,KAAK,kBAAkB,IAAI,iBAAiB;AACtE,OAAI,wBAAwB,KAAA,GAAW;AACrC,0BAAsB,EAAE;AACxB,SAAK,kBAAkB,IAAI,kBAAkB,oBAAoB;;GAGnE,MAAM,WAA2B;IAC/B;IACA,QAAQ,aAAa;IACtB;GACD,MAAM,aAA6B;IACjC,MAAM,aAAa;IACnB,QAAQ,aAAa;IACrB,aAAa,aAAa;IAC3B;AACD,OAAI,OAAO,cAAc,aAAa;AACpC,aAAS,YAAY,aAAa;AAClC,eAAW,YAAY,aAAa;;AAGtC,uBAAoB,KAAK,SAAS;AAClC,QAAK,aAAa,IAAI,IAAI,WAAW;;;CAIzC,SAAmB;AACjB,SAAO,MAAM,KAAK,KAAK,aAAa,MAAM,CAAC;;CAG7C,iBAAiB,IAAwC;AACvD,SAAO,KAAK,aAAa,IAAI,GAAG;;CAGlC,mBAAmB,aAAqB,MAAgC;EACtE,MAAM,MAAM,KAAK,kBAAkB,IAAI,GAAG,YAAY,GAAG,OAAO;AAChE,MAAI,QAAQ,KAAA,EAAW,QAAO,EAAE;AAChC,SAAO"}

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

@@ -0,0 +1,60 @@
+//#region packages/crypto/src/ed25519.d.ts
+type RawEd25519Verifier = (signature: Uint8Array, message: Uint8Array, pubkey: Uint8Array) => Promise<boolean>;
+type RawEd25519Signer = (bytesToSign: Uint8Array) => Promise<Uint8Array>;
+type Ed25519Generator = (seed?: Uint8Array) => {
+  ed25519Pubkey: Uint8Array;
+  ed25519SecretKey: Uint8Array;
+  rawEd25519Signer: RawEd25519Signer;
+};
+/**
+ * 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.
+ */
+declare const nobleEd25519Verifier: RawEd25519Verifier;
+/**
+ * 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.
+ */
+declare const ed25519Verifier: RawEd25519Verifier;
+/**
+ * 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.
+ */
+declare const nobleEd25519Generator: Ed25519Generator;
+/**
+ * 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.
+ */
+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, Ed25519SigningKey, RawEd25519Signer, RawEd25519Verifier, WrappedEd25519Seed, ed25519Generator, ed25519Verifier, nobleEd25519Generator, nobleEd25519Verifier };
+//# sourceMappingURL=ed25519.d.ts.map

package/packages/crypto/src/ed25519.js

@@ -0,0 +1,58 @@
+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,SAAA,GAAA,sBAAA,QAAyB,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,53 @@
+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,14 @@
+require("../../../_virtual/_rolldown/runtime.js");
+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, 32);
+}
+//#endregion
+exports.hash = hash;
+
+//# sourceMappingURL=hash.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hash.js","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,SAAA,GAAA,sBAAA,YAAkB,MAAM,CAAC,MAAM,GAAA,GAAqB"}

package/packages/crypto/src/hash.mjs

@@ -0,0 +1,13 @@
+import "../../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, 32);
+}
+//#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,GAAA,GAAqB"}

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

@@ -0,0 +1,36 @@
+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,36 @@
+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,mCAAAA,cAAc;AAE9B,MAAa,4BAA+C,OAAO,SAAsB;CACvF,MAAM,YAAY,QAAQ,IAAI,WAAW,GAAG;AAC5C,KAAI,SAAS,KAAA,EACX,QAAO,gBAAgB,UAAU;CAGnC,MAAM,WAAA,GAAA,mCAAA,UAAmB,OAAO,KAAK,UAAU,CAAC;CAEhD,MAAM,mBAAuC,OAAO,SAAiB,UAAkB;EACrF,MAAM,gBAAgB,MAAM,IAAI,OAAO,SAASC,mCAAAA,WAAW,SAAS,SAAS,OAAOC,mCAAAA,oBAAoB,QAAQ;EAEhH,MAAM,mBAAqC,OAAO,gBAAiD;AACjG,UAAO,IAAI,oBAAoB,SAASD,mCAAAA,WAAW,SAAS,SAAS,OAAO,aAAaC,mCAAAA,oBAAoB,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,mCAAAA,oBAAoB,QAAQ;GAER;;AAGjF,QAAO;EAAE,WAAW;EAAS;EAAkB"}

package/packages/crypto/src/hd.mjs

@@ -0,0 +1,35 @@
+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,KAAA,EACX,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,142 @@
+const require_runtime = require("../../../_virtual/_rolldown/runtime.js");
+require("./ed25519.js");
+require("./hash.js");
+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);
+let _noble_curves_ed25519_js = require("@noble/curves/ed25519.js");
+let _noble_curves_utils_js = require("@noble/curves/utils.js");
+let _noble_curves_abstract_modular_js = require("@noble/curves/abstract/modular.js");
+//#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 = (0, _noble_curves_utils_js.bytesToNumberLE)(extendedSecretKey.subarray(0, 32));
+	const kR = extendedSecretKey.subarray(32, 64);
+	const publicKey = rawPubkey(extendedSecretKey);
+	const r = (0, _noble_curves_abstract_modular_js.mod)((0, _noble_curves_utils_js.bytesToNumberLE)((0, _noble_hashes_sha2_js.sha512)(new Uint8Array([...kR, ...data]))), _noble_curves_ed25519_js.ed25519.Point.Fn.ORDER);
+	const R = _noble_curves_ed25519_js.ed25519.Point.BASE.multiply(r);
+	const S = (0, _noble_curves_abstract_modular_js.mod)(r + (0, _noble_curves_abstract_modular_js.mod)((0, _noble_curves_utils_js.bytesToNumberLE)((0, _noble_hashes_sha2_js.sha512)(new Uint8Array([
+		...R.toBytes(),
+		...publicKey,
+		...data
+	]))), _noble_curves_ed25519_js.ed25519.Point.Fn.ORDER) * scalar, _noble_curves_ed25519_js.ed25519.Point.Fn.ORDER);
+	return new Uint8Array([...R.toBytes(), ...(0, _noble_curves_utils_js.numberToBytesLE)(S, 32)]);
+}
+function rawPubkey(extendedSecretKey) {
+	const scalar = (0, _noble_curves_utils_js.bytesToNumberLE)(extendedSecretKey.subarray(0, 32));
+	if ((scalar & 1n << 255n) !== 0n) throw new Error("Invalid HD-expanded Ed25519 secret scalar: most-significant bit (bit 255) of the 32-byte scalar must be 0 for rawSign/rawPubkey inputs.");
+	const reducedScalar = (0, _noble_curves_abstract_modular_js.mod)(scalar, _noble_curves_ed25519_js.ed25519.Point.Fn.ORDER);
+	return _noble_curves_ed25519_js.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.subarray(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.subarray(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":["ed25519","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.subarray(0, 32))\n\n  const kR = extendedSecretKey.subarray(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.subarray(0, 32))\n  if ((scalar & (1n << 255n)) !== 0n) {\n    throw new Error(\n      'Invalid HD-expanded Ed25519 secret scalar: most-significant bit (bit 255) of the 32-byte scalar must be 0 for rawSign/rawPubkey inputs.',\n    )\n  }\n  const reducedScalar = mod(scalar, 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.subarray(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.subarray(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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"}