@civiwave/mesh-core 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1221 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// node_modules/blakejs/util.js
+var require_util = __commonJS({
+  "node_modules/blakejs/util.js"(exports2, module2) {
+    "use strict";
+    var ERROR_MSG_INPUT = "Input must be an string, Buffer or Uint8Array";
+    function normalizeInput(input) {
+      let ret;
+      if (input instanceof Uint8Array) {
+        ret = input;
+      } else if (typeof input === "string") {
+        const encoder = new TextEncoder();
+        ret = encoder.encode(input);
+      } else {
+        throw new Error(ERROR_MSG_INPUT);
+      }
+      return ret;
+    }
+    function toHex2(bytes) {
+      return Array.prototype.map.call(bytes, function(n) {
+        return (n < 16 ? "0" : "") + n.toString(16);
+      }).join("");
+    }
+    function uint32ToHex(val) {
+      return (4294967296 + val).toString(16).substring(1);
+    }
+    function debugPrint(label, arr, size) {
+      let msg = "\n" + label + " = ";
+      for (let i = 0; i < arr.length; i += 2) {
+        if (size === 32) {
+          msg += uint32ToHex(arr[i]).toUpperCase();
+          msg += " ";
+          msg += uint32ToHex(arr[i + 1]).toUpperCase();
+        } else if (size === 64) {
+          msg += uint32ToHex(arr[i + 1]).toUpperCase();
+          msg += uint32ToHex(arr[i]).toUpperCase();
+        } else throw new Error("Invalid size " + size);
+        if (i % 6 === 4) {
+          msg += "\n" + new Array(label.length + 4).join(" ");
+        } else if (i < arr.length - 2) {
+          msg += " ";
+        }
+      }
+      console.log(msg);
+    }
+    function testSpeed(hashFn, N, M) {
+      let startMs = (/* @__PURE__ */ new Date()).getTime();
+      const input = new Uint8Array(N);
+      for (let i = 0; i < N; i++) {
+        input[i] = i % 256;
+      }
+      const genMs = (/* @__PURE__ */ new Date()).getTime();
+      console.log("Generated random input in " + (genMs - startMs) + "ms");
+      startMs = genMs;
+      for (let i = 0; i < M; i++) {
+        const hashHex = hashFn(input);
+        const hashMs = (/* @__PURE__ */ new Date()).getTime();
+        const ms = hashMs - startMs;
+        startMs = hashMs;
+        console.log("Hashed in " + ms + "ms: " + hashHex.substring(0, 20) + "...");
+        console.log(
+          Math.round(N / (1 << 20) / (ms / 1e3) * 100) / 100 + " MB PER SECOND"
+        );
+      }
+    }
+    module2.exports = {
+      normalizeInput,
+      toHex: toHex2,
+      debugPrint,
+      testSpeed
+    };
+  }
+});
+
+// node_modules/blakejs/blake2b.js
+var require_blake2b = __commonJS({
+  "node_modules/blakejs/blake2b.js"(exports2, module2) {
+    "use strict";
+    var util = require_util();
+    function ADD64AA(v2, a, b) {
+      const o0 = v2[a] + v2[b];
+      let o1 = v2[a + 1] + v2[b + 1];
+      if (o0 >= 4294967296) {
+        o1++;
+      }
+      v2[a] = o0;
+      v2[a + 1] = o1;
+    }
+    function ADD64AC(v2, a, b0, b1) {
+      let o0 = v2[a] + b0;
+      if (b0 < 0) {
+        o0 += 4294967296;
+      }
+      let o1 = v2[a + 1] + b1;
+      if (o0 >= 4294967296) {
+        o1++;
+      }
+      v2[a] = o0;
+      v2[a + 1] = o1;
+    }
+    function B2B_GET32(arr, i) {
+      return arr[i] ^ arr[i + 1] << 8 ^ arr[i + 2] << 16 ^ arr[i + 3] << 24;
+    }
+    function B2B_G(a, b, c, d, ix, iy) {
+      const x0 = m[ix];
+      const x1 = m[ix + 1];
+      const y0 = m[iy];
+      const y1 = m[iy + 1];
+      ADD64AA(v, a, b);
+      ADD64AC(v, a, x0, x1);
+      let xor0 = v[d] ^ v[a];
+      let xor1 = v[d + 1] ^ v[a + 1];
+      v[d] = xor1;
+      v[d + 1] = xor0;
+      ADD64AA(v, c, d);
+      xor0 = v[b] ^ v[c];
+      xor1 = v[b + 1] ^ v[c + 1];
+      v[b] = xor0 >>> 24 ^ xor1 << 8;
+      v[b + 1] = xor1 >>> 24 ^ xor0 << 8;
+      ADD64AA(v, a, b);
+      ADD64AC(v, a, y0, y1);
+      xor0 = v[d] ^ v[a];
+      xor1 = v[d + 1] ^ v[a + 1];
+      v[d] = xor0 >>> 16 ^ xor1 << 16;
+      v[d + 1] = xor1 >>> 16 ^ xor0 << 16;
+      ADD64AA(v, c, d);
+      xor0 = v[b] ^ v[c];
+      xor1 = v[b + 1] ^ v[c + 1];
+      v[b] = xor1 >>> 31 ^ xor0 << 1;
+      v[b + 1] = xor0 >>> 31 ^ xor1 << 1;
+    }
+    var BLAKE2B_IV32 = new Uint32Array([
+      4089235720,
+      1779033703,
+      2227873595,
+      3144134277,
+      4271175723,
+      1013904242,
+      1595750129,
+      2773480762,
+      2917565137,
+      1359893119,
+      725511199,
+      2600822924,
+      4215389547,
+      528734635,
+      327033209,
+      1541459225
+    ]);
+    var SIGMA8 = [
+      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
+    ];
+    var SIGMA82 = new Uint8Array(
+      SIGMA8.map(function(x) {
+        return x * 2;
+      })
+    );
+    var v = new Uint32Array(32);
+    var m = new Uint32Array(32);
+    function blake2bCompress(ctx, last) {
+      let i = 0;
+      for (i = 0; i < 16; i++) {
+        v[i] = ctx.h[i];
+        v[i + 16] = BLAKE2B_IV32[i];
+      }
+      v[24] = v[24] ^ ctx.t;
+      v[25] = v[25] ^ ctx.t / 4294967296;
+      if (last) {
+        v[28] = ~v[28];
+        v[29] = ~v[29];
+      }
+      for (i = 0; i < 32; i++) {
+        m[i] = B2B_GET32(ctx.b, 4 * i);
+      }
+      for (i = 0; i < 12; i++) {
+        B2B_G(0, 8, 16, 24, SIGMA82[i * 16 + 0], SIGMA82[i * 16 + 1]);
+        B2B_G(2, 10, 18, 26, SIGMA82[i * 16 + 2], SIGMA82[i * 16 + 3]);
+        B2B_G(4, 12, 20, 28, SIGMA82[i * 16 + 4], SIGMA82[i * 16 + 5]);
+        B2B_G(6, 14, 22, 30, SIGMA82[i * 16 + 6], SIGMA82[i * 16 + 7]);
+        B2B_G(0, 10, 20, 30, SIGMA82[i * 16 + 8], SIGMA82[i * 16 + 9]);
+        B2B_G(2, 12, 22, 24, SIGMA82[i * 16 + 10], SIGMA82[i * 16 + 11]);
+        B2B_G(4, 14, 16, 26, SIGMA82[i * 16 + 12], SIGMA82[i * 16 + 13]);
+        B2B_G(6, 8, 18, 28, SIGMA82[i * 16 + 14], SIGMA82[i * 16 + 15]);
+      }
+      for (i = 0; i < 16; i++) {
+        ctx.h[i] = ctx.h[i] ^ v[i] ^ v[i + 16];
+      }
+    }
+    var parameterBlock = new Uint8Array([
+      0,
+      0,
+      0,
+      0,
+      //  0: outlen, keylen, fanout, depth
+      0,
+      0,
+      0,
+      0,
+      //  4: leaf length, sequential mode
+      0,
+      0,
+      0,
+      0,
+      //  8: node offset
+      0,
+      0,
+      0,
+      0,
+      // 12: node offset
+      0,
+      0,
+      0,
+      0,
+      // 16: node depth, inner length, rfu
+      0,
+      0,
+      0,
+      0,
+      // 20: rfu
+      0,
+      0,
+      0,
+      0,
+      // 24: rfu
+      0,
+      0,
+      0,
+      0,
+      // 28: rfu
+      0,
+      0,
+      0,
+      0,
+      // 32: salt
+      0,
+      0,
+      0,
+      0,
+      // 36: salt
+      0,
+      0,
+      0,
+      0,
+      // 40: salt
+      0,
+      0,
+      0,
+      0,
+      // 44: salt
+      0,
+      0,
+      0,
+      0,
+      // 48: personal
+      0,
+      0,
+      0,
+      0,
+      // 52: personal
+      0,
+      0,
+      0,
+      0,
+      // 56: personal
+      0,
+      0,
+      0,
+      0
+      // 60: personal
+    ]);
+    function blake2bInit(outlen, key, salt, personal) {
+      if (outlen === 0 || outlen > 64) {
+        throw new Error("Illegal output length, expected 0 < length <= 64");
+      }
+      if (key && key.length > 64) {
+        throw new Error("Illegal key, expected Uint8Array with 0 < length <= 64");
+      }
+      if (salt && salt.length !== 16) {
+        throw new Error("Illegal salt, expected Uint8Array with length is 16");
+      }
+      if (personal && personal.length !== 16) {
+        throw new Error("Illegal personal, expected Uint8Array with length is 16");
+      }
+      const ctx = {
+        b: new Uint8Array(128),
+        h: new Uint32Array(16),
+        t: 0,
+        // input count
+        c: 0,
+        // pointer within buffer
+        outlen
+        // output length in bytes
+      };
+      parameterBlock.fill(0);
+      parameterBlock[0] = outlen;
+      if (key) parameterBlock[1] = key.length;
+      parameterBlock[2] = 1;
+      parameterBlock[3] = 1;
+      if (salt) parameterBlock.set(salt, 32);
+      if (personal) parameterBlock.set(personal, 48);
+      for (let i = 0; i < 16; i++) {
+        ctx.h[i] = BLAKE2B_IV32[i] ^ B2B_GET32(parameterBlock, i * 4);
+      }
+      if (key) {
+        blake2bUpdate(ctx, key);
+        ctx.c = 128;
+      }
+      return ctx;
+    }
+    function blake2bUpdate(ctx, input) {
+      for (let i = 0; i < input.length; i++) {
+        if (ctx.c === 128) {
+          ctx.t += ctx.c;
+          blake2bCompress(ctx, false);
+          ctx.c = 0;
+        }
+        ctx.b[ctx.c++] = input[i];
+      }
+    }
+    function blake2bFinal(ctx) {
+      ctx.t += ctx.c;
+      while (ctx.c < 128) {
+        ctx.b[ctx.c++] = 0;
+      }
+      blake2bCompress(ctx, true);
+      const out = new Uint8Array(ctx.outlen);
+      for (let i = 0; i < ctx.outlen; i++) {
+        out[i] = ctx.h[i >> 2] >> 8 * (i & 3);
+      }
+      return out;
+    }
+    function blake2b2(input, key, outlen, salt, personal) {
+      outlen = outlen || 64;
+      input = util.normalizeInput(input);
+      if (salt) {
+        salt = util.normalizeInput(salt);
+      }
+      if (personal) {
+        personal = util.normalizeInput(personal);
+      }
+      const ctx = blake2bInit(outlen, key, salt, personal);
+      blake2bUpdate(ctx, input);
+      return blake2bFinal(ctx);
+    }
+    function blake2bHex(input, key, outlen, salt, personal) {
+      const output = blake2b2(input, key, outlen, salt, personal);
+      return util.toHex(output);
+    }
+    module2.exports = {
+      blake2b: blake2b2,
+      blake2bHex,
+      blake2bInit,
+      blake2bUpdate,
+      blake2bFinal
+    };
+  }
+});
+
+// node_modules/blakejs/blake2s.js
+var require_blake2s = __commonJS({
+  "node_modules/blakejs/blake2s.js"(exports2, module2) {
+    "use strict";
+    var util = require_util();
+    function B2S_GET32(v2, i) {
+      return v2[i] ^ v2[i + 1] << 8 ^ v2[i + 2] << 16 ^ v2[i + 3] << 24;
+    }
+    function B2S_G(a, b, c, d, x, y) {
+      v[a] = v[a] + v[b] + x;
+      v[d] = ROTR32(v[d] ^ v[a], 16);
+      v[c] = v[c] + v[d];
+      v[b] = ROTR32(v[b] ^ v[c], 12);
+      v[a] = v[a] + v[b] + y;
+      v[d] = ROTR32(v[d] ^ v[a], 8);
+      v[c] = v[c] + v[d];
+      v[b] = ROTR32(v[b] ^ v[c], 7);
+    }
+    function ROTR32(x, y) {
+      return x >>> y ^ x << 32 - y;
+    }
+    var BLAKE2S_IV = new Uint32Array([
+      1779033703,
+      3144134277,
+      1013904242,
+      2773480762,
+      1359893119,
+      2600822924,
+      528734635,
+      1541459225
+    ]);
+    var 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
+    ]);
+    var v = new Uint32Array(16);
+    var m = new Uint32Array(16);
+    function blake2sCompress(ctx, last) {
+      let i = 0;
+      for (i = 0; i < 8; i++) {
+        v[i] = ctx.h[i];
+        v[i + 8] = BLAKE2S_IV[i];
+      }
+      v[12] ^= ctx.t;
+      v[13] ^= ctx.t / 4294967296;
+      if (last) {
+        v[14] = ~v[14];
+      }
+      for (i = 0; i < 16; i++) {
+        m[i] = B2S_GET32(ctx.b, 4 * i);
+      }
+      for (i = 0; i < 10; i++) {
+        B2S_G(0, 4, 8, 12, m[SIGMA[i * 16 + 0]], m[SIGMA[i * 16 + 1]]);
+        B2S_G(1, 5, 9, 13, m[SIGMA[i * 16 + 2]], m[SIGMA[i * 16 + 3]]);
+        B2S_G(2, 6, 10, 14, m[SIGMA[i * 16 + 4]], m[SIGMA[i * 16 + 5]]);
+        B2S_G(3, 7, 11, 15, m[SIGMA[i * 16 + 6]], m[SIGMA[i * 16 + 7]]);
+        B2S_G(0, 5, 10, 15, m[SIGMA[i * 16 + 8]], m[SIGMA[i * 16 + 9]]);
+        B2S_G(1, 6, 11, 12, m[SIGMA[i * 16 + 10]], m[SIGMA[i * 16 + 11]]);
+        B2S_G(2, 7, 8, 13, m[SIGMA[i * 16 + 12]], m[SIGMA[i * 16 + 13]]);
+        B2S_G(3, 4, 9, 14, m[SIGMA[i * 16 + 14]], m[SIGMA[i * 16 + 15]]);
+      }
+      for (i = 0; i < 8; i++) {
+        ctx.h[i] ^= v[i] ^ v[i + 8];
+      }
+    }
+    function blake2sInit(outlen, key) {
+      if (!(outlen > 0 && outlen <= 32)) {
+        throw new Error("Incorrect output length, should be in [1, 32]");
+      }
+      const keylen = key ? key.length : 0;
+      if (key && !(keylen > 0 && keylen <= 32)) {
+        throw new Error("Incorrect key length, should be in [1, 32]");
+      }
+      const ctx = {
+        h: new Uint32Array(BLAKE2S_IV),
+        // hash state
+        b: new Uint8Array(64),
+        // input block
+        c: 0,
+        // pointer within block
+        t: 0,
+        // input count
+        outlen
+        // output length in bytes
+      };
+      ctx.h[0] ^= 16842752 ^ keylen << 8 ^ outlen;
+      if (keylen > 0) {
+        blake2sUpdate(ctx, key);
+        ctx.c = 64;
+      }
+      return ctx;
+    }
+    function blake2sUpdate(ctx, input) {
+      for (let i = 0; i < input.length; i++) {
+        if (ctx.c === 64) {
+          ctx.t += ctx.c;
+          blake2sCompress(ctx, false);
+          ctx.c = 0;
+        }
+        ctx.b[ctx.c++] = input[i];
+      }
+    }
+    function blake2sFinal(ctx) {
+      ctx.t += ctx.c;
+      while (ctx.c < 64) {
+        ctx.b[ctx.c++] = 0;
+      }
+      blake2sCompress(ctx, true);
+      const out = new Uint8Array(ctx.outlen);
+      for (let i = 0; i < ctx.outlen; i++) {
+        out[i] = ctx.h[i >> 2] >> 8 * (i & 3) & 255;
+      }
+      return out;
+    }
+    function blake2s(input, key, outlen) {
+      outlen = outlen || 32;
+      input = util.normalizeInput(input);
+      const ctx = blake2sInit(outlen, key);
+      blake2sUpdate(ctx, input);
+      return blake2sFinal(ctx);
+    }
+    function blake2sHex(input, key, outlen) {
+      const output = blake2s(input, key, outlen);
+      return util.toHex(output);
+    }
+    module2.exports = {
+      blake2s,
+      blake2sHex,
+      blake2sInit,
+      blake2sUpdate,
+      blake2sFinal
+    };
+  }
+});
+
+// node_modules/blakejs/index.js
+var require_blakejs = __commonJS({
+  "node_modules/blakejs/index.js"(exports2, module2) {
+    "use strict";
+    var b2b = require_blake2b();
+    var b2s = require_blake2s();
+    module2.exports = {
+      blake2b: b2b.blake2b,
+      blake2bHex: b2b.blake2bHex,
+      blake2bInit: b2b.blake2bInit,
+      blake2bUpdate: b2b.blake2bUpdate,
+      blake2bFinal: b2b.blake2bFinal,
+      blake2s: b2s.blake2s,
+      blake2sHex: b2s.blake2sHex,
+      blake2sInit: b2s.blake2sInit,
+      blake2sUpdate: b2s.blake2sUpdate,
+      blake2sFinal: b2s.blake2sFinal
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  SS58_PREFIX: () => SS58_PREFIX,
+  addStake: () => addStake,
+  balanceQueryUrl: () => balanceQueryUrl,
+  buildDIDDocument: () => buildDIDDocument,
+  createWallet: () => createWallet,
+  deleteWallet: () => deleteWallet,
+  didFromSS58: () => didFromSS58,
+  extrinsicUrl: () => extrinsicUrl,
+  fromHex: () => fromHex,
+  generateDIDHash: () => generateDIDHash,
+  generateKeypair: () => generateKeypair,
+  getChainMetadata: () => getChainMetadata,
+  getKeeperEndpoint: () => getKeeperEndpoint,
+  loadWallet: () => loadWallet,
+  metadataUrl: () => metadataUrl,
+  publicKeyToSS58: () => publicKeyToSS58,
+  queryBalance: () => queryBalance,
+  registerDID: () => registerDID,
+  removeStake: () => removeStake,
+  saveWallet: () => saveWallet,
+  setKeeperEndpoint: () => setKeeperEndpoint,
+  sign: () => sign,
+  stakingUrl: () => stakingUrl,
+  submitExtrinsic: () => submitExtrinsic,
+  submitPalletExtrinsic: () => submitPalletExtrinsic,
+  toHex: () => toHex,
+  transfer: () => transfer,
+  verify: () => verify
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/wallet.ts
+var ed = __toESM(require("@noble/ed25519"), 1);
+var WALLET_STORAGE_KEY = "@mesh/wallet";
+var SS58_PREFIX = 42;
+function toHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function fromHex(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16);
+  }
+  return bytes;
+}
+function publicKeyToSS58(pubkey, prefix = SS58_PREFIX) {
+  const { blake2b: blake2b2 } = require_blakejs();
+  const prefixByte = new Uint8Array([prefix]);
+  const payload = new Uint8Array(1 + pubkey.length);
+  payload.set(prefixByte, 0);
+  payload.set(pubkey, 1);
+  const ss58Pre = new TextEncoder().encode("SS58PRE");
+  const input = new Uint8Array(ss58Pre.length + payload.length);
+  input.set(ss58Pre, 0);
+  input.set(payload, ss58Pre.length);
+  const hash = blake2b2(input, void 0, 64);
+  const checksum = hash.slice(0, 2);
+  const full = new Uint8Array(payload.length + 2);
+  full.set(payload, 0);
+  full.set(checksum, payload.length);
+  return base58Encode(full);
+}
+function base58Encode(bytes) {
+  const ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+  let leadingZeros = 0;
+  for (const b of bytes) {
+    if (b !== 0) break;
+    leadingZeros++;
+  }
+  let num = BigInt(0);
+  for (const b of bytes) {
+    num = num * BigInt(256) + BigInt(b);
+  }
+  let result = "";
+  while (num > BigInt(0)) {
+    const rem = Number(num % BigInt(58));
+    num = num / BigInt(58);
+    result = ALPHABET[rem] + result;
+  }
+  return "1".repeat(leadingZeros) + result;
+}
+async function generateKeypair() {
+  const secretKey = ed.utils.randomPrivateKey();
+  const publicKey = await ed.getPublicKeyAsync(secretKey);
+  return { publicKey, secretKey };
+}
+async function sign(message, secretKey) {
+  const signature = await ed.signAsync(message, secretKey);
+  return signature;
+}
+async function verify(signature, message, publicKey) {
+  return ed.verifyAsync(signature, message, publicKey);
+}
+async function saveWallet(wallet, storage) {
+  const json = {
+    publicKeyHex: toHex(wallet.publicKey),
+    secretKeyHex: toHex(wallet.secretKey),
+    ss58Address: wallet.ss58Address,
+    createdAt: wallet.createdAt
+  };
+  await storage.setItem(WALLET_STORAGE_KEY, JSON.stringify(json));
+}
+async function loadWallet(storage) {
+  const raw = await storage.getItem(WALLET_STORAGE_KEY);
+  if (!raw) return null;
+  const json = JSON.parse(raw);
+  return {
+    publicKey: fromHex(json.publicKeyHex),
+    secretKey: fromHex(json.secretKeyHex),
+    ss58Address: json.ss58Address,
+    createdAt: json.createdAt
+  };
+}
+async function deleteWallet(storage) {
+  await storage.removeItem(WALLET_STORAGE_KEY);
+}
+function createWallet(publicKey, secretKey) {
+  return {
+    publicKey,
+    secretKey,
+    ss58Address: publicKeyToSS58(publicKey),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/did.ts
+var import_blakejs = __toESM(require_blakejs(), 1);
+
+// src/chain.ts
+var DEFAULT_KEEPER_ENDPOINT = "http://localhost:8422";
+var keeperEndpoint = DEFAULT_KEEPER_ENDPOINT;
+function setKeeperEndpoint(url) {
+  keeperEndpoint = url.replace(/\/+$/, "");
+}
+function getKeeperEndpoint() {
+  return keeperEndpoint;
+}
+function balanceQueryUrl(base, account) {
+  return `${base}/v1/chain/query/balance?account=${account}`;
+}
+function extrinsicUrl(base) {
+  return `${base}/v1/chain/extrinsic`;
+}
+function metadataUrl(base, account) {
+  return `${base}/v1/chain/metadata?account=${account}`;
+}
+function stakingUrl(base, op) {
+  return `${base}/v1/staking/${op}`;
+}
+async function queryBalance(ss58Address) {
+  try {
+    const url = balanceQueryUrl(keeperEndpoint, ss58Address);
+    const response = await fetch(url);
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+async function submitExtrinsic(hexPayload) {
+  try {
+    const url = extrinsicUrl(keeperEndpoint);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ extrinsic: hexPayload })
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+async function getChainMetadata(ss58Address) {
+  try {
+    const url = metadataUrl(keeperEndpoint, ss58Address);
+    const response = await fetch(url);
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+async function submitPalletExtrinsic(request) {
+  try {
+    const url = extrinsicUrl(keeperEndpoint);
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(request)
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+async function addStake(hotkey, netuid, amount) {
+  try {
+    const url = stakingUrl(keeperEndpoint, "add-stake");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ hotkey, netuid, amount })
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+async function removeStake(hotkey, netuid, amount) {
+  try {
+    const url = stakingUrl(keeperEndpoint, "remove-stake");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ hotkey, netuid, amount })
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+async function transfer(destination, amount) {
+  try {
+    const url = stakingUrl(keeperEndpoint, "transfer");
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ destination, amount })
+    });
+    if (!response.ok) {
+      return { success: false, error: `HTTP ${response.status}: ${response.statusText}` };
+    }
+    const data = await response.json();
+    return { success: true, data };
+  } catch (err) {
+    return { success: false, error: "Connection failed" };
+  }
+}
+
+// src/did.ts
+function generateDIDHash(publicKey) {
+  return (0, import_blakejs.blake2b)(publicKey, void 0, 32);
+}
+function buildDIDDocument(ss58Address, publicKey) {
+  const publicKeyHex = toHex(publicKey);
+  return {
+    "@context": ["https://www.w3.org/ns/did/v1"],
+    id: `did:civiwave:${ss58Address}`,
+    authentication: [
+      {
+        type: "Ed25519VerificationKey2020",
+        publicKeyMultibase: publicKeyHex
+      }
+    ]
+  };
+}
+async function registerDID(wallet) {
+  const publicKeyHex = toHex(wallet.publicKey);
+  const didDocument = buildDIDDocument(wallet.ss58Address, wallet.publicKey);
+  return submitPalletExtrinsic({
+    pallet: "IdentityHub",
+    call: "register_did",
+    params: {
+      public_key: publicKeyHex,
+      did_document: didDocument
+    }
+  });
+}
+function didFromSS58(ss58Address) {
+  return `did:civiwave:${ss58Address}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  SS58_PREFIX,
+  addStake,
+  balanceQueryUrl,
+  buildDIDDocument,
+  createWallet,
+  deleteWallet,
+  didFromSS58,
+  extrinsicUrl,
+  fromHex,
+  generateDIDHash,
+  generateKeypair,
+  getChainMetadata,
+  getKeeperEndpoint,
+  loadWallet,
+  metadataUrl,
+  publicKeyToSS58,
+  queryBalance,
+  registerDID,
+  removeStake,
+  saveWallet,
+  setKeeperEndpoint,
+  sign,
+  stakingUrl,
+  submitExtrinsic,
+  submitPalletExtrinsic,
+  toHex,
+  transfer,
+  verify
+});