@rougechain/sdk 0.5.0 → 0.7.0

package/README.md

@@ -14,7 +14,7 @@
 <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>
 
@@ -55,6 +55,7 @@ const { balance } = await rc.getBalance(wallet.publicKey);
 | **Wallet** | — | ML-DSA-65 keypair generation, import/export, client-side signing |
 | **Transfers** | `rc` | Send XRGE or custom tokens, burn tokens |
 | **Token Creation** | `rc` | Launch new tokens with on-chain logo support |
+| **Token Allowances** | `rc` | ERC-20 style approve/transferFrom for DeFi composability |
 | **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 |
@@ -64,14 +65,18 @@ const { balance } = await rc.getBalance(wallet.publicKey);
 | **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);
 
@@ -80,6 +85,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
@@ -428,7 +438,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

@@ -101,6 +101,23 @@ function createSignedTokenMetadataClaim(wallet, tokenSymbol) {
     token_symbol: tokenSymbol
   });
 }
+function createSignedTokenApproval(wallet, spender, tokenSymbol, amount) {
+  return buildAndSign(wallet, {
+    type: "approve",
+    spender,
+    token_symbol: tokenSymbol,
+    amount
+  });
+}
+function createSignedTokenTransferFrom(wallet, owner, to, tokenSymbol, amount) {
+  return buildAndSign(wallet, {
+    type: "transfer_from",
+    owner,
+    to,
+    token_symbol: tokenSymbol,
+    amount
+  });
+}
 function createSignedSwap(wallet, tokenIn, tokenOut, amountIn, minAmountOut) {
   return buildAndSign(wallet, {
     type: "swap",
@@ -1056,6 +1073,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;
@@ -1084,6 +1225,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.
    */
@@ -1101,6 +1249,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;
@@ -1108,13 +1257,18 @@ exports.createShieldedNote = createShieldedNote;
 exports.createSignedBridgeWithdraw = createSignedBridgeWithdraw;
 exports.createSignedShield = createSignedShield;
 exports.createSignedShieldedTransfer = createSignedShieldedTransfer;
+exports.createSignedTokenApproval = createSignedTokenApproval;
 exports.createSignedTokenMetadataClaim = createSignedTokenMetadataClaim;
 exports.createSignedTokenMetadataUpdate = createSignedTokenMetadataUpdate;
+exports.createSignedTokenTransferFrom = createSignedTokenTransferFrom;
 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;