@across-protocol/sdk 4.3.11 → 4.3.13

package/src/arch/svm/BlockUtils.ts

@@ -5,6 +5,7 @@ import { isDefined } from "../../utils/TypeGuards";
 import { getCurrentTime } from "../../utils/TimeUtils";
 import { CHAIN_IDs } from "../../constants";
 import { SVMProvider } from "./";
+import { getTimestampForSlot } from "./SpokeUtils";
 
 interface SVMBlock extends Block {}
 
@@ -23,13 +24,9 @@ export function averageBlockTime(): Pick<BlockTimeAverage, "average" | "blockRan
   return averageBlockTimes[CHAIN_IDs.SOLANA];
 }
 
-async function estimateBlocksElapsed(
-  seconds: number,
-  cushionPercentage = 0.0,
-  _provider: SVMProvider
-): Promise<number> {
+function estimateBlocksElapsed(seconds: number, cushionPercentage = 0.0, _provider: SVMProvider): number {
   const cushionMultiplier = cushionPercentage + 1.0;
-  const { average } = await averageBlockTime();
+  const { average } = averageBlockTime();
   return Math.floor((seconds * cushionMultiplier) / average);
 }
 
@@ -73,7 +70,7 @@ export class SVMBlockFinder extends BlockFinder<SVMBlock> {
       const cushion = 1;
       const incrementDistance = Math.max(
         // Ensure the increment slot distance is _at least_ a single slot to prevent an infinite loop.
-        await estimateBlocksElapsed(initialBlock.timestamp - timestamp, cushion, this.provider),
+        estimateBlocksElapsed(initialBlock.timestamp - timestamp, cushion, this.provider),
         1
       );
 
@@ -92,15 +89,33 @@ export class SVMBlockFinder extends BlockFinder<SVMBlock> {
     return this.findBlock(this.blocks[index - 1], this.blocks[index], timestamp);
   }
 
+  /**
+   * For a given slot, resolve the current or preceding timestamp.
+   * Not all Solana slots have an associated block timestamp; in case of no block at the requested slot, the most
+   * immediate preceding block timestamp will be used. Note that this may return an eventually-incorrect timestamp for
+   * future slots.
+   */
+  private async getBlockTime(_slot?: bigint): Promise<{ slot: bigint; timestamp: number }> {
+    let timestamp: number | undefined;
+    let slot = _slot ?? (await this.provider.getSlot({ commitment: "finalized" }).send());
+
+    do {
+      timestamp = await getTimestampForSlot(this.provider, slot);
+    } while (!isDefined(timestamp) && --slot);
+    assert(isDefined(timestamp), `Unable to resolve block time for SVM slot ${_slot ?? "latest"}`);
+    assert(BigInt(Number(timestamp) === timestamp), `Unexpected SVM block timestamp: ${timestamp}`);
+
+    return { slot, timestamp: Number(timestamp) };
+  }
+
   // Grabs the most recent slot and caches it.
   private async getLatestBlock(): Promise<SVMBlock> {
-    const latestSlot = await this.provider.getSlot().send();
-    const estimatedSlotTime = await this.provider.getBlockTime(latestSlot).send();
+    const { slot, timestamp } = await this.getBlockTime();
 
     // Cast the return type to an SVMBlock.
     const block: SVMBlock = {
-      timestamp: Number(estimatedSlotTime),
-      number: Number(latestSlot),
+      timestamp,
+      number: Number(slot),
     };
     const index = sortedIndexBy(this.blocks, block, "number");
     if (this.blocks[index]?.number !== block.number) this.blocks.splice(index, 0, block);
@@ -112,18 +127,20 @@ export class SVMBlockFinder extends BlockFinder<SVMBlock> {
     let index = sortedIndexBy(this.blocks, { number } as Block, "number");
     if (this.blocks[index]?.number === number) return this.blocks[index]; // Return early if block already exists.
 
-    const estimatedSlotTime = await this.provider.getBlockTime(BigInt(number)).send();
+    // The resolved slot may be rotated backwards if no timestamp exists at the requested slot.
+    const { slot: _slot, timestamp } = await this.getBlockTime(BigInt(number));
+    const slot = Number(_slot);
     // Cast the return type to an SVMBlock.
     const block: SVMBlock = {
-      timestamp: Number(estimatedSlotTime),
-      number,
+      timestamp,
+      number: slot,
     };
 
     // Recompute the index after the async call since the state of this.blocks could have changed!
-    index = sortedIndexBy(this.blocks, { number } as Block, "number");
+    index = sortedIndexBy(this.blocks, { number: slot } as Block, "number");
 
     // Rerun this check to avoid duplicate insertion.
-    if (this.blocks[index]?.number === number) return this.blocks[index];
+    if (this.blocks[index]?.number === slot) return this.blocks[index];
     this.blocks.splice(index, 0, block); // A simple insert at index.
     return block;
   }

package/src/arch/svm/SpokeUtils.ts

@@ -1,7 +1,8 @@
-import { SvmSpokeClient } from "@across-protocol/contracts";
+import { MessageTransmitterClient, SvmSpokeClient, TokenMessengerMinterClient } from "@across-protocol/contracts";
 import { decodeFillStatusAccount, fetchState } from "@across-protocol/contracts/dist/src/svm/clients/SvmSpoke";
-import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
 import { hashNonEmptyMessage } from "@across-protocol/contracts/dist/src/svm/web3-v1";
+import { intToU8Array32 } from "@across-protocol/contracts/dist/src/svm/web3-v1/conversionUtils";
+import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
 import {
   ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
   TOKEN_PROGRAM_ADDRESS,
@@ -10,48 +11,60 @@ import {
   getCreateAssociatedTokenIdempotentInstruction,
 } from "@solana-program/token";
 import {
+  AccountRole,
   Address,
+  IAccountMeta,
+  KeyPairSigner,
+  ReadonlyUint8Array,
   appendTransactionMessageInstruction,
   fetchEncodedAccount,
   fetchEncodedAccounts,
   getAddressEncoder,
+  getBase64EncodedWireTransaction,
   getProgramDerivedAddress,
+  getSignatureFromTransaction,
   getU32Encoder,
   getU64Encoder,
   pipe,
-  ReadonlyUint8Array,
+  signTransactionMessageWithSigners,
   some,
   type TransactionSigner,
 } from "@solana/kit";
 import assert from "assert";
 import { arrayify, hexZeroPad, hexlify } from "ethers/lib/utils";
 import { Logger } from "winston";
-import { SYSTEM_PROGRAM_ADDRESS } from "@solana-program/system";
+import { CHAIN_IDs, TOKEN_SYMBOLS_MAP } from "../../constants";
 import { DepositWithBlock, FillStatus, FillWithBlock, RelayData, RelayExecutionEventInfo } from "../../interfaces";
 import {
   BigNumber,
   EvmAddress,
-  SvmAddress,
   Address as SdkAddress,
+  SvmAddress,
+  bs58,
+  chainIsProd,
   chainIsSvm,
   chunk,
   isUnsafeDepositId,
   keccak256,
+  mapAsync,
   toAddressType,
 } from "../../utils";
-import { SvmCpiEventsClient } from "./eventsClient";
 import {
   bigToU8a32,
   createDefaultTransaction,
+  getCCTPNoncePda,
   getEventAuthority,
   getFillStatusPda,
+  getSelfAuthority,
   getStatePda,
+  isDepositForBurnEvent,
+  simulateAndDecode,
   toAddress,
   unwrapEventData,
-} from "./utils";
-import { CHAIN_IDs } from "../../constants";
-import { isSolanaError, SVM_NO_BLOCK_AT_SLOT } from "./provider";
-import { SVMEventNames, SVMProvider } from "./types";
+} from "./";
+import { SvmCpiEventsClient } from "./eventsClient";
+import { SVM_NO_BLOCK_AT_SLOT, isSolanaError } from "./provider";
+import { AttestedCCTPMessage, SVMEventNames, SVMProvider } from "./types";
 
 /**
  * @note: Average Solana slot duration is about 400-500ms. We can be conservative
@@ -796,6 +809,19 @@ export const createCloseFillPdaInstruction = async (
   );
 };
 
+export const createReceiveMessageInstruction = async (
+  signer: TransactionSigner,
+  solanaClient: SVMProvider,
+  input: MessageTransmitterClient.ReceiveMessageInput,
+  remainingAccounts: IAccountMeta<string>[]
+) => {
+  const receiveMessageIx = await MessageTransmitterClient.getReceiveMessageInstruction(input);
+  (receiveMessageIx.accounts as IAccountMeta<string>[]).push(...remainingAccounts);
+  return pipe(await createDefaultTransaction(solanaClient, signer), (tx) =>
+    appendTransactionMessageInstruction(receiveMessageIx, tx)
+  );
+};
+
 export async function getAssociatedTokenAddress(
   owner: SvmAddress,
   mint: SvmAddress,
@@ -1048,3 +1074,239 @@ export async function getFillRelayDelegatePda(
 
   return pda;
 }
+
+/**
+ * Checks if a CCTP message has been processed.
+ * @param solanaClient The Solana client.
+ * @param signer The signer of the transaction.
+ * @param nonce The nonce to check.
+ * @param sourceDomain The source domain.
+ * @returns True if the message has been processed, false otherwise.
+ */
+export const hasCCTPV1MessageBeenProcessed = async (
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  nonce: number,
+  sourceDomain: number
+): Promise<boolean> => {
+  const noncePda = await getCCTPNoncePda(solanaClient, signer, nonce, sourceDomain);
+  const isNonceUsedIx = await MessageTransmitterClient.getIsNonceUsedInstruction({
+    nonce: nonce,
+    usedNonces: noncePda,
+  });
+  const parserFunction = (buf: Buffer): boolean => {
+    if (buf.length != 1) {
+      throw new Error("Invalid buffer length for isNonceUsedIx");
+    }
+    return Boolean(buf[0]);
+  };
+  return await simulateAndDecode(solanaClient, isNonceUsedIx, signer, parserFunction);
+};
+
+/**
+ * Returns the account metas for a tokenless message.
+ * @returns The account metas for a tokenless message.
+ */
+export async function getAccountMetasForTokenlessMessage(): Promise<IAccountMeta<string>[]> {
+  const statePda = await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS);
+  return [
+    { address: statePda, role: AccountRole.READONLY },
+    { address: await getSelfAuthority(), role: AccountRole.READONLY },
+    { address: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+    { address: statePda, role: AccountRole.WRITABLE },
+    { address: await getEventAuthority(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS), role: AccountRole.READONLY },
+    { address: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+  ];
+}
+
+/**
+ * Returns the account metas for a deposit message.
+ * @param message The CCTP message.
+ * @param hubChainId The chain ID of the hub.
+ * @param tokenMessengerMinter The token messenger minter address.
+ * @returns The account metas for a deposit message.
+ */
+async function getAccountMetasForDepositMessage(
+  message: AttestedCCTPMessage,
+  hubChainId: number,
+  tokenMessengerMinter: Address
+): Promise<IAccountMeta<string>[]> {
+  const l1Usdc = EvmAddress.from(TOKEN_SYMBOLS_MAP.USDC.addresses[hubChainId]);
+  const l2Usdc = SvmAddress.from(
+    TOKEN_SYMBOLS_MAP.USDC.addresses[chainIsProd(hubChainId) ? CHAIN_IDs.SOLANA : CHAIN_IDs.SOLANA_DEVNET]
+  );
+
+  const [tokenMessengerPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["token_messenger"],
+  });
+
+  const [tokenMinterPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["token_minter"],
+  });
+
+  const [localTokenPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["local_token", bs58.decode(l2Usdc.toBase58())],
+  });
+
+  const [tokenMessengerEventAuthorityPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["__event_authority"],
+  });
+
+  const [custodyTokenAccountPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["custody", bs58.decode(l2Usdc.toBase58())],
+  });
+
+  const state = await getStatePda(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS);
+  const tokenProgram = TOKEN_PROGRAM_ADDRESS;
+  const vault = await getAssociatedTokenAddress(
+    SvmAddress.from(state),
+    SvmAddress.from(l2Usdc.toBase58()),
+    tokenProgram
+  );
+
+  // Define accounts dependent on deposit information.
+  const [tokenPairPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: [
+      new Uint8Array(Buffer.from("token_pair")),
+      new Uint8Array(Buffer.from(String(message.sourceDomain))),
+      new Uint8Array(Buffer.from(l1Usdc.toBytes32().slice(2), "hex")),
+    ],
+  });
+
+  const [remoteTokenMessengerPda] = await getProgramDerivedAddress({
+    programAddress: tokenMessengerMinter,
+    seeds: ["remote_token_messenger", String(message.sourceDomain)],
+  });
+
+  return [
+    { address: tokenMessengerPda, role: AccountRole.READONLY },
+    { address: remoteTokenMessengerPda, role: AccountRole.READONLY },
+    { address: tokenMinterPda, role: AccountRole.WRITABLE },
+    { address: localTokenPda, role: AccountRole.WRITABLE },
+    { address: tokenPairPda, role: AccountRole.READONLY },
+    { address: vault, role: AccountRole.WRITABLE },
+    { address: custodyTokenAccountPda, role: AccountRole.WRITABLE },
+    { address: TOKEN_PROGRAM_ADDRESS, role: AccountRole.READONLY },
+    { address: tokenMessengerEventAuthorityPda, role: AccountRole.READONLY },
+    { address: tokenMessengerMinter, role: AccountRole.READONLY },
+  ];
+}
+
+/**
+ * Returns the CCTP v1 receive message transaction.
+ * @param solanaClient The Solana client.
+ * @param signer The signer of the transaction.
+ * @param message The CCTP message.
+ * @param hubChainId The chain ID of the hub.
+ * @returns The CCTP v1 receive message transaction.
+ */
+export async function getCCTPV1ReceiveMessageTx(
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  message: AttestedCCTPMessage,
+  hubChainId: number
+) {
+  const [messageTransmitterPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["message_transmitter"],
+  });
+
+  const [eventAuthorityPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["__event_authority"],
+  });
+
+  const cctpMessageReceiver = isDepositForBurnEvent(message)
+    ? TokenMessengerMinterClient.TOKEN_MESSENGER_MINTER_PROGRAM_ADDRESS
+    : SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS;
+
+  const [authorityPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["message_transmitter_authority", bs58.decode(cctpMessageReceiver)],
+  });
+
+  // Notice: message.nonce is only valid for v1 messages
+  const usedNonces = await getCCTPNoncePda(solanaClient, signer, message.nonce, message.sourceDomain);
+
+  // Notice: for Svm tokenless messages, we currently only support very specific finalizations: Hub -> Spoke relayRootBundle calls
+  const accountMetas: IAccountMeta<string>[] = isDepositForBurnEvent(message)
+    ? await getAccountMetasForDepositMessage(
+        message,
+        hubChainId,
+        TokenMessengerMinterClient.TOKEN_MESSENGER_MINTER_PROGRAM_ADDRESS
+      )
+    : await getAccountMetasForTokenlessMessage();
+
+  const messageBytes = message.messageBytes.startsWith("0x")
+    ? Buffer.from(message.messageBytes.slice(2), "hex")
+    : Buffer.from(message.messageBytes, "hex");
+
+  const input: MessageTransmitterClient.ReceiveMessageInput = {
+    program: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    payer: signer,
+    caller: signer,
+    authorityPda,
+    messageTransmitter: messageTransmitterPda,
+    eventAuthority: eventAuthorityPda,
+    usedNonces,
+    receiver: SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS,
+    systemProgram: SYSTEM_PROGRAM_ADDRESS,
+    message: messageBytes,
+    attestation: Buffer.from(message.attestation.slice(2), "hex"),
+  };
+
+  return createReceiveMessageInstruction(signer, solanaClient, input, accountMetas);
+}
+
+/**
+ * Finalizes CCTP deposits and messages on Solana.
+ *
+ * @param solanaClient The Solana client.
+ * @param attestedMessages The CCTP messages to Solana.
+ * @param signer A base signer to be converted into a Solana signer.
+ * @param simulate Whether to simulate the transaction.
+ * @param hubChainId The chain ID of the hub.
+ * @returns A list of executed transaction signatures.
+ */
+
+export function finalizeCCTPV1Messages(
+  solanaClient: SVMProvider,
+  attestedMessages: AttestedCCTPMessage[],
+  signer: KeyPairSigner,
+  simulate = false,
+  hubChainId = 1
+): Promise<string[]> {
+  return mapAsync(attestedMessages, async (message) => {
+    const receiveMessageIx = await getCCTPV1ReceiveMessageTx(solanaClient, signer, message, hubChainId);
+
+    if (simulate) {
+      const result = await solanaClient
+        .simulateTransaction(
+          getBase64EncodedWireTransaction(await signTransactionMessageWithSigners(receiveMessageIx)),
+          {
+            encoding: "base64",
+          }
+        )
+        .send();
+      if (result.value.err) {
+        throw new Error(result.value.err.toString());
+      }
+      return "";
+    }
+
+    const signedTransaction = await signTransactionMessageWithSigners(receiveMessageIx);
+    const signature = getSignatureFromTransaction(signedTransaction);
+    const encodedTransaction = getBase64EncodedWireTransaction(signedTransaction);
+    await solanaClient
+      .sendTransaction(encodedTransaction, { preflightCommitment: "confirmed", encoding: "base64" })
+      .send();
+
+    return signature;
+  });
+}

