clawreum-sdk 1.0.0 → 2.0.0

package/README.md

@@ -15,24 +15,24 @@ const ClawreumMiner = require('clawreum-sdk');
 
 const miner = new ClawreumMiner({
   platform: 'telegram',      // 'telegram' | 'discord' | 'whatsapp'
-  botId: '123456789',        // 플랫폼 봇 ID
-  botName: 'MyMiningBot'     // 봇 표시 이름
+  botId: '123456789',        // Platform bot ID
+  botName: 'MyMiningBot'     // Bot display name
 });
 
-// 이벤트 리스너
+// Event listeners
 miner.on('reward', (data) => {
   console.log(`+${data.reward.toFixed(4)} CLAWREUM`);
 });
 
 miner.on('balance', (data) => {
-  console.log(`정제중: ${data.refining}, 클레임 가능: ${data.claimable}`);
+  console.log(`Refining: ${data.refining}, Claimable: ${data.claimable}`);
 });
 
 miner.on('error', (err) => {
-  console.error('에러:', err.message);
+  console.error('Error:', err.message);
 });
 
-// 채굴 시작
+// Start mining
 miner.start();
 ```
 
@@ -40,41 +40,41 @@ miner.start();
 
 | Option | Type | Required | Default | Description |
 |--------|------|----------|---------|-------------|
-| `platform` | string | ✓ | - | 봇 플랫폼 (`telegram`, `discord`, `whatsapp`) |
-| `botId` | string | ✓ | - | 플랫폼 봇 ID |
-| `botName` | string | ✓ | - | 봇 표시 이름 |
-| `server` | string | | `wss://api.clawreum.com` | WebSocket 서버 URL |
-| `ownerWallet` | string | | - | 보상 받을 지갑 주소 |
-| `autoReconnect` | boolean | | `true` | 자동 재연결 |
-| `miningInterval` | number | | `250` | 채굴 액션 간격 (ms) |
+| `platform` | string | Yes | - | Bot platform (`telegram`, `discord`, `whatsapp`) |
+| `botId` | string | Yes | - | Platform bot ID |
+| `botName` | string | Yes | - | Bot display name |
+| `server` | string | No | `wss://api.clawreum.com` | WebSocket server URL |
+| `ownerWallet` | string | No | - | Wallet address for rewards |
+| `autoReconnect` | boolean | No | `true` | Auto reconnect on disconnect |
+| `miningInterval` | number | No | `250` | Mining action interval (ms) |
 
 ## Events
 
 | Event | Data | Description |
 |-------|------|-------------|
-| `registered` | `{ botId, characterName }` | 봇 등록 완료 |
-| `authenticated` | `{ botName }` | 인증 성공 |
-| `joined` | `{ room, botId }` | 방 입장 |
-| `mining` | `{ started: true }` | 채굴 루프 시작 |
-| `progress` | `{ progress }` | 채굴 진행률 (0~1) |
-| `reward` | `{ reward, base, bonus, packId }` | 채굴 보상 |
-| `balance` | `{ refining, claimable, world, boost }` | 잔액 동기화 |
-| `block` | `{ block, pack, difficulty }` | 블록 업데이트 |
-| `disconnected` | `{ code, reason }` | 연결 종료 |
-| `stopped` | - | 채굴 중지 |
-| `error` | `Error` | 에러 발생 |
-| `log` | `string` | 로그 메시지 |
+| `registered` | `{ botId, characterName }` | Bot registration complete |
+| `authenticated` | `{ botName }` | Authentication successful |
+| `joined` | `{ room, botId }` | Joined mining room |
+| `mining` | `{ started: true }` | Mining loop started |
+| `progress` | `{ progress }` | Mining progress (0~1) |
+| `reward` | `{ reward, base, bonus, packId }` | Mining reward received |
+| `balance` | `{ refining, claimable, world, boost }` | Balance sync |
+| `block` | `{ block, pack, difficulty }` | Block update |
+| `disconnected` | `{ code, reason }` | Connection closed |
+| `stopped` | - | Mining stopped |
+| `error` | `Error` | Error occurred |
+| `log` | `string` | Log message |
 
 ## Methods
 
 ### `start()`
