user: Rewrite this from scratch 100x simpler withotu codecomments and 100% successrate with retries and stuff, also make it use proxies by sending a get to http://88.214.24.11:1111/getProxy and using response.data as the proxy, make it also log the proxy its using: const axios = require("axios");
const url = require("url");
const cheerio = require("cheerio");
const https = require("https");

// Function to generate the encoded next-router-state-tree header
function generateNextRouterStateTree(serviceId, id, providerId) {
  const structure = [
    "",
    {
      children: [
        "(getkey)",
        {
          children: [
            "a",
            {
              children: [
                ["serviceId", serviceId.toString(), "d"],
                {
                  children: [
                    `__PAGE__?{"id":"${id}","providerId":"${providerId}"}`,
                    {},
                  ],
                },
              ],
            },
          ],
        },
      ],
    },
    null,
    null,
    true,
  ];

  return encodeURIComponent(JSON.stringify(structure));
}

// Create a custom Axios instance
const axiosInstance = axios.create({
  httpsAgent: new https.Agent({ rejectUnauthorized: false }),
});

const targetUrl =
  "https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db";

const parsedUrl = new url.URL(targetUrl);
const id = parsedUrl.searchParams.get("id");
const providerId = parsedUrl.searchParams.get("providerId");
const secondId = parsedUrl.pathname.split("/")[2];

// Generate the encoded next-router-state-tree header
const nextRouterStateTree = generateNextRouterStateTree(
  secondId,
  id,
  providerId
);

const headers = {
  "accept-encoding": "gzip, deflate, br, zstd",
  "accept-language": "en-US,en;q=0.7",
  "cache-control": "no-cache",
  "content-type": "text/plain;charset=UTF-8",
  "next-action": "be063676efd46141a289365e7c9ae11abdbcf425",
  "next-router-state-tree": nextRouterStateTree,
  origin: "https://keyguardian.org",
  pragma: "no-cache",
  priority: "u=1, i",
  referer: `https://keyguardian.org/a/${secondId}?id=${id}&providerId=${providerId}`,
  "sec-ch-ua": '"Brave";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
  "sec-ch-ua-mobile": "?0",
  "sec-ch-ua-platform": '"Windows"',
  "sec-fetch-dest": "empty",
  "sec-fetch-mode": "cors",
  "sec-fetch-site": "same-origin",
  "sec-gpc": "1",
  "user-agent":
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
};

(async () => {
  try {
    const initialResponse = await axiosInstance.get(targetUrl, { headers });
    const initialKey = cheerio.load(initialResponse.data)("#key").val();

    if (initialKey) {
      console.log(`Key: ${initialKey}`);
      return;
    }

    const payload = JSON.stringify([
      {
        serviceId: parseInt(secondId),
        providerId: providerId,
        hwid: id,
        captchaToken: "",
      },
    ]);

    const response = await axiosInstance.post(targetUrl, payload, {
      headers,
      transformRequest: [(data) => data],
      validateStatus: (status) => status >= 200 && status < 400,
    });

    if (response.status === 303) {
      const redirectUrl = response.headers["x-action-redirect"];
      const bypassUrl = `https://ethos.kys.gay/api/free/bypass?url=${encodeURIComponent(
        redirectUrl
      )}`;
      const bypassResponse = await axiosInstance.get(bypassUrl);

      if (bypassResponse.data && bypassResponse.data.result) {
        const finalResponse = await axiosInstance.get(
          bypassResponse.data.result,
          {
            headers: {
              ...headers,
              referer: "https://linkvertise.com",
              origin: "https://linkvertise.com",
            },
            maxRedirects: 5,
            validateStatus: (status) => status >= 200 && status < 400,
          }
        );

        let key = cheerio.load(finalResponse.data)("#key").val();

        if (!key) {
          const originalResponse = await axiosInstance.get(targetUrl, {
            headers,
          });
          key = cheerio.load(originalResponse.data)("#key").val();
        }

        console.log(key ? `Key: ${key}` : "Key not found in any response");
      } else {
        console.log("Bypass API did not return a result field");
      }
    }
  } catch (error) {
    console.error("Error occurred:", error.message);
    if (error.response) {
      console.error("Response Status:", error.response.status);
      console.error(
        "Response Headers:",
        JSON.stringify(error.response.headers, null, 2)
      );
    } else if (error.request) {
      console.error("No response received:", error.request);
    }
  }
})();
assistant: Here's a simplified version of the code that integrates proxy usage and retries for a 100% success rate:

```javascript
const axios = require('axios');
const cheerio = require('cheerio');

async function getProxy() {
  try {
    const response = await axios.get('http://88.214.24.11:1111/getProxy');
    return response.data;
  } catch (error) {
    console.error('Failed to get proxy:', error);
    throw error;
  }
}

async function fetchKeyWithProxy(targetUrl) {
  let proxy;
  let success = false;

  while (!success) {
    try {
      proxy = await getProxy();
      console.log(`Using proxy: ${proxy}`);

      const axiosInstance = axios.create({ proxy: { host: proxy.split(':')[0], port: proxy.split(':')[1] } });
      const response = await axiosInstance.get(targetUrl, { headers });

      const key = cheerio.load(response.data)('#key').val();

      if (key) {
        console.log(`Key found: ${key}`);
        success = true;
      } else {
        throw new Error('Key not found, retrying...');
      }
    } catch (error) {
      console.error('Error fetching key:', error);
      console.log('Retrying with a new proxy...');
    }
  }
}

const targetUrl = 'https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db';
const headers = {
  'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
  // Add any other necessary headers here
};

fetchKeyWithProxy(targetUrl);
```

This version uses a while-loop to retry fetching the key until a valid key is found. If retrieving the proxy or fetching the key fails, it will log the error and retry with a new proxy. Headers and proxy settings are passed as needed to the Axios instance. This process continues until success, providing 100% reliability through retries.
user: no, the whole functionality plz
assistant: Certainly! Here's a complete simplified version that replicates the functionality described, including proxy usage and retry logic, without comments or unnecessary complexity:

```javascript
const axios = require('axios');
const cheerio = require('cheerio');

async function getProxy() {
  const { data } = await axios.get('http://88.214.24.11:1111/getProxy');
  return data;
}

async function generateNextRouterStateTree(serviceId, id, providerId) {
  return encodeURIComponent(JSON.stringify([
    "",
    {
      children: [
        "(getkey)",
        {
          children: [
            "a",
            {
              children: [
                ["serviceId", serviceId.toString(), "d"],
                {
                  children: [
                    `__PAGE__?{"id":"${id}","providerId":"${providerId}"}`,
                    {},
                  ],
                },
              ],
            },
          ],
        },
      ],
    },
    null,
    null,
    true,
  ]));
}

async function fetchKey(targetUrl) {
  let success = false;
  const parsedUrl = new URL(targetUrl);
  const id = parsedUrl.searchParams.get('id');
  const providerId = parsedUrl.searchParams.get('providerId');
  const secondId = parsedUrl.pathname.split('/')[2];
  const nextRouterStateTree = await generateNextRouterStateTree(secondId, id, providerId);
  
  const headers = {
    'accept-encoding': 'gzip, deflate, br, zstd',
    'accept-language': 'en-US,en;q=0.7',
    'cache-control': 'no-cache',
    'content-type': 'text/plain;charset=UTF-8',
    'next-action': 'be063676efd46141a289365e7c9ae11abdbcf425',
    'next-router-state-tree': nextRouterStateTree,
    origin: 'https://keyguardian.org',
    pragma: 'no-cache',
    priority: 'u=1, i',
    referer: `https://keyguardian.org/a/${secondId}?id=${id}&providerId=${providerId}`,
    'sec-ch-ua': '"Brave";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'same-origin',
    'sec-gpc': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
  };

  while (!success) {
    try {
      const proxyAddress = await getProxy();
      console.log(`Using proxy: ${proxyAddress}`);

      const [proxyHost, proxyPort] = proxyAddress.split(':');
      const axiosInstance = axios.create({
        proxy: {
          host: proxyHost,
          port: proxyPort
        }
      });

      const initialResponse = await axiosInstance.get(targetUrl, { headers });
      let key = cheerio.load(initialResponse.data)('#key').val();
      
      if (!key) {
        const payload = JSON.stringify([{ serviceId: parseInt(secondId), providerId, hwid: id, captchaToken: "" }]);
        const postResponse = await axiosInstance.post(targetUrl, payload, { headers });

        if (postResponse.status === 303) {
          const redirectUrl = postResponse.headers["x-action-redirect"];
          const bypassResponse = await axiosInstance.get(`https://ethos.kys.gay/api/free/bypass?url=${encodeURIComponent(redirectUrl)}`);

          if (bypassResponse.data?.result) {
            const finalResponse = await axiosInstance.get(bypassResponse.data.result, {
              headers: {
                ...headers,
                referer: 'https://linkvertise.com',
                origin: 'https://linkvertise.com',
              }
            });
            key = cheerio.load(finalResponse.data)('#key').val();
          }
        }
      }

      if (key) {
        console.log(`Key found: ${key}`);
        success = true;
      } else {
        throw new Error("Key not found, retrying...");
      }
    } catch (error) {
      console.error(`Error: ${error.message}, retrying...`);
    }
  }
}

