withub-cli 0.1.0 → 0.2.1

package/dist/lib/evmRepo.js

@@ -0,0 +1,192 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EvmRepoService = void 0;
+exports.formatRepoId = formatRepoId;
+const ethers_1 = require("ethers");
+const ui_1 = require("./ui");
+const WIT_POLY_REPO_ABI = [
+    "function createRepo(string name, string description, bool isPrivate) public returns (uint256)",
+    "event RepositoryCreated(uint256 indexed repoId, address indexed owner, string name)",
+    "function updateHead(uint256 repoId, string newCommitCid, string newManifestCid, string newQuiltId, string newRootHash, uint64 expectedVersion, string parentCommitCid) public",
+    "function hasAccess(uint256 repoId, address user) public view returns (bool)",
+    "function addCollaborator(uint256 repoId, address user) public",
+    "function removeCollaborator(uint256 repoId, address user) public",
+    "event CollaboratorAdded(uint256 indexed repoId, address indexed user)",
+    "event CollaboratorRemoved(uint256 indexed repoId, address indexed user)",
+    "function repositories(uint256) public view returns (uint256 id, string name, string description, bool isPrivate, address owner, uint64 version, string headCommitCid, string headManifestCid, string headQuiltId, string rootHash, string parentCommitCid)"
+];
+// Deployed Proxy Address on Mantle Sepolia (5003)
+const WIT_CONTRACT_ADDRESS_MANTLE_SEPOLIA = '0x5996bDBfF0818F948781A27fdEfABa3e608d1506';
+// Deployed Proxy Address on Mantle Mainnet (5000)
+const WIT_CONTRACT_ADDRESS_MANTLE_MAINNET = '0xbc89b2F377386A46c20E09E02d83A8479bFDc203';
+class EvmRepoService {
+    constructor(signerCtx) {
+        this.signerCtx = signerCtx;
+        const address = resolveContractAddress(signerCtx.config.chainId);
+        this.contract = new ethers_1.Contract(address, WIT_POLY_REPO_ABI, signerCtx.signer);
+    }
+    async createRepo(name, description, isPrivate) {
+        console.log(ui_1.colors.gray(`Creating repo "${name}" on contract ${this.contract.target}...`));
+        try {
+            const tx = await this.contract.createRepo(name, description, isPrivate);
+            console.log(ui_1.colors.gray(`Tx sent: ${getExplorerLink(tx.hash)}`));
+            const receipt = await tx.wait();
+            // Parse logs to find RepositoryCreated
+            const event = receipt.logs
+                .map(log => {
+                try {
+                    return this.contract.interface.parseLog(log);
+                }
+                catch {
+                    return null;
+                }
+            })
+                .find(parsed => parsed?.name === 'RepositoryCreated');
+            if (!event) {
+                throw new Error(`RepositoryCreated event not found in tx ${tx.hash}`);
+            }
+            return event.args[0];
+        }
+        catch (err) {
+            await this.handleTxError(err);
+            throw err;
+        }
+    }
+    async updateHead(repoId, commitCid, manifestCid, snapshotId, rootHash, expectedVersion, parentCommitCid) {
+        const parent = parentCommitCid || "";
+        // Ensure rootHash is bytes32?? Contract says string. 
+        // Wait, Contract definition: rootHash is string (based on earlier ABI thought, but let's check solidity)
+        // Checking WitPolyRepo.sol: `string rootHash` (line 19 struct). 
+        // Yes, updateHead arg 5 is string newRootHash.
+        console.log(ui_1.colors.gray(`Updating head for repo ${formatRepoId(repoId)} to version ${expectedVersion + 1n}...`));
+        try {
+            const tx = await this.contract.updateHead(repoId, commitCid, manifestCid, snapshotId, rootHash, expectedVersion, parent);
+            console.log(ui_1.colors.gray(`Tx sent: ${getExplorerLink(tx.hash)}`));
+            await tx.wait();
+        }
+        catch (err) {
+            await this.handleTxError(err);
+            throw err;
+        }
+    }
+    async addCollaborator(repoId, user) {
+        console.log(ui_1.colors.gray(`Adding collaborator ${user} to repo ${formatRepoId(repoId)}...`));
+        try {
+            const tx = await this.contract.addCollaborator(repoId, user);
+            console.log(ui_1.colors.gray(`Tx sent: ${getExplorerLink(tx.hash)}`));
+            await tx.wait();
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.green(`✅ Collaborator ${user} added successfully.`));
+        }
+        catch (err) {
+            await this.handleTxError(err);
+            throw err;
+        }
+    }
+    async removeCollaborator(repoId, user) {
+        console.log(ui_1.colors.gray(`Removing collaborator ${user} from repo ${formatRepoId(repoId)}...`));
+        try {
+            const tx = await this.contract.removeCollaborator(repoId, user);
+            console.log(ui_1.colors.gray(`Tx sent: ${getExplorerLink(tx.hash)}`));
+            await tx.wait();
+            // eslint-disable-next-line no-console
+            console.log(ui_1.colors.green(`✅ Collaborator ${user} removed successfully.`));
+        }
+        catch (err) {
+            await this.handleTxError(err);
+            throw err;
+        }
+    }
+    async handleTxError(err) {
+        const msg = (err?.message || '').toLowerCase();
+        // Check for common out of gas / insufficient funds errors
+        if (msg.includes('insufficient funds') || msg.includes('gas') || msg.includes('exceeds balance')) {
+            try {
+                const bal = await this.signerCtx.provider.getBalance(this.signerCtx.address);
+                const isMantleMainnet = this.signerCtx.config.chainId === 5000;
+                const symbol = 'MNT';
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.red(`\n❌ Transaction failed: Insufficient funds.`));
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.red(`   Wallet:  ${this.signerCtx.address}`));
+                // eslint-disable-next-line no-console
+                console.log(ui_1.colors.red(`   Balance: ${(0, ethers_1.formatEther)(bal)} ${symbol}`));
+                if (isMantleMainnet && bal === 0n) {
+                    // eslint-disable-next-line no-console
+                    console.log(ui_1.colors.yellow(`\n👉 This is Mantle Mainnet. You need real ${symbol} tokens to pay for gas.`));
+                    // eslint-disable-next-line no-console
+                    console.log(ui_1.colors.yellow(`   Please fund your wallet: ${this.signerCtx.address}`));
+                }
+                else {
+                    // eslint-disable-next-line no-console
+                    console.log(ui_1.colors.yellow(`\n👉 Please ensure you have enough ${symbol} for gas fees.`));
+                }
+                process.exit(1);
+            }
+            catch (inner) {
+                // If checking balance fails, just let original error propagate
+            }
+        }
+    }
+    async getRepoState(repoId) {
+        const r = await this.contract.repositories(repoId);
+        // r is Result array: [id, name, description, isPrivate, owner, version, headCommitCid, headManifestCid, headQuiltId, rootHash, parentCommitCid]
+        // The ABI definition above maps names to indices if structured, or we access by index/name.
+        // Ethers v6 Result object supports name access.
+        // Safety check: if id is 0, it doesn't exist
+        if (r.id === 0n) {
+            throw new Error(`Repository ${repoId} not found on chain.`);
+        }
+        return {
+            id: r.id,
+            name: r.name,
+            description: r.description,
+            isPrivate: r.isPrivate,
+            owner: r.owner,
+            version: r.version,
+            headCommit: r.headCommitCid,
+            headManifest: r.headManifestCid,
+            headSnapshot: r.headQuiltId,
+            rootHash: r.rootHash,
+            parentCommit: r.parentCommitCid
+        };
+    }
+    getAddress() {
+        return this.contract.target;
+    }
+}
+exports.EvmRepoService = EvmRepoService;
+function resolveContractAddress(chainId) {
+    if (chainId === 5003) {
+        return WIT_CONTRACT_ADDRESS_MANTLE_SEPOLIA;
+    }
+    if (chainId === 5000) {
+        return WIT_CONTRACT_ADDRESS_MANTLE_MAINNET;
+    }
+    throw new Error(`No contract address known for chain ID ${chainId}`);
+}
+function getExplorerLink(txHash) {
+    // Mantle Sepolia Explorer
+    // Mantle Explorer
+    if (txHash.startsWith('0x')) {
+        // Simple check, theoretically we should pass chainId to this function or check global context
+        // For now, let's just make it generic or use mainnet if configured?
+        // Actually, let's assume if it calls this, we want the link.
+        // But we don't know the chain here easily without passing it.
+        // Let's modify it to be generic or default to mainnet if we are switching?
+        // Or check a global?
+        // Let's just return a generic msg or try to guess.
+        // Better: assume Mantle Mainnet is the target now.
+        return `https://mantlescan.xyz/tx/${txHash}`;
+    }
+    return `https://sepolia.mantlescan.xyz/tx/${txHash}`;
+}
+function formatRepoId(id) {
+    // Format as 20-byte hex string (similar to address)
+    // 20 bytes = 40 hex chars
+    let hex = id.toString(16);
+    while (hex.length < 40) {
+        hex = '0' + hex;
+    }
+    return '0x' + hex;
+}

