{contextHolder}

AIWS

{!isMobile && ( {/* */} { setNetwork(type); // after connection, trigger signature immediately const walletInfo = walletService.getWalletInfo(); if (walletInfo?.address) { const storedAddress = localStorage.getItem("Token_address"); if (!storedAddress || storedAddress !== walletInfo.address) { await handleLogin(walletInfo.address); } } }} /> )}

{!isMobile ? ( { setCurrentPage(page); setPageSize(size); }, }} onChange={handleTableChange} rowClassName={(record) => (record.isTop ? "top-agent-row" : "")} /> ) : (

{tableLoading ? (

) : ( agents.map((agent) => ( )) )}

)} {!isMobile ? (

{ setCurrentMessagePage(page); setMessagePageSize(size); }, }} onChange={handleMessageTableChange} /> ) : (

{tableMessageLoading ? (

) : ( messages.map((message) => ( )) )}

)} setDrawerOpen(false)} open={drawerOpen} width="100%" styles={{ body: { padding: 24, display: "flex", justifyContent: "center", }, }} > {isWalletConnected ? (

) : (

Please connect wallet first

)} ); }; export default AgentList; ================================================ FILE: src/pages/Publish/index.less ================================================ .publish-container { width: 100%; padding: 24px 10%; box-sizing: border-box; .publish-steps { .ant-steps-icon { color: #141414 !important; } } .publish-card { max-width: 800px; margin: 0 auto; .ant-upload-select { width: 128px !important; height: 128px !important; } .ant-form-item-label { font-weight: 500; } } .ant-progress { margin-top: 16px; } .ant-btn-loading { opacity: 0.8; } .sub-label { .ant-form-item-label > label { font-size: 14px !important; } } } #media-form { .ant-form-item-label > label { font-size: 14px !important; } } .media-modal { .ant-modal-title { font-size: 20px !important; } .ant-modal-close { top: 18px !important; } } .ant-form-item { .ant-input-textarea-show-count { &::after { color: rgba(0, 0, 0, 0.45); } } .ant-checkbox-inner:after { border-color: #333; } .config-desc { color: #4f4f4f; font-size: 14px; } .social-media-desc { color: #4f4f4f; font-size: 14px; margin-bottom: 8px; } .social-media-container { display: flex; gap: 10px; align-items: center; justify-content: space-between; .social-media-title { font-size: 12px; font-weight: 500; color: #fff; } .social-media-icon { width: 90px; display: flex; justify-content: center; align-items: center; flex-direction: column; gap: 4px; .connect-button { width: 90px; height: 24px; line-height: 24px; text-align: center; font-size: 12px; border-radius: 6px; color: #f0b90b; background-color: #141414; border: 1px solid rgba(255, 255, 255, 0.2); cursor: pointer; } } } .ant-form-item-label { label { width: 100%; font-size: 16px; &::after { content: ""; margin: 0; } } } .prompt-label { flex: 1; width: 100%; display: flex; justify-content: space-between; align-items: center; .optional-label { margin-left: 8px; color: #999; font-size: 16px; } a { color: #f0b90b; font-size: 14px; &:hover { text-decoration: underline; } } } .ant-checkbox-wrapper { margin-bottom: 4px; } } ================================================ FILE: src/pages/Publish/index.tsx ================================================ /* eslint-disable @typescript-eslint/no-explicit-any */ /** * AI Agent Publication Component * Allows users to create and publish new AI agents */ import React, { useState } from "react"; import { Form, Input, Upload, Button, message, Select, Spin, Steps, Checkbox, CheckboxChangeEvent, Modal, Tooltip, } from "antd"; import { UploadOutlined } from "@ant-design/icons"; import type { RcFile } from "antd/es/upload/interface"; import "./index.less"; import { uploadToIPFS } from "@/services/upload"; import { ENetwork } from "@/services/network"; import { PublishStep, StepData, FormValues } from "@/types"; import { WalletService } from "@/services/wallet"; import x from "@/assets/images/x.png"; import tg from "@/assets/images/tg.png"; import farcaster from "@/assets/images/farcaster.png"; import discord from "@/assets/images/discord.png"; import { useRecoilState } from "recoil"; import { isWalletConnectedState } from "@/store/network"; const { TextArea } = Input; /** * Props interface for Publish component */ interface PublishProps { onSuccess: () => void; } // Define step messages const STEPS = { PREPARING: "Preparing files...", CREATING_AGENT: "Creating Agent...", UPLOADING_FILES: "Uploading files...", CONFIRMING: "Binding Domain...", COMPLETED: "Completed!", }; const enum EDataset { INDEX3 = "Index3", FARCASTER = "Farcaster", WEB3NEWS = "Web3 News", DAILYFEEDS = "Dailyfeeds", COINGECKO = "Coingecko", KNOWLEDGEBASE = "KnowledgeBase", } // add social media type definition interface SocialMediaConfig { [ESocialMedia.TWITTER]?: { apiKey: string; apiSecret: string; accessToken: string; accessTokenSecret: string; userId: string; }; [ESocialMedia.TELEGRAM]?: { botToken: string; chatId: string; }; [ESocialMedia.FARCASER]?: { apiKey: string; username: string; }; [ESocialMedia.DISCORD]?: { webhookUrl: string; botName: string; }; } enum ESocialMedia { TWITTER = "twitter", TELEGRAM = "telegram", FARCASER = "farcaster", DISCORD = "discord", } /** * Publish component for creating new AI agents */ const Publish: React.FC = ({ onSuccess }) => { // Form and state management const [form] = Form.useForm(); const chatConfigValue = Form.useWatch("chatConfig", form); const blogConfigValue = Form.useWatch("blogConfig", form); const [avatarFile, setAvatarFile] = useState(); const [submitting, setSubmitting] = React.useState(false); const [currentStep, setCurrentStep] = useState( PublishStep.CONTRACT ); const [stepMessage, setStepMessage] = useState(""); const [domains, setDomains] = React.useState([]); const [loadingDomains, setLoadingDomains] = React.useState(false); const [imageUrl, setImageUrl] = useState(); const [stepData, setStepData] = useState({ step: PublishStep.CONTRACT, }); const walletService = WalletService.getInstance(); const address = walletService.getWalletInfo()?.address; const [isWalletConnected] = useRecoilState(isWalletConnectedState); const network = walletService.getCurrentNetwork(); const [errorStep, setErrorStep] = useState(null); const isFormDisabled = currentStep !== PublishStep.CONTRACT; // add social media config const [socialMediaConfig, setSocialMediaConfig] = useState( {} ); const [currentMedia, setCurrentMedia] = useState(null); const [mediaModalVisible, setMediaModalVisible] = useState(false); const [mediaForm] = Form.useForm(); // add dataset Form.useWatch const datasetValue = Form.useWatch("dataset", form); /** * Validate and upload avatar before adding to form */ const beforeUpload = (file: RcFile): boolean => { const isJpgOrPng = file.type === "image/jpeg" || file.type === "image/png"; if (!isJpgOrPng) { message.error("You can only upload JPG/PNG files!"); return false; } const isLt1M = file.size / 1024 / 1024 < 1; if (!isLt1M) { message.error("Image must be smaller than 1MB!"); return false; } setAvatarFile(file); getBase64(file, setImageUrl); return false; }; const getErrorMessage = (step: PublishStep) => { switch (step) { case PublishStep.CONTRACT: return "Contract creation failed. Please try this step again."; case PublishStep.IPFS: return "IPFS upload failed. Please try this step again."; case PublishStep.ENS: return "Domain record update failed. Please try this step again."; default: return "An error occurred. Please try again."; } }; // Handle contract step const handleContractStep = async (values: FormValues) => { try { setErrorStep(null); setSubmitting(true); setStepMessage(STEPS.PREPARING); if (!avatarFile) { message.error("Please upload an avatar!"); return; } const data = { name: values.name, avatar: avatarFile, functionDesc: values.functionDesc, behaviorDesc: values.behaviorDesc, did: values.did, dataset: values.dataset, blog_dataset: values.blog_dataset, blogPrompt: values.blogPrompt, hasBlog: values.blogPrompt ? true : false, hasRAG: values.chatConfig, website: values.website, website1: values.website1, website2: values.website2, }; setStepMessage(STEPS.CREATING_AGENT); const { txHash, ipfsInfo, fileList } = await walletService.createRecord( data ); // Save data const newStepData = { step: PublishStep.IPFS, formData: values, fileList, contractData: { txHash, }, ipfsData: { ...ipfsInfo, ipfsUploaded: false, }, }; setStepData(newStepData); // Go to next step updateStep(PublishStep.IPFS, newStepData); } catch (error) { console.error("Contract step failed:", error); message.error("Contract step failed"); setErrorStep(PublishStep.CONTRACT); setSubmitting(false); setStepMessage(""); } }; const handleIpfsStep = async (stepData: StepData) => { try { setErrorStep(null); setSubmitting(true); setStepMessage(STEPS.UPLOADING_FILES); const { formData, contractData, ipfsData } = stepData; if (!formData || !contractData || !ipfsData) { throw new Error("Missing required data"); } if (!avatarFile) { throw new Error("Avatar file not found"); } let chainId = "1"; if (network === ENetwork.Solana) { chainId = "101"; } const socialMediaData = socialMediaConfig[ESocialMedia.TWITTER] ? { twitter_user_id: socialMediaConfig[ESocialMedia.TWITTER].userId || "", twitter_client_secret: socialMediaConfig[ESocialMedia.TWITTER].apiSecret || "", twitter_api_key: socialMediaConfig[ESocialMedia.TWITTER].apiKey || "", twitter_api_secret: socialMediaConfig[ESocialMedia.TWITTER].apiSecret || "", twitter_access_token: socialMediaConfig[ESocialMedia.TWITTER].accessToken || "", twitter_access_secret: socialMediaConfig[ESocialMedia.TWITTER].accessTokenSecret || "", } : undefined; const result = await uploadToIPFS( stepData, chainId, socialMediaData, (percent: any) => { setStepMessage(`Uploading... ${percent}%`); } ); if (!result || !result.contentHash) { throw new Error("Upload failed"); } const newStepData = { ...stepData, ipfsData: { ...ipfsData, contentHash: result.contentHash, ipfsUploaded: true, }, }; setStepData(newStepData); updateStep(PublishStep.ENS, newStepData); } catch (error) { console.error("IPFS step failed:", error); message.error("IPFS upload failed"); setErrorStep(PublishStep.IPFS); setSubmitting(false); setStepMessage(""); } }; const handleEnsStep = async (stepData: StepData) => { try { setErrorStep(null); setSubmitting(true); setStepMessage(STEPS.CONFIRMING); const { formData, ipfsData } = stepData; if (!formData || !ipfsData || !ipfsData.ipfsUploaded) { throw new Error("Missing required data"); } // Set records try { await walletService.setRecord({ did: formData.did, contenthash: ipfsData.contentHash, }); message.success("Records updated successfully"); } catch (error) { console.error("Failed to set records:", error); if (error instanceof Error) { message.error(`Failed to update records: ${error.message}`); } else { message.error("Failed to update records"); } return; } updateStep(PublishStep.COMPLETED); setStepMessage(STEPS.COMPLETED); onSuccess(); message.success("Agent created successfully"); form.resetFields(); setAvatarFile(undefined); setImageUrl(undefined); setStepData({ step: PublishStep.CONTRACT }); setCurrentStep(PublishStep.CONTRACT); } catch (error) { console.error("failed:", error); message.error("Domain update failed"); setErrorStep(PublishStep.ENS); } finally { setSubmitting(false); setStepMessage(""); } }; const onFinish = async (values: FormValues) => { // add social media config to values const formValuesWithSocial = { ...values, socialMediaConfig, }; switch (currentStep) { case PublishStep.CONTRACT: await handleContractStep(formValuesWithSocial); break; case PublishStep.IPFS: await handleIpfsStep(stepData); break; case PublishStep.ENS: await handleEnsStep(stepData); break; default: break; } }; /** * Fetch ENS domains on component mount */ React.useEffect(() => { const fetchENSDomains = async () => { if (!address) return; try { setLoadingDomains(true); const ownedNames = await walletService.getAllOwnedDomains(); if (ownedNames.length > 0) { setDomains(ownedNames); } } catch (error) { console.error("Failed to fetch domains:", error); message.error("Failed to load domains. Please try again later."); } finally { setLoadingDomains(false); } }; fetchENSDomains(); }, [address, walletService]); const handleReset = () => { form.resetFields(); setAvatarFile(undefined); setImageUrl(undefined); setLoadingDomains(false); setStepData({ step: PublishStep.CONTRACT }); setCurrentStep(PublishStep.CONTRACT); setStepMessage(""); }; const uploadButton = (

Upload

); const getBase64 = (img: RcFile, callback: (url: string) => void) => { const reader = new FileReader(); reader.addEventListener("load", () => callback(reader.result as string)); reader.readAsDataURL(img); }; // Execute step logic const executeStep = async (step: PublishStep, stepData: StepData) => { switch (step) { case PublishStep.CONTRACT: await form.validateFields(); await handleContractStep(form.getFieldsValue()); break; case PublishStep.IPFS: await handleIpfsStep(stepData); break; case PublishStep.ENS: await handleEnsStep(stepData); break; default: break; } }; // Update current step const updateStep = (newStep: PublishStep, stepData?: StepData) => { setCurrentStep(newStep); if (newStep !== PublishStep.COMPLETED && stepData) { executeStep(newStep, stepData); } }; const handleChatConfigChange = (e: CheckboxChangeEvent) => { if (e.target.checked) { form.setFieldsValue({ chatConfig: true, dataset: undefined, blog_dataset: undefined, }); } else { form.setFieldsValue({ chatConfig: false, dataset: undefined, blog_dataset: undefined, }); } }; const handleBlogConfigChange = (e: CheckboxChangeEvent) => { if (e.target.checked) { form.setFieldsValue({ blogConfig: true, blogPrompt: undefined, }); } else { form.setFieldsValue({ blogConfig: false, blogPrompt: undefined, blog_dataset: undefined, }); } }; const initialValues = { chatConfig: false, blogConfig: false, dataset: undefined, blogPrompt: undefined, }; // add media icon component const SocialMediaIcon = ({ type, onClick, active, }: { type: ESocialMedia; onClick: () => void; active: boolean; }) => { const getIcon = () => { switch (type) { case ESocialMedia.TWITTER: return ( <> twitter

Twitter

); case ESocialMedia.TELEGRAM: return ( <>

); case ESocialMedia.FARCASER: return ( <>

Farcaster

); case ESocialMedia.DISCORD: return ( <> discord

Discord

); default: return null; } }; const getTooltipTitle = () => { switch (type) { case ESocialMedia.TWITTER: return "Twitter"; case ESocialMedia.TELEGRAM: return "Telegram"; case ESocialMedia.FARCASER: return "Farcaster"; case ESocialMedia.DISCORD: return "Discord"; default: return ""; } }; return (

{getIcon()}

); }; // add media form fields config const getMediaFormFields = (type: string) => { switch (type) { case ESocialMedia.TWITTER: return ( <> ); case ESocialMedia.TELEGRAM: return ( <> ); case ESocialMedia.FARCASER: return ( <> ); case ESocialMedia.DISCORD: return ( <> ); default: return null; } }; // add handle function const handleMediaIconClick = (type: ESocialMedia) => { setCurrentMedia(type); mediaForm.resetFields(); // if has config, fill form if (socialMediaConfig[type]) { mediaForm.setFieldsValue(socialMediaConfig[type]); } setMediaModalVisible(true); }; const handleMediaFormSubmit = () => { mediaForm.validateFields().then((values) => { setSocialMediaConfig((prev) => ({ ...prev, [currentMedia as string]: values, })); setMediaModalVisible(false); message.success(`${currentMedia} configuration saved`); }); }; return (

