#!/usr/bin/env python # -*- coding: utf-8 -*- # Copyright (c) 2023-2024 tecnovert # Copyright (c) 2024 The Basicswap developers # Distributed under the MIT software license, see the accompanying # file LICENSE or http://www.opensource.org/licenses/mit-license.php. """ Create offers { "min_seconds_between_offers": Add a random delay between creating offers between min and max, default 60. "max_seconds_between_offers": ^, default "min_seconds_between_offers" * 4 "min_seconds_between_bids": Add a random delay between creating bids between min and max, default 60. "max_seconds_between_bids": ^, default "min_seconds_between_bids" * 4 "wallet_port_override": Used for testing. "offers": [ { "name": Offer template name, eg "Offer 0", will be automatically renamed if not unique. "coin_from": Coin you send. "coin_to": Coin you receive. "amount": Amount to create the offer for. "minrate": Rate below which the offer won't drop. "ratetweakpercent": modify the offer rate from the fetched value, can be negative. "amount_variable": bool, bidder can set a different amount "address": Address offer is sent from, default will generate a new address per offer. "min_coin_from_amt": Won't generate offers if the wallet would drop below min_coin_from_amt. "offer_valid_seconds": Seconds that the generated offers will be valid for. # Optional "enabled": Set to false to ignore offer template. "swap_type": Type of swap, defaults to "adaptor_sig" "min_swap_amount": Sets "amt_bid_min" on the offer, minimum valid bid when offer amount is variable. "amount_step": If set offers will be created for amount values between "amount" and "min_coin_from_amt" in decrements of "amount_step". }, ... ], "bids": [ { "name": Bid template name, must be unique, eg "Bid 0", will be automatically renamed if not unique. "coin_from": Coin you receive. "coin_to": Coin you send. "amount": amount to bid. "max_rate": Maximum rate for bids. "min_coin_to_balance": Won't send bids if wallet amount of "coin_to" would drop below. # Optional "enabled": Set to false to ignore bid template. "max_concurrent": Maximum number of bids to have active at once, default 1. "amount_variable": Can send bids below the set "amount" where possible if true. "max_coin_from_balance": Won't send bids if wallet amount of "coin_from" would be above. "address": Address offer is sent from, default will generate a new address per bid. }, ... ] } """ __version__ = "0.2" import os import json import time import random import shutil import signal import urllib import logging import argparse import threading from urllib.request import urlopen delay_event = threading.Event() DEFAULT_CONFIG_FILE: str = "createoffers.json" DEFAULT_STATE_FILE: str = "createoffers_state.json" def post_req(url: str, json_data=None): req = urllib.request.Request(url, headers={"User-Agent": "Mozilla/5.0"}) if json_data: req.add_header("Content-Type", "application/json; charset=utf-8") post_bytes = json.dumps(json_data).encode("utf-8") req.add_header("Content-Length", len(post_bytes)) else: post_bytes = None return urlopen(req, data=post_bytes, timeout=300).read() def make_json_api_func(host: str, port: int): host = host port = port def api_func(path=None, json_data=None, timeout=300): nonlocal host, port url = f"http://{host}:{port}/json" if path is not None: url += "/" + path if json_data is not None: return json.loads(post_req(url, json_data)) response = urlopen(url, timeout=300).read() return json.loads(response) return api_func def signal_handler(sig, frame) -> None: logging.info("Signal {} detected.".format(sig)) delay_event.set() def findCoin(coin: str, known_coins) -> str: for known_coin in known_coins: if ( known_coin["name"].lower() == coin.lower() or known_coin["ticker"].lower() == coin.lower() ): if known_coin["active"] is False: raise ValueError(f"Inactive coin {coin}") return known_coin["name"] raise ValueError(f"Unknown coin {coin}") def readConfig(args, known_coins): config_path: str = args.configfile num_changes: int = 0 with open(config_path) as fs: config = json.load(fs) if "offers" not in config: config["offers"] = [] if "bids" not in config: config["bids"] = [] if "stealthex" not in config: config["stealthex"] = [] if "min_seconds_between_offers" not in config: config["min_seconds_between_offers"] = 60 print("Set min_seconds_between_offers", config["min_seconds_between_offers"]) num_changes += 1 if "max_seconds_between_offers" not in config: config["max_seconds_between_offers"] = config["min_seconds_between_offers"] * 4 print("Set max_seconds_between_offers", config["max_seconds_between_offers"]) num_changes += 1 if "min_seconds_between_bids" not in config: config["min_seconds_between_bids"] = 60 print("Set min_seconds_between_bids", config["min_seconds_between_bids"]) num_changes += 1 if "max_seconds_between_bids" not in config: config["max_seconds_between_bids"] = config["min_seconds_between_bids"] * 4 print("Set max_seconds_between_bids", config["max_seconds_between_bids"]) num_changes += 1 offer_templates = config["offers"] offer_templates_map = {} num_enabled = 0 for i, offer_template in enumerate(offer_templates): num_enabled += 1 if offer_template.get("enabled", True) else 0 if "name" not in offer_template: print("Naming offer template", i) offer_template["name"] = f"Offer {i}" num_changes += 1 if offer_template["name"] in offer_templates_map: print("Renaming offer template", offer_template["name"]) original_name = offer_template["name"] offset = 2 while f"{original_name}_{offset}" in offer_templates_map: offset += 1 offer_template["name"] = f"{original_name}_{offset}" num_changes += 1 offer_templates_map[offer_template["name"]] = offer_template if "amount_step" not in offer_template: if offer_template.get("min_coin_from_amt", 0) < offer_template["amount"]: print("Setting min_coin_from_amt for", offer_template["name"]) offer_template["min_coin_from_amt"] = offer_template["amount"] num_changes += 1 else: if "min_coin_from_amt" not in offer_template: print("Setting min_coin_from_amt for", offer_template["name"]) offer_template["min_coin_from_amt"] = 0 num_changes += 1 if "address" not in offer_template: print("Setting address to auto for offer", offer_template["name"]) offer_template["address"] = "auto" num_changes += 1 if "ratetweakpercent" not in offer_template: print("Setting ratetweakpercent to 0 for offer", offer_template["name"]) offer_template["ratetweakpercent"] = 0 num_changes += 1 if "amount_variable" not in offer_template: print("Setting amount_variable to True for offer", offer_template["name"]) offer_template["amount_variable"] = True num_changes += 1 if offer_template.get("enabled", True) is False: continue offer_template["coin_from"] = findCoin(offer_template["coin_from"], known_coins) offer_template["coin_to"] = findCoin(offer_template["coin_to"], known_coins) config["num_enabled_offers"] = num_enabled bid_templates = config["bids"] bid_templates_map = {} num_enabled = 0 for i, bid_template in enumerate(bid_templates): num_enabled += 1 if bid_template.get("enabled", True) else 0 if "name" not in bid_template: print("Naming bid template", i) bid_template["name"] = f"Bid {i}" num_changes += 1 if bid_template["name"] in bid_templates_map: print("Renaming bid template", bid_template["name"]) original_name = bid_template["name"] offset = 2 while f"{original_name}_{offset}" in bid_templates_map: offset += 1 bid_template["name"] = f"{original_name}_{offset}" num_changes += 1 bid_templates_map[bid_template["name"]] = bid_template if bid_template.get("min_swap_amount", 0.0) < 0.001: print("Setting min_swap_amount for bid template", bid_template["name"]) bid_template["min_swap_amount"] = 0.001 if "address" not in bid_template: print("Setting address to auto for bid", bid_template["name"]) bid_template["address"] = "auto" num_changes += 1 if bid_template.get("enabled", True) is False: continue bid_template["coin_from"] = findCoin(bid_template["coin_from"], known_coins) bid_template["coin_to"] = findCoin(bid_template["coin_to"], known_coins) config["num_enabled_bids"] = num_enabled num_enabled = 0 stealthex_swaps = config["stealthex"] for i, swap in enumerate(stealthex_swaps): num_enabled += 1 if swap.get("enabled", True) else 0 if swap.get("enabled", True) is False: continue swap["coin_from"] = findCoin(swap["coin_from"], known_coins) config["num_enabled_swaps"] = num_enabled if num_changes > 0: shutil.copyfile(config_path, config_path + ".last") with open(config_path, "w") as fp: json.dump(config, fp, indent=4) return config def write_state(statefile, script_state): if os.path.exists(statefile): shutil.copyfile(statefile, statefile + ".last") with open(statefile, "w") as fp: json.dump(script_state, fp, indent=4) def main(): parser = argparse.ArgumentParser(description=__doc__) parser.add_argument( "-v", "--version", action="version", version="%(prog)s {version}".format(version=__version__), ) parser.add_argument( "--host", dest="host", help="RPC host (default=127.0.0.1)", type=str, default="127.0.0.1", required=False, ) parser.add_argument( "--port", dest="port", help="RPC port (default=12700)", type=int, default=12700, required=False, ) parser.add_argument( "--oneshot", dest="oneshot", help="Exit after one iteration (default=false)", required=False, action="store_true", ) parser.add_argument( "--debug", dest="debug", help="Print extra debug messages (default=false)", required=False, action="store_true", ) parser.add_argument( "--configfile", dest="configfile", help=f"config file path (default={DEFAULT_CONFIG_FILE})", type=str, default=DEFAULT_CONFIG_FILE, required=False, ) parser.add_argument( "--statefile", dest="statefile", help=f"state file path (default={DEFAULT_STATE_FILE})", type=str, default=DEFAULT_STATE_FILE, required=False, ) args = parser.parse_args() read_json_api = make_json_api_func(args.host, args.port) if not os.path.exists(args.configfile): raise ValueError(f'Config file "{args.configfile}" not found.') known_coins = read_json_api("coins") coins_map = {} for known_coin in known_coins: coins_map[known_coin["name"]] = known_coin script_state = {} if os.path.exists(args.statefile): with open(args.statefile) as fs: script_state = json.load(fs) signal.signal(signal.SIGINT, signal_handler) while not delay_event.is_set(): # Read config each iteration so they can be modified without restarting config = readConfig(args, known_coins) offer_templates = config["offers"] random.shuffle(offer_templates) bid_templates = config["bids"] random.shuffle(bid_templates) stealthex_swaps = config["stealthex"] random.shuffle(bid_templates) # override wallet api calls for testing if "wallet_port_override" in config: wallet_api_port = int(config["wallet_port_override"]) print(f"Overriding wallet api port: {wallet_api_port}") read_json_api_wallet = make_json_api_func(args.host, wallet_api_port) else: read_json_api_wallet = read_json_api try: sent_offers = read_json_api("sentoffers", {"active": "active"}) if args.debug and len(offer_templates) > 0: print( "Processing {} offer template{}".format( config["num_enabled_offers"], "s" if config["num_enabled_offers"] != 1 else "", ) ) for offer_template in offer_templates: if offer_template.get("enabled", True) is False: continue offers_found = 0 coin_from_data = coins_map[offer_template["coin_from"]] coin_to_data = coins_map[offer_template["coin_to"]] wallet_from = read_json_api_wallet( "wallets/{}".format(coin_from_data["ticker"]) ) for offer in sent_offers: created_offers = script_state.get("offers", {}) prev_template_offers = created_offers.get( offer_template["name"], {} ) if next( ( x for x in prev_template_offers if x["offer_id"] == offer["offer_id"] ), None, ): offers_found += 1 if float(wallet_from["balance"]) <= float( offer_template["min_coin_from_amt"] ): offer_id = offer["offer_id"] print( "Revoking offer {}, wallet from balance below minimum".format( offer_id ) ) result = read_json_api(f"revokeoffer/{offer_id}") print("revokeoffer", result) if offers_found > 0: continue max_offer_amount: float = offer_template["amount"] min_offer_amount: float = offer_template.get( "amount_step", max_offer_amount ) wallet_balance: float = float(wallet_from["balance"]) min_wallet_from_amount: float = float( offer_template["min_coin_from_amt"] ) if wallet_balance - min_offer_amount <= min_wallet_from_amount: print( "Skipping template {}, wallet from balance below minimum".format( offer_template["name"] ) ) continue offer_amount: float = max_offer_amount if wallet_balance - max_offer_amount <= min_wallet_from_amount: available_balance: float = wallet_balance - min_wallet_from_amount min_steps: int = available_balance // min_offer_amount assert min_steps > 0 # Should not be possible, checked above offer_amount = min_offer_amount * min_steps delay_next_offer_before = script_state.get("delay_next_offer_before", 0) if delay_next_offer_before > int(time.time()): print("Delaying offers until {}".format(delay_next_offer_before)) break """ received_offers = read_json_api(args.port, 'offers', {'active': 'active', 'include_sent': False, 'coin_from': coin_from_data['id'], 'coin_to': coin_to_data['id']}) print('received_offers', received_offers) TODO - adjust rates based on existing offers """ rates = read_json_api( "rates", {"coin_from": coin_from_data["id"], "coin_to": coin_to_data["id"]}, ) print("Rates", rates) coingecko_rate = float(rates["coingecko"]["rate_inferred"]) use_rate = coingecko_rate if offer_template["ratetweakpercent"] != 0: print( "Adjusting rate {} by {}%.".format( use_rate, offer_template["ratetweakpercent"] ) ) tweak = offer_template["ratetweakpercent"] / 100.0 use_rate += use_rate * tweak if use_rate < offer_template["minrate"]: print("Warning: Clamping rate to minimum.") use_rate = offer_template["minrate"] print( "Creating offer for: {} at rate: {}".format( offer_template, use_rate ) ) template_from_addr = offer_template["address"] offer_data = { "addr_from": ( -1 if template_from_addr == "auto" else template_from_addr ), "coin_from": coin_from_data["ticker"], "coin_to": coin_to_data["ticker"], "amt_from": offer_amount, "amt_var": offer_template["amount_variable"], "valid_for_seconds": offer_template.get( "offer_valid_seconds", config.get("offer_valid_seconds", 3600) ), "rate": use_rate, "swap_type": offer_template.get("swap_type", "adaptor_sig"), "lockhrs": "24", "automation_strat_id": 1, } if "min_swap_amount" in offer_template: offer_data["amt_bid_min"] = offer_template["min_swap_amount"] if args.debug: print("offer data {}".format(offer_data)) new_offer = read_json_api("offers/new", offer_data) if "error" in new_offer: raise ValueError( "Server failed to create offer: {}".format(new_offer["error"]) ) print("New offer: {}".format(new_offer["offer_id"])) if "offers" not in script_state: script_state["offers"] = {} template_name = offer_template["name"] if template_name not in script_state["offers"]: script_state["offers"][template_name] = [] script_state["offers"][template_name].append( {"offer_id": new_offer["offer_id"], "time": int(time.time())} ) max_seconds_between_offers = config["max_seconds_between_offers"] min_seconds_between_offers = config["min_seconds_between_offers"] time_between_offers = min_seconds_between_offers if max_seconds_between_offers > min_seconds_between_offers: time_between_offers = random.randint( min_seconds_between_offers, max_seconds_between_offers ) script_state["delay_next_offer_before"] = ( int(time.time()) + time_between_offers ) write_state(args.statefile, script_state) if args.debug and len(bid_templates) > 0: print( "Processing {} bid template{}".format( config["num_enabled_bids"], "s" if config["num_enabled_bids"] != 1 else "", ) ) for bid_template in bid_templates: if bid_template.get("enabled", True) is False: continue delay_next_bid_before = script_state.get("delay_next_bid_before", 0) if delay_next_bid_before > int(time.time()): print("Delaying bids until {}".format(delay_next_bid_before)) break # Check bids in progress max_concurrent = bid_template.get("max_concurrent", 1) if "bids" not in script_state: script_state["bids"] = {} template_name = bid_template["name"] if template_name not in script_state["bids"]: script_state["bids"][template_name] = [] previous_bids = script_state["bids"][template_name] bids_in_progress: int = 0 for previous_bid in previous_bids: if not previous_bid["active"]: continue previous_bid_id = previous_bid["bid_id"] previous_bid_info = read_json_api(f"bids/{previous_bid_id}") bid_state = previous_bid_info["bid_state"] if bid_state in ( "Completed", "Timed-out", "Abandoned", "Error", "Rejected", ): print( f"Marking bid inactive {previous_bid_id}, state {bid_state}" ) previous_bid["active"] = False write_state(args.statefile, script_state) continue if bid_state in ("Sent", "Received") and previous_bid_info[ "expired_at" ] < int(time.time()): print(f"Marking bid inactive {previous_bid_id}, expired") previous_bid["active"] = False write_state(args.statefile, script_state) continue bids_in_progress += 1 if bids_in_progress >= max_concurrent: print("Max concurrent bids reached for template") continue # Bidder sends coin_to and receives coin_from coin_from_data = coins_map[bid_template["coin_from"]] coin_to_data = coins_map[bid_template["coin_to"]] page_limit: int = 25 offers_options = { "active": "active", "include_sent": False, "coin_from": coin_from_data["id"], "coin_to": coin_to_data["id"], "with_extra_info": True, "sort_by": "rate", "sort_dir": "asc", "offset": 0, "limit": page_limit, } received_offers = [] for i in range(1000000): # for i in itertools.count() page_offers = read_json_api("offers", offers_options) if len(page_offers) < 1: break received_offers += page_offers offers_options["offset"] = offers_options["offset"] + page_limit if i > 100: print(f"Warning: Broke offers loop at: {i}") break if args.debug: print("Received Offers", received_offers) for offer in received_offers: offer_id = offer["offer_id"] offer_amount = float(offer["amount_from"]) offer_rate = float(offer["rate"]) bid_amount = bid_template["amount"] min_swap_amount = bid_template.get( "min_swap_amount", 0.01 ) # TODO: Make default vary per coin can_adjust_offer_amount: bool = offer["amount_negotiable"] can_adjust_bid_amount: bool = bid_template.get( "amount_variable", True ) can_adjust_amount: bool = ( can_adjust_offer_amount and can_adjust_bid_amount ) if offer_amount < min_swap_amount: if args.debug: print(f"Offer amount below min swap amount bid {offer_id}") continue if can_adjust_offer_amount is False and offer_amount > bid_amount: if args.debug: print(f"Bid amount too low for offer {offer_id}") continue if bid_amount > offer_amount: if can_adjust_bid_amount: bid_amount = offer_amount else: if args.debug: print(f"Bid amount too high for offer {offer_id}") continue if offer_rate > bid_template["maxrate"]: if args.debug: print(f"Bid rate too low for offer {offer_id}") continue sent_bids = read_json_api( "sentbids", { "offer_id": offer["offer_id"], "with_available_or_active": True, }, ) if len(sent_bids) > 0: if args.debug: print(f"Already bidding on offer {offer_id}") continue offer_identity = read_json_api( "identities/{}".format(offer["addr_from"]) ) if len(offer_identity) > 0: id_offer_from = offer_identity[0] automation_override = id_offer_from["automation_override"] if automation_override == 2: if args.debug: print( f"Not bidding on offer {offer_id}, automation_override ({automation_override})." ) continue if automation_override == 1: if args.debug: print( "Offer address from {}, set to always accept.".format( offer["addr_from"] ) ) else: successful_sent_bids = id_offer_from[ "num_sent_bids_successful" ] failed_sent_bids = id_offer_from["num_sent_bids_failed"] if ( failed_sent_bids > 3 and failed_sent_bids > successful_sent_bids ): if args.debug: print( f"Not bidding on offer {offer_id}, too many failed bids ({failed_sent_bids})." ) continue validateamount: bool = False max_coin_from_balance = bid_template.get( "max_coin_from_balance", -1 ) if max_coin_from_balance > 0: wallet_from = read_json_api_wallet( "wallets/{}".format(coin_from_data["ticker"]) ) total_balance_from = float(wallet_from["balance"]) + float( wallet_from["unconfirmed"] ) if args.debug: print(f"Total coin from balance {total_balance_from}") if total_balance_from + bid_amount > max_coin_from_balance: if ( can_adjust_amount and max_coin_from_balance - total_balance_from > min_swap_amount ): bid_amount = max_coin_from_balance - total_balance_from validateamount = True print(f"Reduced bid amount to {bid_amount}") else: if args.debug: print( f"Bid amount would exceed maximum wallet total for offer {offer_id}" ) continue min_coin_to_balance = bid_template["min_coin_to_balance"] if min_coin_to_balance > 0: wallet_to = read_json_api_wallet( "wallets/{}".format(coin_to_data["ticker"]) ) total_balance_to = float(wallet_to["balance"]) + float( wallet_to["unconfirmed"] ) if args.debug: print(f"Total coin to balance {total_balance_to}") swap_amount_to = bid_amount * offer_rate if total_balance_to - swap_amount_to < min_coin_to_balance: if can_adjust_amount: adjusted_swap_amount_to = ( total_balance_to - min_coin_to_balance ) adjusted_bid_amount = ( adjusted_swap_amount_to / offer_rate ) if adjusted_bid_amount > min_swap_amount: bid_amount = adjusted_bid_amount validateamount = True print(f"Reduced bid amount to {bid_amount}") swap_amount_to = adjusted_bid_amount * offer_rate if total_balance_to - swap_amount_to < min_coin_to_balance: if args.debug: print( f"Bid amount would exceed minimum coin to wallet total for offer {offer_id}" ) continue if validateamount: bid_amount = read_json_api( "validateamount", { "coin": coin_from_data["ticker"], "amount": bid_amount, "method": "rounddown", }, ) bid_data = { "offer_id": offer["offer_id"], "amount_from": bid_amount, } if "address" in bid_template: addr_from = bid_template["address"] if addr_from != -1 and addr_from != "auto": bid_data["addr_from"] = addr_from if config.get("test_mode", False): print("Would create bid: {}".format(bid_data)) bid_id = "simulated" else: if args.debug: print("Creating bid: {}".format(bid_data)) new_bid = read_json_api("bids/new", bid_data) if "error" in new_bid: raise ValueError( "Server failed to create bid: {}".format( new_bid["error"] ) ) print( "New bid: {} on offer {}".format( new_bid["bid_id"], offer["offer_id"] ) ) bid_id = new_bid["bid_id"] script_state["bids"][template_name].append( {"bid_id": bid_id, "time": int(time.time()), "active": True} ) max_seconds_between_bids = config["max_seconds_between_bids"] min_seconds_between_bids = config["min_seconds_between_bids"] if max_seconds_between_bids > min_seconds_between_bids: time_between_bids = random.randint( min_seconds_between_bids, max_seconds_between_bids ) else: time_between_bids = min_seconds_between_bids script_state["delay_next_bid_before"] = ( int(time.time()) + time_between_bids ) write_state(args.statefile, script_state) break # Create max one bid per iteration if args.debug and len(stealthex_swaps) > 0: print( "Processing {} stealthex template{}".format( config["num_enabled_swaps"], "s" if config["num_enabled_swaps"] != 1 else "", ) ) for stealthex_swap in stealthex_swaps: if stealthex_swap.get("enabled", True) is False: continue coin_from_data = coins_map[stealthex_swap["coin_from"]] wallet_from = read_json_api_wallet( "wallets/{}".format(coin_from_data["ticker"]) ) current_balance = float(wallet_from["balance"]) min_balance_from = float(stealthex_swap["min_balance_from"]) min_swap_amount = float(stealthex_swap["min_amount_tx"]) max_swap_amount = float(stealthex_swap["max_amount_tx"]) # TODO: Check range limits if current_balance >= min_balance_from + min_swap_amount: swap_amount = max_swap_amount if current_balance - swap_amount < min_balance_from: swap_amount = max( min_swap_amount, current_balance - min_balance_from ) estimate_url = "https://api.stealthex.io/api/v2/estimate/{}/{}?amount={}&api_key={}&fixed=true".format( coin_from_data["ticker"].lower(), stealthex_swap["coin_to"].lower(), swap_amount, stealthex_swap["api_key"], ) if args.debug: print(f"Estimate URL: {estimate_url}") estimate_response = json.loads(post_req(estimate_url)) amount_to = float(estimate_response["estimated_amount"]) rate = swap_amount / amount_to min_rate = float(stealthex_swap["min_rate"]) if rate < min_rate: if args.debug: print( "Stealthex rate {} below minimum {} for {} to {}".format( rate, min_rate, coin_from_data["ticker"], stealthex_swap["coin_to"], ) ) continue exchange_url = ( "https://api.stealthex.io/api/v2/exchange?api_key={}".format( stealthex_swap["api_key"] ) ) address_to = stealthex_swap.get("receive_address", "auto") if address_to == "auto": address_to = read_json_api( "wallets/{}/nextdepositaddr".format( stealthex_swap["coin_to"] ) ) address_refund = stealthex_swap.get("refund_address", "auto") if address_refund == "auto": address_refund = read_json_api( "wallets/{}/nextdepositaddr".format( coin_from_data["ticker"] ) ) exchange_data = { "currency_from": coin_from_data["ticker"].lower(), "currency_to": stealthex_swap["coin_to"].lower(), "address_to": address_to, "amount_from": swap_amount, "fixed": True, # 'extra_id_to': # 'referral': "refund_address": address_refund, # 'refund_extra_id': "rate_id": estimate_response["rate_id"], } if args.debug: print(f"Exchange URL: {estimate_url}") print(f"Exchange data: {exchange_data}") exchange_response = json.loads( post_req(exchange_url, exchange_data) ) if "Error" in exchange_response: raise ValueError("Exchange error " + exchange_response) raise ValueError("TODO") except Exception as e: print(f"Error: {e}.") if args.oneshot: break print("Looping indefinitely, ctrl+c to exit.") delay_event.wait(60) print("Done.") if __name__ == "__main__": main()