@halot/cli 1.0.0

package/dist/shared/integrations/agent-id/agent-id-register.service.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentIdRegisterService = void 0;
+exports.createZeroGAgentUri = createZeroGAgentUri;
+const viem_1 = require("viem");
+const accounts_1 = require("viem/accounts");
+const env_1 = require("@halot/cli/shared/config/env");
+const agentIdentityRegistryAbi = [
+    {
+        inputs: [{ internalType: 'string', name: 'agentURI', type: 'string' }],
+        name: 'register',
+        outputs: [{ internalType: 'uint256', name: 'agentId', type: 'uint256' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'string', name: 'agentURI', type: 'string' },
+            {
+                components: [
+                    { internalType: 'string', name: 'metadataKey', type: 'string' },
+                    { internalType: 'bytes', name: 'metadataValue', type: 'bytes' },
+                ],
+                internalType: 'struct MetadataEntry[]',
+                name: 'metadata',
+                type: 'tuple[]',
+            },
+        ],
+        name: 'register',
+        outputs: [{ internalType: 'uint256', name: 'agentId', type: 'uint256' }],
+        stateMutability: 'nonpayable',
+        type: 'function',
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: 'uint256', name: 'agentId', type: 'uint256' },
+            { indexed: false, internalType: 'string', name: 'agentURI', type: 'string' },
+            { indexed: true, internalType: 'address', name: 'owner', type: 'address' },
+        ],
+        name: 'Registered',
+        type: 'event',
+    },
+    {
+        anonymous: false,
+        inputs: [
+            { indexed: true, internalType: 'address', name: 'from', type: 'address' },
+            { indexed: true, internalType: 'address', name: 'to', type: 'address' },
+            { indexed: true, internalType: 'uint256', name: 'tokenId', type: 'uint256' },
+        ],
+        name: 'Transfer',
+        type: 'event',
+    },
+];
+function createZeroGAgentUri(rootHash) {
+    const env = (0, env_1.loadCliEnv)();
+    const gateway = env.zeroGStorageGateway;
+    if (gateway) {
+        return `${gateway}/${rootHash}`;
+    }
+    return `0g://${rootHash}`;
+}
+class AgentIdRegisterService {
+    async registerAgent(input) {
+        const env = (0, env_1.loadCliEnv)();
+        const registryAddress = input.registryAddress ?? env.agentIdRegistryAddress;
+        if (!registryAddress) {
+            throw new Error('Agent ID registration requires HALOT_AGENT_ID_REGISTRY_ADDRESS.');
+        }
+        const account = (0, accounts_1.privateKeyToAccount)(input.privateKey);
+        if (account.address.toLowerCase() !== input.ownerAddress.toLowerCase()) {
+            throw new Error('Agent ID registration wallet address does not match the configured owner address.');
+        }
+        const chain = (0, viem_1.defineChain)({
+            id: input.chainId,
+            name: '0G Chain',
+            nativeCurrency: {
+                name: '0G',
+                symbol: '0G',
+                decimals: 18,
+            },
+            rpcUrls: {
+                default: { http: [input.rpcUrl] },
+                public: { http: [input.rpcUrl] },
+            },
+        });
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain,
+            transport: (0, viem_1.http)(input.rpcUrl),
+        });
+        const walletClient = (0, viem_1.createWalletClient)({
+            account,
+            chain,
+            transport: (0, viem_1.http)(input.rpcUrl),
+        });
+        const transactionHash = await this.writeRegisterTransaction({
+            account: account.address,
+            agentUri: input.agentUri,
+            publicClient,
+            registryAddress,
+            walletClient,
+        });
+        const receipt = await publicClient.waitForTransactionReceipt({ hash: transactionHash });
+        const agentId = this.extractAgentId(receipt.logs);
+        return {
+            registryAddress,
+            agentId,
+            agentRegistry: `eip155:${input.chainId}:${registryAddress}`,
+            agentUri: input.agentUri,
+            transactionHash,
+        };
+    }
+    async writeRegisterTransaction(input) {
+        try {
+            const simulation = await input.publicClient.simulateContract({
+                account: input.account,
+                address: input.registryAddress,
+                abi: agentIdentityRegistryAbi,
+                functionName: 'register',
+                args: [input.agentUri],
+            });
+            return input.walletClient.writeContract(simulation.request);
+        }
+        catch {
+            const simulation = await input.publicClient.simulateContract({
+                account: input.account,
+                address: input.registryAddress,
+                abi: agentIdentityRegistryAbi,
+                functionName: 'register',
+                args: [input.agentUri, []],
+            });
+            return input.walletClient.writeContract(simulation.request);
+        }
+    }
+    extractAgentId(logs) {
+        const registeredLogs = (0, viem_1.parseEventLogs)({
+            abi: agentIdentityRegistryAbi,
+            eventName: 'Registered',
+            logs: logs,
+            strict: false,
+        });
+        const registeredLog = registeredLogs[0];
+        if (registeredLog?.args?.agentId !== undefined) {
+            return String(registeredLog.args.agentId);
+        }
+        const transferLogs = (0, viem_1.parseEventLogs)({
+            abi: agentIdentityRegistryAbi,
+            eventName: 'Transfer',
+            logs: logs,
+            strict: false,
+        });
+        const transferLog = transferLogs[0];
+        if (transferLog?.args?.tokenId !== undefined) {
+            return String(transferLog.args.tokenId);
+        }
+        throw new Error('Agent ID registration completed, but no Registered or Transfer event was found.');
+    }
+}
+exports.AgentIdRegisterService = AgentIdRegisterService;

