make it as function and retrun string in types

zo-sol · zo-sol · commit 2b11bbedbf9d · 2025-01-10T11:18:29.000Z
diff --git a/agent/src/index.ts b/agent/src/index.ts
@@ -65,7 +65,9 @@ import { abstractPlugin } from "@elizaos/plugin-abstract";
 import { avalanchePlugin } from "@elizaos/plugin-avalanche";
 import { webSearchPlugin } from "@elizaos/plugin-web-search";
 import { echoChamberPlugin } from "@elizaos/plugin-echochambers";
-import { elizaCodeinPlugin } from "@elizaos/plugin-iq6900";
+import { elizaCodeinPlugin, onchainJson } from "@elizaos/plugin-iq6900";
+
+
 import Database from "better-sqlite3";
 import fs from "fs";
 import path from "path";
@@ -123,13 +125,15 @@ function isAllStrings(arr: unknown[]): boolean {
     return Array.isArray(arr) && arr.every((item) => typeof item === "string");
 }
 
-export async function loadCharacterFromOnchain(walletAddress:string): Promise<Character[]> {
-    const jsonResult = await elizaCodeinPlugin.providers[0].get(undefined,undefined);
-    console.log("JSON 데이터:", jsonResult);
-    if (jsonResult == "null") return;
+export async function loadCharacterFromOnchain(): Promise<Character[]> {
+    const jsonText = onchainJson;
+
+    console.log('JSON:', jsonText);
+    if (jsonText == "null") return;
     const loadedCharacters = [];
     try {
-        const character = JSON.parse(jsonResult);
+
+        const character = JSON.parse(jsonText);
         validateCharacterConfig(character);
 
         // .id isn't really valid
@@ -165,16 +169,17 @@ export async function loadCharacterFromOnchain(walletAddress:string): Promise<Ch
 
         loadedCharacters.push(character);
         elizaLogger.info(
-            `Successfully loaded character from: ${walletAddress}`
+            `Successfully loaded character from: ${process.env.IQ_WALLET_ADDRESS}`
         );
+        return loadedCharacters;
     } catch (e) {
         elizaLogger.error(
-            `Error parsing character from ${walletAddress}: ${e}`
+            `Error parsing character from ${process.env.IQ_WALLET_ADDRESS}: ${e}`
         );
         process.exit(1);
     }
-
 }
+
 export async function loadCharacters(
     charactersArg: string
 ): Promise<Character[]> {
@@ -578,6 +583,10 @@ export async function createAgent(
         character,
         // character.plugins are handled when clients are added
         plugins: [
+            getSecret(character, "IQ_WALLET_ADDRESS")&&
+            getSecret(character, "IQSOlRPC")
+                ? elizaCodeinPlugin
+                : null,
             bootstrapPlugin,
             getSecret(character, "CONFLUX_CORE_PRIVATE_KEY")
                 ? confluxPlugin
@@ -811,13 +820,11 @@ const startAgents = async () => {
     const args = parseArguments();
     let charactersArg = args.characters || args.character;
     let characters = [defaultCharacter];
-    let onchainJson = [];
-    let iqWallet = process.env.IQ_WALLET_ADDRESS;
 
-    if (iqWallet!=null){
-        onchainJson = await loadCharacterFromOnchain(iqWallet);
+    if (process.env.IQ_WALLET_ADDRESS) {
+        characters = await loadCharacterFromOnchain();
     }
-    if (onchainJson.length === 0 && charactersArg) {
+    if (onchainJson && charactersArg) {
         characters = await loadCharacters(charactersArg);
     }
 
diff --git a/packages/plugin-iq6900/src/functions/bringIQData.ts b/packages/plugin-iq6900/src/functions/bringIQData.ts
@@ -1,27 +1,20 @@
 import {
-    Provider,
-    IAgentRuntime,
-    Memory,
-    State,
     elizaLogger,
 } from "@elizaos/core";
 
 
 import { Connection, PublicKey } from "@solana/web3.js";
+const network = process.env.IQSOlRPC;
+const stringAddress = process.env.IQ_WALLET_ADDRESS;
 
-let network = process.env.IQSOlRPC;
-const iqHost = "https://solanacontractapi.uc.r.appspot.com";
-
-class OnChainJsonProvider {
-    private connection: Connection;
+const connection = new Connection(network, 'confirmed');
 
-    constructor() {
-        this.connection = new Connection(network, "confirmed");
-    }
+const iqHost = "https://solanacontractapi.uc.r.appspot.com";
 
-    private async fetchDBPDA(userKey: string): Promise<string> {
+    async function fetchDBPDA(): Promise<string> {
         try {
-            const response = await fetch(`${iqHost}/getDBPDA/${userKey}`);
+            elizaLogger.info("Your Address:"+stringAddress);
+            const response = await fetch(`${iqHost}/getDBPDA/${stringAddress}`);
             const data = await response.json();
             if (response.ok) {
                 return data.DBPDA as string;
@@ -34,26 +27,26 @@ class OnChainJsonProvider {
         }
     }
 
-    private convertTextToEmoji(text: string) {
+    async function convertTextToEmoji(text: string) {
         return text.replace(/\/u([0-9A-Fa-f]{4,6})/g, (match, code) => {
             return String.fromCodePoint(parseInt(code, 16));
         });
     }
 
-    private async fetchTransactionInfo(txId: string) {
+    async function fetchTransactionInfo(txId: string) {
         try {
             const response = await fetch(`${iqHost}/get_transaction_info/${txId}`);
             if (response.ok) {
                 const data = await response.json();
                 return data.argData;
             }
         } catch (error) {
-            console.error("Error fetching transaction info:", error);
+            elizaLogger.error("Error fetching transaction info:", error);
         }
         return null;
     }
 
-    private async getTransactionData(transactionData: {
+    async function getTransactionData(transactionData: {
         method: string;
         code: string;
         decode_break: number;
@@ -76,8 +69,8 @@ class OnChainJsonProvider {
         }
     }
 
-    private async extractCommitMessage(dataTxid: string): Promise<string> {
-        const txInfo = await this.fetchTransactionInfo(dataTxid);
+    async function extractCommitMessage(dataTxid: string): Promise<string> {
+        const txInfo = await fetchTransactionInfo(dataTxid);
         if (!txInfo) return "null";
 
         const type_field = txInfo.type_field || "null";
@@ -90,8 +83,8 @@ class OnChainJsonProvider {
         }
     }
 
-    private async bringCode(dataTxid: string) {
-        const txInfo = await this.fetchTransactionInfo(dataTxid);
+    async function bringCode(dataTxid: string) {
+        const txInfo = await fetchTransactionInfo(dataTxid);
         if (!txInfo) return {
             json_data: "false",
             commit_message: "false",
@@ -101,19 +94,24 @@ class OnChainJsonProvider {
         const offset = txInfo.offset || "null";
         let chunks = [];
         let before_tx = tail_tx;
+        if (before_tx == "null") return {
+            json_data: "false",
+            commit_message: "false",
+        };
 
         while (before_tx !== "Genesis") {
             if (before_tx) {
-                const chunk = await this.fetchTransactionInfo(before_tx);
+                elizaLogger.info("Chunks: "+before_tx);
+                const chunk = await fetchTransactionInfo(before_tx);
                 if (!chunk) {
-                    console.log("No chunk found.");
+                    elizaLogger.error("No chunk found.");
                     return {
                         json_data: "false",
                         commit_message: "false",
                     };
                 }
 
-                const chunkData = await this.getTransactionData(chunk);
+                const chunkData = await getTransactionData(chunk);
                 if (chunkData.data == "null"){
                     console.error("chunk data undefined");
                     return {
@@ -134,18 +132,19 @@ class OnChainJsonProvider {
         }
 
         const textList = chunks.reverse();
-        const textData = textList.join();
+        const textData = textList.join("");
 
         return {
-            json_data: this.convertTextToEmoji(textData),
+            json_data: convertTextToEmoji(textData),
             commit_message: offset,
         };
     }
 
-    private async fetchSignaturesForAddress(dbAddress: PublicKey): Promise<string[]> {
+    async function fetchSignaturesForAddress(dbAddress: PublicKey): Promise<string[]> {
         try {
-            const signatures = await this.connection.getSignaturesForAddress(dbAddress, {
-                limit: 30,
+            elizaLogger.info("Find Your Signature...(IQ6900)");
+            const signatures = await connection.getSignaturesForAddress(dbAddress, {
+                limit: 20,
             });
             return signatures.map((sig) => sig.signature);
         } catch (error) {
@@ -154,48 +153,36 @@ class OnChainJsonProvider {
         }
     }
 
-    private async findRecentJsonSignature(stringAddress: string): Promise<string> {
-        const dbAddress = await this.fetchDBPDA(stringAddress);
-        const signatures = await this.fetchSignaturesForAddress(new PublicKey(dbAddress));
+    async function findRecentJsonSignature(): Promise<string> {
+        elizaLogger.info("FindRecentJsonSignature...(IQ6900)");
+        const dbAddress = await fetchDBPDA();
+        const signatures = await fetchSignaturesForAddress(new PublicKey(dbAddress));
 
         for (const signature of signatures) {
-            const commit = await this.extractCommitMessage(signature);
+            const commit = await extractCommitMessage(signature);
             if (commit !== "null") return signature;
         }
         return "null";
     }
 
-    async bringAgentWithWalletAddress(stringAddress: string) {
+    export async function bringAgentWithWalletAddress() {
         elizaLogger.info("Connecting to Solana...(IQ6900)");
-        const recent = await this.findRecentJsonSignature(stringAddress);
+        const recent = await findRecentJsonSignature();
         if (recent === "null") {
-            return { json_data: "null", commit_message: "null" };
+
+            elizaLogger.error("Cannot found onchain data in this wallet.");
+            return  "null";
         }
-        const result = await this.bringCode(recent);
-        elizaLogger.info("Your Json:"+ result.json_data.slice(0,20)+"....");
-        return result;
+        const result = await bringCode(recent);
+
+        const json_string =  await result.json_data;
+
+        return await json_string;
     }
-}
 
 
 
 
-const onChainJsonProvider: Provider = {
-    get: async (
-        runtime: IAgentRuntime,
-        _message: Memory,
-        _state?: State
-    ): Promise<string> => {
-        const userWallet = process.env.IQ_WALLET_ADDRESS;
-        if (userWallet != null){
-        const provider = new OnChainJsonProvider();
-        const result = await provider.bringAgentWithWalletAddress(userWallet);
-        return result.json_data;
-        }
-        return "null";
-    },
 
-};
 
-// Module exports
-export { onChainJsonProvider };
+
diff --git a/packages/plugin-iq6900/src/index.ts b/packages/plugin-iq6900/src/index.ts
@@ -1,20 +1,18 @@
 import { Plugin } from "@elizaos/core";
-import { onChainJsonProvider } from "./providers/onChainJsonProvider";
+export { onchainJson } from "./types/iq";
 
 export const elizaCodeinPlugin: Plugin = {
     name: "eliza-codein",
     description: "Plugin that interacts with the on-chain inscription method “Code-In",
     actions: [
-         /* custom actions */
     ],
     providers: [
-        onChainJsonProvider
+        /* custom providers */
     ],
     evaluators: [
          /* custom evaluators */
     ],
     services: [],
     clients: [],
-};
 
-export default elizaCodeinPlugin;
+};
diff --git a/packages/plugin-iq6900/src/types/iq.ts b/packages/plugin-iq6900/src/types/iq.ts
@@ -0,0 +1,8 @@
+import { bringAgentWithWalletAddress } from "../functions/bringIQData";
+
+
+const onchainJson = await (async () => {
+    return await bringAgentWithWalletAddress();
+})();
+
+export { onchainJson };
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
