@rougechain/sdk 0.3.7 → 0.4.1

package/README.md

@@ -8,7 +8,7 @@
 
 <p align="center">
   <strong>Build quantum-safe dApps on RougeChain</strong><br />
-  Transfers · DEX · NFTs · Bridge · Mail · Messenger
+  Transfers · DEX · NFTs · Shielded Transactions · Bridge · Mail · Messenger
 </p>
 
 <p align="center">
@@ -58,7 +58,8 @@ const { balance } = await rc.getBalance(wallet.publicKey);
 | **Staking** | `rc` | Stake/unstake XRGE for validation |
 | **DEX** | `rc.dex` | AMM pools, swaps with slippage protection, liquidity |
 | **NFTs** | `rc.nft` | RC-721 collections, mint, batch mint, royalties, freeze |
-| **Bridge** | `rc.bridge` | ETH ↔ qETH, USDC ↔ qUSDC, XRGE bridge (Base Sepolia) |
+| **Shielded** | `rc.shielded` | Private transfers with zk-STARK proofs, shield/unshield XRGE |
+| **Bridge** | `rc.bridge` | ETH ↔ qETH, USDC ↔ qUSDC, XRGE bridge (Base Sepolia) |\r
 | **Mail** | `rc.mail` | On-chain encrypted email (`@rouge.quant`) |
 | **Messenger** | `rc.messenger` | E2E encrypted messaging with self-destruct |
 
@@ -306,6 +307,45 @@ const messages = await rc.messenger.getMessages(conversationId);
 await rc.messenger.deleteMessage(messageId);
 ```
 
+## Shielded Transactions (`rc.shielded`)
+
+Private value transfers using zk-STARK proofs. Shield XRGE into private notes, transfer privately, and unshield back to public balance.
+
+```typescript
+import { createShieldedNote, computeCommitment, computeNullifier } from "@rougechain/sdk";
+
+// Shield 100 XRGE into a private note
+const { note } = await rc.shielded.shield(wallet, { amount: 100 });
+// ⚠️ Save `note` securely — losing it means losing the funds!
+// note = { commitment, nullifier, value, randomness, ownerPubKey }
+
+// Check pool stats
+const stats = await rc.shielded.getStats();
+// { commitment_count, nullifier_count, active_notes }
+
+// Check if a nullifier has been spent
+const { spent } = await rc.shielded.isNullifierSpent(note.nullifier);
+
+// Private transfer (requires STARK proof from Rust prover)
+await rc.shielded.transfer(wallet, {
+  nullifiers: [note.nullifier],
+  outputCommitments: [recipientCommitment],
+  proof: starkProofHex,
+});
+
+// Unshield back to public balance
+await rc.shielded.unshield(wallet, {
+  nullifiers: [note.nullifier],
+  amount: 100,
+  proof: starkProofHex,
+});
+
+// Client-side crypto primitives
+const randomness = generateRandomness();
+const commitment = computeCommitment(100, wallet.publicKey, randomness);
+const nullifier = computeNullifier(randomness, commitment);
+```
+
 ## Low-Level Signing
 
 For advanced use cases:
@@ -347,6 +387,8 @@ import type {
   NftToken, LiquidityPool, BalanceResponse, Validator,
   BridgeConfig, MailMessage, MessengerMessage, WalletKeys,
   PriceSnapshot, PoolEvent, PoolStats, SwapQuote,
+  ShieldParams, ShieldedTransferParams, UnshieldParams, ShieldedStats,
+  ShieldedNote,
 } from "@rougechain/sdk";
 ```
 
