Agent-native storage with cryptographic verification on Solana. Keyless: clients sign and pay.
| Endpoint | https://mcp.nukez.xyz/mcp (streamable-http) |
|---|---|
| Registry version | 1.3.0 |
| Now | 15 tools · grade D (55) · pin ts_6652cca8e4081bca52db7fc9506924f7 · protocol 2025-06-18 |
| First / last listed | 2026-10-29 02:26 UTC / 2026-10-29 02:26 UTC |
| Grade over time | 2026-10-29: D (55), 15 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: nukez_quote nukez_pay nukez_provision nukez_setup nukez_create_file nukez_store nukez_confirm nukez_upload_chunk nukez_retrieve nukez_verify nukez_recompute_verify nukez_status nukez_delete nukez_remember nukez_recall
nukez_quote | Step 1: Get storage pricing and payment options. Returns price breakdown and every available payment method (SOL/USDC/USDT/WETH/BETA on Solana, USDC/USDT0/MON/WETH on Monad). Each option carries a `destination_kind`: 'wallet' (native SOL — send lamports to pay_to_address), 'spl_token_account' (Solana SPL tokens — pay_to_address IS already the treasury's token account; pass it DIRECTLY as the trans params: units, provider, pay_network, pay_asset |
nukez_pay | Step 2: Record an externally-executed on-chain payment. The server is keyless and never signs transactions — execute the transfer yourself (Solana sendTransaction or an EVM client) and pass the resulting signature as tx_sig. Uses pay_req_id from nukez_quote (auto-resolved from state). Specify chain and pay_asset to identify the rail (e.g. chain='solana-mainnet', pay_asset='BETA'); defaults to the params: pay_req_id, tx_sig, chain, pay_asset |
nukez_provision | Step 3: Confirm payment settlement on the gateway and provision the storage locker. Two modes: (a) Without `envelope`: pass pay_req_id + tx_sig (auto-resolved from state). Returns the receipt_id and a hint to build a signed `locker:provision` envelope. (b) With `receipt_id` + `envelope`: forwards the signed envelope to /v1/storage/signed_provision and activates the locker. Also accepts `receipt_id params: pay_req_id, tx_sig, chain, pay_asset, receipt_id, envelope |
nukez_setup | Set up Nukez storage: checks wallet, purchases storage, and provisions locker in a single call. Call with no args to run the full flow. Call with receipt_id to rehydrate an existing locker. Providers: gcs (default), mongodb, storj, arweave, filecoin, firestore. Payments: Solana (SOL, USDC, USDT, WETH, BETA) and Monad/EVM (MON, USDC, USDT0, WETH) — chain is auto-detected. params: receipt_id, units, provider, envelope |
nukez_create_file | Create a file entry and get upload_url + confirm_url for direct upload. The client PUTs raw bytes directly to the upload_url (307-redirects to GCS), then calls nukez_confirm to finalize. Bytes never transit the MCP server. Use this for large files from local/external sources against Cloud Run. For small inline content (<4KB), use nukez_store with data_b64 instead. KEYLESS (hosted) SERVER: this ser params: filename*, content_type, receipt_id, envelope |
nukez_store | Store files in your Nukez locker. ALWAYS BATCH: pass ALL the files you want to upload in a SINGLE call, as a list under `files`. Do NOT loop over your file list and call nukez_store once per file — that triggers one on-chain attestation per file (slow + costs SOL fees per push). One nukez_store call with N files triggers exactly ONE attestation for the whole batch. Each list item: {name, <data_sou params: files*, receipt_id, envelope |
nukez_confirm | Confirm a file upload after sandbox curl completes. Call this after executing the curl command returned by nukez_store in sandbox mode. The server computes SHA-256 and records the hash. Requires a payer-signed locker:write envelope: signer-mode deployments sign automatically via the SDK; keyless clients first call without envelope to receive the exact envelope spec to sign, then re-call with envel params: filename, receipt_id, envelope, use_job, job_id |
nukez_upload_chunk | Upload a file in chunks when sandbox curl/network is blocked. PREPARATION — run this bash script first to split and hash:
python3 -c "
import base64, hashlib, os, json, math
path = '<SANDBOX_FILE_PATH>'
CHUNK = 4096
size = os.path.getsize(path)
n = math.ceil(size / CHUNK)
os.makedirs('/tmp/nkz', exist_ok=True)
hashes = []
with open(path, 'rb') as f:
for i in range(n):
raw = f.read(CH params: filename*, data_b64*, part_no*, is_last, content_type, receipt_id, sha256, job_id, file_id |
nukez_retrieve | List files or download content from your Nukez locker. Call with no filenames to list all files. Call with filenames=['file.txt'] to download specific files. KEYLESS (hosted) SERVER: a call without `envelope` returns action_required='sign_envelopes' with the exact list spec to sign (locker:list, plus locker:read when downloading); sign it with your wallet and re-call with the same arguments plus e params: filenames, receipt_id, encoding, envelope |
nukez_verify | Fast structural verification of locker state. Returns merkle root, attestation status, and optional per-file proof. Pass memory_key to verify a specific memory record by key. Cheap: reads the persisted attestation; latency is independent of locker size (~sub-second typical). With push=True, also triggers a fresh on-chain attestation: the gateway enqueues the same background job the async path uses params: push, receipt_id, filename, memory_key, envelope |
nukez_recompute_verify | Byte-level integrity proof: re-downloads every file from storage, recomputes content hashes, rebuilds the merkle tree, and compares the result against the persisted attestation. Returns match=True when storage bytes still match the recorded hashes, match=False when they have drifted. Cost: scales with total locker bytes (re-downloads everything). Slower than nukez_verify — reach for this only on a params: receipt_id, envelope |
nukez_status | Check wallet balance, locker state, and lifecycle stage. Works at any stage — no active locker required. params: receipt_id, envelope |
nukez_delete | Delete files from your Nukez locker. WARNING: permanent and irreversible. Invalidates existing attestation. KEYLESS (hosted) SERVER: a call without `envelope` returns action_required='sign_envelopes' with the exact delete spec to sign (locker:write, bound to one file's path); sign it with your wallet and re-call with filenames=[that file] plus envelope=<signed result>. One file per call in envelop params: filenames*, receipt_id, envelope |
nukez_remember | Store a structured memory record in your Nukez locker. Memories are indexed for fast search via nukez_recall. Use namespaces to organize (e.g., 'config', 'context', 'decisions'). Requires: key, content, summary. ENVELOPE: pass a list of 2 envelopes (each with unique nonce, POST path, ops=locker:write) — one for the record file, one for the index. params: key*, content*, summary*, namespace, tags, supersedes, receipt_id, envelope |
nukez_recall | Search and retrieve memory records from your Nukez locker. Two modes: exact key lookup (pass key) returns full content + proof, or search (pass namespace/tags/query/prefix) returns matching index entries. ENVELOPE: none needed — both index and record are read via the public receipt-proxy URL. Just pass receipt_id. params: key, namespace, tags, query, prefix, limit, receipt_id, envelope |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.