วิธีใช้ Hyperliquid API

แพลตฟอร์ม Hyperliquid โดดเด่นในฐานะการแลกเปลี่ยนแบบกระจายอำนาจที่มีประสิทธิภาพสูงสำหรับสัญญาซื้อขายล่วงหน้าแบบไม่จำกัดระยะเวลา (perpetual futures) โดยนำเสนอการซื้อขายที่มีความหน่วงต่ำและคุณสมบัติขั้นสูงสำหรับนักพัฒนา นักพัฒนามักใช้ hyperliquid api เพื่อทำการซื้อขายอัตโนมัติ ตรวจสอบตลาด และสร้างแอปพลิเคชันที่กำหนดเอง

คุณเริ่มต้นด้วยการทำความเข้าใจส่วนประกอบหลักของ hyperliquid api API แบ่งออกเป็นหมวดหมู่หลักๆ ได้แก่ Info API สำหรับการสอบถามข้อมูลตลาด, Exchange API สำหรับการดำเนินการซื้อขาย และ WebSocket สำหรับการอัปเดตแบบเรียลไทม์ นอกจากนี้ SDK ในภาษาต่างๆ เช่น Python และ Node.js ยังช่วยให้การโต้ตอบง่ายขึ้น เมื่อคุณดำเนินการต่อไป คุณจะเห็นว่าการปรับเปลี่ยนพารามิเตอร์คำขอเพียงเล็กน้อยสามารถนำไปสู่การปรับปรุงประสิทธิภาพการดำเนินการได้อย่างมาก

Hyperliquid API คืออะไร?

hyperliquid api ช่วยให้สามารถเข้าถึงการแลกเปลี่ยนสัญญาซื้อขายล่วงหน้าแบบกระจายอำนาจของ Hyperliquid ได้ด้วยโปรแกรม โดยรองรับการทำงานทั้งบนสภาพแวดล้อม mainnet และ testnet คุณเชื่อมต่อกับ mainnet และ testnet z API ใช้ JSON สำหรับคำขอและการตอบกลับ โดยอาศัย HTTP POST สำหรับการดำเนินการส่วนใหญ่ และ WebSocket สำหรับการสมัครสมาชิก

ในบางกรณี คุณจะยืนยันตัวตนโดยใช้คีย์ส่วนตัวแทนคีย์ API แบบดั้งเดิม แต่ Hyperliquid ยังมีกระเป๋าเงิน API สำหรับการมอบหมายที่ปลอดภัย กระเป๋าเงินเหล่านี้ทำหน้าที่ในนามของบัญชีหลักของคุณโดยไม่มีสิทธิ์ถอนเงิน ซึ่งช่วยเพิ่มความปลอดภัยสำหรับการซื้อขายอัตโนมัติ ตัวอย่างเช่น คุณสร้างกระเป๋าเงิน API ผ่านแอป Hyperliquid ให้สิทธิ์ และใช้คีย์ส่วนตัวของมันในสคริปต์ของคุณ

ถัดไป พิจารณาประเภทข้อมูล API ใช้โครงสร้างและ enum ที่เฉพาะเจาะจง สินทรัพย์ถูกระบุด้วยดัชนีจากรายการจักรวาล ฝั่งคำสั่งซื้อใช้ค่าบูลีน (true สำหรับซื้อ, false สำหรับขาย) และตัวเลือก time-in-force รวมถึง 'Gtc' สำหรับ good 'til canceled คุณเรียกรายละเอียดเหล่านี้จากปลายทางเมตาดาต้าเพื่อให้แน่ใจว่าคำขอของคุณถูกต้อง

ด้วยรากฐานนี้ คุณจะย้ายไปสู่การตั้งค่าสภาพแวดล้อมการพัฒนาของคุณ การกำหนดค่าที่เหมาะสมจะช่วยป้องกันข้อผิดพลาดทั่วไปและเร่งความเร็วในการทำซ้ำ

การตั้งค่าสภาพแวดล้อมของคุณสำหรับ Hyperliquid API

คุณเริ่มต้นการตั้งค่าโดยเลือกภาษาโปรแกรมของคุณและติดตั้ง SDK ที่เกี่ยวข้อง สำหรับผู้ใช้ Python, hyperliquid-python-sdk เป็นจุดเริ่มต้นที่แข็งแกร่ง ติดตั้งผ่าน pip ด้วยคำสั่ง pip install hyperliquid-python-sdk SDK นี้จัดการการเชื่อมต่อ การยืนยันตัวตน และการดำเนินการทั่วไป