@@ -360,7 +402,7 @@ import type {
 
 - [Website](https://rougechain.io)
 - [Documentation](https://docs.rougechain.io)
-- [Chrome Extension](https://chromewebstore.google.com/detail/rougechain-wallet)
+- [Chrome Extension](https://chromewebstore.google.com/detail/rougechain-wallet/ilkbgjgphhaolfdjkfefdfiifipmhakj)
 - [GitHub](https://github.com/cyberdreadx/quantum-vault)
 
 ## License

package/dist/index.cjs

@@ -1,6 +1,7 @@
 'use strict';
 
 var mlDsa_js = require('@noble/post-quantum/ml-dsa.js');
+var sha2 = require('@noble/hashes/sha2');
 
 // src/signer.ts
 
@@ -228,6 +229,88 @@ function createSignedNftFreezeCollection(wallet, collectionId, frozen) {
     fee: 0.1
   });
 }
+function createSignedShield(wallet, amount, commitment) {
+  return buildAndSign(wallet, {
+    type: "shield",
+    amount,
+    commitment
+  });
+}
+function createSignedShieldedTransfer(wallet, nullifiers, outputCommitments, proof, shieldedFee) {
+  return buildAndSign(wallet, {
+    type: "shielded_transfer",
+    nullifiers,
+    output_commitments: outputCommitments,
+    proof,
+    fee: shieldedFee ?? 0
+  });
+}
+function createSignedUnshield(wallet, nullifiers, amount, proof) {
+  return buildAndSign(wallet, {
+    type: "unshield",
+    nullifiers,
+    amount,
+    proof
+  });
+}
+var COMMITMENT_DOMAIN = new TextEncoder().encode("ROUGECHAIN_COMMITMENT_V1");
+var NULLIFIER_DOMAIN = new TextEncoder().encode("ROUGECHAIN_NULLIFIER_V1");
+function generateRandomness() {
+  const buf = new Uint8Array(32);
+  crypto.getRandomValues(buf);
+  return bytesToHex(buf);
+}
+function u64ToBytes(value) {
+  const buf = new Uint8Array(8);
+  const view = new DataView(buf.buffer);
+  view.setBigUint64(0, BigInt(value), false);
+  return buf;
+}
+function hexToU8(hex) {
+  const clean = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const bytes = new Uint8Array(clean.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(clean.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+function computeCommitment(value, ownerPubKey, randomness) {
+  const valueBytes = u64ToBytes(value);
+  const pubkeyBytes = hexToU8(ownerPubKey);
+  const randBytes = hexToU8(randomness);
+  const input = new Uint8Array(
+    COMMITMENT_DOMAIN.length + valueBytes.length + pubkeyBytes.length + randBytes.length
+  );
+  let offset = 0;
+  input.set(COMMITMENT_DOMAIN, offset);
+  offset += COMMITMENT_DOMAIN.length;
+  input.set(valueBytes, offset);
+  offset += valueBytes.length;
+  input.set(pubkeyBytes, offset);
+  offset += pubkeyBytes.length;
+  input.set(randBytes, offset);
+  return bytesToHex(sha2.sha256(input));
+}
+function computeNullifier(randomness, commitment) {
+  const randBytes = hexToU8(randomness);
+  const commitBytes = hexToU8(commitment);
+  const input = new Uint8Array(
+    NULLIFIER_DOMAIN.length + randBytes.length + commitBytes.length
+  );
+  let offset = 0;
+  input.set(NULLIFIER_DOMAIN, offset);
+  offset += NULLIFIER_DOMAIN.length;
+  input.set(randBytes, offset);
+  offset += randBytes.length;
+  input.set(commitBytes, offset);
+  return bytesToHex(sha2.sha256(input));
+}
+function createShieldedNote(value, ownerPubKey) {
+  const randomness = generateRandomness();
+  const commitment = computeCommitment(value, ownerPubKey, randomness);
+  const nullifier = computeNullifier(randomness, commitment);
+  return { commitment, nullifier, value, randomness, ownerPubKey };
+}
 
 // src/client.ts
 var RougeChain = class {
@@ -243,6 +326,7 @@ var RougeChain = class {
     this.bridge = new BridgeClient(this);
     this.mail = new MailClient(this);
     this.messenger = new MessengerClient(this);
+    this.shielded = new ShieldedClient(this);
   }
   // ===== Internal helpers =====
   /** @internal */
@@ -898,6 +982,63 @@ var MessengerClient = class {
     }
   }
 };
+var ShieldedClient = class {
+  constructor(rc) {
+    this.rc = rc;
+  }
+  // Queries
+  async getStats() {
+    return this.rc.get("/shielded/stats");
+  }
+  async isNullifierSpent(nullifierHex) {
+    return this.rc.get(
+      `/shielded/nullifier/${encodeURIComponent(nullifierHex)}`
+    );
+  }
+  // Write operations
+  /**
+   * Shield public XRGE into a private note.
+   * Creates the commitment client-side, submits to the chain.
+   *
+   * @returns The ShieldedNote (keep this locally — it's the only way to spend the note)
+   */
+  async shield(wallet, params) {
+    const note = createShieldedNote(params.amount, wallet.publicKey);
+    const tx = createSignedShield(wallet, params.amount, note.commitment);
+    const result = await this.rc.submitTx("/v2/shielded/shield", tx);
+    if (result.success) {
+      return { ...result, note };
+    }
+    return result;
+  }
+  /**
+   * Transfer between shielded notes (private → private).
+   * Requires a pre-generated STARK proof.
+   */
+  async transfer(wallet, params) {
+    const tx = createSignedShieldedTransfer(
+      wallet,
+      params.nullifiers,
+      params.outputCommitments,
+      params.proof,
+      params.shieldedFee
+    );
+    return this.rc.submitTx("/v2/shielded/transfer", tx);
+  }
+  /**
+   * Unshield a private note back to public XRGE.
+   * Requires a STARK proof of note ownership.
+   */
+  async unshield(wallet, params) {
+    const tx = createSignedUnshield(
+      wallet,
+      params.nullifiers,
+      params.amount,
+      params.proof
+    );
+    return this.rc.submitTx("/v2/shielded/unshield", tx);
+  }
+};
 var Wallet = class _Wallet {
   constructor(publicKey, privateKey) {
     this.publicKey = publicKey;
@@ -944,10 +1085,17 @@ exports.BURN_ADDRESS = BURN_ADDRESS;
 exports.RougeChain = RougeChain;
 exports.Wallet = Wallet;
 exports.bytesToHex = bytesToHex;
+exports.computeCommitment = computeCommitment;
+exports.computeNullifier = computeNullifier;
+exports.createShieldedNote = createShieldedNote;
 exports.createSignedBridgeWithdraw = createSignedBridgeWithdraw;
+exports.createSignedShield = createSignedShield;
+exports.createSignedShieldedTransfer = createSignedShieldedTransfer;
 exports.createSignedTokenMetadataClaim = createSignedTokenMetadataClaim;
 exports.createSignedTokenMetadataUpdate = createSignedTokenMetadataUpdate;
+exports.createSignedUnshield = createSignedUnshield;
 exports.generateNonce = generateNonce;
+exports.generateRandomness = generateRandomness;
 exports.hexToBytes = hexToBytes;
 exports.isBurnAddress = isBurnAddress;
 exports.serializePayload = serializePayload;