@rougechain/sdk 0.8.2 → 0.8.4

package/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   <strong>Build quantum-safe dApps on RougeChain</strong><br />
-  Transfers · DEX · NFTs · Shielded Transactions · Bridge · Rollups · Mail · Messenger
+  Transfers · DEX · NFTs · Shielded Transactions · Bridge · Rollups · Dynamic Fees · Finality Proofs · WebSocket · Mail · Messenger
 </p>
 
 <p align="center">
@@ -64,6 +64,13 @@ const { balance } = await rc.getBalance(wallet.publicKey);
 | **Rollup** | `rc` | zk-STARK batch proofs, rollup status, submit transfers |
 | **Mail** | `rc.mail` | On-chain encrypted email (`@rouge.quant`) |
 | **Messenger** | `rc.messenger` | E2E encrypted messaging with self-destruct |
+| **Address Resolution** | `rc` | O(1) rouge1↔pubkey resolution via on-chain index |
+| **Push Notifications** | `rc` | PQC-signed push token registration (Expo) |
+| **Token Freeze** | `rc` | Creator-only token freeze/pause |
+| **Mintable Tokens** | `rc` | Ongoing token minting with supply cap enforcement |
+| **Dynamic Fees** | `rc` | EIP-1559 base fee, priority tips, fee burning |
+| **Finality Proofs** | `rc` | BFT finality certificates with ≥2/3 validator stake |
+| **WebSocket** | `rc` | Real-time event streaming with topic subscriptions |
 
 ## Wallet & Addresses
 