package/dist/shared/integrations/space-id/space-id-register.service.js

@@ -0,0 +1,467 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SpaceIdRegisterService = void 0;
+const utils_1 = require("@web3-name-sdk/core/utils");
+const viem_1 = require("viem");
+const accounts_1 = require("viem/accounts");
+const env_1 = require("@halot/cli/shared/config/env");
+const yearInSeconds = 31556952n;
+const zeroGSpaceIdDefaults = {
+    tldId: 26,
+    chainId: 16661,
+    graphUrl: 'https://graphigo.prd.space.id/query',
+    identifier: '449205675366457712613706471770511817162982777845754732038879201565074548',
+    controllerAddress: '0xd7b837a0e388b4c25200983bdaa3ef3a83ca86b7',
+    resolverAddress: '0x6D3B3F99177FB2A5de7F9E928a9BD807bF7b5BAD',
+    registryAddress: '0x5dC881dDA4e4a8d312be3544AD13118D1a04Cb17',
+    sannAddress: '0x9af6F1244df403dAe39Eb2D0be1C3fD0B38e0789',
+    verifiedTldHubAddress: '0x754D6827A57334143eD5fB58C5b1A4aAe4396ba5',
+    verifiedTldHubRpcUrl: 'https://ethereum-rpc.publicnode.com',
+    defaultRpc: 'https://evmrpc.0g.ai',
+};
+const sidV3ControllerAbi = [
+    {
+        inputs: [{ internalType: 'uint256', name: 'realPrice', type: 'uint256' }],
+        name: 'SimulatePrice',
+        type: 'error',
+    },
+    {
+        inputs: [
+            { internalType: 'uint256', name: 'identifier', type: 'uint256' },
+            { internalType: 'string', name: 'name', type: 'string' },
+        ],
+        name: 'available',
+        outputs: [{ internalType: 'bool', name: '', type: 'bool' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'uint256', name: 'identifier', type: 'uint256' },
+            { internalType: 'string[]', name: 'names', type: 'string[]' },
+            { internalType: 'address', name: 'owner', type: 'address' },
+            { internalType: 'uint256', name: 'duration', type: 'uint256' },
+            { internalType: 'address', name: 'resolver', type: 'address' },
+            { internalType: 'bool', name: 'setTldName', type: 'bool' },
+            { internalType: 'bytes[]', name: 'extraData', type: 'bytes[]' },
+        ],
+        name: 'bulkRegister',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+    {
+        inputs: [
+            { internalType: 'uint256', name: 'identifier', type: 'uint256' },
+            { internalType: 'string[]', name: 'names', type: 'string[]' },
+            { internalType: 'address', name: 'owner', type: 'address' },
+            { internalType: 'uint256', name: 'duration', type: 'uint256' },
+            { internalType: 'address', name: 'resolver', type: 'address' },
+            { internalType: 'bool', name: 'setTldName', type: 'bool' },
+            { internalType: 'bytes[]', name: 'extraData', type: 'bytes[]' },
+        ],
+        name: 'bulkRegisterSimulate',
+        outputs: [{ internalType: 'uint256', name: '', type: 'uint256' }],
+        stateMutability: 'payable',
+        type: 'function',
+    },
+];
+const sidRegistryAbi = [
+    {
+        inputs: [{ internalType: 'bytes32', name: 'node', type: 'bytes32' }],
+        name: 'resolver',
+        outputs: [{ internalType: 'address', name: '', type: 'address' }],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+const verifiedTldHubAbi = [
+    {
+        inputs: [{ internalType: 'string[]', name: 'tlds', type: 'string[]' }],
+        name: 'getTldInfo',
+        outputs: [
+            {
+                components: [
+                    { internalType: 'string', name: 'tld', type: 'string' },
+                    { internalType: 'uint256', name: 'identifier', type: 'uint256' },
+                    { internalType: 'uint256', name: 'chainId', type: 'uint256' },
+                    { internalType: 'string', name: 'defaultRpc', type: 'string' },
+                    { internalType: 'address', name: 'registry', type: 'address' },
+                    { internalType: 'address', name: 'sann', type: 'address' },
+                ],
+                internalType: 'struct VerifiedTldHub.completeTldInfo[]',
+                name: '',
+                type: 'tuple[]',
+            },
+        ],
+        stateMutability: 'view',
+        type: 'function',
+    },
+];
+class SpaceIdRegisterService {
+    async registerZeroGDomain(input) {
+        if (!input.domain.endsWith('.0g')) {
+            throw new Error('Only .0g domains are supported by this registration flow.');
+        }
+        const label = this.normalizeLabel(input.domain);
+        const config = await this.resolveConfig(input);
+        const chain = (0, viem_1.defineChain)({
+            id: input.chainId,
+            name: '0G Chain',
+            nativeCurrency: {
+                name: '0G',
+                symbol: '0G',
+                decimals: 18,
+            },
+            rpcUrls: {
+                default: { http: [input.rpcUrl] },
+                public: { http: [input.rpcUrl] },
+            },
+        });
+        const account = (0, accounts_1.privateKeyToAccount)(input.privateKey);
+        if (account.address.toLowerCase() !== input.address.toLowerCase()) {
+            throw new Error('SPACE ID registration wallet address does not match the configured owner address.');
+        }
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain,
+            transport: (0, viem_1.http)(input.rpcUrl),
+        });
+        const walletClient = (0, viem_1.createWalletClient)({
+            account,
+            chain,
+            transport: (0, viem_1.http)(input.rpcUrl),
+        });
+        const available = await publicClient.readContract({
+            address: config.controllerAddress,
+            abi: sidV3ControllerAbi,
+            functionName: 'available',
+            args: [config.identifier, label],
+        });
+        if (!available) {
+            throw new Error('Domain is unavailable or already registered.');
+        }
+        const years = input.years ?? 1;
+        const duration = BigInt(years) * yearInSeconds;
+        const extraData = [this.encodeExtraData(false)];
+        const price = await this.getRentPrice(publicClient, config, label, duration, extraData);
+        const bufferedPrice = (price * 101n) / 100n;
+        const data = (0, viem_1.encodeFunctionData)({
+            abi: sidV3ControllerAbi,
+            functionName: 'bulkRegister',
+            args: [
+                config.identifier,
+                [label],
+                input.address,
+                duration,
+                config.resolverAddress,
+                true,
+                extraData,
+            ],
+        });
+        let gas = await publicClient.estimateGas({
+            account: account.address,
+            to: config.controllerAddress,
+            data,
+            value: bufferedPrice,
+        });
+        if (gas > 0n) {
+            gas = (gas * 12n) / 10n;
+        }
+        const transactionHash = await walletClient.sendTransaction({
+            account,
+            chain,
+            to: config.controllerAddress,
+            value: bufferedPrice,
+            data,
+            gas,
+        });
+        await publicClient.waitForTransactionReceipt({ hash: transactionHash });
+        return {
+            domain: input.domain,
+            address: input.address,
+            price: price.toString(),
+            transactionHash,
+        };
+    }
+    async resolveConfig(input) {
+        const env = (0, env_1.loadCliEnv)();
+        const discovered = await this.discoverZeroGConfig(input).catch(() => null);
+        const identifier = input.identifier
+            ?? env.spaceIdIdentifier
+            ?? discovered?.identifier
+            ?? zeroGSpaceIdDefaults.identifier;
+        const controllerAddress = input.controllerAddress
+            ?? env.spaceIdControllerAddress
+            ?? discovered?.controllerAddress
+            ?? zeroGSpaceIdDefaults.controllerAddress;
+        const resolverAddress = input.resolverAddress
+            ?? env.spaceIdResolverAddress
+            ?? discovered?.resolverAddress
+            ?? zeroGSpaceIdDefaults.resolverAddress;
+        const simulateAccount = input.simulateAccount
+            ?? env.spaceIdSimulateAccount;
+        const simulateValue = input.simulateValue ?? env.spaceIdSimulateValue;
+        if (!identifier || !controllerAddress || !resolverAddress) {
+            throw new Error('SPACE ID .0g registration requires HALOT_SPACE_ID_IDENTIFIER, HALOT_SPACE_ID_CONTROLLER_ADDRESS, and HALOT_SPACE_ID_RESOLVER_ADDRESS.');
+        }
+        return {
+            identifier: BigInt(identifier),
+            controllerAddress,
+            resolverAddress,
+            simulateAccount: simulateAccount ?? viem_1.zeroAddress,
+            simulateValue: (0, viem_1.parseEther)(simulateValue ?? '500'),
+        };
+    }
+    async discoverZeroGConfig(input) {
+        if (input.chainId !== zeroGSpaceIdDefaults.chainId) {
+            return {
+                identifier: zeroGSpaceIdDefaults.identifier,
+                controllerAddress: zeroGSpaceIdDefaults.controllerAddress,
+                resolverAddress: zeroGSpaceIdDefaults.resolverAddress,
+            };
+        }
+        const graphTld = await this.fetchGraphTld();
+        const verifiedTld = await this.fetchVerifiedTld();
+        const sampleNames = await this.fetchSampleDomains();
+        const resolverAddress = await this.fetchResolverAddress(verifiedTld, sampleNames);
+        return {
+            identifier: graphTld.identifier,
+            controllerAddress: graphTld.controllerAddr,
+            resolverAddress,
+        };
+    }
+    normalizeLabel(domain) {
+        const label = domain.replace(/\.0g$/iu, '');
+        const normalized = (0, utils_1.validateName)(label);
+        const characterCount = (0, utils_1.countCharacters)(normalized);
+        if (normalized !== label) {
+            throw new Error('SPACE ID label must already be normalized.');
+        }
+        if (characterCount < 3 || characterCount > 512) {
+            throw new Error('SPACE ID label length must be between 3 and 512 characters.');
+        }
+        return normalized;
+    }
+    encodeExtraData(usePoints, referrerAddress) {
+        if (!usePoints && !referrerAddress) {
+            return '0x';
+        }
+        const rewardHookExtraData = referrerAddress
+            ? (0, viem_1.encodeAbiParameters)([{ type: 'address', name: 'referrerAddress' }], [referrerAddress])
+            : '0x';
+        const pointHookExtraData = (0, viem_1.encodeAbiParameters)([{ type: 'bool', name: 'useGiftCardPoints' }], [usePoints]);
+        return (0, viem_1.encodeAbiParameters)([
+            {
+                components: [
+                    { type: 'bytes', name: 'QualificationHookExtraData' },
+                    { type: 'bytes', name: 'PriceHookExtraData' },
+                    { type: 'bytes', name: 'PointHookExtraData' },
+                    { type: 'bytes', name: 'RewardHookExtraData' },
+                ],
+                name: 'extraData',
+                type: 'tuple',
+            },
+        ], [
+            {
+                QualificationHookExtraData: '0x',
+                PriceHookExtraData: '0x',
+                PointHookExtraData: pointHookExtraData,
+                RewardHookExtraData: rewardHookExtraData,
+            },
+        ]);
+    }
+    async getRentPrice(publicClient, config, label, duration, extraData) {
+        try {
+            await publicClient.simulateContract({
+                address: config.controllerAddress,
+                abi: sidV3ControllerAbi,
+                account: config.simulateAccount,
+                functionName: 'bulkRegisterSimulate',
+                args: [
+                    config.identifier,
+                    [label],
+                    config.simulateAccount,
+                    duration,
+                    config.resolverAddress,
+                    false,
+                    extraData,
+                ],
+                value: config.simulateValue,
+            });
+        }
+        catch (error) {
+            const price = this.extractSimulatedPrice(error);
+            if (price !== null) {
+                return price;
+            }
+            throw error;
+        }
+        throw new Error('SPACE ID rent price simulation did not return a price.');
+    }
+    async fetchGraphTld() {
+        const env = (0, env_1.loadCliEnv)();
+        const graphUrl = env.spaceIdGraphUrl || zeroGSpaceIdDefaults.graphUrl;
+        const result = await this.queryGraph(graphUrl, 'query Tld($tldIDs: [Int!]!) { Tlds(tldIDs: $tldIDs) { tldID tldName identifier chainID controllerAddr } }', { tldIDs: [zeroGSpaceIdDefaults.tldId] });
+        const tld = result.Tlds[0];
+        if (!tld) {
+            throw new Error('SPACE ID graph did not return the .0g TLD row.');
+        }
+        return tld;
+    }
+    async fetchSampleDomains() {
+        const env = (0, env_1.loadCliEnv)();
+        const graphUrl = env.spaceIdGraphUrl || zeroGSpaceIdDefaults.graphUrl;
+        const result = await this.queryGraph(graphUrl, 'query domains($input: ListDomainsInput!) { domains(input: $input) { list { name } } }', {
+            input: {
+                tldID: zeroGSpaceIdDefaults.tldId,
+                first: 5,
+            },
+        });
+        const names = result.domains.list
+            .map((domain) => domain.name.trim())
+            .filter((domain) => domain.length > 0)
+            .map((domain) => domain.endsWith('.0g') ? domain : `${domain}.0g`);
+        if (names.length === 0) {
+            throw new Error('SPACE ID graph did not return any registered .0g domains.');
+        }
+        return names;
+    }
+    async fetchVerifiedTld() {
+        const env = (0, env_1.loadCliEnv)();
+        const hubRpcUrl = env.spaceIdVerifiedTldHubRpcUrl || zeroGSpaceIdDefaults.verifiedTldHubRpcUrl;
+        const hubAddress = env.spaceIdVerifiedTldHubAddress || zeroGSpaceIdDefaults.verifiedTldHubAddress;
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain: (0, viem_1.defineChain)({
+                id: 1,
+                name: 'Ethereum',
+                nativeCurrency: {
+                    name: 'Ether',
+                    symbol: 'ETH',
+                    decimals: 18,
+                },
+                rpcUrls: {
+                    default: { http: [hubRpcUrl] },
+                    public: { http: [hubRpcUrl] },
+                },
+            }),
+            transport: (0, viem_1.http)(hubRpcUrl),
+        });
+        const rows = await publicClient.readContract({
+            address: hubAddress,
+            abi: verifiedTldHubAbi,
+            functionName: 'getTldInfo',
+            args: [['0g']],
+        });
+        const tld = rows[0];
+        if (!tld) {
+            throw new Error('Verified TLD Hub did not return the .0g TLD row.');
+        }
+        return tld;
+    }
+    async fetchResolverAddress(verifiedTld, sampleNames) {
+        const rpcUrl = verifiedTld.defaultRpc || zeroGSpaceIdDefaults.defaultRpc;
+        const chainId = Number(verifiedTld.chainId || BigInt(zeroGSpaceIdDefaults.chainId));
+        const registryAddress = verifiedTld.registry || zeroGSpaceIdDefaults.registryAddress;
+        const publicClient = (0, viem_1.createPublicClient)({
+            chain: (0, viem_1.defineChain)({
+                id: chainId,
+                name: '0G Chain',
+                nativeCurrency: {
+                    name: '0G',
+                    symbol: '0G',
+                    decimals: 18,
+                },
+                rpcUrls: {
+                    default: { http: [rpcUrl] },
+                    public: { http: [rpcUrl] },
+                },
+            }),
+            transport: (0, viem_1.http)(rpcUrl),
+        });
+        const counts = new Map();
+        for (const sampleName of sampleNames) {
+            const node = (0, utils_1.tldNamehash)(sampleName, verifiedTld.identifier);
+            const resolver = await publicClient.readContract({
+                address: registryAddress,
+                abi: sidRegistryAbi,
+                functionName: 'resolver',
+                args: [node],
+            });
+            if (resolver === viem_1.zeroAddress) {
+                continue;
+            }
+            counts.set(resolver, (counts.get(resolver) ?? 0) + 1);
+        }
+        const resolver = [...counts.entries()]
+            .map(([address, count]) => ({ address, count }))
+            .sort((left, right) => right.count - left.count)[0]?.address;
+        return resolver ?? zeroGSpaceIdDefaults.resolverAddress;
+    }
+    extractSimulatedPrice(error) {
+        const visited = new Set();
+        const queue = [error];
+        while (queue.length > 0) {
+            const current = queue.shift();
+            if (!current || visited.has(current)) {
+                continue;
+            }
+            visited.add(current);
+            if (typeof current === 'object') {
+                const record = current;
+                const args = record.args;
+                if (Array.isArray(args) && args[0] !== undefined) {
+                    try {
+                        return BigInt(String(args[0]));
+                    }
+                    catch { }
+                }
+                const metaMessages = record.metaMessages;
+                if (Array.isArray(metaMessages)) {
+                    const joined = metaMessages.filter((item) => typeof item === 'string').join('\n');
+                    const parsed = this.parseSimulatePrice(joined);
+                    if (parsed !== null) {
+                        return parsed;
+                    }
+                }
+                const shortMessage = typeof record.shortMessage === 'string' ? record.shortMessage : '';
+                const message = typeof record.message === 'string' ? record.message : '';
+                const parsed = this.parseSimulatePrice(`${shortMessage}\n${message}`);
+                if (parsed !== null) {
+                    return parsed;
+                }
+                queue.push(record.cause);
+                queue.push(record.details);
+                queue.push(record.data);
+            }
+        }
+        return null;
+    }
+    parseSimulatePrice(message) {
+        const match = message.match(/SimulatePrice\(uint256 realPrice\)[\s\S]*?\[(\d+)\]/u);
+        if (!match?.[1]) {
+            return null;
+        }
+        return BigInt(match[1]);
+    }
+    async queryGraph(url, query, variables) {
+        const response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'content-type': 'application/json',
+            },
+            body: JSON.stringify({ query, variables }),
+        });
+        const payload = await response.json();
+        if (!response.ok) {
+            throw new Error(`SPACE ID graph request failed with status ${response.status}.`);
+        }
+        if (payload.errors?.length) {
+            throw new Error(payload.errors.map((error) => error.message || 'Unknown SPACE ID graph error.').join(' '));
+        }
+        if (!payload.data) {
+            throw new Error('SPACE ID graph returned no data.');
+        }
+        return payload.data;
+    }
+}
+exports.SpaceIdRegisterService = SpaceIdRegisterService;

