I pressed cancel on the auto pay for the hunter rumour script and it still charged me for it. I haven’t used the script at all. Need refund. Ty.

any update on the account?  

Searching for a good coder who can test this script. I on the other hand dont know how to code. I spent alot of hours talking to chat gpt and creating code with it depending on what and how i wanted it to work. I will post the full code here so anybody whos good with coding can try to see if it works..i want no credit or profit if it ends up working. or u make changes and get it to work . I only want free life time use and access to use it as soon as it works .    You gonna need to download weka and use the weka.jar and json.jar and then the dreambots api jar     import org.dreambot.api.script.AbstractScript; import org.dreambot.api.script.ScriptManifest; import org.dreambot.api.utilities.Logger; import org.dreambot.api.methods.dialog.Bank; import org.dreambot.api.methods.input.Keyboard; import org.dreambot.api.methods.input.Mouse; import org.dreambot.api.methods.tab.Inventory; import org.dreambot.api.methods.tab.Tab; import org.dreambot.api.methods.api.item.Item; import org.dreambot.api.methods.item.Items; import org.dreambot.api.methods.container.impl.shop.GrandExchange; import org.dreambot.api.methods.container.impl.shop.Offer; import org.dreambot.api.methods.container.impl.shop.OfferState; import org.dreambot.api.methods.container.impl.shop.OfferType; import org.dreambot.api.methods.walking.Walking; import org.dreambot.api.methods.walking.pathfinding.Position; import org.dreambot.api.methods.walking.pathfinding.Area; import javax.swing.*; import java.awt.*; import java.io.BufferedReader; import java.io.InputStreamReader; import java.net.HttpURLConnection; import java.net.URL; import java.util.HashMap; import java.util.Map; import org.json.JSONObject; import weka.classifiers.trees.RandomForest; // Weka Random Forest Classifier import weka.core.Instance; import weka.core.DenseInstance; import weka.core.Instances; import weka.core.Attribute; import java.util.ArrayList; @ScriptManifest(author = "YourName", name = "OSRS GE Flipper", version = 1.0, description = "A script to flip items in the OSRS Grand Exchange") public class GEFlipper extends AbstractScript {     private boolean scriptActive = false;     private int profitMargin = 10; // Profit margin percentage     private int maxOrderTime = 1200000; // Max order time in milliseconds     private int volumeThreshold = 100; // Min volume to consider buying     private Map<String, ItemData> itemDataMap = new HashMap<>();     private Map<String, Integer> lastBuyPrices = new HashMap<>(); // Store last buy prices     private long orderPlacedTime;     private long startTime; // Track the start time of the script     private RandomForest randomForest; // Random Forest model for price prediction     private Instances trainingData; // Instances for Weka model training     // Performance Tracking Variables     private double totalProfit = 0;     private int totalTrades = 0;     private double currentSessionProfit = 0;     // User-selected item type (F2P or P2P)     private boolean isF2PMode = false; // true for F2P, false for P2P     private int tradingSlots = 8; // Default to P2P slots     public void onStart() {         loadItemData(); // Load item data from the API         initializeModel(); // Initialize the random forest model         new SettingsGUI(this); // Open settings GUI         walkToGrandExchange(); // Ensure the player is at the Grand Exchange         startTime = System.currentTimeMillis(); // Record the start time of the script     }     public int onLoop() {         if (scriptActive) {             updatePrices();             if (shouldUpdateModel()) {                 retrainModel(); // Retrain model if conditions are met             }             updatePerformanceTracking(); // Update performance tracking             adjustProfitMarginBasedOnMarket(); // Adjust profit margin based on market conditions             // Random mouse movement while waiting for orders             if (isWaitingForOrder()) {                 moveMouseRandomly();             }         }         return 1000; // Loop delay     }     public void toggleScript() {         scriptActive = !scriptActive;         log(scriptActive ? "Script Activated." : "Script Deactivated.");     }     private boolean isWaitingForOrder() {         // Determine if the script is currently waiting for a buy or sell order to be fulfilled         return GrandExchange.isOpen() && (System.currentTimeMillis() - orderPlacedTime < maxOrderTime);     }     private void moveMouseRandomly() {         // Perform random mouse movements to simulate human behavior         int randomX = random(600, 800) + random(-10, 10);         int randomY = random(400, 600) + random(-10, 10);         Mouse.move(randomX, randomY);         sleep(random(2000, 5000)); // Random delay between movements     }     private void walkToGrandExchange() {         // Logic to walk to the Grand Exchange         if (!isInGrandExchange()) {             log("Walking to Grand Exchange...");             Walking.walk(getRandomPositionNearGE());             sleepUntil(() -> isInGrandExchange(), 15000); // Wait until we are at GE         } else if (!GrandExchange.isOpen()) {             GrandExchange.open(); // Open Grand Exchange if already there         }     }     private boolean isInGrandExchange() {         // Check if the player is in the Grand Exchange area         return getLocalPlayer().getArea().contains(getGrandExchangeArea());     }     private Area getGrandExchangeArea() {         // Define the area of the Grand Exchange         return new Area(3164, 3486, 3180, 3497);     }     private Position getRandomPositionNearGE() {         // Return a random position near the Grand Exchange         return new Position(3165 + random(-5, 5), 3486 + random(-5, 5), 0);     }     private void updatePrices() {         Map<String, ItemData> pricesJSON = fetchPrices();         if (pricesJSON == null) {             log("Failed to fetch prices from API.");             return;         }         for (String itemName : pricesJSON.keySet()) {             ItemData data = pricesJSON.get(itemName);             log("Item: " + itemName + " Buy: " + data.buy + " Sell: " + data.sell + " Volume: " + data.volumeHour);             // Limit the items to trade based on F2P or P2P mode             if (isF2PMode && !isF2PItem(itemName)) {                 continue; // Skip non-F2P items if in F2P mode             }             int availableCoins = getAvailableCoins();             int buyQuantity = calculateBuyQuantity(data, availableCoins); // Calculate buy quantity based on strategy             // AI Trading Logic             if (shouldBuy(data)) {                 buyItem(itemName, data.buy, buyQuantity);                 orderPlacedTime = System.currentTimeMillis();                 lastBuyPrices.put(itemName, data.buy); // Store last buy price             }             if (shouldSell(data, itemName)) {                 sellItem(itemName, data.sell, Inventory.getAmount(itemName));             }         }     }     private boolean isF2PItem(String itemName) {         // Define a list of F2P items         String[] f2pItems = {"Bronze sword", "Iron sword", "Steel sword"}; // Example F2P items         for (String f2pItem : f2pItems) {             if (itemName.equals(f2pItem)) {                 return true;             }         }         return false;     }     private int calculateBuyQuantity(ItemData data, int availableCoins) {         // Calculate the quantity to buy based on available coins and profit expectations         if (data.profit > profitMargin) {             return availableCoins / data.buy; // Buy as much as possible if profit is high         }         return availableCoins / data.buy / 2; // Buy less if profit is marginal     }     private boolean shouldBuy(ItemData data) {         // AI decision logic for buying         return data.profit > 0 && data.volumeHour > volumeThreshold && isPriceExpectedToIncrease(data);     }     private boolean shouldSell(ItemData data, String itemName) {         // AI decision logic for selling         return data.sell > data.buy && Inventory.contains(itemName) && isPriceExpectedToDecrease(data);     }     private boolean isPriceExpectedToIncrease(ItemData data) {         double predictedPrice = predictPrice(data); // Predict based on current data         return predictedPrice > data.buy; // Expect price to rise     }     private boolean isPriceExpectedToDecrease(ItemData data) {         double predictedPrice = predictPrice(data); // Predict based on current data         return predictedPrice < data.sell; // Expect price to fall     }     private double predictPrice(ItemData data) {         // Create instance for prediction         Instance instance = new DenseInstance(4); // Now 4 attributes         instance.setValue(trainingData.attribute(0), data.volumeHour); // Set volume as feature         instance.setValue(trainingData.attribute(1), data.buy); // Set current buy price as feature         instance.setValue(trainingData.attribute(2), calculatePriceTrend(data)); // Set price trend as feature         instance.setValue(trainingData.attribute(3), calculatePriceVolatility(data)); // Set price volatility as feature         instance.setDataset(trainingData); // Set dataset for instance         try {             return randomForest.classifyInstance(instance); // Predict price using the model         } catch (Exception e) {             log("Error predicting price: " + e.getMessage());             return data.buy; // Fallback to current buy price if prediction fails         }     }     private Map<String, ItemData> fetchPrices() {         String urlString = "https://prices.runescape.wiki/api/v1/osrs/latest";         int retryCount = 0; // Retry counter         while (retryCount < 3) { // Try up to 3 times             try {                 URL url = new URL(urlString);                 HttpURLConnection conn = (HttpURLConnection) url.openConnection();                 conn.setRequestMethod("GET");                 BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));                 String inputLine;                 StringBuilder response = new StringBuilder();                 while ((inputLine = in.readLine()) != null) {                     response.append(inputLine);                 }                 in.close();                 return parsePrices(response.toString());             } catch (Exception e) {                 log("Error fetching prices: " + e.getMessage());                 retryCount++;                 sleep(2000); // Wait before retrying             }         }         log("Failed to fetch prices after 3 attempts.");         return null;     }     private Map<String, ItemData> parsePrices(String json) {         Map<String, ItemData> prices = new HashMap<>();         JSONObject jsonObject = new JSONObject(json).getJSONObject("data");         for (String key : jsonObject.keySet()) {             int value = jsonObject.getInt(key);             // Fetch volume data from the API if available             int volume = fetchVolumeData(key); // Adjust to fetch actual volume data if needed             prices.put(key, new ItemData(value, value * (1 + profitMargin / 100), volume, 0)); // Volume values set to fetched data         }         return prices;     }     private int fetchVolumeData(String itemName) {         // You can implement the logic to fetch volume data if needed, or set to 0 if not applicable         return 0; // Placeholder for volume data fetching logic     }     private int getAvailableCoins() {         // Logic to check available coins in the inventory         return Inventory.count("Coins"); // Dynamic coin checking     }     private void buyItem(String itemName, int price, int quantity) {         GrandExchange.open();         if (GrandExchange.isOpen()) {             GrandExchange.offer(OfferType.BUY, itemName, quantity, price);             log("Buying " + quantity + " " + itemName + " at " + price + " each.");             randomMouseClick(); // Simulate a human-like mouse click             // Wait for full buy order to be fulfilled before collecting items             sleepUntil(() -> {                 Offer offer = GrandExchange.getOffer(itemName);                 return offer != null && offer.getState() == OfferState.FULFILLED;             }, maxOrderTime);             // Collect items only after full order is completed             if (GrandExchange.isReadyToCollect()) {                 GrandExchange.collect();                 log("Collected full order of " + itemName);             } else {                 log("Order for " + itemName + " was not fulfilled in time.");             }         } else {             log("Failed to open Grand Exchange for buying.");         }     }     private void sellItem(String itemName, int price, int quantity) {         GrandExchange.open();         if (GrandExchange.isOpen()) {             GrandExchange.offer(OfferType.SELL, itemName, quantity, price);             log("Selling " + quantity + " " + itemName + " at " + price + " each.");             randomMouseClick(); // Simulate a human-like mouse click             // Wait for full sell order to be fulfilled before collecting coins             sleepUntil(() -> {                 Offer offer = GrandExchange.getOffer(itemName);                 return offer != null && offer.getState() == OfferState.FULFILLED;             }, maxOrderTime);             // Collect coins only after full order is completed             if (GrandExchange.isReadyToCollect()) {                 GrandExchange.collect();                 log("Collected full payment for " + itemName);             } else {                 log("Sell order for " + itemName + " was not fulfilled in time.");             }         } else {             log("Failed to open Grand Exchange for selling.");         }     }     private void randomMouseClick() {         // Simulate a human-like mouse click with random movement         int x = random(600, 800); // Example coordinates; adjust as necessary         int y = random(400, 600);         getMouse().move(x + random(-10, 10), y + random(-10, 10)); // Move to coordinates with slight randomness         sleep(random(300, 600)); // Random delay for human-like behavior         getMouse().click(); // Simulate click     }     private int getBuyPrice(String itemName) {         // Implement logic to retrieve the last buy price of the item for profit calculation         return lastBuyPrices.getOrDefault(itemName, 0); // Get last buy price or return 0 if not found     }     private void cancelOrder(String item) {         log("Cancelling order for " + item);         GrandExchange.close(); // Logic for canceling order     }     private void initializeModel() {         // Initialize the random forest model and training data         trainingData = new Instances("ItemData", createAttributes(), 0);         randomForest = new RandomForest(); // Create a new random forest classifier         retrainModel(); // Train the model with historical data     }     private ArrayList<Attribute> createAttributes() {         ArrayList<Attribute> attributes = new ArrayList<>();         attributes.add(new Attribute("VolumeHour")); // Feature 1         attributes.add(new Attribute("CurrentBuyPrice")); // Feature 2         attributes.add(new Attribute("PriceTrend")); // Feature 3         attributes.add(new Attribute("PriceVolatility")); // Feature 4         attributes.add(new Attribute("PredictedPrice")); // Target variable         return attributes;     }     private boolean shouldUpdateModel() {         // Define the logic to determine when to retrain the model         return (trainingData.numInstances() % 10 == 0); // Retrain every 10 instances for demonstration     }     private void retrainModel() {         try {             randomForest.buildClassifier(trainingData); // Train the Random Forest model with current data             log("Model retrained with current historical data.");         } catch (Exception e) {             log("Error retraining model: " + e.getMessage());         }     }     private double calculatePriceTrend(ItemData data) {         // Implement a logic to calculate price trends         return data.sell - data.buy; // Simplified example: price difference     }     private double calculatePriceVolatility(ItemData data) {         // Implement a logic to calculate price volatility         return Math.abs(data.sell - data.buy) / data.buy; // Simplified example: relative price change     }     private void updatePerformanceTracking() {         long elapsedTime = System.currentTimeMillis() - startTime; // Time since script started         double gpPerHour = (currentSessionProfit * 3600000) / elapsedTime; // Calculate GP earned per hour         log("Total Profit: " + totalProfit);         log("Total Trades: " + totalTrades);         log("Current Session Profit: " + currentSessionProfit);         log("GP Earned Per Hour: " + gpPerHour);         log("Elapsed Time: " + (elapsedTime / 1000) + " seconds");         log("Average Profit per Trade: " + (totalTrades > 0 ? totalProfit / totalTrades : 0));     }     private void adjustProfitMarginBasedOnMarket() {         // Adjust profit margin based on market conditions         for (ItemData data : itemDataMap.values()) {             if (data.volumeHour > volumeThreshold) {                 // Increase profit margin if the item is being actively traded                 profitMargin = Math.min(profitMargin + 1, 50); // Cap the profit margin at 50%             } else {                 // Decrease profit margin if the item is not actively traded                 profitMargin = Math.max(profitMargin - 1, 5); // Cap the profit margin at a minimum of 5%             }         }         log("Adjusted profit margin to: " + profitMargin);     }     public void loadItemData() {         // Load item data from the API or other source         String urlString = "https://prices.runescape.wiki/api/v1/osrs/latest";         int retryCount = 0; // Retry counter         while (retryCount < 3) { // Try up to 3 times             try {                 URL url = new URL(urlString);                 HttpURLConnection conn = (HttpURLConnection) url.openConnection();                 conn.setRequestMethod("GET");                 BufferedReader in = new BufferedReader(new InputStreamReader(conn.getInputStream()));                 String inputLine;                 StringBuilder response = new StringBuilder();                 while ((inputLine = in.readLine()) != null) {                     response.append(inputLine);                 }                 in.close();                 // Parse the response to populate itemDataMap                 JSONObject jsonObject = new JSONObject(response.toString()).getJSONObject("data");                 for (String key : jsonObject.keySet()) {                     int value = jsonObject.getInt(key);                     // Fetch the volume data here if available or set it to 0 for now                     int volume = fetchVolumeData(key); // Adjust to fetch actual volume data if needed                     itemDataMap.put(key, new ItemData(value, value * (1 + profitMargin / 100), volume, 0)); // Use fetched volume data                 }                 return; // Exit the loop on success             } catch (Exception e) {                 log("Error loading item data: " + e.getMessage());                 retryCount++;                 sleep(2000); // Wait before retrying             }         }         log("Failed to load item data after 3 attempts.");     } } class ItemData {     int buy;     int sell;     int volumeHour;     int volume5Min;     int profit;     public ItemData(int buy, int sell, int volumeHour, int volume5Min) {         this.buy = buy;         this.sell = sell;         this.volumeHour = volumeHour;         this.volume5Min = volume5Min;         this.profit = sell - buy;     } } class SettingsGUI {     public SettingsGUI(GEFlipper script) {         JFrame frame = new JFrame("Settings");         frame.setSize(300, 200);         frame.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);         frame.setLayout(new FlowLayout());         JTextField profitMarginField = new JTextField(String.valueOf(script.profitMargin), 5);         JTextField maxOrderTimeField = new JTextField(String.valueOf(script.maxOrderTime), 5);         JTextField volumeThresholdField = new JTextField(String.valueOf(script.volumeThreshold), 5);         JCheckBox f2pCheckbox = new JCheckBox("Free-to-Play Items Only", script.isF2PMode);                  JButton saveButton = new JButton("Save");         saveButton.addActionListener(e -> {             script.profitMargin = Integer.parseInt(profitMarginField.getText());             script.maxOrderTime = Integer.parseInt(maxOrderTimeField.getText());             script.volumeThreshold = Integer.parseInt(volumeThresholdField.getText());             script.isF2PMode = f2pCheckbox.isSelected(); // Update F2P mode             script.tradingSlots = script.isF2PMode ? 3 : 8; // Set trading slots based on mode             frame.dispose();             script.log("Settings saved: Profit Margin=" + script.profitMargin + ", Max Order Time=" + script.maxOrderTime + ", Volume Threshold=" + script.volumeThreshold + ", F2P Mode=" + script.isF2PMode);         });         frame.add(new JLabel("Profit Margin (%):"));         frame.add(profitMarginField);         frame.add(new JLabel("Max Order Time (ms):"));         frame.add(maxOrderTimeField);         frame.add(new JLabel("Volume Threshold:"));         frame.add(volumeThresholdField);         frame.add(f2pCheckbox);         frame.add(saveButton);         frame.setVisible(true);     } }   The OSRS GE Flipper script is an advanced automation tool designed for trading items in the Grand Exchange of Old School RuneScape (OSRS). Here’s a detailed explanation of its features and functionalities: Key Features: Automated Trading: The script automates the buying and selling of items in the Grand Exchange, allowing users to profit from item price fluctuations without manual intervention. Real-Time Price Fetching: It retrieves current item prices and volumes from the Runescape Wiki API, ensuring that the trading decisions are based on the most up-to-date market data. This includes average prices and historical trends, which the script uses to make informed trading decisions. AI-Based Price Prediction: The script employs a Random Forest machine learning model to predict future prices based on historical data. It analyzes various factors, such as: Volume: The number of items traded over a specified period. Current Buy Price: The price at which the item is currently being bought. Price Trend: Changes in price over time to identify upward or downward trends. Price Volatility: The degree of variation in the price to assess the risk associated with trading an item. Dynamic Decision-Making: The script evaluates whether to buy or sell an item based on the following criteria: Profit Margin: Users can set a desired profit margin percentage, guiding the script's buy/sell decisions. Volume Threshold: A minimum trading volume is established to ensure liquidity when executing trades. Price Expectations: It predicts whether an item's price will increase or decrease, determining the optimal time for buying and selling. User Customization: The script includes a settings GUI where users can customize parameters such as: Profit margin percentage. Maximum order time (time to wait for a buy/sell order to complete). Volume threshold for trading. Option to focus on Free-to-Play (F2P) items or Pay-to-Play (P2P) items. Performance Tracking: It tracks and logs performance metrics, including: Total Profit: The cumulative profit made during the script's operation. Total Trades: The number of trades executed. Current Session Profit: Profit generated in the current session. GP Earned Per Hour: An estimate of how much gold is earned per hour based on current performance. Random Mouse Movement: To simulate human behavior and reduce the risk of detection by the game’s anti-botting measures, the script includes functionality for random mouse movements during execution. Error Handling: The script incorporates robust error handling mechanisms to manage issues that may arise, such as connectivity problems when fetching prices, ensuring the script can recover gracefully without crashing. Overall Functionality: The OSRS GE Flipper operates in a loop, continuously monitoring market conditions and executing trades based on the predefined strategies and user settings. By automating these processes, it allows players to focus on other aspects of the game while still making profit from item flipping. The integration of machine learning enhances its capability to adapt to changing market trends, making it a powerful tool for maximizing in-game wealth.   Startup Process: Initialization: The script begins by initializing its core components. This includes setting up variables and data structures necessary for operation. Loading Item Data: The script fetches current item data from the Runescape Wiki API. It retrieves the latest prices and trading volumes for various items available in the Grand Exchange. This ensures that the trading decisions are based on the most recent market information. Model Initialization: The script initializes the Random Forest machine learning model used for price prediction. This involves setting up the training data structure and preparing the model for use. Settings GUI: A graphical user interface (GUI) appears, allowing users to configure the script settings. Users can adjust parameters such as: Profit Margin: The percentage of profit desired from trades. Max Order Time: The time (in milliseconds) that the script will wait for buy/sell orders to be fulfilled. Volume Threshold: The minimum trade volume required for an item to be considered for buying. F2P Mode: An option to restrict trading to Free-to-Play items. Navigating to Grand Exchange: After loading the item data and setting up the model, the script automatically navigates the player character to the Grand Exchange. It checks the player's current location and walks to the designated area if necessary. Start Time Recording: The script records the start time to track the duration of its operation. This information is used later for performance metrics, such as calculating GP earned per hour. Script Activation: Once the initialization and setup are complete, the script enters its main trading loop. Here, it actively monitors market conditions, updates prices, and executes trades based on the AI-driven decision-making process outlined previously. Overall, the startup process ensures that the script is fully prepared to operate effectively, leveraging real-time data and machine learning for optimal trading in the Grand Exchange. Message me on how it goes and if it works.

hello brother thanks for responding. After a little further investigation in the logs. It frequently tells me that it fails to deposit armour. Then it says please ensure your bank is not full! Then it stops the script all together. This happens very frequently and its very frustrating. My bank is for sure not full as well i've made sure of that obviously. 

No.