@leofcoin/chain 1.10.12 → 1.10.14

package/exports/browser/hkdf-CnZvwpZ9.js

@@ -0,0 +1,222 @@
+import { a as ahash, b as abytes, c as clean, d as aexists, e as aoutput, f as anumber } from './sha2-piimb6xL.js';
+
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @module
+ */
+/**
+ * Internal class for HMAC.
+ * Accepts any byte key, although RFC 2104 §3 recommends keys at least
+ * `HashLen` bytes long.
+ */
+class _HMAC {
+    oHash;
+    iHash;
+    blockLen;
+    outputLen;
+    canXOF = false;
+    finished = false;
+    destroyed = false;
+    constructor(hash, key) {
+        ahash(hash);
+        abytes(key, undefined, 'key');
+        this.iHash = hash.create();
+        if (typeof this.iHash.update !== 'function')
+            throw new Error('expected Hash instance');
+        this.blockLen = this.iHash.blockLen;
+        this.outputLen = this.iHash.outputLen;
+        const blockLen = this.blockLen;
+        const pad = new Uint8Array(blockLen);
+        // blockLen can be bigger than outputLen
+        pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36;
+        this.iHash.update(pad);
+        // By doing update (processing of the first block) of the outer hash here,
+        // we can re-use it between multiple calls via clone.
+        this.oHash = hash.create();
+        // Undo internal XOR && apply outer XOR
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        this.oHash.update(pad);
+        clean(pad);
+    }
+    update(buf) {
+        aexists(this);
+        this.iHash.update(buf);
+        return this;
+    }
+    digestInto(out) {
+        aexists(this);
+        aoutput(out, this);
+        this.finished = true;
+        const buf = out.subarray(0, this.outputLen);
+        // Reuse the first outputLen bytes for the inner digest; the outer hash consumes them before
+        // overwriting that same prefix with the final tag, leaving any oversized tail untouched.
+        this.iHash.digestInto(buf);
+        this.oHash.update(buf);
+        this.oHash.digestInto(buf);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since the key
+        // is already in state and we don't know it.
+        to ||= Object.create(Object.getPrototypeOf(this), {});
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        to.canXOF = canXOF;
+        to.oHash = oHash._cloneInto(to.oHash);
+        to.iHash = iHash._cloneInto(to.iHash);
+        return to;
+    }
+    clone() {
+        return this._cloneInto();
+    }
+    destroy() {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
+    }
+}
+const hmac = /* @__PURE__ */ (() => {
+    const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());
+    hmac_.create = (hash, key) => new _HMAC(hash, key);
+    return hmac_;
+})();
+
+/**
+ * HKDF (RFC 5869): extract + expand in one step.
+ * See {@link https://soatok.blog/2021/11/17/understanding-hkdf/}.
+ * @module
+ */
+// Shared mutable scratch byte for the RFC 5869 block counter `N`.
+// Safe to reuse because `expand()` is synchronous and resets it with `clean(...)` before returning.
+const HKDF_COUNTER = /* @__PURE__ */ Uint8Array.of(0);
+// Shared RFC 5869 empty string for both `info === undefined` and the first-block `T(0)` input.
+const EMPTY_BUFFER = /* @__PURE__ */ Uint8Array.of();
+/**
+ * HKDF-expand from the spec. The most important part. `HKDF-Expand(PRK, info, L) -> OKM`
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param prk - a pseudorandom key of at least HashLen octets
+ *   (usually, the output from the extract step)
+ * @param info - optional context and application specific information (can be a zero-length string)
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
+ * @param _recycled - Internal destroyed extract hashes owned by the combined `hkdf()` call.
+ * @returns Output keying material with the requested length.
+ * @throws If the requested output length exceeds the HKDF limit
+ *   for the selected hash. {@link Error}
+ * @example
+ * Run the HKDF expand step.
+ * ```ts
+ * import { expand } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * expand(sha256, new Uint8Array(32), new Uint8Array([1, 2, 3]), 16);
+ * ```
+ */
+function expand(hash, prk, info, length = 32, _recycled) {
+    ahash(hash);
+    anumber(length, 'length');
+    abytes(prk, undefined, 'prk');
+    const olen = hash.outputLen;
+    // RFC 5869 §2.3: PRK is "a pseudorandom key of at least HashLen octets".
+    if (prk.length < olen)
+        throw new Error('"prk" must be at least HashLen octets');
+    // RFC 5869 §2.3 only bounds `L` by `<= 255*HashLen`; `L=0` is valid and yields empty OKM.
+    if (length > 255 * olen)
+        throw new Error('Length must be <= 255*HashLen');
+    const blocks = Math.ceil(length / olen);
+    if (info === undefined)
+        info = EMPTY_BUFFER;
+    else
+        abytes(info, undefined, 'info');
+    if (!blocks) {
+        if (_recycled)
+            clean(prk); // Full hkdf() owns this intermediate PRK.
+        return new Uint8Array();
+    }
+    // first L(ength) octets of T
+    // The private PRK can become both T and a one-block result after HMAC consumes the key.
+    const okm = _recycled && blocks === 1 ? prk : new Uint8Array(blocks * olen);
+    const { iHash, oHash } = hmac.create(hash, prk);
+    // Driving them directly also skips `_HMAC.digestInto`'s per-digest destroy.
+    const T = _recycled ? prk : new Uint8Array(olen);
+    // Full hkdf() donates one destroyed extract hash; standalone creates one alternating worker.
+    const worker = blocks > 1 ? _recycled?.iHash || hash.create() : undefined;
+    for (let counter = 0; counter < blocks - 1; counter++) {
+        HKDF_COUNTER[0] = counter + 1;
+        const iWork = iHash._cloneInto(worker);
+        // T(0) = empty string (zero length)
+        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
+        if (counter)
+            iWork.update(T);
+        iWork.update(info).update(HKDF_COUNTER).digestInto(T);
+        oHash._cloneInto(worker).update(T).digestInto(T);
+        okm.set(T, olen * counter);
+    }
+    // Midstates are key-equivalent: they allow computing HMAC(prk, ...) for any message.
+    HKDF_COUNTER[0] = blocks; // Final block consumes them; retain worker for cleanup.
+    if (blocks > 1)
+        iHash.update(T);
+    iHash.update(info).update(HKDF_COUNTER).digestInto(T);
+    oHash.update(T).digestInto(T);
+    okm.set(T, olen * (blocks - 1));
+    iHash.destroy(); // Raw digests may leave key-derived base/worker state; wipe all explicitly.
+    oHash.destroy();
+    worker?.destroy();
+    if (T !== okm)
+        clean(T); // Wipe private T/PRK; standalone preserves caller-owned PRK.
+    clean(HKDF_COUNTER);
+    // Exact fit: return without the extra copy.
+    if (length === okm.length)
+        return okm;
+    // Copy the requested prefix, then wipe the full buffer: its tail holds
+    // up to HashLen-1 bytes of derived key material past `length`.
+    const res = okm.slice(0, length);
+    clean(okm);
+    return res;
+}
+/**
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * Combines hkdf_extract + hkdf_expand in one step
+ * @param hash - hash function that would be used (e.g. sha256)
+ * @param ikm - input keying material, the initial key
+ * @param salt - optional salt value (a non-secret random value)
+ * @param info - optional context and application specific information bytes
+ * @param length - length of output keying material in bytes.
+ *   RFC 5869 §2.3 allows `0..255*HashLen`, so `0` returns an empty OKM.
+ * @returns Output keying material derived from the input key.
+ * @throws If the requested output length exceeds the HKDF limit
+ *   for the selected hash. {@link Error}
+ * @example
+ * HKDF (RFC 5869): derive keys from an initial input.
+ * ```ts
+ * import { hkdf } from '@noble/hashes/hkdf.js';
+ * import { sha256 } from '@noble/hashes/sha2.js';
+ * import { randomBytes, utf8ToBytes } from '@noble/hashes/utils.js';
+ * const inputKey = randomBytes(32);
+ * const salt = randomBytes(32);
+ * const info = utf8ToBytes('application-key');
+ * const okm = hkdf(sha256, inputKey, salt, info, 32);
+ * ```
+ */
+const hkdf = (hash, ikm, salt, info, length) => {
+    ahash(hash);
+    if (salt === undefined)
+        salt = new Uint8Array(hash.outputLen);
+    const HMAC = hmac.create(hash, salt).update(ikm);
+    // The intermediate PRK is secret key material; wipe it instead of
+    // leaving it for GC.
+    return expand(hash, HMAC.digest(), info, length, HMAC); // expand() owns and consumes it.
+};
+
+export { hkdf as h };

