strategy-tools 1.0.0

package/dist/cetus/CetusStrategyApiConnection.d.ts

@@ -0,0 +1,25 @@
+import { ExternalApiConnection, StandardKeyGroup } from "itrm-tools";
+export interface CetusStrategy {
+    id: number;
+    name: string;
+    settings: any;
+    memory: any;
+    account: string;
+    pair: string;
+    intermediary: string;
+    status: string;
+}
+export declare enum StrategyStatus {
+    RUNNING = "RUNNING",
+    BUY_ONLY = "BUY_ONLY",
+    SELL_ONLY = "SELL_ONLY",
+    STOPPED = "STOPPED"
+}
+export declare class CetusStrategyApiConnection extends ExternalApiConnection {
+    constructor(apiUrl: string, keys: StandardKeyGroup);
+    getStrategies(params: {
+        name: string;
+        pair: string;
+        account: string;
+    }): Promise<CetusStrategy[]>;
+}

package/dist/cetus/CetusStrategyApiConnection.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CetusStrategyApiConnection = exports.StrategyStatus = void 0;
+const itrm_tools_1 = require("itrm-tools");
+var StrategyStatus;
+(function (StrategyStatus) {
+    StrategyStatus["RUNNING"] = "RUNNING";
+    StrategyStatus["BUY_ONLY"] = "BUY_ONLY";
+    StrategyStatus["SELL_ONLY"] = "SELL_ONLY";
+    StrategyStatus["STOPPED"] = "STOPPED";
+})(StrategyStatus || (exports.StrategyStatus = StrategyStatus = {}));
+class CetusStrategyApiConnection extends itrm_tools_1.ExternalApiConnection {
+    constructor(apiUrl, keys) {
+        super("cetus", apiUrl, keys);
+    }
+    async getStrategies(params) {
+        const queryString = new URLSearchParams(params).toString();
+        return this.request(itrm_tools_1.RequestMethod.GET, `/v1/strategies?${queryString}`);
+    }
+}
+exports.CetusStrategyApiConnection = CetusStrategyApiConnection;
+//# sourceMappingURL=CetusStrategyApiConnection.js.map

