cryptoiz-mcp 4.14.0 → 4.15.1

package/README.md

@@ -0,0 +1,51 @@
+# CryptoIZ MCP Server
+
+Solana DEX trading signals for Claude Desktop via x402 USDC micropayments.
+
+## v4.15.0 — x402 V2 (Dexter Facilitator)
+
+**NEW:** Dexter facilitator sponsors gas fees. Users only need USDC, no SOL required for transaction fees.
+
+### Payment Protocol
+
+- **V2 (default):** Client builds partially-signed tx → edge function forwards to Dexter `/settle` → Dexter adds feePayer signature, submits on-chain, sponsors gas
+- **V1 (fallback):** Client sends USDC on-chain → edge function verifies via Solana RPC
+
+### Setup
+
+```bash
+npm install -g cryptoiz-mcp@4.15.0
+```
+
+### Claude Desktop Config (Windows)
+
+```json
+{
+  "mcpServers": {
+    "cryptoiz": {
+      "command": "C:\\Program Files\\nodejs\\node.exe",
+      "args": ["C:\\Users\\CRYPT0_iz\\AppData\\Roaming\\npm\\node_modules\\cryptoiz-mcp\\index.js"],
+      "env": {
+        "SVM_PRIVATE_KEY": "your-base58-solana-private-key"
+      }
+    }
+  }
+}
+```
+
+### Tools & Pricing
+
+| Tool | Price | Data |
+|------|-------|------|
+| `get_alpha_scanner` | $0.05 USDC | 20 smart money signals |
+| `get_divergence` | $0.02 USDC | 20 divergence signals |
+| `get_accumulation` | $0.02 USDC | 20 accumulation tokens |
+| `get_btc_regime` | $0.01 USDC | BTC macro + technicals |
+| `get_token_ca` | FREE | Contract address lookup |
+| `get_status` | FREE | Server status |
+
+### Links
+
+- Platform: https://cryptoiz.org
+- Setup Guide: https://cryptoiz.org/McpLanding
+- Twitter: @cryptoiz_IDN

package/index.js

@@ -1,131 +1,357 @@
 #!/usr/bin/env node
+// CryptoIZ MCP Server v4.15.0
+// x402 V2: Dexter facilitator (gas sponsored) + V1 backward compat
+// ZERO template literals — Windows PowerShell safe
 
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { Connection, Keypair, PublicKey, Transaction } from '@solana/web3.js';
+import { Connection, Keypair, PublicKey, Transaction, SystemProgram, VersionedTransaction, TransactionMessage } from '@solana/web3.js';
 import bs58 from 'bs58';
 
-const EDGE_FUNCTION_URL = 'https://rehqwsypjnjirhuiapqh.supabase.co/functions/v1/mcp-x402-gateway';
-const DEV_SECRET = process.env.CRYPTOIZ_DEV_KEY || null;
-const SVM_PRIVATE_KEY = process.env.SVM_PRIVATE_KEY || null;
-const CRYPTOIZ_WALLET = 'DsKmdkYx49Xc1WhqMUAztwhdYPTqieyC98VmnnJdgpXX';
-const USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
-const SOLANA_RPC = 'https://api.mainnet-beta.solana.com';
-const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
-const ATA_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+var VERSION = 'v4.15.1';
+var GATEWAY = 'https://rehqwsypjnjirhuiapqh.supabase.co/functions/v1/mcp-x402-gateway';
+var RECIPIENT = 'DsKmdkYx49Xc1WhqMUAztwhdYPTqieyC98VmnnJdgpXX';
+var USDC_MINT = 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v';
+var DEXTER_FEE_PAYER = 'DEXVS3su4dZQWTvvPnLDJLRK1CeeKG6K3QqdzthgAkNV';
+var SOL_RPC = 'https://api.mainnet-beta.solana.com';
+var TOKEN_PROGRAM = 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA';
+var ATA_PROGRAM = 'ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL';
+var DEV_KEY = process.env.CRYPTOIZ_DEV_KEY || '';
 
 function getKeypair() {
-  if (!SVM_PRIVATE_KEY) return null;
-  try { return Keypair.fromSecretKey(bs58.decode(SVM_PRIVATE_KEY)); }
-  catch(e) { console.error('[Payment] Bad key:', e.message); return null; }
+  var privKey = process.env.SVM_PRIVATE_KEY;
+  if (!privKey) throw new Error('SVM_PRIVATE_KEY env var not set');
+  try {
+    var decoded = bs58.decode(privKey);
+    return Keypair.fromSecretKey(decoded);
+  } catch(e) {
+    throw new Error('Invalid SVM_PRIVATE_KEY: ' + e.message);
+  }
 }
 
 function findATA(wallet, mint) {
-  const [addr] = PublicKey.findProgramAddressSync(
-    [new PublicKey(wallet).toBuffer(), TOKEN_PROGRAM_ID.toBuffer(), new PublicKey(mint).toBuffer()],
-    ATA_PROGRAM_ID
-  );
-  return addr;
+  var walletPk = new PublicKey(wallet);
+  var mintPk = new PublicKey(mint);
+  var ataProgramPk = new PublicKey(ATA_PROGRAM);
+  var tokenProgramPk = new PublicKey(TOKEN_PROGRAM);
+  var seeds = [walletPk.toBuffer(), tokenProgramPk.toBuffer(), mintPk.toBuffer()];
+  var ata = PublicKey.findProgramAddressSync(seeds, ataProgramPk);
+  return ata[0];
 }
 
