Write SDK

import {
  DecibelWriteDex,
  TESTNET_CONFIG,
  GasPriceManager,
} from "@decibeltrade/sdk";
import { Ed25519Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";

const account = new Ed25519Account({
  privateKey: new Ed25519PrivateKey(process.env.PRIVATE_KEY!),
});

const gas = new GasPriceManager(TESTNET_CONFIG);
await gas.initialize(); // optional but recommended

const write = new DecibelWriteDex(TESTNET_CONFIG, account, {
  // Required: SDK will send Authorization: Bearer <YOUR_NODE_API_KEY> on fullnode requests
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
  gasPriceManager: gas, // speeds up building with cached gas
  skipSimulate: false, // default: simulate to estimate gas
  timeDeltaMs: 0, // see Advanced for clock skew handling
});

const sub = write.getPrimarySubaccountAddress(write.account.accountAddress);

// Deposit and then withdraw collateral (u64 base units)
await write.deposit(1_000_000, sub);
await write.withdraw(500_000, sub); // Example requested

type PlaceOrderArgs = {
  marketName: string;
  price: number; // already converted to on-chain units
  size: number; // on-chain base units
  isBuy: boolean;
  timeInForce: TimeInForce;
  isReduceOnly: boolean;
  clientOrderId?: string;
  stopPrice?: number;
  tpTriggerPrice?: number;
  tpLimitPrice?: number;
  slTriggerPrice?: number;
  slLimitPrice?: number;
  builderAddr?: string;
  builderFee?: number;
  subaccountAddr?: string;
  accountOverride?: Account;
  tickSize?: number;
};

import { DecibelReadDex, TimeInForce } from "@decibeltrade/sdk";
// amountToChainUnits helper defined in docs/developer-hub/on-chain/overview/formatting-prices-sizes.mdx
const read = new DecibelReadDex(write.config, {
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
});
// getAll() rows carry px_decimals / sz_decimals / tick_size; getByName() returns the on-chain config object, which does not
const market = (await read.markets.getAll()).find((m) => m.market_name === "BTC/USD");
if (!market) throw new Error("Market not found");

const orderResult = await write.placeOrder({
  marketName: "BTC/USD",
  price: amountToChainUnits(45_000, market.px_decimals),
  size: amountToChainUnits(0.25, market.sz_decimals),
  isBuy: true,
  timeInForce: TimeInForce.GoodTillCanceled,
  isReduceOnly: false,
  clientOrderId: "dash-1234",
  builderAddr: "0x...builder",
  builderFee: 25, // 0.25%
  tickSize: market.tick_size, // optional price snapping to the market tick size
});

if (orderResult.success && orderResult.orderId) {
  await write.cancelOrder({
    orderId: orderResult.orderId,
    marketName: "BTC/USD",
  });
}

await write.placeTwapOrder({
  marketName: "BTC/USD",
  size: amountToChainUnits(2, market.sz_decimals),
  isBuy: true,
  isReduceOnly: false,
  twapFrequencySeconds: 30,
  twapDurationSeconds: 15 * 60,
});

await write.cancelBulkOrder({
  marketName: "BTC/USD",
});

await write.updateOrder({
  orderId: 12345,
  marketAddr: "0x...market",
  price: amountToChainUnits(45_100, market.px_decimals),
  size: amountToChainUnits(0.3, market.sz_decimals),
  isBuy: true,
  timeInForce: TimeInForce.GoodTillCanceled,
  isReduceOnly: false,
});

import { roundToTickSizeForSide } from "@decibeltrade/sdk";

// 4.545123 quote units on a 6-decimal quote asset, tick size 100
const submitted = roundToTickSizeForSide(4_545_123, 100, true); // 4_545_100 (buy: down)
const asSell = roundToTickSizeForSide(4_545_123, 100, false); // 4_545_200 (sell: up)

import { TimeInForce } from "@decibeltrade/sdk";

const spotMarket = await read.markets.getAllSpot().then(
  (ms) => ms.find((m) => m.market_name === "APT/USDC"),
);
if (!spotMarket) throw new Error("Market not found");

const result = await write.placeSpotOrder({
  marketName: "APT/USDC",
  price: amountToChainUnits(4.25, spotMarket.px_decimals),
  size: amountToChainUnits(100, spotMarket.sz_decimals),
  isBuy: true,
  timeInForce: TimeInForce.GoodTillCanceled,
  tickSize: spotMarket.tick_size,
});

if (result.success && result.pendingCbs) {
  // Order queued behind a CBS withdrawal — poll for the acknowledgment
}

if (result.success && result.orderId) {
  await write.cancelSpotOrder({
    orderId: result.orderId,
    marketName: "APT/USDC",
  });
}

import { DecibelReadDex } from "@decibeltrade/sdk";

const read = new DecibelReadDex(write.config, {
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
});
const markets = await read.markets.getAll();
const market = markets.find((m) => m.market_addr === "0x...market");
if (!market) throw new Error("Market not found");

await write.placeTpSlOrderForPosition({
  marketAddr: "0x...market",
  // amountToChainUnits helper defined in docs/developer-hub/on-chain/overview/formatting-prices-sizes.mdx
  tpTriggerPrice: amountToChainUnits(47_000, market.px_decimals),
  tpLimitPrice: amountToChainUnits(46_950, market.px_decimals),
  tpSize: amountToChainUnits(0.1, market.sz_decimals),
  slTriggerPrice: amountToChainUnits(43_000, market.px_decimals),
  slLimitPrice: amountToChainUnits(43_050, market.px_decimals),
  slSize: amountToChainUnits(0.1, market.sz_decimals),
  tickSize: market.tick_size,
});

await write.delegateTradingToForSubaccount({
  subaccountAddr: "0x...subaccount",
  accountToDelegateTo: "0x...operator",
});

await write.approveMaxBuilderFee({
  builderAddr: "0x...builder",
  maxFee: 100, // 1%
});

const buildTx = await write.buildCreateVaultTx({
  // Asset metadata object address (for example USDC metadata), not a Move type tag
  contributionAssetType: write.config.deployment.usdc,
  vaultName: "My Vault",
  vaultDescription: "Strategy description",
  vaultSocialLinks: [],
  vaultShareSymbol: "MVS",
  feeBps: 0,
  feeIntervalS: 0,
  contributionLockupDurationS: 0,
  initialFunding: 0,
  acceptsContributions: false,
  delegateToCreator: false,
  signerAddress: write.account.accountAddress,
});

const depositTx = await write.buildDepositToVaultTx({
  vaultAddress: "0x...vault",
  amount: 1_000_000,
  signerAddress: write.account.accountAddress,
});

import { AccountAddress } from "@aptos-labs/ts-sdk";
import {
  DecibelReadDex,
  getPrimarySubaccountAddr,
  TimeInForce,
} from "@decibeltrade/sdk";

const vaultSubaccount = getPrimarySubaccountAddr(
  AccountAddress.fromString(vaultAddress),
  write.config.compatVersion,
  write.config.deployment.package,
);

const read = new DecibelReadDex(write.config, {
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
});
const markets = await read.markets.getAll();
const marketPrices = await read.marketPrices.getAll();
const market = markets.find((m) => m.market_name === "APT/USD");
if (!market) throw new Error("Market not found");

const midPx = marketPrices.find((p) => p.market === market.market_addr)?.mid_px;
if (midPx == null) throw new Error("No mid price");

function amountToChainUnits(amount: number, decimals: number) {
  return Math.floor(amount * 10 ** decimals);
}

const orderResult = await write.placeOrder({
  marketName: market.market_name,
  price: amountToChainUnits(midPx, market.px_decimals),
  size: market.min_size,
  isBuy: true,
  timeInForce: TimeInForce.ImmediateOrCancel,
  isReduceOnly: false,
  subaccountAddr: vaultSubaccount,
  tickSize: market.tick_size,
});

if (orderResult.success) {
  console.log("Vault order placed:", orderResult.transactionHash);
} else {
  console.error("Order failed:", orderResult.error);
}

import { DecibelReadDex, TimeInForce } from "@decibeltrade/sdk";
import { Ed25519Account, Ed25519PrivateKey } from "@aptos-labs/ts-sdk";

const read = new DecibelReadDex(write.config, {
  nodeApiKey: process.env.APTOS_NODE_API_KEY!,
});
// getAll() rows carry px_decimals / sz_decimals / tick_size; getByName() returns the on-chain config object, which does not
const market = (await read.markets.getAll()).find((m) => m.market_name === "BTC/USD");
if (!market) throw new Error("Market not found");

const session = new Ed25519Account({
  privateKey: new Ed25519PrivateKey(process.env.SESSION_PRIVATE_KEY!),
});

await write.placeOrder({
  marketName: "BTC/USD",
  price: amountToChainUnits(45_100, market.px_decimals),
  size: amountToChainUnits(0.5, market.sz_decimals),
  isBuy: true,
  timeInForce: TimeInForce.GoodTillCanceled,
  isReduceOnly: false,
  builderAddr: "0x...builder",
  builderFee: 25, // 0.25%
  accountOverride: session,
});

// RenameSubaccountArgs
type RenameSubaccountArgs = {
  subaccountAddress: string;
  newName: string;
};

// Utility used throughout builder helpers
type WithSignerAddress<T> = T & {
  signerAddress: AccountAddress;
};

// CreateVaultArgs (see src/read/types.ts)
type CreateVaultArgs = {
  contributionAssetType?: string;
  vaultName: string;
  vaultDescription: string;
  vaultSocialLinks: string[];
  vaultShareSymbol: string;
  vaultShareIconUri?: string;
  vaultShareProjectUri?: string;
  subaccountAddr?: string | null;
  feeBps: number;
  feeIntervalS: number;
  contributionLockupDurationS: number;
  initialFunding?: number; // default 0
  acceptsContributions?: boolean; // default false
  delegateToCreator?: boolean; // default false
};

type TransactionSubmissionFailure = {
  outcome: "not-submitted" | "reverted" | "unknown";
  transactionHash?: string;
};

type PlaceOrderResult =
  | {
      success: true;
      orderId: string | undefined;
      transactionHash: string;
    }
  | {
      success: false;
      error: string;
      submission?: TransactionSubmissionFailure;
    };

type PlaceSpotOrderResult =
  | {
      success: true;
      orderId: string | undefined;
      // True when the order was queued behind a rate-limited CBS withdrawal
      // instead of reaching the book in this transaction.
      pendingCbs: boolean;
      transactionHash: string;
    }
  | {
      success: false;
      error: string;
    };

type ActivateVaultArgs = {
  vaultAddress: string;
  additionalFunding?: number;
};

type DepositToVaultArgs = {
  vaultAddress: string;
  amount: number;
};

type WithdrawFromVaultArgs = {
  vaultAddress: string;
  shares: number;
};