Client SDK for TypeScript and JavaScript applications

import {ClientSdk, OAuthMethod} from '@quadcode-tech/client-sdk-js'

async function startLogin() {
	const oauth = new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com', // local: use the same prod host (DO NOT use localhost) — this is the OAuth/Token server; redirects are handled by the provider, not via Vite proxy
		clientId: CLIENT_ID,                         // your client ID (you can request CLIENT_ID and CLIENT_SECRET via form: https://forms.gle/J8NQxxMQWKXggWet6)
		redirectUri: 'https://your.app/callback',    // redirect URI ( local: http://localhost:5173/callback )
		scope: 'full'                                // scope (e.g. 'full' or 'full offline_access')
	})
	const {url, codeVerifier} = await oauth.createAuthorizationUrl()
	sessionStorage.setItem('pkce_verifier', codeVerifier)
	window.location.href = url
}

// Example of in-memory tokens storage (you can implement your own persistent storage)
// NOTE: In a real application, consider using localStorage/sessionStorage or IndexedDB for persistence across page reloads.
class InMemoryOAuthTokensStorage {
	private tokens: { accessToken: string; refreshToken?: string } = {
		accessToken: '',
	};

	get(): { accessToken: string; refreshToken?: string } {
		return this.tokens;
	}

	set(tokens: { accessToken: string; refreshToken?: string }): void {
		this.tokens = tokens;
	}
}


async function handleCallback() {
	const params = new URLSearchParams(window.location.search);
	const code = params.get('code');
	const codeVerifier = sessionStorage.getItem('pkce_verifier');

	if (!code) throw new Error('Missing ?code in callback URL');
	if (!codeVerifier) throw new Error('Missing PKCE code_verifier');

	const oauth = new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com', // local (dev via Vite proxy from the browser): http://localhost:5173/proxy/api
		clientId: CLIENT_ID,
		redirectUri: 'https://your.app/callback',    // local: http://localhost:5173/callback
		scope: 'full',
		// NEVER put clientSecret in the browser; access/refresh tokens are managed by tokensStorage
		tokensStorage // custom tokens storage to persist tokens in memory (or use localStorage/sessionStorage)
	});

	await oauth.issueAccessTokenWithAuthCode(code, codeVerifier);

	const sdk = await ClientSdk.create(
		'wss://ws.trade.example.com/echo/websocket', // local (dev via Vite proxy): ws://localhost:5173/proxy/ws/echo/websocket
		82,
		oauth
	);

	const balances = await sdk.balances();
	console.log(balances.getBalances());
}

import {ClientSdk, OAuthMethod} from '@quadcode-tech/client-sdk-js'

async function startLogin() {
	const oauth = new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com', // local: use the same prod host (DO NOT use localhost) — this is the OAuth/Token server; redirects are handled by the provider, not via Vite proxy
		clientId: CLIENT_ID,                         // your client ID (you can request CLIENT_ID and CLIENT_SECRET via form: https://forms.gle/J8NQxxMQWKXggWet6)
		redirectUri: 'https://your.app/callback',    // redirect URI
		scope: 'full offline_access'                 // scope (e.g. 'full' or 'full offline_access')
	})
	const {url, codeVerifier} = await oauth.createAuthorizationUrl()
	sessionStorage.setItem('pkce_verifier', codeVerifier)
	window.location.href = url
}

import express from 'express'
import {OAuthMethod} from '@quadcode-tech/client-sdk-js'

const app = express()
app.use(express.json())

app.post('/api/oauth/exchange', async (req, res) => {
	const {code, codeVerifier} = req.body
	if (!code || !codeVerifier) return res.status(400).json({error: 'Bad request'})

	const oauth = new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com',
		clientId: Number(process.env.CLIENT_ID),
		redirectUri: 'https://your.app/callback',
		scope: 'full offline_access',
		clientSecret: process.env.CLIENT_SECRET, // SECRET: server-side only
		tokensStorage                            // server-side tokens storage (DB/kv bound to user/session); manages access/refresh tokens
	})

	const {accessToken, refreshToken, expiresIn} = await oauth.issueAccessTokenWithAuthCode(code, codeVerifier)

	// Persist refreshToken securely (DB/kv bound to user/session)
	await saveUserRefreshToken(req, refreshToken)

	// Return ONLY a short-lived access token to the browser
	res.json({accessToken, expiresIn})
})