package/dist/lib/ipfsCar.js

@@ -0,0 +1,132 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.packCar = packCar;
+exports.unpackCar = unpackCar;
+exports.mapCarPaths = mapCarPaths;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const promises_1 = require("stream/promises");
+const stream_1 = require("stream");
+const PLACEHOLDER_ROOT = 'bafybeigdyrzt5sfp7udm7hu76uh7y26nf3efuylqabf3oclgtqy55fbzdi';
+async function packCar(inputPath, outputPath, opts) {
+    const absInput = path_1.default.resolve(inputPath);
+    const absOutput = path_1.default.resolve(outputPath);
+    const wrapWithDirectory = opts?.wrap !== false;
+    const [{ CarWriter }, { filesFromPaths }, ipfsCar, { CID }] = await Promise.all([
+        import('@ipld/car/writer'),
+        import('files-from-path'),
+        import('ipfs-car'),
+        import('multiformats/cid'),
+    ]);
+    const { CAREncoderStream, createDirectoryEncoderStream, createFileEncoderStream } = ipfsCar;
+    const placeholderCid = CID.parse(PLACEHOLDER_ROOT);
+    const stat = await fs_1.default.promises.stat(absInput);
+    const files = await filesFromPaths([absInput], { hidden: false, sort: true });
+    if (files.length === 0) {
+        throw new Error(`No files found at ${absInput}`);
+    }
+    const encoder = stat.isFile() && !wrapWithDirectory ? createFileEncoderStream(files[0]) : createDirectoryEncoderStream(files);
+    let rootCid;
+    const carStream = encoder
+        .pipeThrough(new TransformStream({
+        transform(block, controller) {
+            rootCid = CID.asCID(block.cid) ?? CID.decode(block.cid.bytes);
+            controller.enqueue(block);
+        },
+    }))
+        .pipeThrough(new CAREncoderStream([placeholderCid]));
+    await (0, promises_1.pipeline)(stream_1.Readable.fromWeb(carStream), fs_1.default.createWriteStream(absOutput));
+    if (!rootCid) {
+        throw new Error('Failed to resolve CAR root CID.');
+    }
+    const fd = await fs_1.default.promises.open(absOutput, 'r+');
+    try {
+        await CarWriter.updateRootsInFile(fd, [rootCid]);
+    }
+    finally {
+        await fd.close();
+    }
+    return { root: rootCid.toString(), output: absOutput };
+}
+async function unpackCar(inputPath, outputDir) {
+    const absInput = path_1.default.resolve(inputPath);
+    const absOutput = path_1.default.resolve(outputDir);
+    const [{ CarIndexedReader }, { recursive: exporter }] = await Promise.all([
+        import('@ipld/car/indexed-reader'),
+        import('ipfs-unixfs-exporter'),
+    ]);
+    const reader = await CarIndexedReader.fromFile(absInput);
+    const roots = await reader.getRoots();
+    if (!roots.length) {
+        throw new Error('CAR file does not include roots.');
+    }
+    const entries = exporter(roots[0], {
+        async get(cid) {
+            const block = await reader.get(cid);
+            if (!block) {
+                throw new Error(`Missing block: ${cid}`);
+            }
+            return block.bytes;
+        },
+    });
+    for await (const entry of entries) {
+        const entryPath = mapEntryPath(absOutput, entry.path);
+        if (entry.type === 'directory') {
+            await fs_1.default.promises.mkdir(entryPath, { recursive: true });
+            continue;
+        }
+        if (entry.type === 'file' || entry.type === 'raw' || entry.type === 'identity') {
+            await fs_1.default.promises.mkdir(path_1.default.dirname(entryPath), { recursive: true });
+            await (0, promises_1.pipeline)(() => entry.content(), fs_1.default.createWriteStream(entryPath));
+            continue;
+        }
+        throw new Error(`Unsupported CAR entry type "${entry.type}" for path: ${entry.path}`);
+    }
+}
+async function mapCarPaths(inputPath, opts = {}) {
+    const absInput = path_1.default.resolve(inputPath);
+    const [{ CarIndexedReader }, { recursive: exporter }] = await Promise.all([
+        import('@ipld/car/indexed-reader'),
+        import('ipfs-unixfs-exporter'),
+    ]);
+    const reader = await CarIndexedReader.fromFile(absInput);
+    const roots = await reader.getRoots();
+    if (!roots.length) {
+        throw new Error('CAR file does not include roots.');
+    }
+    const root = roots[0].toString();
+    const entries = exporter(roots[0], {
+        async get(cid) {
+            const block = await reader.get(cid);
+            if (!block) {
+                throw new Error(`Missing block: ${cid}`);
+            }
+            return block.bytes;
+        },
+    });
+    const map = {};
+    for await (const entry of entries) {
+        if (entry.type === 'file' || entry.type === 'raw' || entry.type === 'identity') {
+            const rel = opts.stripRoot === false ? entry.path : stripCarRoot(entry.path);
+            map[rel] = entry.cid.toString();
+        }
+    }
+    return { root, map };
+}
+function mapEntryPath(outputRoot, entryPath) {
+    const parts = entryPath.split('/');
+    if (parts.length === 0) {
+        return outputRoot;
+    }
+    parts[0] = outputRoot;
+    return path_1.default.join(...parts);
+}
+function stripCarRoot(entryPath) {
+    const parts = entryPath.split('/').filter((part) => part.length > 0);
+    if (parts.length <= 1)
+        return entryPath;
+    return parts.slice(1).join('/');
+}

