@wiimdy/openfunderse-agents 0.1.1

package/.env.example

@@ -0,0 +1,51 @@
+# Relayer client (default credentials)
+RELAYER_URL=http://127.0.0.1:3100
+BOT_ID=bot-participant-1
+BOT_API_KEY=replace_me
+BOT_ADDRESS=0x0000000000000000000000000000000000000001
+
+# Optional participant-scoped credentials (if omitted, BOT_* is used)
+PARTICIPANT_BOT_ID=bot-participant-1
+PARTICIPANT_BOT_API_KEY=replace_me
+PARTICIPANT_BOT_ADDRESS=0x0000000000000000000000000000000000000001
+
+# Signing
+CHAIN_ID=10143
+BOT_PRIVATE_KEY=0xYOUR_PRIVATE_KEY
+# Optional dedicated participant signer key (fallbacks to BOT_PRIVATE_KEY)
+# PARTICIPANT_PRIVATE_KEY=0xYOUR_PARTICIPANT_PRIVATE_KEY
+CLAIM_ATTESTATION_VERIFIER_ADDRESS=0x0000000000000000000000000000000000000101
+CLAIM_BOOK_ADDRESS=0x0000000000000000000000000000000000000101
+INTENT_BOOK_ADDRESS=0x0000000000000000000000000000000000000102
+
+# Participant source safety
+PARTICIPANT_ALLOWED_SOURCE_HOSTS=www.reddit.com,api.coingecko.com
+PARTICIPANT_MAX_RESPONSE_BYTES=524288
+# PARTICIPANT_ALLOW_HTTP_SOURCE=true
+
+# NadFun strategy quote
+RPC_URL=http://127.0.0.1:8545
+CLAW_FUND_FACTORY_ADDRESS=0x0000000000000000000000000000000000000000
+NADFUN_LENS_ADDRESS=0xB056d79CA5257589692699a46623F901a3BB76f1
+NADFUN_BONDING_CURVE_ROUTER=0x865054F0F6A288adaAc30261731361EA7E908003
+NADFUN_DEX_ROUTER=0x5D4a4f430cA3B1b2dB86B9cFE48a5316800F5fb2
+NADFUN_WMON_ADDRESS=0x5a4E0bFDeF88C9032CB4d24338C5EB3d3870BfDd
+NADFUN_EXECUTION_ADAPTER_ADDRESS=0x0000000000000000000000000000000000000000
+VAULT_ADDRESS=0x0000000000000000000000000000000000000000
+CLAW_CORE_ADDRESS=0x0000000000000000000000000000000000000000
+
+# Strategy AA (Monad testnet, public bundler)
+STRATEGY_AA_RPC_URL=https://testnet-rpc.monad.xyz
+STRATEGY_AA_BUNDLER_URL=https://public.pimlico.io/v2/10143/rpc
+# v06 for public Pimlico-style bundlers, v07 for packed UserOp bundlers
+STRATEGY_AA_USER_OP_VERSION=v06
+STRATEGY_AA_ENTRYPOINT_ADDRESS=0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789
+STRATEGY_AA_ACCOUNT_ADDRESS=0x0000000000000000000000000000000000000000
+STRATEGY_AA_OWNER_PRIVATE_KEY=0xYOUR_STRATEGY_AA_OWNER_PRIVATE_KEY
+STRATEGY_CREATE_MIN_AA_BALANCE_WEI=10000000000000000
+# Optional tuning overrides:
+# STRATEGY_AA_CALL_GAS_LIMIT=400000
+# STRATEGY_AA_VERIFICATION_GAS_LIMIT=300000
+# STRATEGY_AA_PRE_VERIFICATION_GAS=2000000
+# STRATEGY_AA_MAX_PRIORITY_FEE_PER_GAS=
+# STRATEGY_AA_MAX_FEE_PER_GAS=

package/README.md

