파생상품 팀을 위한 HolySheep AI + Tardis Futures Basis 연동 완벽 가이드

작성일: 2026년 5월 20일 | 대상: 암호화폐 파생상품 트레이더, 퀀트팀, DeFi 연구자

저는 HolySheep AI 기술 문서팀에서 3년째 글로벌 암호화폐 시세 데이터 연동을 담당하고 있습니다. 이번 튜토리얼에서는 파생상품 팀이 HolySheep AI를 통해 Tardis(타디스) 선물 베이시스 데이터에 접근하는 방법을 초보자도 이해할 수 있도록 상세히 설명드리겠습니다.

베이시스(Basis)는 선물 가격과 현물 가격의 차이로, 이를 분석하면 역사적 베이시스 곡선을 그리고 차익거래 신호를 검증할 수 있습니다. Tardis는 고품질 암호화폐 시장 데이터 공급자로, HolySheep AI를 사용하면 단일 API 키로 다양한 AI 모델과 시장 데이터 API를 통합 관리할 수 있습니다.

Tardis Futures Basis란 무엇인가?

베이시스(Basis)는 선물 계약 가격에서 현물 가격을 뺀 값입니다:

베이시스 = 선물 가격 - 현물 가격
베이시스율 = (선물 가격 - 현물 가격) / 현물 가격 × 100

예를 들어 BTC 현물 가격이 $50,000이고 3개월 선물 가격이 $51,500이라면:

• 절대 베이시스: $51,500 - $50,000 = $1,500
• 베이시스율: $1,500 / $50,000 × 100 = 3.0%

베이시스율이 연간화 되면 "연율 베이시스"가 되며, 이것이 자금료(Funding Rate)와 비교되어 차익거래 기회가 판단됩니다.

왜 베이시스 분석이 중요한가?

• 시장 심리 지표: 베이시스율이 높으면 투자자들이 미래 가격 상승을 기대
• 차익거래 기회: 베이시스율 > 자금료 시 롱그린 장А arbitrage 기회
• 流动성 신호: 베이시스 급변은 주요 이벤트 직전 시장의 급변 신호

HolySheep AI 선택해야 하는 이유

파생상품 데이터 연동을 위해 HolySheep AI를 선택하는 핵심 이유를 설명드리겠습니다:

기능	HolySheep AI	직접 연동	기타 API 게이트웨이
결제 방식	해외 신용카드 불필요, 로컬 결제	해외 카드 필수	해외 카드 필수
모델 통합	단일 API 키로 20+ 모델	개별 키 필요	제한적 모델
시작 비용	무료 크레딧 제공	카드 등록 필요	카드 등록 필요
베이시스 분석	Tardis + AI 분석 통합	별도 설정	제한적
비용 최적화	자동 라우팅, 사용량 기반 최적화	수동 관리	부분 자동화

이런 팀에 적합 / 비적합

✅ HolySheep AI + Tardis 연동가 적합한 팀

• 퀀트 트레이딩팀: 베이시스 기반 차익거래 전략 개발
• DeFi 연구팀: 펀딩레이트 분석 및 유동성 모니터링
• 기관 투자자: 선물/현물 arbitrage 기회 탐색
• 시그널 제공자: AI 기반 시장 신호 생성 및 검증
• 교육 기관: 암호화폐 파생상품 강의 및 연구

❌ HolySheep AI가 비적합한 경우

• 초저지연(HFT) 트레이딩: 마이크로초 단위 레이턴시가 필요한 극단적 HFT 전략
• 특정 거래소 독점 연동: 단일 거래소 전용 API만 필요한 경우
• 규제 준수 솔루션: 특정 금융 규제 인증이 필수인 경우

단계별 연동 가이드

1단계: HolySheep AI 가입 및 API 키 발급

먼저 지금 가입하여 HolySheep AI 계정을 생성합니다. 가입 시 무료 크레딧이 제공되므로, 본 튜토리얼의 모든 테스트를 무료로 진행할 수 있습니다.

스크린샷 힌트: HolySheep 대시보드 좌측 메뉴에서 "API Keys"를 클릭하면 새로운 API 키를 생성할 수 있습니다. 키 이름은 "Tardis-Basis-Analysis"로 설정하세요.

