Nano Digital Asset Exchange Gateway (MCP)

This Model Context Protocol (MCP) service exposes functionality for MCP-compliant consumers, including certain artificial intelligence constructs, to initiate Nano asset movements and retrieve pertinent account and block metadata by leveraging the underlying Nano node RPC infrastructure.

As AI entities increasingly adopt the MCP paradigm, this gateway furnishes them with the capability to dispatch Nano currency based on principal directives or, in certain operational configurations, act with operational autonomy 🤖

❔ Understanding MCP

The Model Context Protocol (MCP) establishes an open specification defining a uniform methodology for applications to convey situational context to Large Language Models (LLMs).

❔ What is Nano?

Nano represents a novel form of digital currency engineered for high-throughput, scalable, and zero-fee transactional throughput. It is designed to circumvent prevalent bottlenecks found in established cryptographic payment systems, like excessive transactional tariffs and protracted confirmation cycles, positioning it as a highly efficient medium for direct peer-to-peer value exchange. Further details are available at nano.org

🚨 Critical Precautionary Notice 🚨

Warning: Given the potential for LLM outputs to deviate from expected parameters (hallucination), exercise prudence and initially validate this server's capabilities using negligible quantities of Nano.

🛠️ Service Endpoints Offered by this Gateway

🔧 nano_send - Executes the transfer of a specified quantity of Nano currency.

🔧 nano_account_info - Fetches comprehensive metadata pertaining to a designated Nano ledger address.

🔧 nano_my_account_info - Retrieves comprehensive metadata for the service's preconfigured custodian Nano address.

🔧 block_info - Fetches detailed information for a specific transaction block hash.

Prerequisites for Deployment

Ensure that the Node.js runtime environment, bundled with NPM, is installed on your system.

Installation Procedure

git clone https://github.com/kilkelly/nano-currency-mcp-server.git cd nano-currency-mcp-server npm install

To utilize this gateway, an MCP client (such as the configuration demonstrated below for Claude Desktop) is necessary for establishing a connection. Each client implementation dictates its own protocol for interfacing with MCP gateways. You must ascertain the mechanism your chosen client employs for setting environment variables related to MCP servers. Once known, configure the subsequent environment variables to activate the Nano Asset Gateway:

Environmental Configuration Variables

NANO_RPC_URL - The Uniform Resource Locator required for communicating with a Nano node's RPC interface. This can point to a locally hosted or externally provisioned endpoint. This URL specification is mandatory.

