This is what you need to do to avoid problems with bot transactions that are trying to go through on each block. Don't be a douche, copy the code
<center></a></center>
Using @nectarflower API and the hard work of @thecrazygm to allow it all to happen.
This is just the bot code, not the fetch_market or place_order which this uses.
```
# peake_bot.py
import time
import datetime
import json
import os
from fetch_market import get_orderbook_top
from place_order import place_order, get_open_orders, cancel_order, get_balance # ✅ Uses external module with PEK gas logic
# 🔐 Hive account
HIVE_ACCOUNT = "paulmoon410"
TOKEN = "PEK"
TICK = 0.000001
DELAY = 60 # seconds between cycles
last_gas_time = 20
GAS_INTERVAL = 3720 # seconds (1 hour and 2 minutes)
def maybe_buy_gas(account_name):
global last_gas_time
now = time.time()
print(f"[DEBUG] now: {now}, last_gas_time: {last_gas_time}, elapsed: {now - last_gas_time}, interval: {GAS_INTERVAL}")
if now - last_gas_time > GAS_INTERVAL:
print("Placing SWAP.MATIC buy order (hourly, up to 0.01 at market value, will use all available balance if less)...")
from fetch_market import get_orderbook_top
from place_order import place_order, get_balance
matic_market = get_orderbook_top("SWAP.MATIC")
print(f"[DEBUG] SWAP.MATIC market data: {matic_market}")
if not matic_market or not matic_market.get("lowestAsk"):
print("❌ Could not fetch SWAP.MATIC market price. Skipping buy.")
return
matic_price = float(matic_market["lowestAsk"])
max_qty = 0.01
# Check available SWAP.HIVE balance
swap_hive_balance = get_balance(account_name, "SWAP.HIVE")
print(f"[DEBUG] SWAP.HIVE balance: {swap_hive_balance}")
# Calculate max affordable qty
affordable_qty = swap_hive_balance / matic_price if matic_price > 0 else 0
buy_qty = min(max_qty, affordable_qty)
min_qty = 0.001
if buy_qty < min_qty:
print(f"[INFO] Not enough SWAP.HIVE to buy even the minimum ({min_qty}) SWAP.MATIC. Skipping buy.")
return
print(f"[DEBUG] Attempting to place order: account={account_name}, price={matic_price}, qty={buy_qty}")
try:
result = place_order(account_name, "SWAP.MATIC", matic_price, buy_qty, order_type="buy")
print(f"SWAP.MATIC buy: ✅ Placed order for {buy_qty} at {matic_price}")
print(f"[DEBUG] place_order result: {result}")
except Exception as e:
print(f"SWAP.MATIC buy: ❌ Failed to place order ({e})")
last_gas_time = now
else:
print(f"Skipping SWAP.MATIC buy order (not time yet, {int(GAS_INTERVAL - (now - last_gas_time))}s left).")
def smart_trade(account_name, token, forbidden_user=None):
print(f"\n==============================")
print(f"🤖 Starting Smart Trade for {token}")
print(f"==============================")
try:
open_orders = get_open_orders(account_name, token)
num_open_orders = len(open_orders) if open_orders else 0
all_open_orders = get_open_orders(account_name)
total_open_orders = len(all_open_orders) if all_open_orders else 0
print(f"📊 Open {token} orders: {num_open_orders} | Total open: {total_open_orders}")
ORDER_LIMIT = 198
if num_open_orders >= ORDER_LIMIT or total_open_orders >= ORDER_LIMIT:
print(f"⚠️ Too many open orders. Cancelling oldest...")
if open_orders:
oldest = min(open_orders, key=lambda o: o.get('timestamp', o.get('_id', 0)))
order_id = oldest.get('_id')
try:
success, txid, error = cancel_order(account_name, order_id)
print(f"🗑️ Cancel oldest: {'✅ Success' if success else '❌ Fail'}")
except Exception as e:
print(f"🗑️ Cancel oldest: ❌ Fail ({e})")
else:
print("🗑️ Cancel oldest: ❌ Fail (no open orders)")
maybe_buy_gas(account_name)
print(f"⏭️ Trade for {token} skipped due to order limit.")
print(f"==============================\n")
return
print("✅ Order limit check passed.")
buy_orders = [o for o in open_orders if o.get('type') == 'buy']
sell_orders = [o for o in open_orders if o.get('type') == 'sell']
print(f"🔄 Orders split: {len(buy_orders)} buy | {len(sell_orders)} sell")
market = get_orderbook_top(token)
if not market:
print("❌ Market fetch failed!")
print(f"==============================\n")
return
print("✅ Market fetch success.")
bid = market["highestBid"]
ask = market["lowestAsk"]
buy_price = round(bid + 0.00000001, 8)
sell_price = round(max(ask - 0.00000001, buy_price + 0.00000001), 8)
# --- 20% of HIVE for buys, 20% of LTC for sells ---
hive_balance = get_balance(account_name, "SWAP.HIVE")
ltc_balance = get_balance(account_name, token)
buy_qty = round(hive_balance * 0.20 / buy_price, 8) if buy_price > 0 else 0
sell_qty = round(ltc_balance * 0.20, 8)
```
I was thinking off adding a Forbidden User Function if there was a user abusing the platform
```
# --- Check forbidden user in orderbook ---
# if forbidden_user:
# # Check top of book for forbidden user
# if any(o.get('account') == forbidden_user for o in market.get('buyOrders', [])):
# print(f"[BLOCKED] Top buy order is from forbidden user {forbidden_user}. Skipping buy.")
# return
# if any(o.get('account') == forbidden_user for o in market.get('sellOrders', [])):
# print(f"[BLOCKED] Top sell order is from forbidden user {forbidden_user}. Skipping sell.")
# return
own_min_sell = min([float(o['price']) for o in sell_orders], default=None)
if own_min_sell is not None and buy_price >= own_min_sell:
print("📥 Buy: ❌ Skipped (would cross own sell)")
elif any(abs(float(o['price']) - buy_price) < 1e-8 for o in buy_orders):
print("📥 Buy: ❌ Skipped (already have buy)")
else:
try:
print(f"📥 Placing BUY order for {buy_qty} {token} at {buy_price}...")
place_order(account_name, token, buy_price, buy_qty, order_type="buy")
print("📥 Buy: ✅ Success")
time.sleep(10) # Ensure 10s between buy and sell
except Exception as e:
print(f"📥 Buy: ❌ Fail ({e})")
own_max_buy = max([float(o['price']) for o in buy_orders], default=None)
if own_max_buy is not None and sell_price <= own_max_buy:
print("📤 Sell: ❌ Skipped (would cross own buy)")
elif any(abs(float(o['price']) - sell_price) < 1e-8 for o in sell_orders):
print("📤 Sell: ❌ Skipped (already have sell)")
else:
try:
print(f"📤 Placing SELL order for {sell_qty} {token} at {sell_price}...")
place_order(account_name, token, sell_price, sell_qty, order_type="sell")
print("📤 Sell: ✅ Success")
time.sleep(10) # Ensure 10s after sell as well
except Exception as e:
print(f"📤 Sell: ❌ Fail ({e})")
print(f"🏁 Trade for {token} complete.")
print(f"==============================\n")
except Exception as e:
print(f"❌ Trade: Fail ({e})\n==============================\n")
```
Now here's the piece you don't want to miss... this is offsetting the transactions.
```
if __name__ == "__main__":
cycle = 0
while True:
try:
# Buy
if cycle % 3 == 0:
smart_trade(HIVE_ACCOUNT, TOKEN)
# Sell
elif cycle % 3 == 1:
smart_trade(HIVE_ACCOUNT, TOKEN)
# Gas/Matic
elif cycle % 3 == 2:
maybe_buy_gas(HIVE_ACCOUNT)
cycle = (cycle + 1) % 3
time.sleep(10) # 10s offset between each action
except Exception as e:
print(f"⚠️ Unexpected error: {e}")
# Wait the remainder of the DELAY, minus the 10s already waited
remaining = max(0, DELAY - 10)
if remaining > 0:
time.sleep(remaining)
```
hiveblocks