@toon-protocol/townhouse 0.7.0 → 0.9.0

package/dist/{chunk-ZUMMJFGH.js → chunk-UBFITLPQ.js}

@@ -25,6 +25,7 @@ import {
   u32
 } from "./chunk-5O4SBV5O.js";
 import {
+  ACCOUNT_INDEX_APEX,
   ACCOUNT_INDEX_DVM,
   ACCOUNT_INDEX_MILL,
   ACCOUNT_INDEX_TOWN,
@@ -34,7 +35,7 @@ import {
   MILL_HEALTH_PORT,
   NODE_BTP_PORT,
   TOWN_HEALTH_PORT
-} from "./chunk-NZR5C3KD.js";
+} from "./chunk-BLNEL3QS.js";
 import {
   __commonJS,
   __require,
@@ -6489,11 +6490,13 @@ function validateConfig(raw) {
             `${path}.tokenAddress must match /^0x[a-fA-F0-9]+$/`
           );
         }
-        assertString(entry["keyId"], `${path}.keyId`);
-        if (!HEX_ADDRESS.test(entry["keyId"])) {
-          throw new ConfigValidationError(
-            `${path}.keyId must match /^0x[a-fA-F0-9]+$/`
-          );
+        if (entry["keyId"] !== void 0) {
+          assertString(entry["keyId"], `${path}.keyId`);
+          if (!HEX_ADDRESS.test(entry["keyId"])) {
+            throw new ConfigValidationError(
+              `${path}.keyId must match /^0x[a-fA-F0-9]+$/`
+            );
+          }
         }
         return {
           chainType: "evm",
@@ -6501,13 +6504,15 @@ function validateConfig(raw) {
           rpcUrl: entry["rpcUrl"],
           registryAddress: entry["registryAddress"],
           tokenAddress: entry["tokenAddress"],
-          keyId: entry["keyId"]
+          ...entry["keyId"] !== void 0 ? { keyId: entry["keyId"] } : {}
         };
       }
       if (chainType === "solana") {
         assertString(entry["rpcUrl"], `${path}.rpcUrl`);
         assertString(entry["programId"], `${path}.programId`);
-        assertString(entry["keyId"], `${path}.keyId`);
+        if (entry["keyId"] !== void 0) {
+          assertString(entry["keyId"], `${path}.keyId`);
+        }
         if (entry["wsUrl"] !== void 0) {
           assertString(entry["wsUrl"], `${path}.wsUrl`);
         }
@@ -6521,7 +6526,7 @@ function validateConfig(raw) {
           ...entry["wsUrl"] !== void 0 ? { wsUrl: entry["wsUrl"] } : {},
           programId: entry["programId"],
           ...entry["tokenMint"] !== void 0 ? { tokenMint: entry["tokenMint"] } : {},
-          keyId: entry["keyId"]
+          ...entry["keyId"] !== void 0 ? { keyId: entry["keyId"] } : {}
         };
       }
       assertString(entry["graphqlUrl"], `${path}.graphqlUrl`);
@@ -6809,7 +6814,7 @@ var ConnectorConfigGenerator = class {
             rpcUrl: p.rpcUrl,
             registryAddress: p.registryAddress,
             tokenAddress: p.tokenAddress,
-            keyId: p.keyId
+            ...p.keyId !== void 0 ? { keyId: p.keyId } : {}
           };
         }
         if (p.chainType === "solana") {
@@ -6820,7 +6825,7 @@ var ConnectorConfigGenerator = class {
             ...p.wsUrl !== void 0 ? { wsUrl: p.wsUrl } : {},
             programId: p.programId,
             ...p.tokenMint !== void 0 ? { tokenMint: p.tokenMint } : {},
-            keyId: p.keyId
+            ...p.keyId !== void 0 ? { keyId: p.keyId } : {}
           };
         }
         return {
@@ -8754,9 +8759,45 @@ var import_websocket_server = __toESM(require_websocket_server(), 1);
 
 // ../core/dist/index.js
 import { getPublicKey as getPublicKey2, verifyEvent } from "nostr-tools/pure";
-import { SimplePool as SimplePool3 } from "nostr-tools/pool";
-import { getPublicKey as getPublicKey3 } from "nostr-tools/pure";
-import { getPublicKey as getPublicKey4 } from "nostr-tools/pure";
+
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_u64.js
+var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+var _32n = /* @__PURE__ */ BigInt(32);
+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 };
+}
+function split2(lst, le = false) {
+  const len = lst.length;
+  let Ah = new Uint32Array(len);
+  let Al = new Uint32Array(len);
+  for (let i = 0; i < len; i++) {
+    const { h, l } = fromBig(lst[i], le);
+    [Ah[i], Al[i]] = [h, l];
+  }
+  return [Ah, Al];
+}
+var shrSH = (h, _l, s) => h >>> s;
+var shrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+var rotlSH2 = (h, l, s) => h << s | l >>> 32 - s;
+var rotlSL2 = (h, l, s) => l << s | h >>> 32 - s;
+var rotlBH2 = (h, l, s) => l << s - 32 | h >>> 64 - s;
+var rotlBL2 = (h, l, s) => h << s - 32 | l >>> 64 - s;
+function add(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
 
 // ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/utils.js
 function isBytes2(a) {
@@ -8923,121 +8964,190 @@ var oidNist = (suffix) => ({
   oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
 });
 
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/hmac.js
-var _HMAC = class {
-  oHash;
-  iHash;
-  blockLen;
-  outputLen;
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/sha3.js
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var _7n = BigInt(7);
+var _256n = BigInt(256);
+var _0x71n = BigInt(113);
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << BigInt(j)) - _1n;
+  }
+  _SHA3_IOTA.push(t);
+}
+var IOTAS = split2(_SHA3_IOTA, true);
+var SHA3_IOTA_H = IOTAS[0];
+var SHA3_IOTA_L = IOTAS[1];
+var rotlH = (h, l, s) => s > 32 ? rotlBH2(h, l, s) : rotlSH2(h, l, s);
+var rotlL = (h, l, s) => s > 32 ? rotlBL2(h, l, s) : rotlSL2(h, l, s);
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean2(B);
+}
+var Keccak = class _Keccak {
+  state;
+  pos = 0;
+  posOut = 0;
   finished = false;
+  state32;
   destroyed = false;
-  constructor(hash, key) {
-    ahash2(hash);
-    abytes2(key, void 0, "key");
-    this.iHash = hash.create();
-    if (typeof this.iHash.update !== "function")
-      throw new Error("Expected instance of class which extends utils.Hash");
-    this.blockLen = this.iHash.blockLen;
-    this.outputLen = this.iHash.outputLen;
-    const blockLen = this.blockLen;
-    const pad = new Uint8Array(blockLen);
-    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54;
-    this.iHash.update(pad);
-    this.oHash = hash.create();
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54 ^ 92;
-    this.oHash.update(pad);
-    clean2(pad);
+  blockLen;
+  suffix;
+  outputLen;
+  enableXOF = false;
+  rounds;
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    anumber2(outputLen, "outputLen");
+    if (!(0 < blockLen && blockLen < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200);
+    this.state32 = u322(this.state);
   }
-  update(buf) {
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    swap32IfBE2(this.state32);
+    keccakP(this.state32, this.rounds);
+    swap32IfBE2(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
     aexists2(this);
-    this.iHash.update(buf);
+    abytes2(data);
+    const { blockLen, state } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
     return this;
   }
-  digestInto(out) {
-    aexists2(this);
-    abytes2(out, this.outputLen, "output");
+  finish() {
+    if (this.finished)
+      return;
     this.finished = true;
-    this.iHash.digestInto(out);
-    this.oHash.update(out);
-    this.oHash.digestInto(out);
-    this.destroy();
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
   }
-  digest() {
-    const out = new Uint8Array(this.oHash.outputLen);
-    this.digestInto(out);
+  writeInto(out) {
+    aexists2(this, false);
+    abytes2(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      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;
   }
-  _cloneInto(to) {
-    to ||= Object.create(Object.getPrototypeOf(this), {});
-    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-    to = to;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    to.blockLen = blockLen;
-    to.outputLen = outputLen;
-    to.oHash = oHash._cloneInto(to.oHash);
-    to.iHash = iHash._cloneInto(to.iHash);
-    return to;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  destroy() {
-    this.destroyed = true;
-    this.oHash.destroy();
-    this.iHash.destroy();
-  }
-};
-var hmac2 = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
-hmac2.create = (hash, key) => new _HMAC(hash, key);
-
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/pbkdf2.js
-function pbkdf2Init(hash, _password, _salt, _opts) {
-  ahash2(hash);
-  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
-  const { c, dkLen, asyncTick } = opts;
-  anumber2(c, "c");
-  anumber2(dkLen, "dkLen");
-  anumber2(asyncTick, "asyncTick");
-  if (c < 1)
-    throw new Error("iterations (c) must be >= 1");
-  const password = kdfInputToBytes(_password, "password");
-  const salt = kdfInputToBytes(_salt, "salt");
-  const DK = new Uint8Array(dkLen);
-  const PRF = hmac2.create(hash, password);
-  const PRFSalt = PRF._cloneInto().update(salt);
-  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
-}
-function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
-  PRF.destroy();
-  PRFSalt.destroy();
-  if (prfW)
-    prfW.destroy();
-  clean2(u);
-  return DK;
-}
-function pbkdf2(hash, password, salt, opts) {
-  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
-  let prfW;
-  const arr = new Uint8Array(4);
-  const view = createView(arr);
-  const u = new Uint8Array(PRF.outputLen);
-  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-    const Ti = DK.subarray(pos, pos + PRF.outputLen);
-    view.setInt32(0, ti, false);
-    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-    Ti.set(u.subarray(0, Ti.length));
-    for (let ui = 1; ui < c; ui++) {
-      PRF._cloneInto(prfW).update(u).digestInto(u);
-      for (let i = 0; i < Ti.length; i++)
-        Ti[i] ^= u[i];
-    }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
   }
-  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}
+  xof(bytes) {
+    anumber2(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput2(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = true;
+    clean2(this.state);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to ||= new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.destroyed = this.destroyed;
+    return to;
+  }
+};
+var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher2(() => new Keccak(blockLen, suffix, outputLen), info);
+var keccak_256 = /* @__PURE__ */ genKeccak(1, 136, 32);
 
 // ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_md.js
 function Chi(a, b, c) {
@@ -9170,45 +9280,6 @@ var SHA512_IV = /* @__PURE__ */ Uint32Array.from([
   327033209
 ]);
 
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/_u64.js
-var U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
-var _32n = /* @__PURE__ */ BigInt(32);
-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 };
-}
-function split2(lst, le = false) {
-  const len = lst.length;
-  let Ah = new Uint32Array(len);
-  let Al = new Uint32Array(len);
-  for (let i = 0; i < len; i++) {
-    const { h, l } = fromBig(lst[i], le);
-    [Ah[i], Al[i]] = [h, l];
-  }
-  return [Ah, Al];
-}
-var shrSH = (h, _l, s) => h >>> s;
-var shrSL = (h, l, s) => h << 32 - s | l >>> s;
-var rotrSH = (h, l, s) => h >>> s | l << 32 - s;
-var rotrSL = (h, l, s) => h << 32 - s | l >>> s;
-var rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
-var rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
-var rotlSH2 = (h, l, s) => h << s | l >>> 32 - s;
-var rotlSL2 = (h, l, s) => l << s | h >>> 32 - s;
-var rotlBH2 = (h, l, s) => l << s - 32 | h >>> 64 - s;
-var rotlBL2 = (h, l, s) => h << s - 32 | l >>> 64 - s;
-function add(Ah, Al, Bh, Bl) {
-  const l = (Al >>> 0) + (Bl >>> 0);
-  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
-}
-var add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
-var add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
-var add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
-var add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
-var add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
-var add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
-
 // ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/sha2.js
 var SHA256_K = /* @__PURE__ */ Uint32Array.from([
   1116352408,
@@ -9565,6 +9636,127 @@ var sha512 = /* @__PURE__ */ createHasher2(
   /* @__PURE__ */ oidNist(3)
 );
 
+// ../core/dist/index.js
+import { SimplePool as SimplePool3 } from "nostr-tools/pool";
+import { getPublicKey as getPublicKey3 } from "nostr-tools/pure";
+import { getPublicKey as getPublicKey4 } from "nostr-tools/pure";
+
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/hmac.js
+var _HMAC = class {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = false;
+  destroyed = false;
+  constructor(hash, key) {
+    ahash2(hash);
+    abytes2(key, void 0, "key");
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean2(pad);
+  }
+  update(buf) {
+    aexists2(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists2(this);
+    abytes2(out, this.outputLen, "output");
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+};
+var hmac2 = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
+hmac2.create = (hash, key) => new _HMAC(hash, key);
+
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/pbkdf2.js
+function pbkdf2Init(hash, _password, _salt, _opts) {
+  ahash2(hash);
+  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
+  const { c, dkLen, asyncTick } = opts;
+  anumber2(c, "c");
+  anumber2(dkLen, "dkLen");
+  anumber2(asyncTick, "asyncTick");
+  if (c < 1)
+    throw new Error("iterations (c) must be >= 1");
+  const password = kdfInputToBytes(_password, "password");
+  const salt = kdfInputToBytes(_salt, "salt");
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac2.create(hash, password);
+  const PRFSalt = PRF._cloneInto().update(salt);
+  return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
+}
+function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
+  PRF.destroy();
+  PRFSalt.destroy();
+  if (prfW)
+    prfW.destroy();
+  clean2(u);
+  return DK;
+}
+function pbkdf2(hash, password, salt, opts) {
+  const { c, dkLen, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
+  let prfW;
+  const arr = new Uint8Array(4);
+  const view = createView(arr);
+  const u = new Uint8Array(PRF.outputLen);
+  for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
+    const Ti = DK.subarray(pos, pos + PRF.outputLen);
+    view.setInt32(0, ti, false);
+    (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
+    Ti.set(u.subarray(0, Ti.length));
+    for (let ui = 1; ui < c; ui++) {
+      PRF._cloneInto(prfW).update(u).digestInto(u);
+      for (let i = 0; i < Ti.length; i++)
+        Ti[i] ^= u[i];
+    }
+  }
+  return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
+}
+
 // ../../node_modules/.pnpm/@scure+base@2.0.0/node_modules/@scure/base/index.js
 function isBytes3(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
@@ -11964,8 +12156,8 @@ zone
 zoo`.split("\n");
 
 // ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/utils.js
-var _0n = /* @__PURE__ */ BigInt(0);
-var _1n = /* @__PURE__ */ BigInt(1);
+var _0n2 = /* @__PURE__ */ BigInt(0);
+var _1n2 = /* @__PURE__ */ BigInt(1);
 function abool(value, title = "") {
   if (typeof value !== "boolean") {
     const prefix = title && `"${title}" `;
@@ -11988,7 +12180,7 @@ function numberToHexUnpadded(num) {
 function hexToNumber(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
-  return hex === "" ? _0n : BigInt("0x" + hex);
+  return hex === "" ? _0n2 : BigInt("0x" + hex);
 }
 function bytesToNumberBE(bytes) {
   return hexToNumber(bytesToHex2(bytes));
@@ -12010,7 +12202,7 @@ function numberToBytesLE(n, len) {
 function copyBytes(bytes) {
   return Uint8Array.from(bytes);
 }
-var isPosBig = (n) => typeof n === "bigint" && _0n <= n;
+var isPosBig = (n) => typeof n === "bigint" && _0n2 <= n;
 function inRange(n, min, max) {
   return isPosBig(n) && isPosBig(min) && isPosBig(max) && min <= n && n < max;
 }
@@ -12020,11 +12212,11 @@ function aInRange(title, n, min, max) {
 }
 function bitLen(n) {
   let len;
-  for (len = 0; n > _0n; n >>= _1n, len += 1)
+  for (len = 0; n > _0n2; n >>= _1n2, len += 1)
     ;
   return len;
 }
-var bitMask = (n) => (_1n << BigInt(n)) - _1n;
+var bitMask = (n) => (_1n2 << BigInt(n)) - _1n2;
 function createHmacDrbg(hashLen, qByteLen, hmacFn) {
   anumber2(hashLen, "hashLen");
   anumber2(qByteLen, "qByteLen");
@@ -12104,37 +12296,37 @@ function memoized(fn) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/modular.js
-var _0n2 = /* @__PURE__ */ BigInt(0);
-var _1n2 = /* @__PURE__ */ BigInt(1);
-var _2n = /* @__PURE__ */ BigInt(2);
+var _0n3 = /* @__PURE__ */ BigInt(0);
+var _1n3 = /* @__PURE__ */ BigInt(1);
+var _2n2 = /* @__PURE__ */ BigInt(2);
 var _3n = /* @__PURE__ */ BigInt(3);
 var _4n = /* @__PURE__ */ BigInt(4);
 var _5n = /* @__PURE__ */ BigInt(5);
-var _7n = /* @__PURE__ */ BigInt(7);
+var _7n2 = /* @__PURE__ */ BigInt(7);
 var _8n = /* @__PURE__ */ BigInt(8);
 var _9n = /* @__PURE__ */ BigInt(9);
 var _16n = /* @__PURE__ */ BigInt(16);
 function mod(a, b) {
   const result = a % b;
-  return result >= _0n2 ? result : b + result;
+  return result >= _0n3 ? result : b + result;
 }
 function pow2(x, power, modulo) {
   let res = x;
-  while (power-- > _0n2) {
+  while (power-- > _0n3) {
     res *= res;
     res %= modulo;
   }
   return res;
 }
 function invert(number, modulo) {
-  if (number === _0n2)
+  if (number === _0n3)
     throw new Error("invert: expected non-zero number");
-  if (modulo <= _0n2)
+  if (modulo <= _0n3)
     throw new Error("invert: expected positive modulus, got " + modulo);
   let a = mod(number, modulo);
   let b = modulo;
-  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
-  while (a !== _0n2) {
+  let x = _0n3, y = _1n3, u = _1n3, v = _0n3;
+  while (a !== _0n3) {
     const q = b / a;
     const r = b % a;
     const m = x - u * q;
@@ -12142,7 +12334,7 @@ function invert(number, modulo) {
     b = a, a = r, x = u, y = v, u = m, v = n;
   }
   const gcd2 = b;
-  if (gcd2 !== _1n2)
+  if (gcd2 !== _1n3)
     throw new Error("invert: does not exist");
   return mod(x, modulo);
 }
@@ -12151,17 +12343,17 @@ function assertIsSquare(Fp, root, n) {
     throw new Error("Cannot find square root");
 }
 function sqrt3mod4(Fp, n) {
-  const p1div4 = (Fp.ORDER + _1n2) / _4n;
+  const p1div4 = (Fp.ORDER + _1n3) / _4n;
   const root = Fp.pow(n, p1div4);
   assertIsSquare(Fp, root, n);
   return root;
 }
 function sqrt5mod8(Fp, n) {
   const p5div8 = (Fp.ORDER - _5n) / _8n;
-  const n2 = Fp.mul(n, _2n);
+  const n2 = Fp.mul(n, _2n2);
   const v = Fp.pow(n2, p5div8);
   const nv = Fp.mul(n, v);
-  const i = Fp.mul(Fp.mul(nv, _2n), v);
+  const i = Fp.mul(Fp.mul(nv, _2n2), v);
   const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
   assertIsSquare(Fp, root, n);
   return root;
@@ -12172,7 +12364,7 @@ function sqrt9mod16(P) {
   const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
   const c2 = tn(Fp_, c1);
   const c3 = tn(Fp_, Fp_.neg(c1));
-  const c4 = (P + _7n) / _16n;
+  const c4 = (P + _7n2) / _16n;
   return (Fp, n) => {
     let tv1 = Fp.pow(n, c4);
     let tv2 = Fp.mul(tv1, c1);
@@ -12191,13 +12383,13 @@ function sqrt9mod16(P) {
 function tonelliShanks(P) {
   if (P < _3n)
     throw new Error("sqrt is not defined for small field");
-  let Q = P - _1n2;
+  let Q = P - _1n3;
   let S = 0;
-  while (Q % _2n === _0n2) {
-    Q /= _2n;
+  while (Q % _2n2 === _0n3) {
+    Q /= _2n2;
     S++;
   }
-  let Z = _2n;
+  let Z = _2n2;
   const _Fp = Field(P);
   while (FpLegendre(_Fp, Z) === 1) {
     if (Z++ > 1e3)
@@ -12206,7 +12398,7 @@ function tonelliShanks(P) {
   if (S === 1)
     return sqrt3mod4;
   let cc = _Fp.pow(Z, Q);
-  const Q1div2 = (Q + _1n2) / _2n;
+  const Q1div2 = (Q + _1n3) / _2n2;
   return function tonelliSlow(Fp, n) {
     if (Fp.is0(n))
       return n;
@@ -12227,7 +12419,7 @@ function tonelliShanks(P) {
         if (i === M)
           throw new Error("Cannot find square root");
       }
-      const exponent = _1n2 << BigInt(M - i - 1);
+      const exponent = _1n3 << BigInt(M - i - 1);
       const b = Fp.pow(c, exponent);
       M = i;
       c = Fp.sqr(b);
@@ -12246,7 +12438,7 @@ function FpSqrt(P) {
     return sqrt9mod16(P);
   return tonelliShanks(P);
 }
-var isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n2) === _1n2;
+var isNegativeLE = (num, modulo) => (mod(num, modulo) & _1n3) === _1n3;
 var FIELD_FIELDS = [
   "create",
   "isValid",
@@ -12280,19 +12472,19 @@ function validateField(field) {
   return field;
 }
 function FpPow(Fp, num, power) {
-  if (power < _0n2)
+  if (power < _0n3)
     throw new Error("invalid exponent, negatives unsupported");
-  if (power === _0n2)
+  if (power === _0n3)
     return Fp.ONE;
-  if (power === _1n2)
+  if (power === _1n3)
     return num;
   let p = Fp.ONE;
   let d = num;
-  while (power > _0n2) {
-    if (power & _1n2)
+  while (power > _0n3) {
+    if (power & _1n3)
       p = Fp.mul(p, d);
     d = Fp.sqr(d);
-    power >>= _1n2;
+    power >>= _1n3;
   }
   return p;
 }
@@ -12314,7 +12506,7 @@ function FpInvertBatch(Fp, nums, passZero = false) {
   return inverted;
 }
 function FpLegendre(Fp, n) {
-  const p1mod2 = (Fp.ORDER - _1n2) / _2n;
+  const p1mod2 = (Fp.ORDER - _1n3) / _2n2;
   const powered = Fp.pow(n, p1mod2);
   const yes = Fp.eql(powered, Fp.ONE);
   const zero = Fp.eql(powered, Fp.ZERO);
@@ -12335,14 +12527,14 @@ var _Field = class {
   BITS;
   BYTES;
   isLE;
-  ZERO = _0n2;
-  ONE = _1n2;
+  ZERO = _0n3;
+  ONE = _1n3;
   _lengths;
   _sqrt;
   // cached sqrt
   _mod;
   constructor(ORDER, opts = {}) {
-    if (ORDER <= _0n2)
+    if (ORDER <= _0n3)
       throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
     let _nbitLength = void 0;
     this.isLE = false;
@@ -12373,17 +12565,17 @@ var _Field = class {
   isValid(num) {
     if (typeof num !== "bigint")
       throw new Error("invalid field element: expected bigint, got " + typeof num);
-    return _0n2 <= num && num < this.ORDER;
+    return _0n3 <= num && num < this.ORDER;
   }
   is0(num) {
-    return num === _0n2;
+    return num === _0n3;
   }
   // is valid and invertible
   isValidNot0(num) {
     return !this.is0(num) && this.isValid(num);
   }
   isOdd(num) {
-    return (num & _1n2) === _1n2;
+    return (num & _1n3) === _1n3;
   }
   neg(num) {
     return mod(-num, this.ORDER);
@@ -12486,13 +12678,13 @@ function mapHashToField(key, fieldOrder, isLE2 = false) {
   if (len < 16 || len < minLen || len > 1024)
     throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
   const num = isLE2 ? bytesToNumberLE(key) : bytesToNumberBE(key);
-  const reduced = mod(num, fieldOrder - _1n2) + _1n2;
+  const reduced = mod(num, fieldOrder - _1n3) + _1n3;
   return isLE2 ? numberToBytesLE(reduced, fieldLen) : numberToBytesBE(reduced, fieldLen);
 }
 
 // ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/curve.js
-var _0n3 = /* @__PURE__ */ BigInt(0);
-var _1n3 = /* @__PURE__ */ BigInt(1);
+var _0n4 = /* @__PURE__ */ BigInt(0);
+var _1n4 = /* @__PURE__ */ BigInt(1);
 function negateCt(condition, item) {
   const neg = item.negate();
   return condition ? neg : item;
@@ -12520,7 +12712,7 @@ function calcOffsets(n, window2, wOpts) {
   let nextN = n >> shiftBy;
   if (wbits > windowSize) {
     wbits -= maxNumber;
-    nextN += _1n3;
+    nextN += _1n4;
   }
   const offsetStart = window2 * windowSize;
   const offset = offsetStart + Math.abs(wbits) - 1;
@@ -12536,7 +12728,7 @@ function getW(P) {
   return pointWindowSizes.get(P) || 1;
 }
 function assert0(n) {
-  if (n !== _0n3)
+  if (n !== _0n4)
     throw new Error("invalid wNAF");
 }
 var wNAF = class {
@@ -12554,11 +12746,11 @@ var wNAF = class {
   // non-const time multiplication ladder
   _unsafeLadder(elm, n, p = this.ZERO) {
     let d = elm;
-    while (n > _0n3) {
-      if (n & _1n3)
+    while (n > _0n4) {
+      if (n & _1n4)
         p = p.add(d);
       d = d.double();
-      n >>= _1n3;
+      n >>= _1n4;
     }
     return p;
   }
@@ -12622,7 +12814,7 @@ var wNAF = class {
   wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
     const wo = calcWOpts(W, this.bits);
     for (let window2 = 0; window2 < wo.windows; window2++) {
-      if (n === _0n3)
+      if (n === _0n4)
         break;
       const { nextN, offset, isZero, isNeg } = calcOffsets(n, window2, wo);
       n = nextN;
@@ -12674,14 +12866,14 @@ function mulEndoUnsafe(Point2, point, k1, k2) {
   let acc = point;
   let p1 = Point2.ZERO;
   let p2 = Point2.ZERO;
-  while (k1 > _0n3 || k2 > _0n3) {
-    if (k1 & _1n3)
+  while (k1 > _0n4 || k2 > _0n4) {
+    if (k1 & _1n4)
       p1 = p1.add(acc);
-    if (k2 & _1n3)
+    if (k2 & _1n4)
       p2 = p2.add(acc);
     acc = acc.double();
-    k1 >>= _1n3;
-    k2 >>= _1n3;
+    k1 >>= _1n4;
+    k2 >>= _1n4;
   }
   return { p1, p2 };
 }
@@ -12702,7 +12894,7 @@ function createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
     throw new Error(`expected valid ${type} CURVE object`);
   for (const p of ["p", "n", "h"]) {
     const val = CURVE[p];
-    if (!(typeof val === "bigint" && val > _0n3))
+    if (!(typeof val === "bigint" && val > _0n4))
       throw new Error(`CURVE.${p} must be positive bigint`);
   }
   const Fp = createField(CURVE.p, curveOpts.Fp, FpFnLE);
@@ -12724,21 +12916,21 @@ function createKeygen(randomSecretKey, getPublicKey7) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/weierstrass.js
-var divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n2) / den;
+var divNearest = (num, den) => (num + (num >= 0 ? den : -den) / _2n3) / den;
 function _splitEndoScalar(k, basis, n) {
   const [[a1, b1], [a2, b2]] = basis;
   const c1 = divNearest(b2 * k, n);
   const c2 = divNearest(-b1 * k, n);
   let k1 = k - c1 * a1 - c2 * a2;
   let k2 = -c1 * b1 - c2 * b2;
-  const k1neg = k1 < _0n4;
-  const k2neg = k2 < _0n4;
+  const k1neg = k1 < _0n5;
+  const k2neg = k2 < _0n5;
   if (k1neg)
     k1 = -k1;
   if (k2neg)
     k2 = -k2;
-  const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n4;
-  if (k1 < _0n4 || k1 >= MAX_NUM || k2 < _0n4 || k2 >= MAX_NUM) {
+  const MAX_NUM = bitMask(Math.ceil(bitLen(n) / 2)) + _1n5;
+  if (k1 < _0n5 || k1 >= MAX_NUM || k2 < _0n5 || k2 >= MAX_NUM) {
     throw new Error("splitScalar (endomorphism): failed, k=" + k);
   }
   return { k1neg, k1, k2neg, k2 };
@@ -12826,7 +13018,7 @@ var DER = {
   _int: {
     encode(num) {
       const { Err: E } = DER;
-      if (num < _0n4)
+      if (num < _0n5)
         throw new E("integer: negative integers are not allowed");
       let hex = numberToHexUnpadded(num);
       if (Number.parseInt(hex[0], 16) & 8)
@@ -12864,9 +13056,9 @@ var DER = {
     return tlv.encode(48, seq);
   }
 };
-var _0n4 = BigInt(0);
-var _1n4 = BigInt(1);
-var _2n2 = BigInt(2);
+var _0n5 = BigInt(0);
+var _1n5 = BigInt(1);
+var _2n3 = BigInt(2);
 var _3n2 = BigInt(3);
 var _4n2 = BigInt(4);
 function weierstrass(params, extraOpts = {}) {
@@ -13232,9 +13424,9 @@ function weierstrass(params, extraOpts = {}) {
       const p = this;
       if (!Fn2.isValid(sc))
         throw new Error("invalid scalar: out of range");
-      if (sc === _0n4 || p.is0())
+      if (sc === _0n5 || p.is0())
         return Point2.ZERO;
-      if (sc === _1n4)
+      if (sc === _1n5)
         return p;
       if (wnaf.hasCache(this))
         return this.multiply(sc);
@@ -13259,7 +13451,7 @@ function weierstrass(params, extraOpts = {}) {
      */
     isTorsionFree() {
       const { isTorsionFree } = extraOpts;
-      if (cofactor === _1n4)
+      if (cofactor === _1n5)
         return true;
       if (isTorsionFree)
         return isTorsionFree(Point2, this);
@@ -13267,7 +13459,7 @@ function weierstrass(params, extraOpts = {}) {
     }
     clearCofactor() {
       const { clearCofactor } = extraOpts;
-      if (cofactor === _1n4)
+      if (cofactor === _1n5)
         return this;
       if (clearCofactor)
         return clearCofactor(Point2, this);
@@ -13383,9 +13575,9 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
     format: "compact",
     extraEntropy: false
   };
-  const hasLargeCofactor = CURVE_ORDER * _2n2 < Fp.ORDER;
+  const hasLargeCofactor = CURVE_ORDER * _2n3 < Fp.ORDER;
   function isBiggerThanHalfOrder(number) {
-    const HALF = CURVE_ORDER >> _1n4;
+    const HALF = CURVE_ORDER >> _1n5;
     return number > HALF;
   }
   function validateRS(title, num) {
@@ -13498,7 +13690,7 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
   };
   const ORDER_MASK = bitMask(fnBits);
   function int2octets(num) {
-    aInRange("num < 2^" + fnBits, num, _0n4, ORDER_MASK);
+    aInRange("num < 2^" + fnBits, num, _0n5, ORDER_MASK);
     return Fn2.toBytes(num);
   }
   function validateMsgAndHash(message, prehash) {
@@ -13526,12 +13718,12 @@ function ecdsa(Point2, hash, ecdsaOpts = {}) {
       const ik = Fn2.inv(k);
       const q = Point2.BASE.multiply(k).toAffine();
       const r = Fn2.create(q.x);
-      if (r === _0n4)
+      if (r === _0n5)
         return;
       const s = Fn2.create(ik * Fn2.create(m + r * d));
-      if (s === _0n4)
+      if (s === _0n5)
         return;
-      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n4);
+      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n5);
       let normS = s;
       if (lowS && isBiggerThanHalfOrder(s)) {
         normS = Fn2.neg(s);
@@ -13612,7 +13804,7 @@ var secp256k1_ENDO = {
     [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
   ]
 };
-var _2n3 = /* @__PURE__ */ BigInt(2);
+var _2n4 = /* @__PURE__ */ BigInt(2);
 function sqrtMod(y) {
   const P = secp256k1_CURVE.p;
   const _3n5 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
@@ -13621,7 +13813,7 @@ function sqrtMod(y) {
   const b3 = b2 * b2 * y % P;
   const b6 = pow2(b3, _3n5, P) * b3 % P;
   const b9 = pow2(b6, _3n5, P) * b3 % P;
-  const b11 = pow2(b9, _2n3, P) * b2 % P;
+  const b11 = pow2(b9, _2n4, P) * b2 % P;
   const b22 = pow2(b11, _11n, P) * b11 % P;
   const b44 = pow2(b22, _22n, P) * b22 % P;
   const b88 = pow2(b44, _44n, P) * b44 % P;
@@ -13630,7 +13822,7 @@ function sqrtMod(y) {
   const b223 = pow2(b220, _3n5, P) * b3 % P;
   const t1 = pow2(b223, _23n, P) * b22 % P;
   const t2 = pow2(t1, _6n, P) * b2 % P;
-  const root = pow2(t2, _2n3, P);
+  const root = pow2(t2, _2n4, P);
   if (!Fpk1.eql(Fpk1.sqr(root), y))
     throw new Error("Cannot find square root");
   return root;
@@ -13995,6 +14187,56 @@ var HDKey = class _HDKey {
 
 // ../core/dist/index.js
 import { getPublicKey as getPublicKey5 } from "nostr-tools/pure";
+function hexToBytes3(hex) {
+  const clean3 = hex.startsWith("0x") ? hex.slice(2) : hex;
+  if (clean3.length % 2 !== 0 || !/^[0-9a-fA-F]*$/.test(clean3)) {
+    throw new Error(`Invalid hex string: ${hex}`);
+  }
+  return hexToBytes2(clean3);
+}
+function concatBytes3(...parts) {
+  let len = 0;
+  for (const p of parts) len += p.length;
+  const out = new Uint8Array(len);
+  let o = 0;
+  for (const p of parts) {
+    out.set(p, o);
+    o += p.length;
+  }
+  return out;
+}
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let zeros = 0;
+  for (let i = 0; i < bytes.length && bytes[i] === 0; i++) zeros++;
+  let value = 0n;
+  for (const byte of bytes) {
+    value = value * 256n + BigInt(byte);
+  }
+  let result = "";
+  while (value > 0n) {
+    result = BASE58_ALPHABET[Number(value % 58n)] + result;
+    value = value / 58n;
+  }
+  for (let i = 0; i < zeros; i++) {
+    result = "1" + result;
+  }
+  return result || "1";
+}
+var MINA_PRIVATE_KEY_VERSION = 90;
+function hexToMinaBase58PrivateKey(privateKey) {
+  if (!/^(0x)?[0-9a-fA-F]{64}$/.test(privateKey)) {
+    return privateKey;
+  }
+  const beScalar = hexToBytes3(privateKey);
+  const leScalar = Uint8Array.from(beScalar).reverse();
+  const payload = concatBytes3(
+    Uint8Array.from([MINA_PRIVATE_KEY_VERSION, 1]),
+    leScalar
+  );
+  const checksum2 = sha2562(sha2562(payload)).slice(0, 4);
+  return base58Encode(concatBytes3(payload, checksum2));
+}
 var ILP_TO_SEMANTIC = Object.freeze({
   T00: "internal_error",
   T04: "insufficient_funds",
@@ -14312,11 +14554,27 @@ function writeHsConnectorConfig(configDir, config, options = {}) {
     } catch {
     }
   }
+  const apexEvmKey = options.apexSettlementKeys?.evmPrivateKeyHex;
+  const apexSolanaKey = options.apexSettlementKeys?.solanaPrivateKeyBase58;
+  const apexMinaKey = options.apexSettlementKeys?.minaPrivateKeyBase58;
   const derived = resolveConfigNetworkProfile(
     config,
-    DEFAULT_HS_CHAIN_PROVIDERS[0]?.keyId
+    apexEvmKey ?? DEFAULT_HS_CHAIN_PROVIDERS[0]?.keyId
   ).chainProviders;
-  const hsConfig = derived.length > 0 ? { ...config, chainProviders: derived } : { ...config, chainProviders: [...DEFAULT_HS_CHAIN_PROVIDERS] };
+  const fillApexKey = (providers) => providers.map((p) => {
+    if (p.keyId) return p;
+    if (p.chainType === "evm" && apexEvmKey) {
+      return { ...p, keyId: apexEvmKey };
+    }
+    if (p.chainType === "solana" && apexSolanaKey) {
+      return { ...p, keyId: apexSolanaKey };
+    }
+    if (p.chainType === "mina" && apexMinaKey) {
+      return { ...p, keyId: apexMinaKey };
+    }
+    return p;
+  });
+  const hsConfig = derived.length > 0 ? { ...config, chainProviders: fillApexKey(derived) } : { ...config, chainProviders: [...DEFAULT_HS_CHAIN_PROVIDERS] };
   const generator = new ConnectorConfigGenerator(hsConfig);
   const baseConfig = generator.generate([]);
   const HS_LOCAL_SOCKS_PROXY = "socks5h://127.0.0.1:9050";
@@ -15148,33 +15406,33 @@ async function readImageManifest(path) {
 import { getPublicKey as getPublicKey6 } from "nostr-tools/pure";
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/sha3.js
-var _0n5 = BigInt(0);
-var _1n5 = BigInt(1);
-var _2n4 = BigInt(2);
-var _7n2 = BigInt(7);
-var _256n = BigInt(256);
-var _0x71n = BigInt(113);
-var SHA3_PI = [];
-var SHA3_ROTL = [];
-var _SHA3_IOTA = [];
-for (let round = 0, R = _1n5, x = 1, y = 0; round < 24; round++) {
+var _0n6 = BigInt(0);
+var _1n6 = BigInt(1);
+var _2n5 = BigInt(2);
+var _7n3 = BigInt(7);
+var _256n2 = BigInt(256);
+var _0x71n2 = BigInt(113);
+var SHA3_PI2 = [];
+var SHA3_ROTL2 = [];
+var _SHA3_IOTA2 = [];
+for (let round = 0, R = _1n6, x = 1, y = 0; round < 24; round++) {
   [x, y] = [y, (2 * x + 3 * y) % 5];
-  SHA3_PI.push(2 * (5 * y + x));
-  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
-  let t = _0n5;
+  SHA3_PI2.push(2 * (5 * y + x));
+  SHA3_ROTL2.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n6;
   for (let j = 0; j < 7; j++) {
-    R = (R << _1n5 ^ (R >> _7n2) * _0x71n) % _256n;
-    if (R & _2n4)
-      t ^= _1n5 << (_1n5 << /* @__PURE__ */ BigInt(j)) - _1n5;
+    R = (R << _1n6 ^ (R >> _7n3) * _0x71n2) % _256n2;
+    if (R & _2n5)
+      t ^= _1n6 << (_1n6 << /* @__PURE__ */ BigInt(j)) - _1n6;
   }
-  _SHA3_IOTA.push(t);
-}
-var IOTAS = split(_SHA3_IOTA, true);
-var SHA3_IOTA_H = IOTAS[0];
-var SHA3_IOTA_L = IOTAS[1];
-var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
-var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
-function keccakP(s, rounds = 24) {
+  _SHA3_IOTA2.push(t);
+}
+var IOTAS2 = split(_SHA3_IOTA2, true);
+var SHA3_IOTA_H2 = IOTAS2[0];
+var SHA3_IOTA_L2 = IOTAS2[1];
+var rotlH2 = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+var rotlL2 = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP2(s, rounds = 24) {
   const B = new Uint32Array(5 * 2);
   for (let round = 24 - rounds; round < 24; round++) {
     for (let x = 0; x < 10; x++)
@@ -15184,8 +15442,8 @@ function keccakP(s, rounds = 24) {
       const idx0 = (x + 2) % 10;
       const B0 = B[idx0];
       const B1 = B[idx0 + 1];
-      const Th = rotlH(B0, B1, 1) ^ B[idx1];
-      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      const Th = rotlH2(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL2(B0, B1, 1) ^ B[idx1 + 1];
       for (let y = 0; y < 50; y += 10) {
         s[x + y] ^= Th;
         s[x + y + 1] ^= Tl;
@@ -15194,10 +15452,10 @@ function keccakP(s, rounds = 24) {
     let curH = s[2];
     let curL = s[3];
     for (let t = 0; t < 24; t++) {
-      const shift = SHA3_ROTL[t];
-      const Th = rotlH(curH, curL, shift);
-      const Tl = rotlL(curH, curL, shift);
-      const PI = SHA3_PI[t];
+      const shift = SHA3_ROTL2[t];
+      const Th = rotlH2(curH, curL, shift);
+      const Tl = rotlL2(curH, curL, shift);
+      const PI = SHA3_PI2[t];
       curH = s[PI];
       curL = s[PI + 1];
       s[PI] = Th;
@@ -15209,12 +15467,12 @@ function keccakP(s, rounds = 24) {
       for (let x = 0; x < 10; x++)
         s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
     }
-    s[0] ^= SHA3_IOTA_H[round];
-    s[1] ^= SHA3_IOTA_L[round];
+    s[0] ^= SHA3_IOTA_H2[round];
+    s[1] ^= SHA3_IOTA_L2[round];
   }
   clean(B);
 }
-var Keccak = class _Keccak extends Hash {
+var Keccak2 = class _Keccak extends Hash {
   // NOTE: we accept arguments in bytes instead of bits here.
   constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
     super();
@@ -15239,7 +15497,7 @@ var Keccak = class _Keccak extends Hash {
   }
   keccak() {
     swap32IfBE(this.state32);
-    keccakP(this.state32, this.rounds);
+    keccakP2(this.state32, this.rounds);
     swap32IfBE(this.state32);
     this.posOut = 0;
     this.pos = 0;
@@ -15325,12 +15583,12 @@ var Keccak = class _Keccak extends Hash {
     return to;
   }
 };
-var gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak(blockLen, suffix, outputLen));
-var keccak_256 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
+var gen = (suffix, blockLen, outputLen) => createHasher(() => new Keccak2(blockLen, suffix, outputLen));
+var keccak_2562 = /* @__PURE__ */ (() => gen(1, 136, 256 / 8))();
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/utils.js
-var _0n6 = /* @__PURE__ */ BigInt(0);
-var _1n6 = /* @__PURE__ */ BigInt(1);
+var _0n7 = /* @__PURE__ */ BigInt(0);
+var _1n7 = /* @__PURE__ */ BigInt(1);
 function _abool2(value, title = "") {
   if (typeof value !== "boolean") {
     const prefix = title && `"${title}"`;
@@ -15357,7 +15615,7 @@ function numberToHexUnpadded2(num) {
 function hexToNumber2(hex) {
   if (typeof hex !== "string")
     throw new Error("hex string expected, got " + typeof hex);
-  return hex === "" ? _0n6 : BigInt("0x" + hex);
+  return hex === "" ? _0n7 : BigInt("0x" + hex);
 }
 function bytesToNumberBE2(bytes) {
   return hexToNumber2(bytesToHex(bytes));
@@ -15390,7 +15648,7 @@ function ensureBytes(title, hex, expectedLength) {
     throw new Error(title + " of length " + expectedLength + " expected, got " + len);
   return res;
 }
-var isPosBig2 = (n) => typeof n === "bigint" && _0n6 <= n;
+var isPosBig2 = (n) => typeof n === "bigint" && _0n7 <= n;
 function inRange2(n, min, max) {
   return isPosBig2(n) && isPosBig2(min) && isPosBig2(max) && min <= n && n < max;
 }
@@ -15400,11 +15658,11 @@ function aInRange2(title, n, min, max) {
 }
 function bitLen2(n) {
   let len;
-  for (len = 0; n > _0n6; n >>= _1n6, len += 1)
+  for (len = 0; n > _0n7; n >>= _1n7, len += 1)
     ;
   return len;
 }
-var bitMask2 = (n) => (_1n6 << BigInt(n)) - _1n6;
+var bitMask2 = (n) => (_1n7 << BigInt(n)) - _1n7;
 function createHmacDrbg2(hashLen, qByteLen, hmacFn) {
   if (typeof hashLen !== "number" || hashLen < 2)
     throw new Error("hashLen must be a number");
@@ -15482,37 +15740,37 @@ function memoized2(fn) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/modular.js
-var _0n7 = BigInt(0);
-var _1n7 = BigInt(1);
-var _2n5 = /* @__PURE__ */ BigInt(2);
+var _0n8 = BigInt(0);
+var _1n8 = BigInt(1);
+var _2n6 = /* @__PURE__ */ BigInt(2);
 var _3n3 = /* @__PURE__ */ BigInt(3);
 var _4n3 = /* @__PURE__ */ BigInt(4);
 var _5n2 = /* @__PURE__ */ BigInt(5);
-var _7n3 = /* @__PURE__ */ BigInt(7);
+var _7n4 = /* @__PURE__ */ BigInt(7);
 var _8n2 = /* @__PURE__ */ BigInt(8);
 var _9n2 = /* @__PURE__ */ BigInt(9);
 var _16n2 = /* @__PURE__ */ BigInt(16);
 function mod2(a, b) {
   const result = a % b;
-  return result >= _0n7 ? result : b + result;
+  return result >= _0n8 ? result : b + result;
 }
 function pow22(x, power, modulo) {
   let res = x;
-  while (power-- > _0n7) {
+  while (power-- > _0n8) {
     res *= res;
     res %= modulo;
   }
   return res;
 }
 function invert2(number, modulo) {
-  if (number === _0n7)
+  if (number === _0n8)
     throw new Error("invert: expected non-zero number");
-  if (modulo <= _0n7)
+  if (modulo <= _0n8)
     throw new Error("invert: expected positive modulus, got " + modulo);
   let a = mod2(number, modulo);
   let b = modulo;
-  let x = _0n7, y = _1n7, u = _1n7, v = _0n7;
-  while (a !== _0n7) {
+  let x = _0n8, y = _1n8, u = _1n8, v = _0n8;
+  while (a !== _0n8) {
     const q = b / a;
     const r = b % a;
     const m = x - u * q;
@@ -15520,7 +15778,7 @@ function invert2(number, modulo) {
     b = a, a = r, x = u, y = v, u = m, v = n;
   }
   const gcd2 = b;
-  if (gcd2 !== _1n7)
+  if (gcd2 !== _1n8)
     throw new Error("invert: does not exist");
   return mod2(x, modulo);
 }
@@ -15529,17 +15787,17 @@ function assertIsSquare2(Fp, root, n) {
     throw new Error("Cannot find square root");
 }
 function sqrt3mod42(Fp, n) {
-  const p1div4 = (Fp.ORDER + _1n7) / _4n3;
+  const p1div4 = (Fp.ORDER + _1n8) / _4n3;
   const root = Fp.pow(n, p1div4);
   assertIsSquare2(Fp, root, n);
   return root;
 }
 function sqrt5mod82(Fp, n) {
   const p5div8 = (Fp.ORDER - _5n2) / _8n2;
-  const n2 = Fp.mul(n, _2n5);
+  const n2 = Fp.mul(n, _2n6);
   const v = Fp.pow(n2, p5div8);
   const nv = Fp.mul(n, v);
-  const i = Fp.mul(Fp.mul(nv, _2n5), v);
+  const i = Fp.mul(Fp.mul(nv, _2n6), v);
   const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
   assertIsSquare2(Fp, root, n);
   return root;
@@ -15550,7 +15808,7 @@ function sqrt9mod162(P) {
   const c1 = tn(Fp_, Fp_.neg(Fp_.ONE));
   const c2 = tn(Fp_, c1);
   const c3 = tn(Fp_, Fp_.neg(c1));
-  const c4 = (P + _7n3) / _16n2;
+  const c4 = (P + _7n4) / _16n2;
   return (Fp, n) => {
     let tv1 = Fp.pow(n, c4);
     let tv2 = Fp.mul(tv1, c1);
@@ -15569,13 +15827,13 @@ function sqrt9mod162(P) {
 function tonelliShanks2(P) {
   if (P < _3n3)
     throw new Error("sqrt is not defined for small field");
-  let Q = P - _1n7;
+  let Q = P - _1n8;
   let S = 0;
-  while (Q % _2n5 === _0n7) {
-    Q /= _2n5;
+  while (Q % _2n6 === _0n8) {
+    Q /= _2n6;
     S++;
   }
-  let Z = _2n5;
+  let Z = _2n6;
   const _Fp = Field2(P);
   while (FpLegendre2(_Fp, Z) === 1) {
     if (Z++ > 1e3)
@@ -15584,7 +15842,7 @@ function tonelliShanks2(P) {
   if (S === 1)
     return sqrt3mod42;
   let cc = _Fp.pow(Z, Q);
-  const Q1div2 = (Q + _1n7) / _2n5;
+  const Q1div2 = (Q + _1n8) / _2n6;
   return function tonelliSlow(Fp, n) {
     if (Fp.is0(n))
       return n;
@@ -15605,7 +15863,7 @@ function tonelliShanks2(P) {
         if (i === M)
           throw new Error("Cannot find square root");
       }
-      const exponent = _1n7 << BigInt(M - i - 1);
+      const exponent = _1n8 << BigInt(M - i - 1);
       const b = Fp.pow(c, exponent);
       M = i;
       c = Fp.sqr(b);
@@ -15658,19 +15916,19 @@ function validateField2(field) {
   return field;
 }
 function FpPow2(Fp, num, power) {
-  if (power < _0n7)
+  if (power < _0n8)
     throw new Error("invalid exponent, negatives unsupported");
-  if (power === _0n7)
+  if (power === _0n8)
     return Fp.ONE;
-  if (power === _1n7)
+  if (power === _1n8)
     return num;
   let p = Fp.ONE;
   let d = num;
-  while (power > _0n7) {
-    if (power & _1n7)
+  while (power > _0n8) {
+    if (power & _1n8)
       p = Fp.mul(p, d);
     d = Fp.sqr(d);
-    power >>= _1n7;
+    power >>= _1n8;
   }
   return p;
 }
@@ -15692,7 +15950,7 @@ function FpInvertBatch2(Fp, nums, passZero = false) {
   return inverted;
 }
 function FpLegendre2(Fp, n) {
-  const p1mod2 = (Fp.ORDER - _1n7) / _2n5;
+  const p1mod2 = (Fp.ORDER - _1n8) / _2n6;
   const powered = Fp.pow(n, p1mod2);
   const yes = Fp.eql(powered, Fp.ONE);
   const zero = Fp.eql(powered, Fp.ZERO);
@@ -15709,7 +15967,7 @@ function nLength2(n, nBitLength) {
   return { nBitLength: _nBitLength, nByteLength };
 }
 function Field2(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
-  if (ORDER <= _0n7)
+  if (ORDER <= _0n8)
     throw new Error("invalid field: expected ORDER > 0, got " + ORDER);
   let _nbitLength = void 0;
   let _sqrt = void 0;
@@ -15744,19 +16002,19 @@ function Field2(ORDER, bitLenOrOpts, isLE2 = false, opts = {}) {
     BITS,
     BYTES,
     MASK: bitMask2(BITS),
-    ZERO: _0n7,
-    ONE: _1n7,
+    ZERO: _0n8,
+    ONE: _1n8,
     allowedLengths,
     create: (num) => mod2(num, ORDER),
     isValid: (num) => {
       if (typeof num !== "bigint")
         throw new Error("invalid field element: expected bigint, got " + typeof num);
-      return _0n7 <= num && num < ORDER;
+      return _0n8 <= num && num < ORDER;
     },
-    is0: (num) => num === _0n7,
+    is0: (num) => num === _0n8,
     // is valid and invertible
     isValidNot0: (num) => !f.is0(num) && f.isValid(num),
-    isOdd: (num) => (num & _1n7) === _1n7,
+    isOdd: (num) => (num & _1n8) === _1n8,
     neg: (num) => mod2(-num, ORDER),
     eql: (lhs, rhs) => lhs === rhs,
     sqr: (num) => mod2(num * num, ORDER),
@@ -15822,13 +16080,13 @@ function mapHashToField2(key, fieldOrder, isLE2 = false) {
   if (len < 16 || len < minLen || len > 1024)
     throw new Error("expected " + minLen + "-1024 bytes of input, got " + len);
   const num = isLE2 ? bytesToNumberLE2(key) : bytesToNumberBE2(key);
-  const reduced = mod2(num, fieldOrder - _1n7) + _1n7;
+  const reduced = mod2(num, fieldOrder - _1n8) + _1n8;
   return isLE2 ? numberToBytesLE2(reduced, fieldLen) : numberToBytesBE2(reduced, fieldLen);
 }
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/curve.js
-var _0n8 = BigInt(0);
-var _1n8 = BigInt(1);
+var _0n9 = BigInt(0);
+var _1n9 = BigInt(1);
 function negateCt2(condition, item) {
   const neg = item.negate();
   return condition ? neg : item;
@@ -15856,7 +16114,7 @@ function calcOffsets2(n, window2, wOpts) {
   let nextN = n >> shiftBy;
   if (wbits > windowSize) {
     wbits -= maxNumber;
-    nextN += _1n8;
+    nextN += _1n9;
   }
   const offsetStart = window2 * windowSize;
   const offset = offsetStart + Math.abs(wbits) - 1;
@@ -15888,7 +16146,7 @@ function getW2(P) {
   return pointWindowSizes2.get(P) || 1;
 }
 function assert02(n) {
-  if (n !== _0n8)
+  if (n !== _0n9)
     throw new Error("invalid wNAF");
 }
 var wNAF2 = class {
@@ -15902,11 +16160,11 @@ var wNAF2 = class {
   // non-const time multiplication ladder
   _unsafeLadder(elm, n, p = this.ZERO) {
     let d = elm;
-    while (n > _0n8) {
-      if (n & _1n8)
+    while (n > _0n9) {
+      if (n & _1n9)
         p = p.add(d);
       d = d.double();
-      n >>= _1n8;
+      n >>= _1n9;
     }
     return p;
   }
@@ -15970,7 +16228,7 @@ var wNAF2 = class {
   wNAFUnsafe(W, precomputes, n, acc = this.ZERO) {
     const wo = calcWOpts2(W, this.bits);
     for (let window2 = 0; window2 < wo.windows; window2++) {
-      if (n === _0n8)
+      if (n === _0n9)
         break;
       const { nextN, offset, isZero, isNeg } = calcOffsets2(n, window2, wo);
       n = nextN;
@@ -16022,14 +16280,14 @@ function mulEndoUnsafe2(Point2, point, k1, k2) {
   let acc = point;
   let p1 = Point2.ZERO;
   let p2 = Point2.ZERO;
-  while (k1 > _0n8 || k2 > _0n8) {
-    if (k1 & _1n8)
+  while (k1 > _0n9 || k2 > _0n9) {
+    if (k1 & _1n9)
       p1 = p1.add(acc);
-    if (k2 & _1n8)
+    if (k2 & _1n9)
       p2 = p2.add(acc);
     acc = acc.double();
-    k1 >>= _1n8;
-    k2 >>= _1n8;
+    k1 >>= _1n9;
+    k2 >>= _1n9;
   }
   return { p1, p2 };
 }
@@ -16089,7 +16347,7 @@ function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
     throw new Error(`expected valid ${type} CURVE object`);
   for (const p of ["p", "n", "h"]) {
     const val = CURVE[p];
-    if (!(typeof val === "bigint" && val > _0n8))
+    if (!(typeof val === "bigint" && val > _0n9))
       throw new Error(`CURVE.${p} must be positive bigint`);
   }
   const Fp = createField2(CURVE.p, curveOpts.Fp, FpFnLE);
@@ -16105,21 +16363,21 @@ function _createCurveFields(type, CURVE, curveOpts = {}, FpFnLE) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/abstract/weierstrass.js
-var divNearest2 = (num, den) => (num + (num >= 0 ? den : -den) / _2n6) / den;
+var divNearest2 = (num, den) => (num + (num >= 0 ? den : -den) / _2n7) / den;
 function _splitEndoScalar2(k, basis, n) {
   const [[a1, b1], [a2, b2]] = basis;
   const c1 = divNearest2(b2 * k, n);
   const c2 = divNearest2(-b1 * k, n);
   let k1 = k - c1 * a1 - c2 * a2;
   let k2 = -c1 * b1 - c2 * b2;
-  const k1neg = k1 < _0n9;
-  const k2neg = k2 < _0n9;
+  const k1neg = k1 < _0n10;
+  const k2neg = k2 < _0n10;
   if (k1neg)
     k1 = -k1;
   if (k2neg)
     k2 = -k2;
-  const MAX_NUM = bitMask2(Math.ceil(bitLen2(n) / 2)) + _1n9;
-  if (k1 < _0n9 || k1 >= MAX_NUM || k2 < _0n9 || k2 >= MAX_NUM) {
+  const MAX_NUM = bitMask2(Math.ceil(bitLen2(n) / 2)) + _1n10;
+  if (k1 < _0n10 || k1 >= MAX_NUM || k2 < _0n10 || k2 >= MAX_NUM) {
     throw new Error("splitScalar (endomorphism): failed, k=" + k);
   }
   return { k1neg, k1, k2neg, k2 };
@@ -16207,7 +16465,7 @@ var DER2 = {
   _int: {
     encode(num) {
       const { Err: E } = DER2;
-      if (num < _0n9)
+      if (num < _0n10)
         throw new E("integer: negative integers are not allowed");
       let hex = numberToHexUnpadded2(num);
       if (Number.parseInt(hex[0], 16) & 8)
@@ -16245,9 +16503,9 @@ var DER2 = {
     return tlv.encode(48, seq);
   }
 };
-var _0n9 = BigInt(0);
-var _1n9 = BigInt(1);
-var _2n6 = BigInt(2);
+var _0n10 = BigInt(0);
+var _1n10 = BigInt(1);
+var _2n7 = BigInt(2);
 var _3n4 = BigInt(3);
 var _4n4 = BigInt(4);
 function _normFnElement(Fn2, key) {
@@ -16619,9 +16877,9 @@ function weierstrassN(params, extraOpts = {}) {
       const p = this;
       if (!Fn2.isValid(sc))
         throw new Error("invalid scalar: out of range");
-      if (sc === _0n9 || p.is0())
+      if (sc === _0n10 || p.is0())
         return Point2.ZERO;
-      if (sc === _1n9)
+      if (sc === _1n10)
         return p;
       if (wnaf.hasCache(this))
         return this.multiply(sc);
@@ -16650,7 +16908,7 @@ function weierstrassN(params, extraOpts = {}) {
      */
     isTorsionFree() {
       const { isTorsionFree } = extraOpts;
-      if (cofactor === _1n9)
+      if (cofactor === _1n10)
         return true;
       if (isTorsionFree)
         return isTorsionFree(Point2, this);
@@ -16658,7 +16916,7 @@ function weierstrassN(params, extraOpts = {}) {
     }
     clearCofactor() {
       const { clearCofactor } = extraOpts;
-      if (cofactor === _1n9)
+      if (cofactor === _1n10)
         return this;
       if (clearCofactor)
         return clearCofactor(Point2, this);
@@ -16816,7 +17074,7 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
   };
   const defaultSigOpts_format = "compact";
   function isBiggerThanHalfOrder(number) {
-    const HALF = CURVE_ORDER >> _1n9;
+    const HALF = CURVE_ORDER >> _1n10;
     return number > HALF;
   }
   function validateRS(title, num) {
@@ -16866,7 +17124,7 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
       const { r, s, recovery: rec } = this;
       if (rec == null || ![0, 1, 2, 3].includes(rec))
         throw new Error("recovery id invalid");
-      const hasCofactor = CURVE_ORDER * _2n6 < FIELD_ORDER;
+      const hasCofactor = CURVE_ORDER * _2n7 < FIELD_ORDER;
       if (hasCofactor && rec > 1)
         throw new Error("recovery id is ambiguous for h>1 curve");
       const radj = rec === 2 || rec === 3 ? r + CURVE_ORDER : r;
@@ -16941,7 +17199,7 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
   };
   const ORDER_MASK = bitMask2(fnBits);
   function int2octets(num) {
-    aInRange2("num < 2^" + fnBits, num, _0n9, ORDER_MASK);
+    aInRange2("num < 2^" + fnBits, num, _0n10, ORDER_MASK);
     return Fn2.toBytes(num);
   }
   function validateMsgAndHash(message, prehash) {
@@ -16969,12 +17227,12 @@ function ecdsa2(Point2, hash, ecdsaOpts = {}) {
       const ik = Fn2.inv(k);
       const q = Point2.BASE.multiply(k).toAffine();
       const r = Fn2.create(q.x);
-      if (r === _0n9)
+      if (r === _0n10)
         return;
       const s = Fn2.create(ik * Fn2.create(m + r * d));
-      if (s === _0n9)
+      if (s === _0n10)
         return;
-      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n9);
+      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n10);
       let normS = s;
       if (lowS && isBiggerThanHalfOrder(s)) {
         normS = Fn2.neg(s);
@@ -17141,7 +17399,7 @@ var secp256k1_ENDO2 = {
     [BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"), BigInt("0x3086d221a7d46bcde86c90e49284eb15")]
   ]
 };
-var _2n7 = /* @__PURE__ */ BigInt(2);
+var _2n8 = /* @__PURE__ */ BigInt(2);
 function sqrtMod2(y) {
   const P = secp256k1_CURVE2.p;
   const _3n5 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
@@ -17150,7 +17408,7 @@ function sqrtMod2(y) {
   const b3 = b2 * b2 * y % P;
   const b6 = pow22(b3, _3n5, P) * b3 % P;
   const b9 = pow22(b6, _3n5, P) * b3 % P;
-  const b11 = pow22(b9, _2n7, P) * b2 % P;
+  const b11 = pow22(b9, _2n8, P) * b2 % P;
   const b22 = pow22(b11, _11n, P) * b11 % P;
   const b44 = pow22(b22, _22n, P) * b22 % P;
   const b88 = pow22(b44, _44n, P) * b44 % P;
@@ -17159,7 +17417,7 @@ function sqrtMod2(y) {
   const b223 = pow22(b220, _3n5, P) * b3 % P;
   const t1 = pow22(b223, _23n, P) * b22 % P;
   const t2 = pow22(t1, _6n, P) * b2 % P;
-  const root = pow22(t2, _2n7, P);
+  const root = pow22(t2, _2n8, P);
   if (!Fpk12.eql(Fpk12.sqr(root), y))
     throw new Error("Cannot find square root");
   return root;
@@ -17274,9 +17532,9 @@ async function deleteArweaveJwkFromCache(path, nodeType) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/abstract/edwards.js
-var _0n10 = BigInt(0);
-var _1n10 = BigInt(1);
-var _2n8 = BigInt(2);
+var _0n11 = BigInt(0);
+var _1n11 = BigInt(1);
+var _2n9 = BigInt(2);
 var _8n3 = BigInt(8);
 function isEdValidXY(Fp, CURVE, x, y) {
   const x2 = Fp.sqr(x);
@@ -17291,19 +17549,19 @@ function edwards(params, extraOpts = {}) {
   let CURVE = validated.CURVE;
   const { h: cofactor } = CURVE;
   validateObject(extraOpts, {}, { uvRatio: "function" });
-  const MASK = _2n8 << BigInt(Fn2.BYTES * 8) - _1n10;
+  const MASK = _2n9 << BigInt(Fn2.BYTES * 8) - _1n11;
   const modP = (n) => Fp.create(n);
   const uvRatio2 = extraOpts.uvRatio || ((u, v) => {
     try {
       return { isValid: true, value: Fp.sqrt(Fp.div(u, v)) };
     } catch (e) {
-      return { isValid: false, value: _0n10 };
+      return { isValid: false, value: _0n11 };
     }
   });
   if (!isEdValidXY(Fp, CURVE, CURVE.Gx, CURVE.Gy))
     throw new Error("bad curve params: generator point");
   function acoord(title, n, banZero = false) {
-    const min = banZero ? _1n10 : _0n10;
+    const min = banZero ? _1n11 : _0n11;
     aInRange("coordinate " + title, n, min, MASK);
     return n;
   }
@@ -17320,8 +17578,8 @@ function edwards(params, extraOpts = {}) {
     const y = modP(Y * iz);
     const zz = Fp.mul(Z, iz);
     if (is0)
-      return { x: _0n10, y: _1n10 };
-    if (zz !== _1n10)
+      return { x: _0n11, y: _1n11 };
+    if (zz !== _1n11)
       throw new Error("invZ was invalid");
     return { x, y };
   });
@@ -17347,9 +17605,9 @@ function edwards(params, extraOpts = {}) {
   });
   class Point2 {
     // base / generator point
-    static BASE = new Point2(CURVE.Gx, CURVE.Gy, _1n10, modP(CURVE.Gx * CURVE.Gy));
+    static BASE = new Point2(CURVE.Gx, CURVE.Gy, _1n11, modP(CURVE.Gx * CURVE.Gy));
     // zero / infinity / identity point
-    static ZERO = new Point2(_0n10, _1n10, _1n10, _0n10);
+    static ZERO = new Point2(_0n11, _1n11, _1n11, _0n11);
     // 0, 1, 1, 0
     // math field
     static Fp = Fp;
@@ -17375,7 +17633,7 @@ function edwards(params, extraOpts = {}) {
       const { x, y } = p || {};
       acoord("x", x);
       acoord("y", y);
-      return new Point2(x, y, _1n10, modP(x * y));
+      return new Point2(x, y, _1n11, modP(x * y));
     }
     // Uses algo from RFC8032 5.1.3.
     static fromBytes(bytes, zip215 = false) {
@@ -17388,16 +17646,16 @@ function edwards(params, extraOpts = {}) {
       normed[len - 1] = lastByte & ~128;
       const y = bytesToNumberLE(normed);
       const max = zip215 ? MASK : Fp.ORDER;
-      aInRange("point.y", y, _0n10, max);
+      aInRange("point.y", y, _0n11, max);
       const y2 = modP(y * y);
-      const u = modP(y2 - _1n10);
+      const u = modP(y2 - _1n11);
       const v = modP(d * y2 - a);
       let { isValid, value: x } = uvRatio2(u, v);
       if (!isValid)
         throw new Error("bad point: invalid y coordinate");
-      const isXOdd = (x & _1n10) === _1n10;
+      const isXOdd = (x & _1n11) === _1n11;
       const isLastByteOdd = (lastByte & 128) !== 0;
-      if (!zip215 && x === _0n10 && isLastByteOdd)
+      if (!zip215 && x === _0n11 && isLastByteOdd)
         throw new Error("bad point: x=0 and x_0=1");
       if (isLastByteOdd !== isXOdd)
         x = modP(-x);
@@ -17415,7 +17673,7 @@ function edwards(params, extraOpts = {}) {
     precompute(windowSize = 8, isLazy = true) {
       wnaf.createCache(this, windowSize);
       if (!isLazy)
-        this.multiply(_2n8);
+        this.multiply(_2n9);
       return this;
     }
     // Useful in fromAffine() - not for fromBytes(), which always created valid points.
@@ -17447,7 +17705,7 @@ function edwards(params, extraOpts = {}) {
       const { X: X1, Y: Y1, Z: Z1 } = this;
       const A = modP(X1 * X1);
       const B = modP(Y1 * Y1);
-      const C = modP(_2n8 * modP(Z1 * Z1));
+      const C = modP(_2n9 * modP(Z1 * Z1));
       const D = modP(a * A);
       const x1y1 = X1 + Y1;
       const E = modP(modP(x1y1 * x1y1) - A - B);
@@ -17500,9 +17758,9 @@ function edwards(params, extraOpts = {}) {
     multiplyUnsafe(scalar, acc = Point2.ZERO) {
       if (!Fn2.isValid(scalar))
         throw new Error("invalid scalar: expected 0 <= sc < curve.n");
-      if (scalar === _0n10)
+      if (scalar === _0n11)
         return Point2.ZERO;
-      if (this.is0() || scalar === _1n10)
+      if (this.is0() || scalar === _1n11)
         return this;
       return wnaf.unsafe(this, scalar, (p) => normalizeZ(Point2, p), acc);
     }
@@ -17524,14 +17782,14 @@ function edwards(params, extraOpts = {}) {
       return toAffineMemo(this, invertedZ);
     }
     clearCofactor() {
-      if (cofactor === _1n10)
+      if (cofactor === _1n11)
         return this;
       return this.multiplyUnsafe(cofactor);
     }
     toBytes() {
       const { x, y } = this.toAffine();
       const bytes = Fp.toBytes(y);
-      bytes[bytes.length - 1] |= x & _1n10 ? 128 : 0;
+      bytes[bytes.length - 1] |= x & _1n11 ? 128 : 0;
       return bytes;
     }
     toHex() {
@@ -17672,7 +17930,7 @@ function eddsa(Point2, cHash, eddsaOpts = {}) {
       const is25519 = size === 32;
       if (!is25519 && size !== 57)
         throw new Error("only defined for 25519 and 448");
-      const u = is25519 ? Fp.div(_1n10 + y, _1n10 - y) : Fp.div(y - _1n10, y + _1n10);
+      const u = is25519 ? Fp.div(_1n11 + y, _1n11 - y) : Fp.div(y - _1n11, y + _1n11);
       return Fp.toBytes(u);
     },
     toMontgomerySecret(secretKey) {
@@ -17694,8 +17952,8 @@ function eddsa(Point2, cHash, eddsaOpts = {}) {
 }
 
 // ../../node_modules/.pnpm/@noble+curves@2.0.1/node_modules/@noble/curves/ed25519.js
-var _1n11 = BigInt(1);
-var _2n9 = BigInt(2);
+var _1n12 = BigInt(1);
+var _2n10 = BigInt(2);
 var _5n3 = BigInt(5);
 var _8n4 = BigInt(8);
 var ed25519_CURVE_p = BigInt("0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffed");
@@ -17713,8 +17971,8 @@ function ed25519_pow_2_252_3(x) {
   const P = ed25519_CURVE_p;
   const x2 = x * x % P;
   const b2 = x2 * x % P;
-  const b4 = pow2(b2, _2n9, P) * b2 % P;
-  const b5 = pow2(b4, _1n11, P) * x % P;
+  const b4 = pow2(b2, _2n10, P) * b2 % P;
+  const b5 = pow2(b4, _1n12, P) * x % P;
   const b10 = pow2(b5, _5n3, P) * b5 % P;
   const b20 = pow2(b10, _10n, P) * b10 % P;
   const b40 = pow2(b20, _20n, P) * b20 % P;
@@ -17722,7 +17980,7 @@ function ed25519_pow_2_252_3(x) {
   const b160 = pow2(b80, _80n, P) * b80 % P;
   const b240 = pow2(b160, _80n, P) * b80 % P;
   const b250 = pow2(b240, _10n, P) * b10 % P;
-  const pow_p_5_8 = pow2(b250, _2n9, P) * x % P;
+  const pow_p_5_8 = pow2(b250, _2n10, P) * x % P;
   return { pow_p_5_8, b2 };
 }
 function adjustScalarBytes(bytes) {
@@ -17758,191 +18016,6 @@ function ed(opts) {
 }
 var ed25519 = /* @__PURE__ */ ed({});
 
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/sha3.js
-var _0n11 = BigInt(0);
-var _1n12 = BigInt(1);
-var _2n10 = BigInt(2);
-var _7n4 = BigInt(7);
-var _256n2 = BigInt(256);
-var _0x71n2 = BigInt(113);
-var SHA3_PI2 = [];
-var SHA3_ROTL2 = [];
-var _SHA3_IOTA2 = [];
-for (let round = 0, R = _1n12, x = 1, y = 0; round < 24; round++) {
-  [x, y] = [y, (2 * x + 3 * y) % 5];
-  SHA3_PI2.push(2 * (5 * y + x));
-  SHA3_ROTL2.push((round + 1) * (round + 2) / 2 % 64);
-  let t = _0n11;
-  for (let j = 0; j < 7; j++) {
-    R = (R << _1n12 ^ (R >> _7n4) * _0x71n2) % _256n2;
-    if (R & _2n10)
-      t ^= _1n12 << (_1n12 << BigInt(j)) - _1n12;
-  }
-  _SHA3_IOTA2.push(t);
-}
-var IOTAS2 = split2(_SHA3_IOTA2, true);
-var SHA3_IOTA_H2 = IOTAS2[0];
-var SHA3_IOTA_L2 = IOTAS2[1];
-var rotlH2 = (h, l, s) => s > 32 ? rotlBH2(h, l, s) : rotlSH2(h, l, s);
-var rotlL2 = (h, l, s) => s > 32 ? rotlBL2(h, l, s) : rotlSL2(h, l, s);
-function keccakP2(s, rounds = 24) {
-  const B = new Uint32Array(5 * 2);
-  for (let round = 24 - rounds; round < 24; round++) {
-    for (let x = 0; x < 10; x++)
-      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
-    for (let x = 0; x < 10; x += 2) {
-      const idx1 = (x + 8) % 10;
-      const idx0 = (x + 2) % 10;
-      const B0 = B[idx0];
-      const B1 = B[idx0 + 1];
-      const Th = rotlH2(B0, B1, 1) ^ B[idx1];
-      const Tl = rotlL2(B0, B1, 1) ^ B[idx1 + 1];
-      for (let y = 0; y < 50; y += 10) {
-        s[x + y] ^= Th;
-        s[x + y + 1] ^= Tl;
-      }
-    }
-    let curH = s[2];
-    let curL = s[3];
-    for (let t = 0; t < 24; t++) {
-      const shift = SHA3_ROTL2[t];
-      const Th = rotlH2(curH, curL, shift);
-      const Tl = rotlL2(curH, curL, shift);
-      const PI = SHA3_PI2[t];
-      curH = s[PI];
-      curL = s[PI + 1];
-      s[PI] = Th;
-      s[PI + 1] = Tl;
-    }
-    for (let y = 0; y < 50; y += 10) {
-      for (let x = 0; x < 10; x++)
-        B[x] = s[y + x];
-      for (let x = 0; x < 10; x++)
-        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
-    }
-    s[0] ^= SHA3_IOTA_H2[round];
-    s[1] ^= SHA3_IOTA_L2[round];
-  }
-  clean2(B);
-}
-var Keccak2 = class _Keccak {
-  state;
-  pos = 0;
-  posOut = 0;
-  finished = false;
-  state32;
-  destroyed = false;
-  blockLen;
-  suffix;
-  outputLen;
-  enableXOF = false;
-  rounds;
-  // NOTE: we accept arguments in bytes instead of bits here.
-  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
-    this.blockLen = blockLen;
-    this.suffix = suffix;
-    this.outputLen = outputLen;
-    this.enableXOF = enableXOF;
-    this.rounds = rounds;
-    anumber2(outputLen, "outputLen");
-    if (!(0 < blockLen && blockLen < 200))
-      throw new Error("only keccak-f1600 function is supported");
-    this.state = new Uint8Array(200);
-    this.state32 = u322(this.state);
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  keccak() {
-    swap32IfBE2(this.state32);
-    keccakP2(this.state32, this.rounds);
-    swap32IfBE2(this.state32);
-    this.posOut = 0;
-    this.pos = 0;
-  }
-  update(data) {
-    aexists2(this);
-    abytes2(data);
-    const { blockLen, state } = this;
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      for (let i = 0; i < take; i++)
-        state[this.pos++] ^= data[pos++];
-      if (this.pos === blockLen)
-        this.keccak();
-    }
-    return this;
-  }
-  finish() {
-    if (this.finished)
-      return;
-    this.finished = true;
-    const { state, suffix, pos, blockLen } = this;
-    state[pos] ^= suffix;
-    if ((suffix & 128) !== 0 && pos === blockLen - 1)
-      this.keccak();
-    state[blockLen - 1] ^= 128;
-    this.keccak();
-  }
-  writeInto(out) {
-    aexists2(this, false);
-    abytes2(out);
-    this.finish();
-    const bufferOut = this.state;
-    const { blockLen } = this;
-    for (let pos = 0, len = out.length; pos < len; ) {
-      if (this.posOut >= blockLen)
-        this.keccak();
-      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 for this instance");
-    return this.writeInto(out);
-  }
-  xof(bytes) {
-    anumber2(bytes);
-    return this.xofInto(new Uint8Array(bytes));
-  }
-  digestInto(out) {
-    aoutput2(out, this);
-    if (this.finished)
-      throw new Error("digest() was already called");
-    this.writeInto(out);
-    this.destroy();
-    return out;
-  }
-  digest() {
-    return this.digestInto(new Uint8Array(this.outputLen));
-  }
-  destroy() {
-    this.destroyed = true;
-    clean2(this.state);
-  }
-  _cloneInto(to) {
-    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
-    to ||= new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
-    to.state32.set(this.state32);
-    to.pos = this.pos;
-    to.posOut = this.posOut;
-    to.finished = this.finished;
-    to.rounds = rounds;
-    to.suffix = suffix;
-    to.outputLen = outputLen;
-    to.enableXOF = enableXOF;
-    to.destroyed = this.destroyed;
-    return to;
-  }
-};
-var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher2(() => new Keccak2(blockLen, suffix, outputLen), info);
-var keccak_2562 = /* @__PURE__ */ genKeccak(1, 136, 32);
-
 // ../mill/dist/chunk-44VWYELC.js
 var import_ed25519_hd_key = __toESM(require_dist(), 1);
 var MillWalletError = class extends Error {
@@ -18014,13 +18087,13 @@ function deriveEvm(seed, accountIndex, addressIndex) {
 }
 function computeEvmAddress(privateKey) {
   const uncompressed = secp256k1.getPublicKey(privateKey, false);
-  const hash = keccak_2562(uncompressed.slice(1));
+  const hash = keccak_256(uncompressed.slice(1));
   const addressHex = bytesToHex2(hash.slice(-20));
   return toChecksumAddress(addressHex);
 }
 function toChecksumAddress(addressHex) {
   const lower = addressHex.toLowerCase();
-  const hashHex = bytesToHex2(keccak_2562(new TextEncoder().encode(lower)));
+  const hashHex = bytesToHex2(keccak_256(new TextEncoder().encode(lower)));
   let out = "0x";
   for (let i = 0; i < 40; i++) {
     const ch = lower.charAt(i);
@@ -18048,7 +18121,7 @@ function deriveMina(seed, accountIndex, addressIndex) {
   const firstByte = scalar[0];
   scalar[0] = firstByte & 63;
   const privateKeyHex = bytesToHex2(scalar);
-  const publicKeyHex = bytesToHex2(keccak_2562(scalar));
+  const publicKeyHex = bytesToHex2(keccak_256(scalar));
   return {
     privateKey: privateKeyHex,
     publicKey: publicKeyHex,
@@ -18065,15 +18138,15 @@ function deriveSolana(seed, accountIndex) {
 }
 
 // src/wallet/manager.ts
-var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-function base58Encode(bytes) {
+var BASE58_ALPHABET2 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode2(bytes) {
   let zeros = 0;
   for (let i = 0; i < bytes.length && bytes[i] === 0; i++) zeros++;
   let value = 0n;
   for (const byte of bytes) value = value * 256n + BigInt(byte);
   let result = "";
   while (value > 0n) {
-    result = BASE58_ALPHABET[Number(value % 58n)] + result;
+    result = BASE58_ALPHABET2[Number(value % 58n)] + result;
     value = value / 58n;
   }
   for (let i = 0; i < zeros; i++) result = "1" + result;
@@ -18226,7 +18299,7 @@ var WalletManager = class {
           accountIndex: derivationIndex
         });
         if (chainKeys.solana) {
-          solanaAddress = base58Encode(chainKeys.solana.publicKey);
+          solanaAddress = base58Encode2(chainKeys.solana.publicKey);
           solanaPrivateKey = chainKeys.solana.privateKey;
           solanaDerivationPath = chainKeys.solana.path;
         }
@@ -18261,6 +18334,74 @@ var WalletManager = class {
     const keys = this.getNodeKeys(nodeType);
     return bytesToHex(keys.evmPrivateKey);
   }
+  /**
+   * Derive the APEX (connector) settlement key from the operator mnemonic at
+   * ACCOUNT_INDEX_APEX. The apex signs settlement claims with this key, so the
+   * operator never has to supply a raw `keyId` to `townhouse chains add`.
+   *
+   * Returns the EVM private key as a `0x`-prefixed 64-char hex string — the
+   * form the connector config's `keyId` expects (matches the dev placeholder
+   * `0x7c85…`). Also returns Solana + Mina settlement keys (connector 3.9.0)
+   * derived at the same `ACCOUNT_INDEX_APEX`, in the RAW base58 form the
+   * connector resolves a non-EVM `keyId` as:
+   *   - Solana: base58 of the 32-byte Ed25519 seed,
+   *   - Mina:   `EK…` base58check (via `hexToMinaBase58PrivateKey`).
+   *
+   * EVM derivation must always succeed (it throws on failure). Solana/Mina
+   * derivation is best-effort: if `deriveMillKeys` throws (unsupported
+   * platform, library load error) the corresponding key is OMITTED rather than
+   * failing the whole method, so the EVM keyId path is never blocked.
+   *
+   * Async because `deriveMillKeys` is async. Throws when the wallet is locked.
+   */
+  async getApexSettlementKeys() {
+    if (!this.state) {
+      throw new Error(
+        "Wallet not initialized. Call generate() or fromMnemonic() first."
+      );
+    }
+    const mnemonic = this.state.mnemonic;
+    let seed;
+    let evmPrivateKeyHex;
+    try {
+      seed = mnemonicToSeedSync(mnemonic);
+      const path = `m/44'/60'/${ACCOUNT_INDEX_APEX}'/0/0`;
+      const hd = HDKey.fromMasterSeed(seed).derive(path);
+      if (!hd.privateKey) {
+        throw new Error(`Apex EVM private key missing at ${path}`);
+      }
+      evmPrivateKeyHex = `0x${bytesToHex(new Uint8Array(hd.privateKey))}`;
+    } finally {
+      if (seed) seed.fill(0);
+    }
+    let solanaPrivateKeyBase58;
+    let minaPrivateKeyBase58;
+    try {
+      const chainKeys = await deriveMillKeys({
+        mnemonic,
+        chains: ["solana", "mina"],
+        accountIndex: ACCOUNT_INDEX_APEX
+      });
+      if (chainKeys.solana) {
+        solanaPrivateKeyBase58 = base58Encode(chainKeys.solana.privateKey);
+      }
+      if (chainKeys.mina) {
+        minaPrivateKeyBase58 = hexToMinaBase58PrivateKey(
+          chainKeys.mina.privateKey
+        );
+      }
+    } catch (err) {
+      const errMsg = err instanceof Error ? err.message : String(err);
+      console.warn(
+        `[WalletManager] deriveMillKeys failed for apex (accountIndex=${ACCOUNT_INDEX_APEX}): ${errMsg} \u2014 Solana/Mina apex keys omitted`
+      );
+    }
+    return {
+      evmPrivateKeyHex,
+      ...solanaPrivateKeyBase58 ? { solanaPrivateKeyBase58 } : {},
+      ...minaPrivateKeyBase58 ? { minaPrivateKeyBase58 } : {}
+    };
+  }
   /**
    * Returns the Solana Ed25519 private key seed for a node as a 64-char
    * lowercase hex string (32 raw seed bytes). Throws when the wallet is
@@ -18405,7 +18546,7 @@ var WalletManager = class {
             accountIndex
           });
           if (chainKeys.solana) {
-            chainExtras[nodeType].solanaAddress = base58Encode(
+            chainExtras[nodeType].solanaAddress = base58Encode2(
               chainKeys.solana.publicKey
             );
             chainExtras[nodeType].solanaPrivateKey = chainKeys.solana.privateKey;
@@ -18512,13 +18653,13 @@ function zeroArweaveJwk(jwk) {
 }
 function computeEvmAddress2(privateKey) {
   const uncompressed = secp256k12.getPublicKey(privateKey, false);
-  const hash = keccak_256(uncompressed.slice(1));
+  const hash = keccak_2562(uncompressed.slice(1));
   const addressHex = bytesToHex(hash.slice(-20));
   return toChecksumAddress2(addressHex);
 }
 function toChecksumAddress2(addressHex) {
   const lower = addressHex.toLowerCase();
-  const hashHex = bytesToHex(keccak_256(new TextEncoder().encode(lower)));
+  const hashHex = bytesToHex(keccak_2562(new TextEncoder().encode(lower)));
   let out = "0x";
   for (let i = 0; i < 40; i++) {
     const ch = lower.charAt(i);
@@ -22862,4 +23003,4 @@ export {
 @scure/bip32/index.js:
   (*! scure-bip32 - MIT License (c) 2022 Patricio Palladino, Paul Miller (paulmillr.com) *)
 */
-//# sourceMappingURL=chunk-ZUMMJFGH.js.map
+//# sourceMappingURL=chunk-UBFITLPQ.js.map