+// ===== V2: Build partially-signed tx for Dexter facilitator =====
+// Dexter pays gas (feePayer), user only signs the transfer
+async function buildV2PaymentPayload(amount) {
+  var kp = getKeypair();
+  var conn = new Connection(SOL_RPC, 'confirmed');
+
+  var userATA = findATA(kp.publicKey.toBase58(), USDC_MINT);
+  var recipientATA = findATA(RECIPIENT, USDC_MINT);
+  var feePayerPk = new PublicKey(DEXTER_FEE_PAYER);
+
+  // Build SPL Token transfer instruction
+  var tokenProgramPk = new PublicKey(TOKEN_PROGRAM);
+  var keys = [
+    { pubkey: userATA, isSigner: false, isWritable: true },
+    { pubkey: recipientATA, isSigner: false, isWritable: true },
+    { pubkey: kp.publicKey, isSigner: true, isWritable: false },
+  ];
+
+  // SPL Token Transfer instruction data: instruction index 3 + u64 amount (LE)
+  var data = Buffer.alloc(9);
+  data.writeUInt8(3, 0); // Transfer instruction index
+  // Write amount as u64 LE
+  var lo = amount & 0xFFFFFFFF;
+  var hi = Math.floor(amount / 0x100000000) & 0xFFFFFFFF;
+  data.writeUInt32LE(lo, 1);
+  data.writeUInt32LE(hi, 5);
+
+  var transferIx = {
+    programId: tokenProgramPk,
+    keys: keys,
+    data: data,
+  };
+
+  // Get recent blockhash
+  var bhResult = await conn.getLatestBlockhash('confirmed');
+
+  // Build V0 message with Dexter as feePayer
+  var message = new TransactionMessage({
+    payerKey: feePayerPk,
+    recentBlockhash: bhResult.blockhash,
+    instructions: [transferIx],
+  }).compileToV0Message();
+
+  var vtx = new VersionedTransaction(message);
+
+  // Partially sign with user keypair only (Dexter signs as feePayer later)
+  vtx.sign([kp]);
+
+  // Serialize and base64 encode
+  var serialized = vtx.serialize();
+  var txB64 = Buffer.from(serialized).toString('base64');
+
+  return txB64;
+}
+
+// ===== V1 FALLBACK: Send USDC on-chain, return signature =====
 async function sendUSDC(amount) {
-  const kp = getKeypair();
-  if (!kp) throw new Error('SVM_PRIVATE_KEY not set');
-  const conn = new Connection(SOLANA_RPC, 'confirmed');
-  const payerATA = findATA(kp.publicKey.toString(), USDC_MINT);
-  const recipATA = findATA(CRYPTOIZ_WALLET, USDC_MINT);
-  const tx = new Transaction();
-  const recipInfo = await conn.getAccountInfo(recipATA);
-  if (!recipInfo) {
-    tx.add({ keys:[
-      {pubkey:kp.publicKey,isSigner:true,isWritable:true},
-      {pubkey:recipATA,isSigner:false,isWritable:true},
-      {pubkey:new PublicKey(CRYPTOIZ_WALLET),isSigner:false,isWritable:false},
-      {pubkey:new PublicKey(USDC_MINT),isSigner:false,isWritable:false},
-      {pubkey:new PublicKey('11111111111111111111111111111111'),isSigner:false,isWritable:false},
-      {pubkey:TOKEN_PROGRAM_ID,isSigner:false,isWritable:false},
-      {pubkey:new PublicKey('SysvarRent111111111111111111111111111111111'),isSigner:false,isWritable:false},
-    ], programId:ATA_PROGRAM_ID, data:Buffer.alloc(0) });
-  }
-  const data = Buffer.alloc(9); data.writeUInt8(3,0); data.writeBigUInt64LE(BigInt(amount),1);
-  tx.add({ keys:[
-    {pubkey:payerATA,isSigner:false,isWritable:true},
-    {pubkey:recipATA,isSigner:false,isWritable:true},
-    {pubkey:kp.publicKey,isSigner:true,isWritable:false},
-  ], programId:TOKEN_PROGRAM_ID, data });
-  const {blockhash} = await conn.getLatestBlockhash('confirmed');
-  tx.recentBlockhash = blockhash; tx.feePayer = kp.publicKey; tx.sign(kp);
-  const sig = await conn.sendRawTransaction(tx.serialize(), {skipPreflight:false,preflightCommitment:'confirmed'});
-  await conn.confirmTransaction(sig, 'confirmed');
-  console.error('[Payment] Sent ' + amount + ' micro-USDC. Sig: ' + sig);
+  var kp = getKeypair();
+  var conn = new Connection(SOL_RPC, 'confirmed');
+
+  var userATA = findATA(kp.publicKey.toBase58(), USDC_MINT);
+  var recipientATA = findATA(RECIPIENT, USDC_MINT);
+
+  var tokenProgramPk = new PublicKey(TOKEN_PROGRAM);
+  var keys = [
+    { pubkey: userATA, isSigner: false, isWritable: true },
+    { pubkey: recipientATA, isSigner: false, isWritable: true },
+    { pubkey: kp.publicKey, isSigner: true, isWritable: false },
+  ];
+
+  var data = Buffer.alloc(9);
+  data.writeUInt8(3, 0);
+  var lo = amount & 0xFFFFFFFF;
+  var hi = Math.floor(amount / 0x100000000) & 0xFFFFFFFF;
+  data.writeUInt32LE(lo, 1);
+  data.writeUInt32LE(hi, 5);
+
+  var transferIx = {
+    programId: tokenProgramPk,
+    keys: keys,
+    data: data,
+  };
+
+  var bhResult = await conn.getLatestBlockhash('confirmed');
+  var tx = new Transaction({
+    feePayer: kp.publicKey,
+    blockhash: bhResult.blockhash,
+    lastValidBlockHeight: bhResult.lastValidBlockHeight,
+  });
+  tx.add(transferIx);
+  tx.sign(kp);
+
+  var rawTx = tx.serialize();
+  var sig = await conn.sendRawTransaction(rawTx, { skipPreflight: false });
+  await conn.confirmTransaction({ signature: sig, blockhash: bhResult.blockhash, lastValidBlockHeight: bhResult.lastValidBlockHeight }, 'confirmed');
   return sig;
 }
 
