/**
 * Sends a GET request to the specified endpoint with the given parameters.
 * 
 * @param {string} endpoint - The API endpoint to send the request to.
 * @param {Object} [params={}] - The query parameters to include in the request.
 * @returns {Promise<Object>} - The response data from the API.
 */
async function getRequest(endpoint, params = {}) {
    // Add a timestamp to the parameters for request uniqueness
    const timestamp = Date.now().toString();
    params.timestamp = timestamp;

    // Determine if the endpoint is a market endpoint
    const isMarketEndpoint = endpoint.startsWith("/v1/market");
    let url = "";

    // Construct the URL based on the endpoint type
    if (isMarketEndpoint) {
        url = `${publicBaseUrl}${endpoint}`;
    } else {
        url = `${baseUrl}${endpoint}?${new URLSearchParams(params).toString()}`;
    }

    // Generate a signature for the request
    const signature = generateSignature(params, apiSecret);

    try {
        // Send the GET request
        const response = await axios.get(
            url,
            !isMarketEndpoint ? {
                headers: {
                    "api-key": apiKey,
                    "signature": signature,
                },
            } : {}
        );
        // Log and return the response data
        console.log("Response:", response.data);
        return response.data;
    } catch (error) {
        // Handle and log any errors that occur during the request
        console.error(
            "Error:",
            error.response ? error.response.data : error.message
        );
    }
}

// Generic POST request function
async function postRequest(endpoint, params = {}) {
  const timestamp = Date.now().toString();
  const isMarketEndpoint = endpoint.startsWith("/v1/market");
  const baseUrlToUse = isMarketEndpoint ? publicBaseUrl : baseUrl;
  const url = `${baseUrlToUse}${endpoint}`;

  if (!isMarketEndpoint) {
    params.timestamp = timestamp;
  }

  const signature = crypto
    .createHmac("sha256", apiSecret)
    .update(JSON.stringify(params))
    .digest("hex");

  try {
    const response = await axios.post(
      url,
      params,
      isMarketEndpoint
        ? {}
        : {
            headers: {
              "api-key": apiKey,
              signature: signature,
            },
          }
    );
    console.log("Response:", response.data);
    return response.data;
  } catch (error) {
    console.error(
      "Error:",
      error.response ? error.response.data : error.message
    );
    throw error; // Optional: re-throw the error if you want to handle it further up the call stack
  }
}

const crypto = require('crypto');
const axios = require('axios');

async function putRequest(endpoint, params = {}) {
  const timestamp = Date.now().toString();
  params.timestamp = timestamp;

  const signature = crypto
    .createHmac("sha256", apiSecret)
    .update(JSON.stringify(params))
    .digest("hex");

  const url = `${baseUrl}${endpoint}`;

  try {
    const response = await axios.put(url, params, {
      headers: {
        "api-key": apiKey,
        "signature": signature,
      },
    });

    console.log("Response:", response.data);
    return response.data;

  } catch (error) {
    console.error(
      "Error:",
      error.response ? error.response.data : error.message
    );
  }
}

const crypto = require('crypto');
const axios = require('axios');

async function deleteRequest(endpoint, params = {}) {
  // Generate a timestamp and add it to the params
  const timestamp = Date.now().toString();
  params.timestamp = timestamp;

  // Create a cryptographic signature using HMAC with SHA-256
  const signature = crypto
    .createHmac("sha256", apiSecret)
    .update(JSON.stringify(params))
    .digest("hex");

  // Construct the full request URL
  const url = `${baseUrl}${endpoint}`;

  try {
    // Send the DELETE request using axios
    const response = await axios.delete(url, {
      headers: {
        "api-key": apiKey,
        "signature": signature,
      },
      data: params,
    });

    // Log and return the response data if the request is successful
    console.log("Response:", response.data);
    return response.data;

  } catch (error) {
    // Handle and log any errors that occur during the request
    console.error(
      "Error:",
      error.response ? error.response.data : error.message
    );
  }
}

async function placeOrder(orderType, quantity = 38, price = null) {
  // Validate orderType
  if (!["MARKET", "LIMIT"].includes(orderType)) {
    throw new Error("Invalid order type. Must be 'MARKET' or 'LIMIT'.");
  }

  // Validate quantity
  if (quantity <= 0) {
    throw new Error("Quantity must be greater than 0.");
  }

  const params = {
    placeType: "ORDER_FORM",
    quantity: quantity, // Dynamically set quantity
    side: "BUY",
    symbol: "GRTINR",
    reduceOnly: false,
    marginAsset: "INR",
    type: orderType, // Set the order type dynamically
  };

  // Add additional parameters if the order is a LIMIT order
  if (orderType === "LIMIT") {
    if (price === null || price <= 0) {
      throw new Error("Price must be specified and greater than 0 for LIMIT orders.");
    }
    params.price = price; // Dynamically set price for LIMIT orders
  }

  const endpoint = "/v1/order/place-order";

  try {
    // Call the postRequest function
    const response = await postRequest(endpoint, params);
    return response;
  } catch (error) {
    console.error("Failed to place order:", error);
    throw error;
  }
}

