trade.ts•5.55 kB
import { KiteConnect } from "kiteconnect";
import dotenv from 'dotenv';
dotenv.config();
const apiKey = process.env.KITE_API_KEY!;
const apiSecret = process.env.KITE_API_SECRET!;
const requestToken = process.env.KITE_REQUEST_TOKEN!;
const kc = new KiteConnect({ api_key: apiKey });
let sessionToken = "";
interface QuoteData {
last_price: number;
volume: number;
ohlc?: {
high: number;
low: number;
open: number;
close: number;
};
change?: number;
change_percent?: number;
}
interface EquityData {
available: {
cash: number;
opening_balance: number;
net: number;
};
used: {
margin: number;
opening_balance: number;
net: number;
};
}
async function generateSession() {
try {
const response = await kc.generateSession(requestToken, apiSecret);
sessionToken = response.access_token;
kc.setAccessToken(sessionToken);
console.log("Session generated successfully");
} catch (err) {
console.error("Error generating session:", err);
throw err;
}
}
generateSession().catch(console.error);
export async function tradeStock(tradingsymbol: string, quantity: number, transaction_type: "BUY" | "SELL") {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
const orderResponse = await kc.placeOrder("regular", {
exchange: "NSE",
tradingsymbol,
transaction_type,
quantity,
order_type: "MARKET",
product: "CNC",
});
return {
order_id: orderResponse.order_id,
status: "success",
message: `Order placed for ${quantity} shares of ${tradingsymbol} to ${transaction_type}`,
};
} catch (err) {
console.error("Error placing order:", err);
return {
status: "error",
message: err instanceof Error ? err.message : "Unknown error occurred",
};
}
}
export async function getPositions() {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
const positions = await kc.getPositions();
return positions.net.map(position => ({
tradingsymbol: position.tradingsymbol,
quantity: position.quantity,
average_price: position.average_price,
current_price: position.last_price,
profit_loss: position.pnl,
}));
} catch (err) {
console.error("Error fetching positions:", err);
throw err;
}
}
export async function getMarketStatus() {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
const status = await (kc as any).getMarketStatus();
return status;
} catch (err) {
console.error("Error fetching market status:", err);
throw err;
}
}
export async function getQuote(tradingsymbol: string) {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
const quote = await kc.getQuote(tradingsymbol);
const quoteData = (quote[tradingsymbol] || {}) as QuoteData;
const ohlc = (quoteData.ohlc || {}) as QuoteData['ohlc'];
return {
tradingsymbol,
last_price: quoteData.last_price || 0,
change: quoteData.change || 0,
change_percent: quoteData.change_percent || 0,
volume: quoteData.volume || 0,
high: ohlc?.high || 0,
low: ohlc?.low || 0,
open: ohlc?.open || 0,
close: ohlc?.close || 0
};
} catch (err) {
console.error("Error fetching quote:", err);
throw err;
}
}
export async function getOrderHistory() {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
const orders = await kc.getOrders();
return orders.map(order => ({
order_id: order.order_id,
tradingsymbol: order.tradingsymbol,
transaction_type: order.transaction_type,
quantity: order.quantity,
status: order.status,
order_timestamp: order.order_timestamp,
average_price: order.average_price,
product: order.product,
order_type: order.order_type
}));
} catch (err) {
console.error("Error fetching orders:", err);
throw err;
}
}
export async function cancelOrder(orderId: string) {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
await (kc as any).cancelOrder(orderId, "regular");
return {
order_id: orderId,
status: "CANCELLED",
message: "Order cancelled successfully"
};
} catch (err) {
console.error("Error cancelling order:", err);
throw err;
}
}
export async function getAccountBalance() {
if (!sessionToken) {
throw new Error("Session token is not available. Please generate a session first.");
}
try {
const balance = await kc.getMargins();
const equity = (balance.equity || {}) as EquityData;
const available = equity.available || { cash: 0, opening_balance: 0, net: 0 };
const used = equity.used || { margin: 0, opening_balance: 0, net: 0 };
return {
equity: {
available: {
cash: available.cash,
opening_balance: available.opening_balance,
net: available.net
},
used: {
margin: used.margin,
opening_balance: used.opening_balance,
net: used.net
}
}
};
} catch (err) {
console.error("Error fetching account balance:", err);
throw err;
}
}