clawreum-sdk 1.0.0

package/README.md

@@ -0,0 +1,141 @@
+# clawreum-sdk
+
+Clawreum Mining SDK - Node.js client for mining CLAWREUM tokens.
+
+## Installation
+
+```bash
+npm install clawreum-sdk
+```
+
+## Quick Start
+
+```javascript
+const ClawreumMiner = require('clawreum-sdk');
+
+const miner = new ClawreumMiner({
+  platform: 'telegram',      // 'telegram' | 'discord' | 'whatsapp'
+  botId: '123456789',        // 플랫폼 봇 ID
+  botName: 'MyMiningBot'     // 봇 표시 이름
+});
+
+// 이벤트 리스너
+miner.on('reward', (data) => {
+  console.log(`+${data.reward.toFixed(4)} CLAWREUM`);
+});
+
+miner.on('balance', (data) => {
+  console.log(`정제중: ${data.refining}, 클레임 가능: ${data.claimable}`);
+});
+
+miner.on('error', (err) => {
+  console.error('에러:', err.message);
+});
+
+// 채굴 시작
+miner.start();
+```
+
+## Options
+
+| 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) |
+
+## 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` | 로그 메시지 |
+
+## Methods
+
+### `start()`
+채굴을 시작합니다.
+
+### `stop()`
+채굴을 중지하고 연결을 종료합니다.
+
+### `getStatus()`
+현재 상태를 반환합니다.
+
+```javascript
+const status = miner.getStatus();
+// {
+//   connected: true,
+//   room: 'server1',
+//   botId: 'tg_123456789',
+//   stats: { totalMined: 150.5, miningCount: 12, ... },
+//   uptime: 3600000
+// }
+```
+
+## Example: Full Usage
+
+```javascript
+const ClawreumMiner = require('clawreum-sdk');
+
+const miner = new ClawreumMiner({
+  platform: 'telegram',
+  botId: process.env.BOT_ID,
+  botName: process.env.BOT_NAME,
+  ownerWallet: '0x...',
+  autoReconnect: true
+});
+
+miner.on('log', console.log);
+miner.on('error', console.error);
+
+miner.on('registered', ({ botId }) => {
+  console.log(`봇 등록됨: ${botId}`);
+});
+
+miner.on('reward', ({ reward, bonus }) => {
+  console.log(`채굴 성공! +${reward.toFixed(4)} (보너스: ${bonus.toFixed(4)})`);
+});
+
+miner.on('balance', ({ refining, claimable }) => {
+  console.log(`잔액 - 정제중: ${refining.toFixed(2)}, 클레임: ${claimable.toFixed(2)}`);
+});
+
+// 시작
+miner.start();
+
+// 10분 후 상태 확인
+setTimeout(() => {
+  const status = miner.getStatus();
+  console.log(`총 채굴량: ${status.stats.totalMined.toFixed(4)} CLAWREUM`);
+}, 600000);
+
+// 종료 처리
+process.on('SIGINT', () => {
+  miner.stop();
+  process.exit();
+});
+```
+
+## Requirements
+
+- Node.js 18+
+- 등록된 봇 (Telegram/Discord/WhatsApp)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "clawreum-sdk",
+  "version": "1.0.0",
+  "description": "Clawreum Mining SDK - Bot client for mining CLAWREUM tokens",
+  "main": "src/index.js",
+  "types": "src/index.d.ts",
+  "keywords": [
+    "clawreum",
+    "mining",
+    "blockchain",
+    "bsc",
+    "crypto",
+    "bot",
+    "sdk"
+  ],
+  "author": "Clawreum Team",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/clawreum/clawreum-sdk"
+  },
+  "homepage": "https://clawreum.com",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "dependencies": {
+    "ws": "^8.16.0"
+  },
+  "scripts": {
+    "test": "node test/test.js"
+  }
+}

package/src/index.js

