@newtype-ai/nit 0.3.0 → 0.4.1

package/README.md

@@ -76,6 +76,8 @@ nit push --all
 
 Platforms verify your identity by challenging you to sign a nonce — no shared secrets, no bearer tokens.
 
+nit also derives blockchain wallet addresses from your keypair — Solana (Ed25519 native) and EVM chains (Ethereum, BSC, Polygon, etc.) via a deterministic secp256k1 derivation. Run `nit status` to see your addresses.
+
 ### Branches
 
 Each branch is a different agent card for a different platform. Branch name = root domain of the platform (e.g., `faam.io`, `polymarket.com`).
@@ -132,7 +134,7 @@ your-project/
 ## Programmatic API
 
 ```typescript
-import { init, commit, checkout, branch, push, status, sign, loginPayload, loadRawKeyPair } from '@newtype-ai/nit';
+import { init, commit, checkout, branch, push, status, sign, loginPayload, loadRawKeyPair, getWalletAddresses } from '@newtype-ai/nit';
 
 await init();
 
@@ -147,6 +149,10 @@ await push({ all: true });
 // Access raw Ed25519 keypair (64 bytes: [seed || pubkey])
 const keypair = await loadRawKeyPair('/path/to/.nit');
 // → Uint8Array(64) — compatible with Solana and other Ed25519 libraries
+
+// Get blockchain wallet addresses (derived from your identity)
+const addresses = await getWalletAddresses('/path/to/.nit');
+// → { solana: "C54kvW3...", ethereum: "0x2317..." }
 ```
 
 ## Design Principles

package/dist/{chunk-CJUMX46F.js → chunk-BC7OEIFR.js}

@@ -1,8 +1,8 @@
 // nit — version control for agent cards
 
 // src/index.ts
-import { promises as fs6, statSync } from "fs";
-import { join as join6, basename as basename2, resolve as resolve2 } from "path";
+import { promises as fs7, statSync } from "fs";
+import { join as join7, basename as basename2, resolve as resolve2 } from "path";
 
 // src/objects.ts
 import { createHash } from "crypto";
@@ -484,6 +484,362 @@ function parseFrontmatter(content, dirName, filePath) {
   };
 }
 