package/src/arch/svm/types.ts

@@ -61,3 +61,11 @@ export type RpcClient = {
   rpc: SVMProvider;
   rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi>;
 };
+
+export type AttestedCCTPMessage = {
+  nonce: number;
+  sourceDomain: number;
+  messageBytes: string;
+  attestation: string;
+  type: "transfer" | "message";
+};

package/src/arch/svm/utils.ts

@@ -1,24 +1,29 @@
-import bs58 from "bs58";
-import { ethers } from "ethers";
+import { MessageTransmitterClient, SvmSpokeClient } from "@across-protocol/contracts";
 import { BN, BorshEventCoder, Idl } from "@coral-xyz/anchor";
 import {
   Address,
+  IInstruction,
+  KeyPairSigner,
   address,
+  appendTransactionMessageInstruction,
+  createTransactionMessage,
   getAddressEncoder,
+  getBase64EncodedWireTransaction,
   getProgramDerivedAddress,
-  getU64Encoder,
   getU32Encoder,
+  getU64Encoder,
   isAddress,
-  type TransactionSigner,
   pipe,
-  createTransactionMessage,
   setTransactionMessageFeePayerSigner,
   setTransactionMessageLifetimeUsingBlockhash,
+  signTransactionMessageWithSigners,
+  type TransactionSigner,
 } from "@solana/kit";