จากนั้นคุณกำหนดค่าข้อมูลรับรองของคุณ สร้างไฟล์ config.json ที่มีที่อยู่บัญชีของคุณ (คีย์สาธารณะ) และคีย์ลับ (คีย์ส่วนตัว) เพื่อความปลอดภัย คุณสร้างกระเป๋าเงิน API โดยเฉพาะ ไปที่แอป Hyperliquid เลือก "เพิ่มเติม > API" ป้อนชื่อสำหรับคีย์ วางที่อยู่กระเป๋าเงินของคุณ แล้วคลิก "สร้าง" ให้สิทธิ์กระเป๋าเงิน API และคัดลอกคีย์ส่วนตัวของมันลงในการกำหนดค่าของคุณ

SDK นำเข้าค่าคงที่สำหรับ URL เช่น constants.TESTNET_API_URL สำหรับการทดสอบ คุณเริ่มต้นไคลเอนต์ดังนี้:

from hyperliquid.info import Info
from hyperliquid.utils import constants

info = Info(constants.TESTNET_API_URL, skip_ws=True)

การตั้งค่านี้จะข้าม WebSocket ไปก่อน โดยเน้นที่ HTTP คุณทดสอบการเชื่อมต่อโดยการสอบถามสถานะผู้ใช้:

user_state = info.user_state("your_account_address")
print(user_state)

หากการตอบกลับแสดงรายละเอียดบัญชีของคุณ สภาพแวดล้อมของคุณทำงานถูกต้อง อย่างไรก็ตาม หากคุณพบข้อผิดพลาด ให้ตรวจสอบคีย์ส่วนตัวและการเลือกเครือข่ายของคุณ

สำหรับ Node.js คุณใช้แพ็กเกจ @nktkas/hyperliquid ติดตั้งด้วย npm จากนั้นตั้งค่า transports และไคลเอนต์โดยใช้ ethers สำหรับการจัดการกระเป๋าเงิน คุณระบุ isTestnet: true เพื่อหลีกเลี่ยงการใช้เงินจริงในระหว่างการพัฒนา

เครื่องมืออย่าง Apidog ช่วยเสริมการตั้งค่านี้ คุณนำเข้าข้อมูลจำเพาะของ hyperliquid api เข้าสู่ Apidog ยืนยันตัวตนด้วยคีย์ของคุณ และจำลองคำขอ วิธีการนี้จะเปิดเผยโครงสร้างการตอบกลับได้อย่างรวดเร็ว ช่วยประหยัดเวลาในการเขียนโค้ดด้วยตนเอง

เมื่อกำหนดค่าแล้ว คุณจะเข้าสู่ขั้นตอนวิธีการยืนยันตัวตน การยืนยันตัวตนที่เหมาะสมช่วยให้มั่นใจว่าการดำเนินการของคุณจะถูกดำเนินการอย่างปลอดภัย

การยืนยันตัวตนด้วย Hyperliquid API

คุณยืนยันตัวตนหลักๆ ผ่านการลงนามด้วยคีย์ส่วนตัว เนื่องจาก Hyperliquid ทำงานบนระบบบล็อกเชน SDK จะจัดการการลงนามโดยอัตโนมัติเมื่อคุณระบุอินสแตนซ์ของกระเป๋าเงิน

สำหรับการเรียก API โดยตรงโดยไม่มี SDK คุณลงนามเพย์โหลดโดยใช้คีย์ส่วนตัวของคุณ เนื้อหาคำขอจะรวม nonce สำหรับการป้องกันการเล่นซ้ำ และคุณโพสต์ไปยังปลายทาง /exchange หรือ /info

กระเป๋าเงิน API เพิ่มความยืดหยุ่น คุณสร้างกระเป๋าเงินโดยการตั้งชื่อ เชื่อมโยงกับที่อยู่กระเป๋าเงินหลักของคุณ สร้างคีย์ และให้สิทธิ์ กระเป๋าเงินนี้สามารถทำการซื้อขายได้ แต่ไม่สามารถถอนเงินได้ ซึ่งช่วยลดความเสี่ยงสำหรับบอท ในโค้ด คุณใช้คีย์ส่วนตัวของกระเป๋าเงิน API ในขณะที่ระบุที่อยู่บัญชีหลัก

