molly-cli 0.1.0

package/dist/commands/address.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerAddress(program: Command): void;

package/dist/commands/address.js

@@ -0,0 +1,24 @@
+import { createAccount } from "genlayer-js";
+import { resolveConfig } from "../lib/config-manager.js";
+import { output, outputError } from "../lib/output.js";
+import { EXIT_AUTH_ERROR } from "../lib/errors.js";
+export function registerAddress(program) {
+    program
+        .command("address")
+        .description("Print wallet address")
+        .action((_opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey });
+            if (!config.privateKey) {
+                outputError("No wallet configured. Run 'molly init' first or set PRIVATE_KEY env var.", EXIT_AUTH_ERROR, pretty);
+            }
+            const account = createAccount(config.privateKey);
+            output({ address: account.address }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_AUTH_ERROR, pretty);
+        }
+    });
+}

package/dist/commands/campaign.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerCampaign(program: Command): void;

package/dist/commands/campaign.js

@@ -0,0 +1,253 @@
+import { resolveConfig } from "../lib/config-manager.js";
+import { buildClient, buildReadClient } from "../lib/client.js";
+import { writeAndWait, readContract } from "../lib/tx.js";
+import { output, outputError } from "../lib/output.js";
+import { EXIT_TX_ERROR, EXIT_NETWORK_ERROR, EXIT_INPUT_ERROR } from "../lib/errors.js";
+function getAddress(cmd) {
+    const globals = cmd.optsWithGlobals();
+    const address = globals.address;
+    if (!address) {
+        outputError("Campaign address is required. Use: molly campaign --address <addr> <command>", EXIT_INPUT_ERROR, globals.pretty);
+    }
+    return address;
+}
+export function registerCampaign(program) {
+    const campaign = program
+        .command("campaign")
+        .description("Interact with a deployed campaign")
+        .requiredOption("--address <addr>", "Campaign contract address");
+    // ── Read commands ──────────────────────────────────────────────────
+    campaign
+        .command("metadata")
+        .description("Get campaign metadata")
+        .action(async (_opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const data = await readContract(client, address, "get_campaign_metadata", []);
+            output({ ok: true, data }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("info")
+        .description("Get full campaign info including submissions")
+        .action(async (_opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const data = await readContract(client, address, "get_campaign_info", []);
+            output({ ok: true, data }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("scoreboard")
+        .description("Get scores per period")
+        .action(async (_opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const data = await readContract(client, address, "get_scoreboard", []);
+            output({ ok: true, data }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("submissions <mission-id>")
+        .description("List submissions for a mission")
+        .action(async (missionId, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const data = await readContract(client, address, "get_submissions", [missionId]);
+            output({ ok: true, data }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("distribution <period>")
+        .description("Get period distribution")
+        .action(async (period, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const data = await readContract(client, address, "get_period_distribution", [parseInt(period, 10)]);
+            output({ ok: true, data }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    // ── Write commands ─────────────────────────────────────────────────
+    campaign
+        .command("submit <mission-id> <post-url>")
+        .description("Submit a post to a campaign mission")
+        .option("--referrer <code>", "Referrer code", "")
+        .action(async (missionId, postUrl, opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "submit_post", [missionId, postUrl, opts.referrer || ""], { timeout: globals.timeout });
+            output({ ok: true, hash, missionId, postUrl }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("resubmit <mission-id> <post-url>")
+        .description("Resubmit a post for re-evaluation")
+        .action(async (missionId, postUrl, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "resubmit_post", [missionId, postUrl], { timeout: globals.timeout });
+            output({ ok: true, hash, missionId, postUrl }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("retry <mission-id> <post-url>")
+        .description("Retry a failed submission")
+        .action(async (missionId, postUrl, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "retry_submission", [missionId, postUrl], { timeout: globals.timeout });
+            output({ ok: true, hash, missionId, postUrl }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("bridge-distribution <period>")
+        .description("Bridge a period distribution to EVM")
+        .action(async (period, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "bridge_period_distribution", [parseInt(period, 10)], { timeout: globals.timeout });
+            output({ ok: true, hash, period: parseInt(period, 10) }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("challenge <post-id>")
+        .description("Challenge a deleted post")
+        .action(async (postId, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "challenge_deleted_post", [postId], { timeout: globals.timeout });
+            output({ ok: true, hash, postId }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("disqualify <post-id>")
+        .description("Disqualify a submission (creator only)")
+        .action(async (postId, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "disqualify_submission", [postId], { timeout: globals.timeout });
+            output({ ok: true, hash, postId }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("update-targeting")
+        .description("Update campaign targeting (creator only)")
+        .option("--whitelisted <addrs...>", "Whitelisted submitter addresses")
+        .option("--verified-only <bool>", "Require verified users")
+        .option("--min-followers <n>", "Minimum followers", parseInt)
+        .option("--max-followers <n>", "Maximum followers", parseInt)
+        .action(async (opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const args = [
+                opts.whitelisted || null,
+                opts.verifiedOnly !== undefined ? opts.verifiedOnly === "true" : null,
+                opts.minFollowers ?? null,
+                opts.maxFollowers ?? null,
+            ];
+            const { hash } = await writeAndWait(client, address, "update_campaign_targeting", args, { timeout: globals.timeout });
+            output({ ok: true, hash }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    campaign
+        .command("update-duration <periods>")
+        .description("Update campaign duration in periods (creator only)")
+        .action(async (periods, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        const address = getAddress(cmd);
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, address, "update_campaign_duration_periods", [parseInt(periods, 10)], { timeout: globals.timeout });
+            output({ ok: true, hash, periods: parseInt(periods, 10) }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerConfig(program: Command): void;

package/dist/commands/config.js

@@ -0,0 +1,36 @@
+import { updateConfig, getConfigPath, resolveConfig } from "../lib/config-manager.js";
+import { output, outputError } from "../lib/output.js";
+import { EXIT_INPUT_ERROR } from "../lib/errors.js";
+export function registerConfig(program) {
+    const configCmd = program
+        .command("config")
+        .description("Show or update configuration");
+    configCmd
+        .command("show", { isDefault: true })
+        .description("Show current resolved configuration")
+        .action((_opts, cmd) => {
+        const pretty = cmd.optsWithGlobals().pretty;
+        const resolved = resolveConfig({});
+        // Mask private key for display
+        const display = {
+            ...resolved,
+            privateKey: resolved.privateKey
+                ? resolved.privateKey.slice(0, 6) + "..." + resolved.privateKey.slice(-4)
+                : "(not set)",
+            configPath: getConfigPath(),
+        };
+        output(display, pretty);
+    });
+    configCmd
+        .command("set <key> <value>")
+        .description("Update a config value (network, factoryAddress, identityAddress, privateKey)")
+        .action((key, value, _opts, cmd) => {
+        const pretty = cmd.optsWithGlobals().pretty;
+        const validKeys = ["network", "factoryAddress", "identityAddress", "privateKey"];
+        if (!validKeys.includes(key)) {
+            outputError(`Invalid config key: ${key}. Valid keys: ${validKeys.join(", ")}`, EXIT_INPUT_ERROR, pretty);
+        }
+        updateConfig(key, value);
+        output({ ok: true, key, value: key === "privateKey" ? "***" : value }, pretty);
+    });
+}

package/dist/commands/factory.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerFactory(program: Command): void;

package/dist/commands/factory.js

@@ -0,0 +1,273 @@
+import { resolveConfig } from "../lib/config-manager.js";
+import { buildClient, buildReadClient } from "../lib/client.js";
+import { writeAndWait, readContract } from "../lib/tx.js";
+import { output, outputError } from "../lib/output.js";
+import { EXIT_TX_ERROR, EXIT_NETWORK_ERROR, EXIT_INPUT_ERROR } from "../lib/errors.js";
+// Default campaign parameter values (from scripts/create-campaign.ts:50-76)
+const CAMPAIGN_DEFAULTS = {
+    knowledge_base: "",
+    rules: "1. Posts must be original content\n2. No spam or duplicate submissions\n3. Content must be relevant to the campaign goal",
+    style: "",
+    campaign_duration_periods: 4,
+    period_length_days: 7,
+    missions: {
+        main: {
+            title: "Main Mission",
+            description: "Create engaging social media content that promotes the campaign goal",
+            rules: "Posts must be original and relevant to the campaign theme",
+            active: true,
+        },
+    },
+    distribution_contract_chain_id: 0,
+    distribution_contract_address: "0x0000000000000000000000000000000000000000",
+    only_verified_users: false,
+    minimum_followers: 0,
+    maximum_followers: 0,
+    whitelisted_submitters: [],
+    alpha: 50,
+    beta: 50,
+    gate_weights: [1, 1, 1],
+    metric_weights: [1, 1, 1, 1],
+    allow_old_posts: true,
+    max_submissions_per_participant: 0,
+    target_chain_rpc_url: "",
+    disqualification_enabled: false,
+    num_shards: 3,
+};
+function generateId(title) {
+    const slug = title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/(^-|-$)/g, "");
+    const timestamp = Date.now().toString(36);
+    return `${slug}-${timestamp}`;
+}
+function getStartTime() {
+    const now = new Date();
+    now.setHours(now.getHours() + 1);
+    now.setMinutes(0, 0, 0);
+    return now.toISOString();
+}
+export function registerFactory(program) {
+    const factory = program
+        .command("factory")
+        .description("Manage campaigns via CampaignFactory");
+    factory
+        .command("create")
+        .description("Create a new campaign")
+        .option("--params-json <json>", "Full campaign params as JSON")
+        .option("--id <id>", "Campaign ID")
+        .option("--title <title>", "Campaign title")
+        .option("--goal <goal>", "Campaign goal")
+        .option("--knowledge-base <text>", "Knowledge base")
+        .option("--rules <text>", "Campaign rules")
+        .option("--style <text>", "Campaign style")
+        .option("--start <iso>", "Start datetime ISO")
+        .option("--duration-periods <n>", "Number of periods", parseInt)
+        .option("--period-days <n>", "Days per period", parseInt)
+        .option("--missions-json <json>", "Missions as JSON object")
+        .option("--dist-chain-id <n>", "Distribution contract chain ID", parseInt)
+        .option("--dist-address <addr>", "Distribution contract address")
+        .option("--verified-only", "Require verified users")
+        .option("--min-followers <n>", "Minimum followers", parseInt)
+        .option("--max-followers <n>", "Maximum followers", parseInt)
+        .option("--whitelisted <addrs...>", "Whitelisted submitter addresses")
+        .option("--alpha <n>", "Alpha parameter", parseInt)
+        .option("--beta <n>", "Beta parameter", parseInt)
+        .option("--gate-weights <weights...>", "Gate weights (space-separated)")
+        .option("--metric-weights <weights...>", "Metric weights (space-separated)")
+        .option("--no-old-posts", "Disallow old posts")
+        .option("--max-submissions <n>", "Max submissions per participant", parseInt)
+        .option("--target-rpc <url>", "Target chain RPC URL")
+        .option("--enable-disqualification", "Enable disqualification")
+        .option("--num-shards <n>", "Number of shards", parseInt)
+        .action(async (opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            let params;
+            if (opts.paramsJson) {
+                try {
+                    params = JSON.parse(opts.paramsJson);
+                }
+                catch {
+                    outputError("Invalid --params-json", EXIT_INPUT_ERROR, pretty);
+                    return; // unreachable but helps TS
+                }
+            }
+            else {
+                if (!opts.title || !opts.goal) {
+                    outputError("--title and --goal are required (or use --params-json)", EXIT_INPUT_ERROR, pretty);
+                }
+                params = {};
+                if (opts.title)
+                    params.title = opts.title;
+                if (opts.goal)
+                    params.goal = opts.goal;
+                if (opts.id)
+                    params.id = opts.id;
+                if (opts.knowledgeBase)
+                    params.knowledge_base = opts.knowledgeBase;
+                if (opts.rules)
+                    params.rules = opts.rules;
+                if (opts.style)
+                    params.style = opts.style;
+                if (opts.start)
+                    params.start_datetime_iso = opts.start;
+                if (opts.durationPeriods)
+                    params.campaign_duration_periods = opts.durationPeriods;
+                if (opts.periodDays)
+                    params.period_length_days = opts.periodDays;
+                if (opts.missionsJson) {
+                    try {
+                        params.missions = JSON.parse(opts.missionsJson);
+                    }
+                    catch {
+                        outputError("Invalid --missions-json", EXIT_INPUT_ERROR, pretty);
+                    }
+                }
+                if (opts.distChainId)
+                    params.distribution_contract_chain_id = opts.distChainId;
+                if (opts.distAddress)
+                    params.distribution_contract_address = opts.distAddress;
+                if (opts.verifiedOnly)
+                    params.only_verified_users = true;
+                if (opts.minFollowers)
+                    params.minimum_followers = opts.minFollowers;
+                if (opts.maxFollowers)
+                    params.maximum_followers = opts.maxFollowers;
+                if (opts.whitelisted)
+                    params.whitelisted_submitters = opts.whitelisted;
+                if (opts.alpha)
+                    params.alpha = opts.alpha;
+                if (opts.beta)
+                    params.beta = opts.beta;
+                if (opts.gateWeights)
+                    params.gate_weights = opts.gateWeights.map(Number);
+                if (opts.metricWeights)
+                    params.metric_weights = opts.metricWeights.map(Number);
+                if (opts.oldPosts === false)
+                    params.allow_old_posts = false;
+                if (opts.maxSubmissions)
+                    params.max_submissions_per_participant = opts.maxSubmissions;
+                if (opts.targetRpc)
+                    params.target_chain_rpc_url = opts.targetRpc;
+                if (opts.enableDisqualification)
+                    params.disqualification_enabled = true;
+                if (opts.numShards)
+                    params.num_shards = opts.numShards;
+            }
+            // Merge with defaults
+            const p = params;
+            const campaign = {
+                id: p.id || generateId(p.title),
+                title: p.title,
+                goal: p.goal,
+                knowledge_base: p.knowledge_base ?? CAMPAIGN_DEFAULTS.knowledge_base,
+                rules: p.rules ?? CAMPAIGN_DEFAULTS.rules,
+                style: p.style ?? CAMPAIGN_DEFAULTS.style,
+                start_datetime_iso: p.start_datetime_iso ?? getStartTime(),
+                campaign_duration_periods: p.campaign_duration_periods ?? CAMPAIGN_DEFAULTS.campaign_duration_periods,
+                period_length_days: p.period_length_days ?? CAMPAIGN_DEFAULTS.period_length_days,
+                missions: p.missions ?? CAMPAIGN_DEFAULTS.missions,
+                distribution_contract_chain_id: p.distribution_contract_chain_id ?? CAMPAIGN_DEFAULTS.distribution_contract_chain_id,
+                distribution_contract_address: p.distribution_contract_address ?? CAMPAIGN_DEFAULTS.distribution_contract_address,
+                only_verified_users: p.only_verified_users ?? CAMPAIGN_DEFAULTS.only_verified_users,
+                minimum_followers: p.minimum_followers ?? CAMPAIGN_DEFAULTS.minimum_followers,
+                maximum_followers: p.maximum_followers ?? CAMPAIGN_DEFAULTS.maximum_followers,
+                whitelisted_submitters: p.whitelisted_submitters ?? CAMPAIGN_DEFAULTS.whitelisted_submitters,
+                alpha: p.alpha ?? CAMPAIGN_DEFAULTS.alpha,
+                beta: p.beta ?? CAMPAIGN_DEFAULTS.beta,
+                gate_weights: p.gate_weights ?? CAMPAIGN_DEFAULTS.gate_weights,
+                metric_weights: p.metric_weights ?? CAMPAIGN_DEFAULTS.metric_weights,
+                allow_old_posts: p.allow_old_posts ?? CAMPAIGN_DEFAULTS.allow_old_posts,
+                max_submissions_per_participant: p.max_submissions_per_participant ?? CAMPAIGN_DEFAULTS.max_submissions_per_participant,
+                target_chain_rpc_url: p.target_chain_rpc_url ?? CAMPAIGN_DEFAULTS.target_chain_rpc_url,
+                disqualification_enabled: p.disqualification_enabled ?? CAMPAIGN_DEFAULTS.disqualification_enabled,
+                num_shards: p.num_shards ?? CAMPAIGN_DEFAULTS.num_shards,
+            };
+            const { client } = buildClient(config);
+            // create_campaign args match CampaignFactory.__init__.py:73-99
+            const { hash } = await writeAndWait(client, config.factoryAddress, "create_campaign", [
+                campaign.id,
+                campaign.title,
+                campaign.goal,
+                campaign.knowledge_base,
+                campaign.rules,
+                campaign.style,
+                campaign.start_datetime_iso,
+                campaign.campaign_duration_periods,
+                campaign.period_length_days,
+                campaign.missions,
+                campaign.distribution_contract_chain_id,
+                campaign.distribution_contract_address,
+                campaign.only_verified_users,
+                campaign.minimum_followers,
+                campaign.maximum_followers,
+                campaign.whitelisted_submitters,
+                campaign.alpha,
+                campaign.beta,
+                campaign.gate_weights,
+                campaign.metric_weights,
+                campaign.allow_old_posts,
+                campaign.max_submissions_per_participant,
+                campaign.target_chain_rpc_url,
+                campaign.disqualification_enabled,
+                campaign.num_shards,
+            ], { timeout: globals.timeout });
+            output({ ok: true, hash, campaignId: campaign.id }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    factory
+        .command("get <campaign-id>")
+        .description("Get campaign address by ID")
+        .action(async (campaignId, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const address = await readContract(client, config.factoryAddress, "get_contract_by_id", [campaignId]);
+            output({ ok: true, campaignId, address }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    factory
+        .command("list-all")
+        .description("List all campaigns (IDs and addresses)")
+        .action(async (_opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const campaigns = await readContract(client, config.factoryAddress, "get_all_campaigns", []);
+            output({ ok: true, campaigns }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    factory
+        .command("list <ids...>")
+        .description("Get multiple campaign addresses by IDs")
+        .action(async (ids, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const addresses = await readContract(client, config.factoryAddress, "get_contracts_by_ids", [ids]);
+            output({ ok: true, ids, addresses }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+}

package/dist/commands/identity.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerIdentity(program: Command): void;

package/dist/commands/identity.js

@@ -0,0 +1,114 @@
+import { resolveConfig } from "../lib/config-manager.js";
+import { buildClient, buildReadClient } from "../lib/client.js";
+import { writeAndWait, readContract } from "../lib/tx.js";
+import { output, outputError } from "../lib/output.js";
+import { EXIT_TX_ERROR, EXIT_NETWORK_ERROR } from "../lib/errors.js";
+export function registerIdentity(program) {
+    const identity = program
+        .command("identity")
+        .description("Manage MoltBook identity");
+    identity
+        .command("link-start <username>")
+        .description("Initiate address link — returns a verification token")
+        .action(async (username, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client, account } = buildClient(config);
+            const { hash } = await writeAndWait(client, config.identityAddress, "initiate_address_link", [username], { timeout: globals.timeout });
+            // Read the token back
+            const tokenInfo = await readContract(client, config.identityAddress, "get_token", [account.address]);
+            output({ ok: true, hash, address: account.address, token: tokenInfo }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    identity
+        .command("link-complete <username>")
+        .description("Complete address link (token must be in your MoltBook profile)")
+        .action(async (username, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, config.identityAddress, "complete_address_link", [username], { timeout: globals.timeout });
+            output({ ok: true, hash }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+    identity
+        .command("get-wallet <username>")
+        .description("Look up wallet address by MoltBook username")
+        .action(async (username, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const wallet = await readContract(client, config.identityAddress, "get_wallet", [username]);
+            output({ ok: true, username, wallet }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    identity
+        .command("get-username <address>")
+        .description("Look up MoltBook username by wallet address")
+        .action(async (address, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ network: globals.network });
+            const { client } = buildReadClient(config);
+            const username = await readContract(client, config.identityAddress, "get_username", [address]);
+            output({ ok: true, address, username }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    identity
+        .command("get-token [address]")
+        .description("Check pending verification token for an address")
+        .action(async (address, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            let targetAddress = address;
+            if (!targetAddress) {
+                // Need a wallet to derive own address
+                const { account } = buildClient(config);
+                targetAddress = account.address;
+            }
+            const { client } = buildReadClient(config);
+            const token = await readContract(client, config.identityAddress, "get_token", [targetAddress]);
+            output({ ok: true, address: targetAddress, token }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_NETWORK_ERROR, pretty);
+        }
+    });
+    identity
+        .command("bridge <username> <chain-id>")
+        .description("Bridge identity to an EVM chain")
+        .action(async (username, chainId, _opts, cmd) => {
+        const globals = cmd.optsWithGlobals();
+        const pretty = globals.pretty;
+        try {
+            const config = resolveConfig({ privateKey: globals.privateKey, network: globals.network });
+            const { client } = buildClient(config);
+            const { hash } = await writeAndWait(client, config.identityAddress, "bridge_user_to_chain", [username, parseInt(chainId, 10)], { timeout: globals.timeout });
+            output({ ok: true, hash, username, chainId: parseInt(chainId, 10) }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_TX_ERROR, pretty);
+        }
+    });
+}

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare function registerInit(program: Command): void;

package/dist/commands/init.js

@@ -0,0 +1,37 @@
+import { createAccount } from "genlayer-js";
+import { randomBytes } from "crypto";
+import { readConfig, writeConfig, getConfigPath } from "../lib/config-manager.js";
+import { output, outputError } from "../lib/output.js";
+import { EXIT_AUTH_ERROR } from "../lib/errors.js";
+export function registerInit(program) {
+    program
+        .command("init")
+        .description("Generate a new wallet and save config")
+        .action(async (_opts, cmd) => {
+        const pretty = cmd.optsWithGlobals().pretty;
+        try {
+            const existing = readConfig();
+            if (existing.privateKey) {
+                const account = createAccount(existing.privateKey);
+                output({
+                    ok: true,
+                    message: "Wallet already exists",
+                    address: account.address,
+                    configPath: getConfigPath(),
+                }, pretty);
+                return;
+            }
+            const privateKey = `0x${randomBytes(32).toString("hex")}`;
+            const account = createAccount(privateKey);
+            writeConfig({ ...existing, privateKey });
+            output({
+                ok: true,
+                address: account.address,
+                configPath: getConfigPath(),
+            }, pretty);
+        }
+        catch (err) {
+            outputError(err, EXIT_AUTH_ERROR, pretty);
+        }
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerInit } from "./commands/init.js";
+import { registerConfig } from "./commands/config.js";
+import { registerAddress } from "./commands/address.js";
+import { registerIdentity } from "./commands/identity.js";
+import { registerFactory } from "./commands/factory.js";
+import { registerCampaign } from "./commands/campaign.js";
+const program = new Command();
+program
+    .name("molly")
+    .description("CLI for AI bots to interact with GenLayer via Moltrally")
+    .version("0.1.0")
+    .option("--network <url>", "GenLayer RPC URL")
+    .option("--private-key <key>", "Private key (overrides config)")
+    .option("--pretty", "Pretty-print JSON output")
+    .option("--timeout <ms>", "Transaction timeout in milliseconds", parseInt);
+registerInit(program);
+registerConfig(program);
+registerAddress(program);
+registerIdentity(program);
+registerFactory(program);
+registerCampaign(program);
+program.parseAsync(process.argv);

package/dist/lib/client.d.ts

@@ -0,0 +1,18 @@
+import { createAccount } from "genlayer-js";
+import type { GenLayerClient, GenLayerChain } from "genlayer-js/types";
+import type { ResolvedConfig } from "./types.js";
+/**
+ * Build a read-only client (no account needed).
+ * Use this for readContract calls that don't require a wallet.
+ */
+export declare function buildReadClient(config: ResolvedConfig): {
+    client: GenLayerClient<GenLayerChain>;
+};
+/**
+ * Build a full client with account for write operations.
+ * Throws a clear error if no private key is configured.
+ */
+export declare function buildClient(config: ResolvedConfig): {
+    client: GenLayerClient<GenLayerChain>;
+    account: ReturnType<typeof createAccount>;
+};

package/dist/lib/client.js

@@ -0,0 +1,60 @@
+import { createAccount, createClient } from "genlayer-js";
+import { localnet, studionet } from "genlayer-js/chains";
+/**
+ * Select the base chain config based on the network URL.
+ * localnet (127.0.0.1 / localhost) uses chain ID 61127.
+ * studionet (studio.genlayer.com) uses chain ID 61999.
+ */
+function resolveBaseChain(networkUrl) {
+    try {
+        const url = new URL(networkUrl);
+        if (url.hostname === "127.0.0.1" || url.hostname === "localhost") {
+            return localnet;
+        }
+    }
+    catch {
+        // fall through to default
+    }
+    return studionet;
+}
+/**
+ * Build a read-only client (no account needed).
+ * Use this for readContract calls that don't require a wallet.
+ */
+export function buildReadClient(config) {
+    const baseChain = resolveBaseChain(config.network);
+    const chain = {
+        ...baseChain,
+        rpcUrls: {
+            default: { http: [config.network] },
+        },
+    };
+    const client = createClient({
+        chain,
+        endpoint: config.network,
+    });
+    return { client };
+}
+/**
+ * Build a full client with account for write operations.
+ * Throws a clear error if no private key is configured.
+ */
+export function buildClient(config) {
+    if (!config.privateKey) {
+        throw new Error("No wallet configured. Run 'molly init' or set PRIVATE_KEY env var.");
+    }
+    const account = createAccount(config.privateKey);
+    const baseChain = resolveBaseChain(config.network);
+    const chain = {
+        ...baseChain,
+        rpcUrls: {
+            default: { http: [config.network] },
+        },
+    };
+    const client = createClient({
+        chain,
+        account,
+        endpoint: config.network,
+    });
+    return { client, account };
+}

package/dist/lib/config-manager.d.ts

@@ -0,0 +1,12 @@
+import type { MollyConfig, ResolvedConfig } from "./types.js";
+export declare function getConfigPath(): string;
+export declare function readConfig(): MollyConfig;
+export declare function writeConfig(config: MollyConfig): void;
+export declare function updateConfig(key: string, value: string): void;
+/**
+ * Resolution order: CLI flag > env var > config file > default
+ */
+export declare function resolveConfig(overrides: {
+    privateKey?: string;
+    network?: string;
+}): ResolvedConfig;

package/dist/lib/config-manager.js

@@ -0,0 +1,55 @@
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import path from "path";
+import os from "os";
+import { studionet } from "genlayer-js/chains";
+import { DEFAULT_FACTORY_ADDRESS, DEFAULT_IDENTITY_ADDRESS, } from "./contracts.js";
+const CONFIG_DIR = path.join(os.homedir(), ".molly");
+const CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+/** Default network URL from the studionet chain config */
+const DEFAULT_NETWORK = studionet.rpcUrls.default.http[0];
+export function getConfigPath() {
+    return CONFIG_PATH;
+}
+export function readConfig() {
+    if (!existsSync(CONFIG_PATH)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+export function writeConfig(config) {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true });
+    }
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 });
+}
+export function updateConfig(key, value) {
+    const config = readConfig();
+    config[key] = value;
+    writeConfig(config);
+}
+/**
+ * Resolution order: CLI flag > env var > config file > default
+ */
+export function resolveConfig(overrides) {
+    const file = readConfig();
+    const privateKey = overrides.privateKey ||
+        process.env.PRIVATE_KEY ||
+        file.privateKey ||
+        "";
+    const network = overrides.network ||
+        process.env.MOLLY_NETWORK ||
+        file.network ||
+        DEFAULT_NETWORK;
+    const factoryAddress = process.env.MOLLY_FACTORY_ADDRESS ||
+        file.factoryAddress ||
+        DEFAULT_FACTORY_ADDRESS;
+    const identityAddress = process.env.MOLLY_IDENTITY_ADDRESS ||
+        file.identityAddress ||
+        DEFAULT_IDENTITY_ADDRESS;
+    return { privateKey, network, factoryAddress, identityAddress };
+}

package/dist/lib/contracts.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Default contract addresses for studionet (studio.genlayer.com).
+ * Override via ~/.molly/config.json or CLI flags.
+ */
+export declare const DEFAULT_FACTORY_ADDRESS = "0x0000000000000000000000000000000000000000";
+export declare const DEFAULT_IDENTITY_ADDRESS = "0x0000000000000000000000000000000000000000";

package/dist/lib/contracts.js

@@ -0,0 +1,6 @@
+/**
+ * Default contract addresses for studionet (studio.genlayer.com).
+ * Override via ~/.molly/config.json or CLI flags.
+ */
+export const DEFAULT_FACTORY_ADDRESS = "0x0000000000000000000000000000000000000000";
+export const DEFAULT_IDENTITY_ADDRESS = "0x0000000000000000000000000000000000000000";

package/dist/lib/errors.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Exit codes:
+ *   0 = success
+ *   1 = transaction / contract error
+ *   2 = auth / wallet error
+ *   3 = network error
+ *   4 = invalid input
+ */
+export declare const EXIT_SUCCESS = 0;
+export declare const EXIT_TX_ERROR = 1;
+export declare const EXIT_AUTH_ERROR = 2;
+export declare const EXIT_NETWORK_ERROR = 3;
+export declare const EXIT_INPUT_ERROR = 4;

package/dist/lib/errors.js

@@ -0,0 +1,13 @@
+/**
+ * Exit codes:
+ *   0 = success
+ *   1 = transaction / contract error
+ *   2 = auth / wallet error
+ *   3 = network error
+ *   4 = invalid input
+ */
+export const EXIT_SUCCESS = 0;
+export const EXIT_TX_ERROR = 1;
+export const EXIT_AUTH_ERROR = 2;
+export const EXIT_NETWORK_ERROR = 3;
+export const EXIT_INPUT_ERROR = 4;

package/dist/lib/output.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Structured output for bot consumption.
+ * All data goes to stdout as JSON. Errors go to stderr as JSON.
+ */
+export declare function output(data: unknown, pretty?: boolean): void;
+export declare function outputError(error: unknown, exitCode: number, pretty?: boolean): never;

package/dist/lib/output.js

@@ -0,0 +1,69 @@
+/**
+ * Structured output for bot consumption.
+ * All data goes to stdout as JSON. Errors go to stderr as JSON.
+ */
+export function output(data, pretty) {
+    if (pretty) {
+        console.log(JSON.stringify(data, replacer, 2));
+    }
+    else {
+        console.log(JSON.stringify(data, replacer));
+    }
+}
+export function outputError(error, exitCode, pretty) {
+    const payload = { ok: false };
+    if (error instanceof Error) {
+        payload.error = error.message;
+    }
+    else if (typeof error === "string") {
+        payload.error = error;
+    }
+    else {
+        payload.error = String(error);
+    }
+    if (pretty) {
+        process.stderr.write(JSON.stringify(payload, null, 2) + "\n");
+    }
+    else {
+        process.stderr.write(JSON.stringify(payload) + "\n");
+    }
+    process.exit(exitCode);
+}
+/**
+ * Detect CalldataAddress byte objects: { bytes: { 0: n, 1: n, ... } }
+ * and convert to hex string "0x..."
+ */
+function isCalldataAddress(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const obj = value;
+    if (!("bytes" in obj) || typeof obj.bytes !== "object" || obj.bytes === null)
+        return false;
+    const bytes = obj.bytes;
+    return "0" in bytes && typeof bytes["0"] === "number";
+}
+function bytesObjectToHex(bytes) {
+    const keys = Object.keys(bytes).map(Number).sort((a, b) => a - b);
+    const hex = keys.map((k) => bytes[String(k)].toString(16).padStart(2, "0")).join("");
+    return "0x" + hex;
+}
+/**
+ * JSON replacer that converts Map instances to plain objects,
+ * BigInt to string, and CalldataAddress byte objects to hex strings.
+ */
+function replacer(_key, value) {
+    if (value instanceof Map) {
+        const obj = {};
+        for (const [k, v] of value) {
+            obj[String(k)] = v;
+        }
+        return obj;
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    if (isCalldataAddress(value)) {
+        return bytesObjectToHex(value.bytes);
+    }
+    return value;
+}

package/dist/lib/tx.d.ts

@@ -0,0 +1,16 @@
+import type { GenLayerClient, GenLayerChain, GenLayerTransaction, CalldataEncodable } from "genlayer-js/types";
+/**
+ * Write to a contract and wait for the tx to be accepted.
+ * Pattern from scripts/create-campaign.ts:175-215
+ */
+export declare function writeAndWait(client: GenLayerClient<GenLayerChain>, address: string, functionName: string, args: CalldataEncodable[], opts?: {
+    leaderOnly?: boolean;
+    timeout?: number;
+}): Promise<{
+    hash: string;
+    receipt: GenLayerTransaction;
+}>;
+/**
+ * Read from a contract (view call).
+ */
+export declare function readContract(client: GenLayerClient<GenLayerChain>, address: string, functionName: string, args: CalldataEncodable[]): Promise<CalldataEncodable>;

package/dist/lib/tx.js

@@ -0,0 +1,29 @@
+/**
+ * Write to a contract and wait for the tx to be accepted.
+ * Pattern from scripts/create-campaign.ts:175-215
+ */
+export async function writeAndWait(client, address, functionName, args, opts) {
+    const hash = await client.writeContract({
+        address: address,
+        functionName,
+        args,
+        value: 0n,
+        leaderOnly: opts?.leaderOnly ?? true,
+    });
+    const receipt = await client.waitForTransactionReceipt({
+        hash,
+        status: "ACCEPTED",
+        retries: opts?.timeout ? Math.ceil(opts.timeout / 2000) : 60,
+    });
+    return { hash, receipt };
+}
+/**
+ * Read from a contract (view call).
+ */
+export async function readContract(client, address, functionName, args) {
+    return client.readContract({
+        address: address,
+        functionName,
+        args,
+    });
+}

package/dist/lib/types.d.ts

@@ -0,0 +1,15 @@
+export interface MollyConfig {
+    privateKey?: string;
+    network?: string;
+    factoryAddress?: string;
+    identityAddress?: string;
+}
+export interface ResolvedConfig {
+    privateKey: string;
+    network: string;
+    factoryAddress: string;
+    identityAddress: string;
+}
+export interface OutputOptions {
+    pretty?: boolean;
+}

package/dist/lib/types.js

@@ -0,0 +1 @@
+export {};

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "molly-cli",
+  "version": "0.1.0",
+  "description": "CLI for AI bots to interact with the GenLayer blockchain via Moltrally",
+  "type": "module",
+  "bin": {
+    "molly": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx src/index.ts",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/genlayerlabs/moltrally.git",
+    "directory": "cli"
+  },
+  "homepage": "https://github.com/genlayerlabs/moltrally/tree/main/cli",
+  "bugs": {
+    "url": "https://github.com/genlayerlabs/moltrally/issues"
+  },
+  "author": "GenLayer Labs",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "commander": "^13.1.0",
+    "genlayer-js": "^0.18.9"
+  },
+  "devDependencies": {
+    "@types/node": "^22.10.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "genlayer",
+    "moltrally",
+    "moltbook",
+    "cli",
+    "ai",
+    "bot"
+  ],
+  "license": "MIT"
+}