form={form} layout="vertical" onFinish={onFinish} requiredMark={false} onReset={handleReset} initialValues={initialValues} > {imageUrl ? ( avatar

) : ( uploadButton )}

</Form.Item>

<Form.Item label="Chat Configuration" name="chatConfig">
          <Checkbox onChange={handleChatConfigChange}>Chat with RAG</Checkbox>
          <p className="config-desc">
            Enhance chat responses by retrieving and integrating external data
            from selected datasets.
          </p>
        </Form.Item>

{chatConfigValue && (
          <Form.Item
            className="sub-label"
            label="Dataset"
            name="dataset"
            rules={[
              {
                required: chatConfigValue,
                message: "Please select a dataset!",
              },
            ]}
          >
            <Select placeholder="Please select a dataset">
              <Select.Option value={EDataset.INDEX3}>
                {EDataset.INDEX3} (Mirror, Farcaster, ENS Websites, Web3 News)
              </Select.Option>
              <Select.Option value={EDataset.FARCASTER}>
                {EDataset.FARCASTER}
              </Select.Option>
              <Select.Option value={EDataset.WEB3NEWS}>
                {EDataset.WEB3NEWS}
              </Select.Option>
              <Select.Option value={EDataset.COINGECKO}>
                {EDataset.COINGECKO}
              </Select.Option>
              <Select.Option value={EDataset.KNOWLEDGEBASE}>
                {EDataset.KNOWLEDGEBASE}
              </Select.Option>
            </Select>
          </Form.Item>
        )}

{datasetValue === EDataset.KNOWLEDGEBASE && (
          <div style={{ marginLeft: "24px" }}>
            <Form.Item
              label={null}
              name="website"
              rules={[
                {
                  required: datasetValue === EDataset.KNOWLEDGEBASE,
                  message: "Please enter the website address!",
                },
              ]}
            >
              <Input
                autoComplete="off"
                placeholder="Enter the website address"
              />
            </Form.Item>
            <Form.Item
              label={null}
              name="website1"
              rules={[
                {
                  required: false,
                  message: "Please enter the website address!",
                },
              ]}
            >
              <Input
                autoComplete="off"
                placeholder="Enter the website address"
              />
            </Form.Item>
            <Form.Item
              label={null}
              name="website2"
              rules={[
                {
                  required: false,
                  message: "Please enter the website address!",
                },
              ]}
            >
              <Input
                autoComplete="off"
                placeholder="Enter the website address"
              />
            </Form.Item>
          </div>
        )}

<Form.Item
          label={
            <div className="prompt-label">
              <span style={{ fontSize: "14px" }}>Chat Prompt</span>{" "}
              <a
                target="_blank"
                href="https://ipfs.glitterprotocol.dev/ipfs/QmcY138nyXn9PEf26STTPeWHUBNUwbF43tih7avvJvsedt"
              >
                Prompt Template
              </a>
            </div>
          }
          name="behaviorDesc"
          rules={[
            {
              required: true,
              message: "Please input Chat Prompt!",
            },
          ]}
        >
          <TextArea
            disabled={isFormDisabled}
            placeholder="Define how the Agent should interact with users during chats. Include the tone, knowledge focus, and expected behavior."
            autoSize={{ minRows: 3, maxRows: 6 }}
          />
        </Form.Item>

<Form.Item
          label={
            <>
              <span>Blog Configuration</span>
              <span
                style={{ color: "rgba(255, 255, 255, 0.5)", marginLeft: "2px" }}
                className="optional-label"
              >
                (Optional)
              </span>
            </>
          }
          name="blogConfig"
          rules={[
            {
              required: blogConfigValue,
              message: "Please input Blog Prompt!",
            },
          ]}
        >
          <Checkbox onChange={handleBlogConfigChange}>
            Blog Generation with RAG
          </Checkbox>
          <p className="config-desc">
            Automatically generate blog summarizing key trends and highlights
            from selected datasets.
          </p>
        </Form.Item>

{blogConfigValue && (
          <Form.Item
            className="sub-label"
            label="Blog Dataset"
            name="blog_dataset"
            rules={[
              {
                required: blogConfigValue,
                message: "Please select a dataset!",
              },
            ]}
          >
            <Select placeholder="Please select a dataset">
              <Select.Option value={EDataset.WEB3NEWS}>
                {EDataset.WEB3NEWS}
              </Select.Option>
            </Select>
          </Form.Item>
        )}

<Form.Item
          label={
            <div className="prompt-label">
              <div>
                <span style={{ fontSize: "14px" }}>Blog Prompt</span>
              </div>
              <a
                target="_blank"
                href="https://ipfs.glitterprotocol.dev/ipfs/QmeTrPTkDbEKBchPiQm85SAvbZ5NxEh8GDbW6fvGGnWggP"
              >
                Prompt Template
              </a>
            </div>
          }
          name="blogPrompt"
          rules={[
            {
              required: blogConfigValue,
              message: "Please input Blog Prompt!",
            },
          ]}
        >
          <TextArea
            disabled={isFormDisabled}
            placeholder="Describe how the Agent should generate blog posts. Include the focus topics, writing style and target audience."
            autoSize={{ minRows: 3, maxRows: 6 }}
          />
        </Form.Item>

<Form.Item
          label="DID"
          name="did"
          rules={[{ required: true, message: "Please select a domain!" }]}
        >
          <Select
            disabled={isFormDisabled || !isWalletConnected}
            placeholder={
              address ? "Select your domain" : "Please connect wallet first"
            }
            loading={loadingDomains}
            notFoundContent={
              loadingDomains ? (
                <Spin size="small" />
              ) : !address ? (
                "Please connect wallet first"
              ) : domains.length === 0 ? (
                "No domains found for this address"
              ) : null
            }
            onDropdownVisibleChange={async (open) => {
              if (open && address) {
                try {
                  setLoadingDomains(true);
                  const domains = await walletService.getAllOwnedDomains();
                  if (domains.length > 0) {
                    setDomains(domains);
                  }
                } catch (error) {
                  console.error("Failed to fetch domains:", error);
                  message.error("Failed to load domains");
                } finally {
                  setLoadingDomains(false);
                }
              }
            }}
          >
            {domains.map((domain) => (
              <Select.Option key={domain} value={domain}>
                {domain}
                {network === ENetwork.Solana ? ".sol" : ""}
              </Select.Option>
            ))}
          </Select>
        </Form.Item>

<Form.Item
          label={
            <>
              <span>Connect Your Accounts</span>
              <span
                style={{ color: "rgba(255, 255, 255, 0.5)", marginLeft: "2px" }}
                className="optional-label"
              >
                (Optional)
              </span>
            </>
          }
        >
          <p className="social-media-desc">
            Connect your social media to use Agent on it.
          </p>
          <div className="social-media-container">
            <SocialMediaIcon
              type={ESocialMedia.TWITTER}
              onClick={() => handleMediaIconClick(ESocialMedia.TWITTER)}
              active={!!socialMediaConfig[ESocialMedia.TWITTER]}
            />
          </div>
        </Form.Item>

{errorStep && (
          <div
            style={{
              color: "#ff4d4f",
              marginBottom: 16,
              textAlign: "center",
            }}
          >
            {getErrorMessage(errorStep)}
          </div>
        )}

<Form.Item>
          <Button
            style={{ marginTop: "24px", color: "#141414" }}
            type="primary"
            htmlType="submit"
            block
            loading={submitting}
          >
            {submitting
              ? stepMessage || "Creating..."
              : errorStep
              ? "Retry this step"
              : "Create"}
          </Button>
        </Form.Item>
      </Form>

{/* add social media form modal */}
      <Modal
        centered
        className="media-modal"
        title={
          currentMedia
            ? `Connect ${
                currentMedia.charAt(0).toUpperCase() + currentMedia.slice(1)
              }`
            : ""
        }
        open={mediaModalVisible}
        onCancel={() => setMediaModalVisible(false)}
        footer={[
          <div
            key="buttons"
            style={{
              display: "flex",
              gap: "16px",
              justifyContent: "center",
              width: "100%",
            }}
          >
            <Button key="cancel" onClick={() => setMediaModalVisible(false)}>
              Cancel
            </Button>
            <Button
              style={{ color: "#141414" }}
              key="submit"
              type="primary"
              onClick={handleMediaFormSubmit}
            >
              Confirm
            </Button>
          </div>,
        ]}
      >
        <Form id="media-form" form={mediaForm} layout="vertical">
          {currentMedia && getMediaFormFields(currentMedia)}
        </Form>
      </Modal>
    </div>
  );
};

export default Publish;

================================================
FILE: src/services/ai.ts
================================================
/**
 * AI Service Module
 */

