@raintree-technology/perps 0.1.3 → 0.1.4

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.4] - 2026-02-26
+
+### Added
+- Expanded advanced `order` command surface with direct adapter-backed workflows, including batch placement/cancel, cancel-all-after, MMP, TWAP, isolated margin adjustment, and read commands (`get`, `open`, `trades`, `position`, `history`, `funding-history`, `public-trades`).
+- Added first-class `markets` read commands for `get`, `ticker`, `tickers`, `funding-rate`, and `funding-rates`.
+- Added Decibel REST auth-header regression tests and websocket protocol coverage tests.
+- Added `specs/perp-parity/*` and `scripts/ops/ralph-perp-parity-loop.sh` to support systematic exchange parity execution loops.
+
+### Changed
+- Updated Decibel, Hyperliquid, Aevo, Orderly, and Paradex adapter/command parity wiring to expose only direct, capability-backed behavior.
+- Updated docs and operator guidance (`README`, `CAPABILITIES`, exchange docs, release notes) to match the current command surface and Decibel auth behavior.
+- Updated website static endpoint delivery to use `public/` assets and refreshed marketing shell components.
+
+### Fixed
+- Fixed Decibel REST auth semantics so Authorization headers are only attached where required and aligned `trades` endpoint handling with authenticated API behavior.
+- Restored command registration and test coverage for newly added `order` and `markets` subcommands.
+
 ## [0.1.2] - 2026-02-26
 
 ### Added
@@ -71,7 +88,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Risk management: limits, drawdown, position sizing
 - Execution journal and safety checks
 
-[Unreleased]: https://github.com/raintree-technology/perps/compare/v0.1.2...HEAD
+[Unreleased]: https://github.com/raintree-technology/perps/compare/v0.1.4...HEAD
+[0.1.4]: https://github.com/raintree-technology/perps/releases/tag/v0.1.4
 [0.1.2]: https://github.com/raintree-technology/perps/releases/tag/v0.1.2
 [0.1.1]: https://github.com/raintree-technology/perps/releases/tag/v0.1.1
 [0.1.0]: https://github.com/raintree-technology/perps/releases/tag/v0.1.0

package/README.md

@@ -133,8 +133,8 @@ See **[CAPABILITIES.md](CAPABILITIES.md)** for the full reference — every comm
 ## Command Surface
 
 ```bash
-perps markets ls --help       # List markets with funding, OI, volume
-perps order --help            # Place orders (market, limit, stop, take-profit)
+perps markets --help          # Market data + read commands (ls/get/ticker/tickers/funding-rate/funding-rates)
+perps order --help            # Order lifecycle + advanced reads (get/open/trades/position/history/public-trades)
 perps arb --help              # Cross-exchange arbitrage
 perps account --help          # Portfolio (positions, balances)
 perps agent --help            # HTTP agent gateway
@@ -152,6 +152,16 @@ perps doctor                  # Health check
 
 Every command supports `--json` for machine-readable output and `--help` for usage details.
 
+Advanced order commands are feature-gated per exchange and exposed directly when supported:
+
+```bash
+perps order batch-place --help
+perps order batch-cancel --help
+perps order cancel-all-after --help
+perps order mmp --help
+perps order twap --help
+```
+
 Agent-friendly mode:
 
 ```bash

package/dist/adapters/aevo.d.ts

@@ -5,7 +5,7 @@
  * API Docs: https://docs.aevo.xyz/
  * Base URL: https://api.aevo.xyz
  */
