End-to-end transaction flow

const prepared = await account.prepareTransaction({
  source: { chain: base, token: usdcOnBase },
  destination: { chain: arbitrum, token: usdcOnArbitrum, amount, calls: [...calls] },
});

const quote = prepared.quotes.best;
console.log(quote.cost.input, quote.cost.output, quote.cost.fees);
console.log(quote.expiresAt, prepared.quotes.traceId);
console.log(quote.purpose, quote.plan, quote.requirements, quote.signingRequests);

import { isExecutionError } from "@rhinestone/sdk/errors";

if (Date.now() >= quote.expiresAt * 1_000) {
  throw new Error("Quote expired; prepare and sign a new route");
}

const submitted = await account.submitTransaction(signed);
console.log(submitted.id, submitted.traceId);

try {
  const status = await account.waitForExecution(submitted);
  console.log(status.status, status.operations);
} catch (error) {
  if (error instanceof Error && isExecutionError(error)) {
    console.error(error.message, error.context, submitted.traceId);
  }
  throw error;
}

const proofs = [];

for (const request of route.signingRequests) {
  const { payload, authority } = request;
  if (
    request.account.vm !== "evm" ||
    request.account.address.toLowerCase() !== eoaAddress.toLowerCase() ||
    authority.kind !== "secp256k1" ||
    authority.address.toLowerCase() !== eoaAddress.toLowerCase() ||
    payload.kind !== "eip712" ||
    payload.signatureFormat !== "secp256k1"
  ) {
    throw new Error("Unsupported signing request or authority");
  }

  if (Date.now() >= route.expiresAt * 1_000) {
    throw new Error("Quote expired; request and review a new route");
  }
  for (const constraint of request.validity) {
    if (constraint.kind !== "timestamp") {
      throw new Error("Unsupported validity constraint");
    }
    if (Date.now() >= constraint.expiresAt * 1_000) {
      throw new Error("Signing request expired; re-quote");
    }
  }

  proofs.push({
    kind: "eip712",
    signature: await signer.signTypedData({
      ...payload.typedData,
      account: eoaAddress,
    }),
  });
}

if (Date.now() >= route.expiresAt * 1_000) {
  throw new Error("Quote expired; request and sign a new route");
}

const submitResponse = await fetch(`${baseUrl}/intents`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    intentId: route.intentId,
    proofs,
  }),
});

if (!submitResponse.ok) throw new Error(await submitResponse.text());
const result = await submitResponse.json();

async function pollIntent(intentId: string) {
  for (let attempt = 0; attempt < 60; attempt++) {
    const response = await fetch(`${baseUrl}/intents/${intentId}`, { headers });
    if (!response.ok) throw new Error(await response.text());

    const latest = await response.json();
    if (latest.status === "COMPLETED" || latest.status === "FAILED") {
      return latest;
    }

    await new Promise((resolve) => setTimeout(resolve, 2_000));
  }

  return undefined;
}

const latest = await pollIntent(result.intentId);
console.log(result.intentId, latest);

const transactions = latest?.operations.flatMap((operation) =>
  operation.items.flatMap((item) => item.transaction ? [item.transaction] : []),
) ?? [];

for (const transaction of transactions) {
  let id;
  switch (transaction.vm) {
    case "evm":
    case "stellar": id = transaction.txHash; break;
    case "svm": id = transaction.signature; break;
    case "tvm": id = transaction.txId; break;
    case "unknown": id = transaction.id; break;
    default: continue;
  }
  console.log(transaction.vm, transaction.chainId, id);
}