@laceio/sdk 0.1.1-canary.2 → 0.1.1

package/dist/dist-C3SHC_Ho.cjs

@@ -1,1394 +0,0 @@
-require("./rolldown-runtime-Br2OG8yv.cjs");
-const require_bip32 = require("./bip32-D6wd_QMn.cjs");
-const require_english = require("./english-Byb9M0E_.cjs");
-//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/utils.js
-/**
-* Checks if something is Uint8Array. Be careful: nodejs Buffer will return true.
-* @param a - value to test
-* @returns `true` when the value is a Uint8Array-compatible view.
-* @example
-* Check whether a value is a Uint8Array-compatible view.
-* ```ts
-* isBytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function isBytes$1(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-/**
-* Asserts something is a non-negative integer.
-* @param n - number to validate
-* @param title - label included in thrown errors
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a non-negative integer option.
-* ```ts
-* anumber(32, 'length');
-* ```
-*/
-function anumber$1(n, title = "") {
-	if (typeof n !== "number") {
-		const prefix = title && `"${title}" `;
-		throw new TypeError(`${prefix}expected number, got ${typeof n}`);
-	}
-	if (!Number.isSafeInteger(n) || n < 0) {
-		const prefix = title && `"${title}" `;
-		throw new RangeError(`${prefix}expected integer >= 0, got ${n}`);
-	}
-}
-/**
-* Asserts something is Uint8Array.
-* @param value - value to validate
-* @param length - optional exact length constraint
-* @param title - label included in thrown errors
-* @returns The validated byte array.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate that a value is a byte array.
-* ```ts
-* abytes(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function abytes$1(value, length, title = "") {
-	const bytes = isBytes$1(value);
-	const len = value?.length;
-	const needsLen = length !== void 0;
-	if (!bytes || needsLen && len !== length) {
-		const prefix = title && `"${title}" `;
-		const ofLen = needsLen ? ` of length ${length}` : "";
-		const got = bytes ? `length=${len}` : `type=${typeof value}`;
-		const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
-		if (!bytes) throw new TypeError(message);
-		throw new RangeError(message);
-	}
-	return value;
-}
-/**
-* Asserts a hash instance has not been destroyed or finished.
-* @param instance - hash instance to validate
-* @param checkFinished - whether to reject finalized instances
-* @throws If the hash instance has already been destroyed or finalized. {@link Error}
-* @example
-* Validate that a hash instance is still usable.
-* ```ts
-* import { aexists } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aexists(hash);
-* ```
-*/
-function aexists(instance, checkFinished = true) {
-	if (instance.destroyed) throw new Error("Hash instance has been destroyed");
-	if (checkFinished && instance.finished) throw new Error("Hash#digest() has already been called");
-}
-/**
-* Asserts output is a sufficiently-sized byte array.
-* @param out - destination buffer
-* @param instance - hash instance providing output length
-* Oversized buffers are allowed; downstream code only promises to fill the first `outputLen` bytes.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Validate a caller-provided digest buffer.
-* ```ts
-* import { aoutput } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const hash = sha256.create();
-* aoutput(new Uint8Array(hash.outputLen), hash);
-* ```
-*/
-function aoutput(out, instance) {
-	abytes$1(out, void 0, "digestInto() output");
-	const min = instance.outputLen;
-	if (out.length < min) throw new RangeError("\"digestInto() output\" expected to be of length >=" + min);
-}
-/**
-* Zeroizes typed arrays in place. Warning: JS provides no guarantees.
-* @param arrays - arrays to overwrite with zeros
-* @example
-* Zeroize sensitive buffers in place.
-* ```ts
-* clean(new Uint8Array([1, 2, 3]));
-* ```
-*/
-function clean(...arrays) {
-	for (let i = 0; i < arrays.length; i++) arrays[i].fill(0);
-}
-/**
-* Creates a DataView for byte-level manipulation.
-* @param arr - source typed array
-* @returns DataView over the same buffer region.
-* @example
-* Create a DataView over an existing buffer.
-* ```ts
-* createView(new Uint8Array(4));
-* ```
-*/
-function createView(arr) {
-	return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-}
-/**
-* Rotate-right operation for uint32 values.
-* @param word - source word
-* @param shift - shift amount in bits
-* @returns Rotated word.
-* @example
-* Rotate a 32-bit word to the right.
-* ```ts
-* rotr(0x12345678, 8);
-* ```
-*/
-function rotr(word, shift) {
-	return word << 32 - shift | word >>> shift;
-}
-new Uint8Array(new Uint32Array([287454020]).buffer)[0];
-typeof Uint8Array.from([]).toHex === "function" && Uint8Array.fromHex;
-/**
-* Creates a callable hash function from a stateful class constructor.
-* @param hashCons - hash constructor or factory
-* @param info - optional metadata such as DER OID
-* @returns Frozen callable hash wrapper with `.create()`.
-*   Wrapper construction eagerly calls `hashCons(undefined)` once to read
-*   `outputLen` / `blockLen`, so constructor side effects happen at module
-*   init time.
-* @example
-* Wrap a stateful hash constructor into a callable helper.
-* ```ts
-* import { createHasher } from '@noble/hashes/utils.js';
-* import { sha256 } from '@noble/hashes/sha2.js';
-* const wrapped = createHasher(sha256.create, { oid: sha256.oid });
-* wrapped(new Uint8Array([1]));
-* ```
-*/
-function createHasher(hashCons, info = {}) {
-	const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-	const tmp = hashCons(void 0);
-	hashC.outputLen = tmp.outputLen;
-	hashC.blockLen = tmp.blockLen;
-	hashC.canXOF = tmp.canXOF;
-	hashC.create = (opts) => hashCons(opts);
-	Object.assign(hashC, info);
-	return Object.freeze(hashC);
-}
-/**
-* Cryptographically secure PRNG backed by `crypto.getRandomValues`.
-* @param bytesLength - number of random bytes to generate
-* @returns Random bytes.
-* The platform `getRandomValues()` implementation still defines any
-* single-call length cap, and this helper rejects oversize requests
-* with a stable library `RangeError` instead of host-specific errors.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @throws If the current runtime does not provide `crypto.getRandomValues`. {@link Error}
-* @example
-* Generate a fresh random key or nonce.
-* ```ts
-* const key = randomBytes(16);
-* ```
-*/
-function randomBytes(bytesLength = 32) {
-	anumber$1(bytesLength, "bytesLength");
-	const cr = typeof globalThis === "object" ? globalThis.crypto : null;
-	if (typeof cr?.getRandomValues !== "function") throw new Error("crypto.getRandomValues must be defined");
-	if (bytesLength > 65536) throw new RangeError(`"bytesLength" expected <= 65536, got ${bytesLength}`);
-	return cr.getRandomValues(new Uint8Array(bytesLength));
-}
-/**
-* Creates OID metadata for NIST hashes with prefix `06 09 60 86 48 01 65 03 04 02`.
-* @param suffix - final OID byte for the selected hash.
-*   The helper accepts any byte even though only the documented NIST hash
-*   suffixes are meaningful downstream.
-* @returns Object containing the DER-encoded OID.
-* @example
-* Build OID metadata for a NIST hash.
-* ```ts
-* oidNist(0x01);
-* ```
-*/
-const oidNist = (suffix) => ({ oid: Uint8Array.from([
-	6,
-	9,
-	96,
-	134,
-	72,
-	1,
-	101,
-	3,
-	4,
-	2,
-	suffix
-]) });
-//#endregion
-//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/_md.js
-/**
-* Internal Merkle-Damgard hash utils.
-* @module
-*/
-/**
-* Shared 32-bit conditional boolean primitive reused by SHA-256, SHA-1, and MD5 `F`.
-* Returns bits from `b` when `a` is set, otherwise from `c`.
-* The XOR form is equivalent to MD5's `F(X,Y,Z) = XY v not(X)Z` because the masked terms never
-* set the same bit.
-* @param a - selector word
-* @param b - word chosen when selector bit is set
-* @param c - word chosen when selector bit is clear
-* @returns Mixed 32-bit word.
-* @example
-* Combine three words with the shared 32-bit choice primitive.
-* ```ts
-* Chi(0xffffffff, 0x12345678, 0x87654321);
-* ```
-*/
-function Chi(a, b, c) {
-	return a & b ^ ~a & c;
-}
-/**
-* Shared 32-bit majority primitive reused by SHA-256 and SHA-1.
-* Returns bits shared by at least two inputs.
-* @param a - first input word
-* @param b - second input word
-* @param c - third input word
-* @returns Mixed 32-bit word.
-* @example
-* Combine three words with the shared 32-bit majority primitive.
-* ```ts
-* Maj(0xffffffff, 0x12345678, 0x87654321);
-* ```
-*/
-function Maj(a, b, c) {
-	return a & b ^ a & c ^ b & c;
-}
-/**
-* Merkle-Damgard hash construction base class.
-* Could be used to create MD5, RIPEMD, SHA1, SHA2.
-* Accepts only byte-aligned `Uint8Array` input, even when the underlying spec describes bit
-* strings with partial-byte tails.
-* @param blockLen - internal block size in bytes
-* @param outputLen - digest size in bytes
-* @param padOffset - trailing length field size in bytes
-* @param isLE - whether length and state words are encoded in little-endian
-* @example
-* Use a concrete subclass to get the shared Merkle-Damgard update/digest flow.
-* ```ts
-* import { _SHA1 } from '@noble/hashes/legacy.js';
-* const hash = new _SHA1();
-* hash.update(new Uint8Array([97, 98, 99]));
-* hash.digest();
-* ```
-*/
-var HashMD = class {
-	blockLen;
-	outputLen;
-	canXOF = false;
-	padOffset;
-	isLE;
-	buffer;
-	view;
-	finished = false;
-	length = 0;
-	pos = 0;
-	destroyed = false;
-	constructor(blockLen, outputLen, padOffset, isLE) {
-		this.blockLen = blockLen;
-		this.outputLen = outputLen;
-		this.padOffset = padOffset;
-		this.isLE = isLE;
-		this.buffer = new Uint8Array(blockLen);
-		this.view = createView(this.buffer);
-	}
-	update(data) {
-		aexists(this);
-		abytes$1(data);
-		const { view, buffer, blockLen } = this;
-		const len = data.length;
-		for (let pos = 0; pos < len;) {
-			const take = Math.min(blockLen - this.pos, len - pos);
-			if (take === blockLen) {
-				const dataView = createView(data);
-				for (; blockLen <= len - pos; pos += blockLen) this.process(dataView, pos);
-				continue;
-			}
-			buffer.set(data.subarray(pos, pos + take), this.pos);
-			this.pos += take;
-			pos += take;
-			if (this.pos === blockLen) {
-				this.process(view, 0);
-				this.pos = 0;
-			}
-		}
-		this.length += data.length;
-		this.roundClean();
-		return this;
-	}
-	digestInto(out) {
-		aexists(this);
-		aoutput(out, this);
-		this.finished = true;
-		const { buffer, view, blockLen, isLE } = this;
-		let { pos } = this;
-		buffer[pos++] = 128;
-		clean(this.buffer.subarray(pos));
-		if (this.padOffset > blockLen - pos) {
-			this.process(view, 0);
-			pos = 0;
-		}
-		for (let i = pos; i < blockLen; i++) buffer[i] = 0;
-		view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
-		this.process(view, 0);
-		const oview = createView(out);
-		const len = this.outputLen;
-		if (len % 4) throw new Error("_sha2: outputLen must be aligned to 32bit");
-		const outLen = len / 4;
-		const state = this.get();
-		if (outLen > state.length) throw new Error("_sha2: outputLen bigger than state");
-		for (let i = 0; i < outLen; i++) oview.setUint32(4 * i, state[i], isLE);
-	}
-	digest() {
-		const { buffer, outputLen } = this;
-		this.digestInto(buffer);
-		const res = buffer.slice(0, outputLen);
-		this.destroy();
-		return res;
-	}
-	_cloneInto(to) {
-		to ||= new this.constructor();
-		to.set(...this.get());
-		const { blockLen, buffer, length, finished, destroyed, pos } = this;
-		to.destroyed = destroyed;
-		to.finished = finished;
-		to.length = length;
-		to.pos = pos;
-		if (length % blockLen) to.buffer.set(buffer);
-		return to;
-	}
-	clone() {
-		return this._cloneInto();
-	}
-};
-/**
-* Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
-* Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
-*/
-/** Initial SHA256 state from RFC 6234 §6.1: the first 32 bits of the fractional parts of the
-* square roots of the first eight prime numbers. Exported as a shared table; callers must treat
-* it as read-only because constructors copy words from it by index. */
-const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
-	1779033703,
-	3144134277,
-	1013904242,
-	2773480762,
-	1359893119,
-	2600822924,
-	528734635,
-	1541459225
-]);
-//#endregion
-//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/_u64.js
-const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-const _32n = /* @__PURE__ */ BigInt(32);
-function fromBig(n, le = false) {
-	if (le) return {
-		h: Number(n & U32_MASK64),
-		l: Number(n >> _32n & U32_MASK64)
-	};
-	return {
-		h: Number(n >> _32n & U32_MASK64) | 0,
-		l: Number(n & U32_MASK64) | 0
-	};
-}
-function split(lst, le = false) {
-	const len = lst.length;
-	let Ah = new Uint32Array(len);
-	let Al = new Uint32Array(len);
-	for (let i = 0; i < len; i++) {
-		const { h, l } = fromBig(lst[i], le);
-		[Ah[i], Al[i]] = [h, l];
-	}
-	return [Ah, Al];
-}
-//#endregion
-//#region ../../node_modules/@scure/bip39/node_modules/@noble/hashes/sha2.js
-/**
-* SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
-* SHA256 is the fastest hash implementable in JS, even faster than Blake3.
-* Check out {@link https://www.rfc-editor.org/rfc/rfc4634 | RFC 4634} and
-* {@link https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf | FIPS 180-4}.
-* @module
-*/
-/**
-* SHA-224 / SHA-256 round constants from RFC 6234 §5.1: the first 32 bits
-* of the cube roots of the first 64 primes (2..311).
-*/
-const SHA256_K = /* @__PURE__ */ Uint32Array.from([
-	1116352408,
-	1899447441,
-	3049323471,
-	3921009573,
-	961987163,
-	1508970993,
-	2453635748,
-	2870763221,
-	3624381080,
-	310598401,
-	607225278,
-	1426881987,
-	1925078388,
-	2162078206,
-	2614888103,
-	3248222580,
-	3835390401,
-	4022224774,
-	264347078,
-	604807628,
-	770255983,
-	1249150122,
-	1555081692,
-	1996064986,
-	2554220882,
-	2821834349,
-	2952996808,
-	3210313671,
-	3336571891,
-	3584528711,
-	113926993,
-	338241895,
-	666307205,
-	773529912,
-	1294757372,
-	1396182291,
-	1695183700,
-	1986661051,
-	2177026350,
-	2456956037,
-	2730485921,
-	2820302411,
-	3259730800,
-	3345764771,
-	3516065817,
-	3600352804,
-	4094571909,
-	275423344,
-	430227734,
-	506948616,
-	659060556,
-	883997877,
-	958139571,
-	1322822218,
-	1537002063,
-	1747873779,
-	1955562222,
-	2024104815,
-	2227730452,
-	2361852424,
-	2428436474,
-	2756734187,
-	3204031479,
-	3329325298
-]);
-/** Reusable SHA-224 / SHA-256 message schedule buffer `W_t` from RFC 6234 §6.2 step 1. */
-const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-/** Internal SHA-224 / SHA-256 compression engine from RFC 6234 §6.2. */
-var SHA2_32B = class extends HashMD {
-	constructor(outputLen) {
-		super(64, outputLen, 8, false);
-	}
-	get() {
-		const { A, B, C, D, E, F, G, H } = this;
-		return [
-			A,
-			B,
-			C,
-			D,
-			E,
-			F,
-			G,
-			H
-		];
-	}
-	set(A, B, C, D, E, F, G, H) {
-		this.A = A | 0;
-		this.B = B | 0;
-		this.C = C | 0;
-		this.D = D | 0;
-		this.E = E | 0;
-		this.F = F | 0;
-		this.G = G | 0;
-		this.H = H | 0;
-	}
-	process(view, offset) {
-		for (let i = 0; i < 16; i++, offset += 4) SHA256_W[i] = view.getUint32(offset, false);
-		for (let i = 16; i < 64; i++) {
-			const W15 = SHA256_W[i - 15];
-			const W2 = SHA256_W[i - 2];
-			const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-			SHA256_W[i] = (rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10) + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-		}
-		let { A, B, C, D, E, F, G, H } = this;
-		for (let i = 0; i < 64; i++) {
-			const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-			const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-			const T2 = (rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22)) + Maj(A, B, C) | 0;
-			H = G;
-			G = F;
-			F = E;
-			E = D + T1 | 0;
-			D = C;
-			C = B;
-			B = A;
-			A = T1 + T2 | 0;
-		}
-		A = A + this.A | 0;
-		B = B + this.B | 0;
-		C = C + this.C | 0;
-		D = D + this.D | 0;
-		E = E + this.E | 0;
-		F = F + this.F | 0;
-		G = G + this.G | 0;
-		H = H + this.H | 0;
-		this.set(A, B, C, D, E, F, G, H);
-	}
-	roundClean() {
-		clean(SHA256_W);
-	}
-	destroy() {
-		this.destroyed = true;
-		this.set(0, 0, 0, 0, 0, 0, 0, 0);
-		clean(this.buffer);
-	}
-};
-/** Internal SHA-256 hash class grounded in RFC 6234 §6.2. */
-var _SHA256 = class extends SHA2_32B {
-	A = SHA256_IV[0] | 0;
-	B = SHA256_IV[1] | 0;
-	C = SHA256_IV[2] | 0;
-	D = SHA256_IV[3] | 0;
-	E = SHA256_IV[4] | 0;
-	F = SHA256_IV[5] | 0;
-	G = SHA256_IV[6] | 0;
-	H = SHA256_IV[7] | 0;
-	constructor() {
-		super(32);
-	}
-};
-const K512 = split([
-	"0x428a2f98d728ae22",
-	"0x7137449123ef65cd",
-	"0xb5c0fbcfec4d3b2f",
-	"0xe9b5dba58189dbbc",
-	"0x3956c25bf348b538",
-	"0x59f111f1b605d019",
-	"0x923f82a4af194f9b",
-	"0xab1c5ed5da6d8118",
-	"0xd807aa98a3030242",
-	"0x12835b0145706fbe",
-	"0x243185be4ee4b28c",
-	"0x550c7dc3d5ffb4e2",
-	"0x72be5d74f27b896f",
-	"0x80deb1fe3b1696b1",
-	"0x9bdc06a725c71235",
-	"0xc19bf174cf692694",
-	"0xe49b69c19ef14ad2",
-	"0xefbe4786384f25e3",
-	"0x0fc19dc68b8cd5b5",
-	"0x240ca1cc77ac9c65",
-	"0x2de92c6f592b0275",
-	"0x4a7484aa6ea6e483",
-	"0x5cb0a9dcbd41fbd4",
-	"0x76f988da831153b5",
-	"0x983e5152ee66dfab",
-	"0xa831c66d2db43210",
-	"0xb00327c898fb213f",
-	"0xbf597fc7beef0ee4",
-	"0xc6e00bf33da88fc2",
-	"0xd5a79147930aa725",
-	"0x06ca6351e003826f",
-	"0x142929670a0e6e70",
-	"0x27b70a8546d22ffc",
-	"0x2e1b21385c26c926",
-	"0x4d2c6dfc5ac42aed",
-	"0x53380d139d95b3df",
-	"0x650a73548baf63de",
-	"0x766a0abb3c77b2a8",
-	"0x81c2c92e47edaee6",
-	"0x92722c851482353b",
-	"0xa2bfe8a14cf10364",
-	"0xa81a664bbc423001",
-	"0xc24b8b70d0f89791",
-	"0xc76c51a30654be30",
-	"0xd192e819d6ef5218",
-	"0xd69906245565a910",
-	"0xf40e35855771202a",
-	"0x106aa07032bbd1b8",
-	"0x19a4c116b8d2d0c8",
-	"0x1e376c085141ab53",
-	"0x2748774cdf8eeb99",
-	"0x34b0bcb5e19b48a8",
-	"0x391c0cb3c5c95a63",
-	"0x4ed8aa4ae3418acb",
-	"0x5b9cca4f7763e373",
-	"0x682e6ff3d6b2b8a3",
-	"0x748f82ee5defb2fc",
-	"0x78a5636f43172f60",
-	"0x84c87814a1f0ab72",
-	"0x8cc702081a6439ec",
-	"0x90befffa23631e28",
-	"0xa4506cebde82bde9",
-	"0xbef9a3f7b2c67915",
-	"0xc67178f2e372532b",
-	"0xca273eceea26619c",
-	"0xd186b8c721c0c207",
-	"0xeada7dd6cde0eb1e",
-	"0xf57d4f7fee6ed178",
-	"0x06f067aa72176fba",
-	"0x0a637dc5a2c898a6",
-	"0x113f9804bef90dae",
-	"0x1b710b35131c471b",
-	"0x28db77f523047d84",
-	"0x32caab7b40c72493",
-	"0x3c9ebe0a15c9bebc",
-	"0x431d67c49c100d4c",
-	"0x4cc5d4becb3e42b6",
-	"0x597f299cfc657e2a",
-	"0x5fcb6fab3ad6faec",
-	"0x6c44198c4a475817"
-].map((n) => BigInt(n)));
-K512[0];
-K512[1];
-/**
-* SHA2-256 hash function from RFC 4634. In JS it's the fastest: even faster than Blake3. Some info:
-*
-* - Trying 2^128 hashes would get 50% chance of collision, using birthday attack.
-* - BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
-* - Each sha256 hash is executing 2^18 bit operations.
-* - Good 2024 ASICs can do 200Th/sec with 3500 watts of power, corresponding to 2^36 hashes/joule.
-* @param msg - message bytes to hash
-* @returns Digest bytes.
-* @example
-* Hash a message with SHA2-256.
-* ```ts
-* sha256(new Uint8Array([97, 98, 99]));
-* ```
-*/
-const sha256 = /* @__PURE__ */ createHasher(() => new _SHA256(), /* @__PURE__ */ oidNist(1));
-//#endregion
-//#region ../../node_modules/@scure/bip39/node_modules/@scure/base/index.js
-/*! scure-base - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-function isBytes(a) {
-	return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-function isArrayOf(isString, arr) {
-	if (!Array.isArray(arr)) return false;
-	if (arr.length === 0) return true;
-	if (isString) return arr.every((item) => typeof item === "string");
-	else return arr.every((item) => Number.isSafeInteger(item));
-}
-function afn(input) {
-	if (typeof input !== "function") throw new TypeError("function expected");
-	return true;
-}
-function astr(label, input) {
-	if (typeof input !== "string") throw new TypeError(`${label}: string expected`);
-	return true;
-}
-function anumber(n) {
-	if (typeof n !== "number") throw new TypeError(`number expected, got ${typeof n}`);
-	if (!Number.isSafeInteger(n)) throw new RangeError(`invalid integer: ${n}`);
-}
-function aArr(input) {
-	if (!Array.isArray(input)) throw new TypeError("array expected");
-}
-function astrArr(label, input) {
-	if (!isArrayOf(true, input)) throw new TypeError(`${label}: array of strings expected`);
-}
-function anumArr(label, input) {
-	if (!isArrayOf(false, input)) throw new TypeError(`${label}: array of numbers expected`);
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function chain(...args) {
-	const id = (a) => a;
-	const wrap = (a, b) => (c) => a(b(c));
-	return {
-		encode: args.map((x) => x.encode).reduceRight(wrap, id),
-		decode: args.map((x) => x.decode).reduce(wrap, id)
-	};
-}
-/**
-* Encodes integer radix representation to array of strings using alphabet and back.
-* Could also be array of strings.
-* @__NO_SIDE_EFFECTS__
-*/
-function alphabet(letters) {
-	const lettersA = typeof letters === "string" ? letters.split("") : letters;
-	const len = lettersA.length;
-	astrArr("alphabet", lettersA);
-	const indexes = new Map(lettersA.map((l, i) => [l, i]));
-	return {
-		encode: (digits) => {
-			aArr(digits);
-			return digits.map((i) => {
-				if (!Number.isSafeInteger(i) || i < 0 || i >= len) throw new Error(`alphabet.encode: digit index outside alphabet "${i}". Allowed: ${letters}`);
-				return lettersA[i];
-			});
-		},
-		decode: (input) => {
-			aArr(input);
-			return input.map((letter) => {
-				astr("alphabet.decode", letter);
-				const i = indexes.get(letter);
-				if (i === void 0) throw new Error(`Unknown letter: "${letter}". Allowed: ${letters}`);
-				return i;
-			});
-		}
-	};
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function join(separator = "") {
-	astr("join", separator);
-	return {
-		encode: (from) => {
-			astrArr("join.decode", from);
-			return from.join(separator);
-		},
-		decode: (to) => {
-			astr("join.decode", to);
-			return to.split(separator);
-		}
-	};
-}
-/**
-* Pad strings array so it has integer number of bits
-* @__NO_SIDE_EFFECTS__
-*/
-function padding(bits, chr = "=") {
-	anumber(bits);
-	astr("padding", chr);
-	return {
-		encode(data) {
-			astrArr("padding.encode", data);
-			while (data.length * bits % 8) data.push(chr);
-			return data;
-		},
-		decode(input) {
-			astrArr("padding.decode", input);
-			let end = input.length;
-			if (end * bits % 8) throw new Error("padding: invalid, string should have whole number of bytes");
-			for (; end > 0 && input[end - 1] === chr; end--) if ((end - 1) * bits % 8 === 0) throw new Error("padding: invalid, string has too much padding");
-			return input.slice(0, end);
-		}
-	};
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function normalize$1(fn) {
-	afn(fn);
-	return {
-		encode: (from) => from,
-		decode: (to) => fn(to)
-	};
-}
-/**
-* Slow: O(n^2) time complexity
-*/
-function convertRadix(data, from, to) {
-	if (from < 2) throw new RangeError(`convertRadix: invalid from=${from}, base cannot be less than 2`);
-	if (to < 2) throw new RangeError(`convertRadix: invalid to=${to}, base cannot be less than 2`);
-	aArr(data);
-	if (!data.length) return [];
-	let pos = 0;
-	const res = [];
-	const digits = Array.from(data, (d) => {
-		anumber(d);
-		if (d < 0 || d >= from) throw new Error(`invalid integer: ${d}`);
-		return d;
-	});
-	const dlen = digits.length;
-	while (true) {
-		let carry = 0;
-		let done = true;
-		for (let i = pos; i < dlen; i++) {
-			const digit = digits[i];
-			const fromCarry = from * carry;
-			const digitBase = fromCarry + digit;
-			if (!Number.isSafeInteger(digitBase) || fromCarry / from !== carry || digitBase - digit !== fromCarry) throw new Error("convertRadix: carry overflow");
-			const div = digitBase / to;
-			carry = digitBase % to;
-			const rounded = Math.floor(div);
-			digits[i] = rounded;
-			if (!Number.isSafeInteger(rounded) || rounded * to + carry !== digitBase) throw new Error("convertRadix: carry overflow");
-			if (!done) continue;
-			else if (!rounded) pos = i;
-			else done = false;
-		}
-		res.push(carry);
-		if (done) break;
-	}
-	for (let i = 0; i < data.length - 1 && data[i] === 0; i++) res.push(0);
-	return res.reverse();
-}
-const gcd = (a, b) => b === 0 ? a : gcd(b, a % b);
-const radix2carry = /* @__NO_SIDE_EFFECTS__ */ (from, to) => from + (to - gcd(from, to));
-const powers = /* @__PURE__ */ (() => {
-	let res = [];
-	for (let i = 0; i < 40; i++) res.push(2 ** i);
-	return res;
-})();
-/**
-* Implemented with numbers, because BigInt is 5x slower
-*/
-function convertRadix2(data, from, to, padding) {
-	aArr(data);
-	if (from <= 0 || from > 32) throw new RangeError(`convertRadix2: wrong from=${from}`);
-	if (to <= 0 || to > 32) throw new RangeError(`convertRadix2: wrong to=${to}`);
-	if (/* @__PURE__ */ radix2carry(from, to) > 32) throw new Error(`convertRadix2: carry overflow from=${from} to=${to} carryBits=${/* @__PURE__ */ radix2carry(from, to)}`);
-	let carry = 0;
-	let pos = 0;
-	const max = powers[from];
-	const mask = powers[to] - 1;
-	const res = [];
-	for (const n of data) {
-		anumber(n);
-		if (n >= max) throw new Error(`convertRadix2: invalid data word=${n} from=${from}`);
-		carry = carry << from | n;
-		if (pos + from > 32) throw new Error(`convertRadix2: carry overflow pos=${pos} from=${from}`);
-		pos += from;
-		for (; pos >= to; pos -= to) res.push((carry >> pos - to & mask) >>> 0);
-		const pow = powers[pos];
-		if (pow === void 0) throw new Error("invalid carry");
-		carry &= pow - 1;
-	}
-	carry = carry << to - pos & mask;
-	if (!padding && pos >= from) throw new Error("Excess padding");
-	if (!padding && carry > 0) throw new Error(`Non-zero padding: ${carry}`);
-	if (padding && pos > 0) res.push(carry >>> 0);
-	return res;
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function radix(num) {
-	anumber(num);
-	const _256 = 2 ** 8;
-	return {
-		encode: (bytes) => {
-			if (!isBytes(bytes)) throw new TypeError("radix.encode input should be Uint8Array");
-			return convertRadix(Array.from(bytes), _256, num);
-		},
-		decode: (digits) => {
-			anumArr("radix.decode", digits);
-			return Uint8Array.from(convertRadix(digits, num, _256));
-		}
-	};
-}
-/**
-* If both bases are power of same number (like `2**8 <-> 2**64`),
-* there is a linear algorithm. For now we have implementation for power-of-two bases only.
-* @__NO_SIDE_EFFECTS__
-*/
-function radix2(bits, revPadding = false) {
-	anumber(bits);
-	if (bits <= 0 || bits > 32) throw new RangeError("radix2: bits should be in (0..32]");
-	if (/* @__PURE__ */ radix2carry(8, bits) > 32 || /* @__PURE__ */ radix2carry(bits, 8) > 32) throw new RangeError("radix2: carry overflow");
-	return {
-		encode: (bytes) => {
-			if (!isBytes(bytes)) throw new TypeError("radix2.encode input should be Uint8Array");
-			return convertRadix2(Array.from(bytes), 8, bits, !revPadding);
-		},
-		decode: (digits) => {
-			anumArr("radix2.decode", digits);
-			return Uint8Array.from(convertRadix2(digits, bits, 8, revPadding));
-		}
-	};
-}
-function unsafeWrapper(fn) {
-	afn(fn);
-	return function(...args) {
-		try {
-			return fn.apply(null, args);
-		} catch (e) {}
-	};
-}
-function checksum(len, fn) {
-	anumber(len);
-	if (len <= 0) throw new RangeError(`checksum length must be positive: ${len}`);
-	afn(fn);
-	const _fn = fn;
-	return {
-		encode(data) {
-			if (!isBytes(data)) throw new TypeError("checksum.encode: input should be Uint8Array");
-			const sum = _fn(data).slice(0, len);
-			const res = new Uint8Array(data.length + len);
-			res.set(data);
-			res.set(sum, data.length);
-			return res;
-		},
-		decode(data) {
-			if (!isBytes(data)) throw new TypeError("checksum.decode: input should be Uint8Array");
-			const payload = data.slice(0, -len);
-			const oldChecksum = data.slice(-len);
-			const newChecksum = _fn(payload).slice(0, len);
-			for (let i = 0; i < len; i++) if (newChecksum[i] !== oldChecksum[i]) throw new Error("Invalid checksum");
-			return payload;
-		}
-	};
-}
-/**
-* Low-level building blocks used by the exported codecs.
-* @example
-* Build a radix-32 coder from the low-level helpers.
-* ```ts
-* import { utils } from '@scure/base';
-* utils.radix2(5).encode(Uint8Array.from([1, 2, 3]));
-* ```
-*/
-const utils = /* @__PURE__ */ Object.freeze({
-	alphabet,
-	chain,
-	checksum,
-	convertRadix,
-	convertRadix2,
-	radix,
-	radix2,
-	join,
-	padding
-});
-chain(radix2(4), alphabet("0123456789ABCDEF"), join(""));
-chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding(5), join(""));
-chain(radix2(5), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), join(""));
-chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding(5), join(""));
-chain(radix2(5), alphabet("0123456789ABCDEFGHIJKLMNOPQRSTUV"), join(""));
-chain(radix2(5), alphabet("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join(""), normalize$1((s) => s.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
-const hasBase64Builtin = typeof Uint8Array.from([]).toBase64 === "function" && typeof Uint8Array.fromBase64 === "function";
-hasBase64Builtin || chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding(6), join(""));
-chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), join(""));
-hasBase64Builtin || chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding(6), join(""));
-chain(radix2(6), alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), join(""));
-const BECH_ALPHABET = chain(alphabet("qpzry9x8gf2tvdw0s3jn54khce6mua7l"), join(""));
-const POLYMOD_GENERATORS = [
-	996825010,
-	642813549,
-	513874426,
-	1027748829,
-	705979059
-];
-function bech32Polymod(pre) {
-	const b = pre >> 25;
-	let chk = (pre & 33554431) << 5;
-	for (let i = 0; i < POLYMOD_GENERATORS.length; i++) if ((b >> i & 1) === 1) chk ^= POLYMOD_GENERATORS[i];
-	return chk;
-}
-function bechChecksum(prefix, words, encodingConst = 1) {
-	const len = prefix.length;
-	let chk = 1;
-	for (let i = 0; i < len; i++) {
-		const c = prefix.charCodeAt(i);
-		if (c < 33 || c > 126) throw new Error(`Invalid prefix (${prefix})`);
-		chk = bech32Polymod(chk) ^ c >> 5;
-	}
-	chk = bech32Polymod(chk);
-	for (let i = 0; i < len; i++) chk = bech32Polymod(chk) ^ prefix.charCodeAt(i) & 31;
-	for (let v of words) chk = bech32Polymod(chk) ^ v;
-	for (let i = 0; i < 6; i++) chk = bech32Polymod(chk);
-	chk ^= encodingConst;
-	return BECH_ALPHABET.encode(convertRadix2([chk % powers[30]], 30, 5, false));
-}
-/**
-* @__NO_SIDE_EFFECTS__
-*/
-function genBech32(encoding) {
-	const ENCODING_CONST = encoding === "bech32" ? 1 : 734539939;
-	const _words = radix2(5);
-	const fromWords = _words.decode;
-	const toWords = _words.encode;
-	const fromWordsUnsafe = unsafeWrapper(fromWords);
-	function encode(prefix, words, limit = 90) {
-		astr("bech32.encode prefix", prefix);
-		if (isBytes(words)) words = Array.from(words);
-		anumArr("bech32.encode", words);
-		const plen = prefix.length;
-		if (plen === 0) throw new TypeError(`Invalid prefix length ${plen}`);
-		const actualLength = plen + 7 + words.length;
-		if (limit !== false && actualLength > limit) throw new TypeError(`Length ${actualLength} exceeds limit ${limit}`);
-		const lowered = prefix.toLowerCase();
-		const sum = bechChecksum(lowered, words, ENCODING_CONST);
-		return `${lowered}1${BECH_ALPHABET.encode(words)}${sum}`;
-	}
-	function decode(str, limit = 90) {
-		astr("bech32.decode input", str);
-		const slen = str.length;
-		if (slen < 8 || limit !== false && slen > limit) throw new TypeError(`invalid string length: ${slen} (${str}). Expected (8..${limit})`);
-		const lowered = str.toLowerCase();
-		if (str !== lowered && str !== str.toUpperCase()) throw new Error(`String must be lowercase or uppercase`);
-		const sepIndex = lowered.lastIndexOf("1");
-		if (sepIndex === 0 || sepIndex === -1) throw new Error(`Letter "1" must be present between prefix and data only`);
-		const prefix = lowered.slice(0, sepIndex);
-		const data = lowered.slice(sepIndex + 1);
-		if (data.length < 6) throw new Error("Data must be at least 6 characters long");
-		const words = BECH_ALPHABET.decode(data).slice(0, -6);
-		const sum = bechChecksum(prefix, words, ENCODING_CONST);
-		if (!data.endsWith(sum)) throw new Error(`Invalid checksum in ${str}: expected "${sum}"`);
-		return {
-			prefix,
-			words
-		};
-	}
-	const decodeUnsafe = unsafeWrapper(decode);
-	function decodeToBytes(str) {
-		const { prefix, words } = decode(str, false);
-		return {
-			prefix,
-			words,
-			bytes: fromWords(words)
-		};
-	}
-	function encodeFromBytes(prefix, bytes) {
-		return encode(prefix, toWords(bytes));
-	}
-	return {
-		encode,
-		decode,
-		encodeFromBytes,
-		decodeToBytes,
-		decodeUnsafe,
-		fromWords,
-		fromWordsUnsafe,
-		toWords
-	};
-}
-genBech32("bech32");
-genBech32("bech32m");
-"".isWellFormed;
-typeof Uint8Array.from([]).toHex === "function" && typeof Uint8Array.fromHex === "function" || chain(radix2(4), alphabet("0123456789abcdef"), join(""), normalize$1((s) => {
-	if (typeof s !== "string" || s.length % 2 !== 0) throw new TypeError(`hex.decode: expected string, got ${typeof s} with length ${s.length}`);
-	return s.toLowerCase();
-}));
-//#endregion
-//#region ../../node_modules/@scure/bip39/index.js
-const isJapanese = (wordlist) => wordlist[0] === "あいこくしん";
-function nfkd(str) {
-	if (typeof str !== "string") throw new TypeError("invalid mnemonic type: " + typeof str);
-	return str.normalize("NFKD");
-}
-function normalize(str) {
-	const norm = nfkd(str);
-	const words = norm.split(" ");
-	if (![
-		12,
-		15,
-		18,
-		21,
-		24
-	].includes(words.length)) throw new Error("Invalid mnemonic");
-	return {
-		nfkd: norm,
-		words
-	};
-}
-function aentropy(ent) {
-	abytes$1(ent);
-	if (![
-		16,
-		20,
-		24,
-		28,
-		32
-	].includes(ent.length)) throw new RangeError("invalid entropy length");
-}
-/**
-* Generate x random words. Uses Cryptographically-Secure Random Number Generator.
-* @param wordlist - Imported wordlist for a specific language.
-* @param strength - Mnemonic strength, from 128 to 256 bits.
-* @returns 12-24 word mnemonic phrase.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Generate a new English mnemonic.
-* ```ts
-* import { generateMnemonic } from '@scure/bip39';
-* import { wordlist } from '@scure/bip39/wordlists/english.js';
-* const mnemonic = generateMnemonic(wordlist, 128);
-* // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
-* ```
-*/
-function generateMnemonic(wordlist, strength = 128) {
-	anumber$1(strength);
-	if (strength % 32 !== 0 || strength > 256) throw new RangeError("Invalid entropy");
-	return entropyToMnemonic(randomBytes(strength / 8), wordlist);
-}
-const calcChecksum = (entropy) => {
-	const bitsLeft = 8 - entropy.length / 4;
-	return new Uint8Array([sha256(entropy)[0] >> bitsLeft << bitsLeft]);
-};
-function getCoder(wordlist) {
-	if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== "string") throw new TypeError("Wordlist: expected array of 2048 strings");
-	wordlist.forEach((i) => {
-		if (typeof i !== "string") throw new TypeError("wordlist: non-string element: " + i);
-	});
-	return utils.chain(utils.checksum(1, calcChecksum), utils.radix2(11, true), utils.alphabet(wordlist));
-}
-/**
-* Reversible: Converts mnemonic string to raw entropy in form of byte array.
-* @param mnemonic - 12-24 words.
-* @param wordlist - Imported wordlist for a specific language.
-* @returns Raw entropy bytes.
-* @throws If the mnemonic shape or checksum is invalid. {@link Error}
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Decode a mnemonic back into its original entropy bytes.
-* ```ts
-* import { mnemonicToEntropy } from '@scure/bip39';
-* import { wordlist } from '@scure/bip39/wordlists/english.js';
-* const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
-* const entropy = mnemonicToEntropy(mnem, wordlist);
-* // Produces the original 16-byte entropy payload.
-* new Uint8Array([
-*   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-*   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
-* ])
-* ```
-*/
-function mnemonicToEntropy(mnemonic, wordlist) {
-	const { words } = normalize(mnemonic);
-	const entropy = getCoder(wordlist).decode(words);
-	aentropy(entropy);
-	return entropy;
-}
-/**
-* Reversible: Converts raw entropy in form of byte array to mnemonic string.
-* @param entropy - Byte array.
-* @param wordlist - Imported wordlist for a specific language.
-* @returns 12-24 words.
-* @throws On wrong argument types. {@link TypeError}
-* @throws On wrong argument ranges or values. {@link RangeError}
-* @example
-* Convert raw entropy into an English mnemonic.
-* ```ts
-* import { entropyToMnemonic } from '@scure/bip39';
-* import { wordlist } from '@scure/bip39/wordlists/english.js';
-* const ent = new Uint8Array([
-*   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
-*   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
-* ]);
-* const mnemonic = entropyToMnemonic(ent, wordlist);
-* // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
-* ```
-*/
-function entropyToMnemonic(entropy, wordlist) {
-	aentropy(entropy);
-	return getCoder(wordlist).encode(entropy).join(isJapanese(wordlist) ? "　" : " ");
-}
-/**
-* Validates mnemonic for being 12-24 words contained in `wordlist`.
-* @param mnemonic - 12-24 words.
-* @param wordlist - Imported wordlist for a specific language.
-* @returns `true` when mnemonic checksum and words are valid.
-* @example
-* Validate one English mnemonic.
-* ```ts
-* import { validateMnemonic } from '@scure/bip39';
-* import { wordlist } from '@scure/bip39/wordlists/english.js';
-* const ok = validateMnemonic(
-*   'legal winner thank year wave sausage worth useful legal winner thank yellow',
-*   wordlist
-* );
-* // => true
-* ```
-*/
-function validateMnemonic$1(mnemonic, wordlist) {
-	try {
-		mnemonicToEntropy(mnemonic, wordlist);
-	} catch (e) {
-		return false;
-	}
-	return true;
-}
-//#endregion
-//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-hd/dist/HDWallet.js
-const Roles = {
-	NightExternal: 0,
-	NightInternal: 1,
-	Dust: 2,
-	Zswap: 3,
-	EcdsaUnshielded: 4
-};
-const PURPOSE = 44;
-const COIN_TYPE = 2400;
-const isValidChildIndex = (value) => Number.isSafeInteger(value) && value >= 0 && value < 2147483648;
-const CompositeDerivationResult = { fromResults: (results) => {
-	const { succeededKeys, failedRoles } = results.reduce((acc, result) => {
-		if (result.result.type === "keyDerived") acc.succeededKeys[result.role] = result.result.key;
-		else acc.failedRoles.push(result.role);
-		return acc;
-	}, {
-		succeededKeys: {},
-		failedRoles: []
-	});
-	if (failedRoles.length > 0) return {
-		type: "keyOutOfBounds",
-		roles: failedRoles
-	};
-	else return {
-		type: "keysDerived",
-		keys: succeededKeys
-	};
-} };
-var HDWallet = class HDWallet {
-	rootKey;
-	constructor(key) {
-		this.rootKey = key;
-	}
-	static fromSeed(seed) {
-		try {
-			return {
-				type: "seedOk",
-				hdWallet: new HDWallet(require_bip32.HDKey.fromMasterSeed(seed))
-			};
-		} catch (e) {
-			return {
-				type: "seedError",
-				error: e
-			};
-		}
-	}
-	selectAccount(account) {
-		return new AccountKey(this.rootKey, account);
-	}
-	/**
-	* Wipes the root key's private-key buffer, narrowing the window in which the seed is reachable.
-	*
-	* It does not reach the intermediate keys BIP32 allocates at each level of a derivation path, nor the derived keys
-	* already handed to callers — neither is reachable from here, so both are left to the garbage collector. Call this
-	* once all keys are derived, but do not read it as a guarantee that the seed is gone from the process.
-	*/
-	clear() {
-		this.rootKey.wipePrivateData();
-	}
-};
-var AccountKey = class {
-	rootKey;
-	account;
-	constructor(rootKey, account) {
-		this.account = account;
-		this.rootKey = rootKey;
-	}
-	selectRole(role) {
-		return new RoleKey(this.rootKey, this.account, role);
-	}
-	selectRoles(roles) {
-		return new CompositeRoleKey(this.rootKey, this.account, roles);
-	}
-};
-var RoleKey = class {
-	rootKey;
-	account;
-	role;
-	constructor(rootKey, account, role) {
-		this.role = role;
-		this.account = account;
-		this.rootKey = rootKey;
-	}
-	deriveKeyAt(index) {
-		if (![
-			this.account,
-			this.role,
-			index
-		].every(isValidChildIndex)) return { type: "keyOutOfBounds" };
-		const path = `m/${PURPOSE}'/${COIN_TYPE}'/${this.account}'/${this.role}/${index}`;
-		const derivedKey = this.rootKey.derive(path);
-		return derivedKey.privateKey ? {
-			type: "keyDerived",
-			key: derivedKey.privateKey
-		} : { type: "keyOutOfBounds" };
-	}
-};
-var CompositeRoleKey = class {
-	rootKey;
-	account;
-	roles;
-	constructor(rootKey, account, roles) {
-		this.roles = roles;
-		this.rootKey = rootKey;
-		this.account = account;
-	}
-	deriveKeysAt(index) {
-		const results = this.roles.map((role) => ({
-			role,
-			result: new RoleKey(this.rootKey, this.account, role).deriveKeyAt(index)
-		}));
-		return CompositeDerivationResult.fromResults(results);
-	}
-};
-//#endregion
-//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-hd/dist/MnemonicUtils.js
-const mnemonicToWords = (mnemonic) => mnemonic.split(" ");
-/** A wrapper around the bip39 package function, with default strength applied to produce 24 words */
-const generateMnemonicWords = (strength = 256) => mnemonicToWords(generateMnemonic(require_english.wordlist, strength));
-const joinMnemonicWords = (mnenomic) => mnenomic.join(" ");
-const generateRandomSeed = (strength = 256) => {
-	return crypto.getRandomValues(new Uint8Array(Math.ceil(strength / 8)));
-};
-/** A wrapper around the bip39 package function */
-const validateMnemonic = (mnemonic) => validateMnemonic$1(mnemonic, require_english.wordlist);
-//#endregion
-//#region ../../packages/module/passport-account/node_modules/@midnightntwrk/wallet-sdk-hd/dist/WalletSeeds.js
-/**
-* The one seed an application holds, and the three the wallets are started from.
-*
-* @remarks
-*   A Midnight wallet is three wallets, and each is started from its own seed derived from one master seed at its own
-*   place in the BIP32 tree. Everything needed to walk that tree has always been here — {@link HDWallet}, {@link Roles} —
-*   but the walk itself was left to callers, and every caller wrote it out again: select account zero, select the role,
-*   derive at index zero, wipe the tree. Naming it once is what this is.
-*/
-/** Raised when a master seed cannot be walked down to the three per-wallet seeds. */
-var SeedDerivationError = class extends Error {
-	name = "SeedDerivationError";
-	constructor(message, options) {
-		super(message, options);
-	}
-};
-/**
-* The seeds an application starts its three wallets from.
-*
-* @remarks
-*   Throws rather than returning a result, because this sits at the boundary an application calls directly and its
-*   failures are programming errors rather than ordinary states: a master seed BIP32 rejects, or an index outside the
-*   tree. {@link HDWallet} remains available for a caller that would rather branch on a tagged result than catch.
-*/
-const WalletSeeds = { fromMasterSeed: (masterSeed, options = {}) => {
-	const { account = 0, addressIndex = 0, unshieldedRole = Roles.NightExternal } = options;
-	const opened = HDWallet.fromSeed(masterSeed);
-	if (opened.type !== "seedOk") throw new SeedDerivationError("This master seed is not one a BIP32 tree can be built from, so no wallet seed can be derived from it.", { cause: opened.error });
-	const derived = opened.hdWallet.selectAccount(account).selectRoles([
-		Roles.Zswap,
-		unshieldedRole,
-		Roles.Dust
-	]).deriveKeysAt(addressIndex);
-	opened.hdWallet.clear();
-	if (derived.type !== "keysDerived") throw new SeedDerivationError(`No key exists at account ${account}, address index ${addressIndex} for ${derived.roles.length === 1 ? "role" : "roles"} ${derived.roles.join(", ")}: a BIP32 account, role and index are each whole numbers below 2^31.`);
-	return {
-		shielded: derived.keys[Roles.Zswap],
-		unshielded: derived.keys[unshieldedRole],
-		dust: derived.keys[Roles.Dust]
-	};
-} };
-//#endregion
-exports.AccountKey = AccountKey;
-exports.CompositeRoleKey = CompositeRoleKey;
-exports.HDWallet = HDWallet;
-exports.RoleKey = RoleKey;
-exports.Roles = Roles;
-exports.SeedDerivationError = SeedDerivationError;
-exports.WalletSeeds = WalletSeeds;
-exports.generateMnemonicWords = generateMnemonicWords;
-exports.generateRandomSeed = generateRandomSeed;
-exports.joinMnemonicWords = joinMnemonicWords;
-exports.mnemonicToWords = mnemonicToWords;
-exports.validateMnemonic = validateMnemonic;