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);
}

def amount_to_chain_units(amount: float, decimal: int = 6) -> int:
    """
    Converts a decimal amount to chain units (e.g., USDC).
    For USDC, this means multiplying by 10^6.

    Args:
        amount: The decimal amount to convert
        decimal: The number of decimal places for the token (default is 6 for USDC)

    Returns:
        The amount in chain units
    """
    return int(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;
}

def chain_units_to_amount(chain_units: int, decimal: int = 6) -> float:
    """
    Converts chain units to decimal amount (e.g., USDC).
    For USDC, this means dividing by 10^6.

    Args:
        chain_units: The amount in chain units
        decimal: The number of decimal places for the token (default is 6 for USDC)

    Returns:
        The decimal amount
    """
    return chain_units / (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;
}

def round_to_valid_price(price: float, market: dict) -> float:
    """
    Rounds a price to the nearest valid tick size.

    Args:
        price: The decimal price to round
        market: The market configuration object with px_decimals and tick_size

    Returns:
        The rounded price
    """
    if price == 0:
        return 0.0

    # Convert to chain units
    denormalized_price = price * (10 ** market["px_decimals"])

    # Round to nearest multiple of tick_size
    rounded_price = round(denormalized_price / market["tick_size"]) * market["tick_size"]

    # Convert back to decimal
    normalized_price = round(rounded_price) / (10 ** market["px_decimals"])

    return normalized_price

/**
 * 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;
}

def round_to_valid_order_size(order_size: float, market: dict) -> float:
    """
    Rounds an order size to the nearest valid lot size.

    Args:
        order_size: The decimal order size to round
        market: The market configuration object with sz_decimals, lot_size, and min_size

    Returns:
        The rounded order size
    """
    if order_size == 0:
        return 0.0

    normalized_min_size = market["min_size"] / (10 ** market["sz_decimals"])

    # Ensure size meets minimum requirement
    if order_size < normalized_min_size:
        return normalized_min_size

    # Convert to chain units
    denormalized_order_size = order_size * (10 ** market["sz_decimals"])

    # Round to nearest multiple of lot_size
    rounded_order_size = round(denormalized_order_size / market["lot_size"]) * market["lot_size"]

    # Convert back to decimal
    normalized_order_size = round(rounded_order_size) / (10 ** market["sz_decimals"])

    return normalized_order_size

// 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
],
},
});

# Fetch market data from v1/markets endpoint
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
user_price = 5.6789
user_size = 1.234

# Step 1: Round price to valid tick size
rounded_price = round_to_valid_price(user_price, market)
# Result: 5.679 (rounded to nearest 0.001)

# Step 2: Round size to valid lot size and check minimum
rounded_size = round_to_valid_order_size(user_size, market)
# Result: 1.2 (rounded to nearest 0.1, meets minimum of 1.0)

# Step 3: Convert to chain units for the transaction
chain_price = amount_to_chain_units(rounded_price, market["px_decimals"])
# Result: 5679000000 (5.679 × 10^9)

chain_size = amount_to_chain_units(rounded_size, market["sz_decimals"])
# Result: 1200000000 (1.2 × 10^9)

# Step 4: Build and submit transaction
from aptos_sdk.client import RestClient
from aptos_sdk.account import Account

PACKAGE = "0x50ead22afd6ffd9769e3b3d6e0e64a2a350d68e8b102c4e72e33d0b8cfdfdb06"
rest_client = RestClient("https://fullnode.mainnet.aptoslabs.com")

transaction = rest_client.build_transaction(
    sender=account.address(),
    payload={
        "function": f"{PACKAGE}::dex_accounts_entry::place_order_to_subaccount",
        "type_arguments": [],
        "function_arguments": [
            "0x123...abc",  # subaccountAddr
            market["market_addr"],  # marketAddr
            chain_price,  # price in chain units
            chain_size,  # size in chain units
            True,  # isBuy
            0,  # timeInForce
            False,  # isReduceOnly
            None,  # clientOrderId
            None,  # stopPrice
            None,  # tpTriggerPrice
            None,  # tpLimitPrice
            None,  # slTriggerPrice
            None,  # slLimitPrice
            None,  # builderAddress
            None,  # builderFees
        ],
    },
)