// Optional refresh endpoint (server uses stored refresh token)
app.post('/api/oauth/refresh', async (req, res) => {
	const oauth = new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com',
		clientId: Number(process.env.CLIENT_ID),
		redirectUri: 'https://your.app/callback',
		scope: 'full offline_access',
		clientSecret: process.env.CLIENT_SECRET,
		tokensStorage                            // server-side tokens storage (DB/kv bound to user/session); manages access/refresh tokens
	})

	const {accessToken, expiresIn} = await oauth.refreshAccessToken()

	return res.json({accessToken, expiresIn})
})

import {ClientSdk, OAuthMethod} from '@quadcode-tech/client-sdk-js'

export async function handleCallbackAndStart() {
	const params = new URLSearchParams(window.location.search)
	const code = params.get('code')
	const codeVerifier = sessionStorage.getItem('pkce_verifier')
	if (!code || !codeVerifier) throw new Error('Missing code or PKCE verifier')

	// Exchange on the server (server stores refresh; client gets only accessToken)
	const r = await fetch('/api/oauth/exchange', {
		method: 'POST',
		headers: {'Content-Type': 'application/json'},
		body: JSON.stringify({code, codeVerifier})
	})
	const {accessToken} = await r.json()

	const sdk = await ClientSdk.create(
		'wss://ws.trade.example.com/echo/websocket',  // local (dev via Vite proxy): ws://localhost:5173/proxy/ws/echo/websocket
		82,
		new OAuthMethod({
			apiBaseUrl: 'https://api.trade.example.com', // local (dev via Vite proxy from the browser): http://localhost:5173/proxy/api
			clientId: CLIENT_ID,
			redirectUri: 'https://your.app/callback',    // local: http://localhost:5173/callback
			scope: 'full offline_access',
			accessToken // NEVER put clientSecret or a refresh token in the browser
		})
	)

	// use SDK
	const balances = await sdk.balances()
	console.log(balances.getBalances())
}

const sdk = await ClientSdk.create(
	'wss://ws.trade.example.com/echo/websocket',
	82,
	new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com',
		clientId: CLIENT_ID,
		redirectUri: 'https://your.app/callback',
		scope: 'full offline_access',
		accessToken // NEVER put clientSecret or a refresh token in the browser
	}),
	{
		// Optional: Override the default static files host
		// Default: 'https://static.cdnroute.io/files'
		staticHost: 'https://your-static-host.com/files',

		// Optional: Override the default host for API requests
		// Default: Extracted from the WebSocket URL
		host: 'https://trade.example.com'
	}
)

import {ClientSdk, OAuthMethod} from '@quadcode-tech/client-sdk-js'

const sdk = await ClientSdk.create(
	'wss://ws.trade.example.com/echo/websocket',
	82,
	new OAuthMethod({
		apiBaseUrl: 'https://api.trade.example.com',
		clientId: Number(process.env.CLIENT_ID),
		redirectUri: 'https://your.app/callback',
		scope: 'full offline_access',
		clientSecret: process.env.CLIENT_SECRET, // SECRET: server-side only
		tokensStorage                            // server-side tokens storage (DB/kv bound to user/session); manages access/refresh tokens
	})
)

import {ClientSdk, SsidAuthMethod, WsConnectionStateEnum} from '@quadcode-tech/client-sdk-js'

const wsConnectionState = await sdk.wsConnectionState()