-import { SvmSpokeClient } from "@across-protocol/contracts";
+import bs58 from "bs58";
+import { ethers } from "ethers";
 import { FillType, RelayData } from "../../interfaces";
-import { BigNumber, getRelayDataHash, isDefined, isUint8Array, Address as SdkAddress } from "../../utils";
-import { EventName, SVMEventNames, SVMProvider } from "./types";
+import { BigNumber, Address as SdkAddress, getRelayDataHash, isDefined, isUint8Array } from "../../utils";
+import { AttestedCCTPMessage, EventName, SVMEventNames, SVMProvider } from "./types";
 
 export { isSolanaError } from "@solana/kit";
 
@@ -334,6 +339,18 @@ export async function getEventAuthority(programId: Address): Promise<Address> {
   return eventAuthority;
 }
 
+/**
+ * Returns the PDA for the Self Authority.
+ * @returns The PDA for the Self Authority.
+ */
+export const getSelfAuthority = async () => {
+  const [selfAuthority] = await getProgramDerivedAddress({
+    programAddress: address(SvmSpokeClient.SVM_SPOKE_PROGRAM_ADDRESS),
+    seeds: ["self_authority"],
+  });
+  return selfAuthority;
+};
+
 /**
  * Returns a random SVM address.
  */
@@ -358,8 +375,82 @@ export const createDefaultTransaction = async (rpcClient: SVMProvider, signer: T
   );
 };
 
