Class Router

constructor

• new Router(config?: CallerConfig): Router

  Creates a router client without making a network request.

  A later read or transaction request fails with an AftermathTransportError of kind network when neither config.baseUrl nor config.network is set.

  Parameters

  • Optionalconfig: CallerConfig

    Optional API host, network, endpoint, and access-token configuration.

  Returns Router

  Example

  const afSdk = await Aftermath.create({ network: "MAINNET" });
  
  const router = afSdk.Router();
  Copy

Static Readonlyconstants

addTransactionForCompleteTradeRoute

• addTransactionForCompleteTradeRoute(
      inputs: Omit<
          ApiRouterAddTransactionForCompleteTradeRouteBody,
          "serializedTx",
      > & { tx: Transaction },
  ): Promise<
      { coinOutId: TransactionObjectArgument
      | undefined; tx: Transaction },
  >

  Appends a complete route to an existing transaction.

  The method serializes the supplied transaction for the API, sends the route request, and parses the returned serialized transaction into a new Transaction. The input transaction is not mutated. Use the returned coinOutId when the response exposes the swap output. It can be undefined.

  Parameters

  • inputs: Omit<ApiRouterAddTransactionForCompleteTradeRouteBody, "serializedTx"> & {
        tx: Transaction;
    }

    Existing transaction, sender, complete route, slippage, and optional input coin argument.

  Returns Promise<{ coinOutId: TransactionObjectArgument | undefined; tx: Transaction }>

  A new transaction and the optional output coin argument.

  Throws

  AftermathTransportError when the API request, serialization response, or transaction parsing fails.

  Example

  // 1) Create a route
  const route = await router.getCompleteTradeRouteGivenAmountIn({ ... });
  
  // 2) Initialize your transaction
  const tx = new Transaction();
  
  // 3) Add router instructions
  const { tx: updatedTx, coinOutId } =
    await router.addTransactionForCompleteTradeRoute({
      tx,
      completeRoute: route,
      slippage: 0.01,
      walletAddress: "0x<your_address>"
  });
  
  // 4) Continue building your transaction with the resulting coinOutId, if desired
  updatedTx.transferObjects([coinOutId!], "0x<your_address>");
  Copy

getCompleteTradeRouteGivenAmountIn

• getCompleteTradeRouteGivenAmountIn(
      inputs: ApiRouterPartialCompleteTradeRouteBody & {
          coinInAmount: bigint;
      },
      abortSignal?: AbortSignal,
  ): Promise<RouterCompleteTradeRoute>

  Requests an exact-input route for a specified coin amount.

  The API may split the input across several routes. Each route can contain several sequential paths, and each path identifies its DEX protocol and pool. referrer and externalFee are forwarded to the API. Protocol and pool allowlists and blocklists constrain route selection.

  Parameters

  • inputs: ApiRouterPartialCompleteTradeRouteBody & { coinInAmount: bigint }

    Input and output types, input amount in smallest units, and optional routing constraints.

    • coinInAmount: bigint

      Amount of coin being given away

  • OptionalabortSignal: AbortSignal

    Optional caller-owned cancellation signal.

  Returns Promise<RouterCompleteTradeRoute>

  A promise for the complete route, including split portions, path fees, and amounts.

  Throws

  AftermathTransportError when the route request fails or the response cannot be decoded.

  Example

  const route = await router.getCompleteTradeRouteGivenAmountIn({
    coinInType: "0x2::sui::SUI",
    coinOutType: "0x<...>::coin::TOKEN",
    coinInAmount: BigInt(10_000_000_000),
    // optional fields:
    referrer: "0x<referrer_address>",
    externalFee: {
      recipient: "0x<fee_collector>",
      feePercentage: 0.01
    },
    protocolBlacklist: ["Cetus", "BlueMove"],
    poolBlacklist: ["0x<pool_id>"]
  });
  console.log(route);
  Copy

getCompleteTradeRouteGivenAmountOut