package/dist/lib/keccak.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keccak256 = keccak256;
+const MASK_64 = (1n << 64n) - 1n;
+const ROT = [
+    [0, 36, 3, 41, 18],
+    [1, 44, 10, 45, 2],
+    [62, 6, 43, 15, 61],
+    [28, 55, 25, 21, 56],
+    [27, 20, 39, 8, 14],
+];
+const RC = [
+    0x0000000000000001n,
+    0x0000000000008082n,
+    0x800000000000808an,
+    0x8000000080008000n,
+    0x000000000000808bn,
+    0x0000000080000001n,
+    0x8000000080008081n,
+    0x8000000000008009n,
+    0x000000000000008an,
+    0x0000000000000088n,
+    0x0000000080008009n,
+    0x000000008000000an,
+    0x000000008000808bn,
+    0x800000000000008bn,
+    0x8000000000008089n,
+    0x8000000000008003n,
+    0x8000000000008002n,
+    0x8000000000000080n,
+    0x000000000000800an,
+    0x800000008000000an,
+    0x8000000080008081n,
+    0x8000000000008080n,
+    0x0000000080000001n,
+    0x8000000080008008n,
+];
+const RATE_BYTES = 136; // 1088-bit rate for keccak-256
+const OUTPUT_BYTES = 32;
+function keccak256(data) {
+    const state = new Array(25).fill(0n);
+    let offset = 0;
+    while (offset + RATE_BYTES <= data.length) {
+        absorbBlock(state, data.subarray(offset, offset + RATE_BYTES));
+        keccakF(state);
+        offset += RATE_BYTES;
+    }
+    const block = new Uint8Array(RATE_BYTES);
+    block.set(data.subarray(offset));
+    block[data.length - offset] = 0x01;
+    block[RATE_BYTES - 1] |= 0x80;
+    absorbBlock(state, block);
+    keccakF(state);
+    const out = new Uint8Array(OUTPUT_BYTES);
+    for (let i = 0; i < OUTPUT_BYTES / 8; i += 1) {
+        store64(out, i * 8, state[i]);
+    }
+    return out;
+}
+function absorbBlock(state, block) {
+    for (let i = 0; i < RATE_BYTES / 8; i += 1) {
+        state[i] ^= load64(block, i * 8);
+    }
+}
+function load64(bytes, offset) {
+    let value = 0n;
+    for (let i = 0; i < 8; i += 1) {
+        value |= BigInt(bytes[offset + i] ?? 0) << BigInt(8 * i);
+    }
+    return value;
+}
+function store64(out, offset, value) {
+    for (let i = 0; i < 8; i += 1) {
+        out[offset + i] = Number((value >> BigInt(8 * i)) & 0xffn);
+    }
+}
+function rotl64(value, shift) {
+    if (shift === 0)
+        return value & MASK_64;
+    const s = BigInt(shift);
+    return ((value << s) | (value >> (64n - s))) & MASK_64;
+}
+function keccakF(state) {
+    const B = new Array(25).fill(0n);
+    const C = new Array(5).fill(0n);
+    const D = new Array(5).fill(0n);
+    for (let round = 0; round < 24; round += 1) {
+        for (let x = 0; x < 5; x += 1) {
+            C[x] =
+                state[x] ^
+                    state[x + 5] ^
+                    state[x + 10] ^
+                    state[x + 15] ^
+                    state[x + 20];
+        }
+        for (let x = 0; x < 5; x += 1) {
+            D[x] = C[(x + 4) % 5] ^ rotl64(C[(x + 1) % 5], 1);
+        }
+        for (let x = 0; x < 5; x += 1) {
+            for (let y = 0; y < 5; y += 1) {
+                state[x + 5 * y] ^= D[x];
+            }
+        }
+        for (let x = 0; x < 5; x += 1) {
+            for (let y = 0; y < 5; y += 1) {
+                const idx = x + 5 * y;
+                const rot = ROT[x][y];
+                const nx = y;
+                const ny = (2 * x + 3 * y) % 5;
+                B[nx + 5 * ny] = rotl64(state[idx], rot);
+            }
+        }
+        for (let y = 0; y < 5; y += 1) {
+            const row = y * 5;
+            for (let x = 0; x < 5; x += 1) {
+                const idx = row + x;
+                const b0 = B[idx];
+                const b1 = B[row + ((x + 1) % 5)];
+                const b2 = B[row + ((x + 2) % 5)];
+                state[idx] = (b0 ^ ((~b1) & b2)) & MASK_64;
+            }
+        }
+        state[0] = (state[0] ^ RC[round]) & MASK_64;
+    }
+}