@@ -0,0 +1,252 @@
+# agents
+
+Runtime entry for participant/strategy MoltBots.
+
+ER2 quickstart:
+- runbook: `packages/agents/ER2_RUNBOOK.md`
+- env template: `packages/agents/.env.er2.example`
+
+Unified entrypoint:
+
+```bash
+npm run clawbot:run -w @claw/agents -- \
+  --role strategy \
+  --action propose_intent \
+  --fund-id demo-fund \
+  --intent-file /tmp/intent.json \
+  --execution-route-file /tmp/route.json
+```
+
+One-command smoke:
+```bash
+npm run bot:smoke:e2e -w @claw/agents
+```
+
+## Role
+- Monorepo bot runtime package (execution code), not installer/distribution.
+- Owns crawl/verify/propose runtime flows used by local smoke/E2E paths.
+
+Shared protocol utilities:
+- `@claw/protocol-sdk` from `packages/sdk`
+
+Run:
+
+```bash
+npm run dev -w @claw/agents
+```
+
+## Reddit MVP: Data Mining + Verification
+
+MVP baseline source is Reddit (no API key required):
+- participant mines keyword stats from `r/<subreddit>/new.json`
+- participant re-crawls the mined post ids via `by_id` and checks deterministic match
+
+Commands:
+
+```bash
+# 1) mine claim + save evidence/claim bundle
+npm run crawl:reddit -w @claw/agents -- \
+  --subreddit CryptoCurrency \
+  --keywords monad,airdrop \
+  --limit 25
+
+# 2) verify an existing claim bundle
+npm run verify:reddit -w @claw/agents -- \
+  --claim /absolute/path/to/*.claim.json
+
+# 3) one-shot mvp flow (crawl -> verify)
+npm run flow:reddit -w @claw/agents -- \
+  --subreddit CryptoCurrency \
+  --keywords monad,airdrop \
+  --limit 25
+```
+
+Generated files are stored in:
+- `packages/agents/data/claims/*.claim.json`
+- `packages/agents/data/claims/*.evidence.json`
+- `packages/agents/data/claims/*.verification.json`
+
+Optional env:
+- `CRAWLER_ADDRESS=0x...`
+- `REDDIT_USER_AGENT=openclaw-mvp-crawler/0.1`
+
+## Wave A runtime env (relayer client + signer)
+
+Relayer client:
+- `RELAYER_URL`
+- `BOT_ID`
+- `BOT_API_KEY`
+- `BOT_ADDRESS` (required for claim submit/attest; must match registered participant bot address)
+
+Signer:
+- `BOT_PRIVATE_KEY` or `VERIFIER_PRIVATE_KEY`
+- `CHAIN_ID`
+- `CLAIM_ATTESTATION_VERIFIER_ADDRESS` (preferred)
+- `CLAIM_BOOK_ADDRESS` (fallback for claim attest domain)
+- `INTENT_BOOK_ADDRESS` (required only for intent attestation signing)
+
+Participant source safety:
+- `PARTICIPANT_ALLOWED_SOURCE_HOSTS=www.reddit.com,api.coingecko.com`
+- `PARTICIPANT_MAX_RESPONSE_BYTES=524288`
+- `PARTICIPANT_ALLOW_HTTP_SOURCE=true` (local dev only)
+
+Participant optional scoped env:
+- `PARTICIPANT_BOT_ID`, `PARTICIPANT_BOT_API_KEY`, `PARTICIPANT_BOT_ADDRESS`
+- if omitted, participant flow uses `BOT_ID`, `BOT_API_KEY`, `BOT_ADDRESS`
+
+Strategy AA env:
+- `STRATEGY_AA_BUNDLER_URL`
+- `STRATEGY_AA_USER_OP_VERSION` (`v06` or `v07`)
+- `STRATEGY_AA_ENTRYPOINT_ADDRESS`
+- `STRATEGY_AA_ACCOUNT_ADDRESS`
+- `STRATEGY_AA_OWNER_PRIVATE_KEY` (or `STRATEGY_PRIVATE_KEY`)
+- `CLAW_FUND_FACTORY_ADDRESS`
+- `INTENT_BOOK_ADDRESS`, `CLAW_CORE_ADDRESS`
+- `NADFUN_EXECUTION_ADAPTER_ADDRESS` (fallback: `ADAPTER_ADDRESS`)
+- optional preflight: `STRATEGY_CREATE_MIN_AA_BALANCE_WEI`
+- optional tuning: `STRATEGY_AA_CALL_GAS_LIMIT`, `STRATEGY_AA_VERIFICATION_GAS_LIMIT`, `STRATEGY_AA_PRE_VERIFICATION_GAS`, `STRATEGY_AA_MAX_PRIORITY_FEE_PER_GAS`, `STRATEGY_AA_MAX_FEE_PER_GAS`
+
+Monad testnet reference values:
+- public bundler: `https://public.pimlico.io/v2/10143/rpc`
+- `v06` + EntryPoint `0x5FF137D4b0FDCD49DcA30c7CF57E578a026d2789`
+- `v07` + EntryPoint `0x0000000071727De22E5E9d8BAf0edAc6f37da032` (when your bundler supports packed UserOp)
+
+## Participant commands
+
+```bash
+# 1) Mine a claim from source URL
+npm run participant:mine -w @claw/agents -- \
+  --fund-id demo-fund \
+  --epoch-id 1 \
+  --source-ref https://www.reddit.com/r/CryptoCurrency/new.json?limit=10&raw_json=1 \
+  --token-address 0x0000000000000000000000000000000000000001 \
+  --out-file /tmp/participant-mine.json
+
+# 2) Verify mined claim
+npm run participant:verify -w @claw/agents -- \
+  --claim-file /tmp/participant-mine.json \
+  --max-data-age-seconds 300
+
+# 3) Submit mined claim to relayer
+npm run participant:submit -w @claw/agents -- \
+  --claim-file /tmp/participant-mine.json
+
+# 4) Attest submitted claim
+npm run participant:attest -w @claw/agents -- \
+  --fund-id demo-fund \
+  --epoch-id 1 \
+  --claim-hash 0x...
+
+# 5) One-shot e2e (mine -> verify -> submit -> attest)
+npm run participant:e2e -w @claw/agents -- \
+  --fund-id demo-fund \
+  --epoch-id 1 \
+  --source-ref https://www.reddit.com/r/CryptoCurrency/new.json?limit=10&raw_json=1 \
+  --token-address 0x0000000000000000000000000000000000000001 \
+  --report-file /tmp/participant-e2e-report.json
+```
+
+## Strategy commands (AA)
+
+```bash
+# 0) Create fund directly onchain via Factory (dry-run only)
+npm run strategy:create:fund -w @claw/agents -- \
+  --fund-id demo-fund-001 \
+  --fund-name "Demo Fund 001" \
+  --deploy-config-file /absolute/path/to/deploy-config.json
+
+# 0-a) Set default strategy AA address in agents .env
+npm run strategy:set:aa -w @claw/agents -- \
+  --address 0xYourStrategySmartAccount
+
+# 0-1) Submit createFund onchain + sync deployment metadata to relayer
+npm run strategy:create:fund -w @claw/agents -- \
+  --fund-id demo-fund-001 \
+  --fund-name "Demo Fund 001" \
+  --deploy-config-file /absolute/path/to/deploy-config.json \
+  --telegram-room-id -1001234567890 \
+  --submit
+
+# 1) READY_FOR_ONCHAIN intent attestation submit (IntentBook.attestIntent via UserOp)
+npm run strategy:attest:onchain -w @claw/agents -- \
+  --fund-id demo-fund \
+  --intent-hash 0x...
+
+# 2) READY execution jobs submit (ClawCore.executeIntent via UserOp)
+npm run strategy:execute:ready -w @claw/agents -- \
+  --fund-id demo-fund \
+  --limit 10
+
+# 3) Dry-run intent execution against core
+npm run strategy:dry-run:intent -w @claw/agents -- \
+  --intent-hash 0x... \
+  --intent-file /tmp/intent.json \
+  --execution-route-file /tmp/route.json
+```
+
+## Strategy skill auto submit (recommended)
+
+Programmatic skill path can now run proposal + submission in one call:
+
+1. build strategy decision (`proposeIntent`)
+2. submit canonical intent to relayer (`POST /intents/propose`)
+3. send onchain `IntentBook.proposeIntent` via strategy AA
+
+```ts
+import { proposeIntentAndSubmit } from '@claw/agents';
+
+const out = await proposeIntentAndSubmit({
+  taskType: 'propose_intent',
+  fundId: 'demo-fund',
+  roomId: '-1001234567890',
+  epochId: 12,
+  snapshot: {
+    snapshotHash: '0x...',
+    finalized: true,
+    claimCount: 6
+  },
+  marketState: {
+    network: 10143,
+    nadfunCurveState: {},
+    liquidity: {},
+    volatility: {}
+  },
+  riskPolicy: {
+    maxNotional: '1000000000000000000',
+    maxSlippageBps: 500,
+    allowlistTokens: ['0x...'],
+    allowlistVenues: ['nadfun']
+  }
+});
+```
+
+Implemented modules:
+- `/Users/wiimdy/agent/packages/agents/src/lib/relayer-client.ts`
+- `/Users/wiimdy/agent/packages/agents/src/lib/signer.ts`
+
+## Install-pack canonical source
+Target onboarding UX:
+
+```bash
+npx @wiimdy/openfunderse@latest install openfunderse
+```
+
+Canonical pack files are maintained at:
+- `packages/openfunderse/packs/openfunderse/config/setup-manifest.json`
+- `packages/openfunderse/packs/openfunderse/skills/clawbot-core/SKILL.md`
+- `packages/openfunderse/packs/openfunderse/prompts/core/system.md`
+- `packages/openfunderse/packs/openfunderse/skills/strategy/SKILL.md`
+- `packages/openfunderse/packs/openfunderse/skills/participant/SKILL.md`
+- `packages/openfunderse/packs/openfunderse/skills/relayer/SKILL.md`
+- `packages/openfunderse/packs/openfunderse/prompts/strategy/system.md`
+- `packages/openfunderse/packs/openfunderse/prompts/participant/system.md`
+- `packages/openfunderse/packs/openfunderse/prompts/relayer/system.md`
+
+`packages/agents` keeps runtime code only (`src/*`, `dist/*`).
+
+Prompt references from docs:
+- `docs/jupyter-notebook/openclaw-agent-prompt-book.ipynb`
+- `docs/prompts/kr/base_system.md`
+- `docs/prompts/kr/participant_moltbot.md`
+- `docs/prompts/kr/strategy_moltbot.md`
+- `docs/prompts/kr/relayer_next_server.md`