package/exports/browser/{index-Bxr5Iztg-C6xBk0rK.js → index-Bxr5Iztg-AmkW0EHS.js}

@@ -1,8 +1,8 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-xlqSBOaN.js';
-import 'crypto';
-import './constants-Cv0p224A.js';
-import './proposal.proto-BcUgd885.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-CQugE1WZ.js';
+import './browser-crypto-CTP3Yk4M.js';
+import './connection-monitor-pdopeM1I.js';
 import './index-CvKt4UDE.js';
+import './sha2-piimb6xL.js';
 
 /**
  * @params {String} network

package/exports/browser/index-Bxr5Iztg-Bdpw_E83.js

@@ -0,0 +1,40 @@
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-1VSuCeew.js';
+import './browser-crypto-BHeOz9rj.js';
+import './connection-monitor-BjXI0nBP.js';
+import './index-CvKt4UDE.js';
+import './sha2-Dkoic3vb.js';
+
+/**
+ * @params {String} network
+ * @return {object} { identity, accounts, config }
+ */
+var index = async (password, network) => {
+    if (!password)
+        throw new Error('wallets need to be password protected.');
+    let wallet = new MultiWallet(network);
+    /**
+     * @type {string}
+     */
+    let mnemonic = await wallet.generate(password);
+    wallet = new MultiWallet(network);
+    await wallet.recover(mnemonic, password, network);
+    mnemonic = new Uint8Array(await encrypt(password, mnemonic));
+    const multiWIF = new Uint8Array(await encrypt(password, await wallet.multiWIF));
+    /**
+     * @type {object}
+     */
+    const external = await wallet.account(1).external(1);
+    const externalAddress = await external.address;
+    const internal = await wallet.account(1).internal(1);
+    const internalAddress = await internal.address;
+    return {
+        identity: {
+            mnemonic: base58$1.encode(mnemonic),
+            multiWIF: base58$1.encode(multiWIF),
+            walletId: await external.id
+        },
+        accounts: [['main account', externalAddress, internalAddress]]
+    };
+};
+
+export { index as default };