-class CryptoIZMCPServer {
-  constructor() {
-    this.server = new Server(
-      { name: 'cryptoiz-mcp', version: '4.14.0' },
-      { capabilities: { tools: {} } }
-    );
-    this.setupToolHandlers();
-    this.server.onerror = (error) => console.error('[MCP Error]', error);
-    process.on('SIGINT', async () => { await this.server.close(); process.exit(0); });
+// ===== TOOL CALL HANDLER =====
+async function callTool(toolName, args) {
+  var toolParam = toolName;
+  var queryParts = ['tool=' + toolParam];
+
+  if (toolName === 'get_divergence' && args && args.timeframe) {
+    queryParts.push('tf=' + args.timeframe);
+  }
+  if (toolName === 'get_token_ca' && args && args.name) {
+    queryParts.push('name=' + encodeURIComponent(args.name));
+  }
+
+  var url = GATEWAY + '?' + queryParts.join('&');
+
+  // Dev mode bypass
+  if (DEV_KEY) {
+    var devResp = await fetch(url, { headers: { 'x-dev-key': DEV_KEY } });
+    var devData = await devResp.json();
+    return devData;
+  }
+
+  // Step 1: Fetch gateway — expect 402 or 200 (free tools)
+  var resp1 = await fetch(url);
+
+  if (resp1.status === 200) {
+    return await resp1.json();
+  }
+
+  if (resp1.status !== 402) {
+    var errText = await resp1.text();
+    throw new Error('Gateway error ' + resp1.status + ': ' + errText);
   }
-  setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
-      tools: [
-        { name:'get_alpha_scanner', description:'Get top 20 smart money signals. Cost: $0.05 USDC.', inputSchema:{type:'object',properties:{}} },
-        { name:'get_divergence', description:'Get top 20 divergence signals. Cost: $0.02 USDC.', inputSchema:{type:'object',properties:{tf:{type:'string',description:'4h or 1d',enum:['4h','1d']}}} },
-        { name:'get_accumulation', description:'Get top 20 accumulation tokens with holder delta. Cost: $0.02 USDC.', inputSchema:{type:'object',properties:{}} },
-        { name:'get_btc_regime', description:'Get BTC macro regime analysis. Cost: $0.01 USDC.', inputSchema:{type:'object',properties:{}} },
-        { name:'get_token_ca', description:'Lookup token CA by name. FREE.', inputSchema:{type:'object',properties:{name:{type:'string',description:'Token name'}},required:['name']} },
-        { name:'get_status', description:'Server status and pricing. FREE.', inputSchema:{type:'object',properties:{}} },
-      ],
-    }));
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const { name, arguments: args } = request.params;
-      try {
-        const url = new URL(EDGE_FUNCTION_URL);
-        url.searchParams.set('tool', name);
-        if (name === 'get_divergence' && args.tf) url.searchParams.set('tf', args.tf);
-        if (name === 'get_token_ca' && args.name) url.searchParams.set('name', args.name);
-        const headers = { 'Content-Type': 'application/json' };
-        if (DEV_SECRET) headers['x-dev-key'] = DEV_SECRET;
-
-        let response = await fetch(url.toString(), { headers });
-
-        if (response.status === 402 && SVM_PRIVATE_KEY && !DEV_SECRET) {
-          const payInfo = await response.json();
-          const accepts = payInfo.accepts;
-          if (!accepts || !accepts.length) throw new Error('No payment options');
-          const amt = parseInt(accepts[0].amount);
-          console.error('[Payment] ' + name + ' requires ' + amt + ' micro-USDC');
-          const sig = await sendUSDC(amt);
-          const proof = Buffer.from(JSON.stringify({ signature: sig })).toString('base64');
-          response = await fetch(url.toString(), { headers: { 'Content-Type':'application/json', 'x-payment': proof } });
-          if (!response.ok) {
-            const err = await response.text();
-            throw new Error('Payment OK but data failed (' + response.status + '): ' + err + ' Sig: ' + sig);
-          }
-          console.error('[Payment] Success! ' + name + ' paid & received.');
-        }
-
-        if (response.status === 402) {
-          return { content:[{type:'text',text:'Payment required. Set SVM_PRIVATE_KEY in config.\nSetup: https://cryptoiz.org/McpLanding'}] };
-        }
-        if (!response.ok) throw new Error('HTTP ' + response.status + ': ' + (await response.text()));
-        return { content:[{type:'text',text:JSON.stringify(await response.json(), null, 2)}] };
-      } catch (error) {
-        return { content:[{type:'text',text:'Error calling ' + name + ': ' + error.message}], isError:true };
+
+  // Step 2: Parse 402 response — try V2 header first, fallback to body
+  var paymentRequirements = null;
+  var useV2 = false;
+
+  var prHeader = resp1.headers.get('payment-required');
+  if (prHeader) {
+    try {
+      var prDecoded = Buffer.from(prHeader, 'base64').toString('utf8');
+      var prArray = JSON.parse(prDecoded);
+      if (Array.isArray(prArray) && prArray.length > 0) {
+        paymentRequirements = prArray[0];
+        useV2 = true;
       }
-    });
+    } catch(e) {
+      console.error('[cryptoiz-mcp] Failed to parse PAYMENT-REQUIRED header:', e.message);
+    }
   }
