@gibs/bridge-sdk 1.13.0 → 1.17.0

package/docs/examples/example-a-ether-to-pulse.ts

@@ -0,0 +1,300 @@
+/**
+ * Example A: ETH on Ethereum to PLS on PulseChain.
+ *
+ * 1. Build viem clients from the wallet's own RPC endpoints.
+ * 2. Search with `searchBridgeRoutes` and pick the best served route.
+ * 3. Plan ONE section at a time with `planCandidateExecution`
+ *    (`firstSectionIndex`), so a later section spends what actually arrived,
+ *    with a fresh swap floor and deadline, or a fresh aggregator quote.
+ * 4. Send each section's transactions, honouring `waitForReceipt`, and wait
+ *    for the crossing to arrive before planning the next section.
+ * 5. Poll `fetchTransferStatus` until the last crossing is delivered.
+ *
+ * Typechecked only (`docs/examples/tsconfig.json` in `@gibs/bridge-sdk`). Never run against mainnet.
+ */
+import type { AggregatorStatusSource, FetchTransferStatusOptions } from '@gibs/bridge-indexer';
+import { tokenBridgeInfo } from '@gibs/bridge-sdk/chain-info';
+import { type Provider, Providers, toChain } from '@gibs/bridge-sdk/config';
+import type { ConsolidatedQuote } from '@gibs/bridge-sdk/consolidated-quote';
+import {
+  type CandidateExecutionPlan,
+  planCandidateExecution,
+  readPulseXSectionQuote,
+  type SectionExecutionInputs,
+} from '@gibs/bridge-sdk/execution';
+import type { PlannedHop, ResolveNodeToken, RoutePlan } from '@gibs/bridge-sdk/routing';
+import { fetchLiveSectionQuote, type ServedBridgeRoute, searchBridgeRoutes } from '@gibs/quotes/search';
+import { type Hex, type PublicClient, zeroAddress } from 'viem';
+import {
+  allowanceReaderWith,
+  createClientLookup,
+  deadlineIn,
+  type RpcUrlByChainId,
+  readBalance,
+  requireClientWith,
+  type SentTransaction,
+  sendPlannedTransactions,
+  type WalletSigner,
+  waitForTransferStatus,
+} from './shared.js';
+
+const ethereumChainId = 1;
+const pulsechainChainId = 369;
+
+/** What the example needs from the wallet. */
+export type EtherToPulseOptions = {
+  readonly signer: WalletSigner;
+  readonly rpcUrlByChainId: RpcUrlByChainId;
+  /** The ether to send, in wei. */
+  readonly amountWei: bigint;
+  /** Cancels the search, every live quote and every status poll. */
+  readonly signal: AbortSignal;
+  /** The wallet's own LI.FI key, sent only as the `x-lifi-api-key` header. Leave it out to use LI.FI's keyless tier. */
+  readonly lifiApiKey?: string;
+  /** The wallet's own Relay key, sent only as a header. Leave it out to use Relay's anonymous tier. */
+  readonly relayApiKey?: string;
+};
+
+const omnibridgeCarriers: ReadonlySet<string> = new Set(Object.values(Providers));
+
+const isOmnibridgeCarrier = (carrier: string): carrier is Provider =>
+  omnibridgeCarriers.has(carrier);
+
+/** A plan's sections, one per signature, each as its hops. */
+const sectionsOf = (plan: RoutePlan): readonly (readonly PlannedHop[])[] =>
+  plan.signatures.map((group) => group.flatMap((hopIndex) => plan.hops[hopIndex] ?? []));
+
+/** Where `fetchTransferStatus` asks about an aggregator's leg. */
+const aggregatorSourceOf = (
+  quote: ConsolidatedQuote,
+  relayApiKey: string | undefined,
+): AggregatorStatusSource => {
+  if (quote.provider === 'lifi') return { provider: 'lifi' };
+  if (quote.provider === 'relay') {
+    return {
+      provider: 'relay',
+      requestId: quote.quoteId,
+      ...(relayApiKey === undefined ? {} : { apiKey: relayApiKey }),
+    };
+  }
+  return { provider: 'near-intents', depositAddress: quote.quoteId };
+};
+
+/** One section's inputs, and the live quote it signs when an aggregator carries it. */
+type SectionPlanInputs = {
+  readonly inputs: SectionExecutionInputs;
+  readonly liveQuote: ConsolidatedQuote | null;
+};
+
+/**
+ * Builds the inputs for ONE section, from what it spends NOW: the typed
+ * amount for the first section, what actually arrived for a later one.
+ */
+const buildSectionInputs = async (options: {
+  readonly served: ServedBridgeRoute;
+  readonly sectionIndex: number;
+  readonly hops: readonly PlannedHop[];
+  readonly amountIn: bigint;
+  readonly resolveToken: ResolveNodeToken;
+  readonly account: Hex;
+  readonly requireClient: (chainId: number) => PublicClient;
+  readonly clientForChain: (chainId: number) => PublicClient | null;
+  readonly signal: AbortSignal;
+  readonly lifiApiKey: string | undefined;
+  readonly relayApiKey: string | undefined;
+}): Promise<SectionPlanInputs> => {
+  const { served, sectionIndex, hops, amountIn, resolveToken, account, requireClient } = options;
+  const firstHop = hops[0];
+  if (firstHop === undefined) throw new Error(`section ${sectionIndex} has no hops`);
+  // Every section delivers to the signer; this example sends to the signer too.
+  const recipient = account;
+  const { carrier, from, to } = firstHop.edge;
+
+  if (isOmnibridgeCarrier(carrier)) {
+    // How the token maps across the bridge. Native ether reads the wrapped-ether mapping.
+    const assetLink = await tokenBridgeInfo({
+      bridgeKey: [carrier, toChain(from.chainId), toChain(to.chainId)],
+      assetIn: resolveToken(from),
+      isProd: true,
+      fromChainClient: requireClient(from.chainId),
+      toChainClient: requireClient(to.chainId),
+    });
+    if (assetLink === null)
+      throw new Error(`no omnibridge mapping for ${from.address} on chain ${from.chainId}`);
+    // The explicit delivery choice. Entering PulseChain, the bridge itself
+    // executes the crossing, so `shouldDeliver: false` is the only accepted
+    // choice here. Leaving PulseChain, see Example B.
+    const omnibridge = { isProd: true, assetLink, delivery: { shouldDeliver: false }, unwrap: false } as const;
+    return { inputs: { amountIn, recipient, omnibridge }, liveQuote: null };
+  }
+  if (carrier === 'PulseX') {
+    // A FRESH QUOTE, read now along the exact path the swap signs, for the
+    // amount that actually arrived. The floor is one percent below it, and the
+    // deadline starts now, not before the crossing.
+    const quotedAmountOut = await readPulseXSectionQuote({
+      hop: firstHop,
+      amountIn,
+      client: requireClient(from.chainId),
+    });
+    if (quotedAmountOut === null) throw new Error(`section ${sectionIndex}: PulseX gave no quote`);
+    return {
+      inputs: { amountIn, recipient, swap: { slippageBasisPoints: 100n, deadline: deadlineIn(20 * 60), quotedAmountOut } },
+      liveQuote: null,
+    };
+  }
+  if (carrier === 'wrap') return { inputs: { amountIn, recipient }, liveQuote: null };
+  // Any other carrier is an aggregator. It signs only a LIVE quote, asked now
+  // for this wallet, this recipient and this amount.
+  const live = await fetchLiveSectionQuote({
+    plan: served.plan,
+    sectionIndex,
+    resolveToken,
+    amountIn,
+    account,
+    recipient,
+    clientForChain: options.clientForChain,
+    fetch: (input, init) => globalThis.fetch(input, init),
+    signal: options.signal,
+    keys: {
+      ...(options.lifiApiKey === undefined ? {} : { lifiApiKey: options.lifiApiKey }),
+      ...(options.relayApiKey === undefined ? {} : { relayApiKey: options.relayApiKey }),
+    },
+    nearIntentsUserAgent: 'your-wallet/1.0',
+  });
+  if (live.kind !== 'quoted') throw new Error(`section ${sectionIndex}: no live quote (${live.kind})`);
+  return { inputs: { amountIn, recipient, aggregator: { quote: live.quote, request: live.request } }, liveQuote: live.quote };
+};
+
+/** Turns a refused plan into an error a person can act on. */
+const assertPlanned = (
+  plan: CandidateExecutionPlan,
+): Extract<CandidateExecutionPlan, { kind: 'planned' }> => {
+  if (plan.kind === 'planned') return plan;
+  throw new Error(
+    `section ${plan.sectionIndex} cannot be planned: ${JSON.stringify(plan.refusal, (_key, value) => (typeof value === 'bigint' ? value.toString() : value))}`,
+  );
+};
+
+/**
+ * Sends ether from Ethereum and delivers Pulse on PulseChain.
+ *
+ * @param options - see {@link EtherToPulseOptions}
+ * @returns the transactions sent, and the final status of the last crossing
+ */
+export const sendEtherToPulse = async (options: EtherToPulseOptions) => {
+  const { signer, signal } = options;
+  const clientForChain = createClientLookup(options.rpcUrlByChainId);
+  const requireClient = requireClientWith(clientForChain);
+
+  // 1. Search. No attribution and no fee: the wallet names none here.
+  const search = await searchBridgeRoutes({
+    origin: {
+      chainId: ethereumChainId,
+      token: { address: zeroAddress, decimals: 18, symbol: 'ETH' },
+      amount: options.amountWei,
+      account: signer.address,
+    },
+    destination: {
+      chainId: pulsechainChainId,
+      token: { address: zeroAddress, decimals: 18, symbol: 'PLS' },
+      recipient: signer.address,
+    },
+    clientForChain,
+    fetch: (input, init) => globalThis.fetch(input, init),
+    signal,
+    timeouts: { requestMs: 15_000, searchMs: 60_000 },
+    ...(options.lifiApiKey === undefined ? {} : { lifiApiKey: options.lifiApiKey }),
+    ...(options.relayApiKey === undefined ? {} : { relayApiKey: options.relayApiKey }),
+    nearIntentsUserAgent: 'your-wallet/1.0',
+  });
+
+  // 2. Pick a route. `routes` is best first, one per provider.
+  const served = search.routes[0];
+  if (served === undefined) {
+    const why =
+      search.priceImpactRefusal === null ? `${search.refusals.length} refusals` : 'price impact';
+    throw new Error(`no route can be served (${why})`);
+  }
+  const hopsBySection = sectionsOf(served.plan);
+
+  const statusOptionsFor = (
+    crossing: SentTransaction,
+    liveQuote: ConsolidatedQuote | null,
+  ): FetchTransferStatusOptions => ({
+    signal,
+    originClient: requireClient(crossing.transaction.chainId),
+    ...(liveQuote === null ? {} : { aggregator: aggregatorSourceOf(liveQuote, options.relayApiKey) }),
+  });
+  const waitForDelivered = (crossing: SentTransaction, liveQuote: ConsolidatedQuote | null) =>
+    waitForTransferStatus({
+      source: { chainId: crossing.transaction.chainId, txHash: crossing.hash },
+      statusOptions: statusOptionsFor(crossing, liveQuote),
+      isDone: (status) => status.state === 'delivered',
+      intervalMs: 15_000,
+    });
+
+  // 3 and 4. One section at a time. The first spends the typed amount; each
+  //    later one spends what actually arrived from the one before it.
+  const sent: SentTransaction[] = [];
+  let amountIn = options.amountWei;
+  for (const [sectionIndex, hops] of hopsBySection.entries()) {
+    const { inputs, liveQuote } = await buildSectionInputs({
+      served,
+      sectionIndex,
+      hops,
+      amountIn,
+      resolveToken: search.resolveToken,
+      account: signer.address,
+      requireClient,
+      clientForChain,
+      signal,
+      lifiApiKey: options.lifiApiKey,
+      relayApiKey: options.relayApiKey,
+    });
+    const plan = assertPlanned(
+      await planCandidateExecution({
+        candidate: served.candidate,
+        account: signer.address,
+        readAllowance: allowanceReaderWith(requireClient),
+        resolveToken: search.resolveToken,
+        firstSectionIndex: sectionIndex,
+        sections: [inputs],
+      }),
+    );
+    // Show `plan.deliveries` and every fee before the user signs. See "Fees and attribution".
+
+    // What the next section will spend arrives on its own chain. Read the
+    // balance there before this section runs, and again once it arrived.
+    const nextHop = hopsBySection[sectionIndex + 1]?.[0];
+    const nextToken = nextHop === undefined ? null : search.resolveToken(nextHop.edge.from);
+    const readNextBalance = () =>
+      nextToken === null
+        ? Promise.resolve(0n)
+        : readBalance({ client: requireClient(nextToken.chainId), token: nextToken.address, owner: signer.address });
+    const balanceBefore = await readNextBalance();
+
+    // Every transaction of one section is on one chain.
+    const sectionSent = await sendPlannedTransactions({
+      transactions: plan.transactions,
+      signer,
+      requireClient,
+      waitForArrival: async () => {},
+    });
+    sent.push(...sectionSent);
+    const last = sectionSent.at(-1);
+    if (last === undefined) throw new Error(`section ${sectionIndex} planned no transactions`);
+    const receipt = await requireClient(last.transaction.chainId).waitForTransactionReceipt({ hash: last.hash });
+    if (receipt.status !== 'success') throw new Error(`the transaction ${last.hash} reverted`);
+
+    const crossesChains = last.transaction.kind === 'bridge';
+    // 5. The route ends with this section. A crossing is done when delivered;
+    //    a swap is done when its receipt succeeds.
+    if (nextToken === null) {
+      return { sent, finalStatus: crossesChains ? await waitForDelivered(last, liveQuote) : null };
+    }
+    if (crossesChains) await waitForDelivered(last, liveQuote);
+    amountIn = (await readNextBalance()) - balanceBefore;
+    if (amountIn <= 0n) throw new Error(`nothing arrived for section ${sectionIndex + 1}`);
+  }
+  throw new Error('the route had no sections');
+};

