เช่าพลังงาน TRON อัตโนมัติผ่าน API

2026-05-13

ถ้าคุณดูแล hot wallet ระบบถอนเงินของตลาดแลกเปลี่ยน หรือคอนแทรกต์ที่สั่งโอน TRC-20 แทนผู้ใช้ คุณรู้ปัญหานี้ดี พลังงาน TRON ต้องพร้อมในวินาทีที่ธุรกรรมจะถูกยิงออกไป การเติมพลังงานด้วยมือผ่าน UI ไม่ไหวเมื่อเกินไม่กี่ครั้งต่อวัน และถ้าพลาดจังหวะ ธุรกรรมจะเผา TRX จากที่อยู่ผู้ส่งแทน ซึ่งมักแพงกว่าพลังงานที่เช่าไว้ล่วงหน้ามาก ทางแก้คือเรียก API เช่าพลังงานในจังหวะที่แบ็กเอนด์กำลังจะ broadcast ธุรกรรม ให้พลังงานถูกจัดสรรโดยโปรแกรมโดยไม่มีคนอยู่ในลูป

API ทำอะไรบนเชน

โมเดลทรัพยากรของ TRON แยกการคำนวณ (พลังงาน) ออกจากขนาดธุรกรรม (bandwidth) การโอน USDT TRC-20 มาตรฐานใช้พลังงานประมาณ 65,000 เมื่อผู้รับมี USDT อยู่แล้ว และประมาณ 130,000 เมื่อยอด USDT ของผู้รับเป็นศูนย์ การโอนเข้าครั้งแรกจ่ายค่า storage สำหรับสร้างรายการยอดคงเหลือ ต้นทุนจึงขึ้นอยู่กับผู้รับทั้งหมด ไม่ใช่ผู้ส่ง ส่วน bandwidth อยู่ที่ราว 345 ไบต์ เล็กพอที่บัญชีส่วนใหญ่จ่ายจากโควตาฟรีรายวันได้

เมื่อคุณเรียก API เช่าพลังงาน บริการจะสเตก TRX ของตัวเองและมอบสิทธิ์พลังงานที่ได้ให้ที่อยู่ที่คุณระบุ โดยใช้ DelegateResourceContract ของ Stake 2.0 การมอบสิทธิ์ผูกกับที่อยู่นั้นและมีกำหนดเวลา เมื่อระยะเช่าหมด บริการเรียกพลังงานคืนอัตโนมัติ

รายละเอียดสำคัญ การเช่าเป็นแบบ asynchronous API ตอบกลับทันทีด้วย orderId และ state PAID_BY_USER แต่ธุรกรรมมอบสิทธิ์บนเชนถูก broadcast ในเบื้องหลัง และมักลงบล็อกภายในไม่กี่วินาที ให้ถือว่าการตอบกลับครั้งแรกเป็นการยืนยันว่าคำสั่งซื้อได้รับและชำระแล้ว จากนั้น poll endpoint รายละเอียดคำสั่งซื้อจนกว่า state จะเป็น ENERGY_DELEGATED

เลือกระยะเวลาเช่า

API รับพารามิเตอร์ period สี่ค่า 1h, 1d, 3d, 30d ราคาผันผวนตามตลาดพลังงานบนเชนและเปลี่ยนระหว่างวัน ตัวเลขปัจจุบันอยู่ที่หน้าราคาเสมอ ลำดับเชิงเปรียบเทียบคงที่ 1h ถูกที่สุดต่อการเรียกหนึ่งครั้ง 30d ถูกที่สุดเมื่อเฉลี่ยกับการโอนหลายครั้งจากที่อยู่เดียวกัน

สำหรับระบบที่ขับด้วยอีเวนต์ซึ่งสั่งเช่าหนึ่งครั้งต่อการโอนออกหนึ่งครั้ง ระยะ 1h แทบจะถูกต้องเสมอ คุณจ่ายต้นทุนสัมบูรณ์ต่ำสุด และพลังงานถูกใช้ภายในไม่กี่วินาทีหลังมอบสิทธิ์ ระยะ 1d และยาวกว่าเหมาะกับงาน batch ที่คาดเดาได้ เช่น งานจ่ายเงินช่วงกลางคืน ซึ่งคุณอยากเช่าพลังงานก้อนใหญ่ครั้งเดียวแทนการเรียก API หลายสิบครั้ง ถ้าระบบของคุณยิงการโอนเกิน 20-30 ครั้งต่อชั่วโมงจากที่อยู่เดียวอย่างสม่ำเสมอ การเช่าก้อน 1d ขนาดครอบคลุมปริมาณที่คาดไว้สะอาดกว่าการเรียกต่อการโอน ต้นทุนตั้งต้นสูงขึ้น แต่ overhead ของ API และความหน่วงรอยืนยันบนเชนหายไปจาก hot path