-  async run() {
-    const transport = new StdioServerTransport();
-    await this.server.connect(transport);
-    console.error('CryptoIZ MCP Server v4.14.0 running on stdio');
+
+  // Fallback: read from body (V1 compat)
+  if (!paymentRequirements) {
+    var body402 = await resp1.json();
+    if (body402.accepts && body402.accepts.length > 0) {
+      paymentRequirements = body402.accepts[0];
+    } else {
+      throw new Error('402 response missing payment requirements');
+    }
   }
+
+  var amount = parseInt(paymentRequirements.maxAmountRequired || paymentRequirements.amount || '10000');
+  var displayAmount = (amount / 1000000).toFixed(4);
+  var hasFeePayer = paymentRequirements.extra && paymentRequirements.extra.feePayer;
+  console.error('[cryptoiz-mcp] Payment required: ' + displayAmount + ' USDC for ' + toolName + (hasFeePayer ? ' (V2 Dexter)' : ' (V1 self-pay)'));
+
+  // Step 3: Build and send payment
+  var paymentHeader = '';
+  var headerName = '';
+
+  if (useV2 && paymentRequirements.extra && paymentRequirements.extra.feePayer) {
+    // V2: Build partially-signed tx, Dexter pays gas
+    console.error('[cryptoiz-mcp] V2 mode: building partial tx for Dexter gas sponsorship...');
+    try {
+      var txB64 = await buildV2PaymentPayload(amount);
+
+      // Build V2 payment payload per x402 spec
+      var v2Payload = {
+        x402Version: 2,
+        scheme: 'exact',
+        network: paymentRequirements.network || 'solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp',
+        payload: {
+          transaction: txB64,
+        },
+      };
+
+      paymentHeader = Buffer.from(JSON.stringify(v2Payload)).toString('base64');
+      headerName = 'payment-signature';
+      console.error('[cryptoiz-mcp] V2 partial tx built, sending via PAYMENT-SIGNATURE header');
+    } catch(e) {
+      console.error('[cryptoiz-mcp] V2 build failed: ' + e.message + ', falling back to V1');
+      useV2 = false;
+    }
+  } else {
+    // No feePayer in requirements — force V1
+    useV2 = false;
+  }
+
+  if (!useV2) {
+    // V1 fallback: send USDC on-chain, then pass signature
+    console.error('[cryptoiz-mcp] V1 mode: sending USDC on-chain...');
+    var sig = await sendUSDC(amount);
+    console.error('[cryptoiz-mcp] V1 TX confirmed: ' + sig);
+
+    var v1Payload = { signature: sig };
+    paymentHeader = Buffer.from(JSON.stringify(v1Payload)).toString('base64');
+    headerName = 'x-payment';
+  }
+
+  // Step 4: Retry with payment header
+  var headers2 = {};
+  headers2[headerName] = paymentHeader;
+
+  var resp2 = await fetch(url, { headers: headers2 });
+
+  if (resp2.status !== 200) {
+    var errBody = await resp2.text();
+    throw new Error('Payment failed (' + resp2.status + '): ' + errBody);
+  }
+
+  // Read receipt header (V2 or V1)
+  var receipt = resp2.headers.get('payment-response') || resp2.headers.get('x-payment-response');
+  if (receipt) {
+    try {
+      var receiptData = JSON.parse(Buffer.from(receipt, 'base64').toString('utf8'));
+      console.error('[cryptoiz-mcp] Payment receipt: TX=' + (receiptData.transaction || 'n/a') + ' via ' + (receiptData.version || 'unknown'));
+    } catch(e) {
+      // ignore receipt parse errors
+    }
+  }
+
+  var data = await resp2.json();
+  return data;
+}
+
+// ===== MCP SERVER SETUP =====
+var TOOLS = [
+  {
+    name: 'get_alpha_scanner',
+    description: 'Get top 20 smart money alpha signals from CryptoIZ Solana DEX scanner. Shows accumulation patterns, whale/dolphin activity, and entry timing. Cost: $0.05 USDC.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'get_divergence',
+    description: 'Get divergence signals - hidden accumulation, breakout accumulation, classic divergence between price and smart money. Cost: $0.02 USDC.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        timeframe: { type: 'string', description: 'Timeframe: 4h (default) or 1d', enum: ['4h', '1d'] },
+      },
+      required: [],
+    },
+  },
+  {
+    name: 'get_accumulation',
+    description: 'Get tokens in accumulation phase with holder tier analysis (whale/dolphin/shrimp deltas). Cost: $0.02 USDC.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'get_btc_regime',
+    description: 'Get Bitcoin macro regime, fear/greed index, futures signals, and technicals (RSI, EMA, MACD). Cost: $0.01 USDC.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+  {
+    name: 'get_token_ca',
+    description: 'Look up a Solana token contract address by name. FREE - no payment required.',
+    inputSchema: {
+      type: 'object',
+      properties: {
+        name: { type: 'string', description: 'Token name to search for' },
+      },
+      required: ['name'],
+    },
+  },
+  {
+    name: 'get_status',
+    description: 'Check CryptoIZ MCP server status, available tools, and pricing. FREE.',
+    inputSchema: { type: 'object', properties: {}, required: [] },
+  },
+];
+
+var server = new Server(
+  { name: 'cryptoiz-mcp', version: VERSION },
+  { capabilities: { tools: {} } }
+);
+
+server.setRequestHandler(ListToolsRequestSchema, async function() {
+  return { tools: TOOLS };
+});
+
+server.setRequestHandler(CallToolRequestSchema, async function(request) {
+  var toolName = request.params.name;
+  var args = request.params.arguments || {};
+
+  try {
+    var result = await callTool(toolName, args);
+    return {
+      content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+    };
+  } catch(e) {
+    return {
+      content: [{ type: 'text', text: 'Error: ' + e.message }],
+      isError: true,
+    };
+  }
+});
+
+async function main() {
+  var transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('[cryptoiz-mcp] ' + VERSION + ' running on stdio (x402 V2 Dexter + V1 compat)');
 }