คุณทดสอบการยืนยันตัวตนโดยการส่งคำขอข้อมูลแบบง่าย หากไม่ได้รับอนุญาต API จะส่งคืนข้อผิดพลาด เช่น "User or API Wallet does not exist." หากต้องการแก้ไขปัญหานี้ ตรวจสอบให้แน่ใจว่ากระเป๋าเงินของคุณมีหลักประกันขั้นต่ำ เช่น USDC สำหรับสัญญาซื้อขายล่วงหน้า

ความปลอดภัยยังคงเป็นสิ่งสำคัญสูงสุด คุณจัดเก็บคีย์ในตัวแปรสภาพแวดล้อมหรือห้องนิรภัยที่ปลอดภัย หมุนเวียนคีย์เป็นระยะ และตรวจสอบกิจกรรมที่ผิดปกติ เมื่อมีการยืนยันตัวตนแล้ว คุณจะสำรวจปลายทาง Info API

การสำรวจปลายทาง Info API

Info API ให้การเข้าถึงข้อมูลตลาดและบัญชีแบบอ่านอย่างเดียว คุณใช้เพื่อดึงเมตาดาต้า ราคา คำสั่งซื้อ และอื่นๆ โดยไม่ต้องยืนยันตัวตนสำหรับข้อมูลสาธารณะ

คุณเริ่มต้นด้วยปลายทาง meta ซึ่งส่งคืนจักรวาลสินทรัพย์และบริบท ใน Node.js:

const [meta] = await infoClient.metaAndAssetCtxs();

สิ่งนี้จะส่งคืนอาร์เรย์ของสินทรัพย์ที่มีชื่อ ดัชนี และข้อมูลจำเพาะ เช่น เลเวอเรจสูงสุด คุณใช้ดัชนีสินทรัพย์ในคำขอซื้อขาย

ถัดไป คุณสอบถามราคาเฉลี่ยด้วย allMids ซึ่งส่งคืนจุดกึ่งกลางปัจจุบันสำหรับทุกคู่ คำสั่งซื้อที่เปิดอยู่มาจาก openOrders ซึ่งต้องใช้ที่อยู่ของคุณ

ปลายทางอื่นๆ ได้แก่:

• userState: ดึงตำแหน่ง มาร์จิ้น และยอดคงเหลือ
• fundingHistory: แสดงอัตรา funding เมื่อเวลาผ่านไป
• l2Book: ให้สมุดคำสั่งซื้อระดับ 2 สำหรับเหรียญ

คุณส่งคำขอ POST พร้อมเนื้อหา JSON เช่น {"type": "meta"} ไปยัง /info การตอบกลับใช้โครงสร้างที่สอดคล้องกัน โดยมี "data" บรรจุผลลัพธ์

Apidog ช่วยในเรื่องนี้—คุณตั้งค่าคอลเลกชันสำหรับ Info API เพิ่มคำขอสำหรับแต่ละประเภท และกำหนดพารามิเตอร์เหรียญหรือที่อยู่ การแสดงภาพนี้ช่วยในการทำความเข้าใจการไหลของข้อมูล

เมื่อคุณรวบรวมข้อมูล คุณจะเปลี่ยนไปใช้ Exchange API สำหรับการดำเนินการซื้อขาย

การใช้ปลายทาง Exchange API สำหรับการซื้อขาย

Exchange API จัดการการดำเนินการต่างๆ เช่น การสั่งซื้อ การยกเลิก และการแก้ไข คุณยืนยันตัวตนคำขอทั้งหมดด้วยเพย์โหลดที่ลงนาม

คุณวางคำสั่งซื้อโดยกำหนดพารามิเตอร์: ดัชนีสินทรัพย์, ฝั่ง, ราคา, ขนาด, แฟล็ก reduce-only และประเภท (limit หรือ market) สำหรับการขายแบบ limit:

ใน Elixir (จากเอกสาร SDK):

Hyperliquid.Api.Exchange.place_order(order)

โดยที่ order เป็นแผนที่ที่มี a: สินทรัพย์, b: false (ขาย), p: "100", s: "0.1", r: false, t: {limit: {tif: "Gtc"}}

การตอบกลับจะรวมสถานะและรหัสคำสั่งซื้อหากสำเร็จ

คุณยกเลิกคำสั่งซื้อโดยใช้สินทรัพย์และ oid (รหัสคำสั่งซื้อ):

