@massalabs/wallet-provider 1.2.1-dev.20230803141012 → 1.2.1-dev.20230810090154

package/bundle.js

@@ -1,6 +1,1116 @@
 /******/ (() => { // webpackBootstrap
 /******/ 	var __webpack_modules__ = ({
 
+/***/ "./node_modules/@noble/hashes/_assert.js":
+/*!***********************************************!*\
+  !*** ./node_modules/@noble/hashes/_assert.js ***!
+  \***********************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.output = exports.exists = exports.hash = exports.bytes = exports.bool = exports.number = void 0;
+function number(n) {
+    if (!Number.isSafeInteger(n) || n < 0)
+        throw new Error(`Wrong positive integer: ${n}`);
+}
+exports.number = number;
+function bool(b) {
+    if (typeof b !== 'boolean')
+        throw new Error(`Expected boolean, not ${b}`);
+}
+exports.bool = bool;
+function bytes(b, ...lengths) {
+    if (!(b instanceof Uint8Array))
+        throw new Error('Expected Uint8Array');
+    if (lengths.length > 0 && !lengths.includes(b.length))
+        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+}
+exports.bytes = bytes;
+function hash(hash) {
+    if (typeof hash !== 'function' || typeof hash.create !== 'function')
+        throw new Error('Hash should be wrapped by utils.wrapConstructor');
+    number(hash.outputLen);
+    number(hash.blockLen);
+}
+exports.hash = hash;
+function exists(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');
+}
+exports.exists = exists;
+function output(out, instance) {
+    bytes(out);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+    }
+}
+exports.output = output;
+const assert = {
+    number,
+    bool,
+    bytes,
+    hash,
+    exists,
+    output,
+};
+exports["default"] = assert;
+//# sourceMappingURL=_assert.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/_blake2.js":
+/*!***********************************************!*\
+  !*** ./node_modules/@noble/hashes/_blake2.js ***!
+  \***********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.BLAKE2 = exports.SIGMA = void 0;
+const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/@noble/hashes/_assert.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// For BLAKE2b, the two extra permutations for rounds 10 and 11 are SIGMA[10..11] = SIGMA[0..1].
+// prettier-ignore
+exports.SIGMA = new Uint8Array([
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+    11, 8, 12, 0, 5, 2, 15, 13, 10, 14, 3, 6, 7, 1, 9, 4,
+    7, 9, 3, 1, 13, 12, 11, 14, 2, 6, 5, 10, 4, 0, 15, 8,
+    9, 0, 5, 7, 2, 4, 10, 15, 14, 1, 11, 12, 6, 8, 3, 13,
+    2, 12, 6, 10, 0, 11, 8, 3, 4, 13, 7, 5, 15, 14, 1, 9,
+    12, 5, 1, 15, 14, 13, 4, 10, 0, 7, 6, 3, 9, 2, 8, 11,
+    13, 11, 7, 14, 12, 1, 3, 9, 5, 0, 15, 4, 8, 6, 2, 10,
+    6, 15, 14, 9, 11, 3, 0, 8, 12, 2, 13, 7, 1, 4, 10, 5,
+    10, 2, 8, 4, 7, 6, 1, 5, 15, 11, 9, 14, 3, 12, 13, 0,
+    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+    14, 10, 4, 8, 9, 15, 13, 6, 1, 12, 0, 2, 11, 7, 5, 3,
+]);
+class BLAKE2 extends utils_js_1.Hash {
+    constructor(blockLen, outputLen, opts = {}, keyLen, saltLen, persLen) {
+        super();
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.length = 0;
+        this.pos = 0;
+        this.finished = false;
+        this.destroyed = false;
+        _assert_js_1.default.number(blockLen);
+        _assert_js_1.default.number(outputLen);
+        _assert_js_1.default.number(keyLen);
+        if (outputLen < 0 || outputLen > keyLen)
+            throw new Error('outputLen bigger than keyLen');
+        if (opts.key !== undefined && (opts.key.length < 1 || opts.key.length > keyLen))
+            throw new Error(`key must be up 1..${keyLen} byte long or undefined`);
+        if (opts.salt !== undefined && opts.salt.length !== saltLen)
+            throw new Error(`salt must be ${saltLen} byte long or undefined`);
+        if (opts.personalization !== undefined && opts.personalization.length !== persLen)
+            throw new Error(`personalization must be ${persLen} byte long or undefined`);
+        this.buffer32 = (0, utils_js_1.u32)((this.buffer = new Uint8Array(blockLen)));
+    }
+    update(data) {
+        _assert_js_1.default.exists(this);
+        // Main difference with other hashes: there is flag for last block,
+        // so we cannot process current block before we know that there
+        // is the next one. This significantly complicates logic and reduces ability
+        // to do zero-copy processing
+        const { blockLen, buffer, buffer32 } = this;
+        data = (0, utils_js_1.toBytes)(data);
+        const len = data.length;
+        const offset = data.byteOffset;
+        const buf = data.buffer;
+        for (let pos = 0; pos < len;) {
+            // If buffer is full and we still have input (don't process last block, same as blake2s)
+            if (this.pos === blockLen) {
+                this.compress(buffer32, 0, false);
+                this.pos = 0;
+            }
+            const take = Math.min(blockLen - this.pos, len - pos);
+            const dataOffset = offset + pos;
+            // full block && aligned to 4 bytes && not last in input
+            if (take === blockLen && !(dataOffset % 4) && pos + take < len) {
+                const data32 = new Uint32Array(buf, dataOffset, Math.floor((len - pos) / 4));
+                for (let pos32 = 0; pos + blockLen < len; pos32 += buffer32.length, pos += blockLen) {
+                    this.length += blockLen;
+                    this.compress(data32, pos32, false);
+                }
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            this.length += take;
+            pos += take;
+        }
+        return this;
+    }
+    digestInto(out) {
+        _assert_js_1.default.exists(this);
+        _assert_js_1.default.output(out, this);
+        const { pos, buffer32 } = this;
+        this.finished = true;
+        // Padding
+        this.buffer.subarray(pos).fill(0);
+        this.compress(buffer32, 0, true);
+        const out32 = (0, utils_js_1.u32)(out);
+        this.get().forEach((v, i) => (out32[i] = v));
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        const { buffer, length, finished, destroyed, outputLen, pos } = this;
+        to || (to = new this.constructor({ dkLen: outputLen }));
+        to.set(...this.get());
+        to.length = length;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.outputLen = outputLen;
+        to.buffer.set(buffer);
+        to.pos = pos;
+        return to;
+    }
+}
+exports.BLAKE2 = BLAKE2;
+//# sourceMappingURL=_blake2.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/_sha2.js":
+/*!*********************************************!*\
+  !*** ./node_modules/@noble/hashes/_sha2.js ***!
+  \*********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.SHA2 = void 0;
+const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/@noble/hashes/_assert.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// Polyfill for Safari 14
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    const _32n = BigInt(32);
+    const _u32_max = BigInt(0xffffffff);
+    const wh = Number((value >> _32n) & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE ? 4 : 0;
+    const l = isLE ? 0 : 4;
+    view.setUint32(byteOffset + h, wh, isLE);
+    view.setUint32(byteOffset + l, wl, isLE);
+}
+// Base SHA2 class (RFC 6234)
+class SHA2 extends utils_js_1.Hash {
+    constructor(blockLen, outputLen, padOffset, isLE) {
+        super();
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = (0, utils_js_1.createView)(this.buffer);
+    }
+    update(data) {
+        _assert_js_1.default.exists(this);
+        const { view, buffer, blockLen } = this;
+        data = (0, utils_js_1.toBytes)(data);
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = (0, utils_js_1.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) {
+        _assert_js_1.default.exists(this);
+        _assert_js_1.default.output(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        // append the bit '1' to the message
+        buffer[pos++] = 0b10000000;
+        this.buffer.subarray(pos).fill(0);
+        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
+        if (this.padOffset > blockLen - pos) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (let i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        const oview = (0, utils_js_1.createView)(out);
+        const len = this.outputLen;
+        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+        if (len % 4)
+            throw new Error('_sha2: outputLen should 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 || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.length = length;
+        to.pos = pos;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+}
+exports.SHA2 = SHA2;
+//# sourceMappingURL=_sha2.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/_u64.js":
+/*!********************************************!*\
+  !*** ./node_modules/@noble/hashes/_u64.js ***!
+  \********************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.add = exports.toBig = exports.split = exports.fromBig = void 0;
+const U32_MASK64 = BigInt(2 ** 32 - 1);
+const _32n = BigInt(32);
+// We are not using BigUint64Array, because they are extremely slow as per 2022
+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 };
+}
+exports.fromBig = fromBig;
+function split(lst, le = false) {
+    let Ah = new Uint32Array(lst.length);
+    let Al = new Uint32Array(lst.length);
+    for (let i = 0; i < lst.length; i++) {
+        const { h, l } = fromBig(lst[i], le);
+        [Ah[i], Al[i]] = [h, l];
+    }
+    return [Ah, Al];
+}
+exports.split = split;
+const toBig = (h, l) => (BigInt(h >>> 0) << _32n) | BigInt(l >>> 0);
+exports.toBig = toBig;
+// for Shift in [0, 32)
+const shrSH = (h, l, s) => h >>> s;
+const shrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in [1, 32)
+const rotrSH = (h, l, s) => (h >>> s) | (l << (32 - s));
+const rotrSL = (h, l, s) => (h << (32 - s)) | (l >>> s);
+// Right rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotrBH = (h, l, s) => (h << (64 - s)) | (l >>> (s - 32));
+const rotrBL = (h, l, s) => (h >>> (s - 32)) | (l << (64 - s));
+// Right rotate for shift===32 (just swaps l&h)
+const rotr32H = (h, l) => l;
+const rotr32L = (h, l) => h;
+// Left rotate for Shift in [1, 32)
+const rotlSH = (h, l, s) => (h << s) | (l >>> (32 - s));
+const rotlSL = (h, l, s) => (l << s) | (h >>> (32 - s));
+// Left rotate for Shift in (32, 64), NOTE: 32 is special case.
+const rotlBH = (h, l, s) => (l << (s - 32)) | (h >>> (64 - s));
+const rotlBL = (h, l, s) => (h << (s - 32)) | (l >>> (64 - s));
+// JS uses 32-bit signed integers for bitwise operations which means we cannot
+// simple take carry out of low bit sum by shift, we need to use division.
+// Removing "export" has 5% perf penalty -_-
+function add(Ah, Al, Bh, Bl) {
+    const l = (Al >>> 0) + (Bl >>> 0);
+    return { h: (Ah + Bh + ((l / 2 ** 32) | 0)) | 0, l: l | 0 };
+}
+exports.add = add;
+// Addition with more than 2 elements
+const add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+const add3H = (low, Ah, Bh, Ch) => (Ah + Bh + Ch + ((low / 2 ** 32) | 0)) | 0;
+const add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+const add4H = (low, Ah, Bh, Ch, Dh) => (Ah + Bh + Ch + Dh + ((low / 2 ** 32) | 0)) | 0;
+const add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+const add5H = (low, Ah, Bh, Ch, Dh, Eh) => (Ah + Bh + Ch + Dh + Eh + ((low / 2 ** 32) | 0)) | 0;
+// prettier-ignore
+const u64 = {
+    fromBig, split, toBig: exports.toBig,
+    shrSH, shrSL,
+    rotrSH, rotrSL, rotrBH, rotrBL,
+    rotr32H, rotr32L,
+    rotlSH, rotlSL, rotlBH, rotlBL,
+    add, add3L, add3H, add4L, add4H, add5H, add5L,
+};
+exports["default"] = u64;
+//# sourceMappingURL=_u64.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/blake2s.js":
+/*!***********************************************!*\
+  !*** ./node_modules/@noble/hashes/blake2s.js ***!
+  \***********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.blake2s = exports.compress = exports.IV = void 0;
+const _blake2_js_1 = __webpack_require__(/*! ./_blake2.js */ "./node_modules/@noble/hashes/_blake2.js");
+const _u64_js_1 = __webpack_require__(/*! ./_u64.js */ "./node_modules/@noble/hashes/_u64.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// Initial state:
+// first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19)
+// same as SHA-256
+// prettier-ignore
+exports.IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]);
+// Mixing function G splitted in two halfs
+function G1(a, b, c, d, x) {
+    a = (a + b + x) | 0;
+    d = (0, utils_js_1.rotr)(d ^ a, 16);
+    c = (c + d) | 0;
+    b = (0, utils_js_1.rotr)(b ^ c, 12);
+    return { a, b, c, d };
+}
+function G2(a, b, c, d, x) {
+    a = (a + b + x) | 0;
+    d = (0, utils_js_1.rotr)(d ^ a, 8);
+    c = (c + d) | 0;
+    b = (0, utils_js_1.rotr)(b ^ c, 7);
+    return { a, b, c, d };
+}
+// prettier-ignore
+function compress(s, offset, msg, rounds, v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15) {
+    let j = 0;
+    for (let i = 0; i < rounds; i++) {
+        ({ a: v0, b: v4, c: v8, d: v12 } = G1(v0, v4, v8, v12, msg[offset + s[j++]]));
+        ({ a: v0, b: v4, c: v8, d: v12 } = G2(v0, v4, v8, v12, msg[offset + s[j++]]));
+        ({ a: v1, b: v5, c: v9, d: v13 } = G1(v1, v5, v9, v13, msg[offset + s[j++]]));
+        ({ a: v1, b: v5, c: v9, d: v13 } = G2(v1, v5, v9, v13, msg[offset + s[j++]]));
+        ({ a: v2, b: v6, c: v10, d: v14 } = G1(v2, v6, v10, v14, msg[offset + s[j++]]));
+        ({ a: v2, b: v6, c: v10, d: v14 } = G2(v2, v6, v10, v14, msg[offset + s[j++]]));
+        ({ a: v3, b: v7, c: v11, d: v15 } = G1(v3, v7, v11, v15, msg[offset + s[j++]]));
+        ({ a: v3, b: v7, c: v11, d: v15 } = G2(v3, v7, v11, v15, msg[offset + s[j++]]));
+        ({ a: v0, b: v5, c: v10, d: v15 } = G1(v0, v5, v10, v15, msg[offset + s[j++]]));
+        ({ a: v0, b: v5, c: v10, d: v15 } = G2(v0, v5, v10, v15, msg[offset + s[j++]]));
+        ({ a: v1, b: v6, c: v11, d: v12 } = G1(v1, v6, v11, v12, msg[offset + s[j++]]));
+        ({ a: v1, b: v6, c: v11, d: v12 } = G2(v1, v6, v11, v12, msg[offset + s[j++]]));
+        ({ a: v2, b: v7, c: v8, d: v13 } = G1(v2, v7, v8, v13, msg[offset + s[j++]]));
+        ({ a: v2, b: v7, c: v8, d: v13 } = G2(v2, v7, v8, v13, msg[offset + s[j++]]));
+        ({ a: v3, b: v4, c: v9, d: v14 } = G1(v3, v4, v9, v14, msg[offset + s[j++]]));
+        ({ a: v3, b: v4, c: v9, d: v14 } = G2(v3, v4, v9, v14, msg[offset + s[j++]]));
+    }
+    return { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 };
+}
+exports.compress = compress;
+class BLAKE2s extends _blake2_js_1.BLAKE2 {
+    constructor(opts = {}) {
+        super(64, opts.dkLen === undefined ? 32 : opts.dkLen, opts, 32, 8, 8);
+        // Internal state, same as SHA-256
+        this.v0 = exports.IV[0] | 0;
+        this.v1 = exports.IV[1] | 0;
+        this.v2 = exports.IV[2] | 0;
+        this.v3 = exports.IV[3] | 0;
+        this.v4 = exports.IV[4] | 0;
+        this.v5 = exports.IV[5] | 0;
+        this.v6 = exports.IV[6] | 0;
+        this.v7 = exports.IV[7] | 0;
+        const keyLength = opts.key ? opts.key.length : 0;
+        this.v0 ^= this.outputLen | (keyLength << 8) | (0x01 << 16) | (0x01 << 24);
+        if (opts.salt) {
+            const salt = (0, utils_js_1.u32)((0, utils_js_1.toBytes)(opts.salt));
+            this.v4 ^= salt[0];
+            this.v5 ^= salt[1];
+        }
+        if (opts.personalization) {
+            const pers = (0, utils_js_1.u32)((0, utils_js_1.toBytes)(opts.personalization));
+            this.v6 ^= pers[0];
+            this.v7 ^= pers[1];
+        }
+        if (opts.key) {
+            // Pad to blockLen and update
+            const tmp = new Uint8Array(this.blockLen);
+            tmp.set((0, utils_js_1.toBytes)(opts.key));
+            this.update(tmp);
+        }
+    }
+    get() {
+        const { v0, v1, v2, v3, v4, v5, v6, v7 } = this;
+        return [v0, v1, v2, v3, v4, v5, v6, v7];
+    }
+    // prettier-ignore
+    set(v0, v1, v2, v3, v4, v5, v6, v7) {
+        this.v0 = v0 | 0;
+        this.v1 = v1 | 0;
+        this.v2 = v2 | 0;
+        this.v3 = v3 | 0;
+        this.v4 = v4 | 0;
+        this.v5 = v5 | 0;
+        this.v6 = v6 | 0;
+        this.v7 = v7 | 0;
+    }
+    compress(msg, offset, isLast) {
+        const { h, l } = _u64_js_1.default.fromBig(BigInt(this.length));
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = compress(_blake2_js_1.SIGMA, offset, msg, 10, this.v0, this.v1, this.v2, this.v3, this.v4, this.v5, this.v6, this.v7, exports.IV[0], exports.IV[1], exports.IV[2], exports.IV[3], l ^ exports.IV[4], h ^ exports.IV[5], isLast ? ~exports.IV[6] : exports.IV[6], exports.IV[7]);
+        this.v0 ^= v0 ^ v8;
+        this.v1 ^= v1 ^ v9;
+        this.v2 ^= v2 ^ v10;
+        this.v3 ^= v3 ^ v11;
+        this.v4 ^= v4 ^ v12;
+        this.v5 ^= v5 ^ v13;
+        this.v6 ^= v6 ^ v14;
+        this.v7 ^= v7 ^ v15;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.buffer32.fill(0);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    }
+}
+/**
+ * BLAKE2s - optimized for 32-bit platforms. JS doesn't have uint64, so it's faster than BLAKE2b.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen, key, salt, personalization
+ */
+exports.blake2s = (0, utils_js_1.wrapConstructorWithOpts)((opts) => new BLAKE2s(opts));
+//# sourceMappingURL=blake2s.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/blake3.js":
+/*!**********************************************!*\
+  !*** ./node_modules/@noble/hashes/blake3.js ***!
+  \**********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.blake3 = void 0;
+const _assert_js_1 = __webpack_require__(/*! ./_assert.js */ "./node_modules/@noble/hashes/_assert.js");
+const _u64_js_1 = __webpack_require__(/*! ./_u64.js */ "./node_modules/@noble/hashes/_u64.js");
+const _blake2_js_1 = __webpack_require__(/*! ./_blake2.js */ "./node_modules/@noble/hashes/_blake2.js");
+const blake2s_js_1 = __webpack_require__(/*! ./blake2s.js */ "./node_modules/@noble/hashes/blake2s.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// Flag bitset
+var Flags;
+(function (Flags) {
+    Flags[Flags["CHUNK_START"] = 1] = "CHUNK_START";
+    Flags[Flags["CHUNK_END"] = 2] = "CHUNK_END";
+    Flags[Flags["PARENT"] = 4] = "PARENT";
+    Flags[Flags["ROOT"] = 8] = "ROOT";
+    Flags[Flags["KEYED_HASH"] = 16] = "KEYED_HASH";
+    Flags[Flags["DERIVE_KEY_CONTEXT"] = 32] = "DERIVE_KEY_CONTEXT";
+    Flags[Flags["DERIVE_KEY_MATERIAL"] = 64] = "DERIVE_KEY_MATERIAL";
+})(Flags || (Flags = {}));
+const SIGMA = (() => {
+    const Id = Array.from({ length: 16 }, (_, i) => i);
+    const permute = (arr) => [2, 6, 3, 10, 7, 0, 4, 13, 1, 11, 12, 5, 9, 14, 15, 8].map((i) => arr[i]);
+    const res = [];
+    for (let i = 0, v = Id; i < 7; i++, v = permute(v))
+        res.push(...v);
+    return Uint8Array.from(res);
+})();
+// Why is this so slow? It should be 6x faster than blake2b.
+// - There is only 30% reduction in number of rounds from blake2s
+// - This function uses tree mode to achive parallelisation via SIMD and threading,
+//   however in JS we don't have threads and SIMD, so we get only overhead from tree structure
+// - It is possible to speed it up via Web Workers, hovewer it will make code singnificantly more
+//   complicated, which we are trying to avoid, since this library is intended to be used
+//   for cryptographic purposes. Also, parallelization happens only on chunk level (1024 bytes),
+//   which won't really benefit small inputs.
+class BLAKE3 extends _blake2_js_1.BLAKE2 {
+    constructor(opts = {}, flags = 0) {
+        super(64, opts.dkLen === undefined ? 32 : opts.dkLen, {}, Number.MAX_SAFE_INTEGER, 0, 0);
+        this.flags = 0 | 0;
+        this.chunkPos = 0; // Position of current block in chunk
+        this.chunksDone = 0; // How many chunks we already have
+        this.stack = [];
+        // Output
+        this.posOut = 0;
+        this.bufferOut32 = new Uint32Array(16);
+        this.chunkOut = 0; // index of output chunk
+        this.enableXOF = true;
+        this.outputLen = opts.dkLen === undefined ? 32 : opts.dkLen;
+        _assert_js_1.default.number(this.outputLen);
+        if (opts.key !== undefined && opts.context !== undefined)
+            throw new Error('Blake3: only key or context can be specified at same time');
+        else if (opts.key !== undefined) {
+            const key = (0, utils_js_1.toBytes)(opts.key).slice();
+            if (key.length !== 32)
+                throw new Error('Blake3: key should be 32 byte');
+            this.IV = (0, utils_js_1.u32)(key);
+            this.flags = flags | Flags.KEYED_HASH;
+        }
+        else if (opts.context !== undefined) {
+            const context_key = new BLAKE3({ dkLen: 32 }, Flags.DERIVE_KEY_CONTEXT)
+                .update(opts.context)
+                .digest();
+            this.IV = (0, utils_js_1.u32)(context_key);
+            this.flags = flags | Flags.DERIVE_KEY_MATERIAL;
+        }
+        else {
+            this.IV = blake2s_js_1.IV.slice();
+            this.flags = flags;
+        }
+        this.state = this.IV.slice();
+        this.bufferOut = (0, utils_js_1.u8)(this.bufferOut32);
+    }
+    // Unused
+    get() {
+        return [];
+    }
+    set() { }
+    b2Compress(counter, flags, buf, bufPos = 0) {
+        const { state: s, pos } = this;
+        const { h, l } = _u64_js_1.default.fromBig(BigInt(counter), true);
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = (0, blake2s_js_1.compress)(SIGMA, bufPos, buf, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], blake2s_js_1.IV[0], blake2s_js_1.IV[1], blake2s_js_1.IV[2], blake2s_js_1.IV[3], h, l, pos, flags);
+        s[0] = v0 ^ v8;
+        s[1] = v1 ^ v9;
+        s[2] = v2 ^ v10;
+        s[3] = v3 ^ v11;
+        s[4] = v4 ^ v12;
+        s[5] = v5 ^ v13;
+        s[6] = v6 ^ v14;
+        s[7] = v7 ^ v15;
+    }
+    compress(buf, bufPos = 0, isLast = false) {
+        // Compress last block
+        let flags = this.flags;
+        if (!this.chunkPos)
+            flags |= Flags.CHUNK_START;
+        if (this.chunkPos === 15 || isLast)
+            flags |= Flags.CHUNK_END;
+        if (!isLast)
+            this.pos = this.blockLen;
+        this.b2Compress(this.chunksDone, flags, buf, bufPos);
+        this.chunkPos += 1;
+        // If current block is last in chunk (16 blocks), then compress chunks
+        if (this.chunkPos === 16 || isLast) {
+            let chunk = this.state;
+            this.state = this.IV.slice();
+            // If not the last one, compress only when there are trailing zeros in chunk counter
+            // chunks used as binary tree where current stack is path. Zero means current leaf is finished and can be compressed.
+            // 1 (001) - leaf not finished (just push current chunk to stack)
+            // 2 (010) - leaf finished at depth=1 (merge with last elm on stack and push back)
+            // 3 (011) - last leaf not finished
+            // 4 (100) - leafs finished at depth=1 and depth=2
+            for (let last, chunks = this.chunksDone + 1; isLast || !(chunks & 1); chunks >>= 1) {
+                if (!(last = this.stack.pop()))
+                    break;
+                this.buffer32.set(last, 0);
+                this.buffer32.set(chunk, 8);
+                this.pos = this.blockLen;
+                this.b2Compress(0, this.flags | Flags.PARENT, this.buffer32, 0);
+                chunk = this.state;
+                this.state = this.IV.slice();
+            }
+            this.chunksDone++;
+            this.chunkPos = 0;
+            this.stack.push(chunk);
+        }
+        this.pos = 0;
+    }
+    _cloneInto(to) {
+        to = super._cloneInto(to);
+        const { IV, flags, state, chunkPos, posOut, chunkOut, stack, chunksDone } = this;
+        to.state.set(state.slice());
+        to.stack = stack.map((i) => Uint32Array.from(i));
+        to.IV.set(IV);
+        to.flags = flags;
+        to.chunkPos = chunkPos;
+        to.chunksDone = chunksDone;
+        to.posOut = posOut;
+        to.chunkOut = chunkOut;
+        to.enableXOF = this.enableXOF;
+        to.bufferOut32.set(this.bufferOut32);
+        return to;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.state.fill(0);
+        this.buffer32.fill(0);
+        this.IV.fill(0);
+        this.bufferOut32.fill(0);
+        for (let i of this.stack)
+            i.fill(0);
+    }
+    // Same as b2Compress, but doesn't modify state and returns 16 u32 array (instead of 8)
+    b2CompressOut() {
+        const { state: s, pos, flags, buffer32, bufferOut32: out32 } = this;
+        const { h, l } = _u64_js_1.default.fromBig(BigInt(this.chunkOut++));
+        // prettier-ignore
+        const { v0, v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15 } = (0, blake2s_js_1.compress)(SIGMA, 0, buffer32, 7, s[0], s[1], s[2], s[3], s[4], s[5], s[6], s[7], blake2s_js_1.IV[0], blake2s_js_1.IV[1], blake2s_js_1.IV[2], blake2s_js_1.IV[3], l, h, pos, flags);
+        out32[0] = v0 ^ v8;
+        out32[1] = v1 ^ v9;
+        out32[2] = v2 ^ v10;
+        out32[3] = v3 ^ v11;
+        out32[4] = v4 ^ v12;
+        out32[5] = v5 ^ v13;
+        out32[6] = v6 ^ v14;
+        out32[7] = v7 ^ v15;
+        out32[8] = s[0] ^ v8;
+        out32[9] = s[1] ^ v9;
+        out32[10] = s[2] ^ v10;
+        out32[11] = s[3] ^ v11;
+        out32[12] = s[4] ^ v12;
+        out32[13] = s[5] ^ v13;
+        out32[14] = s[6] ^ v14;
+        out32[15] = s[7] ^ v15;
+        this.posOut = 0;
+    }
+    finish() {
+        if (this.finished)
+            return;
+        this.finished = true;
+        // Padding
+        this.buffer.fill(0, this.pos);
+        // Process last chunk
+        let flags = this.flags | Flags.ROOT;
+        if (this.stack.length) {
+            flags |= Flags.PARENT;
+            this.compress(this.buffer32, 0, true);
+            this.chunksDone = 0;
+            this.pos = this.blockLen;
+        }
+        else {
+            flags |= (!this.chunkPos ? Flags.CHUNK_START : 0) | Flags.CHUNK_END;
+        }
+        this.flags = flags;
+        this.b2CompressOut();
+    }
+    writeInto(out) {
+        _assert_js_1.default.exists(this, false);
+        _assert_js_1.default.bytes(out);
+        this.finish();
+        const { blockLen, bufferOut } = this;
+        for (let pos = 0, len = out.length; pos < len;) {
+            if (this.posOut >= blockLen)
+                this.b2CompressOut();
+            const take = Math.min(blockLen - this.posOut, len - pos);
+            out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+            this.posOut += take;
+            pos += take;
+        }
+        return out;
+    }
+    xofInto(out) {
+        if (!this.enableXOF)
+            throw new Error('XOF is not possible after digest call');
+        return this.writeInto(out);
+    }
+    xof(bytes) {
+        _assert_js_1.default.number(bytes);
+        return this.xofInto(new Uint8Array(bytes));
+    }
+    digestInto(out) {
+        _assert_js_1.default.output(out, this);
+        if (this.finished)
+            throw new Error('digest() was already called');
+        this.enableXOF = false;
+        this.writeInto(out);
+        this.destroy();
+        return out;
+    }
+    digest() {
+        return this.digestInto(new Uint8Array(this.outputLen));
+    }
+}
+/**
+ * BLAKE3 hash function.
+ * @param msg - message that would be hashed
+ * @param opts - dkLen, key, context
+ */
+exports.blake3 = (0, utils_js_1.wrapXOFConstructorWithOpts)((opts) => new BLAKE3(opts));
+//# sourceMappingURL=blake3.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/crypto.js":
+/*!**********************************************!*\
+  !*** ./node_modules/@noble/hashes/crypto.js ***!
+  \**********************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.crypto = void 0;
+exports.crypto = typeof globalThis === 'object' && 'crypto' in globalThis ? globalThis.crypto : undefined;
+//# sourceMappingURL=crypto.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/sha256.js":
+/*!**********************************************!*\
+  !*** ./node_modules/@noble/hashes/sha256.js ***!
+  \**********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.sha224 = exports.sha256 = void 0;
+const _sha2_js_1 = __webpack_require__(/*! ./_sha2.js */ "./node_modules/@noble/hashes/_sha2.js");
+const utils_js_1 = __webpack_require__(/*! ./utils.js */ "./node_modules/@noble/hashes/utils.js");
+// Choice: a ? b : c
+const Chi = (a, b, c) => (a & b) ^ (~a & c);
+// Majority function, true if any two inpust is true
+const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+// Round constants:
+// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
+// prettier-ignore
+const SHA256_K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
+]);
+// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+// prettier-ignore
+const IV = new Uint32Array([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
+]);
+// Temporary buffer, not used to store anything between runs
+// Named this way because it matches specification.
+const SHA256_W = new Uint32Array(64);
+class SHA256 extends _sha2_js_1.SHA2 {
+    constructor() {
+        super(64, 32, 8, false);
+        // We cannot use array here since array allows indexing by variable
+        // which means optimizer/compiler cannot use registers.
+        this.A = IV[0] | 0;
+        this.B = IV[1] | 0;
+        this.C = IV[2] | 0;
+        this.D = IV[3] | 0;
+        this.E = IV[4] | 0;
+        this.F = IV[5] | 0;
+        this.G = IV[6] | 0;
+        this.H = IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    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) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        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 = (0, utils_js_1.rotr)(W15, 7) ^ (0, utils_js_1.rotr)(W15, 18) ^ (W15 >>> 3);
+            const s1 = (0, utils_js_1.rotr)(W2, 17) ^ (0, utils_js_1.rotr)(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = (0, utils_js_1.rotr)(E, 6) ^ (0, utils_js_1.rotr)(E, 11) ^ (0, utils_js_1.rotr)(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = (0, utils_js_1.rotr)(A, 2) ^ (0, utils_js_1.rotr)(A, 13) ^ (0, utils_js_1.rotr)(A, 22);
+            const T2 = (sigma0 + 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;
+        }
+        // Add the compressed chunk to the current hash value
+        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() {
+        SHA256_W.fill(0);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        this.buffer.fill(0);
+    }
+}
+// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
+class SHA224 extends SHA256 {
+    constructor() {
+        super();
+        this.A = 0xc1059ed8 | 0;
+        this.B = 0x367cd507 | 0;
+        this.C = 0x3070dd17 | 0;
+        this.D = 0xf70e5939 | 0;
+        this.E = 0xffc00b31 | 0;
+        this.F = 0x68581511 | 0;
+        this.G = 0x64f98fa7 | 0;
+        this.H = 0xbefa4fa4 | 0;
+        this.outputLen = 28;
+    }
+}
+/**
+ * SHA2-256 hash function
+ * @param message - data that would be hashed
+ */
+exports.sha256 = (0, utils_js_1.wrapConstructor)(() => new SHA256());
+exports.sha224 = (0, utils_js_1.wrapConstructor)(() => new SHA224());
+//# sourceMappingURL=sha256.js.map
+
+/***/ }),
+
+/***/ "./node_modules/@noble/hashes/utils.js":
+/*!*********************************************!*\
+  !*** ./node_modules/@noble/hashes/utils.js ***!
+  \*********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.randomBytes = exports.wrapXOFConstructorWithOpts = exports.wrapConstructorWithOpts = exports.wrapConstructor = exports.checkOpts = exports.Hash = exports.concatBytes = exports.toBytes = exports.utf8ToBytes = exports.asyncLoop = exports.nextTick = exports.hexToBytes = exports.bytesToHex = exports.isLE = exports.rotr = exports.createView = exports.u32 = exports.u8 = void 0;
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated, we can just drop the import.
+const crypto_1 = __webpack_require__(/*! @noble/hashes/crypto */ "./node_modules/@noble/hashes/crypto.js");
+const u8a = (a) => a instanceof Uint8Array;
+// Cast array to different type
+const u8 = (arr) => new Uint8Array(arr.buffer, arr.byteOffset, arr.byteLength);
+exports.u8 = u8;
+const u32 = (arr) => new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+exports.u32 = u32;
+// Cast array to view
+const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+exports.createView = createView;
+// The rotate right (circular right shift) operation for uint32
+const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
+exports.rotr = rotr;
+// big-endian hardware is rare. Just in case someone still decides to run hashes:
+// early-throw an error because we don't support BE yet.
+exports.isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+if (!exports.isLE)
+    throw new Error('Non little-endian hardware is not supported');
+const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+/**
+ * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'
+ */
+function bytesToHex(bytes) {
+    if (!u8a(bytes))
+        throw new Error('Uint8Array expected');
+    // pre-caching improves the speed 6x
+    let hex = '';
+    for (let i = 0; i < bytes.length; i++) {
+        hex += hexes[bytes[i]];
+    }
+    return hex;
+}
+exports.bytesToHex = bytesToHex;
+/**
+ * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])
+ */
+function hexToBytes(hex) {
+    if (typeof hex !== 'string')
+        throw new Error('hex string expected, got ' + typeof hex);
+    const len = hex.length;
+    if (len % 2)
+        throw new Error('padded hex string expected, got unpadded hex of length ' + len);
+    const array = new Uint8Array(len / 2);
+    for (let i = 0; i < array.length; i++) {
+        const j = i * 2;
+        const hexByte = hex.slice(j, j + 2);
+        const byte = Number.parseInt(hexByte, 16);
+        if (Number.isNaN(byte) || byte < 0)
+            throw new Error('Invalid byte sequence');
+        array[i] = byte;
+    }
+    return array;
+}
+exports.hexToBytes = hexToBytes;
+// There is no setImmediate in browser and setTimeout is slow.
+// call of async fn will return Promise, which will be fullfiled only on
+// next scheduler queue processing step and this is exactly what we need.
+const nextTick = async () => { };
+exports.nextTick = nextTick;
+// Returns control to thread each 'tick' ms to avoid blocking
+async function asyncLoop(iters, tick, cb) {
+    let ts = Date.now();
+    for (let i = 0; i < iters; i++) {
+        cb(i);
+        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
+        const diff = Date.now() - ts;
+        if (diff >= 0 && diff < tick)
+            continue;
+        await (0, exports.nextTick)();
+        ts += diff;
+    }
+}
+exports.asyncLoop = asyncLoop;
+/**
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+function utf8ToBytes(str) {
+    if (typeof str !== 'string')
+        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+exports.utf8ToBytes = utf8ToBytes;
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes(data);
+    if (!u8a(data))
+        throw new Error(`expected Uint8Array, got ${typeof data}`);
+    return data;
+}
+exports.toBytes = toBytes;
+/**
+ * Copies several Uint8Arrays into one.
+ */
+function concatBytes(...arrays) {
+    const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
+    let pad = 0; // walk through each item, ensure they have proper type
+    arrays.forEach((a) => {
+        if (!u8a(a))
+            throw new Error('Uint8Array expected');
+        r.set(a, pad);
+        pad += a.length;
+    });
+    return r;
+}
+exports.concatBytes = concatBytes;
+// For runtime check if class implements interface
+class Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
+}
+exports.Hash = Hash;
+// Check if object doens't have custom constructor (like Uint8Array/Array)
+const isPlainObject = (obj) => Object.prototype.toString.call(obj) === '[object Object]' && obj.constructor === Object;
+function checkOpts(defaults, opts) {
+    if (opts !== undefined && (typeof opts !== 'object' || !isPlainObject(opts)))
+        throw new Error('Options should be object or undefined');
+    const merged = Object.assign(defaults, opts);
+    return merged;
+}
+exports.checkOpts = checkOpts;
+function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+exports.wrapConstructor = wrapConstructor;
+function wrapConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+exports.wrapConstructorWithOpts = wrapConstructorWithOpts;
+function wrapXOFConstructorWithOpts(hashCons) {
+    const hashC = (msg, opts) => hashCons(opts).update(toBytes(msg)).digest();
+    const tmp = hashCons({});
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = (opts) => hashCons(opts);
+    return hashC;
+}
+exports.wrapXOFConstructorWithOpts = wrapXOFConstructorWithOpts;
+/**
+ * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
+ */
+function randomBytes(bytesLength = 32) {
+    if (crypto_1.crypto && typeof crypto_1.crypto.getRandomValues === 'function') {
+        return crypto_1.crypto.getRandomValues(new Uint8Array(bytesLength));
+    }
+    throw new Error('crypto.getRandomValues must be defined');
+}
+exports.randomBytes = randomBytes;
+//# sourceMappingURL=utils.js.map
+
+/***/ }),
+
 /***/ "./node_modules/axios/index.js":
 /*!*************************************!*\
   !*** ./node_modules/axios/index.js ***!
@@ -2161,6 +3271,138 @@ module.exports = {
 };
 
 
+/***/ }),
+
+/***/ "./node_modules/base-x/src/index.js":
+/*!******************************************!*\
+  !*** ./node_modules/base-x/src/index.js ***!
+  \******************************************/
+/***/ ((module) => {
+
+"use strict";
+
+// base-x encoding / decoding
+// Copyright (c) 2018 base-x contributors
+// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
+// Distributed under the MIT software license, see the accompanying
+// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
+function base (ALPHABET) {
+  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
+  var BASE_MAP = new Uint8Array(256)
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i)
+    var xc = x.charCodeAt(0)
+    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
+    BASE_MAP[xc] = i
+  }
+  var BASE = ALPHABET.length
+  var LEADER = ALPHABET.charAt(0)
+  var FACTOR = Math.log(BASE) / Math.log(256) // log(BASE) / log(256), rounded up
+  var iFACTOR = Math.log(256) / Math.log(BASE) // log(256) / log(BASE), rounded up
+  function encode (source) {
+    if (source instanceof Uint8Array) {
+    } else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength)
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source)
+    }
+    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
+    if (source.length === 0) { return '' }
+        // Skip & count leading zeroes.
+    var zeroes = 0
+    var length = 0
+    var pbegin = 0
+    var pend = source.length
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++
+      zeroes++
+    }
+        // Allocate enough space in big-endian base58 representation.
+    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0
+    var b58 = new Uint8Array(size)
+        // Process the bytes.
+    while (pbegin !== pend) {
+      var carry = source[pbegin]
+            // Apply "b58 = b58 * 256 + ch".
+      var i = 0
+      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
+        carry += (256 * b58[it1]) >>> 0
+        b58[it1] = (carry % BASE) >>> 0
+        carry = (carry / BASE) >>> 0
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i
+      pbegin++
+    }
+        // Skip leading zeroes in base58 result.
+    var it2 = size - length
+    while (it2 !== size && b58[it2] === 0) {
+      it2++
+    }
+        // Translate the result into a string.
+    var str = LEADER.repeat(zeroes)
+    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]) }
+    return str
+  }
+  function decodeUnsafe (source) {
+    if (typeof source !== 'string') { throw new TypeError('Expected String') }
+    if (source.length === 0) { return new Uint8Array() }
+    var psz = 0
+        // Skip and count leading '1's.
+    var zeroes = 0
+    var length = 0
+    while (source[psz] === LEADER) {
+      zeroes++
+      psz++
+    }
+        // Allocate enough space in big-endian base256 representation.
+    var size = (((source.length - psz) * FACTOR) + 1) >>> 0 // log(58) / log(256), rounded up.
+    var b256 = new Uint8Array(size)
+        // Process the characters.
+    while (source[psz]) {
+            // Decode character
+      var carry = BASE_MAP[source.charCodeAt(psz)]
+            // Invalid character
+      if (carry === 255) { return }
+      var i = 0
+      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
+        carry += (BASE * b256[it3]) >>> 0
+        b256[it3] = (carry % 256) >>> 0
+        carry = (carry / 256) >>> 0
+      }
+      if (carry !== 0) { throw new Error('Non-zero carry') }
+      length = i
+      psz++
+    }
+        // Skip leading zeroes in b256.
+    var it4 = size - length
+    while (it4 !== size && b256[it4] === 0) {
+      it4++
+    }
+    var vch = new Uint8Array(zeroes + (size - it4))
+    var j = zeroes
+    while (it4 !== size) {
+      vch[j++] = b256[it4++]
+    }
+    return vch
+  }
+  function decode (string) {
+    var buffer = decodeUnsafe(string)
+    if (buffer) { return buffer }
+    throw new Error('Non-base' + BASE + ' character')
+  }
+  return {
+    encode: encode,
+    decodeUnsafe: decodeUnsafe,
+    decode: decode
+  }
+}
+module.exports = base
+
+
 /***/ }),
 
 /***/ "./node_modules/base64-js/index.js":
