Add comprehensive installation and setup documentation

- Add GETTING_STARTED.md with quick start guide and development modes
- Add INSTALL.sh automated installation script
- Add INSTALLATION_CHECKLIST.md, INSTALLATION_SUCCESS.md, and INSTALLATION_SUMMARY.md
- Add QUICK_REFERENCE.md for common commands
- Add SETUP_GUIDE.md with detailed setup instructions
- Update README.md with improved project overview
- Add did-wallet app dependencies and node_modules

apps/web5-dwn/node_modules/@scure/bip39/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the “Software”), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

apps/web5-dwn/node_modules/@scure/bip39/README.md

@@ -0,0 +1,101 @@
+# scure-bip39
+
+Audited & minimal JS implementation of [BIP39 mnemonic phrases](https://github.com/bitcoin/bips/blob/master/bip-0039.mediawiki).
+
+- 🔒 [**Audited**](#security) by an independent security firm
+- 🔻 Tree-shaking-friendly: use only what's necessary, other code won't be included
+- 📦 ESM and common.js
+- ➰ Only 2 audited dependencies by the same author:
+  [noble-curves](https://github.com/paulmillr/noble-curves) and [scure-base](https://github.com/paulmillr/scure-base)
+- 🪶 37KB with all deps bundled and 279KB with wordlists: much smaller than similar libraries
+
+Check out [scure-bip32](https://github.com/paulmillr/scure-bip32) if you need
+hierarchical deterministic wallets ("HD Wallets").
+
+### This library belongs to *scure*
+
+> **scure** — audited micro-libraries.
+
+- Zero or minimal dependencies
+- Highly readable TypeScript / JS code
+- PGP-signed releases and transparent NPM builds
+- Check out [homepage](https://paulmillr.com/noble/#scure) & all libraries:
+  [base](https://github.com/paulmillr/scure-base),
+  [bip32](https://github.com/paulmillr/scure-bip32),
+  [bip39](https://github.com/paulmillr/scure-bip39),
+  [btc-signer](https://github.com/paulmillr/scure-btc-signer),
+  [starknet](https://github.com/paulmillr/scure-starknet)
+
+## Usage
+
+> npm install @scure/bip39
+
+```js
+import * as bip39 from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english';
+
+// Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+const mn = bip39.generateMnemonic(wordlist);
+console.log(mn);
+
+// Reversible: Converts mnemonic string to raw entropy in form of byte array.
+const ent = bip39.mnemonicToEntropy(mn, wordlist)
+
+// Reversible: Converts raw entropy in form of byte array to mnemonic string.
+bip39.entropyToMnemonic(ent, wordlist);
+
+// Validates mnemonic for being 12-24 words contained in `wordlist`.
+bip39.validateMnemonic(mn, wordlist);
+
+// Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+await bip39.mnemonicToSeed(mn, 'password');
+bip39.mnemonicToSeedSync(mn, 'password');
+```
+
+This submodule contains the word lists defined by BIP39 for Czech, English, French, Italian, Japanese, Korean, Portuguese, Simplified and Traditional Chinese, and Spanish. These are not imported by default, as that would increase bundle sizes too much. Instead, you should import and use them explicitly.
+
+```typescript
+function generateMnemonic(wordlist: string[], strength?: number): string;
+function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
+function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
+function validateMnemonic(mnemonic: string, wordlist: string[]): boolean;
+function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
+function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;
+```
+
+All wordlists:
+
+```typescript
+import { wordlist as czech } from '@scure/bip39/wordlists/czech';
+import { wordlist as english } from '@scure/bip39/wordlists/english';
+import { wordlist as french } from '@scure/bip39/wordlists/french';
+import { wordlist as italian } from '@scure/bip39/wordlists/italian';
+import { wordlist as japanese } from '@scure/bip39/wordlists/japanese';
+import { wordlist as korean } from '@scure/bip39/wordlists/korean';
+import { wordlist as portuguese } from '@scure/bip39/wordlists/portuguese';
+import { wordlist as simplifiedChinese } from '@scure/bip39/wordlists/simplified-chinese';
+import { wordlist as spanish } from '@scure/bip39/wordlists/spanish';
+import { wordlist as traditionalChinese } from '@scure/bip39/wordlists/traditional-chinese';
+```
+
+## Security
+
+To audit wordlist content, run `node scripts/fetch-wordlist.js`.
+
+The library has been independently audited:
+
+- at version 1.0.0, in Jan 2022, by [cure53](https://cure53.de)
+  - PDFs: [online](https://cure53.de/pentest-report_hashing-libs.pdf), [offline](./audit/2022-01-05-cure53-audit-nbl2.pdf)
+  - [Changes since audit](https://github.com/paulmillr/scure-bip39/compare/1.0.0..main).
+  - The audit has been funded by [Ethereum Foundation](https://ethereum.org/en/) with help of [Nomic Labs](https://nomiclabs.io)
+
+The library was initially developed for [js-ethereum-cryptography](https://github.com/ethereum/js-ethereum-cryptography).
+At commit [ae00e6d7](https://github.com/ethereum/js-ethereum-cryptography/commit/ae00e6d7d24fb3c76a1c7fe10039f6ecd120b77e),
+it was extracted to a separate package called `micro-bip39`.
+After the audit we've decided to use `@scure` NPM namespace for security.
+
+## License
+
+[MIT License](./LICENSE)
+
+Copyright (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com)

apps/web5-dwn/node_modules/@scure/bip39/esm/index.js

@@ -0,0 +1,134 @@
+/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+import { bytes as assertBytes, number as assertNumber } from '@noble/hashes/_assert';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { randomBytes } from '@noble/hashes/utils';
+import { utils as baseUtils } from '@scure/base';
+// Japanese wordlist
+const isJapanese = (wordlist) => wordlist[0] === '\u3042\u3044\u3053\u304f\u3057\u3093';
+// Normalization replaces equivalent sequences of characters
+// so that any two texts that are equivalent will be reduced
+// to the same sequence of code points, called the normal form of the original text.
+// https://tonsky.me/blog/unicode/#why-is-a----
+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 assertEntropy(entropy) {
+    assertBytes(entropy, 16, 20, 24, 28, 32);
+}
+/**
+ * Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+ * @param wordlist imported wordlist for specific language
+ * @param strength mnemonic strength 128-256 bits
+ * @example
+ * generateMnemonic(wordlist, 128)
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export function generateMnemonic(wordlist, strength = 128) {
+    assertNumber(strength);
+    if (strength % 32 !== 0 || strength > 256)
+        throw new TypeError('Invalid entropy');
+    return entropyToMnemonic(randomBytes(strength / 8), wordlist);
+}
+const calcChecksum = (entropy) => {
+    // Checksum is ent.length/4 bits long
+    const bitsLeft = 8 - entropy.length / 4;
+    // Zero rightmost "bitsLeft" bits in byte
+    // For example: bitsLeft=4 val=10111101 -> 10110000
+    return new Uint8Array([(sha256(entropy)[0] >> bitsLeft) << bitsLeft]);
+};
+function getCoder(wordlist) {
+    if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')
+        throw new Error('Wordlist: expected array of 2048 strings');
+    wordlist.forEach((i) => {
+        if (typeof i !== 'string')
+            throw new Error(`Wordlist: non-string element: ${i}`);
+    });
+    return baseUtils.chain(baseUtils.checksum(1, calcChecksum), baseUtils.radix2(11, true), baseUtils.alphabet(wordlist));
+}
+/**
+ * Reversible: Converts mnemonic string to raw entropy in form of byte array.
+ * @param mnemonic 12-24 words
+ * @param wordlist imported wordlist for specific language
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToEntropy(mnem, wordlist)
+ * // Produces
+ * new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ])
+ */
+export function mnemonicToEntropy(mnemonic, wordlist) {
+    const { words } = normalize(mnemonic);
+    const entropy = getCoder(wordlist).decode(words);
+    assertEntropy(entropy);
+    return entropy;
+}
+/**
+ * Reversible: Converts raw entropy in form of byte array to mnemonic string.
+ * @param entropy byte array
+ * @param wordlist imported wordlist for specific language
+ * @returns 12-24 words
+ * @example
+ * const ent = new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ]);
+ * entropyToMnemonic(ent, wordlist);
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export function entropyToMnemonic(entropy, wordlist) {
+    assertEntropy(entropy);
+    const words = getCoder(wordlist).encode(entropy);
+    return words.join(isJapanese(wordlist) ? '\u3000' : ' ');
+}
+/**
+ * Validates mnemonic for being 12-24 words contained in `wordlist`.
+ */
+export function validateMnemonic(mnemonic, wordlist) {
+    try {
+        mnemonicToEntropy(mnemonic, wordlist);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+const salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * await mnemonicToSeed(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export function mnemonicToSeed(mnemonic, passphrase = '') {
+    return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+}
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export function mnemonicToSeedSync(mnemonic, passphrase = '') {
+    return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+}

apps/web5-dwn/node_modules/@scure/bip39/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

apps/web5-dwn/node_modules/@scure/bip39/index.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+ * @param wordlist imported wordlist for specific language
+ * @param strength mnemonic strength 128-256 bits
+ * @example
+ * generateMnemonic(wordlist, 128)
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export declare function generateMnemonic(wordlist: string[], strength?: number): string;
+/**
+ * Reversible: Converts mnemonic string to raw entropy in form of byte array.
+ * @param mnemonic 12-24 words
+ * @param wordlist imported wordlist for specific language
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToEntropy(mnem, wordlist)
+ * // Produces
+ * new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ])
+ */
+export declare function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array;
+/**
+ * Reversible: Converts raw entropy in form of byte array to mnemonic string.
+ * @param entropy byte array
+ * @param wordlist imported wordlist for specific language
+ * @returns 12-24 words
+ * @example
+ * const ent = new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ]);
+ * entropyToMnemonic(ent, wordlist);
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export declare function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string;
+/**
+ * Validates mnemonic for being 12-24 words contained in `wordlist`.
+ */
+export declare function validateMnemonic(mnemonic: string, wordlist: string[]): boolean;
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * await mnemonicToSeed(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export declare function mnemonicToSeed(mnemonic: string, passphrase?: string): Promise<Uint8Array>;
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export declare function mnemonicToSeedSync(mnemonic: string, passphrase?: string): Uint8Array;

apps/web5-dwn/node_modules/@scure/bip39/index.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mnemonicToSeedSync = exports.mnemonicToSeed = exports.validateMnemonic = exports.entropyToMnemonic = exports.mnemonicToEntropy = exports.generateMnemonic = void 0;
+/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+const _assert_1 = require("@noble/hashes/_assert");
+const pbkdf2_1 = require("@noble/hashes/pbkdf2");
+const sha256_1 = require("@noble/hashes/sha256");
+const sha512_1 = require("@noble/hashes/sha512");
+const utils_1 = require("@noble/hashes/utils");
+const base_1 = require("@scure/base");
+// Japanese wordlist
+const isJapanese = (wordlist) => wordlist[0] === '\u3042\u3044\u3053\u304f\u3057\u3093';
+// Normalization replaces equivalent sequences of characters
+// so that any two texts that are equivalent will be reduced
+// to the same sequence of code points, called the normal form of the original text.
+// https://tonsky.me/blog/unicode/#why-is-a----
+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 assertEntropy(entropy) {
+    (0, _assert_1.bytes)(entropy, 16, 20, 24, 28, 32);
+}
+/**
+ * Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+ * @param wordlist imported wordlist for specific language
+ * @param strength mnemonic strength 128-256 bits
+ * @example
+ * generateMnemonic(wordlist, 128)
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+function generateMnemonic(wordlist, strength = 128) {
+    (0, _assert_1.number)(strength);
+    if (strength % 32 !== 0 || strength > 256)
+        throw new TypeError('Invalid entropy');
+    return entropyToMnemonic((0, utils_1.randomBytes)(strength / 8), wordlist);
+}
+exports.generateMnemonic = generateMnemonic;
+const calcChecksum = (entropy) => {
+    // Checksum is ent.length/4 bits long
+    const bitsLeft = 8 - entropy.length / 4;
+    // Zero rightmost "bitsLeft" bits in byte
+    // For example: bitsLeft=4 val=10111101 -> 10110000
+    return new Uint8Array([((0, sha256_1.sha256)(entropy)[0] >> bitsLeft) << bitsLeft]);
+};
+function getCoder(wordlist) {
+    if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')
+        throw new Error('Wordlist: expected array of 2048 strings');
+    wordlist.forEach((i) => {
+        if (typeof i !== 'string')
+            throw new Error(`Wordlist: non-string element: ${i}`);
+    });
+    return base_1.utils.chain(base_1.utils.checksum(1, calcChecksum), base_1.utils.radix2(11, true), base_1.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 specific language
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToEntropy(mnem, wordlist)
+ * // Produces
+ * 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);
+    assertEntropy(entropy);
+    return entropy;
+}
+exports.mnemonicToEntropy = mnemonicToEntropy;
+/**
+ * Reversible: Converts raw entropy in form of byte array to mnemonic string.
+ * @param entropy byte array
+ * @param wordlist imported wordlist for specific language
+ * @returns 12-24 words
+ * @example
+ * const ent = new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ]);
+ * entropyToMnemonic(ent, wordlist);
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+function entropyToMnemonic(entropy, wordlist) {
+    assertEntropy(entropy);
+    const words = getCoder(wordlist).encode(entropy);
+    return words.join(isJapanese(wordlist) ? '\u3000' : ' ');
+}
+exports.entropyToMnemonic = entropyToMnemonic;
+/**
+ * Validates mnemonic for being 12-24 words contained in `wordlist`.
+ */
+function validateMnemonic(mnemonic, wordlist) {
+    try {
+        mnemonicToEntropy(mnemonic, wordlist);
+    }
+    catch (e) {
+        return false;
+    }
+    return true;
+}
+exports.validateMnemonic = validateMnemonic;
+const salt = (passphrase) => nfkd(`mnemonic${passphrase}`);
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * await mnemonicToSeed(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+function mnemonicToSeed(mnemonic, passphrase = '') {
+    return (0, pbkdf2_1.pbkdf2Async)(sha512_1.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+}
+exports.mnemonicToSeed = mnemonicToSeed;
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+function mnemonicToSeedSync(mnemonic, passphrase = '') {
+    return (0, pbkdf2_1.pbkdf2)(sha512_1.sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+}
+exports.mnemonicToSeedSync = mnemonicToSeedSync;

apps/web5-dwn/node_modules/@scure/bip39/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@scure/bip39",
+  "version": "1.2.2",
+  "description": "Secure, audited & minimal implementation of BIP39 mnemonic phrases",
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "wordlists/*.js",
+    "wordlists/*.d.ts",
+    "esm",
+    "src/index.ts"
+  ],
+  "types": "index.d.ts",
+  "dependencies": {
+    "@noble/hashes": "~1.3.2",
+    "@scure/base": "~1.1.4"
+  },
+  "devDependencies": {
+    "micro-should": "0.4.0",
+    "prettier": "3.1.1",
+    "typescript": "5.3.2"
+  },
+  "author": "Paul Miller (https://paulmillr.com)",
+  "homepage": "https://paulmillr.com/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/paulmillr/scure-bip39.git"
+  },
+  "contributors": [
+    {
+      "name": "Patricio Palladino",
+      "email": "patricio@nomiclabs.io"
+    },
+    {
+      "name": "Paul Miller",
+      "url": "https://paulmillr.com"
+    }
+  ],
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc && tsc -p tsconfig.esm.json",
+    "lint": "prettier --check 'src/**/*.ts' 'test/*.test.ts' 'scripts/*.js'",
+    "format": "prettier --write 'src/**/*.ts' 'test/*.test.ts' 'scripts/*.js'",
+    "test": "cd test && tsc && node bip39.test.js",
+    "fetch-wordlist": "./scripts/fetch-wordlist.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./esm/index.js",
+      "default": "./index.js"
+    },
+    "./index": {
+      "types": "./index.d.ts",
+      "import": "./esm/index.js",
+      "default": "./index.js"
+    },
+    "./wordlists/czech": {
+      "types": "./wordlists/czech.d.ts",
+      "import": "./esm/wordlists/czech.js",
+      "default": "./wordlists/czech.js"
+    },
+    "./wordlists/english": {
+      "types": "./wordlists/english.d.ts",
+      "import": "./esm/wordlists/english.js",
+      "default": "./wordlists/english.js"
+    },
+    "./wordlists/french": {
+      "types": "./wordlists/french.d.ts",
+      "import": "./esm/wordlists/french.js",
+      "default": "./wordlists/french.js"
+    },
+    "./wordlists/italian": {
+      "types": "./wordlists/italian.d.ts",
+      "import": "./esm/wordlists/italian.js",
+      "default": "./wordlists/italian.js"
+    },
+    "./wordlists/japanese": {
+      "types": "./wordlists/japanese.d.ts",
+      "import": "./esm/wordlists/japanese.js",
+      "default": "./wordlists/japanese.js"
+    },
+    "./wordlists/korean": {
+      "types": "./wordlists/korean.d.ts",
+      "import": "./esm/wordlists/korean.js",
+      "default": "./wordlists/korean.js"
+    },
+    "./wordlists/portuguese": {
+      "types": "./wordlists/portuguese.d.ts",
+      "import": "./esm/wordlists/portuguese.js",
+      "default": "./wordlists/portuguese.js"
+    },
+    "./wordlists/simplified-chinese": {
+      "types": "./wordlists/simplified-chinese.d.ts",
+      "import": "./esm/wordlists/simplified-chinese.js",
+      "default": "./wordlists/simplified-chinese.js"
+    },
+    "./wordlists/spanish": {
+      "types": "./wordlists/spanish.d.ts",
+      "import": "./esm/wordlists/spanish.js",
+      "default": "./wordlists/spanish.js"
+    },
+    "./wordlists/traditional-chinese": {
+      "types": "./wordlists/traditional-chinese.d.ts",
+      "import": "./esm/wordlists/traditional-chinese.js",
+      "default": "./wordlists/traditional-chinese.js"
+    }
+  },
+  "keywords": [
+    "bip39",
+    "mnemonic",
+    "phrase",
+    "code",
+    "bip0039",
+    "bip-39",
+    "scure",
+    "wordlist",
+    "noble"
+  ],
+  "funding": "https://paulmillr.com/funding/"
+}

apps/web5-dwn/node_modules/@scure/bip39/src/index.ts

@@ -0,0 +1,146 @@
+/*! scure-bip39 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) */
+import { bytes as assertBytes, number as assertNumber } from '@noble/hashes/_assert';
+import { pbkdf2, pbkdf2Async } from '@noble/hashes/pbkdf2';
+import { sha256 } from '@noble/hashes/sha256';
+import { sha512 } from '@noble/hashes/sha512';
+import { randomBytes } from '@noble/hashes/utils';
+import { utils as baseUtils } from '@scure/base';
+
+// Japanese wordlist
+const isJapanese = (wordlist: string[]) => wordlist[0] === '\u3042\u3044\u3053\u304f\u3057\u3093';
+
+// Normalization replaces equivalent sequences of characters
+// so that any two texts that are equivalent will be reduced
+// to the same sequence of code points, called the normal form of the original text.
+// https://tonsky.me/blog/unicode/#why-is-a----
+function nfkd(str: string) {
+  if (typeof str !== 'string') throw new TypeError(`Invalid mnemonic type: ${typeof str}`);
+  return str.normalize('NFKD');
+}
+
+function normalize(str: string) {
+  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 assertEntropy(entropy: Uint8Array) {
+  assertBytes(entropy, 16, 20, 24, 28, 32);
+}
+
+/**
+ * Generate x random words. Uses Cryptographically-Secure Random Number Generator.
+ * @param wordlist imported wordlist for specific language
+ * @param strength mnemonic strength 128-256 bits
+ * @example
+ * generateMnemonic(wordlist, 128)
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export function generateMnemonic(wordlist: string[], strength: number = 128): string {
+  assertNumber(strength);
+  if (strength % 32 !== 0 || strength > 256) throw new TypeError('Invalid entropy');
+  return entropyToMnemonic(randomBytes(strength / 8), wordlist);
+}
+
+const calcChecksum = (entropy: Uint8Array) => {
+  // Checksum is ent.length/4 bits long
+  const bitsLeft = 8 - entropy.length / 4;
+  // Zero rightmost "bitsLeft" bits in byte
+  // For example: bitsLeft=4 val=10111101 -> 10110000
+  return new Uint8Array([(sha256(entropy)[0]! >> bitsLeft) << bitsLeft]);
+};
+
+function getCoder(wordlist: string[]) {
+  if (!Array.isArray(wordlist) || wordlist.length !== 2048 || typeof wordlist[0] !== 'string')
+    throw new Error('Wordlist: expected array of 2048 strings');
+  wordlist.forEach((i) => {
+    if (typeof i !== 'string') throw new Error(`Wordlist: non-string element: ${i}`);
+  });
+  return baseUtils.chain(
+    baseUtils.checksum(1, calcChecksum),
+    baseUtils.radix2(11, true),
+    baseUtils.alphabet(wordlist)
+  );
+}
+
+/**
+ * Reversible: Converts mnemonic string to raw entropy in form of byte array.
+ * @param mnemonic 12-24 words
+ * @param wordlist imported wordlist for specific language
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToEntropy(mnem, wordlist)
+ * // Produces
+ * new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ])
+ */
+export function mnemonicToEntropy(mnemonic: string, wordlist: string[]): Uint8Array {
+  const { words } = normalize(mnemonic);
+  const entropy = getCoder(wordlist).decode(words);
+  assertEntropy(entropy);
+  return entropy;
+}
+
+/**
+ * Reversible: Converts raw entropy in form of byte array to mnemonic string.
+ * @param entropy byte array
+ * @param wordlist imported wordlist for specific language
+ * @returns 12-24 words
+ * @example
+ * const ent = new Uint8Array([
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f,
+ *   0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f
+ * ]);
+ * entropyToMnemonic(ent, wordlist);
+ * // 'legal winner thank year wave sausage worth useful legal winner thank yellow'
+ */
+export function entropyToMnemonic(entropy: Uint8Array, wordlist: string[]): string {
+  assertEntropy(entropy);
+  const words = getCoder(wordlist).encode(entropy);
+  return words.join(isJapanese(wordlist) ? '\u3000' : ' ');
+}
+
+/**
+ * Validates mnemonic for being 12-24 words contained in `wordlist`.
+ */
+export function validateMnemonic(mnemonic: string, wordlist: string[]): boolean {
+  try {
+    mnemonicToEntropy(mnemonic, wordlist);
+  } catch (e) {
+    return false;
+  }
+  return true;
+}
+
+const salt = (passphrase: string) => nfkd(`mnemonic${passphrase}`);
+
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * await mnemonicToSeed(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export function mnemonicToSeed(mnemonic: string, passphrase = '') {
+  return pbkdf2Async(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+}
+
+/**
+ * Irreversible: Uses KDF to derive 64 bytes of key data from mnemonic + optional password.
+ * @param mnemonic 12-24 words
+ * @param passphrase string that will additionally protect the key
+ * @returns 64 bytes of key data
+ * @example
+ * const mnem = 'legal winner thank year wave sausage worth useful legal winner thank yellow';
+ * mnemonicToSeedSync(mnem, 'password');
+ * // new Uint8Array([...64 bytes])
+ */
+export function mnemonicToSeedSync(mnemonic: string, passphrase = '') {
+  return pbkdf2(sha512, normalize(mnemonic).nfkd, salt(passphrase), { c: 2048, dkLen: 64 });
+}

apps/web5-dwn/node_modules/@scure/bip39/wordlists/czech.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/english.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/french.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/italian.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/japanese.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/korean.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/portuguese.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/simplified-chinese.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/spanish.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];

apps/web5-dwn/node_modules/@scure/bip39/wordlists/traditional-chinese.d.ts

@@ -0,0 +1 @@
+export declare const wordlist: string[];