+/**
+ * Simulates a transaction and decodes the result using a parser function.
+ * @param solanaClient - The Solana client.
+ * @param ix - The instruction to simulate.
+ * @param signer - The signer of the transaction.
+ * @param parser - The parser function to decode the result.
+ * @returns The decoded result.
+ */
+export const simulateAndDecode = async <P extends (buf: Buffer) => unknown>(
+  solanaClient: SVMProvider,
+  ix: IInstruction,
+  signer: KeyPairSigner,
+  parser: P
+): Promise<ReturnType<P>> => {
+  const simulationTx = appendTransactionMessageInstruction(ix, await createDefaultTransaction(solanaClient, signer));
+
+  const simulationResult = await solanaClient
+    .simulateTransaction(getBase64EncodedWireTransaction(await signTransactionMessageWithSigners(simulationTx)), {
+      encoding: "base64",
+    })
+    .send();
+
+  if (!simulationResult.value.returnData?.data[0]) {
+    throw new Error("No return data");
+  }
+
+  return parser(Buffer.from(simulationResult.value.returnData.data[0], "base64")) as ReturnType<P>;
+};
+
+/**
+ * Returns the PDA for the CCTP nonce.
+ * @param solanaClient The Solana client.
+ * @param signer The signer of the transaction.
+ * @param nonce The nonce to get the PDA for.
+ * @param sourceDomain The source domain.
+ * @returns The PDA for the CCTP nonce.
+ */
+export const getCCTPNoncePda = async (
+  solanaClient: SVMProvider,
+  signer: KeyPairSigner,
+  nonce: number,
+  sourceDomain: number
+) => {
+  const [messageTransmitterPda] = await getProgramDerivedAddress({
+    programAddress: MessageTransmitterClient.MESSAGE_TRANSMITTER_PROGRAM_ADDRESS,
+    seeds: ["message_transmitter"],
+  });
+  const getNonceIx = await MessageTransmitterClient.getGetNoncePdaInstruction({
+    messageTransmitter: messageTransmitterPda,
+    nonce,
+    sourceDomain: sourceDomain,
+  });
+
+  const parserFunction = (buf: Buffer): Address => {
+    if (buf.length === 32) {
+      return address(bs58.encode(buf));
+    }
+    throw new Error("Invalid buffer");
+  };
+
+  return await simulateAndDecode(solanaClient, getNonceIx, signer, parserFunction);
+};
+
+/**
+ * Checks if a CCTP message is a deposit for burn event.
+ * @param event The CCTP message event.
+ * @returns True if the message is a deposit for burn event, false otherwise.
+ */
+export function isDepositForBurnEvent(event: AttestedCCTPMessage): boolean {
+  return event.type === "transfer";
+}
+
 /**
  * Convert a bigint (0 ≤ n < 2^256) to a 32-byte Uint8Array (big-endian).
+ * @param n The bigint to convert.
+ * @returns The 32-byte Uint8Array.
  */
 export function bigintToU8a32(n: bigint): Uint8Array {
   if (n < BigInt(0) || n > ethers.constants.MaxUint256.toBigInt()) {

package/src/caching/IPFS/PinataIPFSClient.ts

@@ -89,4 +89,12 @@ export class PinataIPFSClient implements CachingMechanismInterface {
     });
     return storeValueInIPFS(key, JSON.stringify(value, jsonReplacerWithBigNumbers), this.client);
   }