wsConnectionState.subscribeOnStateChanged(async (state) => {
	if (state === WsConnectionStateEnum.AuthenticationFailed) {
		// The session is no longer valid. Dispose of the old instance and
		// create a new one with a freshly obtained SSID.
		await sdk.shutdown()

		sdk = await ClientSdk.create(
			'wss://ws.trade.example.com/echo/websocket',
			82,
			new SsidAuthMethod(await obtainFreshSsid())
		)
	}
})

const balances = await sdk.balances()

console.log(balances.getBalances())

const balance = balances.getBalances().find((balance) => balance.type === BalanceType.Real)

balance.subscribeOnUpdate((updatedBalance) => console.log(updatedBalance))

const balances = await sdk.balances()

console.log(balances.getBalances())

const balance = balances.getBalances().find((balance) => balance.type === BalanceType.Demo)

balance.resetDemoBalance()

const balances = await sdk.balances()

const balance = balances.getBalanceById(12345)

balance.subscribeOnUpdate((updatedBalance) => console.log(updatedBalance))

const balances = await sdk.balances()

const balance = balances.getBalances().find((balance) => balance.type === BalanceType.Real)

// Amount available for options trading (blitz / turbo / binary / digital), includes bonuses
console.log(balance.availableForOptionsAmount())

// Amount available for margin trading (CFD / Forex / Crypto)
console.log(balance.availableForMarginAmount())

// Keep the available amounts up to date in real time
balance.subscribeOnUpdate((updatedBalance) => {
    console.log('options:', updatedBalance.availableForOptionsAmount())
    console.log('margin:', updatedBalance.availableForMarginAmount())
})

const quotes = await sdk.quotes()

const currentQuote = await quotes.getCurrentQuoteForActive(1)

currentQuote.subscribeOnUpdate((updatedCurrentQuote) => console.log(updatedCurrentQuote))

const blitzOptions = await sdk.blitzOptions()

const blitzOptionsActives = blitzOptions.getActives()

const blitzOptionsFirstAvailableActive = blitzOptionsActives.find((active) => active.canBeBoughtAt(sdk.currentTime()))

const callOption = await blitzOptions.buy(
	blitzOptionsFirstAvailableActive,
	BlitzOptionsDirection.Call,
	blitzOptionsFirstAvailableActive.expirationTimes[0],
	1,
	balance
)

console.log(callOption)

const putOption = await blitzOptions.buy(
	blitzOptionsFirstAvailableActive,
	BlitzOptionsDirection.Put,
	blitzOptionsFirstAvailableActive.expirationTimes[0],
	1,
	balance
)

console.log(putOption)

const blitzOptions = await sdk.blitzOptions()
const positions = await sdk.positions()

console.log(positions.getOpenedPositions().filter((position) => position.instrumentType === InstrumentType.BlitzOption))

positions.subscribeOnUpdatePosition((position) => {
	if (position.instrumentType === InstrumentType.BlitzOption) {
		console.log(position)
	}
})

const blitzOptions = await sdk.blitzOptions()
const positions = await sdk.positions()
const positionsHistory = await positions.getPositionsHistory()

if (positionsHistory.hasPrevPage()) {
	await positionsHistory.fetchPrevPage()
}

console.log(positionsHistory.getPositions())

const positions = await sdk.positions()
const position = positions.getOpenedPositions().find((position) => position.externalId == 1)
await position.sell() // not available for blitz options 

const positions = await sdk.positions()
const position = positions.getOpenedPositions().find((position) => position.externalId == 1)
console.log(position.pnlNet)
console.log(position.sellProfit)

const turboOptions = await sdk.turboOptions()

const actives = turboOptions.getActives().filter((active) => active.canBeBoughtAt(sdk.currentTime()))

const firstActive = actives[0]

const firstActiveInstruments = await firstActive.instruments()

const firstActiveAvailableInstruments = firstActiveInstruments.getAvailableForBuyAt(sdk.currentTime())

const firstInstrument = firstActiveAvailableInstruments[0]

