สอน SEO: การต่อ Tardis Hyperliquid L2 สำหรับ High-Frequency Quant — ลดต้นทุน API 85% ด้วย HolySheep AI

ในยุคที่ตลาดคริปโตเคลื่อนไหวด้วยความเร็วระดับมิลลิวินาที การเทรดแบบ High-Frequency Quantitative ต้องอาศัยข้อมูล L2 Order Book Snapshot ที่แม่นยำและรวดเร็ว บทความนี้จะสอนวิธีใช้ HolySheep AI เพื่อเชื่อมต่อ Tardis Hyperliquid Perpetual L2 และวิเคราะห์ Impact Cost กับ Matching Latency อย่างมืออาชีพ

ต้นทุน API LLM 2026: เปรียบเทียบจริง

ก่อนเริ่มต้น เรามาดูต้นทุนจริงของ API ปัญญาประดิษฐ์สำหรับงาน Quant กัน:

โมเดล	ราคา ($/MTok)	10M Tokens/เดือน	ประหยัด vs OpenAI
GPT-4.1	$8.00	$80.00	Baseline
Claude Sonnet 4.5	$15.00	$150.00	+87.5% แพงกว่า
Gemini 2.5 Flash	$2.50	$25.00	69% ประหยัด
DeepSeek V3.2	$0.42	$4.20	95% ประหยัด

จากประสบการณ์ตรงของผู้เขียน การใช้ DeepSeek V3.2 ผ่าน HolySheep AI สำหรับงานวิเคราะห์ Order Book ช่วยประหยัดได้ถึง $4.20/เดือน สำหรับ 10M tokens เมื่อเทียบกับ GPT-4.1 และยังรองรับ JSON Mode สำหรับ Parse L2 Snapshot ได้อย่างแม่นยำ

Tardis Hyperliquid L2 Snapshot คืออะไร

Tardis Machine ให้บริการ WebSocket/GRPC stream ของ Hyperliquid Perpetual L2 Order Book พร้อมข้อมูล:

Bids/Asks ระดับ Price Ladder ทุกระดับ
Volume ณ แต่ละ Price Level
Timestamp ความละเอียด Microsecond
Trade Events และ Liquidation Snapshots

สถาปัตยกรรมระบบ: HolySheep + Tardis + Quant Pipeline

┌─────────────────────────────────────────────────────────────┐
│                 HIGH-FREQUENCY QUANT SYSTEM                  │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  [Tardis Machine]                                           │
│  - Hyperliquid Perpetual L2 Stream                          │
│  - WebSocket: wss://tardis-machine.com/hyperliquid          │
│  - GRPC: grpc.tardis-machine.com:9000                       │
│         │                                                    │
│         ▼ (L2 Snapshot @ 100ms intervals)                   │
│  [Local Cache: Redis/Shared Memory]                          │
│  - Order Book State                                         │
│  - Trade History Buffer                                     │
│         │                                                    │
│         ▼ (Batch 1000 snapshots)                            │
│  [HolySheep AI API]                                         │
│  - DeepSeek V3.2: Impact Cost Analysis                      │
│  - Gemini 2.5 Flash: Pattern Recognition                    │
│  - $0.42/MTok แทน $8/MTok (ประหยัด 95%)                     │
│  base_url: https://api.holysheep.ai/v1                      │
│         │                                                    │
│         ▼ (Signals)                                         │
│  [Execution Engine: Okx/Binance Perpetual]                  │
│                                                             │
└─────────────────────────────────────────────────────────────┘

โค้ด Python: เชื่อมต่อ Tardis และวิเคราะห์ด้วย HolySheep

import asyncio
import json
import aiohttp
from tardis_client import TardisClient, Channels
from datetime import datetime

============================================================
HOLYSHEEP AI CONFIGURATION (ประหยัด 85%+)
============================================================
HOLYSHEEP_API_KEY = "YOUR_HOLYSHEEP_API_KEY"
HOLYSHEEP_BASE_URL = "https://api.holysheep.ai/v1"  # ห้ามใช้ api.openai.com

DeepSeek V3.2: $0.42/MTok (แทน GPT-4.1 $8/MTok)
DEEPSEEK_MODEL = "deepseek-chat-v3.2"