@@ -0,0 +1,398 @@
+/**
+ * Clawreum Mining SDK
+ *
+ * 사용법:
+ *   const ClawreumMiner = require('clawreum-sdk');
+ *
+ *   const miner = new ClawreumMiner({
+ *     platform: 'telegram',
+ *     botId: '123456789',
+ *     botName: 'MyMiningBot'
+ *   });
+ *
+ *   miner.on('reward', (data) => console.log(`+${data.reward} CLAWREUM`));
+ *   miner.start();
+ */
+
+const WebSocket = require('ws');
+const crypto = require('crypto');
+const os = require('os');
+const { EventEmitter } = require('events');
+
+const DEFAULT_SERVER = 'wss://api.clawreum.com';
+
+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)
+   */
+  constructor(options = {}) {
+    super();
+
+    if (!options.platform || !options.botId || !options.botName) {
+      throw new Error('필수 옵션: platform, botId, botName');
+    }
+
+    this.options = {
+      server: DEFAULT_SERVER,
+      autoReconnect: true,
+      miningInterval: 250,
+      ...options
+    };
+
+    this.ws = null;
+    this.isConnected = false;
+    this.sessionSecret = null;
+    this.currentRoom = null;
+    this.miningLoop = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 10;
+    this.botId = null;
+
+    // 통계
+    this.stats = {
+      totalMined: 0,
+      miningCount: 0,
+      connectedAt: null,
+      lastRewardAt: null
+    };
+  }
+
+  /**
+   * 채굴 시작
+   */
+  async start() {
+    if (this.isConnected) {
+      this.emit('warn', '이미 연결되어 있습니다');
+      return;
+    }
+
+    this.emit('log', `서버 연결 중: ${this.options.server}`);
+
+    try {
+      const wsToken = await this._registerBot();
+      await this._connect(wsToken);
+    } catch (err) {
+      this.emit('error', err);
+      if (this.options.autoReconnect) {
+        this._scheduleReconnect();
+      }
+    }
+  }
+
+  /**
+   * 채굴 중지
+   */
+  stop() {
+    this._stopMiningLoop();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.isConnected = false;
+    this.sessionSecret = null;
+    this.currentRoom = null;
+    this.emit('stopped');
+  }
+
+  /**
+   * 현재 상태 조회
+   */
+  getStatus() {
+    return {
+      connected: this.isConnected,
+      room: this.currentRoom,
+      botId: this.botId,
+      stats: { ...this.stats },
+      uptime: this.stats.connectedAt
+        ? Date.now() - this.stats.connectedAt
+        : 0
+    };
+  }
+
+  // ============================================================
+  // Private Methods
+  // ============================================================
+
+  async _registerBot() {
+    const fingerprint = this._generateFingerprint();
+    const binaryHash = this._generateBinaryHash();
+
+    const apiUrl = this.options.server
+      .replace('wss://', 'https://')
+      .replace('ws://', 'http://');
+
+    const response = await fetch(`${apiUrl}/api/bot/register`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        platform: this.options.platform,
+        platformBotId: this.options.botId,
+        platformBotName: this.options.botName,
+        binaryHash,
+        version: '1.0.0',
+        hardwareFingerprint: fingerprint,
+        vmReport: { hypervisorPresent: false, runningProcesses: [] },
+        ownerWallet: this.options.ownerWallet || null,
+        snsVerification: { verified: true }
+      })
+    });
+
+    const result = await response.json();
+
+    if (!result.success) {
+      throw new Error(result.message || '봇 등록 실패');
+    }
+
+    this.botId = result.botId;
+    this.emit('registered', { botId: result.botId, characterName: result.characterName });
+
+    return result.wsToken;
+  }
+
+  async _connect(wsToken) {
+    return new Promise((resolve, reject) => {
+      const wsUrl = `${this.options.server}?token=${wsToken}`;
+      this.ws = new WebSocket(wsUrl);
+
+      const timeout = setTimeout(() => {
+        reject(new Error('연결 타임아웃'));
+        this.ws.close();
+      }, 30000);
+
+      this.ws.on('open', () => {
+        clearTimeout(timeout);
+        this.emit('log', 'WebSocket 연결됨');
+        this.reconnectAttempts = 0;
+      });
+
+      this.ws.on('message', (data) => {
+        try {
+          const msg = JSON.parse(data.toString());
+          this._handleMessage(msg, resolve, reject);
+        } catch (err) {
+          this.emit('error', new Error(`메시지 파싱 실패: ${err.message}`));
+        }
+      });
+
+      this.ws.on('close', (code, reason) => {
+        clearTimeout(timeout);
+        this.isConnected = false;
+        this._stopMiningLoop();
+        this.emit('disconnected', { code, reason: reason.toString() });
+
+        if (this.options.autoReconnect && code !== 4002) {
+          this._scheduleReconnect();
+        }
+      });
+
+      this.ws.on('error', (err) => {
+        clearTimeout(timeout);
+        this.emit('error', err);
+        reject(err);
+      });
+    });
+  }
+
+  _handleMessage(msg, resolveConnect, rejectConnect) {
+    const { type, data } = msg;
+
+    switch (type) {
+      case 'attestChallenge':
+        this._handleChallenge(data);
+        break;
+
+      case 'attestSuccess':
+        this.sessionSecret = data.sessionSecret;
+        this.isConnected = true;
+        this.stats.connectedAt = Date.now();
+        this.emit('authenticated', { botName: data.botDisplayName });
+        this._joinRoom();
+        if (resolveConnect) resolveConnect();
+        break;
+
+      case 'attestFail':
+        this.emit('error', new Error(`인증 실패: ${data.reason}`));
+        if (rejectConnect) rejectConnect(new Error(data.reason));
+        break;
+
+      case 'joinRoomSuccess':
+        this.currentRoom = data.roomCode;
+        this.emit('joined', { room: data.roomCode, botId: data.botId });
+        this._startMiningLoop();
+        break;
+
+      case 'syncBalance':
+        this.emit('balance', {
+          refining: data.refiningAmount,
+          claimable: data.cleanedAmount,
+          world: data.worldAmount,
+          boost: data.social_boost
+        });
+        break;
+
+      case 'miningProgress':
+        this.emit('progress', { progress: data.progress });
+        break;
+
+      case 'miningSuccess':
+        this.stats.totalMined += data.reward || 0;
+        this.stats.miningCount++;
+        this.stats.lastRewardAt = Date.now();
+        this.emit('reward', {
+          reward: data.reward,
+          base: data.baseReward,
+          bonus: data.bonusReward,
+          packId: data.packId,
+          totalInPack: data.totalInPack
+        });
+        break;
+
+      case 'adenaReward':
+        this.emit('effect', { base: data.base, bonus: data.bonus, level: data.level });
+        break;
+
+      case 'reAttestChallenge':
+        this._handleChallenge(data, true);
+        break;
+
+      case 'reAttestSuccess':
+        this.sessionSecret = data.sessionSecret;
+        this.emit('log', '재인증 성공');
+        break;
+
+      case 'sessionRevoked':
+        this.emit('error', new Error(`세션 취소: ${data.reason}`));
+        this.stop();
+        break;
+
+      case 'blockUpdate':
+        this.emit('block', {
+          block: data.block,
+          pack: data.pack,
+          difficulty: data.diff
+        });
+        break;
+
+      case 'error':
+        this.emit('error', new Error(data.message));
+        break;
+
+      default:
+        // 기타 메시지
+        break;
+    }
+  }
+
+  _handleChallenge(challenge, isReAttest = false) {
+    const { challengeId, nonce, difficulty } = challenge;
+
+    this.emit('log', `${isReAttest ? '재' : ''}인증 챌린지 (difficulty: ${difficulty})`);
+
+    const solution = this._solveChallenge(nonce, difficulty);
+
+    this._send({
+      type: isReAttest ? 'botReAttest' : 'botAttest',
+      data: {
+        challengeId,
+        solution,
+        sessionSecret: isReAttest ? this.sessionSecret : undefined
+      }
+    });
+  }
+
+  _solveChallenge(nonce, difficulty) {
+    const target = '0'.repeat(difficulty);
+    let counter = 0;
+
+    while (counter < 100000000) {
+      const attempt = `${nonce}:${counter}`;
+      const hash = crypto.createHash('sha256').update(attempt).digest('hex');
+
+      if (hash.startsWith(target)) {
+        return counter.toString();
+      }
+      counter++;
+    }
+
+    throw new Error('Challenge solving timeout');
+  }
+
+  _joinRoom(roomCode = 'server1') {
+    this._send({
+      type: 'botJoinRoom',
+      data: { roomCode }
+    });
+  }
+
+  _startMiningLoop() {
+    if (this.miningLoop) return;
+
+    this._send({ type: 'botMineStart', data: {} });
+
+    this.miningLoop = setInterval(() => {
+      if (this.isConnected && this.currentRoom) {
+        this._send({ type: 'botMine', data: {} });
+      }
+    }, this.options.miningInterval);
+
+    this.emit('mining', { started: true });
+  }
+
+  _stopMiningLoop() {
+    if (this.miningLoop) {
+      clearInterval(this.miningLoop);
+      this.miningLoop = null;
+    }
+  }
+
+  _scheduleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.emit('error', new Error('최대 재연결 시도 초과'));
+      return;
+    }
+
+    const delay = Math.min(1000 * Math.pow(2, this.reconnectAttempts), 30000);
+    this.reconnectAttempts++;
+
+    this.emit('log', `${delay / 1000}초 후 재연결 시도 (${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+
+    setTimeout(() => {
+      this.start();
+    }, delay);
+  }
+
+  _send(msg) {
+    if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(msg));
+    }
+  }
+
+  _generateFingerprint() {
+    return {
+      cpuId: os.cpus()[0]?.model || 'unknown',
+      hostname: os.hostname(),
+      platform: os.platform(),
+      arch: os.arch(),
+      macAddresses: Object.values(os.networkInterfaces())
+        .flat()
+        .filter(i => i && !i.internal && i.mac !== '00:00:00:00:00:00')
+        .map(i => i.mac)
+        .slice(0, 3)
+    };
+  }
+
+  _generateBinaryHash() {
+    return crypto.createHash('sha256')
+      .update(`clawreum-sdk-v1.0.0-${os.hostname()}`)
+      .digest('hex');
+  }
+}
+
+module.exports = ClawreumMiner;