package/dist/cetus/CetusStrategyApiConnection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CetusStrategyApiConnection.js","sourceRoot":"","sources":["../../src/cetus/CetusStrategyApiConnection.ts"],"names":[],"mappings":";;;AAAA,2CAAoF;AAapF,IAAY,cAKX;AALD,WAAY,cAAc;IACtB,qCAAmB,CAAA;IACnB,uCAAqB,CAAA;IACrB,yCAAuB,CAAA;IACvB,qCAAmB,CAAA;AACvB,CAAC,EALW,cAAc,8BAAd,cAAc,QAKzB;AAED,MAAa,0BAA2B,SAAQ,kCAAqB;IACjE,YAAY,MAAc,EAAE,IAAsB;QAC9C,KAAK,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IACjC,CAAC;IAEM,KAAK,CAAC,aAAa,CAAC,MAAuD;QAC9E,MAAM,WAAW,GAAG,IAAI,eAAe,CAAC,MAAa,CAAC,CAAC,QAAQ,EAAE,CAAC;QAClE,OAAO,IAAI,CAAC,OAAO,CAAkB,0BAAa,CAAC,GAAG,EAAE,kBAAkB,WAAW,EAAE,CAAC,CAAC;IAC7F,CAAC;CACJ;AATD,gEASC"}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { BinanceApiSigner as BinanceApiSigner } from './binance/BinanceApiSigner';
+export { BinanceConnection as BinanceConnection } from './binance/BinanceConnection';
+export { BinanceOperationConnection as BinanceOperationConnection } from './binance/connection/BinanceOperationConnection';
+export { BinanceParams as BinanceParams, BinanceResponse as BinanceResponse, BinanceAccountResponse as BinanceAccountResponse, BinanceSymbolStatus as BinanceSymbolStatus, BinanceOrderSide as BinanceOrderSide, BinanceOrderType as BinanceOrderType, BinanceTimeInForce as BinanceTimeInForce, BinanceOrder as BinanceOrder, BinanceOrderStatus as BinanceOrderStatus, BinanceCancelRestrictions as BinanceCancelRestrictions } from './binance/BinanceTypes';
+export { CetusStrategyApiConnection as CetusStrategyApiConnection, CetusStrategy as CetusStrategy, StrategyStatus as StrategyStatus } from './cetus/CetusStrategyApiConnection';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StrategyStatus = exports.CetusStrategyApiConnection = exports.BinanceCancelRestrictions = exports.BinanceOrderStatus = exports.BinanceTimeInForce = exports.BinanceOrderType = exports.BinanceOrderSide = exports.BinanceSymbolStatus = exports.BinanceOperationConnection = exports.BinanceConnection = exports.BinanceApiSigner = void 0;
+var BinanceApiSigner_1 = require("./binance/BinanceApiSigner");
+Object.defineProperty(exports, "BinanceApiSigner", { enumerable: true, get: function () { return BinanceApiSigner_1.BinanceApiSigner; } });
+var BinanceConnection_1 = require("./binance/BinanceConnection");
+Object.defineProperty(exports, "BinanceConnection", { enumerable: true, get: function () { return BinanceConnection_1.BinanceConnection; } });
+var BinanceOperationConnection_1 = require("./binance/connection/BinanceOperationConnection");
+Object.defineProperty(exports, "BinanceOperationConnection", { enumerable: true, get: function () { return BinanceOperationConnection_1.BinanceOperationConnection; } });
+var BinanceTypes_1 = require("./binance/BinanceTypes");
+Object.defineProperty(exports, "BinanceSymbolStatus", { enumerable: true, get: function () { return BinanceTypes_1.BinanceSymbolStatus; } });
+Object.defineProperty(exports, "BinanceOrderSide", { enumerable: true, get: function () { return BinanceTypes_1.BinanceOrderSide; } });
+Object.defineProperty(exports, "BinanceOrderType", { enumerable: true, get: function () { return BinanceTypes_1.BinanceOrderType; } });
+Object.defineProperty(exports, "BinanceTimeInForce", { enumerable: true, get: function () { return BinanceTypes_1.BinanceTimeInForce; } });
+Object.defineProperty(exports, "BinanceOrderStatus", { enumerable: true, get: function () { return BinanceTypes_1.BinanceOrderStatus; } });
+Object.defineProperty(exports, "BinanceCancelRestrictions", { enumerable: true, get: function () { return BinanceTypes_1.BinanceCancelRestrictions; } });
+var CetusStrategyApiConnection_1 = require("./cetus/CetusStrategyApiConnection");
+Object.defineProperty(exports, "CetusStrategyApiConnection", { enumerable: true, get: function () { return CetusStrategyApiConnection_1.CetusStrategyApiConnection; } });
+Object.defineProperty(exports, "StrategyStatus", { enumerable: true, get: function () { return CetusStrategyApiConnection_1.StrategyStatus; } });
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AAAA,+DAAkF;AAAzE,oHAAA,gBAAgB,OAAoB;AAC7C,iEAAqF;AAA5E,sHAAA,iBAAiB,OAAqB;AAC/C,8FAA2H;AAAlH,wIAAA,0BAA0B,OAA8B;AACjE,uDAAgc;AAAjU,mHAAA,mBAAmB,OAAuB;AAAE,gHAAA,gBAAgB,OAAoB;AAAE,gHAAA,gBAAgB,OAAoB;AAAE,kHAAA,kBAAkB,OAAsB;AAAgC,kHAAA,kBAAkB,OAAsB;AAAE,yHAAA,yBAAyB,OAA6B;AAE/Z,iFAAgL;AAAvK,wIAAA,0BAA0B,OAA8B;AAAkC,4HAAA,cAAc,OAAkB"}

package/jest.config.js