Hyperliquid.Api.Exchange.cancel_order(asset, oid)

สำหรับคำสั่งซื้อจำนวนมาก คุณใช้ cancel_orders กับรายการ

การแก้ไขก็เช่นกัน: ระบุ oid และพารามิเตอร์ใหม่

การดำเนินการอื่นๆ รวมถึงการอัปเดตเลเวอเรจ:

Hyperliquid.Api.Exchange.update_leverage(asset, is_cross, leverage)

และ การโอน เช่น spot_perp_transfer สำหรับการย้ายเงินระหว่างบัญชี

คุณจัดการข้อผิดพลาดโดยการตรวจสอบสถานะการตอบกลับ— "ok" สำหรับความสำเร็จ มิฉะนั้นจะเป็นรายละเอียดเช่นหลักประกันไม่เพียงพอ

ตัวอย่างแสดงให้เห็นการใช้งานจริง ตัวอย่างเช่น คุณสร้างบอทที่วางคำสั่งซื้อเมื่อราคาลดลงต่ำกว่าเกณฑ์ โดยใช้ข้อมูลสำหรับการตรวจสอบราคาและใช้ exchange สำหรับการวางคำสั่งซื้อ

นอกจากนี้ คุณยังรวม WebSocket สำหรับการอัปเดตแบบเรียลไทม์เพื่อเพิ่มการตอบสนอง

การรวม WebSocket สำหรับข้อมูลแบบเรียลไทม์

คุณเชื่อมต่อกับ WebSocket สำหรับสตรีมสด ใช้ wss://api.hyperliquid.xyz/ws สำหรับ mainnet หรือ testnet ที่เทียบเท่ากัน

คุณสมัครสมาชิกโดยการส่ง JSON: {"method": "subscribe", "subscription": {"type": "trades", "coin": "SOL"}}

เซิร์ฟเวอร์จะตอบกลับด้วยการยืนยัน จากนั้นจะส่งการอัปเดต เช่น การซื้อขายใหม่

คุณจัดการหัวข้อต่างๆ เช่น orderbook, เหตุการณ์ผู้ใช้ และการแจ้งเตือน ใน Python SDK ให้ตั้งค่า skip_ws=False เพื่อเปิดใช้งาน

ความสามารถแบบเรียลไทม์นี้ช่วยให้คุณตอบสนองต่อการเปลี่ยนแปลงของตลาดได้ทันที เช่น การปรับคำสั่งซื้อเมื่อมีการจับคู่

เมื่อครอบคลุมปลายทางแล้ว คุณจะพิจารณา Python SDK อย่างละเอียด

การใช้ประโยชน์จาก Hyperliquid Python SDK

Python SDK สรุปการเรียก API เป็นคลาส คุณนำเข้า Info สำหรับการสอบถามและ Exchange สำหรับการดำเนินการ

คุณวางคำสั่งซื้อพื้นฐานดังนี้ (จากตัวอย่าง):

ขั้นแรก โหลดการกำหนดค่า:

import json

def address_and_private_key():
    with open("examples/config.json") as f:
        config = json.load(f)
    return config["account_address"], config["secret_key"]

จากนั้น เริ่มต้น Exchange:

from hyperliquid.exchange import Exchange
from hyperliquid.utils import constants

address, private = address_and_private_key()
exchange = Exchange(address, private, base_url=constants.TESTNET_API_URL)

วางคำสั่งซื้อ:

order_result = exchange.order("BTC", True, 0.02, 30000, {"limit": {"tif": "Gtc"}})
print(order_result)

นี่คือการซื้อ BTC 0.02 หน่วยที่ราคาจำกัด 30,000 ดอลลาร์

คุณขยายสิ่งนี้สำหรับคุณสมบัติขั้นสูง เช่น คำสั่งซื้อจำนวนมากหรือการยกเลิก

SDK ยังรองรับที่อยู่ vault สำหรับบัญชีที่จัดการ

ตัวอย่างใน repo ครอบคลุม basic_order, user_state และอื่นๆ ซึ่งแสดงให้เห็นถึงขั้นตอนการทำงานที่สมบูรณ์

เมื่อคุณสร้าง คุณจะรวมแนวทางปฏิบัติที่ดีที่สุดเพื่อเพิ่มประสิทธิภาพ

แนวทางปฏิบัติที่ดีที่สุดสำหรับการใช้งาน Hyperliquid API