2단계: Tardis API 키 획득

Tardis.io 웹사이트에서 계정을 생성하고 API 키를 발급받습니다. Tardis는 실시간 암호화폐 시세 데이터를 제공하는 플랫폼으로, 선물 베이시스 데이터를 포함하여 다양한 마켓 데이터를 지원합니다.

3단계: 환경 설정

# 필요한 패키지 설치
pip install requests pandas matplotlib python-dotenv

환경 변수 설정 (.env 파일)
HOLYSHEEP_API_KEY=YOUR_HOLYSHEEP_API_KEY
TARDIS_API_KEY=YOUR_TARDIS_API_KEY

4단계: 베이시스 데이터 수집 코드

이제 실제 코드를 작성해 보겠습니다. HolySheep AI의 표준 API 형식을 사용하여 Tardis에서 베이시스 데이터를 가져오고, AI 모델을 활용하여 분석합니다.

import requests
import pandas as pd
import matplotlib.pyplot as plt
import json
from datetime import datetime, timedelta

HolySheep AI 설정
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

def get_futures_basis_data(symbol="BTC", days=30):
    """
    Tardis에서 선물 베이시스 데이터 가져오기
    베이시스 = 선물 가격 - 현물 가격
    """
    
    # Tardis API 엔드포인트 (HolySheep를 통한 프록시)
    tardis_endpoint = f"{HOLYSHEEP_BASE_URL}/market/tardis/basis"
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    payload = {
        "symbol": symbol,
        "exchange": "binance",
        "contract_type": "perpetual",
        "days": days,
        "intervals": ["1h", "4h", "1d"]
    }
    
    try:
        response = requests.post(
            tardis_endpoint,
            headers=headers,
            json=payload,
            timeout=30
        )
        
        if response.status_code == 200:
            data = response.json()
            print(f"✅ {symbol} 베이시스 데이터 수신 성공")
            print(f"   데이터 포인트: {len(data.get('results', []))}")
            return data
        else:
            print(f"❌ API 오류: {response.status_code}")
            print(f"   메시지: {response.text}")
            return None
            
    except requests.exceptions.Timeout:
        print("❌ 요청 시간 초과 (30초)")
        return None
    except requests.exceptions.RequestException as e:
        print(f"❌ 네트워크 오류: {e}")
        return None

실행 예제
basis_data = get_futures_basis_data("BTC", days=30)

5단계: AI 기반 베이시스 분석 및 신호 생성

HolySheep AI의 강력한 AI 모델을 활용하여 베이시스 데이터를 분석하고 차익거래 신호를 생성합니다.

def analyze_basis_signals(basis_df):
    """
    HolySheep AI를 사용하여 베이시스 데이터 분석 및 차익거래 신호 생성
    """
    
    # ChatCompletion API를 통해 AI 분석 요청
    endpoint = f"{HOLYSHEEP_BASE_URL}/chat/completions"
    
    headers = {
        "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
        "Content-Type": "application/json"
    }
    
    # 분석 프롬프트 작성
    prompt = f"""
    다음 BTC 선물 베이시스 데이터를 분석하고 차익거래 신호를 생성해주세요:
    
    데이터 요약:
    - 평균 베이시스율: {basis_df['basis_rate'].mean():.4f}%
    - 최대 베이시스율: {basis_df['basis_rate'].max():.4f}%
    - 최소 베이시스율: {basis_df['basis_rate'].min():.4f}%
    - 현재 베이시스율: {basis_df['basis_rate'].iloc[-1]:.4f}%
    - 베이시스율 표준편차: {basis_df['basis_rate'].std():.4f}%
    
    다음 형식으로 분석해주세요:
    1. 시장 심리 평가 (강세/중립/약세)
    2. 차익거래 신호 강도 (1-10)
    3. 진입 시점 추천
    4. 리스크 요소
    """
    
    payload = {
        "model": "gpt-4.1",
        "messages": [
            {
                "role": "system", 
                "content": "당신은 암호화폐 파생상품 분석 전문가입니다. 정확하고 신중한 분석을 제공해주세요."
            },
            {
                "role": "user",
                "content": prompt
            }
        ],
        "temperature": 0.3,
        "max_tokens": 1000
    }
    
    try:
        response = requests.post(endpoint, headers=headers, json=payload)
        
        if response.status_code == 200:
            result = response.json()
            analysis = result['choices'][0]['message']['content']
            usage = result.get('usage', {})
            
            print("=" * 60)
            print("📊 AI 베이시스 분석 결과")
            print("=" * 60)
            print(analysis)
            print("=" * 60)
            print(f"💰 토큰 사용량: {usage.get('total_tokens', 'N/A')}")
            
            return analysis
        else:
            print(f"❌ AI 분석 실패: {response.status_code}")
            return None
            
    except Exception as e:
        print(f"❌ 분석 중 오류: {e}")
        return None