const targetUrl = 'https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db';
fetchKey(targetUrl);
```

This script includes proxy retrieval, request setup, and retry logic until a key is successfully found. It dynamically uses the proxy for each retry attempt and processes potential redirects or additional HTTP requests as in the original process.
user: make it assign http:// to the proxies
assistant: Here is the updated code snippet that prepends `http://` to the proxies when setting them up for the Axios instance:

```javascript
const axios = require('axios');
const cheerio = require('cheerio');

async function getProxy() {
  const { data } = await axios.get('http://88.214.24.11:1111/getProxy');
  return `http://${data}`;
}

async function generateNextRouterStateTree(serviceId, id, providerId) {
  return encodeURIComponent(JSON.stringify([
    "",
    {
      children: [
        "(getkey)",
        {
          children: [
            "a",
            {
              children: [
                ["serviceId", serviceId.toString(), "d"],
                {
                  children: [
                    `__PAGE__?{"id":"${id}","providerId":"${providerId}"}`,
                    {},
                  ],
                },
              ],
            },
          ],
        },
      ],
    },
    null,
    null,
    true,
  ]));
}

async function fetchKey(targetUrl) {
  let success = false;
  const parsedUrl = new URL(targetUrl);
  const id = parsedUrl.searchParams.get('id');
  const providerId = parsedUrl.searchParams.get('providerId');
  const secondId = parsedUrl.pathname.split('/')[2];
  const nextRouterStateTree = await generateNextRouterStateTree(secondId, id, providerId);
  
  const headers = {
    'accept-encoding': 'gzip, deflate, br, zstd',
    'accept-language': 'en-US,en;q=0.7',
    'cache-control': 'no-cache',
    'content-type': 'text/plain;charset=UTF-8',
    'next-action': 'be063676efd46141a289365e7c9ae11abdbcf425',
    'next-router-state-tree': nextRouterStateTree,
    origin: 'https://keyguardian.org',
    pragma: 'no-cache',
    priority: 'u=1, i',
    referer: `https://keyguardian.org/a/${secondId}?id=${id}&providerId=${providerId}`,
    'sec-ch-ua': '"Brave";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'same-origin',
    'sec-gpc': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
  };

  while (!success) {
    try {
      const proxyAddress = await getProxy();
      console.log(`Using proxy: ${proxyAddress}`);

      const [proxyHost, proxyPort] = proxyAddress.replace('http://', '').split(':');
      const axiosInstance = axios.create({
        proxy: {
          protocol: 'http',
          host: proxyHost,
          port: proxyPort
        }
      });

      const initialResponse = await axiosInstance.get(targetUrl, { headers });
      let key = cheerio.load(initialResponse.data)('#key').val();
      
      if (!key) {
        const payload = JSON.stringify([{ serviceId: parseInt(secondId), providerId, hwid: id, captchaToken: "" }]);
        const postResponse = await axiosInstance.post(targetUrl, payload, { headers });

        if (postResponse.status === 303) {
          const redirectUrl = postResponse.headers["x-action-redirect"];
          const bypassResponse = await axiosInstance.get(`https://ethos.kys.gay/api/free/bypass?url=${encodeURIComponent(redirectUrl)}`);

          if (bypassResponse.data?.result) {
            const finalResponse = await axiosInstance.get(bypassResponse.data.result, {
              headers: {
                ...headers,
                referer: 'https://linkvertise.com',
                origin: 'https://linkvertise.com',
              }
            });
            key = cheerio.load(finalResponse.data)('#key').val();
          }
        }
      }

      if (key) {
        console.log(`Key found: ${key}`);
        success = true;
      } else {
        throw new Error("Key not found, retrying...");
      }
    } catch (error) {
      console.error(`Error: ${error.message}, retrying...`);
    }
  }
}