+
+  sub(_topic: string, _callback: (message: string, channel: string) => unknown): Promise<number> {
+    return Promise.resolve(1);
+  }
+
+  pub(_topic: string, _message: string) {
+    return Promise.resolve(1);
+  }
 }

package/src/caching/Memory/MemoryCacheClient.ts

@@ -32,4 +32,12 @@ export class MemoryCacheClient implements CachingMechanismInterface {
       resolve(key);
     });
   }
+
+  sub(_topic: string, _callback: (message: string, channel: string) => unknown) {
+    return Promise.resolve(1);
+  }
+
+  pub(_topic: string, _message: string) {
+    return Promise.resolve(1);
+  }
 }

package/src/clients/BundleDataClient/utils/PoolRebalanceUtils.ts

@@ -25,7 +25,8 @@ export async function getWidestPossibleExpectedBlockRange(
   endBlockBuffers: number[],
   clients: Clients,
   latestMainnetBlock: number,
-  enabledChains: number[]
+  enabledChains: number[],
+  optimistic: boolean = false
 ): Promise<number[][]> {
   // We impose a buffer on the head of the chain to increase the probability that the received blocks are final.
   // Reducing the latest block that we query also gives partially filled deposits slightly more buffer for relayers
@@ -85,7 +86,9 @@ export async function getWidestPossibleExpectedBlockRange(
     // Chain has advanced far enough including the buffer, return range from previous proposed end block + 1 to
     // latest block for chain minus buffer.
     return [
-      clients.hubPoolClient.getNextBundleStartBlockNumber(chainIds, latestMainnetBlock, chainId),
+      optimistic
+        ? clients.hubPoolClient.getOptimisticBundleStartBlockNumber(chainIds, latestMainnetBlock, chainId)
+        : clients.hubPoolClient.getNextBundleStartBlockNumber(chainIds, latestMainnetBlock, chainId),
       latestPossibleBundleEndBlockNumbers[index],
     ];
   });