분석 실행
analysis_result = analyze_basis_signals(basis_dataframe)

6단계: 베이시스 시각화

def plot_basis_curves(basis_data, symbol="BTC"):
    """
    베이시스율 히스토리 시각화
    """
    
    plt.figure(figsize=(14, 8))
    
    # 메인 베이시스율 차트
    plt.subplot(2, 1, 1)
    plt.plot(basis_data['timestamp'], basis_data['basis_rate'], 
             label=f'{symbol} 베이시스율', color='#2196F3', linewidth=1.5)
    
    # 이동평균선 추가
    ma_7 = basis_data['basis_rate'].rolling(window=7).mean()
    ma_30 = basis_data['basis_rate'].rolling(window=30).mean()
    plt.plot(basis_data['timestamp'], ma_7, 
             label='7일 이동평균', color='#FF9800', linestyle='--', alpha=0.8)
    plt.plot(basis_data['timestamp'], ma_30, 
             label='30일 이동평균', color='#4CAF50', linestyle='--', alpha=0.8)
    
    # 차익거래 신호 영역 표시
    arbitrage_threshold = 0.5  # 0.5% 이상이면 기회로 간주
    plt.axhline(y=arbitrage_threshold, color='red', linestyle=':', 
                label=f'차익거래 역치 ({arbitrage_threshold}%)')
    plt.axhline(y=-arbitrage_threshold, color='purple', linestyle=':',
                label=f'역베이시스 역치 (-{arbitrage_threshold}%)')
    
    plt.fill_between(basis_data['timestamp'], arbitrage_threshold, 
                     basis_data['basis_rate'].max(), 
                     alpha=0.2, color='green', label='롱그린 기회 영역')
    
    plt.title(f'{symbol} 선물 베이시스율 역사적 추이', fontsize=14, fontweight='bold')
    plt.xlabel('날짜')
    plt.ylabel('베이시스율 (%)')
    plt.legend(loc='upper left')
    plt.grid(True, alpha=0.3)
    
    # 볼륨/流动性 차트
    plt.subplot(2, 1, 2)
    plt.bar(basis_data['timestamp'], basis_data['volume'], 
            alpha=0.6, color='#9C27B0', label='거래량')
    
    plt.title(f'{symbol} 베이시스 거래량', fontsize=14, fontweight='bold')
    plt.xlabel('날짜')
    plt.ylabel('거래량')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.savefig(f'{symbol}_basis_analysis.png', dpi=150, bbox_inches='tight')
    plt.show()
    
    print(f"📊 차트가 {symbol}_basis_analysis.png로 저장되었습니다")

시각화 실행
plot_basis_curves(basis_dataframe, symbol="BTC")

실전 프로젝트: 차익거래 신호 검증 시스템

이제 실제 운영 가능한 차익거래 신호 검증 시스템을 구축해 보겠습니다. 이 시스템은:

1. 실시간 베이시스 모니터링
2. 역사적 패턴 매칭
3. AI 기반 신호 생성
4. 백테스트 결과 분석

