Back to skill

Security audit

tronlink-skills

Security checks for vulnerabilities and agentic risk

Overview

This TRON wallet skill is mostly read-only, but it installs and exposes a much broader persistent tool suite than the wallet-only skill describes, and it can leak configured API keys to non-TronGrid services.

Review carefully before installing. Prefer running the specific wallet commands locally from a reviewed copy instead of the one-command installer. Do not set TRONGRID_API_KEY or TRONSCAN_API_KEY unless the credential handling is fixed, and avoid global MCP or agent integrations unless you want all TRON suite tools available across sessions and projects.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (6)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/tron_api.mjs:62
Finding
TronGrid API Key Disclosed to Unrelated Third-Party Services<![CDATA[ ## Vulnerability Details **File Location**: `scripts/tron_api.mjs:62-66` **Vulnerability Type**: Credential disclosure caused by an overbroad authentication-header policy **Risk Level**: Critical ### Vulnerable Code ```js function headers(url = "") { const h = { "Content-Type": "application/json", Accept: "application/json" }; // Only add TRON-PRO-API-KEY for TronGrid requests, not for TronScan if (TRONGRID_API_KEY && !url.includes("tronscanapi.com")) { h["TRON-PRO-API-KEY"] = TRONGRID_API_KEY; } return h; } ``` The affected helper is used for destinations configured elsewhere in the same file: ```js const SUNIO_ROUTER_API = { mainnet: "https://rot.endjgfsv.link", nile: "https://tnrouter.endjgfsv.link", }; const COINGECKO_API = "https://api.coingecko.com/api/v3"; ``` ### Technical Analysis The comment states that the credential should only be added to TronGrid requests, but the condition implements a negative check that excludes only URLs containing `tronscanapi.com`. Every other host receives the `TRON-PRO-API-KEY` header. As a result, requests to CoinGecko and the Sun.io router domains receive a credential intended for TronGrid. This violates least privilege and unnecessarily expands the set of parties trusted with the secret. The behavior is not required for the declared read-only market and swap-quotation functionality. Those external APIs can be queried without receiving a TronGrid credential. ### Attack Path 1. A user exports a valid `TRONGRID_API_KEY`. 2. The user or Agent invokes a CoinGecko-backed command such as `trending-tokens`, `token-rankings`, or `token-price --contract TRX`, or invokes `swap-quote`. 3. `httpGet()` calls `headers(url)`. 4. Because the destination is not `tronscanapi.com`, the helper adds the TronGrid key. 5. The key is transmitted to `api.coingecko.com`, `rot.endjgfsv.link`, or `tnrouter.endjgfsv.link`. 6. The receiving service, its infrastructure operators, or a compromised endpoint can r ...[truncated 544 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Replace negative substring filtering with an exact origin allowlist: ```js const TRONGRID_ORIGINS = new Set([ "https://api.trongrid.io", "https://api.shasta.trongrid.io", "https://nile.trongrid.io", ]); function headers(url = "") { const h = { "Content-Type": "application/json", Accept: "application/json", }; const origin = new URL(url).origin; if (TRONGRID_API_KEY && TRONGRID_ORIGINS.has(origin)) { h["TRON-PRO-API-KEY"] = TRONGRID_API_KEY; } return h; } ``` 2. Use separate request helpers or authentication policies for TronGrid, TronScan, CoinGecko, and the swap router. 3. Add automated tests asserting that credentials are absent from all non-TronGrid requests. 4. Document every service that receives user-supplied data and credentials. 5. Advise existing users to rotate TronGrid keys that may already have been exposed. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/tron_api.mjs:71
Finding
TronScan API Key Embedded in Request URLs<![CDATA[ ## Vulnerability Details **File Location**: `scripts/tron_api.mjs:71-77` **Vulnerability Type**: Sensitive credential transmitted as a URL query parameter **Risk Level**: Medium ### Vulnerable Code ```js async function httpGet(url, params = {}) { try { // Add TRONSCAN API Key for tronscan API requests (as URL parameter) if (url.includes("tronscanapi.com") && TRONSCAN_API_KEY) { params.apikey = TRONSCAN_API_KEY; } const qs = new URLSearchParams(params).toString(); const fullUrl = qs ? `${url}?${qs}` : url; ``` ### Technical Analysis The implementation appends `TRONSCAN_API_KEY` to the query string. Query strings are commonly retained in server access logs, reverse-proxy logs, monitoring platforms, debugging output, network observability systems, and error reports. HTTPS protects the URL while it is in transit from passive network observers, but it does not prevent the destination service or trusted intermediaries from logging the complete request target. The code also mutates the caller-provided `params` object, which can cause the key to remain in that object if it is later reused or inspected. ### Attack Path 1. A user configures `TRONSCAN_API_KEY`. 2. The user invokes any command backed by the TronScan API. 3. `httpGet()` adds the key to `params.apikey`. 4. `URLSearchParams` serializes the credential into `fullUrl`. 5. The complete URL may be retained by the remote service, proxy infrastructure, monitoring software, or diagnostic tooling. 6. Anyone with access to those records may recover and reuse the key. ### Impact Assessment The primary impact is unauthorized use of the TronScan credential, including quota consumption, service throttling, request attribution to the victim, and possible account-level consequences supported by the key. The issue does not provide filesystem access or wallet-signing capability, but it exposes a reusable authentication value beyond the minimum scope necessary for the Skill. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Use the official TronScan authentication header if the API supports header-based credentials. 2. Keep credentials out of URLs, query strings, redirects, and exception messages. 3. Construct a new parameter object rather than mutating caller-owned input. 4. Redact authentication values in all HTTP diagnostics and logging. 5. If the API only supports query authentication, explicitly document the logging risk, minimize key permissions, support rapid rotation, and avoid passing complete URLs to observability systems. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
README.md:13
Finding
Mutable Remote Installation and Uninstallation Scripts Piped Directly into a Shell<![CDATA[ ## Vulnerability Details **File Location**: `README.md:13-16` and `README.md:24-28` **Vulnerability Type**: Unverified remote payload retrieval and immediate execution **Risk Level**: Critical ### Vulnerable Code ```bash ### Recommended (auto-detects your AI environment) ```bash curl -sSL https://raw.githubusercontent.com/TronLink/tronlink-skills/main/install.sh | sh ``` ``` The uninstallation instructions repeat the same unsafe pattern: ```bash # If you still have the repo locally: sh uninstall.sh # Or run remotely: curl -sSL https://raw.githubusercontent.com/TronLink/tronlink-skills/main/uninstall.sh | sh ``` Equivalent usage instructions also appear in comments at `install.sh:8` and `uninstall.sh:15`. ### Technical Analysis These commands retrieve content from the mutable `main` branch and send it directly to a shell. The downloaded content is not pinned to an immutable commit, checked against a digest, verified with a signature, or presented for inspection before execution. The effective payload can therefore change after this artifact has been audited. Trust in the audited local files does not establish trust in the future content returned by the remote URL. Although GitHub is a recognized code-hosting platform, repository compromise, maintainer-account compromise, unauthorized upstream changes, or distribution-path compromise would turn the documented command into arbitrary code execution. ### Attack Path 1. An attacker compromises the upstream repository, a maintainer account, or another component of the publication path. 2. The attacker modifies `install.sh` or `uninstall.sh` on the `main` branch. 3. A user follows the documented `curl ... | sh` command. 4. The shell executes the modified content immediately without verification or review. 5. The payload runs with all privileges available to the invoking user. ### Impact Assessment A malicious remote script could read or alter user files, steal environment variables and API crede ...[truncated 367 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Remove all pipe-to-shell installation and uninstallation instructions. 2. Publish immutable, versioned releases rather than directing users to `main`. 3. Provide a workflow that separates download, verification, inspection, and execution: ```bash curl -fLO https://example.invalid/releases/v1.0.1/install.sh echo "<expected-sha256> install.sh" | sha256sum -c - less install.sh sh install.sh ``` 4. Sign release artifacts with a documented signing key and require signature verification. 5. Avoid silent curl options for security-sensitive installation; failures should be visible. 6. Ensure the uninstaller is installed locally so users never need to retrieve mutable remote code to remove the product. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
install.sh:66
Finding
Installer Activates Unpinned Remote Code as Persistent Agent and MCP Configuration<![CDATA[ ## Vulnerability Details **File Location**: `install.sh:66-74`, with activation behavior at `install.sh:126-146` and `install.sh:190-213` **Vulnerability Type**: Mutable remote code activation and cross-session Agent integration **Risk Level**: High ### Vulnerable Code The installer retrieves or updates an unpinned branch: ```sh if [ -d "$INSTALL_DIR/.git" ]; then info "Updating existing installation..." cd "$INSTALL_DIR" && git pull --quiet ok "Updated to latest version" else info "Cloning tronlink-skills..." git clone --depth 1 "$REPO_URL" "$INSTALL_DIR" 2>/dev/null ok "Cloned to $INSTALL_DIR" fi ``` It then registers the downloaded executable globally and modifies Agent instruction state: ```sh # Method 1: Register as global MCP server (available in all projects) info "Registering MCP server (global)..." if claude mcp add -s user tronlink -- node "$INSTALL_DIR/scripts/mcp_server.mjs" 2>/dev/null; then ok "MCP server registered globally (25 TRON tools available in all projects)" fi ``` ```sh if [ ! -f "CLAUDE.md" ]; then cp "$INSTALL_DIR/CLAUDE.md" ./CLAUDE.md ok "Added CLAUDE.md to current project" else # Append if CLAUDE.md already exists if ! grep -qi "tronlink" CLAUDE.md 2>/dev/null; then echo "" >> CLAUDE.md cat "$INSTALL_DIR/CLAUDE.md" >> CLAUDE.md ok "Appended TronLink instructions to existing CLAUDE.md" fi fi ``` Codex integration is also installed across sessions: ```sh mkdir -p "$HOME/.agents/skills" ln -sf "$INSTALL_DIR/skills" "$HOME/.agents/skills/tronlink-skills" ``` ### Technical Analysis The installer does not pin a release tag or commit and does not verify a signature or expected digest. It subsequently activates that mutable content as a global MCP server, a persistent skill symlink, or project-level Agent instructions. These integrations are legitimate mechanisms for an Agent Skill, but global registration and automatic instruction-file modification exceed the minimum privilege necessa ...[truncated 1768 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin installation to a specific signed release and immutable commit. 2. Verify a cryptographic signature or published digest before activating downloaded code. 3. Do not run `git pull` automatically against an activated MCP installation. Require an explicit update command that displays the old and new versions. 4. Default to project-local installation and registration. 5. Obtain separate, explicit confirmation before: - registering a global MCP server; - creating persistent skill symlinks; - writing or appending `CLAUDE.md` or `AGENTS.md`; - installing OpenCode or Cursor integration files. 6. Display every filesystem and configuration change before applying it. 7. Package every referenced integration file in the reviewed artifact, or remove unsupported installation branches. 8. Provide a dry-run mode and a complete manifest that the uninstaller can use for precise rollback. ]]>

T08 · Insecure Dependencies

Warning
Location
README.md:34
Finding
Installation Documentation Executes an Unpinned Third-Party Package Through npx<![CDATA[ ## Vulnerability Details **File Location**: `README.md:34-38` and `README.md:47-51` **Vulnerability Type**: Unpinned package execution through a package runner **Risk Level**: Medium ### Vulnerable Code ```bash # Option A: Vercel Skills CLI npx skills add TronLink/tronlink-skills ``` The same command is recommended for Cursor and Windsurf: ```bash ### Cursor / Windsurf ```bash npx skills add TronLink/tronlink-skills ``` ``` ### Technical Analysis `npx` can retrieve and execute a package when the requested command is not already installed. The documentation specifies the generic package name `skills` without a version or integrity constraint. The executable package can therefore change after this Skill is reviewed. A compromised registry account, malicious later release, package-name takeover, or dependency compromise could cause arbitrary install-time execution. The audit did not establish that the currently published package is malicious. The vulnerability is the unsafe, unpinned execution method. ### Attack Path 1. An attacker compromises the publication account or supply chain for the `skills` package. 2. The attacker publishes a malicious version under the same package name. 3. A user follows the README and runs `npx skills add ...`. 4. `npx` downloads the current package version. 5. The downloaded package executes with the user's privileges. ### Impact Assessment A compromised package can perform arbitrary actions available to the invoking user, including reading files and credentials, modifying Agent configuration, installing persistent components, and altering the target project. If the user runs the command with elevated privileges, the effect can extend beyond the user account. The documented command itself does not request elevation. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions 1. Pin the package to a reviewed version: ```bash npx --yes skills@<reviewed-version> add TronLink/tronlink-skills ``` 2. Document the expected package publisher and integrity information. 3. Prefer a locally installed and lockfile-controlled dependency where feasible. 4. Use a trusted, versioned release of the installer rather than resolving the latest package dynamically. 5. Reassess the package and transitive dependencies before updating the pinned version. 6. Avoid recommending elevated execution for package-manager commands. ]]>

T03 · Remote Payload Retrieval and Execution

Error
Location
README.md:53
Finding
Agent Is Directed to Fetch and Follow Mutable Remote Instructions<![CDATA[ ## Vulnerability Details **File Location**: `README.md:53-56` **Vulnerability Type**: Delegation of Agent behavior to unreviewed mutable remote content **Risk Level**: High ### Vulnerable Code ```text ### Codex CLI ``` Fetch and follow instructions from https://raw.githubusercontent.com/TronLink/tronlink-skills/main/.codex/INSTALL.md ``` ``` ### Technical Analysis The README instructs an Agent to retrieve and follow an instruction document from the mutable `main` branch. The referenced `.codex/INSTALL.md` file is not present in the audited artifact, so its content could not be reviewed. Unlike a conventional hyperlink offered for human reference, the wording explicitly directs the Agent to follow whatever instructions are returned. The remote document can change independently after this Skill has passed review and can potentially direct command execution or configuration changes. This creates a remote execution channel mediated by the Agent. The precise impact depends on the Agent's tools and whether it asks for user approval, but the Skill should not delegate installation authority to mutable external instructions. ### Attack Path 1. An attacker compromises the repository or modifies the remote `.codex/INSTALL.md`. 2. A user gives Codex the README instruction. 3. Codex retrieves the mutable remote file. 4. The remote content instructs Codex to run commands, download files, or modify configuration. 5. Codex follows those instructions using the tools and permissions available in the current session. 6. The attacker-controlled actions occur outside the scope of the originally audited artifact. ### Impact Assessment The reachable privileges are those available to the Agent, potentially including command execution, project-file modification, access to environment variables, installation of tools, and persistent Agent configuration. The affected scope can include the current project and the user's Agent configuration. If the Agent operates with ...[truncated 94 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Include the complete Codex installation instructions in the reviewed repository artifact. 2. Do not tell an Agent to blindly “fetch and follow” external instructions. 3. If an external document is necessary, pin its URL to an immutable commit and verify its digest. 4. Require the Agent to display retrieved instructions and obtain explicit user approval before executing each command. 5. Limit installation instructions to project-local changes unless the user separately authorizes global configuration. 6. Ensure release review includes all hidden integration directories referenced by documentation or installation scripts. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (71)

Description-Behavior Mismatch

Critical
Confidence
99% confidence
Finding
The manifest explicitly says this skill must not be used for swap/trading and directs swap requests to a different skill, yet the server exposes a swap-quote tool. Even if it only returns quotes, it materially enables trading workflows and undermines policy-based tool separation, allowing an agent to bypass intended routing and user safety boundaries.

Description-Behavior Mismatch

Critical
Confidence
99% confidence
Finding
The manifest explicitly excludes staking and says to use tron-staking instead, but this server exposes staking list, staking info, and staking APY tools. This breaks capability isolation and lets an agent access staking operations through a skill that users and higher-level routing logic would reasonably trust as wallet-view-only.

Chaining Abuse

High
Category
Tool Misuse
Content
### Recommended (auto-detects your AI environment)

```bash
curl -sSL https://raw.githubusercontent.com/TronLink/tronlink-skills/main/install.sh | sh
```

This automatically detects Claude Code, Cursor, Codex, OpenCode, or Windsurf and configures everything.
Confidence
98% confidence
Finding
The `| sh` shell-chaining pattern removes the user's opportunity to review downloaded content before execution and turns a remote fetch into immediate code execution. In the context of an AI-agent skill README, this is especially risky because users may copy-paste commands with elevated trust, increasing the chance of silent compromise.

Chaining Abuse

High
Category
Tool Misuse
Content
sh uninstall.sh

# Or run remotely:
curl -sSL https://raw.githubusercontent.com/TronLink/tronlink-skills/main/uninstall.sh | sh
```

Removes MCP registrations, symlinks, copied config files, and `~/.tronlink-skills`.
Confidence
98% confidence
Finding
The uninstall flow also uses `| sh`, preserving the same arbitrary code execution risk while encouraging users to run it during cleanup without scrutiny. The skill context does not mitigate this risk; if anything, wallet-related branding may increase user trust and make unsafe execution more likely.

Tp4

High
Category
MCP Tool Poisoning
Confidence
98% confidence
Finding
The declared purpose is narrowly about a wallet-viewing skill for TRON balances, holdings, transaction history, and account info. The actual code does not implement wallet-checking behavior at all; it is an integration-guide shell/documentation file for installing and running the broader TronLink skills suite. It also references unrelated capabilities such as security audits, energy price checks, swaps, representative lists, and resource optimization. This is a materially different primary purpose from the declared wallet-information skill, so it should be flagged as a mismatch.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The description presents a runtime skill for viewing TRON wallet balances, token holdings, and transaction history, with explicit exclusions for swapping and staking. The actual code chunk does not perform wallet/account queries at all. Instead, it is an installation/setup script for the entire TronLink skills package. It modifies the local environment, integrates with multiple AI tools, and advertises broader capabilities including swap and staking. This is a materially different primary purpose and includes undeclared system-modifying capabilities, so the description does not accurately represent the code.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description says this skill should help users inspect TRON wallet balances, token holdings, transaction history, and related account information. The supplied code does none of that. It does not connect to TRON, inspect wallets, read balances, query transaction history, or manage TronLink wallet state. Instead, its primary purpose is uninstalling the TronLink Skills package and related local integrations by deleting files and deregistering tooling. That is a materially different purpose and involves undeclared destructive local system actions, so this is a clear description-behavior mismatch.

Ae1

High
Category
analysis-evasion
Content
node scripts/tron_api.mjs wallet-balance --address <TRON_ADDRESS>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
node scripts/tron_api.mjs wallet-balance --address <TRON_ADDRESS>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
node scripts/tron_api.mjs wallet-balance --address <TRON_ADDRESS>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
node scripts/tron_api.mjs wallet-balance --address <TRON_ADDRESS>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
node scripts/tron_api.mjs wallet-balance --address <TRON_ADDRESS>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
node scripts/tron_api.mjs wallet-balance --address <TRON_ADDRESS>
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
The guide exposes swap- and staking-related tools in the same integration surface even though the tron-wallet skill metadata explicitly says not to use this skill for swap/trading or staking. This scope mismatch can cause an agent to over-select this skill or assume authority beyond its declared purpose, increasing the chance of unintended tool use and policy bypass through ambiguous routing.

Chaining Abuse

High
Category
Tool Misuse
Content
# TronLink Skills — One-Command Installer
#
# Usage:
#   curl -sSL https://raw.githubusercontent.com/TronLink/tronlink-skills/main/install.sh | sh
#
# Local development (no GitHub needed):
#   sh install.sh --local /path/to/tronlink-skills
Confidence
95% confidence
Finding
The explicit use of a pipe into sh chains remote retrieval directly into command execution, eliminating any review barrier and making compromise of the source or delivery path immediately actionable on the host. In an installer that also writes to home-directory agent/plugin locations and modifies project files, this pattern substantially increases the blast radius of a bad update.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The manifest for this skill limits scope to TRON wallet balance, holdings, and transaction history, explicitly excluding swap and staking. This installer registers '25 TRON tools' globally and elsewhere describes the package as 'Wallet · Market · Swap · Energy · Stake', indicating installation/integration of a much broader capability set than the wallet skill claims.

Description-Behavior Mismatch

High
Confidence
99% confidence
Finding
The manifest says this skill is for checking TRON wallet information and explicitly says not to use it for swap or staking. The installer banner presents the installed capability set as 'Wallet · Market · Swap · Energy · Stake', which materially exceeds the declared wallet-only scope.

Known Vulnerable Dependency: axios==1.13.5 — 16 advisory(ies): CVE-2026-44494 (axios Vulnerable to Full Man-in-the-Middle via Prototype Pollution Gadget in `co); CVE-2026-44495 (axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollut); CVE-2025-62718 (Axios has a NO_PROXY Hostname Normalization Bypass that Leads to SSRF) +13 more

High
Category
Supply Chain
Confidence
97% confidence
Finding
The lockfile pins axios 1.13.5, which is flagged with multiple advisories including SSRF-related proxy handling and prototype-pollution/MITM-style issues. Even though this file is only a dependency manifest, the skill is a TRON wallet/account skill that will likely make outbound RPC/API requests to blockchain infrastructure, so flaws in the HTTP client are security-relevant and can affect request routing, credential handling, or response trust.

Known Vulnerable Dependency: form-data==4.0.5 — 1 advisory(ies): CVE-2026-12143 (form-data: CRLF injection in form-data via unescaped multipart field names and f)

High
Category
Supply Chain
Confidence
87% confidence
Finding
form-data 4.0.5 is flagged for CRLF injection via unescaped multipart field names and filenames. This becomes exploitable when attacker-controlled values are inserted into multipart requests; while a wallet balance skill may not heavily rely on multipart uploads, the vulnerable package is still present transitively and could be abused if such request paths exist now or are added later.

Known Vulnerable Dependency: ws==8.17.1 — 2 advisory(ies): CVE-2026-45736 (ws: Uninitialized memory disclosure); CVE-2026-48779 (ws: Memory exhaustion DoS from tiny fragments and data chunks)

High
Category
Supply Chain
Confidence
91% confidence
Finding
ws 8.17.1 is flagged for memory disclosure and memory-exhaustion denial of service issues. Wallet and blockchain tooling commonly use WebSocket connections for subscriptions or live account/transaction updates, so a vulnerable ws version can expose the process to remote instability or data leakage if it connects to malicious or compromised endpoints.

Description-Behavior Mismatch

High
Confidence
97% confidence
Finding
The manifested skill is scoped to wallet balance, holdings, and transaction history, but the MCP server exposes a much broader set of token analytics and market-intelligence tools. This violates least-privilege and creates a capability-expansion path where an agent selecting this wallet skill can perform unrelated market analysis actions the user and orchestrator did not intend.

Intent-Code Divergence

High
Confidence
96% confidence
Finding
The module header advertises DEX swap and TRX staking support even though the manifest explicitly excludes those functions. This contradiction is dangerous because operators and automated tooling may trust the manifest while the implementation and documentation quietly encourage higher-risk capabilities.

Credential Access

High
Category
Privilege Escalation
Content
trx_24h_volume: trx.usd_24h_vol || 0,
      latest_block: sysData.database?.block || sysData.full?.block || 0,
      confirmed_block: sysData.database?.confirmedBlock || sysData.solidity?.block || 0,
      network_env: sysData.network?.env || "unknown",
    },
  }));
}
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The skill manifest explicitly says this skill must not be used for swap/trading, yet the file exposes swap quote and routing commands and wires them into the CLI. This scope mismatch is dangerous because an orchestrator or downstream agent may invoke trading-related functionality through a wallet-inspection skill, bypassing intended policy separation and increasing the chance of unauthorized or misleading financial actions.

Description-Behavior Mismatch

High
Confidence
98% confidence
Finding
The manifest states staking belongs to another skill, but this file includes staking discovery and reward-related commands. Even if these commands are informational, embedding staking capabilities in the wrong skill undermines least-privilege and can cause an agent to use the wrong tool for sensitive financial workflows.

Static analysis

Detected: suspicious.env_credential_access, suspicious.exposed_secret_literal

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
scripts/tron_api.mjs:21

File appears to expose a hardcoded API secret or token.

Critical
Code
suspicious.exposed_secret_literal
Location
scripts/tron_api.mjs:74