@@ -0,0 +1,19 @@
+module.exports = {
+    preset: "jest-puppeteer",
+    transform: {
+      '^.+\\.ts?$': [
+        'ts-jest',
+        {
+          transpilation: true,
+        }
+      ],
+    },
+    testEnvironment: 'jest-environment-node',
+    testRegex: '/test/.*\\.(test|spec)?\\.(ts|tsx)$',
+    moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+    automock: false,
+    resetMocks: false,
+    moduleNameMapper: {
+      '^jose$': '<rootDir>/__mocks__/jose.js'
+    }
+  };

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "strategy-tools",
+  "version": "1.0.0",
+  "description": "Librería para el desarrollo de estrategias de Cetus",
+  "main": "index.js",
+  "scripts": {
+    "build": "rimraf ./dist && tsc --skipLibCheck",
+    "publish-lib": "npm run build && npm publish",
+    "publish-beta": "npm run build && npm publish --tag beta",
+    "publish-dryrun": "npm run build && npm publish --dry-run",
+    "link": "npm run build && npm link",
+    "test": "npm run build && set NODE_OPTIONS=--experimental-vm-modules && jest --runInBand --detectOpenHandles",
+    "test-silent": "npm run build && set NODE_OPTIONS=--experimental-vm-modules && jest --runInBand --detectOpenHandles --silent",
+    "test-watch": "npm run build && set NODE_OPTIONS=--experimental-vm-modules && jest --watch --runInBand --detectOpenHandles",
+    "test-watch-start": "npm run build && set NODE_OPTIONS=--experimental-vm-modules && jest --watch --runInBand --detectOpenHandles",
+    "test-coverage": "npm run build && set NODE_OPTIONS=--experimental-vm-modules && jest --runInBand --detectOpenHandles --silent --coverage"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ITRMachines/strategy-tools.git"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "bugs": {
+    "url": "https://github.com/ITRMachines/strategy-tools/issues"
+  },
+  "homepage": "https://github.com/ITRMachines/strategy-tools#readme",
+  "dependencies": {
+    "itrm-tools": "^1.3.28",
+    "jsrsasign": "^11.1.0"
+  },
+  "devDependencies": {
+    "@types/crypto-js": "^4.2.2",
+    "@types/jest": "^30.0.0",
+    "dotenv": "^17.2.3",
+    "jest": "^30.2.0",
+    "jest-puppeteer": "^11.0.0",
+    "rimraf": "^6.1.2",
+    "ts-jest": "^29.4.5",
+    "typescript": "^5.9.3"
+  }
+}

package/src/Signer.ts

@@ -0,0 +1,4 @@
+export interface Signer<I, K, S> {
+    sign(input: I, key: K): S;
+    verify(input: I, key: K, signature: S): boolean;
+}

package/src/binance/BinanceApiSigner.ts

@@ -0,0 +1,20 @@
+const { KJUR, hextob64 } = require('jsrsasign');
+//import { Signer } from "itrm-tools";
+import { Signer } from "../Signer";
+import { BinanceParams } from "./BinanceTypes";
+
+export class BinanceApiSigner implements Signer<BinanceParams, string, string> {
+    public sign(params: BinanceParams, key: string): string {
+        const queryString = new URLSearchParams(params as URLSearchParams).toString();
+        const signer = new KJUR.crypto.Signature({"alg": "SHA256withRSA"});
+        signer.init(key);
+        signer.updateString(queryString);
+        const signatureHex = signer.sign();
+        const signature = hextob64(signatureHex);
+        return encodeURIComponent(signature);
+    }
+    
+    public verify(input: BinanceParams, key: string, signature: string): boolean {
+        return true;
+    }
+}

package/src/binance/BinanceConnection.ts