การยืนยันตัวตนและรูปแบบคำขอ

endpoint สำหรับเช่าพลังงานคือ

GET https://api.tronenergyrent.com/place-energy-order

เป็นคำขอ GET ธรรมดาพร้อม query parameter การยืนยันตัวตนคือ query parameter apiKey ซึ่งคุณสร้างจากแดชบอร์ดหลังลงทะเบียนและเติมเงินเข้าบัญชี ไม่มีการยืนยันตัวตนผ่าน header และไม่มี request body แบบ JSON พารามิเตอร์มีดังนี้

  • apiKey (จำเป็น): API key ของคุณจากแดชบอร์ด
  • period (จำเป็น): ระยะเวลาเช่า หนึ่งใน 1h, 1d, 3d, 30d
  • energyAmount (จำเป็น): จำนวนพลังงานที่จะมอบสิทธิ์ ค่าต่ำสุดคือ 15000 สำหรับการโอน USDT มาตรฐานหนึ่งครั้งไปยังผู้รับที่มี USDT อยู่แล้ว 65000 เป็นตัวเลขที่ปลอดภัย ส่วนการโอนครั้งแรกไปยังผู้ถือ USDT รายใหม่ใช้ 130000
  • destinationAddress (จำเป็น): ที่อยู่ TRON (base58check ขึ้นต้นด้วย T) ที่จะได้รับพลังงาน
  • preActivateDestinationAddress (ไม่บังคับ ค่าเริ่มต้น 0): ตั้งเป็น 1 ถ้าที่อยู่ปลายทางไม่เคยได้รับ TRX และจึงยังไม่เปิดใช้งานบนเชน บริการจะส่ง 1.5 TRX จากยอดคงเหลือที่ชำระล่วงหน้าของคุณเพื่อเปิดใช้งานที่อยู่ก่อนมอบสิทธิ์พลังงาน ถ้าที่อยู่เปิดใช้งานแล้ว ให้คงค่า 0 เพื่อไม่เสียค่าใช้จ่ายเพิ่ม

การตอบกลับมี HTTP status 200 เสมอ ไม่ว่าคำสั่งซื้อจะสำเร็จหรือล้มเหลว ให้แยกเงื่อนไขจากฟิลด์ status ใน JSON แทน HTTP status เนื้อหาเมื่อสำเร็จมีลักษณะดังนี้

{
  "status": "SUCCESS",
  "errorCode": null,
  "errorDescription": null,
  "requestId": "2651eacd-2428",
  "payload": {
    "orderId": "128de799-501e-44b2-8d6f-1fa825c2deed",
    "totalPriceSun": 5662800,
    "totalPriceTrx": 5.6628,
    "state": "PAID_BY_USER"
  }
}

เนื้อหาเมื่อผิดพลาดมี status: "ERROR" พร้อม errorCode สำหรับเครื่องอ่าน และ errorDescription สำหรับคนอ่าน

{
  "status": "ERROR",
  "errorCode": "INVALID_ENERGY_AMOUNT",
  "errorDescription": "energyAmount is less than 15000",
  "requestId": "71431087-4",
  "payload": null
}

บันทึก log requestId เสมอทั้งสองกรณี ถ้าต้องขอให้ทีมซัพพอร์ตตามการเช่ารายการใดรายการหนึ่ง นี่คือ ID ที่พวกเขาใช้ค้นหา

วงจรชีวิตของคำสั่งซื้อ

ฟิลด์ state ใน payload เปลี่ยนตามลำดับสั้น ๆ ที่คงที่

  • PAID_BY_USER: state เริ่มต้น คำสั่งซื้อถูกชำระจากยอดคงเหลือของคุณแล้ว แต่ยังไม่มีอะไรเกิดขึ้นบนเชน
  • WAITING_DELEGATION: บริการรับคำสั่งซื้อแล้วและกำลังเตรียมธุรกรรมมอบสิทธิ์
  • ENERGY_DELEGATED: ธุรกรรมมอบสิทธิ์ลงบล็อกแล้ว ที่อยู่ปลายทางถือพลังงานที่เช่าและใช้กับธุรกรรมขาออกครั้งถัดไปได้
  • ERROR_DELEGATION: การมอบสิทธิ์ล้มเหลว พบน้อย แต่เกิดได้ช่วงที่เครือข่ายแออัดหนัก
  • CANCELLED: คำสั่งซื้อถูกยกเลิกและคืนเงินเข้ายอดคงเหลือของคุณ