package/exports/browser/index-Bxr5Iztg-CxXVYm3t.js

@@ -0,0 +1,40 @@
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-wDmRaOEo.js';
+import './browser-crypto-Yk_e6OHw.js';
+import './connection-monitor-Cf0vNDCA.js';
+import './index-CvKt4UDE.js';
+import './sha2-Dkoic3vb.js';
+
+/**
+ * @params {String} network
+ * @return {object} { identity, accounts, config }
+ */
+var index = async (password, network) => {
+    if (!password)
+        throw new Error('wallets need to be password protected.');
+    let wallet = new MultiWallet(network);
+    /**
+     * @type {string}
+     */
+    let mnemonic = await wallet.generate(password);
+    wallet = new MultiWallet(network);
+    await wallet.recover(mnemonic, password, network);
+    mnemonic = new Uint8Array(await encrypt(password, mnemonic));
+    const multiWIF = new Uint8Array(await encrypt(password, await wallet.multiWIF));
+    /**
+     * @type {object}
+     */
+    const external = await wallet.account(1).external(1);
+    const externalAddress = await external.address;
+    const internal = await wallet.account(1).internal(1);
+    const internalAddress = await internal.address;
+    return {
+        identity: {
+            mnemonic: base58$1.encode(mnemonic),
+            multiWIF: base58$1.encode(multiWIF),
+            walletId: await external.id
+        },
+        accounts: [['main account', externalAddress, internalAddress]]
+    };
+};
+
+export { index as default };