// Example usage for market order
placeOrder("MARKET");

// Example usage for limit order with price
placeOrder("LIMIT", 38, 11.9);

def place_order():
    # Generate the current timestamp in milliseconds
    timestamp = str(int(time.time() * 1000))

    # Define the order parameters
    params = {
        'timestamp': timestamp,        # Current timestamp in milliseconds
        'placeType': 'ORDER_FORM',     # Type of order placement, e.g., 'ORDER_FORM'
        'quantity': 0.002,             # Quantity of the asset to trade
        'side': 'BUY',                 # Order side, either 'BUY' or 'SELL'
        'symbol': 'BTCUSDT',           # Trading pair, e.g., Bitcoin to USDT
        'type': 'MARKET',              # Order type, either 'MARKET' or 'LIMIT'
        'reduceOnly': False,           # Whether to reduce an existing position only
        'marginAsset': 'INR',          # The asset used as margin (INR in this case)
        'deviceType': 'WEB',           # Device type (e.g., WEB, MOBILE)
        'userCategory': 'EXTERNAL',    # User category (e.g., EXTERNAL, INTERNAL)
        'price': 50000,                # Price for the limit order (included here but irrelevant for market orders)
    }

    # Convert the parameters to a JSON string to sign
    data_to_sign = json.dumps(params, separators=(',', ':'))

    # Generate the signature for authentication
    signature = generate_signature(api_secret, data_to_sign)

    # Define the headers including the API key and the signature
    headers = {
        'api-key': api_key,
        'signature': signature,
    }

    try:
        # Send the POST request to place the order
        response = requests.post(f'{base_url}/v1/order/place-order', json=params, headers=headers)

        # Raise an HTTPError if the response status is 4xx or 5xx
        response.raise_for_status()

        # Parse the JSON response data
        response_data = response.json()

        # Print the success message with the order details
        print('Order placed successfully:', json.dumps(response_data, indent=4))

    except requests.exceptions.HTTPError as err:
        # Handle HTTP errors specifically
        print(f"Error: {err.response.text if err.response else err}")

    except Exception as e:
        # Handle any other unexpected errors
        print(f"An unexpected error occurred: {str(e)}")

# Response
{
    "clientOrderId": "19db8caf3cd3e5a08cfa-6895-ext",
    "time": "2024-09-13T08:19:18.029Z",
    "symbol": "BTCUSDT",
    "contractType": "PERPETUAL",
    "type": "MARKET",
    "side": "BUY",
    "price": 58002,
    "orderAmount": 0.003,
    "filledAmount": 0,
    "availableBalance": 8564.64,
    "linkId": "19db8caf3cd3e5a08cfa-6895-ext",
    "linkType": "ORDER",
    "subType": "PRIMARY",
    "placeType": "ORDER_FORM",
    "lockedMargin": 19.5274,
    "baseAsset": "BTC",
    "quoteAsset": "USDT",
    "marginAsset": "INR",
    "lockedMarginInMarginAsset": 1698.88
}

async function addMargin() {
    // Define the API endpoint for adding margin
    const endpoint = "/v1/order/add-margin";

    // Define the fixed values for positionId and amount
    const positionId = "18c6c979-b089-4e67-b627-4c2072d0d5cb";  // Unique identifier for the position
    const amount = 1;  // The amount of margin to be added

    // Prepare request payload
    const params = {
        positionId: positionId,  // ID of the position to which margin is being added
        amount: amount,          // Amount of margin to add
    };

    // Call the postRequest function to send the POST request to the API
    return await postRequest(endpoint, params);
}

def add_margin():
    position_id = input("Enter the positionId: ")
    amount_input = input("Enter the amount: ")

    add_margin_url = "https://fapi.pi42.com/v1/order/add-margin"

    try:
        amount = int(amount_input)
    except ValueError:
        amount = float(amount_input)

    timestamp = str(int(time.time() * 1000))

    params = {
        'positionId': position_id,
        'amount': amount,
        'timestamp': timestamp
    }

    data_to_sign = json.dumps(params, separators=(',', ':'))
    signature = generate_signature(api_secret, data_to_sign)

    headers = {
        'api-key': api_key,
        'Content-Type': 'application/json',
        'signature': signature,
    }

    try:
        response = requests.post(add_margin_url, json=params, headers=headers)
        response.raise_for_status()
        response_data = response.json()
        print('Margin added successfully:', json.dumps(response_data, indent=4))

    except requests.exceptions.HTTPError as err:
        print(f"Failed {response.status_code}: {response.text}")
    except Exception as e:
        print(f"An unexpected error occurred: {str(e)}")

# Response
{
  "lockedBalance": 870,
  "withdrawableBalance": 9393.52,
  "asset": "INR",
  "message": "Margin added successfully"
}