ตรวจ state ปัจจุบันด้วย

GET https://api.tronenergyrent.com/single-order-details?apiKey=YOUR_API_KEY&orderId=ORDER_ID

การตอบกลับใช้ envelope status / errorCode / payload เดิม โดย state ปัจจุบันอยู่ใน payload ให้ poll ทุกหนึ่งหรือสองวินาทีหลังวางคำสั่งซื้อ และโอน TRC-20 ก็ต่อเมื่อเห็น ENERGY_DELEGATED เท่านั้น ในทางปฏิบัติมักใช้ poll แค่หนึ่งหรือสองครั้ง

ตัวอย่าง Python ที่ใช้งานได้จริง

นี่คือรูปแบบที่สั้นที่สุดแต่มีโครงพร้อมใช้งานจริง โค้ดวางคำสั่งซื้อ poll จนการมอบสิทธิ์ลงเชน และแจ้งข้อผิดพลาดชัดเจนถ้ามีอะไรผิด

import logging
import time
import requests

API_BASE = "https://api.tronenergyrent.com"
API_KEY = "your_api_key_here"
ENERGY_FOR_TRANSFER = 65_000   # use 130_000 if recipient has zero USDT balance
HTTP_TIMEOUT_SECS = 10
POLL_INTERVAL_SECS = 1
POLL_TIMEOUT_SECS = 30


def place_order(destination_address: str, period: str = "1h",
                energy_amount: int = ENERGY_FOR_TRANSFER) -> dict:
    resp = requests.get(
        f"{API_BASE}/place-energy-order",
        params={
            "apiKey": API_KEY,
            "period": period,
            "energyAmount": energy_amount,
            "destinationAddress": destination_address,
            "preActivateDestinationAddress": 0,
        },
        timeout=HTTP_TIMEOUT_SECS,
    )
    resp.raise_for_status()
    body = resp.json()
    if body.get("status") != "SUCCESS":
        raise RuntimeError(
            f"place-energy-order failed: {body.get('errorCode')} "
            f"({body.get('errorDescription')}) requestId={body.get('requestId')}"
        )
    return body["payload"]


def wait_for_delegation(order_id: str) -> dict:
    deadline = time.monotonic() + POLL_TIMEOUT_SECS
    while time.monotonic() < deadline:
        resp = requests.get(
            f"{API_BASE}/single-order-details",
            params={"apiKey": API_KEY, "orderId": order_id},
            timeout=HTTP_TIMEOUT_SECS,
        )
        resp.raise_for_status()
        body = resp.json()
        if body.get("status") != "SUCCESS":
            raise RuntimeError(
                f"single-order-details failed: {body.get('errorCode')} "
                f"({body.get('errorDescription')})"
            )
        state = body["payload"]["state"]
        if state == "ENERGY_DELEGATED":
            return body["payload"]
        if state == "ERROR_DELEGATION":
            raise RuntimeError(f"Delegation failed for order {order_id}")
        if state == "CANCELLED":
            raise RuntimeError(f"Order {order_id} was cancelled")
        time.sleep(POLL_INTERVAL_SECS)
    raise TimeoutError(f"Order {order_id} did not reach ENERGY_DELEGATED in {POLL_TIMEOUT_SECS}s")


def rent_energy(destination_address: str) -> dict:
    placed = place_order(destination_address)
    logging.info(
        "Order placed: id=%s priceSun=%s priceTrx=%s",
        placed["orderId"], placed["totalPriceSun"], placed["totalPriceTrx"],
    )
    delegated = wait_for_delegation(placed["orderId"])
    logging.info("Order delegated: id=%s", delegated["orderId"])
    return delegated

มีบางจุดที่ควรสังเกต การตรวจ status == "SUCCESS" อย่างชัดเจนจำเป็น เพราะ HTTP status เป็น 200 เสมอ resp.raise_for_status() อย่างเดียวจึงบอกอะไรเกี่ยวกับผลลัพธ์จริงไม่ได้ ลูป polling มี timeout ตายตัว คำสั่งซื้อที่ค้างจะไม่บล็อก pipeline การโอนของคุณไปเรื่อย ๆ และการแยกเงื่อนไขตาม state จัดการผลลัพธ์ปลายทางทั้งสามแบบ (ENERGY_DELEGATED, ERROR_DELEGATION, CANCELLED) อย่างชัดเจน แทนการเหมารวมว่า “ไม่สำเร็จ”

