pyre-agent-kit 1.0.0

package/dist/index.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendAndConfirm = exports.ensureStronghold = exports.VOICE_NUDGES = exports.personalityDesc = exports.PERSONALITY_WEIGHTS = exports.PERSONALITY_SOL = exports.assignPersonality = void 0;
+exports.createPyreAgent = createPyreAgent;
+const pyre_world_kit_1 = require("pyre-world-kit");
+const defaults_1 = require("./defaults");
+const action_1 = require("./action");
+const agent_1 = require("./agent");
+const executor_1 = require("./executor");
+const stronghold_1 = require("./stronghold");
+const util_1 = require("./util");
+var defaults_2 = require("./defaults");
+Object.defineProperty(exports, "assignPersonality", { enumerable: true, get: function () { return defaults_2.assignPersonality; } });
+Object.defineProperty(exports, "PERSONALITY_SOL", { enumerable: true, get: function () { return defaults_2.PERSONALITY_SOL; } });
+Object.defineProperty(exports, "PERSONALITY_WEIGHTS", { enumerable: true, get: function () { return defaults_2.PERSONALITY_WEIGHTS; } });
+Object.defineProperty(exports, "personalityDesc", { enumerable: true, get: function () { return defaults_2.personalityDesc; } });
+Object.defineProperty(exports, "VOICE_NUDGES", { enumerable: true, get: function () { return defaults_2.VOICE_NUDGES; } });
+var stronghold_2 = require("./stronghold");
+Object.defineProperty(exports, "ensureStronghold", { enumerable: true, get: function () { return stronghold_2.ensureStronghold; } });
+var tx_1 = require("./tx");
+Object.defineProperty(exports, "sendAndConfirm", { enumerable: true, get: function () { return tx_1.sendAndConfirm; } });
+async function createPyreAgent(config) {
+    const { connection, keypair, network, llm, maxFoundedFactions = 2, strongholdFundSol, strongholdTopupThresholdSol, strongholdTopupReserveSol, } = config;
+    const publicKey = keypair.publicKey.toBase58();
+    const personality = config.personality ?? config.state?.personality ?? (0, defaults_1.assignPersonality)();
+    const solRange = config.solRange ?? defaults_1.PERSONALITY_SOL[personality];
+    const logger = config.logger ?? ((msg) => console.log(`[${(0, util_1.ts)()}] ${msg}`));
+    const strongholdOpts = {
+        fundSol: strongholdFundSol,
+        topupThresholdSol: strongholdTopupThresholdSol,
+        topupReserveSol: strongholdTopupReserveSol,
+    };
+    // Build agent state from serialized or fresh
+    const prior = config.state;
+    const state = {
+        keypair,
+        publicKey,
+        personality,
+        holdings: new Map(Object.entries(prior?.holdings ?? {})),
+        founded: prior?.founded ?? [],
+        rallied: new Set(prior?.rallied ?? []),
+        voted: new Set([...(prior?.voted ?? []), ...Object.keys(prior?.holdings ?? {})]),
+        hasStronghold: prior?.hasStronghold ?? false,
+        activeLoans: new Set(prior?.activeLoans ?? []),
+        infiltrated: new Set(prior?.infiltrated ?? []),
+        sentiment: new Map(Object.entries(prior?.sentiment ?? {})),
+        allies: new Set(prior?.allies ?? []),
+        rivals: new Set(prior?.rivals ?? []),
+        actionCount: prior?.actionCount ?? 0,
+        lastAction: prior?.lastAction ?? 'none',
+        recentHistory: prior?.recentHistory ?? [],
+    };
+    // Track known factions and used names
+    const knownFactions = [];
+    const usedFactionNames = new Set();
+    const recentMessages = [];
+    // Discover existing factions
+    try {
+        const result = await (0, pyre_world_kit_1.getFactions)(connection, { limit: 50, sort: 'newest' });
+        for (const t of result.factions) {
+            if (!(0, pyre_world_kit_1.isPyreMint)(t.mint))
+                continue;
+            knownFactions.push({ mint: t.mint, name: t.name, symbol: t.symbol, status: t.status });
+            usedFactionNames.add(t.name);
+        }
+        logger(`[${publicKey.slice(0, 8)}] discovered ${knownFactions.length} factions`);
+    }
+    catch {
+        logger(`[${publicKey.slice(0, 8)}] faction discovery failed`);
+    }
+    // Ensure stronghold exists
+    await (0, stronghold_1.ensureStronghold)(connection, state, logger, strongholdOpts);
+    function serialize() {
+        return {
+            publicKey: state.publicKey,
+            personality: state.personality,
+            holdings: Object.fromEntries(state.holdings),
+            founded: state.founded,
+            rallied: Array.from(state.rallied),
+            voted: Array.from(state.voted),
+            hasStronghold: state.hasStronghold,
+            activeLoans: Array.from(state.activeLoans),
+            infiltrated: Array.from(state.infiltrated),
+            sentiment: Object.fromEntries(state.sentiment),
+            allies: Array.from(state.allies).slice(0, 20),
+            rivals: Array.from(state.rivals).slice(0, 20),
+            actionCount: state.actionCount,
+            lastAction: state.lastAction,
+            recentHistory: state.recentHistory.slice(-10),
+        };
+    }
+    async function tick(factions) {
+        const activeFactions = factions ?? knownFactions;
+        // Try LLM decision first, fall back to weighted random
+        let decision = null;
+        let usedLLM = false;
+        if (llm && activeFactions.length > 0) {
+            decision = await (0, agent_1.llmDecide)(state, activeFactions, connection, recentMessages, llm, logger, solRange);
+            if (decision)
+                usedLLM = true;
+        }
+        // Fallback: weighted random
+        if (!decision) {
+            const canRally = activeFactions.some(f => !state.rallied.has(f.mint));
+            const action = (0, action_1.chooseAction)(state.personality, state, canRally, activeFactions);
+            const [minSol, maxSol] = solRange;
+            decision = { action, sol: (0, util_1.randRange)(minSol, maxSol) };
+            // Pick a target faction for the fallback
+            if (action === 'join') {
+                const f = activeFactions.length > 0 ? (0, util_1.pick)(activeFactions) : null;
+                if (!f)
+                    return { action, success: false, error: 'no factions', usedLLM: false };
+                decision.faction = f.symbol;
+                decision.sol = (0, action_1.sentimentBuySize)(state, f.mint);
+            }
+            else if (action === 'message' || action === 'fud') {
+                return { action, success: false, error: 'no LLM for message', usedLLM: false };
+            }
+            else if (action === 'defect') {
+                const infiltratedHeld = [...state.holdings.entries()].filter(([m, b]) => b > 0 && state.infiltrated.has(m));
+                const regularHeld = [...state.holdings.entries()].filter(([, b]) => b > 0);
+                const held = infiltratedHeld.length > 0 ? infiltratedHeld : regularHeld;
+                if (held.length === 0)
+                    return { action, success: false, error: 'no holdings', usedLLM: false };
+                const [mint] = (0, util_1.pick)(held);
+                const f = activeFactions.find(ff => ff.mint === mint);
+                if (!f)
+                    return { action, success: false, error: 'faction not found', usedLLM: false };
+                decision.faction = f.symbol;
+            }
+            else if (action === 'rally') {
+                const eligible = activeFactions.filter(f => !state.rallied.has(f.mint));
+                if (eligible.length === 0)
+                    return { action, success: false, error: 'nothing to rally', usedLLM: false };
+                decision.faction = (0, util_1.pick)(eligible).symbol;
+            }
+            else if (action === 'war_loan') {
+                const held = [...state.holdings.entries()].filter(([, b]) => b > 0);
+                const heldAscended = held.filter(([mint]) => activeFactions.find(f => f.mint === mint)?.status === 'ascended');
+                if (heldAscended.length === 0)
+                    return { action, success: false, error: 'no ascended holdings', usedLLM: false };
+                const [mint] = (0, util_1.pick)(heldAscended);
+                const f = activeFactions.find(ff => ff.mint === mint);
+                if (!f)
+                    return { action, success: false, error: 'faction not found', usedLLM: false };
+                decision.faction = f.symbol;
+            }
+            else if (action === 'repay_loan') {
+                const loanMints = [...state.activeLoans];
+                if (loanMints.length === 0)
+                    return { action, success: false, error: 'no loans', usedLLM: false };
+                const mint = (0, util_1.pick)(loanMints);
+                const f = activeFactions.find(ff => ff.mint === mint);
+                if (!f)
+                    return { action, success: false, error: 'faction not found', usedLLM: false };
+                decision.faction = f.symbol;
+            }
+            else if (action === 'ascend') {
+                const ready = activeFactions.filter(f => f.status === 'ready');
+                if (ready.length === 0)
+                    return { action, success: false, error: 'no ready factions', usedLLM: false };
+                decision.faction = (0, util_1.pick)(ready).symbol;
+            }
+            else if (action === 'raze') {
+                const razeable = activeFactions.filter(f => f.status === 'rising');
+                if (razeable.length === 0)
+                    return { action, success: false, error: 'no rising factions', usedLLM: false };
+                const bearish = razeable.filter(f => (state.sentiment.get(f.mint) ?? 0) < -2);
+                decision.faction = (bearish.length > 0 ? (0, util_1.pick)(bearish) : (0, util_1.pick)(razeable)).symbol;
+            }
+            else if (action === 'siege') {
+                const ascended = activeFactions.filter(f => f.status === 'ascended');
+                if (ascended.length === 0)
+                    return { action, success: false, error: 'no ascended factions', usedLLM: false };
+                decision.faction = (0, util_1.pick)(ascended).symbol;
+            }
+            else if (action === 'tithe') {
+                if (activeFactions.length === 0)
+                    return { action, success: false, error: 'no factions', usedLLM: false };
+                const bearish = activeFactions.filter(f => (state.sentiment.get(f.mint) ?? 0) < -2);
+                decision.faction = (bearish.length > 0 ? (0, util_1.pick)(bearish) : (0, util_1.pick)(activeFactions)).symbol;
+            }
+            else if (action === 'infiltrate') {
+                const heldMints = [...state.holdings.keys()];
+                const rivals = activeFactions.filter(f => !heldMints.includes(f.mint));
+                if (rivals.length === 0)
+                    return { action, success: false, error: 'no rival factions', usedLLM: false };
+                const target = (0, util_1.pick)(rivals);
+                decision.faction = target.symbol;
+                decision.sol = (0, action_1.sentimentBuySize)(state, target.mint) * 1.5;
+            }
+        }
+        const result = await (0, executor_1.executeAction)({
+            connection, agent: state, factions: activeFactions, decision, brain: usedLLM ? 'LLM' : 'RNG',
+            log: logger, llm, maxFoundedFactions, usedFactionNames, strongholdOpts,
+        });
+        // Record message to prevent repetition
+        if (result.success && decision.message) {
+            recentMessages.push(decision.message.replace(/^<+/, '').replace(/>+\s*$/, '').toLowerCase());
+            if (recentMessages.length > 30)
+                recentMessages.shift();
+        }
+        return {
+            action: decision.action,
+            faction: decision.faction,
+            message: decision.message,
+            reasoning: decision.reasoning,
+            success: result.success,
+            error: result.error,
+            usedLLM,
+        };
+    }
+    return {
+        publicKey,
+        personality,
+        tick,
+        getState: () => state,
+        serialize,
+    };
+}