@@ -2322,6 +3564,103 @@ function fromByteArray (uint8) {
 }
 
 
+/***/ }),
+
+/***/ "./node_modules/bs58/index.js":
+/*!************************************!*\
+  !*** ./node_modules/bs58/index.js ***!
+  \************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+const basex = __webpack_require__(/*! base-x */ "./node_modules/base-x/src/index.js")
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+
+module.exports = basex(ALPHABET)
+
+
+/***/ }),
+
+/***/ "./node_modules/bs58check/base.js":
+/*!****************************************!*\
+  !*** ./node_modules/bs58check/base.js ***!
+  \****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var base58 = __webpack_require__(/*! bs58 */ "./node_modules/bs58/index.js")
+
+module.exports = function (checksumFn) {
+  // Encode a buffer as a base58-check encoded string
+  function encode (payload) {
+    var payloadU8 = Uint8Array.from(payload)
+    var checksum = checksumFn(payloadU8)
+    var length = payloadU8.length + 4
+    var both = new Uint8Array(length)
+    both.set(payloadU8, 0)
+    both.set(checksum.subarray(0, 4), payloadU8.length)
+    return base58.encode(both, length)
+  }
+
+  function decodeRaw (buffer) {
+    var payload = buffer.slice(0, -4)
+    var checksum = buffer.slice(-4)
+    var newChecksum = checksumFn(payload)
+
+    if (checksum[0] ^ newChecksum[0] |
+        checksum[1] ^ newChecksum[1] |
+        checksum[2] ^ newChecksum[2] |
+        checksum[3] ^ newChecksum[3]) return
+
+    return payload
+  }
+
+  // Decode a base58-check encoded string to a buffer, no result if checksum is wrong
+  function decodeUnsafe (string) {
+    var buffer = base58.decodeUnsafe(string)
+    if (!buffer) return
+
+    return decodeRaw(buffer)
+  }
+
+  function decode (string) {
+    var buffer = base58.decode(string)
+    var payload = decodeRaw(buffer, checksumFn)
+    if (!payload) throw new Error('Invalid checksum')
+    return payload
+  }
+
+  return {
+    encode: encode,
+    decode: decode,
+    decodeUnsafe: decodeUnsafe
+  }
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/bs58check/index.js":
+/*!*****************************************!*\
+  !*** ./node_modules/bs58check/index.js ***!
+  \*****************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+"use strict";
+
+
+var { sha256 } = __webpack_require__(/*! @noble/hashes/sha256 */ "./node_modules/@noble/hashes/sha256.js")
+var bs58checkBase = __webpack_require__(/*! ./base */ "./node_modules/bs58check/base.js")
+
+// SHA256(SHA256(buffer))
+function sha256x2 (buffer) {
+  return sha256(sha256(buffer))
+}
+
+module.exports = bs58checkBase(sha256x2)
+
+
 /***/ }),
 
 /***/ "./node_modules/buffer/index.js":