@@ -0,0 +1,86 @@
+import { BinanceApiSigner } from "./BinanceApiSigner";
+import { BinanceSapiSignerBinanceApiSigner } from "./BinanceSapiSigner";
+import { BinanceAccountResponse, BinanceParams, BinanceResponse } from "./BinanceTypes";
+import { RequestAxiosCall } from "itrm-tools";
+
+export interface BinanceConfig {
+    baseUrl: string;
+    secretKey: string;
+    privateKey: string;
+};
+
+export class BinanceConnection {
+    protected config: BinanceConfig;
+    private apiSigner: BinanceApiSigner = new BinanceApiSigner();
+    private sapiSigner: BinanceSapiSignerBinanceApiSigner = new BinanceSapiSignerBinanceApiSigner();
+
+    constructor(config: BinanceConfig) {
+        this.config= config;
+    }
+
+    public async getAccount(params: { omitZeroBalances?: boolean; recvWindow?: number; }): Promise<BinanceAccountResponse> {
+        let response = await this.sendGetRequest('/api/v3/account', params);
+        return {
+            makerCommission: response.makerCommission!,
+            takerCommission: response.takerCommission!,
+            buyerCommission: response.buyerCommission!,
+            sellerCommission: response.sellerCommission!,
+            commissionRates: {
+                maker: parseFloat(response.commissionRates!.maker),
+                taker: parseFloat(response.commissionRates!.taker),
+                buyer: parseFloat(response.commissionRates!.buyer),
+                seller: parseFloat(response.commissionRates!.seller)
+            },
+            canTrade: response.canTrade!,
+            canWithdraw: response.canWithdraw!,
+            canDeposit: response.canDeposit!,
+            brokered: response.brokered!,
+            requireSelfTradePrevention: response.requireSelfTradePrevention!,
+            preventSor: response.preventSor!,
+            updateTime: response.updateTime!,
+            accountType: response.accountType!,
+            balances: this.parseBalances(response.balances!),
+            permissions: response.permissions!,
+            uid: response.uid!
+        };
+    }
+    
+    private parseBalances(balances: { asset: string; free: string; locked: string; }[]) {
+        let result = [];
+        for (let balance of balances)
+            result.push({
+                asset: balance.asset,
+                free: parseFloat(balance.free),
+                locked: parseFloat(balance.locked)
+            });
+        return result;
+    }
+
+    protected async sendGetRequest(endpoint: string, params: BinanceParams) {
+        params.timestamp = Date.now();
+        const queryString = new URLSearchParams(params as URLSearchParams).toString();
+        const url = `${this.config.baseUrl}${endpoint}?${queryString}&signature=${this.apiSigner.sign(params, this.config.privateKey)}`;
+        return await RequestAxiosCall.get<BinanceResponse>(url, { headers: { "X-MBX-APIKEY": this.config.secretKey } });
+    }
+
+    protected async sendPostRequest(endpoint: string, params: BinanceParams) {
+        params.timestamp = Date.now();
+        const queryString = new URLSearchParams(params as URLSearchParams).toString();
+        const requestBody = `${queryString}&signature=${this.apiSigner.sign(params, this.config.privateKey)}`;
+        return await RequestAxiosCall.post<BinanceResponse>(`${this.config.baseUrl}${endpoint}`, requestBody, { headers: { "X-MBX-APIKEY": this.config.secretKey } });
+    }
+
+    protected async sendDeleteRequest(endpoint: string, params: BinanceParams) {
+        params.timestamp = Date.now();
+        const queryString = new URLSearchParams(params as URLSearchParams).toString();
+        const url = `${this.config.baseUrl}${endpoint}?${queryString}&signature=${this.apiSigner.sign(params, this.config.privateKey)}`;
+        return await RequestAxiosCall.delete<BinanceResponse>(url, { headers: { "X-MBX-APIKEY": this.config.secretKey } });
+    }
+
+    protected async sendSapiPostRequest(endpoint: string, params: BinanceParams) {
+        params.timestamp = Date.now();
+        const queryString = new URLSearchParams(params as URLSearchParams).toString().replace(/\%40/g, '@');
+        const requestBody = `${queryString}&signature=${this.apiSigner.sign(params, this.config.privateKey)}`;
+        return await RequestAxiosCall.post<BinanceResponse>(`${this.config.baseUrl}${endpoint}`, requestBody, { headers: { "X-MBX-APIKEY": this.config.secretKey } });
+    }
+}

package/src/binance/BinanceSapiSigner.ts

@@ -0,0 +1,21 @@
+import { BinanceParams } from "./BinanceTypes";
+import { HmacSHA256, enc } from "crypto-js";
+import { Signer } from "../Signer";
+
+export class BinanceSapiSignerBinanceApiSigner implements Signer<BinanceParams, string, string> {
+    public sign(params: BinanceParams, key: string): string {
+        const queryString = new URLSearchParams(params as URLSearchParams).toString();
+        const signature = HmacSHA256(queryString, key).toString(enc.Hex);
+        /*const signer = new KJUR.crypto.Signature({"alg": "SHA256withRSA"});
+        signer.init(key);
+        signer.updateString(queryString);
+        const signatureHex = signer.sign();
+        const signature = hextob64(signatureHex);*/
+        console.log(">>> signature:", signature);
+        return encodeURIComponent(signature);
+    }
+    
+    public verify(input: BinanceParams, key: string, signature: string): boolean {
+        return true;
+    }
+}