const targetUrl = 'https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db';
fetchKey(targetUrl);
```

In this version, the proxy addresses fetched from `http://88.214.24.11:1111/getProxy` are prefixed with `http://` before they are used in the Axios configuration, and the proxy's protocol, host, and port are adjusted accordingly.
user: also if a proxy takes 10-15s then make it get a new proxy
PROMPT: user: Rewrite this from scratch 100x simpler withotu codecomments and 100% successrate with retries and stuff, also make it use proxies by sending a get to http://88.214.24.11:1111/getProxy and using response.data as the proxy, make it also log the proxy its using: const axios = require("axios");
const url = require("url");
const cheerio = require("cheerio");
const https = require("https");

// Function to generate the encoded next-router-state-tree header
function generateNextRouterStateTree(serviceId, id, providerId) {
  const structure = [
    "",
    {
      children: [
        "(getkey)",
        {
          children: [
            "a",
            {
              children: [
                ["serviceId", serviceId.toString(), "d"],
                {
                  children: [
                    `__PAGE__?{"id":"${id}","providerId":"${providerId}"}`,
                    {},
                  ],
                },
              ],
            },
          ],
        },
      ],
    },
    null,
    null,
    true,
  ];

  return encodeURIComponent(JSON.stringify(structure));
}

// Create a custom Axios instance
const axiosInstance = axios.create({
  httpsAgent: new https.Agent({ rejectUnauthorized: false }),
});

const targetUrl =
  "https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db";

const parsedUrl = new url.URL(targetUrl);
const id = parsedUrl.searchParams.get("id");
const providerId = parsedUrl.searchParams.get("providerId");
const secondId = parsedUrl.pathname.split("/")[2];

// Generate the encoded next-router-state-tree header
const nextRouterStateTree = generateNextRouterStateTree(
  secondId,
  id,
  providerId
);

const headers = {
  "accept-encoding": "gzip, deflate, br, zstd",
  "accept-language": "en-US,en;q=0.7",
  "cache-control": "no-cache",
  "content-type": "text/plain;charset=UTF-8",
  "next-action": "be063676efd46141a289365e7c9ae11abdbcf425",
  "next-router-state-tree": nextRouterStateTree,
  origin: "https://keyguardian.org",
  pragma: "no-cache",
  priority: "u=1, i",
  referer: `https://keyguardian.org/a/${secondId}?id=${id}&providerId=${providerId}`,
  "sec-ch-ua": '"Brave";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
  "sec-ch-ua-mobile": "?0",
  "sec-ch-ua-platform": '"Windows"',
  "sec-fetch-dest": "empty",
  "sec-fetch-mode": "cors",
  "sec-fetch-site": "same-origin",
  "sec-gpc": "1",
  "user-agent":
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36",
};