package/dist/stronghold.d.ts

@@ -0,0 +1,7 @@
+import { Connection } from '@solana/web3.js';
+import { AgentState } from './types';
+export declare const ensureStronghold: (connection: Connection, agent: AgentState, log: (msg: string) => void, opts?: {
+    fundSol?: number;
+    topupThresholdSol?: number;
+    topupReserveSol?: number;
+}) => Promise<void>;

package/dist/stronghold.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureStronghold = void 0;
+const web3_js_1 = require("@solana/web3.js");
+const pyre_world_kit_1 = require("pyre-world-kit");
+const tx_1 = require("./tx");
+const defaults_1 = require("./defaults");
+const ensureStronghold = async (connection, agent, log, opts) => {
+    const short = agent.publicKey.slice(0, 8);
+    const fundSol = opts?.fundSol ?? defaults_1.STRONGHOLD_FUND_SOL;
+    const topupThreshold = opts?.topupThresholdSol ?? defaults_1.STRONGHOLD_TOPUP_THRESHOLD_SOL;
+    const topupReserve = opts?.topupReserveSol ?? defaults_1.STRONGHOLD_TOPUP_RESERVE_SOL;
+    if (agent.hasStronghold) {
+        // Already known — just check if vault needs a top-up
+        try {
+            const existing = await (0, pyre_world_kit_1.getStronghold)(connection, agent.publicKey);
+            const vaultBal = existing?.sol_balance ?? 0;
+            const threshold = topupThreshold * pyre_world_kit_1.LAMPORTS_PER_SOL;
+            if (existing && vaultBal < threshold) {
+                const walletBal = await connection.getBalance(new web3_js_1.PublicKey(agent.publicKey));
+                const reserve = topupReserve * pyre_world_kit_1.LAMPORTS_PER_SOL;
+                const available = walletBal - reserve;
+                if (available > 0.01 * pyre_world_kit_1.LAMPORTS_PER_SOL) {
+                    const fundAmt = Math.floor(available);
+                    const fundResult = await (0, pyre_world_kit_1.fundStronghold)(connection, {
+                        depositor: agent.publicKey,
+                        stronghold_creator: agent.publicKey,
+                        amount_sol: fundAmt,
+                    });
+                    await (0, tx_1.sendAndConfirm)(connection, agent.keypair, fundResult);
+                    log(`[${short}] topped up vault with ${(fundAmt / pyre_world_kit_1.LAMPORTS_PER_SOL).toFixed(2)} SOL`);
+                }
+            }
+        }
+        catch (err) {
+            log(`[${short}] vault topup check failed: ${err.message?.slice(0, 80) ?? err}`);
+        }
+        return;
+    }
+    // Check if stronghold already exists on-chain (from a previous run)
+    try {
+        const existing = await (0, pyre_world_kit_1.getStronghold)(connection, agent.publicKey);
+        if (existing) {
+            agent.hasStronghold = true;
+            if (existing.sol_balance < topupThreshold * pyre_world_kit_1.LAMPORTS_PER_SOL) {
+                try {
+                    const walletBal = await connection.getBalance(new web3_js_1.PublicKey(agent.publicKey));
+                    const reserve = topupReserve * pyre_world_kit_1.LAMPORTS_PER_SOL;
+                    const available = walletBal - reserve;
+                    if (available > 0.01 * pyre_world_kit_1.LAMPORTS_PER_SOL) {
+                        const fundAmt = Math.floor(available);
+                        const fundResult = await (0, pyre_world_kit_1.fundStronghold)(connection, {
+                            depositor: agent.publicKey,
+                            stronghold_creator: agent.publicKey,
+                            amount_sol: fundAmt,
+                        });
+                        await (0, tx_1.sendAndConfirm)(connection, agent.keypair, fundResult);
+                        log(`[${short}] topped up vault with ${(fundAmt / pyre_world_kit_1.LAMPORTS_PER_SOL).toFixed(2)} SOL`);
+                    }
+                }
+                catch { /* top-up failed, continue anyway */ }
+            }
+            return;
+        }
+    }
+    catch { /* not found, create one */ }
+    try {
+        const result = await (0, pyre_world_kit_1.createStronghold)(connection, { creator: agent.publicKey });
+        await (0, tx_1.sendAndConfirm)(connection, agent.keypair, result);
+        agent.hasStronghold = true;
+        // Fund it so it can trade on DEX
+        const fundAmt = Math.floor(fundSol * pyre_world_kit_1.LAMPORTS_PER_SOL);
+        try {
+            const fundResult = await (0, pyre_world_kit_1.fundStronghold)(connection, {
+                depositor: agent.publicKey,
+                stronghold_creator: agent.publicKey,
+                amount_sol: fundAmt,
+            });
+            await (0, tx_1.sendAndConfirm)(connection, agent.keypair, fundResult);
+        }
+        catch { /* fund failed, stronghold still created */ }
+        log(`[${short}] auto-created stronghold`);
+    }
+    catch (err) {
+        log(`[${short}] failed to create stronghold: ${err.message?.slice(0, 80)}`);
+    }
+};
+exports.ensureStronghold = ensureStronghold;