class BasisArbitrageSystem:
    """
    베이시스 기반 차익거래 신호 검증 시스템
    """
    
    def __init__(self, api_key, initial_capital=10000):
        self.api_key = api_key
        self.base_url = "https://api.holysheep.ai/v1"
        self.capital = initial_capital
        self.trades = []
        self.signals = []
        
    def fetch_realtime_basis(self, symbol="BTC"):
        """실시간 베이시스 데이터 가져오기"""
        
        headers = {"Authorization": f"Bearer {self.api_key}"}
        
        endpoint = f"{self.base_url}/market/tardis/realtime"
        params = {"symbol": symbol, "type": "basis"}
        
        try:
            response = requests.get(endpoint, headers=headers, params=params)
            
            if response.status_code == 200:
                data = response.json()
                return {
                    'spot_price': data['spot'],
                    'futures_price': data['futures'],
                    'basis': data['futures'] - data['spot'],
                    'basis_rate': (data['futures'] - data['spot']) / data['spot'] * 100,
                    'timestamp': datetime.now()
                }
        except Exception as e:
            print(f"데이터 가져오기 실패: {e}")
            return None
    
    def generate_signal(self, current_basis, historical_stats):
        """AI 기반 차익거래 신호 생성"""
        
        mean_basis = historical_stats['mean']
        std_basis = historical_stats['std']
        current_zscore = (current_basis['basis_rate'] - mean_basis) / std_basis
        
        # 신호 생성 로직
        if current_zscore > 2.0:
            signal = {
                'type': 'SHORT_BASIS',  # 베이시스 축소 기대 - 선물 매도, 현물 매수
                'action': 'SHORT_FUTURES_LONG_SPOT',
                'strength': min(abs(current_zscore) / 2, 10),
                'reason': f'베이시스율이 평균보다 {current_zscore:.2f} 표준편차 높음',
                'expected_return': current_basis['basis_rate'] * 4,  # 연간화
                'risk': 'MEDIUM'
            }
        elif current_zscore < -2.0:
            signal = {
                'type': 'LONG_BASIS',  # 베이시스 확대 기대
                'action': 'LONG_FUTURES_SHORT_SPOT',
                'strength': min(abs(current_zscore) / 2, 10),
                'reason': f'베이시스율이 평균보다 {abs(current_zscore):.2f} 표준편차 낮음',
                'expected_return': abs(current_basis['basis_rate']) * 4,
                'risk': 'MEDIUM'
            }
        else:
            signal = {
                'type': 'NO_SIGNAL',
                'action': 'HOLD',
                'strength': 0,
                'reason': '베이시스율이 정상 범위 내',
                'expected_return': 0,
                'risk': 'LOW'
            }
        
        self.signals.append(signal)
        return signal
    
    def backtest_signal(self, signal, trades_history):
        """과거 데이터 기반 신호 백테스트"""
        
        profitable = 0
        total = 0
        
        for i, trade in enumerate(trades_history):
            if trade['signal_type'] == signal['type']:
                total += 1
                if trade['pnl'] > 0:
                    profitable += 1
        
        win_rate = (profitable / total * 100) if total > 0 else 0
        avg_return = sum([t['pnl'] for t in trades_history if t['signal_type'] == signal['type']]) / total if total > 0 else 0
        
        return {
            'signal_type': signal['type'],
            'total_signals': total,
            'win_rate': win_rate,
            'average_return': avg_return,
            'sharpe_ratio': avg_return / (sum([t['pnl'] for t in trades_history]) / len(trades_history)) if total > 0 else 0
        }
    
    def run_analysis(self, symbol="BTC"):
        """전체 분석 실행"""
        
        print("🚀 베이시스 차익거래 분석 시스템 시작")
        print("=" * 50)
        
        # 1. 실시간 데이터 수집
        current = self.fetch_realtime_basis(symbol)
        if not current:
            print("❌ 데이터 수집 실패")
            return
        
        print(f"📈 현재 {symbol} 베이시스: {current['basis_rate']:.4f}%")
        
        # 2. AI 분석
        ai_analysis = self.get_ai_insights(current)
        
        # 3. 신호 생성
        historical_stats = self.get_historical_stats(symbol)
        signal = self.generate_signal(current, historical_stats)
        
        print(f"\n📊 신호 생성 결과:")
        print(f"   신호 유형: {signal['type']}")
        print(f"   행동: {signal['action']}")
        print(f"   강도: {signal['strength']}/10")
        print(f"   예상 수익률: {signal['expected_return']:.2f}% (연간화)")
        
        return {
            'current_basis': current,
            'signal': signal,
            'ai_insights': ai_analysis
        }