async function reduceMargin() {
    // Define the API endpoint for reducing margin
    const endpoint = "/v1/order/reduce-margin";

    // Define the fixed values for positionId and amount
    const positionId = "18c6c979-b089-4e67-b627-4c2072d0d5cb";  // Unique identifier for the position
    const amount = 1;  // The amount of margin to be reduced

    // Prepare request payload
    const params = {
        positionId: positionId,  // ID of the position from which margin is being reduced
        amount: amount,          // Amount of margin to reduce
    };

    // Call the postRequest function to send the POST request to the API
    return await postRequest(endpoint, params);
}

def reduce_margin():
    # Collect position ID and amount to reduce from user input
    position_id = input("Enter the positionId: ")
    amountInput = input("Enter the amount to reduce: ")

    try:
        # Convert input to integer or float as necessary
        amount = int(amountInput)
    except ValueError:
        amount = float(amountInput)

    # Generate current timestamp in milliseconds
    timestamp = str(int(time.time() * 1000))

    # Prepare the request payload (JSON)
    params = {
        'positionId': position_id,
        'amount': amount,
        'timestamp': timestamp
    }

    # Convert the payload to a JSON string for signature
    data_to_sign = json.dumps(params, separators=(',', ':'))

    # Generate the signature using a helper function
    signature = generate_signature(api_secret, data_to_sign)

    # Set the headers for the POST request
    headers = {
        'api-key': api_key,
        'Content-Type': 'application/json',
        'signature': signature
    }

    # Construct the full API endpoint URL
    reduce_margin_url = f"{base_url}/v1/order/reduce-margin"

    try:
        # Send the POST request to reduce margin
        response = requests.post(reduce_margin_url, json=params, headers=headers)
        response.raise_for_status()  # Raises an error for HTTP responses with 4xx/5xx status codes
        response_data = response.json()
        print('Margin reduced successfully:', json.dumps(response_data, indent=4))
    except requests.exceptions.HTTPError as err:
        print(f"Error: {err.response.text if err.response else err}")
    except Exception as e:
        print(f"An unexpected error occurred: {str(e)}")

# Response
{
    "lockedBalance": 870,
    "withdrawableBalance": 9393.52,
    "asset": "INR",
    "message": "Margin reduced successfully"
}

def get_open_orders():
# Generate the current timestamp
    timestamp = str(int(time.time() * 1000))

# Prepare parameters with the current timestamp
    params = f"timestamp={timestamp}"

# Generate the signature using the current timestamp
    signature = generate_signature(api_secret, params)

# Prepare headers
    headers = {
    'api-key': api_key,
    'signature': signature,
    }
    open_orders_url = f"{base_url}/v1/order/open-orders"
    try:

# Send GET request to fetch open orders with the timestamp parameter
    response = requests.get(open_orders_url, headers=headers, params={'timestamp': timestamp})
    response.raise_for_status() # Raises an error for bad HTTP responses
    response_data = response.json()
    print('Open orders fetched successfully:', json.dumps(response_data, indent=4))
    except requests.exceptions.HTTPError as err:
    print(f"Failed {response.status_code}: {response.text}")
    except Exception as e:
    print(f"An unexpected error occurred: {str(e)}")

async function getOpenOrders() {
const pageSize = 100;
const sortOrder = "desc";
const startTimestamp = "1696425435000";
const endTimestamp = "1725451568979";
const symbol = "BTCUSDT";
const params = {
 // Optional Params
    pageSize: pageSize.toString(),
    sortOrder: sortOrder,
    startTimestamp: startTimestamp,
    endTimestamp: endTimestamp,
    symbol: symbol,
    };

const endpoint = "/v1/order/open-orders"; // Your endpoint for fetching open orders

// Call the postRequest function
return await getRequest(endpoint, params);
}

[
  {
    "clientOrderId": "ccef6a84a5cf6a463353-6238-ext",
    "time": "2024-09-13T07:57:15.305Z",
    "symbol": "BTCINR",
    "contractType": "PERPETUAL",
    "type": "MARKET",
    "side": "BUY",
    "price": 5170418,
    "orderAmount": 0.002,
    "filledAmount": 0,
    "linkId": "ccef6a84a5cf6a463353-6238-ext",
    "linkType": "ORDER",
    "subType": "PRIMARY",
    "placeType": "ORDER_FORM",
    "baseAsset": "BTC",
    "quoteAsset": "INR"
  }
]

# Function to fetch and display order history
def order_history():
timestamp = str(int(time.time() * 1000))
order_history_url = "https://fapi.pi42.com/v1/order/order-history"
params = {
'sortOrder': 'desc',
'pageSize': 100,
'timestamp': timestamp
 }

query_string = f"sortOrder={params['sortOrder']}&pageSize={params['pageSize']}&timestamp=
{params['timestamp']}"

signature = generate_signature(api_secret, query_string)

headers = {
'api-key': api_key,
'signature': signature,
}

