> For the complete documentation index, see [llms.txt](https://docs.kanalabs.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.kanalabs.io/spot-and-perp-apis/trading-apis/kana-perps-api/kana-perps-python-rest-api.md). # Kana Perps Python REST API ## **1. Get Market Info** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getMarketInfo`](#id-1.-get-market-info) * **Method**:\ `GET` * **Query Parameters**: * `marketId` (Required) - The ID of the market you want information about. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getMarketInfo?marketId=501 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Market information fetched successfully", "data": [ { "__variant__": "V1", "base_decimals": 8, "base_name": "APT/USDC", "counter": "17", "creator": "0xb61d7b57333abf8ac036e752f19d0ba0c4baa5404db1cbf868c57dac3628f2bf", "lot_size": "100000", "maintenance_margin": "250", "market_address": "0xfd8d58fdd05dd9d0442a9d555a4f8ed310112eb7d1c297307038a650136e207b", "market_id": "501", "max_leverage": "20", "max_lots": "150000000", "min_lots": "500", "quote_decimals": 6, "quote_precision": 3, "tick_size": "1" } ] } ``` **Example Code to Fetch Market Information:** The following Python script demonstrates how to call the Get Market Info API using the requests library. ```python import requests import os from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getMarketInfo' params = { 'marketId': 'your_market_id' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_market_info = response.json() print("getMarketInfo: ", get_market_info) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **2.** Get Wallet Account Balance * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getWalletAccountBalance`](https://perps-tradeapi.kanalabs.io/getWalletAccountBalance) * **Method**:\ `GET` * **Query Parameters**: * `userAddress` (Required) - The wallet address for which the account balance is being fetched. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getWalletAccountBalance?userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched wallet account balance successfully", "data": "16391.60" } ``` **Example Code to Fetch** Wallet Account Balance **Information:** The following Python script demonstrates how to call the Get Wallet Account Balance API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getWalletAccountBalance' params = { 'userAddress': 'your_wallet_address' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_wallet_account_balance = response.json() print("getWalletAccountBalance: ", get_wallet_account_balance) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **3.** Get Profile Balance Snapshot * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getProfileBalanceSnpashot`](https://perps-tradeapi.kanalabs.io/getProfileBalanceSnpashot) * **Method**:\ `GET` * **Query Parameters**: * `userAddress` (Required) - The wallet address for which the account balance is being fetched. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getProfileBalanceSnpashot?userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Profile balance snapshot fetched successfully", "data": "44.321972" } ``` **Example Code to Fetch** Trading Account Balance **Information:** The following Python script demonstrates how to call the Get Trading Account Balance API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getProfileBalanceSnpashot' params = { 'userAddress': 'your_wallet_address' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_trading_account_balance = response.json() print("getTradingAccountBalance: ", get_trading_account_balance) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **4. Deposit** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/deposit`](https://perps-tradeapi.kanalabs.io/deposit) * **Method**:\ `GET` * **Query Parameters:** * `amount` (Required) - The amount of the quote coin to deposit. * `userAddress` (Required) - The address of the user making the deposit. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/deposit?userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770&amount=50000000 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Deposit payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::deposit", "functionArguments": [ "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770", 50000000 ], "typeArguments": [] } } ``` **Example Code to Depsoit a quote coin:** The following Python script demonstrates how to call the Get Deposit API using the requests library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.account_address import AccountAddress # Import this from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url, params, headers): try: response = requests.get(api_url, params=params, headers=headers) response.raise_for_status() return response.json().get("data") except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/deposit" PARAMS = { "userAddress":"0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770", "amount": 50 } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, PARAMS, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ AccountAddress.from_str(payload_data["functionArguments"][0]), int(payload_data["functionArguments"][1]), ] payload_data["argumentTypes"] = [Serializer.struct, Serializer.u64] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **5. Withdraw Specific Market** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/withdrawSpecifiMarket`](https://perps-tradeapi.kanalabs.io/withdrawSpecifiMarket) * **Method**:\ `GET` * **Query Parameters**: * `marketId` (Required) - The ID of the market you want to withdraw. * `amount` (Required) - The amount of the quote coin to withdraw. * `userAddress` (Required) - The address of the user making the withdraw. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/withdrawSpecifiMarket?marketId=501&userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770&amount=50 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Withdraw specific market payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::withdraw_specific_market", "functionArguments": [ "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770", "501", 50000000 ], "typeArguments": [] } } ``` **Example Code to Withdraw a quote coin:** The following Python script demonstrates how to call the Get Withdraw API using the requests library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.account_address import AccountAddress # Import this from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url, params, headers): try: response = requests.get(api_url, params=params, headers=headers) response.raise_for_status() return response.json().get("data") except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/withdrawSpecifiMarket" PARAMS = { "userAddress": "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770", "marketId": 501, "amount": 50 } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, PARAMS, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ AccountAddress.from_str(payload_data["functionArguments"][0]), int(payload_data["functionArguments"][1]), int(payload_data["functionArguments"][1]), ] payload_data["argumentTypes"] = [Serializer.struct, Serializer.u64, Serializer.u64] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **6. Place Limit Order** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/placeLimitOrder`](https://perps-tradeapi.kanalabs.io/placeLimitOrder) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market where the limit order will be placed. * **tradeSide** (Required) - Indicates the trade side: * `true` for the long side. * `false` for the short side. * **direction** (Required) - Indicates the direction of the trade: * `false` to open a position. * `true` to close a position. * **size** (Required) - The size of the order. * **price** (Required) - The price at which the order is to be placed. * **leverage** (Required) - The leverage to be used for the order. * **restriction** - Specifies the type of order restriction. It is an optional parameter with a default value of `0`.\ Possible values are: * `0` - `NO_RESTRICTION`: Optionally fill as a taker, then post to the book as a maker. * `1` - `FILL_OR_ABORT`: Abort if any size posts as a maker (only fill). * `3` - `POST_OR_ABORT`: Abort if any size fills as a taker (only post). * If `restriction` is not provided, it defaults to `0`. It can either be a number or left undefined. * **takeProfit** - The take profit value is optional. If not provided, it defaults to `0`. It can either be a number or left undefined. * **stopLoss** - The stop loss value is also optional. If not provided, it defaults to `0`. It can either be a number or left undefined. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/placeLimitOrder/?marketId=501&tradeSide=true&direction=false&size=10000&price=3000&leverage=3 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Limit Order payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::place_limit_order", "functionArguments": [ "501", "true", "false", 1000000, 8000000, "5", 0, 0, 0 ], "typeArguments": [] } } ``` **Example Code to Place a limit order:** The following Python script demonstrates how to call the Get Place Limit Order API using the requests library. ```python import asyncio import os import requests from dotenv import load_dotenv from typing import List from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url, params, headers): try: response = requests.get(api_url, params=params, headers=headers) response.raise_for_status() return response.json().get("data") except requests.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_function_arguments(self, arguments: List, types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: module, function_id = "::".join(payload["function"].split("::")[:-1]), payload["function"].split("::")[-1] function_arguments = self.create_transaction_function_arguments(payload["functionArguments"], payload["argumentTypes"]) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural(module=module, function=function_id, ty_args=type_arguments, args=function_arguments) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction = await self.rest_client.create_bcs_signed_transaction(self.account, transaction_payload) txn_hash = await self.rest_client.submit_bcs_transaction(signed_transaction) await self.rest_client.wait_for_transaction(txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" private_key_hex = os.getenv('APTOS_PRIVATEKEY') if not private_key_hex: print("Error: APTOS_PRIVATEKEY is missing in .env file.") return account = Account.load_key(bytes.fromhex(private_key_hex[2:] if private_key_hex.startswith("0x") else private_key_hex)) rest_client = RestClient(NODE_URL) API_URL = "https://perps-tradeapi.kanalabs.io/placeLimitOrder" PARAMS = {"marketId": 501, "tradeSide": True, "direction": False, "size": 2, "price": 7, "leverage": 2} HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, PARAMS, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ int(payload_data["functionArguments"][0]), payload_data["functionArguments"][1].lower() == "true", payload_data["functionArguments"][2].lower() == "true", *map(int, payload_data["functionArguments"][3:]) ] payload_data["argumentTypes"] = [ Serializer.u64, Serializer.bool, Serializer.bool, Serializer.u64, Serializer.u64, Serializer.u64, Serializer.u8, Serializer.u64, Serializer.u64 ] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Hash: {txn_hash}") except Exception as e: print(f"Transaction process error: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **7. Place Market Order** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/placeMarketOrder`](https://perps-tradeapi.kanalabs.io/placeMarketOrder) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market where the limit order will be placed. * **tradeSide** (Required) - Indicates the trade side: * `true` for the long side. * `false` for the short side. * **direction** (Required) - Indicates the direction of the trade: * `false` to open a position. * `true` to close a position. * **size** (Required) - The size of the order. * **leverage** (Required) - The leverage to be used for the order. * **takeProfit** - The take profit value is optional. If not provided, it defaults to `0`. It can either be a number or left undefined. * **stopLoss** - The stop loss value is also optional. If not provided, it defaults to `0`. It can either be a number or left undefined. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/placeMarketOrder?marketId=66&tradeSide=false&direction=true&size=1000&leverage=20 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Market Order payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::place_market_order", "functionArguments": [ "501", "true", "false", 1000000, "5", 0, 0 ], "typeArguments": [] } } ``` **Example Code to Place a market order:** The following Python script demonstrates how to call the Get Place Market Order API using the requests library. ```python import asyncio import os import requests from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag from dotenv import load_dotenv from typing import List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url: str, params: dict, headers: dict) -> dict | None: try: response = requests.get(api_url, params=params, headers=headers) response.raise_for_status() return response.json().get("data") except requests.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: module, function_id = "::".join(payload["function"].split("::")[:-1]), payload["function"].split("::")[-1] type_arguments = [TypeTag(StructTag.from_str(arg)) for arg in payload["typeArguments"]] function_arguments = [TransactionArgument(arg, serializer) for arg, serializer in zip(payload["functionArguments"], payload["argumentTypes"])] return TransactionPayload(payload=EntryFunction.natural(module, function_id, type_arguments, function_arguments)) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_txn = await self.rest_client.create_bcs_signed_transaction(sender=self.account, payload=transaction_payload) txn_hash = await self.rest_client.submit_bcs_transaction(signed_transaction=signed_txn) await self.rest_client.wait_for_transaction(txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" API_URL = "https://perps-tradeapi.kanalabs.io/placeMarketOrder" HEADERS = {"x-api-key": os.getenv('API_KEY')} PARAMS = {"marketId": 501, "tradeSide": True, "direction": False, "size": 2, "leverage": 2} rest_client = RestClient(NODE_URL) private_key = os.getenv('APTOS_PRIVATEKEY', "").lstrip("0x") if not private_key: print("Error: APTOS_PRIVATEKEY is missing in .env file.") return account = Account.load_key(bytes.fromhex(private_key)) handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, PARAMS, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ int(payload_data["functionArguments"][0]), payload_data["functionArguments"][1].lower() == "true", payload_data["functionArguments"][2].lower() == "true", *map(int, payload_data["functionArguments"][3:]) ] payload_data["argumentTypes"] = [Serializer.u64, Serializer.bool, Serializer.bool] + [Serializer.u64] * (len(payload_data["functionArguments"]) - 3) transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **8. Cancel Multiple Orders** * **Endpoint URL**:\ [`htps://perps-tradeapi.kanalabs.io/cancelMultipleOrders`](#api-overview) * **Method**:\ `POST` * **Request Body**: * **marketId**: The ID of the market for which the orders will be canceled. * **orderIds**: A list of order IDs to cancel. * cancelTradeSides: The sides of the orders to cancel (true for long, false for short). **Example Request:** ```json { "marketId": 66, "cancelOrderIds": ["1077898597726583798162207", "1077880153515406921884445"], "orderSides": [true, false] } ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Cancel Multiple Orders payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::cancel_multiple_orders", "functionArguments": [ 501, [ "1077898597726583798162207", "1077880153515406921884445" ], [ true, false ] ], "typeArguments": [] } } ``` **Example Code to Cancel multiple orders:** The following Python script demonstrates how to call the Post Cancel Multiple Orders API using the requests library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url, json_data, headers): try: response = requests.post(api_url, json=json_data, headers=headers) response.raise_for_status() return response.json().get("data") except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") try: return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] except Exception as e: print(f"Error creating transaction arguments: {e}") raise def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/cancelMultipleOrders" BODY = { "marketId": 501, "cancelOrderIds": [627189579998281341784], "orderSides": [True] } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, BODY, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ BODY["marketId"], BODY["cancelOrderIds"], BODY["orderSides"] ] payload_data["argumentTypes"] = [ Serializer.u64, Serializer.sequence_serializer(Serializer.u128), Serializer.sequence_serializer(Serializer.bool) ] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **8. Place Multiple Orders** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/placeMultipleOrders`](https://perps-tradeapi.kanalabs.io/placeMultipleOrders) * **Method**:\ `POST` Request Body : * marketId (Required) - The ID of the market where the orders will be placed. * orderTypes (Required) - An array of order types for each order: * true for limit orders. * false for market orders. * tradeSides (Required) - An array indicating the trade sides for each order: * true for long positions. * false for short positions. * directions (Required) - An array indicating the direction of each trade: * false to open a position. * true to close a position. * sizes (Required) - An array of sizes for each order. * leverages (Required) - An array of leverages for each order. * prices (Required) - An array of prices at which each order is to be placed. * **restriction** - Specifies the type of order restriction. It is an optional parameter with a default value of `0`.\ Possible values are: * `0` - `NO_RESTRICTION`: Optionally fill as a taker, then post to the book as a maker. * `1` - `FILL_OR_ABORT`: Abort if any size posts as a maker (only fill). * `3` - `POST_OR_ABORT`: Abort if any size fills as a taker (only post). * If `restriction` is not provided, it defaults to `0`. It can either be a number or left undefined. * **takeProfits** - The take profit value is optional. If not provided, it defaults to `0`. It can either be a number or left undefined. * **stopLosses** - The stop loss value is also optional. If not provided, it defaults to `0`. It can either be a number or left undefined. **Example Request:** ```json { "marketId": 66, "orderTypes": [true, true], "tradeSides": [true, true], "directions": [true, true], "sizes": [1000, 1000], "prices": [1000, 1000], "leverages": [2, 2] } ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Multiple Orders payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::place_multiple_orders", "functionArguments": [ 501, [ true, true ], [ true, true ], [ true, true ], [ 1000, 1000 ], [ 4670, 6780 ], [ 2, 2 ], [ 0, 0 ], [ 4600 ], [ 0, 0 ] ], "typeArguments": [] } } ``` **Example Code to Place a multiple orders:** The following Python script demonstrates how to call the Get Place Multiple Orders API using the requests library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url: str, json_data: dict, headers: dict) -> dict: try: response = requests.post(api_url, json=json_data, headers=headers) response.raise_for_status() payload_data = response.json().get("data") if payload_data is None: print("No data returned from API.") return {} # Dynamically ensure the length matches the sizes provided payload_data["takeProfits"] = payload_data.get("takeProfits", [0] * len(json_data["sizes"])) payload_data["stopLosses"] = payload_data.get("stopLosses", [0] * len(json_data["sizes"])) payload_data["restrictions"] = payload_data.get("restrictions", [0] * len(json_data["sizes"])) return payload_data except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return {} def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") try: return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] except Exception as e: print(f"Error creating transaction arguments: {e}") raise def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/placeMultipleOrders" BODY = { "marketId": 501, "orderTypes": [True], "tradeSides": [True], "directions": [False], "sizes": [1000], "prices": [7], "leverages": [2] } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, BODY, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ BODY["marketId"], BODY["orderTypes"], BODY["tradeSides"], BODY["directions"], BODY["sizes"], BODY["prices"], BODY["leverages"], payload_data["restrictions"], payload_data["takeProfits"], payload_data["stopLosses"] ] payload_data["argumentTypes"] = [ Serializer.u64, Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u8), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u64) ] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **9. Cancel and Place Multiple Orders** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/cancelAndPlaceMultipleOrders`](https://perps-tradeapi.kanalabs.io/cancelAndPlaceMultipleOrders) * **Method**:\ `POST` Request Body : * marketId (Required) - The ID of the market where the orders will be placed. * cancelOrderIds **(Required)** - An array of strings representing the IDs of the orders to be canceled. * orderSides **(Required)** - An array indicating the sides of the orders being canceled: * `true` for long sides. * `false` for short sides. * orderTypes (Required) - An array of order types for each order: * true for limit orders. * false for market orders. * tradeSides (Required) - An array indicating the trade sides for each order: * true for long positions. * false for short positions. * directions (Required) - An array indicating the direction of each trade: * false to open a position. * true to close a position. * sizes (Required) - An array of sizes for each order. * leverages (Required) - An array of leverages for each order. * prices (Required) - An array of prices at which each order is to be placed. * **restriction** - Specifies the type of order restriction. It is an optional parameter with a default value of `0`.\ Possible values are: * `0` - `NO_RESTRICTION`: Optionally fill as a taker, then post to the book as a maker. * `1` - `FILL_OR_ABORT`: Abort if any size posts as a maker (only fill). * `3` - `POST_OR_ABORT`: Abort if any size fills as a taker (only post). * If `restriction` is not provided, it defaults to `0`. It can either be a number or left undefined * **takeProfits** - The take profit value is optional. If not provided, it defaults to `0`. It can either be a number or left undefined. * **stopLosses** - The stop loss value is also optional. If not provided, it defaults to `0`. It can either be a number or left undefined. **Example Request:** ```json { "marketId": 66, "cancelOrderIds": [23434565434567", "454345665456], "orderSides": [true, true], "orderTypes": [true, true], "tradeSides": [true, false], "directions": [true, true], "sizes": [1000, 2000], "prices": [5000, 6000], "leverages": [2, 2] } ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Cancel and place multiple Orders payload has been built successfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::cancel_and_place_multiple_orders", "functionArguments": [ 501, [ "23434565434567", "454345665456" ], [ "true", "true" ], [ true, true ], [ true, false ], [ true, true ], [ 1000, 2000 ], [ 5000, 6000 ], [ 2, 2 ], [ 0, 0 ], [ 0, 0 ], [ 0, 0 ] ], "typeArguments": [] } } ``` **Example Code to cancel and Place a multiple orders:** The following TypeScript/Node.js script demonstrates how to call the Get Cancel And Place Multiple Orders API using the `axios` library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url: str, json_data: dict, headers: dict) -> dict: try: response = requests.post(api_url, json=json_data, headers=headers) response.raise_for_status() payload_data = response.json().get("data") if payload_data is None: print("No data returned from API.") return {} # Dynamically ensure the length matches the sizes provided payload_data["takeProfits"] = payload_data.get("takeProfits", [0] * len(json_data["sizes"])) payload_data["stopLosses"] = payload_data.get("stopLosses", [0] * len(json_data["sizes"])) payload_data["restrictions"] = payload_data.get("restrictions", [0] * len(json_data["sizes"])) return payload_data except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return {} def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") try: return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] except Exception as e: print(f"Error creating transaction arguments: {e}") raise def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/cancelAndPlaceMultipleOrders" BODY = { "marketId": 501, "cancelOrderIds": [664083068162880314200], "orderSides": [True], "orderTypes": [True], "tradeSides": [True], "directions": [False], "sizes": [1000], "prices": [7], "leverages": [2] } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, BODY, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ BODY["marketId"], BODY["cancelOrderIds"], BODY["orderSides"], BODY["orderTypes"], BODY["tradeSides"], BODY["directions"], BODY["sizes"], BODY["prices"], BODY["leverages"], payload_data["restrictions"], payload_data["takeProfits"], payload_data["stopLosses"] ] payload_data["argumentTypes"] = [ Serializer.u64, Serializer.sequence_serializer(Serializer.u128), Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.bool), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u8), Serializer.sequence_serializer(Serializer.u64), Serializer.sequence_serializer(Serializer.u64) ] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **10.** Get Open Orders * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getOpenOrders`](https://perps-tradeapi.kanalabs.io/getOpenOrders) * **Method**:\ `GET` * **Query Parameters**: * **userAddress** (Required) - The wallet address to retrieve open orders for. * **marketId** - The ID of the market to filter open orders. // Optional ``` Note : order_type Explanation: OPEN_LONG (1): Opens a new long position. OPEN_SHORT (2): Opens a new short position. INCREASE_LONG (3): Increases the size of an existing long position. INCREASE_SHORT (4): Increases the size of an existing short position. DECREASE_LONG (5): Reduces the size of an existing long position. DECREASE_SHORT (6): Reduces the size of an existing short position. CLOSE_LONG (7): Closes an existing long position. CLOSE_SHORT (8): Closes an existing short position. ``` **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getOpenOrders?userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770&marketId=66 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched open orders successfully", "data": [ { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 3, "timestamp": "1741444213", "price": "7", "total_size": "2", "remaining_size": "2", "order_value": "14", "order_id": "645636324063400958808", "trade_id": "295147905179352826357", "last_updated": "1741444214" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 3, "timestamp": "1741445758", "price": "7", "total_size": "2", "remaining_size": "2", "order_value": "14", "order_id": "682529812245179800408", "trade_id": "295147905179352826357", "last_updated": "1741445758" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 3, "timestamp": "1741446786", "price": "7", "total_size": "2", "remaining_size": "2", "order_value": "14", "order_id": "700976556301709482840", "trade_id": "295147905179352826357", "last_updated": "1741446786" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 3, "timestamp": "1741446907", "price": "7", "total_size": "2", "remaining_size": "2", "order_value": "14", "order_id": "719423300401188838232", "trade_id": "295147905179352826357", "last_updated": "1741446908" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 3, "timestamp": "1741447619", "price": "0.007", "total_size": "1", "remaining_size": "1", "order_value": "0.007", "order_id": "737869903703050289159", "trade_id": "295147905179352826357", "last_updated": "1741447620" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 3, "timestamp": "1741447815", "price": "0.007", "total_size": "1", "remaining_size": "1", "order_value": "0.007", "order_id": "756316647793939709959", "trade_id": "295147905179352826357", "last_updated": "1741447815" } ] } ``` **Example Code to Fetch** Open Orders**:** The following Python script demonstrates how to call the Get Open Orders API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getOpenOrders' params = { 'marketId': 501, 'userAddress': "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770" } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_open_orders = response.json() print("getOpenOrders: ", get_open_orders) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **11.** Get Order History * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getOrderHistory`](https://perps-tradeapi.kanalabs.io/getOrderHistory) * **Method**:\ `GET` * **Query Parameters**: * **userAddress** (Required) - The wallet address to retrieve the order history for. * **marketId** (optional) - The ID of the market to filter the order history. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getOrderHistory?userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770&marketId=66 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched order history successfully", "data": [ { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 1, "timestamp": "1741167151", "is_market_order": false, "size": "1.50", "price": "4.678", "order_value": "7.01700", "status": "Open", "order_id": "18446884819787846214", "trade_id": "18446744073709552117", "last_updated": "1741262093" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 1, "timestamp": "1741236277", "is_market_order": false, "size": "1.50", "price": "4.678", "order_value": "7.01700", "status": "Cancelled", "order_id": "18446884819787846214", "trade_id": "18446744073709552117", "last_updated": "1741262168" }, { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "order_type": 1, "timestamp": "1741236468", "is_market_order": false, "size": "1.50", "price": "4.50", "order_value": "6.7500", "status": "Open", "order_id": "36893628893497397652", "trade_id": "36893488147419103733", "last_updated": "1741262168" } } ] ``` **Example Code to Fetch Order History:** The following Python script demonstrates how to call the Get Order History API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getOrderHistory' params = { 'marketId': 501, 'userAddress': "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770" } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_order_history = response.json() print("getOrderHistory: ", get_order_history) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **12.** Get Positions * **Endpoint URL**:\ [h`ttps://perps-tradeapi.kanalabs.io/getPositions`](https://perps-tradeapi.kanalabs.io/getPositions) * **Method**:\ `GET` * **Query Parameters**: * **userAddress** (Required) - The wallet address of the user to view positions for. * **marketId** (optional) - The ID of the market to filter the positions. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getPositions?marketId=66&userAddress=0x2eda5777ed2bf68cbcc67359dd00ae5fa73b1d5fa160b7c3aeb42d748d485387 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched positions successfully", "data": [ { "address": "0x3c78886aa67752706b3502b12959edf92e68d85ae64b24226783d26ce6efc1e", "market_id": "501", "leverage": 2, "is_long": true, "size": "1", "available_order_size": "1", "value": "5.678", "entry_price": "5.678", "liq_price": "2.9117948717948717990163355253", "margin": "2.839", "tp": "6.012", "sl": null, "trade_id": "295147905179352826357", "last_updated": "1741262185" } ] } ``` **Example Code to Fetch** Open Position**:** The following Python script demonstrates how to call the Get Open Position API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getPositions' params = { 'marketId': 501, 'userAddress': "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770" } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_open_position = response.json() print("getOpenPosition: ", get_open_position) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **12.** Get All Trades * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getAllTrades`](https://perps-tradeapi.kanalabs.io/getAllTrades) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market to retrieve all trades information. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getAllTrades?marketId=66 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Recent trades fetched successfully", "data": [ { "txn_version": 6297687196, "event_idx": 5, "emit_address": "0x2eda5777ed2bf68cbcc67359dd00ae5fa73b1d5fa160b7c3aeb42d748d485387", "time": "2024-11-20T20:33:38.600241+00:00", "maker_address": "0x2eda5777ed2bf68cbcc67359dd00ae5fa73b1d5fa160b7c3aeb42d748d485387", "maker_custodian_id": 28, "maker_order_id": "15951655917465922493754983", "maker_side": true, "market_id": 66, "price": 11879, "sequence_number_for_trade": 0, "size": 10000, "taker_address": "0x13eb7ea6b62c6cd791b5c4e0e2ef1dfbe59d1cf4823929343a273274c288bc8a", "taker_custodian_id": 28, "taker_order_id": "15951748150764039921729536", "taker_quote_fees_paid": 59395 }, { "txn_version": 6297687196, "event_idx": 4, "emit_address": "0x13eb7ea6b62c6cd791b5c4e0e2ef1dfbe59d1cf4823929343a273274c288bc8a", "time": "2024-11-20T20:33:38.600241+00:00", "maker_address": "0x2eda5777ed2bf68cbcc67359dd00ae5fa73b1d5fa160b7c3aeb42d748d485387", "maker_custodian_id": 28, "maker_order_id": "15951655917465922493754983", "maker_side": true, "market_id": 66, "price": 11879, "sequence_number_for_trade": 0, "size": 10000, "taker_address": "0x13eb7ea6b62c6cd791b5c4e0e2ef1dfbe59d1cf4823929343a273274c288bc8a", "taker_custodian_id": 28, "taker_order_id": "15951748150764039921729536", "taker_quote_fees_paid": 59395 } ] } ``` **Example Code to Fetch** All trades**:** The following Python script demonstrates how to call the Get Open Position API using the requests library. ```typescript import axios from "axios"; async function main(): Promise { const baseURL = 'https://perps-tradeapi.kanalabs.io/getAllTrades'; const params = { marketId: 'your_market_id' }; const res = await axios.get(baseURL, { params, headers: { 'x-api-key': process.env.API_KEY, }, }); const getAllTrades = res.data; console.log("getAllTrades : ", getAllTrades); } main().catch(error => { console.error('An error occurred:', error); }); ``` ## **13.** Get Order Status By Order Id * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getOrderStatusByOrderId`](https://perps-tradeapi.kanalabs.io/getOrderStatusByOrderId) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market associated with the order. * **orderId** (Required) - The unique identifier of the order to retrieve its status. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getOrderStatusByOrderId?marketId=66&orderId=15308325717473050761363456 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "status": true, "message": "Fetched order status for a given order Id successfully", "data": { "market_id": 66, "order_id": "15308325717473050761363456", "created_at": "2024-11-20T11:54:45.957059+00:00", "last_updated_at": "2024-11-20T11:54:45.957059+00:00", "integrator": "0xee820ab02631dd1a195d3c53fa64f0a8f455dbb9261388e141c3bd3bd3c08363", "total_filled": 1000, "remaining_size": 0, "order_status": "closed", "order_type": "market", "user": "0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770", "direction": "buy", "price": 0, "average_execution_price": 12813, "custodian_id": 28, "self_match_behavior": 0, "restriction": 0, "last_increase_stamp": null, "min_base": null, "max_base": null, "min_quote": null, "max_quote": null, "total_fees_paid_in_quote_subunits": 6406 } } ``` **Example Code to Fetch** Order Status B Order Id**:** The following Python script demonstrates how to call the Get Order Status By Order Id API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getOrderStatusByOrderId' params = { 'marketId': 'your_market_id', 'orderId': 'your_order_id' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_order_status_by_order_id = response.json() print("getOrderStatusByOrderId: ", get_order_status_by_order_id) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **14.** Get Fills * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getFills`](https://perps-tradeapi.kanalabs.io/getFills) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market for which fills are retrieved. * **address** (Optional) - The address of the user to filter fills (if applicable). * **from** (Required) - The start time of the range in ISO 8601 format (e.g., `2024-11-21T00:00:00Z`). * **to** (Required) - The end time of the range in ISO 8601 format (e.g., `2024-11-21T23:59:59Z`). * **orderId** (Required) - The unique identifier of the order to retrieve its status. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getFills?marketId=66&address=0x3a6b332c7889784fe57ea61f507b5056e386db8f56c6323b4d898485f468f0c2&from=2024-11-20T00:00:00Z&to=2024-11-21T23:59:59Z ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched fill trades for a given time range Successfully", "data": [ { "txn_version": 6296434935, "event_idx": 1, "emit_address": "0x3a6b332c7889784fe57ea61f507b5056e386db8f56c6323b4d898485f468f0c2", "time": "2024-11-20T19:23:14.67535+00:00", "maker_address": "0x2eda5777ed2bf68cbcc67359dd00ae5fa73b1d5fa160b7c3aeb42d748d485387", "maker_custodian_id": 28, "maker_order_id": "15891335065048614061485282", "maker_side": true, "market_id": 66, "price": 11490, "sequence_number_for_trade": 0, "size": 1000, "taker_address": "0x3a6b332c7889784fe57ea61f507b5056e386db8f56c6323b4d898485f468f0c2", "taker_custodian_id": 28, "taker_order_id": "15891427297643009687945216", "taker_quote_fees_paid": 5745 }, { "txn_version": 6295302625, "event_idx": 4, "emit_address": "0x3a6b332c7889784fe57ea61f507b5056e386db8f56c6323b4d898485f468f0c2", "time": "2024-11-20T18:19:35.70863+00:00", "maker_address": "0x2eda5777ed2bf68cbcc67359dd00ae5fa73b1d5fa160b7c3aeb42d748d485387", "maker_custodian_id": 28, "maker_order_id": "15812401447297883953966476", "maker_side": false, "market_id": 66, "price": 11660, "sequence_number_for_trade": 0, "size": 1000, "taker_address": "0x3a6b332c7889784fe57ea61f507b5056e386db8f56c6323b4d898485f468f0c2", "taker_custodian_id": 28, "taker_order_id": "15812549019983827645235200", "taker_quote_fees_paid": 5830 } ] } ``` **Example Code to Fetch** Order Status B Order IdFills Data**:** The following Python script demonstrates how to call the Get Fills Data API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getFills' params = { 'marketId': 'your_market_id', 'address': 'your_address', 'from': 'your_from_time', 'to': 'your_to_time' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_fills_data = response.json() print("getFillsData: ", get_fills_data) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **14.** Get Market Price * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getMarketPrice`](https://perps-tradeapi.kanalabs.io/getMarketPrice) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market for which the price information is being retrieved. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getMarketPrice?marketId=66 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched Market Price Successfully", "data": { "bestAskPrice": 6.400, "bestBidPrice": 9.880 } } ``` **Example Code to Fetch** Market Price**:** The following Python script demonstrates how to call the Get Market Price API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getMarketPrice' params = { 'marketId': 501 } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_market_price = response.json() print("getMarketPrice: ", get_market_price) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **15.** Get Last Execution Price * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getLastPlacedPrice`](https://perps-tradeapi.kanalabs.io/getLastPlacedPrice) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market for which the last execution price information is being retrieved. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getLastPlacedPrice?marketId=66 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched last execution price Successfully", "data": 8.989 } ``` **Example Code to Fetch** Last Execution Price**:** The following Python script demonstrates how to call the Get Last Execution Price API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getLastPlacedPrice' params = { 'marketId': '501' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_last_execution_price = response.json() print("getLastExecutionPrice: ", get_last_execution_price) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **16.** Get All Open Order Ids * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getAllOpenOrderIds`](https://perps-tradeapi.kanalabs.io/getAllOpenOrderIds) * **Method**:\ `GET` * **Query Parameters**: * userAddress(Required) - The address associated with the orders. * **marketId** (optional) - The ID of the market for which open order IDs are being retrieved. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getAllOpenOrderIds?marketId=66&userAddress=0x3a6b332c7889784fe57ea61f507b5056e386db8f56c6323b4d898485f468f0c2 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Open order IDs fetched successfully", "data": [ "645636324063400958808", "682529812245179800408", "700976556301709482840", "719423300401188838232", "737869903703050289159", "756316647793939709959" ] } ``` **Example Code to Fetch** Open Order Ids**:** The following Python script demonstrates how to call the Get Open Order Ids API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getAllOpenOrderIds' params = { 'userAddress': 'your_wallet_address', 'marketId': 'your_market_id' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_open_order_ids = response.json() print("getOpenOrderIds: ", get_open_order_ids) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **17. Update Take Profit** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/updateTakeProfit`](https://perps-tradeapi.kanalabs.io/updateTakeProfit) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market for which the take profit values will be updated. * **tradeSide** (Required) - The trade side: * `true` for the long side. * `false` for the short side. * **newTakeProfitPrice** (Required) - The new take profit price to be set for the trade. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/updateTakeProfit?marketId=66&tradeSide=true&newTakeProfitPrice=6000 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Update take profit payload built succesfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::update_take_profit", "functionArguments": [ "501", "true", 7590 ], "typeArguments": [] } } ``` **Example Code to Update take profit price:** The following Python script demonstrates how to call the Get Update Take Profit Price API using the requests library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url, params, headers): try: response = requests.get(api_url, params=params, headers=headers) response.raise_for_status() return response.json().get("data") except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/updateTakeProfit" PARAMS = { "marketId": 501, "tradeSide": True, "newTakeProfitPrice": 6.89 } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, PARAMS, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ int(payload_data["functionArguments"][0]), payload_data["functionArguments"][1].lower() == "true", int(payload_data["functionArguments"][2]), ] payload_data["argumentTypes"] = [Serializer.u64, Serializer.bool, Serializer.u64] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ``` ## **18.** Get Account Aptos Balance * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/getAccountAptBalance`](https://perps-tradeapi.kanalabs.io/getAccountAptBalance) * **Method**:\ `GET` * **Query Parameters**: * **userAddress** (Required) - The address of the account whose balance will be **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/getAccountAptBalance?userAddress=0x4d6dc68e391e86991e58ab4d548b7e92872430d1f51bc666fe0c206bad7ff770 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Fetched Account Apt Balance Successfully", "data": 8.2344617 } ``` **Example Code to Fetch** Wallet Account Aptos Balance **Information:** The following Python script demonstrates how to call the Get Wallet Account Aptos Balance API using the requests library. ```python import os import requests from dotenv import load_dotenv load_dotenv() def main(): try: base_url = 'https://perps-tradeapi.kanalabs.io/getAccountAptBalance' params = { 'userAddress': 'your_wallet_address' } api_key = os.getenv('API_KEY') headers = { 'x-api-key': api_key } response = requests.get(base_url, params=params, headers=headers) response.raise_for_status() get_wallet_account_aptos_balance = response.json() print("getWalletAccountAptosBalance: ", get_wallet_account_aptos_balance) except requests.exceptions.RequestException as error: print('An error occurred:', error) if __name__ == "__main__": main() ``` ## **19. Update Stop Loss** * **Endpoint URL**:\ [`https://perps-tradeapi.kanalabs.io/updateStopLoss`](https://perps-tradeapi.kanalabs.io/updateStopLoss) * **Method**:\ `GET` * **Query Parameters**: * **marketId** (Required) - The ID of the market for which the take profit values will be updated. * **tradeSide** (Required) - The trade side: * `true` for the long side. * `false` for the short side. * newStopLossPrice (Required) - The new stop loss price to be set for the trade. **Example Request:** ```http GET https://perps-tradeapi.kanalabs.io/updateStopLoss?marketId=66&tradeSide=true&newStopLossPrice=6000 ``` **Example Response:** * **Status Code**: `200 OK` * **Response Body**: ```json { "success": true, "message": "Update stop loss payload built succesfully", "data": { "function": "0xabbf40e0c31cbedf182f3e6e9c3570f3f91629424723da876becb514bf5d9fc6::perpetual_scripts::update_stop_loss", "functionArguments": [ "501", "true", 7590 ], "typeArguments": [] } } ``` **Example Code to Update stop loss price:** The following Python script demonstrates how to call the Get Update Stop Loss Price API using the requests library. ```python import asyncio import os from aptos_sdk.account import Account from aptos_sdk.async_client import RestClient from aptos_sdk.transactions import EntryFunction, TransactionArgument, TransactionPayload from aptos_sdk.bcs import Serializer from aptos_sdk.type_tag import TypeTag, StructTag import requests from dotenv import load_dotenv from typing import Any, List load_dotenv() class AptosTransactionHandler: def __init__(self, rest_client: RestClient, account: Account): self.rest_client = rest_client self.account = account def fetch_payload(self, api_url, params, headers): try: response = requests.get(api_url, params=params, headers=headers) response.raise_for_status() return response.json().get("data") except requests.exceptions.RequestException as e: print(f"Error fetching payload: {e}") return None def create_transaction_function_arguments(self, arguments: List[Any], types: List[Serializer]) -> List[TransactionArgument]: if len(arguments) != len(types): raise ValueError("Arguments and types length mismatch.") return [TransactionArgument(arg, serializer) for arg, serializer in zip(arguments, types)] def create_transaction_payload(self, payload: dict) -> TransactionPayload: try: function_information = payload["function"].split("::") module = "::".join(function_information[:-1]) function_id = function_information[-1] function_arguments = self.create_transaction_function_arguments( payload["functionArguments"], payload["argumentTypes"] ) type_arguments = [TypeTag(StructTag.from_str(argument)) for argument in payload["typeArguments"]] entry_function = EntryFunction.natural( module=module, function=function_id, ty_args=type_arguments, args=function_arguments, ) return TransactionPayload(payload=entry_function) except Exception as e: print(f"Error creating transaction payload: {e}") raise async def submit_transaction(self, transaction_payload: TransactionPayload) -> str: try: signed_transaction_request = await self.rest_client.create_bcs_signed_transaction( sender=self.account, payload=transaction_payload ) txn_hash = await self.rest_client.submit_bcs_transaction( signed_transaction=signed_transaction_request ) await self.rest_client.wait_for_transaction(txn_hash=txn_hash) return txn_hash except Exception as e: print(f"Error during transaction submission: {e}") raise async def main(): NODE_URL = "https://api.testnet.aptoslabs.com/v1" rest_client = RestClient(NODE_URL) private_key_hex = os.getenv('APTOS_PRIVATEKEY') if private_key_hex.startswith("0x"): private_key_hex = private_key_hex[2:] private_key_bytes = bytes.fromhex(private_key_hex) account = Account.load_key(private_key_bytes) API_URL = "https://perps-tradeapi.kanalabs.io/updateStopLoss" PARAMS = { "marketId": 501, "tradeSide": True, "newStopLossPrice": 6.89 } HEADERS = {"x-api-key": os.getenv('API_KEY')} handler = AptosTransactionHandler(rest_client, account) payload_data = handler.fetch_payload(API_URL, PARAMS, HEADERS) if not payload_data: print("Failed to fetch payload data.") return try: payload_data["functionArguments"] = [ int(payload_data["functionArguments"][0]), payload_data["functionArguments"][1].lower() == "true", int(payload_data["functionArguments"][2]), ] payload_data["argumentTypes"] = [Serializer.u64, Serializer.bool, Serializer.u64] transaction_payload = handler.create_transaction_payload(payload_data) print("Transaction payload created successfully.") txn_hash = await handler.submit_transaction(transaction_payload) print(f"Transaction submitted successfully. Transaction hash: {txn_hash}") except Exception as e: print(f"Error during transaction process: {e}") if __name__ == "__main__": asyncio.run(main()) ```