const callOption = await turboOptions.buy(firstInstrument, TurboOptionsDirection.Call, 1, balance)
console.log(callOption)

const putOption = await turboOptions.buy(firstInstrument, TurboOptionsDirection.Put, 1, balance)
console.log(putOption)

const turboOptions = await sdk.turboOptions()
const positions = await sdk.positions()

console.log(positions.getOpenedPositions().filter((position) => position.instrumentType === InstrumentType.TurboOption))

positions.subscribeOnUpdatePosition((position) => {
	if (position.instrumentType === InstrumentType.TurboOption) {
		console.log(position)
	}
})

const binaryOptions = await sdk.binaryOptions()

const actives = binaryOptions.getActives().filter((active) => active.canBeBoughtAt(sdk.currentTime()))

const firstActive = actives[0]

const firstActiveInstruments = await firstActive.instruments()

const firstActiveAvailableInstruments = firstActiveInstruments.getAvailableForBuyAt(sdk.currentTime())

const firstInstrument = firstActiveAvailableInstruments[0]
const purchaseEndTime = firstInstrument.purchaseEndTime();

const callOption = await binaryOptions.buy(firstInstrument, BinaryOptionsDirection.Call, 1, balance)
console.log(callOption)

const putOption = await binaryOptions.buy(firstInstrument, BinaryOptionsDirection.Put, 1, balance)
console.log(putOption)

const binaryOptions = await sdk.binaryOptions()

const actives = binaryOptions.getActives()

const firstActive = actives[0]

const firstActiveInstruments = await firstActive.instruments()

const firstActiveAvailableInstruments = firstActiveInstruments.getAvailableForBuyAt(sdk.currentTime())

const firstInstrument = firstActiveAvailableInstruments[0]

const purchaseEndTime = firstInstrument.purchaseEndTime();

const durationRemainingForPurchase = firstInstrument.durationRemainingForPurchase();

const binaryOptions = await sdk.binaryOptions()
const positions = await sdk.positions()

console.log(positions.getOpenedPositions().filter((position) => position.instrumentType === InstrumentType.BinaryOption))

binaryOptionsPositions.subscribeOnUpdatePosition((position) => {
	if (position.instrumentType === InstrumentType.BinaryOption) {
		console.log(position)
	}
})

const digitalOptions = await sdk.digitalOptions()

const underlyings = digitalOptions.getUnderlyingsAvailableForTradingAt(sdk.currentTime())

const firstUnderlying = underlyings.find((u) => {
	return u.activeId === 1
})

const firstUnderlyingInstruments = await firstUnderlying.instruments()

const firstUnderlyingAvailableInstruments = firstUnderlyingInstruments.getAvailableForBuyAt(sdk.currentTime())

const firstInstrument = firstUnderlyingAvailableInstruments[0]

const callOption = await digitalOptions.buySpotStrike(firstInstrument, DigitalOptionsDirection.Call, 1, balance)
console.log(callOption)

const putOption = await digitalOptions.buySpotStrike(firstInstrument, DigitalOptionsDirection.Put, 1, balance)
console.log(putOption)

const digitalOptions = await sdk.digitalOptions()
const positions = await sdk.positions()

console.log(digitalOptionsPositions.getOpenedPositions().filter((position) => position.instrumentType === InstrumentType.DigitalOption))

digitalOptionsPositions.subscribeOnUpdatePosition((position) => {
	if (position.instrumentType === InstrumentType.DigitalOption) {
		console.log(position)
	}
})

const translations = await sdk.translations()

// By default, English (en) translations for the 'front' group are already loaded
// and will automatically reload every 10 minutes
const translatedText = translations.getTranslation('front.EURGBP')

// To get translations in other languages or groups, you need to fetch them first
await translations.fetchTranslations('es', [TranslationGroup.Front])
const translatedTextEs = translations.getTranslation('front.EURGBP', 'es')

// Get active name with translation (automatically uses loaded translations)
const actives = await sdk.actives()
const active = await actives.getActive(1)
console.log(active.name) // Returns translated name