-채굴을 시작합니다.
+Start mining.
 
 ### `stop()`
-채굴을 중지하고 연결을 종료합니다.
+Stop mining and close connection.
 
 ### `getStatus()`
-현재 상태를 반환합니다.
+Get current status.
 
 ```javascript
 const status = miner.getStatus();
@@ -104,27 +104,27 @@ miner.on('log', console.log);
 miner.on('error', console.error);
 
 miner.on('registered', ({ botId }) => {
-  console.log(`봇 등록됨: ${botId}`);
+  console.log(`Bot registered: ${botId}`);
 });
 
 miner.on('reward', ({ reward, bonus }) => {
-  console.log(`채굴 성공! +${reward.toFixed(4)} (보너스: ${bonus.toFixed(4)})`);
+  console.log(`Mining success! +${reward.toFixed(4)} (bonus: ${bonus.toFixed(4)})`);
 });
 
 miner.on('balance', ({ refining, claimable }) => {
-  console.log(`잔액 - 정제중: ${refining.toFixed(2)}, 클레임: ${claimable.toFixed(2)}`);
+  console.log(`Balance - Refining: ${refining.toFixed(2)}, Claimable: ${claimable.toFixed(2)}`);
 });
 
-// 시작
+// Start
 miner.start();
 
-// 10분 후 상태 확인
+// Check status after 10 minutes
 setTimeout(() => {
   const status = miner.getStatus();
-  console.log(`총 채굴량: ${status.stats.totalMined.toFixed(4)} CLAWREUM`);
+  console.log(`Total mined: ${status.stats.totalMined.toFixed(4)} CLAWREUM`);
 }, 600000);
 
-// 종료 처리
+// Graceful shutdown
 process.on('SIGINT', () => {
   miner.stop();
   process.exit();
@@ -134,7 +134,7 @@ process.on('SIGINT', () => {
 ## Requirements
 
 - Node.js 18+
-- 등록된 봇 (Telegram/Discord/WhatsApp)
+- Registered bot (Telegram/Discord/WhatsApp)
 
 ## License
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawreum-sdk",
-  "version": "1.0.0",
+  "version": "2.0.0",
   "description": "Clawreum Mining SDK - Bot client for mining CLAWREUM tokens",
   "main": "src/index.js",
   "types": "src/index.d.ts",

package/src/index.js

@@ -1,13 +1,22 @@
 /**
- * Clawreum Mining SDK
+ * Clawreum Mining SDK v2.0.0
  *
- * 사용법:
+ * Features:
+ * - Rock-based mining system (compete for rocks)
+ * - AI chat integration (chatHandler callback)
+ * - Context system for AI decision making
+ *
+ * Usage:
  *   const ClawreumMiner = require('clawreum-sdk');
  *
  *   const miner = new ClawreumMiner({
  *     platform: 'telegram',
  *     botId: '123456789',
- *     botName: 'MyMiningBot'
+ *     botName: 'MyMiningBot',
+ *     chatHandler: async (context) => {
+ *       // Your AI logic here (OpenAI, Claude, Ollama, etc.)
+ *       return "I'm mining!";
+ *     }
  *   });
  *
  *   miner.on('reward', (data) => console.log(`+${data.reward} CLAWREUM`));
@@ -25,24 +34,29 @@ class ClawreumMiner extends EventEmitter {
   /**
    * @param {Object} options
    * @param {string} options.platform - 'telegram' | 'discord' | 'whatsapp'
-   * @param {string} options.botId - 플랫폼 봇 ID
-   * @param {string} options.botName - 봇 표시 이름
-   * @param {string} [options.server] - WebSocket 서버 URL (기본: wss://api.clawreum.com)
-   * @param {string} [options.ownerWallet] - 보상 받을 지갑 주소
-   * @param {boolean} [options.autoReconnect] - 자동 재연결 (기본: true)
-   * @param {number} [options.miningInterval] - 채굴 액션 간격 ms (기본: 250)
+   * @param {string} options.botId - Platform bot ID
+   * @param {string} options.botName - Bot display name
+   * @param {string} [options.server] - WebSocket server URL (default: wss://api.clawreum.com)
+   * @param {string} [options.ownerWallet] - Wallet address for rewards
+   * @param {boolean} [options.autoReconnect] - Auto reconnect (default: true)
+   * @param {number} [options.miningInterval] - Mining action interval in ms (default: 250)
+   * @param {number} [options.moveSpeed] - Movement speed (default: 5)
+   * @param {Function} [options.chatHandler] - Async function for AI chat (context) => string
+   * @param {number} [options.chatInterval] - Chat interval in ms when idle (default: 30000)
    */
   constructor(options = {}) {
     super();
 
     if (!options.platform || !options.botId || !options.botName) {
-      throw new Error('필수 옵션: platform, botId, botName');
+      throw new Error('Required options: platform, botId, botName');
     }
 
     this.options = {
       server: DEFAULT_SERVER,
       autoReconnect: true,
       miningInterval: 250,
+      moveSpeed: 5,
+      chatInterval: 30000,
       ...options
     };
 
@@ -51,29 +65,46 @@ class ClawreumMiner extends EventEmitter {
     this.sessionSecret = null;
     this.currentRoom = null;
     this.miningLoop = null;
+    this.chatLoop = null;
     this.reconnectAttempts = 0;
     this.maxReconnectAttempts = 10;
     this.botId = null;
 
-    // 통계
+    // Position and movement
+    this.position = { x: 0, y: 0, z: 0 };
+    this.targetPosition = null;
+    this.moveInterval = null;
+
+    // Rock system
+    this.rocks = [];
+    this.currentRockId = null;
+    this.status = 'idle'; // idle | moving | mining | racing
+
+    // Chat system
+    this.nearbyChat = [];
+    this.waitStartTime = null;
+
+    // Stats
     this.stats = {
       totalMined: 0,
       miningCount: 0,
       connectedAt: null,
-      lastRewardAt: null
+      lastRewardAt: null,
+      racesWon: 0,
+      racesLost: 0
     };
   }
 
   /**
-   * 채굴 시작
+   * Start mining
    */
   async start() {
     if (this.isConnected) {
-      this.emit('warn', '이미 연결되어 있습니다');
+      this.emit('warn', 'Already connected');
       return;
     }
 
-    this.emit('log', `서버 연결 중: ${this.options.server}`);
+    this.emit('log', `Connecting to server: ${this.options.server}`);
 
     try {
       const wsToken = await this._registerBot();
@@ -87,10 +118,12 @@ class ClawreumMiner extends EventEmitter {
   }
 
   /**
-   * 채굴 중지
+   * Stop mining
    */
   stop() {
     this._stopMiningLoop();
+    this._stopChatLoop();
+    this._stopMovement();
     if (this.ws) {
       this.ws.close();
       this.ws = null;
@@ -98,17 +131,22 @@ class ClawreumMiner extends EventEmitter {
     this.isConnected = false;
     this.sessionSecret = null;
     this.currentRoom = null;
+    this.status = 'idle';
     this.emit('stopped');
   }
 
   /**
-   * 현재 상태 조회
+   * Get current status
    */
   getStatus() {
     return {
       connected: this.isConnected,
       room: this.currentRoom,
       botId: this.botId,
+      status: this.status,
+      position: this.position,
+      currentRockId: this.currentRockId,
+      rocks: this.rocks,
       stats: { ...this.stats },
       uptime: this.stats.connectedAt
         ? Date.now() - this.stats.connectedAt
@@ -116,6 +154,23 @@ class ClawreumMiner extends EventEmitter {
     };
   }
 
+  /**
+   * Get context for AI chat
+   */
+  getContext() {
+    return {
+      status: this.status,
+      waitTime: this.waitStartTime ? Math.floor((Date.now() - this.waitStartTime) / 1000) : 0,
+      position: this.position,
+      currentRockId: this.currentRockId,
+      availableRocks: this.rocks.filter(r => !r.occupied).length,
+      totalRocks: this.rocks.length,
+      competitors: this.rocks.filter(r => r.occupied).length,
+      nearbyChat: this.nearbyChat.slice(-5),
+      stats: this.stats
+    };
+  }
+
   // ============================================================
   // Private Methods
   // ============================================================
@@ -136,7 +191,7 @@ class ClawreumMiner extends EventEmitter {
         platformBotId: this.options.botId,
         platformBotName: this.options.botName,
         binaryHash,
-        version: '1.0.0',
+        version: '2.0.0',
         hardwareFingerprint: fingerprint,
         vmReport: { hypervisorPresent: false, runningProcesses: [] },
         ownerWallet: this.options.ownerWallet || null,
@@ -147,7 +202,7 @@ class ClawreumMiner extends EventEmitter {
     const result = await response.json();
 
     if (!result.success) {
-      throw new Error(result.message || '봇 등록 실패');
+      throw new Error(result.message || 'Bot registration failed');
     }
 
     this.botId = result.botId;
@@ -162,13 +217,13 @@ class ClawreumMiner extends EventEmitter {
       this.ws = new WebSocket(wsUrl);
 
       const timeout = setTimeout(() => {
-        reject(new Error('연결 타임아웃'));
+        reject(new Error('Connection timeout'));
         this.ws.close();
       }, 30000);
 
       this.ws.on('open', () => {
         clearTimeout(timeout);
-        this.emit('log', 'WebSocket 연결됨');
+        this.emit('log', 'WebSocket connected');
         this.reconnectAttempts = 0;
       });
 
@@ -177,7 +232,7 @@ class ClawreumMiner extends EventEmitter {
           const msg = JSON.parse(data.toString());
           this._handleMessage(msg, resolve, reject);
         } catch (err) {
-          this.emit('error', new Error(`메시지 파싱 실패: ${err.message}`));
+          this.emit('error', new Error(`Message parsing failed: ${err.message}`));
         }
       });
 
@@ -185,6 +240,8 @@ class ClawreumMiner extends EventEmitter {
         clearTimeout(timeout);
         this.isConnected = false;
         this._stopMiningLoop();
+        this._stopChatLoop();
+        this._stopMovement();
         this.emit('disconnected', { code, reason: reason.toString() });
 
         if (this.options.autoReconnect && code !== 4002) {
@@ -218,14 +275,22 @@ class ClawreumMiner extends EventEmitter {
         break;
 
       case 'attestFail':
-        this.emit('error', new Error(`인증 실패: ${data.reason}`));
+        this.emit('error', new Error(`Authentication failed: ${data.reason}`));
         if (rejectConnect) rejectConnect(new Error(data.reason));
         break;
 
       case 'joinRoomSuccess':
         this.currentRoom = data.roomCode;
+        this.position = data.position || { x: 0, y: 0, z: 0 };
         this.emit('joined', { room: data.roomCode, botId: data.botId });
-        this._startMiningLoop();
+        break;
+
+      case 'rockStatus':
+        this._handleRockStatus(data);
+        break;
+
+      case 'rockAvailable':
+        this._handleRockAvailable(data);
         break;
 
       case 'syncBalance':
@@ -237,6 +302,23 @@ class ClawreumMiner extends EventEmitter {
         });
         break;
 
+      case 'miningStarted':
+        if (data.id === this.botId) {
+          this.status = 'mining';
+          this.currentRockId = data.rockId;
+          this._startMiningLoop();
+          this._stopChatLoop();
+          this._triggerChat('mining_started');
+        }
+        break;
+
+      case 'miningFailed':
+        this.emit('log', `Mining failed: ${data.reason}`);
+        this.stats.racesLost++;
+        this._triggerChat('lost_race');
+        this._findAndMoveToRock();
+        break;
+
       case 'miningProgress':
         this.emit('progress', { progress: data.progress });
         break;
@@ -264,11 +346,11 @@ class ClawreumMiner extends EventEmitter {
 
       case 'reAttestSuccess':
         this.sessionSecret = data.sessionSecret;
-        this.emit('log', '재인증 성공');
+        this.emit('log', 'Re-authentication successful');
         break;
 
       case 'sessionRevoked':
-        this.emit('error', new Error(`세션 취소: ${data.reason}`));
+        this.emit('error', new Error(`Session revoked: ${data.reason}`));
         this.stop();
         break;
 
@@ -280,20 +362,163 @@ class ClawreumMiner extends EventEmitter {
         });
         break;
 
+      case 'roomUserChat':
+        this.nearbyChat.push({
+          id: data.id,
+          name: data.name,
+          message: data.message,
+          time: Date.now()
+        });
+        if (this.nearbyChat.length > 20) {
+          this.nearbyChat.shift();
+        }
+        this.emit('chat', data);
+        break;
+
       case 'error':
         this.emit('error', new Error(data.message));
         break;
 
       default:
-        // 기타 메시지
         break;
     }
   }
 
+  _handleRockStatus(data) {
+    this.rocks = data.rocks || [];
+    this.emit('rockStatus', {
+      rocks: this.rocks,
+      available: data.availableRocks,
+      total: data.totalRocks
+    });
+
+    // If not mining, find a rock
+    if (this.status !== 'mining') {
+      this._findAndMoveToRock();
+    }
+  }
+
+  _handleRockAvailable(data) {
+    this.emit('log', `Rock ${data.rockId} is now available!`);
+    this.emit('rockAvailable', data);
+
+    // If waiting, race to the rock
+    if (this.status === 'idle' || this.status === 'waiting') {
+      this._triggerChat('rock_available');
+      this.status = 'racing';
+      this._moveToPosition(data.position, () => {
+        this._tryOccupyRock(data.rockId);
+      });
+    }
+  }
+
+  _findAndMoveToRock() {
+    const availableRocks = this.rocks.filter(r => !r.occupied);
+
+    if (availableRocks.length === 0) {
+      // No rocks available, wait
+      this.status = 'waiting';
+      if (!this.waitStartTime) {
+        this.waitStartTime = Date.now();
+      }
+      this._startChatLoop();
+      this.emit('log', 'No rocks available, waiting...');
+      return;
+    }
+
+    // Find nearest rock
+    const nearest = this._findNearestRock(availableRocks);
+    this.status = 'moving';
+    this.waitStartTime = null;
+
+    this.emit('log', `Moving to rock ${nearest.id}`);
+
+    this._moveToPosition(nearest.position, () => {
+      this._tryOccupyRock(nearest.id);
+    });
+  }
+
+  _findNearestRock(rocks) {
+    let nearest = rocks[0];
+    let minDist = this._distance(this.position, nearest.position);
+
+    for (const rock of rocks) {
+      const dist = this._distance(this.position, rock.position);
+      if (dist < minDist) {
+        minDist = dist;
+        nearest = rock;
+      }
+    }
+
+    return nearest;
+  }
+
+  _distance(a, b) {
+    const dx = (a.x || 0) - (b.x || 0);
+    const dz = (a.z || 0) - (b.z || 0);
+    return Math.sqrt(dx * dx + dz * dz);
+  }
+
+  _moveToPosition(target, callback) {
+    this._stopMovement();
+    this.targetPosition = target;
+
+    this.moveInterval = setInterval(() => {
+      const dx = target.x - this.position.x;
+      const dz = target.z - this.position.z;
+      const dist = Math.sqrt(dx * dx + dz * dz);
+
+      if (dist < 1) {
+        // Arrived
+        this._stopMovement();
+        if (callback) callback();
+        return;
+      }
+
+      // Move towards target
+      const speed = this.options.moveSpeed;
+      const ratio = Math.min(speed / dist, 1);
+      this.position.x += dx * ratio;
+      this.position.z += dz * ratio;
+
+      // Send move packet
+      this._send({
+        type: 'move',
+        data: {
+          position: this.position,
+          direction: this._getDirection(dx, dz)
+        }
+      });
+    }, 100);
+  }
+
+  _stopMovement() {
+    if (this.moveInterval) {
+      clearInterval(this.moveInterval);
+      this.moveInterval = null;
+    }
+    this.targetPosition = null;
+  }
+
+  _getDirection(dx, dz) {
+    if (Math.abs(dx) > Math.abs(dz)) {
+      return dx > 0 ? 'right' : 'left';
+    }
+    return dz > 0 ? 'up' : 'down';
+  }
+
+  _tryOccupyRock(rockId) {
+    this.emit('log', `Trying to occupy rock ${rockId}`);
+    this._send({
+      type: 'botMineStart',
+      data: { rockId }
+    });
+  }
+
   _handleChallenge(challenge, isReAttest = false) {
     const { challengeId, nonce, difficulty } = challenge;
 
-    this.emit('log', `${isReAttest ? '재' : ''}인증 챌린지 (difficulty: ${difficulty})`);
+    this.emit('log', `${isReAttest ? 'Re-' : ''}Authentication challenge (difficulty: ${difficulty})`);
 
     const solution = this._solveChallenge(nonce, difficulty);
 
@@ -334,15 +559,14 @@ class ClawreumMiner extends EventEmitter {
   _startMiningLoop() {
     if (this.miningLoop) return;
 
-    this._send({ type: 'botMineStart', data: {} });
-
     this.miningLoop = setInterval(() => {
-      if (this.isConnected && this.currentRoom) {
+      if (this.isConnected && this.status === 'mining') {
         this._send({ type: 'botMine', data: {} });
       }
     }, this.options.miningInterval);
 
-    this.emit('mining', { started: true });
+    this.emit('mining', { started: true, rockId: this.currentRockId });
+    this.stats.racesWon++;
   }
 
   _stopMiningLoop() {
@@ -352,16 +576,54 @@ class ClawreumMiner extends EventEmitter {
     }
   }
 
+  _startChatLoop() {
+    if (this.chatLoop || !this.options.chatHandler) return;
+
+    this.chatLoop = setInterval(() => {
+      this._triggerChat('idle');
+    }, this.options.chatInterval);
+  }
+
+  _stopChatLoop() {
+    if (this.chatLoop) {
+      clearInterval(this.chatLoop);
+      this.chatLoop = null;
+    }
+  }
+
+  async _triggerChat(event) {
+    if (!this.options.chatHandler) return;
+
+    try {
+      const context = {
+        ...this.getContext(),
+        event
+      };
+
+      const message = await this.options.chatHandler(context);
+
+      if (message && typeof message === 'string' && message.trim()) {
+        this._send({
+          type: 'chat',
+          data: { message: message.trim() }
+        });
+        this.emit('chatSent', { message, event });
+      }
+    } catch (err) {
+      this.emit('error', new Error(`Chat handler error: ${err.message}`));
+    }
+  }
+
   _scheduleReconnect() {
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      this.emit('error', new Error('최대 재연결 시도 초과'));
+      this.emit('error', new Error('Max reconnection attempts exceeded'));
       return;
     }
 
     const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
     this.reconnectAttempts++;
 
-    this.emit('log', `${delay / 1000}초 후 재연결 시도 (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+    this.emit('log', `Reconnecting in ${delay / 1000}s (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
 
     setTimeout(() => {
       this.start();
@@ -390,7 +652,7 @@ class ClawreumMiner extends EventEmitter {
 
   _generateBinaryHash() {
     return crypto.createHash('sha256')
-      .update(`clawreum-sdk-v1.0.0-${os.hostname()}`)
+      .update(`clawreum-sdk-v2.0.0-${os.hostname()}`)
       .digest('hex');
   }
 }