Formatting Prices and Sizes for Orders

/**
 * Converts a decimal amount to chain units (e.g., USDC).
 * For USDC, this means multiplying by 10^6.
 * @param amount - The decimal amount to convert
 * @param decimal - The number of decimal places for the token (default is 6 for USDC).
 * @returns The amount in chain units
 */
export function amountToChainUnits(amount: number, decimal = 6): number {
  return Math.floor(amount * 10 ** decimal);
}

/**
 * Converts chain units to decimal amount (e.g., USDC).
 * For USDC, this means dividing by 10^6.
 * @param chainUnits - The amount in chain units
 * @param decimal - The number of decimal places for the token (default is 6 for USDC).
 * @returns The decimal amount
 */
export function chainUnitsToAmount(chainUnits: number, decimal = 6): number {
  return chainUnits / 10 ** decimal;
}

/**
 * Rounds a price to the nearest valid tick size
 * @param price - The decimal price to round
 * @param market - The market configuration object
 * @returns The rounded price
 */
export function roundToValidPrice(price: number, market: PerpMarket): number {
  if (price === 0) {
    return 0;
  }

// Convert to chain units
const denormalizedPrice = price \* 10 \*\* market.px_decimals;

// Round to nearest multiple of tickSize
const roundedPrice =
Math.round(denormalizedPrice / market.tick_size) \* market.tick_size;

// Convert back to decimal
const normalizedPrice = Math.round(roundedPrice) / 10 \*\* market.px_decimals;

return normalizedPrice;
}

/**
 * Rounds an order size to the nearest valid lot size
 * @param orderSize - The decimal order size to round
 * @param market - The market configuration object
 * @returns The rounded order size
 */
export function roundToValidOrderSize(
  orderSize: number,
  market: PerpMarket
): number {
  if (orderSize === 0) {
    return 0;
  }

const normalizedMinSize = market.min_size / 10 \*\* market.sz_decimals;

// Ensure size meets minimum requirement
if (orderSize < normalizedMinSize) {
return normalizedMinSize;
}

// Convert to chain units
const denormalizedOrderSize = orderSize \* 10 \*\* market.sz_decimals;

// Round to nearest multiple of lotSize
const roundedOrderSize =
Math.round(denormalizedOrderSize / market.lot_size) \* market.lot_size;

// Convert back to decimal
const normalizedOrderSize =
Math.round(roundedOrderSize) / 10 \*\* market.sz_decimals;

return normalizedOrderSize;
}

// Fetch market data from v1/markets endpoint
const market = {
  market_addr: "0x456...def",
  market_name: "APT-USD",
  px_decimals: 9,
  sz_decimals: 9,
  tick_size: 1000000, // 0.001 in decimal (1000000 / 10^9)
  lot_size: 100000000, // 0.1 in decimal (100000000 / 10^9)
  min_size: 1000000000, // 1.0 in decimal (1000000000 / 10^9)
};

// User wants to place an order at $5.6789 with size 1.234
const userPrice = 5.6789;
const userSize = 1.234;

// Step 1: Round price to valid tick size
const roundedPrice = roundToValidPrice(userPrice, market);
// Result: 5.679 (rounded to nearest 0.001)

// Step 2: Round size to valid lot size and check minimum
const roundedSize = roundToValidOrderSize(userSize, market);
// Result: 1.2 (rounded to nearest 0.1, meets minimum of 1.0)

// Step 3: Convert to chain units for the transaction
const chainPrice = amountToChainUnits(roundedPrice, market.px_decimals);
// Result: 5679000000 (5.679 × 10^9)

const chainSize = amountToChainUnits(roundedSize, market.sz_decimals);
// Result: 1200000000 (1.2 × 10^9)

// Step 4: Build and submit transaction
const transaction = await aptos.transaction.build.simple({
sender: account.accountAddress,
data: {
function: `${PACKAGE}::dex_accounts_entry::place_order_to_subaccount`,
typeArguments: [],
functionArguments: [
"0x123...abc", // subaccountAddr
market.market_addr, // marketAddr
chainPrice, // price in chain units
chainSize, // size in chain units
true, // isBuy
0, // timeInForce
false, // isReduceOnly
null, // clientOrderId
null, // stopPrice
null, // tpTriggerPrice
null, // tpLimitPrice
null, // slTriggerPrice
null, // slLimitPrice
null, // builderAddress
null, // builderFees
],
},
});