package/dist/tx.d.ts

@@ -0,0 +1,2 @@
+import { Connection, Keypair } from '@solana/web3.js';
+export declare const sendAndConfirm: (connection: Connection, keypair: Keypair, result: any) => Promise<string>;

package/dist/tx.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendAndConfirm = void 0;
+async function confirm(connection, sig) {
+    try {
+        await connection.confirmTransaction(sig, 'confirmed');
+    }
+    catch {
+        // WebSocket failed — fall back to polling
+        const start = Date.now();
+        while (Date.now() - start < 60000) {
+            const status = await connection.getSignatureStatus(sig);
+            if (status?.value?.confirmationStatus === 'confirmed' || status?.value?.confirmationStatus === 'finalized') {
+                if (status.value.err)
+                    throw new Error(`Transaction failed: ${JSON.stringify(status.value.err)}`);
+                return;
+            }
+            await new Promise(r => setTimeout(r, 2000));
+        }
+        throw new Error(`Transaction confirmation timeout: ${sig}`);
+    }
+}
+const sendAndConfirm = async (connection, keypair, result) => {
+    const tx = result.transaction;
+    tx.partialSign(keypair);
+    const sig = await connection.sendRawTransaction(tx.serialize(), {
+        skipPreflight: false,
+        preflightCommitment: 'confirmed',
+    });
+    await confirm(connection, sig);
+    if (result.additionalTransactions) {
+        for (const addlTx of result.additionalTransactions) {
+            addlTx.partialSign(keypair);
+            const addlSig = await connection.sendRawTransaction(addlTx.serialize());
+            await confirm(connection, addlSig);
+        }
+    }
+    return sig;
+};
+exports.sendAndConfirm = sendAndConfirm;