-import { type PerpDEXAdapter, type ExchangeInfo, type ExchangeConfig, type Market, type Ticker, type OrderBook, type FundingRate, type Position, type Order, type Balance, type Trade, type OrderParams, type CancelOrderParams, type ModifyOrderParams, type FundingPayment, type PublicTrade, type SubscriptionCallbacks, type Unsubscribe, type MarginType, type MMPConfig, type MMPStatus, type TWAPParams, type TWAPStatus } from "./interface.js";
+import { type PerpDEXAdapter, type ExchangeInfo, type ExchangeConfig, type Market, type Ticker, type OrderBook, type FundingRate, type Position, type Order, type Balance, type Trade, type OrderParams, type CancelOrderParams, type ModifyOrderParams, type FundingPayment, type PublicTrade, type SubscriptionCallbacks, type Unsubscribe, type MarginType, type MMPConfig, type MMPStatus } from "./interface.js";
 export declare class AevoAdapter implements PerpDEXAdapter {
     readonly info: ExchangeInfo;
     private baseUrl;
@@ -41,17 +41,12 @@ export declare class AevoAdapter implements PerpDEXAdapter {
     modifyOrder(params: ModifyOrderParams): Promise<Order>;
     batchPlaceOrders(paramsList: OrderParams[]): Promise<Order[]>;
     batchCancelOrders(paramsList: CancelOrderParams[]): Promise<boolean[]>;
-    cancelAllAfter(_timeoutMs: number): Promise<void>;
     getOrderHistory(market?: string, limit?: number): Promise<Order[]>;
     getFundingHistory(market?: string, limit?: number): Promise<FundingPayment[]>;
     getPublicTrades(market: string, limit?: number): Promise<PublicTrade[]>;
     setMMP(config: MMPConfig): Promise<void>;
     getMMP(market: string): Promise<MMPStatus>;
     resetMMP(market: string): Promise<void>;
-    placeTWAP(_params: TWAPParams): Promise<TWAPStatus>;
-    cancelTWAP(_twapId: string): Promise<boolean>;
-    getTWAPStatus(_twapId: string): Promise<TWAPStatus | null>;
-    updateIsolatedMargin(_market: string, _amount: string): Promise<void>;
     subscribe(callbacks: SubscriptionCallbacks): Unsubscribe;
     subscribeOrderBook(market: string, callback: (book: OrderBook) => void): Unsubscribe;
     subscribeTicker(market: string, callback: (ticker: Ticker) => void): Unsubscribe;

package/dist/adapters/aevo.js

@@ -641,9 +641,6 @@ export class AevoAdapter {
         }
         return results;
     }
-    async cancelAllAfter(_timeoutMs) {
-        throw new Error("Aevo does not support cancelAllAfter (dead man's switch)");
-    }
     async getOrderHistory(market, limit = 100) {
         this.ensureAuth();
         const query = new URLSearchParams();
@@ -731,24 +728,6 @@ export class AevoAdapter {
         });
     }
     // --------------------------------------------------------------------------
