@blockrun/clawrouter 0.11.14 → 0.12.1

package/dist/index.js

@@ -95,7 +95,10 @@ var init_solana_balance = __esm({
           }
           return total;
         } catch (err) {
-          throw new Error(`Failed to fetch Solana USDC balance: ${err instanceof Error ? err.message : String(err)}`);
+          throw new Error(
+            `Failed to fetch Solana USDC balance: ${err instanceof Error ? err.message : String(err)}`,
+            { cause: err }
+          );
         } finally {
           clearTimeout(timer);
         }
@@ -114,12 +117,546 @@ var init_solana_balance = __esm({
   }
 });
 
+// node_modules/@noble/hashes/esm/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n) {
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new Error("positive integer expected, got " + n);
+}
+function abytes(b, ...lengths) {
+  if (!isBytes(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 ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  anumber(h.outputLen);
+  anumber(h.blockLen);
+}
+function aexists(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) {
+  abytes(out);
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error("digestInto() expects output buffer of length at least " + min);
+  }
+}
+function clean(...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 Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes(data);
+  abytes(data);
+  return data;
+}
+function createHasher(hashCons) {
+  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+  const tmp = hashCons();
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+var Hash;
+var init_utils = __esm({
+  "node_modules/@noble/hashes/esm/utils.js"() {
+    "use strict";
+    Hash = class {
+    };
+  }
+});
+
+// node_modules/@noble/hashes/esm/hmac.js
+var HMAC, hmac;
+var init_hmac = __esm({
+  "node_modules/@noble/hashes/esm/hmac.js"() {
+    "use strict";
+    init_utils();
+    HMAC = class extends Hash {
+      constructor(hash, _key) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        ahash(hash);
+        const key = toBytes(_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);
+        clean(pad);
+      }
+      update(buf) {
+        aexists(this);
+        this.iHash.update(buf);
+        return this;
+      }
+      digestInto(out) {
+        aexists(this);
+        abytes(out, this.outputLen);
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+      }
+      digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+      }
+      _cloneInto(to) {
+        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        const { oHash, iHash, finished: finished2, destroyed, blockLen, outputLen } = this;
+        to = to;
+        to.finished = finished2;
+        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();
+      }
+    };
+    hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+    hmac.create = (hash, key) => new HMAC(hash, key);
+  }
+});
+
+// node_modules/@noble/hashes/esm/_md.js
+function setBigUint64(view, byteOffset, value, isLE) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE);
+  const _32n2 = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  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);
+}
+var HashMD, SHA512_IV;
+var init_md = __esm({
+  "node_modules/@noble/hashes/esm/_md.js"() {
+    "use strict";
+    init_utils();
+    HashMD = class extends Hash {
+      constructor(blockLen, outputLen, padOffset, isLE) {
+        super();
+        this.finished = false;
+        this.length = 0;
+        this.pos = 0;
+        this.destroyed = false;
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
+        this.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+      }
+      update(data) {
+        aexists(this);
+        data = toBytes(data);
+        abytes(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) {
+        aexists(this);
+        aoutput(out, this);
+        this.finished = true;
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        buffer[pos++] = 128;
+        clean(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;
+        setBigUint64(view, 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 should be aligned to 32bit");
+        const outLen = len / 4;
+        const state = this.get();
+        if (outLen > state.length)
+          throw new Error("_sha2: outputLen bigger than state");
+        for (let i = 0; i < outLen; i++)
+          oview.setUint32(4 * i, state[i], isLE);
+      }
+      digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+      }
+      _cloneInto(to) {
+        to || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished: finished2, destroyed, pos } = this;
+        to.destroyed = destroyed;
+        to.finished = finished2;
+        to.length = length;
+        to.pos = pos;
+        if (length % blockLen)
+          to.buffer.set(buffer);
+        return to;
+      }
+      clone() {
+        return this._cloneInto();
+      }
+    };
+    SHA512_IV = /* @__PURE__ */ Uint32Array.from([
+      1779033703,
+      4089235720,
+      3144134277,
+      2227873595,
+      1013904242,
+      4271175723,
+      2773480762,
+      1595750129,
+      1359893119,
+      2917565137,
+      2600822924,
+      725511199,
+      528734635,
+      4215389547,
+      1541459225,
+      327033209
+    ]);
+  }
+});
+
+// node_modules/@noble/hashes/esm/_u64.js
+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 split(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];
+}
+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 U32_MASK64, _32n, shrSH, shrSL, rotrSH, rotrSL, rotrBH, rotrBL, add3L, add3H, add4L, add4H, add5L, add5H;
+var init_u64 = __esm({
+  "node_modules/@noble/hashes/esm/_u64.js"() {
+    "use strict";
+    U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
+    _32n = /* @__PURE__ */ BigInt(32);
+    shrSH = (h, _l, s) => h >>> s;
+    shrSL = (h, l, s) => h << 32 - s | l >>> s;
+    rotrSH = (h, l, s) => h >>> s | l << 32 - s;
+    rotrSL = (h, l, s) => h << 32 - s | l >>> s;
+    rotrBH = (h, l, s) => h << 64 - s | l >>> s - 32;
+    rotrBL = (h, l, s) => h >>> s - 32 | l << 64 - s;
+    add3L = (Al, Bl, Cl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0);
+    add3H = (low, Ah, Bh, Ch) => Ah + Bh + Ch + (low / 2 ** 32 | 0) | 0;
+    add4L = (Al, Bl, Cl, Dl) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0);
+    add4H = (low, Ah, Bh, Ch, Dh) => Ah + Bh + Ch + Dh + (low / 2 ** 32 | 0) | 0;
+    add5L = (Al, Bl, Cl, Dl, El) => (Al >>> 0) + (Bl >>> 0) + (Cl >>> 0) + (Dl >>> 0) + (El >>> 0);
+    add5H = (low, Ah, Bh, Ch, Dh, Eh) => Ah + Bh + Ch + Dh + Eh + (low / 2 ** 32 | 0) | 0;
+  }
+});
+
+// node_modules/@noble/hashes/esm/sha2.js
+var K512, SHA512_Kh, SHA512_Kl, SHA512_W_H, SHA512_W_L, SHA512, sha512;
+var init_sha2 = __esm({
+  "node_modules/@noble/hashes/esm/sha2.js"() {
+    "use strict";
+    init_md();
+    init_u64();
+    init_utils();
+    K512 = /* @__PURE__ */ (() => split([
+      "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))))();
+    SHA512_Kh = /* @__PURE__ */ (() => K512[0])();
+    SHA512_Kl = /* @__PURE__ */ (() => K512[1])();
+    SHA512_W_H = /* @__PURE__ */ new Uint32Array(80);
+    SHA512_W_L = /* @__PURE__ */ new Uint32Array(80);
+    SHA512 = class extends HashMD {
+      constructor(outputLen = 64) {
+        super(128, outputLen, 16, false);
+        this.Ah = SHA512_IV[0] | 0;
+        this.Al = SHA512_IV[1] | 0;
+        this.Bh = SHA512_IV[2] | 0;
+        this.Bl = SHA512_IV[3] | 0;
+        this.Ch = SHA512_IV[4] | 0;
+        this.Cl = SHA512_IV[5] | 0;
+        this.Dh = SHA512_IV[6] | 0;
+        this.Dl = SHA512_IV[7] | 0;
+        this.Eh = SHA512_IV[8] | 0;
+        this.El = SHA512_IV[9] | 0;
+        this.Fh = SHA512_IV[10] | 0;
+        this.Fl = SHA512_IV[11] | 0;
+        this.Gh = SHA512_IV[12] | 0;
+        this.Gl = SHA512_IV[13] | 0;
+        this.Hh = SHA512_IV[14] | 0;
+        this.Hl = SHA512_IV[15] | 0;
+      }
+      // 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_H[i] = view.getUint32(offset);
+          SHA512_W_L[i] = view.getUint32(offset += 4);
+        }
+        for (let i = 16; i < 80; i++) {
+          const W15h = SHA512_W_H[i - 15] | 0;
+          const W15l = SHA512_W_L[i - 15] | 0;
+          const s0h = rotrSH(W15h, W15l, 1) ^ rotrSH(W15h, W15l, 8) ^ shrSH(W15h, W15l, 7);
+          const s0l = rotrSL(W15h, W15l, 1) ^ rotrSL(W15h, W15l, 8) ^ shrSL(W15h, W15l, 7);
+          const W2h = SHA512_W_H[i - 2] | 0;
+          const W2l = SHA512_W_L[i - 2] | 0;
+          const s1h = rotrSH(W2h, W2l, 19) ^ rotrBH(W2h, W2l, 61) ^ shrSH(W2h, W2l, 6);
+          const s1l = rotrSL(W2h, W2l, 19) ^ rotrBL(W2h, W2l, 61) ^ shrSL(W2h, W2l, 6);
+          const SUMl = add4L(s0l, s1l, SHA512_W_L[i - 7], SHA512_W_L[i - 16]);
+          const SUMh = add4H(SUMl, s0h, s1h, SHA512_W_H[i - 7], SHA512_W_H[i - 16]);
+          SHA512_W_H[i] = SUMh | 0;
+          SHA512_W_L[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 = rotrSH(Eh, El, 14) ^ rotrSH(Eh, El, 18) ^ rotrBH(Eh, El, 41);
+          const sigma1l = rotrSL(Eh, El, 14) ^ rotrSL(Eh, El, 18) ^ rotrBL(Eh, El, 41);
+          const CHIh = Eh & Fh ^ ~Eh & Gh;
+          const CHIl = El & Fl ^ ~El & Gl;
+          const T1ll = add5L(Hl, sigma1l, CHIl, SHA512_Kl[i], SHA512_W_L[i]);
+          const T1h = add5H(T1ll, Hh, sigma1h, CHIh, SHA512_Kh[i], SHA512_W_H[i]);
+          const T1l = T1ll | 0;
+          const sigma0h = rotrSH(Ah, Al, 28) ^ rotrBH(Ah, Al, 34) ^ rotrBH(Ah, Al, 39);
+          const sigma0l = rotrSL(Ah, Al, 28) ^ rotrBL(Ah, Al, 34) ^ rotrBL(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 } = add(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 = add3L(T1l, sigma0l, MAJl);
+          Ah = add3H(All, T1h, sigma0h, MAJh);
+          Al = All | 0;
+        }
+        ({ h: Ah, l: Al } = add(this.Ah | 0, this.Al | 0, Ah | 0, Al | 0));
+        ({ h: Bh, l: Bl } = add(this.Bh | 0, this.Bl | 0, Bh | 0, Bl | 0));
+        ({ h: Ch, l: Cl } = add(this.Ch | 0, this.Cl | 0, Ch | 0, Cl | 0));
+        ({ h: Dh, l: Dl } = add(this.Dh | 0, this.Dl | 0, Dh | 0, Dl | 0));
+        ({ h: Eh, l: El } = add(this.Eh | 0, this.El | 0, Eh | 0, El | 0));
+        ({ h: Fh, l: Fl } = add(this.Fh | 0, this.Fl | 0, Fh | 0, Fl | 0));
+        ({ h: Gh, l: Gl } = add(this.Gh | 0, this.Gl | 0, Gh | 0, Gl | 0));
+        ({ h: Hh, l: Hl } = add(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() {
+        clean(SHA512_W_H, SHA512_W_L);
+      }
+      destroy() {
+        clean(this.buffer);
+        this.set(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+      }
+    };
+    sha512 = /* @__PURE__ */ createHasher(() => new SHA512());
+  }
+});
+
+// node_modules/@noble/hashes/esm/sha512.js
+var sha5122;
+var init_sha512 = __esm({
+  "node_modules/@noble/hashes/esm/sha512.js"() {
+    "use strict";
+    init_sha2();
+    sha5122 = sha512;
+  }
+});
+
 // src/wallet.ts
 var wallet_exports = {};
 __export(wallet_exports, {
   deriveAllKeys: () => deriveAllKeys,
   deriveEvmKey: () => deriveEvmKey,
   deriveSolanaKeyBytes: () => deriveSolanaKeyBytes,
+  deriveSolanaKeyBytesLegacy: () => deriveSolanaKeyBytesLegacy,
   generateWalletMnemonic: () => generateWalletMnemonic,
   isValidMnemonic: () => isValidMnemonic
 });
@@ -143,10 +680,29 @@ function deriveEvmKey(mnemonic) {
   return { privateKey: hex, address: account.address };
 }
 function deriveSolanaKeyBytes(mnemonic) {
+  const seed = mnemonicToSeedSync(mnemonic);
+  let I = hmac(sha5122, "ed25519 seed", seed);
+  let key = I.slice(0, 32);
+  let chainCode = I.slice(32);
+  for (const index of SOLANA_HARDENED_INDICES) {
+    const data = new Uint8Array(37);
+    data[0] = 0;
+    data.set(key, 1);
+    data[33] = index >>> 24 & 255;
+    data[34] = index >>> 16 & 255;
+    data[35] = index >>> 8 & 255;
+    data[36] = index & 255;
+    I = hmac(sha5122, chainCode, data);
+    key = I.slice(0, 32);
+    chainCode = I.slice(32);
+  }
+  return new Uint8Array(key);
+}
+function deriveSolanaKeyBytesLegacy(mnemonic) {
   const seed = mnemonicToSeedSync(mnemonic);
   const hdKey = HDKey.fromMasterSeed(seed);
-  const derived = hdKey.derive(SOLANA_DERIVATION_PATH);
-  if (!derived.privateKey) throw new Error("Failed to derive Solana private key");
+  const derived = hdKey.derive("m/44'/501'/0'/0'");
+  if (!derived.privateKey) throw new Error("Failed to derive legacy Solana private key");
   return new Uint8Array(derived.privateKey);
 }
 function deriveAllKeys(mnemonic) {
@@ -154,12 +710,247 @@ function deriveAllKeys(mnemonic) {
   const solanaPrivateKeyBytes = deriveSolanaKeyBytes(mnemonic);
   return { mnemonic, evmPrivateKey, evmAddress, solanaPrivateKeyBytes };
 }
-var ETH_DERIVATION_PATH, SOLANA_DERIVATION_PATH;
+var ETH_DERIVATION_PATH, SOLANA_HARDENED_INDICES;
 var init_wallet = __esm({
   "src/wallet.ts"() {
     "use strict";
+    init_hmac();
+    init_sha512();
     ETH_DERIVATION_PATH = "m/44'/60'/0'/0/0";
-    SOLANA_DERIVATION_PATH = "m/44'/501'/0'/0'";
+    SOLANA_HARDENED_INDICES = [
+      44 + 2147483648,
+      501 + 2147483648,
+      0 + 2147483648,
+      0 + 2147483648
+    ];
+  }
+});
+
+// src/solana-sweep.ts
+var solana_sweep_exports = {};
+__export(solana_sweep_exports, {
+  sweepSolanaWallet: () => sweepSolanaWallet
+});
+import {
+  address as solAddress2,
+  createSolanaRpc as createSolanaRpc2,
+  createSolanaRpcSubscriptions,
+  createKeyPairSignerFromPrivateKeyBytes,
+  pipe,
+  createTransactionMessage,
+  setTransactionMessageFeePayer,
+  setTransactionMessageLifetimeUsingBlockhash,
+  appendTransactionMessageInstructions,
+  signTransactionMessageWithSigners,
+  getSignatureFromTransaction,
+  sendAndConfirmTransactionFactory,
+  getProgramDerivedAddress,
+  getAddressEncoder
+} from "@solana/kit";
+async function getAssociatedTokenAddress(owner, mint) {
+  const encoder = getAddressEncoder();
+  const [ata] = await getProgramDerivedAddress({
+    programAddress: ASSOCIATED_TOKEN_PROGRAM,
+    seeds: [encoder.encode(owner), encoder.encode(TOKEN_PROGRAM), encoder.encode(mint)]
+  });
+  return ata;
+}
+function buildCreateAtaIdempotentInstruction(payer, ata, owner, mint) {
+  return {
+    programAddress: ASSOCIATED_TOKEN_PROGRAM,
+    accounts: [
+      {
+        address: payer,
+        role: 3
+        /* writable signer */
+      },
+      {
+        address: ata,
+        role: 1
+        /* writable */
+      },
+      {
+        address: owner,
+        role: 0
+        /* readonly */
+      },
+      {
+        address: mint,
+        role: 0
+        /* readonly */
+      },
+      {
+        address: SYSTEM_PROGRAM,
+        role: 0
+        /* readonly */
+      },
+      {
+        address: TOKEN_PROGRAM,
+        role: 0
+        /* readonly */
+      }
+    ],
+    data: new Uint8Array([1])
+    // instruction index 1 = CreateIdempotent
+  };
+}
+function buildTokenTransferInstruction(source, destination, authority, amount) {
+  const data = new Uint8Array(9);
+  data[0] = 3;
+  const view = new DataView(data.buffer, data.byteOffset);
+  view.setBigUint64(1, amount, true);
+  return {
+    programAddress: TOKEN_PROGRAM,
+    accounts: [
+      {
+        address: source,
+        role: 1
+        /* writable */
+      },
+      {
+        address: destination,
+        role: 1
+        /* writable */
+      },
+      {
+        address: authority,
+        role: 2
+        /* signer */
+      }
+    ],
+    data
+  };
+}
+async function sweepSolanaWallet(oldKeyBytes, newKeyBytes, rpcUrl) {
+  const url = rpcUrl || process["env"].CLAWROUTER_SOLANA_RPC_URL || SOLANA_DEFAULT_RPC2;
+  const rpc = createSolanaRpc2(url);
+  const [oldSigner, newSigner] = await Promise.all([
+    createKeyPairSignerFromPrivateKeyBytes(oldKeyBytes),
+    createKeyPairSignerFromPrivateKeyBytes(newKeyBytes)
+  ]);
+  const oldAddress = oldSigner.address;
+  const newAddress = newSigner.address;
+  const mint = solAddress2(SOLANA_USDC_MINT2);
+  let newSolBalance;
+  try {
+    const solResp = await rpc.getBalance(solAddress2(newAddress)).send();
+    newSolBalance = solResp.value;
+  } catch (err) {
+    return {
+      error: `Failed to check SOL balance: ${err instanceof Error ? err.message : String(err)}`,
+      oldAddress,
+      newAddress
+    };
+  }
+  let usdcBalance = 0n;
+  let oldTokenAccount;
+  try {
+    const response = await rpc.getTokenAccountsByOwner(
+      solAddress2(oldAddress),
+      { mint },
+      { encoding: "jsonParsed" }
+    ).send();
+    if (response.value.length > 0) {
+      for (const account of response.value) {
+        const parsed = account.account.data;
+        const amount = BigInt(parsed.parsed.info.tokenAmount.amount);
+        if (amount > 0n) {
+          usdcBalance += amount;
+          oldTokenAccount = account.pubkey;
+        }
+      }
+    }
+  } catch (err) {
+    return {
+      error: `Failed to check USDC balance: ${err instanceof Error ? err.message : String(err)}`,
+      oldAddress,
+      newAddress
+    };
+  }
+  if (usdcBalance === 0n) {
+    return {
+      error: "No USDC found in old wallet. Nothing to sweep.",
+      oldAddress,
+      newAddress,
+      solBalance: newSolBalance,
+      usdcBalance: 0n
+    };
+  }
+  const MIN_SOL_FOR_GAS = 5000000n;
+  if (newSolBalance < MIN_SOL_FOR_GAS) {
+    const needed = Number(MIN_SOL_FOR_GAS - newSolBalance) / 1e9;
+    return {
+      error: `Insufficient SOL for transaction fees in your new wallet. Send ~${needed.toFixed(4)} SOL to ${newAddress} (your new Phantom-compatible address) to cover gas. Current SOL balance: ${(Number(newSolBalance) / 1e9).toFixed(6)} SOL`,
+      oldAddress,
+      newAddress,
+      solBalance: newSolBalance,
+      usdcBalance
+    };
+  }
+  if (!oldTokenAccount) {
+    return {
+      error: "Could not find USDC token account in old wallet.",
+      oldAddress,
+      newAddress
+    };
+  }
+  try {
+    const newAta = await getAssociatedTokenAddress(solAddress2(newAddress), mint);
+    const { value: latestBlockhash } = await rpc.getLatestBlockhash().send();
+    const createAtaIx = buildCreateAtaIdempotentInstruction(
+      newSigner.address,
+      // new wallet pays for ATA creation
+      newAta,
+      solAddress2(newAddress),
+      mint
+    );
+    const transferIx = buildTokenTransferInstruction(
+      solAddress2(oldTokenAccount),
+      newAta,
+      oldSigner.address,
+      // old wallet authorizes the token transfer
+      usdcBalance
+    );
+    const txMessage = pipe(
+      createTransactionMessage({ version: 0 }),
+      (msg) => setTransactionMessageFeePayer(newSigner.address, msg),
+      // new wallet pays gas
+      (msg) => setTransactionMessageLifetimeUsingBlockhash(latestBlockhash, msg),
+      (msg) => appendTransactionMessageInstructions([createAtaIx, transferIx], msg)
+    );
+    const signedTx = await signTransactionMessageWithSigners(txMessage);
+    const txSignature = getSignatureFromTransaction(signedTx);
+    const wsUrl = url.replace("https://", "wss://").replace("http://", "ws://");
+    const rpcSubscriptions = createSolanaRpcSubscriptions(wsUrl);
+    const sendAndConfirm = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
+    await sendAndConfirm(signedTx, { commitment: "confirmed" });
+    const dollars = Number(usdcBalance) / 1e6;
+    return {
+      transferred: `$${dollars.toFixed(2)}`,
+      transferredMicros: usdcBalance,
+      txSignature,
+      oldAddress,
+      newAddress
+    };
+  } catch (err) {
+    return {
+      error: `Transaction failed: ${err instanceof Error ? err.message : String(err)}`,
+      oldAddress,
+      newAddress,
+      solBalance: newSolBalance,
+      usdcBalance
+    };
+  }
+}
+var SOLANA_USDC_MINT2, SOLANA_DEFAULT_RPC2, TOKEN_PROGRAM, ASSOCIATED_TOKEN_PROGRAM, SYSTEM_PROGRAM;
+var init_solana_sweep = __esm({
+  "src/solana-sweep.ts"() {
+    "use strict";
+    SOLANA_USDC_MINT2 = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+    SOLANA_DEFAULT_RPC2 = "https://api.mainnet-beta.solana.com";
+    TOKEN_PROGRAM = "TokenkegQfeN4jV6bme4LphiJbfPe2VopRsimuVSoZ5K";
+    ASSOCIATED_TOKEN_PROGRAM = "ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL";
+    SYSTEM_PROGRAM = "11111111111111111111111111111111";
   }
 });
 
@@ -859,7 +1650,8 @@ function createPayFetchWithPreAuth(baseFetch, client, ttlMs = DEFAULT_TTL_MS, op
       cache.set(urlPath, { paymentRequired, cachedAt: Date.now() });
     } catch (error) {
       throw new Error(
-        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`
+        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`,
+        { cause: error }
       );
     }
     const payload = await client.createPaymentPayload(paymentRequired);
@@ -3329,6 +4121,32 @@ async function generateAndSaveWallet() {
     solanaPrivateKeyBytes: derived.solanaPrivateKeyBytes
   };
 }
+async function logMigrationWarning(legacyKeyBytes, newKeyBytes) {
+  try {
+    const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+    const [oldSigner, newSigner] = await Promise.all([
+      createKeyPairSignerFromPrivateKeyBytes2(legacyKeyBytes),
+      createKeyPairSignerFromPrivateKeyBytes2(newKeyBytes)
+    ]);
+    console.log(`[ClawRouter]`);
+    console.log(`[ClawRouter] \u26A0 SOLANA WALLET MIGRATION DETECTED`);
+    console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+    console.log(`[ClawRouter]   Old address (secp256k1): ${oldSigner.address}`);
+    console.log(`[ClawRouter]   New address (SLIP-10):   ${newSigner.address}`);
+    console.log(`[ClawRouter]`);
+    console.log(`[ClawRouter]   Your Solana wallet derivation has been fixed to use`);
+    console.log(`[ClawRouter]   SLIP-10 Ed25519 (Phantom/Solflare compatible).`);
+    console.log(`[ClawRouter]`);
+    console.log(`[ClawRouter]   If you had funds in the old wallet, run:`);
+    console.log(`[ClawRouter]     /wallet migrate-solana`);
+    console.log(`[ClawRouter]`);
+    console.log(`[ClawRouter]   The new wallet pays gas. Send ~0.005 SOL to:`);
+    console.log(`[ClawRouter]     ${newSigner.address}`);
+    console.log(`[ClawRouter] \u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550`);
+    console.log(`[ClawRouter]`);
+  } catch {
+  }
+}
 async function resolveOrGenerateWalletKey() {
   const saved = await loadSavedWallet();
   if (saved) {
@@ -3336,13 +4154,19 @@ async function resolveOrGenerateWalletKey() {
     const mnemonic = await loadMnemonic();
     if (mnemonic) {
       const solanaKeyBytes = deriveSolanaKeyBytes(mnemonic);
-      return {
+      const result2 = {
         key: saved,
         address: account.address,
         source: "saved",
         mnemonic,
         solanaPrivateKeyBytes: solanaKeyBytes
       };
+      const legacyKeyBytes = deriveSolanaKeyBytesLegacy(mnemonic);
+      if (Buffer.from(legacyKeyBytes).toString("hex") !== Buffer.from(solanaKeyBytes).toString("hex")) {
+        result2.legacySolanaKeyBytes = legacyKeyBytes;
+        await logMigrationWarning(legacyKeyBytes, solanaKeyBytes);
+      }
+      return result2;
     }
     return { key: saved, address: account.address, source: "saved" };
   }
@@ -3352,13 +4176,19 @@ async function resolveOrGenerateWalletKey() {
     const mnemonic = await loadMnemonic();
     if (mnemonic) {
       const solanaKeyBytes = deriveSolanaKeyBytes(mnemonic);
-      return {
+      const result2 = {
         key: envKey,
         address: account.address,
         source: "env",
         mnemonic,
         solanaPrivateKeyBytes: solanaKeyBytes
       };
+      const legacyKeyBytes = deriveSolanaKeyBytesLegacy(mnemonic);
+      if (Buffer.from(legacyKeyBytes).toString("hex") !== Buffer.from(solanaKeyBytes).toString("hex")) {
+        result2.legacySolanaKeyBytes = legacyKeyBytes;
+        await logMigrationWarning(legacyKeyBytes, solanaKeyBytes);
+      }
+      return result2;
     }
     return { key: envKey, address: account.address, source: "env" };
   }
@@ -3374,9 +4204,7 @@ async function resolveOrGenerateWalletKey() {
 async function setupSolana() {
   const existing = await loadMnemonic();
   if (existing) {
-    throw new Error(
-      "Solana wallet already set up. Mnemonic file exists at " + MNEMONIC_FILE
-    );
+    throw new Error("Solana wallet already set up. Mnemonic file exists at " + MNEMONIC_FILE);
   }
   const savedKey = await loadSavedWallet();
   if (!savedKey) {
@@ -5121,7 +5949,9 @@ async function startProxy(options) {
   const paymentChain = options.paymentChain ?? await resolvePaymentChain();
   const apiBase = options.apiBase ?? (paymentChain === "solana" && solanaPrivateKeyBytes ? BLOCKRUN_SOLANA_API : BLOCKRUN_API);
   if (paymentChain === "solana" && !solanaPrivateKeyBytes) {
-    console.warn(`[ClawRouter] Payment chain is Solana but no Solana keys provided. Using Base (EVM).`);
+    console.warn(
+      `[ClawRouter] Payment chain is Solana but no Solana keys provided. Using Base (EVM).`
+    );
   } else if (paymentChain === "solana") {
     console.log(`[ClawRouter] Payment chain: Solana (${BLOCKRUN_SOLANA_API})`);
   }
@@ -5142,15 +5972,17 @@ async function startProxy(options) {
         );
       }
     } else if (paymentChain !== "base") {
-      console.warn(`[ClawRouter] Existing proxy on port ${listenPort} does not report paymentChain (pre-v0.11 instance). Assuming Base.`);
+      console.warn(
+        `[ClawRouter] Existing proxy on port ${listenPort} does not report paymentChain (pre-v0.11 instance). Assuming Base.`
+      );
       throw new Error(
         `Existing proxy on port ${listenPort} is a pre-v0.11 instance (assumed Base) but ${paymentChain} was requested. Stop the existing proxy first or use a different port.`
       );
     }
     let reuseSolanaAddress;
     if (solanaPrivateKeyBytes) {
-      const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
-      const solanaSigner = await createKeyPairSignerFromPrivateKeyBytes(solanaPrivateKeyBytes);
+      const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+      const solanaSigner = await createKeyPairSignerFromPrivateKeyBytes2(solanaPrivateKeyBytes);
       reuseSolanaAddress = solanaSigner.address;
     }
     const balanceMonitor2 = paymentChain === "solana" && reuseSolanaAddress ? new SolanaBalanceMonitor(reuseSolanaAddress) : new BalanceMonitor(account2.address);
@@ -5173,8 +6005,8 @@ async function startProxy(options) {
   let solanaAddress;
   if (solanaPrivateKeyBytes) {
     const { registerExactSvmScheme } = await import("@x402/svm/exact/client");
-    const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
-    const solanaSigner = await createKeyPairSignerFromPrivateKeyBytes(solanaPrivateKeyBytes);
+    const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+    const solanaSigner = await createKeyPairSignerFromPrivateKeyBytes2(solanaPrivateKeyBytes);
     solanaAddress = solanaSigner.address;
     registerExactSvmScheme(x402, { signer: solanaSigner });
     console.log(`[ClawRouter] Solana x402 scheme registered: ${solanaAddress}`);
@@ -5341,7 +6173,11 @@ async function startProxy(options) {
           const existingProxy2 = await checkExistingProxy(listenPort);
           if (existingProxy2) {
             console.log(`[ClawRouter] Existing proxy detected on port ${listenPort}, reusing`);
-            rejectAttempt({ code: "REUSE_EXISTING", wallet: existingProxy2.wallet, existingChain: existingProxy2.paymentChain });
+            rejectAttempt({
+              code: "REUSE_EXISTING",
+              wallet: existingProxy2.wallet,
+              existingChain: existingProxy2.paymentChain
+            });
             return;
           }
           if (attempt < PORT_RETRY_ATTEMPTS) {
@@ -5376,7 +6212,8 @@ async function startProxy(options) {
       if (error.code === "REUSE_EXISTING" && error.wallet) {
         if (error.existingChain && error.existingChain !== paymentChain) {
           throw new Error(
-            `Existing proxy on port ${listenPort} is using ${error.existingChain} but ${paymentChain} was requested. Stop the existing proxy first or use a different port.`
+            `Existing proxy on port ${listenPort} is using ${error.existingChain} but ${paymentChain} was requested. Stop the existing proxy first or use a different port.`,
+            { cause: err }
           );
         }
         const baseUrl2 = `http://127.0.0.1:${listenPort}`;
@@ -5484,15 +6321,12 @@ async function tryModelRequest(upstreamUrl, method, headers, body, modelId, maxT
   } catch {
   }
   try {
-    const response = await payFetch(
-      upstreamUrl,
-      {
-        method,
-        headers,
-        body: requestBody.length > 0 ? new Uint8Array(requestBody) : void 0,
-        signal
-      }
-    );
+    const response = await payFetch(upstreamUrl, {
+      method,
+      headers,
+      body: requestBody.length > 0 ? new Uint8Array(requestBody) : void 0,
+      signal
+    });
     if (response.status !== 200) {
       const errorBody = await response.text();
       const isProviderErr = isProviderError(response.status, errorBody);
@@ -6443,7 +7277,14 @@ async function proxyRequest(req, res, apiBase, payFetch, options, routerOpts, de
               if (balanceFallbackNotice) {
                 const noticeChunk = {
                   ...baseChunk,
-                  choices: [{ index, delta: { content: balanceFallbackNotice }, logprobs: null, finish_reason: null }]
+                  choices: [
+                    {
+                      index,
+                      delta: { content: balanceFallbackNotice },
+                      logprobs: null,
+                      finish_reason: null
+                    }
+                  ]
                 };
                 const noticeData = `data: ${JSON.stringify(noticeChunk)}
 
@@ -7009,6 +7850,7 @@ function formatDuration(seconds) {
 
 // src/index.ts
 init_wallet();
+init_solana_sweep();
 
 // src/retry.ts
 var DEFAULT_RETRY_CONFIG = {
@@ -7363,7 +8205,8 @@ async function startProxyInBackground(api) {
   activeProxyHandle = proxy;
   api.logger.info(`ClawRouter ready \u2014 smart routing enabled`);
   api.logger.info(`Pricing: Simple ~$0.001 | Code ~$0.01 | Complex ~$0.05 | Free: $0`);
-  const displayAddress = proxy.solanaAddress ?? wallet.address;
+  const currentChain = await resolvePaymentChain();
+  const displayAddress = currentChain === "solana" && proxy.solanaAddress ? proxy.solanaAddress : wallet.address;
   proxy.balanceMonitor.checkBalance().then((balance) => {
     if (balance.isEmpty) {
       api.logger.info(`Wallet: ${displayAddress} | Balance: $0.00`);
@@ -7448,8 +8291,8 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
               hasMnemonic = true;
               const { deriveSolanaKeyBytes: deriveSolanaKeyBytes2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
               const solKeyBytes = deriveSolanaKeyBytes2(mnemonic);
-              const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
-              const signer = await createKeyPairSignerFromPrivateKeyBytes(solKeyBytes);
+              const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+              const signer = await createKeyPairSignerFromPrivateKeyBytes2(solKeyBytes);
               lines.push(
                 "",
                 "**Solana:**",
@@ -7490,8 +8333,8 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
               await savePaymentChain("solana");
               const { deriveSolanaKeyBytes: deriveSolanaKeyBytes2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
               const solKeyBytes = deriveSolanaKeyBytes2(existingMnemonic);
-              const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
-              const signer2 = await createKeyPairSignerFromPrivateKeyBytes2(solKeyBytes);
+              const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes3 } = await import("@solana/kit");
+              const signer2 = await createKeyPairSignerFromPrivateKeyBytes3(solKeyBytes);
               solanaAddr = signer2.address;
               return {
                 text: [
@@ -7505,8 +8348,8 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
           }
           const { solanaPrivateKeyBytes } = await setupSolana();
           await savePaymentChain("solana");
-          const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
-          const signer = await createKeyPairSignerFromPrivateKeyBytes(solanaPrivateKeyBytes);
+          const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+          const signer = await createKeyPairSignerFromPrivateKeyBytes2(solanaPrivateKeyBytes);
           return {
             text: [
               "**Solana Wallet Set Up**",
@@ -7527,6 +8370,88 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
           };
         }
       }
+      if (subcommand === "migrate-solana") {
+        try {
+          if (!existsSync2(MNEMONIC_FILE)) {
+            return {
+              text: "No mnemonic file found. Solana wallet not set up \u2014 nothing to migrate.",
+              isError: true
+            };
+          }
+          const mnemonic = readTextFileSync(MNEMONIC_FILE).trim();
+          if (!mnemonic) {
+            return { text: "Mnemonic file is empty.", isError: true };
+          }
+          const { deriveSolanaKeyBytes: deriveSolanaKeyBytes2, deriveSolanaKeyBytesLegacy: deriveSolanaKeyBytesLegacy2 } = await Promise.resolve().then(() => (init_wallet(), wallet_exports));
+          const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+          const legacyKeyBytes = deriveSolanaKeyBytesLegacy2(mnemonic);
+          const newKeyBytes = deriveSolanaKeyBytes2(mnemonic);
+          const [oldSigner, newSigner] = await Promise.all([
+            createKeyPairSignerFromPrivateKeyBytes2(legacyKeyBytes),
+            createKeyPairSignerFromPrivateKeyBytes2(newKeyBytes)
+          ]);
+          if (oldSigner.address === newSigner.address) {
+            return { text: "Legacy and new Solana addresses are the same. No migration needed." };
+          }
+          let oldUsdcText = "unknown";
+          try {
+            const { SolanaBalanceMonitor: SolanaBalanceMonitor2 } = await Promise.resolve().then(() => (init_solana_balance(), solana_balance_exports));
+            const monitor = new SolanaBalanceMonitor2(oldSigner.address);
+            const balance = await monitor.checkBalance();
+            oldUsdcText = balance.balanceUSD;
+            if (balance.isEmpty) {
+              return {
+                text: [
+                  "**Solana Migration Status**",
+                  "",
+                  `Old wallet (secp256k1): \`${oldSigner.address}\``,
+                  `  USDC: $0.00`,
+                  "",
+                  `New wallet (SLIP-10): \`${newSigner.address}\``,
+                  "",
+                  "No USDC in old wallet. Nothing to sweep.",
+                  "Your new SLIP-10 address is Phantom/Solflare compatible."
+                ].join("\n")
+              };
+            }
+          } catch {
+          }
+          const { sweepSolanaWallet: sweepSolanaWallet2 } = await Promise.resolve().then(() => (init_solana_sweep(), solana_sweep_exports));
+          const result = await sweepSolanaWallet2(legacyKeyBytes, newKeyBytes);
+          if ("error" in result) {
+            return {
+              text: [
+                "**Solana Migration Failed**",
+                "",
+                `Old wallet: \`${result.oldAddress}\` (USDC: ${oldUsdcText})`,
+                `New wallet: \`${result.newAddress || newSigner.address}\``,
+                "",
+                `Error: ${result.error}`
+              ].join("\n"),
+              isError: true
+            };
+          }
+          return {
+            text: [
+              "**Solana Migration Complete**",
+              "",
+              `Swept **${result.transferred}** USDC from old to new wallet.`,
+              "",
+              `Old wallet: \`${result.oldAddress}\``,
+              `New wallet: \`${result.newAddress}\``,
+              `TX: https://solscan.io/tx/${result.txSignature}`,
+              "",
+              "Your new SLIP-10 address is Phantom/Solflare compatible.",
+              "You can recover it from your 24-word mnemonic in any standard wallet."
+            ].join("\n")
+          };
+        } catch (err) {
+          return {
+            text: `Migration failed: ${err instanceof Error ? err.message : String(err)}`,
+            isError: true
+          };
+        }
+      }
       if (subcommand === "base") {
         try {
           await savePaymentChain("base");
@@ -7540,7 +8465,7 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
           };
         }
       }
-      let evmBalanceText = "Balance: (checking...)";
+      let evmBalanceText;
       try {
         const monitor = new BalanceMonitor(address);
         const balance = await monitor.checkBalance();
@@ -7555,8 +8480,8 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
           const mnemonic = readTextFileSync(MNEMONIC_FILE).trim();
           if (mnemonic) {
             const solKeyBytes = deriveSolanaKeyBytes2(mnemonic);
-            const { createKeyPairSignerFromPrivateKeyBytes } = await import("@solana/kit");
-            const signer = await createKeyPairSignerFromPrivateKeyBytes(solKeyBytes);
+            const { createKeyPairSignerFromPrivateKeyBytes: createKeyPairSignerFromPrivateKeyBytes2 } = await import("@solana/kit");
+            const signer = await createKeyPairSignerFromPrivateKeyBytes2(solKeyBytes);
             const solAddr = signer.address;
             let solBalanceText = "Balance: (checking...)";
             try {
@@ -7598,7 +8523,8 @@ Run \`openclaw plugins install @blockrun/clawrouter\` to generate a wallet.`,
           "\u2022 `/wallet export` - Export private key for backup",
           !solanaSection ? "\u2022 `/wallet solana` - Enable Solana payments" : "",
           solanaSection ? "\u2022 `/wallet base` - Switch to Base (EVM)" : "",
-          solanaSection ? "\u2022 `/wallet solana` - Switch to Solana" : ""
+          solanaSection ? "\u2022 `/wallet solana` - Switch to Solana" : "",
+          solanaSection ? "\u2022 `/wallet migrate-solana` - Sweep funds from old Solana wallet" : ""
         ].filter(Boolean).join("\n")
       };
     }
@@ -7774,6 +8700,7 @@ export {
   deriveAllKeys,
   deriveEvmKey,
   deriveSolanaKeyBytes,
+  deriveSolanaKeyBytesLegacy,
   fetchWithRetry,
   formatDuration,
   formatStatsAscii,
@@ -7801,6 +8728,12 @@ export {
   route,
   savePaymentChain,
   setupSolana,
-  startProxy
+  startProxy,
+  sweepSolanaWallet
 };
+/*! Bundled license information:
+
+@noble/hashes/esm/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
 //# sourceMappingURL=index.js.map