ในเวิร์กโฟลว์การโอน ให้เรียก rent_energy() ก่อน แล้วจึง broadcast การโอน TRC-20 ลำดับนี้สำคัญ ถ้า broadcast ก่อน ธุรกรรมจะเผา TRX จากผู้ส่ง เพราะการมอบสิทธิ์ยังไม่ลงบล็อก

ยอดคงเหลือและการจัดการข้อผิดพลาด

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

GET https://api.tronenergyrent.com/account-info?apiKey=YOUR_API_KEY

payload มียอดคงเหลือและ state ของบัญชี ต่อเข้ากับระบบมอนิเตอร์ของคุณ แล้วจะไม่ต้องตกใจกับยอดที่หมดเกลี้ยงตอนตีสอง การเติมเงินขั้นต่ำเข้ายอดคงเหลือ tronenergyrent.com คือ 10 TRX

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

  1. INSUFFICIENT_BALANCE: ยอดคงเหลือที่ชำระล่วงหน้าไม่พอสำหรับการเช่าที่ขอบวกค่าเปิดใช้งานล่วงหน้า (ถ้ามี) อย่า retry เพราะไม่ช่วยอะไร ให้ดักกรณีนี้โดยเฉพาะแล้วส่งการแจ้งเตือนหรือเริ่ม flow เติมเงิน และใส่ requestId ลงใน payload ของการแจ้งเตือน
  2. INVALID_ADDRESS: destinationAddress decode แบบ base58check ไม่ผ่านบนเซิร์ฟเวอร์ ถ้าระบบของคุณสร้างที่อยู่แบบไดนามิก เช่น จาก input ของผู้ใช้ ให้ตรวจความถูกต้องในเครื่องก่อนเรียก API ไลบรารี Python tronpy มี is_address() สำหรับเรื่องนี้ ปฏิเสธ input ที่ผิดฝั่ง client เร็วกว่ารอ round trip
  3. INACTIVE_DESTINATION_ADDRESS_ERROR: ที่อยู่ปลายทางยังไม่เคยเปิดใช้งานบนเชน และคุณไม่ได้ขอให้บริการเปิดใช้งานให้ แก้โดยส่ง TRX จำนวนเล็กน้อยเข้าที่อยู่นั้นจากที่อื่นก่อน หรือส่ง preActivateDestinationAddress=1 ในการเรียกครั้งถัดไป ให้บริการเปิดใช้งานให้ในราคา 1.5 TRX

กรณีที่ละเอียดกว่านั้น ORDER_IS_ALREADY_IN_PROGRESS อาจกลับมาถ้าคุณมีหลาย worker วางคำสั่งเช่าสำหรับปลายทางเดียวกันพร้อมกัน ทางแก้อยู่ฝั่ง process ไม่ใช่ฝั่ง API ใช้ distributed lock (Redis ใช้ได้ดี) ที่ key ด้วยที่อยู่ปลายทาง และถือไว้จนการมอบสิทธิ์เสร็จ

ยืนยันบนเชน

สำหรับการเชื่อมต่อส่วนใหญ่ การ poll /single-order-details จนได้ ENERGY_DELEGATED ก็พอแล้ว ถ้าต้องการความมั่นใจอีกชั้น query TRON full node โดยตรงหลังการมอบสิทธิ์ลงบล็อก

GET https://api.trongrid.io/v1/accounts/{destinationAddress}

การตอบกลับมีสถานะทรัพยากรปัจจุบันของที่อยู่ รวมถึงพลังงานที่ถูกมอบสิทธิ์มาจากที่อยู่ภายนอก ชื่อฟิลด์ที่แน่นอนขึ้นกับ view ปัจจุบันของ Stake 2.0 ตอนเชื่อมต่อให้ดูเอกสาร TRON HTTP API ฉบับล่าสุด ถ้าทำเป็นการตรวจแบบเบา ๆ ที่แค่ log คำเตือนแทนการบล็อกการโอน มันเป็นสัญญาณเตือนที่มีประโยชน์สำหรับกรณีหายากที่บางอย่างผิดพลาดหลัง API เช่าพลังงานทำงานเสร็จ และช่วยประหยัดเวลาดีบักหลายชั่วโมงในครั้งที่การเช่าดูสำเร็จใน API แต่มีอะไรบางอย่างผิดบนเชน

ต้องการประหยัดค่าธรรมเนียม TRON? ตรวจสอบราคาพลังงานตอนนี้ ประมาณราคา
กลับไปยังบล็อก