• getCompleteTradeRouteGivenAmountOut(
      inputs: ApiRouterPartialCompleteTradeRouteBody & {
          coinOutAmount: bigint;
          slippage: number;
      },
      abortSignal?: AbortSignal,
  ): Promise<RouterCompleteTradeRoute>

  Requests an exact-output route for a target coin amount.

  slippage is required because the router must protect the input needed to reach the target. The API may split the trade across routes and chain paths across protocols. Amounts are smallest-unit bigint values.

  Parameters

  • inputs: ApiRouterPartialCompleteTradeRouteBody & {
        coinOutAmount: bigint;
        slippage: number;
    }

    Input and output types, target output in smallest units, slippage, and optional constraints.

    • coinOutAmount: bigint

      Amount of coin expected to receive

    • slippage: number

  • OptionalabortSignal: AbortSignal

    Optional caller-owned cancellation signal.

  Returns Promise<RouterCompleteTradeRoute>

  A promise for the complete exact-output route.

  Throws

  AftermathTransportError when the route request fails or the response cannot be decoded.

  Example

  const route = await router.getCompleteTradeRouteGivenAmountOut({
    coinInType: "0x2::sui::SUI",
    coinOutType: "0x<...>::coin::TOKEN",
    coinOutAmount: BigInt(20_000_000),
    slippage: 0.01, // 1%
    protocolWhitelist: ["Aftermath", "Cetus"],
    poolWhitelist: ["0x<pool_id>"]
  });
  console.log(route);
  Copy

getInteractionEvents

• getInteractionEvents(
      inputs: ApiRouterTradeEventsBody,
  ): Promise<IndexerEventsWithCursor<RouterTradeEvent>>

  Fetches routed trade events for one wallet from the indexer.

  Parameters

  • inputs: ApiRouterTradeEventsBody

    Wallet address and optional numeric cursor and page limit.

  Returns Promise<IndexerEventsWithCursor<RouterTradeEvent>>

  A promise for paginated RouterTradeEvent values. A full page advances nextCursor.

  Throws

  AftermathTransportError when the indexer request or response fails.

  Example

  const events = await router.getInteractionEvents({
    walletAddress: "0x<your_address>",
    cursor: 0,
    limit: 10
  });
  console.log(events);
  Copy

getSupportedCoins

• getSupportedCoins(): Promise<string[]>

  Fetches every coin type currently supported by the router.

  Returns Promise<string[]>

  A promise for fully qualified Sui coin type strings.

  Throws

  AftermathTransportError when the API request or response fails.

  Example

  const supportedCoins = await router.getSupportedCoins();
  console.log(supportedCoins); // ["0x2::sui::SUI", "0x<...>::coin::TOKEN", ...]
  Copy

getTransactionForCompleteTradeRoute

• getTransactionForCompleteTradeRoute(
      inputs: ApiRouterTransactionForCompleteTradeRouteBody,
  ): Promise<Transaction>

  Fetches an unsigned transaction for a previously calculated complete route.

  The request serializes nested bigint amounts and fixed split portions as strings ending in n. The API response is parsed into a Transaction, and walletAddress is assigned as its sender. The method does not sign or submit it.

  Parameters

  • inputs: ApiRouterTransactionForCompleteTradeRouteBody

    Sender, complete route, route slippage, and optional sponsorship or recipient settings.

  Returns Promise<Transaction>

  A promise for the unsigned parsed Transaction returned by the API.

  Throws

  AftermathTransportError for transport, response decoding, or transaction parsing failures.

  Example

  const route = await router.getCompleteTradeRouteGivenAmountIn({ ... });
  const transactionBytes = await router.getTransactionForCompleteTradeRoute({
    walletAddress: "0x<your_address>",
    completeRoute: route,
    slippage: 0.01
  });
  // The returned bytes can now be signed and executed using your chosen wallet.
  Copy

getVolume24hrs

• getVolume24hrs(): Promise<number>

  Fetches the router's total 24-hour trading volume.

  Returns Promise<number>

  A promise for the numeric API value. This class does not convert its unit.

  Throws

  AftermathTransportError for HTTP, network, abort, timeout, or decode failures.

  Example

  const volume = await router.getVolume24hrs();
  console.log(volume); // e.g. 1234567.89
  Copy

searchSupportedCoins

• searchSupportedCoins(
      inputs: { filter: string },
      abortSignal?: AbortSignal,
  ): Promise<string[]>

  Fetches supported coin types whose API path matches a filter string.

  Parameters

  • inputs: { filter: string }

    The filter segment appended to the supported-coins endpoint.

  • OptionalabortSignal: AbortSignal

    Optional caller-owned cancellation signal.

  Returns Promise<string[]>

  A promise for matching fully qualified coin type strings.

  Throws

  AftermathTransportError when the request is cancelled, fails, or cannot be decoded.

  Example

  const searchResult = await router.searchSupportedCoins({ filter: "SUI" });
  console.log(searchResult); // e.g. ["0x2::sui::SUI"]
  Copy