@rougechain/sdk 0.7.0 → 0.8.1

package/dist/index.js

@@ -1,5 +1,9 @@
 import { ml_dsa65 } from '@noble/post-quantum/ml-dsa.js';
 import { sha256 } from '@noble/hashes/sha2';
+import { generateMnemonic as generateMnemonic$1, validateMnemonic as validateMnemonic$1, mnemonicToSeedSync } from '@scure/bip39';
+import { wordlist } from '@scure/bip39/wordlists/english.js';
+import { hkdf } from '@noble/hashes/hkdf.js';
+import { sha256 as sha256$1 } from '@noble/hashes/sha2.js';
 
 // src/signer.ts
 
@@ -459,6 +463,28 @@ 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`);
+  }
+  // ===== Push Notifications =====
+  /** Register an Expo push token for a wallet to receive notifications. */
+  async registerPushToken(publicKey, pushToken, platform = "expo") {
+    return this.post("/push/register", { publicKey, pushToken, platform });
+  }
+  /** Unregister push notifications for a wallet. */
+  async unregisterPushToken(publicKey) {
+    return this.post("/push/unregister", { publicKey });
+  }
   // ===== Write operations =====
   async transfer(wallet, params) {
     const tx = createSignedTransfer(
@@ -1193,24 +1219,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 generateMnemonic$1(wordlist, strength);
+}
+function validateMnemonic(mnemonic) {
+  return validateMnemonic$1(mnemonic, wordlist);
+}
+function mnemonicToMLDSASeed(mnemonic, passphrase) {
+  const bip39Seed = mnemonicToSeedSync(mnemonic, passphrase);
+  return hkdf(sha256$1, 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 = 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 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(strength = 128) {
+    const mnemonic = generateMnemonic(strength);
+    const { publicKey, secretKey } = keypairFromMnemonic(mnemonic);
+    return new _Wallet(publicKey, secretKey, mnemonic);
   }
   /**
-   * Generate a new ML-DSA-65 keypair.
-   * Uses crypto.getRandomValues for secure randomness.
+   * Generate a wallet using pure random entropy (no mnemonic).
+   * Keys cannot be recovered from a seed phrase.
    */
-  static generate() {
+  static generateRandom() {
     const keypair = 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.
    */
@@ -1221,7 +1292,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.
@@ -1244,6 +1319,6 @@ var Wallet = class _Wallet {
   }
 };
 
-export { BURN_ADDRESS, RougeChain, Wallet, addressToHash, bytesToHex, computeCommitment, computeNullifier, createShieldedNote, createSignedBridgeWithdraw, createSignedShield, createSignedShieldedTransfer, createSignedTokenApproval, createSignedTokenMetadataClaim, createSignedTokenMetadataUpdate, createSignedTokenTransferFrom, createSignedUnshield, formatAddress, generateNonce, generateRandomness, hexToBytes, isBurnAddress, isRougeAddress, pubkeyToAddress, serializePayload, signTransaction, verifyTransaction };
+export { BURN_ADDRESS, RougeChain, Wallet, addressToHash, bytesToHex, computeCommitment, computeNullifier, createShieldedNote, createSignedBridgeWithdraw, createSignedShield, createSignedShieldedTransfer, createSignedTokenApproval, createSignedTokenMetadataClaim, createSignedTokenMetadataUpdate, createSignedTokenTransferFrom, createSignedUnshield, formatAddress, generateMnemonic, generateNonce, generateRandomness, hexToBytes, isBurnAddress, isRougeAddress, keypairFromMnemonic, mnemonicToMLDSASeed, pubkeyToAddress, serializePayload, signTransaction, validateMnemonic, verifyTransaction };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map