package/src/binance/BinanceTypes.ts

@@ -0,0 +1,168 @@
+export interface BinanceParams {
+    quoteId?: string;
+    rfqId?: string;
+    baseAsset?: string;
+    quoteAsset?: string;
+    quantity?: number;
+    price?: number;
+    settleTime?: number;
+    omitZeroBalances?: boolean;
+    recvWindow?: number;
+    timestamp?: number;
+    symbol?: string;
+    side?: BinanceOrderSide;
+    type?: BinanceOrderType;
+    timeInForce?: BinanceTimeInForce;
+    quoteOrderQty?: number;
+    orderId?: number;
+    origClientOrderId?: string;
+    newClientOrderId?: string;
+    cancelRestrictions?: BinanceCancelRestrictions;
+    toEmail?: string;
+    asset?: string;
+    amount?: number;
+};
+
+export interface BinanceResponse {
+    makerCommission?: number;
+    takerCommission?: number;
+    buyerCommission?: number,
+    sellerCommission?: number,
+    commissionRates?: {
+        maker: string;
+        taker: string;
+        buyer: string;
+        seller: string;
+    },
+    canTrade?: boolean;
+    canWithdraw?: boolean;
+    canDeposit?: boolean;
+    brokered?: boolean;
+    requireSelfTradePrevention?: boolean;
+    preventSor?: boolean;
+    updateTime?: number;
+    accountType?: string;
+    balances?: {
+        asset: string;
+        free: string;
+        locked: string;
+    } [];
+    permissions?: string[];
+    uid?: number;
+    symbol?: string;
+    orderId?: number;
+    orderListId?: number;
+    clientOrderId?: string;
+    transactTime?: number;
+    price?: string;
+    origQty?: string;
+    executedQty?: string;
+    origQuoteOrderQty?: string;
+    cummulativeQuoteQty?: string;
+    status?: BinanceOrderStatus;
+    timeInForce?: BinanceTimeInForce;
+    type?: BinanceOrderType;
+    side?: BinanceOrderSide;
+    workingTime?: number;
+    fills?: {
+        qty: string;
+        price: string;
+        tradeId: number;
+        commission: string;
+        commissionAsset: string;
+    }[];
+    selfTradePreventionMode?: string;
+}
+
+export interface BinanceAccountResponse {
+    makerCommission: number;
+    takerCommission: number;
+    buyerCommission: number;
+    sellerCommission: number;
+    commissionRates: {
+        maker: number;
+        taker: number;
+        buyer: number;
+        seller: number;
+    };
+    canTrade: boolean;
+    canWithdraw: boolean;
+    canDeposit: boolean;
+    brokered: boolean;
+    requireSelfTradePrevention: boolean;
+    preventSor: boolean;
+    updateTime: number;
+    accountType: string;
+    balances: {
+        asset: string;
+        free: number;
+        locked: number;
+    }[];
+    permissions: string[];
+    uid: number;
+}
+
+export interface BinanceOrder {
+    symbol: string;
+    orderId: number;
+    orderListId: number;
+    clientOrderId: string;
+    transactTime: number;
+    price: number;
+    origQty: number;
+    executedQty: number;
+    origQuoteOrderQty: number;
+    cummulativeQuoteQty: number;
+    status: BinanceOrderStatus;
+    timeInForce: BinanceTimeInForce;
+    type: BinanceOrderType;
+    side: BinanceOrderSide;
+    workingTime: number;
+    fills: {
+        qty: number;
+        price: number;
+        tradeId: number;
+        commission: number;
+        commissionAsset: string;
+    }[];
+    selfTradePreventionMode: string;
+}
+
+export enum BinanceSymbolStatus {
+    TRADING = 'TRADING',
+    BREAK = 'BREAK',
+    HALT = 'HALT'
+}
+
+export enum BinanceOrderSide {
+    BUY = 'BUY',
+    SELL = 'SELL'
+}
+
+export enum BinanceOrderType {
+    LIMIT = 'LIMIT',
+    MARKET = 'MARKET',
+    STOP_LOSS = 'STOP_LOSS',
+    STOP_LOSS_LIMIT = 'STOP_LOSS_LIMIT',
+    TAKE_PROFIT = 'TAKE_PROFIT',
+    TAKE_PROFIT_LIMIT = 'TAKE_PROFIT_LIMIT',
+    LIMIT_MAKER = 'LIMIT_MAKER'
+}
+
+export enum BinanceTimeInForce {
+    GOOD_TILL_CANCELED = 'GTC',
+    INMEDIATE_OR_CANCEL = 'IOC',
+    FILL_OR_KILL = 'FOK'
+}
+
+export enum BinanceOrderStatus {
+    NEW = 'NEW',
+    FILLED = 'FILLED',
+    CANCELED = 'CANCELED',
+    PARTIALLY_FILLED = 'PARTIALLY_FILLED'
+}
+
+export enum BinanceCancelRestrictions {
+    ONLY_NEW = 'ONLY_NEW',
+    ONLY_PARTIALLY_FILLED = 'ONLY_PARTIALLY_FILLED'
+}