package/docs/examples/example-b-token-pulsechain-to-ethereum.ts

@@ -0,0 +1,270 @@
+/**
+ * Example B: an ERC-20 token from PulseChain to Ethereum, with delivery off.
+ *
+ * 1. Read how the token maps across the bridge, and search for the route.
+ * 2. Plan the direct crossing with `shouldDeliver: false`: an exact approval,
+ *    then `relayTokens`.
+ * 3. Poll `fetchTransferStatus` until the crossing is `claimable`.
+ * 4. Read the bridge request with `fetchClaimRecords` and build the claim
+ *    with `buildClaimTransaction`, handling every typed refusal.
+ * 5. Send the claim on Ethereum, then poll until the transfer is delivered.
+ *
+ * Typechecked only (`docs/examples/tsconfig.json` in `@gibs/bridge-sdk`). Never run against mainnet.
+ */
+import { type ClaimRecord, fetchClaimRecords, type TransferStatus } from '@gibs/bridge-indexer';
+import { tokenBridgeInfo } from '@gibs/bridge-sdk/chain-info';
+import { buildClaimTransaction, type ClaimRefusal } from '@gibs/bridge-sdk/claims';
+import { Chains, Providers } from '@gibs/bridge-sdk/config';
+import { planCandidateExecution } from '@gibs/bridge-sdk/execution';
+import type { BridgeKey, Token } from '@gibs/bridge-sdk/types';
+import { searchBridgeRoutes } from '@gibs/quotes/search';
+import type { Hex } from 'viem';
+import {
+  allowanceReaderWith,
+  createClientLookup,
+  type RpcUrlByChainId,
+  requireClientWith,
+  sendPlannedTransactions,
+  sleep,
+  type WalletSigner,
+  waitForTransferStatus,
+} from './shared.js';
+
+const pulsechainChainId = 369;
+
+/** PulseX (PLSX), an ERC-20 token native to PulseChain. */
+const plsx: Token = {
+  chainId: pulsechainChainId,
+  address: '0x95B303987A60C71504D99Aa1b13B4DA07b0790ab',
+  decimals: 18,
+  symbol: 'PLSX',
+  name: 'PulseX',
+  logoURI: null,
+};
+
+const pulsechainToEthereum: BridgeKey = [Providers.PULSECHAIN, Chains.PLS, Chains.ETH];
+
+/** What the example needs from the wallet. */
+export type TokenToEthereumOptions = {
+  readonly signer: WalletSigner;
+  readonly rpcUrlByChainId: RpcUrlByChainId;
+  /** The amount to send, in the token's base units. */
+  readonly amount: bigint;
+  /** Cancels the search and every poll. */
+  readonly signal: AbortSignal;
+};
+
+/** A claim the wallet must not send, and must not retry by waiting. */
+export class ClaimRefusedError extends Error {
+  constructor(readonly refusal: ClaimRefusal) {
+    super(`the claim was refused: ${refusal.reason}`);
+    this.name = 'ClaimRefusedError';
+  }
+}
+
+/**
+ * Reads the one bridge request a crossing transaction started.
+ * `fetchClaimRecords` asks the indexer for exactly the fields a claim reads,
+ * lowercases the hash (the indexer matches hex in lowercase only), and never
+ * reads a relation the indexer leaves null.
+ *
+ * @param options.txHash - the crossing transaction on PulseChain
+ * @param options.signal - cancels the request
+ * @returns the record, in the shape `buildClaimTransaction` takes
+ * @throws on a network or GraphQL failure, or when the transaction started other than one request
+ */
+const readClaimRecord = async (options: {
+  readonly txHash: Hex;
+  readonly signal: AbortSignal;
+}): Promise<ClaimRecord> => {
+  const records = await fetchClaimRecords({
+    source: { chainId: pulsechainChainId, txHash: options.txHash },
+    signal: options.signal,
+  });
+  const [record] = records;
+  if (record === undefined || records.length !== 1) {
+    throw new Error(`expected one bridge request for ${options.txHash}, found ${records.length}`);
+  }
+  return record;
+};
+
+/** What to do with a refused claim. */
+type RefusalAction =
+  | { readonly kind: 'done' }
+  | { readonly kind: 'wait' }
+  | { readonly kind: 'stop'; readonly error: Error };
+
+/**
+ * Decides what each typed refusal means for the wallet. The switch is
+ * exhaustive: a new refusal reason fails the typecheck here.
+ *
+ * @param refusal - the refusal from `buildClaimTransaction`
+ * @returns the action
+ */
+const actionForRefusal = (refusal: ClaimRefusal): RefusalAction => {
+  switch (refusal.reason) {
+    case 'already-delivered':
+      // Somebody executed the release already. Nothing to send.
+      return { kind: 'done' };
+    case 'not-signed-yet':
+      // The validators are still signing. Ask again later.
+      return { kind: 'wait' };
+    case 'signatures-incomplete':
+      // The indexer stored fewer signatures than the bridge needs (see
+      // "Known limits": the submitSignature case). Waiting does not fix it.
+      // Tell the user, and report the transfer to Gibs.
+      return { kind: 'stop', error: new ClaimRefusedError(refusal) };
+    case 'wrong-type':
+      // Not a signature request. The validators execute an affirmation themselves.
+      return { kind: 'stop', error: new ClaimRefusedError(refusal) };
+    case 'malformed-request':
+      // A field is not the shape the indexer documents. Report it.
+      return { kind: 'stop', error: new ClaimRefusedError(refusal) };
+    default: {
+      const unhandled: never = refusal;
+      return { kind: 'stop', error: new Error(`unhandled refusal ${JSON.stringify(unhandled)}`) };
+    }
+  }
+};
+
+/**
+ * Sends an ERC-20 token from PulseChain to Ethereum and claims it there by hand.
+ *
+ * @param options - see {@link TokenToEthereumOptions}
+ * @returns the crossing hash, the claim hash (null when somebody else released it), and the final status
+ */
+export const sendTokenToEthereum = async (
+  options: TokenToEthereumOptions,
+): Promise<{
+  readonly crossingHash: Hex;
+  readonly claimHash: Hex | null;
+  readonly finalStatus: TransferStatus;
+}> => {
+  const { signer, signal } = options;
+  const clientForChain = createClientLookup(options.rpcUrlByChainId);
+  const requireClient = requireClientWith(clientForChain);
+  const pulsechainClient = requireClient(pulsechainChainId);
+  const ethereumClient = requireClient(Number(Chains.ETH));
+
+  // 1. How PLSX maps onto Ethereum. A null `assetOutAddress` means the token
+  //    has not crossed before; the first transfer creates it. The search needs
+  //    a destination address, so this example stops there.
+  const assetLink = await tokenBridgeInfo({
+    bridgeKey: pulsechainToEthereum,
+    assetIn: plsx,
+    isProd: true,
+    fromChainClient: pulsechainClient,
+    toChainClient: ethereumClient,
+  });
+  if (assetLink === null || assetLink.assetOutAddress === null) {
+    throw new Error('PLSX has no bridged address on Ethereum yet');
+  }
+
+  const search = await searchBridgeRoutes({
+    origin: {
+      chainId: pulsechainChainId,
+      token: plsx,
+      amount: options.amount,
+      account: signer.address,
+    },
+    destination: {
+      chainId: Number(Chains.ETH),
+      token: { address: assetLink.assetOutAddress, decimals: plsx.decimals, symbol: plsx.symbol },
+      recipient: signer.address,
+    },
+    clientForChain,
+    fetch: (input, init) => globalThis.fetch(input, init),
+    signal,
+  });
+
+  // The direct crossing: one section, one omnibridge hop.
+  const crossing = search.routes.find(
+    ({ plan }) =>
+      plan.signatures.length === 1 && plan.hops[0]?.edge.carrier === Providers.PULSECHAIN,
+  );
+  if (crossing === undefined)
+    throw new Error('the search served no direct crossing for this token');
+
+  // 2. Plan it. Delivery is off: nobody is paid to release it on Ethereum, so
+  //    the user claims it there and pays the Ethereum gas.
+  const plan = await planCandidateExecution({
+    candidate: crossing.candidate,
+    account: signer.address,
+    readAllowance: allowanceReaderWith(requireClient),
+    resolveToken: search.resolveToken,
+    sections: [
+      {
+        amountIn: options.amount,
+        recipient: signer.address,
+        omnibridge: { isProd: true, assetLink, delivery: { shouldDeliver: false }, unwrap: false },
+      },
+    ],
+  });
+  if (plan.kind === 'refused') throw new Error(`cannot plan the crossing: ${plan.refusal.reason}`);
+  // plan.transactions is [approve (when the allowance is short), bridge], both on PulseChain.
+
+  const sent = await sendPlannedTransactions({
+    transactions: plan.transactions,
+    signer,
+    requireClient,
+    // Every transaction is on PulseChain, so this is never called.
+    waitForArrival: async () => {},
+  });
+  const bridge = sent.find(({ transaction }) => transaction.kind === 'bridge');
+  if (bridge === undefined) throw new Error('the plan held no bridge transaction');
+  const source = { chainId: pulsechainChainId, txHash: bridge.hash } as const;
+  const statusOptions = { signal, originClient: pulsechainClient } as const;
+
+  // 3. Wait until the validators have signed. `claimable` is true in both
+  //    ready states. `delivered` means somebody released it already.
+  const ready = await waitForTransferStatus({
+    source,
+    statusOptions,
+    isDone: (status) => status.claimable || status.state === 'delivered',
+    intervalMs: 30_000,
+  });
+  if (ready.state === 'delivered')
+    return { crossingHash: bridge.hash, claimHash: null, finalStatus: ready };
+
+  // 4. Build the claim from the indexer's record. Retry only on `not-signed-yet`.
+  for (;;) {
+    const request = await readClaimRecord({ txHash: bridge.hash, signal });
+    // Delivery was off, so the claim goes straight to the destination bridge and pays no tip.
+    const claim = buildClaimTransaction({ request, via: { kind: 'direct' } });
+    if (claim.kind === 'refused') {
+      const action = actionForRefusal(claim.refusal);
+      if (action.kind === 'stop') throw action.error;
+      if (action.kind === 'done') {
+        const finalStatus = await waitForTransferStatus({
+          source,
+          statusOptions,
+          isDone: (status) => status.state === 'delivered',
+          intervalMs: 15_000,
+        });
+        return { crossingHash: bridge.hash, claimHash: null, finalStatus };
+      }
+      await sleep(30_000, signal);
+      continue;
+    }
+
+    // 5. Send the claim on Ethereum (`claim.transaction.chainId` is 1).
+    const [claimSent] = await sendPlannedTransactions({
+      transactions: [claim.transaction],
+      signer,
+      requireClient,
+      waitForArrival: async () => {},
+    });
+    if (claimSent === undefined) throw new Error('the claim was not sent');
+    const receipt = await requireClient(claim.transaction.chainId).waitForTransactionReceipt({
+      hash: claimSent.hash,
+    });
+    if (receipt.status !== 'success') throw new Error(`the claim ${claimSent.hash} reverted`);
+    const finalStatus = await waitForTransferStatus({
+      source,
+      statusOptions,
+      isDone: (status) => status.state === 'delivered',
+      intervalMs: 15_000,
+    });
+    return { crossingHash: bridge.hash, claimHash: claimSent.hash, finalStatus };
+  }
+};