Types Reference

interface Trade {
  id: string;                    // Unique trade ID (UUID)
  type: TradeType;               // "deposit" or "withdraw"
  source: TradeSource;           // "client" or "self" (origin flow)
  status: TradeStatus;           // Current trade status
  game: string;                  // Game app ID ("730" or "252490")

  // Participants
  merchantId: string;            // Your merchant ID
  clientUserId: string;          // Internal client user ID
  clientSteamID: string;         // User's Steam ID 64
  clientTradeUrl: string;        // User's Steam trade URL

  // Items and pricing
  items: Item[];                 // Items in this trade
  totalPrice: number;            // Total value in USD

  // Instant deposit fields (deposits only)
  preCredit?: number;            // Amount credited instantly (USD)
  pendingCredit?: number;        // Amount held until "completed" (USD)
  isInstant?: boolean;           // Whether instant credit was requested
  collateral?: {
    merchant: number;            // Merchant collateral portion
    provider: number;            // Provider collateral portion
  };

  // Tracking
  externalId?: string;           // Your tracking ID (from externalId param)
  externalClientUserId?: string; // Your user ID (from clientId param)
  offerID?: string;              // Steam trade offer ID (present from "active" onward)

  // Timing
  holdEndDate?: Date;            // When the Steam hold expires (present from "hold" onward)
  activeAt?: Date;               // When the trade offer went live at the user (present from "active" onward)
  autoCancelAt?: Date;           // When items the seller hasn't sent will be canceled automatically.
                                 //   Items already offered to the user or in Steam hold are never
                                 //   auto-canceled. Absent when auto-cancel is off, and on Rust.
  createdAt: Date;
  updatedAt: Date;

  // Status-specific
  revertedBy?: RevertedBy;       // Who reversed the trade (status === "reverted")
  error?: TradeErrorCode;        // Failure reason. Withdrawals: set only when the whole trade failed
                                 //   with one shared cause (per-item codes are on Item.error).

  // Bot details
  botInfo?: {
    name: string;
    avatar?: string;
    steamId?: string;
    joined?: Date;
  };

  // Basket splits (/secure/sell only)
  relatedTrades?: Trade[];       // The other trades a basket was split into, each a full Trade.
                                 //   Present on the primary trade returned by /secure/sell.
}

interface Item {
  // Identity
  id: string;                    // On CS2 withdraw items, the listing id you quoted, stable for the
                                 //   item's whole life. On inventory and deposit items, the encoded
                                 //   item id. Cancel endpoints accept it alongside externalId.
  itemId?: string;               // The parent catalog item this listing belongs to: the same id you
                                 //   pass to /market/item, while id above is the individual listing.
                                 //   CS2 GET /market rows only: /market/item omits it because you
                                 //   named the item in the request, and it is never present on Rust,
                                 //   inventory, deposit or withdraw items.
  externalId?: string;           // Your own per-item reference, when you supplied one at buy time.
                                 //   Cancel accepts it in place of id. Omitted on stacked Rust rows,
                                 //   which stand for several items at once.
  assetId?: string;              // Raw Steam assetid. Always present on inventory listings and deposit
                                 //   items; omitted on withdraw items until the item lands in the
                                 //   recipient's Steam inventory.
  classId?: string;              // Steam classid, when known
  instanceId?: string;           // Steam instanceid, when known
  appid: number;                 // Game app ID (730 or 252490)

  // Description: omitted on bare withdraw items where AssetPay has no Steam-side
  // metadata yet (you supplied only itemId + price). Always present for inventory,
  // market, and post-completion trade items.
  name?: string;                 // Display name (e.g. "AK-47 | Redline")
  marketHashName?: string;       // Full market name (e.g. "AK-47 | Redline (Field-Tested)")
  type?: string;                 // Item type (e.g. "Rifle", "Knife")
  iconUrl?: string;              // Steam image hash (use with Steam CDN base URL)

  // Trade state
  tradable: boolean;             // Whether the item can be traded
  amount?: number;               // Stack count for Rust items

  // Pricing
  marketPrice?: number;          // Market reference price (USD)
  offer?: ItemOffer;             // See ItemOffer below

  // Cosmetic attributes
  exterior?: string;             // "Factory New", "Minimal Wear", etc.
  rarity?: string;               // "Consumer Grade", "Covert", etc.
  color?: string;                // Rarity color hex (e.g. "#EB4B4B")
  wear?: string;                 // Float value as string
  paintSeed?: number;            // Paint seed number
  previewToken?: string;         // Steam inspect/preview token (CS2). Present on inventory and
                                 //   internal-pool (self-owned) items, and on third-party
                                 //   marketplace listings when the marketplace provides one.
  doppler?: Doppler;             // Doppler phase details
  fade?: Fade;                   // Fade percentage details
  hardened?: Hardened;           // Case Hardened pattern details

  // Applied items
  stickers?: Sticker[];          // Applied stickers
  charm?: Charm;                 // Applied charm (CS2 only)

  // Market-specific
  botInfo?: {                    // Holding bot identity, present on internal-pool market items
    name: string;
    avatar?: string;
    steamId?: string;
    joined?: Date;
  };

