@leofcoin/chain 1.10.9 → 1.10.11

package/exports/browser/{client-BVhUamQG-D-D1e_x8.js → client-B-jyclOB-CsNYfj4Z.js}

@@ -1,6 +1,8 @@
-import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-DlzZ5CP_.js';
+import { i as inflate_1, c as createDebugger, d as deflate_1, L as LittlePubSub } from './node-browser-xlqSBOaN.js';
 import 'crypto';
-import './constants-gMYZLHKp.js';
+import './constants-Cv0p224A.js';
+import './proposal.proto-BcUgd885.js';
+import './index-CvKt4UDE.js';
 
 class Api {
     _pubsub;
@@ -231,7 +233,7 @@ class SocketRequestClient {
             const init = async () => {
                 // @ts-ignore
                 if (!globalThis.WebSocket && !this.#experimentalWebsocket)
-                    globalThis.WebSocket = (await import('./browser-_hiyXwPp-DYI1tyUr.js').then(function (n) { return n.b; })).default.w3cwebsocket;
+                    globalThis.WebSocket = (await import('./browser-DvU1xNFS-sdlKNCJc.js').then(function (n) { return n.b; })).default.w3cwebsocket;
                 const client = new WebSocket(this.#url, this.#protocol);
                 if (this.#experimentalWebsocket) {
                     client.addEventListener('error', this.onerror);
@@ -1323,7 +1325,7 @@ class Client {
         }
     }
     async #loadNodeWebrtcImplementation() {
-        const koushWrtcModule = await import('./browser-D-r0O9Qn-BZDYY6cg.js').then(function (n) { return n.b; });
+        const koushWrtcModule = await import('./browser-CWeoyGUw-BabtHowB.js').then(function (n) { return n.b; });
         const koushWrtc = koushWrtcModule.default;
         if (!isWrtcImplementation(koushWrtc)) {
             throw new Error('@koush/wrtc does not match required wrtc contract');

package/exports/browser/constants-Cv0p224A.js

@@ -0,0 +1,130 @@
+import { F as FormatInterface, n as proto$2, o as proto$3, i as index, f as index$1, q as proto$4 } from './proposal.proto-BcUgd885.js';
+
+class ValidatorMessage extends FormatInterface {
+  get messageName() {
+    return "ValidatorMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof ValidatorMessage)
+      return buffer;
+    const name = "validator-message";
+    super(buffer, proto$2, { name });
+  }
+}
+
+class BlockMessage extends FormatInterface {
+  get messageName() {
+    return "BlockMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof BlockMessage)
+      return buffer;
+    const name = "block-message";
+    super(buffer, proto$3, { name });
+  }
+  encode(decoded) {
+    decoded = decoded || this.decoded;
+    const validators = [];
+    for (const validator of decoded.validators) {
+      if (validator instanceof ValidatorMessage)
+        validators.push(validator.encode());
+      else
+        validators.push(new ValidatorMessage(validator).encode());
+    }
+    return super.encode({
+      ...decoded,
+      validators: index(validators)
+    });
+  }
+  decode(encoded) {
+    encoded = encoded || this.encoded;
+    super.decode(encoded);
+    this.decoded.validators = index$1(this.decoded.validators).map((validator) => new ValidatorMessage(validator).decoded);
+    return this.decoded;
+  }
+}
+
+var proto$1 = {
+  up: Number(),
+  down: Number()
+};
+
+class BWMessage extends FormatInterface {
+  get messageName() {
+    return "BWMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof BWMessage)
+      return buffer;
+    const name = "bw-message";
+    super(buffer, proto$1, { name });
+  }
+}
+
+class LastBlockMessage extends FormatInterface {
+  get messageName() {
+    return "LastBlockMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof LastBlockMessage)
+      return buffer;
+    const name = "last-block-message";
+    super(buffer, proto$4, { name });
+  }
+}
+
+var proto = {
+  lastblock: Object(),
+  values: Object()
+};
+
+class StateMessage extends FormatInterface {
+  get messageName() {
+    return "StateMessage";
+  }
+  constructor(buffer) {
+    if (buffer instanceof StateMessage)
+      return buffer;
+    const name = "state-message";
+    super(buffer, proto, { name });
+  }
+}
+
+var networks = {
+  leofcoin: {
+    mainnet: {
+      // ports don't really matter since it is favorable to have it begind a ngninx proxy but if we change something to the proto it's easier maybe?
+      port: 44444,
+      // todo a versionhash would be nice to have as a double check?
+      versionHash: "0",
+      // a short description identifying the version
+      description: "Main net current version",
+      stars: ["wss://star.leofcoin.org"]
+      // todo webrtc and bittorent stars
+    },
+    peach: {
+      port: 44444,
+      description: "Main testnet: latest step before merging into main",
+      versionHash: "1",
+      stars: ["wss://star.leofcoin.org"]
+      // todo webrtc and bittorent stars
+    }
+  }
+};
+
+var networks$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    default: networks
+});
+
+const PROTOCOL_VERSION = "0.3.0";
+const REACHED_ONE_ZERO_ZERO = false;
+const DEFAULT_NODE_OPTIONS = {
+  autoStart: false,
+  network: "leofcoin:peach",
+  networkVersion: "peach",
+  version: PROTOCOL_VERSION,
+  stars: networks.leofcoin.peach.stars
+};
+
+export { BlockMessage as B, DEFAULT_NODE_OPTIONS as D, LastBlockMessage as L, PROTOCOL_VERSION as P, REACHED_ONE_ZERO_ZERO as R, StateMessage as S, ValidatorMessage as V, BWMessage as a, networks$1 as n };

package/exports/browser/hkdf-DhdhLAAv.js

@@ -0,0 +1,147 @@
+import { H as Hash, h as hash, t as toBytes, e as exists, b as bytes, n as number } from './weierstrass-C-jX_jly.js';
+
+// HMAC (RFC 2104)
+class HMAC extends Hash {
+    constructor(hash$1, _key) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        hash(hash$1);
+        const key = toBytes(_key);
+        this.iHash = hash$1.create();
+        if (typeof this.iHash.update !== 'function')
+            throw new Error('Expected instance of class which extends utils.Hash');
+        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$1.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 first block) of outer hash here we can re-use it between multiple calls via clone
+        this.oHash = hash$1.create();
+        // Undo internal XOR && apply outer XOR
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        this.oHash.update(pad);
+        pad.fill(0);
+    }
+    update(buf) {
+        exists(this);
+        this.iHash.update(buf);
+        return this;
+    }
+    digestInto(out) {
+        exists(this);
+        bytes(out, this.outputLen);
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        to.oHash = oHash._cloneInto(to.oHash);
+        to.iHash = iHash._cloneInto(to.iHash);
+        return to;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
+    }
+}
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ */
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new HMAC(hash, key);
+
+// HKDF (RFC 5869)
+// https://soatok.blog/2021/11/17/understanding-hkdf/
+/**
+ * HKDF-Extract(IKM, salt) -> PRK
+ * Arguments position differs from spec (IKM is first one, since it is not optional)
+ * @param hash
+ * @param ikm
+ * @param salt
+ * @returns
+ */
+function extract(hash$1, ikm, salt) {
+    hash(hash$1);
+    // NOTE: some libraries treat zero-length array as 'not provided';
+    // we don't, since we have undefined as 'not provided'
+    // https://github.com/RustCrypto/KDFs/issues/15
+    if (salt === undefined)
+        salt = new Uint8Array(hash$1.outputLen); // if not provided, it is set to a string of HashLen zeros
+    return hmac(hash$1, toBytes(salt), toBytes(ikm));
+}
+// HKDF-Expand(PRK, info, L) -> OKM
+const HKDF_COUNTER = /* @__PURE__ */ new Uint8Array([0]);
+const EMPTY_BUFFER = /* @__PURE__ */ new Uint8Array();
+/**
+ * HKDF-expand from the spec.
+ * @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 octets
+ */
+function expand(hash$1, prk, info, length = 32) {
+    hash(hash$1);
+    number(length);
+    if (length > 255 * hash$1.outputLen)
+        throw new Error('Length should be <= 255*HashLen');
+    const blocks = Math.ceil(length / hash$1.outputLen);
+    if (info === undefined)
+        info = EMPTY_BUFFER;
+    // first L(ength) octets of T
+    const okm = new Uint8Array(blocks * hash$1.outputLen);
+    // Re-use HMAC instance between blocks
+    const HMAC = hmac.create(hash$1, prk);
+    const HMACTmp = HMAC._cloneInto();
+    const T = new Uint8Array(HMAC.outputLen);
+    for (let counter = 0; counter < blocks; counter++) {
+        HKDF_COUNTER[0] = counter + 1;
+        // T(0) = empty string (zero length)
+        // T(N) = HMAC-Hash(PRK, T(N-1) | info | N)
+        HMACTmp.update(counter === 0 ? EMPTY_BUFFER : T)
+            .update(info)
+            .update(HKDF_COUNTER)
+            .digestInto(T);
+        okm.set(T, hash$1.outputLen * counter);
+        HMAC._cloneInto(HMACTmp);
+    }
+    HMAC.destroy();
+    HMACTmp.destroy();
+    T.fill(0);
+    HKDF_COUNTER.fill(0);
+    return okm.slice(0, length);
+}
+/**
+ * HKDF (RFC 5869): extract + 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
+ * @param length - length of output keying material in octets
+ */
+const hkdf = (hash, ikm, salt, info, length) => expand(hash, extract(hash, ikm, salt), info, length);
+
+export { hkdf as a, hmac as h };

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

@@ -1,6 +1,8 @@
-import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-DlzZ5CP_.js';
+import { M as MultiWallet, e as encrypt, b as base58$1 } from './node-browser-xlqSBOaN.js';
 import 'crypto';
-import './constants-gMYZLHKp.js';
+import './constants-Cv0p224A.js';
+import './proposal.proto-BcUgd885.js';
+import './index-CvKt4UDE.js';
 
 /**
  * @params {String} network