404 lines
14 KiB
TypeScript
404 lines
14 KiB
TypeScript
// Create a class with a constructor that takes a username and password and sets the credentials
|
|
|
|
import axios from 'axios';
|
|
import type { AccountItem, AuthLoginResponse, Contract } from './tradovate-helpers';
|
|
import { computeSec, randomUUIDV4 } from './tradovate-helpers';
|
|
|
|
export class TradovateClient {
|
|
private name: string;
|
|
private password: string;
|
|
private accessInfo: AuthLoginResponse;
|
|
private deviceId = randomUUIDV4();
|
|
|
|
public accountList: AccountItem[] = [];
|
|
public accountCashBalances: {
|
|
[accountId: number]: {
|
|
amount: number;
|
|
realizedPnL: number;
|
|
};
|
|
} = {};
|
|
public positions: {
|
|
[accountId: number]: {
|
|
contractId: number;
|
|
netPos: number;
|
|
netPrice: number;
|
|
timestamp: Date;
|
|
};
|
|
} = {};
|
|
|
|
public daysTraded: { [accountId: number]: number } = {};
|
|
|
|
private ws: WebSocket;
|
|
private callbackOnSyncRequest: () => Promise<void>;
|
|
|
|
// Events that we sent out, and tradovate gives us a response for the id we sent out
|
|
private directEventCallbacks: {
|
|
[id: number]: (response: any) => void;
|
|
} = {};
|
|
private indirectEventCallbacks: {
|
|
entityType:
|
|
| 'order'
|
|
| 'orderVersion'
|
|
| 'auditUserAction'
|
|
| 'command'
|
|
| 'commandReport'
|
|
| 'fill'
|
|
| 'fillFee'
|
|
| 'executionReport'
|
|
| 'cashBalance';
|
|
eventType: 'Created' | 'Updated';
|
|
// Since the entity is not always the same, we need a validator to check if the response is the one we are looking for
|
|
validator: (response: any) => boolean;
|
|
callback: (response: any) => void;
|
|
}[] = [];
|
|
|
|
constructor(name: string, password: string, callbackOnSyncRequest: () => Promise<void>) {
|
|
this.name = name;
|
|
this.password = password;
|
|
this.callbackOnSyncRequest = callbackOnSyncRequest;
|
|
|
|
this.login().then((res) => {
|
|
if (!res?.accessToken) {
|
|
console.log('Failed to login', res);
|
|
return;
|
|
}
|
|
|
|
console.log('Logged in', res);
|
|
|
|
// check every 2 minutes if the access token is expired
|
|
setInterval(() => {
|
|
// If we are within 15 minutes of the expiration time, renew the access token
|
|
if (
|
|
new Date(res.expirationTime).getTime() <
|
|
new Date().getTime() + 15 * 60 * 1000
|
|
) {
|
|
this.renewAccessToken();
|
|
}
|
|
}, 2 * 60 * 1000);
|
|
|
|
this.accessInfo = res;
|
|
|
|
const randomnumber = Math.random().toString(36).substring(2, 15);
|
|
this.ws = new WebSocket(`wss://demo.tradovateapi.com/v1/websocket?r=${randomnumber}`);
|
|
|
|
this.ws.onopen = () => {
|
|
console.log('Connected to websocket');
|
|
this.ws.send('authorize\n2\n\n' + this.accessInfo.accessToken);
|
|
this.directEventCallbacks[2] = (response: any) => {
|
|
// Once authorize, start syncing every 60 seconds
|
|
this.requestAccountUpdates();
|
|
setInterval(() => this.requestAccountUpdates(), 60000);
|
|
|
|
// Every 2.5 seconds send a heartbeat
|
|
setInterval(() => {
|
|
this.ws.send('[]');
|
|
}, 2500);
|
|
};
|
|
};
|
|
|
|
this.ws.onmessage = (event) => {
|
|
if (event.data[0] === 'a') {
|
|
const dataString = event.data.slice(1);
|
|
|
|
const data: (
|
|
| {
|
|
i?: number; // Id
|
|
s?: number; // Status
|
|
d?: any; // Data
|
|
}
|
|
| {
|
|
e?: string;
|
|
d?: {
|
|
entityType:
|
|
| 'order'
|
|
| 'orderVersion'
|
|
| 'auditUserAction'
|
|
| 'command'
|
|
| 'commandReport';
|
|
eventType: 'Created' | 'Updated';
|
|
entity: any;
|
|
};
|
|
}
|
|
)[] = JSON.parse(dataString);
|
|
|
|
for (const response of data) {
|
|
if (
|
|
'i' in response &&
|
|
response.i &&
|
|
this.directEventCallbacks[response.i]
|
|
) {
|
|
this.directEventCallbacks[response.i](response.d);
|
|
}
|
|
|
|
if ('e' in response && response.e) {
|
|
// Handle callbacks
|
|
for (const info of this.indirectEventCallbacks) {
|
|
if (
|
|
response.d?.entityType === info?.entityType &&
|
|
response.d?.eventType === info?.eventType &&
|
|
info?.validator(response.d.entity)
|
|
) {
|
|
info?.callback(response.d.entity);
|
|
}
|
|
}
|
|
|
|
// console.log('No callback found', response.d);
|
|
}
|
|
}
|
|
} else if (event.data[0] === 'h') {
|
|
// Heartbeat response
|
|
}
|
|
};
|
|
|
|
this.ws.onerror = (event) => {
|
|
console.error('Error on websocket', event);
|
|
};
|
|
});
|
|
}
|
|
|
|
private async requestAccountUpdates(): Promise<void> {
|
|
this.directEventCallbacks[3] = (response: any) => {
|
|
|
|
// Syncing DLL or MLL hit
|
|
const riskStatusById: { [id: number]: { liquidateOnly?: string } } = (
|
|
response.accountRiskStatuses || []
|
|
).reduce((acc: any, item: any) => {
|
|
acc[item.id] = item;
|
|
return acc;
|
|
}, {});
|
|
|
|
this.accountList = (response.accounts as AccountItem[]).map((account) => {
|
|
if (riskStatusById[account.id]?.liquidateOnly) {
|
|
return { ...account, active: false };
|
|
}
|
|
return account;
|
|
});
|
|
|
|
this.accountCashBalances = response.cashBalances.reduce(
|
|
(
|
|
acc: {
|
|
[accountId: number]: { amount: number; realizedPnL: number };
|
|
},
|
|
item: { accountId: number; amount: number; realizedPnL: number }
|
|
) => {
|
|
acc[item.accountId] = {
|
|
amount: item.amount,
|
|
realizedPnL: item.realizedPnL,
|
|
};
|
|
return acc;
|
|
},
|
|
{} as { [accountId: number]: { amount: number; realizedPnL: number } }
|
|
);
|
|
this.positions = response.positions
|
|
.filter((item) => item.netPos !== 0)
|
|
.reduce(
|
|
(
|
|
acc: {
|
|
[accountId: number]: {
|
|
contractId: number;
|
|
netPos: number;
|
|
netPrice: number;
|
|
timestamp: Date;
|
|
};
|
|
},
|
|
item: {
|
|
accountId: number;
|
|
contractId: number;
|
|
netPos: number;
|
|
netPrice: number;
|
|
timestamp: Date;
|
|
}
|
|
) => {
|
|
acc[item.accountId] = {
|
|
contractId: item.contractId,
|
|
netPos: item.netPos,
|
|
netPrice: item.netPrice,
|
|
timestamp: new Date(item.timestamp),
|
|
};
|
|
return acc;
|
|
},
|
|
{} as {
|
|
[accountId: number]: {
|
|
contractId: number;
|
|
netPos: number;
|
|
netPrice: number;
|
|
timestamp: Date;
|
|
};
|
|
}
|
|
);
|
|
|
|
this.callbackOnSyncRequest();
|
|
this.fetchDaysTraded();
|
|
};
|
|
|
|
this.ws.send('user/syncrequest\n3\n\n{"splitResponses":false}');
|
|
}
|
|
|
|
private async fetchDaysTraded(): Promise<void> {
|
|
if (!this.accessInfo?.accessToken) return;
|
|
|
|
const cutoff = new Date();
|
|
cutoff.setDate(cutoff.getDate() - 28);
|
|
|
|
for (const account of this.accountList) {
|
|
try {
|
|
const res = await axios.get(
|
|
`https://demo.tradovateapi.com/v1/fill/ldeps?masterid=${account.id}`,
|
|
{ headers: { Authorization: `Bearer ${this.accessInfo.accessToken}` } }
|
|
);
|
|
const fills: { timestamp: string }[] = res.data ?? [];
|
|
const tradingDays = new Set(
|
|
fills
|
|
.filter((f) => new Date(f.timestamp) >= cutoff)
|
|
.map((f) => new Date(f.timestamp).toDateString())
|
|
);
|
|
this.daysTraded[account.id] = tradingDays.size;
|
|
} catch (err) {
|
|
console.error(`[fetchDaysTraded] account ${account.id}`, err);
|
|
this.daysTraded[account.id] = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
private async login(): Promise<AuthLoginResponse> {
|
|
const chl = '' + (Date.now() - 1581e9);
|
|
const sec = computeSec(this.name, this.password, this.deviceId, chl);
|
|
|
|
const generateEncodedPassword = (e) => {
|
|
const { name: t, password: n } = e,
|
|
o = t.length % n.length,
|
|
r = (n.slice(o) + n.slice(0, o)).split('').reverse().join('');
|
|
return btoa(r);
|
|
};
|
|
|
|
const res = await axios.post('https://live.tradovateapi.com/v1/auth/accesstokenrequest', {
|
|
name: this.name,
|
|
password: generateEncodedPassword({ name: this.name, password: this.password }),
|
|
environment: 'demo',
|
|
appId: 'tradovate_trader(web)',
|
|
appVersion: '3.251205.0',
|
|
deviceId: this.deviceId,
|
|
cid: '1',
|
|
chl: chl,
|
|
sec: sec,
|
|
enc: true,
|
|
});
|
|
|
|
if (res.status !== 200) {
|
|
console.error('Failed to login', res.data);
|
|
}
|
|
|
|
return res.data;
|
|
}
|
|
|
|
private async renewAccessToken(): Promise<void> {
|
|
const res = await axios.get('https://live.tradovateapi.com/v1/auth/renewAccessToken', {
|
|
headers: {
|
|
Authorization: `Bearer ${this.accessInfo.accessToken}`,
|
|
},
|
|
});
|
|
|
|
if (res.status !== 200) {
|
|
console.error('Failed to renew access token', res.data);
|
|
}
|
|
|
|
console.log('Renewed access token');
|
|
this.accessInfo = res.data;
|
|
}
|
|
|
|
async getAccountList(): Promise<AccountItem[]> {
|
|
if (!this.accessInfo?.accessToken) {
|
|
console.log('Not authenticated');
|
|
return [];
|
|
}
|
|
|
|
const res = await axios.get('https://demo.tradovateapi.com/v1/account/list', {
|
|
headers: {
|
|
Authorization: `Bearer ${this.accessInfo.accessToken}`,
|
|
},
|
|
});
|
|
|
|
return res.data;
|
|
}
|
|
|
|
async requestContractsFromSocket(names: string[]): Promise<{
|
|
[name: string]: Contract;
|
|
}> {
|
|
if (!this.ws) {
|
|
console.log('Websocket not connected');
|
|
return {};
|
|
}
|
|
|
|
return new Promise((resolve) => {
|
|
this.directEventCallbacks[10] = (response: any) => {
|
|
resolve(
|
|
(response || []).reduce((acc: { [name: string]: Contract }, item: Contract) => {
|
|
return { ...acc, [item.name]: item };
|
|
}, {} as { [name: string]: Contract })
|
|
);
|
|
};
|
|
this.ws.send(`contract/finds\n10\nnames=${names.join(',')}`);
|
|
});
|
|
}
|
|
|
|
async sendOrder(
|
|
accountId: number,
|
|
contractId: number,
|
|
quantity: number,
|
|
action: 'Buy' | 'Sell',
|
|
orderType: 'Market' | 'Limit',
|
|
price?: number
|
|
): Promise<any> {
|
|
if (!this.ws) {
|
|
console.log('Websocket not connected');
|
|
return;
|
|
}
|
|
|
|
this.ws.send(
|
|
`user/registeraudituseraction\n25\n\n${JSON.stringify({
|
|
accountId: accountId,
|
|
actionType: action + orderType,
|
|
details: `DOM MESZ5: Buy ${orderType}, Buy ${quantity} ${orderType}${
|
|
price ? ` ${price}` : ''
|
|
}, TIF Day`,
|
|
})}`
|
|
);
|
|
|
|
return new Promise((resolve, reject) => {
|
|
this.directEventCallbacks[26] = (response: any) => {
|
|
// console.log('Order id', response?.orderId);
|
|
console.log('Order placed, order id: ', response);
|
|
|
|
// TODO: Implement for limit orders and rejected market orders
|
|
|
|
// If we don't get a response within 5 seconds, reject the promise
|
|
setTimeout(() => {
|
|
reject(new Error('No response from order placement'));
|
|
}, 5000);
|
|
|
|
this.indirectEventCallbacks.push({
|
|
entityType: 'fill',
|
|
eventType: 'Created',
|
|
validator: (item: any) => item?.orderId === response?.orderId,
|
|
callback: (response: any) => {
|
|
resolve(response);
|
|
},
|
|
});
|
|
};
|
|
|
|
this.ws.send(
|
|
`order/placeorder\n26\n\n${JSON.stringify({
|
|
accountId: accountId,
|
|
action: action,
|
|
symbol: contractId,
|
|
orderQty: quantity,
|
|
orderType: orderType,
|
|
price: price,
|
|
timeInForce: 'Day',
|
|
text: 'DOM',
|
|
})}`
|
|
);
|
|
});
|
|
}
|
|
}
|