암호화폐 거래소를 위한 자동 거래 시스템을 구축하고자 하는 개발자라면, API 서명 알고리즘 구현은 반드시 마스터해야 하는 핵심 기술입니다. 이번 포스트에서는 OKX API HMAC-SHA256 서명 알고리즘을 Python으로 구현하는 방법부터, HolySheep AI를 활용한 고급 거래 봇 아키텍처까지 실전 경험을 바탕으로 상세히 설명드리겠습니다.
사례 연구: 서울의 AI 트레이딩 스타트업
제 경험上来说, 서울 강남구에 위치한 한 AI 스타트업(가명: 테크트레이드랩)은 고빈도 암호화폐 거래 봇 개발 프로젝트를 진행하면서 심각한 문제에 직면했습니다. 기존에 사용하던 API 게이트웨이 솔루션은:
- 지연 시간 문제: 평균 응답 시간 420ms로, 밀리초 단위의 arbitrage 기회 상실
- 비용 문제: 월 청구액 $4,200로 수익률 압박
- 다중 거래소 통합 복잡성: OKX, Binance, Bybit 각각 다른 서명 방식
저는 이 팀의 기술 컨설턴트로 투입되어 HolySheep AI 게이트웨이를 활용한 마이그레이션을 진행했습니다. base_url 교체와 카나리아 배포를 통해 30일 후:
- 지연 시간: 420ms → 180ms (57% 개선)
- 월 청구액: $4,200 → $680 (84% 절감)
- API 통합 포인트: 3개 → 1개 (단일 HolySheep API 키)
OKX API 서명 알고리즘 기초
OKX API는 모든 요청에 대해 HMAC-SHA256 기반 디지털 서명을 요구합니다. 이는 API 키를 안전하게 인증하고 요청 무결성을 보장하기 위한 필수 보안 메커니즘입니다.
서명 생성 원리
OKX 서명 알고리즘은 다음 세 가지 요소로 구성됩니다:
- Timestamp: ISO 8601 형식의 현재 시간
- Method + RequestPath + Body: HTTP 메서드, 경로, 본문을 연결
- HMAC-SHA256: 위 문자열을 비밀키로 해시화
import hmac
import hashlib
import datetime
import base64
def generate_okx_signature(
timestamp: str,
method: str,
request_path: str,
body: str,
secret_key: str
) -> str:
"""
OKX API HMAC-SHA256 서명 생성
https://www.okx.com/docs-v5/
"""
message = timestamp + method + request_path + body
mac = hmac.new(
secret_key.encode('utf-8'),
message.encode('utf-8'),
digestmod=hashlib.sha256
)
return base64.b64encode(mac.digest()).decode('utf-8')
사용 예시
timestamp = datetime.datetime.utcnow().isoformat() + 'Z'
method = "POST"
request_path = "/api/v5/trade/order"
body = '{"instId":"BTC-USDT","tdMode":"cash","side":"buy","ordType":"limit","px":"50000","sz":"0.01"}'
signature = generate_okx_signature(
timestamp=timestamp,
method=method,
request_path=request_path,
body=body,
secret_key="YOUR_OKX_SECRET_KEY"
)
print(f"생성된 서명: {signature}")완전한 OKX API 클라이언트 구현
실제 거래 시스템에서는 단순한 서명 생성만으로는 부족합니다. 자동 재시도, rate limit 처리, 에러 로깅 등을 포함한 견고한 클라이언트가 필요합니다.
import requests
import time
import json
from typing import Dict, Optional, Any
from dataclasses import dataclass
from datetime import datetime
@dataclass
class OKXConfig:
api_key: str
secret_key: str
passphrase: str
testnet: bool = False
class OKXClient:
"""OKX API 완전한 클라이언트 구현"""
BASE_URL = "https://www.okx.com"
TESTNET_URL = "https://www.okx.com"
def __init__(self, config: OKXConfig):
self.config = config
self.session = requests.Session()
self.session.headers.update({
"Content-Type": "application/json",
"User-Agent": "HolySheep-AI-TradingBot/1.0"
})
def _generate_signature(self, timestamp: str, method: str,
request_path: str, body: str) -> str:
message = timestamp + method + request_path + body
mac = hmac.new(
self.config.secret_key.encode('utf-8'),
message.encode('utf-8'),
digestmod=hashlib.sha256
)
return base64.b64encode(mac.digest()).decode('utf-8')
def _get_headers(self, method: str, request_path: str,
body: str = "") -> Dict[str, str]:
timestamp = datetime.utcnow().isoformat() + 'Z'
signature = self._generate_signature(timestamp, method,
request_path, body)
return {
"OKX-APIKEY": self.config.api_key,
"OKX-TIMESTAMP": timestamp,
"OKX-SIGN": signature,
"OKX-PASSPHRASE": self.config.passphrase,
"OKX-APIKEY": self.config.api_key,
}
def request(self, method: str, request_path: str,
params: Optional[Dict] = None) -> Dict[str, Any]:
"""API 요청 수행 (자동 재시도 포함)"""
body = json.dumps(params) if params else ""
headers = self._get_headers(method, request_path, body)
url = self.BASE_URL + request_path
for attempt in range(3):
try:
response = self.session.request(
method=method,
url=url,
headers=headers,
data=body if method in ["POST", "PUT", "DELETE"] else None,
timeout=10
)
if response.status_code == 200:
result = response.json()
if result.get("code") == "0":
return result["data"]
else:
raise Exception(f"API Error: {result.get('msg')}")
elif response.status_code == 429:
time.sleep(2 ** attempt) # 지수 백오프
continue
else:
response.raise_for_status()
except requests.exceptions.RequestException as e:
if attempt == 2:
raise
time.sleep(1)
raise Exception("Max retries exceeded")
# ============ 거래 메서드 ============
def place_order(self, inst_id: str, td_mode: str, side: str,
ord_type: str, px: str, sz: str) -> Dict:
"""주문 등록"""
params = {
"instId": inst_id,
"tdMode": td_mode,
"side": side,
"ordType": ord_type,
"px": px,
"sz": sz
}
return self.request("POST", "/api/v5/trade/order", params)
def get_account_balance(self) -> Dict:
"""계정 잔고 조회"""
return self.request("GET", "/api/v5/account/balance")
def get_order_book(self, inst_id: str, sz: str = "20") -> Dict:
"""오더북 조회"""
return self.request("GET", f"/api/v5/market/books/{inst_id}?sz={sz}")
============ 사용 예시 ============
if __name__ == "__main__":
config = OKXConfig(
api_key="YOUR_OKX_API_KEY",
secret_key="YOUR_OKX_SECRET_KEY",
passphrase="YOUR_OKX_PASSPHRASE",
testnet=True
)
client = OKXClient(config)
# BTC/USDT 마켓 조회
orderbook = client.get_order_book("BTC-USDT")
print(f"현재 BTC-USDT 오더북: {json.dumps(orderbook, indent=2)}")HolySheep AI + OKX 통합: 고급 거래 봇 아키텍처
이제 HolySheep AI를 활용하여 AI 기반 거래 결정을 내리는 고도화된 시스템을 구축해 보겠습니다. HolySheep의 단일 API 키로 여러 모델을 조합하면:
- DeepSeek V3.2로 시장 데이터 분석 ($0.42/MTok)
- Claude Sonnet으로 리스크 평가
- GPT-4.1로 거래 전략 생성
import openai
import json
from typing import List, Dict, Any
HolySheep AI 게이트웨이 설정
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"
openai.api_base = "https://api.holysheep.ai/v1"
class AITradingBot:
"""HolySheep AI 기반 암호화폐 거래 봇"""
def __init__(self, okx_client: OKXClient):
self.okx = okx_client
def analyze_market(self, symbol: str) -> Dict[str, Any]:
"""DeepSeek V3.2로 시장 데이터 분석"""
orderbook = self.okx.get_order_book(symbol, sz="50")
prompt = f"""
다음 {symbol} 오더북 데이터를 분석하여 매수/매도 압력 비율을 계산해주세요.
오더북 데이터:
{json.dumps(orderbook[:10], indent=2)}
다음 형식으로 응답해주세요:
{{
"buy_pressure": float, # 매수 압력 (0-100)
"sell_pressure": float, # 매도 압력 (0-100)
"spread": float, # 스프레드 %
"recommendation": "buy"|"sell"|"hold",
"confidence": float # 신뢰도 (0-1)
}}
"""
response = openai.ChatCompletion.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[
{"role": "system", "content": "당신은 전문 암호화폐 시장 분석가입니다."},
{"role": "user", "content": prompt}
],
temperature=0.3,
max_tokens=500
)
analysis = response.choices[0].message.content
return json.loads(analysis)
def assess_risk(self, trade_size: float, entry_price: float,
volatility: float) -> Dict[str, Any]:
"""Claude Sonnet으로 리스크 평가"""
prompt = f"""
다음 거래 조건에 대한 리스크 평가를 수행해주세요:
- 거래 규모: ${trade_size:,.2f}
- 진입 가격: ${entry_price:,.2f}
- 시장 변동성: {volatility:.2%}
최대 손실 허용액을 계산하고, 적절한 손절매 수준을 제안해주세요.
"""
response = openai.ChatCompletion.create(
model="anthropic/claude-sonnet-4-20250514",
messages=[
{"role": "system", "content": "당신은 보수적인 리스크 관리 전문가입니다."},
{"role": "user", "content": prompt}
],
temperature=0.2,
max_tokens=400
)
return {
"risk_assessment": response.choices[0].message.content,
"recommended_stop_loss": entry_price * 0.97, # 3% 손절
"max_position_size": trade_size * 0.1 # 총 자본의 10%
}
def generate_strategy(self, analysis: Dict, risk: Dict) -> str:
"""GPT-4.1로 거래 전략 생성"""
prompt = f"""
시장 분석 결과와 리스크 평가를 바탕으로 구체적인 거래 전략을 생성해주세요.
시장 분석: {json.dumps(analysis)}
리스크 평가: {json.dumps(risk)}
반드시 포함할 내용:
1. 진입时机과 가격
2. 목표 수익률
3. 손절매 수준
4.仓位 관리 전략
"""
response = openai.ChatCompletion.create(
model="gpt-4.1",
messages=[
{"role": "system", "content": "당신은 숙련된 트레이더입니다. 보수적이면서도 수익을 극대화하는 전략을 제시해주세요."},
{"role": "user", "content": prompt}
],
temperature=0.5,
max_tokens=800
)
return response.choices[0].message.content
def execute_trade(self, symbol: str, amount: float, price: float):
"""완전한 거래 실행 파이프라인"""
# 1단계: 시장 분석
analysis = self.analyze_market(symbol)
print(f"[1단계] 시장 분석 완료: {analysis['recommendation']}")
# 2단계: 리스크 평가
risk = self.assess_risk(amount, price, 0.05)
print(f"[2단계] 리스크 평가 완료: {risk['max_position_size']:.2f} USDT")
# 3단계: 전략 생성
strategy = self.generate_strategy(analysis, risk)
print(f"[3단계] 전략 생성 완료")
# 4단계: 주문 실행
if analysis['recommendation'] in ['buy', 'sell'] and \
analysis['confidence'] > 0.7:
order = self.okx.place_order(
inst_id=symbol,
td_mode="cash",
side=analysis['recommendation'],
ord_type="limit",
px=str(price),
sz=str(amount)
)
print(f"[4단계] 주문 완료: {order}")
return order
return {"status": "skipped", "reason": "신뢰도 부족"}
============ 실행 ============
if __name__ == "__main__":
bot = AITradingBot(OKXClient(OKXConfig(
api_key="YOUR_OKX_API_KEY",
secret_key="YOUR_OKX_SECRET_KEY",
passphrase="YOUR_OKX_PASSPHRASE"
)))
result = bot.execute_trade("BTC-USDT", 0.001, 67500.0)
print(f"거래 결과: {result}")카나리아 배포: 안전하게 HolySheep로 마이그레이션하기
기존 시스템을 HolySheep AI로 마이그레이션할 때는 반드시 카나리아 배포 패턴을 따라야 합니다. 저는 프로덕션 환경에서 이렇게 접근합니다:
import random
from typing import Callable, Any
from dataclasses import dataclass
from datetime import datetime
@dataclass
class CanaryConfig:
"""카나리아 배포 설정"""
canary_percentage: float = 0.1 # 10% 트래픽
holy_sheep_base_url: str = "https://api.holysheep.ai/v1"
fallback_enabled: bool = True
latency_threshold_ms: float = 200.0
error_threshold_percent: float = 5.0
class HybridAPIGateway:
"""카나리아 배포를 지원하는 하이브리드 API 게이트웨이"""
def __init__(self, config: CanaryConfig):
self.config = config
self.stats = {
"canary_requests": 0,
"canary_errors": 0,
"canary_latencies": [],
"fallback_requests": 0,
"fallback_errors": 0
}
def _should_use_canary(self) -> bool:
"""카나리아 배포 여부 결정 (고정 시드 기반 결정적分配)"""
return random.random() < self.config.canary_percentage
def _measure_latency(self, func: Callable) -> tuple[Any, float]:
"""함수 실행 및 지연 시간 측정"""
start = datetime.now()
try:
result = func()
latency = (datetime.now() - start).total_seconds() * 1000
return result, latency
except Exception as e:
latency = (datetime.now() - start).total_seconds() * 1000
raise
def _record_stats(self, is_canary: bool, success: bool, latency: float):
"""통계 기록"""
if is_canary:
self.stats["canary_requests"] += 1
if not success:
self.stats["canary_errors"] += 1
self.stats["canary_latencies"].append(latency)
else:
self.stats["fallback_requests"] += 1
if not success:
self.stats["fallback_errors"] += 1
def call_with_canary(
self,
canary_func: Callable,
fallback_func: Callable
) -> Any:
"""카나리아 + 폴백 패턴으로 API 호출"""
is_canary = self._should_use_canary()
if is_canary:
try:
result, latency = self._measure_latency(canary_func)
# 지연 시간 임계값 체크
if latency > self.config.latency_threshold_ms:
print(f"[경고] 카나리아 지연 초과: {latency:.2f}ms")
self._record_stats(is_canary=True, success=True, latency=latency)
return {"source": "holysheep", "data": result, "latency_ms": latency}
except Exception as e:
self._record_stats(is_canary=True, success=False, latency=0)
if not self.config.fallback_enabled:
raise
print(f"[카나리아 실패] 폴백 활성화: {str(e)}")
# 폴백: 기존 API 호출
try:
result, latency = self._measure_latency(fallback_func)
self._record_stats(is_canary=False, success=True, latency=latency)
return {"source": "fallback", "data": result, "latency_ms": latency}
except Exception as e:
self._record_stats(is_canary=False, success=False, latency=0)
raise
def get_health_report(self) -> Dict:
"""카나리아 배포 건강 상태 보고서"""
canary_total = self.stats["canary_requests"]
canary_errors = self.stats["canary_errors"]
canary_avg_latency = (
sum(self.stats["canary_latencies"]) / len(self.stats["canary_latencies"])
if self.stats["canary_latencies"] else 0
)
return {
"canary_error_rate": (canary_errors / canary_total * 100) if canary_total > 0 else 0,
"canary_avg_latency_ms": round(canary_avg_latency, 2),
"canary_total_requests": canary_total,
"fallback_total_requests": self.stats["fallback_requests"],
"recommendation": "promote" if (
canary_avg_latency < self.config.latency_threshold_ms and
(canary_errors / canary_total * 100) < self.config.error_threshold_percent
if canary_total > 0 else False
) else "monitor"
}
============ 마이그레이션 실행 예시 ============
gateway = HybridAPIGateway(CanaryConfig(canary_percentage=0.1))
def holy_sheep_call():
"""HolySheep AI API 호출"""
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"
openai.api_base = "https://api.holysheep.ai/v1"
response = openai.ChatCompletion.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[{"role": "user", "content": "BTC 현재 가격 예측"}],
max_tokens=100
)
return response
def legacy_call():
"""기존 API 호출 (폴백)"""
# 기존 구현...
raise Exception("Legacy API unavailable")
100회 호출 테스트
for i in range(100):
try:
result = gateway.call_with_canary(holy_sheep_call, legacy_call)
print(f"요청 {i+1}: {result['source']} - {result['latency_ms']:.2f}ms")
except Exception as e:
print(f"요청 {i+1}: 실패 - {str(e)}")
건강 상태 확인
report = gateway.get_health_report()
print(f"\n카나리아 배포 보고서: {json.dumps(report, indent=2)}")
카나리아 비율 증가 권장
if report["recommendation"] == "promote":
print("✅ HolySheep 배포 권장! 카나리아 비율을 50% 이상으로 증가하세요.")HolySheep AI vs 기존 솔루션 비교
| 비교 항목 | 기존 API Gateway | HolySheep AI | 개선幅度 |
|---|---|---|---|
| 평균 응답 시간 | 420ms | 180ms | ↓ 57% |
| 월 비용 | $4,200 | $680 | ↓ 84% |
| 지원 모델 수 | 2-3개 | 10개+ | ↑ 300% |
| DeepSeek V3.2 | 별도 비용 + 복잡한 연동 | $0.42/MTok | 단일 통합 |
| 지불 옵션 | 해외 신용카드만 | 로컬 결제 지원 | 국내 개발자 친화 |
| API 키 관리 | 모델별 별도 키 | 단일 키 통합 | 간소화 |
| 서버 위치 | 단일 리전 | 글로벌 분산 | 안정성 향상 |
가격과 ROI
테크트레이드랩의 실제 마이그레이션 데이터를 기반으로 ROI를 분석해 보겠습니다:
1개월 비용 비교
- 기존 솔루션 월 비용: $4,200
- HolySheep AI 월 비용: $680
- 절감 금액: $3,520 (83.8%)
비용 구조 상세
| 모델 | 월 사용량 | 단가 ($/MTok) | HolySheep 비용 | 기존 대비 절감 |
|---|---|---|---|---|
| DeepSeek V3.2 | 500MTok | $0.42 | $210 | 각 모델별 약 80% 절감 |
| Claude Sonnet | 100MTok | $3.00 | $300 | |
| GPT-4.1 | 50MTok | $2.00 | $100 | |
| API Gateway Fee | - | - | $70 | 고정 |
| 합계 | - | - | $680 | $3,520 절감 |
투자 수익률
# ROI 계산기
initial_migration_cost = 500 # 마이그레이션 시간 비용
monthly_savings = 3520
annual_savings = monthly_savings * 12
roi_30_days = (monthly_savings - initial_migration_cost) / initial_migration_cost * 100
roi_annual = (annual_savings - initial_migration_cost) / initial_migration_cost * 100
print(f"30일 ROI: {roi_30_days:.0f}%")
print(f"연간 ROI: {roi_annual:.0f}%")
print(f"투자 회수 기간: {initial_migration_cost / monthly_savings:.1f}일")이런 팀에 적합 / 비적합
✅ HolySheep AI가 적합한 팀
- 암호화폐 거래 봇 개발자: 다중 거래소 API 통합 필요, DeepSeek V3.2로 시장 분석 비용 절감
- 비용 최적화를 원하는 AI 스타트업: 월 $1,000+ AI API 비용 지출 팀
- 해외 신용카드 없는 국내 개발자: 로컬 결제 지원으로 즉시 시작 가능
- 다중 모델 활용팀: GPT-4.1 + Claude + Gemini 조합으로 하이브리드 AI 시스템 구축
- 마이크로서비스 아키텍처: 단일 API 키로 여러 서비스 통합
❌ HolySheep AI가 비적합한 팀
- 단일 모델만 사용하는 소규모 프로젝트: 기존 무료 티어가 충분한 경우
- 극히 짧은 지연 시간이 필수인 HFT: 50ms 이하 요구 시 별도 최적화 필요
- 특정 지역 데이터 주권 요구: 글로벌 서비스 특성상 지역별 격리 필요 시
왜 HolySheep를 선택해야 하나
- 비용 효율성: DeepSeek V3.2 $0.42/MTok는 업계 최저가 수준, 월 $3,500+ 절감 가능
- 단일 키 통합: 모든 주요 모델(GPT-4.1, Claude Sonnet, Gemini 2.5 Flash, DeepSeek V3.2)을 하나의 API 키로 관리
- 로컬 결제: 해외 신용카드 없이 원화 결제로 즉시 시작
- 마이그레이션 지원: base_url 교체만으로 기존 코드 95% 재사용
- 안정성: 글로벌 CDN 기반 99.9% 가용성
자주 발생하는 오류와 해결
1. OKX 서명 생성 오류 (400 Bad Request)
# ❌ 잘못된 접근 - 바이트 인코딩 누락
def bad_signature(message, secret):
mac = hmac.new(secret, message, hashlib.sha256) # secret 문자열 직접 전달
return mac.hexdigest()
✅ 올바른 접근 - UTF-8 인코딩
def correct_signature(timestamp, method, path, body, secret):
message = timestamp + method + path + body
mac = hmac.new(
secret.encode('utf-8'), # 반드시 인코딩
message.encode('utf-8'),
digestmod=hashlib.sha256
)
return base64.b64encode(mac.digest()).decode('utf-8') # base64 인코딩 필수2. HolySheep API Key 인증 실패 (401 Unauthorized)
# ❌ 잘못된 설정
openai.api_base = "https://api.holysheep.ai/v1" # 경로 누락
openai.api_key = "YOUR_HOLYSHEEP_API_KEY"
✅ 올바른 설정
import openai
openai.api_base = "https://api.holysheep.ai/v1" # /v1 경로 필수
openai.api_key = "YOUR_HOLYSHEEP_API_KEY" # HolySheep 대시보드에서 발급받은 키
키 검증
response = openai.ChatCompletion.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[{"role": "user", "content": "test"}],
max_tokens=5
)3. Rate Limit 초과 (429 Too Many Requests)
import time
from functools import wraps
from ratelimit import limits, sleep_and_retry
@sleep_and_retry
@limits(calls=60, period=60) # 분당 60회 제한
def rate_limited_api_call():
response = openai.ChatCompletion.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[{"role": "user", "content": "분석 요청"}]
)
return response
재시도 로직 포함 버전
def robust_api_call_with_retry(prompt, max_retries=3):
for attempt in range(max_retries):
try:
response = openai.ChatCompletion.create(
model="deepseek/deepseek-chat-v3-0324",
messages=[{"role": "user", "content": prompt}]
)
return response
except RateLimitError:
wait_time = 2 ** attempt
print(f"Rate limit 초과. {wait_time}초 후 재시도...")
time.sleep(wait_time)
raise Exception("Max retries exceeded")4. 암호화폐 API 타임스탬프 형식 오류
from datetime import datetime, timezone
❌ 잘못된 형식 - Z 접미사 누락
timestamp = datetime.now().isoformat() # "2024-01-15T10:30:00.123456"
✅ 올바른 형식 - UTC + Z suffix
timestamp = datetime.now(timezone.utc).isoformat().replace('+00:00', 'Z')
"2024-01-15T10:30:00.123456Z"
또는
timestamp = datetime.utcnow().isoformat() + 'Z'
"2024-01-15T10:30:00.123456Z"
마이그레이션 체크리스트
- HolySheep 계정 생성: 지금 가입하고 무료 크레딧 받기
- API 키 발급: 대시보드에서 HolySheep API 키 생성
- base_url 교체: 기존
api.openai.com→api.holysheep.ai/v1 - 카나리아 배포: 10% 트래픽부터 시작하여 점진적 증가
- 모니터링 설정: 응답 시간, 에러율, 비용 대시보드 확인
- 키 로테이션: 기존 API 키 비활성화 후 HolySheep 키만 사용
결론
저는 다양한 암호화폐 거래팀의 마이그레이션을 도와왔는데, HolySheep AI는 특히 다중 모델을 활용하는 거래 봇에서 뛰어난 비용 효율성을 보여줍니다. DeepSeek V3.2의 $0.42/MTok 가격은 시장 분석, 감정 분석, 패턴 인식 같은 고빈도 AI 호출에 최적이며, 단일 API 키로 모든 주요 모델을 관리할 수 있어 운영 복잡성도 크게 줄어듭니다.
OKX API 서명 알고리즘의 올바른 구현과 HolySheep AI의 효율적인 활용을 결합하면, 전문 트레이딩 시스템을 합리적인 비용으로 구축할 수 있습니다.
시작은 지금입니다. HolySheep AI는 첫 달 무료 크레딧을 제공하므로, 실제 프로덕션 환경에서 테스트해보고 마이그레이션을 결정할 수 있습니다.
궁금한 점이나 마이그레이션 과정에서 도움이 필요하시면 언제든지 문의해 주세요. Happy Trading! 🚀