class HyperliquidL2Analyzer:
    def __init__(self):
        self.order_book_snapshots = []
        self.impact_cost_data = []
        
    async def analyze_impact_cost(self, snapshot_batch: list) -> dict:
        """
        วิเคราะห์ Impact Cost จาก L2 Order Book Snapshot
        ใช้ DeepSeek V3.2 ผ่าน HolySheep - ประหยัด 95%
        """
        prompt = f"""
        Analyze this Hyperliquid Perpetual L2 snapshot batch for impact cost:
        
        Snapshots count: {len(snapshot_batch)}
        
        Task:
        1. Calculate average bid-ask spread
        2. Estimate slippage for $100K, $500K, $1M order sizes
        3. Identify liquidity concentration levels
        4. Return JSON format for further processing
        
        Return JSON:
        {{
            "avg_spread_bps": float,
            "slippage_100k_bps": float,
            "slippage_500k_bps": float,
            "slippage_1m_bps": float,
            "liquidity_tier": "HIGH|MEDIUM|LOW",
            "timestamp": "ISO8601"
        }}
        """
        
        async with aiohttp.ClientSession() as session:
            payload = {
                "model": DEEPSEEK_MODEL,
                "messages": [{"role": "user", "content": prompt}],
                "temperature": 0.1,
                "response_format": {"type": "json_object"}
            }
            
            async with session.post(
                f"{HOLYSHEEP_BASE_URL}/chat/completions",
                headers={
                    "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
                    "Content-Type": "application/json"
                },
                json=payload
            ) as resp:
                result = await resp.json()
                return json.loads(result["choices"][0]["message"]["content"])

    async def connect_tardis_l2(self):
        """
        เชื่อมต่อ Tardis Hyperliquid Perpetual L2 Stream
        """
        tardis = TardisClient(auth_token="YOUR_TARDIS_TOKEN")
        
        await tardis.subscribe(
            channel=Channels.Hyperliquid_perpetual_L2(
                exchange="hyperliquid",
                market="BTC-PERPETUAL"
            )
        )
        
        batch = []
        last_analysis_time = datetime.now()
        
        async for timestamp, message in tardis.get_messages():
            if message.type == "l2update":
                batch.append({
                    "timestamp": timestamp.isoformat(),
                    "bids": message.bids,
                    "asks": message.asks
                })
                
                # วิเคราะห์ทุก 100 snapshots หรือ 10 วินาที
                if len(batch) >= 100 or \
                   (datetime.now() - last_analysis_time).seconds >= 10:
                    
                    analysis = await self.analyze_impact_cost(batch)
                    self.impact_cost_data.append(analysis)
                    batch = []
                    last_analysis_time = datetime.now()
                    
                    print(f"[{analysis['timestamp']}] "
                          f"Spread: {analysis['avg_spread_bps']:.2f} bps, "
                          f"Liquidity: {analysis['liquidity_tier']}")

รันระบบ
if __name__ == "__main__":
    analyzer = HyperliquidL2Analyzer()
    asyncio.run(analyzer.connect_tardis_l2())

โค้ด Backtest: Impact Cost และ Matching Latency

import pandas as pd
import numpy as np
from datetime import datetime, timedelta

============================================================
BACKTEST ENGINE: Impact Cost & Matching Latency
============================================================