NANO_WORK_GENERATION_URL - The URL designated for interacting with an endpoint that services the work_generate RPC instruction (referencing https://docs.nano.org/commands/rpc-protocol/#work_generate). If omitted, it defaults to the value assigned to NANO_RPC_URL. Utilized by tool 🔧 nano_send.

NANO_PRIVATE_KEY - The Nano private key essential for cryptographic signing of outgoing transfer transactions and deriving the associated Nano recipient address. Crucial Note: 🚨THIS IS NOT THE WALLET SEED🚨. Test this using the private key associated with an account holding a modest Nano balance. Required by tools 🔧 nano_send and 🔧 nano_my_account_info.

NANO_MAX_SEND_AMOUNT - The upper limit (expressed in nano/Ӿ atomic units) permitted for remittance within a singular transaction. For security governance, the default ceiling is set to 0.01 nano (Ӿ0.01). To permit transfers exceeding this threshold, this variable must be explicitly overridden. Utilized by tool: 🔧 nano_send.

Claude Desktop Integration Guide

1. Install and initiate Claude Desktop

2. Access the configuration interface (Settings)

3. Navigate to the Developer tab and select the Edit Config button to locate and open the claude_desktop_config.json file.

4. Open claude_desktop_config.json in your preferred text editor and insert the subsequent structure, substituting the placeholder values with your specific operational configuration:

{ "mcpServers": { "nano_currency": { "command": "INSERT_ABSOLUTE_PATH_TO_NODE_DOT_EXE_ON_YOUR_MACHINE", "args": [ "INSERT_ABSOLUTE_PATH_TO_NANO_CURRENCY_JS_FILE_FROM_THIS_REPOSITORY" ], "env": { "NANO_RPC_URL": "INSERT_YOUR_NANO_RPC_URL", "NANO_WORK_GENERATION_URL": "INSERT_YOUR_NANO_WORK_GENERATION_URL", "NANO_PRIVATE_KEY": "INSERT_YOUR_NANO_PRIVATE_KEY", "NANO_MAX_SEND_AMOUNT": "INSERT_A_REVISED_MAX_TRANSFER_LIMIT" }
}
} }

Notes:

• INSERT_ABSOLUTE_PATH_TO_NODE_DOT_EXE_ON_YOUR_MACHINE must resolve to the node.exe binary within your Node.js installation (e.g., C:\Program Files\nodejs\node.exe).
• INSERT_ABSOLUTE_PATH_TO_NANO_CURRENCY_JS_FILE_FROM_THIS_REPOSITORY must point to the service script, e.g., C:\development\nano-currency-mcp-server\nano-currency.js.
• For Windows systems, employ double backslashes for path entries (e.g., C:\path\to\file).
• If the RPC and work generation URLs are identical, you may omit the NANO_WORK_GENERATION_URL entry. A typical RPC endpoint might resemble http://localhost:7076.
• INSERT_YOUR_NANO_PRIVATE_KEY: This must be the private signing key, NOT the comprehensive wallet seed. This key is vital for signing transfers and generating your public address. Use a key tied to a minimal Nano balance for initial validation.
• INSERT_A_REVISED_MAX_TRANSFER_LIMIT: This optional parameter overrides the 0.01 nano default. Provide a pure numeric value. It is strongly advised to keep this low or unset during initial testing to mitigate potential losses stemming from erroneous LLM instructions.

5. Persist changes to claude_desktop_config.json and relaunch Claude Desktop.

6. Upon successful configuration, an indicator icon will appear when Claude Desktop initializes.

Click this icon to view the documentation of the provisioned utilities.

7. Engage with Claude Desktop using prompts related to Nano operations to test the integrated utilities.

https://github.com/user-attachments/assets/c877cc5a-0847-416c-b169-a988cac796f9

🚨 Legal Disclaimer 🚨

As is standard when interfacing with tangible value systems like Nano, extreme caution must be exercised when deploying this software. The developers and contributors assume absolutely no liability for any financial detriment, whether intended or accidental, resulting from the utilization of this software's capabilities.

License

MIT

WIKIPEDIA: XMLHttpRequest (XHR) is an Application Programming Interface implemented as a JavaScript object, whose methods are designed to transmit Hypertext Transfer Protocol (HTTP) requests from a web browser environment to a remote web server. These methods enable browser-based scripts to dispatch requests to the server asynchronously subsequent to page load completion, and subsequently receive and process returned data. XMLHttpRequest forms a foundational element of Ajax programming techniques. Prior to Ajax's ubiquity, traditional page navigation via hyperlinks and form submissions were the dominant methods for server interaction, frequently necessitating a full page refresh upon response reception.

== Chronology == The conceptual foundation for XMLHttpRequest was formulated in the year 2000 by the development team at Microsoft Outlook. This concept was subsequently instantiated within the Internet Explorer 5 browser release (1999). However, the initial syntax did not employ the standardized XMLHttpRequest object identifier. Instead, developers utilized COM object instantiation via ActiveXObject("Msxml2.XMLHTTP") and ActiveXObject("Microsoft.XMLHTTP"). By the time Internet Explorer 7 (2006) was released, all major browsers had adopted the standardized XMLHttpRequest identifier. The XMLHttpRequest identifier has since solidified its status as the prevailing convention across principal web browser engines, encompassing Mozilla's Gecko layout engine (2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Formalization === The World Wide Web Consortium (W3C) published an initial Working Draft specification for the XMLHttpRequest object on April 5, 2006. On February 25, 2008, the W3C released the Level 2 specification draft. Level 2 enhanced functionality by introducing mechanisms for monitoring event progression, enabling requests across differing security domains (cross-site requests), and facilitating the handling of raw byte streams. By the conclusion of 2011, the Level 2 specification elements were integrated back into the primary specification document. At the close of 2012, responsibility for the maintenance of this standard transitioned to the WHATWG, which now manages a continuously evolving document utilizing Web IDL (Interface Definition Language).

== Operational Use == Generally, dispatching a request utilizing XMLHttpRequest involves several distinct programming maneuvers:

Instantiate an XMLHttpRequest object by invoking its constructor: Invoke the "open" method to define the request method type, specify the target resource Uniform Resource Identifier (URI), and choose between synchronous or asynchronous execution modes: For asynchronous operations, establish an event handler function to be notified upon transitions in the request's state: Trigger the request lifecycle by calling the "send" method, potentially including a request body payload: Process state changes within the registered event listener. If the server returns response data, it is typically consolidated within the "responseText" property by default. Upon completion of the server's response processing, the object transitions to state 4, the "done" state. Beyond these fundamental steps, XMLHttpRequest provides extensive configuration points for fine-tuning request transmission and response interpretation. Custom header fields can be programmatically appended to tailor server expectations. Data payload can be transmitted to the server via the argument passed to the "send" invocation. Responses retrieved in JSON format can be directly parsed into usable JavaScript objects or streamed incrementally as they arrive, circumventing the need to wait for the entire transmission. The request may also be terminated prematurely via an abort call or configured to time out if completion is not achieved within a set duration.

== Cross-domain Transactions ==

During the nascent phases of the World Wide Web's evolution, it was observed that the mechanism allowed unauthorized cross-domain requests, a security vulnerability that required subsequent mitigation.