package/dist/types.d.ts

@@ -0,0 +1,118 @@
+import { Connection, Keypair } from '@solana/web3.js';
+export type Personality = 'loyalist' | 'mercenary' | 'provocateur' | 'scout' | 'whale';
+export type Action = 'join' | 'defect' | 'rally' | 'launch' | 'message' | 'stronghold' | 'war_loan' | 'repay_loan' | 'siege' | 'ascend' | 'raze' | 'tithe' | 'infiltrate' | 'fud';
+export interface LLMDecision {
+    action: Action;
+    faction?: string;
+    sol?: number;
+    message?: string;
+    reasoning?: string;
+}
+export interface FactionInfo {
+    mint: string;
+    name: string;
+    symbol: string;
+    status: 'rising' | 'ready' | 'ascended' | 'razed';
+}
+export interface FactionIntel {
+    symbol: string;
+    members: {
+        address: string;
+        percentage: number;
+    }[];
+    totalMembers: number;
+    recentComms: {
+        sender: string;
+        memo: string;
+    }[];
+}
+export interface AgentState {
+    keypair: Keypair;
+    publicKey: string;
+    personality: Personality;
+    holdings: Map<string, number>;
+    founded: string[];
+    rallied: Set<string>;
+    voted: Set<string>;
+    hasStronghold: boolean;
+    activeLoans: Set<string>;
+    infiltrated: Set<string>;
+    sentiment: Map<string, number>;
+    allies: Set<string>;
+    rivals: Set<string>;
+    actionCount: number;
+    lastAction: string;
+    recentHistory: string[];
+}
+/** Pluggable LLM interface — bring your own model */
+export interface LLMAdapter {
+    generate: (prompt: string) => Promise<string | null>;
+}
+/** Configuration for creating a Pyre agent */
+export interface PyreAgentConfig {
+    /** Solana RPC connection */
+    connection: Connection;
+    /** Agent's keypair (use createEphemeralAgent from torchsdk to generate one) */
+    keypair: Keypair;
+    /** Network to operate on */
+    network: 'devnet' | 'mainnet';
+    /** LLM adapter for intelligent decisions (omit for random fallback) */
+    llm?: LLMAdapter;
+    /** Override personality (auto-assigned if omitted) */
+    personality?: Personality;
+    /** Override SOL spend range [min, max] per action */
+    solRange?: [number, number];
+    /** Max factions this agent can found (default: 2) */
+    maxFoundedFactions?: number;
+    /** SOL to fund stronghold vault on creation */
+    strongholdFundSol?: number;
+    /** Vault balance threshold below which to top up */
+    strongholdTopupThresholdSol?: number;
+    /** SOL reserve to keep in wallet (don't spend below this) */
+    strongholdTopupReserveSol?: number;
+    /** Restore from a previously serialized state */
+    state?: SerializedAgentState;
+    /** Logger function (defaults to console.log) */
+    logger?: (msg: string) => void;
+}
+/** Result of a single agent tick */
+export interface AgentTickResult {
+    action: Action;
+    faction?: string;
+    message?: string;
+    reasoning?: string;
+    success: boolean;
+    error?: string;
+    usedLLM: boolean;
+}
+/** Serializable agent state for persistence */
+export interface SerializedAgentState {
+    publicKey: string;
+    personality: Personality;
+    holdings: Record<string, number>;
+    founded: string[];
+    rallied: string[];
+    voted: string[];
+    hasStronghold: boolean;
+    activeLoans: string[];
+    infiltrated: string[];
+    sentiment: Record<string, number>;
+    allies: string[];
+    rivals: string[];
+    actionCount: number;
+    lastAction: string;
+    recentHistory: string[];
+}
+/** The Pyre agent instance */
+export interface PyreAgent {
+    /** Agent's public key */
+    readonly publicKey: string;
+    /** Agent's personality */
+    readonly personality: Personality;
+    /** Run one decision+action cycle */
+    tick(factions?: FactionInfo[]): Promise<AgentTickResult>;
+    /** Get current mutable state */
+    getState(): AgentState;
+    /** Serialize state for persistence */
+    serialize(): SerializedAgentState;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/util.d.ts

@@ -0,0 +1,6 @@
+export declare const pick: <T>(arr: T[]) => T;
+export declare const randRange: (min: number, max: number) => number;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare const ts: () => string;
+export declare const log: (agent: string, msg: string) => void;
+export declare const logGlobal: (msg: string) => void;

package/dist/util.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logGlobal = exports.log = exports.ts = exports.sleep = exports.randRange = exports.pick = void 0;
+const pick = (arr) => arr[Math.floor(Math.random() * arr.length)];
+exports.pick = pick;
+const randRange = (min, max) => min + Math.random() * (max - min);
+exports.randRange = randRange;
+const sleep = (ms) => new Promise(r => setTimeout(r, ms));
+exports.sleep = sleep;
+const ts = () => new Date().toISOString().substring(11, 19);
+exports.ts = ts;
+const log = (agent, msg) => {
+    console.log(`[${(0, exports.ts)()}] [${agent}] ${msg}`);
+};
+exports.log = log;
+const logGlobal = (msg) => {
+    console.log(`[${(0, exports.ts)()}] [SWARM] ${msg}`);
+};
+exports.logGlobal = logGlobal;

package/package.json

@@ -0,0 +1,30 @@
+{
+  "name": "pyre-agent-kit",
+  "version": "1.0.0",
+  "description": "Autonomous agent kit for Pyre — plug in your own LLM and play pyre.world",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "bin": {
+    "pyre-agent-kit": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "clean": "rm -rf dist",
+    "test": "npx tsx tests/test_e2e.ts"
+  },
+  "dependencies": {
+    "@solana/spl-token": "^0.4.6",
+    "@solana/web3.js": "^1.98.4",
+    "pyre-world-kit": "1.0.21"
+  },
+  "devDependencies": {
+    "@types/node": "^25.4.0",
+    "tsx": "^4.19.4",
+    "typescript": "^5.4.0"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "packageManager": "pnpm@9.10.0+sha512.73a29afa36a0d092ece5271de5177ecbf8318d454ecd701343131b8ebc0c1a91c487da46ab77c8e596d6acf1461e3594ced4becedf8921b074fbd8653ed7051c"
+}