try:
response = requests.get(f"{order_history_url}?{query_string}", headers=headers)
response.raise_for_status()
response_data = response.json()
print('Order history fetched successfully:', json.dumps(response_data, indent=4))
except requests.exceptions.HTTPError as err:
print(f"Failed {response.status_code}: {response.text}")

//Get Order History
async function getOrderHistory() {
  const pageSize = 100;
  const sortOrder = "desc";
  const startTimestamp = "1696425435000";
  const endTimestamp = "1725451568979";
  const symbol = "BTCUSDT";
  const params = {
    // Optional Params
    pageSize: pageSize.toString(),
    sortOrder: sortOrder,
    startTimestamp: startTimestamp,
    endTimestamp: endTimestamp,
    symbol: symbol,
  };
  const endpoint = "/v1/order/order-history"; // Your endpoint for fetching order history
  // Call the postRequest function
  return await getRequest(endpoint, params);
}

[
  {
    "clientOrderId": "c707985129f41a13ab40-6238-ext",
    "updatedAt": "2024-09-13T10:48:57.630Z",
    "symbol": "BTCINR",
    "type": "MARKET",
    "isIsolated": true,
    "side": "SELL",
    "price": "5182995",
    "avgPrice": "5182656",
    "origQty": "10365.31",
    "cumQty": "0.002",
    "executedQty": "0.002",
    "reduceOnly": false,
    "status": "FILLED",
    "leverage": 25,
    "subType": "PRIMARY",
    "stopPrice": null,
    "lockedMargin": 0,
    "lockedMarginInMarginAsset": 0,
    "marginAsset": "INR",
    "contractType": "PERPETUAL",
    "iconUrl": "https://storage.googleapis.com/pi42-dev-static/contract-icons/btc.png",
    "quoteAsset": "INR",
    "baseAsset": "BTC",
    "leveragedQty": 0.002
  }
]

# Function to fetch linked orders based on linkId
def linked_orders():
link_id = input("Enter the Link Id: ")
timestamp = str(int(time.time() * 1000))
linked_orders_url = "https://fapi.pi42.com/v1/order/linked-orders"

url = f"{linked_orders_url}/{link_id}"

params = {
'timestamp': timestamp
}
query_string = f"timestamp={params['timestamp']}"

signature = generate_signature(api_secret, query_string)

headers = {
'api-key': api_key,
'signature': signature,
'accept': '*/*'
 }
try:
response = requests.get(f"{url}?{query_string}", headers=headers)
response.raise_for_status()
response_data = response.json()
print('Linked orders fetched successfully:', json.dumps(response_data, indent=4))
except requests.exceptions.HTTPError as err:
print(f"Failed {response.status_code}: {response.text}")

// Get Linked Orders
async function linkedOrders(linkId) {
  const linkId = "6acd808ba5957340b009-6238-ext"
  const endpoint = `/v1/order/linked-orders/${linkId}`; // Endpoint for fetching linked orders

// Call the getRequest function (similar to postRequest)
  return await getRequest(endpoint);
}