คุณตรวจสอบขีดจำกัดอัตราเพื่อหลีกเลี่ยงการถูกจำกัดความเร็ว—Hyperliquid บังคับใช้ขีดจำกัดต่อ IP และต่อบัญชี

คุณใช้ testnet สำหรับการพัฒนาทั้งหมดเพื่อป้องกันการสูญเสียทางการเงิน

การจัดการข้อผิดพลาดเกี่ยวข้องกับการบันทึกรายละเอียดและการลองใหม่สำหรับความล้มเหลวชั่วคราวด้วย backoff

เพื่อความสามารถในการปรับขนาด คุณรวมคำขอเป็นชุดเมื่อเป็นไปได้ เช่น การยกเลิกหลายรายการ

ความปลอดภัยขยายไปถึงการใช้กระเป๋าเงิน API และหลักการสิทธิ์ขั้นต่ำ

คุณยังจัดเวอร์ชันโค้ดของคุณด้วยการอัปเดต SDK เนื่องจาก Hyperliquid ใช้การกำหนดเวอร์ชันเชิงความหมาย

เครื่องมืออย่าง Apidog ช่วยในการจำลองการตอบกลับสำหรับการทดสอบหน่วย

การแก้ไขปัญหาจะตามมาเมื่อเกิดปัญหาขึ้น

การแก้ไขปัญหา Hyperliquid API ทั่วไป

คุณจะพบ "หลักประกันไม่เพียงพอ" เมื่อหลักประกันต่ำ—ฝาก USDC เพื่อแก้ไข

หาก "ไม่พบสินทรัพย์" ให้ตรวจสอบดัชนีจาก meta

ข้อผิดพลาดในการยืนยันตัวตนเกิดจากคีย์ไม่ถูกต้อง—สร้างใหม่และให้สิทธิ์กระเป๋าเงิน API

ปัญหาเครือข่ายต้องตรวจสอบ URL และใช้พร็อกซีหากจำเป็น

คุณแก้ไขข้อบกพร่องด้วย Apidog โดยการเล่นซ้ำคำขอที่ล้มเหลว

บันทึกจาก SDK ให้การประทับเวลาและเพย์โหลดสำหรับการวิเคราะห์

ด้วยเคล็ดลับเหล่านี้ คุณจะรักษาการรวมระบบที่เชื่อถือได้

กรณีการใช้งานขั้นสูงด้วย Hyperliquid API

คุณสร้างบอทซื้อขายที่ตรวจสอบ l2Book และวางคำสั่งซื้อเมื่อเกิดความไม่สมดุล

กลยุทธ์เกี่ยวข้องกับอัตรา funding จากประวัติเพื่อโอกาสในการทำ arbitrage

บัญชีย่อยช่วยให้สามารถซื้อขายแยกส่วนได้: สร้างด้วยชื่อ โอนเงิน และซื้อขายแยกกัน

การโอน Vault รองรับกลุ่มสภาพคล่องที่ใช้ร่วมกัน

คุณจำลองด้วยข้อมูลย้อนหลังจาก API เพื่อ backtest

การรวมเข้ากับ Apidog ช่วยให้สามารถแก้ไขข้อบกพร่องร่วมกันในทีมได้

สุดท้าย คุณสรุปโดยพิจารณาการปรับปรุงในอนาคต

บทสรุป: การเชี่ยวชาญ Hyperliquid API สำหรับการซื้อขายแบบกระจายอำนาจ

ตอนนี้คุณมีความรู้ที่จะใช้ hyperliquid api ได้อย่างมีประสิทธิภาพแล้ว ตั้งแต่การตั้งค่าและการยืนยันตัวตน ไปจนถึงปลายทางและ SDKs คู่มือนี้จะช่วยให้คุณสามารถสร้างแอปพลิเคชันที่ซับซ้อนได้ โปรดจำไว้ว่าการปรับปรุงโค้ดของคุณทีละเล็กทีละน้อยจะนำไปสู่ประสิทธิภาพที่เพิ่มขึ้นอย่างมาก ทดลองบน testnet ใช้ประโยชน์จากเครื่องมืออย่าง Apidog และติดตามเอกสารของ Hyperliquid ให้ทันสมัยอยู่เสมอ เมื่อแพลตฟอร์มพัฒนาขึ้น ทักษะของคุณจะทำให้คุณสามารถใช้ประโยชน์จากคุณสมบัติใหม่ๆ ได้