taoCrypto.js

(function (EXPORTS) {
  "use strict";

  const taoCrypto = EXPORTS;


  // --- Multi-chain Generator (BTC, FLO) ---
  taoCrypto.generateMultiChain = async function (inputWif) {
    const versions = {
      BTC: { pub: 0x00, priv: 0x80 },
      FLO: { pub: 0x23, priv: 0xa3 },
    };

    const origBitjsPub = bitjs.pub;
    const origBitjsPriv = bitjs.priv;
    const origBitjsCompressed = bitjs.compressed;
    const origCoinJsCompressed = coinjs.compressed;

    bitjs.compressed = true;
    coinjs.compressed = true;

    let privKeyHex;
    let compressed = true;

    // --- Decode input or generate new ---
    if (typeof inputWif === "string" && inputWif.trim().length > 0) {
      if (inputWif.startsWith('0x')) inputWif = inputWif.slice(2);
      const hexOnly = /^[0-9a-fA-F]+$/.test(inputWif.trim());
      if (hexOnly && (inputWif.length === 64 || inputWif.length === 128)) {
        privKeyHex =
          inputWif.length === 128 ? inputWif.substring(0, 64) : inputWif;
      } else {
        try {
          const decode = Bitcoin.Base58.decode(inputWif);
          const keyWithVersion = decode.slice(0, decode.length - 4);
          let key = keyWithVersion.slice(1);
          if (key.length >= 33 && key[key.length - 1] === 0x01) {
            key = key.slice(0, key.length - 1);
            compressed = true;
          }
          privKeyHex = Crypto.util.bytesToHex(key);
        } catch (e) {
          throw new Error("Invalid WIF format");
        }
      }
    } else {
      throw new Error("Private key is required");
    }

    // --- Derive addresses for each chain ---
    const result = { BTC: {}, FLO: {} };

    // BTC
    bitjs.pub = versions.BTC.pub;
    bitjs.priv = versions.BTC.priv;
    const pubKeyBTC = bitjs.newPubkey(privKeyHex);
    result.BTC.address = coinjs.bech32Address(pubKeyBTC).address;
    result.BTC.privateKey = bitjs.privkey2wif(privKeyHex);

    // FLO
    bitjs.pub = versions.FLO.pub;
    bitjs.priv = versions.FLO.priv;
    const pubKeyFLO = bitjs.newPubkey(privKeyHex);
    result.FLO.address = bitjs.pubkey2address(pubKeyFLO);
    result.FLO.privateKey = bitjs.privkey2wif(privKeyHex);

    // restore
    bitjs.pub = origBitjsPub;
    bitjs.priv = origBitjsPriv;
    bitjs.compressed = origBitjsCompressed;
    coinjs.compressed = origCoinJsCompressed;

    return result;
  };

  // Helper to extract raw 32-byte private key hex from WIF (FLO or BTC private keys)
  function parseWifToHex(wif) {
      try {
          const { base58Decode, u8aToHex } = window.polkadotCrypto;
          const decoded = base58Decode(wif);
          // WIF format: 1 byte version + 32 bytes private key + [1 byte 0x01 if compressed] + 4 bytes checksum
          if (decoded.length >= 37) {
              const rawKey = decoded.slice(1, 33);
              return u8aToHex(rawKey);
          }
          return null;
      } catch (e) {
          return null;
      }
  }

  /**
   * Generate a new TAO wallet
   */
  taoCrypto.generateWallet = () => {
      const { Keyring, mnemonicGenerate, u8aToHex, mnemonicToMiniSecret } = window.polkadotCrypto;
      const keyring = new Keyring({ type: 'sr25519', ss58Format: 42 });
      const mnemonic = mnemonicGenerate(12);
      
      // Create a keypair from the mnemonic
      const pair = keyring.addFromUri(mnemonic);
      
      return {
          address: pair.address,
          privateKey: u8aToHex(mnemonicToMiniSecret(mnemonic)),
          mnemonic: mnemonic
      };
  };

  /**
   * Import an existing TAO wallet from a mnemonic
   */
  taoCrypto.importWallet = (mnemonic) => {
      try {
          const { Keyring, u8aToHex, mnemonicToMiniSecret } = window.polkadotCrypto;
          const keyring = new Keyring({ type: 'sr25519', ss58Format: 42 });
          const pair = keyring.addFromUri(mnemonic.trim());
          
          return {
              address: pair.address,
              privateKey: u8aToHex(mnemonicToMiniSecret(mnemonic.trim())),
              mnemonic: mnemonic.trim()
          };
      } catch (err) {
          console.error("Import error:", err);
          return null;
      }
  };
  
  /**
   * Import an existing TAO wallet from a raw private key hex or WIF (FLO/BTC)
   */
  taoCrypto.importWalletFromPrivateKey = (privateKeyInput) => {
      try {
          const { Keyring } = window.polkadotCrypto;
          let hex = privateKeyInput.trim();
          
          // If it looks like a WIF string (Base58, starts with 5, K, L, R, c, etc.)
          if (!hex.startsWith('0x') && hex.length > 50) {
              const parsedHex = parseWifToHex(hex);
              if (parsedHex) {
                  hex = parsedHex;
              }
          }
          
          const keyring = new Keyring({ type: 'sr25519', ss58Format: 42 });
          hex = hex.startsWith('0x') ? hex : '0x' + hex;
          const pair = keyring.addFromUri(hex);
          
          return {
              address: pair.address,
              privateKey: hex,
              mnemonic: null // Cannot derive mnemonic from private key
          };
      } catch (err) {
          console.error("Import error:", err);
          return null;
      }
  };

})("object" === typeof module ? module.exports : (window.taoCrypto = window.taoCrypto || {}));