package/dist/clawbot-cli.d.ts

@@ -0,0 +1 @@
+export declare const runClawbotCli: (argv: string[]) => Promise<boolean>;

package/dist/clawbot-cli.js

@@ -0,0 +1,114 @@
+import { runParticipantCli } from './participant-cli.js';
+import { runStrategyCli } from './strategy-cli.js';
+const parseCli = (argv) => {
+    const [command, ...rest] = argv;
+    const options = new Map();
+    const flags = new Set();
+    for (let i = 0; i < rest.length; i += 1) {
+        const token = rest[i];
+        if (!token.startsWith('--'))
+            continue;
+        const key = token.slice(2);
+        if (key.includes('=')) {
+            const [left, ...right] = key.split('=');
+            options.set(left, right.join('='));
+            continue;
+        }
+        const next = rest[i + 1];
+        if (next && !next.startsWith('--')) {
+            options.set(key, next);
+            i += 1;
+            continue;
+        }
+        flags.add(key);
+    }
+    return { command, options, flags };
+};
+const stripOption = (args, key) => {
+    const result = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const token = args[i];
+        if (token === `--${key}`) {
+            const next = args[i + 1];
+            if (next && !next.startsWith('--')) {
+                i += 1;
+            }
+            continue;
+        }
+        if (token.startsWith(`--${key}=`)) {
+            continue;
+        }
+        result.push(token);
+    }
+    return result;
+};
+const mapCommand = (role, action) => {
+    if (role === 'strategy') {
+        if (action === 'create_fund_onchain')
+            return 'strategy-create-fund';
+        if (action === 'propose_intent')
+            return 'strategy-propose';
+        if (action === 'dry_run_intent_execution')
+            return 'strategy-dry-run-intent';
+        if (action === 'attest_intent_onchain')
+            return 'strategy-attest-onchain';
+        if (action === 'execute_intent_onchain')
+            return 'strategy-execute-ready';
+        if (action === 'set_aa')
+            return 'strategy-set-aa';
+    }
+    if (role === 'participant') {
+        if (action === 'mine_claim')
+            return 'participant-mine';
+        if (action === 'verify_claim')
+            return 'participant-verify';
+        if (action === 'verify_claim_or_intent_validity')
+            return 'participant-verify';
+        if (action === 'submit_claim')
+            return 'participant-submit';
+        if (action === 'submit_mined_claim')
+            return 'participant-submit';
+        if (action === 'attest_claim')
+            return 'participant-attest';
+        if (action === 'participant_e2e')
+            return 'participant-e2e';
+    }
+    throw new Error(`unsupported clawbot action: role=${role}, action=${action}`);
+};
+const printUsage = () => {
+    console.log(`
+[agents] clawbot-run
+
+clawbot-run --role <strategy|participant> --action <action> [action options...]
+
+Examples:
+  clawbot-run --role strategy --action propose_intent --fund-id demo-fund --intent-file ./intent.json --execution-route-file ./route.json
+  clawbot-run --role participant --action mine_claim --fund-id demo-fund --epoch-id 1 --source-ref https://example.com --token-address 0x...
+`);
+};
+export const runClawbotCli = async (argv) => {
+    const parsed = parseCli(argv);
+    const command = parsed.command ?? '';
+    if (command !== 'clawbot-run') {
+        return false;
+    }
+    if (parsed.flags.has('help')) {
+        printUsage();
+        return true;
+    }
+    const role = (parsed.options.get('role') ?? '').trim().toLowerCase();
+    const action = (parsed.options.get('action') ?? '').trim().toLowerCase();
+    if (!role)
+        throw new Error('missing required option --role');
+    if (!action)
+        throw new Error('missing required option --action');
+    const mapped = mapCommand(role, action);
+    const forwarded = stripOption(stripOption(argv.slice(1), 'role'), 'action');
+    const delegatedArgv = [mapped, ...forwarded];
+    if (mapped.startsWith('strategy-')) {
+        await runStrategyCli(delegatedArgv);
+        return true;
+    }
+    await runParticipantCli(delegatedArgv);
+    return true;
+};

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export { createRelayerClient, RelayerClient } from './lib/relayer-client.js';
+export type { ClaimAttestationInput, ClaimQuery, ClaimTemplateInput, IntentAttestationInput, IntentOnchainBundleItem, IntentOnchainBundleResponse, ReadyExecutionPayloadItem, RelayerProposeIntentInput, RelayerClientOptions, RelayerHttpErrorShape, SyncFundDeploymentInput, SseEvent, SseHandlers, SseSubscription } from './lib/relayer-client.js';
+export { createBotSigner, BotSigner } from './lib/signer.js';
+export type { BotSignerOptions, SignedClaimAttestation, SignedIntentAttestation } from './lib/signer.js';
+export { StrategyAaClient } from './lib/aa-client.js';
+export type { ExecuteViaAaInput, StrategyAaClientEnvOverrides, StrategyAaClientConfig, UserOperationResult } from './lib/aa-client.js';
+export { attestClaim, mineClaim, submitMinedClaim, verifyClaim } from './skills/participant/index.js';
+export type { AttestClaimInput, AttestClaimOutput, MineClaimInput, MineClaimOutput, MineClaimObservation, SubmitMinedClaimInput, SubmitMinedClaimOutput, VerifyClaimInput, VerifyClaimOutput } from './skills/participant/index.js';
+export { proposeIntent, proposeIntentAndSubmit } from './skills/strategy/index.js';
+export type { ProposeIntentAndSubmitInput, ProposeIntentAndSubmitOutput, ProposeIntentInput, ProposeIntentOutput, ProposeDecision, HoldDecision, RiskChecks } from './skills/strategy/index.js';

