@decibeltrade/sdk 0.1.1

package/dist/write.js

@@ -0,0 +1,485 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecibelWriteDex = exports.TimeInForce = void 0;
+const base_1 = require("./base");
+const order_status_1 = require("./order-status");
+const subaccount_types_1 = require("./subaccount-types");
+const utils_1 = require("./utils");
+exports.TimeInForce = {
+    GoodTillCanceled: 0,
+    PostOnly: 1,
+    ImmediateOrCancel: 2,
+};
+/**
+ * Rounds price to the nearest tick size multiple
+ * @param price The price to round
+ * @param tickSize The market's tick size
+ * @returns Price rounded to nearest tick size multiple
+ */
+function roundToTickSize(price, tickSize) {
+    if (price === 0 || tickSize === 0)
+        return 0;
+    return Math.round(price / tickSize) * tickSize;
+}
+class DecibelWriteDex extends base_1.BaseSDK {
+    cache;
+    orderStatusClient;
+    constructor(config, account, opts) {
+        super(config, account, opts);
+        this.cache = {};
+        this.orderStatusClient = new order_status_1.OrderStatusClient(config);
+    }
+    /**
+     * Extract order_id from OrderEvent in transaction response
+     */
+    extractOrderIdFromTransaction(txResponse, subaccountAddr) {
+        const orderEvents = ["market_types::OrderEvent", "async_matching_engine::TwapEvent"];
+        try {
+            // Check if the response is a UserTransactionResponse with events
+            if ("events" in txResponse && Array.isArray(txResponse.events)) {
+                for (const event of txResponse.events) {
+                    // Check if this is an OrderEvent from the market module
+                    for (const orderEvent of orderEvents) {
+                        if (event.type.includes(orderEvent)) {
+                            const orderEvent = event.data;
+                            // Verify the event's user field matches the subaccount placing the order
+                            const userAddress = subaccountAddr ?? this.account.accountAddress;
+                            const orderUserAddress = orderEvent.user;
+                            const twapUserAddress = orderEvent.account;
+                            if (orderUserAddress === userAddress || twapUserAddress === userAddress) {
+                                return typeof orderEvent.order_id === "string"
+                                    ? orderEvent.order_id
+                                    : orderEvent.order_id.order_id;
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            console.error("Error extracting order_id from transaction:", error);
+            return null;
+        }
+    }
+    async renameSubaccount({ subaccountAddress, newName }) {
+        return await (0, utils_1.postRequest)({
+            schema: subaccount_types_1.RenameSubaccountSchema,
+            url: `${this.config.tradingHttpUrl}/api/v1/subaccounts/${subaccountAddress}`,
+            body: { name: newName },
+        });
+    }
+    async createSubaccount() {
+        return await this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::create_new_subaccount`,
+            typeArguments: [],
+            functionArguments: [],
+        });
+    }
+    async sendSubaccountTx(sendTx, subaccountAddr) {
+        if (!subaccountAddr) {
+            subaccountAddr = (0, utils_1.getPrimarySubaccountAddr)(this.account.accountAddress);
+        }
+        return await sendTx(subaccountAddr);
+    }
+    async withSubaccount(fn, subaccountAddr) {
+        if (!subaccountAddr) {
+            subaccountAddr = (0, utils_1.getPrimarySubaccountAddr)(this.account.accountAddress);
+        }
+        return await fn(subaccountAddr);
+    }
+    /**
+     * @param amount u64 amount of collateral to deposit
+     */
+    async deposit(amount, subaccountAddr) {
+        if (!subaccountAddr) {
+            return await this.sendTx({
+                function: `${this.config.deployment.package}::dex_accounts::deposit_to_subaccount`,
+                typeArguments: [],
+                functionArguments: [this.config.deployment.usdc, amount],
+            });
+        }
+        else {
+            return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+                function: `${this.config.deployment.package}::dex_accounts::deposit_to_subaccount_at`,
+                typeArguments: [],
+                functionArguments: [subaccountAddr, this.config.deployment.usdc, amount],
+            }), subaccountAddr);
+        }
+    }
+    /**
+     * @param amount u64 amount of collateral to withdraw
+     */
+    async withdraw(amount, subaccountAddr) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::withdraw_from_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, this.config.deployment.usdc, amount],
+        }), subaccountAddr);
+    }
+    async configureUserSettingsForMarket({ marketAddr, subaccountAddr, isCross, userLeverage, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::configure_user_settings_for_market`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, marketAddr, isCross, userLeverage],
+        }), subaccountAddr);
+    }
+    async placeOrder({ marketName, price, size, isBuy, timeInForce, isReduceOnly, clientOrderId, stopPrice, tpTriggerPrice, tpLimitPrice, slTriggerPrice, slLimitPrice, builderAddr, builderFee, subaccountAddr, accountOverride, tickSize, }) {
+        try {
+            const marketAddr = (0, utils_1.getMarketAddr)(marketName, this.config.deployment.perpEngineGlobal);
+            // Apply tick size rounding if tickSize is provided
+            const roundedPrice = tickSize ? roundToTickSize(price, tickSize) : price;
+            const roundedStopPrice = stopPrice !== undefined && tickSize ? roundToTickSize(stopPrice, tickSize) : stopPrice;
+            const roundedTpTriggerPrice = tpTriggerPrice !== undefined && tickSize
+                ? roundToTickSize(tpTriggerPrice, tickSize)
+                : tpTriggerPrice;
+            const roundedTpLimitPrice = tpLimitPrice !== undefined && tickSize
+                ? roundToTickSize(tpLimitPrice, tickSize)
+                : tpLimitPrice;
+            const roundedSlTriggerPrice = slTriggerPrice !== undefined && tickSize
+                ? roundToTickSize(slTriggerPrice, tickSize)
+                : slTriggerPrice;
+            const roundedSlLimitPrice = slLimitPrice !== undefined && tickSize
+                ? roundToTickSize(slLimitPrice, tickSize)
+                : slLimitPrice;
+            const txResponse = await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+                function: `${this.config.deployment.package}::dex_accounts::place_order_to_subaccount`,
+                typeArguments: [],
+                functionArguments: [
+                    subaccountAddr,
+                    marketAddr.toString(),
+                    roundedPrice,
+                    size,
+                    isBuy,
+                    timeInForce,
+                    isReduceOnly,
+                    clientOrderId,
+                    roundedStopPrice,
+                    roundedTpTriggerPrice,
+                    roundedTpLimitPrice,
+                    roundedSlTriggerPrice,
+                    roundedSlLimitPrice,
+                    builderAddr,
+                    builderFee,
+                ],
+            }, accountOverride), subaccountAddr);
+            // Extract order_id from the transaction events
+            const orderId = this.extractOrderIdFromTransaction(txResponse, subaccountAddr);
+            return {
+                success: true,
+                orderId: orderId || undefined,
+                transactionHash: txResponse.hash,
+            };
+        }
+        catch (error) {
+            console.error("Error placing order:", error);
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : "Unknown error",
+            };
+        }
+    }
+    async triggerMatching({ marketAddr, maxWorkUnit }) {
+        const txResponse = await this.sendTx({
+            function: `${this.config.deployment.package}::public_apis::trigger_matching`,
+            typeArguments: [],
+            functionArguments: [marketAddr, maxWorkUnit],
+        });
+        return {
+            success: true,
+            transactionHash: txResponse.hash,
+        };
+    }
+    async placeTwapOrder({ marketName, size, isBuy, isReduceOnly, twapFrequencySeconds, twapDurationSeconds, builderAddress, builderFees, subaccountAddr, accountOverride, }) {
+        const marketAddr = (0, utils_1.getMarketAddr)(marketName, this.config.deployment.perpEngineGlobal);
+        const txResponse = await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::place_twap_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [
+                subaccountAddr,
+                marketAddr.toString(),
+                size,
+                isBuy,
+                isReduceOnly,
+                twapFrequencySeconds,
+                twapDurationSeconds,
+                builderAddress,
+                builderFees,
+            ],
+        }, accountOverride), subaccountAddr);
+        const orderId = this.extractOrderIdFromTransaction(txResponse, subaccountAddr);
+        return {
+            success: true,
+            orderId: orderId || undefined,
+            transactionHash: txResponse.hash,
+        };
+    }
+    /**
+     * Cancel an order on the exchange
+     * @param orderId The id of the order to cancel
+     * @param marketId The id of the market the order is in
+     * @param subaccountAddr Optional subaccount address, will use primary if not provided
+     * @returns Transaction response
+     */
+    async cancelOrder({ orderId, subaccountAddr, accountOverride, ...args }) {
+        // Either marketName or marketAddr must be provided
+        const marketAddr = "marketName" in args
+            ? (0, utils_1.getMarketAddr)(args.marketName, this.config.deployment.perpEngineGlobal)
+            : args.marketAddr;
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::cancel_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, BigInt(orderId.toString()), marketAddr.toString()],
+        }, accountOverride), subaccountAddr);
+    }
+    async cancelClientOrder({ clientOrderId, marketName, subaccountAddr, accountOverride, }) {
+        const marketAddr = (0, utils_1.getMarketAddr)(marketName, this.config.deployment.perpEngineGlobal);
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::cancel_client_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, clientOrderId, marketAddr.toString()],
+        }, accountOverride), subaccountAddr);
+    }
+    async delegateTradingTo({ subaccountAddr, accountToDelegateTo, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::delegate_trading_to`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, accountToDelegateTo],
+        }), subaccountAddr);
+    }
+    async revokeDelegation({ subaccountAddr, accountToRevoke, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::revoke_delegation`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, accountToRevoke],
+        }), subaccountAddr);
+    }
+    /**
+     * Place a TP/SL order for a position
+     */
+    async placeTpSlOrderForPosition({ marketAddr, tpTriggerPrice, tpLimitPrice, tpSize, slTriggerPrice, slLimitPrice, slSize, subaccountAddr, accountOverride, tickSize, }) {
+        const roundedTpTriggerPrice = tpTriggerPrice !== undefined && tickSize
+            ? roundToTickSize(tpTriggerPrice, tickSize)
+            : tpTriggerPrice;
+        const roundedTpLimitPrice = tpLimitPrice !== undefined && tickSize
+            ? roundToTickSize(tpLimitPrice, tickSize)
+            : tpLimitPrice;
+        const roundedSlTriggerPrice = slTriggerPrice !== undefined && tickSize
+            ? roundToTickSize(slTriggerPrice, tickSize)
+            : slTriggerPrice;
+        const roundedSlLimitPrice = slLimitPrice !== undefined && tickSize
+            ? roundToTickSize(slLimitPrice, tickSize)
+            : slLimitPrice;
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::place_tp_sl_order_for_position`,
+            typeArguments: [],
+            functionArguments: [
+                subaccountAddr,
+                marketAddr,
+                roundedTpTriggerPrice,
+                roundedTpLimitPrice,
+                tpSize,
+                roundedSlTriggerPrice,
+                roundedSlLimitPrice,
+                slSize,
+                undefined, // builderAddr
+                undefined, // builderFees
+            ],
+        }, accountOverride), subaccountAddr);
+    }
+    /**
+     * Update TP for a position
+     */
+    async updateTpOrderForPosition({ marketAddr, prevOrderId, tpTriggerPrice, tpLimitPrice, tpSize, subaccountAddr, accountOverride, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::update_tp_order_for_position`,
+            typeArguments: [],
+            functionArguments: [
+                subaccountAddr,
+                BigInt(prevOrderId.toString()),
+                marketAddr,
+                tpTriggerPrice,
+                tpLimitPrice,
+                tpSize,
+            ],
+        }, accountOverride), subaccountAddr);
+    }
+    /**
+     * Update SL for a position
+     */
+    async updateSlOrderForPosition({ marketAddr, prevOrderId, slTriggerPrice, slLimitPrice, slSize, subaccountAddr, accountOverride, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::update_sl_order_for_position`,
+            typeArguments: [],
+            functionArguments: [
+                subaccountAddr,
+                BigInt(prevOrderId.toString()),
+                marketAddr,
+                slTriggerPrice,
+                slLimitPrice,
+                slSize,
+            ],
+        }, accountOverride), subaccountAddr);
+    }
+    /**
+     * Cancel a TP/SL order for a position
+     */
+    async cancelTpSlOrderForPosition({ marketAddr, orderId, subaccountAddr, accountOverride, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::cancel_tp_sl_order_for_position`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, marketAddr, BigInt(orderId.toString())],
+        }, accountOverride), subaccountAddr);
+    }
+    async cancelTwapOrder({ orderId, marketAddr, subaccountAddr, accountOverride, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::cancel_twap_orders_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, marketAddr, orderId],
+        }, accountOverride), subaccountAddr);
+    }
+    async buildDeactiveSubaccountTx({ subaccountAddr, revokeAllDelegations = true, signerAddress, }) {
+        const transaction = await this.buildTx({
+            function: `${this.config.deployment.package}::dex_accounts::deactivate_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, revokeAllDelegations],
+        }, signerAddress);
+        return transaction;
+    }
+    // ======= VAULT FUNCTIONS =======
+    // @Todo: We can move this to another Class and this doesnt requires subaccount so dont belong in here
+    /**
+     * Create a new vault with optional initial funding
+     */
+    async buildCreateVaultTx({ contributionAssetType, vaultName, vaultShareSymbol, vaultShareIconUri = "", vaultShareProjectUri = "", feeBps, feeIntervalS, contributionLockupDurationS, initialFunding = 0, acceptsContributions = false, delegateToCreator = false, signerAddress, vaultDescription, vaultSocialLinks, }) {
+        const transaction = await this.buildTx({
+            function: `${this.config.deployment.package}::vault::create_and_fund_vault`,
+            typeArguments: [],
+            functionArguments: [
+                contributionAssetType,
+                vaultName,
+                vaultDescription,
+                vaultSocialLinks,
+                vaultShareSymbol,
+                vaultShareIconUri,
+                vaultShareProjectUri,
+                feeBps,
+                feeIntervalS,
+                contributionLockupDurationS,
+                initialFunding,
+                acceptsContributions,
+                delegateToCreator,
+            ],
+        }, signerAddress);
+        return transaction;
+    }
+    async createVault(args) {
+        const txResponse = await this.sendSubaccountTx(() => this.sendTx({
+            function: `${this.config.deployment.package}::vault::create_and_fund_vault`,
+            typeArguments: [],
+            functionArguments: [
+                args.contributionAssetType,
+                args.vaultName,
+                args.vaultDescription,
+                args.vaultSocialLinks,
+                args.vaultShareSymbol,
+                args.vaultShareIconUri,
+                args.vaultShareProjectUri,
+                args.feeBps,
+                args.feeIntervalS,
+                args.contributionLockupDurationS,
+                args.initialFunding,
+                args.acceptsContributions,
+                args.delegateToCreator,
+            ],
+        }, args.accountOverride), args.subaccountAddr);
+        return txResponse;
+    }
+    /**
+     * Activate a vault to accept contributions
+     */
+    async buildActivateVaultTx({ vaultAddress, additionalFunding = 0, signerAddress, }) {
+        return await this.buildTx({
+            function: `${this.config.deployment.package}::vault::activate_vault`,
+            typeArguments: [],
+            functionArguments: [vaultAddress, additionalFunding],
+        }, signerAddress);
+    }
+    /**
+     * Contribute funds to a vault in exchange for shares
+     */
+    async buildDepositToVaultTx({ vaultAddress, amount, signerAddress, }) {
+        return await this.buildTx({
+            function: `${this.config.deployment.package}::vault::contribute`,
+            typeArguments: [],
+            functionArguments: [vaultAddress, amount],
+        }, signerAddress);
+    }
+    async depositToVault(args) {
+        const txResponse = await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts_vault_extension::contribute_to_vault`,
+            typeArguments: [],
+            functionArguments: [
+                subaccountAddr,
+                args.vaultAddress,
+                this.config.deployment.usdc,
+                args.amount,
+            ],
+        }), args.subaccountAddr);
+        return txResponse;
+    }
+    /**
+     * Redeem shares from a vault for underlying assets
+     */
+    async buildWithdrawFromVaultTx({ vaultAddress, shares, signerAddress, }) {
+        return await this.buildTx({
+            function: `${this.config.deployment.package}::vault::redeem`,
+            typeArguments: [],
+            functionArguments: [vaultAddress, shares],
+        }, signerAddress);
+    }
+    async withdrawFromVault(args) {
+        const txResponse = await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts_vault_extension::redeem_from_vault`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, args.vaultAddress, args.shares],
+        }, args.accountOverride), args.subaccountAddr);
+        return txResponse;
+    }
+    /**
+     * Delegate trading to another account for a vault
+     */
+    async buildDelegateDexActionsToTx({ vaultAddress, accountToDelegateTo, signerAddress, expirationTimestampSecs, }) {
+        return await this.buildTx({
+            function: `${this.config.deployment.package}::vault::delegate_dex_actions_to`,
+            typeArguments: [],
+            functionArguments: [vaultAddress, accountToDelegateTo, expirationTimestampSecs],
+        }, signerAddress);
+    }
+    /**
+     * Approve max builder fee for a subaccount
+     * @param builderAddr The address of the builder
+     * @param maxFee The maximum fee in basis points (e.g., 100 = 0.01%)
+     * @param subaccountAddr Optional subaccount address, will use primary if not provided
+     */
+    async approveMaxBuilderFee({ builderAddr, maxFee, subaccountAddr, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::approve_max_builder_fee_for_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, builderAddr, maxFee],
+        }), subaccountAddr);
+    }
+    /**
+     * Revoke max builder fee for a subaccount
+     * @param builderAddr The address of the builder
+     * @param subaccountAddr Optional subaccount address, will use primary if not provided
+     */
+    async revokeMaxBuilderFee({ builderAddr, subaccountAddr, }) {
+        return await this.sendSubaccountTx((subaccountAddr) => this.sendTx({
+            function: `${this.config.deployment.package}::dex_accounts::revoke_max_builder_fee_for_subaccount`,
+            typeArguments: [],
+            functionArguments: [subaccountAddr, builderAddr],
+        }), subaccountAddr);
+    }
+}
+exports.DecibelWriteDex = DecibelWriteDex;

package/eslint.config.mjs

@@ -0,0 +1,25 @@
+// @ts-check
+
+import { baseConfig } from "@decibeltrade/eslint-config/base";
+import { dirname } from "path";
+import tseslint from "typescript-eslint";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export default tseslint.config(
+  {
+    languageOptions: {
+      parserOptions: {
+        ecmaVersion: "latest",
+        sourceType: "module",
+        projectService: {
+          allowDefaultProject: ["*.mjs"],
+        },
+        tsconfigRootDir: __dirname,
+      },
+    },
+  },
+  baseConfig,
+);

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@decibeltrade/sdk",
+  "version": "0.1.1",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run --passWithNoTests",
+    "lint": "eslint src --fix --max-warnings 0",
+    "lint:check": "eslint src --max-warnings 0",
+    "generate:abis": "tsx src/abi/generate-abis.ts"
+  },
+  "dependencies": {
+    "isomorphic-ws": "^5.0.0",
+    "ws": "^8.18.1"
+  },
+  "peerDependencies": {
+    "@aptos-labs/ts-sdk": "^5.1.2",
+    "@types/ws": "^8.18.0",
+    "zod": "^3.25.62"
+  },
+  "devDependencies": {
+    "@decibeltrade/eslint-config": "workspace:*",
+    "@decibeltrade/tsconfig": "workspace:*",
+    "@types/estree": "^1.0.6",
+    "eslint": "^9.28.0",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.46.2",
+    "tsx": "^4.20.5",
+    "vitest": "^3.1.1"
+  }
+}