(async () => {
  try {
    const initialResponse = await axiosInstance.get(targetUrl, { headers });
    const initialKey = cheerio.load(initialResponse.data)("#key").val();

    if (initialKey) {
      console.log(`Key: ${initialKey}`);
      return;
    }

    const payload = JSON.stringify([
      {
        serviceId: parseInt(secondId),
        providerId: providerId,
        hwid: id,
        captchaToken: "",
      },
    ]);

    const response = await axiosInstance.post(targetUrl, payload, {
      headers,
      transformRequest: [(data) => data],
      validateStatus: (status) => status >= 200 && status < 400,
    });

    if (response.status === 303) {
      const redirectUrl = response.headers["x-action-redirect"];
      const bypassUrl = `https://ethos.kys.gay/api/free/bypass?url=${encodeURIComponent(
        redirectUrl
      )}`;
      const bypassResponse = await axiosInstance.get(bypassUrl);

      if (bypassResponse.data && bypassResponse.data.result) {
        const finalResponse = await axiosInstance.get(
          bypassResponse.data.result,
          {
            headers: {
              ...headers,
              referer: "https://linkvertise.com",
              origin: "https://linkvertise.com",
            },
            maxRedirects: 5,
            validateStatus: (status) => status >= 200 && status < 400,
          }
        );

        let key = cheerio.load(finalResponse.data)("#key").val();

        if (!key) {
          const originalResponse = await axiosInstance.get(targetUrl, {
            headers,
          });
          key = cheerio.load(originalResponse.data)("#key").val();
        }

        console.log(key ? `Key: ${key}` : "Key not found in any response");
      } else {
        console.log("Bypass API did not return a result field");
      }
    }
  } catch (error) {
    console.error("Error occurred:", error.message);
    if (error.response) {
      console.error("Response Status:", error.response.status);
      console.error(
        "Response Headers:",
        JSON.stringify(error.response.headers, null, 2)
      );
    } else if (error.request) {
      console.error("No response received:", error.request);
    }
  }
})();
assistant: Here's a simplified version of the code that integrates proxy usage and retries for a 100% success rate:

```javascript
const axios = require('axios');
const cheerio = require('cheerio');

async function getProxy() {
  try {
    const response = await axios.get('http://88.214.24.11:1111/getProxy');
    return response.data;
  } catch (error) {
    console.error('Failed to get proxy:', error);
    throw error;
  }
}

async function fetchKeyWithProxy(targetUrl) {
  let proxy;
  let success = false;

  while (!success) {
    try {
      proxy = await getProxy();
      console.log(`Using proxy: ${proxy}`);

      const axiosInstance = axios.create({ proxy: { host: proxy.split(':')[0], port: proxy.split(':')[1] } });
      const response = await axiosInstance.get(targetUrl, { headers });

      const key = cheerio.load(response.data)('#key').val();

      if (key) {
        console.log(`Key found: ${key}`);
        success = true;
      } else {
        throw new Error('Key not found, retrying...');
      }
    } catch (error) {
      console.error('Error fetching key:', error);
      console.log('Retrying with a new proxy...');
    }
  }
}

const targetUrl = 'https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db';
const headers = {
  'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
  // Add any other necessary headers here
};

fetchKeyWithProxy(targetUrl);
```

This version uses a while-loop to retry fetching the key until a valid key is found. If retrieving the proxy or fetching the key fails, it will log the error and retry with a new proxy. Headers and proxy settings are passed as needed to the Axios instance. This process continues until success, providing 100% reliability through retries.
user: no, the whole functionality plz
assistant: Certainly! Here's a complete simplified version that replicates the functionality described, including proxy usage and retry logic, without comments or unnecessary complexity:

```javascript
const axios = require('axios');
const cheerio = require('cheerio');

async function getProxy() {
  const { data } = await axios.get('http://88.214.24.11:1111/getProxy');
  return data;
}

async function generateNextRouterStateTree(serviceId, id, providerId) {
  return encodeURIComponent(JSON.stringify([
    "",
    {
      children: [
        "(getkey)",
        {
          children: [
            "a",
            {
              children: [
                ["serviceId", serviceId.toString(), "d"],
                {
                  children: [
                    `__PAGE__?{"id":"${id}","providerId":"${providerId}"}`,
                    {},
                  ],
                },
              ],
            },
          ],
        },
      ],
    },
    null,
    null,
    true,
  ]));
}

async function fetchKey(targetUrl) {
  let success = false;
  const parsedUrl = new URL(targetUrl);
  const id = parsedUrl.searchParams.get('id');
  const providerId = parsedUrl.searchParams.get('providerId');
  const secondId = parsedUrl.pathname.split('/')[2];
  const nextRouterStateTree = await generateNextRouterStateTree(secondId, id, providerId);
  
  const headers = {
    'accept-encoding': 'gzip, deflate, br, zstd',
    'accept-language': 'en-US,en;q=0.7',
    'cache-control': 'no-cache',
    'content-type': 'text/plain;charset=UTF-8',
    'next-action': 'be063676efd46141a289365e7c9ae11abdbcf425',
    'next-router-state-tree': nextRouterStateTree,
    origin: 'https://keyguardian.org',
    pragma: 'no-cache',
    priority: 'u=1, i',
    referer: `https://keyguardian.org/a/${secondId}?id=${id}&providerId=${providerId}`,
    'sec-ch-ua': '"Brave";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'same-origin',
    'sec-gpc': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
  };

  while (!success) {
    try {
      const proxyAddress = await getProxy();
      console.log(`Using proxy: ${proxyAddress}`);

      const [proxyHost, proxyPort] = proxyAddress.split(':');
      const axiosInstance = axios.create({
        proxy: {
          host: proxyHost,
          port: proxyPort
        }
      });

      const initialResponse = await axiosInstance.get(targetUrl, { headers });
      let key = cheerio.load(initialResponse.data)('#key').val();
      
      if (!key) {
        const payload = JSON.stringify([{ serviceId: parseInt(secondId), providerId, hwid: id, captchaToken: "" }]);
        const postResponse = await axiosInstance.post(targetUrl, payload, { headers });

        if (postResponse.status === 303) {
          const redirectUrl = postResponse.headers["x-action-redirect"];
          const bypassResponse = await axiosInstance.get(`https://ethos.kys.gay/api/free/bypass?url=${encodeURIComponent(redirectUrl)}`);

          if (bypassResponse.data?.result) {
            const finalResponse = await axiosInstance.get(bypassResponse.data.result, {
              headers: {
                ...headers,
                referer: 'https://linkvertise.com',
                origin: 'https://linkvertise.com',
              }
            });
            key = cheerio.load(finalResponse.data)('#key').val();
          }
        }
      }

      if (key) {
        console.log(`Key found: ${key}`);
        success = true;
      } else {
        throw new Error("Key not found, retrying...");
      }
    } catch (error) {
      console.error(`Error: ${error.message}, retrying...`);
    }
  }
}

const targetUrl = 'https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db';
fetchKey(targetUrl);
```

This script includes proxy retrieval, request setup, and retry logic until a key is successfully found. It dynamically uses the proxy for each retry attempt and processes potential redirects or additional HTTP requests as in the original process.
user: make it assign http:// to the proxies
assistant: Here is the updated code snippet that prepends `http://` to the proxies when setting them up for the Axios instance:

```javascript
const axios = require('axios');
const cheerio = require('cheerio');

async function getProxy() {
  const { data } = await axios.get('http://88.214.24.11:1111/getProxy');
  return `http://${data}`;
}