-const server = new CryptoIZMCPServer();
-server.run().catch(console.error);
+
+main().catch(function(e) {
+  console.error('[cryptoiz-mcp] Fatal:', e.message);
+  process.exit(1);
+});

package/package.json

@@ -1,20 +1,40 @@
 {
   "name": "cryptoiz-mcp",
-  "version": "4.14.0",
-  "description": "CryptoIZ MCP Server - AI-powered Solana DEX trading intelligence with x402 micropayments",
+  "version": "4.15.1",
+  "description": "CryptoIZ MCP Server - Solana DEX trading signals via Claude Desktop with x402 USDC micropayments (V2 Dexter facilitator)",
   "main": "index.js",
   "type": "module",
-  "bin": { "cryptoiz-mcp": "./index.js" },
-  "files": ["index.js", "package.json", "README.md"],
-  "keywords": ["mcp", "claude", "solana", "dex", "crypto", "x402"],
-  "author": "CryptoIZ",
-  "license": "MIT",
-  "homepage": "https://cryptoiz.org/McpLanding",
+  "bin": {
+    "cryptoiz-mcp": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "package.json",
+    "README.md"
+  ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.4",
-    "@dexterai/x402": "latest",
     "@solana/web3.js": "^1.95.8",
     "bs58": "^6.0.0"
   },
-  "engines": { "node": ">=18.0.0" }
-}
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "claude",
+    "solana",
+    "crypto",
+    "trading",
+    "x402",
+    "usdc",
+    "dexter"
+  ],
+  "author": "CryptoIZ",
+  "license": "MIT",
+  "homepage": "https://cryptoiz.org/McpLanding",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dadang11/cryptoiz-mcp"
+  }
+}