Bithumb 실제 자동 코인 거래 프로그램 (시장가 매수,매도)

import pandas as pd
import time
import numpy as np
from pybithumb import Bithumb
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM
from sklearn.preprocessing import MinMaxScaler
import jwt
import uuid
import hashlib
import requests
import json
from urllib.parse import urlencode

# API 키 입력
conkey = '' #이곳에 bithumb api키 입력
seckey = '' #이곳에 bithumb secret키 입력
apiUrl = 'https://api.bithumb.com'

# Bithumb 객체 생성
bithumb = Bithumb(conkey, seckey)

# CSV 초기화
csv_filename = "coin_data.csv"
pd.DataFrame(columns=["Coin", "Price", "Buy Orders", "Sell Orders"]).to_csv(csv_filename, index=False)

# 사용자 입력: 확인할 코인의 심볼 입력 및 투자 금액 입력
coin = input("확인할 코인의 심볼을 입력하세요 (예: BTC): ").strip().upper()
investment_amount = float(input("투자할 금액을 입력하세요 (예: 100000): "))

# 현재 보유 코인과 잔액
balance = investment_amount  # 초기 투자 금액
coins_held = 0.0

def see_my_bag():
    payload = {
        'access_key': conkey,
        'nonce': str(uuid.uuid4()),
        'timestamp': round(time.time() * 1000)
    }
    jwt_token = jwt.encode(payload, seckey)
    authorization_token = 'Bearer {}'.format(jwt_token)
    headers = {
    'Authorization': authorization_token
    }

    try:
        # Call API
        response = requests.get(apiUrl + '/v1/accounts', headers=headers)
        # handle to success or fail
        return (response.json())
    except Exception as err:
        # handle exception
        print(err)

# 데이터 수집 함수
def collect_data():
    try:
        orderbook = bithumb.get_orderbook(coin)
        buy_orders = orderbook['bids'][:5]  # 매수 호가 5개
        sell_orders = orderbook['asks'][:5]  # 매도 호가 5개
        price = bithumb.get_current_price(coin)

        buy_orders_str = ", ".join([f"{order['price']} ({order['quantity']})" for order in buy_orders])
        sell_orders_str = ", ".join([f"{order['price']} ({order['quantity']})" for order in sell_orders])

        data = {
            "Coin": [coin],
            "Price": [price],
            "Buy Orders": [buy_orders_str],
            "Sell Orders": [sell_orders_str]
        }

        return data, price

    except Exception as e:
        print(f"Error occurred: {e}")
        return {}, None


# 거래 실행 함수
def execute_trade(action, price):  # price는 매수하고 싶은 금액
    global balance, coins_held, coin
    try:
        current_price = status_price  # 실시간 시장 가격

        if current_price is None:
            print("[알림] 가격 조회 실패. 거래를 종료합니다.")
            return

        if action == "buy":
            if balance < price:
                print(f"[알림] 잔액 부족으로 {price}원만큼 매수할 수 없습니다.")
                return

            requestBody = {
                'market': f'KRW-{coin}',
                'side': 'bid',
                'price': price,
                'ord_type': 'price'
            }

            query = urlencode(requestBody).encode()
            hash = hashlib.sha512()
            hash.update(query)
            query_hash = hash.hexdigest()

            payload = {
                'access_key': conkey,
                'nonce': str(uuid.uuid4()),
                'timestamp': round(time.time() * 1000),
                'query_hash': query_hash,
                'query_hash_alg': 'SHA512',
            }

            jwt_token = jwt.encode(payload, seckey)
            authorization_token = f'Bearer {jwt_token}'

            headers = {
                'Authorization': authorization_token,
                'Content-Type': 'application/json'
            }
            if coins_held == 0:
                response = requests.post(f'{apiUrl}/v1/orders', data=json.dumps(requestBody), headers=headers)
                print(f"[매수 주문 요청] 응답 코드: {response.status_code}")
                print('매수 체결 완료 되었습니다.')
                coins_held = float(see_my_bag()[2]['balance'])
            else :
                print("[알림] 이미 보유한 코인이 있습니다")
                return
            
        elif action == "sell":
            if coins_held <= 0:
                print("[알림] 보유한 코인이 없어 매도할 수 없습니다.")
                return

            # 매도할 코인 수량은 현재 보유 수량 전부
            requestBody = {
                'market': f'KRW-{coin}',
                'side': 'ask',
                'volume': coins_held,
                'ord_type': 'market'  # 시장가 매도
            }

            query = urlencode(requestBody).encode()
            hash = hashlib.sha512()
            hash.update(query)
            query_hash = hash.hexdigest()

            payload = {
                'access_key': conkey,
                'nonce': str(uuid.uuid4()),
                'timestamp': round(time.time() * 1000),
                'query_hash': query_hash,
                'query_hash_alg': 'SHA512',
            }

            jwt_token = jwt.encode(payload, seckey)
            authorization_token = f'Bearer {jwt_token}'

            headers = {
                'Authorization': authorization_token,
                'Content-Type': 'application/json'
            }

            response = requests.post(f'{apiUrl}/v1/orders', data=json.dumps(requestBody), headers=headers)
            if coins_held>0:      
                print('매도 체결이 완료되었습니다.')
                coins_held = 0


    except Exception as e:
        print(f"[거래 오류] {action} 실행 중 오류 발생: {e}")

