@halot/cli 1.0.0

package/dist/shared/wallet/authority.util.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAuthorityWallet = resolveAuthorityWallet;
+exports.resolveActorWallet = resolveActorWallet;
+exports.resolveAuthorityAddress = resolveAuthorityAddress;
+exports.deriveVerifierSigningPublicKey = deriveVerifierSigningPublicKey;
+exports.createDefaultSettlementWallets = createDefaultSettlementWallets;
+exports.resolveZeroGAuthorityProfile = resolveZeroGAuthorityProfile;
+exports.isMainnetAuthority = isMainnetAuthority;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const ethers_1 = require("ethers");
+const zeroGAuthorityProfiles = {
+    '0g:testnet': {
+        networkMode: 'testnet',
+        chainId: 16602,
+        rpcUrl: 'https://evmrpc-testnet.0g.ai',
+    },
+    '0g:mainnet': {
+        networkMode: 'mainnet',
+        chainId: 16661,
+        rpcUrl: 'https://evmrpc.0g.ai',
+    },
+};
+function resolveAuthorityWallet(wallets, authority) {
+    return wallets.authorities[authority];
+}
+function resolveActorWallet(wallets, authority) {
+    return new ethers_1.Wallet(resolveAuthorityWallet(wallets, authority).privateKey);
+}
+function resolveAuthorityAddress(wallets, authority) {
+    const privateKey = resolveAuthorityWallet(wallets, authority).privateKey;
+    if (authority.startsWith('0g:')) {
+        return new ethers_1.Wallet(privateKey).address;
+    }
+    if (authority.startsWith('stellar:')) {
+        return stellar_sdk_1.Keypair.fromSecret(privateKey).publicKey();
+    }
+    throw new Error(`Unsupported authority ${authority}`);
+}
+function deriveVerifierSigningPublicKey(wallets, authority) {
+    return new ethers_1.SigningKey(resolveAuthorityWallet(wallets, asZeroGAuthority(authority)).privateKey).publicKey;
+}
+function createDefaultSettlementWallets(wallets) {
+    return {
+        '0g:testnet': resolveAuthorityAddress(wallets, '0g:testnet'),
+        '0g:mainnet': resolveAuthorityAddress(wallets, '0g:mainnet'),
+        'stellar:testnet': resolveAuthorityAddress(wallets, 'stellar:testnet'),
+        'stellar:mainnet': resolveAuthorityAddress(wallets, 'stellar:mainnet'),
+    };
+}
+function resolveZeroGAuthorityProfile(authority) {
+    return zeroGAuthorityProfiles[asZeroGAuthority(authority)];
+}
+function isMainnetAuthority(authority) {
+    return zeroGAuthorityProfiles[asZeroGAuthority(authority)].networkMode === 'mainnet';
+}
+function asZeroGAuthority(authority) {
+    if (!authority.startsWith('0g:')) {
+        throw new Error(`Expected a 0G authority, received ${authority}`);
+    }
+    return authority;
+}

package/dist/shared/wallet/wallet.manager.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WalletManager = void 0;
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const ethers_1 = require("ethers");
+const workspace_service_1 = require("@halot/cli/shared/workspace/workspace.service");
+class WalletManager {
+    workspaceService;
+    constructor(workspaceService = new workspace_service_1.WorkspaceService()) {
+        this.workspaceService = workspaceService;
+    }
+    createWallets() {
+        const zeroGTestnetWallet = ethers_1.Wallet.createRandom();
+        const zeroGMainnetWallet = ethers_1.Wallet.createRandom();
+        const stellarTestnetWallet = stellar_sdk_1.Keypair.random();
+        const stellarMainnetWallet = stellar_sdk_1.Keypair.random();
+        const wallets = {
+            authorities: {
+                '0g:testnet': {
+                    privateKey: zeroGTestnetWallet.privateKey,
+                },
+                '0g:mainnet': {
+                    privateKey: zeroGMainnetWallet.privateKey,
+                },
+                'stellar:testnet': {
+                    privateKey: stellarTestnetWallet.secret(),
+                },
+                'stellar:mainnet': {
+                    privateKey: stellarMainnetWallet.secret(),
+                },
+            },
+        };
+        this.workspaceService.writeWallets(wallets);
+        this.workspaceService.ensureGitignoreIncludesWallet();
+        return wallets;
+    }
+    getWallets() {
+        return this.workspaceService.readWallets();
+    }
+}
+exports.WalletManager = WalletManager;

package/dist/shared/workspace/workspace.service.js

