feat: Code In Plugin, load characters from blockchain

.env.example

@@ -361,6 +361,13 @@ ZEROG_EVM_RPC=
 ZEROG_PRIVATE_KEY=
 ZEROG_FLOW_ADDRESS=
 
+# IQ6900
+# Load json recorded on-chain through IQ
+# Inscribe your json character file here: https://elizacodein.com/
+
+IQ_WALLET_ADDRESS=              # If you enter the wallet address used on the site, the most recently inscribed json will be loaded.
+IQSOlRPC =  https://api.mainnet-beta.solana.com
+
 # Squid Router
 SQUID_SDK_URL=https://apiplus.squidrouter.com # Default: https://apiplus.squidrouter.com
 SQUID_INTEGRATOR_ID=                          # get integrator id through https://docs.squidrouter.com/

agent/package.json

@@ -70,6 +70,7 @@
         "@elizaos/plugin-ton": "workspace:*",
         "@elizaos/plugin-sui": "workspace:*",
         "@elizaos/plugin-sgx": "workspace:*",
+        "@elizaos/plugin-iq6900": "workspace:*",
         "@elizaos/plugin-tee": "workspace:*",
         "@elizaos/plugin-tee-log": "workspace:*",
         "@elizaos/plugin-tee-marlin": "workspace:*",

agent/src/index.ts

@@ -13,6 +13,11 @@ import { TwitterClientInterface } from "@elizaos/client-twitter";
 import { FarcasterClientInterface } from "@elizaos/client-farcaster";
 // import { ReclaimAdapter } from "@elizaos/plugin-reclaim";
 import { PrimusAdapter } from "@elizaos/plugin-primus";
+import {
+    elizaCodeinPlugin,
+    onchainJson
+} from "@elizaos/plugin-iq6900";
+
 
 import {
     AgentRuntime,
@@ -188,6 +193,63 @@ function mergeCharacters(base: Character, child: Character): Character {
     };
     return mergeObjects(base, child);
 }
+function isAllStrings(arr: unknown[]): boolean {
+    return Array.isArray(arr) && arr.every((item) => typeof item === "string");
+}
+export async function loadCharacterFromOnchain(): Promise<Character[]> {
+    const jsonText = onchainJson;
+
+    console.log('JSON:', jsonText);
+    if (jsonText == "null") return;
+    const loadedCharacters = [];
+    try {
+
+        const character = JSON.parse(jsonText);
+        validateCharacterConfig(character);
+
+        // .id isn't really valid
+        const characterId = character.id || character.name;
+        const characterPrefix = `CHARACTER.${characterId.toUpperCase().replace(/ /g, "_")}.`;
+
+        const characterSettings = Object.entries(process.env)
+            .filter(([key]) => key.startsWith(characterPrefix))
+            .reduce((settings, [key, value]) => {
+                const settingKey = key.slice(characterPrefix.length);
+                return { ...settings, [settingKey]: value };
+            }, {});
+
+        if (Object.keys(characterSettings).length > 0) {
+            character.settings = character.settings || {};
+            character.settings.secrets = {
+                ...characterSettings,
+                ...character.settings.secrets,
+            };
+        }
+
+        // Handle plugins
+        if (isAllStrings(character.plugins)) {
+            elizaLogger.info("Plugins are: ", character.plugins);
+            const importedPlugins = await Promise.all(
+                character.plugins.map(async (plugin) => {
+                    const importedPlugin = await import(plugin);
+                    return importedPlugin.default;
+                })
+            );
+            character.plugins = importedPlugins;
+        }
+
+        loadedCharacters.push(character);
+        elizaLogger.info(
+            `Successfully loaded character from: ${process.env.IQ_WALLET_ADDRESS}`
+        );
+        return loadedCharacters;
+    } catch (e) {
+        elizaLogger.error(
+            `Error parsing character from ${process.env.IQ_WALLET_ADDRESS}: ${e}`
+        );
+        process.exit(1);
+    }
+}
 
 async function loadCharacterFromUrl(url: string): Promise<Character> {
     const response = await fetch(url);
@@ -773,6 +835,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, "DEXSCREENER_API_KEY")
                 ? dexScreenerPlugin