package/src/binance/connection/BinanceOperationConnection.ts

@@ -0,0 +1,122 @@
+import { RequestAxiosCall } from "itrm-tools";
+import { BinanceConfig, BinanceConnection } from "../BinanceConnection";
+import { BinanceCancelRestrictions, BinanceOrder, BinanceOrderSide, BinanceOrderType, BinanceParams, BinanceResponse, BinanceSymbolStatus, BinanceTimeInForce } from "../BinanceTypes";
+
+export interface BinanceBookTicker {
+    symbol: string;
+    bidPrice: number;
+    bidQty: number;
+    askPrice: number;
+    askQty: number;
+}
+
+export class BinanceOperationConnection extends BinanceConnection {
+    constructor(config: BinanceConfig) {
+        super(config);
+    }
+
+    public async getBookTicker(symbols: string[]) {
+        const url = `${this.config.baseUrl}/api/v3/ticker/bookTicker?symbols=${JSON.stringify(symbols)}`;
+        let response = await RequestAxiosCall.get<{ symbol: string; bidPrice: string; bidQty: string; askPrice: string; askQty: string; }[]>(url);
+        let result: BinanceBookTicker[] = [];
+        for (let value of response)
+            result.push({
+                symbol: value.symbol,
+                askPrice: parseFloat(value.askPrice),
+                askQty: parseFloat(value.askQty),
+                bidPrice: parseFloat(value.bidPrice),
+                bidQty: parseFloat(value.bidQty)
+            });
+        return result;
+    }
+
+    public async createOrder(params: {
+        symbol: string;
+        side: BinanceOrderSide;
+        type: BinanceOrderType;
+        timeInForce: BinanceTimeInForce;
+        quantity?: number;
+        quoteOrderQty?: number;
+        price?: number;
+        recvWindow?: number;
+    }): Promise<BinanceOrder> {
+        let response = await this.sendPostRequest('/api/v3/order', params);
+        return this.parseOrder(response);
+    }
+
+    private parseOrder(response: BinanceResponse) {
+        return {
+            symbol: response.symbol!,
+            orderId: response.orderId!,
+            orderListId: response.orderListId!,
+            clientOrderId: response.clientOrderId!,
+            transactTime: response.transactTime!,
+            price: parseFloat(response.price!),
+            origQty: parseFloat(response.origQty!),
+            executedQty: parseFloat(response.executedQty!),
+            origQuoteOrderQty: parseFloat(response.origQuoteOrderQty!),
+            cummulativeQuoteQty: parseFloat(response.cummulativeQuoteQty!),
+            status: response.status!,
+            timeInForce: response.timeInForce!,
+            type: response.type!,
+            side: response.side!,
+            workingTime: response.workingTime!,
+            fills: response.fills ? this.parseOrderFills(response.fills!) : [],
+            selfTradePreventionMode: response.selfTradePreventionMode!
+        };
+    }
+    
+    private parseOrderFills(fills: { qty: string; price: string; tradeId: number; commission: string; commissionAsset: string; }[]): { qty: number; price: number; tradeId: number; commission: number; commissionAsset: string; }[] {
+        let result = [];
+        for (let fill of fills)
+            result.push({
+                qty: parseFloat(fill.qty),
+                price: parseFloat(fill.price),
+                tradeId: fill.tradeId,
+                commission: parseFloat(fill.commission),
+                commissionAsset: fill.commissionAsset
+            });
+        return result;
+    }
+
+    public async cancelOrder(params: {
+        symbol: string;
+        orderId?: number;
+        origClientOrderId?: string;
+        newClientOrderId?: string;
+        cancelRestrictions?: BinanceCancelRestrictions;
+        recvWindow?: number
+    }) {
+        let response = await this.sendDeleteRequest('/api/v3/order', params);
+        return this.parseOrder(response);
+    }
+
+    public async getOrder(params: {
+        symbol: string;
+        orderId?: number;
+        origClientOrderId?: string;
+        recvWindow?: number;
+    }) {
+        let response = await this.sendGetRequest('/api/v3/order', params);
+        return this.parseOrder(response);
+    }
+
+    public async getOpenOrders(params: { symbol?: string; recvWindow?: number }) {
+        let response = (await this.sendGetRequest('/api/v3/openOrders', params) as BinanceResponse[]);
+        let result = [];
+        for (let order of response)
+            result.push(this.parseOrder(order));
+        return result;
+    }
+
+    public async transferToSubaccountOfSameMaster(params: {
+        toEmail: string;
+        asset: string;
+        amount: number;
+        recvWindow?: number;
+    }) {
+        //const signature = CryptoJS.HmacSHA256(queryString, SUB_ACCOUNT_SECRET).toString();
+        let response = (await this.sendSapiPostRequest('/sapi/v1/sub-account/transfer/subToSub', params));
+        return response;
+    }
+}

