Python Scripts

pip install requests
export AGENTVERSE_API_KEY=your_key_here

#!/usr/bin/env python3
"""
Launch a token on agent-launch.ai

Usage:
    python launch.py --name "MyCoin" --ticker "MC"

Requires:
    pip install requests
    export AGENTVERSE_API_KEY=your_key
"""

import argparse
import os
import requests

API_URL = "https://agent-launch.ai/api/agents"

def launch_token(name: str, symbol: str, description: str = None, category_id: int = 5):
    api_key = os.getenv("AGENTVERSE_API_KEY")
    if not api_key:
        raise ValueError("Set AGENTVERSE_API_KEY environment variable")

    response = requests.post(
        f"{API_URL}/tokenize",
        headers={
            "X-API-Key": api_key,
            "Content-Type": "application/json",
        },
        json={
            "name": name,
            "symbol": symbol,
            "description": description or f"Token for {name}",
            "category": {"id": category_id},
            "logo": "https://picsum.photos/400",
            "chainId": 97,  # BSC Testnet (use 56 for mainnet)
        },
    )

    if response.status_code in (200, 201):
        data = response.json()
        if data.get("success"):
            token_id = data["data"]["id"]
            print(f"Token created: {name} ({symbol})")
            print(f"Token ID: {token_id}")
            print(f"Handoff link: https://agent-launch.ai/deploy/{token_id}")
            return data["data"]
        else:
            raise Exception(data.get("message", "Unknown error"))
    else:
        raise Exception(f"HTTP {response.status_code}: {response.text}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="Launch a token")
    parser.add_argument("--name", required=True, help="Token name")
    parser.add_argument("--ticker", required=True, help="Token symbol")
    parser.add_argument("--description", help="Token description")
    parser.add_argument("--category", type=int, default=5, help="Category ID (default: 5 = AI/ML)")
    args = parser.parse_args()

    launch_token(args.name, args.ticker, args.description, args.category)

#!/usr/bin/env python3
"""
List tokens on agent-launch.ai

Usage:
    python list_tokens.py
    python list_tokens.py --search "trading"
    python list_tokens.py --category 5
"""

import argparse
import requests

API_URL = "https://agent-launch.ai/api"

def list_tokens(page: int = 1, limit: int = 20, search: str = None, category_id: int = None):
    params = {"page": page, "limit": limit}
    if search:
        params["search"] = search
    if category_id:
        params["categoryId"] = category_id

    response = requests.get(f"{API_URL}/tokens", params=params)

    if response.status_code == 200:
        data = response.json()
        tokens = data.get("data", [])
        meta = data.get("meta", {})

        print(f"Page {meta.get('page', 1)} of {meta.get('totalPages', 1)} ({meta.get('total', 0)} total)")
        print("-" * 60)

        for token in tokens:
            print(f"{token['name']} ({token['symbol']})")
            print(f"  Address: {token.get('address', 'pending')}")
            print(f"  Price: {token.get('price', 0):.8f} FET")
            print(f"  Progress: {token.get('progress', 0)}%")
            print()

        return tokens
    else:
        raise Exception(f"HTTP {response.status_code}: {response.text}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description="List tokens")
    parser.add_argument("--page", type=int, default=1, help="Page number")
    parser.add_argument("--limit", type=int, default=20, help="Items per page")
    parser.add_argument("--search", help="Search query")
    parser.add_argument("--category", type=int, help="Category ID")
    args = parser.parse_args()

    list_tokens(args.page, args.limit, args.search, args.category)

#!/usr/bin/env python3
"""
Deploy Token Launcher agent to Agentverse

Usage:
    python deploy_agent.py YOUR_API_KEY

Get API key at: https://agentverse.ai/profile/api-keys
"""

import json
import sys
import time
import requests

API = "https://agentverse.ai/v1"

AGENT_CODE = '''
from datetime import datetime
from uuid import uuid4
import requests
from uagents import Agent, Context, Protocol
from uagents_core.contrib.protocols.chat import (
    ChatAcknowledgement, ChatMessage, EndSessionContent,
    TextContent, chat_protocol_spec,
)

agent = Agent()
chat_proto = Protocol(spec=chat_protocol_spec)

@chat_proto.on_message(ChatMessage)
async def handle_chat(ctx: Context, sender: str, msg: ChatMessage):
    await ctx.send(sender, ChatAcknowledgement(
        timestamp=datetime.now(),
        acknowledged_msg_id=msg.msg_id,
    ))

    text = " ".join(item.text for item in msg.content
                    if isinstance(item, TextContent)).strip()

    api_key = ctx.storage.get("AGENTVERSE_API_KEY")
    result = requests.post(
        "https://agent-launch.ai/api/agents/tokenize",
        headers={"X-API-Key": api_key},
        json={"name": "MyCoin", "symbol": "MC", "description": "Token",
              "category": {"id": 5}, "chainId": 97}
    ).json()

    token_id = result.get("data", {}).get("id", "?")
    await ctx.send(sender, ChatMessage(
        timestamp=datetime.now(), msg_id=uuid4(),
        content=[
            TextContent(type="text", text=f"Deploy: https://agent-launch.ai/deploy/{token_id}"),
            EndSessionContent(type="end-session"),
        ],
    ))

@chat_proto.on_message(ChatAcknowledgement)
async def handle_ack(ctx, sender, msg):
    pass

agent.include(chat_proto, publish_manifest=True)
'''

def deploy(api_key: str, name: str = "AgentLaunch Token Creator"):
    headers = {"Authorization": f"bearer {api_key}", "Content-Type": "application/json"}

    # Create
    print(f"Creating agent '{name}'...")
    res = requests.post(f"{API}/hosting/agents", headers=headers, json={"name": name})
    agent_addr = res.json()["address"]
    print(f"  Created: {agent_addr}")

    # Upload code (double-encoded!)
    print("Uploading code...")
    code_array = [{"language": "python", "name": "agent.py", "value": AGENT_CODE}]
    requests.put(f"{API}/hosting/agents/{agent_addr}/code", headers=headers,
                 json={"code": json.dumps(code_array)})

    # Set secret
    print("Setting secret...")
    requests.post(f"{API}/hosting/secrets", headers=headers,
                  json={"address": agent_addr, "name": "AGENTVERSE_API_KEY", "secret": api_key})

    # Start
    print("Starting agent...")
    requests.post(f"{API}/hosting/agents/{agent_addr}/start", headers=headers)

    # Wait for compilation
    print("Waiting for compilation...")
    for i in range(12):
        time.sleep(5)
        status = requests.get(f"{API}/hosting/agents/{agent_addr}", headers=headers).json()
        if status.get("compiled"):
            print("\nAgent deployed successfully!")
            print(f"Address: {agent_addr}")
            print(f"Test: 'Launch token called MyCoin ticker MC'")
            return agent_addr
        print(f"  Waiting... ({(i+1)*5}s)")

    print("\nCompilation timeout - check Agentverse UI")
    return None

if __name__ == "__main__":
    if len(sys.argv) < 2:
        print(__doc__)
        sys.exit(1)
    deploy(sys.argv[1])