// Fetch Margin History
async function fetchMarginHistory() {
 const endpoint = "/v1/order/fetch-margin-history";
 const pageSize = 100;
 const sortOrder = "desc";
 const startTimestamp = "1696425435000";
 const endTimestamp = "1725451568979";
 const symbol = "BTCUSDT";

// Prepare query parameters
 const params = {

// Optional Params
 pageSize: pageSize.toString(),
 sortOrder: sortOrder,
 startTimestamp: startTimestamp,
 endTimestamp: endTimestamp,
 symbol: symbol,
 };

// Response
[
  {
    "clientOrderId": "m2l-1f04cd91efa7ebe09cad-6238-ext",
    "time": "2024-09-11T12:14:03.706Z",
    "symbol": "BTCINR",
    "contractType": "PERPETUAL",
    "type": "MARKET",
    "side": "BUY",
    "price": 5054068,
    "orderAmount": 0.002,
    "filledAmount": 0,
    "linkId": "m2l-1f04cd91efa7ebe09cad-6238-ext",
    "subType": "PRIMARY",
    "linkType": "ORDER_SL",
    "takeProfitPrice": null,
    "stopLossPrice": null,
    "status": "NEW",
    "placeType": "ORDER_FORM",
    "baseAsset": "BTC",
    "quoteAsset": "INR"
  }
]

def fetch_margin_history():
    endpoint = "/v1/order/fetch-margin-history"
    symbol = input("Enter the symbol (e.g., BTCUSDT): ").upper()

    pageSize = 100
    sortOrder = "desc"

# Generate current timestamp for signing
 timestamp = str(int(time.time() * 1000))

# Prepare query parameters
    params = {
    'pageSize': str(pageSize),
    'sortOrder': sortOrder,
    'symbol': symbol,
    'timestamp': timestamp
    }

# Convert params to query string
    query_string = '&'.join([f"{key}={value}" for key, value in params.items()])

# Generate signature
    signature = generate_signature(api_secret, query_string)

# Headers for the request
    headers = {
    'api-key': api_key,
     'signature': signature,
    'accept': '*/*'
    }
full_url = f"{base_url}{endpoint}?{query_string}"

try:
# Send the GET request to fetch margin history
response = requests.get(full_url, headers=headers)
response.raise_for_status() # Raises an error for 4xx/5xx responses
response_data = response.json()
print('Margin history fetched successfully:', json.dumps(response_data, indent=4))
except requests.exceptions.HTTPError as err:
print(f"Error: {err.response.text if err.response else err}")
except Exception as e:
print(f"An unexpected error occurred: {str(e)}")

// Fetch Margin History
async function fetchMarginHistory() {
  const endpoint = "/v1/order/fetch-margin-history";

  const pageSize = 100;
  const sortOrder = "desc";
  const startTimestamp = "1696425435000";
  const endTimestamp = "1725451568979";
  const symbol = "BTCUSDT";

// Prepare query parameters
  const params = {

// Optional Params
    pageSize: pageSize.toString(),
    sortOrder: sortOrder,
    startTimestamp: startTimestamp,
    endTimestamp: endTimestamp,
    symbol: symbol,
  };

// Call the getRequest function
  return await getRequest(endpoint, params);
}

// Response
{
  "data": [
    {
      "id": 549,
      "amount": 0.1,
      "refId": null,
      "marginInMarginAsset": 8.7,
      "marginAsset": "INR",
      "positionId": "90483119-0c3a-4cc0-9afa-25366f907fca",
      "operation": "REDUCE_MARGIN",
      "createdAt": "2024-09-12T08:59:57.707Z",
      "updatedAt": "2024-09-12T08:59:57.707Z"
    }
  ],
  "totalCount": 45,
  "nextTimestamp": "1725624883814"
}

# Function to fetch positions
def fetch_positions():
position_status = input("Enter position status (open, closed, liquidated): ").upper()
symbol = input("Enter the trading pair (e.g., BTCINR): ").upper()

if position_status not in ["OPEN", "CLOSED", "LIQUIDATED"]:
print("Invalid position status. Please enter 'open', 'closed', or 'liquidated'.")
return

# Optional parameters
sort_order = "desc" # Default sort order
page_size = 100 # Default page size

# Prepare the query parameters
params = {
'sortOrder': sort_order,
'pageSize': str(page_size),
'symbol': symbol,
  }

# Generate current timestamp
timestamp = str(int(time.time() * 1000))
params['timestamp'] = timestamp

# Generate signature based on the parameters
query_string = '&'.join([f"{key}={value}" for key, value in params.items()])
signature = generate_signature(api_secret, query_string)

# Headers for the GET request
headers = {
'api-key': api_key,
'signature': signature,
'accept': '*/*'
 }

# Construct the full URL including the path parameter for position status
full_url = f"{base_url}/v1/positions/{position_status}?{query_string}"

try:
# Send the GET request to fetch positions
response = requests.get(full_url, headers=headers)
response.raise_for_status() # Raises an error for 4xx/5xx responses
response_data = response.json()
print('Positions fetched successfully:', json.dumps(response_data, indent=4))
except requests.exceptions.HTTPError as err:
print(f"Error: {err.response.text if err.response else err}")
except Exception as e:
print(f"An unexpected error occurred: {str(e)}")

async function fetchPositions() {
  const endpoint = "/v1/positions/";

  const positionStatus = "OPEN"; // Required parameter
  const startTimestamp = "1696425435000"; // Optional
  const endTimestamp = "1725451568979"; // Optional
  const sortOrder = "desc"; // Optional
  const pageSize = 100; // Optional
  const symbol = "BTCINR"; // Optional

  const params = {
    // Optional Params
    // pageSize: pageSize.toString(),
    // sortOrder: sortOrder,
    // startTimestamp: startTimestamp,
    // endTimestamp: endTimestamp,
    // symbol: symbol,
  };
  const url = `${endpoint}${positionStatus}`;

// Call the getRequest function
  return await getRequest(url, params);
}

{
  "id": 5454,
  "contractPair": "GRTINR",
  "contractType": "PERPETUAL",
  "entryPrice": 12.541,
  "leverage": 10,
  "liquidationPrice": 11.4,
  "marginType": "ISOLATED",
  "margin": 45.6,
  "marginInMarginAsset": 45.6,
  "positionAmount": 36,
  "positionId": "8b56348d-0d5d-4de1-85e1-3325bdf84087",
  "positionSize": 451.48,
  "positionStatus": "OPEN",
  "positionType": "LONG",
  "realizedProfit": null,
  "quantity": 36,
  "baseAsset": "GRT",
  "marginAsset": "INR",
  "quoteAsset": "INR",
  "createdTime": "2024-09-16T09:39:41.689Z",
  "updatedTime": "2024-09-16T09:39:41.689Z"
}

def get_positions():
 position_status = input("Enter position status (open, closed, liquidated): ").upper()

  if position_status not in ["OPEN", "CLOSED", "LIQUIDATED"]:
  print("Invalid position status. Please enter 'open', 'closed', or 'liquidated'.")
  return

# Generate the current timestamp
    timestamp = str(int(time.time() * 1000))

# Prepare the query parameters
    params = {
    'sortOrder': 'desc',
    'pageSize': 100,
    'timestamp': timestamp
    }

# Convert the params into a query string to sign
    query_string = f"sortOrder={params['sortOrder']}&pageSize={params['pageSize']}&timestamp=
    {params['timestamp']}"

# Generate the signature
 signature = generate_signature(api_secret, query_string)

# Headers for the GET request
headers = {
'api-key': api_key,
'signature': signature,
'accept': '*/*'
 }

# Construct the full URL including the path parameter for position status
full_url = f"{base_url}/v1/positions/{position_status}?sortOrder={params['sortOrder']}&pageSize=
{params['pageSize']}&timestamp={params['timestamp']}"

try:
# Send the GET request to fetch positions
response = requests.get(full_url, headers=headers)
response.raise_for_status() # Raises an error for 4xx/5xx responses
response_data = response.json()
print('Positions fetched successfully:', json.dumps(response_data, indent=4))
except requests.exceptions.HTTPError as err:
print(f"Error: {err.response.text if err.response else err}")
except Exception as e:
print(f"An unexpected error occurred: {str(e)}")

async function getPosition() {
  const endpoint = "/v1/positions";
  const positionId = "sample-2c52-45cb-addf-9c1fde92fce5";

  const params = {
    positionId,
  };

  return await getRequest(endpoint, params);
}

// Response
[
    {
        "contractPair": "BTCUSDT",
        "entryPrice": 58003.7,
        "leverage": 9,
        "liquidationPrice": 52173.1,
        "marginType": "ISOLATED",
        "marginAsset": "INR",
        "margin": 19.404,
        "marginInMarginAsset": 1688.15,
        "positionAmount": 0.003,
        "positionId": "dd89732b-3a9d-4500-acec-64e1384c7149",
        "positionSize": 174.0111,
        "positionStatus": "OPEN",
        "positionType": "LONG",
        "realizedProfit": 0,
        "quantity": 0.003,
        "createdAt": "2024-09-13T08:19:18.642Z",
        "contractType": "PERPETUAL",
        "iconUrl": "https://storage.googleapis.com/pi42-dev-static/contract-icons/btc.png",
        "baseAsset": "BTC",
        "quoteAsset": "USDT"
    }
]

async function fetchUserTradeHistory() {
  const endpoint = "/v1/user-data/trade-history";
  const startTimestamp = "1696425435000"; // Optional
  const endTimestamp = "1725451568979"; // Optional
  const sortOrder = "desc"; // Optional
  const pageSize = 100; // Optional
  const symbol = "BTCINR"; // Optional

const params = {
   //Optional Params
    pageSize: pageSize.toString(),
    sortOrder: sortOrder,
    startTimestamp: startTimestamp,
    endTimestamp: endTimestamp,
    symbol: symbol,
  };

// Call the getRequest function
  return await getRequest(endpoint, params);
}

# Function to fetch trade history
def trade_history():
    timestamp = str(int(time.time() * 1000))
    trade_history_url = "https://fapi.pi42.com/v1/user-data/trade-history"

params = {
    sortOrder': 'desc',
    'pageSize': 100,
    'timestamp': timestamp
 }

query_string = f"sortOrder={params['sortOrder']}&pageSize={params['pageSize']}&timestamp=
{params['timestamp']}"

 signature = generate_signature(api_secret, query_string)

 headers = {
    'api-key': api_key,
    'signature': signature,
    'accept': '*/*'
 }

try:
    response = requests.get(f"{trade_history_url}?{query_string}", headers=headers)
    response.raise_for_status()
    response_data = response.json()
    print('Trade history fetched successfully:', json.dumps(response_data, indent=4))
except requests.exceptions.HTTPError as err:
    print(f"Failed {response.status_code}: {response.text}")

[
  {
    "id": 26260,
    "time": "2024-09-16T09:39:41.675Z",
    "symbol": "GRTINR",
    "type": "LIMIT",
    "side": "BUY",
    "price": 12.541,
    "quantity": 36,
    "role": "MAKER",
    "fee": 0,
    "realizedProfit": 0,
    "contractType": "PERPETUAL",
    "clientOrderId": "8acc0af94a3516126cdf-6238-ext",
    "baseAsset": "GRT",
    "quoteAsset": "INR",
    "marginAsset": "INR"
  }
]

def get_transaction_history():
    # Default values for optional parameters
    start_timestamp = None
    end_timestamp = None
    sort_order = 'desc'
    page_size = 100
    symbol = None
    trade_id = None
    position_id = None

    # Generate the current timestamp (used as part of the authentication/signing process)
    timestamp = str(int(time.time() * 1000))

    # Prepare query parameters with required and optional fields
    params = {
        'sortOrder': sort_order,
        'pageSize': page_size,
        'timestamp': timestamp
    }

    # Include optional parameters only if they are provided
    if start_timestamp:
        params['startTimestamp'] = start_timestamp
    if end_timestamp:
        params['endTimestamp'] = end_timestamp
    if symbol:
        params['symbol'] = symbol
    if trade_id:
        params['tradeId'] = trade_id
    if position_id:
        params['positionId'] = position_id

    # Convert the parameters to a query string to be signed
    query_string = '&'.join([f"{key}={value}" for key, value in params.items()])

    # Generate the signature (assuming `generate_signature` is defined)
    signature = generate_signature(api_secret, query_string)

    # Headers for the GET request
    headers = {
        'api-key': api_key,
        'signature': signature,
        'accept': '*/*'
    }

    # Construct the full URL with the query string
    full_url = f"{base_url}/v1/user-data/transaction-history?{query_string}"

    try:
        # Send the GET request to fetch transaction history
        response = requests.get(full_url, headers=headers)
        response.raise_for_status()  # Raises an error for HTTP 4xx/5xx responses
        response_data = response.json()
        print('Transaction history fetched successfully:', json.dumps(response_data, indent=4))
    except requests.exceptions.HTTPError as err:
        # Handle specific HTTP errors
        print(f"HTTP Error: {err.response.text if err.response else 'No response text'}")
    except Exception as e:
        # Handle any other exceptions
        print(f"Failed {response.status_code}: {response.text}")

async function fetchUserTransactionHistory() {
    const endpoint = "/v1/user-data/transaction-history";

    // Optional parameters for filtering and sorting the transaction history
    const startTimestamp = "1696425435000"; // Start timestamp in milliseconds
    const endTimestamp = "1725451568979";   // End timestamp in milliseconds
    const sortOrder = "desc";               // Sorting order: "asc" or "desc"
    const pageSize = 100;                   // Number of records per page
    const symbol = "BTCINR";                // Trading symbol, e.g., "BTCINR"
    const tradeId = 12;                     // Specific trade ID to filter
    const positionId = "3d5f302b-2c52-45cb-addf-9c1fde92fce5"; // Specific position ID

    // Construct the query parameters object
    const params = {
        pageSize: pageSize.toString(),
        sortOrder: sortOrder,
        startTimestamp: startTimestamp,
        endTimestamp: endTimestamp,
        symbol: symbol,
        tradeId: tradeId,
        positionId: positionId,
    };

    // Call the getRequest function with the endpoint and query parameters
    return await getRequest(endpoint, params);
}

[
  {
    "id": 109884,
    "time": "2024-09-16T09:39:28.754Z",
    "type": "COMMISSION",
    "amount": -2.1,
    "asset": "INR",
    "symbol": "BTCINR",
    "contractType": "PERPETUAL",
    "baseAsset": "BTC",
    "quoteAsset": "INR"
  }
]

async function updateLeverage() {
    const endpoint = "/v1/exchange/update/leverage";

    const leverage = 10;
    const contractName = "BTCINR";

    // Prepare request payload
    const params = {
        leverage: leverage,       // Ensure leverage is an integer
        contractName: contractName,
    };

    // Call the postRequest function
    return await postRequest(endpoint, params);
}

def update_leverage():
  leverage = int(input("Enter the leverage value: "))
  contract_name = input("Enter the contract name: ")

  # Generate the current timestamp
  timestamp = str(int(time.time() * 1000))

  # Prepare the request body (JSON)
  params = {
      'leverage': int(leverage),
      'contractName': contract_name,
      'timestamp': timestamp
  }

  # Convert the request body to a JSON string for signing
  data_to_sign = json.dumps(params, separators=(',', ':'))

  # Generate the signature
  signature = generate_signature(api_secret, data_to_sign)

  # Headers for the POST request
  headers = {
      'api-key': api_key,
      'Content-Type': 'application/json',
      'signature': signature
  }

  # Construct the full URL
  update_leverage_url = f"{base_url}/v1/exchange/update/leverage"

  try:
      # Send the POST request to update the leverage
      response = requests.post(update_leverage_url, json=params, headers=headers)
      response.raise_for_status() # Raises an error for 4xx/5xx responses
      response_data = response.json()
      print('Leverage updated successfully:', json.dumps(response_data, indent=4))
  except requests.exceptions.HTTPError as err:
      print(f"Error: {err.response.text if err.response else err}")
  except Exception as e:
      print(f"An unexpected error occurred: {str(e)}")

// Response
{
  "updatedLeverage": 10,
  "contractName": "ETHINR"
}

async function deleteOrder() {
    const endpoint = "/v1/order/delete-order";
    const clientOrderId = "a9c5ba9893c99828e4b5-6238-ext";
    const timestamp = Date.now().toString();

    // Prepare request payload
    const params = {
        clientOrderId: clientOrderId,
        timestamp: timestamp,
    };

    // Call the deleteRequest function
    return await deleteRequest(endpoint, params);
}

def delete_order():
    client_order_id = input("Enter the clientOrderId to delete: ")
    delete_order_url = "https://fapi.pi42.com/v1/order/delete-order"

    timestamp = str(int(time.time() * 1000))

    params = {
        'clientOrderId': client_order_id,
        'timestamp': timestamp
    }

    data_to_sign = json.dumps(params, separators=(',', ':'))
    signature = generate_signature(api_secret, data_to_sign)

    headers = {
        'api-key': api_key,
        'Content-Type': 'application/json',
        'signature': signature,
    }

    try:
        response = requests.delete(delete_order_url, json=params, headers=headers)
        response.raise_for_status()
        print(f"Order with clientOrderId {client_order_id} deleted successfully.")
    except requests.exceptions.HTTPError as err:
        print(f"Failed {response.status_code}: {response.text}")

{
  "clientOrderId": "93513fe2a8af44157234-6238-ext",
  "orderId": 24717,
  "status": "CANCELED",
  "success": true
}

async function fetchTicker() {
    const endpoint = "/v1/market/ticker24Hr/";  // API endpoint for fetching the 24-hour market ticker
    const contractPair = "BTCINR";              // The trading pair for which the ticker data is being requested
    const url = `${endpoint}${contractPair}`;   // Constructs the full URL by appending the trading pair to the endpoint

    // Call the getRequest function with the constructed URL
    return await getRequest(url, {});
}

import requests
import json

def get_24hr_ticker_update():
    # Get the contract pair input from the user
    contract_pair = input("Enter the contract pair (e.g., btc, eth): ").lower()

    # Validate the input
    if not contract_pair:
        print("Invalid contract pair. Please enter a valid contract pair (e.g., btc, eth).")
        return

    # Construct the full URL for the API request using the provided contract pair
    full_url = f"https://api.pi42.com/v1/market/ticker24Hr/{contract_pair}"

    try:
        # Send the GET request to the API
        response = requests.get(full_url)
        response.raise_for_status()  # Raise an error for HTTP 4xx/5xx responses

        # Parse the JSON response data
        response_data = response.json()

        # Print the 24-hour ticker update in a formatted manner
        print('24-hour ticker update fetched successfully:', json.dumps(response_data, indent=4))
    except requests.exceptions.HTTPError as err:
        # Handle HTTP errors specifically
        print(f"Error: {err.response.text if err.response else err}")
    except Exception as e:
        # Handle any other unexpected errors
        print(f"An unexpected error occurred: {str(e)}")

// Response
{
  "data": {
    "e": "24hrTicker",
    "E": 1726313209122,
    "s": "BTCINR",
    "p": "139470.66",
    "P": "2.718",
    "w": "5230573.12",
    "c": "5271387.66",
    "Q": "0.081",
    "o": "5131917",
    "h": "5344655.41",
    "l": "5079790.8",
    "v": "274282.584",
    "q": "16265932028.08",
    "O": 1726226760000,
    "C": 1726313209120,
    "F": 5380307688,
    "L": 5383597456,
    "n": 3289757
  }
}

async function fetchAggTrade() {
    const endpoint = "/v1/market/aggTrade/";   // Define the API endpoint for aggregated trades
    const contractPair = "BTCINR";             // Specify the trading pair (e.g., Bitcoin to Indian Rupee)
    const url = `${endpoint}${contractPair}`;  // Construct the full URL by appending the trading pair to the endpoint

    // Call the getRequest function to send the GET request to the API
    return await getRequest(url, {});
}

import requests
import json

def get_trade_updates():
    # Prompt the user to enter a contract pair
    contract_pair = input("Enter the contract pair (e.g., btc, eth): ").lower()

    # Validate the user input
    if not contract_pair:
        print("Invalid contract pair. Please enter a valid contract pair (e.g., btc, eth).")
        return

    # Construct the URL for the API request using the provided contract pair
    full_url = f"https://api.pi42.com/v1/market/aggTrade/{contract_pair}"

    try:
        # Send the GET request to fetch trade updates
        response = requests.get(full_url)
        response.raise_for_status()  # Raise an exception for HTTP error responses

        # Parse the JSON response data
        response_data = response.json()

        # Print the trade updates in a formatted manner
        print('Trade updates fetched successfully:', json.dumps(response_data, indent=4))
    except requests.exceptions.HTTPError as err:
        # Handle HTTP errors specifically
        print(f"Error: {err.response.text if err.response else err}")
    except Exception as e:
        # Handle any other unexpected errors
        print(f"An unexpected error occurred: {str(e)}")

// Response
{
  "data": [
    {
      "e": "aggTrade",
      "E": 1726313202969,
      "a": 2329235556,
      "s": "BTCINR",
      "p": "5271343.57",
      "q": "0.002",
      "f": 5383597285,
      "l": 5383597285,
      "T": 1726313202966,
      "m": true
    }
  ]
}