package/src/binance/connection/BinanceRfqConnection.ts

@@ -0,0 +1 @@
+export class BinanceRfqConnection {}

package/src/cetus/CetusStrategyApiConnection.ts

@@ -0,0 +1,30 @@
+import { ExternalApiConnection, RequestMethod, StandardKeyGroup } from "itrm-tools";
+
+export interface CetusStrategy {
+    id: number;
+    name: string;
+    settings: any;
+    memory: any;
+    account: string;
+    pair: string;
+    intermediary: string;
+    status: string;
+}
+
+export enum StrategyStatus {
+    RUNNING = "RUNNING",
+    BUY_ONLY = "BUY_ONLY",
+    SELL_ONLY = "SELL_ONLY",
+    STOPPED = "STOPPED"
+}
+
+export class CetusStrategyApiConnection extends ExternalApiConnection {
+    constructor(apiUrl: string, keys: StandardKeyGroup) {
+        super("cetus", apiUrl, keys);
+    }
+
+    public async getStrategies(params: { name: string; pair: string; account: string }) {
+        const queryString = new URLSearchParams(params as any).toString();
+        return this.request<CetusStrategy[]>(RequestMethod.GET, `/v1/strategies?${queryString}`);
+    }
+}

package/src/index.ts

@@ -0,0 +1,6 @@
+export { BinanceApiSigner as BinanceApiSigner } from './binance/BinanceApiSigner';
+export { BinanceConnection as BinanceConnection } from './binance/BinanceConnection';
+export { BinanceOperationConnection as BinanceOperationConnection } from './binance/connection/BinanceOperationConnection';
+export { BinanceParams as BinanceParams, BinanceResponse as BinanceResponse, BinanceAccountResponse as BinanceAccountResponse, BinanceSymbolStatus as BinanceSymbolStatus, BinanceOrderSide as BinanceOrderSide, BinanceOrderType as BinanceOrderType, BinanceTimeInForce as BinanceTimeInForce, BinanceOrder as BinanceOrder, BinanceOrderStatus as BinanceOrderStatus, BinanceCancelRestrictions as BinanceCancelRestrictions } from './binance/BinanceTypes';
+
+export { CetusStrategyApiConnection as CetusStrategyApiConnection, CetusStrategy as CetusStrategy, StrategyStatus as StrategyStatus } from './cetus/CetusStrategyApiConnection';