@rougechain/sdk 0.7.0 → 0.8.1

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
 
@@ -461,6 +465,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(
@@ -1195,24 +1221,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 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 = 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.
    */
@@ -1223,7 +1294,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.
@@ -1263,14 +1338,18 @@ 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