package/dist/index.js

@@ -0,0 +1,34 @@
+import { runRedditMvpCli } from './reddit-mvp.js';
+import { runParticipantCli } from './participant-cli.js';
+import { runStrategyCli } from './strategy-cli.js';
+import { runClawbotCli } from './clawbot-cli.js';
+export { createRelayerClient, RelayerClient } from './lib/relayer-client.js';
+export { createBotSigner, BotSigner } from './lib/signer.js';
+export { StrategyAaClient } from './lib/aa-client.js';
+export { attestClaim, mineClaim, submitMinedClaim, verifyClaim } from './skills/participant/index.js';
+export { proposeIntent, proposeIntentAndSubmit } from './skills/strategy/index.js';
+console.log('[agents] boot');
+console.log(`[agents] strategy key set=${Boolean(process.env.STRATEGY_PRIVATE_KEY)}`);
+console.log(`[agents] participant key set=${Boolean(process.env.PARTICIPANT_PRIVATE_KEY ||
+    process.env.BOT_PRIVATE_KEY ||
+    process.env.VERIFIER_PRIVATE_KEY)}`);
+const main = async () => {
+    const argv = process.argv.slice(2);
+    const handledByClawbot = await runClawbotCli(argv);
+    if (handledByClawbot) {
+        return;
+    }
+    const handledByStrategy = await runStrategyCli(argv);
+    if (handledByStrategy) {
+        return;
+    }
+    const handledByParticipant = await runParticipantCli(argv);
+    if (!handledByParticipant) {
+        await runRedditMvpCli(argv);
+    }
+};
+main().catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    console.error(`[agents] error: ${message}`);
+    process.exitCode = 1;
+});

