Class QuipSigner

src/cli.cpp:120–174

QuipSigner: Deterministic Winternitz keypair generator using quantum secret and vaultId

// QuipSigner: Deterministic Winternitz keypair generator using quantum secret
// and vaultId
class QuipSigner {
public:
  QuipSigner(const std::array<uint8_t, 32> &quantum_secret_raw)
      : wots_(keccak256) {
    // Store the raw quantum secret, hashing happens in recoverKeyPair
    quantum_secret_ = quantum_secret_raw;
  }

  // Generate a NEW keypair for a given vaultId using a random public seed
  // This is used for creating the NEXT keypair during transfers
  std::pair<WinternitzAddress, std::vector<std::array<uint8_t, 32>>>
  generateKeyPair(const std::array<uint8_t, 32> &vaultId) {
    // Use a cryptographically secure random 32-byte public seed for the next PQ owner
    std::array<uint8_t, 32> public_seed = randomSeed32();
    return recoverKeyPair(vaultId, public_seed);
  }

  // Deterministically recover keypair for a given vaultId and publicSeed
  std::pair<WinternitzAddress, std::vector<std::array<uint8_t, 32>>>
  recoverKeyPair(const std::array<uint8_t, 32> &vaultId,
                 const std::array<uint8_t, 32> &publicSeed) {
    // Create the private seed by concatenating the quantum secret and
    // the vaultId, then hash it (matching TypeScript implementation)
    std::vector<uint8_t> concat(quantum_secret_.begin(),
                                quantum_secret_.end());
    concat.insert(concat.end(), vaultId.begin(), vaultId.end());
    std::array<uint8_t, 32> private_seed_array = keccak256(concat);
    std::vector<uint8_t> private_seed(private_seed_array.begin(), private_seed_array.end());
    

    // Generate keypair using the two-parameter interface (protocol-compatible)
    auto [public_key, private_key] =
        wots_.generate_key_pair(private_seed, publicSeed);

    // Create WinternitzAddress from the generated public key
    WinternitzAddress pqAddress;
    std::copy(public_key.begin(), public_key.begin() + 32,
              pqAddress.publicSeed.begin());
    std::copy(public_key.begin() + 32, public_key.end(),
              pqAddress.publicKeyHash.begin());
    return {pqAddress, private_key};
  }

  // Sign a message using a recovered keypair
  Signature sign(const std::array<uint8_t, 32> &message,
                 const std::vector<std::array<uint8_t, 32>> &private_key,
                 const std::array<uint8_t, 32> &publicSeed) {
    // Sign the message with the provided private key and public seed
    return wots_.sign(private_key, publicSeed, message);
  }

private:
  std::array<uint8_t, 32> quantum_secret_;
  hashsigs::WOTSPlus wots_;
};

CLI::CLI(const std::string &rpc_url, const std::string &contract_address)
    : rpc_url_(rpc_url), contract_address_(contract_address) {