@rougechain/sdk 0.6.0 → 0.8.0

package/README.md

@@ -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 |

package/dist/index.cjs

@@ -2,6 +2,10 @@
 
 var mlDsa_js = require('@noble/post-quantum/ml-dsa.js');
 var sha2 = require('@noble/hashes/sha2');
+var bip39 = require('@scure/bip39');
+var english_js = require('@scure/bip39/wordlists/english.js');
+var hkdf_js = require('@noble/hashes/hkdf.js');
+var sha2_js = require('@noble/hashes/sha2.js');
 
 // src/signer.ts
 
@@ -101,6 +105,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",
@@ -444,6 +465,19 @@ var RougeChain = class {
   async getBurnedTokens() {
     return this.get("/burned");
   }
+  // ===== Address Resolution =====
+  /**
+   * Resolve a rouge1… address to its public key, or a public key to its rouge1 address.
+   * Uses the persistent on-chain address index for O(1) lookups.
+   */
+  async resolveAddress(input) {
+    return this.get(`/resolve/${encodeURIComponent(input)}`);
+  }
+  // ===== Nonce =====
+  /** Get the current sequential nonce for an account. */
+  async getNonce(publicKey) {
+    return this.get(`/account/${encodeURIComponent(publicKey)}/nonce`);
+  }
   // ===== Write operations =====
   async transfer(wallet, params) {
     const tx = createSignedTransfer(
@@ -1178,24 +1212,69 @@ function formatAddress(address, prefixLen = 12, suffixLen = 4) {
   if (address.length <= prefixLen + suffixLen + 3) return address;
   return `${address.slice(0, prefixLen)}...${address.slice(-suffixLen)}`;
 }
+var DOMAIN_INFO = new TextEncoder().encode("rougechain-ml-dsa-65-v1");
+function generateMnemonic(strength = 256) {
+  return bip39.generateMnemonic(english_js.wordlist, strength);
+}
+function validateMnemonic(mnemonic) {
+  return bip39.validateMnemonic(mnemonic, english_js.wordlist);
+}
+function mnemonicToMLDSASeed(mnemonic, passphrase) {
+  const bip39Seed = bip39.mnemonicToSeedSync(mnemonic, passphrase);
+  return hkdf_js.hkdf(sha2_js.sha256, bip39Seed, void 0, DOMAIN_INFO, 32);
+}
+function keypairFromMnemonic(mnemonic, passphrase) {
+  if (!validateMnemonic(mnemonic)) {
+    throw new Error("Invalid mnemonic phrase");
+  }
+  const seed = mnemonicToMLDSASeed(mnemonic, passphrase);
+  const keypair = mlDsa_js.ml_dsa65.keygen(seed);
+  return {
+    publicKey: bytesToHex(keypair.publicKey),
+    secretKey: bytesToHex(keypair.secretKey)
+  };
+}
 
 // src/wallet.ts
 var Wallet = class _Wallet {
-  constructor(publicKey, privateKey) {
+  constructor(publicKey, privateKey, mnemonic) {
     this.publicKey = publicKey;
     this.privateKey = privateKey;
+    this.mnemonic = mnemonic;
   }
   /**
-   * Generate a new ML-DSA-65 keypair.
-   * Uses crypto.getRandomValues for secure randomness.
+   * 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
    */
-  static generate() {
+  static generate(strength = 128) {
+    const mnemonic = generateMnemonic(strength);
+    const { publicKey, secretKey } = keypairFromMnemonic(mnemonic);
+    return new _Wallet(publicKey, secretKey, mnemonic);
+  }
+  /**
+   * Generate a wallet using pure random entropy (no mnemonic).
+   * Keys cannot be recovered from a seed phrase.
+   */
+  static generateRandom() {
     const keypair = mlDsa_js.ml_dsa65.keygen();
     return new _Wallet(
       bytesToHex(keypair.publicKey),
       bytesToHex(keypair.secretKey)
     );
   }
+  /**
+   * Restore a wallet from a BIP-39 mnemonic seed phrase.
+   * @param mnemonic 12 or 24 word BIP-39 mnemonic
+   * @param passphrase Optional BIP-39 passphrase (25th word)
+   */
+  static fromMnemonic(mnemonic, passphrase) {
+    if (!validateMnemonic(mnemonic)) {
+      throw new Error("Invalid mnemonic phrase");
+    }
+    const { publicKey, secretKey } = keypairFromMnemonic(mnemonic, passphrase);
+    return new _Wallet(publicKey, secretKey, mnemonic);
+  }
   /**
    * Restore a wallet from existing hex-encoded keys.
    */
@@ -1206,7 +1285,11 @@ var Wallet = class _Wallet {
    * Export keys as a plain object (for serialization/storage).
    */
   toJSON() {
-    return { publicKey: this.publicKey, privateKey: this.privateKey };
+    return {
+      publicKey: this.publicKey,
+      privateKey: this.privateKey,
+      ...this.mnemonic ? { mnemonic: this.mnemonic } : {}
+    };
   }
   /**
    * Derive the compact Bech32m address from the public key.
@@ -1240,18 +1323,24 @@ 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.generateMnemonic = generateMnemonic;
 exports.generateNonce = generateNonce;
 exports.generateRandomness = generateRandomness;
 exports.hexToBytes = hexToBytes;
 exports.isBurnAddress = isBurnAddress;
 exports.isRougeAddress = isRougeAddress;
+exports.keypairFromMnemonic = keypairFromMnemonic;
+exports.mnemonicToMLDSASeed = mnemonicToMLDSASeed;
 exports.pubkeyToAddress = pubkeyToAddress;
 exports.serializePayload = serializePayload;
 exports.signTransaction = signTransaction;
+exports.validateMnemonic = validateMnemonic;
 exports.verifyTransaction = verifyTransaction;
 //# sourceMappingURL=index.cjs.map
 //# sourceMappingURL=index.cjs.map