const marginCfd = await sdk.marginCfd() // or marginForex or marginCrypto

const underlyings = marginCfd.getUnderlyingsAvailableForTradingAt(sdk.currentTime())

const firstUnderlying = underlyings.find((u) => {
	return u.activeId === 1
})

const firstUnderlyingInstruments = await firstUnderlying.instruments()

const firstUnderlyingAvailableInstruments = firstUnderlyingInstruments.getAvailableForBuyAt(sdk.currentTime())

const firstInstrument = firstUnderlyingAvailableInstruments[0]

// The 3rd argument is `count` = quantity * instrument.lotSize, NOT a bare quantity.
// instrument.lotSize is 100000 for Forex and 1 for CFD/Crypto, so for Forex a bare `1` means
// 1 unit - 100000x smaller than 1 lot. The same `count` is expected by calculateMargin(),
// buyStop() and buyLimit(), so always build it the same way.
const count = firstInstrument.minQty * firstInstrument.lotSize

const callOption = await marginCfd.buy(firstInstrument, Margin.Buy, count, balance)
console.log(callOption)

const putOption = await marginCfd.buy(firstInstrument, Margin.Sell, count, balance)
console.log(putOption)

const marginCfd = await sdk.marginCfd() // or marginCrypto

const underlyings = marginCfd.getUnderlyingsAvailableForTradingAt(sdk.currentTime())
const instruments = await underlyings[0].instruments()
const instrument = instruments.getAvailableForBuyAt(sdk.currentTime())[0]

// `count` is a quantity multiplied by the instrument lot size, the same value you pass to buy().
// Use instrument.lotSize (Forex = 100000, CFD/Crypto = 1) instead of hard-coding the lot size.
// Passing a bare quantity (forgetting * lotSize) makes the Forex margin come out 100000x too
// small - e.g. 0.2 instead of 20000 - because CFD/Crypto lotSize is 1 but Forex lotSize is 100000.
const count = instrument.minQty * instrument.lotSize

// Direction is optional - omit it to price at the mid quote. Pass a pending price as the
// 5th argument to price a pending (stop/limit) order.
const calculation = await marginCfd.calculateMargin(instrument, count, balance, Margin.Buy)

// margin and pipValue are expressed in the balance (account) currency. They are `undefined`
// until the first quote / exchange-rate tick arrives, so read them via subscribeOnUpdate.
calculation.subscribeOnUpdate((c) => {
	console.log('margin:', c.margin, 'pip value:', c.pipValue)
})

const marginForex = await sdk.marginForex()

const underlyings = marginForex.getUnderlyingsAvailableForTradingAt(sdk.currentTime())
const instruments = await underlyings[0].instruments()
const instrument = instruments.getAvailableForBuyAt(sdk.currentTime())[0]

const count = instrument.minQty * instrument.lotSize

const calculation = await marginForex.calculateMargin(instrument, count, balance, Margin.Buy)

calculation.subscribeOnUpdate((c) => {
	console.log('margin:', c.margin, 'pip value:', c.pipValue)
})

const calculation = await marginForex.calculateMargin(instrument, count, balance, Margin.Buy)

calculation.subscribeOnUpdate((c) => {
	const openPrice = 1.2345 // position open (underlying) price

	// Take-profit / stop-loss trigger prices. These are absolute prices, not deltas;
	// here they are 0.0010 (10 pips on a 4-decimal pair) above / below the open price.
	const takeProfitPrice = openPrice + 0.0010
	const stopLossPrice = openPrice - 0.0010

	// For a Buy, a take-profit above the open price yields a positive PnL,
	// and a stop-loss below it yields a negative PnL (reversed for a Sell).
	console.log('take-profit PnL:', c.pnlForTPSL(openPrice, takeProfitPrice))
	console.log('stop-loss PnL:', c.pnlForTPSL(openPrice, stopLossPrice))
})