// import { getChatCompletionsStream } from "./api";
import { getChatCompletionsStream, uploadMessage } from "./api";
import { createAvatarCid, createJsonFile } from "./upload";

/**
 * Declare global window.aiData type
 */
declare global {
  interface Window {
    aiData: {
      agentId: string; // AI ID
      name: string; // AI name
      functionDesc: string; // Function description
      behaviorDesc: string; // Behavior description
      model: string; // Model used
      did: string; // Device ID
      id: string; // AI ID
      avatar: string; // Avatar
      apiKey: string; // API key
      testKey: string; // Test key
    };
  }
}

/**
 * Remove quotes from start and end of text
 */
const removeQuotes = (text: string): string => {
  return text.replace(/^["'""]|["'""]$/g, "").trim();
};

interface ICalculateCidData {
  message: string;
  prev_message_cid: string;
  role: 0 | 1;
  agent_id: string;
  ens: string;
  session: string;
}

export const calculateCid = async (
  data: ICalculateCidData
): Promise<string> => {
  const json = {
    message: data.message,
    session: data.session,
    create_time: Date.now(),
    prev_message_cid: data.prev_message_cid,
    role: data.role,
    agent_id: data.agent_id,
    ens: data.ens,
  };
  const jsonFile = await createJsonFile(json);
  const ipfsHashCid = await createAvatarCid(jsonFile);
  return ipfsHashCid[0].cid;
};

/**
 * Send message to AI and get response
 * @param message User's message
 * @returns AI's response content
 */
export const sendMessage = async (
  message: string,
  sessionId: string,
  onSend?: (text: string, messageCid: string) => void,
  onProgress?: (text: string, messageCid: string) => void,
  onFinish?: (text: string, messageCid: string) => void
) => {
  try {
    if (message.length === 0) {
      return;
    }
    const agent_id = window.aiData?.agentId || window.aiData?.id || "l5_pEJ6aAydRl8c0KQsIH";
    const did = window.aiData?.did || "test.agent";

// Get current conversation history
    const history = conversationHistories[currentConversationId] || [];

const message_cid = await calculateCid({
      message: message,
      prev_message_cid: history[history.length - 1]?.messageCid || "",
      role: 0,
      agent_id: agent_id,
      ens: did,
      session: sessionId,
    });
    onSend?.(message, message_cid);

uploadMessage({
      agent_id: String(agent_id),
      ens: did,
      message: message,
      message_cid: message_cid,
      prev_message_cid: history[history.length - 1]?.messageCid || "",
      role: 0,
      session: sessionId,
    });

history.push({ role: "user", content: message, messageCid: message_cid });

let fullResponse = '';
    const tempMessageCid = 'loading_message_cid'; // Temporary messageCid

await getChatCompletionsStream(
      {
        input: {
          agent_id: String(agent_id),
          messages: [{ content: message || "" }],
          thread_id: sessionId,
        },
      },
      {
        onMessage: (content) => {
          fullResponse += content;
          const cleanResponse = removeQuotes(fullResponse);
          
          // Find if message already exists
          const existingMessageIndex = history.findIndex(msg => msg.messageCid === tempMessageCid);
          if (existingMessageIndex !== -1) {
            // Update existing message content
            history[existingMessageIndex].content = cleanResponse;
          } else {
            // Add new message
            history.push({
              role: "assistant",
              content: cleanResponse,
              messageCid: tempMessageCid,
            });
          }
          
          conversationHistories[currentConversationId] = history;
          onProgress?.(fullResponse, tempMessageCid);
        },
        onComplete: async () => {
          const cleanResponse = removeQuotes(fullResponse);
          
          // Calculate real messageCid
          const response_cid = await calculateCid({
            message: cleanResponse,
            prev_message_cid: message_cid,
            role: 1,
            agent_id: agent_id,
            ens: did,
            session: sessionId,
          });

// Replace temporary messageCid
          const messageIndex = history.findIndex(msg => msg.messageCid === tempMessageCid);
          if (messageIndex !== -1) {
            history[messageIndex].messageCid = response_cid;
          }
          
          conversationHistories[currentConversationId] = history;
          onFinish?.(fullResponse, response_cid);

uploadMessage({
            agent_id: String(agent_id),
            ens: did,
            message: cleanResponse,
            message_cid: response_cid,
            prev_message_cid: message_cid,
            role: 1,
            session: sessionId,
          });
        },
        onError: (error) => {
          throw error;
        },
        onTimeout: () => {
          throw new Error("Request timeout");
        }
      }
    );

return fullResponse;
  } catch (error) {
    console.error("Error sending message:", error);
    const errorMessage = "Sorry, an error occurred. Please try again later.";
    const history = conversationHistories[currentConversationId] || [];
    const agent_id = window.aiData?.agentId || window.aiData?.id || "dgl6Ez4ZKOu5GczMN3veC";
    const did = window.aiData?.did || "test.agent";
    const error_cid = await calculateCid({
      message: errorMessage,
      prev_message_cid: history[history.length - 1]?.messageCid || "",
      role: 1,
      agent_id: agent_id,
      ens: did,
      session: sessionId,
    });
    uploadMessage({
      agent_id: String(agent_id),
      ens: did,
      message: errorMessage,
      message_cid: error_cid,
      prev_message_cid: history[history.length - 1]?.messageCid || "",
      role: 1,
      session: sessionId,
    });
    history.push({
      role: "assistant",
      content: errorMessage,
      messageCid: error_cid,
    });
    conversationHistories[currentConversationId] = history;
    throw error;
  }
};

/**
 * Store all conversation histories
 */
const conversationHistories: Record<
  string,
  Array<{
    role: "system" | "user" | "assistant";
    content: string;
    messageCid: string;
  }>
> = {};

/**
 * Current conversation ID
 */
let currentConversationId = "0";

/**
 * Set current active conversation
 * @param conversationId Conversation ID
 */
export const setCurrentConversation = (conversationId: string) => {
  currentConversationId = conversationId;
  // Initialize history if new conversation
  if (!conversationHistories[conversationId]) {
    conversationHistories[conversationId] = [];
    if (window.aiData?.behaviorDesc) {
      conversationHistories[conversationId].push({
        role: "system",
        content: window.aiData.behaviorDesc,
        messageCid: "",
      });
    }
  }
};

/**
 * Clear current conversation history
 */
export const clearHistory = () => {
  conversationHistories[currentConversationId] = [];
};

/**
 * Clear all conversation histories
 */
export const clearAllHistory = () => {
  Object.keys(conversationHistories).forEach((key) => {
    conversationHistories[key] = [];
  });
};

/**
 * Get current conversation history (excluding system messages)
 * @returns Current conversation history array
 */
export const getCurrentHistory = () => {
  const history = conversationHistories[currentConversationId] || [];
  return history.filter((msg) => msg.role !== "system");
};

================================================
FILE: src/services/aiChatFeed.ts
================================================
import axios from 'axios'

const GLITTER_IPFS_API_URL = 'https://airag.glitterprotocol.tech'

interface IBlogListParams {
  page: number
  limit: number
  agent_id: string
}
interface IBlogItem {
  title: string
  content: string
  ens: string
  agent_id: string
  createTime: string
}
interface IBlogListRes {
  data: IBlogItem[]
}

export const getBlogList = async (params: IBlogListParams) => {
  const response = await axios.post<IBlogListRes>(`${GLITTER_IPFS_API_URL}/v1/post/list`, params)
  return response.data
}

================================================
FILE: src/services/api.ts
================================================
import axios from "axios";

interface IMessageProps {
  agent_id: string;
  messages: {
    content: string;
  }[];
  thread_id: string;
}

const API_HOST = import.meta.env.VITE_APP_APIHOST;

export const getChatCompletions = async (data: { input: IMessageProps }) => {
  try {
    const response = await axios.post(
      `${API_HOST}/chat/completions/wait`,
      data,
      {
        timeout: 90000, // 90 seconds timeout
      }
    );
    return response.data;
  } catch (error) {
    if (axios.isAxiosError(error)) {
      if (error.response?.status === 500) {
        throw new Error("Server error. Please try again later.");
      }
      throw new Error("Failed to get chat completions");
    }
    throw error;
  }
};

export const uploadMessage = async (data: {
  agent_id: string;
  ens: string;
  message: string;
  message_cid: string;
  prev_message_cid: string;
  role: 0 | 1;
  session: string;
}) => {
  const response = await axios.post(`${API_HOST}/chat/upload`, data);
  return response.data;
};

export const getMessageList = async (data: { page: number; limit: number }) => {
  const response = await axios.post(`${API_HOST}/chat/list`, data);
  return response.data;
};

export const getChat = async (data: { message_cid: string }) => {
  const response = await axios.post(`${API_HOST}/chat/get`, data);
  return response.data;
};

interface StreamHandler {
  onMessage: (message: string) => void;
  onError?: (error: Error) => void;
  onComplete?: () => void;
  onTimeout?: () => void;
}

export const getChatCompletionsStream = async (
  data: { input: IMessageProps },
  handler: StreamHandler
) => {
  const timeoutController = new AbortController();
  const controller = new AbortController();
  let hasError = false;
  let isCompleted = false;

const timeoutId = setTimeout(() => {
    if (!hasError) {
      hasError = true;
      timeoutController.abort();
      handler.onTimeout?.();
    }
  }, 30000);

timeoutController.signal.addEventListener("abort", () => {
    controller.abort("timeout");
  });

try {
    const response = await fetch(`${API_HOST}/chat/completions/stream`, {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'Accept': 'text/event-stream',
      },
      body: JSON.stringify(data),
      signal: controller.signal
    });

clearTimeout(timeoutId);

if (!response.ok) {
      const text = await response.text();
      throw new Error(text);
    }

const reader = response.body?.getReader();
    if (!reader) {
      throw new Error("Response body is null");
    }

const decoder = new TextDecoder();
    let buffer = '';

try {
      while (true) {
        try {
          const { value, done } = await reader.read();
          if (done) {
            // Normal completion, not an error
            if (!isCompleted) {
              handler.onComplete?.();
            }
            break;
          }

buffer += decoder.decode(value, { stream: true });
          const lines = buffer.split('\n');
          buffer = lines.pop() || '';

for (const line of lines) {
            if (line.trim()) {
              try {
                const data = JSON.parse(line);
                if (data?.messages?.[0]) {
                  const message = data.messages[0];
                  if (message.content) {
                    handler.onMessage(message.content);
                  }
                  if (message?.response_metadata?.finish_reason === "stop") {
                    isCompleted = true;
                    handler.onComplete?.();
                  }
                }
              } catch {
                // Ignore parsing errors
              }
            }
          }
        } catch (readError) {
          // Only throw if not completed
          if (!isCompleted) {
            throw readError;
          }
          break;
        }
      }

// Process remaining buffer
      if (buffer.trim()) {
        try {
          const data = JSON.parse(buffer);
          if (data?.messages?.[0]) {
            const message = data.messages[0];
            if (message.content) {
              handler.onMessage(message.content);
            }
            if (message?.response_metadata?.finish_reason === "stop") {
              isCompleted = true;
              handler.onComplete?.();
            }
          }
        } catch {
          // Ignore parsing errors
        }
      }
    } finally {
      reader.releaseLock();
    }
  } catch (error) {
    clearTimeout(timeoutId);
    // Only trigger error if not completed
    if (!isCompleted) {
      if (error instanceof Error) {
        handler.onError?.(error);
      } else {
        handler.onError?.(new Error('Unknown error occurred'));
      }
    }
  }
};

================================================
FILE: src/services/ens.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
import { ethers } from "ethers";
import { encode } from "@ensdomains/content-hash";
import { createEnsPublicClient } from "@ensdomains/ensjs";
import { mainnet } from "viem/chains";
import { http } from "viem";
import { ENetwork, switchNetworkMetaMask } from "./network";

const ENS_ADDRESS = "0x00000000000c2e074ec69a0dfb2997ba6c7d2e1e";

const ENS_ABI = [
  "function resolver(bytes32 node) external view returns (address)",
  "function owner(bytes32 node) external view returns (address)",
];

const RESOLVER_ABI = [
  "function setText(bytes32 node, string key, string value) public",
  "function text(bytes32 node, string key) public view returns (string)",
  "function setContenthash(bytes32 node, bytes hash) public",
  "function contenthash(bytes32 node) public view returns (bytes)",
];

export const setEnsRecord = async (ensName: string, ipfsHash: string) => {
  try {
    if (!window.ethereum) {
      throw new Error("MetaMask not installed");
    }

const provider = new ethers.providers.Web3Provider(window.ethereum);

// Check and switch network
    const network = await provider.getNetwork();
    if (network.chainId !== ENetwork.Ethereum) {
      await switchNetworkMetaMask(ENetwork.Ethereum);
    }

await provider.send("eth_requestAccounts", []);
    const signer = await provider.getSigner();

const namehash = ethers.utils.namehash(ensName);

// Get ENS contract instance
    const ensContract = new ethers.Contract(ENS_ADDRESS, ENS_ABI, provider);

// Get Resolver address
    const resolverAddress = await ensContract.resolver(namehash);

if (!resolverAddress || resolverAddress === ethers.constants.AddressZero) {
      throw new Error("No resolver found for this ENS name");
    }

// Create Resolver contract instance
    const resolverContract = new ethers.Contract(
      resolverAddress,
      RESOLVER_ABI,
      signer
    );

// Set IPFS contenthash
    const contentHash = "0x" + encode("ipfs", ipfsHash);

const contentTx = await resolverContract.setContenthash(
      namehash,
      contentHash
    );
    const contentReceipt = await contentTx.wait();
    if (!contentReceipt.status) {
      throw new Error("Failed to set content hash");
    }

return true;
  } catch (error) {
    console.error("Error setting ENS record:", error);
    throw error;
  }
};

export const getUserENSDomains = async (address: string): Promise<string[]> => {
  try {
    if (!window.ethereum) {
      console.warn("MetaMask not installed");
      return [];
    }

const provider = new ethers.providers.Web3Provider(window.ethereum);

const network = await provider.getNetwork();
    if (network.chainId !== ENetwork.Ethereum) {
      console.warn("Please switch to Ethereum mainnet");
      return [];
    }

const ensReverseRecordsAddress =
      "0x3671aE578E63FdF66ad4F3E12CC0c0d71Ac7510C";
    const ensReverseRecordsABI = [
      "function getNames(address[] addresses) external view returns (string[] memory)",
    ];

const reverseRecords = new ethers.Contract(
      ensReverseRecordsAddress,
      ensReverseRecordsABI,
      provider
    );

const timeoutPromise = new Promise<string[]>((_, reject) => {
      setTimeout(() => reject(new Error("Request timeout")), 10000);
    });

const namesPromise = reverseRecords.getNames([address]);
    const names = await Promise.race([namesPromise, timeoutPromise]);

return Array.isArray(names)
      ? names.filter((name: string) => name && name !== "")
      : [];
  } catch (error) {
    console.error("Failed to fetch ENS domains:", error);
    return [];
  }
};

const createSharedEnsClient = () =>
  createEnsPublicClient({
    chain: mainnet,
    transport: http(
      "https://eth-mainnet.g.alchemy.com/v2/omJBXWIY1zRbJPFZziPcaWLckUpBER7L"
    ),
    pollingInterval: 1000,
    batch: {
      multicall: {
        batchSize: 100,
        wait: 1000,
      },
    },
  });

export async function getENSSubdomains(
  parentDomain: string
): Promise<string[]> {
  const ens = createSharedEnsClient();

try {
    const subnames = await ens.getSubnames({
      name: parentDomain,
      pageSize: 100,
      orderBy: "createdAt",
    });

return subnames.map((subname) => subname.name || "");
  } catch (error) {
    console.error("Error fetching ENS subdomains:", error);
    return [];
  }
}

export async function getAllOwnedENSDomains(
  address: string
): Promise<string[]> {
  const ens = createSharedEnsClient();
  const allNames: string[] = [];

try {
    const ownedNames = await ens.getNamesForAddress({
      address: address as `0x${string}`,
    });

allNames.push(...ownedNames.map((name) => name.name || ""));

const primaryDomains = await getUserENSDomains(address);

const subdomainPromises = primaryDomains.map((domain) =>
      getENSSubdomains(domain)
    );
    const subdomains = await Promise.all(subdomainPromises);

return [...new Set([...allNames, ...primaryDomains, ...subdomains.flat()])];
  } catch (error) {
    console.error("Error fetching all ENS domains:", error);
    return [];
  }
}

/**
 * Get ENS social accounts for a given ENS name
 * @param ensName ENS name
 * @returns Object containing social accounts
 */
export const getEnsSocialAccounts = async (
  ensName: string
): Promise<{
  twitter: string;
  telegram: string;
  github: string;
  farcaster: string;
}> => {
  try {
    if (!ensName) {
      return {
        twitter: "",
        telegram: "",
        github: "",
        farcaster: "",
      };
    }
    const client = await createSharedEnsClient();

// Get text records for social accounts
    const twitter = await client.getTextRecord({
      name: ensName,
      key: "com.twitter",
    });

const telegram = await client.getTextRecord({
      name: ensName,
      key: "org.telegram",
    });

const github = await client.getTextRecord({
      name: ensName,
      key: "com.github",
    });
    const farcaster = await client.getTextRecord({
      name: ensName,
      key: "xyz.farcaster",
    });

return {
      twitter: twitter || "",
      telegram: telegram || "",
      github: github || "",
      farcaster: farcaster || "",
    };
  } catch (error) {
    console.error("Failed to get ENS social accounts:", error);
    return {
      twitter: "",
      telegram: "",
      github: "",
      farcaster: "",
    };
  }
};

================================================
FILE: src/services/network.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
import chainsMini from "@/const/chains_mini.json";

export interface INetwork {
  label: string;
  value: ENetwork;
  icon?: string;
  price: number;
  unit: string;
  unitName: number;
  contractAddr: string;
}

export const enum ENetwork {
  SepoliaTest = 11155111,
  Ethereum = 1,
  Polygon = 137,
  Optimism = 10,
  BNB = 56,
  Avalanche = 43114,
  Arbitrum = 42161,
  Base = 8453,
  FileCoin = 314,
  Mantle = 5000,
  Scroll = 534352,
  Solana = 101,
}

export const networks: INetwork[] = [
  // {
  //   label: "SepoliaTest",
  //   value: ENetwork.SepoliaTest,
  //   price: 0.01,
  //   unit: "ETH",
  //   unitName: 18,
  //   contractAddr: "0xb028123909eb45be96f3bec9582f67255930577d",
  // },
  {
    label: "Ethereum",
    value: ENetwork.Ethereum,
    price: 0.01,
    unit: "ETH",
    unitName: 18,
    // https://etherscan.io/address/0x29e78bfd54c15c811bdd6560c10215c0ef687966
    contractAddr: "0x071e5993a7fa46ccaa7135ff07e840c7b9c5073c",
  },
  {
    label: "Solana",
    value: ENetwork.Solana,
    price: 0.01,
    unit: "SOL",
    unitName: 9,
    contractAddr: "0x071e5993a7fa46ccaa7135ff07e840c7b9c5073c",
  },
];

export const switchNetworkMetaMask = async (
  chainId: number
): Promise<{
  status: boolean;
  message?: string;
}> => {
  const networkChainId = Number(chainId);
  console.log(networkChainId, "networkChainId");
  if (window.ethereum) {
    try {
      const nowChainId = await window.ethereum.request({
        method: "eth_chainId",
      });
      console.log(nowChainId, "nowChainId");
      console.log(
        networkChainId !== Number(nowChainId),
        "networkChainId !== Number(nowChainId)"
      );
      if (networkChainId !== Number(nowChainId)) {
        const chainId = chainIdNumberToHex(networkChainId);
        console.log(chainId, "chainId");

await window.ethereum.request({
          method: "wallet_switchEthereumChain",
          params: [{ chainId: chainId }],
        });
        return {
          status: true,
        };
      }
      return {
        status: true,
        message: "Network already selected",
      };
    } catch (error: any) {
      console.error("Switching network:", error);
      const errroCode = [4902, -32603];
      // https://docs.metamask.io/wallet/reference/wallet_switchethereumchain/
      // 4902	Unrecognized chain ID. Try adding the chain using wallet_addEthereumChain first.
      // IN MetaMask Application:
      // -32603	Unrecognized chain ID. Try adding the chain using wallet_addEthereumChain first.
      if (error && errroCode.includes(error.code)) {
        const res = await addNetworkMetaMask(networkChainId);
        return {
          status: res,
          message:
            "Unrecognized chain ID. Try adding the chain using wallet_addEthereumChain first.",
        };
      } else {
        let chainInfo: any = null;
        chainsMini.forEach((item) => {
          if (item.chainId === networkChainId) {
            chainInfo = item;
          }
        });
        return {
          status: false,
          message: `Please connect to ${chainInfo?.name}, chainID: ${chainInfo?.chainId}`,
        };
      }
    }
  } else {
    return {
      status: false,
      message: "MetaMask not detected.",
    };
  }
};

export const chainIdNumberToHex = (chainId: number) => {
  return `0x${chainId.toString(16)}`;
};

export const addNetworkMetaMask = async (chainId: number): Promise<boolean> => {
  const networkChainId = Number(chainId);

let chainInfo: any = null;
  chainsMini.forEach((item) => {
    if (item.chainId === networkChainId) {
      chainInfo = item;
    }
  });

try {
    if (chainInfo) {
      const chainId = chainIdNumberToHex(networkChainId);
      const params = {
        chainId,
        chainName: chainInfo.name,
        nativeCurrency: chainInfo.nativeCurrency,
        rpcUrls: chainInfo.rpc,
        blockExplorerUrls:
          chainInfo.faucets && chainInfo.faucets.length > 0
            ? chainInfo.faucets
            : null,
      };
      try {
        await window.ethereum.request({
          method: "wallet_addEthereumChain",
          params: [params],
        });
        return true;
      } catch (error: any) {
        console.warn("Adding network:", error);
        return false;
      }
    }
    return false;
  } catch (error) {
    console.log(
      "🚀 ~ file: metaMask.ts:78 ~ switchNetworkMetaMask ~ error",
      error
    );
    return false;
  }
};

================================================
FILE: src/services/upload.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
import axios, { AxiosError } from "axios";
import { message } from "antd";
import { ethers } from "ethers";
import { UPLOAD_ABI } from "@/abis/uploadAbi";
import { importer, ImportCandidate } from "ipfs-unixfs-importer";
import {
  ENetwork,
  INetwork,
  networks,
  switchNetworkMetaMask,
} from "@/services/network";
import { readFileAsUint8Array } from "@/utils";
import { nanoid } from "nanoid";
import { StepData } from "@/types";

// Glitter IPFS API endpoint
const GLITTER_IPFS_API_URL = "https://ipfs.glitterprotocol.dev/api/v0";
// RPC
const MAINNET_RPC =
  "https://eth-mainnet.g.alchemy.com/v2/R3tcNhC28ASQj99HY5D4JCVrCKGybkIx";

/**
 * Interface for IPFS upload response
 */
interface IUploadRes {
  Hash: string;
  Size: string;
}

/**
 * Interface for AI agent data
 */
export interface IAgentData {
  name: string;
  functionDesc: string;
  behaviorDesc: string;
  did: string;
  dataset: string;
  blogPrompt: string;
  hasBlog: boolean;
  hasRAG: boolean;
  avatar?: string;
  id?: string;
  agentId: string;
  network: string;
}

export interface IFile {
  filename: string;
  contenthash: string;
  filesize: number;
  timestamp: number;
}

export interface IRecord {
  filename: string;
  contenthash: string;
  timestamp: number;
  did: string;
  creator_address: string;
  agent_name: string;
  agent_intro: string;
  avatar: string;
  network: ENetwork;
}

// get Provider
const getProvider = async (needSigner = false) => {
  if (needSigner) {
    if (!window.ethereum) throw new Error("MetaMask not found");
    const provider = new ethers.providers.Web3Provider(window.ethereum);
    const network = await provider.getNetwork();
    if (network.chainId === ENetwork.Ethereum) {
      await switchNetworkMetaMask(ENetwork.Ethereum);
    }
    return provider;
  }

// if (window.ethereum) {
  //   return new ethers.providers.Web3Provider(window.ethereum);
  // }

return new ethers.providers.JsonRpcProvider(MAINNET_RPC);
};

export const getAllSolanaRecords = async (): Promise<{
  total: number;
  records: IRecord[];
}> => {
  try {
    const provider = await getProvider();
    const network = await provider.getNetwork();
    if (Number(network.chainId) !== ENetwork.Solana) {
      const { status } = await switchNetworkMetaMask(ENetwork.Solana);
      if (status) {
        console.log("switch network success");
        return getAllSolanaRecords();
      }
    }
    const contractAddress = networks.find(
      (item: INetwork) => item.value === Number(network.chainId)
    )?.contractAddr;
    if (!contractAddress) throw new Error("Contract address not found");
    const contract = new ethers.Contract(contractAddress, UPLOAD_ABI, provider);
    const count = await contract.getRecordCount();
    if (count === 0) {
      return {
        total: 0,
        records: [],
      };
    }
    const records = await contract.fetchData(0, count);
    const formattedRecords: IRecord[] = records
      .map((record: any) => ({
        did: record.ensName,
        contenthash: record.contenthash,
        timestamp: record.timestamp?.toNumber(),
        creator_address: record.creator_address,
        avatar: record.avatarContentHash,
        agent_name: record.agent_name,
        agent_intro: record.agent_intro,
        optionalField: record.optionalField,
        extension: record.extension,
      }))
      .sort((a: IRecord, b: IRecord) => b.timestamp - a.timestamp);
    return {
      total: count.toNumber(),
      records: formattedRecords,
    };
  } catch (error) {
    console.error("Get records error:", error);
    throw error;
  }
};

export const getAllRecords = async (): Promise<{
  total: number;
  records: IRecord[];
}> => {
  try {
    const provider = await getProvider();
    const network = await provider.getNetwork();
    if (Number(network.chainId) !== ENetwork.Ethereum) {
      const { status } = await switchNetworkMetaMask(ENetwork.Ethereum);
      if (status) {
        console.log("switch network success");
        return getAllRecords();
      }
    }
    const contractAddress = networks.find(
      (item: INetwork) => item.value === Number(network.chainId)
    )?.contractAddr;
    if (!contractAddress) throw new Error("Contract address not found");
    const contract = new ethers.Contract(contractAddress, UPLOAD_ABI, provider);

try {
      const count = await contract.getRecordCount();
      if (count === 0) {
        return {
          total: 0,
          records: [],
        };
      }

// get all records
      const records = await contract.fetchData(0, count);
      console.log(records, "records");
      // format records
      const formattedRecords: IRecord[] = records
        .map((record: any) => ({
          did: record.ensName,
          contenthash: record.contenthash,
          timestamp: record.timestamp?.toNumber(),
          creator_address: record.creator_address,
          avatar: record.avatarContentHash,
          agent_name: record.agent_name,
          agent_intro: record.agent_intro,
          optionalField: record.optionalField,
          extension: record.extension,
          network: ENetwork.Ethereum,
        }))
        .sort((a: IRecord, b: IRecord) => b.timestamp - a.timestamp);
      return {
        total: count.toNumber(),
        records: formattedRecords,
      };
    } catch (error) {
      console.error("Contract call error:", error);
      throw new Error("Failed to fetch records from contract");
    }
  } catch (error) {
    console.error("Get records error:", error);
    message.error(
      error instanceof Error ? error.message : "Failed to get records"
    );
    throw error;
  }
};

export interface ISocialMediaData {
  twitter_user_id: string;
  twitter_api_key: string;
  twitter_api_secret: string;
  twitter_access_token: string;
  twitter_access_secret: string;
}

/**
 * Upload file to Glitter IPFS
 * @param file File or Blob to upload
 * @param onProgress Progress callback
 * @returns Upload response
 */
export const uploadToGlitter = async (
  fileList: File[],
  txId: string,
  chainId: string,
  socialMediaData?: ISocialMediaData,
  onProgress?: (percent: number) => void
): Promise<IUploadRes> => {
  try {
    const formData = new FormData();
    fileList.forEach((file) => {
      formData.append(`files[${file.name}]`, file);
    });

if (socialMediaData) {
      const arr = [1];
      formData.append("social_type", arr.join(","));
      formData.append("twitter_user_id", socialMediaData?.twitter_user_id);
      formData.append("twitter_api_key", socialMediaData?.twitter_api_key);
      formData.append(
        "twitter_api_secret",
        socialMediaData?.twitter_api_secret
      );
      formData.append(
        "twitter_access_token",
        socialMediaData?.twitter_access_token
      );
      formData.append(
        "twitter_access_secret",
        socialMediaData?.twitter_access_secret
      );
    }

const { data } = await axios.post(
      `${GLITTER_IPFS_API_URL}/upagent?tx_id=${txId}&chainid=${chainId}`,
      formData,
      {
        headers: {
          "Content-Type": "multipart/form-data",
        },
        onUploadProgress(progressEvent) {
          const { loaded, total } = progressEvent;
          onProgress?.((loaded / total) * 100);
        },
      }
    );

if (!data.data?.[0]) {
      throw new Error("Upload failed: No response data");
    }

const item = data.data.find((item: any) => !item.Name.includes("/"));
    return {
      Hash: item.Hash,
      Size: item.Size,
    };
  } catch (err) {
    const error = err as Error | AxiosError;
    console.error("Upload error:", error);

if (error.message === "MetaMask not found") {
      message.error("Please install MetaMask first");
    } else if (error.message.includes("Login failed")) {
      message.error("Authentication failed, please try again");
    } else {
      message.error("Upload failed, please try again");
    }

throw error;
  }
};

export const ipfsUnixfsImporterBlock = {
  blocks: new Map(),
  get: async (cid: any) => {
    const bytes = ipfsUnixfsImporterBlock.blocks.get(cid.toString());
    if (!bytes) throw new Error(`block not found: ${cid}`);
    return bytes;
  },
  put: async (bytes: Uint8Array) => {
    const cid = await bytes;
    ipfsUnixfsImporterBlock.blocks.set(cid.toString(), bytes);
    return cid;
  },
};

export const createAvatarCid = async (file: File) => {
  const avatarCid = [];
  const { content: uint8Array } = await readFileAsUint8Array(file);

let fileCid: any = "";
  const source: ImportCandidate[] = [{ content: uint8Array }];
  for await (const entry of importer(source, ipfsUnixfsImporterBlock, {
    cidVersion: 0,
    onlyHash: true,
  })) {
    fileCid = entry.cid;
  }

avatarCid.push({
    name: file.name,
    size: file.size,
    cid: fileCid.toString(),
  });

return avatarCid;
};

/**
 * Create HTML file from content
 * @param content HTML content string
 * @returns HTML File object
 */
export const createHtmlFile = async (content: string): Promise<File> => {
  try {
    const blob = new Blob([content], { type: "text/html" });
    const file = new File([blob], "index.html", {
      type: "text/html",
      lastModified: Date.now(),
    });

return file;
  } catch (error) {
    console.error("Create HTML file error:", error);
    throw error;
  }
};

/**
 * Create JSON file from content
 * @param content JSON content string
 * @returns JSON File object
 */
export const createJsonFile = async (content: object): Promise<File> => {
  try {
    const jsonString = JSON.stringify(content, null, 2);
    const blob = new Blob([jsonString], { type: "application/json" });
    const file = new File([blob], "agent.json", {
      type: "application/json",
      lastModified: Date.now(),
    });

return file;
  } catch (error) {
    console.error("Create json file error:", error);
    throw error;
  }
};

export const uploadFolderToIPFS = async (dirFileList: File[]) => {
  const list: IFile[] = [];
  const folderName = `agent_${Date.now()}`;

const source = await Promise.all(sourcePromises);

for await (const entry of importer(source, ipfsUnixfsImporterBlock, {
    cidVersion: 0,
    onlyHash: true,
    wrapWithDirectory: true,
  })) {
    const data = {
      filename: entry.path || "",
      contenthash: entry.cid.toString(),
      filesize: entry.size,
      timestamp: Date.now(),
    };

list.push(data);
  }

return list;
};

/**
 * upload file params
 */
interface IRecordDataParam {
  contenthash: string;
  timestamp: number;
  agent_name: string;
  agent_intro: string;
  ensName: string;
  avatarContentHash: string;
  extension: string;
  optionalField: string;
}

export interface IUploadData {
  name: string;
  avatar: File;
  functionDesc: string;
  behaviorDesc: string;
  dataset: string;
  blogPrompt: string;
  blog_dataset: string;
  hasBlog: boolean;
  hasRAG: boolean;
  did: string;
  website?: string;
  website1?: string;
  website2?: string;
}

export const createContractRecord = async (
  formData: IUploadData
): Promise<{
  txHash: string;
  fileList: File[];
  ipfsInfo: {
    avatarHash: string;
    contentHash: string;
    agentId: string;
  };
}> => {
  try {
    const provider = await getProvider(true);
    const signer = await provider.getSigner();
    const network = await provider.getNetwork();

if (Number(network.chainId) !== ENetwork.Ethereum) {
      const { status } = await switchNetworkMetaMask(ENetwork.Ethereum);
      if (!status) {
        throw new Error("Failed to switch network");
      }
    }

const contractAddress = networks.find(
      (item: INetwork) => item.value === Number(network.chainId)
    )?.contractAddr;

if (!contractAddress) throw new Error("Contract address not found");

const contract = new ethers.Contract(contractAddress, UPLOAD_ABI, signer);

const avatarCid = await createAvatarCid(formData.avatar);
    const agentId = nanoid();
    const chatKnowledgeBase = [
      formData.website,
      formData.website1,
      formData.website2
    ].filter(url => url && url.trim() !== '');
    
    const { htmlString } = generateHTML({
      name: formData.name,
      avatar: avatarCid[0].cid,
      functionDesc: formData.functionDesc,
      behaviorDesc: formData.behaviorDesc,
      did: formData.did,
      network: "ETH",
      dataset: formData.dataset,
      blogPrompt: formData.blogPrompt,
      hasBlog: formData.hasBlog,
      hasRAG: formData.hasRAG,
      agentId: agentId,
    });

const JSON_DATA = {
      version: 1,
      agent_type: formData.hasBlog ? 2 : 1,
      agent_id: agentId,
      agent_name: formData.name,
      agent_avatar: avatarCid[0].cid,
      agent_intro: formData.functionDesc,
      did: formData.did,
      network: "ETH",
      detail: {
        chat_prompt: formData.behaviorDesc,
        chat_dataset: formData.dataset,
        chat_knowledge_base: {
          website: chatKnowledgeBase,
        },
        blog_prompt: formData.blogPrompt,
        blog_dataset: formData.blog_dataset,
      },
    };

const htmlFile = await createHtmlFile(htmlString);
    const jsonFile = await createJsonFile(JSON_DATA);
    const fileList = [htmlFile, formData.avatar, jsonFile];
    const ipfsHashCids = await uploadFolderToIPFS(fileList);

const findCid = ipfsHashCids.find(
      (item: IFile) => !item.filename.includes("/")
    );

const data: IRecordDataParam = {
      contenthash: findCid ? findCid.contenthash : "",
      timestamp: Date.now(),
      agent_name: formData.name,
      agent_intro: formData.functionDesc,
      ensName: formData.did,
      avatarContentHash: avatarCid[0].cid,
      extension: JSON.stringify({ agentId }),
      optionalField: "{}",
    };

const price = await contract.priceEth();
    const tx = await contract.recordData(
      data.contenthash,
      data.timestamp,
      data.agent_name,
      data.agent_intro,
      data.ensName,
      data.avatarContentHash,
      data.extension,
      data.optionalField,
      {
        value: price,
        gasLimit: 900000,
      }
    );

// step 2: upload to IPFS
export const uploadToIPFS = async (
  stepData: StepData,
  network: string,
  socialMediaData?: ISocialMediaData,
  onProgress?: (percent: number) => void
): Promise<{ contentHash: string; avatarHash: string }> => {
  try {
    const { contractData, ipfsData, fileList } = stepData;
    if (!fileList) throw new Error("fileList not found");
    const dirFileList = await createFolderWithFiles(fileList);

if (!contractData?.txHash || !ipfsData?.avatarHash)
      throw new Error("txHash not found");

// upload to Glitter
    const glitterHash = await uploadToGlitter(
      dirFileList,
      contractData.txHash,
      network, // Ethereum mainnet
      socialMediaData,
      onProgress
    );

return {
      contentHash: glitterHash.Hash,
      avatarHash: ipfsData?.avatarHash,
    };
  } catch (error: any) {
    console.error("IPFS step error:", error);
    throw error;
  }
};

/**
 * Generate HTML content for AI agent
 * @param data Agent data
 * @returns Generated HTML string
 */
export const generateHTML = (data: IAgentData) => {
  const avatarUrl =
    typeof data.avatar === "string" && data.avatar
      ? data.avatar.startsWith("http")
        ? data.avatar
        : `https://ipfs.glitterprotocol.dev/ipfs/${data.avatar}`
      : "";
  const metaData = {
    name: data.name,
    functionDesc: data.functionDesc,
    behaviorDesc: data.behaviorDesc,
    did: data.did,
    id: Date.now(),
    dataset: data.dataset,
    blogPrompt: data.blogPrompt,
    hasBlog: data.hasBlog,
    hasRAG: data.hasRAG,
    avatar: avatarUrl,
    agentId: data.agentId,
    network: data.network,
  };

const createFolderWithFiles = async (fileList: File[]): Promise<File[]> => {
  try {
    const timestamp = Date.now();
    const folderName = `agent_${timestamp}`;
    const dirFileList: File[] = [];

const folderMetadata = {
      timestamp,
      files: fileList.map((file) => ({
        name: file.name,
        type: file.type,
        size: file.size,
      })),
    };

const folder = new Blob([JSON.stringify(folderMetadata)], {
      type: "application/x-directory",
    });

const folderFile = new File([folder], folderName, {
      type: "application/x-directory",
      lastModified: timestamp,
    });
    dirFileList.push(folderFile);

// add files to folder
    fileList.forEach((file) => {
      const newFile = new File([file], `${folderName}/${file.name}`, {
        type: file.type,
        lastModified: timestamp,
      });
      dirFileList.push(newFile);
    });

return dirFileList;
  } catch (error) {
    console.error("Create folder error:", error);
    throw error;
  }
};

================================================
FILE: src/services/wallet/base.ts
================================================
import { BaseWalletServiceProps, IWalletService, WalletInfo, WalletType, WalletProvider } from './types'

export abstract class BaseWalletService implements IWalletService {
  protected _isConnected = false
  protected _info: WalletInfo | null = null
  protected _provider: WalletProvider | null = null

constructor(protected props: BaseWalletServiceProps) {}

get isConnected() {
    return this._isConnected
  }

get info() {
    return this._info
  }

get provider() {
    return this._provider
  }

abstract get type(): WalletType

abstract connect(): Promise<WalletInfo>
  abstract disconnect(): Promise<void>
  abstract signMessage(message: string): Promise<string>

protected setConnected(connected: boolean) {
    this._isConnected = connected
  }

protected setInfo(info: WalletInfo | null) {
    this._info = info
  }

protected setProvider(provider: WalletProvider | null) {
    this._provider = provider
  }
}

================================================
FILE: src/services/wallet/index.ts
================================================
import { BaseWalletServiceProps, WalletType } from './types'
import { MetaMaskWalletService } from './metamask'
import { PhantomWalletService } from './phantom'

export class WalletService {
  private static instance: WalletService
  private currentWallet: MetaMaskWalletService | PhantomWalletService | null = null

private constructor() {}

static getInstance() {
    if (!WalletService.instance) {
      WalletService.instance = new WalletService()
    }
    return WalletService.instance
  }

init(type: WalletType, props: BaseWalletServiceProps) {
    switch(type) {
      case WalletType.MetaMask:
        this.currentWallet = new MetaMaskWalletService(props)
        break
      case WalletType.Phantom:
        this.currentWallet = new PhantomWalletService(props)
        break
      default:
        throw new Error('Unsupported wallet type')
    }
  }

get wallet() {
    if (!this.currentWallet) {
      throw new Error('Wallet not initialized')
    }
    return this.currentWallet
  }
}

export const walletService = WalletService.getInstance()

export * from './types'

================================================
FILE: src/services/wallet/metamask.ts
================================================
import { createConfig, configureChains, mainnet } from 'wagmi'
import { MetaMaskConnector } from 'wagmi/connectors/metaMask'
import { publicProvider } from 'wagmi/providers/public'
import { BaseWalletService } from './base'
import { BaseWalletServiceProps, WalletInfo, WalletType, EthereumProvider } from './types'

export class MetaMaskWalletService extends BaseWalletService {
  private connector: MetaMaskConnector
  
  constructor(props: BaseWalletServiceProps) {
    super(props)
    
    const { chains, publicClient } = configureChains(
      [mainnet],
      [publicProvider()]
    )

const config = createConfig({
      autoConnect: true,
      connectors: [
        new MetaMaskConnector({ 
          chains,
          options: {
            shimDisconnect: true,
            UNSTABLE_shimOnConnectSelectAccount: true,
          }
        })
      ],
      publicClient
    })  
    console.log(config.connectors[0])

this.connector = config.connectors[0] as MetaMaskConnector
    this.setupListeners()
  }

get type() {
    return WalletType.MetaMask
  }

private setupListeners() {
    this.connector.on('change', ({ account, chain }) => {
      if(account) {
        this.props.onAccountsChange?.([account])
      }
      if(chain?.id) {
        this.props.onChainChange?.(chain.id)
      }
    })

this.connector.on('disconnect', () => {
      this.setConnected(false)
      this.setInfo(null)
      this.props.onDisconnect?.()
    })
  }

async connect(): Promise<WalletInfo> {
    const provider = await this.connector.getProvider()
    if (!provider?.isMetaMask) {
      throw new Error('MetaMask not found')
    }

const { account, chain } = await this.connector.connect()
    
    const info: WalletInfo = {
      address: account,
      chainId: chain?.id
    }

this.setConnected(true)
    this.setInfo(info)
    this.setProvider(provider as EthereumProvider)

return info
  }

async disconnect(): Promise<void> {
    this.setConnected(false)
    this.setInfo(null)
    this.setProvider(null)
    this.props.onDisconnect?.()
  }

async signMessage(message: string): Promise<string> {
    if (!this.isConnected || !this.info?.address) {
      throw new Error('Wallet not connected')
    }
    
    return this.provider?.request({
      method: 'personal_sign',
      params: [message, this.info.address]
    })
  }
}

================================================
FILE: src/services/wallet/phantom.ts
================================================
import { BaseWalletService } from './base'
import { BaseWalletServiceProps, WalletInfo, WalletType, PhantomProvider } from './types'

declare global {
  interface Window {
    phantom?: {
      solana?: PhantomProvider
    }
  }
}

export class PhantomWalletService extends BaseWalletService {
  protected _provider: PhantomProvider | null = null

constructor(props: BaseWalletServiceProps) {
    super(props)
    this._provider = window.phantom?.solana || null
    
    if (this._provider) {
      this.setupListeners()
    }
  }

get type() {
    return WalletType.Phantom
  }

private setupListeners() {
    if (!this._provider) return

this._provider.on('accountChanged', (publicKey: string) => {
      if (publicKey) {
        this.props.onAccountsChange?.([publicKey])
      }
    })

this._provider.on('disconnect', () => {
      this.setConnected(false) 
      this.setInfo(null)
      this.props.onDisconnect?.()
    })
  }

async connect(): Promise<WalletInfo> {
    if (!this._provider) {
      throw new Error('Phantom provider not found')
    }

try {
      const resp = await this._provider.connect()
      const info: WalletInfo = {
        address: resp.publicKey.toString()
      }
      
      this.setConnected(true)
      this.setInfo(info)
      
      return info
    } catch {
      throw new Error('Failed to connect to Phantom')
    }
  }

async disconnect(): Promise<void> {
    if (!this._provider) return
    
    await this._provider.disconnect()
    this.setConnected(false)
    this.setInfo(null)
  }

async signMessage(message: string): Promise<string> {
    if (!this.isConnected || !this.info?.address || !this._provider) {
      throw new Error('Wallet not connected')
    }

try {
      const encodedMessage = new TextEncoder().encode(message)
      const signedMessage = await this._provider.signMessage(encodedMessage)
      return signedMessage.signature
    } catch {
      throw new Error('Failed to sign message')
    }
  }
}

================================================
FILE: src/services/wallet/types.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
export enum WalletType {
  MetaMask = 'MetaMask',
  Phantom = 'Phantom'
}

export interface EthereumProvider {
  request: (args: { method: string; params?: any[] }) => Promise<any>
  on: (eventName: string, handler: (...args: any[]) => void) => void
  removeListener: (eventName: string, handler: (...args: any[]) => void) => void
}

export interface PhantomProvider {
  connect: () => Promise<{ publicKey: { toString: () => string } }>
  disconnect: () => Promise<void>
  on: (event: string, callback: (args: any) => void) => void
  signMessage: (message: Uint8Array) => Promise<{ signature: string }>
  solana?: any
}

export type WalletProvider = EthereumProvider | PhantomProvider

export interface WalletInfo {
  address: string
  chainId?: number
  balance?: string
}

export interface BaseWalletServiceProps {
  onAccountsChange?: (accounts: string[]) => void
  onChainChange?: (chainId: number) => void
  onDisconnect?: () => void
}

export interface IWalletService {
  type: WalletType
  isConnected: boolean
  info: WalletInfo | null
  provider: WalletProvider | null
  
  connect(): Promise<WalletInfo>
  disconnect(): Promise<void> 
  signMessage(message: string): Promise<string>
}

================================================
FILE: src/services/wallet.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
import {
  Connection,
  PublicKey,
  SystemProgram,
  Transaction,
  TransactionInstruction,
} from "@solana/web3.js";

import { getAllOwnedENSDomains, setEnsRecord } from "./ens";
import {
  getDomainKeysWithReverses,
  //   findSubdomains,
  getRecordV2Key,
  serializeRecordV2Content,
  Record,
  createRecordV2Instruction,
  updateRecordV2Instruction,
  validateRecordV2Content,
} from "@bonfida/spl-name-service";
import {
  createContractRecord,
  getAllRecords as getRecordsFromUpload,
  IFile,
  IRecord,
  IUploadData,
} from "@/services/upload";
import { AnchorProvider, Program, BN } from "@coral-xyz/anchor";
import idl from "@/const/solana.json";
import { ethers } from "ethers";
import { nanoid } from "nanoid";
import {
  createAvatarCid,
  createJsonFile,
  createHtmlFile,
  generateHTML,
  uploadFolderToIPFS,
} from "@/services/upload";

import buffer from "buffer";
import { ENetwork } from "./network";
import { NETWORK_TYPE } from "@/utils/constants";

window.Buffer = buffer.Buffer;

interface WalletInfo {
  address: string;
  network: ENetwork;
  balance?: string;
}

export interface ISnsProfile {
  snsName: string;
  contenthash: string;
  timestamp: BN;
  agentName: string;
  agentIntro: string;
  agentId: string;
  avatarContentHash: string;
  extension: string;
  optionalField: string;
  creatorAddress: BN;
}

class WalletError extends Error {
  constructor(message: string) {
    super(message);
    this.name = "WalletError";
  }
}

type StateChangeListener = () => void;

interface SolanaWallet {
  connect(): Promise<{ publicKey: { toString(): string } }>;
  disconnect(): Promise<void>;
  signMessage(message: Uint8Array): Promise<{ signature: Uint8Array }>;
}

interface EthereumProvider {
  isMetaMask?: boolean;
  providers?: EthereumProvider[];
  request: (args: { method: string; params?: any[] }) => Promise<any>;
  selectedAddress?: string;
}

const recordAccountSize = 2008;
const programID = new PublicKey(idl.address);
const PDASeeds = "state";
const RPC_URL = {
  mainnet:
    "https://solana-mainnet.g.alchemy.com/v2/omJBXWIY1zRbJPFZziPcaWLckUpBER7L",
  devnet:
    "https://solana-devnet.g.alchemy.com/v2/omJBXWIY1zRbJPFZziPcaWLckUpBER7L",
};

export class WalletService {
  private static instance: WalletService;
  private walletInfo: WalletInfo | null = null;
  private listeners: Set<StateChangeListener> = new Set();

private constructor() {}

public static getInstance(): WalletService {
    if (!WalletService.instance) {
      WalletService.instance = new WalletService();
    }
    return WalletService.instance;
  }

public subscribe(listener: StateChangeListener): () => void {
    this.listeners.add(listener);
    return () => {
      this.listeners.delete(listener);
    };
  }

private notifyListeners(): void {
    this.listeners.forEach((listener) => listener());
  }

private getMetaMaskProvider(): EthereumProvider | null {
    if (window.ethereum?.providers) {
      const provider = window.ethereum.providers.find(
        (p: EthereumProvider) => p.isMetaMask
      );
      if (provider) return provider;
    }

if (window.ethereum?.isMetaMask) {
      return window.ethereum;
    }

return null;
  }

public switchAccount(network: ENetwork): void {
    if (network === ENetwork.Ethereum) {
      this.connectEthereumWallet();
    } else {
      this.connectSolanaWallet();
    }
  }

private async connectEthereumWallet(): Promise<WalletInfo> {
    const provider = this.getMetaMaskProvider();
    if (!provider) {
      throw new WalletError("Please install or enable MetaMask");
    }

try {
      const accounts = await provider.request({
        method: "eth_requestAccounts",
      });

if (!accounts || accounts.length === 0) {
        throw new WalletError("Failed to get wallet address");
      }

this.walletInfo = {
        address: accounts[0],
        network: ENetwork.Ethereum,
      };

return this.walletInfo;
    } catch (error) {
      console.error("MetaMask connection failed:", error);
      throw new WalletError("Failed to connect MetaMask");
    }
  }

public async connectWallet(network: ENetwork): Promise<WalletInfo> {
    try {
      const result =
        network === ENetwork.Ethereum
          ? await this.connectEthereumWallet()
          : await this.connectSolanaWallet();

this.notifyListeners();
      return result;
    } catch (error) {
      console.error("Wallet connection failed:", error);
      throw new WalletError(
        error instanceof Error ? error.message : "Failed to connect wallet"
      );
    }
  }

private async connectSolanaWallet(): Promise<WalletInfo> {
    if (!window.solana) {
      throw new WalletError("Please install Phantom");
    }

try {
      const wallet = window.solana as SolanaWallet;
      const resp = await wallet.connect();

if (!resp?.publicKey) {
        throw new WalletError("Failed to get Solana wallet address");
      }

this.walletInfo = {
        address: resp.publicKey.toString(),
        network: ENetwork.Solana,
      };

return this.walletInfo;
    } catch (_error) {
      console.error("Phantom connection failed:", _error);
      throw new WalletError("Failed to connect Phantom");
    }
  }

public async disconnectWallet(): Promise<void> {
    try {
      if (
        this.walletInfo?.network === ENetwork.Ethereum &&
        window.ethereum?.selectedAddress
      ) {
        await window.ethereum.request({
          method: "eth_requestAccounts",
          params: [{ eth_accounts: {} }],
        });
      } else if (
        this.walletInfo?.network === ENetwork.Solana &&
        window.solana?.isConnected
      ) {
        await window.solana.disconnect();
      }

this.reset();
      localStorage.removeItem("Authentication-Tokens");
      localStorage.removeItem("Token_address");

this.walletInfo = null;
      this.notifyListeners();
    } catch (error) {
      window.location.reload();
      console.error("Failed to disconnect wallet:", error);
      throw new WalletError("Failed to disconnect wallet");
    }
  }

public reset(): void {
    this.walletInfo = null;
    this.notifyListeners();
  }

public getWalletInfo(): WalletInfo | null {
    return this.walletInfo;
  }

public isConnected(): boolean {
    return this.walletInfo !== null;
  }

public getCurrentNetwork(): ENetwork | null {
    return this.walletInfo?.network || null;
  }

private uint8ArrayToHex(arr: Uint8Array): string {
    return Array.from(arr)
      .map((b) => b.toString(16).padStart(2, "0"))
      .join("");
  }

public async signMessage(message: string): Promise<string> {
    if (!this.walletInfo) {
      throw new WalletError("Please connect wallet first");
    }

if (this.walletInfo.network === ENetwork.Ethereum) {
      const provider = this.getMetaMaskProvider();
      if (!provider) {
        throw new WalletError("Please install MetaMask");
      }
      const signature = await provider.request({
        method: "personal_sign",
        params: [message, this.walletInfo.address],
      });
      return signature;
    } else {
      if (!window.solana) {
        throw new WalletError("Please install Phantom");
      }
      const wallet = window.solana as SolanaWallet;
      const encodedMessage = new TextEncoder().encode(message);
      const { signature } = await wallet.signMessage(encodedMessage);
      return this.uint8ArrayToHex(signature);
    }
  }

public async getAllOwnedDomains(): Promise<string[]> {
    if (!this.walletInfo) {
      throw new WalletError("Please connect wallet first");
    }

try {
      if (this.walletInfo.network === ENetwork.Ethereum) {
        return this.getEthereumDomains();
      } else {
        return this.getSolanaDomains();
      }
    } catch (error) {
      console.error("Failed to get domains:", error);
      return [];
    }
  }

private async getEthereumDomains(): Promise<string[]> {
    if (!window.ethereum) {
      throw new WalletError("Please install MetaMask");
    }
    if (!this.walletInfo?.address) {
      throw new WalletError("Failed to get wallet address");
    }

try {
      const res = await getAllOwnedENSDomains(this.walletInfo.address);
      return res;
    } catch (error) {
      console.error("Failed to get ENS domains:", error);
      throw new WalletError("Failed to get ENS domains");
    }
  }

private async get_all_domains_by_addr(): Promise<string[]> {
    const provider = this.getProvider(RPC_URL.mainnet);
    const userAddr = provider.wallet.publicKey;
    const connection = provider.connection;

private async getSolanaDomains(): Promise<string[]> {
    try {
      const allDomains = await this.get_all_domains_by_addr();
      console.log(allDomains, "allDomains");
      return allDomains.map((item) => item.toString());
    } catch (error) {
      console.error("Failed to get Solana domains:", error);
      return [];
    }
  }

private getProvider(url: string): AnchorProvider {
    const connection = new Connection(url, "confirmed");
    return new AnchorProvider(connection, window.solana, {
      preflightCommitment: "confirmed",
    });
  }

private async getAllSolanaRecords(): Promise<{
    total: number;
    records: IRecord[];
  }> {
    const connection = new Connection(RPC_URL.mainnet);
    try {
      const provider = this.getProvider(RPC_URL.mainnet);
      const program: any = new Program(idl as any, provider);

const programId = new PublicKey(programID);

return {
        total: pageRecord.length,
        records: pageRecord
          .map(({ data }: { data: ISnsProfile }) => ({
            did: data.snsName,
            contenthash: data.contenthash,
            agentId: data.agentId,
            timestamp: data.timestamp.toNumber(),
            creator_address: data.creatorAddress.toString(),
            avatar: data.avatarContentHash,
            agent_name: data.agentName,
            agent_intro: data.agentIntro,
            filename: data.snsName,
            network: ENetwork.Solana,
          }))
          .sort((a, b) => b.timestamp - a.timestamp),
      };
    } catch (error) {
      console.error("Failed to fetch Solana records:", error);
      throw error;
    }
  }

async getAllRecords(): Promise<{
    total: number;
    records: IRecord[];
  }> {
    // const walletType = Number(localStorage.getItem(NETWORK_TYPE));
    const solana = await this.getAllSolanaRecords();
    const ethereum = await getRecordsFromUpload();
    const records = [...solana.records, ...ethereum.records];
    return {
      total: records.length,
      records,
    };
  }

private async createSolanaRecord(data: IUploadData): Promise<{
    txHash: string;
    fileList: File[];
    ipfsInfo: {
      avatarHash: string;
      contentHash: string;
      agentId: string;
    };
  }> {
    try {
      if (!window.solana) {
        throw new Error("Please connect Phantom wallet first");
      }

const provider = this.getProvider(RPC_URL.mainnet);
      console.log(provider, "provider");

const connection = provider.connection;
      const signer = provider.wallet.publicKey;

const programId = new PublicKey(programID);
      const program: any = new Program(idl as any, provider);

const seeds = [Buffer.from(PDASeeds)];
      const [statusPDA] = PublicKey.findProgramAddressSync(seeds, programId);

const snsName = data.did;
      const agentId = nanoid();
      const [recordPDA] = PublicKey.findProgramAddressSync(
        [provider.wallet.publicKey.toBuffer(), Buffer.from(agentId)],
        program.programId
      );

console.log("Creating Solana record with data:", {
        name: data.name,
        functionDesc: data.functionDesc,
        avatar: data.avatar.name,
        did: data.did,
      });

const avatarCid = await createAvatarCid(data.avatar);

const { htmlString } = generateHTML({
        name: data.name,
        avatar: avatarCid[0].cid,
        functionDesc: data.functionDesc,
        behaviorDesc: data.behaviorDesc,
        did: data.did,
        dataset: data.dataset,
        blogPrompt: data.blogPrompt,
        hasBlog: data.hasBlog,
        hasRAG: data.hasRAG,
        agentId: agentId,
        network: "SOLANA",
      });

const jsonData = {
        version: 1,
        agent_type: data.hasBlog ? 2 : 1,
        agent_id: agentId,
        agent_name: data.name,
        agent_avatar: avatarCid[0].cid,
        agent_intro: data.functionDesc,
        did: data.did + ".sol",
        network: "SOLANA",
        detail: {
          chat_prompt: data.behaviorDesc,
          chat_dataset: data.dataset,
          blog_prompt: data.blogPrompt,
          chat_knowledge_base: {
            website: [data.website, data.website1, data.website2].filter(
              (url) => url && url.trim() !== ""
            ),
          },
          blog_dataset: data.blog_dataset,
        },
      };

const htmlFile = await createHtmlFile(htmlString);
      const jsonFile = await createJsonFile(jsonData);
      const fileList = [htmlFile, data.avatar, jsonFile];

const ipfsHashCids = await uploadFolderToIPFS(fileList);
      const findCid = ipfsHashCids.find(
        (item: IFile) => !item.filename.includes("/")
      );

const systemProgram = SystemProgram.programId;
      const transaction = await program.methods
        .recordData(
          agentId,
          snsName,
          findCid ? findCid.contenthash : "",
          new BN(Date.now()),
          data.name,
          data.functionDesc,
          avatarCid[0].cid,
          "",
          "{}"
        )
        .accounts({
          signer: signer,
          state: statusPDA,
          recordAccount: recordPDA,
          systemProgram: systemProgram,
        })
        .signers([signer])
        .transaction();

transaction.recentBlockhash = (
        await connection.getLatestBlockhash()
      ).blockhash;
      transaction.feePayer = signer;

const signedTransaction = await provider.wallet.signTransaction(
        transaction
      );

console.log("Created instruction:", signedTransaction);

const txID = await connection.sendRawTransaction(
        signedTransaction.serialize(),
        {
          skipPreflight: false,
          preflightCommitment: "confirmed",
        }
      );

return {
        txHash: txID,
        fileList,
        ipfsInfo: {
          avatarHash: avatarCid[0].cid,
          contentHash: findCid ? findCid.contenthash : "",
          agentId,
        },
      };
    } catch (error) {
      console.error("Failed to create Solana record:", error);
      if (error instanceof Error) {
        throw new Error(`Failed to create Solana record: ${error.message}`);
      }
      throw error;
    }
  }

public async createRecord(data: IUploadData): Promise<{
    txHash: string;
    fileList: File[];
    ipfsInfo: {
      avatarHash: string;
      contentHash: string;
    };
  }> {
    const walletType = Number(localStorage.getItem(NETWORK_TYPE));
    if (walletType === ENetwork.Solana) {
      return this.createSolanaRecord(data);
    } else {
      return this.createEthereumRecord(data);
    }
  }

private async createEthereumRecord(data: IUploadData): Promise<{
    txHash: string;
    fileList: File[];
    ipfsInfo: {
      avatarHash: string;
      contentHash: string;
    };
  }> {
    return createContractRecord(data);
  }

public async setRecord(data: {
    did: string;
    contenthash: string;
  }): Promise<void> {
    const walletType = Number(localStorage.getItem(NETWORK_TYPE));

try {
      if (walletType === ENetwork.Solana) {
        await this.setSolanaRecord(data);
      } else {
        await this.setEthereumRecord(data);
      }
    } catch (error) {
      console.error("Failed to set record:", error);
      if (error instanceof Error) {
        throw new Error(`Failed to set record: ${error.message}`);
      }
      throw error;
    }
  }

private async setEthereumRecord(data: {
    did: string;
    contenthash: string;
  }): Promise<void> {
    if (!window.ethereum) {
      throw new Error("Ethereum provider not found");
    }

const chainId = ethers.BigNumber.from(window.ethereum.chainId).toNumber();
    if (chainId !== ENetwork.Ethereum) {
      throw new Error("Please switch to Ethereum mainnet");
    }

await setEnsRecord(data.did, data.contenthash);
  }

private async setSolanaRecord(data: {
    did: string;
    contenthash: string;
  }): Promise<void> {
    if (!window.solana) {
      throw new Error("Please connect Phantom wallet first");
    }
    console.log(data, "data");

const provider = this.getProvider(RPC_URL.mainnet);
    console.log(provider, "provider");
    const connection = provider.connection;
    const signer = provider.wallet.publicKey;

const recordV2Key = await getRecordV2Key(data.did, Record.IPFS);
    console.log("recordV2Key", recordV2Key.toString());

const accountInfo = await connection.getAccountInfo(recordV2Key);
    const instructions: TransactionInstruction[] = [];

if (!accountInfo?.data) {
      console.log("have no ipfs");
      const createInstruction = createRecordV2Instruction(
        data.did,
        Record.IPFS,
        serializeRecordV2Content(
          `ipfs://${data.contenthash}`,
          Record.IPFS
        ) as any,
        signer,
        signer
      );
      instructions.push(createInstruction);
    } else {
      console.log("have ipfs");
      const updateInstruction = updateRecordV2Instruction(
        data.did,
        Record.IPFS,
        serializeRecordV2Content(
          `ipfs://${data.contenthash}`,
          Record.IPFS
        ) as any,
        signer,
        signer
      );
      instructions.push(updateInstruction);
    }
    const verifyInstruction = validateRecordV2Content(
      true,
      data.did,
      Record.IPFS,
      signer,
      signer,
      signer
    );
    instructions.push(verifyInstruction);

try {
      const transaction = new Transaction().add(...instructions);
      const { blockhash } = await connection.getLatestBlockhash();
      transaction.recentBlockhash = blockhash;
      transaction.feePayer = window.solana.publicKey;
      const signedTransaction = await window.solana.signTransaction(
        transaction
      );
      const txid = await connection.sendRawTransaction(
        signedTransaction.serialize()
      );
      console.log("TX", txid);
    } catch (error) {
      console.error("Transaction failed:", error);
      throw error;
    }
  }
}

declare global {
  interface Window {
    ethereum?: any;
    solana?: any;
  }
}

================================================
FILE: src/store/network.ts
================================================
import { atom } from "recoil";
import { ENetwork } from "@/services/network";

const UrlNetwork = () => {
  const url = window.location.href;
  if (url.includes("sol.build")) {
    return ENetwork.Solana;
  }
  return ENetwork.Ethereum;
};

export const networkState = atom<ENetwork>({
  key: "networkState",
  default:
    (Number(localStorage.getItem("network_type")) as ENetwork) || UrlNetwork(),
});

export const isWalletConnectedState = atom<boolean>({
  key: "isWalletConnectedState",
  default: !!localStorage.getItem("Authentication-Tokens"),
});

================================================
FILE: src/types/global.d.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
interface Window {
  ethereum?: any;
}
/**
 * Extend Window interface to include ethereum property
 */
declare global {
  interface Window {
    ethereum?: any;
  }
}

================================================
FILE: src/types/images.d.ts
================================================
declare module "*.png" {
  const value: string;
  export default value;
}

declare module "*.jpg" {
  const value: string;
  export default value;
}

declare module "*.jpeg" {
  const value: string;
  export default value;
}

declare module "*.gif" {
  const value: string;
  export default value;
}

declare module "*.svg" {
  const value: string;
  export default value;
}

================================================
FILE: src/types/index.ts
================================================
export enum PublishStep {
  CONTRACT = 'CONTRACT', 
  IPFS = 'IPFS',
  ENS = 'ENS',
  COMPLETED = 'COMPLETED'
}

export interface FormValues {
  name: string;
  functionDesc: string;
  behaviorDesc: string;
  did: string;
  chatConfig: boolean;
  dataset: string;
  blogConfig: boolean;
  blogPrompt: string;
  blog_dataset: string;
  website: string;
  website1: string;
  website2: string;
}

export interface StepData {
  step: PublishStep;
  formData?: FormValues;
  fileList?: File[];
  contractData?: {
    txHash: string;
  };
  ipfsData?: {
    avatarHash: string;
    contentHash: string;
    agentId?: string;
    ipfsUploaded?: boolean;
  };
}

================================================
FILE: src/utils/constants.ts
================================================
// network type storage key name
export const NETWORK_TYPE = "network_type";

================================================
FILE: src/utils/index.ts
================================================
/* eslint-disable @typescript-eslint/no-explicit-any */
import { CID } from 'multiformats/cid'
import { sha256 } from 'multiformats/hashes/sha2'

export const AVATAR_URL = "https://ipfs.glitterprotocol.dev/ipfs/";
export const MESSAGE_URL = "https://airag.glitterprotocol.tech/ipfs/";

/**
 * Encrypt API key using XOR cipher 
 * @param apiKey Original API key to encrypt
 * @returns Base64 encoded encrypted string
 */
export const encryptApiKey = (apiKey: string): string => {
  try {
    const key = 'glitter-protocol'
    let result = ''
    for (let i = 0; i < apiKey.length; i++) {
      const charCode = apiKey.charCodeAt(i) ^ key.charCodeAt(i % key.length)
      result += String.fromCharCode(charCode)
    }
    return btoa(encodeURIComponent(result))
  } catch (error) {
    console.error('Encryption error:', error)
    return apiKey
  }
}

/**
 * Decrypt encrypted API key
 * @param encryptedKey Base64 encoded encrypted key
 * @returns Original decrypted API key
 */
export const decryptApiKey = (encryptedKey: string): string => {
  if (!encryptedKey) return ''

try {
    if (!/^[A-Za-z0-9+/]*={0,2}$/.test(encryptedKey)) {
      throw new Error('Invalid Base64 format')
    }

const decoded = atob(encryptedKey)
    const decodedStr = decodeURIComponent(decoded)
    const key = 'glitter-protocol'
    let result = ''

for (let i = 0; i < decodedStr.length; i++) {
      const charCode = decodedStr.charCodeAt(i) ^ key.charCodeAt(i % key.length)
      result += String.fromCharCode(charCode)
    }

return result
  } catch (error) {
    console.error('Decryption error:', error)
    return ''
  }
}

interface IReadFileReturn {
  path: string
  content: any
}

export const readFileAsUint8Array = (file: any): Promise<IReadFileReturn> =>
  new Promise((resolve) => {
    const reader = new FileReader()
    reader.onload = async (e: any) => {
      const arrayBuffer = e.target.result
      const uint8Array = new Uint8Array(arrayBuffer)
      resolve({
        path: file.webkitRelativePath,
        content: uint8Array,
      })
    }
    reader.readAsArrayBuffer(file)
  })

export const generateChatCID = async (message: string): Promise<string> => {
  try {
    const encoder = new TextEncoder()
    const bytes = encoder.encode(message)

const hash = await sha256.digest(bytes)

const cid = CID.createV0(hash)

return cid.toString()
  } catch (error) {
    console.error('Error generating CID:', error)
    throw new Error('Failed to generate CID')
  }
}

================================================
FILE: src/vite-env.d.ts
================================================
/// <reference types="vite/client" />

================================================
FILE: tsconfig.app.json
================================================
{
  "extends": "./tsconfig.json",
  "compilerOptions": {
    "composite": true
  },
  "include": ["src"],
  "exclude": ["src/**/__tests__/*"]
}

================================================
FILE: tsconfig.json
================================================
{
  "compilerOptions": {
    "target": "ES2020",
    "useDefineForClassFields": true,
    "lib": ["ES2020", "DOM", "DOM.Iterable"],
    "module": "ESNext",
    "skipLibCheck": true,
    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "resolveJsonModule": true,
    "isolatedModules": true,
    "noEmit": true,
    "jsx": "react-jsx",
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,
    "baseUrl": ".",
    "paths": {
      "@/*": ["src/*"],
      "@solana/buffer-layout-utils": ["./node_modules/@solana/buffer-layout-utils"]
    },
    "typeRoots": ["./node_modules/@types", "./src/types"]
  },
  "include": ["src", "src/types"]
}

================================================
FILE: tsconfig.node.json
================================================
{
  "compilerOptions": {
    "tsBuildInfoFile": "./node_modules/.tmp/tsconfig.node.tsbuildinfo",
    "target": "ES2022",
    "lib": ["ES2023"],
    "module": "ESNext",
    "skipLibCheck": true,

/* Bundler mode */
    "moduleResolution": "bundler",
    "allowImportingTsExtensions": true,
    "isolatedModules": true,
    "moduleDetection": "force",
    "noEmit": true,

/* Linting */
    "strict": true,
    "noUnusedLocals": true,
    "noUnusedParameters": true,
    "noFallthroughCasesInSwitch": true,
    "noUncheckedSideEffectImports": true
  },
  "include": ["vite.config.ts"]
}

================================================
FILE: tsconfig.tsbuildinfo
================================================
{"root":["./src/app.tsx","./src/main.tsx","./src/vite-env.d.ts","./src/config/settings.ts","./src/config/wagmi.ts","./src/pages/aiagent/index.tsx","./src/pages/agentlist/index.tsx","./src/pages/publish/index.tsx","./src/services/ai.ts","./src/services/upload.ts","./src/types/global.d.ts"],"version":"5.6.3"}

================================================
FILE: vite.agent.config.ts
================================================
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import path from 'path'

export default defineConfig({
  base: './',
  plugins: [react()],
  resolve: {
    alias: {
      '@': path.resolve(__dirname, './src'),
    },
  },
  css: {
    preprocessorOptions: {
      less: {
        javascriptEnabled: true,
      },
    },
  },
  build: {
    outDir: 'dist/agent',
    emptyOutDir: true,
    assetsDir: '.',
    assetsInlineLimit: 4096000,
    rollupOptions: {
      input: {
        agent: path.resolve(__dirname, 'AIAgent.html'),
      },
      output: {
        entryFileNames: '[name].js',
        chunkFileNames: '[name].js',
        assetFileNames: (assetInfo) => {
          if (assetInfo.name?.endsWith('.css')) {
            return 'agent.css'
          }
          return '[name][extname]'
        },
      },
    },
  },
})

================================================
FILE: vite.config.ts
================================================
import { defineConfig } from 'vite'
import react from '@vitejs/plugin-react'
import path from 'path'

export default defineConfig(({ command }) => ({
  base: './',
  // , basicSsl()
  plugins: [react()],
  server: {
    port: 3000,
    proxy: {
      '/ipfs': {
        target: 'https://ipfs.glitterprotocol.dev',
        changeOrigin: true,
        secure: false,
        rewrite: (path) => path.replace(/^\/ipfs/, '/api/v0'),
      },
      '/agent': {
        target: 'https://airag.glitterprotocol.tech',
        changeOrigin: true,
        secure: false,
        rewrite: (path) => path.replace(/^\/agent/, ''),
      },
    },
  },
  resolve: {
    alias: [
      {
        find: /@\//,
        replacement: `${path.resolve(__dirname, './src')}/`,
      },
    ],
  },
  define: {
    'process.env.NODE_ENV': JSON.stringify(command === 'build' ? 'production' : 'development')
  },
  build: {
    outDir: 'dist',
    assetsDir: './',
    rollupOptions: {
      input: {
        main: path.resolve(__dirname, 'index.html'),
      },
    },
  },
}))

Blog Prompt

Instructions

Example Output

Tone and Style

Chat Prompt

Instructions

Example User Queries and Responses

Key Behaviors

{name}

Agent Intro:

Chat Description Prompt:

Blog Description Prompt:

DID:

AIWS