first_my_krw = float(see_my_bag()[1]['balance'])

# 메인 루프
data_list = []

while True:
    try:
        data, price = collect_data()
        global status_price
        status_price = price
        df = pd.DataFrame(data)
        df.to_csv(csv_filename, mode='a', header=False, index=False)

        data_list.append(price)

        if len(data_list) > 30:
            print("Training model...")
            scaler = MinMaxScaler(feature_range=(0, 1))
            scaled_data = scaler.fit_transform(np.array(data_list).reshape(-1, 1))

            X = []
            y = []
            for i in range(30, len(scaled_data)):
                X.append(scaled_data[i-30:i, 0])
                y.append(scaled_data[i, 0])

            X = np.array(X)
            y = np.array(y)

            X = np.reshape(X, (X.shape[0], X.shape[1], 1))

            model = Sequential()
            model.add(LSTM(units=30, return_sequences=True, input_shape=(X.shape[1], 1)))
            model.add(LSTM(units=30))
            model.add(Dense(units=20))

            model.compile(optimizer='adam', loss='mean_squared_error')
            model.fit(X, y, epochs=12, batch_size=3, verbose=0)

            predicted_price = model.predict(X[-1].reshape(1, X.shape[1], 1))
            predicted_price = scaler.inverse_transform(predicted_price)[0, 0]

            expected_change_rate = ((predicted_price - price) / price) * 100
            print('----------------------------------------------')
            print(f"현재 코인 가격 : {price}")
            print(f"예측된 평균가격: {predicted_price}")
            print(f"예상 등락률: {expected_change_rate:.3f}%")
            print('')
            my_krw = float(see_my_bag()[1]['balance'])
            if coins_held>0:
                purchase_price = float(see_my_bag()[2]['balance']) * float(see_my_bag()[2]['avg_buy_price'])
                my_coin = float(see_my_bag()[2]['balance'])
                my_coin_buy_price = float(see_my_bag()[2]['avg_buy_price'])
                print(f'보유중인 원화 : {my_krw}원')
                print(f'보유중인 코인 : {my_coin} {coin}')
                print(f'평균 매수가 : {my_coin_buy_price}원')

                print(f'보유중인 총 자산 : {my_krw + purchase_price}원')
                status_my_krw = my_krw+purchase_price
                print(f'현재수익률 : {np.round((status_my_krw - first_my_krw)/first_my_krw * 100,3)}%')
                current_price_rate = (status_my_krw - first_my_krw)/first_my_krw * 100
                if current_price_rate > 7 : 
                    execute_trade("sell",investment_amount)
                    print('수익률 7% 달성 완료! 거래를 종료합니다.')
                    break
                elif current_price_rate < -5:
                    execute_trade('sell',investment_amount)
                    print('손실률이 5%를 넘었습니다.. 거래를 종료합니다.')
                    break

            else :
                print(f'보유중인 총 자산 : {my_krw}원')
                print(f'현재수익률 : {(my_krw- first_my_krw)/first_my_krw * 100}%')
            


            if expected_change_rate > 0.3:
                execute_trade("buy", investment_amount)
            elif expected_change_rate < -0.3:
                execute_trade("sell", investment_amount)
            print('----------------------------------------------')
        time.sleep(15)

    except Exception as e:
        print(f"[오류 발생]: {e}")

 

15초마다 현재 코인의 가격을 불러와 csv에 저장하고 데이터가 30개 이상 쌓일시 LSTM 딥러닝으로 다음 주가 예측후 

0.3%이상 오름 예상시 지정한 금액만큼 시장가 매수, 0.3% 이상 하락 예상시 전액 매도, 총 수익률이 7%이상이거나 손해율이 5%이상일 경우 보유한 코인을 전액 시장가 매도한 후 프로그램 실행 종료