package/dist/shared/integrations/zero-g/verifier-registry.service.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZeroGVerifierRegistryService = void 0;
+const ethers_1 = require("ethers");
+const sdk_1 = require("@halot/sdk");
+const env_1 = require("@halot/cli/shared/config/env");
+const registryAbi = [
+    'function upsertVerifier(uint256 categoryMask, bytes32[] allowedServiceHashes) payable',
+    'function requestUnstake()',
+    'function withdrawStake()',
+];
+class ZeroGVerifierRegistryService {
+    env = (0, env_1.loadCliEnv)();
+    async registerVerifier(input) {
+        const registry = this.getRegistry(input.privateKey, input.rpcUrl);
+        const categoryMask = (0, sdk_1.serviceCategoriesToMask)(input.categories);
+        const serviceHashes = input.serviceIds.map((serviceId) => (0, sdk_1.hashText)(serviceId));
+        const transaction = await registry.upsertVerifier(categoryMask, serviceHashes, { value: (0, ethers_1.parseEther)(input.stakeAmount) });
+        const receipt = await transaction.wait();
+        if (!receipt || receipt.status !== 1) {
+            throw new Error('0G verifier registry transaction failed');
+        }
+        return { transactionHash: transaction.hash };
+    }
+    async requestUnstake(input) {
+        const registry = this.getRegistry(input.privateKey, input.rpcUrl);
+        const transaction = await registry.requestUnstake();
+        const receipt = await transaction.wait();
+        if (!receipt || receipt.status !== 1) {
+            throw new Error('0G verifier unstake request failed');
+        }
+        return { transactionHash: transaction.hash };
+    }
+    async withdrawStake(input) {
+        const registry = this.getRegistry(input.privateKey, input.rpcUrl);
+        const transaction = await registry.withdrawStake();
+        const receipt = await transaction.wait();
+        if (!receipt || receipt.status !== 1) {
+            throw new Error('0G verifier stake withdrawal failed');
+        }
+        return { transactionHash: transaction.hash };
+    }
+    getRegistry(privateKey, rpcUrl) {
+        const provider = new ethers_1.JsonRpcProvider(rpcUrl);
+        const wallet = new ethers_1.Wallet(privateKey, provider);
+        return new ethers_1.Contract(this.getRegistryAddress(), registryAbi, wallet);
+    }
+    getRegistryAddress() {
+        if (!this.env.zeroGVerifierRegistryAddress) {
+            throw new Error('Missing HALOT_ZERO_G_VERIFIER_REGISTRY_ADDRESS');
+        }
+        return this.env.zeroGVerifierRegistryAddress;
+    }
+}
+exports.ZeroGVerifierRegistryService = ZeroGVerifierRegistryService;

package/dist/shared/output/print.util.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printJson = printJson;
+exports.sleep = sleep;
+function printJson(value) {
+    console.log(JSON.stringify(value, null, 2));
+}
+async function sleep(ms) {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+}