Runnable TypeScript example

import { Transaction, TransactionBuilder, rpc, xdr } from "@stellar/stellar-sdk";

type Wallet = {
  address: string;
  // Adapt your wallet's signing API; return its signed transaction XDR.
  signTransaction(xdr: string, networkPassphrase: string): Promise<string>;
};
type Context = {
  apiUrl: string;
  rpcUrl: string;
  networkPassphrase: string; // Trusted app configuration, not the quote alone.
  router: string;
  wallet: Wallet;
  // Decode operations and obtain user approval for tokens, amounts, fees,
  // recipient, router, and any outer-contract calls. Throw on mismatch.
  review(transaction: Transaction): Promise<void>;
};
type Quote = {
  amountIn: string;
  amountOut: string;
  amountOutMin?: string;
  routeXdr?: string;
  transaction?: {
    envelopeXdr: string;
    networkPassphrase: string;
    routerContract: string;
    simulated: boolean;
  };
  transactions?: unknown[];
};

async function getJson<T>(url: string): Promise<T> {
  const response = await fetch(url);
  if (!response.ok) throw new Error(`${response.status}: ${await response.text()}`);
  return response.json() as Promise<T>;
}

async function getQuote(ctx: Context, params: URLSearchParams): Promise<Quote> {
  const config = await getJson<{ networkPassphrase: string; router: string | null }>(
    `${ctx.apiUrl}/api/v1/config`,
  );
  if (config.networkPassphrase !== ctx.networkPassphrase || config.router !== ctx.router) {
    throw new Error("Unexpected aggregator deployment");
  }
  return getJson<Quote>(`${ctx.apiUrl}/api/v1/quote?${params}`);
}

// One in-flight transaction per source account. Coordinate all other submitters too.
async function signSubmitConfirm(ctx: Context, unsignedXdr: string, prepared: boolean) {
  const server = new rpc.Server(ctx.rpcUrl);
  const network = await server.getNetwork();
  if (network.passphrase !== ctx.networkPassphrase) throw new Error("Wrong RPC network");
  const envelope = xdr.TransactionEnvelope.fromXDR(unsignedXdr, "base64");
  if (envelope.switch() !== xdr.EnvelopeType.envelopeTypeTx()) {
    throw new Error("Expected a regular transaction envelope");
  }
  if (envelope.v1().signatures().length !== 0) throw new Error("Expected unsigned XDR");
  const original = new Transaction(envelope, ctx.networkPassphrase);
  if (original.source !== ctx.wallet.address) throw new Error("Wrong source account");
  let transaction = original;
  if (!prepared) {
    const account = await server.getAccount(ctx.wallet.address);
    // Preserve operations, authorizations, fees, footprint, and existing bounds.
    envelope.v1().tx().seqNum(xdr.Int64.fromString(
      (BigInt(account.sequenceNumber()) + 1n).toString(),
    ));
    transaction = new Transaction(envelope, ctx.networkPassphrase);
    const simulation = await server.simulateTransaction(transaction);
    if (!rpc.Api.isSimulationSuccess(simulation) || "restorePreamble" in simulation) {
      throw new Error("Simulation failed or restoration is required; do not sign");
    }
    transaction = rpc.assembleTransaction(transaction, simulation).build();
  }
  await ctx.review(transaction);
  const signedXdr = await ctx.wallet.signTransaction(transaction.toXDR(), ctx.networkPassphrase);
  const signed = TransactionBuilder.fromXDR(signedXdr, ctx.networkPassphrase);
  if (!(signed instanceof Transaction) || !signed.hash().equals(transaction.hash())) {
    throw new Error("Wallet changed the transaction");
  }
  const hash = signed.hash().toString("hex");
  let submitted;
  try {
    submitted = await server.sendTransaction(signed);
  } catch (error) {
    throw new Error(`Submission uncertain; query ${hash} before retrying. ${String(error)}`);
  }
  if (submitted.status === "ERROR") throw new Error(`Submission rejected: ${hash}`);
  if (submitted.status === "TRY_AGAIN_LATER") {
    throw new Error(`Submission deferred; check ${hash} before retrying the same signed XDR`);
  }
  const deadline = Date.now() + 120_000;
  while (Date.now() < deadline) {
    const result = await server.getTransaction(hash).catch(error => {
      throw new Error(`Status lookup failed; query ${hash} before retrying. ${String(error)}`);
    });
    if (result.status === rpc.Api.GetTransactionStatus.SUCCESS) return result;
    if (result.status === rpc.Api.GetTransactionStatus.FAILED) {
      throw new Error(`Transaction failed: ${hash}`);
    }
    await new Promise(resolve => setTimeout(resolve, 2_000));
  }
  throw new Error(`Confirmation timed out; query ${hash} before any new swap`);
}

export async function swap(
  ctx: Context, from: string, to: string, atomicAmount: string, slippage: string,
) {
  const quote = await getQuote(ctx, new URLSearchParams({
    from, to, amount_in: atomicAmount, slippage,
    sender: ctx.wallet.address, fresh: "true",
  }));
  const tx = quote.transaction;
  if (quote.transactions || !tx) throw new Error("This example requires one transaction");
  if (tx.networkPassphrase !== ctx.networkPassphrase || tx.routerContract !== ctx.router) {
    throw new Error("Unexpected transaction deployment");
  }
  return signSubmitConfirm(ctx, tx.envelopeXdr, tx.simulated);
}

export async function composeWithLending(
  ctx: Context, from: string, to: string, atomicAmount: string, slippage: string,
  // Supply the current lending SDK builder; it must bind the quote's exact
  // input and minimum output to the intended lending action and account.
  buildControllerTransaction: (routeXdr: string, quote: Quote) => Promise<Transaction>,
) {
  const quote = await getQuote(ctx, new URLSearchParams({
    from, to, amount_in: atomicAmount, slippage, fresh: "true",
  }));
  if (!quote.routeXdr) throw new Error("No atomic composition payload available");
  const outer = await buildControllerTransaction(quote.routeXdr, quote);
  // Always simulate the complete outer transaction; inner plan simulation
  // says nothing about this transaction's authorization or resource budget.
  return signSubmitConfirm(ctx, outer.toXDR(), false);
}