-    // TWAP Orders
-    // --------------------------------------------------------------------------
-    async placeTWAP(_params) {
-        throw new Error("Aevo TWAP orders are not supported through this adapter");
-    }
-    async cancelTWAP(_twapId) {
-        throw new Error("Aevo TWAP orders are not supported through this adapter");
-    }
-    async getTWAPStatus(_twapId) {
-        throw new Error("Aevo TWAP orders are not supported through this adapter");
-    }
-    // --------------------------------------------------------------------------
-    // Margin Management
-    // --------------------------------------------------------------------------
-    async updateIsolatedMargin(_market, _amount) {
-        throw new Error("Aevo does not support isolated margin adjustment");
-    }
-    // --------------------------------------------------------------------------
     // Subscriptions (polling)
     // --------------------------------------------------------------------------
     subscribe(callbacks) {

package/dist/adapters/certification.js

@@ -10,12 +10,57 @@ const CAPABILITY_CATEGORIES = [
     "advancedTrading",
 ];
 const CATEGORY_METHODS = {
-    marketData: ["getMarkets", "getTicker", "getOrderBook", "getFundingRate", "getPublicTrades"],
-    authenticatedReads: ["getPositions", "getOrders", "getBalances", "getTrades", "getOrderHistory", "getFundingHistory"],
-    orderLifecycle: ["placeOrder", "getOrder", "getOrders", "modifyOrder"],
-    orderCancellation: ["cancelOrder", "cancelAllOrders", "cancelAllAfter"],
-    subscriptions: ["subscribe", "subscribeOrderBook", "subscribeTicker"],
-    advancedTrading: ["modifyOrder", "batchPlaceOrders", "batchCancelOrders", "cancelAllAfter", "getOrderHistory", "getFundingHistory", "getPublicTrades", "setMMP", "getMMP", "resetMMP", "placeTWAP", "cancelTWAP", "getTWAPStatus", "updateIsolatedMargin"],
+    marketData: [
+        { method: "getMarkets" },
+        { method: "getTicker" },
+        { method: "getOrderBook" },
+        { method: "getFundingRate" },
+        { method: "getPublicTrades", when: (adapter) => adapter.info.features.publicTrades },
+    ],
+    authenticatedReads: [
+        { method: "getPositions" },
+        { method: "getOrders" },
+        { method: "getBalances" },
+        { method: "getTrades" },
+        { method: "getOrderHistory", when: (adapter) => adapter.info.features.orderHistory },
+        { method: "getFundingHistory", when: (adapter) => adapter.info.features.fundingHistory },
+    ],
+    orderLifecycle: [
+        { method: "placeOrder" },
+        { method: "getOrder" },
+        { method: "getOrders" },
+        { method: "modifyOrder", when: (adapter) => adapter.info.features.modifyOrders },
+    ],
+    orderCancellation: [
+        { method: "cancelOrder" },
+        { method: "cancelAllOrders" },
+        { method: "cancelAllAfter", when: (adapter) => adapter.info.features.cancelAllAfter },
+    ],
+    subscriptions: [
+        { method: "subscribe" },
+        { method: "subscribeOrderBook" },
+        { method: "subscribeTicker" },
+    ],
+    advancedTrading: [
+        { method: "modifyOrder", when: (adapter) => adapter.info.features.modifyOrders },
+        { method: "batchPlaceOrders", when: (adapter) => adapter.info.features.batchOrders },
+        { method: "batchCancelOrders", when: (adapter) => adapter.info.features.batchOrders },
+        { method: "cancelAllAfter", when: (adapter) => adapter.info.features.cancelAllAfter },
+        { method: "getOrderHistory", when: (adapter) => adapter.info.features.orderHistory },
+        { method: "getFundingHistory", when: (adapter) => adapter.info.features.fundingHistory },
+        { method: "getPublicTrades", when: (adapter) => adapter.info.features.publicTrades },
+        { method: "setMMP", when: (adapter) => adapter.info.features.mmp },
+        { method: "getMMP", when: (adapter) => adapter.info.features.mmp },
+        { method: "resetMMP", when: (adapter) => adapter.info.features.mmp },
+        { method: "placeTWAP", when: (adapter) => adapter.info.features.twapOrders },
+        { method: "cancelTWAP", when: (adapter) => adapter.info.features.twapOrders },
+        {
+            method: "getTWAPStatus",
+            when: (adapter) => adapter.info.features.twapOrders &&
+                typeof adapter.getTWAPStatus === "function",
+        },
+        { method: "updateIsolatedMargin", when: (adapter) => adapter.info.features.isolatedMargin },
+    ],
 };
 function methodLooksImplemented(method) {
     if (typeof method !== "function") {
@@ -40,10 +85,11 @@ function getCapabilityLevel(implemented, total) {
     return "partial";
 }
 function certifyCategory(adapter, category) {
-    const methods = CATEGORY_METHODS[category].map((methodName) => {
-        const probe = methodLooksImplemented(adapter[methodName]);
+    const applicableMethods = CATEGORY_METHODS[category].filter((spec) => !spec.when || spec.when(adapter));
+    const methods = applicableMethods.map((spec) => {
+        const probe = methodLooksImplemented(adapter[spec.method]);
         return {
-            method: methodName,
+            method: spec.method,
             implemented: probe.implemented,
             reason: probe.reason,
         };

package/dist/adapters/decibel/order-manager.d.ts

@@ -24,10 +24,44 @@ export interface PlaceDecibelOrderParams {
     builderAddr?: string;
     builderFeeBps?: number;
 }
+export interface UpdateDecibelOrderParams {
+    market: DecibelExecutionMarket;
+    orderId?: string;
+    clientOrderId?: string;
+    side: "buy" | "sell";
+    price: number;
+    sizeUnits: number;
+    timeInForce?: 0 | 1 | 2;
+    reduceOnly?: boolean;
+    stopPrice?: number;
+    tpTriggerPrice?: number;
+    tpLimitPrice?: number;
+    slTriggerPrice?: number;
+    slLimitPrice?: number;
+    builderAddr?: string;
+    builderFeeBps?: number;
+}
+export interface PlaceDecibelTwapParams {
+    market: DecibelExecutionMarket;
+    side: "buy" | "sell";
+    sizeUnits: number;
+    reduceOnly?: boolean;
+    clientOrderId?: string;
+    twapFrequencySeconds: number;
+    twapDurationSeconds: number;
+    builderAddr?: string;
+    builderFeeBps?: number;
+}
+export interface PlaceDecibelTwapResult {
+    txHash: string;
+    orderId: string | null;
+}
 export interface DecibelOrderManagerConfig {
     fullnodeUrl: string;
     network: "testnet" | "mainnet";
     packageAddress: string;
+    usdcAddress: string;
+    usdcDecimals?: number;
     privateKey: Hex;
     subaccountAddress: string;
 }
@@ -35,11 +69,18 @@ export declare class DecibelOrderManager {
     private readonly aptos;
     private readonly account;
     private readonly packageAddress;
+    private readonly usdcAddress;
+    private readonly usdcDecimals;
     private subaccountAddress;
     constructor(config: DecibelOrderManagerConfig);
     setSubaccount(addr: string): void;
     placeOrder(params: PlaceDecibelOrderParams): Promise<string>;
     cancelOrder(orderId: string, marketAddr: string): Promise<string>;
     cancelAllOrders(marketAddr: string): Promise<string>;
+    updateOrder(params: UpdateDecibelOrderParams): Promise<string>;
     configureUserSettingsForMarket(marketAddr: string, isCross: boolean, userLeverageBps: number): Promise<string>;
+    updateIsolatedPositionMargin(marketAddr: string, amount: number): Promise<string>;
+    placeTwapOrder(params: PlaceDecibelTwapParams): Promise<PlaceDecibelTwapResult>;
+    cancelTwapOrder(orderId: string, marketAddr: string): Promise<string>;
+    private extractOrderIdFromTransaction;
 }

package/dist/adapters/decibel/order-manager.js

@@ -5,6 +5,8 @@ export class DecibelOrderManager {
     aptos;
     account;
     packageAddress;
+    usdcAddress;
+    usdcDecimals;
     subaccountAddress;
     constructor(config) {
         const aptosConfig = new AptosConfig({
@@ -16,6 +18,8 @@ export class DecibelOrderManager {
             privateKey: new Ed25519PrivateKey(config.privateKey),
         });
         this.packageAddress = config.packageAddress;
+        this.usdcAddress = config.usdcAddress;
+        this.usdcDecimals = config.usdcDecimals ?? 6;
         this.subaccountAddress = config.subaccountAddress;
     }
     setSubaccount(addr) {
@@ -100,6 +104,74 @@ export class DecibelOrderManager {
         log.info("Decibel cancel-all submitted", { txHash: pending.hash, marketAddr });
         return pending.hash;
     }
+    async updateOrder(params) {
+        const { market, orderId, clientOrderId, side, price, sizeUnits, timeInForce = 0, reduceOnly = false, stopPrice, tpTriggerPrice, tpLimitPrice, slTriggerPrice, slLimitPrice, builderAddr, builderFeeBps, } = params;
+        if (!orderId && !clientOrderId) {
+            throw new Error("Decibel updateOrder requires orderId or clientOrderId");
+        }
+        const chainPrice = formatPrice(price, market);
+        const chainSize = formatSize(sizeUnits, market);
+        const isBuy = side === "buy";
+        const payload = {
+            function: orderId
+                ? `${this.packageAddress}::dex_accounts_entry::update_order_to_subaccount`
+                : `${this.packageAddress}::dex_accounts_entry::update_client_order_to_subaccount`,
+            typeArguments: [],
+            functionArguments: orderId
+                ? [
+                    this.subaccountAddress,
+                    orderId,
+                    market.marketAddr,
+                    chainPrice.toString(),
+                    chainSize.toString(),
+                    isBuy,
+                    timeInForce,
+                    reduceOnly,
+                    stopPrice != null ? formatPrice(stopPrice, market).toString() : null,
+                    tpTriggerPrice != null ? formatPrice(tpTriggerPrice, market).toString() : null,
+                    tpLimitPrice != null ? formatPrice(tpLimitPrice, market).toString() : null,
+                    slTriggerPrice != null ? formatPrice(slTriggerPrice, market).toString() : null,
+                    slLimitPrice != null ? formatPrice(slLimitPrice, market).toString() : null,
+                    builderAddr ?? null,
+                    builderFeeBps ?? null,
+                ]
+                : [
+                    this.subaccountAddress,
+                    clientOrderId,
+                    market.marketAddr,
+                    chainPrice.toString(),
+                    chainSize.toString(),
+                    isBuy,
+                    timeInForce,
+                    reduceOnly,
+                    stopPrice != null ? formatPrice(stopPrice, market).toString() : null,
+                    tpTriggerPrice != null ? formatPrice(tpTriggerPrice, market).toString() : null,
+                    tpLimitPrice != null ? formatPrice(tpLimitPrice, market).toString() : null,
+                    slTriggerPrice != null ? formatPrice(slTriggerPrice, market).toString() : null,
+                    slLimitPrice != null ? formatPrice(slLimitPrice, market).toString() : null,
+                    builderAddr ?? null,
+                    builderFeeBps ?? null,
+                ],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel order update submitted", {
+            txHash: pending.hash,
+            orderId,
+            clientOrderId,
+            market: market.marketName,
+            side,
+            price,
+            size: sizeUnits,
+        });
+        return pending.hash;
+    }
     async configureUserSettingsForMarket(marketAddr, isCross, userLeverageBps) {
         const leverageBps = Math.max(1, Math.round(userLeverageBps));
         const payload = {
@@ -123,6 +195,150 @@ export class DecibelOrderManager {
         });
         return pending.hash;
     }
+    async updateIsolatedPositionMargin(marketAddr, amount) {
+        if (!Number.isFinite(amount) || amount === 0) {
+            throw new Error("Decibel isolated margin update requires a non-zero amount");
+        }
+        const isDeposit = amount > 0;
+        const amountUnits = decimalToChainUnits(Math.abs(amount), this.usdcDecimals);
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts_entry::transfer_collateral_to_isolated_position`,
+            typeArguments: [],
+            functionArguments: [
+                this.subaccountAddress,
+                marketAddr,
+                isDeposit,
+                this.usdcAddress,
+                amountUnits.toString(),
+            ],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel isolated margin update submitted", {
+            txHash: pending.hash,
+            marketAddr,
+            amount,
+            usdcAddress: this.usdcAddress,
+        });
+        return pending.hash;
+    }
+    async placeTwapOrder(params) {
+        const { market, side, sizeUnits, reduceOnly = false, clientOrderId, twapFrequencySeconds, twapDurationSeconds, builderAddr, builderFeeBps, } = params;
+        const isBuy = side === "buy";
+        const chainSize = formatSize(sizeUnits, market);
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts_entry::place_twap_order_to_subaccount_v2`,
+            typeArguments: [],
+            functionArguments: [
+                this.subaccountAddress,
+                market.marketAddr,
+                chainSize.toString(),
+                isBuy,
+                reduceOnly,
+                clientOrderId ?? null,
+                twapFrequencySeconds,
+                twapDurationSeconds,
+                builderAddr ?? null,
+                builderFeeBps ?? null,
+            ],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        const orderId = await this.extractOrderIdFromTransaction(pending.hash);
+        log.info("Decibel TWAP order submitted", {
+            txHash: pending.hash,
+            orderId,
+            market: market.marketName,
+            side,
+            size: sizeUnits,
+            reduceOnly,
+            twapFrequencySeconds,
+            twapDurationSeconds,
+        });
+        return {
+            txHash: pending.hash,
+            orderId,
+        };
+    }
+    async cancelTwapOrder(orderId, marketAddr) {
+        const payload = {
+            function: `${this.packageAddress}::dex_accounts_entry::cancel_twap_orders_to_subaccount`,
+            typeArguments: [],
+            functionArguments: [this.subaccountAddress, marketAddr, orderId],
+        };
+        const tx = await this.aptos.transaction.build.simple({
+            sender: this.account.accountAddress,
+            data: payload,
+        });
+        const pending = await this.aptos.signAndSubmitTransaction({
+            signer: this.account,
+            transaction: tx,
+        });
+        log.info("Decibel TWAP cancel submitted", { txHash: pending.hash, orderId, marketAddr });
+        return pending.hash;
+    }
+    async extractOrderIdFromTransaction(txHash) {
+        try {
+            await this.aptos.waitForTransaction({
+                transactionHash: txHash,
+                options: { checkSuccess: false },
+            });
+        }
+        catch {
+            // The transaction may still be queryable by hash even if wait times out.
+        }
+        try {
+            const tx = await this.aptos.getTransactionByHash({ transactionHash: txHash });
+            const events = tx.events;
+            if (!Array.isArray(events))
+                return null;
+            for (const event of events) {
+                if (!event || typeof event !== "object")
+                    continue;
+                const eventType = event.type;
+                if (typeof eventType !== "string")
+                    continue;
+                if (!eventType.includes("TwapEvent") && !eventType.includes("OrderEvent"))
+                    continue;
+                const data = event.data;
+                if (!data || typeof data !== "object")
+                    continue;
+                const user = data.user;
+                const account = data.account;
+                if (user !== this.subaccountAddress && account !== this.subaccountAddress)
+                    continue;
+                const rawOrderId = data.order_id;
+                if (typeof rawOrderId === "string")
+                    return rawOrderId;
+                if (typeof rawOrderId === "number" || typeof rawOrderId === "bigint") {
+                    return String(rawOrderId);
+                }
+                if (rawOrderId && typeof rawOrderId === "object") {
+                    const nested = rawOrderId.order_id;
+                    if (typeof nested === "string")
+                        return nested;
+                    if (typeof nested === "number" || typeof nested === "bigint")
+                        return String(nested);
+                }
+            }
+        }
+        catch (err) {
+            log.debug("Unable to extract TWAP order id from transaction", { txHash, err });
+        }
+        return null;
+    }
 }
 function decimalToChainUnits(amount, decimals) {
     return BigInt(Math.round(amount * 10 ** decimals));

package/dist/adapters/decibel/rest-client.d.ts

@@ -15,6 +15,7 @@ export interface DecibelPriceResponse {
     mark_px: number | string;
     mid_px: number | string;
     funding_rate_bps: number | string;
+    is_funding_positive?: boolean;
     open_interest: number | string;
     transaction_unix_ms?: number | string;
 }
@@ -37,11 +38,14 @@ export interface DecibelAccountOverviewResponse {
     realized_pnl?: number | string;
     margin_utilization?: number | string;
     cross_margin_ratio?: number | string;
+    usdc_cross_withdrawable_balance?: number | string;
+    usdc_isolated_withdrawable_balance?: number | string;
 }
 export interface DecibelAccountPositionResponse {
     market_name?: string;
     market?: string;
     size: number | string;
+    is_isolated?: boolean;
     entry_price: number | string;
     mark_price?: number | string;
     oracle_price?: number | string;
@@ -123,6 +127,21 @@ export interface DecibelFundingHistoryResponse {
     fee_amount: number | string;
     transaction_unix_ms: number | string;
 }
+export interface DecibelTwapResponse {
+    market: string;
+    is_buy: boolean;
+    order_id: string;
+    client_order_id: string;
+    is_reduce_only: boolean;
+    start_unix_ms: number | string;
+    frequency_s: number | string;
+    duration_s: number | string;
+    orig_size: number | string;
+    remaining_size: number | string;
+    status: string;
+    transaction_unix_ms: number | string;
+    transaction_version: number | string;
+}
 export interface DecibelFundHistoryResponse {
     type: string;
     amount: number | string;
@@ -168,6 +187,8 @@ export declare class DecibelRestClient {
     getCandlesticks(marketAddr: string, interval: string, startTime: number, endTime: number): Promise<DecibelCandlestickResponse[]>;
     getSubaccounts(ownerAddr: string): Promise<DecibelSubaccountResponse[]>;
     getFundingHistory(accountAddr: string, limit?: number, offset?: number): Promise<DecibelFundingHistoryResponse[]>;
+    getActiveTwaps(accountAddr: string, limit?: number): Promise<DecibelTwapResponse[]>;
+    getTwapHistory(accountAddr: string, limit?: number, offset?: number): Promise<DecibelTwapResponse[]>;
     getOrderById(accountAddr: string, marketAddr: string, orderId?: string, clientOrderId?: string): Promise<DecibelOrderLookupResponse>;
     getPublicTrades(marketAddr: string, limit?: number, offset?: number, orderId?: string): Promise<DecibelPublicTradeResponse[]>;
     getFundHistory(accountAddr: string, limit?: number, offset?: number): Promise<DecibelFundHistoryResponse[]>;

package/dist/adapters/decibel/rest-client.js

@@ -32,16 +32,16 @@ export class DecibelRestClient {
         return this.unwrapRows(payload);
     }
     async getOpenOrders(accountAddr) {
-        const payload = await this.fetchApi("api/v1/open_orders", { user: accountAddr }, true);
+        const payload = await this.fetchApi("api/v1/open_orders", { account: accountAddr }, true);
         return this.unwrapRows(payload);
     }
     async getOrderHistory(accountAddr, limit = 200, offset = 0) {
-        const payload = await this.fetchApi("api/v1/order_history", { user: accountAddr, limit, offset }, true);
+        const payload = await this.fetchApi("api/v1/order_history", { account: accountAddr, limit, offset }, true);
         return this.unwrapRows(payload);
     }
     async getTradeHistory(accountAddr, marketAddr, limit = 200, offset = 0) {
         const params = {
-            user: accountAddr,
+            account: accountAddr,
             limit,
             offset,
         };
@@ -74,6 +74,14 @@ export class DecibelRestClient {
         const payload = await this.fetchApi("api/v1/funding_rate_history", { account: accountAddr, limit, offset }, true);
         return this.unwrapRows(payload);
     }
+    async getActiveTwaps(accountAddr, limit = 200) {
+        const payload = await this.fetchApi("api/v1/active_twaps", { account: accountAddr, limit }, true);
+        return this.unwrapRows(payload);
+    }
+    async getTwapHistory(accountAddr, limit = 200, offset = 0) {
+        const payload = await this.fetchApi("api/v1/twap_history", { account: accountAddr, limit, offset }, true);
+        return this.unwrapRows(payload);
+    }
     async getOrderById(accountAddr, marketAddr, orderId, clientOrderId) {
         const params = {
             account: accountAddr,
@@ -93,11 +101,11 @@ export class DecibelRestClient {
         };
         if (orderId)
             params.order_id = orderId;
-        const payload = await this.fetchApi("api/v1/trades", params);
+        const payload = await this.fetchApi("api/v1/trades", params, true);
         return this.unwrapRows(payload);
     }
     async getFundHistory(accountAddr, limit = 200, offset = 0) {
-        const payload = await this.fetchApi("api/v1/fund_history", { account: accountAddr, limit, offset }, true);
+        const payload = await this.fetchApi("api/v1/account_fund_history", { account: accountAddr, limit, offset }, true);
         return this.unwrapRows(payload);
     }
     async fetchApi(path, params, requiresAuth = false) {
@@ -116,9 +124,6 @@ export class DecibelRestClient {
             }
             headers.Authorization = `Bearer ${this.bearerToken}`;
         }
-        else if (this.bearerToken) {
-            headers.Authorization = `Bearer ${this.bearerToken}`;
-        }
         log.debug(`GET ${url.pathname}${url.search}`);
         const json = await fetchWithTimeout(url.toString(), {
             headers,
@@ -138,8 +143,10 @@ export class DecibelRestClient {
         }
         if (isRecord(payload)) {
             const candidates = [
+                payload.items,
                 payload.results,
                 payload.data,
+                isRecord(payload.data) ? payload.data.items : undefined,
                 isRecord(payload.data) ? payload.data.rows : undefined,
                 isRecord(payload.data) ? payload.data.orders : undefined,
                 isRecord(payload.data) ? payload.data.trades : undefined,