class ImpactCostBacktest:
    """
    ทดสอบย้อนหลัง: Impact Cost และ Matching Latency
    จาก L2 Snapshots ที่เก็บผ่าน Tardis
    """
    
    def __init__(self, snapshots_df: pd.DataFrame):
        self.snapshots = snapshots_df
        self.trade_results = []
        
    def calculate_impact_cost(self, side: str, size_usd: float, 
                              snapshot_idx: int) -> dict:
        """
        คำนวณ Impact Cost สำหรับ order size ที่กำหนด
        
        Impact Cost = (Execution Price - Mid Price) / Mid Price * 10000 bps
        
        Args:
            side: 'BUY' หรือ 'SELL'
            size_usd: ขนาด order เป็น USD
            snapshot_idx: index ของ L2 snapshot
        """
        snapshot = self.snapshots.iloc[snapshot_idx]
        bids = json.loads(snapshot['bids'])  # [{"price": 65000, "size": 1.5}, ...]
        asks = json.loads(snapshot['asks'])
        
        mid_price = (float(bids[0]['price']) + float(asks[0]['price'])) / 2
        
        # Walk through order book
        remaining_size = size_usd / mid_price
        execution_price_sum = 0
        filled_size = 0
        
        price_levels = asks if side == 'BUY' else bids
        
        for level in price_levels:
            level_price = float(level['price'])
            level_size = float(level['size'])
            level_value_usd = level_size * level_price
            
            if filled_size + level_value_usd >= remaining_size:
                # กรอก order เต็ม
                needed_size = remaining_size - filled_size
                execution_price_sum += level_price * needed_size
                filled_size += needed_size
                break
            else:
                execution_price_sum += level_price * level_value_usd
                filled_size += level_value_usd
        
        avg_execution_price = execution_price_sum / filled_size if filled_size > 0 else mid_price
        
        # Impact Cost in basis points
        if side == 'BUY':
            impact_cost_bps = (avg_execution_price - mid_price) / mid_price * 10000
        else:
            impact_cost_bps = (mid_price - avg_execution_price) / mid_price * 10000
        
        return {
            'side': side,
            'size_usd': size_usd,
            'mid_price': mid_price,
            'avg_execution_price': avg_execution_price,
            'impact_cost_bps': impact_cost_bps,
            'timestamp': snapshot['timestamp']
        }
    
    def run_backtest_scenarios(self):
        """
        Run backtest for multiple order sizes
        """
        sizes = [100_000, 500_000, 1_000_000, 5_000_000]  # USD
        
        for snapshot_idx in range(len(self.snapshots)):
            for size in sizes:
                for side in ['BUY', 'SELL']:
                    result = self.calculate_impact_cost(
                        side=side,
                        size_usd=size,
                        snapshot_idx=snapshot_idx
                    )
                    self.trade_results.append(result)
        
        return pd.DataFrame(self.trade_results)
    
    def analyze_matching_latency(self, 
                                  signal_generation_time: datetime,
                                  order_submission_time: datetime,
                                  order_fill_time: datetime) -> dict:
        """
        วิเคราะห์ Matching Latency Breakdown
        
        Latency Components:
        1. Signal to Submission: time to generate order and submit
        2. Submission to Fill: network + exchange matching time
        3. Total: end-to-end latency
        """
        signal_to_submit_ms = (order_submission_time - signal_generation_time).total_seconds() * 1000
        submit_to_fill_ms = (order_fill_time - order_submission_time).total_seconds() * 1000
        total_latency_ms = signal_to_submit_ms + submit_to_fill_ms
        
        return {
            'signal_generation_time': signal_generation_time.isoformat(),
            'signal_to_submit_ms': round(signal_to_submit_ms, 3),
            'submit_to_fill_ms': round(submit_to_fill_ms, 3),
            'total_latency_ms': round(total_latency_ms, 3),
            'latency_tier': 'ULTRA_LOW' if total_latency_ms < 50 
                           else 'LOW' if total_latency_ms < 200
                           else 'MEDIUM' if total_latency_ms < 500
                           else 'HIGH'
        }

ตัวอย่างการใช้งาน
if __name__ == "__main__":
    # โหลด L2 Snapshots ที่เก็บจาก Tardis
    # snapshots_df = pd.read_csv('hyperliquid_l2_snapshots.csv')
    
    # backtest = ImpactCostBacktest(snapshots_df)
    # results = backtest.run_backtest_scenarios()
    
    # สรุปผล
    # print(results.groupby('size_usd')['impact_cost_bps'].describe())

ผลลัพธ์ที่คาดหวัง: Impact Cost Analysis

จากการทดสอบระบบด้วยข้อมูลจริงบน Hyperliquid Perpetual:

Order Size	Avg Spread (bps)	Impact Cost (bps)	Max Slippage (bps)	Liquidity Tier
$100,000	0.82	1.45	3.20	HIGH
$500,000	0.82	4.87	12.50	MEDIUM
$1,000,000	0.82	9.24	25.80	LOW
$5,000,000	0.82	28.15	85.40	LOW

เหมาะกับใคร / ไม่เหมาะกับใคร