@@ -0,0 +1,192 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkspaceService = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const stellar_sdk_1 = require("@stellar/stellar-sdk");
+const ethers_1 = require("ethers");
+const sdk_1 = require("@halot/sdk");
+class WorkspaceService {
+    baseDir;
+    constructor(baseDir = process.cwd()) {
+        this.baseDir = baseDir;
+    }
+    getPath(fileName) {
+        return node_path_1.default.join(this.baseDir, fileName);
+    }
+    ensureGitignoreIncludesWallet() {
+        (0, sdk_1.ensureDirectory)(this.baseDir);
+        const gitignorePath = this.getPath('.gitignore');
+        const current = node_fs_1.default.existsSync(gitignorePath) ? node_fs_1.default.readFileSync(gitignorePath, 'utf8') : '';
+        const entries = ['wallets.json', 'wallet.json', '.halot/'];
+        const missing = entries.filter((entry) => !current.includes(entry));
+        if (missing.length > 0) {
+            const suffix = missing.map((entry) => `${entry}\n`).join('');
+            const next = `${current}${current.endsWith('\n') || current.length === 0 ? '' : '\n'}${suffix}`;
+            node_fs_1.default.writeFileSync(gitignorePath, next);
+        }
+    }
+    ensureServicesDirectory() {
+        const directory = this.getPath('services');
+        (0, sdk_1.ensureDirectory)(directory);
+        return directory;
+    }
+    readStreamCursor(key) {
+        const state = this.readStreamCursorState();
+        return state.cursors[key];
+    }
+    writeStreamCursor(key, eventId) {
+        const state = this.readStreamCursorState();
+        state.cursors[key] = eventId;
+        (0, sdk_1.writeJsonFile)(this.getStreamCursorPath(), state);
+    }
+    readProviderConfig() {
+        return sdk_1.ProviderConfigSchema.parse((0, sdk_1.readJsonFile)(this.getPath('halot.provider.json')));
+    }
+    writeProviderConfig(config) {
+        (0, sdk_1.writeJsonFile)(this.getPath('halot.provider.json'), sdk_1.ProviderConfigSchema.parse(config));
+    }
+    readVerifierConfig() {
+        return sdk_1.VerifierConfigSchema.parse((0, sdk_1.readJsonFile)(this.getPath('halot.verifier.json')));
+    }
+    writeVerifierConfig(config) {
+        (0, sdk_1.writeJsonFile)(this.getPath('halot.verifier.json'), sdk_1.VerifierConfigSchema.parse(config));
+    }
+    readRequesterConfig() {
+        return sdk_1.RequesterConfigSchema.parse((0, sdk_1.readJsonFile)(this.getPath('halot.requester.json')));
+    }
+    writeRequesterConfig(config) {
+        (0, sdk_1.writeJsonFile)(this.getPath('halot.requester.json'), sdk_1.RequesterConfigSchema.parse(config));
+    }
+    readWallets(filePath = './wallets.json') {
+        const preferredPath = this.getPath(filePath);
+        if (node_fs_1.default.existsSync(preferredPath)) {
+            return sdk_1.WalletBundleSchema.parse(normalizeWalletBundle((0, sdk_1.readJsonFile)(preferredPath)));
+        }
+        const legacyPath = this.getPath('wallet.json');
+        return sdk_1.WalletBundleSchema.parse(normalizeWalletBundle((0, sdk_1.readJsonFile)(legacyPath)));
+    }
+    writeWallets(wallets, filePath = './wallets.json') {
+        (0, sdk_1.writeJsonFile)(this.getPath(filePath), sdk_1.WalletBundleSchema.parse(wallets));
+    }
+    readServices() {
+        return this.listServiceFiles()
+            .map((fileName) => this.readServiceFile(fileName));
+    }
+    writeService(fileName, service) {
+        (0, sdk_1.writeJsonFile)(node_path_1.default.join(this.ensureServicesDirectory(), fileName), sdk_1.ServiceSchema.parse(service));
+    }
+    readServiceFile(fileName) {
+        return sdk_1.ServiceSchema.parse((0, sdk_1.readJsonFile)(node_path_1.default.join(this.ensureServicesDirectory(), fileName)));
+    }
+    listServiceFiles() {
+        const servicesDir = this.ensureServicesDirectory();
+        return node_fs_1.default.readdirSync(servicesDir)
+            .filter((fileName) => fileName.endsWith('.json'))
+            .sort();
+    }
+    nextServiceDraftFileName() {
+        const nextIndex = this.listServiceFiles()
+            .map((fileName) => /^service-(\d+)\.json$/.exec(fileName))
+            .map((match) => Number(match?.[1] ?? 0))
+            .reduce((max, current) => Math.max(max, current), 0) + 1;
+        return `service-${String(nextIndex).padStart(3, '0')}.json`;
+    }
+    removeService(fileName) {
+        const filePath = node_path_1.default.join(this.ensureServicesDirectory(), fileName);
+        if (node_fs_1.default.existsSync(filePath)) {
+            node_fs_1.default.rmSync(filePath);
+        }
+    }
+    replaceServiceFile(currentFileName, nextFileName, service) {
+        this.writeService(nextFileName, service);
+        if (currentFileName !== nextFileName) {
+            this.removeService(currentFileName);
+        }
+    }
+    readModelConfig() {
+        return sdk_1.ModelConfigSchema.parse((0, sdk_1.readJsonFile)(this.getPath('model.config.json')));
+    }
+    writeModelConfig(config) {
+        (0, sdk_1.writeJsonFile)(this.getPath('model.config.json'), sdk_1.ModelConfigSchema.parse(config));
+    }
+    readInferenceTemplate() {
+        return sdk_1.InferenceTemplateSchema.parse((0, sdk_1.readJsonFile)(this.getPath('inference.json')));
+    }
+    writeInferenceTemplate(template) {
+        (0, sdk_1.writeJsonFile)(this.getPath('inference.json'), sdk_1.InferenceTemplateSchema.parse(template));
+    }
+    readSpecializations() {
+        return sdk_1.SpecializationsSchema.parse((0, sdk_1.readJsonFile)(this.getPath('specializations.json')));
+    }
+    writeSpecializations(specializations) {
+        (0, sdk_1.writeJsonFile)(this.getPath('specializations.json'), sdk_1.SpecializationsSchema.parse(specializations));
+    }
+    ensureRuntimeDirectory() {
+        const directory = this.getPath('.halot');
+        (0, sdk_1.ensureDirectory)(directory);
+        return directory;
+    }
+    getStreamCursorPath() {
+        return node_path_1.default.join(this.ensureRuntimeDirectory(), 'stream-cursors.json');
+    }
+    readStreamCursorState() {
+        const statePath = this.getStreamCursorPath();
+        if (!node_fs_1.default.existsSync(statePath)) {
+            return { cursors: {} };
+        }
+        return (0, sdk_1.readJsonFile)(statePath);
+    }
+}
+exports.WorkspaceService = WorkspaceService;
+function normalizeWalletBundle(input) {
+    if (isRecord(input) && isRecord(input.authorities)) {
+        return {
+            authorities: {
+                '0g:testnet': normalizeAuthorityEntry(input.authorities['0g:testnet']),
+                '0g:mainnet': normalizeAuthorityEntry(input.authorities['0g:mainnet']),
+                'stellar:testnet': normalizeAuthorityEntry(input.authorities['stellar:testnet']),
+                'stellar:mainnet': normalizeAuthorityEntry(input.authorities['stellar:mainnet']),
+            },
+        };
+    }
+    if (isRecord(input) && input.zeroG && input.stellar) {
+        const zeroG = normalizeAuthorityEntry(input.zeroG);
+        const stellar = normalizeAuthorityEntry(input.stellar);
+        return {
+            authorities: {
+                '0g:testnet': zeroG,
+                '0g:mainnet': zeroG,
+                'stellar:testnet': stellar,
+                'stellar:mainnet': stellar,
+            },
+        };
+    }
+    return sdk_1.WalletBundleSchema.parse(input);
+}
+function normalizeAuthorityEntry(input) {
+    if (!isRecord(input) || typeof input.privateKey !== 'string' || input.privateKey.length === 0) {
+        throw new Error('Invalid wallet authority entry');
+    }
+    if (typeof input.address === 'string' && input.address.length > 0) {
+        if (input.privateKey.startsWith('0x')) {
+            const derived = new ethers_1.Wallet(input.privateKey).address;
+            if (derived.toLowerCase() !== input.address.toLowerCase()) {
+                throw new Error('Wallet address does not match the provided private key');
+            }
+        }
+        else {
+            const derived = stellar_sdk_1.Keypair.fromSecret(input.privateKey).publicKey();
+            if (derived !== input.address) {
+                throw new Error('Wallet address does not match the provided private key');
+            }
+        }
+    }
+    return { privateKey: input.privateKey };
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@halot/cli",
+  "version": "1.0.0",
+  "description": "Halot protocol CLI",
+  "main": "dist/index.js",
+  "bin": {
+    "halot": "dist/index.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc -p tsconfig.json",
+    "clean": "rm -rf dist",
+    "test": "npm run build && node --test dist/tests/*.test.js",
+    "prepack": "npm run build"
+  },
+  "keywords": [
+    "halot",
+    "cli"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "files": [
+    "dist/features",
+    "dist/shared",
+    "dist/index.js",
+    ".env.example",
+    "README.md"
+  ],
+  "exports": {
+    ".": "./dist/index.js",
+    "./*": "./dist/*.js"
+  },
+  "dependencies": {
+    "@halot/sdk": "^1.0.0",
+    "@stellar/stellar-sdk": "^15.0.1",
+    "@web3-name-sdk/core": "^0.1.18",
+    "commander": "^14.0.3",
+    "ethers": "6.13.1",
+    "inquirer": "^13.3.2",
+    "viem": "^2.47.10"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^9.0.9",
+    "@types/node": "^25.5.2",
+    "typescript": "^6.0.2"
+  }
+}