@rougechain/sdk 0.4.1 → 0.6.0

package/README.md

@@ -8,13 +8,13 @@
 
 <p align="center">
   <strong>Build quantum-safe dApps on RougeChain</strong><br />
-  Transfers · DEX · NFTs · Shielded Transactions · Bridge · Mail · Messenger
+  Transfers · DEX · NFTs · Shielded Transactions · Bridge · Rollups · Mail · Messenger
 </p>
 
 <p align="center">
   <a href="https://www.npmjs.com/package/@rougechain/sdk"><img src="https://img.shields.io/npm/v/@rougechain/sdk?color=00d2be&label=npm" alt="npm version" /></a>
   <a href="https://www.npmjs.com/package/@rougechain/sdk"><img src="https://img.shields.io/npm/dm/@rougechain/sdk?color=00d2be" alt="npm downloads" /></a>
-  <a href="https://github.com/cyberdreadx/quantum-vault/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license" /></a>
+  <a href="https://github.com/cyberdreadx/rougechain-node/blob/main/LICENSE"><img src="https://img.shields.io/badge/license-MIT-blue" alt="MIT license" /></a>
   <a href="https://docs.rougechain.io"><img src="https://img.shields.io/badge/docs-rougechain-00d2be" alt="docs" /></a>
 </p>
 
@@ -59,18 +59,23 @@ const { balance } = await rc.getBalance(wallet.publicKey);
 | **DEX** | `rc.dex` | AMM pools, swaps with slippage protection, liquidity |
 | **NFTs** | `rc.nft` | RC-721 collections, mint, batch mint, royalties, freeze |
 | **Shielded** | `rc.shielded` | Private transfers with zk-STARK proofs, shield/unshield XRGE |
-| **Bridge** | `rc.bridge` | ETH ↔ qETH, USDC ↔ qUSDC, XRGE bridge (Base Sepolia) |\r
+| **Bridge** | `rc.bridge` | ETH ↔ qETH, USDC ↔ qUSDC, XRGE bridge (Base Mainnet/Sepolia) |
+| **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 |
 
-## Wallet
+## Wallet & Addresses
 
 ```typescript
-import { Wallet } from "@rougechain/sdk";
+import { Wallet, pubkeyToAddress, isRougeAddress, formatAddress } from "@rougechain/sdk";
 
 // Generate a new post-quantum keypair
 const wallet = Wallet.generate();
 
+// Get the compact rouge1... address (~63 chars vs 3904-char hex pubkey)
+const address = await wallet.address();
+// "rouge1q8f3x7k2m4n9p..."
+
 // Restore from saved keys
 const restored = Wallet.fromKeys(publicKey, privateKey);
 
@@ -79,6 +84,11 @@ const keys = wallet.toJSON(); // { publicKey, privateKey }
 
 // Verify keypair integrity
 wallet.verify(); // true
+
+// Address utilities
+const addr = await pubkeyToAddress(someHexPubKey);
+const display = formatAddress(addr); // "rouge1q8f3x7...k9m2"
+isRougeAddress("rouge1q8f3x7k2m4..."); // true
 ```
 
 ## Transfers & Tokens
@@ -244,6 +254,29 @@ await rc.bridge.withdrawXrge(wallet, {
 });
 ```
 
+## Rollup (zk-STARK Batch Proofs)
+
+Submit transfers to the rollup accumulator for batched STARK proving. Transfers are collected into batches of up to 32 and proven with a single zk-STARK proof.
+
+```typescript
+// Check rollup status
+const status = await rc.getRollupStatus();
+// { pending_transfers, completed_batches, current_state_root, ... }
+
+// Submit a transfer to the rollup batch
+const result = await rc.submitRollupTransfer({
+  sender: wallet.publicKey,
+  receiver: recipientPubKey,
+  amount: 100,
+  fee: 1,
+});
+// result.queued = true (waiting for batch) or result.batch_completed = true
+
+// Get a completed batch result
+const batch = await rc.getRollupBatch(1);
+// { batch_id, transfer_count, proof_size_bytes, proof_time_ms, verified, ... }
+```
+
 ## Mail (`rc.mail`)
 
 On-chain encrypted email with `@rouge.quant` addresses.
@@ -389,6 +422,7 @@ import type {
   PriceSnapshot, PoolEvent, PoolStats, SwapQuote,
   ShieldParams, ShieldedTransferParams, UnshieldParams, ShieldedStats,
   ShieldedNote,
+  RollupStatus, RollupBatchResult, RollupSubmitParams, RollupSubmitResult,
 } from "@rougechain/sdk";
 ```
 