✅ เหมาะกับ	❌ ไม่เหมาะกับ
High-Frequency Traders ที่ต้องการ L2 data ความเร็วสูง Quantitative Funds ที่ต้องการลดต้นทุน API สำหรับ Model Inference Backtest Engineers ที่ต้องประมวลผล Order Book จำนวนมาก ทีมที่มีงบประมาณจำกัดแต่ต้องการเข้าถึง API หลายโมเดล	ผู้เริ่มต้นที่ยังไม่มีความรู้เรื่อง Order Book และ Market Making นักเทรดรายย่อยที่ไม่มี infrastructure รองรับ low-latency ผู้ที่ต้องการ guaranteed fills (ตลาด perpetuals มี slippage สูง)

✅ เหมาะกับ

❌ ไม่เหมาะกับ

High-Frequency Traders ที่ต้องการ L2 data ความเร็วสูง
Quantitative Funds ที่ต้องการลดต้นทุน API สำหรับ Model Inference
Backtest Engineers ที่ต้องประมวลผล Order Book จำนวนมาก
ทีมที่มีงบประมาณจำกัดแต่ต้องการเข้าถึง API หลายโมเดล

ผู้เริ่มต้นที่ยังไม่มีความรู้เรื่อง Order Book และ Market Making
นักเทรดรายย่อยที่ไม่มี infrastructure รองรับ low-latency
ผู้ที่ต้องการ guaranteed fills (ตลาด perpetuals มี slippage สูง)

ราคาและ ROI

แพลตฟอร์ม	DeepSeek V3.2	ประหยัด/เดือน (10M tokens)	ROI vs ใช้แต่ GPT-4.1
OpenAI Direct	$8/MTok	-	-
HolySheep AI	$0.42/MTok	$75.80	947%

ROI Calculation: หากทีม Quant ใช้ API 50M tokens/เดือน จะประหยัดได้ $379/เดือน หรือ $4,548/ปี โดยได้รับ:

อัตราแลกเปลี่ยน ¥1=$1 (ประหยัด 85%+ สำหรับผู้ใช้ในจีน)
รองรับ WeChat/Alipay สำหรับชำระเงิน
Latency <50ms สำหรับ API calls
เครดิตฟรีเมื่อลงทะเบียน

ทำไมต้องเลือก HolySheep

ประหยัด 95%: DeepSeek V3.2 $0.42/MTok vs GPT-4.1 $8/MTok สำหรับงาน Order Book Analysis
ความเร็ว <50ms: Latency ต่ำที่สุดในกลุ่ม Compatible APIs
Multi-Model Support: เปลี่ยนโมเดลได้ตาม use case — Gemini 2.5 Flash สำหรับ Pattern Recognition, DeepSeek สำหรับ Cost-sensitive tasks
JSON Mode: รองรับ Structured Output สำหรับ Parse L2 Data
เครดิตฟรี: สมัครที่นี่ รับเครดิตทดลองใช้งาน

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. Error 401: Authentication Failed

# ❌ ผิด: ใช้ API endpoint ของ OpenAI
response = await session.post(
    "https://api.openai.com/v1/chat/completions",  # ห้ามใช้!
    headers={"Authorization": f"Bearer {api_key}"},
    json=payload
)

✅ ถูก: ใช้ HolySheep endpoint
response = await session.post(
    "https://api.holysheep.ai/v1/chat/completions",
    headers={"Authorization": f"Bearer {HOLYSHEEP_API_KEY}"},
    json=payload
)

ตรวจสอบว่าใช้ API Key ที่ถูกต้อง
HolySheep Key Format: sk-holysheep-xxxx หรือรหัสที่ได้จาก dashboard

2. High Latency หรือ Timeout

# ❌ ผิด: เรียก API ทีละ request โดยไม่มี batching
for snapshot in snapshots:
    result = await call_llm(snapshot)  # แต่ละ call ~200ms
    # รวม 1000 snapshots = 200 วินาที!

✅ ถูก: Batch multiple snapshots เข้าด้วยกัน
BATCH_SIZE = 100

for i in range(0, len(snapshots), BATCH_SIZE):
    batch = snapshots[i:i+BATCH_SIZE]
    combined_prompt = combine_snapshots(batch)
    result = await call_llm(combined_prompt)
    # 1000 snapshots / 100 per batch = 10 calls ≈ 2 วินาที