@@ -5249,44 +6588,783 @@ Object.defineProperty(exports, "Account", ({ enumerable: true, get: function ()
 
 /***/ }),
 
-/***/ "./src/connector/Connector.ts":
-/*!************************************!*\
-  !*** ./src/connector/Connector.ts ***!
-  \************************************/
+/***/ "./src/bearbyWallet/BearbyAccount.ts":
+/*!*******************************************!*\
+  !*** ./src/bearbyWallet/BearbyAccount.ts ***!
+  \*******************************************/
 /***/ ((__unused_webpack_module, exports, __webpack_require__) => {
 
 "use strict";
 
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.connector = exports.MASSA_WINDOW_OBJECT = void 0;
+exports.getBytesPublicKey = exports.BearbyAccount = exports.requestHeaders = exports.OperationTypeId = exports.OperationsType = exports.PUBLIC_NODE_RPC = void 0;
+const bearby_js_1 = __webpack_require__(/*! @hicaru/bearby.js */ "./node_modules/@hicaru/bearby.js/dist/index.js");
+const RequestHandler_1 = __webpack_require__(/*! ../massaStation/RequestHandler */ "./src/massaStation/RequestHandler.ts");
+const jsonRpcMethods_1 = __webpack_require__(/*! ./jsonRpcMethods */ "./src/bearbyWallet/jsonRpcMethods.ts");
+const axios_1 = __webpack_require__(/*! axios */ "./node_modules/axios/index.js");
+const BearbyProvider_1 = __webpack_require__(/*! ./BearbyProvider */ "./src/bearbyWallet/BearbyProvider.ts");
+const Xbqcrypto_1 = __webpack_require__(/*! ./Xbqcrypto */ "./src/bearbyWallet/Xbqcrypto.ts");
 /**
- * This file defines a TypeScript module named connector.
- * It is the tool that allows the 'provider' and 'account' objects to communicate with the web page script.
- *
- * @remarks
- * - If you are only looking to use our library, the connector object will not be useful to you.
- * - If you want to work on this repo, you will probably be interested in this object
- *
+ * The maximum allowed gas for a read operation
  */
-const uid_1 = __webpack_require__(/*! uid */ "./node_modules/uid/dist/index.js");
-const __1 = __webpack_require__(/*! .. */ "./src/index.ts");
-const MassaStationDiscovery_1 = __webpack_require__(/*! ../massaStation/MassaStationDiscovery */ "./src/massaStation/MassaStationDiscovery.ts");
-const MassaStationProvider_1 = __webpack_require__(/*! ../massaStation/MassaStationProvider */ "./src/massaStation/MassaStationProvider.ts");
+const MAX_READ_BLOCK_GAS = BigInt(4294967295);
 /**
- * A constant string that is used to identify the HTML element that is used for
- * communication between the web page script and the content script.
+ * The RPC we are using to query the node
  */
-exports.MASSA_WINDOW_OBJECT = 'massaWalletProvider';
+exports.PUBLIC_NODE_RPC = 'https://buildnet.massa.net/api/v2';
+var OperationsType;
+(function (OperationsType) {
+    OperationsType[OperationsType["Payment"] = 0] = "Payment";
+    OperationsType[OperationsType["RollBuy"] = 1] = "RollBuy";
+    OperationsType[OperationsType["RollSell"] = 2] = "RollSell";
+    OperationsType[OperationsType["ExecuteSC"] = 3] = "ExecuteSC";
+    OperationsType[OperationsType["CallSC"] = 4] = "CallSC";
+})(OperationsType = exports.OperationsType || (exports.OperationsType = {}));
 /**
- * This class enables communication with the content script by sending and receiving messages.
- * @remarks
- * - This class is used to send messages to the content script and to receive messages from the content script.
- * - It is used to send messages to the content script and to receive messages from the content script.
- *
+ * Associates an operation type with a number.
  */
-class Connector {
-    /**
-     * Connector constructor
+var OperationTypeId;
+(function (OperationTypeId) {
+    OperationTypeId[OperationTypeId["Transaction"] = 0] = "Transaction";
+    OperationTypeId[OperationTypeId["RollBuy"] = 1] = "RollBuy";
+    OperationTypeId[OperationTypeId["RollSell"] = 2] = "RollSell";
+    OperationTypeId[OperationTypeId["ExecuteSC"] = 3] = "ExecuteSC";
+    OperationTypeId[OperationTypeId["CallSC"] = 4] = "CallSC";
+})(OperationTypeId = exports.OperationTypeId || (exports.OperationTypeId = {}));
+exports.requestHeaders = {
+    Accept: 'application/json,text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+    'Access-Control-Allow-Origin': '*',
+    'Access-Control-Allow-Credentials': true,
+    'Access-Control-Allow-Methods': 'GET,PUT,POST,DELETE,PATCH,OPTIONS',
+};
+class BearbyAccount {
+    constructor({ address, name }, providerName) {
+        this._nodeUrl = exports.PUBLIC_NODE_RPC;
+        this._address = address;
+        this._name = name ?? 'Bearby_account';
+        this._providerName = providerName;
+    }
+    address() {
+        return this._address;
+    }
+    name() {
+        return this._name;
+    }
+    providerName() {
+        return this._providerName;
+    }
+    // needs testing
+    async balance() {
+        // Not available on bearby. we have to manually call the api
+        const body = {
+            jsonrpc: '2.0',
+            method: 'get_addresses',
+            params: [[this._address]],
+            id: 0,
+        };
+        const addressInfos = await (0, RequestHandler_1.postRequest)(exports.PUBLIC_NODE_RPC, body);
+        if (addressInfos.isError || addressInfos.error) {
+            throw addressInfos.error.message;
+        }
+        return {
+            finalBalance: addressInfos.result.result[0].final_balance,
+            candidateBalance: addressInfos.result.result[0].candidate_balance,
+        };
+    }
+    // need testing
+    async sign(data) {
+        const encoder = new TextEncoder();
+        if (typeof data === 'string') {
+            const signature = await bearby_js_1.web3.wallet.signMessage(data);
+            return {
+                publicKey: signature.publicKey,
+                signature: encoder.encode(signature.signature),
+            };
+        }
+        const strData = new TextDecoder().decode(data);
+        return {
+            publicKey: (await bearby_js_1.web3.wallet.signMessage(strData)).publicKey,
+            signature: encoder.encode((await bearby_js_1.web3.wallet.signMessage(strData)).signature),
+        };
+    }
+    // need testing
+    async buyRolls(amount, fee) {
+        const signedTx = await bearby_js_1.web3.wallet.signTransaction({
+            type: OperationsType.RollBuy,
+            amount: amount.toString(),
+            fee: fee.toString(),
+            payload: '', // TODO: check how do we have to set it
+        });
+        // broadcast the transaction
+        const provider = ''; // TODO: GET THE PROVIDER FROM BEARBY (if possible ..)
+        throw new Error('Method not implemented.');
+    }
+    // need testing
+    async sellRolls(amount, fee) {
+        const signedTx = await bearby_js_1.web3.wallet.signTransaction({
+            type: OperationsType.RollSell,
+            amount: amount.toString(),
+            fee: fee.toString(),
+            payload: '', // TODO: check how do we have to set it
+        });
+        // broadcast the transaction
+        const provider = ''; // TODO: GET THE PROVIDER FROM BEARBY
+        throw new Error('Method not implemented.');
+    }
+    async sendTransaction(amount, recipientAddress, fee) {
+        const signedTx = await bearby_js_1.web3.wallet.signTransaction({
+            type: OperationsType.Payment,
+            amount: amount.toString(),
+            recipient: recipientAddress,
+            fee: fee.toString(),
+            payload: '', // TODO: check how do we have to set it
+        });
+        console.log(signedTx);
+        return {
+            operationId: '00',
+        };
+    }
+    async callSC(contractAddress, functionName, parameter, amount, fee, maxGas, nonPersistentExecution = false) {
+        if (nonPersistentExecution) {
+            return this.nonPersistentCallSC(contractAddress, functionName, parameter, amount, fee, maxGas);
+        }
+        if (parameter instanceof Uint8Array) {
+            throw new Error('Protobuf serialization is not supported by bearby wallet. To use it switch to MassaStation');
+        }
+        // setup the params from Args
+        let params = [];
+        try {
+            params = parameter.getArgsList().map((arg) => {
+                return {
+                    type: arg.type,
+                    value: arg.value,
+                };
+            });
+        }
+        catch (ex) {
+            throw new Error(
+            /* eslint-disable-next-line max-len */
+            'Bearby wallet does not support Uint8Array, serializable and serializableObjectArray. To use them switch to MassaStation');
+        }
+        return await bearby_js_1.web3.contract.call({
+            maxGas: Number(maxGas),
+            coins: Number(amount),
+            fee: Number(fee),
+            targetAddress: contractAddress,
+            functionName: functionName,
+            parameters: params,
+        });
+        // // convert parameter to an array of numbers
+        // let argumentArray: Array<number> = [];
+        // if (parameter instanceof Uint8Array) {
+        //   argumentArray = Array.from(parameter);
+        // } else {
+        //   argumentArray = Array.from(parameter.serialize());
+        // }
+        // const callData = {
+        //   fee: fee,
+        //   maxGas: maxGas,
+        //   coins: amount,
+        //   targetAddress: contractAddress,
+        //   functionName: functionName,
+        //   parameter: argumentArray,
+        // } as ICallData;
+        // // get next period info to set the expiry period
+        // const nodeStatusInfo: NodeStatus = await this.getNodeStatus();
+        // // 5 is the default value used in massa-web3 for expiry period
+        // const expiryPeriod: number = nodeStatusInfo.next_slot.period + 5;
+        // // bytes compaction
+        // const bytesCompact: Buffer = compactBytesForOperation(
+        //   callData,
+        //   OperationTypeId.CallSC,
+        //   expiryPeriod,
+        // );
+        // // We need the public key but bearby doesn't allow us to get it directly.
+        // // We have to sign a message and get the public key from the signature
+        // const pubKey = (await this.sign('nothing')).publicKey;
+        // // sign payload
+        // const bytesPublicKey: Uint8Array = getBytesPublicKey(pubKey);
+        // // get the signature and encode it to base58
+        // const signatureUInt8Array = (
+        //   await this.sign(Buffer.concat([bytesPublicKey, bytesCompact]))
+        // ).signature;
+        // const signature = base58Encode(signatureUInt8Array);
+        // // request data
+        // const data = {
+        //   serialized_content: Array.prototype.slice.call(bytesCompact),
+        //   creator_public_key: pubKey,
+        //   signature: signature,
+        // };
+        // // returns operation ids
+        // let opIds: Array<string> = [];
+        // const jsonRpcRequestMethod = JSON_RPC_REQUEST_METHOD.SEND_OPERATIONS;
+        // opIds = await this.sendJsonRPCRequest(jsonRpcRequestMethod, [[data]]);
+        // if (opIds.length <= 0) {
+        //   throw new Error(
+        //     `Call smart contract operation bad response. No results array in json rpc response. Inspect smart contract`,
+        //   );
+        // }
+        // return opIds[0];
+    }
+    /**
+     * Retrieves the node's status.
+     *
+     * @remarks
+     * The returned information includes:
+     * - Whether the node is reachable
+     * - The number of connected peers
+     * - The node's version
+     * - The node's configuration parameters
+     *
+     * @returns A promise that resolves to the node's status information.
+     */
+    async getNodeStatus() {
+        const jsonRpcRequestMethod = jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_STATUS;
+        return await this.sendJsonRPCRequest(jsonRpcRequestMethod, []);
+    }
+    /**
+     * Sends a post JSON rpc request to the node.
+     *
+     * @param resource - The rpc method to call.
+     * @param params - The parameters to pass to the rpc method.
+     *
+     * @throws An error if the rpc method returns an error.
+     *
+     * @returns A promise that resolves as the result of the rpc method.
+     */
+    async sendJsonRPCRequest(resource, params) {
+        let resp = null;
+        resp = await this.promisifyJsonRpcCall(resource, params);
+        // in case of rpc error, rethrow the error.
+        if (resp.isError || resp.error) {
+            throw resp.error;
+        }
+        return resp.result;
+    }
+    /**
+     * Converts a json rpc call to a promise that resolves as a JsonRpcResponseData
+     *
+     * @privateRemarks
+     * If there is an error while sending the request, the function catches the error, the isError
+     * property is set to true, the result property set to null, and the error property set to a
+     * new Error object with a message indicating that there was an error.
+     *
+     * @param resource - The rpc method to call.
+     * @param params - The parameters to pass to the rpc method.
+     *
+     * @returns A promise that resolves as a JsonRpcResponseData.
+     */
+    async promisifyJsonRpcCall(resource, params) {
+        let resp = null;
+        const body = {
+            jsonrpc: '2.0',
+            method: resource,
+            params: params,
+            id: 0,
+        };
+        try {
+            resp = await axios_1.default.post(this._nodeUrl, body, exports.requestHeaders);
+        }
+        catch (ex) {
+            return {
+                isError: true,
+                result: null,
+                error: new Error('JSON.parse error: ' + String(ex)),
+            };
+        }
+        const responseData = resp.data;
+        if (responseData.error) {
+            return {
+                isError: true,
+                result: null,
+                error: new Error(responseData.error.message),
+            };
+        }
+        return {
+            isError: false,
+            result: responseData.result,
+            error: null,
+        };
+    }
+    /**
+     * Find provider for a concrete rpc method
+     *
+     * @remarks
+     * This method chooses the provider to use for a given rpc method.
+     *  - If the rpc method is about getting or sending data to the blockchain,
+     *    it will choose a public provider.
+     *  - If the rpc method is meant to be used by the node itself, it will choose a private provider.
+     *  - An error is thrown if no provider is found for the rpc method.
+     *
+     * @param requestMethod - The rpc method to find the provider for.
+     *
+     * @returns The provider for the rpc method.
+     */
+    getProviderForRpcMethod(requestMethod) {
+        switch (requestMethod) {
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_ADDRESSES:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_STATUS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.SEND_OPERATIONS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_OPERATIONS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_BLOCKS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_ENDORSEMENTS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_CLIQUES:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_STAKERS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_FILTERED_SC_OUTPUT_EVENT:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.EXECUTE_READ_ONLY_BYTECODE:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.EXECUTE_READ_ONLY_CALL:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_DATASTORE_ENTRIES:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_BLOCKCLIQUE_BLOCK_BY_SLOT:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_GRAPH_INTERVAL: {
+                return new BearbyProvider_1.BearbyProvider('Bearby');
+            }
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.STOP_NODE:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.NODE_BAN_BY_ID:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.NODE_BAN_BY_IP:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.NODE_UNBAN_BY_ID:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.NODE_UNBAN_BY_IP:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.GET_STAKING_ADDRESSES:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.REMOVE_STAKING_ADDRESSES:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.ADD_STAKING_PRIVATE_KEYS:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.NODE_SIGN_MESSAGE:
+            case jsonRpcMethods_1.JSON_RPC_REQUEST_METHOD.NODE_REMOVE_FROM_WHITELIST: {
+                return new BearbyProvider_1.BearbyProvider('Bearby');
+            }
+            default:
+                throw new Error(`Unknown Json rpc method: ${requestMethod}`);
+        }
+    }
+    async nonPersistentCallSC(contractAddress, functionName, parameter, amount, fee, maxGas) {
+        // not clean but bearby doesn't allow us to get its node urls
+        const node = exports.PUBLIC_NODE_RPC;
+        // Gas amount check
+        if (maxGas > MAX_READ_BLOCK_GAS) {
+            throw new Error(`
+        The gas submitted ${maxGas.toString()} exceeds the max. allowed block gas of 
+        ${MAX_READ_BLOCK_GAS.toString()}
+        `);
+        }
+        // convert parameter to an array of numbers
+        let argumentArray = [];
+        if (parameter instanceof Uint8Array) {
+            argumentArray = Array.from(parameter);
+        }
+        else {
+            argumentArray = Array.from(parameter.serialize());
+        }
+        // setup the request body
+        const data = {
+            max_gas: Number(maxGas),
+            target_address: contractAddress,
+            target_function: functionName,
+            parameter: argumentArray,
+            caller_address: this._address,
+            coins: Number(amount),
+            fee: Number(fee),
+        };
+        const body = [
+            {
+                jsonrpc: '2.0',
+                method: 'execute_read_only_call',
+                params: [[data]],
+                id: 0,
+            },
+        ];
+        // returns operation ids
+        let jsonRpcCallResult = [];
+        try {
+            let resp = await (0, RequestHandler_1.postRequest)(node, body);
+            if (resp.isError || resp.error) {
+                throw resp.error.message;
+            }
+            jsonRpcCallResult = resp.result;
+        }
+        catch (ex) {
+            throw new Error(`MassaStation account: error while interacting with smart contract: ${ex}`);
+        }
+        if (jsonRpcCallResult.length <= 0) {
+            throw new Error(`Read operation bad response. No results array in json rpc response. Inspect smart contract`);
+        }
+        if (jsonRpcCallResult[0].result.Error) {
+            throw new Error(jsonRpcCallResult[0].result.Error);
+        }
+        return {
+            returnValue: new Uint8Array(jsonRpcCallResult[0].result[0].result.Ok),
+            info: jsonRpcCallResult[0],
+        };
+    }
+}
+exports.BearbyAccount = BearbyAccount;
+const PUBLIC_KEY_PREFIX = 'P';
+/**
+ * Retrieves the byte representation of a given public key.
+ *
+ * @param publicKey - The public key to obtain the bytes from.
+ *
+ * @throws If the public key has an incorrect {@link PUBLIC_KEY_PREFIX}.
+ *
+ * @returns A Uint8Array containing the bytes of the public key.
+ */
+function getBytesPublicKey(publicKey) {
+    if (!(publicKey[0] == PUBLIC_KEY_PREFIX)) {
+        throw new Error(`Invalid public key prefix: ${publicKey[0]} should be ${PUBLIC_KEY_PREFIX}`);
+    }
+    const publicKeyBase58Decoded = (0, Xbqcrypto_1.base58Decode)(publicKey.slice(1));
+    return publicKeyBase58Decoded;
+}
+exports.getBytesPublicKey = getBytesPublicKey;
+
+
+/***/ }),
+
+/***/ "./src/bearbyWallet/BearbyConnect.ts":
+/*!*******************************************!*\
+  !*** ./src/bearbyWallet/BearbyConnect.ts ***!
+  \*******************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.disconnectBearby = exports.connectBearby = exports.detectBearby = void 0;
+const bearby_js_1 = __webpack_require__(/*! @hicaru/bearby.js */ "./node_modules/@hicaru/bearby.js/dist/index.js");
+async function detectBearby() {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (globalThis.window && globalThis.window['bearby']) {
+        return true;
+    }
+    return false;
+}
+exports.detectBearby = detectBearby;
+async function connectBearby() {
+    try {
+        await bearby_js_1.web3.wallet.connect();
+    }
+    catch (ex) {
+        console.log(ex);
+    }
+}
+exports.connectBearby = connectBearby;
+async function disconnectBearby() {
+    await bearby_js_1.web3.wallet.diconnect(); // diconnect is a typo in the library
+    console.log('Bearby disconnected');
+}
+exports.disconnectBearby = disconnectBearby;
+
+
+/***/ }),
+
+/***/ "./src/bearbyWallet/BearbyProvider.ts":
+/*!********************************************!*\
+  !*** ./src/bearbyWallet/BearbyProvider.ts ***!
+  \********************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.BearbyProvider = void 0;
+const bearby_js_1 = __webpack_require__(/*! @hicaru/bearby.js */ "./node_modules/@hicaru/bearby.js/dist/index.js");
+const BearbyAccount_1 = __webpack_require__(/*! ./BearbyAccount */ "./src/bearbyWallet/BearbyAccount.ts");
+class BearbyProvider {
+    /**
+     * Provider constructor
+     *
+     * @param providerName - The name of the provider.
+     * @returns An instance of the Provider class.
+     */
+    constructor(providerName) {
+        this.providerName = providerName;
+    }
+    name() {
+        return this.providerName;
+    }
+    async accounts() {
+        // check if bearby is unlocked
+        if (!bearby_js_1.web3.wallet.enabled) {
+            await bearby_js_1.web3.wallet.connect();
+        }
+        const account = {
+            address: await bearby_js_1.web3.wallet.account.base58,
+            name: 'Bearby',
+        };
+        return [new BearbyAccount_1.BearbyAccount(account, this.providerName)];
+    }
+    async importAccount(publicKey, privateKey) {
+        throw new Error('Method not implemented.');
+    }
+    async deleteAccount(address) {
+        throw new Error('Method not implemented.');
+    }
+    async getNodesUrls() {
+        return ['https://buildnet.massa.net/api/v2'];
+    }
+    async generateNewAccount(name) {
+        throw new Error('Method not implemented.');
+    }
+}
+exports.BearbyProvider = BearbyProvider;
+
+
+/***/ }),
+
+/***/ "./src/bearbyWallet/Xbqcrypto.ts":
+/*!***************************************!*\
+  !*** ./src/bearbyWallet/Xbqcrypto.ts ***!
+  \***************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.varintDecode = exports.varintEncode = exports.base58Decode = exports.base58Encode = exports.hashBlake3 = void 0;
+const varint = __webpack_require__(/*! varint */ "./node_modules/varint/index.js");
+const blake3_1 = __webpack_require__(/*! @noble/hashes/blake3 */ "./node_modules/@noble/hashes/blake3.js");
+/**
+ * A collection of utility functions for working with various data encoding and hashing formats.
+ *
+ * This module provides several functions for encoding and decoding data in various formats, including
+ * `base58`, `varint`, and `blake3 hashes`.
+ *
+ */
+const unsignedBigIntUtils = __webpack_require__(/*! ./unsignedBigIntUtils */ "./src/bearbyWallet/unsignedBigIntUtils.ts");
+const bs58check_1 = __webpack_require__(/*! bs58check */ "./node_modules/bs58check/index.js");
+/**
+ * Hashes data with blake3
+ *
+ * @param data - The data to hash
+ *
+ * @returns The hash of the data with blake3
+ */
+function hashBlake3(data) {
+    return (0, blake3_1.blake3)(data);
+}
+exports.hashBlake3 = hashBlake3;
+/**
+ * Encodes a buffer or an Uint8Array to base58
+ *
+ * @param data - The data to encode
+ *
+ * @returns The base58 encoded data as a string
+ */
+function base58Encode(data) {
+    return (0, bs58check_1.encode)(data);
+}
+exports.base58Encode = base58Encode;
+/**
+ * Decode a base58 encoded string to a buffer
+ *
+ * @param data - The base58 encoded string
+ *
+ * @returns The decoded buffer
+ */
+function base58Decode(data) {
+    const decoded = (0, bs58check_1.decode)(data);
+    return Buffer.from(decoded);
+}
+exports.base58Decode = base58Decode;
+/**
+ * Encodes a number or bigint to a varint encoded Uint8Array.
+ *
+ * @param data - The data to encode
+ *
+ * @returns The varint encoded data as a Uint8Array
+ */
+function varintEncode(data) {
+    if (typeof data === 'bigint') {
+        return unsignedBigIntUtils.encode(data);
+    }
+    return varint.encode(data);
+}
+exports.varintEncode = varintEncode;
+/**
+ * Decodes a varint encoded Uint8Array to a number
+ *
+ * @param data - The varint encoded Uint8Array
+ *
+ * @returns The decoded number and the number of bytes read
+ */
+function varintDecode(data) {
+    const value = varint.decode(data);
+    const bytes = varint.decode.bytes;
+    return { value, bytes };
+}
+exports.varintDecode = varintDecode;
+
+
+/***/ }),
+
+/***/ "./src/bearbyWallet/jsonRpcMethods.ts":
+/*!********************************************!*\
+  !*** ./src/bearbyWallet/jsonRpcMethods.ts ***!
+  \********************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.JSON_RPC_REQUEST_METHOD = void 0;
+/**
+ * Lists all JSON RPC Request Methods.
+ */
+var JSON_RPC_REQUEST_METHOD;
+(function (JSON_RPC_REQUEST_METHOD) {
+    // public Api
+    JSON_RPC_REQUEST_METHOD["GET_STATUS"] = "get_status";
+    JSON_RPC_REQUEST_METHOD["GET_ADDRESSES"] = "get_addresses";
+    JSON_RPC_REQUEST_METHOD["SEND_OPERATIONS"] = "send_operations";
+    JSON_RPC_REQUEST_METHOD["GET_BLOCKS"] = "get_blocks";
+    JSON_RPC_REQUEST_METHOD["GET_ENDORSEMENTS"] = "get_endorsements";
+    JSON_RPC_REQUEST_METHOD["GET_OPERATIONS"] = "get_operations";
+    JSON_RPC_REQUEST_METHOD["GET_CLIQUES"] = "get_cliques";
+    JSON_RPC_REQUEST_METHOD["GET_STAKERS"] = "get_stakers";
+    JSON_RPC_REQUEST_METHOD["GET_FILTERED_SC_OUTPUT_EVENT"] = "get_filtered_sc_output_event";
+    JSON_RPC_REQUEST_METHOD["EXECUTE_READ_ONLY_BYTECODE"] = "execute_read_only_bytecode";
+    JSON_RPC_REQUEST_METHOD["EXECUTE_READ_ONLY_CALL"] = "execute_read_only_call";
+    JSON_RPC_REQUEST_METHOD["GET_DATASTORE_ENTRIES"] = "get_datastore_entries";
+    JSON_RPC_REQUEST_METHOD["GET_BLOCKCLIQUE_BLOCK_BY_SLOT"] = "get_blockclique_block_by_slot";
+    JSON_RPC_REQUEST_METHOD["GET_GRAPH_INTERVAL"] = "get_graph_interval";
+    // private Api
+    JSON_RPC_REQUEST_METHOD["STOP_NODE"] = "stop_node";
+    JSON_RPC_REQUEST_METHOD["NODE_BAN_BY_IP"] = "node_ban_by_ip";
+    JSON_RPC_REQUEST_METHOD["NODE_BAN_BY_ID"] = "node_ban_by_id";
+    JSON_RPC_REQUEST_METHOD["NODE_UNBAN_BY_IP"] = "node_unban_by_ip";
+    JSON_RPC_REQUEST_METHOD["NODE_UNBAN_BY_ID"] = "node_unban_by_id";
+    JSON_RPC_REQUEST_METHOD["GET_STAKING_ADDRESSES"] = "get_staking_addresses";
+    JSON_RPC_REQUEST_METHOD["REMOVE_STAKING_ADDRESSES"] = "remove_staking_addresses";
+    JSON_RPC_REQUEST_METHOD["ADD_STAKING_PRIVATE_KEYS"] = "add_staking_private_keys";
+    JSON_RPC_REQUEST_METHOD["NODE_SIGN_MESSAGE"] = "node_sign_message";
+    JSON_RPC_REQUEST_METHOD["NODE_REMOVE_FROM_WHITELIST"] = "node_remove_from_whitelist";
+    JSON_RPC_REQUEST_METHOD["NODE_ADD_TO_PEERS_WHITELIST"] = "node_add_to_peers_whitelist";
+})(JSON_RPC_REQUEST_METHOD = exports.JSON_RPC_REQUEST_METHOD || (exports.JSON_RPC_REQUEST_METHOD = {}));
+
+
+/***/ }),
+
+/***/ "./src/bearbyWallet/unsignedBigIntUtils.ts":
+/*!*************************************************!*\
+  !*** ./src/bearbyWallet/unsignedBigIntUtils.ts ***!
+  \*************************************************/
+/***/ ((__unused_webpack_module, exports) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.decode = exports.encode = exports.encodingLength = void 0;
+const LIMIT = BigInt(0x7f);
+const zeroBI = BigInt(0);
+const sevenBI = BigInt(7);
+/**
+ *
+ * This module provides functions to encode and decode unsigned integers,
+ * using Varint which is a more compact binary representation of them.
+ */
+/**
+ * Returns the number of bytes required to store the number in a varint.
+ *
+ * @param value - The number to encode.
+ * @returns The number of bytes required to store the number.
+ */
+function encodingLength(value) {
+    let i = 0;
+    for (; value >= BigInt(0x80); i++) {
+        value >>= sevenBI;
+    }
+    return i + 1;
+}
+exports.encodingLength = encodingLength;
+/**
+ * Encodes a big number as a varint.
+ *
+ * @param i - The big number to encode.
+ * @param buffer - The buffer to write the varint to (optional).
+ * @param byteOffset - The offset in the buffer to start writing at (optional) (default: 0).
+ * @returns The buffer that was written to.
+ */
+function encode(i, buffer, byteOffset) {
+    if (i < zeroBI) {
+        throw new RangeError('value must be unsigned');
+    }
+    const byteLength = encodingLength(i);
+    buffer = buffer || new ArrayBuffer(byteLength);
+    byteOffset = byteOffset || 0;
+    if (buffer.byteLength < byteOffset + byteLength) {
+        throw new RangeError('the buffer is too small to encode the number at the offset');
+    }
+    const array = new Uint8Array(buffer, byteOffset);
+    let offset = 0;
+    while (LIMIT < i) {
+        array[offset++] = Number(i & LIMIT) | 0x80;
+        i >>= sevenBI;
+    }
+    array[offset] = Number(i);
+    return array;
+}
+exports.encode = encode;
+/**
+ * Decodes a varint as a big number.
+ *
+ * @param data - The data to decode.
+ * @param offset - The offset in the data to start reading at (optional) (default: 0).
+ * @returns The decoded big number.
+ */
+function decode(data, offset = 0) {
+    let i = zeroBI;
+    let n = 0;
+    let b;
+    do {
+        b = data[offset + n];
+        if (b === undefined) {
+            throw new RangeError('offset out of range');
+        }
+        i += BigInt(b & 0x7f) << BigInt(n * 7);
+        n++;
+    } while (0x80 <= b);
+    return i;
+}
+exports.decode = decode;
+
+
+/***/ }),
+
+/***/ "./src/connector/Connector.ts":
+/*!************************************!*\
+  !*** ./src/connector/Connector.ts ***!
+  \************************************/
+/***/ ((__unused_webpack_module, exports, __webpack_require__) => {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.connector = exports.MASSA_WINDOW_OBJECT = void 0;
+/**
+ * This file defines a TypeScript module named connector.
+ * It is the tool that allows the 'provider' and 'account' objects to communicate with the web page script.
+ *
+ * @remarks
+ * - If you are only looking to use our library, the connector object will not be useful to you.
+ * - If you want to work on this repo, you will probably be interested in this object
+ *
+ */
+const uid_1 = __webpack_require__(/*! uid */ "./node_modules/uid/dist/index.js");
+const __1 = __webpack_require__(/*! .. */ "./src/index.ts");
+const MassaStationDiscovery_1 = __webpack_require__(/*! ../massaStation/MassaStationDiscovery */ "./src/massaStation/MassaStationDiscovery.ts");
+const MassaStationProvider_1 = __webpack_require__(/*! ../massaStation/MassaStationProvider */ "./src/massaStation/MassaStationProvider.ts");
+/**
+ * A constant string that is used to identify the HTML element that is used for
+ * communication between the web page script and the content script.
+ */
+exports.MASSA_WINDOW_OBJECT = 'massaWalletProvider';
+/**
+ * This class enables communication with the content script by sending and receiving messages.
+ * @remarks
+ * - This class is used to send messages to the content script and to receive messages from the content script.
+ * - It is used to send messages to the content script and to receive messages from the content script.
+ *
+ */
+class Connector {
+    /**
+     * Connector constructor
      *
      * @remarks
      * - The Connector constructor takes no arguments.
@@ -5353,6 +7431,7 @@ class Connector {
         catch (e) {
             console.log('MassaStation is not detected');
         }
+        // check if bearby is installed
     }
     /**
      * This method sends a message from the webpage script to the content script.
@@ -5451,6 +7530,8 @@ if (typeof window !== 'undefined') {
 const Connector_1 = __webpack_require__(/*! ./connector/Connector */ "./src/connector/Connector.ts");
 const Provider_1 = __webpack_require__(/*! ./provider/Provider */ "./src/provider/Provider.ts");
 const MassaStationProvider_1 = __webpack_require__(/*! ./massaStation/MassaStationProvider */ "./src/massaStation/MassaStationProvider.ts");
+const BearbyConnect_1 = __webpack_require__(/*! ./bearbyWallet/BearbyConnect */ "./src/bearbyWallet/BearbyConnect.ts");
+const BearbyProvider_1 = __webpack_require__(/*! ./bearbyWallet/BearbyProvider */ "./src/bearbyWallet/BearbyProvider.ts");
 var AvailableCommands;
 (function (AvailableCommands) {
     AvailableCommands["ProviderListAccounts"] = "LIST_ACCOUNTS";
@@ -5479,6 +7560,11 @@ async function providers(retry = true, timeout = 3000, pollInterval = 500) {
         return [];
     }
     await Connector_1.connector.startMassaStationDiscovery();
+    // Look for Bearby
+    let p;
+    if ((0, BearbyConnect_1.detectBearby)()) {
+        const p = new BearbyProvider_1.BearbyProvider('Bearby');
+    }
     return new Promise((resolve) => {
         let provider = [];
         for (const providerName of Object.keys(Connector_1.connector.getWalletProviders())) {
@@ -5491,6 +7577,10 @@ async function providers(retry = true, timeout = 3000, pollInterval = 500) {
                 provider.push(p);
             }
         }
+        // Look for Bearby
+        if (p) {
+            provider.push(p);
+        }
         // If no providers are available, wait and try again
         if (retry && provider.length === 0) {
             setTimeout(() => {
@@ -6550,6 +8640,1003 @@ function uid(len) {
 
 exports.uid = uid;
 
+/***/ }),
+
+/***/ "./node_modules/varint/decode.js":
+/*!***************************************!*\
+  !*** ./node_modules/varint/decode.js ***!
+  \***************************************/
+/***/ ((module) => {
+
+module.exports = read
+
+var MSB = 0x80
+  , REST = 0x7F
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length
+
+  do {
+    if (counter >= l || shift > 49) {
+      read.bytes = 0
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++]
+    res += shift < 28
+      ? (b & REST) << shift
+      : (b & REST) * Math.pow(2, shift)
+    shift += 7
+  } while (b >= MSB)
+
+  read.bytes = counter - offset
+
+  return res
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/varint/encode.js":
+/*!***************************************!*\
+  !*** ./node_modules/varint/encode.js ***!
+  \***************************************/
+/***/ ((module) => {
+
+module.exports = encode
+
+var MSB = 0x80
+  , REST = 0x7F
+  , MSBALL = ~REST
+  , INT = Math.pow(2, 31)
+
+function encode(num, out, offset) {
+  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+    encode.bytes = 0
+    throw new RangeError('Could not encode varint')
+  }
+  out = out || []
+  offset = offset || 0
+  var oldOffset = offset
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB
+    num /= 128
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB
+    num >>>= 7
+  }
+  out[offset] = num | 0
+  
+  encode.bytes = offset - oldOffset + 1
+  
+  return out
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/varint/index.js":
+/*!**************************************!*\
+  !*** ./node_modules/varint/index.js ***!
+  \**************************************/
+/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
+
+module.exports = {
+    encode: __webpack_require__(/*! ./encode.js */ "./node_modules/varint/encode.js")
+  , decode: __webpack_require__(/*! ./decode.js */ "./node_modules/varint/decode.js")
+  , encodingLength: __webpack_require__(/*! ./length.js */ "./node_modules/varint/length.js")
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/varint/length.js":
+/*!***************************************!*\
+  !*** ./node_modules/varint/length.js ***!
+  \***************************************/
+/***/ ((module) => {
+
+
+var N1 = Math.pow(2,  7)
+var N2 = Math.pow(2, 14)
+var N3 = Math.pow(2, 21)
+var N4 = Math.pow(2, 28)
+var N5 = Math.pow(2, 35)
+var N6 = Math.pow(2, 42)
+var N7 = Math.pow(2, 49)
+var N8 = Math.pow(2, 56)
+var N9 = Math.pow(2, 63)
+
+module.exports = function (value) {
+  return (
+    value < N1 ? 1
+  : value < N2 ? 2
+  : value < N3 ? 3
+  : value < N4 ? 4
+  : value < N5 ? 5
+  : value < N6 ? 6
+  : value < N7 ? 7
+  : value < N8 ? 8
+  : value < N9 ? 9
+  :              10
+  )
+}
+
+
+/***/ }),
+
+/***/ "./node_modules/@hicaru/bearby.js/dist/index.js":
+/*!******************************************************!*\
+  !*** ./node_modules/@hicaru/bearby.js/dist/index.js ***!
+  \******************************************************/
+/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export */ __webpack_require__.d(__webpack_exports__, {
+/* harmony export */   ArgTypes: () => (/* binding */ ArgTypes),
+/* harmony export */   ContentProvider: () => (/* binding */ ContentProvider),
+/* harmony export */   Contract: () => (/* binding */ Contract),
+/* harmony export */   Massa: () => (/* binding */ Massa),
+/* harmony export */   Wallet: () => (/* binding */ Wallet),
+/* harmony export */   Web3: () => (/* binding */ Web3),
+/* harmony export */   web3: () => (/* binding */ web3)
+/* harmony export */ });
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+
+function __classPrivateFieldGet(receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+}
+
+function __classPrivateFieldSet(receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+}
+
+const FAVICON_REQUIRED = 'website favicon is required';
+const WALLET_IS_NOT_CONNECTED = 'Wallet is not connected';
+const INVALID_SIGN_PARAMS = 'Invalid sign params';
+const TIME_OUT = 'Request failed by timeout';
+const AVAILABLE_ONLY_BROWSER = 'bearby-web3 available only browser';
+const WEB3_INSTANCE_CREATED = 'bearby Web3 instance already created!';
+const CALLBACK_ERROR = 'Missing callback arg. use subscribe(cb => /do something/)';
+
+class Transaction {
+    get payload() {
+        return JSON.parse(JSON.stringify({
+            type: this.type,
+            amount: this.amount,
+            fee: this.fee,
+            gasPrice: this.gasPrice,
+            gasLimit: this.gasLimit,
+            coins: this.coins,
+            maxCoins: this.maxCoins,
+            code: this.contract,
+            func: this.functionName,
+            params: this.parameters,
+            toAddr: this.recipient || this.contract,
+            deployer: this.deployer
+        }));
+    }
+    constructor(type, amount, recipient, parameters, contract, functionName) {
+        this.type = type;
+        this.amount = String(amount);
+        this.recipient = recipient;
+        this.parameters = parameters || [];
+        this.contract = contract;
+        this.functionName = functionName;
+    }
+}
+
+var OperationsType;
+(function (OperationsType) {
+    OperationsType[OperationsType["Payment"] = 0] = "Payment";
+    OperationsType[OperationsType["RollBuy"] = 1] = "RollBuy";
+    OperationsType[OperationsType["RollSell"] = 2] = "RollSell";
+    OperationsType[OperationsType["ExecuteSC"] = 3] = "ExecuteSC";
+    OperationsType[OperationsType["CallSC"] = 4] = "CallSC";
+})(OperationsType || (OperationsType = {}));
+
+var JsonRPCRequestMethods;
+(function (JsonRPCRequestMethods) {
+    JsonRPCRequestMethods["GET_STATUS"] = "get_status";
+    JsonRPCRequestMethods["GET_ADDRESSES"] = "get_addresses";
+    // SEND_OPERATIONS              = 'send_operations',
+    JsonRPCRequestMethods["GET_GRAPH_INTERVAL"] = "get_graph_interval";
+    JsonRPCRequestMethods["GET_BLOCKS"] = "get_blocks";
+    JsonRPCRequestMethods["GET_ENDORSEMENTS"] = "get_endorsements";
+    JsonRPCRequestMethods["GET_OPERATIONS"] = "get_operations";
+    JsonRPCRequestMethods["GET_CLIQUES"] = "get_cliques";
+    JsonRPCRequestMethods["GET_STAKERS"] = "get_stakers";
+    JsonRPCRequestMethods["GET_FILTERED_SC_OUTPUT_EVENT"] = "get_filtered_sc_output_event";
+    JsonRPCRequestMethods["EXECUTE_READ_ONLY_BYTECODE"] = "execute_read_only_bytecode";
+    JsonRPCRequestMethods["EXECUTE_READ_ONLY_CALL"] = "execute_read_only_call";
+    JsonRPCRequestMethods["GET_DATASTORE_ENTRIES"] = "get_datastore_entries";
+})(JsonRPCRequestMethods || (JsonRPCRequestMethods = {}));
+
+function utf8ToBytes(str) {
+    let binaryArray = new Uint8Array(str.length);
+    Array.prototype.forEach.call(binaryArray, (_, idx, arr) => {
+        arr[idx] = str.charCodeAt(idx);
+    });
+    return binaryArray;
+}
+
+var ArgTypes;
+(function (ArgTypes) {
+    ArgTypes[ArgTypes["STRING"] = 0] = "STRING";
+    ArgTypes[ArgTypes["BOOL"] = 1] = "BOOL";
+    ArgTypes[ArgTypes["U8"] = 2] = "U8";
+    ArgTypes[ArgTypes["U32"] = 3] = "U32";
+    ArgTypes[ArgTypes["U64"] = 4] = "U64";
+    ArgTypes[ArgTypes["U128"] = 5] = "U128";
+    ArgTypes[ArgTypes["U256"] = 6] = "U256";
+    ArgTypes[ArgTypes["I32"] = 7] = "I32";
+    ArgTypes[ArgTypes["I64"] = 8] = "I64";
+    ArgTypes[ArgTypes["F32"] = 9] = "F32";
+    ArgTypes[ArgTypes["F64"] = 10] = "F64";
+})(ArgTypes || (ArgTypes = {}));
+
+var _Contract_provider, _Contract_wallet;
+class Contract {
+    constructor(provider, wallet) {
+        _Contract_provider.set(this, void 0);
+        _Contract_wallet.set(this, void 0);
+        this.types = ArgTypes;
+        __classPrivateFieldSet(this, _Contract_provider, provider, "f");
+        __classPrivateFieldSet(this, _Contract_wallet, wallet, "f");
+    }
+    async deploy(params) {
+        const transaction = new Transaction(OperationsType.ExecuteSC, '0', undefined, params.parameters, params.contractDataBase64, undefined);
+        transaction.deployer = params.deployerBase64;
+        transaction.fee = String(params.fee);
+        transaction.gasLimit = String(params.maxGas);
+        transaction.gasPrice = String(params.gasPrice);
+        transaction.maxCoins = String(params.maxCoins);
+        transaction.coins = String(params.coins);
+        return __classPrivateFieldGet(this, _Contract_wallet, "f").signTransaction(transaction);
+    }
+    async call(params) {
+        const transaction = new Transaction(OperationsType.CallSC, '0', undefined, params.parameters, params.targetAddress, params.functionName);
+        transaction.fee = String(params.fee);
+        transaction.gasLimit = String(params.maxGas);
+        transaction.coins = String(params.coins || 0);
+        return __classPrivateFieldGet(this, _Contract_wallet, "f").signTransaction(transaction);
+    }
+    async getFilteredSCOutputEvent(...filters) {
+        const method = JsonRPCRequestMethods.GET_FILTERED_SC_OUTPUT_EVENT;
+        const responses = await __classPrivateFieldGet(this, _Contract_provider, "f").send(filters.map((filter) => ({
+            method,
+            params: [filter]
+        })));
+        if (filters.length === 1) {
+            return responses[0];
+        }
+        return responses;
+    }
+    async getDatastoreEntries(...params) {
+        const method = JsonRPCRequestMethods.GET_DATASTORE_ENTRIES;
+        const data = [];
+        for (const { key, address } of params) {
+            data.push({
+                address,
+                key: Array.from(utf8ToBytes(key))
+            });
+        }
+        return await __classPrivateFieldGet(this, _Contract_provider, "f").send([{
+                method,
+                params: [data]
+            }]);
+    }
+    async executeReadOlyBytecode(params) {
+        const method = JsonRPCRequestMethods.EXECUTE_READ_ONLY_BYTECODE;
+        return __classPrivateFieldGet(this, _Contract_provider, "f").send([{
+                method,
+                params: [params]
+            }]);
+    }
+    async readSmartContract(...params) {
+        const method = JsonRPCRequestMethods.EXECUTE_READ_ONLY_CALL;
+        const responses = await __classPrivateFieldGet(this, _Contract_provider, "f").send([{
+                method,
+                params: [params.map((v) => ({
+                        max_gas: v.maxGas,
+                        simulated_gas_price: String(v.simulatedGasPrice),
+                        target_address: v.targetAddress,
+                        target_function: v.targetFunction,
+                        parameters: v.parameters,
+                        caller_address: v.callerAddress || __classPrivateFieldGet(this, _Contract_wallet, "f").account.base58
+                    }))]
+            }]);
+        if (params.length === 1) {
+            return responses[0];
+        }
+        return responses;
+    }
+}
+_Contract_provider = new WeakMap(), _Contract_wallet = new WeakMap();
+
+// This string need that sould did't have problem with conflicts.
+const app = 'BearBy';
+const MTypeTabContent = {
+    CONTENT: `@/${app}/content-script`,
+    INJECTED: `@/${app}/injected-script`
+};
+const MTypeTab = {
+    GET_DATA: `@/${app}/get-wallet-data`,
+    NEW_SLOT: `@/${app}/new-slot-emited`,
+    ACCOUNT_CHANGED: `@/${app}/accounts-just-changed`,
+    CONTENT_PROXY_MEHTOD: `@/${app}/proxy-method`,
+    CONTENT_PROXY_RESULT: `@/${app}/response-from-content`,
+    CONNECT_APP: `@/${app}/connect-app`,
+    RESPONSE_CONNECT_APP: `@/${app}/respoonse-connect-app`,
+    NETWORK_CHANGED: `@/${app}/network-just-changed`,
+    DISCONNECT_APP: `@/${app}/disconnect_app`,
+    DISCONNECT_APP_RESULT: `@/${app}/disconnect_app_result`,
+    LOCKED: `@/${app}/guard-just-lock`,
+    TX_TO_SEND: `@/${app}/add-tx-to-send`,
+    TX_TO_SEND_RESULT: `@/${app}/response-tx-result`,
+    CHECK_MASSA_ADDRESS: `@/${app}/check-massa-address`,
+    CHECK_MASSA_ADDRESS_RES: `@/${app}/check-massa-address-response`,
+    SIGN_MESSAGE: `@/${app}/sign-message-call`,
+    SING_MESSAGE_RESULT: `@/${app}/sign-message-response`
+};
+
+var _TabStream_instances, _TabStream_eventName, _TabStream_dispatch, _TabStream_getEventInit, _TabStream_getEvent;
+const { document } = globalThis;
+/**
+ * Used for communication between a web page and an extension's content script.
+ */
+class TabStream {
+    /**
+     * Creates a new TabStream.
+     * @param {String} eventName - Event type.
+     */
+    constructor(eventName) {
+        _TabStream_instances.add(this);
+        _TabStream_eventName.set(this, void 0);
+        __classPrivateFieldSet(this, _TabStream_eventName, eventName, "f");
+    }
+    /**
+     * Message listener that returns decrypted messages when synced
+     */
+    listen(cb) {
+        document.addEventListener(__classPrivateFieldGet(this, _TabStream_eventName, "f"), (event) => {
+            if (event && event.detail) {
+                cb(JSON.parse(event.detail));
+            }
+        });
+    }
+    /**
+     * Message sender which encrypts messages and adds the sender.
+     * @param data - The payload to send.
+     * @param to - The stream to send messages to.
+     */
+    send(data, to) {
+        data.from = __classPrivateFieldGet(this, _TabStream_eventName, "f");
+        if (Object.values(MTypeTabContent).includes(to)) {
+            __classPrivateFieldGet(this, _TabStream_instances, "m", _TabStream_dispatch).call(this, JSON.stringify(data), to);
+        }
+    }
+}
+_TabStream_eventName = new WeakMap(), _TabStream_instances = new WeakSet(), _TabStream_dispatch = function _TabStream_dispatch(data, to) {
+    document.dispatchEvent(__classPrivateFieldGet(this, _TabStream_instances, "m", _TabStream_getEvent).call(this, data, to));
+}, _TabStream_getEventInit = function _TabStream_getEventInit(detail) {
+    return {
+        detail
+    };
+}, _TabStream_getEvent = function _TabStream_getEvent(detail, to) {
+    return new CustomEvent(to, __classPrivateFieldGet(this, _TabStream_instances, "m", _TabStream_getEventInit).call(this, detail));
+};
+
+var _Subject_events;
+class Subject {
+    constructor() {
+        _Subject_events.set(this, []);
+    }
+    on(listener) {
+        __classPrivateFieldGet(this, _Subject_events, "f").push(listener);
+        return () => this.removeListener(listener);
+    }
+    removeListener(listener) {
+        const idx = __classPrivateFieldGet(this, _Subject_events, "f").indexOf(listener);
+        if (idx > -1)
+            __classPrivateFieldGet(this, _Subject_events, "f").splice(idx, 1);
+    }
+    removeAllListeners() {
+        __classPrivateFieldGet(this, _Subject_events, "f").splice(0, __classPrivateFieldGet(this, _Subject_events, "f").length);
+    }
+    emit(...args) {
+        __classPrivateFieldGet(this, _Subject_events, "f").forEach(listener => listener.apply(this, args));
+    }
+    once(listener) {
+        const remove = this.on((...args) => {
+            remove();
+            listener.apply(this, args);
+        });
+    }
+}
+_Subject_events = new WeakMap();
+
+var _ContentMessage_body;
+class ContentMessage {
+    get type() {
+        return __classPrivateFieldGet(this, _ContentMessage_body, "f").type;
+    }
+    get payload() {
+        return __classPrivateFieldGet(this, _ContentMessage_body, "f").payload;
+    }
+    constructor(msg) {
+        _ContentMessage_body.set(this, void 0);
+        __classPrivateFieldSet(this, _ContentMessage_body, msg, "f");
+    }
+    /**
+     * Method for send message.
+     */
+    send(stream, recipient) {
+        const seralized = JSON.stringify(__classPrivateFieldGet(this, _ContentMessage_body, "f"));
+        const deserialized = JSON.parse(seralized);
+        stream.send(deserialized, recipient);
+    }
+}
+_ContentMessage_body = new WeakMap();
+
+class Handler {
+    constructor() {
+        this.stream = new TabStream(MTypeTabContent.INJECTED);
+        this.subject = new Subject();
+        if (globalThis.document) {
+            // only not ssr
+            this.stream.listen((msg) => {
+                this.subject.emit(msg);
+            });
+        }
+    }
+    initialized() {
+        const type = MTypeTab.GET_DATA;
+        const recipient = MTypeTabContent.CONTENT;
+        new ContentMessage({
+            type,
+            payload: {}
+        }).send(this.stream, recipient);
+    }
+}
+
+function uuidv4() {
+    const size = 20;
+    return [...Array(size)].map(() => Math.floor(Math.random() * 16).toString(16)).join('');
+}
+
+const TIME_OUT_SECONDS = 5000;
+
+var _ContentProvider_stream, _ContentProvider_subject;
+class ContentProvider {
+    constructor(stream, subject) {
+        _ContentProvider_stream.set(this, void 0);
+        _ContentProvider_subject.set(this, void 0);
+        __classPrivateFieldSet(this, _ContentProvider_stream, stream, "f");
+        __classPrivateFieldSet(this, _ContentProvider_subject, subject, "f");
+    }
+    async send(body) {
+        const type = MTypeTab.CONTENT_PROXY_MEHTOD;
+        const recipient = MTypeTabContent.CONTENT;
+        const uuid = uuidv4();
+        let sub;
+        new ContentMessage({
+            type,
+            payload: {
+                body,
+                uuid
+            }
+        }).send(__classPrivateFieldGet(this, _ContentProvider_stream, "f"), recipient);
+        const fulfilled = new Promise((resolve, reject) => {
+            sub = __classPrivateFieldGet(this, _ContentProvider_subject, "f").on((msg) => {
+                if (msg.type !== MTypeTab.CONTENT_PROXY_RESULT)
+                    return;
+                if (!msg.payload || !msg.payload.uuid)
+                    return;
+                if (msg.payload.uuid !== uuid)
+                    return;
+                if (msg.payload && msg.payload.reject) {
+                    sub();
+                    return reject(new Error(msg.payload.reject));
+                }
+                delete msg.payload.uuid;
+                sub();
+                return resolve(msg.payload.resolve);
+            });
+        });
+        const timeout = new Promise((_, reject) => {
+            setTimeout(() => {
+                if (sub)
+                    sub();
+                reject(new Error(TIME_OUT));
+            }, TIME_OUT_SECONDS);
+        });
+        return Promise.race([fulfilled, timeout]);
+    }
+}
+_ContentProvider_stream = new WeakMap(), _ContentProvider_subject = new WeakMap();
+
+var _Massa_provider, _Massa_wallet;
+class Massa {
+    constructor(provider, wallet) {
+        _Massa_provider.set(this, void 0);
+        _Massa_wallet.set(this, void 0);
+        __classPrivateFieldSet(this, _Massa_provider, provider, "f");
+        __classPrivateFieldSet(this, _Massa_wallet, wallet, "f");
+    }
+    async getNodesStatus() {
+        const method = JsonRPCRequestMethods.GET_STATUS;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: []
+            }]);
+        return res;
+    }
+    async getAddresses(...addresses) {
+        const method = JsonRPCRequestMethods.GET_ADDRESSES;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: [addresses]
+            }]);
+        return res;
+    }
+    async getBlocks(...blocks) {
+        const method = JsonRPCRequestMethods.GET_BLOCKS;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: [blocks]
+            }]);
+        return res;
+    }
+    async getGraphInterval(start, end) {
+        const method = JsonRPCRequestMethods.GET_GRAPH_INTERVAL;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: [{
+                        start,
+                        end
+                    }]
+            }]);
+        return res;
+    }
+    async getOperations(...operations) {
+        const method = JsonRPCRequestMethods.GET_OPERATIONS;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: [operations]
+            }]);
+        return res;
+    }
+    async getStakers() {
+        const method = JsonRPCRequestMethods.GET_STAKERS;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: []
+            }]);
+        return res;
+    }
+    async getEndorsements(...Ids) {
+        const method = JsonRPCRequestMethods.GET_ENDORSEMENTS;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: [Ids]
+            }]);
+        return res;
+    }
+    async getCliques() {
+        const method = JsonRPCRequestMethods.GET_CLIQUES;
+        const [res] = await __classPrivateFieldGet(this, _Massa_provider, "f").send([{
+                method,
+                params: []
+            }]);
+        return res;
+    }
+    async payment(amount, recipient) {
+        const transaction = new Transaction(OperationsType.Payment, amount, recipient);
+        return __classPrivateFieldGet(this, _Massa_wallet, "f").signTransaction(transaction);
+    }
+    async buyRolls(amount = '1') {
+        const transaction = new Transaction(OperationsType.RollBuy, amount);
+        return __classPrivateFieldGet(this, _Massa_wallet, "f").signTransaction(transaction);
+    }
+    async sellRolls(amount = '1') {
+        const transaction = new Transaction(OperationsType.RollSell, amount);
+        return __classPrivateFieldGet(this, _Massa_wallet, "f").signTransaction(transaction);
+    }
+}
+_Massa_provider = new WeakMap(), _Massa_wallet = new WeakMap();
+
+function assert(expressions, msg) {
+    if (!expressions) {
+        throw new Error(msg);
+    }
+}
+
+function getFavicon() {
+    let ref = globalThis.document.querySelector('link[rel*=\'icon\']');
+    if (!ref) {
+        throw new Error(FAVICON_REQUIRED);
+    }
+    return ref.href;
+}
+
+var _Account_subject;
+class Account {
+    constructor(subject) {
+        _Account_subject.set(this, void 0);
+        __classPrivateFieldSet(this, _Account_subject, subject, "f");
+    }
+    subscribe(cb) {
+        if (!cb) {
+            throw new Error(CALLBACK_ERROR);
+        }
+        if (this.base58) {
+            cb(this.base58);
+        }
+        const obs = __classPrivateFieldGet(this, _Account_subject, "f").on((msg) => {
+            switch (msg.type) {
+                case MTypeTab.DISCONNECT_APP_RESULT:
+                    this.base58 = undefined;
+                    break;
+                case MTypeTab.ACCOUNT_CHANGED:
+                    this.base58 = msg.payload.base58;
+                    break;
+                case MTypeTab.RESPONSE_CONNECT_APP:
+                    this.base58 = msg.payload.base58;
+                    break;
+                case MTypeTab.GET_DATA:
+                    this.base58 = msg.payload.base58;
+                    break;
+                default:
+                    return;
+            }
+            cb(this.base58);
+        });
+        return {
+            unsubscribe: () => obs()
+        };
+    }
+}
+_Account_subject = new WeakMap();
+
+var _Network_subject;
+class Network {
+    constructor(subject) {
+        _Network_subject.set(this, void 0);
+        __classPrivateFieldSet(this, _Network_subject, subject, "f");
+    }
+    subscribe(cb) {
+        cb(this.net);
+        const obs = __classPrivateFieldGet(this, _Network_subject, "f").on((msg) => {
+            switch (msg.type) {
+                case MTypeTab.RESPONSE_CONNECT_APP:
+                    this.net = msg.payload.net;
+                    break;
+                case MTypeTab.GET_DATA:
+                    this.net = msg.payload.net;
+                    break;
+                case MTypeTab.NETWORK_CHANGED:
+                    this.net = msg.payload.net;
+                    break;
+                default:
+                    return;
+            }
+            cb(this.net);
+        });
+        return {
+            unsubscribe: () => obs()
+        };
+    }
+}
+_Network_subject = new WeakMap();
+
+var _Blockchain_subject;
+class Blockchain {
+    constructor(subject) {
+        _Blockchain_subject.set(this, void 0);
+        this.period = -1;
+        __classPrivateFieldSet(this, _Blockchain_subject, subject, "f");
+    }
+    subscribe(cb) {
+        const obs = __classPrivateFieldGet(this, _Blockchain_subject, "f").on((msg) => {
+            switch (msg.type) {
+                case MTypeTab.NEW_SLOT:
+                    this.period = msg.payload;
+                    cb(this.period);
+                    break;
+                case MTypeTab.GET_DATA:
+                    this.period = msg.payload.period;
+                    cb(this.period);
+                    break;
+                case MTypeTab.NETWORK_CHANGED:
+                    this.period = msg.payload.period;
+                    cb(this.period);
+                    break;
+            }
+        });
+        return {
+            unsubscribe: () => obs()
+        };
+    }
+}
+_Blockchain_subject = new WeakMap();
+
+var _Wallet_instances, _Wallet_account, _Wallet_network, _Wallet_blockchain, _Wallet_stream, _Wallet_subject, _Wallet_connected, _Wallet_enabled, _Wallet_subscribe;
+class Wallet {
+    get account() {
+        return __classPrivateFieldGet(this, _Wallet_account, "f");
+    }
+    get network() {
+        return __classPrivateFieldGet(this, _Wallet_network, "f");
+    }
+    get blockchain() {
+        return __classPrivateFieldGet(this, _Wallet_blockchain, "f");
+    }
+    get connected() {
+        return __classPrivateFieldGet(this, _Wallet_connected, "f");
+    }
+    get enabled() {
+        return __classPrivateFieldGet(this, _Wallet_enabled, "f");
+    }
+    constructor(stream, subject) {
+        _Wallet_instances.add(this);
+        _Wallet_account.set(this, void 0);
+        _Wallet_network.set(this, void 0);
+        _Wallet_blockchain.set(this, void 0);
+        _Wallet_stream.set(this, void 0);
+        _Wallet_subject.set(this, void 0);
+        _Wallet_connected.set(this, false);
+        _Wallet_enabled.set(this, false);
+        __classPrivateFieldSet(this, _Wallet_stream, stream, "f");
+        __classPrivateFieldSet(this, _Wallet_subject, subject, "f");
+        __classPrivateFieldSet(this, _Wallet_account, new Account(subject), "f");
+        __classPrivateFieldSet(this, _Wallet_network, new Network(subject), "f");
+        __classPrivateFieldSet(this, _Wallet_blockchain, new Blockchain(subject), "f");
+        __classPrivateFieldGet(this, _Wallet_instances, "m", _Wallet_subscribe).call(this);
+    }
+    async diconnect() {
+        const type = MTypeTab.DISCONNECT_APP;
+        const recipient = MTypeTabContent.CONTENT;
+        const title = window.document.title;
+        const icon = getFavicon();
+        const uuid = uuidv4();
+        const payload = {
+            title,
+            icon,
+            uuid
+        };
+        new ContentMessage({
+            type,
+            payload
+        }).send(__classPrivateFieldGet(this, _Wallet_stream, "f"), recipient);
+        return new Promise((resolve, reject) => {
+            const obs = __classPrivateFieldGet(this, _Wallet_subject, "f").on((msg) => {
+                if (msg.type !== MTypeTab.DISCONNECT_APP_RESULT)
+                    return;
+                if (msg.payload.uuid !== uuid)
+                    return;
+                if (msg.payload.reject) {
+                    obs();
+                    return reject(new Error(msg.payload.reject));
+                }
+                __classPrivateFieldSet(this, _Wallet_connected, false, "f");
+                __classPrivateFieldGet(this, _Wallet_account, "f").base58 = undefined;
+                __classPrivateFieldGet(this, _Wallet_network, "f").net = msg.payload.net;
+                obs();
+                return resolve(this.connected);
+            });
+        });
+    }
+    async isMassaAddress(addr) {
+        const type = MTypeTab.CHECK_MASSA_ADDRESS;
+        const recipient = MTypeTabContent.CONTENT;
+        const uuid = uuidv4();
+        const payload = {
+            uuid,
+            addr
+        };
+        new ContentMessage({
+            type,
+            payload
+        }).send(__classPrivateFieldGet(this, _Wallet_stream, "f"), recipient);
+        return new Promise((resolve) => {
+            const obs = __classPrivateFieldGet(this, _Wallet_subject, "f").on((msg) => {
+                if (msg.type !== MTypeTab.CHECK_MASSA_ADDRESS_RES)
+                    return;
+                if (msg.payload.uuid !== uuid)
+                    return;
+                obs();
+                return resolve(msg.payload.resolve);
+            });
+        });
+    }
+    async connect() {
+        const type = MTypeTab.CONNECT_APP;
+        const recipient = MTypeTabContent.CONTENT;
+        const uuid = uuidv4();
+        const title = window.document.title;
+        const icon = getFavicon();
+        const payload = {
+            title,
+            icon,
+            uuid
+        };
+        new ContentMessage({
+            type,
+            payload
+        }).send(__classPrivateFieldGet(this, _Wallet_stream, "f"), recipient);
+        return new Promise((resolve, reject) => {
+            const obs = __classPrivateFieldGet(this, _Wallet_subject, "f").on((msg) => {
+                if (msg.type !== MTypeTab.RESPONSE_CONNECT_APP)
+                    return;
+                if (msg.payload.uuid !== uuid)
+                    return;
+                if (msg.payload.reject) {
+                    obs();
+                    return reject(new Error(msg.payload.reject));
+                }
+                __classPrivateFieldSet(this, _Wallet_connected, Boolean(msg.payload.resolve), "f");
+                __classPrivateFieldGet(this, _Wallet_account, "f").base58 = msg.payload.base58;
+                __classPrivateFieldGet(this, _Wallet_network, "f").net = msg.payload.net;
+                obs();
+                return resolve(this.connected);
+            });
+        });
+    }
+    async signMessage(message) {
+        assert(this.connected, WALLET_IS_NOT_CONNECTED);
+        const type = MTypeTab.SIGN_MESSAGE;
+        const recipient = MTypeTabContent.CONTENT;
+        const uuid = uuidv4();
+        const title = window.document.title;
+        const icon = getFavicon();
+        const payload = {
+            message,
+            uuid,
+            title,
+            icon
+        };
+        new ContentMessage({
+            type,
+            payload
+        }).send(__classPrivateFieldGet(this, _Wallet_stream, "f"), recipient);
+        return new Promise((resolve, reject) => {
+            const obs = __classPrivateFieldGet(this, _Wallet_subject, "f").on((msg) => {
+                if (msg.type !== MTypeTab.SING_MESSAGE_RESULT)
+                    return;
+                if (msg.payload.uuid !== uuid)
+                    return;
+                if (msg.payload && msg.payload.reject) {
+                    obs();
+                    return reject(new Error(msg.payload.reject));
+                }
+                obs();
+                return resolve(msg.payload.resolve);
+            });
+        });
+    }
+    async signTransaction(tx) {
+        assert(this.connected, WALLET_IS_NOT_CONNECTED);
+        assert(tx instanceof Transaction, INVALID_SIGN_PARAMS);
+        const type = MTypeTab.TX_TO_SEND;
+        const recipient = MTypeTabContent.CONTENT;
+        const uuid = uuidv4();
+        const payload = {
+            ...tx.payload,
+            uuid,
+            title: window.document.title,
+            icon: getFavicon()
+        };
+        new ContentMessage({
+            type,
+            payload
+        }).send(__classPrivateFieldGet(this, _Wallet_stream, "f"), recipient);
+        return new Promise((resolve, reject) => {
+            const obs = __classPrivateFieldGet(this, _Wallet_subject, "f").on((msg) => {
+                if (msg.type !== MTypeTab.TX_TO_SEND_RESULT)
+                    return;
+                if (msg.payload.uuid !== uuid)
+                    return;
+                if (msg.payload && msg.payload.reject) {
+                    obs();
+                    return reject(new Error(msg.payload.reject));
+                }
+                obs();
+                return resolve(msg.payload.resolve);
+            });
+        });
+    }
+}
+_Wallet_account = new WeakMap(), _Wallet_network = new WeakMap(), _Wallet_blockchain = new WeakMap(), _Wallet_stream = new WeakMap(), _Wallet_subject = new WeakMap(), _Wallet_connected = new WeakMap(), _Wallet_enabled = new WeakMap(), _Wallet_instances = new WeakSet(), _Wallet_subscribe = function _Wallet_subscribe() {
+    if (!globalThis.window)
+        return;
+    __classPrivateFieldGet(this, _Wallet_subject, "f").on((msg) => {
+        switch (msg.type) {
+            case MTypeTab.NEW_SLOT:
+                __classPrivateFieldGet(this, _Wallet_blockchain, "f").period = msg.payload;
+                break;
+            case MTypeTab.LOCKED:
+                __classPrivateFieldSet(this, _Wallet_enabled, msg.payload.enabled, "f");
+                break;
+            case MTypeTab.ACCOUNT_CHANGED:
+                __classPrivateFieldGet(this, _Wallet_account, "f").base58 = msg.payload.base58;
+                break;
+            case MTypeTab.GET_DATA:
+                __classPrivateFieldGet(this, _Wallet_blockchain, "f").period = msg.payload.period;
+                __classPrivateFieldGet(this, _Wallet_account, "f").base58 = msg.payload.base58;
+                __classPrivateFieldSet(this, _Wallet_enabled, msg.payload.enabled, "f");
+                __classPrivateFieldSet(this, _Wallet_connected, msg.payload.connected, "f");
+                __classPrivateFieldGet(this, _Wallet_network, "f").net = msg.payload.net;
+                break;
+            case MTypeTab.NETWORK_CHANGED:
+                __classPrivateFieldGet(this, _Wallet_network, "f").net = msg.payload.net;
+                __classPrivateFieldGet(this, _Wallet_blockchain, "f").period = msg.payload.period;
+                break;
+        }
+    });
+};
+
+var _Web3_handler, _Web3_provider;
+class Web3 {
+    constructor() {
+        _Web3_handler.set(this, new Handler());
+        _Web3_provider.set(this, new ContentProvider(__classPrivateFieldGet(this, _Web3_handler, "f").stream, __classPrivateFieldGet(this, _Web3_handler, "f").subject));
+        this.wallet = new Wallet(__classPrivateFieldGet(this, _Web3_handler, "f").stream, __classPrivateFieldGet(this, _Web3_handler, "f").subject);
+        this.contract = new Contract(__classPrivateFieldGet(this, _Web3_provider, "f"), this.wallet);
+        this.massa = new Massa(__classPrivateFieldGet(this, _Web3_provider, "f"), this.wallet);
+        if (globalThis.window) {
+            if (globalThis.window['bearby']) {
+                throw new Error(WEB3_INSTANCE_CREATED);
+            }
+            try {
+                __classPrivateFieldGet(this, _Web3_handler, "f").initialized();
+                globalThis.window['bearby'] = Object.freeze(this);
+            }
+            catch {
+                console.debug(AVAILABLE_ONLY_BROWSER);
+            }
+        }
+    }
+}
+_Web3_handler = new WeakMap(), _Web3_provider = new WeakMap();
+
+function main() {
+    if (globalThis.window && globalThis.window['bearby']) {
+        return globalThis.window['bearby'];
+    }
+    return new Web3();
+}
+const web3 = main();
+
+
+//# sourceMappingURL=index.js.map
+
+
 /***/ })
 
 /******/ 	});
@@ -6579,6 +9666,35 @@ exports.uid = uid;
 /******/ 	}
 /******/ 	
 /************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	(() => {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = (exports, definition) => {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	(() => {
+/******/ 		__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
+/******/ 	})();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	(() => {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = (exports) => {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	})();
+/******/ 	
+/************************************************************************/
 /******/ 	
 /******/ 	// startup
 /******/ 	// Load entry module and return exports