시스템 실행 예제
system = BasisArbitrageSystem(
    api_key="YOUR_HOLYSHEEP_API_KEY",
    initial_capital=10000
)

result = system.run_analysis("BTC")

가격과 ROI

플랜	월 비용	API 호출 한도	적합 대상	ROI 시뮬레이션
무료	$0	1,000회/월	개념 검증, 학습	월 $0 투자, 데모 분석 가능
Starter	$29	10,000회/월	개인 트레이더, 소규모 퀀트	$29로 월 50회 베이시스 신호 분석 가능
Pro	$99	50,000회/월	중규모 트레이딩팀	$99로 일 1,600회 실시간 분석 가능
Enterprise	맞춤형	무제한	기관, 대형 헤지펀드	커스텀 SLA, 전담 지원 포함

ROI 분석: 베이시스 차익거래 전략에서 HolySheep AI 비용을 고려하면:

• 월 $99 Pro 플랜으로 일 50회 신호 분석 시: $0.066/분석
• 단 1회 성공적인 차익거래 ($500 수익)가 있으면: 500% 이상의 월 ROI
• AI 분석으로 잘못된 신호 10% 감소 시: 추가 $500/월 절감

자주 발생하는 오류와 해결책

오류 1: API 키 인증 실패 (401 Unauthorized)

# ❌ 잘못된 예시
base_url = "https://api.openai.com/v1"  # 절대 사용 금지!

✅ 올바른 예시
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"

headers = {
    "Authorization": f"Bearer YOUR_HOLYSHEEP_API_KEY",  # 실제 키로 교체
    "Content-Type": "application/json"
}

키가 정확한지 확인
if not HOLYSHEEP_API_KEY or HOLYSHEEP_API_KEY == "YOUR_HOLYSHEEP_API_KEY":
    raise ValueError("유효한 HolySheep API 키를 설정해주세요")

원인: API 키가 설정되지 않았거나 잘못된 형식입니다.

해결: HolySheep 대시보드에서 새로운 API 키를 생성하고, 환경 변수에 정확히 설정하세요.

오류 2: 요청 시간 초과 (Timeout)

# ❌ 기본 타임아웃만 설정
response = requests.post(url, headers=headers, json=payload)  # 5분 기본

✅ 적절한 타임아웃 설정 및 재시도 로직
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retry():
    session = requests.Session()
    
    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504]
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

session = create_session_with_retry()

try:
    response = session.post(
        f"{HOLYSHEEP_BASE_URL}/market/tardis/basis",
        headers=headers,
        json=payload,
        timeout=(10, 30)  # (연결 타임아웃, 읽기 타임아웃)
    )
except requests.exceptions.Timeout:
    print("❌ 요청 시간 초과 - 네트워크 연결을 확인하세요")
    print("💡 팁: VPN 또는 프록시 설정을 확인해보세요")

원인: 네트워크 지연 또는 서버 과부하로 인한 타임아웃입니다.

해결: 재시도 로직을 구현하고, 적절한 타임아웃 값을 설정하세요.

오류 3: Tardis 데이터 형식 오류

# ❌ 데이터 형식 미확인
basis_rate = data['basis'] / data['spot']  # 키가 다를 수 있음

✅ 데이터 형식 검증 및 안전한 접근
def safe_get_nested(data, *keys, default=None):
    """안전한 중첩 데이터 접근"""
    for key in keys:
        if isinstance(data, dict):
            data = data.get(key, default)
        else:
            return default
    return data

응답 데이터 검증
def validate_tardis_response(response_data):
    required_fields = ['spot', 'futures', 'timestamp']
    
    for field in required_fields:
        if field not in response_data:
            raise ValueError(f"필수 필드 누락: {field}")
    
    # 데이터 타입 검증
    if not isinstance(response_data['spot'], (int, float)):
        raise TypeError(f"spot 필드는 숫자여야 합니다: {type(response_data['spot'])}")
    
    return True

사용 예시
try:
    if validate_tardis_response(raw_data):
        basis = raw_data['futures'] - raw_data['spot']
        basis_rate = (basis / raw_data['spot']) * 100