package/dist/lib/keys.js

@@ -18,7 +18,8 @@ const path_1 = __importDefault(require("path"));
 const ed25519_1 = require("@mysten/sui/keypairs/ed25519");
 const client_1 = require("@mysten/sui/client");
 const walrus_1 = require("./walrus");
-exports.KEY_HOME = process.env.WIT_KEY_HOME || path_1.default.join(os_1.default.homedir(), '.wit', 'keys');
+exports.KEY_HOME = process.env.WIT_KEY_HOME || path_1.default.join(os_1.default.homedir(), '.wit', 'keys-sui');
+const LEGACY_KEY_HOME = path_1.default.join(os_1.default.homedir(), '.wit', 'keys');
 const GLOBAL_CONFIG = path_1.default.join(os_1.default.homedir(), '.witconfig');
 const SUI_COIN = '0x2::sui::SUI';
 // WAL CoinType map (9 decimals). Default to testnet when unknown.
@@ -31,6 +32,26 @@ const MIN_WAL_BALANCE = 1000000000n; // 1 WAL (assuming 9 decimals)
 function keyPathFor(address) {
     return path_1.default.join(exports.KEY_HOME, `${normalizeAddress(address)}.key`);
 }
+function keyHomes() {
+    if (process.env.WIT_KEY_HOME)
+        return [exports.KEY_HOME];
+    return [exports.KEY_HOME, LEGACY_KEY_HOME];
+}
+async function findKeyFile(address) {
+    const filename = `${normalizeAddress(address)}.key`;
+    for (const dir of keyHomes()) {
+        const file = path_1.default.join(dir, filename);
+        try {
+            await promises_1.default.access(file);
+            return file;
+        }
+        catch (err) {
+            if (err?.code !== 'ENOENT')
+                throw err;
+        }
+    }
+    return null;
+}
 async function createSigner(alias = 'default') {
     const keypair = ed25519_1.Ed25519Keypair.generate();
     const address = keypair.getPublicKey().toSuiAddress();
@@ -38,6 +59,7 @@ async function createSigner(alias = 'default') {
     await promises_1.default.mkdir(path_1.default.dirname(file), { recursive: true });
     const payload = {
         scheme: 'ED25519',
+        chain: 'sui',
         privateKey: keypair.getSecretKey(),
         address,
         publicKey: Buffer.from(keypair.getPublicKey().toRawBytes()).toString('base64'),
@@ -45,12 +67,26 @@ async function createSigner(alias = 'default') {
         alias,
     };
     await promises_1.default.writeFile(file, JSON.stringify(payload, null, 2) + '\n', { encoding: 'utf8', mode: 0o600 });
-    await upsertGlobalConfig((cfg) => ({
-        ...cfg,
-        active_address: address,
-        key_alias: alias || cfg.key_alias || 'default',
-        author: cfg.author && cfg.author !== 'unknown' ? cfg.author : address,
-    }));
+    await upsertGlobalConfig((cfg) => {
+        const next = { ...cfg };
+        next.active_address = address;
+        next.key_alias = alias || cfg.key_alias || 'default';
+        if (!next.active_addresses)
+            next.active_addresses = {};
+        next.active_addresses.sui = address;
+        if (!next.key_aliases)
+            next.key_aliases = {};
+        next.key_aliases.sui = alias || cfg.key_alias || 'default';
+        if (!next.authors)
+            next.authors = {};
+        if (!next.authors.sui || next.authors.sui === 'unknown') {
+            next.authors.sui = address;
+        }
+        if (!cfg.author || cfg.author === 'unknown') {
+            next.author = address;
+        }
+        return next;
+    });
     return { signer: keypair, address, file };
 }
 async function loadSigner(address) {
@@ -59,7 +95,10 @@ async function loadSigner(address) {
     if (!resolvedAddress) {
         throw new Error('No active address configured. Generate a key with createSigner() or set active_address in ~/.witconfig.');
     }
-    const file = keyPathFor(resolvedAddress);
+    const file = await findKeyFile(resolvedAddress);
+    if (!file) {
+        throw new Error(`Key file not found for address ${resolvedAddress}. Generate a key with createSigner().`);
+    }
     const stored = await readKeyFile(file);
     const signer = ed25519_1.Ed25519Keypair.fromSecretKey(stored.privateKey);
     const derived = signer.getPublicKey().toSuiAddress();
@@ -165,51 +204,77 @@ function guessAddress(author) {
     return undefined;
 }
 async function listStoredKeys() {
-    let entries;
-    try {
-        entries = await promises_1.default.readdir(exports.KEY_HOME, { withFileTypes: true });
-    }
-    catch (err) {
-        if (err?.code === 'ENOENT')
-            return [];
-        throw err;
-    }
-    const keys = [];
-    for (const entry of entries) {
-        if (!entry.isFile() || !entry.name.endsWith('.key'))
-            continue;
-        const file = path_1.default.join(exports.KEY_HOME, entry.name);
+    const keysByAddress = new Map();
+    for (const dir of keyHomes()) {
+        let entries;
         try {
-            const parsed = await readKeyFile(file);
-            const derived = parsed.address || ed25519_1.Ed25519Keypair.fromSecretKey(parsed.privateKey).getPublicKey().toSuiAddress();
-            keys.push({
-                address: normalizeAddress(derived),
-                alias: parsed.alias,
-                file,
-                createdAt: parsed.createdAt,
-            });
+            entries = await promises_1.default.readdir(dir, { withFileTypes: true });
         }
         catch (err) {
-            // eslint-disable-next-line no-console
-            console.warn(`Skipping key ${file}: ${err.message}`);
+            if (err?.code === 'ENOENT')
+                continue;
+            throw err;
+        }
+        for (const entry of entries) {
+            if (!entry.isFile() || !entry.name.endsWith('.key'))
+                continue;
+            const file = path_1.default.join(dir, entry.name);
+            try {
+                const parsed = await readKeyFile(file);
+                if (parsed.chain && parsed.chain !== 'sui')
+                    continue;
+                const derived = parsed.address || ed25519_1.Ed25519Keypair.fromSecretKey(parsed.privateKey).getPublicKey().toSuiAddress();
+                const address = normalizeAddress(derived);
+                if (keysByAddress.has(address))
+                    continue;
+                keysByAddress.set(address, {
+                    address,
+                    alias: parsed.alias,
+                    file,
+                    createdAt: parsed.createdAt,
+                });
+            }
+            catch (err) {
+                // eslint-disable-next-line no-console
+                console.warn(`Skipping key ${file}: ${err.message}`);
+            }
         }
     }
-    return keys.sort((a, b) => (a.createdAt || '').localeCompare(b.createdAt || ''));
+    return Array.from(keysByAddress.values()).sort((a, b) => (a.createdAt || '').localeCompare(b.createdAt || ''));
 }
 async function readActiveAddress() {
     const cfg = await readGlobalConfig();
+    const byChain = cfg.active_addresses?.sui;
+    if (byChain)
+        return normalizeAddress(byChain);
     if (cfg.active_address)
         return normalizeAddress(cfg.active_address);
-    const guessed = guessAddress(cfg.author);
+    const guessed = guessAddress(cfg.authors?.sui || cfg.author);
     return guessed ? normalizeAddress(guessed) : null;
 }
 async function setActiveAddress(address, opts) {
     await upsertGlobalConfig((cfg) => {
-        const next = { ...cfg, active_address: normalizeAddress(address) };
+        const normalized = normalizeAddress(address);
+        const next = { ...cfg, active_address: normalized };
         if (opts?.alias)
             next.key_alias = opts.alias;
-        if (opts?.updateAuthorIfUnknown && (!cfg.author || cfg.author === 'unknown')) {
-            next.author = normalizeAddress(address);
+        if (!next.active_addresses)
+            next.active_addresses = {};
+        next.active_addresses.sui = normalized;
+        if (opts?.alias) {
+            if (!next.key_aliases)
+                next.key_aliases = {};
+            next.key_aliases.sui = opts.alias;
+        }
+        if (opts?.updateAuthorIfUnknown) {
+            if (!next.authors)
+                next.authors = {};
+            if (!next.authors.sui || next.authors.sui === 'unknown') {
+                next.authors.sui = normalized;
+            }
+            if (!cfg.author || cfg.author === 'unknown') {
+                next.author = normalized;
+            }
         }
         return next;
     });