@@ -119,6 +126,56 @@ await rc.updateTokenMetadata(wallet, {
 
 // Burn tokens
 await rc.burn(wallet, 500);
+
+// Create a mintable token with supply cap
+await rc.createToken(wallet, {
+  name: "Inflation Token",
+  symbol: "INFT",
+  totalSupply: 100_000,
+  mintable: true,
+  maxSupply: 1_000_000,
+});
+
+// Mint additional tokens (creator only)
+await rc.mintTokens(wallet, { symbol: "INFT", amount: 50_000 });
+```
+
+## Dynamic Fees (EIP-1559)
+
+```typescript
+// Get current fee info — base fee adjusts per block
+const fee = await rc.getFeeInfo();
+console.log(`Base fee: ${fee.base_fee} XRGE`);
+console.log(`Suggested total: ${fee.total_fee_suggestion} XRGE`);
+console.log(`Total burned: ${fee.total_fees_burned} XRGE`);
+```
+
+## Finality Proofs
+
+```typescript
+// Get a BFT finality proof for a block height
+const { proof } = await rc.getFinalityProof(42);
+if (proof) {
+  console.log(`Block ${proof.height} finalized with ${proof.voting_stake}/${proof.total_stake} stake`);
+  console.log(`${proof.precommit_votes.length} precommit signatures`);
+}
+```
+
+## WebSocket Subscriptions
+
+```typescript
+// Subscribe to specific topics for real-time events
+const ws = rc.connectWebSocket(["blocks", `account:${wallet.publicKey}`]);
+
+ws.onmessage = (event) => {
+  const data = JSON.parse(event.data);
+  if (data.type === "new_block") {
+    console.log(`New block #${data.height}`);
+  }
+};
+
+// Available topics: "blocks", "transactions", "stats",
+// "account:<pubkey>", "token:<symbol>"
 ```
 
 ## DEX (`rc.dex`)
@@ -280,7 +337,37 @@ const batch = await rc.getRollupBatch(1);
 
 ## Mail (`rc.mail`)
 
-On-chain encrypted email with `@rouge.quant` addresses.
+On-chain encrypted email with `@rouge.quant` / `@qwalla.mail` addresses.
+
+### Name Registry
+
+Register a mail name so other users can send you encrypted email. Third-party apps (QWALLA, qRougee, etc.) should call these on wallet creation.
+
+```typescript
+// Step 1: Register wallet on the node (required for encryption keys)
+await rc.messenger.registerWallet({
+  id: wallet.publicKey,
+  displayName: "Alice",
+  signingPublicKey: wallet.publicKey,
+  encryptionPublicKey: encPubKey,
+});
+
+// Step 2: Register a mail name
+await rc.mail.registerName("alice", wallet.publicKey);
+
+// Resolve a name → wallet info (includes encryption key)
+const resolved = await rc.mail.resolveName("alice");
+// { entry: { name, wallet_id }, wallet: { id, signing_public_key, encryption_public_key } }
+
+// Reverse lookup: wallet ID → name
+const name = await rc.mail.reverseLookup(wallet.publicKey);
+// "alice"
+
+// Release a name
+await rc.mail.releaseName("alice", wallet.publicKey);
+```
+
+### Sending & Reading Mail
 
 ```typescript
 // Send an encrypted email
@@ -402,6 +489,39 @@ const signedTx = signTransaction(payload, wallet.privateKey, wallet.publicKey);
 const valid = verifyTransaction(signedTx); // true
 ```
 
+## Address Resolution
+
+Resolve between compact `rouge1…` addresses and full hex public keys using the on-chain persistent index.
+
+```typescript
+// rouge1… → public key
+const { publicKey } = await rc.resolveAddress("rouge1q8f3x7k2m4...");
+
+// public key → rouge1…
+const { address } = await rc.resolveAddress(hexPubKey);
+
+// Both return: { success, address, publicKey, balance }
+```
+
+## Push Notifications
+
+Register Expo push tokens for real-time notifications. Requires PQC signature — only the wallet owner can register.
+
+```typescript
+// Register (wallet signs the request with ML-DSA-65)
+await rc.registerPushToken(wallet, expoPushToken);
+
+// Unregister
+await rc.unregisterPushToken(wallet);
+```
+
+## Nonce Management
+
+```typescript
+// Get sequential nonce for an account
+const { nonce, next_nonce } = await rc.getNonce(wallet.publicKey);
+```
+
 ## Environment Support
 
 | Environment | Notes |
@@ -424,6 +544,7 @@ import type {
   ShieldParams, ShieldedTransferParams, UnshieldParams, ShieldedStats,
   ShieldedNote,
   RollupStatus, RollupBatchResult, RollupSubmitParams, RollupSubmitResult,
+  FeeInfo, FinalityProof, MintTokenParams, VoteMessage, WsSubscribeMessage,
 } from "@rougechain/sdk";
 ```
 

package/dist/index.cjs

@@ -468,6 +468,19 @@ var RougeChain = class {
   async getFinality() {
     return this.get("/finality");
   }
+  // ===== EIP-1559 Fee Info =====
+  /** Get current EIP-1559 fee information including base fee and suggestions. */
+  async getFeeInfo() {
+    return this.get("/fee");
+  }
+  // ===== BFT Finality Proofs =====
+  /**
+   * Get a BFT finality proof for a specific block height.
+   * Returns the aggregated precommit votes that prove ≥2/3 validator stake agreed.
+   */
+  async getFinalityProof(height) {
+    return this.get(`/finality/${height}`);
+  }
   // ===== Peers =====
   async getPeers() {
     const data = await this.get("/peers");
@@ -553,6 +566,39 @@ var RougeChain = class {
     const tx = createSignedTokenMetadataClaim(wallet, tokenSymbol);
     return this.submitTx("/v2/token/metadata/claim", tx);
   }
+  /**
+   * Mint additional tokens for a mintable token (creator only).
+   * The token must have been created with `mintable: true`.
+   */
+  async mintTokens(wallet, params) {
+    return this.post("/v2/token/mint", {
+      public_key: wallet.publicKey,
+      symbol: params.symbol,
+      amount: params.amount,
+      fee: params.fee ?? 1,
+      signature: ""
+      // Will be signed server-side via PQC verification
+    });
+  }
+  // ===== WebSocket =====
+  /**
+   * Connect to the node's WebSocket and optionally subscribe to specific topics.
+   * Topics: "blocks", "transactions", "stats", "account:<pubkey>", "token:<symbol>"
+   *
+   * @example
+   * const ws = client.connectWebSocket(["blocks", "account:abc123"]);
+   * ws.onmessage = (e) => console.log(JSON.parse(e.data));
+   */
+  connectWebSocket(topics) {
+    const wsUrl = this.baseUrl.replace(/^http/, "ws") + "/ws";
+    const ws = new WebSocket(wsUrl);
+    if (topics && topics.length > 0) {
+      ws.addEventListener("open", () => {
+        ws.send(JSON.stringify({ subscribe: topics }));
+      });
+    }
+    return ws;
+  }
   // ===== Rollup =====
   /** Get the current rollup accumulator status. */
   async getRollupStatus() {
@@ -913,6 +959,56 @@ var MailClient = class {
   constructor(rc) {
     this.rc = rc;
   }
+  // --- Name Registry ---
+  async registerName(name, walletId) {
+    try {
+      const data = await this.rc.post("/names/register", {
+        name,
+        walletId
+      });
+      return { success: data.success === true, error: data.error, data };
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  async resolveName(name) {
+    try {
+      const data = await this.rc.get(
+        `/names/resolve/${encodeURIComponent(name.toLowerCase())}`
+      );
+      if (!data.success) return null;
+      return { entry: data.entry, wallet: data.wallet };
+    } catch {
+      return null;
+    }
+  }
+  async reverseLookup(walletId) {
+    try {
+      const data = await this.rc.get(
+        `/names/reverse/${encodeURIComponent(walletId)}`
+      );
+      return data.name || null;
+    } catch {
+      return null;
+    }
+  }
+  async releaseName(name, walletId) {
+    try {
+      const res = await this.rc.fetchFn(
+        `${this.rc.baseUrl}/names/release`,
+        {
+          method: "DELETE",
+          headers: { ...this.rc.headers, "Content-Type": "application/json" },
+          body: JSON.stringify({ name, walletId })
+        }
+      );
+      const data = await res.json();
+      return { success: data.success === true, error: data.error };
+    } catch (e) {
+      return { success: false, error: e instanceof Error ? e.message : String(e) };
+    }
+  }
+  // --- Mail ---
   async send(params) {
     try {
       const data = await this.rc.post("/mail/send", params);
@@ -1017,16 +1113,17 @@ var MessengerClient = class {
     );
     return data.messages ?? [];
   }
-  async sendMessage(conversationId, sender, encryptedContent, opts = {}) {
+  async sendMessage(conversationId, senderWalletId, encryptedContent, opts = {}) {
     try {
       const data = await this.rc.post("/messenger/messages", {
-        conversation_id: conversationId,
-        sender,
-        encrypted_content: encryptedContent,
-        media_type: opts.mediaType,
-        media_data: opts.mediaData,
-        self_destruct: opts.selfDestruct,
-        destruct_after_seconds: opts.destructAfterSeconds
+        conversationId,
+        senderWalletId,
+        encryptedContent,
+        signature: opts.signature ?? "",
+        messageType: opts.messageType ?? "text",
+        selfDestruct: opts.selfDestruct ?? false,
+        destructAfterSeconds: opts.destructAfterSeconds,
+        spoiler: opts.spoiler ?? false
       });
       return { success: data.success === true, error: data.error, data };
     } catch (e) {
@@ -1048,7 +1145,7 @@ var MessengerClient = class {
   async markRead(messageId) {
     try {
       const data = await this.rc.post("/messenger/messages/read", {
-        message_id: messageId
+        messageId
       });
       return { success: data.success === true, error: data.error };
     } catch (e) {
@@ -1112,6 +1209,33 @@ var ShieldedClient = class {
     );
     return this.rc.submitTx("/v2/shielded/unshield", tx);
   }
+  // ─── WASM Smart Contracts ──────────────────────────────────────────
+  /** Deploy a WASM smart contract */
+  async deployContract(params) {
+    return this.rc.post("/v2/contract/deploy", params);
+  }
+  /** Call a WASM smart contract method (mutating) */
+  async callContract(params) {
+    return this.rc.post("/v2/contract/call", params);
+  }
+  /** Get contract metadata */
+  async getContract(addr) {
+    return this.rc.get(`/contract/${addr}`);
+  }
+  /** Read contract storage. Omit key for full state dump. */
+  async getContractState(addr, key) {
+    const q = key ? `?key=${encodeURIComponent(key)}` : "";
+    return this.rc.get(`/contract/${addr}/state${q}`);
+  }
+  /** Get contract events */
+  async getContractEvents(addr, limit) {
+    const q = limit ? `?limit=${limit}` : "";
+    return this.rc.get(`/contract/${addr}/events${q}`);
+  }
+  /** List all deployed contracts */
+  async listContracts() {
+    return this.rc.get("/contracts");
+  }
 };
 
 // src/address.ts
@@ -1268,9 +1392,9 @@ var Wallet = class _Wallet {
   /**
    * Generate a new ML-DSA-65 keypair with a BIP-39 mnemonic.
    * The mnemonic is stored on the wallet for backup/recovery.
-   * @param strength 128 = 12 words (default), 256 = 24 words
+   * @param strength 256 = 24 words (default, post-quantum safe), 128 = 12 words
    */
-  static generate(strength = 128) {
+  static generate(strength = 256) {
     const mnemonic = generateMnemonic(strength);
     const { publicKey, secretKey } = keypairFromMnemonic(mnemonic);
     return new _Wallet(publicKey, secretKey, mnemonic);