package/src/clients/HubPoolClient.ts

@@ -789,6 +789,29 @@ export class HubPoolClient extends BaseAbstractClient {
     return endBlock > 0 ? endBlock + 1 : 0;
   }
 
+  // @dev Returns the start block of the next bundle assuming that if there is a currently outstanding root bundle proposal, it will pass liveness.
+  getOptimisticBundleStartBlockNumber(chainIdList: number[], latestMainnetBlock: number, chainId: number): number {
+    // If there is no pending root bundle, then return block ranges based on the latest fully executed root bundle.
+    if (!this.hasPendingProposal()) {
+      return this.getNextBundleStartBlockNumber(chainIdList, latestMainnetBlock, chainId);
+    }
+    // We cannot normally index `this.proposedRootBundles` since a bundle there may have been previously disputed, so only index `this.proposedRootBundles`
+    // if we have a pending proposal, since this must mean that the pending root bundle is the most recent proposed root bundle.
+    const latestProposedBundle = this.proposedRootBundles[this.proposedRootBundles.length - 1];
+
+    // If there is no previous root bundle, then return 0.
+    if (!isDefined(latestProposedBundle)) {
+      return 0;
+    }
+
+    // Otherwise, get the bundle end block for the optimistic bundle.
+    const optimisticEndBlock = this.getBundleEndBlockForChain(latestProposedBundle, chainId, chainIdList);
+
+    // As above, this assumes that chain ID's are only added to the chain ID list over time, and that chains are never
+    // deleted.
+    return optimisticEndBlock > 0 ? optimisticEndBlock + 1 : 0;
+  }
+
   getLatestExecutedRootBundleContainingL1Token(
     block: number,
     chain: number,

package/src/interfaces/CachingMechanism.ts

@@ -34,4 +34,18 @@ export interface CachingMechanismInterface {
     ttl?: number,
     overrides?: OverrideType
   ): Promise<string | undefined>;
+
+  /**
+   * Subscribes to a topic.
+   * @param topic The topic to subscribe to.
+   * @param callback The callback to call when a message is received.
+   */
+  sub(topic: string, callback: (message: string, channel: string) => unknown): Promise<number>;
+
+  /**
+   * Publishes a message to the network.
+   * @param topic The topic to publish to.
+   * @param message The message to publish.
+   */
+  pub(topic: string, message: string): Promise<number>;
 }