def _get_client(cls): """ Get an authenticated GDAX client :returns: an authenticated GDAX client :raises KeyError: Error raised if environment variables are not set """ try: key = os.environ[GDAXTrader.GDAX_KEY_ENV] secret = os.environ[GDAXTrader.GDAX_SECRET_ENV] passphrase = os.environ[GDAXTrader.GDAX_PASSPHRASE_ENV] except KeyError as error: raise KeyError( 'Missing environment variable for GDAX: '.format(error)) try: api_url = os.environ[GDAXTrader.GDAX_API_URL_ENV] except KeyError: client = gdax.AuthenticatedClient(key, secret, passphrase) else: client = gdax.AuthenticatedClient(key, secret, passphrase, api_url=api_url) return client
def initialize_gdax(test_bool): key, secret, passphrase = load_gdax_auth(test_bool) if test_bool == True: logger.info("Initialize GDAX Sandbox API") bot_db.db.my_db = 'gdax_test' bot_db.db.set_engine() ac = gdax.AuthenticatedClient(key, secret, passphrase, api_url="https://api-public.sandbox.gdax.com") if test_bool == False: logger.info("Initialize live GDAX API") bot_db.db.my_db = 'gdax' bot_db.db.set_engine() ac = gdax.AuthenticatedClient(key, secret, passphrase) return(ac)
def get_last_fill(total_ventas, total_compras): #hace falta pasar variables total ventas auth_client = gdax.AuthenticatedClient(key, b64secret, passphrase) response = auth_client.get_fills() for x in response: for y in x: t = y if (t["order_id"] == last_sell_id): print(bcolors.CLOSED + "Se ejecuta la orden de venta" + bcolors.ENDC) total_operacion_venta = float(t["price"]) * float(t["size"]) print("Total operacion venta: " + str(total_operacion_venta)) total_ventas = total_ventas + total_operacion_venta ########REVISAR ESTE indicador_ventas=indicador_ventas+1 UnboundLocalError: local variable 'indicador_ventas' referenced before assignment return 1 #Valor de indicador #ponemos el indicador para que indique que se realizo una venta.. elif (t["order_id"] == last_buy_id): print(bcolors.CLOSED + "Se ejecuta la orden de compra" + bcolors.ENDC) total_operacion_compra = float(t["price"]) * float(t["size"]) print("Total operacion compra: " + str(total_operacion_compra)) total_compras = total_compras + total_operacion_compra #########REVISAR ESTE indicador_compras=indicador_compras+1 return -1
def buy_product(self, price): if not self.can_buy(): return -1 if price <= 0: raise RuntimeError('Cannot buy for a negative price') #auth_client = gdax.AuthenticatedClient(SANDBOX_API_KEY, SANDBOX_API_SECRET, SANDBOX_API_PASSPHRASE, api_url="https://api-public.sandbox.gdax.com") auth_client = gdax.AuthenticatedClient(API_KEY, API_SECRET, API_PASSPHRASE) amount = round(self.period_euro_limit / price, 8) price = round(price, 8) resp = auth_client.buy(price=price, size=amount, product_id=self.product) print(resp) if 'id' in resp: # Ordine piazzato con successo # TODO: Verificare se l'ordine verrà mai completato print("[", self.product, "] Buy order placed, id: ",resp['id'] ,", status: ", resp['status'], sep='') self.last_buy_time = time() try: with (open(self.file_path, "wb")) as file: pickle.dump(self.last_buy_time, file) except: print("[", self.product, "] Error saving file", self.file_path, sep='') return True return False
def _init_client(self): url = "https://api.gdax.com" if self.sandbox: url = "https://api-public.sandbox.gdax.com" self.client_public = gdax.PublicClient() self.client_private = gdax.AuthenticatedClient( self.api_key,self.api_secret,self.api_pass,url)
def gdax_transactions(): transactions = [] apiclient = gdax.AuthenticatedClient(apikeys.gdax["apiKey"], apikeys.gdax["secret"], apikeys.gdax["password"]) gdax_accounts = apiclient.get_accounts() for a in gdax_accounts: ah = apiclient.get_account_history(account_id=a["id"]) for txs in ah: for tx in txs: created = dp(tx["created_at"]) if tx["type"] in ["fee", "match"]: transactions.append([ created, "gdax", tx["type"], a["currency"], Decimal(tx["amount"]), tx["details"], ]) else: transactions.append([ created, "gdax", tx["type"], a["currency"], Decimal(tx["amount"]), tx["details"], ]) return transactions
def authorize_gdax_account(self, api_key=None, api_secret_key=None, api_passphrase=None): """ Returns an authenticated client given valid api credentials Go to https://www.gdax.com/settings/api to create API credentials. As far as I can tell, the View, Trade and Manage permissions are necessary. (Not 100% sure what Manage does however.) Parameters: api_key: string 32 character string representing the account's api key api_secret_key: string 88 character string representing the account's api secret key api_passphrase: string 11 character string representing the account's api passphrase Returns: authenticated_client: gdax.AuthenticatedClient Authenticated client that has access to GDAX account identified by the API key, secret key and passphrase. """ if api_key is None or api_secret_key is None or api_passphrase is None: raise ValueError( 'Must input API credentials into authorize_gdax_account()') authenticated_client = gdax.AuthenticatedClient( api_key, api_secret_key, api_passphrase) return authenticated_client
def __init__(self): """Initializer.""" config = utils.read_config() self._client = gdax.AuthenticatedClient( key=config['key'], b64secret=config['secret'], passphrase=config['passphrase'])
def buyAtBestPrice(size='0.01', product_id='LTC-EUR'): myInfo = infoPerso.infoPerso() auth_client = gdax.AuthenticatedClient(myInfo.gdax_key, myInfo.gdax_b64secret, myInfo.gdax_passphrase) publicClient = gdax.PublicClient() ticker = publicClient.get_product_ticker(product_id) price = float(ticker['price']) - 0.5 keys = {'size': size, 'product_id': product_id, 'price': price} order = auth_client.buy(**keys) print(order) count = 0 while (count < 60): time.sleep(1) auth_client.cancel_order(order['id']) ticker = publicClient.get_product_ticker(product_id) price = float(ticker['price']) - 0.5 keys = {'size': size, 'product_id': product_id, 'price': price} order = auth_client.buy(**keys) print(order) count = count + 1 return order
def __init__(self, name="Bot", currency="BTC-USD", transition_buffer=0.4, webSocket=None): #obtain credentials, authenticate GDAX client and websocket, and then over-write credentials self._passphrase = "" self._secret = "" self._key = "" self.get_credentials(credentials_file="../../credentials.txt" ) #fills in passphrase, secret, and key self._client = gdax.AuthenticatedClient(self._key, self._secret, self._passphrase) self._socket = webSocket self.scramble_credentials( ) #over-writes the credentials with new characters self._name = name self._fsm = FSM(state_usage=[3, 4, 5]) self._currency = currency self._running = False self._calibration = False # These fields will only be used for fake trading analysis. Each bot will keep a portfolio # and at the end of program execution, we'll plot the bots against each other self._prices_at_trading = [ ] #keeps the price history of the crypto at the trading points self._portfolio_at_trading = [ ] #keeps the value history of the bot's portfolio self._crypto = 0 #set an initial value for fake crypto self._cash = float( self.client().get_product_ticker(product_id=self.currency()) ["price"]) #set an initial fake cash value
def login(): """ Prompts the user for their GDAX API key, secret, and passphrase before logging into the trading system. @return: authenticated GDAX Client object """ # TODO: Add a helper message with GDAX instructions and a security disclaimer while True: print("Enter your GDAX API key: ") api_key = input() print("Enter your secret: ") secret = input() print("Enter your passphrase: ") passphrase = input() print("\nAuthenticating...") gdax_client = gdax.AuthenticatedClient(api_key, secret, passphrase) if True: # TODO: Check if authentication was successful config["STATE"]["LOGGED_IN"] = True config["CREDENTIALS"]["API_KEY"] = api_key config["CREDENTIALS"]["SECRET"] = secret config["CREDENTIALS"]["PASSPHRASE"] = passphrase return gdax_client else: print("\nInvalid credentials. Please try again.\n")
def main(): logging.basicConfig(format="%(asctime)s - %(message)s", datefmt="%m/%d/%Y %I:%M:%S %p", filename="../ctrade.log", level=logging.DEBUG) logging.info("CryptoTrade has started successfully.") auth_client = gdax.AuthenticatedClient("", "", "", api_url="") accounts = auth_client.get_accounts() for i in accounts: if i["currency"] == "BTC": wallet = i base = 3600.0 for _ in range(100): ticker = auth_client.get_product_ticker(product_id="BTC-USD") price = float(ticker["price"]) print(price) if price >= base: newPrice = str(round(price * 1.1, 2)) newSize = str(round(float(wallet["available"]) / 2, 10)) auth_client.sell(price=newPrice, size=newSize, product_id="BTC-USD") print("SELL: {0} BTC at ${1} per".format(newSize, newPrice)) time.sleep(5) accounts = auth_client.get_accounts() for i in accounts: if i["currency"] == "BTC": wallet = i exit(0)
def __init__(self, exchangeName): if exchangeName == "GDAX": self.exchangeName = "GDAX" exchange.auth_client = gdax.AuthenticatedClient( exchange.loginData['key'], exchange.loginData['b64secret'], exchange.loginData['passphrase'], exchange.loginData['api_url'])
def __init__(self, name="Bot", currency="BTC-USD", webSocket=None): #obtain credentials, authenticate GDAX client and websocket, and then over-write credentials self._passphrase = "" self._secret = "" self._key = "" self.get_credentials(credentials_file="../../credentials.txt" ) #fills in passphrase, secret, and key #main body parts self._data_center = DataCenter(self) self._client = gdax.AuthenticatedClient(self._key, self._secret, self._passphrase) self._socket = webSocket self._trade_hands = TradeHands(self) #other bot stuff self._name = name self._currency = currency self._running = False self._fake_crypto = 0 #set an initial value for fake crypto self._fake_cash = 1000 #set an initial fake cash value self._socket.set_data_center(self._data_center) self._socket.set_bot(self) self.scramble_credentials()
def gdax_price(market, ts): if os.path.exists("gdax_price.pickle"): with open("gdax_price.pickle", "rb") as f: p = pickle.load(f) else: p = {} if (market, ts) in p: amt = p[market, ts] else: c = gdax.AuthenticatedClient(apikeys.gdax["apiKey"], apikeys.gdax["secret"], apikeys.gdax["password"]) data = c.get_product_historic_rates( market, start=ts.isoformat(), end=(ts + timedelta(minutes=1)).isoformat()) sleep(0.5) try: amt = Decimal(data[0][1]) except IndexError: print(market, ts, data) raise with open("gdax_price.pickle", "wb") as f: p[market, ts] = amt pickle.dump(p, f) # print(f"gdax price {market} {amt:0.2f}") return amt
def main(argv): if len(argv) < 2: raise IOError("No config file provided. Usage: " + argv[0] + " CONFIG_FILE") config_file = os.path.expanduser(argv[1]) config_parser = ConfigParser() config_parser.read([config_file]) key = config_parser.get("GDAXKeys", "key") secret = config_parser.get("GDAXKeys", "secret") passphrase = config_parser.get("GDAXKeys", "passphrase") auth_client = gdax.AuthenticatedClient(key, secret, passphrase, api_url="https://api.gdax.com") print auth_client.get_accounts() print auth_client.get_product_24hr_stats("BTC-USD") prev_price = -1.0 while True: ticker = auth_client.get_product_ticker("BTC-USD") print(ticker) current_price = float(ticker["price"]) if current_price < (0.95 * prev_price): print "BUY BUY BUY at", current_price prev_price = current_price time.sleep(5)
def get_auth_client(): config = json.loads(open('priv/cred.json').read()) key = config["key"] pf = config["pf"] se = config["se"] api_url = config["api_url"] return gdax.AuthenticatedClient(key, se, pf, api_url=api_url)
def __init__(self): if settings.USE_AUTH_CLIENT: self.client = gdax.AuthenticatedClient(settings.API_KEY, settings.API_SECRET, settings.API_KEY_PASSPHRASE) else: self.client = gdax.PublicClient()
def vende(precio, cantidad): auth_client = gdax.AuthenticatedClient(key, b64secret, passphrase) r = auth_client.sell(price=precio, size=cantidad, product_id=producto) if 'message' in r: print(r['message']) return None else: return r
def __init__(self): with open('../TradingAlgo/secrets.txt') as f: gdax_info = f.readlines() passphrase = (gdax_info[0].split(':'))[1].strip() key = (gdax_info[1].split(':'))[1].strip() secret = (gdax_info[2].split(':'))[1].strip() self.auth_client = gdax.AuthenticatedClient(key, secret.encode('ascii'), passphrase)
def __init__(self, options: ExchangeConfig) -> None: super(GDAXExchange, self).__init__(options) self._type = ExchangeType.GDAX self._last = None self._orders = {} if options.trading_type == TradingType.LIVE: self._key, self._secret, self._passphrase = get_keys_from_environment( 'GDAX') self._client = gdax.AuthenticatedClient(self._key, self._secret, self._passphrase) elif options.trading_type == TradingType.SANDBOX: self._key, self._secret, self._passphrase = get_keys_from_environment( 'GDAX_SANDBOX') self._client = gdax.AuthenticatedClient( self._key, self._secret, self._passphrase, api_url=EXCHANGE_ORDER_ENDPOINT(ExchangeType.GDAX, TradingType.SANDBOX)) val = self._client.get_accounts() if hasattr(self, '_client') else [] print(val) if isinstance(val, dict) and val.get('message') == 'Invalid API Key': raise Exception('Something went wrong with the API Key') self._accounts = [] for jsn in val: currency = str_to_currency_type(jsn.get('currency')) balance = float(jsn.get('balance', 'inf')) id = jsn.get('id', 'id') account = Account(id=id, currency=currency, balance=balance) self._accounts.append(account) self._subscription = [ json.dumps({ "type": "subscribe", "product_id": GDAXExchange.currency_pair_to_string(x) }) for x in options.currency_pairs ] self._heartbeat = json.dumps({"type": "heartbeat", "on": True}) self._seqnum_enabled = False # FIXME?
def initialize_gdax(): global joker joker = False gdax_auth = json.load(open('/home/bitnami/auth/gdax')) secret = gdax_auth['secret'] key = gdax_auth['key'] passphrase = gdax_auth['passphrase'] ac = gdax.AuthenticatedClient(key, secret, passphrase) return (ac)
def readKeys(): with open("keys.txt") as key: keyList = list(map(str, key)) API_KEY = keyList[0][keyList[0].find(":") + 1:keyList[0].find("\\")] API_SECRET = keyList[1][keyList[1].find(":") + 1:keyList[1].find("\\")] PASSPHRASE = keyList[2][keyList[2].find(":") + 1:keyList[2].find("\\")] ID = keyList[3][keyList[3].find(":") + 1:] client = gdax.AuthenticatedClient(API_KEY, API_SECRET, PASSPHRASE) return client, ID
def get_order_list(): auth_client = gdax.AuthenticatedClient(key, b64secret, passphrase) response = auth_client.get_orders() try: #json.loads(response[0]) print(response) #comprobamos si puede decodificarlo como json except ValueError, e: #Si no puede lanzará un error y resp = auth_client.get_orders() #volvemos a invocar a la función. return resp #y devolvemos la respuesta
def get_current_price(): auth_client = gdax.AuthenticatedClient(key, b64secret, passphrase) result = auth_client.get_product_ticker(product_id=producto) if 'price' in result: print(result) return (float(result['price'])) else: response = get_current_price() return response
def initialize_auth_client(self, *args, **kwargs): """ Initialize authorized client for API calls. :param sandbox: boolean, if true then use sandbox mode for API :return: auth_client object """ super().initialize_auth_client(*args, **kwargs) if kwargs.get("sandbox", False): return gdax.AuthenticatedClient( settings.GDAX_SANDBOX_API_KEY, settings.GDAX_SANDBOX_API_SECRET, settings.GDAX_SANDBOX_PASSPHRASE, api_url="https://api-public.sandbox.gdax.com") return gdax.AuthenticatedClient(settings.GDAX_API_KEY, settings.GDAX_API_SECRET, settings.GDAX_PASSPHRASE)
def __init__(self, name): self.name = name self.login = pd.read_csv(r'C:\dev\gdax\login.txt') self.auth_client = gdax.AuthenticatedClient( self.login["BLANK LINE"][1], self.login["BLANK LINE"][2], self.login["BLANK LINE"][0]) self.public_client = gdax.PublicClient() self.acc_db = self.get_all_acc()
def __init__(self, gdax_key, gdax_b64secret, gdax_pass): if len(gdax_key) < 30 or len(gdax_b64secret) < 60 or len( gdax_pass) < 5: raise ValueError( 'Error: Currently only the GDAX API is supported, please provide GDAX credentials' ) self.gdax_ws = gdax_ws.gdaxWS() self.gdax_pub = gdax.PublicClient() self.gdax_auth = gdax.AuthenticatedClient(gdax_key, gdax_b64secret, gdax_pass) logging.debug("Connected to GDAX!")
def cancelOrder(order_id): myInfo = infoPerso.infoPerso() auth_client = gdax.AuthenticatedClient(myInfo.gdax_key, myInfo.gdax_b64secret, myInfo.gdax_passphrase) if order_id: orders = auth_client.cancel_order(order_id) print(orders) else: print('no order to cancel')
def __init__(self, pair, period): config = ConfigParser.ConfigParser() config.read("zeus.ini") locale.setlocale(locale.LC_ALL, 'pt_PT.utf8') self.conn = gdax.AuthenticatedClient(config.get("auth", "key"), config.get("auth", "secret"), config.get("auth", "passphrase")) self.pair = pair self.period = period self.data = []