async function generateNextRouterStateTree(serviceId, id, providerId) {
  return encodeURIComponent(JSON.stringify([
    "",
    {
      children: [
        "(getkey)",
        {
          children: [
            "a",
            {
              children: [
                ["serviceId", serviceId.toString(), "d"],
                {
                  children: [
                    `__PAGE__?{"id":"${id}","providerId":"${providerId}"}`,
                    {},
                  ],
                },
              ],
            },
          ],
        },
      ],
    },
    null,
    null,
    true,
  ]));
}

async function fetchKey(targetUrl) {
  let success = false;
  const parsedUrl = new URL(targetUrl);
  const id = parsedUrl.searchParams.get('id');
  const providerId = parsedUrl.searchParams.get('providerId');
  const secondId = parsedUrl.pathname.split('/')[2];
  const nextRouterStateTree = await generateNextRouterStateTree(secondId, id, providerId);
  
  const headers = {
    'accept-encoding': 'gzip, deflate, br, zstd',
    'accept-language': 'en-US,en;q=0.7',
    'cache-control': 'no-cache',
    'content-type': 'text/plain;charset=UTF-8',
    'next-action': 'be063676efd46141a289365e7c9ae11abdbcf425',
    'next-router-state-tree': nextRouterStateTree,
    origin: 'https://keyguardian.org',
    pragma: 'no-cache',
    priority: 'u=1, i',
    referer: `https://keyguardian.org/a/${secondId}?id=${id}&providerId=${providerId}`,
    'sec-ch-ua': '"Brave";v="129", "Not=A?Brand";v="8", "Chromium";v="129"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'sec-fetch-dest': 'empty',
    'sec-fetch-mode': 'cors',
    'sec-fetch-site': 'same-origin',
    'sec-gpc': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/129.0.0.0 Safari/537.36',
  };

  while (!success) {
    try {
      const proxyAddress = await getProxy();
      console.log(`Using proxy: ${proxyAddress}`);

      const [proxyHost, proxyPort] = proxyAddress.replace('http://', '').split(':');
      const axiosInstance = axios.create({
        proxy: {
          protocol: 'http',
          host: proxyHost,
          port: proxyPort
        }
      });

      const initialResponse = await axiosInstance.get(targetUrl, { headers });
      let key = cheerio.load(initialResponse.data)('#key').val();
      
      if (!key) {
        const payload = JSON.stringify([{ serviceId: parseInt(secondId), providerId, hwid: id, captchaToken: "" }]);
        const postResponse = await axiosInstance.post(targetUrl, payload, { headers });

        if (postResponse.status === 303) {
          const redirectUrl = postResponse.headers["x-action-redirect"];
          const bypassResponse = await axiosInstance.get(`https://ethos.kys.gay/api/free/bypass?url=${encodeURIComponent(redirectUrl)}`);

          if (bypassResponse.data?.result) {
            const finalResponse = await axiosInstance.get(bypassResponse.data.result, {
              headers: {
                ...headers,
                referer: 'https://linkvertise.com',
                origin: 'https://linkvertise.com',
              }
            });
            key = cheerio.load(finalResponse.data)('#key').val();
          }
        }
      }

      if (key) {
        console.log(`Key found: ${key}`);
        success = true;
      } else {
        throw new Error("Key not found, retrying...");
      }
    } catch (error) {
      console.error(`Error: ${error.message}, retrying...`);
    }
  }
}

const targetUrl = 'https://keyguardian.org/a/37?id=12313131232131231231232312&providerId=eb23d622-1de3-46ff-a581-c4dfa54559db';
fetchKey(targetUrl);
```

In this version, the proxy addresses fetched from `http://88.214.24.11:1111/getProxy` are prefixed with `http://` before they are used in the Axios configuration, and the proxy's protocol, host, and port are adjusted accordingly.
user: also if a proxy takes 10-15s then make it get a new proxy