@carbon-terminal/trading-sdk 0.2.5

package/dist/modules/trade-manager/index.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TradeManager = void 0;
+const core_1 = require("@carbon-terminal/core");
+const exceptions_1 = require("../../common/exceptions");
+const entities_1 = require("../../entities");
+class TradeManager {
+    constructor(tradingSdk) {
+        this.tradingSdk = tradingSdk;
+    }
+    async getPositionInfo(positionId, chainId) {
+        const response = await this.tradingSdk.get(`/positions/open-request/status?positionId=${positionId}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getOpenPositionsForSubaccount(subaccountAddress, chainId) {
+        const response = await this.tradingSdk.get(`/positions/all?subaccountAddress=${subaccountAddress}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getCloseRequestInfo(closeRequestId, chainId) {
+        const response = await this.tradingSdk.get(`/positions/close-request/status?closeRequestId=${closeRequestId}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async createPosition(params) {
+        let { marketId, subaccountAddress, chainId, positionType, orderType, limitPrice, quantity, deadline, slippage, leverage, solver, useInstantActions, } = params;
+        // Add parameter validation
+        const response = await this.tradingSdk.post("/trade/create-position", {
+            marketId,
+            subaccountAddress,
+            chainId,
+            positionType,
+            orderType,
+            limitPrice: orderType === core_1.OrderType.LIMIT ? limitPrice : null,
+            quantity,
+            leverage,
+            slippage: slippage ?? 0.01,
+            solver,
+            useInstantActions,
+        });
+        if (!response.success) {
+            throw new core_1.OpenPositionError(response.error.message, response.error.code);
+        }
+        const positionEntity = new entities_1.PositionEntity(this.tradingSdk, response.data);
+        return positionEntity;
+    }
+    // first version: only allowing market close
+    // todo: implement limit orders through the transaction relay
+    async closePosition(params) {
+        const response = await this.tradingSdk.post("/trade/close-position", {
+            quoteId: params.quoteId,
+            quantityToClose: params.quantityToClose,
+            chainId: params.chainId,
+            slippage: params.slippage,
+            orderType: params.orderType,
+            useInstantActions: params.useInstantActions,
+        });
+        return new entities_1.CloseRequestEntity(this.tradingSdk, response.data);
+    }
+    async setTpSlForPosition(params) {
+        const timestamp = Math.floor(Date.now() / 1000);
+        const deadline = timestamp + 500;
+        await this.tradingSdk.post("/tpsl/create", {
+            ...params,
+            timestamp,
+            deadline,
+        });
+    }
+    async listTpSlForPositions(chainId, quoteIds) {
+        const response = await this.tradingSdk.post("/tpsl/list", { chainId, quoteIds });
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    async getLockedParameters(chainId, solver, marketName, leverage) {
+        const response = await this.tradingSdk.get(`/solvers/locked-parameters?chainId=${chainId}&solver=${solver}&marketName=${marketName}&leverage=${leverage}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    // Cancel operations
+    async createCancelQuoteRequest(params) {
+        const response = await this.tradingSdk.post("/trade/cancel-quote", params);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return new entities_1.CancelRequestEntity(this.tradingSdk, response.data);
+    }
+    async getCancelQuoteRequestInfo(cancelRequestId, chainId) {
+        const response = await this.tradingSdk.get(`/positions/cancel-request/status?cancelRequestId=${cancelRequestId}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+    // Cancel close request operations
+    async cancelCloseRequest(params) {
+        const response = await this.tradingSdk.post("/trade/cancel-close-request", params);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return new entities_1.CancelCloseRequestEntity(this.tradingSdk, response.data);
+    }
+    async getCancelCloseRequestInfo(cancelRequestId, chainId) {
+        const response = await this.tradingSdk.get(`/positions/cancel-close-request/status?cancelRequestId=${cancelRequestId}&chainId=${chainId}`);
+        if (!response.success) {
+            throw new exceptions_1.APIException({
+                message: response.error?.message,
+                code: response.error?.code,
+                httpStatusCode: response.httpStatusCode,
+            });
+        }
+        return response.data;
+    }
+}
+exports.TradeManager = TradeManager;

package/dist/utils/api/getApiUrl.d.ts

@@ -0,0 +1 @@
+export declare function getApiUrl(): string;

package/dist/utils/api/getApiUrl.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getApiUrl = getApiUrl;
+function getApiUrl() {
+    return process.env.API_URL
+        ? process.env.API_URL + "/v1"
+        : "https://gw.carbon.inc/v1";
+}

package/dist/utils/auth/apiAuth.d.ts

@@ -0,0 +1,5 @@
+export interface AuthCredentials {
+    address: string;
+    token: string;
+}
+export declare function authenticateWithPrivateKey(apiUrl: string, privateKey: string): Promise<AuthCredentials>;

package/dist/utils/auth/apiAuth.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.authenticateWithPrivateKey = authenticateWithPrivateKey;
+const core_1 = require("@carbon-terminal/core");
+const ethers_1 = require("ethers");
+async function authenticateWithPrivateKey(apiUrl, privateKey) {
+    try {
+        // Create wallet from private key
+        const wallet = new ethers_1.ethers.Wallet(privateKey);
+        const address = wallet.address;
+        // Generate typed data for JWT token
+        const typedData = (0, core_1.generateIntentXJWTIssueMessage)(address, [core_1.AllowedScopes.FRONTEND_AUTH], core_1.AllowedExpiration.THIRTY_DAYS);
+        // Sign typed data
+        const signature = await wallet.signTypedData(typedData.domain, typedData.types, typedData.message);
+        // Get JWT token
+        const token = await (0, core_1.issueIntentXJWTToken)(typedData, signature);
+        return { address, token };
+    }
+    catch (error) {
+        console.error("Error:", error.response?.data || error.message);
+        throw error;
+    }
+}

package/dist/utils/auth/siweAuth.d.ts

@@ -0,0 +1,20 @@
+import { AvailableSolvers, SupportedChainId } from "@carbon-terminal/core";
+export declare function siweGetNonce(subaccountAddress: string, chainId: SupportedChainId, solver: AvailableSolvers): Promise<string>;
+export declare function createSiweSignatureWithPrivateKey(subaccountAddress: string, chainId: SupportedChainId, solver: AvailableSolvers, privateKey: string): Promise<{
+    expirationTime: string;
+    issuedAt: string;
+    message: string;
+    signature: string;
+    nonce: string;
+}>;
+export declare function siweGetAccessToken(subaccountAddress: string, chainId: SupportedChainId, solver: AvailableSolvers, { expirationTime, issuedAt, signature, nonce, }: {
+    expirationTime: string;
+    issuedAt: string;
+    signature: string;
+    nonce: string;
+}): Promise<string>;
+export declare function createSiweMessage(address: string, statement: string, chainId: number, nonce: string, domain: string, uri: string, expirationSeconds?: number, version?: string): {
+    message: string;
+    issuedAt: string;
+    expirationTime: string;
+};

package/dist/utils/auth/siweAuth.js

@@ -0,0 +1,106 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.siweGetNonce = siweGetNonce;
+exports.createSiweSignatureWithPrivateKey = createSiweSignatureWithPrivateKey;
+exports.siweGetAccessToken = siweGetAccessToken;
+exports.createSiweMessage = createSiweMessage;
+const core_1 = require("@carbon-terminal/core");
+const axios_1 = __importDefault(require("axios"));
+const ethers_1 = require("ethers");
+const siwe_1 = require("siwe");
+async function siweGetNonce(subaccountAddress, chainId, solver) {
+    const parsedSubaccountAddress = (0, ethers_1.getAddress)(subaccountAddress);
+    const solverBaseUrl = (0, core_1.getSolverBaseUrl)(solver, chainId);
+    const url = `${solverBaseUrl.http}nonce/${parsedSubaccountAddress}`;
+    try {
+        const response = await axios_1.default.get(url, {
+            headers: {
+                "Content-Type": "application/json",
+                Referer: "https://app.intentx.io/",
+            },
+        });
+        const data = response.data;
+        if (!data.nonce) {
+            throw new Error("No nonce found");
+        }
+        return data.nonce;
+    }
+    catch (error) {
+        console.error("Error fetching nonce:");
+        if (error.response) {
+            // The request was made and the server responded with a status code
+            // that falls out of the range of 2xx
+            console.error("Response data:", error.response.data);
+            console.error("Response status:", error.response.status);
+        }
+        else if (error.request) {
+            // The request was made but no response was received
+            console.error("No response received:", error.request);
+        }
+        else {
+            // Something happened in setting up the request that triggered an Error
+            console.error("Error message:", error.message);
+        }
+        throw error;
+    }
+}
+async function createSiweSignatureWithPrivateKey(subaccountAddress, chainId, solver, privateKey) {
+    const parsedSubaccountAddress = (0, ethers_1.getAddress)(subaccountAddress);
+    const nonce = await siweGetNonce(parsedSubaccountAddress, chainId, solver);
+    // const TESTING_PRIVATE_KEY = process.env.TESTING_ACCOUNT_PRIVATE_KEY;
+    const wallet = new ethers_1.ethers.Wallet(privateKey);
+    const userAddress = wallet.address;
+    const solverBaseUrl = (0, core_1.getSolverBaseUrl)(solver, chainId);
+    const { expirationTime, issuedAt, message } = createSiweMessage(userAddress, `msg: ${parsedSubaccountAddress}`, chainId, nonce, 
+    // host,
+    "app.intentx.io", `${solverBaseUrl?.http}login`);
+    const signature = await wallet.signMessage(message);
+    return { expirationTime, issuedAt, message, signature, nonce };
+}
+async function siweGetAccessToken(subaccountAddress, chainId, solver, { expirationTime, issuedAt, signature, nonce, }) {
+    const parsedSubaccountAddress = (0, ethers_1.getAddress)(subaccountAddress);
+    const solverBaseUrl = (0, core_1.getSolverBaseUrl)(solver, chainId);
+    try {
+        const { data } = await axios_1.default.post(`${solverBaseUrl.http}login`, {
+            account_address: parsedSubaccountAddress,
+            expiration_time: expirationTime,
+            issued_at: issuedAt,
+            signature,
+            nonce,
+        }, {
+            headers: {
+                "Content-Type": "application/json",
+                Referer: "https://app.intentx.io/",
+                Origin: "https://app.intentx.io/",
+            },
+        });
+        if (!data.access_token) {
+            throw new Error("No access token received");
+        }
+        return data.access_token;
+    }
+    catch (error) {
+        console.error("SIWE login error:", error.response?.data || error.message);
+        throw error;
+    }
+}
+function createSiweMessage(address, statement, chainId, nonce, domain, uri, expirationSeconds = 60 * 60 * 24, version = "1") {
+    const issuedAt = new Date().toISOString();
+    const expirationTime = new Date(Date.now() + expirationSeconds * 1000).toISOString();
+    const parsedAddress = (0, ethers_1.getAddress)(address);
+    const message = new siwe_1.SiweMessage({
+        domain,
+        address: parsedAddress,
+        statement,
+        chainId,
+        nonce,
+        version,
+        uri,
+        issuedAt,
+        expirationTime,
+    });
+    return { message: message.prepareMessage(), issuedAt, expirationTime };
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@carbon-terminal/trading-sdk",
+  "version": "0.2.5",
+  "description": "This SDK is used to interact with the IntentX Trading API.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./dist/*": {
+      "types": "./dist/*.d.ts",
+      "default": "./dist/*.js"
+    }
+  },
+  "scripts": {
+    "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
+    "dev": "tsc -w",
+    "test": "echo 'no test yet'",
+    "example": "ts-node -r tsconfig-paths/register",
+    "build-publish": "npm run build && npm publish --access public"
+  },
+  "dependencies": {
+    "@carbon-terminal/core": "^1.0.0",
+    "axios": "^1.6.2",
+    "decimal.js": "^10.4.3",
+    "jsonwebtoken": "^9.0.2",
+    "siwe": "^3.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.10.4",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
+    "typescript": "^5.3.3"
+  },
+  "author": "",
+  "license": "ISC",
+  "directories": {
+    "doc": "docs"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}