package/dist/lib/aa-client.d.ts

@@ -0,0 +1,67 @@
+import { type Address, type Hex } from 'viem';
+type UserOpVersion = 'v06' | 'v07';
+export interface StrategyAaClientConfig {
+    chainId: number;
+    rpcUrl: string;
+    bundlerUrl: string;
+    entryPoint: Address;
+    smartAccount: Address;
+    ownerPrivateKey: Hex;
+    initCode?: Hex;
+    callGasLimit?: bigint;
+    verificationGasLimit?: bigint;
+    preVerificationGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    userOpVersion?: UserOpVersion;
+}
+export interface StrategyAaClientEnvOverrides {
+    chainId?: number;
+    rpcUrl?: string;
+    bundlerUrl?: string;
+    entryPoint?: Address;
+    smartAccount?: Address;
+    ownerPrivateKey?: Hex;
+    initCode?: Hex;
+    callGasLimit?: bigint;
+    verificationGasLimit?: bigint;
+    preVerificationGas?: bigint;
+    maxPriorityFeePerGas?: bigint;
+    maxFeePerGas?: bigint;
+    pollIntervalMs?: number;
+    timeoutMs?: number;
+    userOpVersion?: UserOpVersion;
+}
+export interface ExecuteViaAaInput {
+    target: Address;
+    data: Hex;
+    value?: bigint;
+}
+export interface UserOperationResult {
+    userOpHash: Hex;
+    receipt: Record<string, unknown> | null;
+    transactionHash: Hex | null;
+}
+export declare class StrategyAaClient {
+    private readonly config;
+    private readonly publicClient;
+    private readonly owner;
+    constructor(config: StrategyAaClientConfig);
+    static fromEnv(overrides?: StrategyAaClientEnvOverrides): StrategyAaClient;
+    sendExecute(input: ExecuteViaAaInput): Promise<UserOperationResult>;
+    sendUserOperation(callData: Hex): Promise<UserOperationResult>;
+    waitForUserOperationReceipt(userOpHash: Hex): Promise<Record<string, unknown> | null>;
+    private userOpVersion;
+    private submitUserOperation;
+    private resolveGasFees;
+    private parseBigIntLike;
+    private tryResolveBundlerGasFees;
+    private buildSignedUserOperationV07;
+    private buildSignedUserOperationV06;
+    private toRpcUserOperationV07;
+    private toRpcUserOperationV06;
+    private callBundler;
+}
+export {};