@t2000/cli 5.23.0 → 5.24.0

package/dist/index.js

@@ -3,7 +3,7 @@ import { createRequire as __createRequire } from 'module'; import { fileURLToPat
 import {
   AggregatorClient,
   Env
-} from "./chunk-3TZXRO3E.js";
+} from "./chunk-UJGE644R.js";
 import {
   BalanceChange,
   BaseClient,
@@ -16,11 +16,11 @@ import {
   parseTransactionEffectsBcs,
   transactionDataToGrpcTransaction,
   transactionToGrpcJson
-} from "./chunk-5AD7I65O.js";
+} from "./chunk-R6QER65C.js";
 import {
   Transaction,
   coinWithBalance
-} from "./chunk-TP3M7BAU.js";
+} from "./chunk-JEIOQF6Q.js";
 import {
   ObjectError,
   SUI_TYPE_ARG,
@@ -31,7 +31,7 @@ import {
   fromBase64 as fromBase642,
   suiBcs,
   toBase64 as toBase642
-} from "./chunk-X6ON6NN5.js";
+} from "./chunk-5MAY6SK7.js";
 import {
   SIGNATURE_FLAG_TO_SCHEME,
   SIGNATURE_SCHEME_TO_FLAG,
@@ -56,11 +56,9 @@ import {
   bech32,
   blake2b,
   bytesToHex,
-  checkOpts,
   clean,
   concatBytes,
   createHasher,
-  createView,
   fromBase64,
   fromHex,
   hexToBytes,
@@ -68,7 +66,6 @@ import {
   isValidNamedType,
   isValidSuiAddress,
   isValidSuiObjectId,
-  kdfInputToBytes,
   normalizeStructTag,
   normalizeSuiAddress,
   oidNist,
@@ -82,7 +79,7 @@ import {
   split,
   toBase64,
   toHex
-} from "./chunk-I2DCISQP.js";
+} from "./chunk-D3DUYZYR.js";
 import {
   require_bn,
   require_safer
@@ -17201,7 +17198,7 @@ var require_bitmapper = __commonJS({
     function bitRetriever(data, depth) {
       let leftOver = [];
       let i = 0;
-      function split2() {
+      function split3() {
         if (i === data.length) {
           throw new Error("Ran out of data");
         }
@@ -17244,7 +17241,7 @@ var require_bitmapper = __commonJS({
       return {
         get: function(count) {
           while (leftOver.length < count) {
-            split2();
+            split3();
           }
           let returner = leftOver.slice(0, count);
           leftOver = leftOver.slice(count);
@@ -23250,8 +23247,618 @@ var Ed25519PublicKey = class extends PublicKey {
   }
 };
 
-// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/hmac.js
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/utils.js
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+function anumber2(n, title = "") {
+  if (typeof n !== "number") {
+    const prefix = title && `"${title}" `;
+    throw new TypeError(`${prefix}expected number, got ${typeof n}`);
+  }
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new RangeError(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes2(value, length, title = "") {
+  const bytes = isBytes2(value);
+  const len = value?.length;
+  const needsLen = length !== void 0;
+  if (!bytes || needsLen && len !== length) {
+    const prefix = title && `"${title}" `;
+    const ofLen = needsLen ? ` of length ${length}` : "";
+    const got = bytes ? `length=${len}` : `type=${typeof value}`;
+    const message = prefix + "expected Uint8Array" + ofLen + ", got " + got;
+    if (!bytes)
+      throw new TypeError(message);
+    throw new RangeError(message);
+  }
+  return value;
+}
+function ahash2(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new TypeError("Hash must wrapped by utils.createHasher");
+  anumber2(h.outputLen);
+  anumber2(h.blockLen);
+  if (h.outputLen < 1)
+    throw new Error('"outputLen" must be >= 1');
+  if (h.blockLen < 1)
+    throw new Error('"blockLen" must be >= 1');
+}
+function aexists2(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function aoutput(out, instance) {
+  abytes2(out, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new RangeError('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function clean2(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new TypeError("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function kdfInputToBytes(data, errorTitle = "") {
+  if (typeof data === "string")
+    return utf8ToBytes(data);
+  return abytes2(data, void 0, errorTitle);
+}
+function checkOpts(defaults, opts) {
+  if (opts !== void 0 && {}.toString.call(opts) !== "[object Object]")
+    throw new TypeError("options must be object or undefined");
+  const merged = Object.assign(defaults, opts);
+  return merged;
+}
+function createHasher2(hashCons, info = {}) {
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+var oidNist2 = (suffix) => ({
+  // Current NIST hashAlgs suffixes used here fit in one DER subidentifier octet.
+  // Larger suffix values would need base-128 OID encoding and a different length byte.
+  oid: Uint8Array.from([6, 9, 96, 134, 72, 1, 101, 3, 4, 2, suffix])
+});
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/hmac.js
 var _HMAC = class {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  canXOF = false;
+  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);
+    aoutput(out, this);
+    this.finished = true;
+    const buf = out.subarray(0, this.outputLen);
+    this.iHash.digestInto(buf);
+    this.oHash.update(buf);
+    this.oHash.digestInto(buf);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    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 hmac = /* @__PURE__ */ (() => {
+  const hmac_ = ((hash, key, message) => new _HMAC(hash, key).update(message).digest());
+  hmac_.create = (hash, key) => new _HMAC(hash, key);
+  return hmac_;
+})();
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/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");
+  if (dkLen < 1)
+    throw new Error('"dkLen" must be >= 1');
+  if (dkLen > (2 ** 32 - 1) * hash.outputLen)
+    throw new Error("derived key too long");
+  const password = kdfInputToBytes(_password, "password");
+  const salt = kdfInputToBytes(_salt, "salt");
+  const DK = new Uint8Array(dkLen);
+  const PRF = hmac.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/@noble+hashes@2.2.0/node_modules/@noble/hashes/_md.js
+var HashMD2 = class {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  update(data) {
+    aexists2(this);
+    abytes2(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists2(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    clean2(this.buffer.subarray(pos));
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    view.setBigUint64(blockLen - 8, BigInt(this.length * 8), isLE);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen must be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+var SHA512_IV2 = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+]);
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/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 shrSH2 = (h, _l, s) => h >>> s;
+var shrSL2 = (h, l, s) => h << 32 - s | l >>> s;
+var rotrSH2 = (h, l, s) => h >>> s | l << 32 - s;
+var rotrSL2 = (h, l, s) => h << 32 - s | l >>> s;
+var rotrBH2 = (h, l, s) => h << 64 - s | l >>> s - 32;
+var rotrBL2 = (h, l, s) => h >>> s - 32 | l << 64 - s;
+function add2(Ah, Al, Bh, Bl) {
+  const l = (Al >>> 0) + (Bl >>> 0);
+  return { h: Ah + Bh + (l / 2 ** 32 | 0) | 0, l: l | 0 };
+}
+var add3L2 = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+var add3H2 = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+var add4L2 = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+var add4H2 = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+var add5L2 = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+var add5H2 = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+
+// ../../node_modules/.pnpm/@noble+hashes@2.2.0/node_modules/@noble/hashes/sha2.js
+var K5122 = /* @__PURE__ */ (() => split2([
+  "0x428a2f98d728ae22",
+  "0x7137449123ef65cd",
+  "0xb5c0fbcfec4d3b2f",
+  "0xe9b5dba58189dbbc",
+  "0x3956c25bf348b538",
+  "0x59f111f1b605d019",
+  "0x923f82a4af194f9b",
+  "0xab1c5ed5da6d8118",
+  "0xd807aa98a3030242",
+  "0x12835b0145706fbe",
+  "0x243185be4ee4b28c",
+  "0x550c7dc3d5ffb4e2",
+  "0x72be5d74f27b896f",
+  "0x80deb1fe3b1696b1",
+  "0x9bdc06a725c71235",
+  "0xc19bf174cf692694",
+  "0xe49b69c19ef14ad2",
+  "0xefbe4786384f25e3",
+  "0x0fc19dc68b8cd5b5",
+  "0x240ca1cc77ac9c65",
+  "0x2de92c6f592b0275",
+  "0x4a7484aa6ea6e483",
+  "0x5cb0a9dcbd41fbd4",
+  "0x76f988da831153b5",
+  "0x983e5152ee66dfab",
+  "0xa831c66d2db43210",
+  "0xb00327c898fb213f",
+  "0xbf597fc7beef0ee4",
+  "0xc6e00bf33da88fc2",
+  "0xd5a79147930aa725",
+  "0x06ca6351e003826f",
+  "0x142929670a0e6e70",
+  "0x27b70a8546d22ffc",
+  "0x2e1b21385c26c926",
+  "0x4d2c6dfc5ac42aed",
+  "0x53380d139d95b3df",
+  "0x650a73548baf63de",
+  "0x766a0abb3c77b2a8",
+  "0x81c2c92e47edaee6",
+  "0x92722c851482353b",
+  "0xa2bfe8a14cf10364",
+  "0xa81a664bbc423001",
+  "0xc24b8b70d0f89791",
+  "0xc76c51a30654be30",
+  "0xd192e819d6ef5218",
+  "0xd69906245565a910",
+  "0xf40e35855771202a",
+  "0x106aa07032bbd1b8",
+  "0x19a4c116b8d2d0c8",
+  "0x1e376c085141ab53",
+  "0x2748774cdf8eeb99",
+  "0x34b0bcb5e19b48a8",
+  "0x391c0cb3c5c95a63",
+  "0x4ed8aa4ae3418acb",
+  "0x5b9cca4f7763e373",
+  "0x682e6ff3d6b2b8a3",
+  "0x748f82ee5defb2fc",
+  "0x78a5636f43172f60",
+  "0x84c87814a1f0ab72",
+  "0x8cc702081a6439ec",
+  "0x90befffa23631e28",
+  "0xa4506cebde82bde9",
+  "0xbef9a3f7b2c67915",
+  "0xc67178f2e372532b",
+  "0xca273eceea26619c",
+  "0xd186b8c721c0c207",
+  "0xeada7dd6cde0eb1e",
+  "0xf57d4f7fee6ed178",
+  "0x06f067aa72176fba",
+  "0x0a637dc5a2c898a6",
+  "0x113f9804bef90dae",
+  "0x1b710b35131c471b",
+  "0x28db77f523047d84",
+  "0x32caab7b40c72493",
+  "0x3c9ebe0a15c9bebc",
+  "0x431d67c49c100d4c",
+  "0x4cc5d4becb3e42b6",
+  "0x597f299cfc657e2a",
+  "0x5fcb6fab3ad6faec",
+  "0x6c44198c4a475817"
+].map((n) => BigInt(n))))();
+var SHA512_Kh2 = /* @__PURE__ */ (() => K5122[0])();
+var SHA512_Kl2 = /* @__PURE__ */ (() => K5122[1])();
+var SHA512_W_H2 = /* @__PURE__ */ new Uint32Array(80);
+var SHA512_W_L2 = /* @__PURE__ */ new Uint32Array(80);
+var SHA2_64B2 = class extends HashMD2 {
+  constructor(outputLen) {
+    super(128, outputLen, 16, false);
+  }
+  // prettier-ignore
+  get() {
+    const { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    return [Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl];
+  }
+  // prettier-ignore
+  set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl) {
+    this.Ah = Ah | 0;
+    this.Al = Al | 0;
+    this.Bh = Bh | 0;
+    this.Bl = Bl | 0;
+    this.Ch = Ch | 0;
+    this.Cl = Cl | 0;
+    this.Dh = Dh | 0;
+    this.Dl = Dl | 0;
+    this.Eh = Eh | 0;
+    this.El = El | 0;
+    this.Fh = Fh | 0;
+    this.Fl = Fl | 0;
+    this.Gh = Gh | 0;
+    this.Gl = Gl | 0;
+    this.Hh = Hh | 0;
+    this.Hl = Hl | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4) {
+      SHA512_W_H2[i] = view.getUint32(offset);
+      SHA512_W_L2[i] = view.getUint32(offset += 4);
+    }
+    for (let i = 16; i < 80; i++) {
+      const W15h = SHA512_W_H2[i - 15] | 0;
+      const W15l = SHA512_W_L2[i - 15] | 0;
+      const s0h = rotrSH2(W15h, W15l, 1) ^ rotrSH2(W15h, W15l, 8) ^ shrSH2(W15h, W15l, 7);
+      const s0l = rotrSL2(W15h, W15l, 1) ^ rotrSL2(W15h, W15l, 8) ^ shrSL2(W15h, W15l, 7);
+      const W2h = SHA512_W_H2[i - 2] | 0;
+      const W2l = SHA512_W_L2[i - 2] | 0;
+      const s1h = rotrSH2(W2h, W2l, 19) ^ rotrBH2(W2h, W2l, 61) ^ shrSH2(W2h, W2l, 6);
+      const s1l = rotrSL2(W2h, W2l, 19) ^ rotrBL2(W2h, W2l, 61) ^ shrSL2(W2h, W2l, 6);
+      const SUMl = add4L2(s0l, s1l, SHA512_W_L2[i - 7], SHA512_W_L2[i - 16]);
+      const SUMh = add4H2(SUMl, s0h, s1h, SHA512_W_H2[i - 7], SHA512_W_H2[i - 16]);
+      SHA512_W_H2[i] = SUMh | 0;
+      SHA512_W_L2[i] = SUMl | 0;
+    }
+    let { Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl } = this;
+    for (let i = 0; i < 80; i++) {
+      const sigma1h = rotrSH2(Eh, El, 14) ^ rotrSH2(Eh, El, 18) ^ rotrBH2(Eh, El, 41);
+      const sigma1l = rotrSL2(Eh, El, 14) ^ rotrSL2(Eh, El, 18) ^ rotrBL2(Eh, El, 41);
+      const CHIh = Eh & Fh ^ ~Eh & Gh;
+      const CHIl = El & Fl ^ ~El & Gl;
+      const T1ll = add5L2(Hl, sigma1l, CHIl, SHA512_Kl2[i], SHA512_W_L2[i]);
+      const T1h = add5H2(T1ll, Hh, sigma1h, CHIh, SHA512_Kh2[i], SHA512_W_H2[i]);
+      const T1l = T1ll | 0;
+      const sigma0h = rotrSH2(Ah, Al, 28) ^ rotrBH2(Ah, Al, 34) ^ rotrBH2(Ah, Al, 39);
+      const sigma0l = rotrSL2(Ah, Al, 28) ^ rotrBL2(Ah, Al, 34) ^ rotrBL2(Ah, Al, 39);
+      const MAJh = Ah & Bh ^ Ah & Ch ^ Bh & Ch;
+      const MAJl = Al & Bl ^ Al & Cl ^ Bl & Cl;
+      Hh = Gh | 0;
+      Hl = Gl | 0;
+      Gh = Fh | 0;
+      Gl = Fl | 0;
+      Fh = Eh | 0;
+      Fl = El | 0;
+      ({ h: Eh, l: El } = add2(Dh | 0, Dl | 0, T1h | 0, T1l | 0));
+      Dh = Ch | 0;
+      Dl = Cl | 0;
+      Ch = Bh | 0;
+      Cl = Bl | 0;
+      Bh = Ah | 0;
+      Bl = Al | 0;
+      const All = add3L2(T1l, sigma0l, MAJl);
+      Ah = add3H2(All, T1h, sigma0h, MAJh);
+      Al = All | 0;
+    }
+    ({ h: Ah, l: Al } = add2(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+    ({ h: Bh, l: Bl } = add2(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+    ({ h: Ch, l: Cl } = add2(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+    ({ h: Dh, l: Dl } = add2(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+    ({ h: Eh, l: El } = add2(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+    ({ h: Fh, l: Fl } = add2(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+    ({ h: Gh, l: Gl } = add2(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+    ({ h: Hh, l: Hl } = add2(this.Hh | 0, this.Hl | 0, Hh | 0, Hl | 0));
+    this.set(Ah, Al, Bh, Bl, Ch, Cl, Dh, Dl, Eh, El, Fh, Fl, Gh, Gl, Hh, Hl);
+  }
+  roundClean() {
+    clean2(SHA512_W_H2, SHA512_W_L2);
+  }
+  destroy() {
+    this.destroyed = true;
+    clean2(this.buffer);
+    this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+  }
+};
+var _SHA5122 = class extends SHA2_64B2 {
+  Ah = SHA512_IV2[0] | 0;
+  Al = SHA512_IV2[1] | 0;
+  Bh = SHA512_IV2[2] | 0;
+  Bl = SHA512_IV2[3] | 0;
+  Ch = SHA512_IV2[4] | 0;
+  Cl = SHA512_IV2[5] | 0;
+  Dh = SHA512_IV2[6] | 0;
+  Dl = SHA512_IV2[7] | 0;
+  Eh = SHA512_IV2[8] | 0;
+  El = SHA512_IV2[9] | 0;
+  Fh = SHA512_IV2[10] | 0;
+  Fl = SHA512_IV2[11] | 0;
+  Gh = SHA512_IV2[12] | 0;
+  Gl = SHA512_IV2[13] | 0;
+  Hh = SHA512_IV2[14] | 0;
+  Hl = SHA512_IV2[15] | 0;
+  constructor() {
+    super(64);
+  }
+};
+var sha5122 = /* @__PURE__ */ createHasher2(
+  () => new _SHA5122(),
+  /* @__PURE__ */ oidNist2(3)
+);
+
+// ../../node_modules/.pnpm/@scure+bip39@2.2.0/node_modules/@scure/bip39/index.js
+function nfkd(str) {
+  if (typeof str !== "string")
+    throw new TypeError("invalid mnemonic type: " + typeof str);
+  return str.normalize("NFKD");
+}
+function normalize(str) {
+  const norm = nfkd(str);
+  const words = norm.split(" ");
+  if (![12, 15, 18, 21, 24].includes(words.length))
+    throw new Error("Invalid mnemonic");
+  return { nfkd: norm, words };
+}
+var psalt = (passphrase) => nfkd("mnemonic" + passphrase);
+function mnemonicToSeedSync(mnemonic, passphrase = "") {
+  return pbkdf2(sha5122, normalize(mnemonic).nfkd, psalt(passphrase), {
+    c: 2048,
+    dkLen: 64
+  });
+}
+
+// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/cryptography/mnemonics.mjs
+function isValidHardenedPath(path2) {
+  if (!(/* @__PURE__ */ new RegExp("^m\\/44'\\/784'\\/[0-9]+'\\/[0-9]+'\\/[0-9]+'+$")).test(path2)) return false;
+  return true;
+}
+function mnemonicToSeed(mnemonics) {
+  return mnemonicToSeedSync(mnemonics, "");
+}
+function mnemonicToSeedHex(mnemonics) {
+  return toHex(mnemonicToSeed(mnemonics));
+}
+
+// ../../node_modules/.pnpm/@noble+hashes@2.0.1/node_modules/@noble/hashes/hmac.js
+var _HMAC2 = class {
   oHash;
   iHash;
   blockLen;
@@ -23318,83 +23925,8 @@ var _HMAC = class {
     this.iHash.destroy();
   }
 };
-var hmac = (hash, key, message) => new _HMAC(hash, key).update(message).digest();
-hmac.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) {
-  ahash(hash);
-  const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
-  const { c, dkLen, asyncTick } = opts;
-  anumber(c, "c");
-  anumber(dkLen, "dkLen");
-  anumber(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 = hmac.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();
-  clean(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+bip39@2.0.1/node_modules/@scure/bip39/index.js
-function nfkd(str) {
-  if (typeof str !== "string")
-    throw new TypeError("invalid mnemonic type: " + typeof str);
-  return str.normalize("NFKD");
-}
-function normalize(str) {
-  const norm = nfkd(str);
-  const words = norm.split(" ");
-  if (![12, 15, 18, 21, 24].includes(words.length))
-    throw new Error("Invalid mnemonic");
-  return { nfkd: norm, words };
-}
-var psalt = (passphrase) => nfkd("mnemonic" + passphrase);
-function mnemonicToSeedSync(mnemonic, passphrase = "") {
-  return pbkdf2(sha512, normalize(mnemonic).nfkd, psalt(passphrase), { c: 2048, dkLen: 64 });
-}
-
-// ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/cryptography/mnemonics.mjs
-function isValidHardenedPath(path2) {
-  if (!(/* @__PURE__ */ new RegExp("^m\\/44'\\/784'\\/[0-9]+'\\/[0-9]+'\\/[0-9]+'+$")).test(path2)) return false;
-  return true;
-}
-function mnemonicToSeed(mnemonics) {
-  return mnemonicToSeedSync(mnemonics, "");
-}
-function mnemonicToSeedHex(mnemonics) {
-  return toHex(mnemonicToSeed(mnemonics));
-}
+var hmac2 = (hash, key, message) => new _HMAC2(hash, key).update(message).digest();
+hmac2.create = (hash, key) => new _HMAC2(hash, key);
 
 // ../../node_modules/.pnpm/@mysten+sui@2.17.0_typescript@5.9.3/node_modules/@mysten/sui/dist/cryptography/signature.mjs
 function toSerializedSignature({ signature, signatureScheme, publicKey }) {
@@ -23486,7 +24018,7 @@ var HARDENED_OFFSET = 2147483648;
 var pathRegex = /* @__PURE__ */ new RegExp("^m(\\/[0-9]+')+$");
 var replaceDerive = (val) => val.replace("'", "");
 var getMasterKeyFromSeed = (seed) => {
-  const I = hmac.create(sha512, new TextEncoder().encode(ED25519_CURVE)).update(fromHex(seed)).digest();
+  const I = hmac2.create(sha512, new TextEncoder().encode(ED25519_CURVE)).update(fromHex(seed)).digest();
   return {
     key: I.slice(0, 32),
     chainCode: I.slice(32)
@@ -23499,7 +24031,7 @@ var CKDPriv = ({ key, chainCode }, index) => {
   data.set(new Uint8Array(1).fill(0));
   data.set(key, 1);
   data.set(new Uint8Array(indexBuffer, 0, indexBuffer.byteLength), key.length + 1);
-  const I = hmac.create(sha512, chainCode).update(data).digest();
+  const I = hmac2.create(sha512, chainCode).update(data).digest();
   return {
     key: I.slice(0, 32),
     chainCode: I.slice(32)
@@ -23644,39 +24176,39 @@ import * as nc from "crypto";
 var crypto2 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : nc && typeof nc === "object" && "randomBytes" in nc ? nc : void 0;
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/utils.js
-function isBytes2(a) {
+function isBytes3(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
 }
-function anumber2(n) {
+function anumber3(n) {
   if (!Number.isSafeInteger(n) || n < 0)
     throw new Error("positive integer expected, got " + n);
 }
-function abytes2(b, ...lengths) {
-  if (!isBytes2(b))
+function abytes3(b, ...lengths) {
+  if (!isBytes3(b))
     throw new Error("Uint8Array expected");
   if (lengths.length > 0 && !lengths.includes(b.length))
     throw new Error("Uint8Array expected of length " + lengths + ", got length=" + b.length);
 }
-function ahash2(h) {
+function ahash3(h) {
   if (typeof h !== "function" || typeof h.create !== "function")
     throw new Error("Hash should be wrapped by utils.createHasher");
-  anumber2(h.outputLen);
-  anumber2(h.blockLen);
+  anumber3(h.outputLen);
+  anumber3(h.blockLen);
 }
-function aexists2(instance, checkFinished = true) {
+function aexists3(instance, checkFinished = true) {
   if (instance.destroyed)
     throw new Error("Hash instance has been destroyed");
   if (checkFinished && instance.finished)
     throw new Error("Hash#digest() has already been called");
 }
-function aoutput(out, instance) {
-  abytes2(out);
+function aoutput2(out, instance) {
+  abytes3(out);
   const min = instance.outputLen;
   if (out.length < min) {
     throw new Error("digestInto() expects output buffer of length at least " + min);
   }
 }
-function clean2(...arrays) {
+function clean3(...arrays) {
   for (let i = 0; i < arrays.length; i++) {
     arrays[i].fill(0);
   }
@@ -23684,7 +24216,7 @@ function clean2(...arrays) {
 function createView2(arr) {
   return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
-function rotr2(word, shift) {
+function rotr3(word, shift) {
   return word << 32 - shift | word >>> shift;
 }
 var hasHexBuiltin = /* @__PURE__ */ (() => (
@@ -23693,7 +24225,7 @@ var hasHexBuiltin = /* @__PURE__ */ (() => (
 ))();
 var hexes = /* @__PURE__ */ Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
 function bytesToHex2(bytes) {
-  abytes2(bytes);
+  abytes3(bytes);
   if (hasHexBuiltin)
     return bytes.toHex();
   let hex = "";
@@ -23733,22 +24265,22 @@ function hexToBytes2(hex) {
   }
   return array;
 }
-function utf8ToBytes(str) {
+function utf8ToBytes2(str) {
   if (typeof str !== "string")
     throw new Error("string expected");
   return new Uint8Array(new TextEncoder().encode(str));
 }
 function toBytes(data) {
   if (typeof data === "string")
-    data = utf8ToBytes(data);
-  abytes2(data);
+    data = utf8ToBytes2(data);
+  abytes3(data);
   return data;
 }
 function concatBytes2(...arrays) {
   let sum = 0;
   for (let i = 0; i < arrays.length; i++) {
     const a = arrays[i];
-    abytes2(a);
+    abytes3(a);
     sum += a.length;
   }
   const res = new Uint8Array(sum);
@@ -23761,7 +24293,7 @@ function concatBytes2(...arrays) {
 }
 var Hash = class {
 };
-function createHasher2(hashCons) {
+function createHasher3(hashCons) {
   const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
   const tmp = hashCons();
   hashC.outputLen = tmp.outputLen;
@@ -23783,22 +24315,22 @@ function randomBytes2(bytesLength = 32) {
 function setBigUint64(view, byteOffset, value, isLE) {
   if (typeof view.setBigUint64 === "function")
     return view.setBigUint64(byteOffset, value, isLE);
-  const _32n = BigInt(32);
+  const _32n2 = BigInt(32);
   const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
+  const wh = Number(value >> _32n2 & _u32_max);
   const wl = Number(value & _u32_max);
   const h = isLE ? 4 : 0;
   const l = isLE ? 0 : 4;
   view.setUint32(byteOffset + h, wh, isLE);
   view.setUint32(byteOffset + l, wl, isLE);
 }
-function Chi2(a, b, c) {
+function Chi3(a, b, c) {
   return a & b ^ ~a & c;
 }
-function Maj2(a, b, c) {
+function Maj3(a, b, c) {
   return a & b ^ a & c ^ b & c;
 }
-var HashMD2 = class extends Hash {
+var HashMD3 = class extends Hash {
   constructor(blockLen, outputLen, padOffset, isLE) {
     super();
     this.finished = false;
@@ -23813,9 +24345,9 @@ var HashMD2 = class extends Hash {
     this.view = createView2(this.buffer);
   }
   update(data) {
-    aexists2(this);
+    aexists3(this);
     data = toBytes(data);
-    abytes2(data);
+    abytes3(data);
     const { view, buffer, blockLen } = this;
     const len = data.length;
     for (let pos = 0; pos < len; ) {
@@ -23839,13 +24371,13 @@ var HashMD2 = class extends Hash {
     return this;
   }
   digestInto(out) {
-    aexists2(this);
-    aoutput(out, this);
+    aexists3(this);
+    aoutput2(out, this);
     this.finished = true;
     const { buffer, view, blockLen, isLE } = this;
     let { pos } = this;
     buffer[pos++] = 128;
-    clean2(this.buffer.subarray(pos));
+    clean3(this.buffer.subarray(pos));
     if (this.padOffset > blockLen - pos) {
       this.process(view, 0);
       pos = 0;
@@ -23888,7 +24420,7 @@ var HashMD2 = class extends Hash {
     return this._cloneInto();
   }
 };
-var SHA256_IV2 = /* @__PURE__ */ Uint32Array.from([
+var SHA256_IV3 = /* @__PURE__ */ Uint32Array.from([
   1779033703,
   3144134277,
   1013904242,
@@ -23967,17 +24499,17 @@ var SHA256_K = /* @__PURE__ */ Uint32Array.from([
   3329325298
 ]);
 var SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-var SHA256 = class extends HashMD2 {
+var SHA256 = class extends HashMD3 {
   constructor(outputLen = 32) {
     super(64, outputLen, 8, false);
-    this.A = SHA256_IV2[0] | 0;
-    this.B = SHA256_IV2[1] | 0;
-    this.C = SHA256_IV2[2] | 0;
-    this.D = SHA256_IV2[3] | 0;
-    this.E = SHA256_IV2[4] | 0;
-    this.F = SHA256_IV2[5] | 0;
-    this.G = SHA256_IV2[6] | 0;
-    this.H = SHA256_IV2[7] | 0;
+    this.A = SHA256_IV3[0] | 0;
+    this.B = SHA256_IV3[1] | 0;
+    this.C = SHA256_IV3[2] | 0;
+    this.D = SHA256_IV3[3] | 0;
+    this.E = SHA256_IV3[4] | 0;
+    this.F = SHA256_IV3[5] | 0;
+    this.G = SHA256_IV3[6] | 0;
+    this.H = SHA256_IV3[7] | 0;
   }
   get() {
     const { A, B, C, D, E, F, G, H } = this;
@@ -24000,16 +24532,16 @@ var SHA256 = class extends HashMD2 {
     for (let i = 16; i < 64; i++) {
       const W15 = SHA256_W[i - 15];
       const W2 = SHA256_W[i - 2];
-      const s0 = rotr2(W15, 7) ^ rotr2(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr2(W2, 17) ^ rotr2(W2, 19) ^ W2 >>> 10;
+      const s0 = rotr3(W15, 7) ^ rotr3(W15, 18) ^ W15 >>> 3;
+      const s1 = rotr3(W2, 17) ^ rotr3(W2, 19) ^ W2 >>> 10;
       SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
     }
     let { A, B, C, D, E, F, G, H } = this;
     for (let i = 0; i < 64; i++) {
-      const sigma1 = rotr2(E, 6) ^ rotr2(E, 11) ^ rotr2(E, 25);
-      const T1 = H + sigma1 + Chi2(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr2(A, 2) ^ rotr2(A, 13) ^ rotr2(A, 22);
-      const T2 = sigma0 + Maj2(A, B, C) | 0;
+      const sigma1 = rotr3(E, 6) ^ rotr3(E, 11) ^ rotr3(E, 25);
+      const T1 = H + sigma1 + Chi3(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
+      const sigma0 = rotr3(A, 2) ^ rotr3(A, 13) ^ rotr3(A, 22);
+      const T2 = sigma0 + Maj3(A, B, C) | 0;
       H = G;
       G = F;
       F = E;
@@ -24030,14 +24562,14 @@ var SHA256 = class extends HashMD2 {
     this.set(A, B, C, D, E, F, G, H);
   }
   roundClean() {
-    clean2(SHA256_W);
+    clean3(SHA256_W);
   }
   destroy() {
     this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    clean2(this.buffer);
+    clean3(this.buffer);
   }
 };
-var sha2562 = /* @__PURE__ */ createHasher2(() => new SHA256());
+var sha2562 = /* @__PURE__ */ createHasher3(() => new SHA256());
 
 // ../../node_modules/.pnpm/@noble+hashes@1.8.0/node_modules/@noble/hashes/esm/hmac.js
 var HMAC = class extends Hash {
@@ -24045,7 +24577,7 @@ var HMAC = class extends Hash {
     super();
     this.finished = false;
     this.destroyed = false;
-    ahash2(hash);
+    ahash3(hash);
     const key = toBytes(_key);
     this.iHash = hash.create();
     if (typeof this.iHash.update !== "function")
@@ -24062,16 +24594,16 @@ var HMAC = class extends Hash {
     for (let i = 0; i < pad.length; i++)
       pad[i] ^= 54 ^ 92;
     this.oHash.update(pad);
-    clean2(pad);
+    clean3(pad);
   }
   update(buf) {
-    aexists2(this);
+    aexists3(this);
     this.iHash.update(buf);
     return this;
   }
   digestInto(out) {
-    aexists2(this);
-    abytes2(out, this.outputLen);
+    aexists3(this);
+    abytes3(out, this.outputLen);
     this.finished = true;
     this.iHash.digestInto(out);
     this.oHash.update(out);
@@ -24104,8 +24636,8 @@ var HMAC = class extends Hash {
     this.iHash.destroy();
   }
 };
-var hmac2 = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-hmac2.create = (hash, key) => new HMAC(hash, key);
+var hmac3 = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac3.create = (hash, key) => new HMAC(hash, key);
 
 // ../../node_modules/.pnpm/@noble+curves@1.9.7/node_modules/@noble/curves/esm/utils.js
 var _0n5 = /* @__PURE__ */ BigInt(0);
@@ -24118,7 +24650,7 @@ function _abool2(value, title = "") {
   return value;
 }
 function _abytes2(value, length, title = "") {
-  const bytes = isBytes2(value);
+  const bytes = isBytes3(value);
   const len = value?.length;
   const needsLen = length !== void 0;
   if (!bytes || needsLen && len !== length) {
@@ -24142,7 +24674,7 @@ function bytesToNumberBE2(bytes) {
   return hexToNumber2(bytesToHex2(bytes));
 }
 function bytesToNumberLE2(bytes) {
-  abytes2(bytes);
+  abytes3(bytes);
   return hexToNumber2(bytesToHex2(Uint8Array.from(bytes).reverse()));
 }
 function numberToBytesBE2(n, len) {
@@ -24159,7 +24691,7 @@ function ensureBytes(title, hex, expectedLength) {
     } catch (e) {
       throw new Error(title + " must be hex string or Uint8Array, cause: " + e);
     }
-  } else if (isBytes2(hex)) {
+  } else if (isBytes3(hex)) {
     res = Uint8Array.from(hex);
   } else {
     throw new Error(title + " must be hex string or Uint8Array");
@@ -24482,7 +25014,7 @@ function FpLegendre2(Fp, n) {
 }
 function nLength2(n, nBitLength) {
   if (nBitLength !== void 0)
-    anumber2(nBitLength);
+    anumber3(nBitLength);
   const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
   const nByteLength = Math.ceil(_nBitLength / 8);
   return { nBitLength: _nBitLength, nByteLength };
@@ -25573,7 +26105,7 @@ function ecdh(Point, ecdhOpts = {}) {
   return Object.freeze({ getPublicKey, getSharedSecret, keygen, Point, utils, lengths });
 }
 function ecdsa(Point, hash, ecdsaOpts = {}) {
-  ahash2(hash);
+  ahash3(hash);
   _validateObject(ecdsaOpts, {}, {
     hmac: "function",
     lowS: "boolean",
@@ -25582,7 +26114,7 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
     bits2int_modN: "function"
   });
   const randomBytes3 = ecdsaOpts.randomBytes || randomBytes2;
-  const hmac3 = ecdsaOpts.hmac || ((key, ...msgs) => hmac2(hash, key, concatBytes2(...msgs)));
+  const hmac4 = ecdsaOpts.hmac || ((key, ...msgs) => hmac3(hash, key, concatBytes2(...msgs)));
   const { Fp, Fn } = Point;
   const { ORDER: CURVE_ORDER, BITS: fnBits } = Fn;
   const { keygen, getPublicKey, getSharedSecret, utils, lengths } = ecdh(Point, ecdsaOpts);
@@ -25766,13 +26298,13 @@ function ecdsa(Point, hash, ecdsaOpts = {}) {
   function sign(message, secretKey, opts = {}) {
     message = ensureBytes("message", message);
     const { seed, k2sig } = prepSig(message, secretKey, opts);
-    const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac3);
+    const drbg = createHmacDrbg(hash.outputLen, Fn.BYTES, hmac4);
     const sig = drbg(seed, k2sig);
     return sig;
   }
   function tryParsingSig(sg) {
     let sig = void 0;
-    const isHex = typeof sg === "string" || isBytes2(sg);
+    const isHex = typeof sg === "string" || isBytes3(sg);
     const isObj = !isHex && sg !== null && typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint";
     if (!isHex && !isObj)
       throw new Error("invalid signature, expected Uint8Array, hex string or Signature instance");
@@ -27058,7 +27590,7 @@ async function pickSuiExactRequirements(response, network) {
 }
 async function payViaX402(args) {
   const { signer, client, options, reqInit, requirements } = args;
-  const { buildX402SignedPayment, X402_PAYMENT_HEADER, X402_PAYMENT_RESPONSE_HEADER } = await import("./x402-YYM5ZJIK.js");
+  const { buildX402SignedPayment, X402_PAYMENT_HEADER, X402_PAYMENT_RESPONSE_HEADER } = await import("./x402-ALCPXKII.js");
   const amountRaw = BigInt(requirements.maxAmountRequired);
   const migrationGasSui = await ensureAddressBalanceCovers({
     signer,
@@ -27139,7 +27671,7 @@ async function finalize(response, opts) {
   return { status: response.status, body: body2, paid: opts.paid };
 }
 async function makeGrpcBuildClient(client) {
-  const { SuiGrpcClient: SuiGrpcClient3 } = await import("./grpc-CM6M7ZV3.js");
+  const { SuiGrpcClient: SuiGrpcClient3 } = await import("./grpc-G3RQE2L5.js");
   const network = client.network === "testnet" ? "testnet" : "mainnet";
   const baseUrl = network === "testnet" ? "https://fullnode.testnet.sui.io" : "https://fullnode.mainnet.sui.io";
   return new SuiGrpcClient3({ baseUrl, network });
@@ -27167,7 +27699,7 @@ var ZkLoginSigner = class {
     return this.userAddress;
   }
   async signTransaction(txBytes) {
-    const { getZkLoginSignature } = await import("./esm-ORCGSDY7.js");
+    const { getZkLoginSignature } = await import("./esm-ZKAIHFAJ.js");
     const ephSig = await this.ephemeralKeypair.signTransaction(txBytes);
     return {
       signature: getZkLoginSignature({
@@ -27178,7 +27710,7 @@ var ZkLoginSigner = class {
     };
   }
   async signPersonalMessage(messageBytes) {
-    const { getZkLoginSignature } = await import("./esm-ORCGSDY7.js");
+    const { getZkLoginSignature } = await import("./esm-ZKAIHFAJ.js");
     const { signature: ephSig, bytes } = await this.ephemeralKeypair.signPersonalMessage(messageBytes);
     return {
       signature: getZkLoginSignature({
@@ -27661,7 +28193,7 @@ function resolveApiKey(apiKey) {
   if (!key) {
     throw new T2000Error(
       "INVALID_KEY",
-      "No Private API key. Pass `apiKey` or set T2000_API_KEY. Generate one at platform.t2000.ai (Pro/Max)."
+      "No Private API key. Pass `apiKey` or set T2000_API_KEY. Generate one at agents.t2000.ai/manage (Pro/Max)."
     );
   }
   return key;
@@ -32074,7 +32606,7 @@ function numOrUndef(v) {
 }
 function registerChat(program3) {
   program3.command("chat").argument("<message...>", "Your prompt").description(
-    "Chat with a model on the t2000 Private API (OpenAI-compatible, ZDR; a phala/* tier is GPU-TEE confidential). Needs an API key \u2014 generate one at platform.t2000.ai, then pass --api-key or set T2000_API_KEY."
+    "Chat with a model on the t2000 Private API (OpenAI-compatible, ZDR; a phala/* tier is GPU-TEE confidential). Needs an API key \u2014 generate one at agents.t2000.ai/manage, then pass --api-key or set T2000_API_KEY."
   ).option("--model <id>", `Model id (default ${DEFAULT_MODEL}; see \`t2 models\`)`, DEFAULT_MODEL).option("--system <text>", "System prompt").option("--max-tokens <n>", "Max output tokens").option("--temperature <t>", "Sampling temperature (0\u20132)").option("--no-stream", "Wait for the full response instead of streaming").option("--api-key <key>", "Private API key (or set T2000_API_KEY)").option("--api <url>", "API base URL (default https://api.t2000.ai/v1)").action(
     async (messageParts, opts) => {
       try {
@@ -32577,7 +33109,7 @@ function registerMcpStart(parent) {
   parent.command("start", { isDefault: true }).description("Start MCP server (stdio transport \u2014 for AI client integration)").option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").action(async (opts) => {
     let mod3;
     try {
-      mod3 = await import("./dist-TCGFVCLO.js");
+      mod3 = await import("./dist-B7O5FUPB.js");
     } catch {
       console.error("MCP server not installed. Run:\n  npm install -g @t2000/mcp");
       process.exit(1);
@@ -33124,7 +33656,7 @@ Subcommands:
       }
       if (normalizeSuiAddress(owner) === normalizeSuiAddress(address)) {
         throw new Error(
-          "That's this agent's own address. Pass YOUR Passport address (the human owner) \u2014 e.g. the one shown in platform.t2000.ai."
+          "That's this agent's own address. Pass YOUR Passport address (the human owner) \u2014 e.g. the one shown in agents.t2000.ai/manage."
         );
       }
       const { digest } = await runSponsoredTx({
@@ -33545,6 +34077,345 @@ Subcommands:
   );
 }
 
+// src/commands/agents.ts
+var DEFAULT_API_BASE4 = process.env.T2000_API_URL ?? "https://api.t2000.ai/v1";
+async function getJson(url) {
+  const res = await fetch(url, { headers: { accept: "application/json" } });
+  if (!res.ok) {
+    throw new Error(`Directory request failed (${res.status}).`);
+  }
+  return await res.json();
+}
+function firstLine(text, max = 76) {
+  const line = (text ?? "").split("\n")[0]?.trim() ?? "";
+  return line.length > max ? `${line.slice(0, max - 1)}\u2026` : line;
+}
+function registerAgents(program3) {
+  program3.command("agents").argument("[address]", "Show one agent\u2019s full listing (profile + reputation)").description(
+    "Browse the agent store (agents.t2000.ai): priced services from the live directory, or one agent\u2019s full listing. Buy with `t2 agent pay <address>`. [Agent Commerce]"
+  ).option("--category <category>", "Filter the list by store category").option("--all", "Include agents without a priced service").option("--limit <n>", "Max rows (default 30)").option("--api <url>", `API base URL (default ${DEFAULT_API_BASE4})`).action(
+    async (address, opts) => {
+      try {
+        const base = opts.api ?? DEFAULT_API_BASE4;
+        if (address) {
+          const profile = await getJson(`${base}/agents/${address}`);
+          if (isJsonMode()) {
+            printJson(profile);
+            return;
+          }
+          const rep = profile.reputation;
+          printBlank();
+          printHeader(profile.name ?? truncateAddress(profile.address));
+          printKeyValue("Address", profile.address);
+          if (profile.priceUsdc) {
+            printKeyValue(
+              "Price",
+              `${formatUsd(Number.parseFloat(profile.priceUsdc))} / call${profile.category ? `  \xB7  ${profile.category}` : ""}`
+            );
+          }
+          if (profile.description) {
+            printKeyValue("About", firstLine(profile.description, 90));
+          }
+          if (rep) {
+            printKeyValue(
+              "Verified on the rail",
+              `${rep.sales ?? 0} sold \xB7 ${rep.buyers ?? 0} buyer${(rep.buyers ?? 0) === 1 ? "" : "s"} \xB7 ${formatUsd(rep.volumeUsd ?? 0)} settled${typeof rep.deliveredRate === "number" ? ` \xB7 ${Math.round(rep.deliveredRate * 100)}% delivered` : ""}`
+            );
+          }
+          printBlank();
+          if (profile.priceUsdc) {
+            printInfo(`Buy it: t2 agent pay ${profile.address}`);
+          }
+          printInfo(`Listing: https://agents.t2000.ai/${profile.address}`);
+          printBlank();
+          return;
+        }
+        const limit = Math.min(Number.parseInt(opts.limit ?? "30", 10) || 30, 100);
+        const data = await getJson(
+          `${base}/agents?limit=100`
+        );
+        let agents = (data.agents ?? []).filter((a) => a.active !== false);
+        if (!opts.all) {
+          agents = agents.filter((a) => a.service && a.priceUsdc);
+        }
+        if (opts.category) {
+          const cat = opts.category.trim().toLowerCase();
+          agents = agents.filter((a) => a.category?.toLowerCase() === cat);
+        }
+        agents = agents.slice(0, limit);
+        if (isJsonMode()) {
+          printJson({ total: data.total, shown: agents.length, agents });
+          return;
+        }
+        printBlank();
+        printHeader(
+          `Agent store \u2014 ${agents.length} ${opts.all ? "agents" : "priced services"}${opts.category ? ` in ${opts.category}` : ""}`
+        );
+        for (const a of agents) {
+          const price = a.priceUsdc ? formatUsd(Number.parseFloat(a.priceUsdc)).padStart(6) : "     \u2014";
+          printLine(
+            `  ${price}  ${(a.name ?? truncateAddress(a.address)).padEnd(22).slice(0, 22)}  ${(a.category ?? "").padEnd(11).slice(0, 11)}  ${truncateAddress(a.address)}`
+          );
+        }
+        printBlank();
+        printInfo("Detail: t2 agents <address>   \xB7   Buy: t2 agent pay <address>");
+        printBlank();
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
+}
+
+// src/commands/task/index.ts
+var DEFAULT_GATEWAY2 = process.env.T2000_GATEWAY_URL ?? "https://mpp.t2000.ai";
+async function getJson2(url) {
+  const res = await fetch(url, { headers: { accept: "application/json" } });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(json.error ?? `Request failed (${res.status}).`);
+  }
+  return json;
+}
+async function postJson2(url, body2) {
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body2)
+  });
+  const json = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(json.error ?? `Request failed (${res.status}).`);
+  }
+  return json;
+}
+function registerTask(program3) {
+  const group = program3.command("task").description(
+    "Earn from t2000 reward tasks and work (or post) community board tasks \u2014 all paid through the rail. [Agent Commerce]"
+  );
+  group.command("list").description("Live tasks: t2000 rewards (auto-verified) + the community board (poster-approved)").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).action(async (opts) => {
+    try {
+      const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+      const [rewards, board] = await Promise.all([
+        getJson2(`${gateway}/tasks/stats`),
+        getJson2(`${gateway}/tasks/board`)
+      ]);
+      if (isJsonMode()) {
+        printJson({ rewards: rewards.tasks, board: board.tasks });
+        return;
+      }
+      printBlank();
+      printHeader("t2000 reward tasks (auto-verified, one per wallet)");
+      for (const t of rewards.tasks) {
+        printLine(
+          `  ${formatUsd(t.rewardNetUsd).padStart(6)}  ${t.id.padEnd(20)}  ${t.kind.padEnd(8)}  ${t.status === "live" ? "live" : "budget spent"}`
+        );
+      }
+      printBlank();
+      printHeader(`Community board (${board.tasks.length} live, poster approves)`);
+      if (board.tasks.length === 0) {
+        printLine("  (none live \u2014 post one: t2 task post --help)");
+      }
+      for (const t of board.tasks) {
+        const days = Math.max(0, Math.ceil((Date.parse(t.expiresAt) - Date.now()) / 864e5));
+        printLine(
+          `  ${formatUsd(t.rewardUsd).padStart(6)}  ${t.title.slice(0, 44).padEnd(44)}  ${t.remainingCompletions}/${t.maxCompletions} spots \xB7 ${days}d  ${t.id}`
+        );
+      }
+      printBlank();
+      printInfo("Claim a reward: t2 task claim <task>   \xB7   Work the board: t2 task submit <taskId>");
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  group.command("claim").argument("<task>", "Reward task id (e.g. buy-sui, share-a-read) \u2014 see `t2 task list`").description("Claim a t2000 reward task (verified in one request; also retries automated tasks)").option("--tx <digest>", "Swap tx digest (buy-manifest / buy-sui)").option("--post <url>", "Your X post URL (X-proof tasks)").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").action(
+    async (task, opts) => {
+      try {
+        const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+        const agent = await withAgent({ keyPath: opts.key });
+        const result = await postJson2(`${gateway}/tasks/claim`, {
+          task,
+          address: agent.address(),
+          ...opts.tx ? { txDigest: opts.tx } : {},
+          ...opts.post ? { postUrl: opts.post } : {}
+        });
+        if (isJsonMode()) {
+          printJson(result);
+          return;
+        }
+        printBlank();
+        if (result.paid) {
+          printSuccess(`Paid ${formatUsd(result.netUsd ?? 0)} to your agent.`);
+          if (result.suiscan) {
+            printKeyValue("Receipt", result.suiscan);
+          }
+        } else {
+          printWarning(result.note ?? "Not paid.");
+        }
+        printBlank();
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
+  group.command("post").description(
+    "Post a community task \u2014 pays the FULL budget (reward \xD7 completions) into escrow via x402; auto-moderated at post time. SAVE the returned manageKey."
+  ).requiredOption("--title <text>", "What needs doing (8+ chars)").requiredOption("--description <text>", "Exactly what the worker must deliver + what proof (30+ chars)").requiredOption("--reward <usdc>", "Reward per approved completion ($0.01\u2013$50)").option("--completions <n>", "Max completions (default 1)", "1").option("--expiry-days <n>", "Days until unspent budget auto-refunds (default 7)", "7").option("--category <category>", "research | data | marketing | dev | creative | other", "other").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).option("--force", "Override spending limits for this call (see `t2 limit`)").option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").action(
+    async (opts) => {
+      try {
+        const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+        const reward = Number.parseFloat(opts.reward);
+        const completions = Number.parseInt(opts.completions, 10);
+        if (!Number.isFinite(reward) || reward <= 0) {
+          throw new Error(`--reward must be a positive number (got "${opts.reward}").`);
+        }
+        const budget = Math.round(reward * completions * 1e6) / 1e6;
+        const agent = await withAgent({ keyPath: opts.key });
+        const result = await agent.pay({
+          url: `${gateway}/tasks/board`,
+          method: "POST",
+          body: JSON.stringify({
+            title: opts.title,
+            description: opts.description,
+            rewardUsd: reward,
+            maxCompletions: completions,
+            expiryDays: Number.parseInt(opts.expiryDays, 10),
+            category: opts.category
+          }),
+          maxPrice: budget,
+          force: opts.force
+        });
+        const body2 = result.body;
+        if (isJsonMode()) {
+          printJson(body2 ?? result);
+          return;
+        }
+        printBlank();
+        if (body2?.ok && body2.manageKey) {
+          printSuccess(body2.moderation ?? "Task posted.");
+          printKeyValue("Task", body2.task?.id ?? "\u2014");
+          printKeyValue("Escrow", formatUsd(budget));
+          printBlank();
+          printWarning("SAVE THIS manageKey \u2014 shown once. It approves/rejects/closes this task:");
+          printLine(`  ${body2.manageKey}`);
+          printBlank();
+          printInfo(`Review: t2 task review ${body2.task?.id ?? "<taskId>"} --manage-key <key>`);
+        } else {
+          printWarning(
+            `${body2?.error ?? "Posting failed."}${body2?.refunded ? " (Budget refunded.)" : ""}`
+          );
+        }
+        printBlank();
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
+  group.command("submit").argument("<taskId>", "Board task id (see `t2 task list`)").description("Submit proof of completion to a board task (one submission per wallet)").requiredOption("--proof <text>", "What you did + how the poster can verify it (10+ chars)").option("--url <url>", "Proof link (https)").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).option("--key <path>", "Custom wallet path (default ~/.t2000/wallet.key)").action(
+    async (taskId, opts) => {
+      try {
+        const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+        const agent = await withAgent({ keyPath: opts.key });
+        const result = await postJson2(
+          `${gateway}/tasks/board/${taskId}/submit`,
+          {
+            address: agent.address(),
+            proof: opts.proof,
+            ...opts.url ? { url: opts.url } : {}
+          }
+        );
+        if (isJsonMode()) {
+          printJson(result);
+          return;
+        }
+        printBlank();
+        printSuccess(result.note ?? "Submitted \u2014 the poster reviews next.");
+        printBlank();
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
+  group.command("review").argument("<taskId>", "Your board task id").description("List submissions on your board task (poster view \u2014 needs the manageKey)").requiredOption("--manage-key <key>", "The manageKey returned when you posted").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).action(async (taskId, opts) => {
+    try {
+      const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+      const result = await getJson2(`${gateway}/tasks/board/${taskId}?manageKey=${encodeURIComponent(opts.manageKey)}`);
+      if (!result.posterView) {
+        throw new Error(result.error ?? "manageKey not accepted for this task.");
+      }
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      const subs = result.submissions ?? [];
+      printBlank();
+      printHeader(`${result.task?.title ?? taskId} \u2014 ${subs.length} submission${subs.length === 1 ? "" : "s"}`);
+      for (const s of subs) {
+        printLine(`  [${s.status.padEnd(8)}] ${s.id}  ${truncateAddress(s.worker)}`);
+        if (s.proof) {
+          printLine(`             ${s.proof.slice(0, 90)}`);
+        }
+        if (s.url) {
+          printLine(`             ${s.url}`);
+        }
+      }
+      printBlank();
+      printInfo(`Pay: t2 task approve ${taskId} --manage-key <key> --submissions <id,id,\u2026>`);
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+  group.command("approve").argument("<taskId>", "Your board task id").description("Approve (pay) or reject submissions on your board task \u2014 batch up to 50").requiredOption("--manage-key <key>", "The manageKey returned when you posted").requiredOption("--submissions <ids>", "Comma-separated submission ids").option("--reject", "Reject instead of approving").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).action(
+    async (taskId, opts) => {
+      try {
+        const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+        const result = await postJson2(`${gateway}/tasks/board/${taskId}/approve`, {
+          manageKey: opts.manageKey,
+          submissionIds: opts.submissions.split(",").map((s) => s.trim()).filter(Boolean),
+          action: opts.reject ? "reject" : "approve"
+        });
+        if (isJsonMode()) {
+          printJson(result);
+          return;
+        }
+        printBlank();
+        for (const r of result.results ?? []) {
+          if (r.status === "paid") {
+            printSuccess(`${r.submissionId} paid${r.payoutTx ? ` (tx ${r.payoutTx.slice(0, 10)}\u2026)` : ""}`);
+          } else if (r.error) {
+            printWarning(`${r.submissionId}: ${r.error}`);
+          } else {
+            printLine(`  ${r.submissionId}: ${r.status}`);
+          }
+        }
+        printBlank();
+      } catch (error) {
+        handleError(error);
+      }
+    }
+  );
+  group.command("close").argument("<taskId>", "Your board task id").description("Close your board task early \u2014 the unspent budget refunds to your wallet").requiredOption("--manage-key <key>", "The manageKey returned when you posted").option("--gateway <url>", `Gateway base URL (default ${DEFAULT_GATEWAY2})`).action(async (taskId, opts) => {
+    try {
+      const gateway = opts.gateway ?? DEFAULT_GATEWAY2;
+      const result = await postJson2(`${gateway}/tasks/board/${taskId}/close`, { manageKey: opts.manageKey });
+      if (isJsonMode()) {
+        printJson(result);
+        return;
+      }
+      printBlank();
+      printSuccess(`Task closed${result.refunded ? " \u2014 unspent budget refunded" : ""}.`);
+      if (result.suiscan) {
+        printKeyValue("Refund", result.suiscan);
+      }
+      printBlank();
+    } catch (error) {
+      handleError(error);
+    }
+  });
+}
+
 // src/program.ts
 var require3 = createRequire2(import.meta.url);
 var { version: CLI_VERSION2 } = require3("../package.json");
@@ -33566,6 +34437,10 @@ Examples:
   $ t2 models                          List the Private API model catalog
   $ t2 pay <url> --estimate            Preview an x402 service's price + input schema (no payment)
   $ t2 services search "image"         Discover x402 services in the gateway catalog
+  $ t2 agents                          Browse the agent store (agents.t2000.ai)
+  $ t2 agent pay <address>             Buy an agent's service (escrowed, auto-refund on failure)
+  $ t2 task list                       Live reward tasks + the community board
+  $ t2 task claim share-a-read --post <url>   Claim an X-proof reward
   $ t2 limit set --daily 100           Change the daily spend cap (default $100/day)
   $ t2 mcp install                     Connect Claude / Cursor / Windsurf
   $ t2 skills install                  Install skills as local SKILL.md files`);
@@ -33585,6 +34460,8 @@ Examples:
   registerMcp(program3);
   registerSkills(program3);
   registerAgent(program3);
+  registerAgents(program3);
+  registerTask(program3);
   return program3;
 }