def __init__(self, minute_model, api_key, secret_key, passphrase, minute_len=30, prediction_ticker='ETH', bitinfo_list=None, is_sandbox_api=True): temp1 = "2018-05-05 00:00:00 EST" temp2 = "2018-06-05 00:00:00 EST" self.price_model = CryptoPriceModel(temp1, temp2, forecast_offset=minute_len, prediction_ticker=prediction_ticker, sym_list=bitinfo_list, time_units='min', model_path=minute_model) self.bitinfo_list = bitinfo_list self.minute_length = minute_len self.prediction_ticker = prediction_ticker.upper() self.prediction = None self.price = None self.product_id = prediction_ticker.upper() + '-USD' self.save_str = 'most_recent' + str(self.price_model.prediction_length) + 'currency_' + self.prediction_ticker + '.h5' if is_sandbox_api: self.api_base = 'https://api-public.sandbox.pro.coinbase.com' self.auth_client = cbpro.AuthenticatedClient(api_key, secret_key, passphrase, api_url=self.api_base) else: self.api_base = 'https://api.pro.coinbase.com' self.auth_client = cbpro.AuthenticatedClient(api_key, secret_key, passphrase, api_url=self.api_base) data = {'Market': 100, 'Algorithm': 100} current_datetime = current_est_time() self.returns = pd.DataFrame(data=data, index=[current_datetime])
def setapi(key, secret, passp): auth_client = cbpro.AuthenticatedClient( key, secret, passp, api_url="https://api-public.sandbox.pro.coinbase.com") return auth_client
def get_private_client(credentials): """Returns the cbpro AuthenticatedClient using the credentials from the parameters dict""" private_client = cbpro.AuthenticatedClient(credentials['KEY'], credentials['SECRET'], credentials['PASSPHRASE'], api_url=credentials['URL']) return private_client
def __init__(self, ticker, time, live_data, do_trade): ''' Constructor ''' #self.GRANULARITY = (60,300,900,3600, 21600, 86400) self.GRANULARITY = [60] self.ticker = ticker self.live_data = live_data self.do_trade = do_trade # self.future_df = self.getFuture() # inialize future as empty dataframe but we might not need it self.future_df = pd.DataFrame() # we need to connect even if data is not live self.login = Login() self.trade_client = cbpro.AuthenticatedClient(self.login.key, self.login.b64secret, self.login.passphrase) if (live_data): self.virtual_time = datetime.datetime.utcnow().replace( microsecond=0, second=0) else: self.virtual_time = time # data is not live, get from file file = r'../data/coinbase_BTC_master.csv' self.file_data = FileDataReader(file)
def __init__(self, API_KEY, SECRET_KEY, PASSPHRASE): self.API_KEY = API_KEY self.SECRET_KEY = SECRET_KEY self.PASSPHRASE = PASSPHRASE self.auth_client = cbpro.AuthenticatedClient(API_KEY, SECRET_KEY, PASSPHRASE) self.public_client = cbpro.PublicClient()
def get_currency_balance(currency, key, secret, passphrase): auth_client = cbpro.AuthenticatedClient(key, secret, passphrase) response = auth_client.get_accounts() for item in response: if item['currency'] == currency: output = float(item['available']) return output
def on_open(ws): global coin_client, sheet print("Connected") scope = [ 'https://www.googleapis.com/auth/spreadsheets', "https://www.googleapis.com/auth/drive.file", "https://www.googleapis.com/auth/drive" ] try: creds = ServiceAccountCredentials.from_json_keyfile_name( 'Sheets API Key.env', scope) except: print("error here") client = gspread.authorize(creds) sheet = client.open('Bitcoin').worksheet("50-100 sma") url = "https://api-public.sandbox.pro.coinbase.com" coin_client = cbpro.AuthenticatedClient(os.getenv("API"), os.getenv("API_SECRET"), os.getenv("PASSPHRASE"), api_url=url) send_data = { "type": "subscribe", "channels": [{ "name": "ticker", "product_ids": ["BTC-USD"] }] } ws.send(json.dumps(send_data))
def __init__(self, key: str, passphrase: str, b64secret: str): ''' init CoinbaseProStats by using an api key, passphrase, and secret which can be created at this link -> https://pro.coinbase.com/profile/api ''' self.auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase)
def init_engine_and_indicators(self): self.initializing = True try: self.cbpro_websocket.close() except: pass # Periods to update indicators for self.indicator_period_list = [] # Periods to actively trade on (typically 1 per product) self.trade_period_list = {} # List of products that we are actually monitoring self.product_list = set() fiat_currency = self.config['fiat'] if self.config['sandbox']: api_url = "https://api-public.sandbox.pro.coinbase.com" else: api_url = "https://api.pro.coinbase.com" auth_client = cbpro.AuthenticatedClient(self.config['key'], self.config['secret'], self.config['passphrase'], api_url=api_url) for cur_period in self.config['periods']: self.logger.debug("INITIALIZING %s", cur_period['name']) if cur_period.get('meta'): new_period = period.MetaPeriod( period_size=(60 * cur_period['length']), fiat=fiat_currency, product=cur_period['product'], name=cur_period['name'], cbpro_client=auth_client) else: new_period = period.Period(period_size=(60 * cur_period['length']), product=cur_period['product'], name=cur_period['name'], cbpro_client=auth_client) self.indicator_period_list.append(new_period) self.product_list.add(cur_period['product']) if cur_period['trade']: if self.trade_period_list.get(cur_period['product']) is None: self.trade_period_list[cur_period['product']] = [] self.trade_period_list[cur_period['product']].append( new_period) max_slippage = Decimal(str(self.config['max_slippage'])) self.trade_engine = engine.TradeEngine(auth_client, product_list=self.product_list, fiat=fiat_currency, is_live=self.config['live'], max_slippage=max_slippage) self.cbpro_websocket = engine.TradeAndHeartbeatWebsocket( fiat=fiat_currency, sandbox=self.config['sandbox']) self.cbpro_websocket.start() self.indicator_period_list[0].verbose_heartbeat = True self.indicator_subsys = indicators.IndicatorSubsystem( self.indicator_period_list) self.last_indicator_update = time.time() self.init_interface() self.initializing = False
def get_cb_client(client_type, key=None, secret=None, passphrase=None, api_url="https://api.pro.coinbase.com"): """ :param client_type: :param key: :param secret: :param passphrase: :param api_url: :return: usage: >>> key='1b19ba867bf0e06f93f583b88825d485' >>> secret = 'TKCdKrstN+eX7KKZAhG08rPCh3Yo7kMcf9CUXEaE9TlQ/HAOzXely9UkdVv4PdVUtieW8eP97I9kXd0d4I2AGQ==' >>> passphrase = 'uihizupz01' >>> api_url = 'https://api.pro.coinbase.com' >>> client = get_cb_client('private', key, secret, passphrase) """ if client_type == 'public': client = cbpro.PublicClient() else: client = cbpro.AuthenticatedClient(key, secret, passphrase, api_url=api_url) return client
def client(): """Client that connects to sandbox API. Relies on authentication information provided in api_config.json""" with open('api_config.json') as file: api_config = json.load(file) c = cbpro.AuthenticatedClient( api_url='https://api-public.sandbox.pro.coinbase.com', **api_config) # Set up account with deposits and orders. Do this by depositing from # the Coinbase USD wallet, which has a fixed value of > $10,000. # # Only deposit if the balance is below some nominal amount. The # exchange seems to freak out if you run up your account balance. coinbase_accounts = c.get_coinbase_accounts() account_info = [x for x in coinbase_accounts if x['name'] == 'USD Wallet'][0] account_usd = account_info['id'] if float(account_info['balance']) < 70000: c.coinbase_deposit(10000, 'USD', account_usd) # Place some orders to generate history c.place_limit_order('BTC-USD', 'buy', 1, 0.01) c.place_limit_order('BTC-USD', 'buy', 2, 0.01) c.place_limit_order('BTC-USD', 'buy', 3, 0.01) return c
def __init__(self, api_key, secret_key, passphrase, sym_list, base_currency='USD', offset_value=70, is_sandbox=False): self.wallets = {} if is_sandbox: api_base = 'https://api-public.sandbox.pro.coinbase.com' auth_client = cbpro.AuthenticatedClient(api_key, secret_key, passphrase, api_url=api_base) sleep(PRIVATE_SLEEP) pub_client = cbpro.PublicClient(api_url=api_base) else: auth_client = cbpro.AuthenticatedClient(api_key, secret_key, passphrase) sleep(PRIVATE_SLEEP) pub_client = cbpro.PublicClient() self.auth = auth_client for product_id in sym_list: # The base can be put in the symbols in the format Quote-Base for use with multiple currencies if (type(base_currency) is list) or (type(base_currency) is tuple): product_dat = product_id.split('-') symbol = product_dat[0] base = product_dat[1] if base not in base_currency: continue else: symbol = product_id base = base_currency self.wallets[product_id] = Wallet(api_key, secret_key, passphrase, base=base, sym=symbol, auth_client=auth_client, pub_client=pub_client) self.wallets[product_id].offset_value = offset_value self.symbols = sym_list
def __init__(self, key, b64secret, passphrase): self.url = "https://api.pro.coinbase.com" self.auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase) self.public_client = cbpro.PublicClient() self.account_data_w_balance = [] self.instrument_list = [] self.set_account_data()
def api(): key = "ENTER_KEY" secret = "ENTER_SECRET" password = "******" auth_client = cbpro.AuthenticatedClient(key, secret, password) data = auth_client.get_product_ticker('COIN-USDC OR COIN-USD') current = (data['price']) return current
def authenticate(self) -> cbpro.AuthenticatedClient: key = self.config['auth'].get('key') passphrase = self.config['auth'].get('passphrase') b64secret = self.config['auth'].get('b64secret') auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase) assert 'message' not in auth_client.get_accounts( ), 'Auth credentials are invalid.' return auth_client
def check_order_status(response, key, secret, passphrase): auth_client = cbpro.AuthenticatedClient(key, secret, passphrase) order_id = response['id'] output = True if order_id is not None: check = auth_client.get_order(order_id) output = check['settled'] return output
def setup_client(config): global client client = cbpro.AuthenticatedClient(config['system']['api_key'], config['system']['secret_key'], config['system']['passphrase'], api_url=config['system']['uri']) setup_api_timeout() return client
def api(): key = "ENTER_CB_KEY" secret = "ENTER_CB_SECRET" password = "******" auth_client = cbpro.AuthenticatedClient(key, secret, password) # change below pair to coin wanted, most are COIN-USD or COIN-USDC data = auth_client.get_product_ticker('BTC-USD') current = (data['price']) return float(current)
def print_cbpro_funding_accounts(requests): cbpro_api = cbpro.AuthenticatedClient(cbpro_apikey, cbpro_secret, cbpro_passphrase) for funding_account in cbpro_api.get_payment_methods(): print('the id number for {} is: {}'.format(funding_account['name'], funding_account['id']))
def __init__(self): self.folder = "./log_cbpro/" self._public_client = cbpro.PublicClient() self._key = os.getenv("API_KEY_SANDBOX") self._b64secret = os.getenv("API_SECRET_SANDBOX") self._passphrase = os.getenv("API_PASSPHRASE_SANDBOX") self._auth_client = cbpro.AuthenticatedClient(self._key, self._b64secret, self._passphrase, api_url="https://api-public.sandbox.pro.coinbase.com")
def __init__(self, api_key, secret_key, passphrase, prediction_ticker='ETH', is_sandbox_api=False, auth_client=None, pub_client=None, base_ticker='USD'): self.product_id = prediction_ticker.upper() + '-' + base_ticker if not (base_ticker == 'USD'): prediction_ticker = self.product_id self.orders = {'buy': {}, 'sell': {}} self.usd_decimal_num = EXCHANGE_CONSTANTS[prediction_ticker][ 'resolution'] self.usd_res = 10**(-self.usd_decimal_num) self.quote_order_min = QUOTE_ORDER_MIN self.base_order_min = EXCHANGE_CONSTANTS[prediction_ticker][ 'base order min'] self.base_decimal_num = EXCHANGE_CONSTANTS[prediction_ticker][ 'base resolution'] self.crypto_res = 10**(-self.base_decimal_num) self.filt_fills = None self.all_fills = None self.order_book = None self.filtered_fill_times = None self.fill_time = 0 if auth_client is None: if is_sandbox_api: self.api_base = 'https://api-public.sandbox.pro.coinbase.com' self.auth_client = cbpro.AuthenticatedClient( api_key, secret_key, passphrase, api_url=self.api_base) self.pub_client = cbpro.PublicClient(api_url=self.api_base) else: self.auth_client = cbpro.AuthenticatedClient( api_key, secret_key, passphrase) self.pub_client = cbpro.PublicClient() else: self.auth_client = auth_client self.pub_client = pub_client
def apiauth(self): #Auth / APIs auth = tweepy.OAuthHandler('xxXXXXXXXXXXXxx', 'xxXXXXXXXXXXXxx') auth.set_access_token('xxXXXXXXXXXXXxx', 'xxXXXXXXXXXXXxx') twitter_api = tweepy.API(auth) # Twitter crypto_api = cryptonator.Cryptonator() # crypto price API b64secret = 'xxXXXXXXXXXXXxx' key = 'xxXXXXXXXXXXXxx' passphrase = 'xxXXXXXXXXXXXxx' auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase) # CoinbasePro return twitter_api, auth_client
def make_trade(pair, amount, trade_type, key, secret, passphrase): auth_client = cbpro.AuthenticatedClient(key, secret, passphrase) if trade_type == 'buy': response = auth_client.buy(order_type='market', product_id=pair, funds=amount) if trade_type == 'sell': response = auth_client.sell(order_type='market', product_id=pair, size=amount) return response
def buy(name): auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase) balance = get_balance("USD-USD") print( auth_client.buy( funds=balance, #USD order_type='market', product_id=name))
def sell(name): auth_client = cbpro.AuthenticatedClient(key, b64secret, passphrase) balance = get_balance(name) print( auth_client.sell( size=balance, #USD order_type='market', product_id=name))
def print_cbpro_funding_accounts(requests): cbpro_apiurl = "https://api-public.sandbox.pro.coinbase.com" if cbpro_sandbox else "https://api.pro.coinbase.com/" cbpro_api = cbpro.AuthenticatedClient(cbpro_apikey, cbpro_secret, cbpro_passphrase, api_url=cbpro_apiurl) for funding_account in cbpro_api.get_payment_methods(): print('the id number for {} is: {}'.format(funding_account['name'], funding_account['id']))
def __init__(self, logs_to_cloud=False, use_real_money=(getenv('USE_REAL_MONEY') == 'YES')): self.logs = Logs(name="trading", to_cloud=logs_to_cloud) self.cb_public = cbpro.PublicClient() self.cb_stream = CBWebsocketClient if use_real_money: key = getenv('CB_PROD_KEY') b64secret = getenv('CB_PROD_B64SECRET') passphrase = getenv('CB_PROD_PASSPHRASE') self.coinbase = cbpro.AuthenticatedClient(key, b64secret, passphrase) else: key = getenv('CB_SANDBOX_KEY') b64secret = getenv('CB_SANDBOX_B64SECRET') passphrase = getenv('CB_SANDBOX_PASSPHRASE') self.coinbase = cbpro.AuthenticatedClient( key, b64secret, passphrase, api_url="https://api-public.sandbox.pro.coinbase.com")
def main(): keys = [] for line in sys.stdin: keys.append(line.strip()) key = keys[0] secret = keys[1] passphrase = keys[2] auth_client = cbpro.AuthenticatedClient(key,secret,passphrase) print(getCurrentPrice(auth_client, 'BTC-USDT', 300))
def __init__(self, API_KEY, API_SECRET, API_PASS, ENV_URL="https://api-public.sandbox.pro.coinbase.com"): self.API_KEY = API_KEY self.API_SECRET = API_SECRET self.API_PASS = API_PASS self.ENV_URL = ENV_URL self.client = cbpro.AuthenticatedClient(self.API_KEY, self.API_SECRET, self.API_PASS, api_url=self.ENV_URL)
def __init__(self, keys, balance=0, currencies=None): self.client = cbp.AuthenticatedClient(keys["API_KEY"], keys["SECRET"], keys["PHRASE"]) self.balance = balance if currencies is None: self.currencies = {} else: self.currencies = currencies self.starting_value = self.get_account_value() self.account_value = self.starting_value