@@ -403,7 +437,7 @@ import type {
 - [Website](https://rougechain.io)
 - [Documentation](https://docs.rougechain.io)
 - [Chrome Extension](https://chromewebstore.google.com/detail/rougechain-wallet/ilkbgjgphhaolfdjkfefdfiifipmhakj)
-- [GitHub](https://github.com/cyberdreadx/quantum-vault)
+- [GitHub](https://github.com/cyberdreadx/rougechain-node)
 
 ## License
 

package/dist/index.cjs

@@ -496,6 +496,23 @@ var RougeChain = class {
     const tx = createSignedTokenMetadataClaim(wallet, tokenSymbol);
     return this.submitTx("/v2/token/metadata/claim", tx);
   }
+  // ===== Rollup =====
+  /** Get the current rollup accumulator status. */
+  async getRollupStatus() {
+    const data = await this.get("/v2/rollup/status");
+    return data.rollup;
+  }
+  /** Submit a transfer into the rollup batch accumulator. */
+  async submitRollupTransfer(params) {
+    return this.post("/v2/rollup/submit", params);
+  }
+  /** Get the result of a completed rollup batch by ID. */
+  async getRollupBatch(batchId) {
+    const data = await this.get(
+      `/v2/rollup/batch/${batchId}`
+    );
+    return data.batch;
+  }
 };
 var NftClient = class {
   constructor(rc) {
@@ -1039,6 +1056,130 @@ var ShieldedClient = class {
     return this.rc.submitTx("/v2/shielded/unshield", tx);
   }
 };
+
+// src/address.ts
+var CHARSET = "qpzry9x8gf2tvdw0s3jn54khce6mua7l";
+var BECH32M_CONST = 734539939;
+var HRP = "rouge";
+function hrpExpand(hrp) {
+  const ret = [];
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) >> 5);
+  ret.push(0);
+  for (let i = 0; i < hrp.length; i++) ret.push(hrp.charCodeAt(i) & 31);
+  return ret;
+}
+function polymod(values) {
+  const GEN = [996825010, 642813549, 513874426, 1027748829, 705979059];
+  let chk = 1;
+  for (const v of values) {
+    const b = chk >> 25;
+    chk = (chk & 33554431) << 5 ^ v;
+    for (let i = 0; i < 5; i++) {
+      if (b >> i & 1) chk ^= GEN[i];
+    }
+  }
+  return chk;
+}
+function createChecksum(hrp, data) {
+  const values = hrpExpand(hrp).concat(data).concat([0, 0, 0, 0, 0, 0]);
+  const pm = polymod(values) ^ BECH32M_CONST;
+  const ret = [];
+  for (let i = 0; i < 6; i++) ret.push(pm >> 5 * (5 - i) & 31);
+  return ret;
+}
+function verifyChecksum(hrp, data) {
+  return polymod(hrpExpand(hrp).concat(data)) === BECH32M_CONST;
+}
+function convertBits(data, fromBits, toBits, pad) {
+  let acc = 0;
+  let bits = 0;
+  const ret = [];
+  const maxv = (1 << toBits) - 1;
+  for (const value of data) {
+    acc = acc << fromBits | value;
+    bits += fromBits;
+    while (bits >= toBits) {
+      bits -= toBits;
+      ret.push(acc >> bits & maxv);
+    }
+  }
+  {
+    if (bits > 0) ret.push(acc << toBits - bits & maxv);
+  }
+  return ret;
+}
+function bech32mEncode(hrp, data) {
+  const data5bit = convertBits(data, 8, 5);
+  const checksum = createChecksum(hrp, data5bit);
+  const combined = data5bit.concat(checksum);
+  let result = hrp + "1";
+  for (const d of combined) result += CHARSET[d];
+  return result;
+}
+function bech32mDecode(str) {
+  const lower = str.toLowerCase();
+  const pos = lower.lastIndexOf("1");
+  if (pos < 1 || pos + 7 > lower.length) throw new Error("Invalid bech32m string");
+  const hrp = lower.slice(0, pos);
+  const data5bit = [];
+  for (let i = pos + 1; i < lower.length; i++) {
+    const d = CHARSET.indexOf(lower[i]);
+    if (d === -1) throw new Error(`Invalid character: ${lower[i]}`);
+    data5bit.push(d);
+  }
+  if (!verifyChecksum(hrp, data5bit)) throw new Error("Invalid bech32m checksum");
+  const payload = data5bit.slice(0, data5bit.length - 6);
+  const ret = [];
+  let acc = 0, bits = 0;
+  for (const value of payload) {
+    acc = acc << 5 | value;
+    bits += 5;
+    while (bits >= 8) {
+      bits -= 8;
+      ret.push(acc >> bits & 255);
+    }
+  }
+  return { hrp, data: new Uint8Array(ret) };
+}
+function hexToBytes2(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < hex.length; i += 2) {
+    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
+  }
+  return bytes;
+}
+function bytesToHex2(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function sha2562(data) {
+  const buf = data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+  const hash = await crypto.subtle.digest("SHA-256", buf);
+  return new Uint8Array(hash);
+}
+async function pubkeyToAddress(publicKeyHex) {
+  const pkBytes = hexToBytes2(publicKeyHex);
+  const hash = await sha2562(pkBytes);
+  return bech32mEncode(HRP, hash);
+}
+function addressToHash(address) {
+  const { data } = bech32mDecode(address);
+  return bytesToHex2(data);
+}
+function isRougeAddress(input) {
+  if (!input.toLowerCase().startsWith("rouge1") || input.length < 10) return false;
+  try {
+    bech32mDecode(input);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatAddress(address, prefixLen = 12, suffixLen = 4) {
+  if (address.length <= prefixLen + suffixLen + 3) return address;
+  return `${address.slice(0, prefixLen)}...${address.slice(-suffixLen)}`;
+}
+
+// src/wallet.ts
 var Wallet = class _Wallet {
   constructor(publicKey, privateKey) {
     this.publicKey = publicKey;
@@ -1067,6 +1208,13 @@ var Wallet = class _Wallet {
   toJSON() {
     return { publicKey: this.publicKey, privateKey: this.privateKey };
   }
+  /**
+   * Derive the compact Bech32m address from the public key.
+   * Returns a ~63-character `rouge1...` string.
+   */
+  async address() {
+    return pubkeyToAddress(this.publicKey);
+  }
   /**
    * Verify that the keypair is valid by signing and verifying a test message.
    */
@@ -1084,6 +1232,7 @@ var Wallet = class _Wallet {
 exports.BURN_ADDRESS = BURN_ADDRESS;
 exports.RougeChain = RougeChain;
 exports.Wallet = Wallet;
+exports.addressToHash = addressToHash;
 exports.bytesToHex = bytesToHex;
 exports.computeCommitment = computeCommitment;
 exports.computeNullifier = computeNullifier;
@@ -1094,10 +1243,13 @@ exports.createSignedShieldedTransfer = createSignedShieldedTransfer;
 exports.createSignedTokenMetadataClaim = createSignedTokenMetadataClaim;
 exports.createSignedTokenMetadataUpdate = createSignedTokenMetadataUpdate;
 exports.createSignedUnshield = createSignedUnshield;
+exports.formatAddress = formatAddress;
 exports.generateNonce = generateNonce;
 exports.generateRandomness = generateRandomness;
 exports.hexToBytes = hexToBytes;
 exports.isBurnAddress = isBurnAddress;
+exports.isRougeAddress = isRougeAddress;
+exports.pubkeyToAddress = pubkeyToAddress;
 exports.serializePayload = serializePayload;
 exports.signTransaction = signTransaction;
 exports.verifyTransaction = verifyTransaction;