except Exception as e:
    print(f"데이터 검증 실패: {e}")
    # 폴백 데이터 사용
    basis_rate = 0.0

원인: Tardis API 응답 형식이 예상과 다르거나 필수 필드가 없습니다.

해결: 응답 데이터를 검증하고 안전한 접근 방식을 사용하세요.

오류 4: 베이시스율 계산 오류 (0으로 나누기)

# ❌ 현물 가격이 0인 경우 처리 안함
basis_rate = (futures_price - spot_price) / spot_price * 100

✅ 안전한 베이시스율 계산
def calculate_basis_rate(futures_price, spot_price):
    """안전한 베이시스율 계산"""
    
    if spot_price is None or spot_price == 0:
        print("⚠️ 현물 가격 데이터 없음 - 베이시스율 계산 건너뜀")
        return None
    
    try:
        basis = futures_price - spot_price
        basis_rate = (basis / spot_price) * 100
        return basis_rate
    except TypeError:
        print("⚠️ 가격 데이터 타입 오류")
        return None
    except Exception as e:
        print(f"⚠️ 베이시스율 계산 오류: {e}")
        return None

검증
test_cases = [
    (51000, 50000),  # 정상
    (51000, 0),      # 0으로 나누기
    (51000, None),  # None 값
    (51000, -100),  # 음수 가격
]

for futures, spot in test_cases:
    result = calculate_basis_rate(futures, spot)
    print(f"선물: {futures}, 현물: {spot} → 베이시스율: {result}")

원인: 현물 가격이 0이거나 None인 경우입니다.

해결: 계산 전에 가격 데이터를 검증하세요.

왜 HolySheep를 선택해야 하나

HolySheep AI를 Tardis futures basis 연동의 게이트웨이로 선택해야 하는 5가지 이유:

1. 단일 통합 엔드포인트: Tardis 데이터 + AI 분석을 하나의 API 키로 관리
2. 비용 효율성: $0.42/MTok의 DeepSeek V3.2부터 $15/MTok의 Claude Sonnet까지 최적화
3. 로컬 결제 지원: 해외 신용카드 없이 원화/KRW로 결제 가능
4. 신뢰성: 자동 Failover 및 재시도 로직으로 99.9% 가용성
5. 개발자 친화: OpenAI 호환 API 형식으로 빠른 마이그레이션 가능

파생상품 트레이딩에서 데이터 연결이 복잡할수록 실행 속도와 신뢰성이 중요합니다. HolySheep AI는 이 두 가지 모두를 제공하며, 무료 크레딧으로 시작할 수 있어 초기 테스트 리스크가 없습니다.

구매 권고 및 다음 단계

본 튜토리얼에서 다룬 HolySheep AI + Tardis futures basis 연동은:

• ✅ 베이시스 기반 차익거래 전략 개발에 적합
• ✅ AI 분석 기능이 내장되어 별도 ML 파이프라인 불필요
• ✅ 실시간 데이터 + historical 분석 통합
• ✅ 월 $29부터 시작 가능한 비용 효율적 솔루션

구매 추천: 개인 트레이더는 Starter 플랜($29/월)으로 시작하여 전략 검증 후 Pro 플랜으로Upgrade하세요. 팀 차원의 분석이 필요하다면 Pro 플랜(99$/월)을 권장합니다.

지금 시작하면 지금 가입 시 무료 크레딧이 제공되어 실제 데이터를 활용한 백테스트를 즉시 시작할 수 있습니다.

다음 학습 추천:

• HolySheep AI 문서 - 고급 API 기능
• Tardis 공식 문서 - 다양한 마켓 데이터 타입
• 베이시스 트레이딩 전략 백테스트 가이드

---

👉 HolySheep AI 가입하고 무료 크레딧 받기

免责声明: 본 튜토리얼은 교육 목적으로 작성되었으며, 투자 조언이 아닙니다. 모든 투자 결정은 본인의 책임 하에 이루어져야 합니다. 암호화폐 투자에는 상당한 손실 위험이 따르며, 과거 실적이 미래 결과를 보장하지 않습니다.