Handling Hosted Errors

from pmxt.errors import InsufficientFunds
from pmxt._hosted_errors import InsufficientEscrowBalance

try:
    client.create_order(...)
except InsufficientEscrowBalance as e:
    print(f"Need to deposit more. {e.detail}")
    # Build a deposit tx for the shortfall
    tx = client.escrow.deposit_tx(amount=20.0)
    # ... sign and broadcast, then retry the order
except InsufficientFunds:
    # Self-hosted path also lands here
    ...

import { InsufficientEscrowBalance, isHostedError } from "pmxtjs";

try {
  await client.createOrder({ ... });
} catch (e) {
  if (e instanceof InsufficientEscrowBalance) {
    console.log(`Need to deposit. ${e.detail}`);
    const tx = await client.escrow.depositTx(20);
    // sign and broadcast, retry
  } else if (isHostedError(e)) {
    // any other hosted-error parent
  } else {
    throw e;
  }
}

from pmxt._hosted_errors import OrderSizeTooSmall

try:
    client.create_order(amount=2.0, ...)
except OrderSizeTooSmall as e:
    # Resize: at $0.78/share, 5 shares ≈ $3.90. Round up with buffer.
    client.create_order(amount=5.0, ...)

import { OrderSizeTooSmall } from "pmxtjs";

try {
  await client.createOrder({ amount: 2, ... });
} catch (e) {
  if (e instanceof OrderSizeTooSmall) {
    await client.createOrder({ amount: 5, ... });
  } else {
    throw e;
  }
}

from pmxt.errors import AuthenticationError
from pmxt._hosted_errors import InvalidApiKey

try:
    client.fetch_balance()
except InvalidApiKey:
    # Rotate the key; don't retry with the same one
    raise SystemExit("PMXT_API_KEY invalid — rotate from dashboard")

import { InvalidApiKey } from "pmxtjs";

try {
  await client.fetchBalance();
} catch (e) {
  if (e instanceof InvalidApiKey) {
    throw new Error("PMXT_API_KEY invalid — rotate from dashboard");
  }
  throw e;
}

from pmxt._hosted_errors import BuiltOrderExpired

def submit_with_retry(client, **kwargs):
    # In hosted mode, create_order handles build -> sign -> submit atomically.
    # On BuiltOrderExpired the internal submit raced the 30s TTL; just call again.
    for attempt in range(2):
        try:
            return client.create_order(**kwargs)
        except BuiltOrderExpired:
            if attempt == 1:
                raise
            continue

import { BuiltOrderExpired } from "pmxtjs";
import type { CreateOrderInput, Order } from "pmxtjs";

async function submitWithRetry(client, params: CreateOrderInput): Promise<Order> {
  // In hosted mode, createOrder handles build -> sign -> submit atomically.
  // On BuiltOrderExpired the internal submit raced the 30s TTL; just call again.
  for (let attempt = 0; attempt < 2; attempt++) {
    try {
      return await client.createOrder(params);
    } catch (e) {
      if (e instanceof BuiltOrderExpired && attempt === 0) continue;
      throw e;
    }
  }
  throw new Error("unreachable");
}

from pmxt._hosted_errors import NoLiquidity

try:
    client.create_order(order_type="market", ...)
except NoLiquidity:
    # Wait, retry against a different outcome, or post a hosted limit order.
    pass

import { NoLiquidity } from "pmxtjs";

try {
  await client.createOrder({ type: "market", ... });
} catch (e) {
  if (e instanceof NoLiquidity) {
    // Wait, retry against a different outcome, or post a hosted limit order.
  } else {
    throw e;
  }
}

from pmxt._hosted_errors import HostedTradingError

try:
    client.create_order(...)
except HostedTradingError as e:
    log.error("hosted trade failed", status=e.status, detail=e.detail)

import { isHostedError } from "pmxtjs";

try {
  await client.createOrder({ ... });
} catch (e) {
  if (isHostedError(e)) {
    log.error("hosted trade failed", e);
  } else {
    throw e;
  }
}