@@ -1115,7 +1181,12 @@ const startAgents = async () => {
     let charactersArg = args.characters || args.character;
     let characters = [defaultCharacter];
 
-    if (charactersArg || hasValidRemoteUrls()) {
+
+    if (process.env.IQ_WALLET_ADDRESS) {
+        characters = await loadCharacterFromOnchain();
+    }
+
+    if (!onchainJson && charactersArg || hasValidRemoteUrls()) {
         characters = await loadCharacters(charactersArg);
     }
 

packages/plugin-iq6900/.npmignore

@@ -0,0 +1,6 @@
+*
+
+!dist/**
+!package.json
+!readme.md
+!tsup.config.ts

packages/plugin-iq6900/README.md

@@ -0,0 +1,28 @@
+# Code In Plugin For Eliza
+
+## Description
+Through IQ6900's new inscription standard "Code-In", powerful inscription functionality is provided to Eliza.
+Engrave Eliza on the blockchain forever.
+All your Character JSON files are input onto the blockchain without compression.
+Everyone can read your agent from blocks forever.
+
+## inscription
+- **Code-in your eliza**: Go to the site and engrave your character file on-chain. https://elizacodein.com/
+
+## Onchain git
+- **Commit your update**:
+Update your files anytime.
+On our site, your files are managed in a format similar to GitHub,
+and our plugin automatically loads your latest agent file.
+
+## Let's get started
+- **Edit your .env**: write down IQ_WALLET_ADDRESS to your wallet address that you used on website.
+To be sure, right after inscription, wait about 5 minutes and just type pmpn start. You are now all set.
+
+
+You have engraved an eternal record.
+Imagine, someone could develop your agent 200 years from now.
+
+Many things will be updated.
+
+Learn more: https://iq6900.gitbook.io/iq6900/eliza-code-in

packages/plugin-iq6900/eslint.config.mjs

@@ -0,0 +1,3 @@
+import eslintGlobalConfig from "../../eslint.config.mjs";
+
+export default [...eslintGlobalConfig];

packages/plugin-iq6900/package.json

@@ -0,0 +1,21 @@
+{
+    "name": "@elizaos/plugin-iq6900",
+    "version": "0.1.5-alpha.5",
+    "main": "dist/index.js",
+    "type": "module",
+    "types": "dist/index.d.ts",
+    "dependencies": {
+        "@elizaos/core": "workspace:*",
+        "@solana/web3.js": "^1.98.0"
+    },
+
+    "devDependencies": {
+        "tsup": "8.3.5",
+        "@types/node": "^20.0.0"
+    },
+    "scripts": {
+        "build": "tsup --format esm --dts",
+        "dev": "tsup --format esm --dts --watch",
+        "lint": "eslint --fix  --cache ."
+    }
+}

packages/plugin-iq6900/src/functions/bringIQData.ts

@@ -0,0 +1,186 @@
+import {
+    elizaLogger,
+} from "@elizaos/core";
+
+
+import { Connection, PublicKey } from "@solana/web3.js";
+const network = process.env.IQSOlRPC;
+const stringAddress = process.env.IQ_WALLET_ADDRESS;
+
+const connection = new Connection(network, 'confirmed');
+
+const iqHost = "https://solanacontractapi.uc.r.appspot.com";
+
+    async function fetchDBPDA(): Promise<string> {
+        try {
+            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;
+            } else {
+                throw new Error(data.error || "Failed to fetch PDA");
+            }
+        } catch (error) {
+            console.error("Error fetching PDA:", error);
+            return "null";
+        }
+    }
+
+    async function convertTextToEmoji(text: string) {
+        return text.replace(/\/u([0-9A-Fa-f]{4,6})/g, (match, code) => {
+            return String.fromCodePoint(parseInt(code, 16));
+        });
+    }
+
+    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) {
+            elizaLogger.error("Error fetching transaction info:", error);
+        }
+        return null;
+    }
+
+    async function getTransactionData(transactionData: {
+        method: string;
+        code: string;
+        decode_break: number;
+        before_tx: string;
+    }): Promise<{ data: any; before_tx: string }> {
+        if ("code" in transactionData) {
+            return {
+                data: {
+                    code: transactionData.code,
+                    method: transactionData.method,
+                    decode_break: transactionData.decode_break,
+                },
+                before_tx: transactionData.before_tx,
+            };
+        } else {
+            return {
+                data: "fail",
+                before_tx: "fail",
+            };
+        }
+    }
+
+    async function extractCommitMessage(dataTxid: string): Promise<string> {
+        const txInfo = await fetchTransactionInfo(dataTxid);
+        if (!txInfo) return "null";
+
+        const type_field = txInfo.type_field || "null";
+
+        if (type_field === "json") {
+            const offset = txInfo.offset;
+            return offset.split("commit: ")[1];
+        } else {
+            return "null";
+        }
+    }
+
+    async function bringCode(dataTxid: string) {
+        const txInfo = await fetchTransactionInfo(dataTxid);
+        if (!txInfo) return {
+            json_data: "false",
+            commit_message: "false",
+        };
+
+        const tail_tx = txInfo.tail_tx || "null";
+        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) {
+                elizaLogger.info("Chunks: "+before_tx);
+                const chunk = await fetchTransactionInfo(before_tx);
+                if (!chunk) {
+                    elizaLogger.error("No chunk found.");
+                    return {
+                        json_data: "false",
+                        commit_message: "false",
+                    };
+                }
+
+                const chunkData = await getTransactionData(chunk);
+                if (chunkData.data == "null"){
+                    console.error("chunk data undefined");
+                    return {
+                        json_data: "false",
+                        commit_message: "false",
+                    };
+                }else{
+                chunks.push(chunkData.data.code);
+                before_tx = chunkData.before_tx;
+                }
+            } else {
+                console.error("before data undefined");
+                return {
+                    json_data: "false",
+                    commit_message: "false",
+                };
+            }
+        }
+
+        const textList = chunks.reverse();
+        const textData = textList.join("");
+
+        return {
+            json_data: await convertTextToEmoji(textData),
+            commit_message: offset,
+        };
+    }
+
+    async function fetchSignaturesForAddress(dbAddress: PublicKey): Promise<string[]> {
+        try {
+            elizaLogger.info("Find Your Signature...(IQ6900)");
+            const signatures = await connection.getSignaturesForAddress(dbAddress, {
+                limit: 20,
+            });
+            return signatures.map((sig) => sig.signature);
+        } catch (error) {
+            console.error("Error fetching signatures:", error);
+            return [];
+        }
+    }
+
+    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 extractCommitMessage(signature);
+            if (commit !== "null") return signature;
+        }
+        return "null";
+    }
+
+    export async function bringAgentWithWalletAddress() {
+        elizaLogger.info("Connecting to Solana...(IQ6900)");
+        const recent = await findRecentJsonSignature();
+        if (recent === "null") {
+
+            elizaLogger.error("Cannot found onchain data in this wallet.");
+            return  "null";
+        }
+        const result = await bringCode(recent);
+        const json_string =  result.json_data;
+        return await json_string;
+    }
+
+
+
+
+
+
+

packages/plugin-iq6900/src/index.ts

@@ -0,0 +1,18 @@
+import { Plugin } from "@elizaos/core";
+export { onchainJson } from "./types/iq.ts";
+
+export const elizaCodeinPlugin: Plugin = {
+    name: "eliza-codein",
+    description: "Plugin that interacts with the on-chain inscription method 'Code-In'",
+    actions: [
+    ],
+    providers: [
+        /* custom providers */
+    ],
+    evaluators: [
+         /* custom evaluators */
+    ],
+    services: [],
+    clients: [],
+
+};