  // Withdrawal-specific (only set on items belonging to a withdraw trade)
  status?: TradeStatus;          // Per-item purchase status, mirrors Trade.status
  error?: TradeFailureCode;      // Failure code, present only on failed withdraw items
}

interface ItemOffer {
  price: number;                 // Offer price in USD
  delivery?: DeliveryMode;       // "standard" or "instant" (market items, withdraw trade items and quick-buy rows).
                                 //   Absent on Rust market items, and on some CS2 marketplace rows.
  maxAmount?: number;            // Max quantity for stackable items (inventory only)
  accepted?: boolean;            // Whether the item is accepted for deposit (inventory and deposit trade items)
}

interface Sticker {
  name: string;                  // Sticker display name
  marketHashName?: string;       // Sticker's own market hash name, for deep-linking
  slot: number;                  // Position on the weapon (0-4)
  wear?: number;                 // Sticker wear (0 = perfect, 1 = scraped off)
  iconUrl: string;               // Sticker image URL
}

interface Charm {
  name: string;                  // Charm display name
  marketHashName?: string;       // Charm's own market hash name, for deep-linking
  iconUrl: string;               // Charm image URL
}

interface Doppler {
  status?: number;               // Marketplace-issued status code (market listings only)
  name: string;                  // Phase name (e.g. "Phase 1", "Ruby", "Sapphire")
  paintIndex?: number;           // Steam paint index, if known
}

interface Fade {
  percentage: number;            // Fade percentage (0-100)
}

interface Hardened {
  status: number;                // Case Hardened tier code
  name: string;                  // Pattern name (e.g. "Blue Gem")
}

type TradeStatus =
  | 'initiated'   // Trade created. Withdrawals: approval gate (merchant wallet not yet debited)
  | 'pending'     // Withdrawals: supplier is sourcing the item / creating the purchase.
                  //   Deposits: trade offer created, waiting for the bot to confirm it
  | 'active'      // Steam trade offer sent to the user, awaiting acceptance
  | 'hold'        // User accepted; Steam hold window running (carries offerID + holdEndDate)
  | 'completed'   // Trade finished successfully
  | 'failed'      // Trade failed at some point
  | 'canceled'    // Trade was canceled before completion (no penalty)
  | 'declined'    // End user declined / let the Steam offer expire. Withdrawals: marketplace items refund minus its penalty, own stock in full
  | 'reverted';   // Previously completed trade was reversed (see revertedBy)

type TradeType =
  | 'deposit'    // User selling items to merchant
  | 'withdraw';  // User buying items from market

type TradeSource =
  | 'client'    // Initiated by an end-user via /client/trading/*
  | 'self';     // Merchant self-trade via /secure/sell, /secure/buy or /secure/buy/quick

type DeliveryMode =
  | 'standard'  // Trade-offer delivery (bot sources from a supplier and sends a Steam trade offer)
  | 'instant';  // Instant delivery (item already pre-positioned with the bot)

type RevertedBy =
  | 'supplier'   // Marketplace supplier reversed (withdrawals only)
  | 'user';      // End user reversed

type TradeFailureCode =
  | 'LISTING_UNAVAILABLE'      // Listing sold / delisted / out of stock. Retry another listing
  | 'NO_LISTING_AT_PRICE'      // Nothing on sale at or below your max price. Re-quote higher or wait
  | 'PRICE_CHANGED'            // Price moved above your ceiling. Re-quote
  | 'TRADE_URL_INVALID'        // Recipient's Steam trade URL is invalid or escrow-blocked
  | 'STEAM_ACCOUNT_RESTRICTED' // Recipient's Steam account can't receive (VAC / ban / hold / private)
  | 'BUYER_TRADE_RESTRICTED'   // The marketplace suspended this buyer (e.g. repeated unaccepted offers),
                               //   usually until a stated time. Distinct from Steam's own restrictions
  | 'MARKET_UNAVAILABLE'       // Temporary upstream or our-side issue. Retry later
  | 'PURCHASE_FAILED';         // Unclassified failure (catch-all)

type TradeErrorCode =
  | TradeFailureCode
  | 'USER_TRADE_RESTRICTED'    // The user's Steam account can't trade
  | 'USER_INVENTORY_PRIVATE'   // The user's Steam inventory is private
  | 'USER_ESCROW'              // Trades with the user would be held in Steam escrow
  | 'USER_NOT_FOUND'           // No Steam user behind the trade URL
  | 'OFFER_NOT_ACCEPTED'       // Deposits: the offer reached the user and was not accepted
                               //   (declined, expired, canceled, items gone)
  | 'SERVICE_UNAVAILABLE'      // A temporary issue on AssetPay's side. Retry later
  | 'MERCHANT_REJECTED'        // Withdrawals: your approval callback rejected the trade
  | 'APPROVAL_TIMEOUT';        // Withdrawals: your approval callback never gave an answer

enum GameId {
  CS2  = 730,
  RUST = 252490,
}

interface CallbackBody {
  trade: Trade;
}