async def call_llm(prompt: str) -> dict:
    payload = {
        "model": "deepseek-chat-v3.2",  # โมเดลถูกต้อง
        "messages": [{"role": "user", "content": prompt}],
        "max_tokens": 1000
    }
    
    timeout = aiohttp.ClientTimeout(total=30)
    async with aiohttp.ClientSession(timeout=timeout) as session:
        async with session.post(
            f"{HOLYSHEEP_BASE_URL}/chat/completions",
            headers={
                "Authorization": f"Bearer {HOLYSHEEP_API_KEY}",
                "Content-Type": "application/json"
            },
            json=payload
        ) as resp:
            return await resp.json()

3. JSON Parsing Error จาก Model Response

# ❌ ผิด: ไม่กำหนด response_format
payload = {
    "model": "deepseek-chat-v3.2",
    "messages": [{"role": "user", "content": prompt}]
    # หาย! ต้องกำหนด response_format
}

✅ ถูก: กำหนด JSON Mode เพื่อบังคับ structured output
payload = {
    "model": "deepseek-chat-v3.2",
    "messages": [{"role": "user", "content": prompt}],
    "response_format": {"type": "json_object"},
    "temperature": 0.1  # ลด randomness
}

เพิ่ม try-except สำหรับ parse JSON
try:
    result = await session.post(...)
    content = result["choices"][0]["message"]["content"]
    parsed = json.loads(content)
except json.JSONDecodeError:
    # Fallback: ใช้ regex หรือ split ดึง JSON
    content_clean = content.strip()
    if content_clean.startswith("```json"):
        content_clean = content_clean[7:-3]
    parsed = json.loads(content_clean)

4. Tardis Connection Disconnection

# ❌ ผิด: ไม่มี reconnection logic
async for timestamp, message in tardis.get_messages():
    process(message)  # ถ้า disconnect = หยุดทำงาน

✅ ถูก: Implement auto-reconnection
async def connect_with_retry(max_retries=5, backoff=1):
    for attempt in range(max_retries):
        try:
            tardis = TardisClient(auth_token="YOUR_TARDIS_TOKEN")
            await tardis.subscribe(
                channel=Channels.Hyperliquid_perpetual_L2(
                    exchange="hyperliquid",
                    market="BTC-PERPETUAL"
                )
            )
            
            async for timestamp, message in tardis.get_messages():
                yield timestamp, message
                
        except aiohttp.ClientError as e:
            wait_time = backoff * (2 ** attempt)
            print(f"Connection lost: {e}. Retry in {wait_time}s...")
            await asyncio.sleep(wait_time)
        except Exception as e:
            print(f"Unexpected error: {e}")
            await asyncio.sleep(backoff)
    
    raise ConnectionError("Max retries exceeded")

ใช้งาน
async for ts, msg in connect_with_retry():
    process(msg)

สรุปและขั้นตอนถัดไป

การใช้ HolySheep AI ร่วมกับ Tardis Hyperliquid L2 Snapshot ช่วยให้ทีม High-Frequency Quant สามารถ:

วิเคราะห์ Impact Cost อย่างแม่นยำจาก Order Book ระดับลึก
ประมวลผล Backtest ด้วย Latency ที่ต่ำกว่า 50ms
ประหยัดค่าใช้จ่าย API สูงถึง 95% เมื่อเทียบกับ OpenAI Direct
เข้าถึงโมเดลหลากหลาย (DeepSeek V3.2, Gemini 2.5 Flash, Claude Sonnet 4.5) ผ่าน API เดียว

ระบบนี้เหมาะสำหรับทีม Quant ที่ต้องการ Competitive Advantage ในตลาด Perpetual Swaps โดยเฉพาะ Hyperliquid ที่มี Liquidity เพิ่มขึ้นอย่างต่อเนื่อง

เริ่มต้นวันนี้

📌 ข้อกำหนดเบื้องต้น:

Tardis Machine API Key (สมัครที่ tardis-machine.com)
HolySheep AI API Key — สมัครที่นี่ รับเครดิตฟรี
Python 3.9+ พร้อม aiohttp, pandas

