Method executeWithWinternitzValue

src/quip_wallet.cpp:210–388

  }

  bool executeWithWinternitzValue(const WinternitzAddress &winternitz_address,
                                 const Signature &pq_sig,
                                 const Address &target_address,
                                 const std::vector<uint8_t> &opdata,
                                 Amount eth_value) {
    try {
      // Get private key from environment
      const char *env_private_key = std::getenv("PRIVATE_KEY");
      if (!env_private_key) {
        throw std::runtime_error("PRIVATE_KEY environment variable not set");
      }
      PrivateKey private_key = env_private_key;

      // Convert C++ types to the format expected by the ABI encoder
      nlohmann::json nextPqOwner = {
          {"publicSeed", toHex(winternitz_address.publicSeed)},
          {"publicKeyHash", toHex(winternitz_address.publicKeyHash)}};

      // Convert signature elements to hex strings array (ABI expects bytes32[67])
      nlohmann::json elements = nlohmann::json::array();
      for (const auto &element : pq_sig) {
        elements.push_back(toHex(element));
      }
      nlohmann::json pqSig = {{"elements", elements}};

      // Convert opdata to hex string
      std::string opdata_hex = toHex(opdata);

      // Create parameters for ABI encoding
      nlohmann::json params = {nextPqOwner, pqSig, target_address, opdata_hex};

      // Encode the function call using shared abiEncode function
      std::string params_json = params.dump();
      std::string data =
          abiEncode("executeWithWinternitz", abi_json, params_json);

      // Get the execute fee (use passed value)
      Amount executeFee = getExecuteFee();
      Amount totalValue = eth_value; // Use the passed ETH value instead of just the fee

      // Get account address from private key
      std::string from_address = deriveClassicalPublicKey(private_key);

      // Get nonce
      nlohmann::json nonce_params = {from_address, "latest"};
      auto nonce_response =
          sendJsonRpc("eth_getTransactionCount", nonce_params);
      std::string nonce_hex = nonce_response["result"];
      uint64_t nonce = std::stoull(nonce_hex.substr(2), nullptr, 16);

      // Get gas price and convert to EIP-1559 format
      auto gas_price_response =
          sendJsonRpc("eth_gasPrice", nlohmann::json::array());
      std::string gas_price_hex = gas_price_response["result"];
      uint64_t gas_price = std::stoull(gas_price_hex.substr(2), nullptr, 16);

      uint64_t max_fee_per_gas = gas_price * 2;
      uint64_t max_priority_fee_per_gas = gas_price;