+// src/wallet.ts
+import { createHmac, createECDH } from "crypto";
+import { promises as fs5 } from "fs";
+import { join as join5 } from "path";
+
+// 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 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];
+}
+var rotlSH = (h, l, s) => h << s | l >>> 32 - s;
+var rotlSL = (h, l, s) => l << s | h >>> 32 - s;
+var rotlBH = (h, l, s) => l << s - 32 | h >>> 64 - s;
+var rotlBL = (h, l, s) => h << s - 32 | l >>> 64 - s;
+
+// node_modules/@noble/hashes/utils.js
+function isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array";
+}
+function anumber(n, title = "") {
+  if (!Number.isSafeInteger(n) || n < 0) {
+    const prefix = title && `"${title}" `;
+    throw new Error(`${prefix}expected integer >= 0, got ${n}`);
+  }
+}
+function abytes(value, length, title = "") {
+  const bytes = isBytes(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}`;
+    throw new Error(prefix + "expected Uint8Array" + ofLen + ", got " + got);
+  }
+  return value;
+}
+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, void 0, "digestInto() output");
+  const min = instance.outputLen;
+  if (out.length < min) {
+    throw new Error('"digestInto() output" expected to be of length >=' + min);
+  }
+}
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
+}
+function clean(...arrays) {
+  for (let i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i = 0; i < arr.length; i++) {
+    arr[i] = byteSwap(arr[i]);
+  }
+  return arr;
+}
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function createHasher(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.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+
+// node_modules/@noble/hashes/sha3.js
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var _7n = BigInt(7);
+var _256n = BigInt(256);
+var _0x71n = BigInt(113);
+var SHA3_PI = [];
+var SHA3_ROTL = [];
+var _SHA3_IOTA = [];
+for (let round = 0, R = _1n, x = 1, y = 0; round < 24; round++) {
+  [x, y] = [y, (2 * x + 3 * y) % 5];
+  SHA3_PI.push(2 * (5 * y + x));
+  SHA3_ROTL.push((round + 1) * (round + 2) / 2 % 64);
+  let t = _0n;
+  for (let j = 0; j < 7; j++) {
+    R = (R << _1n ^ (R >> _7n) * _0x71n) % _256n;
+    if (R & _2n)
+      t ^= _1n << (_1n << BigInt(j)) - _1n;
+  }
+  _SHA3_IOTA.push(t);
+}
+var IOTAS = split(_SHA3_IOTA, true);
+var SHA3_IOTA_H = IOTAS[0];
+var SHA3_IOTA_L = IOTAS[1];
+var rotlH = (h, l, s) => s > 32 ? rotlBH(h, l, s) : rotlSH(h, l, s);
+var rotlL = (h, l, s) => s > 32 ? rotlBL(h, l, s) : rotlSL(h, l, s);
+function keccakP(s, rounds = 24) {
+  const B = new Uint32Array(5 * 2);
+  for (let round = 24 - rounds; round < 24; round++) {
+    for (let x = 0; x < 10; x++)
+      B[x] = s[x] ^ s[x + 10] ^ s[x + 20] ^ s[x + 30] ^ s[x + 40];
+    for (let x = 0; x < 10; x += 2) {
+      const idx1 = (x + 8) % 10;
+      const idx0 = (x + 2) % 10;
+      const B0 = B[idx0];
+      const B1 = B[idx0 + 1];
+      const Th = rotlH(B0, B1, 1) ^ B[idx1];
+      const Tl = rotlL(B0, B1, 1) ^ B[idx1 + 1];
+      for (let y = 0; y < 50; y += 10) {
+        s[x + y] ^= Th;
+        s[x + y + 1] ^= Tl;
+      }
+    }
+    let curH = s[2];
+    let curL = s[3];
+    for (let t = 0; t < 24; t++) {
+      const shift = SHA3_ROTL[t];
+      const Th = rotlH(curH, curL, shift);
+      const Tl = rotlL(curH, curL, shift);
+      const PI = SHA3_PI[t];
+      curH = s[PI];
+      curL = s[PI + 1];
+      s[PI] = Th;
+      s[PI + 1] = Tl;
+    }
+    for (let y = 0; y < 50; y += 10) {
+      for (let x = 0; x < 10; x++)
+        B[x] = s[y + x];
+      for (let x = 0; x < 10; x++)
+        s[y + x] ^= ~B[(x + 2) % 10] & B[(x + 4) % 10];
+    }
+    s[0] ^= SHA3_IOTA_H[round];
+    s[1] ^= SHA3_IOTA_L[round];
+  }
+  clean(B);
+}
+var Keccak = class _Keccak {
+  state;
+  pos = 0;
+  posOut = 0;
+  finished = false;
+  state32;
+  destroyed = false;
+  blockLen;
+  suffix;
+  outputLen;
+  enableXOF = false;
+  rounds;
+  // NOTE: we accept arguments in bytes instead of bits here.
+  constructor(blockLen, suffix, outputLen, enableXOF = false, rounds = 24) {
+    this.blockLen = blockLen;
+    this.suffix = suffix;
+    this.outputLen = outputLen;
+    this.enableXOF = enableXOF;
+    this.rounds = rounds;
+    anumber(outputLen, "outputLen");
+    if (!(0 < blockLen && blockLen < 200))
+      throw new Error("only keccak-f1600 function is supported");
+    this.state = new Uint8Array(200);
+    this.state32 = u32(this.state);
+  }
+  clone() {
+    return this._cloneInto();
+  }
+  keccak() {
+    swap32IfBE(this.state32);
+    keccakP(this.state32, this.rounds);
+    swap32IfBE(this.state32);
+    this.posOut = 0;
+    this.pos = 0;
+  }
+  update(data) {
+    aexists(this);
+    abytes(data);
+    const { blockLen, state } = this;
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      for (let i = 0; i < take; i++)
+        state[this.pos++] ^= data[pos++];
+      if (this.pos === blockLen)
+        this.keccak();
+    }
+    return this;
+  }
+  finish() {
+    if (this.finished)
+      return;
+    this.finished = true;
+    const { state, suffix, pos, blockLen } = this;
+    state[pos] ^= suffix;
+    if ((suffix & 128) !== 0 && pos === blockLen - 1)
+      this.keccak();
+    state[blockLen - 1] ^= 128;
+    this.keccak();
+  }
+  writeInto(out) {
+    aexists(this, false);
+    abytes(out);
+    this.finish();
+    const bufferOut = this.state;
+    const { blockLen } = this;
+    for (let pos = 0, len = out.length; pos < len; ) {
+      if (this.posOut >= blockLen)
+        this.keccak();
+      const take = Math.min(blockLen - this.posOut, len - pos);
+      out.set(bufferOut.subarray(this.posOut, this.posOut + take), pos);
+      this.posOut += take;
+      pos += take;
+    }
+    return out;
+  }
+  xofInto(out) {
+    if (!this.enableXOF)
+      throw new Error("XOF is not possible for this instance");
+    return this.writeInto(out);
+  }
+  xof(bytes) {
+    anumber(bytes);
+    return this.xofInto(new Uint8Array(bytes));
+  }
+  digestInto(out) {
+    aoutput(out, this);
+    if (this.finished)
+      throw new Error("digest() was already called");
+    this.writeInto(out);
+    this.destroy();
+    return out;
+  }
+  digest() {
+    return this.digestInto(new Uint8Array(this.outputLen));
+  }
+  destroy() {
+    this.destroyed = true;
+    clean(this.state);
+  }
+  _cloneInto(to) {
+    const { blockLen, suffix, outputLen, rounds, enableXOF } = this;
+    to ||= new _Keccak(blockLen, suffix, outputLen, enableXOF, rounds);
+    to.state32.set(this.state32);
+    to.pos = this.pos;
+    to.posOut = this.posOut;
+    to.finished = this.finished;
+    to.rounds = rounds;
+    to.suffix = suffix;
+    to.outputLen = outputLen;
+    to.enableXOF = enableXOF;
+    to.destroyed = this.destroyed;
+    return to;
+  }
+};
+var genKeccak = (suffix, blockLen, outputLen, info = {}) => createHasher(() => new Keccak(blockLen, suffix, outputLen), info);
+var keccak_256 = /* @__PURE__ */ genKeccak(1, 136, 32);
+
+// src/wallet.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let leadingZeros = 0;
+  for (const byte of bytes) {
+    if (byte === 0) leadingZeros++;
+    else break;
+  }
+  let num = 0n;
+  for (const byte of bytes) {
+    num = num * 256n + BigInt(byte);
+  }
+  let encoded = "";
+  while (num > 0n) {
+    encoded = BASE58_ALPHABET[Number(num % 58n)] + encoded;
+    num = num / 58n;
+  }
+  return BASE58_ALPHABET[0].repeat(leadingZeros) + encoded;
+}
+function deriveSecp256k1Seed(ed25519Seed) {
+  const hmac = createHmac("sha512", "secp256k1");
+  hmac.update(ed25519Seed);
+  return hmac.digest().subarray(0, 32);
+}
+function getSecp256k1PublicKey(privateKey) {
+  const ecdh = createECDH("secp256k1");
+  ecdh.setPrivateKey(privateKey);
+  return Buffer.from(ecdh.getPublicKey());
+}
+function evmAddressFromPublicKey(uncompressedPubKey) {
+  const pubKeyBody = uncompressedPubKey.subarray(1);
+  const hash = keccak_256(pubKeyBody);
+  const addressBytes = hash.slice(hash.length - 20);
+  return "0x" + Buffer.from(addressBytes).toString("hex");
+}
+function checksumAddress(address) {
+  const addr = address.slice(2).toLowerCase();
+  const hash = Buffer.from(keccak_256(Buffer.from(addr, "utf-8"))).toString(
+    "hex"
+  );
+  let checksummed = "0x";
+  for (let i = 0; i < addr.length; i++) {
+    checksummed += parseInt(hash[i], 16) >= 8 ? addr[i].toUpperCase() : addr[i];
+  }
+  return checksummed;
+}
+async function getSolanaAddress(nitDir) {
+  const pubBase64 = await loadPublicKey(nitDir);
+  const pubBytes = Buffer.from(pubBase64, "base64");
+  return base58Encode(pubBytes);
+}
+async function getEvmAddress(nitDir) {
+  const keyPath = join5(nitDir, "identity", "agent.key");
+  const privBase64 = (await fs5.readFile(keyPath, "utf-8")).trim();
+  const ed25519Seed = Buffer.from(privBase64, "base64");
+  const secp256k1PrivKey = deriveSecp256k1Seed(ed25519Seed);
+  const secp256k1PubKey = getSecp256k1PublicKey(secp256k1PrivKey);
+  const rawAddress = evmAddressFromPublicKey(secp256k1PubKey);
+  return checksumAddress(rawAddress);
+}
+async function getWalletAddresses(nitDir) {
+  const [solana, ethereum] = await Promise.all([
+    getSolanaAddress(nitDir),
+    getEvmAddress(nitDir)
+  ]);
+  return { solana, ethereum };
+}
+async function loadSecp256k1RawKeyPair(nitDir) {
+  const keyPath = join5(nitDir, "identity", "agent.key");
+  const privBase64 = (await fs5.readFile(keyPath, "utf-8")).trim();
+  const ed25519Seed = Buffer.from(privBase64, "base64");
+  const secp256k1PrivKey = deriveSecp256k1Seed(ed25519Seed);
+  const secp256k1PubKey = getSecp256k1PublicKey(secp256k1PrivKey);
+  const keypair = new Uint8Array(64);
+  keypair.set(secp256k1PrivKey, 0);
+  keypair.set(secp256k1PubKey.subarray(1, 33), 32);
+  return keypair;
+}
+
 // src/diff.ts
 function diffCards(oldCard, newCard) {
   const fields = [];
@@ -670,22 +1026,22 @@ async function fetchBranchCard(cardUrl, branch2, nitDir) {
 }
 
 // src/config.ts
-import { promises as fs5 } from "fs";
-import { join as join5 } from "path";
+import { promises as fs6 } from "fs";
+import { join as join6 } from "path";
 var CONFIG_FILE = "config";
 async function readConfig(nitDir) {
-  const configPath = join5(nitDir, CONFIG_FILE);
+  const configPath = join6(nitDir, CONFIG_FILE);
   let raw;
   try {
-    raw = await fs5.readFile(configPath, "utf-8");
+    raw = await fs6.readFile(configPath, "utf-8");
   } catch {
     return { remotes: {} };
   }
   return parseConfig(raw);
 }
 async function writeConfig(nitDir, config) {
-  const configPath = join5(nitDir, CONFIG_FILE);
-  await fs5.writeFile(configPath, serializeConfig(config), "utf-8");
+  const configPath = join6(nitDir, CONFIG_FILE);
+  await fs6.writeFile(configPath, serializeConfig(config), "utf-8");
 }
 async function getRemoteUrl(nitDir, remoteName) {
   const config = await readConfig(nitDir);
@@ -762,7 +1118,7 @@ var DEFAULT_API_BASE = "https://api.newtype-ai.org";
 function findNitDir(startDir) {
   let dir = resolve2(startDir || process.cwd());
   while (true) {
-    const candidate = join6(dir, NIT_DIR);
+    const candidate = join7(dir, NIT_DIR);
     try {
       const s = statSync(candidate);
       if (s.isDirectory()) return candidate;
@@ -781,17 +1137,17 @@ function projectDir(nitDir) {
   return resolve2(nitDir, "..");
 }
 async function readWorkingCard(nitDir) {
-  const cardPath = join6(projectDir(nitDir), CARD_FILE);
+  const cardPath = join7(projectDir(nitDir), CARD_FILE);
   try {
-    const raw = await fs6.readFile(cardPath, "utf-8");
+    const raw = await fs7.readFile(cardPath, "utf-8");
     return JSON.parse(raw);
   } catch {
     throw new Error(`Cannot read ${CARD_FILE}. Does it exist?`);
   }
 }
 async function writeWorkingCard(nitDir, card) {
-  const cardPath = join6(projectDir(nitDir), CARD_FILE);
-  await fs6.writeFile(cardPath, JSON.stringify(card, null, 2) + "\n", "utf-8");
+  const cardPath = join7(projectDir(nitDir), CARD_FILE);
+  await fs7.writeFile(cardPath, JSON.stringify(card, null, 2) + "\n", "utf-8");
 }
 async function getCardAtCommit(nitDir, commitHash) {
   const commitRaw = await readObject(nitDir, commitHash);
@@ -809,27 +1165,27 @@ async function getAuthorName(nitDir) {
 }
 async function init(options) {
   const projDir = resolve2(options?.projectDir || process.cwd());
-  const nitDir = join6(projDir, NIT_DIR);
+  const nitDir = join7(projDir, NIT_DIR);
   try {
-    await fs6.access(nitDir);
+    await fs7.access(nitDir);
     throw new Error("Already initialized. .nit/ directory exists.");
   } catch (err) {
     if (err instanceof Error && err.message.startsWith("Already")) throw err;
   }
-  await fs6.mkdir(join6(nitDir, "objects"), { recursive: true });
-  await fs6.mkdir(join6(nitDir, "refs", "heads"), { recursive: true });
-  await fs6.mkdir(join6(nitDir, "refs", "remote"), { recursive: true });
-  await fs6.mkdir(join6(nitDir, "identity"), { recursive: true });
-  await fs6.mkdir(join6(nitDir, "logs"), { recursive: true });
+  await fs7.mkdir(join7(nitDir, "objects"), { recursive: true });
+  await fs7.mkdir(join7(nitDir, "refs", "heads"), { recursive: true });
+  await fs7.mkdir(join7(nitDir, "refs", "remote"), { recursive: true });
+  await fs7.mkdir(join7(nitDir, "identity"), { recursive: true });
+  await fs7.mkdir(join7(nitDir, "logs"), { recursive: true });
   const { publicKey: pubBase64 } = await generateKeypair(nitDir);
   const publicKeyField = formatPublicKeyField(pubBase64);
   const agentId = deriveAgentId(publicKeyField);
   await saveAgentId(nitDir, agentId);
-  const cardPath = join6(projDir, CARD_FILE);
+  const cardPath = join7(projDir, CARD_FILE);
   let card;
   let skillsFound = [];
   try {
-    const raw = await fs6.readFile(cardPath, "utf-8");
+    const raw = await fs7.readFile(cardPath, "utf-8");
     card = JSON.parse(raw);
     card.publicKey = publicKeyField;
     skillsFound = card.skills.map((s) => s.id);
@@ -868,16 +1224,18 @@ async function init(options) {
   const commitHash = await writeObject(nitDir, "commit", commitContent);
   await setBranch(nitDir, "main", commitHash);
   await setHead(nitDir, "main");
-  await fs6.writeFile(join6(nitDir, "logs", "HEAD"), "", "utf-8");
+  await fs7.writeFile(join7(nitDir, "logs", "HEAD"), "", "utf-8");
   const skillsDir = await discoverSkillsDir(projDir);
   await writeConfig(nitDir, {
     remotes: { origin: { url: DEFAULT_API_BASE } },
     skillsDir
   });
+  const walletAddresses = await getWalletAddresses(nitDir);
   return {
     agentId,
     publicKey: publicKeyField,
     cardUrl: card.url,
+    walletAddresses,
     skillsFound,
     skillsDir
   };
@@ -933,11 +1291,13 @@ async function status(options) {
     }
     branchStatus.push({ name: b.name, ahead, behind: 0 });
   }
+  const walletAddresses = await getWalletAddresses(nitDir);
   return {
     agentId,
     cardUrl,
     branch: currentBranch,
     publicKey,
+    walletAddresses,
     uncommittedChanges,
     branches: branchStatus
   };
@@ -1163,6 +1523,11 @@ export {
   NIT_NAMESPACE,
   deriveAgentId,
   loadAgentId,
+  base58Encode,
+  getSolanaAddress,
+  getEvmAddress,
+  getWalletAddresses,
+  loadSecp256k1RawKeyPair,
   diffCards,
   formatDiff,
   fetchBranchCard,
@@ -1181,3 +1546,8 @@ export {
   remoteAdd,
   remoteSetUrl
 };
+/*! Bundled license information:
+
+@noble/hashes/utils.js:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/

package/dist/cli.js

@@ -15,7 +15,7 @@ import {
   remoteSetUrl,
   sign,
   status
-} from "./chunk-CJUMX46F.js";
+} from "./chunk-BC7OEIFR.js";
 
 // src/cli.ts
 var bold = (s) => `\x1B[1m${s}\x1B[0m`;
@@ -80,6 +80,11 @@ async function cmdInit() {
   console.log(`  Agent ID:    ${green(result.agentId)}`);
   console.log(`  Public key:  ${dim(result.publicKey)}`);
   console.log(`  Card URL:    ${result.cardUrl}`);
+  console.log();
+  console.log(`  ${bold("Wallet addresses:")}`);
+  console.log(`    Solana:    ${result.walletAddresses.solana}`);
+  console.log(`    Ethereum:  ${result.walletAddresses.ethereum}`);
+  console.log();
   console.log(`  Skills dir:  ${dim(result.skillsDir)}`);
   if (result.skillsFound.length > 0) {
     console.log(`  Skills:      ${result.skillsFound.join(", ")}`);
@@ -88,6 +93,7 @@ async function cmdInit() {
   }
   console.log();
   console.log(dim("Created .nit/ with initial commit on main."));
+  console.log(dim("Fund the wallet addresses above to use blockchain features in apps."));
   console.log();
   console.log(`Next: open ${bold("agent-card.json")} and set your name, description, and skills.`);
 }
@@ -99,6 +105,10 @@ async function cmdStatus() {
   console.log(`  Public key:  ${dim(s.publicKey)}`);
   console.log(`  Card URL:    ${s.cardUrl}`);
   console.log();
+  console.log(`  ${bold("Wallet addresses:")}`);
+  console.log(`    Solana:    ${s.walletAddresses.solana}`);
+  console.log(`    Ethereum:  ${s.walletAddresses.ethereum}`);
+  console.log();
   if (s.uncommittedChanges) {
     console.log(yellow("Uncommitted changes:"));
     console.log(formatDiff(s.uncommittedChanges));

package/dist/index.d.ts

@@ -105,12 +105,18 @@ interface PushResult {
     success: boolean;
     error?: string;
 }
+/** Wallet addresses derived from the agent's Ed25519 keypair. */
+interface WalletAddresses$1 {
+    solana: string;
+    ethereum: string;
+}
 /** Result returned by the status command. */
 interface StatusResult {
     agentId: string;
     cardUrl: string;
     branch: string;
     publicKey: string;
+    walletAddresses: WalletAddresses$1;
     uncommittedChanges: DiffResult | null;
     branches: Array<{
         name: string;
@@ -194,6 +200,32 @@ declare function loadAgentId(nitDir: string): Promise<string>;
  */
 declare function fetchBranchCard(cardUrl: string, branch: string, nitDir?: string): Promise<AgentCard>;
 
+declare function base58Encode(bytes: Uint8Array): string;
+interface WalletAddresses {
+    solana: string;
+    ethereum: string;
+}
+/**
+ * Get the Solana wallet address (base58-encoded Ed25519 public key).
+ */
+declare function getSolanaAddress(nitDir: string): Promise<string>;
+/**
+ * Get the EVM wallet address (Ethereum, BSC, Polygon, etc.).
+ * Derives a secp256k1 key from the Ed25519 seed, then computes keccak256.
+ * Returns EIP-55 checksummed address.
+ */
+declare function getEvmAddress(nitDir: string): Promise<string>;
+/**
+ * Get wallet addresses for all supported chains.
+ */
+declare function getWalletAddresses(nitDir: string): Promise<WalletAddresses>;
+/**
+ * Load the secp256k1 keypair as raw bytes (64-byte Uint8Array).
+ * Format: [32-byte private key || 32-byte compressed public key (X only)]
+ * For EVM transaction signing.
+ */
+declare function loadSecp256k1RawKeyPair(nitDir: string): Promise<Uint8Array>;
+
 /**
  * Walk up from startDir looking for a .nit/ directory.
  * Returns the path to .nit/ or throws if not found.
@@ -203,6 +235,7 @@ interface InitResult {
     agentId: string;
     publicKey: string;
     cardUrl: string;
+    walletAddresses: WalletAddresses$1;
     skillsFound: string[];
     skillsDir: string;
 }
@@ -311,4 +344,4 @@ declare function remoteSetUrl(name: string, url: string, options?: {
     projectDir?: string;
 }): Promise<void>;
 
-export { type AgentCard, type AgentCardSkill, type DiffResult, type FieldDiff, type InitResult, type LoginPayload, NIT_NAMESPACE, type NitBranch, type NitCommit, type NitConfig, type NitHead, type NitRemoteConfig, type PushResult, type RemoteInfo, type SkillMetadata, type StatusResult, branch, checkout, commit, deriveAgentId, diff, diffCards, fetchBranchCard, findNitDir, formatDiff, formatPublicKeyField, init, loadAgentId, loadRawKeyPair, log, loginPayload, parsePublicKeyField, push, remote, remoteAdd, remoteSetUrl, sign, signChallenge, signMessage, status };
+export { type AgentCard, type AgentCardSkill, type DiffResult, type FieldDiff, type InitResult, type LoginPayload, NIT_NAMESPACE, type NitBranch, type NitCommit, type NitConfig, type NitHead, type NitRemoteConfig, type PushResult, type RemoteInfo, type SkillMetadata, type StatusResult, type WalletAddresses$1 as WalletAddresses, base58Encode, branch, checkout, commit, deriveAgentId, diff, diffCards, fetchBranchCard, findNitDir, formatDiff, formatPublicKeyField, getEvmAddress, getSolanaAddress, getWalletAddresses, init, loadAgentId, loadRawKeyPair, loadSecp256k1RawKeyPair, log, loginPayload, parsePublicKeyField, push, remote, remoteAdd, remoteSetUrl, sign, signChallenge, signMessage, status };

package/dist/index.js

@@ -1,6 +1,7 @@
 // nit — version control for agent cards
 import {
   NIT_NAMESPACE,
+  base58Encode,
   branch,
   checkout,
   commit,
@@ -11,9 +12,13 @@ import {
   findNitDir,
   formatDiff,
   formatPublicKeyField,
+  getEvmAddress,
+  getSolanaAddress,
+  getWalletAddresses,
   init,
   loadAgentId,
   loadRawKeyPair,
+  loadSecp256k1RawKeyPair,
   log,
   loginPayload,
   parsePublicKeyField,
@@ -25,9 +30,10 @@ import {
   signChallenge,
   signMessage,
   status
-} from "./chunk-CJUMX46F.js";
+} from "./chunk-BC7OEIFR.js";
 export {
   NIT_NAMESPACE,
+  base58Encode,
   branch,
   checkout,
   commit,
@@ -38,9 +44,13 @@ export {
   findNitDir,
   formatDiff,
   formatPublicKeyField,
+  getEvmAddress,
+  getSolanaAddress,
+  getWalletAddresses,
   init,
   loadAgentId,
   loadRawKeyPair,
+  loadSecp256k1RawKeyPair,
   log,
   loginPayload,
   parsePublicKeyField,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newtype-ai/nit",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "Version control for agent cards",
   "type": "module",
   "bin": {
@@ -42,6 +42,7 @@
   },
   "homepage": "https://github.com/newtype-ai/nit",
   "devDependencies": {
+    "@noble/hashes": "^2.0.1",
     "@types/node": "^25.3.0",
     "tsup": "^8.0.0",
     "typescript": "^5.0.0"