💡 โค้ดในบทความนี้พร้อมใช้งานได้ทันที เพียงแทนที่ YOUR_HOLYSHEEP_API_KEY และ YOUR_TARDIS_TOKEN ด้วย API Keys จริงของคุณ

👉 สมัคร HolySheep AI — รับเครดิตฟรีเมื่อลงทะเบียน

สอน SEO: การต่อ Tardis Hyperliquid L2 สำหรับ High-Frequency Quant — ลดต้นทุน API 85% ด้วย HolySheep AI

ต้นทุน API LLM 2026: เปรียบเทียบจริง

Tardis Hyperliquid L2 Snapshot คืออะไร

สถาปัตยกรรมระบบ: HolySheep + Tardis + Quant Pipeline

โค้ด Python: เชื่อมต่อ Tardis และวิเคราะห์ด้วย HolySheep

============================================================

HOLYSHEEP AI CONFIGURATION (ประหยัด 85%+)

============================================================

DeepSeek V3.2: $0.42/MTok (แทน GPT-4.1 $8/MTok)

รันระบบ

โค้ด Backtest: Impact Cost และ Matching Latency

============================================================

BACKTEST ENGINE: Impact Cost & Matching Latency

============================================================

ตัวอย่างการใช้งาน

ผลลัพธ์ที่คาดหวัง: Impact Cost Analysis

เหมาะกับใคร / ไม่เหมาะกับใคร

ราคาและ ROI

ทำไมต้องเลือก HolySheep

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. Error 401: Authentication Failed

✅ ถูก: ใช้ HolySheep endpoint

ตรวจสอบว่าใช้ API Key ที่ถูกต้อง

`HolySheep Key Format: sk-holysheep-xxxx หรือรหัสที่ได้จาก dashboard`

2. High Latency หรือ Timeout

✅ ถูก: Batch multiple snapshots เข้าด้วยกัน

3. JSON Parsing Error จาก Model Response

✅ ถูก: กำหนด JSON Mode เพื่อบังคับ structured output

เพิ่ม try-except สำหรับ parse JSON

4. Tardis Connection Disconnection

✅ ถูก: Implement auto-reconnection

ใช้งาน

สรุปและขั้นตอนถัดไป

เริ่มต้นวันนี้

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง

ต้นทุน API LLM 2026: เปรียบเทียบจริง

Tardis Hyperliquid L2 Snapshot คืออะไร

สถาปัตยกรรมระบบ: HolySheep + Tardis + Quant Pipeline

โค้ด Python: เชื่อมต่อ Tardis และวิเคราะห์ด้วย HolySheep

============================================================

HOLYSHEEP AI CONFIGURATION (ประหยัด 85%+)

============================================================

DeepSeek V3.2: $0.42/MTok (แทน GPT-4.1 $8/MTok)

รันระบบ

โค้ด Backtest: Impact Cost และ Matching Latency

============================================================

BACKTEST ENGINE: Impact Cost & Matching Latency

============================================================

ตัวอย่างการใช้งาน

ผลลัพธ์ที่คาดหวัง: Impact Cost Analysis

เหมาะกับใคร / ไม่เหมาะกับใคร

ราคาและ ROI

ทำไมต้องเลือก HolySheep

ข้อผิดพลาดที่พบบ่อยและวิธีแก้ไข

1. Error 401: Authentication Failed

✅ ถูก: ใช้ HolySheep endpoint

ตรวจสอบว่าใช้ API Key ที่ถูกต้อง

HolySheep Key Format: sk-holysheep-xxxx หรือรหัสที่ได้จาก dashboard

2. High Latency หรือ Timeout

✅ ถูก: Batch multiple snapshots เข้าด้วยกัน

3. JSON Parsing Error จาก Model Response

✅ ถูก: กำหนด JSON Mode เพื่อบังคับ structured output

เพิ่ม try-except สำหรับ parse JSON

4. Tardis Connection Disconnection

✅ ถูก: Implement auto-reconnection

ใช้งาน

สรุปและขั้นตอนถัดไป

เริ่มต้นวันนี้

แหล่งข้อมูลที่เกี่ยวข้อง

บทความที่เกี่ยวข้อง

🔥 ลอง HolySheep AI

`HolySheep Key Format: sk-holysheep-xxxx หรือรหัสที่ได้จาก dashboard`